api/pkg/apis/dfdaemon/v2/mocks/dfdaemon_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ../dfdaemon_grpc.pb.go
//
// Generated by this command:
//
//	mockgen -destination dfdaemon_mock.go -source ../dfdaemon_grpc.pb.go -package mocks
//

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

import (
	context "context"
	reflect "reflect"

	common "d7y.io/api/v2/pkg/apis/common/v2"
	dfdaemon "d7y.io/api/v2/pkg/apis/dfdaemon/v2"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// MockDfdaemonUploadClient is a mock of DfdaemonUploadClient interface.
type MockDfdaemonUploadClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUploadClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonUploadClientMockRecorder is the mock recorder for MockDfdaemonUploadClient.
type MockDfdaemonUploadClientMockRecorder struct {
	mock *MockDfdaemonUploadClient
}

// NewMockDfdaemonUploadClient creates a new mock instance.
func NewMockDfdaemonUploadClient(ctrl *gomock.Controller) *MockDfdaemonUploadClient {
	mock := &MockDfdaemonUploadClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUploadClientMockRecorder{mock}
	return mock
}

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

// DeletePersistentCacheTask mocks base method.
func (m *MockDfdaemonUploadClient) DeletePersistentCacheTask(ctx context.Context, in *dfdaemon.DeletePersistentCacheTaskRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePersistentCacheTask", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePersistentCacheTask indicates an expected call of DeletePersistentCacheTask.
func (mr *MockDfdaemonUploadClientMockRecorder) DeletePersistentCacheTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePersistentCacheTask", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).DeletePersistentCacheTask), varargs...)
}

// DeleteTask mocks base method.
func (m *MockDfdaemonUploadClient) DeleteTask(ctx context.Context, in *dfdaemon.DeleteTaskRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTask", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTask indicates an expected call of DeleteTask.
func (mr *MockDfdaemonUploadClientMockRecorder) DeleteTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTask", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).DeleteTask), varargs...)
}

// DownloadPersistentCacheTask mocks base method.
func (m *MockDfdaemonUploadClient) DownloadPersistentCacheTask(ctx context.Context, in *dfdaemon.DownloadPersistentCacheTaskRequest, opts ...grpc.CallOption) (dfdaemon.DfdaemonUpload_DownloadPersistentCacheTaskClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DownloadPersistentCacheTask", varargs...)
	ret0, _ := ret[0].(dfdaemon.DfdaemonUpload_DownloadPersistentCacheTaskClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DownloadPersistentCacheTask indicates an expected call of DownloadPersistentCacheTask.
func (mr *MockDfdaemonUploadClientMockRecorder) DownloadPersistentCacheTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadPersistentCacheTask", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).DownloadPersistentCacheTask), varargs...)
}

// DownloadPiece mocks base method.
func (m *MockDfdaemonUploadClient) DownloadPiece(ctx context.Context, in *dfdaemon.DownloadPieceRequest, opts ...grpc.CallOption) (*dfdaemon.DownloadPieceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DownloadPiece", varargs...)
	ret0, _ := ret[0].(*dfdaemon.DownloadPieceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DownloadPiece indicates an expected call of DownloadPiece.
func (mr *MockDfdaemonUploadClientMockRecorder) DownloadPiece(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadPiece", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).DownloadPiece), varargs...)
}

// DownloadTask mocks base method.
func (m *MockDfdaemonUploadClient) DownloadTask(ctx context.Context, in *dfdaemon.DownloadTaskRequest, opts ...grpc.CallOption) (dfdaemon.DfdaemonUpload_DownloadTaskClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DownloadTask", varargs...)
	ret0, _ := ret[0].(dfdaemon.DfdaemonUpload_DownloadTaskClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DownloadTask indicates an expected call of DownloadTask.
func (mr *MockDfdaemonUploadClientMockRecorder) DownloadTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadTask", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).DownloadTask), varargs...)
}

// StatPersistentCacheTask mocks base method.
func (m *MockDfdaemonUploadClient) StatPersistentCacheTask(ctx context.Context, in *dfdaemon.StatPersistentCacheTaskRequest, opts ...grpc.CallOption) (*common.PersistentCacheTask, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StatPersistentCacheTask", varargs...)
	ret0, _ := ret[0].(*common.PersistentCacheTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StatPersistentCacheTask indicates an expected call of StatPersistentCacheTask.
func (mr *MockDfdaemonUploadClientMockRecorder) StatPersistentCacheTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatPersistentCacheTask", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).StatPersistentCacheTask), varargs...)
}

// StatTask mocks base method.
func (m *MockDfdaemonUploadClient) StatTask(ctx context.Context, in *dfdaemon.StatTaskRequest, opts ...grpc.CallOption) (*common.Task, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StatTask", varargs...)
	ret0, _ := ret[0].(*common.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StatTask indicates an expected call of StatTask.
func (mr *MockDfdaemonUploadClientMockRecorder) StatTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatTask", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).StatTask), varargs...)
}

// SyncPieces mocks base method.
func (m *MockDfdaemonUploadClient) SyncPieces(ctx context.Context, in *dfdaemon.SyncPiecesRequest, opts ...grpc.CallOption) (dfdaemon.DfdaemonUpload_SyncPiecesClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SyncPieces", varargs...)
	ret0, _ := ret[0].(dfdaemon.DfdaemonUpload_SyncPiecesClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SyncPieces indicates an expected call of SyncPieces.
func (mr *MockDfdaemonUploadClientMockRecorder) SyncPieces(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncPieces", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).SyncPieces), varargs...)
}

// MockDfdaemonUpload_DownloadTaskClient is a mock of DfdaemonUpload_DownloadTaskClient interface.
type MockDfdaemonUpload_DownloadTaskClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_DownloadTaskClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_DownloadTaskClientMockRecorder is the mock recorder for MockDfdaemonUpload_DownloadTaskClient.
type MockDfdaemonUpload_DownloadTaskClientMockRecorder struct {
	mock *MockDfdaemonUpload_DownloadTaskClient
}

// NewMockDfdaemonUpload_DownloadTaskClient creates a new mock instance.
func NewMockDfdaemonUpload_DownloadTaskClient(ctrl *gomock.Controller) *MockDfdaemonUpload_DownloadTaskClient {
	mock := &MockDfdaemonUpload_DownloadTaskClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_DownloadTaskClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Header mocks base method.
func (m *MockDfdaemonUpload_DownloadTaskClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Recv mocks base method.
func (m *MockDfdaemonUpload_DownloadTaskClient) Recv() (*dfdaemon.DownloadTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*dfdaemon.DownloadTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockDfdaemonUpload_DownloadTaskClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadTaskClient)(nil).RecvMsg), m)
}

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

// SendMsg indicates an expected call of SendMsg.
func (mr *MockDfdaemonUpload_DownloadTaskClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadTaskClient)(nil).SendMsg), m)
}

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

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

// MockDfdaemonUpload_SyncPiecesClient is a mock of DfdaemonUpload_SyncPiecesClient interface.
type MockDfdaemonUpload_SyncPiecesClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_SyncPiecesClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_SyncPiecesClientMockRecorder is the mock recorder for MockDfdaemonUpload_SyncPiecesClient.
type MockDfdaemonUpload_SyncPiecesClientMockRecorder struct {
	mock *MockDfdaemonUpload_SyncPiecesClient
}

// NewMockDfdaemonUpload_SyncPiecesClient creates a new mock instance.
func NewMockDfdaemonUpload_SyncPiecesClient(ctrl *gomock.Controller) *MockDfdaemonUpload_SyncPiecesClient {
	mock := &MockDfdaemonUpload_SyncPiecesClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_SyncPiecesClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Header mocks base method.
func (m *MockDfdaemonUpload_SyncPiecesClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Recv mocks base method.
func (m *MockDfdaemonUpload_SyncPiecesClient) Recv() (*dfdaemon.SyncPiecesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*dfdaemon.SyncPiecesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockDfdaemonUpload_SyncPiecesClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncPiecesClient)(nil).RecvMsg), m)
}

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

// SendMsg indicates an expected call of SendMsg.
func (mr *MockDfdaemonUpload_SyncPiecesClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncPiecesClient)(nil).SendMsg), m)
}

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

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

// MockDfdaemonUpload_DownloadPersistentCacheTaskClient is a mock of DfdaemonUpload_DownloadPersistentCacheTaskClient interface.
type MockDfdaemonUpload_DownloadPersistentCacheTaskClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_DownloadPersistentCacheTaskClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_DownloadPersistentCacheTaskClientMockRecorder is the mock recorder for MockDfdaemonUpload_DownloadPersistentCacheTaskClient.
type MockDfdaemonUpload_DownloadPersistentCacheTaskClientMockRecorder struct {
	mock *MockDfdaemonUpload_DownloadPersistentCacheTaskClient
}

// NewMockDfdaemonUpload_DownloadPersistentCacheTaskClient creates a new mock instance.
func NewMockDfdaemonUpload_DownloadPersistentCacheTaskClient(ctrl *gomock.Controller) *MockDfdaemonUpload_DownloadPersistentCacheTaskClient {
	mock := &MockDfdaemonUpload_DownloadPersistentCacheTaskClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_DownloadPersistentCacheTaskClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Header mocks base method.
func (m *MockDfdaemonUpload_DownloadPersistentCacheTaskClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Recv mocks base method.
func (m *MockDfdaemonUpload_DownloadPersistentCacheTaskClient) Recv() (*dfdaemon.DownloadPersistentCacheTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*dfdaemon.DownloadPersistentCacheTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockDfdaemonUpload_DownloadPersistentCacheTaskClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentCacheTaskClient)(nil).RecvMsg), m)
}

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

// SendMsg indicates an expected call of SendMsg.
func (mr *MockDfdaemonUpload_DownloadPersistentCacheTaskClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentCacheTaskClient)(nil).SendMsg), m)
}

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

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

// MockDfdaemonUploadServer is a mock of DfdaemonUploadServer interface.
type MockDfdaemonUploadServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUploadServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonUploadServerMockRecorder is the mock recorder for MockDfdaemonUploadServer.
type MockDfdaemonUploadServerMockRecorder struct {
	mock *MockDfdaemonUploadServer
}

// NewMockDfdaemonUploadServer creates a new mock instance.
func NewMockDfdaemonUploadServer(ctrl *gomock.Controller) *MockDfdaemonUploadServer {
	mock := &MockDfdaemonUploadServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUploadServerMockRecorder{mock}
	return mock
}

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

// DeletePersistentCacheTask mocks base method.
func (m *MockDfdaemonUploadServer) DeletePersistentCacheTask(arg0 context.Context, arg1 *dfdaemon.DeletePersistentCacheTaskRequest) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePersistentCacheTask", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTask mocks base method.
func (m *MockDfdaemonUploadServer) DeleteTask(arg0 context.Context, arg1 *dfdaemon.DeleteTaskRequest) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTask", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DownloadPersistentCacheTask mocks base method.
func (m *MockDfdaemonUploadServer) DownloadPersistentCacheTask(arg0 *dfdaemon.DownloadPersistentCacheTaskRequest, arg1 dfdaemon.DfdaemonUpload_DownloadPersistentCacheTaskServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DownloadPersistentCacheTask", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DownloadPiece mocks base method.
func (m *MockDfdaemonUploadServer) DownloadPiece(arg0 context.Context, arg1 *dfdaemon.DownloadPieceRequest) (*dfdaemon.DownloadPieceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DownloadPiece", arg0, arg1)
	ret0, _ := ret[0].(*dfdaemon.DownloadPieceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DownloadTask mocks base method.
func (m *MockDfdaemonUploadServer) DownloadTask(arg0 *dfdaemon.DownloadTaskRequest, arg1 dfdaemon.DfdaemonUpload_DownloadTaskServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DownloadTask", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// StatPersistentCacheTask mocks base method.
func (m *MockDfdaemonUploadServer) StatPersistentCacheTask(arg0 context.Context, arg1 *dfdaemon.StatPersistentCacheTaskRequest) (*common.PersistentCacheTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatPersistentCacheTask", arg0, arg1)
	ret0, _ := ret[0].(*common.PersistentCacheTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StatTask mocks base method.
func (m *MockDfdaemonUploadServer) StatTask(arg0 context.Context, arg1 *dfdaemon.StatTaskRequest) (*common.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatTask", arg0, arg1)
	ret0, _ := ret[0].(*common.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SyncPieces mocks base method.
func (m *MockDfdaemonUploadServer) SyncPieces(arg0 *dfdaemon.SyncPiecesRequest, arg1 dfdaemon.DfdaemonUpload_SyncPiecesServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncPieces", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockUnsafeDfdaemonUploadServer is a mock of UnsafeDfdaemonUploadServer interface.
type MockUnsafeDfdaemonUploadServer struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeDfdaemonUploadServerMockRecorder
	isgomock struct{}
}

// MockUnsafeDfdaemonUploadServerMockRecorder is the mock recorder for MockUnsafeDfdaemonUploadServer.
type MockUnsafeDfdaemonUploadServerMockRecorder struct {
	mock *MockUnsafeDfdaemonUploadServer
}

// NewMockUnsafeDfdaemonUploadServer creates a new mock instance.
func NewMockUnsafeDfdaemonUploadServer(ctrl *gomock.Controller) *MockUnsafeDfdaemonUploadServer {
	mock := &MockUnsafeDfdaemonUploadServer{ctrl: ctrl}
	mock.recorder = &MockUnsafeDfdaemonUploadServerMockRecorder{mock}
	return mock
}

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

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

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

// MockDfdaemonUpload_DownloadTaskServer is a mock of DfdaemonUpload_DownloadTaskServer interface.
type MockDfdaemonUpload_DownloadTaskServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_DownloadTaskServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_DownloadTaskServerMockRecorder is the mock recorder for MockDfdaemonUpload_DownloadTaskServer.
type MockDfdaemonUpload_DownloadTaskServerMockRecorder struct {
	mock *MockDfdaemonUpload_DownloadTaskServer
}

// NewMockDfdaemonUpload_DownloadTaskServer creates a new mock instance.
func NewMockDfdaemonUpload_DownloadTaskServer(ctrl *gomock.Controller) *MockDfdaemonUpload_DownloadTaskServer {
	mock := &MockDfdaemonUpload_DownloadTaskServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_DownloadTaskServerMockRecorder{mock}
	return mock
}

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

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

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

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

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockDfdaemonUpload_DownloadTaskServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadTaskServer)(nil).RecvMsg), m)
}

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

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

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

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

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

// SendMsg indicates an expected call of SendMsg.
func (mr *MockDfdaemonUpload_DownloadTaskServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadTaskServer)(nil).SendMsg), m)
}

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

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

// SetTrailer mocks base method.
func (m *MockDfdaemonUpload_DownloadTaskServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

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

// MockDfdaemonUpload_SyncPiecesServer is a mock of DfdaemonUpload_SyncPiecesServer interface.
type MockDfdaemonUpload_SyncPiecesServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_SyncPiecesServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_SyncPiecesServerMockRecorder is the mock recorder for MockDfdaemonUpload_SyncPiecesServer.
type MockDfdaemonUpload_SyncPiecesServerMockRecorder struct {
	mock *MockDfdaemonUpload_SyncPiecesServer
}

// NewMockDfdaemonUpload_SyncPiecesServer creates a new mock instance.
func NewMockDfdaemonUpload_SyncPiecesServer(ctrl *gomock.Controller) *MockDfdaemonUpload_SyncPiecesServer {
	mock := &MockDfdaemonUpload_SyncPiecesServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_SyncPiecesServerMockRecorder{mock}
	return mock
}

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

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

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

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

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockDfdaemonUpload_SyncPiecesServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncPiecesServer)(nil).RecvMsg), m)
}

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

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

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

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

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

// SendMsg indicates an expected call of SendMsg.
func (mr *MockDfdaemonUpload_SyncPiecesServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncPiecesServer)(nil).SendMsg), m)
}

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

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

// SetTrailer mocks base method.
func (m *MockDfdaemonUpload_SyncPiecesServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

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

// MockDfdaemonUpload_DownloadPersistentCacheTaskServer is a mock of DfdaemonUpload_DownloadPersistentCacheTaskServer interface.
type MockDfdaemonUpload_DownloadPersistentCacheTaskServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_DownloadPersistentCacheTaskServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_DownloadPersistentCacheTaskServerMockRecorder is the mock recorder for MockDfdaemonUpload_DownloadPersistentCacheTaskServer.
type MockDfdaemonUpload_DownloadPersistentCacheTaskServerMockRecorder struct {
	mock *MockDfdaemonUpload_DownloadPersistentCacheTaskServer
}

// NewMockDfdaemonUpload_DownloadPersistentCacheTaskServer creates a new mock instance.
func NewMockDfdaemonUpload_DownloadPersistentCacheTaskServer(ctrl *gomock.Controller) *MockDfdaemonUpload_DownloadPersistentCacheTaskServer {
	mock := &MockDfdaemonUpload_DownloadPersistentCacheTaskServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_DownloadPersistentCacheTaskServerMockRecorder{mock}
	return mock
}

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

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

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

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

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockDfdaemonUpload_DownloadPersistentCacheTaskServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentCacheTaskServer)(nil).RecvMsg), m)
}

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

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

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

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

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

// SendMsg indicates an expected call of SendMsg.
func (mr *MockDfdaemonUpload_DownloadPersistentCacheTaskServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentCacheTaskServer)(nil).SendMsg), m)
}

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

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

// SetTrailer mocks base method.
func (m *MockDfdaemonUpload_DownloadPersistentCacheTaskServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

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

// MockDfdaemonDownloadClient is a mock of DfdaemonDownloadClient interface.
type MockDfdaemonDownloadClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonDownloadClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonDownloadClientMockRecorder is the mock recorder for MockDfdaemonDownloadClient.
type MockDfdaemonDownloadClientMockRecorder struct {
	mock *MockDfdaemonDownloadClient
}

// NewMockDfdaemonDownloadClient creates a new mock instance.
func NewMockDfdaemonDownloadClient(ctrl *gomock.Controller) *MockDfdaemonDownloadClient {
	mock := &MockDfdaemonDownloadClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonDownloadClientMockRecorder{mock}
	return mock
}

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

// DeleteHost mocks base method.
func (m *MockDfdaemonDownloadClient) DeleteHost(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteHost", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteHost indicates an expected call of DeleteHost.
func (mr *MockDfdaemonDownloadClientMockRecorder) DeleteHost(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHost", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).DeleteHost), varargs...)
}

// DeletePersistentCacheTask mocks base method.
func (m *MockDfdaemonDownloadClient) DeletePersistentCacheTask(ctx context.Context, in *dfdaemon.DeletePersistentCacheTaskRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePersistentCacheTask", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePersistentCacheTask indicates an expected call of DeletePersistentCacheTask.
func (mr *MockDfdaemonDownloadClientMockRecorder) DeletePersistentCacheTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePersistentCacheTask", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).DeletePersistentCacheTask), varargs...)
}

// DeleteTask mocks base method.
func (m *MockDfdaemonDownloadClient) DeleteTask(ctx context.Context, in *dfdaemon.DeleteTaskRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTask", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTask indicates an expected call of DeleteTask.
func (mr *MockDfdaemonDownloadClientMockRecorder) DeleteTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTask", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).DeleteTask), varargs...)
}

// DownloadPersistentCacheTask mocks base method.
func (m *MockDfdaemonDownloadClient) DownloadPersistentCacheTask(ctx context.Context, in *dfdaemon.DownloadPersistentCacheTaskRequest, opts ...grpc.CallOption) (dfdaemon.DfdaemonDownload_DownloadPersistentCacheTaskClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DownloadPersistentCacheTask", varargs...)
	ret0, _ := ret[0].(dfdaemon.DfdaemonDownload_DownloadPersistentCacheTaskClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DownloadPersistentCacheTask indicates an expected call of DownloadPersistentCacheTask.
func (mr *MockDfdaemonDownloadClientMockRecorder) DownloadPersistentCacheTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadPersistentCacheTask", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).DownloadPersistentCacheTask), varargs...)
}

// DownloadTask mocks base method.
func (m *MockDfdaemonDownloadClient) DownloadTask(ctx context.Context, in *dfdaemon.DownloadTaskRequest, opts ...grpc.CallOption) (dfdaemon.DfdaemonDownload_DownloadTaskClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DownloadTask", varargs...)
	ret0, _ := ret[0].(dfdaemon.DfdaemonDownload_DownloadTaskClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DownloadTask indicates an expected call of DownloadTask.
func (mr *MockDfdaemonDownloadClientMockRecorder) DownloadTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadTask", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).DownloadTask), varargs...)
}

// StatPersistentCacheTask mocks base method.
func (m *MockDfdaemonDownloadClient) StatPersistentCacheTask(ctx context.Context, in *dfdaemon.StatPersistentCacheTaskRequest, opts ...grpc.CallOption) (*common.PersistentCacheTask, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StatPersistentCacheTask", varargs...)
	ret0, _ := ret[0].(*common.PersistentCacheTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StatPersistentCacheTask indicates an expected call of StatPersistentCacheTask.
func (mr *MockDfdaemonDownloadClientMockRecorder) StatPersistentCacheTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatPersistentCacheTask", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).StatPersistentCacheTask), varargs...)
}

// StatTask mocks base method.
func (m *MockDfdaemonDownloadClient) StatTask(ctx context.Context, in *dfdaemon.StatTaskRequest, opts ...grpc.CallOption) (*common.Task, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StatTask", varargs...)
	ret0, _ := ret[0].(*common.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StatTask indicates an expected call of StatTask.
func (mr *MockDfdaemonDownloadClientMockRecorder) StatTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatTask", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).StatTask), varargs...)
}

// UploadPersistentCacheTask mocks base method.
func (m *MockDfdaemonDownloadClient) UploadPersistentCacheTask(ctx context.Context, in *dfdaemon.UploadPersistentCacheTaskRequest, opts ...grpc.CallOption) (*common.PersistentCacheTask, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UploadPersistentCacheTask", varargs...)
	ret0, _ := ret[0].(*common.PersistentCacheTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UploadPersistentCacheTask indicates an expected call of UploadPersistentCacheTask.
func (mr *MockDfdaemonDownloadClientMockRecorder) UploadPersistentCacheTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPersistentCacheTask", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).UploadPersistentCacheTask), varargs...)
}

// UploadTask mocks base method.
func (m *MockDfdaemonDownloadClient) UploadTask(ctx context.Context, in *dfdaemon.UploadTaskRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UploadTask", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UploadTask indicates an expected call of UploadTask.
func (mr *MockDfdaemonDownloadClientMockRecorder) UploadTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadTask", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).UploadTask), varargs...)
}

// MockDfdaemonDownload_DownloadTaskClient is a mock of DfdaemonDownload_DownloadTaskClient interface.
type MockDfdaemonDownload_DownloadTaskClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonDownload_DownloadTaskClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonDownload_DownloadTaskClientMockRecorder is the mock recorder for MockDfdaemonDownload_DownloadTaskClient.
type MockDfdaemonDownload_DownloadTaskClientMockRecorder struct {
	mock *MockDfdaemonDownload_DownloadTaskClient
}

// NewMockDfdaemonDownload_DownloadTaskClient creates a new mock instance.
func NewMockDfdaemonDownload_DownloadTaskClient(ctrl *gomock.Controller) *MockDfdaemonDownload_DownloadTaskClient {
	mock := &MockDfdaemonDownload_DownloadTaskClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonDownload_DownloadTaskClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Header mocks base method.
func (m *MockDfdaemonDownload_DownloadTaskClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Recv mocks base method.
func (m *MockDfdaemonDownload_DownloadTaskClient) Recv() (*dfdaemon.DownloadTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*dfdaemon.DownloadTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockDfdaemonDownload_DownloadTaskClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadTaskClient)(nil).RecvMsg), m)
}

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

// SendMsg indicates an expected call of SendMsg.
func (mr *MockDfdaemonDownload_DownloadTaskClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadTaskClient)(nil).SendMsg), m)
}

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

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

// MockDfdaemonDownload_DownloadPersistentCacheTaskClient is a mock of DfdaemonDownload_DownloadPersistentCacheTaskClient interface.
type MockDfdaemonDownload_DownloadPersistentCacheTaskClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonDownload_DownloadPersistentCacheTaskClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonDownload_DownloadPersistentCacheTaskClientMockRecorder is the mock recorder for MockDfdaemonDownload_DownloadPersistentCacheTaskClient.
type MockDfdaemonDownload_DownloadPersistentCacheTaskClientMockRecorder struct {
	mock *MockDfdaemonDownload_DownloadPersistentCacheTaskClient
}

// NewMockDfdaemonDownload_DownloadPersistentCacheTaskClient creates a new mock instance.
func NewMockDfdaemonDownload_DownloadPersistentCacheTaskClient(ctrl *gomock.Controller) *MockDfdaemonDownload_DownloadPersistentCacheTaskClient {
	mock := &MockDfdaemonDownload_DownloadPersistentCacheTaskClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonDownload_DownloadPersistentCacheTaskClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Header mocks base method.
func (m *MockDfdaemonDownload_DownloadPersistentCacheTaskClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Recv mocks base method.
func (m *MockDfdaemonDownload_DownloadPersistentCacheTaskClient) Recv() (*dfdaemon.DownloadPersistentCacheTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*dfdaemon.DownloadPersistentCacheTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockDfdaemonDownload_DownloadPersistentCacheTaskClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentCacheTaskClient)(nil).RecvMsg), m)
}

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

// SendMsg indicates an expected call of SendMsg.
func (mr *MockDfdaemonDownload_DownloadPersistentCacheTaskClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentCacheTaskClient)(nil).SendMsg), m)
}

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

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

// MockDfdaemonDownloadServer is a mock of DfdaemonDownloadServer interface.
type MockDfdaemonDownloadServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonDownloadServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonDownloadServerMockRecorder is the mock recorder for MockDfdaemonDownloadServer.
type MockDfdaemonDownloadServerMockRecorder struct {
	mock *MockDfdaemonDownloadServer
}

// NewMockDfdaemonDownloadServer creates a new mock instance.
func NewMockDfdaemonDownloadServer(ctrl *gomock.Controller) *MockDfdaemonDownloadServer {
	mock := &MockDfdaemonDownloadServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonDownloadServerMockRecorder{mock}
	return mock
}

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

// DeleteHost mocks base method.
func (m *MockDfdaemonDownloadServer) DeleteHost(arg0 context.Context, arg1 *emptypb.Empty) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHost", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePersistentCacheTask mocks base method.
func (m *MockDfdaemonDownloadServer) DeletePersistentCacheTask(arg0 context.Context, arg1 *dfdaemon.DeletePersistentCacheTaskRequest) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePersistentCacheTask", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTask mocks base method.
func (m *MockDfdaemonDownloadServer) DeleteTask(arg0 context.Context, arg1 *dfdaemon.DeleteTaskRequest) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTask", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DownloadPersistentCacheTask mocks base method.
func (m *MockDfdaemonDownloadServer) DownloadPersistentCacheTask(arg0 *dfdaemon.DownloadPersistentCacheTaskRequest, arg1 dfdaemon.DfdaemonDownload_DownloadPersistentCacheTaskServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DownloadPersistentCacheTask", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DownloadTask mocks base method.
func (m *MockDfdaemonDownloadServer) DownloadTask(arg0 *dfdaemon.DownloadTaskRequest, arg1 dfdaemon.DfdaemonDownload_DownloadTaskServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DownloadTask", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// StatPersistentCacheTask mocks base method.
func (m *MockDfdaemonDownloadServer) StatPersistentCacheTask(arg0 context.Context, arg1 *dfdaemon.StatPersistentCacheTaskRequest) (*common.PersistentCacheTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatPersistentCacheTask", arg0, arg1)
	ret0, _ := ret[0].(*common.PersistentCacheTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StatTask mocks base method.
func (m *MockDfdaemonDownloadServer) StatTask(arg0 context.Context, arg1 *dfdaemon.StatTaskRequest) (*common.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatTask", arg0, arg1)
	ret0, _ := ret[0].(*common.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UploadPersistentCacheTask mocks base method.
func (m *MockDfdaemonDownloadServer) UploadPersistentCacheTask(arg0 context.Context, arg1 *dfdaemon.UploadPersistentCacheTaskRequest) (*common.PersistentCacheTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadPersistentCacheTask", arg0, arg1)
	ret0, _ := ret[0].(*common.PersistentCacheTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UploadTask mocks base method.
func (m *MockDfdaemonDownloadServer) UploadTask(arg0 context.Context, arg1 *dfdaemon.UploadTaskRequest) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadTask", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockUnsafeDfdaemonDownloadServer is a mock of UnsafeDfdaemonDownloadServer interface.
type MockUnsafeDfdaemonDownloadServer struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeDfdaemonDownloadServerMockRecorder
	isgomock struct{}
}

// MockUnsafeDfdaemonDownloadServerMockRecorder is the mock recorder for MockUnsafeDfdaemonDownloadServer.
type MockUnsafeDfdaemonDownloadServerMockRecorder struct {
	mock *MockUnsafeDfdaemonDownloadServer
}

// NewMockUnsafeDfdaemonDownloadServer creates a new mock instance.
func NewMockUnsafeDfdaemonDownloadServer(ctrl *gomock.Controller) *MockUnsafeDfdaemonDownloadServer {
	mock := &MockUnsafeDfdaemonDownloadServer{ctrl: ctrl}
	mock.recorder = &MockUnsafeDfdaemonDownloadServerMockRecorder{mock}
	return mock
}

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

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

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

// MockDfdaemonDownload_DownloadTaskServer is a mock of DfdaemonDownload_DownloadTaskServer interface.
type MockDfdaemonDownload_DownloadTaskServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonDownload_DownloadTaskServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonDownload_DownloadTaskServerMockRecorder is the mock recorder for MockDfdaemonDownload_DownloadTaskServer.
type MockDfdaemonDownload_DownloadTaskServerMockRecorder struct {
	mock *MockDfdaemonDownload_DownloadTaskServer
}

// NewMockDfdaemonDownload_DownloadTaskServer creates a new mock instance.
func NewMockDfdaemonDownload_DownloadTaskServer(ctrl *gomock.Controller) *MockDfdaemonDownload_DownloadTaskServer {
	mock := &MockDfdaemonDownload_DownloadTaskServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonDownload_DownloadTaskServerMockRecorder{mock}
	return mock
}

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

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

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

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

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockDfdaemonDownload_DownloadTaskServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadTaskServer)(nil).RecvMsg), m)
}

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

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

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

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

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

// SendMsg indicates an expected call of SendMsg.
func (mr *MockDfdaemonDownload_DownloadTaskServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadTaskServer)(nil).SendMsg), m)
}

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

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

// SetTrailer mocks base method.
func (m *MockDfdaemonDownload_DownloadTaskServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

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

// MockDfdaemonDownload_DownloadPersistentCacheTaskServer is a mock of DfdaemonDownload_DownloadPersistentCacheTaskServer interface.
type MockDfdaemonDownload_DownloadPersistentCacheTaskServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonDownload_DownloadPersistentCacheTaskServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonDownload_DownloadPersistentCacheTaskServerMockRecorder is the mock recorder for MockDfdaemonDownload_DownloadPersistentCacheTaskServer.
type MockDfdaemonDownload_DownloadPersistentCacheTaskServerMockRecorder struct {
	mock *MockDfdaemonDownload_DownloadPersistentCacheTaskServer
}

// NewMockDfdaemonDownload_DownloadPersistentCacheTaskServer creates a new mock instance.
func NewMockDfdaemonDownload_DownloadPersistentCacheTaskServer(ctrl *gomock.Controller) *MockDfdaemonDownload_DownloadPersistentCacheTaskServer {
	mock := &MockDfdaemonDownload_DownloadPersistentCacheTaskServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonDownload_DownloadPersistentCacheTaskServerMockRecorder{mock}
	return mock
}

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

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

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

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

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockDfdaemonDownload_DownloadPersistentCacheTaskServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentCacheTaskServer)(nil).RecvMsg), m)
}

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

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

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

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

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

// SendMsg indicates an expected call of SendMsg.
func (mr *MockDfdaemonDownload_DownloadPersistentCacheTaskServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentCacheTaskServer)(nil).SendMsg), m)
}

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

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

// SetTrailer mocks base method.
func (m *MockDfdaemonDownload_DownloadPersistentCacheTaskServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

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