trainer_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ../trainer_grpc.pb.go

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

import (
	context "context"
	reflect "reflect"

	trainer "d7y.io/api/pkg/apis/trainer/v1"
	gomock "github.com/golang/mock/gomock"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// MockTrainerClient is a mock of TrainerClient interface.
type MockTrainerClient struct {
	ctrl     *gomock.Controller
	recorder *MockTrainerClientMockRecorder
}

// MockTrainerClientMockRecorder is the mock recorder for MockTrainerClient.
type MockTrainerClientMockRecorder struct {
	mock *MockTrainerClient
}

// NewMockTrainerClient creates a new mock instance.
func NewMockTrainerClient(ctrl *gomock.Controller) *MockTrainerClient {
	mock := &MockTrainerClient{ctrl: ctrl}
	mock.recorder = &MockTrainerClientMockRecorder{mock}
	return mock
}

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

// Train mocks base method.
func (m *MockTrainerClient) Train(ctx context.Context, opts ...grpc.CallOption) (trainer.Trainer_TrainClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Train", varargs...)
	ret0, _ := ret[0].(trainer.Trainer_TrainClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Train indicates an expected call of Train.
func (mr *MockTrainerClientMockRecorder) Train(ctx interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Train", reflect.TypeOf((*MockTrainerClient)(nil).Train), varargs...)
}

// MockTrainer_TrainClient is a mock of Trainer_TrainClient interface.
type MockTrainer_TrainClient struct {
	ctrl     *gomock.Controller
	recorder *MockTrainer_TrainClientMockRecorder
}

// MockTrainer_TrainClientMockRecorder is the mock recorder for MockTrainer_TrainClient.
type MockTrainer_TrainClientMockRecorder struct {
	mock *MockTrainer_TrainClient
}

// NewMockTrainer_TrainClient creates a new mock instance.
func NewMockTrainer_TrainClient(ctrl *gomock.Controller) *MockTrainer_TrainClient {
	mock := &MockTrainer_TrainClient{ctrl: ctrl}
	mock.recorder = &MockTrainer_TrainClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// Send mocks base method.
func (m *MockTrainer_TrainClient) Send(arg0 *trainer.TrainRequest) 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 *MockTrainer_TrainClientMockRecorder) Send(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockTrainer_TrainClient)(nil).Send), arg0)
}

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

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

// MockTrainerServer is a mock of TrainerServer interface.
type MockTrainerServer struct {
	ctrl     *gomock.Controller
	recorder *MockTrainerServerMockRecorder
}

// MockTrainerServerMockRecorder is the mock recorder for MockTrainerServer.
type MockTrainerServerMockRecorder struct {
	mock *MockTrainerServer
}

// NewMockTrainerServer creates a new mock instance.
func NewMockTrainerServer(ctrl *gomock.Controller) *MockTrainerServer {
	mock := &MockTrainerServer{ctrl: ctrl}
	mock.recorder = &MockTrainerServerMockRecorder{mock}
	return mock
}

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

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

// Train indicates an expected call of Train.
func (mr *MockTrainerServerMockRecorder) Train(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Train", reflect.TypeOf((*MockTrainerServer)(nil).Train), arg0)
}

// MockUnsafeTrainerServer is a mock of UnsafeTrainerServer interface.
type MockUnsafeTrainerServer struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeTrainerServerMockRecorder
}

// MockUnsafeTrainerServerMockRecorder is the mock recorder for MockUnsafeTrainerServer.
type MockUnsafeTrainerServerMockRecorder struct {
	mock *MockUnsafeTrainerServer
}

// NewMockUnsafeTrainerServer creates a new mock instance.
func NewMockUnsafeTrainerServer(ctrl *gomock.Controller) *MockUnsafeTrainerServer {
	mock := &MockUnsafeTrainerServer{ctrl: ctrl}
	mock.recorder = &MockUnsafeTrainerServerMockRecorder{mock}
	return mock
}

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

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

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

// MockTrainer_TrainServer is a mock of Trainer_TrainServer interface.
type MockTrainer_TrainServer struct {
	ctrl     *gomock.Controller
	recorder *MockTrainer_TrainServerMockRecorder
}

// MockTrainer_TrainServerMockRecorder is the mock recorder for MockTrainer_TrainServer.
type MockTrainer_TrainServerMockRecorder struct {
	mock *MockTrainer_TrainServer
}

// NewMockTrainer_TrainServer creates a new mock instance.
func NewMockTrainer_TrainServer(ctrl *gomock.Controller) *MockTrainer_TrainServer {
	mock := &MockTrainer_TrainServer{ctrl: ctrl}
	mock.recorder = &MockTrainer_TrainServerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// SendAndClose indicates an expected call of SendAndClose.
func (mr *MockTrainer_TrainServerMockRecorder) SendAndClose(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAndClose", reflect.TypeOf((*MockTrainer_TrainServer)(nil).SendAndClose), arg0)
}

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

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

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

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

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