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

// DeleteCacheTask mocks base method.
func (m *MockDfdaemonUploadClient) DeleteCacheTask(ctx context.Context, in *dfdaemon.DeleteCacheTaskRequest, 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, "DeleteCacheTask", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCacheTask indicates an expected call of DeleteCacheTask.
func (mr *MockDfdaemonUploadClientMockRecorder) DeleteCacheTask(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, "DeleteCacheTask", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).DeleteCacheTask), varargs...)
}

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

// DeletePersistentTask mocks base method.
func (m *MockDfdaemonUploadClient) DeletePersistentTask(ctx context.Context, in *dfdaemon.DeletePersistentTaskRequest, 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, "DeletePersistentTask", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePersistentTask indicates an expected call of DeletePersistentTask.
func (mr *MockDfdaemonUploadClientMockRecorder) DeletePersistentTask(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, "DeletePersistentTask", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).DeletePersistentTask), 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...)
}

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

// DownloadCachePiece indicates an expected call of DownloadCachePiece.
func (mr *MockDfdaemonUploadClientMockRecorder) DownloadCachePiece(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, "DownloadCachePiece", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).DownloadCachePiece), varargs...)
}

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

// DownloadCacheTask indicates an expected call of DownloadCacheTask.
func (mr *MockDfdaemonUploadClientMockRecorder) DownloadCacheTask(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, "DownloadCacheTask", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).DownloadCacheTask), varargs...)
}

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

// DownloadPersistentCachePiece indicates an expected call of DownloadPersistentCachePiece.
func (mr *MockDfdaemonUploadClientMockRecorder) DownloadPersistentCachePiece(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, "DownloadPersistentCachePiece", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).DownloadPersistentCachePiece), 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...)
}

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

// DownloadPersistentPiece indicates an expected call of DownloadPersistentPiece.
func (mr *MockDfdaemonUploadClientMockRecorder) DownloadPersistentPiece(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, "DownloadPersistentPiece", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).DownloadPersistentPiece), varargs...)
}

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

// DownloadPersistentTask indicates an expected call of DownloadPersistentTask.
func (mr *MockDfdaemonUploadClientMockRecorder) DownloadPersistentTask(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, "DownloadPersistentTask", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).DownloadPersistentTask), 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...)
}

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

// ExchangeIBVerbsQueuePairEndpoint indicates an expected call of ExchangeIBVerbsQueuePairEndpoint.
func (mr *MockDfdaemonUploadClientMockRecorder) ExchangeIBVerbsQueuePairEndpoint(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, "ExchangeIBVerbsQueuePairEndpoint", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).ExchangeIBVerbsQueuePairEndpoint), varargs...)
}

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

// ListTaskEntries indicates an expected call of ListTaskEntries.
func (mr *MockDfdaemonUploadClientMockRecorder) ListTaskEntries(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, "ListTaskEntries", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).ListTaskEntries), varargs...)
}

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

// StatCacheTask indicates an expected call of StatCacheTask.
func (mr *MockDfdaemonUploadClientMockRecorder) StatCacheTask(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, "StatCacheTask", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).StatCacheTask), 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...)
}

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

// StatPersistentTask indicates an expected call of StatPersistentTask.
func (mr *MockDfdaemonUploadClientMockRecorder) StatPersistentTask(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, "StatPersistentTask", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).StatPersistentTask), 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...)
}

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

// SyncCachePieces indicates an expected call of SyncCachePieces.
func (mr *MockDfdaemonUploadClientMockRecorder) SyncCachePieces(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, "SyncCachePieces", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).SyncCachePieces), varargs...)
}

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

// SyncHost indicates an expected call of SyncHost.
func (mr *MockDfdaemonUploadClientMockRecorder) SyncHost(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, "SyncHost", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).SyncHost), varargs...)
}

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

// SyncPersistentCachePieces indicates an expected call of SyncPersistentCachePieces.
func (mr *MockDfdaemonUploadClientMockRecorder) SyncPersistentCachePieces(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, "SyncPersistentCachePieces", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).SyncPersistentCachePieces), varargs...)
}

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

// SyncPersistentPieces indicates an expected call of SyncPersistentPieces.
func (mr *MockDfdaemonUploadClientMockRecorder) SyncPersistentPieces(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, "SyncPersistentPieces", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).SyncPersistentPieces), 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...)
}

// UpdatePersistentCacheTask mocks base method.
func (m *MockDfdaemonUploadClient) UpdatePersistentCacheTask(ctx context.Context, in *dfdaemon.UpdatePersistentCacheTaskRequest, 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, "UpdatePersistentCacheTask", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePersistentCacheTask indicates an expected call of UpdatePersistentCacheTask.
func (mr *MockDfdaemonUploadClientMockRecorder) UpdatePersistentCacheTask(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, "UpdatePersistentCacheTask", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).UpdatePersistentCacheTask), varargs...)
}

// UpdatePersistentTask mocks base method.
func (m *MockDfdaemonUploadClient) UpdatePersistentTask(ctx context.Context, in *dfdaemon.UpdatePersistentTaskRequest, 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, "UpdatePersistentTask", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePersistentTask indicates an expected call of UpdatePersistentTask.
func (mr *MockDfdaemonUploadClientMockRecorder) UpdatePersistentTask(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, "UpdatePersistentTask", reflect.TypeOf((*MockDfdaemonUploadClient)(nil).UpdatePersistentTask), 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_DownloadCacheTaskClient is a mock of DfdaemonUpload_DownloadCacheTaskClient interface.
type MockDfdaemonUpload_DownloadCacheTaskClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_DownloadCacheTaskClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_DownloadCacheTaskClientMockRecorder is the mock recorder for MockDfdaemonUpload_DownloadCacheTaskClient.
type MockDfdaemonUpload_DownloadCacheTaskClientMockRecorder struct {
	mock *MockDfdaemonUpload_DownloadCacheTaskClient
}

// NewMockDfdaemonUpload_DownloadCacheTaskClient creates a new mock instance.
func NewMockDfdaemonUpload_DownloadCacheTaskClient(ctrl *gomock.Controller) *MockDfdaemonUpload_DownloadCacheTaskClient {
	mock := &MockDfdaemonUpload_DownloadCacheTaskClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_DownloadCacheTaskClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockDfdaemonUpload_DownloadCacheTaskClient) 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_DownloadCacheTaskClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockDfdaemonUpload_DownloadCacheTaskClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockDfdaemonUpload_DownloadCacheTaskClient) 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_DownloadCacheTaskClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonUpload_DownloadCacheTaskClient)(nil).Context))
}

// Header mocks base method.
func (m *MockDfdaemonUpload_DownloadCacheTaskClient) 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_DownloadCacheTaskClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockDfdaemonUpload_DownloadCacheTaskClient)(nil).Header))
}

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

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

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonUpload_DownloadCacheTaskClient) 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_DownloadCacheTaskClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadCacheTaskClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonUpload_DownloadCacheTaskClient) 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_DownloadCacheTaskClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadCacheTaskClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockDfdaemonUpload_DownloadCacheTaskClient) 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_DownloadCacheTaskClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockDfdaemonUpload_DownloadCacheTaskClient)(nil).Trailer))
}

// MockDfdaemonUpload_SyncCachePiecesClient is a mock of DfdaemonUpload_SyncCachePiecesClient interface.
type MockDfdaemonUpload_SyncCachePiecesClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_SyncCachePiecesClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_SyncCachePiecesClientMockRecorder is the mock recorder for MockDfdaemonUpload_SyncCachePiecesClient.
type MockDfdaemonUpload_SyncCachePiecesClientMockRecorder struct {
	mock *MockDfdaemonUpload_SyncCachePiecesClient
}

// NewMockDfdaemonUpload_SyncCachePiecesClient creates a new mock instance.
func NewMockDfdaemonUpload_SyncCachePiecesClient(ctrl *gomock.Controller) *MockDfdaemonUpload_SyncCachePiecesClient {
	mock := &MockDfdaemonUpload_SyncCachePiecesClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_SyncCachePiecesClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockDfdaemonUpload_SyncCachePiecesClient) 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_SyncCachePiecesClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockDfdaemonUpload_SyncCachePiecesClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockDfdaemonUpload_SyncCachePiecesClient) 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_SyncCachePiecesClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonUpload_SyncCachePiecesClient)(nil).Context))
}

// Header mocks base method.
func (m *MockDfdaemonUpload_SyncCachePiecesClient) 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_SyncCachePiecesClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockDfdaemonUpload_SyncCachePiecesClient)(nil).Header))
}

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

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

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncCachePiecesClient) 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_SyncCachePiecesClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncCachePiecesClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncCachePiecesClient) 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_SyncCachePiecesClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncCachePiecesClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockDfdaemonUpload_SyncCachePiecesClient) 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_SyncCachePiecesClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockDfdaemonUpload_SyncCachePiecesClient)(nil).Trailer))
}

// MockDfdaemonUpload_DownloadPersistentTaskClient is a mock of DfdaemonUpload_DownloadPersistentTaskClient interface.
type MockDfdaemonUpload_DownloadPersistentTaskClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_DownloadPersistentTaskClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_DownloadPersistentTaskClientMockRecorder is the mock recorder for MockDfdaemonUpload_DownloadPersistentTaskClient.
type MockDfdaemonUpload_DownloadPersistentTaskClientMockRecorder struct {
	mock *MockDfdaemonUpload_DownloadPersistentTaskClient
}

// NewMockDfdaemonUpload_DownloadPersistentTaskClient creates a new mock instance.
func NewMockDfdaemonUpload_DownloadPersistentTaskClient(ctrl *gomock.Controller) *MockDfdaemonUpload_DownloadPersistentTaskClient {
	mock := &MockDfdaemonUpload_DownloadPersistentTaskClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_DownloadPersistentTaskClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockDfdaemonUpload_DownloadPersistentTaskClient) 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_DownloadPersistentTaskClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentTaskClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockDfdaemonUpload_DownloadPersistentTaskClient) 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_DownloadPersistentTaskClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentTaskClient)(nil).Context))
}

// Header mocks base method.
func (m *MockDfdaemonUpload_DownloadPersistentTaskClient) 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_DownloadPersistentTaskClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentTaskClient)(nil).Header))
}

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

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

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonUpload_DownloadPersistentTaskClient) 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_DownloadPersistentTaskClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentTaskClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonUpload_DownloadPersistentTaskClient) 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_DownloadPersistentTaskClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentTaskClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockDfdaemonUpload_DownloadPersistentTaskClient) 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_DownloadPersistentTaskClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentTaskClient)(nil).Trailer))
}

// MockDfdaemonUpload_SyncPersistentPiecesClient is a mock of DfdaemonUpload_SyncPersistentPiecesClient interface.
type MockDfdaemonUpload_SyncPersistentPiecesClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_SyncPersistentPiecesClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_SyncPersistentPiecesClientMockRecorder is the mock recorder for MockDfdaemonUpload_SyncPersistentPiecesClient.
type MockDfdaemonUpload_SyncPersistentPiecesClientMockRecorder struct {
	mock *MockDfdaemonUpload_SyncPersistentPiecesClient
}

// NewMockDfdaemonUpload_SyncPersistentPiecesClient creates a new mock instance.
func NewMockDfdaemonUpload_SyncPersistentPiecesClient(ctrl *gomock.Controller) *MockDfdaemonUpload_SyncPersistentPiecesClient {
	mock := &MockDfdaemonUpload_SyncPersistentPiecesClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_SyncPersistentPiecesClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentPiecesClient) 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_SyncPersistentPiecesClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentPiecesClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentPiecesClient) 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_SyncPersistentPiecesClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentPiecesClient)(nil).Context))
}

// Header mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentPiecesClient) 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_SyncPersistentPiecesClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentPiecesClient)(nil).Header))
}

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

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

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncPersistentPiecesClient) 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_SyncPersistentPiecesClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentPiecesClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncPersistentPiecesClient) 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_SyncPersistentPiecesClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentPiecesClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentPiecesClient) 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_SyncPersistentPiecesClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentPiecesClient)(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))
}

// MockDfdaemonUpload_SyncPersistentCachePiecesClient is a mock of DfdaemonUpload_SyncPersistentCachePiecesClient interface.
type MockDfdaemonUpload_SyncPersistentCachePiecesClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_SyncPersistentCachePiecesClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_SyncPersistentCachePiecesClientMockRecorder is the mock recorder for MockDfdaemonUpload_SyncPersistentCachePiecesClient.
type MockDfdaemonUpload_SyncPersistentCachePiecesClientMockRecorder struct {
	mock *MockDfdaemonUpload_SyncPersistentCachePiecesClient
}

// NewMockDfdaemonUpload_SyncPersistentCachePiecesClient creates a new mock instance.
func NewMockDfdaemonUpload_SyncPersistentCachePiecesClient(ctrl *gomock.Controller) *MockDfdaemonUpload_SyncPersistentCachePiecesClient {
	mock := &MockDfdaemonUpload_SyncPersistentCachePiecesClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_SyncPersistentCachePiecesClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentCachePiecesClient) 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_SyncPersistentCachePiecesClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentCachePiecesClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentCachePiecesClient) 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_SyncPersistentCachePiecesClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentCachePiecesClient)(nil).Context))
}

// Header mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentCachePiecesClient) 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_SyncPersistentCachePiecesClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentCachePiecesClient)(nil).Header))
}

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

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

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncPersistentCachePiecesClient) 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_SyncPersistentCachePiecesClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentCachePiecesClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncPersistentCachePiecesClient) 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_SyncPersistentCachePiecesClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentCachePiecesClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentCachePiecesClient) 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_SyncPersistentCachePiecesClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentCachePiecesClient)(nil).Trailer))
}

// MockDfdaemonUpload_SyncHostClient is a mock of DfdaemonUpload_SyncHostClient interface.
type MockDfdaemonUpload_SyncHostClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_SyncHostClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_SyncHostClientMockRecorder is the mock recorder for MockDfdaemonUpload_SyncHostClient.
type MockDfdaemonUpload_SyncHostClientMockRecorder struct {
	mock *MockDfdaemonUpload_SyncHostClient
}

// NewMockDfdaemonUpload_SyncHostClient creates a new mock instance.
func NewMockDfdaemonUpload_SyncHostClient(ctrl *gomock.Controller) *MockDfdaemonUpload_SyncHostClient {
	mock := &MockDfdaemonUpload_SyncHostClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_SyncHostClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockDfdaemonUpload_SyncHostClient) 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_SyncHostClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockDfdaemonUpload_SyncHostClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockDfdaemonUpload_SyncHostClient) 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_SyncHostClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonUpload_SyncHostClient)(nil).Context))
}

// Header mocks base method.
func (m *MockDfdaemonUpload_SyncHostClient) 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_SyncHostClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockDfdaemonUpload_SyncHostClient)(nil).Header))
}

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

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

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncHostClient) 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_SyncHostClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncHostClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncHostClient) 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_SyncHostClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncHostClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockDfdaemonUpload_SyncHostClient) 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_SyncHostClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockDfdaemonUpload_SyncHostClient)(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
}

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

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

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

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

// DeletePersistentTask indicates an expected call of DeletePersistentTask.
func (mr *MockDfdaemonUploadServerMockRecorder) DeletePersistentTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePersistentTask", reflect.TypeOf((*MockDfdaemonUploadServer)(nil).DeletePersistentTask), 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)
}

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

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

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

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

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

// DownloadPersistentCachePiece indicates an expected call of DownloadPersistentCachePiece.
func (mr *MockDfdaemonUploadServerMockRecorder) DownloadPersistentCachePiece(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadPersistentCachePiece", reflect.TypeOf((*MockDfdaemonUploadServer)(nil).DownloadPersistentCachePiece), 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)
}

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

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

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

// DownloadPersistentTask indicates an expected call of DownloadPersistentTask.
func (mr *MockDfdaemonUploadServerMockRecorder) DownloadPersistentTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadPersistentTask", reflect.TypeOf((*MockDfdaemonUploadServer)(nil).DownloadPersistentTask), 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)
}

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

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

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

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

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

// StatCacheTask indicates an expected call of StatCacheTask.
func (mr *MockDfdaemonUploadServerMockRecorder) StatCacheTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatCacheTask", reflect.TypeOf((*MockDfdaemonUploadServer)(nil).StatCacheTask), 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)
}

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

// StatPersistentTask indicates an expected call of StatPersistentTask.
func (mr *MockDfdaemonUploadServerMockRecorder) StatPersistentTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatPersistentTask", reflect.TypeOf((*MockDfdaemonUploadServer)(nil).StatPersistentTask), 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)
}

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

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

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

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

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

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

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

// SyncPersistentPieces indicates an expected call of SyncPersistentPieces.
func (mr *MockDfdaemonUploadServerMockRecorder) SyncPersistentPieces(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncPersistentPieces", reflect.TypeOf((*MockDfdaemonUploadServer)(nil).SyncPersistentPieces), 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)
}

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

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

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

// UpdatePersistentTask indicates an expected call of UpdatePersistentTask.
func (mr *MockDfdaemonUploadServerMockRecorder) UpdatePersistentTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePersistentTask", reflect.TypeOf((*MockDfdaemonUploadServer)(nil).UpdatePersistentTask), 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_DownloadCacheTaskServer is a mock of DfdaemonUpload_DownloadCacheTaskServer interface.
type MockDfdaemonUpload_DownloadCacheTaskServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_DownloadCacheTaskServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_DownloadCacheTaskServerMockRecorder is the mock recorder for MockDfdaemonUpload_DownloadCacheTaskServer.
type MockDfdaemonUpload_DownloadCacheTaskServerMockRecorder struct {
	mock *MockDfdaemonUpload_DownloadCacheTaskServer
}

// NewMockDfdaemonUpload_DownloadCacheTaskServer creates a new mock instance.
func NewMockDfdaemonUpload_DownloadCacheTaskServer(ctrl *gomock.Controller) *MockDfdaemonUpload_DownloadCacheTaskServer {
	mock := &MockDfdaemonUpload_DownloadCacheTaskServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_DownloadCacheTaskServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockDfdaemonUpload_DownloadCacheTaskServer) 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_DownloadCacheTaskServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonUpload_DownloadCacheTaskServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonUpload_DownloadCacheTaskServer) 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_DownloadCacheTaskServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadCacheTaskServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockDfdaemonUpload_DownloadCacheTaskServer) Send(arg0 *dfdaemon.DownloadCacheTaskResponse) 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_DownloadCacheTaskServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockDfdaemonUpload_DownloadCacheTaskServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockDfdaemonUpload_DownloadCacheTaskServer) 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_DownloadCacheTaskServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockDfdaemonUpload_DownloadCacheTaskServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonUpload_DownloadCacheTaskServer) 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_DownloadCacheTaskServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadCacheTaskServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockDfdaemonUpload_DownloadCacheTaskServer) 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_DownloadCacheTaskServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockDfdaemonUpload_DownloadCacheTaskServer)(nil).SetHeader), arg0)
}

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

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

// MockDfdaemonUpload_SyncCachePiecesServer is a mock of DfdaemonUpload_SyncCachePiecesServer interface.
type MockDfdaemonUpload_SyncCachePiecesServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_SyncCachePiecesServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_SyncCachePiecesServerMockRecorder is the mock recorder for MockDfdaemonUpload_SyncCachePiecesServer.
type MockDfdaemonUpload_SyncCachePiecesServerMockRecorder struct {
	mock *MockDfdaemonUpload_SyncCachePiecesServer
}

// NewMockDfdaemonUpload_SyncCachePiecesServer creates a new mock instance.
func NewMockDfdaemonUpload_SyncCachePiecesServer(ctrl *gomock.Controller) *MockDfdaemonUpload_SyncCachePiecesServer {
	mock := &MockDfdaemonUpload_SyncCachePiecesServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_SyncCachePiecesServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockDfdaemonUpload_SyncCachePiecesServer) 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_SyncCachePiecesServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonUpload_SyncCachePiecesServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncCachePiecesServer) 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_SyncCachePiecesServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncCachePiecesServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockDfdaemonUpload_SyncCachePiecesServer) Send(arg0 *dfdaemon.SyncCachePiecesResponse) 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_SyncCachePiecesServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockDfdaemonUpload_SyncCachePiecesServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockDfdaemonUpload_SyncCachePiecesServer) 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_SyncCachePiecesServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockDfdaemonUpload_SyncCachePiecesServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncCachePiecesServer) 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_SyncCachePiecesServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncCachePiecesServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockDfdaemonUpload_SyncCachePiecesServer) 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_SyncCachePiecesServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockDfdaemonUpload_SyncCachePiecesServer)(nil).SetHeader), arg0)
}

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

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

// MockDfdaemonUpload_DownloadPersistentTaskServer is a mock of DfdaemonUpload_DownloadPersistentTaskServer interface.
type MockDfdaemonUpload_DownloadPersistentTaskServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_DownloadPersistentTaskServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_DownloadPersistentTaskServerMockRecorder is the mock recorder for MockDfdaemonUpload_DownloadPersistentTaskServer.
type MockDfdaemonUpload_DownloadPersistentTaskServerMockRecorder struct {
	mock *MockDfdaemonUpload_DownloadPersistentTaskServer
}

// NewMockDfdaemonUpload_DownloadPersistentTaskServer creates a new mock instance.
func NewMockDfdaemonUpload_DownloadPersistentTaskServer(ctrl *gomock.Controller) *MockDfdaemonUpload_DownloadPersistentTaskServer {
	mock := &MockDfdaemonUpload_DownloadPersistentTaskServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_DownloadPersistentTaskServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockDfdaemonUpload_DownloadPersistentTaskServer) 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_DownloadPersistentTaskServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentTaskServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonUpload_DownloadPersistentTaskServer) 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_DownloadPersistentTaskServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentTaskServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockDfdaemonUpload_DownloadPersistentTaskServer) Send(arg0 *dfdaemon.DownloadPersistentTaskResponse) 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_DownloadPersistentTaskServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentTaskServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockDfdaemonUpload_DownloadPersistentTaskServer) 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_DownloadPersistentTaskServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentTaskServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonUpload_DownloadPersistentTaskServer) 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_DownloadPersistentTaskServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentTaskServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockDfdaemonUpload_DownloadPersistentTaskServer) 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_DownloadPersistentTaskServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockDfdaemonUpload_DownloadPersistentTaskServer)(nil).SetHeader), arg0)
}

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

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

// MockDfdaemonUpload_SyncPersistentPiecesServer is a mock of DfdaemonUpload_SyncPersistentPiecesServer interface.
type MockDfdaemonUpload_SyncPersistentPiecesServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_SyncPersistentPiecesServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_SyncPersistentPiecesServerMockRecorder is the mock recorder for MockDfdaemonUpload_SyncPersistentPiecesServer.
type MockDfdaemonUpload_SyncPersistentPiecesServerMockRecorder struct {
	mock *MockDfdaemonUpload_SyncPersistentPiecesServer
}

// NewMockDfdaemonUpload_SyncPersistentPiecesServer creates a new mock instance.
func NewMockDfdaemonUpload_SyncPersistentPiecesServer(ctrl *gomock.Controller) *MockDfdaemonUpload_SyncPersistentPiecesServer {
	mock := &MockDfdaemonUpload_SyncPersistentPiecesServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_SyncPersistentPiecesServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentPiecesServer) 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_SyncPersistentPiecesServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentPiecesServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncPersistentPiecesServer) 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_SyncPersistentPiecesServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentPiecesServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentPiecesServer) Send(arg0 *dfdaemon.SyncPersistentPiecesResponse) 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_SyncPersistentPiecesServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentPiecesServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentPiecesServer) 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_SyncPersistentPiecesServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentPiecesServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncPersistentPiecesServer) 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_SyncPersistentPiecesServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentPiecesServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentPiecesServer) 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_SyncPersistentPiecesServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentPiecesServer)(nil).SetHeader), arg0)
}

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

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockDfdaemonUpload_SyncPersistentPiecesServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentPiecesServer)(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)
}

// MockDfdaemonUpload_SyncPersistentCachePiecesServer is a mock of DfdaemonUpload_SyncPersistentCachePiecesServer interface.
type MockDfdaemonUpload_SyncPersistentCachePiecesServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_SyncPersistentCachePiecesServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_SyncPersistentCachePiecesServerMockRecorder is the mock recorder for MockDfdaemonUpload_SyncPersistentCachePiecesServer.
type MockDfdaemonUpload_SyncPersistentCachePiecesServerMockRecorder struct {
	mock *MockDfdaemonUpload_SyncPersistentCachePiecesServer
}

// NewMockDfdaemonUpload_SyncPersistentCachePiecesServer creates a new mock instance.
func NewMockDfdaemonUpload_SyncPersistentCachePiecesServer(ctrl *gomock.Controller) *MockDfdaemonUpload_SyncPersistentCachePiecesServer {
	mock := &MockDfdaemonUpload_SyncPersistentCachePiecesServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_SyncPersistentCachePiecesServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentCachePiecesServer) 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_SyncPersistentCachePiecesServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentCachePiecesServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncPersistentCachePiecesServer) 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_SyncPersistentCachePiecesServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentCachePiecesServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentCachePiecesServer) Send(arg0 *dfdaemon.SyncPersistentCachePiecesResponse) 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_SyncPersistentCachePiecesServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentCachePiecesServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentCachePiecesServer) 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_SyncPersistentCachePiecesServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentCachePiecesServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncPersistentCachePiecesServer) 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_SyncPersistentCachePiecesServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentCachePiecesServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockDfdaemonUpload_SyncPersistentCachePiecesServer) 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_SyncPersistentCachePiecesServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockDfdaemonUpload_SyncPersistentCachePiecesServer)(nil).SetHeader), arg0)
}

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

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

// MockDfdaemonUpload_SyncHostServer is a mock of DfdaemonUpload_SyncHostServer interface.
type MockDfdaemonUpload_SyncHostServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonUpload_SyncHostServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonUpload_SyncHostServerMockRecorder is the mock recorder for MockDfdaemonUpload_SyncHostServer.
type MockDfdaemonUpload_SyncHostServerMockRecorder struct {
	mock *MockDfdaemonUpload_SyncHostServer
}

// NewMockDfdaemonUpload_SyncHostServer creates a new mock instance.
func NewMockDfdaemonUpload_SyncHostServer(ctrl *gomock.Controller) *MockDfdaemonUpload_SyncHostServer {
	mock := &MockDfdaemonUpload_SyncHostServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonUpload_SyncHostServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockDfdaemonUpload_SyncHostServer) 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_SyncHostServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonUpload_SyncHostServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncHostServer) 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_SyncHostServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncHostServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockDfdaemonUpload_SyncHostServer) Send(arg0 *common.Host) 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_SyncHostServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockDfdaemonUpload_SyncHostServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockDfdaemonUpload_SyncHostServer) 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_SyncHostServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockDfdaemonUpload_SyncHostServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonUpload_SyncHostServer) 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_SyncHostServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonUpload_SyncHostServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockDfdaemonUpload_SyncHostServer) 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_SyncHostServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockDfdaemonUpload_SyncHostServer)(nil).SetHeader), arg0)
}

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

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockDfdaemonUpload_SyncHostServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockDfdaemonUpload_SyncHostServer)(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
}

// DeleteCacheTask mocks base method.
func (m *MockDfdaemonDownloadClient) DeleteCacheTask(ctx context.Context, in *dfdaemon.DeleteCacheTaskRequest, 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, "DeleteCacheTask", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCacheTask indicates an expected call of DeleteCacheTask.
func (mr *MockDfdaemonDownloadClientMockRecorder) DeleteCacheTask(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, "DeleteCacheTask", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).DeleteCacheTask), varargs...)
}

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

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

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

// DownloadCacheTask indicates an expected call of DownloadCacheTask.
func (mr *MockDfdaemonDownloadClientMockRecorder) DownloadCacheTask(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, "DownloadCacheTask", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).DownloadCacheTask), 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...)
}

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

// DownloadPersistentTask indicates an expected call of DownloadPersistentTask.
func (mr *MockDfdaemonDownloadClientMockRecorder) DownloadPersistentTask(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, "DownloadPersistentTask", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).DownloadPersistentTask), 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...)
}

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

// ListTaskEntries indicates an expected call of ListTaskEntries.
func (mr *MockDfdaemonDownloadClientMockRecorder) ListTaskEntries(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, "ListTaskEntries", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).ListTaskEntries), varargs...)
}

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

// StatCacheTask indicates an expected call of StatCacheTask.
func (mr *MockDfdaemonDownloadClientMockRecorder) StatCacheTask(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, "StatCacheTask", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).StatCacheTask), 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...)
}

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

// UploadPersistentTask indicates an expected call of UploadPersistentTask.
func (mr *MockDfdaemonDownloadClientMockRecorder) UploadPersistentTask(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, "UploadPersistentTask", reflect.TypeOf((*MockDfdaemonDownloadClient)(nil).UploadPersistentTask), 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_DownloadCacheTaskClient is a mock of DfdaemonDownload_DownloadCacheTaskClient interface.
type MockDfdaemonDownload_DownloadCacheTaskClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonDownload_DownloadCacheTaskClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonDownload_DownloadCacheTaskClientMockRecorder is the mock recorder for MockDfdaemonDownload_DownloadCacheTaskClient.
type MockDfdaemonDownload_DownloadCacheTaskClientMockRecorder struct {
	mock *MockDfdaemonDownload_DownloadCacheTaskClient
}

// NewMockDfdaemonDownload_DownloadCacheTaskClient creates a new mock instance.
func NewMockDfdaemonDownload_DownloadCacheTaskClient(ctrl *gomock.Controller) *MockDfdaemonDownload_DownloadCacheTaskClient {
	mock := &MockDfdaemonDownload_DownloadCacheTaskClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonDownload_DownloadCacheTaskClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockDfdaemonDownload_DownloadCacheTaskClient) 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_DownloadCacheTaskClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockDfdaemonDownload_DownloadCacheTaskClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockDfdaemonDownload_DownloadCacheTaskClient) 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_DownloadCacheTaskClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonDownload_DownloadCacheTaskClient)(nil).Context))
}

// Header mocks base method.
func (m *MockDfdaemonDownload_DownloadCacheTaskClient) 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_DownloadCacheTaskClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockDfdaemonDownload_DownloadCacheTaskClient)(nil).Header))
}

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

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

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonDownload_DownloadCacheTaskClient) 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_DownloadCacheTaskClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadCacheTaskClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonDownload_DownloadCacheTaskClient) 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_DownloadCacheTaskClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadCacheTaskClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockDfdaemonDownload_DownloadCacheTaskClient) 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_DownloadCacheTaskClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockDfdaemonDownload_DownloadCacheTaskClient)(nil).Trailer))
}

// MockDfdaemonDownload_DownloadPersistentTaskClient is a mock of DfdaemonDownload_DownloadPersistentTaskClient interface.
type MockDfdaemonDownload_DownloadPersistentTaskClient struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonDownload_DownloadPersistentTaskClientMockRecorder
	isgomock struct{}
}

// MockDfdaemonDownload_DownloadPersistentTaskClientMockRecorder is the mock recorder for MockDfdaemonDownload_DownloadPersistentTaskClient.
type MockDfdaemonDownload_DownloadPersistentTaskClientMockRecorder struct {
	mock *MockDfdaemonDownload_DownloadPersistentTaskClient
}

// NewMockDfdaemonDownload_DownloadPersistentTaskClient creates a new mock instance.
func NewMockDfdaemonDownload_DownloadPersistentTaskClient(ctrl *gomock.Controller) *MockDfdaemonDownload_DownloadPersistentTaskClient {
	mock := &MockDfdaemonDownload_DownloadPersistentTaskClient{ctrl: ctrl}
	mock.recorder = &MockDfdaemonDownload_DownloadPersistentTaskClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockDfdaemonDownload_DownloadPersistentTaskClient) 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_DownloadPersistentTaskClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentTaskClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockDfdaemonDownload_DownloadPersistentTaskClient) 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_DownloadPersistentTaskClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentTaskClient)(nil).Context))
}

// Header mocks base method.
func (m *MockDfdaemonDownload_DownloadPersistentTaskClient) 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_DownloadPersistentTaskClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentTaskClient)(nil).Header))
}

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

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

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonDownload_DownloadPersistentTaskClient) 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_DownloadPersistentTaskClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentTaskClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonDownload_DownloadPersistentTaskClient) 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_DownloadPersistentTaskClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentTaskClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockDfdaemonDownload_DownloadPersistentTaskClient) 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_DownloadPersistentTaskClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentTaskClient)(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
}

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

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

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

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

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

// DownloadCacheTask indicates an expected call of DownloadCacheTask.
func (mr *MockDfdaemonDownloadServerMockRecorder) DownloadCacheTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadCacheTask", reflect.TypeOf((*MockDfdaemonDownloadServer)(nil).DownloadCacheTask), 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)
}

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

// DownloadPersistentTask indicates an expected call of DownloadPersistentTask.
func (mr *MockDfdaemonDownloadServerMockRecorder) DownloadPersistentTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadPersistentTask", reflect.TypeOf((*MockDfdaemonDownloadServer)(nil).DownloadPersistentTask), 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)
}

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

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

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

// StatCacheTask indicates an expected call of StatCacheTask.
func (mr *MockDfdaemonDownloadServerMockRecorder) StatCacheTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatCacheTask", reflect.TypeOf((*MockDfdaemonDownloadServer)(nil).StatCacheTask), 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)
}

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

// UploadPersistentTask indicates an expected call of UploadPersistentTask.
func (mr *MockDfdaemonDownloadServerMockRecorder) UploadPersistentTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPersistentTask", reflect.TypeOf((*MockDfdaemonDownloadServer)(nil).UploadPersistentTask), 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_DownloadCacheTaskServer is a mock of DfdaemonDownload_DownloadCacheTaskServer interface.
type MockDfdaemonDownload_DownloadCacheTaskServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonDownload_DownloadCacheTaskServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonDownload_DownloadCacheTaskServerMockRecorder is the mock recorder for MockDfdaemonDownload_DownloadCacheTaskServer.
type MockDfdaemonDownload_DownloadCacheTaskServerMockRecorder struct {
	mock *MockDfdaemonDownload_DownloadCacheTaskServer
}

// NewMockDfdaemonDownload_DownloadCacheTaskServer creates a new mock instance.
func NewMockDfdaemonDownload_DownloadCacheTaskServer(ctrl *gomock.Controller) *MockDfdaemonDownload_DownloadCacheTaskServer {
	mock := &MockDfdaemonDownload_DownloadCacheTaskServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonDownload_DownloadCacheTaskServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockDfdaemonDownload_DownloadCacheTaskServer) 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_DownloadCacheTaskServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonDownload_DownloadCacheTaskServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonDownload_DownloadCacheTaskServer) 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_DownloadCacheTaskServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadCacheTaskServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockDfdaemonDownload_DownloadCacheTaskServer) Send(arg0 *dfdaemon.DownloadCacheTaskResponse) 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_DownloadCacheTaskServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockDfdaemonDownload_DownloadCacheTaskServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockDfdaemonDownload_DownloadCacheTaskServer) 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_DownloadCacheTaskServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockDfdaemonDownload_DownloadCacheTaskServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonDownload_DownloadCacheTaskServer) 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_DownloadCacheTaskServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadCacheTaskServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockDfdaemonDownload_DownloadCacheTaskServer) 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_DownloadCacheTaskServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockDfdaemonDownload_DownloadCacheTaskServer)(nil).SetHeader), arg0)
}

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

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

// MockDfdaemonDownload_DownloadPersistentTaskServer is a mock of DfdaemonDownload_DownloadPersistentTaskServer interface.
type MockDfdaemonDownload_DownloadPersistentTaskServer struct {
	ctrl     *gomock.Controller
	recorder *MockDfdaemonDownload_DownloadPersistentTaskServerMockRecorder
	isgomock struct{}
}

// MockDfdaemonDownload_DownloadPersistentTaskServerMockRecorder is the mock recorder for MockDfdaemonDownload_DownloadPersistentTaskServer.
type MockDfdaemonDownload_DownloadPersistentTaskServerMockRecorder struct {
	mock *MockDfdaemonDownload_DownloadPersistentTaskServer
}

// NewMockDfdaemonDownload_DownloadPersistentTaskServer creates a new mock instance.
func NewMockDfdaemonDownload_DownloadPersistentTaskServer(ctrl *gomock.Controller) *MockDfdaemonDownload_DownloadPersistentTaskServer {
	mock := &MockDfdaemonDownload_DownloadPersistentTaskServer{ctrl: ctrl}
	mock.recorder = &MockDfdaemonDownload_DownloadPersistentTaskServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockDfdaemonDownload_DownloadPersistentTaskServer) 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_DownloadPersistentTaskServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentTaskServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockDfdaemonDownload_DownloadPersistentTaskServer) 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_DownloadPersistentTaskServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentTaskServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockDfdaemonDownload_DownloadPersistentTaskServer) Send(arg0 *dfdaemon.DownloadPersistentTaskResponse) 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_DownloadPersistentTaskServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentTaskServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockDfdaemonDownload_DownloadPersistentTaskServer) 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_DownloadPersistentTaskServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentTaskServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockDfdaemonDownload_DownloadPersistentTaskServer) 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_DownloadPersistentTaskServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentTaskServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockDfdaemonDownload_DownloadPersistentTaskServer) 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_DownloadPersistentTaskServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentTaskServer)(nil).SetHeader), arg0)
}

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

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockDfdaemonDownload_DownloadPersistentTaskServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockDfdaemonDownload_DownloadPersistentTaskServer)(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)
}
