mirror of https://github.com/dragonflyoss/api.git
1779 lines
67 KiB
Go
1779 lines
67 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: ../scheduler_grpc.pb.go
|
|
//
|
|
// Generated by this command:
|
|
//
|
|
// mockgen -destination scheduler_mock.go -source ../scheduler_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"
|
|
scheduler "d7y.io/api/v2/pkg/apis/scheduler/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"
|
|
)
|
|
|
|
// MockSchedulerClient is a mock of SchedulerClient interface.
|
|
type MockSchedulerClient struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockSchedulerClientMockRecorder
|
|
}
|
|
|
|
// MockSchedulerClientMockRecorder is the mock recorder for MockSchedulerClient.
|
|
type MockSchedulerClientMockRecorder struct {
|
|
mock *MockSchedulerClient
|
|
}
|
|
|
|
// NewMockSchedulerClient creates a new mock instance.
|
|
func NewMockSchedulerClient(ctrl *gomock.Controller) *MockSchedulerClient {
|
|
mock := &MockSchedulerClient{ctrl: ctrl}
|
|
mock.recorder = &MockSchedulerClientMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockSchedulerClient) EXPECT() *MockSchedulerClientMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// AnnounceCachePeer mocks base method.
|
|
func (m *MockSchedulerClient) AnnounceCachePeer(ctx context.Context, opts ...grpc.CallOption) (scheduler.Scheduler_AnnounceCachePeerClient, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{ctx}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "AnnounceCachePeer", varargs...)
|
|
ret0, _ := ret[0].(scheduler.Scheduler_AnnounceCachePeerClient)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AnnounceCachePeer indicates an expected call of AnnounceCachePeer.
|
|
func (mr *MockSchedulerClientMockRecorder) AnnounceCachePeer(ctx any, opts ...any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{ctx}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnounceCachePeer", reflect.TypeOf((*MockSchedulerClient)(nil).AnnounceCachePeer), varargs...)
|
|
}
|
|
|
|
// AnnounceHost mocks base method.
|
|
func (m *MockSchedulerClient) AnnounceHost(ctx context.Context, in *scheduler.AnnounceHostRequest, 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, "AnnounceHost", varargs...)
|
|
ret0, _ := ret[0].(*emptypb.Empty)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AnnounceHost indicates an expected call of AnnounceHost.
|
|
func (mr *MockSchedulerClientMockRecorder) AnnounceHost(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, "AnnounceHost", reflect.TypeOf((*MockSchedulerClient)(nil).AnnounceHost), varargs...)
|
|
}
|
|
|
|
// AnnouncePeer mocks base method.
|
|
func (m *MockSchedulerClient) AnnouncePeer(ctx context.Context, opts ...grpc.CallOption) (scheduler.Scheduler_AnnouncePeerClient, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{ctx}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "AnnouncePeer", varargs...)
|
|
ret0, _ := ret[0].(scheduler.Scheduler_AnnouncePeerClient)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AnnouncePeer indicates an expected call of AnnouncePeer.
|
|
func (mr *MockSchedulerClientMockRecorder) AnnouncePeer(ctx any, opts ...any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{ctx}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnouncePeer", reflect.TypeOf((*MockSchedulerClient)(nil).AnnouncePeer), varargs...)
|
|
}
|
|
|
|
// AnnouncePeers mocks base method.
|
|
func (m *MockSchedulerClient) AnnouncePeers(ctx context.Context, opts ...grpc.CallOption) (scheduler.Scheduler_AnnouncePeersClient, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{ctx}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "AnnouncePeers", varargs...)
|
|
ret0, _ := ret[0].(scheduler.Scheduler_AnnouncePeersClient)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AnnouncePeers indicates an expected call of AnnouncePeers.
|
|
func (mr *MockSchedulerClientMockRecorder) AnnouncePeers(ctx any, opts ...any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{ctx}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnouncePeers", reflect.TypeOf((*MockSchedulerClient)(nil).AnnouncePeers), varargs...)
|
|
}
|
|
|
|
// DeleteCachePeer mocks base method.
|
|
func (m *MockSchedulerClient) DeleteCachePeer(ctx context.Context, in *scheduler.DeleteCachePeerRequest, 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, "DeleteCachePeer", varargs...)
|
|
ret0, _ := ret[0].(*emptypb.Empty)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DeleteCachePeer indicates an expected call of DeleteCachePeer.
|
|
func (mr *MockSchedulerClientMockRecorder) DeleteCachePeer(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, "DeleteCachePeer", reflect.TypeOf((*MockSchedulerClient)(nil).DeleteCachePeer), varargs...)
|
|
}
|
|
|
|
// DeleteCacheTask mocks base method.
|
|
func (m *MockSchedulerClient) DeleteCacheTask(ctx context.Context, in *scheduler.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 *MockSchedulerClientMockRecorder) 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((*MockSchedulerClient)(nil).DeleteCacheTask), varargs...)
|
|
}
|
|
|
|
// DeleteHost mocks base method.
|
|
func (m *MockSchedulerClient) DeleteHost(ctx context.Context, in *scheduler.DeleteHostRequest, 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 *MockSchedulerClientMockRecorder) 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((*MockSchedulerClient)(nil).DeleteHost), varargs...)
|
|
}
|
|
|
|
// DeletePeer mocks base method.
|
|
func (m *MockSchedulerClient) DeletePeer(ctx context.Context, in *scheduler.DeletePeerRequest, 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, "DeletePeer", varargs...)
|
|
ret0, _ := ret[0].(*emptypb.Empty)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DeletePeer indicates an expected call of DeletePeer.
|
|
func (mr *MockSchedulerClientMockRecorder) DeletePeer(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, "DeletePeer", reflect.TypeOf((*MockSchedulerClient)(nil).DeletePeer), varargs...)
|
|
}
|
|
|
|
// DeleteTask mocks base method.
|
|
func (m *MockSchedulerClient) DeleteTask(ctx context.Context, in *scheduler.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 *MockSchedulerClientMockRecorder) 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((*MockSchedulerClient)(nil).DeleteTask), varargs...)
|
|
}
|
|
|
|
// StatCachePeer mocks base method.
|
|
func (m *MockSchedulerClient) StatCachePeer(ctx context.Context, in *scheduler.StatCachePeerRequest, opts ...grpc.CallOption) (*common.CachePeer, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "StatCachePeer", varargs...)
|
|
ret0, _ := ret[0].(*common.CachePeer)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StatCachePeer indicates an expected call of StatCachePeer.
|
|
func (mr *MockSchedulerClientMockRecorder) StatCachePeer(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, "StatCachePeer", reflect.TypeOf((*MockSchedulerClient)(nil).StatCachePeer), varargs...)
|
|
}
|
|
|
|
// StatCacheTask mocks base method.
|
|
func (m *MockSchedulerClient) StatCacheTask(ctx context.Context, in *scheduler.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 *MockSchedulerClientMockRecorder) 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((*MockSchedulerClient)(nil).StatCacheTask), varargs...)
|
|
}
|
|
|
|
// StatPeer mocks base method.
|
|
func (m *MockSchedulerClient) StatPeer(ctx context.Context, in *scheduler.StatPeerRequest, opts ...grpc.CallOption) (*common.Peer, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "StatPeer", varargs...)
|
|
ret0, _ := ret[0].(*common.Peer)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StatPeer indicates an expected call of StatPeer.
|
|
func (mr *MockSchedulerClientMockRecorder) StatPeer(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, "StatPeer", reflect.TypeOf((*MockSchedulerClient)(nil).StatPeer), varargs...)
|
|
}
|
|
|
|
// StatTask mocks base method.
|
|
func (m *MockSchedulerClient) StatTask(ctx context.Context, in *scheduler.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 *MockSchedulerClientMockRecorder) 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((*MockSchedulerClient)(nil).StatTask), varargs...)
|
|
}
|
|
|
|
// SyncProbes mocks base method.
|
|
func (m *MockSchedulerClient) SyncProbes(ctx context.Context, opts ...grpc.CallOption) (scheduler.Scheduler_SyncProbesClient, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{ctx}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SyncProbes", varargs...)
|
|
ret0, _ := ret[0].(scheduler.Scheduler_SyncProbesClient)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SyncProbes indicates an expected call of SyncProbes.
|
|
func (mr *MockSchedulerClientMockRecorder) SyncProbes(ctx any, opts ...any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{ctx}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncProbes", reflect.TypeOf((*MockSchedulerClient)(nil).SyncProbes), varargs...)
|
|
}
|
|
|
|
// UploadCacheTaskFailed mocks base method.
|
|
func (m *MockSchedulerClient) UploadCacheTaskFailed(ctx context.Context, in *scheduler.UploadCacheTaskFailedRequest, 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, "UploadCacheTaskFailed", varargs...)
|
|
ret0, _ := ret[0].(*emptypb.Empty)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UploadCacheTaskFailed indicates an expected call of UploadCacheTaskFailed.
|
|
func (mr *MockSchedulerClientMockRecorder) UploadCacheTaskFailed(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, "UploadCacheTaskFailed", reflect.TypeOf((*MockSchedulerClient)(nil).UploadCacheTaskFailed), varargs...)
|
|
}
|
|
|
|
// UploadCacheTaskFinished mocks base method.
|
|
func (m *MockSchedulerClient) UploadCacheTaskFinished(ctx context.Context, in *scheduler.UploadCacheTaskFinishedRequest, 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, "UploadCacheTaskFinished", varargs...)
|
|
ret0, _ := ret[0].(*common.CacheTask)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UploadCacheTaskFinished indicates an expected call of UploadCacheTaskFinished.
|
|
func (mr *MockSchedulerClientMockRecorder) UploadCacheTaskFinished(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, "UploadCacheTaskFinished", reflect.TypeOf((*MockSchedulerClient)(nil).UploadCacheTaskFinished), varargs...)
|
|
}
|
|
|
|
// UploadCacheTaskStarted mocks base method.
|
|
func (m *MockSchedulerClient) UploadCacheTaskStarted(ctx context.Context, in *scheduler.UploadCacheTaskStartedRequest, 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, "UploadCacheTaskStarted", varargs...)
|
|
ret0, _ := ret[0].(*emptypb.Empty)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UploadCacheTaskStarted indicates an expected call of UploadCacheTaskStarted.
|
|
func (mr *MockSchedulerClientMockRecorder) UploadCacheTaskStarted(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, "UploadCacheTaskStarted", reflect.TypeOf((*MockSchedulerClient)(nil).UploadCacheTaskStarted), varargs...)
|
|
}
|
|
|
|
// MockScheduler_AnnouncePeerClient is a mock of Scheduler_AnnouncePeerClient interface.
|
|
type MockScheduler_AnnouncePeerClient struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockScheduler_AnnouncePeerClientMockRecorder
|
|
}
|
|
|
|
// MockScheduler_AnnouncePeerClientMockRecorder is the mock recorder for MockScheduler_AnnouncePeerClient.
|
|
type MockScheduler_AnnouncePeerClientMockRecorder struct {
|
|
mock *MockScheduler_AnnouncePeerClient
|
|
}
|
|
|
|
// NewMockScheduler_AnnouncePeerClient creates a new mock instance.
|
|
func NewMockScheduler_AnnouncePeerClient(ctrl *gomock.Controller) *MockScheduler_AnnouncePeerClient {
|
|
mock := &MockScheduler_AnnouncePeerClient{ctrl: ctrl}
|
|
mock.recorder = &MockScheduler_AnnouncePeerClientMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockScheduler_AnnouncePeerClient) EXPECT() *MockScheduler_AnnouncePeerClientMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// CloseSend mocks base method.
|
|
func (m *MockScheduler_AnnouncePeerClient) 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 *MockScheduler_AnnouncePeerClientMockRecorder) CloseSend() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockScheduler_AnnouncePeerClient)(nil).CloseSend))
|
|
}
|
|
|
|
// Context mocks base method.
|
|
func (m *MockScheduler_AnnouncePeerClient) 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 *MockScheduler_AnnouncePeerClientMockRecorder) Context() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockScheduler_AnnouncePeerClient)(nil).Context))
|
|
}
|
|
|
|
// Header mocks base method.
|
|
func (m *MockScheduler_AnnouncePeerClient) 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 *MockScheduler_AnnouncePeerClientMockRecorder) Header() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockScheduler_AnnouncePeerClient)(nil).Header))
|
|
}
|
|
|
|
// Recv mocks base method.
|
|
func (m *MockScheduler_AnnouncePeerClient) Recv() (*scheduler.AnnouncePeerResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Recv")
|
|
ret0, _ := ret[0].(*scheduler.AnnouncePeerResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Recv indicates an expected call of Recv.
|
|
func (mr *MockScheduler_AnnouncePeerClientMockRecorder) Recv() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockScheduler_AnnouncePeerClient)(nil).Recv))
|
|
}
|
|
|
|
// RecvMsg mocks base method.
|
|
func (m_2 *MockScheduler_AnnouncePeerClient) 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 *MockScheduler_AnnouncePeerClientMockRecorder) RecvMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_AnnouncePeerClient)(nil).RecvMsg), m)
|
|
}
|
|
|
|
// Send mocks base method.
|
|
func (m *MockScheduler_AnnouncePeerClient) Send(arg0 *scheduler.AnnouncePeerRequest) 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 *MockScheduler_AnnouncePeerClientMockRecorder) Send(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_AnnouncePeerClient)(nil).Send), arg0)
|
|
}
|
|
|
|
// SendMsg mocks base method.
|
|
func (m_2 *MockScheduler_AnnouncePeerClient) 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 *MockScheduler_AnnouncePeerClientMockRecorder) SendMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_AnnouncePeerClient)(nil).SendMsg), m)
|
|
}
|
|
|
|
// Trailer mocks base method.
|
|
func (m *MockScheduler_AnnouncePeerClient) 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 *MockScheduler_AnnouncePeerClientMockRecorder) Trailer() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockScheduler_AnnouncePeerClient)(nil).Trailer))
|
|
}
|
|
|
|
// MockScheduler_AnnouncePeersClient is a mock of Scheduler_AnnouncePeersClient interface.
|
|
type MockScheduler_AnnouncePeersClient struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockScheduler_AnnouncePeersClientMockRecorder
|
|
}
|
|
|
|
// MockScheduler_AnnouncePeersClientMockRecorder is the mock recorder for MockScheduler_AnnouncePeersClient.
|
|
type MockScheduler_AnnouncePeersClientMockRecorder struct {
|
|
mock *MockScheduler_AnnouncePeersClient
|
|
}
|
|
|
|
// NewMockScheduler_AnnouncePeersClient creates a new mock instance.
|
|
func NewMockScheduler_AnnouncePeersClient(ctrl *gomock.Controller) *MockScheduler_AnnouncePeersClient {
|
|
mock := &MockScheduler_AnnouncePeersClient{ctrl: ctrl}
|
|
mock.recorder = &MockScheduler_AnnouncePeersClientMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockScheduler_AnnouncePeersClient) EXPECT() *MockScheduler_AnnouncePeersClientMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// CloseSend mocks base method.
|
|
func (m *MockScheduler_AnnouncePeersClient) 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 *MockScheduler_AnnouncePeersClientMockRecorder) CloseSend() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockScheduler_AnnouncePeersClient)(nil).CloseSend))
|
|
}
|
|
|
|
// Context mocks base method.
|
|
func (m *MockScheduler_AnnouncePeersClient) 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 *MockScheduler_AnnouncePeersClientMockRecorder) Context() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockScheduler_AnnouncePeersClient)(nil).Context))
|
|
}
|
|
|
|
// Header mocks base method.
|
|
func (m *MockScheduler_AnnouncePeersClient) 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 *MockScheduler_AnnouncePeersClientMockRecorder) Header() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockScheduler_AnnouncePeersClient)(nil).Header))
|
|
}
|
|
|
|
// Recv mocks base method.
|
|
func (m *MockScheduler_AnnouncePeersClient) Recv() (*emptypb.Empty, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Recv")
|
|
ret0, _ := ret[0].(*emptypb.Empty)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Recv indicates an expected call of Recv.
|
|
func (mr *MockScheduler_AnnouncePeersClientMockRecorder) Recv() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockScheduler_AnnouncePeersClient)(nil).Recv))
|
|
}
|
|
|
|
// RecvMsg mocks base method.
|
|
func (m_2 *MockScheduler_AnnouncePeersClient) 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 *MockScheduler_AnnouncePeersClientMockRecorder) RecvMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_AnnouncePeersClient)(nil).RecvMsg), m)
|
|
}
|
|
|
|
// Send mocks base method.
|
|
func (m *MockScheduler_AnnouncePeersClient) Send(arg0 *scheduler.AnnouncePeersRequest) 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 *MockScheduler_AnnouncePeersClientMockRecorder) Send(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_AnnouncePeersClient)(nil).Send), arg0)
|
|
}
|
|
|
|
// SendMsg mocks base method.
|
|
func (m_2 *MockScheduler_AnnouncePeersClient) 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 *MockScheduler_AnnouncePeersClientMockRecorder) SendMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_AnnouncePeersClient)(nil).SendMsg), m)
|
|
}
|
|
|
|
// Trailer mocks base method.
|
|
func (m *MockScheduler_AnnouncePeersClient) 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 *MockScheduler_AnnouncePeersClientMockRecorder) Trailer() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockScheduler_AnnouncePeersClient)(nil).Trailer))
|
|
}
|
|
|
|
// MockScheduler_SyncProbesClient is a mock of Scheduler_SyncProbesClient interface.
|
|
type MockScheduler_SyncProbesClient struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockScheduler_SyncProbesClientMockRecorder
|
|
}
|
|
|
|
// MockScheduler_SyncProbesClientMockRecorder is the mock recorder for MockScheduler_SyncProbesClient.
|
|
type MockScheduler_SyncProbesClientMockRecorder struct {
|
|
mock *MockScheduler_SyncProbesClient
|
|
}
|
|
|
|
// NewMockScheduler_SyncProbesClient creates a new mock instance.
|
|
func NewMockScheduler_SyncProbesClient(ctrl *gomock.Controller) *MockScheduler_SyncProbesClient {
|
|
mock := &MockScheduler_SyncProbesClient{ctrl: ctrl}
|
|
mock.recorder = &MockScheduler_SyncProbesClientMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockScheduler_SyncProbesClient) EXPECT() *MockScheduler_SyncProbesClientMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// CloseSend mocks base method.
|
|
func (m *MockScheduler_SyncProbesClient) 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 *MockScheduler_SyncProbesClientMockRecorder) CloseSend() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockScheduler_SyncProbesClient)(nil).CloseSend))
|
|
}
|
|
|
|
// Context mocks base method.
|
|
func (m *MockScheduler_SyncProbesClient) 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 *MockScheduler_SyncProbesClientMockRecorder) Context() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockScheduler_SyncProbesClient)(nil).Context))
|
|
}
|
|
|
|
// Header mocks base method.
|
|
func (m *MockScheduler_SyncProbesClient) 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 *MockScheduler_SyncProbesClientMockRecorder) Header() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockScheduler_SyncProbesClient)(nil).Header))
|
|
}
|
|
|
|
// Recv mocks base method.
|
|
func (m *MockScheduler_SyncProbesClient) Recv() (*scheduler.SyncProbesResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Recv")
|
|
ret0, _ := ret[0].(*scheduler.SyncProbesResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Recv indicates an expected call of Recv.
|
|
func (mr *MockScheduler_SyncProbesClientMockRecorder) Recv() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockScheduler_SyncProbesClient)(nil).Recv))
|
|
}
|
|
|
|
// RecvMsg mocks base method.
|
|
func (m_2 *MockScheduler_SyncProbesClient) 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 *MockScheduler_SyncProbesClientMockRecorder) RecvMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_SyncProbesClient)(nil).RecvMsg), m)
|
|
}
|
|
|
|
// Send mocks base method.
|
|
func (m *MockScheduler_SyncProbesClient) Send(arg0 *scheduler.SyncProbesRequest) 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 *MockScheduler_SyncProbesClientMockRecorder) Send(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_SyncProbesClient)(nil).Send), arg0)
|
|
}
|
|
|
|
// SendMsg mocks base method.
|
|
func (m_2 *MockScheduler_SyncProbesClient) 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 *MockScheduler_SyncProbesClientMockRecorder) SendMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_SyncProbesClient)(nil).SendMsg), m)
|
|
}
|
|
|
|
// Trailer mocks base method.
|
|
func (m *MockScheduler_SyncProbesClient) 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 *MockScheduler_SyncProbesClientMockRecorder) Trailer() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockScheduler_SyncProbesClient)(nil).Trailer))
|
|
}
|
|
|
|
// MockScheduler_AnnounceCachePeerClient is a mock of Scheduler_AnnounceCachePeerClient interface.
|
|
type MockScheduler_AnnounceCachePeerClient struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockScheduler_AnnounceCachePeerClientMockRecorder
|
|
}
|
|
|
|
// MockScheduler_AnnounceCachePeerClientMockRecorder is the mock recorder for MockScheduler_AnnounceCachePeerClient.
|
|
type MockScheduler_AnnounceCachePeerClientMockRecorder struct {
|
|
mock *MockScheduler_AnnounceCachePeerClient
|
|
}
|
|
|
|
// NewMockScheduler_AnnounceCachePeerClient creates a new mock instance.
|
|
func NewMockScheduler_AnnounceCachePeerClient(ctrl *gomock.Controller) *MockScheduler_AnnounceCachePeerClient {
|
|
mock := &MockScheduler_AnnounceCachePeerClient{ctrl: ctrl}
|
|
mock.recorder = &MockScheduler_AnnounceCachePeerClientMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockScheduler_AnnounceCachePeerClient) EXPECT() *MockScheduler_AnnounceCachePeerClientMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// CloseSend mocks base method.
|
|
func (m *MockScheduler_AnnounceCachePeerClient) 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 *MockScheduler_AnnounceCachePeerClientMockRecorder) CloseSend() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockScheduler_AnnounceCachePeerClient)(nil).CloseSend))
|
|
}
|
|
|
|
// Context mocks base method.
|
|
func (m *MockScheduler_AnnounceCachePeerClient) 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 *MockScheduler_AnnounceCachePeerClientMockRecorder) Context() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockScheduler_AnnounceCachePeerClient)(nil).Context))
|
|
}
|
|
|
|
// Header mocks base method.
|
|
func (m *MockScheduler_AnnounceCachePeerClient) 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 *MockScheduler_AnnounceCachePeerClientMockRecorder) Header() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockScheduler_AnnounceCachePeerClient)(nil).Header))
|
|
}
|
|
|
|
// Recv mocks base method.
|
|
func (m *MockScheduler_AnnounceCachePeerClient) Recv() (*scheduler.AnnounceCachePeerResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Recv")
|
|
ret0, _ := ret[0].(*scheduler.AnnounceCachePeerResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Recv indicates an expected call of Recv.
|
|
func (mr *MockScheduler_AnnounceCachePeerClientMockRecorder) Recv() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockScheduler_AnnounceCachePeerClient)(nil).Recv))
|
|
}
|
|
|
|
// RecvMsg mocks base method.
|
|
func (m_2 *MockScheduler_AnnounceCachePeerClient) 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 *MockScheduler_AnnounceCachePeerClientMockRecorder) RecvMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_AnnounceCachePeerClient)(nil).RecvMsg), m)
|
|
}
|
|
|
|
// Send mocks base method.
|
|
func (m *MockScheduler_AnnounceCachePeerClient) Send(arg0 *scheduler.AnnounceCachePeerRequest) 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 *MockScheduler_AnnounceCachePeerClientMockRecorder) Send(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_AnnounceCachePeerClient)(nil).Send), arg0)
|
|
}
|
|
|
|
// SendMsg mocks base method.
|
|
func (m_2 *MockScheduler_AnnounceCachePeerClient) 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 *MockScheduler_AnnounceCachePeerClientMockRecorder) SendMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_AnnounceCachePeerClient)(nil).SendMsg), m)
|
|
}
|
|
|
|
// Trailer mocks base method.
|
|
func (m *MockScheduler_AnnounceCachePeerClient) 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 *MockScheduler_AnnounceCachePeerClientMockRecorder) Trailer() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockScheduler_AnnounceCachePeerClient)(nil).Trailer))
|
|
}
|
|
|
|
// MockSchedulerServer is a mock of SchedulerServer interface.
|
|
type MockSchedulerServer struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockSchedulerServerMockRecorder
|
|
}
|
|
|
|
// MockSchedulerServerMockRecorder is the mock recorder for MockSchedulerServer.
|
|
type MockSchedulerServerMockRecorder struct {
|
|
mock *MockSchedulerServer
|
|
}
|
|
|
|
// NewMockSchedulerServer creates a new mock instance.
|
|
func NewMockSchedulerServer(ctrl *gomock.Controller) *MockSchedulerServer {
|
|
mock := &MockSchedulerServer{ctrl: ctrl}
|
|
mock.recorder = &MockSchedulerServerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockSchedulerServer) EXPECT() *MockSchedulerServerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// AnnounceCachePeer mocks base method.
|
|
func (m *MockSchedulerServer) AnnounceCachePeer(arg0 scheduler.Scheduler_AnnounceCachePeerServer) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AnnounceCachePeer", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// AnnounceCachePeer indicates an expected call of AnnounceCachePeer.
|
|
func (mr *MockSchedulerServerMockRecorder) AnnounceCachePeer(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnounceCachePeer", reflect.TypeOf((*MockSchedulerServer)(nil).AnnounceCachePeer), arg0)
|
|
}
|
|
|
|
// AnnounceHost mocks base method.
|
|
func (m *MockSchedulerServer) AnnounceHost(arg0 context.Context, arg1 *scheduler.AnnounceHostRequest) (*emptypb.Empty, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AnnounceHost", arg0, arg1)
|
|
ret0, _ := ret[0].(*emptypb.Empty)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AnnounceHost indicates an expected call of AnnounceHost.
|
|
func (mr *MockSchedulerServerMockRecorder) AnnounceHost(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnounceHost", reflect.TypeOf((*MockSchedulerServer)(nil).AnnounceHost), arg0, arg1)
|
|
}
|
|
|
|
// AnnouncePeer mocks base method.
|
|
func (m *MockSchedulerServer) AnnouncePeer(arg0 scheduler.Scheduler_AnnouncePeerServer) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AnnouncePeer", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// AnnouncePeer indicates an expected call of AnnouncePeer.
|
|
func (mr *MockSchedulerServerMockRecorder) AnnouncePeer(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnouncePeer", reflect.TypeOf((*MockSchedulerServer)(nil).AnnouncePeer), arg0)
|
|
}
|
|
|
|
// AnnouncePeers mocks base method.
|
|
func (m *MockSchedulerServer) AnnouncePeers(arg0 scheduler.Scheduler_AnnouncePeersServer) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AnnouncePeers", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// AnnouncePeers indicates an expected call of AnnouncePeers.
|
|
func (mr *MockSchedulerServerMockRecorder) AnnouncePeers(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnouncePeers", reflect.TypeOf((*MockSchedulerServer)(nil).AnnouncePeers), arg0)
|
|
}
|
|
|
|
// DeleteCachePeer mocks base method.
|
|
func (m *MockSchedulerServer) DeleteCachePeer(arg0 context.Context, arg1 *scheduler.DeleteCachePeerRequest) (*emptypb.Empty, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteCachePeer", arg0, arg1)
|
|
ret0, _ := ret[0].(*emptypb.Empty)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DeleteCachePeer indicates an expected call of DeleteCachePeer.
|
|
func (mr *MockSchedulerServerMockRecorder) DeleteCachePeer(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCachePeer", reflect.TypeOf((*MockSchedulerServer)(nil).DeleteCachePeer), arg0, arg1)
|
|
}
|
|
|
|
// DeleteCacheTask mocks base method.
|
|
func (m *MockSchedulerServer) DeleteCacheTask(arg0 context.Context, arg1 *scheduler.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 *MockSchedulerServerMockRecorder) DeleteCacheTask(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheTask", reflect.TypeOf((*MockSchedulerServer)(nil).DeleteCacheTask), arg0, arg1)
|
|
}
|
|
|
|
// DeleteHost mocks base method.
|
|
func (m *MockSchedulerServer) DeleteHost(arg0 context.Context, arg1 *scheduler.DeleteHostRequest) (*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 *MockSchedulerServerMockRecorder) DeleteHost(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHost", reflect.TypeOf((*MockSchedulerServer)(nil).DeleteHost), arg0, arg1)
|
|
}
|
|
|
|
// DeletePeer mocks base method.
|
|
func (m *MockSchedulerServer) DeletePeer(arg0 context.Context, arg1 *scheduler.DeletePeerRequest) (*emptypb.Empty, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeletePeer", arg0, arg1)
|
|
ret0, _ := ret[0].(*emptypb.Empty)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DeletePeer indicates an expected call of DeletePeer.
|
|
func (mr *MockSchedulerServerMockRecorder) DeletePeer(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePeer", reflect.TypeOf((*MockSchedulerServer)(nil).DeletePeer), arg0, arg1)
|
|
}
|
|
|
|
// DeleteTask mocks base method.
|
|
func (m *MockSchedulerServer) DeleteTask(arg0 context.Context, arg1 *scheduler.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 *MockSchedulerServerMockRecorder) DeleteTask(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTask", reflect.TypeOf((*MockSchedulerServer)(nil).DeleteTask), arg0, arg1)
|
|
}
|
|
|
|
// StatCachePeer mocks base method.
|
|
func (m *MockSchedulerServer) StatCachePeer(arg0 context.Context, arg1 *scheduler.StatCachePeerRequest) (*common.CachePeer, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StatCachePeer", arg0, arg1)
|
|
ret0, _ := ret[0].(*common.CachePeer)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StatCachePeer indicates an expected call of StatCachePeer.
|
|
func (mr *MockSchedulerServerMockRecorder) StatCachePeer(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatCachePeer", reflect.TypeOf((*MockSchedulerServer)(nil).StatCachePeer), arg0, arg1)
|
|
}
|
|
|
|
// StatCacheTask mocks base method.
|
|
func (m *MockSchedulerServer) StatCacheTask(arg0 context.Context, arg1 *scheduler.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 *MockSchedulerServerMockRecorder) StatCacheTask(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatCacheTask", reflect.TypeOf((*MockSchedulerServer)(nil).StatCacheTask), arg0, arg1)
|
|
}
|
|
|
|
// StatPeer mocks base method.
|
|
func (m *MockSchedulerServer) StatPeer(arg0 context.Context, arg1 *scheduler.StatPeerRequest) (*common.Peer, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StatPeer", arg0, arg1)
|
|
ret0, _ := ret[0].(*common.Peer)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StatPeer indicates an expected call of StatPeer.
|
|
func (mr *MockSchedulerServerMockRecorder) StatPeer(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatPeer", reflect.TypeOf((*MockSchedulerServer)(nil).StatPeer), arg0, arg1)
|
|
}
|
|
|
|
// StatTask mocks base method.
|
|
func (m *MockSchedulerServer) StatTask(arg0 context.Context, arg1 *scheduler.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 *MockSchedulerServerMockRecorder) StatTask(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatTask", reflect.TypeOf((*MockSchedulerServer)(nil).StatTask), arg0, arg1)
|
|
}
|
|
|
|
// SyncProbes mocks base method.
|
|
func (m *MockSchedulerServer) SyncProbes(arg0 scheduler.Scheduler_SyncProbesServer) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SyncProbes", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SyncProbes indicates an expected call of SyncProbes.
|
|
func (mr *MockSchedulerServerMockRecorder) SyncProbes(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncProbes", reflect.TypeOf((*MockSchedulerServer)(nil).SyncProbes), arg0)
|
|
}
|
|
|
|
// UploadCacheTaskFailed mocks base method.
|
|
func (m *MockSchedulerServer) UploadCacheTaskFailed(arg0 context.Context, arg1 *scheduler.UploadCacheTaskFailedRequest) (*emptypb.Empty, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UploadCacheTaskFailed", arg0, arg1)
|
|
ret0, _ := ret[0].(*emptypb.Empty)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UploadCacheTaskFailed indicates an expected call of UploadCacheTaskFailed.
|
|
func (mr *MockSchedulerServerMockRecorder) UploadCacheTaskFailed(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadCacheTaskFailed", reflect.TypeOf((*MockSchedulerServer)(nil).UploadCacheTaskFailed), arg0, arg1)
|
|
}
|
|
|
|
// UploadCacheTaskFinished mocks base method.
|
|
func (m *MockSchedulerServer) UploadCacheTaskFinished(arg0 context.Context, arg1 *scheduler.UploadCacheTaskFinishedRequest) (*common.CacheTask, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UploadCacheTaskFinished", arg0, arg1)
|
|
ret0, _ := ret[0].(*common.CacheTask)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UploadCacheTaskFinished indicates an expected call of UploadCacheTaskFinished.
|
|
func (mr *MockSchedulerServerMockRecorder) UploadCacheTaskFinished(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadCacheTaskFinished", reflect.TypeOf((*MockSchedulerServer)(nil).UploadCacheTaskFinished), arg0, arg1)
|
|
}
|
|
|
|
// UploadCacheTaskStarted mocks base method.
|
|
func (m *MockSchedulerServer) UploadCacheTaskStarted(arg0 context.Context, arg1 *scheduler.UploadCacheTaskStartedRequest) (*emptypb.Empty, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UploadCacheTaskStarted", arg0, arg1)
|
|
ret0, _ := ret[0].(*emptypb.Empty)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UploadCacheTaskStarted indicates an expected call of UploadCacheTaskStarted.
|
|
func (mr *MockSchedulerServerMockRecorder) UploadCacheTaskStarted(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadCacheTaskStarted", reflect.TypeOf((*MockSchedulerServer)(nil).UploadCacheTaskStarted), arg0, arg1)
|
|
}
|
|
|
|
// MockUnsafeSchedulerServer is a mock of UnsafeSchedulerServer interface.
|
|
type MockUnsafeSchedulerServer struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockUnsafeSchedulerServerMockRecorder
|
|
}
|
|
|
|
// MockUnsafeSchedulerServerMockRecorder is the mock recorder for MockUnsafeSchedulerServer.
|
|
type MockUnsafeSchedulerServerMockRecorder struct {
|
|
mock *MockUnsafeSchedulerServer
|
|
}
|
|
|
|
// NewMockUnsafeSchedulerServer creates a new mock instance.
|
|
func NewMockUnsafeSchedulerServer(ctrl *gomock.Controller) *MockUnsafeSchedulerServer {
|
|
mock := &MockUnsafeSchedulerServer{ctrl: ctrl}
|
|
mock.recorder = &MockUnsafeSchedulerServerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockUnsafeSchedulerServer) EXPECT() *MockUnsafeSchedulerServerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// mustEmbedUnimplementedSchedulerServer mocks base method.
|
|
func (m *MockUnsafeSchedulerServer) mustEmbedUnimplementedSchedulerServer() {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "mustEmbedUnimplementedSchedulerServer")
|
|
}
|
|
|
|
// mustEmbedUnimplementedSchedulerServer indicates an expected call of mustEmbedUnimplementedSchedulerServer.
|
|
func (mr *MockUnsafeSchedulerServerMockRecorder) mustEmbedUnimplementedSchedulerServer() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedSchedulerServer", reflect.TypeOf((*MockUnsafeSchedulerServer)(nil).mustEmbedUnimplementedSchedulerServer))
|
|
}
|
|
|
|
// MockScheduler_AnnouncePeerServer is a mock of Scheduler_AnnouncePeerServer interface.
|
|
type MockScheduler_AnnouncePeerServer struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockScheduler_AnnouncePeerServerMockRecorder
|
|
}
|
|
|
|
// MockScheduler_AnnouncePeerServerMockRecorder is the mock recorder for MockScheduler_AnnouncePeerServer.
|
|
type MockScheduler_AnnouncePeerServerMockRecorder struct {
|
|
mock *MockScheduler_AnnouncePeerServer
|
|
}
|
|
|
|
// NewMockScheduler_AnnouncePeerServer creates a new mock instance.
|
|
func NewMockScheduler_AnnouncePeerServer(ctrl *gomock.Controller) *MockScheduler_AnnouncePeerServer {
|
|
mock := &MockScheduler_AnnouncePeerServer{ctrl: ctrl}
|
|
mock.recorder = &MockScheduler_AnnouncePeerServerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockScheduler_AnnouncePeerServer) EXPECT() *MockScheduler_AnnouncePeerServerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Context mocks base method.
|
|
func (m *MockScheduler_AnnouncePeerServer) 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 *MockScheduler_AnnouncePeerServerMockRecorder) Context() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockScheduler_AnnouncePeerServer)(nil).Context))
|
|
}
|
|
|
|
// Recv mocks base method.
|
|
func (m *MockScheduler_AnnouncePeerServer) Recv() (*scheduler.AnnouncePeerRequest, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Recv")
|
|
ret0, _ := ret[0].(*scheduler.AnnouncePeerRequest)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Recv indicates an expected call of Recv.
|
|
func (mr *MockScheduler_AnnouncePeerServerMockRecorder) Recv() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockScheduler_AnnouncePeerServer)(nil).Recv))
|
|
}
|
|
|
|
// RecvMsg mocks base method.
|
|
func (m_2 *MockScheduler_AnnouncePeerServer) 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 *MockScheduler_AnnouncePeerServerMockRecorder) RecvMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_AnnouncePeerServer)(nil).RecvMsg), m)
|
|
}
|
|
|
|
// Send mocks base method.
|
|
func (m *MockScheduler_AnnouncePeerServer) Send(arg0 *scheduler.AnnouncePeerResponse) 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 *MockScheduler_AnnouncePeerServerMockRecorder) Send(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_AnnouncePeerServer)(nil).Send), arg0)
|
|
}
|
|
|
|
// SendHeader mocks base method.
|
|
func (m *MockScheduler_AnnouncePeerServer) 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 *MockScheduler_AnnouncePeerServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockScheduler_AnnouncePeerServer)(nil).SendHeader), arg0)
|
|
}
|
|
|
|
// SendMsg mocks base method.
|
|
func (m_2 *MockScheduler_AnnouncePeerServer) 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 *MockScheduler_AnnouncePeerServerMockRecorder) SendMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_AnnouncePeerServer)(nil).SendMsg), m)
|
|
}
|
|
|
|
// SetHeader mocks base method.
|
|
func (m *MockScheduler_AnnouncePeerServer) 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 *MockScheduler_AnnouncePeerServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockScheduler_AnnouncePeerServer)(nil).SetHeader), arg0)
|
|
}
|
|
|
|
// SetTrailer mocks base method.
|
|
func (m *MockScheduler_AnnouncePeerServer) SetTrailer(arg0 metadata.MD) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetTrailer", arg0)
|
|
}
|
|
|
|
// SetTrailer indicates an expected call of SetTrailer.
|
|
func (mr *MockScheduler_AnnouncePeerServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockScheduler_AnnouncePeerServer)(nil).SetTrailer), arg0)
|
|
}
|
|
|
|
// MockScheduler_AnnouncePeersServer is a mock of Scheduler_AnnouncePeersServer interface.
|
|
type MockScheduler_AnnouncePeersServer struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockScheduler_AnnouncePeersServerMockRecorder
|
|
}
|
|
|
|
// MockScheduler_AnnouncePeersServerMockRecorder is the mock recorder for MockScheduler_AnnouncePeersServer.
|
|
type MockScheduler_AnnouncePeersServerMockRecorder struct {
|
|
mock *MockScheduler_AnnouncePeersServer
|
|
}
|
|
|
|
// NewMockScheduler_AnnouncePeersServer creates a new mock instance.
|
|
func NewMockScheduler_AnnouncePeersServer(ctrl *gomock.Controller) *MockScheduler_AnnouncePeersServer {
|
|
mock := &MockScheduler_AnnouncePeersServer{ctrl: ctrl}
|
|
mock.recorder = &MockScheduler_AnnouncePeersServerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockScheduler_AnnouncePeersServer) EXPECT() *MockScheduler_AnnouncePeersServerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Context mocks base method.
|
|
func (m *MockScheduler_AnnouncePeersServer) 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 *MockScheduler_AnnouncePeersServerMockRecorder) Context() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockScheduler_AnnouncePeersServer)(nil).Context))
|
|
}
|
|
|
|
// Recv mocks base method.
|
|
func (m *MockScheduler_AnnouncePeersServer) Recv() (*scheduler.AnnouncePeersRequest, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Recv")
|
|
ret0, _ := ret[0].(*scheduler.AnnouncePeersRequest)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Recv indicates an expected call of Recv.
|
|
func (mr *MockScheduler_AnnouncePeersServerMockRecorder) Recv() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockScheduler_AnnouncePeersServer)(nil).Recv))
|
|
}
|
|
|
|
// RecvMsg mocks base method.
|
|
func (m_2 *MockScheduler_AnnouncePeersServer) 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 *MockScheduler_AnnouncePeersServerMockRecorder) RecvMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_AnnouncePeersServer)(nil).RecvMsg), m)
|
|
}
|
|
|
|
// Send mocks base method.
|
|
func (m *MockScheduler_AnnouncePeersServer) Send(arg0 *emptypb.Empty) 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 *MockScheduler_AnnouncePeersServerMockRecorder) Send(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_AnnouncePeersServer)(nil).Send), arg0)
|
|
}
|
|
|
|
// SendHeader mocks base method.
|
|
func (m *MockScheduler_AnnouncePeersServer) 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 *MockScheduler_AnnouncePeersServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockScheduler_AnnouncePeersServer)(nil).SendHeader), arg0)
|
|
}
|
|
|
|
// SendMsg mocks base method.
|
|
func (m_2 *MockScheduler_AnnouncePeersServer) 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 *MockScheduler_AnnouncePeersServerMockRecorder) SendMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_AnnouncePeersServer)(nil).SendMsg), m)
|
|
}
|
|
|
|
// SetHeader mocks base method.
|
|
func (m *MockScheduler_AnnouncePeersServer) 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 *MockScheduler_AnnouncePeersServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockScheduler_AnnouncePeersServer)(nil).SetHeader), arg0)
|
|
}
|
|
|
|
// SetTrailer mocks base method.
|
|
func (m *MockScheduler_AnnouncePeersServer) SetTrailer(arg0 metadata.MD) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetTrailer", arg0)
|
|
}
|
|
|
|
// SetTrailer indicates an expected call of SetTrailer.
|
|
func (mr *MockScheduler_AnnouncePeersServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockScheduler_AnnouncePeersServer)(nil).SetTrailer), arg0)
|
|
}
|
|
|
|
// MockScheduler_SyncProbesServer is a mock of Scheduler_SyncProbesServer interface.
|
|
type MockScheduler_SyncProbesServer struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockScheduler_SyncProbesServerMockRecorder
|
|
}
|
|
|
|
// MockScheduler_SyncProbesServerMockRecorder is the mock recorder for MockScheduler_SyncProbesServer.
|
|
type MockScheduler_SyncProbesServerMockRecorder struct {
|
|
mock *MockScheduler_SyncProbesServer
|
|
}
|
|
|
|
// NewMockScheduler_SyncProbesServer creates a new mock instance.
|
|
func NewMockScheduler_SyncProbesServer(ctrl *gomock.Controller) *MockScheduler_SyncProbesServer {
|
|
mock := &MockScheduler_SyncProbesServer{ctrl: ctrl}
|
|
mock.recorder = &MockScheduler_SyncProbesServerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockScheduler_SyncProbesServer) EXPECT() *MockScheduler_SyncProbesServerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Context mocks base method.
|
|
func (m *MockScheduler_SyncProbesServer) 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 *MockScheduler_SyncProbesServerMockRecorder) Context() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockScheduler_SyncProbesServer)(nil).Context))
|
|
}
|
|
|
|
// Recv mocks base method.
|
|
func (m *MockScheduler_SyncProbesServer) Recv() (*scheduler.SyncProbesRequest, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Recv")
|
|
ret0, _ := ret[0].(*scheduler.SyncProbesRequest)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Recv indicates an expected call of Recv.
|
|
func (mr *MockScheduler_SyncProbesServerMockRecorder) Recv() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockScheduler_SyncProbesServer)(nil).Recv))
|
|
}
|
|
|
|
// RecvMsg mocks base method.
|
|
func (m_2 *MockScheduler_SyncProbesServer) 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 *MockScheduler_SyncProbesServerMockRecorder) RecvMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_SyncProbesServer)(nil).RecvMsg), m)
|
|
}
|
|
|
|
// Send mocks base method.
|
|
func (m *MockScheduler_SyncProbesServer) Send(arg0 *scheduler.SyncProbesResponse) 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 *MockScheduler_SyncProbesServerMockRecorder) Send(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_SyncProbesServer)(nil).Send), arg0)
|
|
}
|
|
|
|
// SendHeader mocks base method.
|
|
func (m *MockScheduler_SyncProbesServer) 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 *MockScheduler_SyncProbesServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockScheduler_SyncProbesServer)(nil).SendHeader), arg0)
|
|
}
|
|
|
|
// SendMsg mocks base method.
|
|
func (m_2 *MockScheduler_SyncProbesServer) 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 *MockScheduler_SyncProbesServerMockRecorder) SendMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_SyncProbesServer)(nil).SendMsg), m)
|
|
}
|
|
|
|
// SetHeader mocks base method.
|
|
func (m *MockScheduler_SyncProbesServer) 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 *MockScheduler_SyncProbesServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockScheduler_SyncProbesServer)(nil).SetHeader), arg0)
|
|
}
|
|
|
|
// SetTrailer mocks base method.
|
|
func (m *MockScheduler_SyncProbesServer) SetTrailer(arg0 metadata.MD) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetTrailer", arg0)
|
|
}
|
|
|
|
// SetTrailer indicates an expected call of SetTrailer.
|
|
func (mr *MockScheduler_SyncProbesServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockScheduler_SyncProbesServer)(nil).SetTrailer), arg0)
|
|
}
|
|
|
|
// MockScheduler_AnnounceCachePeerServer is a mock of Scheduler_AnnounceCachePeerServer interface.
|
|
type MockScheduler_AnnounceCachePeerServer struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockScheduler_AnnounceCachePeerServerMockRecorder
|
|
}
|
|
|
|
// MockScheduler_AnnounceCachePeerServerMockRecorder is the mock recorder for MockScheduler_AnnounceCachePeerServer.
|
|
type MockScheduler_AnnounceCachePeerServerMockRecorder struct {
|
|
mock *MockScheduler_AnnounceCachePeerServer
|
|
}
|
|
|
|
// NewMockScheduler_AnnounceCachePeerServer creates a new mock instance.
|
|
func NewMockScheduler_AnnounceCachePeerServer(ctrl *gomock.Controller) *MockScheduler_AnnounceCachePeerServer {
|
|
mock := &MockScheduler_AnnounceCachePeerServer{ctrl: ctrl}
|
|
mock.recorder = &MockScheduler_AnnounceCachePeerServerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockScheduler_AnnounceCachePeerServer) EXPECT() *MockScheduler_AnnounceCachePeerServerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Context mocks base method.
|
|
func (m *MockScheduler_AnnounceCachePeerServer) 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 *MockScheduler_AnnounceCachePeerServerMockRecorder) Context() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockScheduler_AnnounceCachePeerServer)(nil).Context))
|
|
}
|
|
|
|
// Recv mocks base method.
|
|
func (m *MockScheduler_AnnounceCachePeerServer) Recv() (*scheduler.AnnounceCachePeerRequest, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Recv")
|
|
ret0, _ := ret[0].(*scheduler.AnnounceCachePeerRequest)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Recv indicates an expected call of Recv.
|
|
func (mr *MockScheduler_AnnounceCachePeerServerMockRecorder) Recv() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockScheduler_AnnounceCachePeerServer)(nil).Recv))
|
|
}
|
|
|
|
// RecvMsg mocks base method.
|
|
func (m_2 *MockScheduler_AnnounceCachePeerServer) 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 *MockScheduler_AnnounceCachePeerServerMockRecorder) RecvMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_AnnounceCachePeerServer)(nil).RecvMsg), m)
|
|
}
|
|
|
|
// Send mocks base method.
|
|
func (m *MockScheduler_AnnounceCachePeerServer) Send(arg0 *scheduler.AnnounceCachePeerResponse) 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 *MockScheduler_AnnounceCachePeerServerMockRecorder) Send(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_AnnounceCachePeerServer)(nil).Send), arg0)
|
|
}
|
|
|
|
// SendHeader mocks base method.
|
|
func (m *MockScheduler_AnnounceCachePeerServer) 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 *MockScheduler_AnnounceCachePeerServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockScheduler_AnnounceCachePeerServer)(nil).SendHeader), arg0)
|
|
}
|
|
|
|
// SendMsg mocks base method.
|
|
func (m_2 *MockScheduler_AnnounceCachePeerServer) 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 *MockScheduler_AnnounceCachePeerServerMockRecorder) SendMsg(m any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_AnnounceCachePeerServer)(nil).SendMsg), m)
|
|
}
|
|
|
|
// SetHeader mocks base method.
|
|
func (m *MockScheduler_AnnounceCachePeerServer) 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 *MockScheduler_AnnounceCachePeerServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockScheduler_AnnounceCachePeerServer)(nil).SetHeader), arg0)
|
|
}
|
|
|
|
// SetTrailer mocks base method.
|
|
func (m *MockScheduler_AnnounceCachePeerServer) SetTrailer(arg0 metadata.MD) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetTrailer", arg0)
|
|
}
|
|
|
|
// SetTrailer indicates an expected call of SetTrailer.
|
|
func (mr *MockScheduler_AnnounceCachePeerServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockScheduler_AnnounceCachePeerServer)(nil).SetTrailer), arg0)
|
|
}
|