github.com/pinpoint-apm/pinpoint-go-agent@v1.4.1-0.20240110120318-a50c2eb18c8c/protobuf/mock/mock_service.go

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

// Package mock_v1 is a generated GoMock package.
package mock

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	empty "github.com/golang/protobuf/ptypes/empty"
	v1 "github.com/pinpoint-apm/pinpoint-go-agent/protobuf"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
)

// MockSpanClient is a mock of SpanClient interface.
type MockSpanClient struct {
	ctrl     *gomock.Controller
	recorder *MockSpanClientMockRecorder
}

// MockSpanClientMockRecorder is the mock recorder for MockSpanClient.
type MockSpanClientMockRecorder struct {
	mock *MockSpanClient
}

// NewMockSpanClient creates a new mock instance.
func NewMockSpanClient(ctrl *gomock.Controller) *MockSpanClient {
	mock := &MockSpanClient{ctrl: ctrl}
	mock.recorder = &MockSpanClientMockRecorder{mock}
	return mock
}

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

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

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

// MockSpan_SendSpanClient is a mock of Span_SendSpanClient interface.
type MockSpan_SendSpanClient struct {
	ctrl     *gomock.Controller
	recorder *MockSpan_SendSpanClientMockRecorder
}

// MockSpan_SendSpanClientMockRecorder is the mock recorder for MockSpan_SendSpanClient.
type MockSpan_SendSpanClientMockRecorder struct {
	mock *MockSpan_SendSpanClient
}

// NewMockSpan_SendSpanClient creates a new mock instance.
func NewMockSpan_SendSpanClient(ctrl *gomock.Controller) *MockSpan_SendSpanClient {
	mock := &MockSpan_SendSpanClient{ctrl: ctrl}
	mock.recorder = &MockSpan_SendSpanClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

// MockSpanServer is a mock of SpanServer interface.
type MockSpanServer struct {
	ctrl     *gomock.Controller
	recorder *MockSpanServerMockRecorder
}

// MockSpanServerMockRecorder is the mock recorder for MockSpanServer.
type MockSpanServerMockRecorder struct {
	mock *MockSpanServer
}

// NewMockSpanServer creates a new mock instance.
func NewMockSpanServer(ctrl *gomock.Controller) *MockSpanServer {
	mock := &MockSpanServer{ctrl: ctrl}
	mock.recorder = &MockSpanServerMockRecorder{mock}
	return mock
}

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

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

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

// MockSpan_SendSpanServer is a mock of Span_SendSpanServer interface.
type MockSpan_SendSpanServer struct {
	ctrl     *gomock.Controller
	recorder *MockSpan_SendSpanServerMockRecorder
}

// MockSpan_SendSpanServerMockRecorder is the mock recorder for MockSpan_SendSpanServer.
type MockSpan_SendSpanServerMockRecorder struct {
	mock *MockSpan_SendSpanServer
}

// NewMockSpan_SendSpanServer creates a new mock instance.
func NewMockSpan_SendSpanServer(ctrl *gomock.Controller) *MockSpan_SendSpanServer {
	mock := &MockSpan_SendSpanServer{ctrl: ctrl}
	mock.recorder = &MockSpan_SendSpanServerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockAgentClient is a mock of AgentClient interface.
type MockAgentClient struct {
	ctrl     *gomock.Controller
	recorder *MockAgentClientMockRecorder
}

// MockAgentClientMockRecorder is the mock recorder for MockAgentClient.
type MockAgentClientMockRecorder struct {
	mock *MockAgentClient
}

// NewMockAgentClient creates a new mock instance.
func NewMockAgentClient(ctrl *gomock.Controller) *MockAgentClient {
	mock := &MockAgentClient{ctrl: ctrl}
	mock.recorder = &MockAgentClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockAgent_PingSessionClient is a mock of Agent_PingSessionClient interface.
type MockAgent_PingSessionClient struct {
	ctrl     *gomock.Controller
	recorder *MockAgent_PingSessionClientMockRecorder
}

// MockAgent_PingSessionClientMockRecorder is the mock recorder for MockAgent_PingSessionClient.
type MockAgent_PingSessionClientMockRecorder struct {
	mock *MockAgent_PingSessionClient
}

// NewMockAgent_PingSessionClient creates a new mock instance.
func NewMockAgent_PingSessionClient(ctrl *gomock.Controller) *MockAgent_PingSessionClient {
	mock := &MockAgent_PingSessionClient{ctrl: ctrl}
	mock.recorder = &MockAgent_PingSessionClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

// MockAgentServer is a mock of AgentServer interface.
type MockAgentServer struct {
	ctrl     *gomock.Controller
	recorder *MockAgentServerMockRecorder
}

// MockAgentServerMockRecorder is the mock recorder for MockAgentServer.
type MockAgentServerMockRecorder struct {
	mock *MockAgentServer
}

// NewMockAgentServer creates a new mock instance.
func NewMockAgentServer(ctrl *gomock.Controller) *MockAgentServer {
	mock := &MockAgentServer{ctrl: ctrl}
	mock.recorder = &MockAgentServerMockRecorder{mock}
	return mock
}

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

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

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

// RequestAgentInfo mocks base method.
func (m *MockAgentServer) RequestAgentInfo(arg0 context.Context, arg1 *v1.PAgentInfo) (*v1.PResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestAgentInfo", arg0, arg1)
	ret0, _ := ret[0].(*v1.PResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockAgent_PingSessionServer is a mock of Agent_PingSessionServer interface.
type MockAgent_PingSessionServer struct {
	ctrl     *gomock.Controller
	recorder *MockAgent_PingSessionServerMockRecorder
}

// MockAgent_PingSessionServerMockRecorder is the mock recorder for MockAgent_PingSessionServer.
type MockAgent_PingSessionServerMockRecorder struct {
	mock *MockAgent_PingSessionServer
}

// NewMockAgent_PingSessionServer creates a new mock instance.
func NewMockAgent_PingSessionServer(ctrl *gomock.Controller) *MockAgent_PingSessionServer {
	mock := &MockAgent_PingSessionServer{ctrl: ctrl}
	mock.recorder = &MockAgent_PingSessionServerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockMetadataClient is a mock of MetadataClient interface.
type MockMetadataClient struct {
	ctrl     *gomock.Controller
	recorder *MockMetadataClientMockRecorder
}

// MockMetadataClientMockRecorder is the mock recorder for MockMetadataClient.
type MockMetadataClientMockRecorder struct {
	mock *MockMetadataClient
}

// NewMockMetadataClient creates a new mock instance.
func NewMockMetadataClient(ctrl *gomock.Controller) *MockMetadataClient {
	mock := &MockMetadataClient{ctrl: ctrl}
	mock.recorder = &MockMetadataClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// MockMetadataServer is a mock of MetadataServer interface.
type MockMetadataServer struct {
	ctrl     *gomock.Controller
	recorder *MockMetadataServerMockRecorder
}

// MockMetadataServerMockRecorder is the mock recorder for MockMetadataServer.
type MockMetadataServerMockRecorder struct {
	mock *MockMetadataServer
}

// NewMockMetadataServer creates a new mock instance.
func NewMockMetadataServer(ctrl *gomock.Controller) *MockMetadataServer {
	mock := &MockMetadataServer{ctrl: ctrl}
	mock.recorder = &MockMetadataServerMockRecorder{mock}
	return mock
}

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

// RequestApiMetaData mocks base method.
func (m *MockMetadataServer) RequestApiMetaData(arg0 context.Context, arg1 *v1.PApiMetaData) (*v1.PResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestApiMetaData", arg0, arg1)
	ret0, _ := ret[0].(*v1.PResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RequestSqlMetaData mocks base method.
func (m *MockMetadataServer) RequestSqlMetaData(arg0 context.Context, arg1 *v1.PSqlMetaData) (*v1.PResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestSqlMetaData", arg0, arg1)
	ret0, _ := ret[0].(*v1.PResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RequestStringMetaData mocks base method.
func (m *MockMetadataServer) RequestStringMetaData(arg0 context.Context, arg1 *v1.PStringMetaData) (*v1.PResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestStringMetaData", arg0, arg1)
	ret0, _ := ret[0].(*v1.PResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockStatClient is a mock of StatClient interface.
type MockStatClient struct {
	ctrl     *gomock.Controller
	recorder *MockStatClientMockRecorder
}

// MockStatClientMockRecorder is the mock recorder for MockStatClient.
type MockStatClientMockRecorder struct {
	mock *MockStatClient
}

// NewMockStatClient creates a new mock instance.
func NewMockStatClient(ctrl *gomock.Controller) *MockStatClient {
	mock := &MockStatClient{ctrl: ctrl}
	mock.recorder = &MockStatClientMockRecorder{mock}
	return mock
}

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

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

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

// MockStat_SendAgentStatClient is a mock of Stat_SendAgentStatClient interface.
type MockStat_SendAgentStatClient struct {
	ctrl     *gomock.Controller
	recorder *MockStat_SendAgentStatClientMockRecorder
}

// MockStat_SendAgentStatClientMockRecorder is the mock recorder for MockStat_SendAgentStatClient.
type MockStat_SendAgentStatClientMockRecorder struct {
	mock *MockStat_SendAgentStatClient
}

// NewMockStat_SendAgentStatClient creates a new mock instance.
func NewMockStat_SendAgentStatClient(ctrl *gomock.Controller) *MockStat_SendAgentStatClient {
	mock := &MockStat_SendAgentStatClient{ctrl: ctrl}
	mock.recorder = &MockStat_SendAgentStatClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

// MockStatServer is a mock of StatServer interface.
type MockStatServer struct {
	ctrl     *gomock.Controller
	recorder *MockStatServerMockRecorder
}

// MockStatServerMockRecorder is the mock recorder for MockStatServer.
type MockStatServerMockRecorder struct {
	mock *MockStatServer
}

// NewMockStatServer creates a new mock instance.
func NewMockStatServer(ctrl *gomock.Controller) *MockStatServer {
	mock := &MockStatServer{ctrl: ctrl}
	mock.recorder = &MockStatServerMockRecorder{mock}
	return mock
}

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

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

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

// MockStat_SendAgentStatServer is a mock of Stat_SendAgentStatServer interface.
type MockStat_SendAgentStatServer struct {
	ctrl     *gomock.Controller
	recorder *MockStat_SendAgentStatServerMockRecorder
}

// MockStat_SendAgentStatServerMockRecorder is the mock recorder for MockStat_SendAgentStatServer.
type MockStat_SendAgentStatServerMockRecorder struct {
	mock *MockStat_SendAgentStatServer
}

// NewMockStat_SendAgentStatServer creates a new mock instance.
func NewMockStat_SendAgentStatServer(ctrl *gomock.Controller) *MockStat_SendAgentStatServer {
	mock := &MockStat_SendAgentStatServer{ctrl: ctrl}
	mock.recorder = &MockStat_SendAgentStatServerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockProfilerCommandServiceClient is a mock of ProfilerCommandServiceClient interface.
type MockProfilerCommandServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockProfilerCommandServiceClientMockRecorder
}

// MockProfilerCommandServiceClientMockRecorder is the mock recorder for MockProfilerCommandServiceClient.
type MockProfilerCommandServiceClientMockRecorder struct {
	mock *MockProfilerCommandServiceClient
}

// NewMockProfilerCommandServiceClient creates a new mock instance.
func NewMockProfilerCommandServiceClient(ctrl *gomock.Controller) *MockProfilerCommandServiceClient {
	mock := &MockProfilerCommandServiceClient{ctrl: ctrl}
	mock.recorder = &MockProfilerCommandServiceClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockProfilerCommandService_HandleCommandClient is a mock of ProfilerCommandService_HandleCommandClient interface.
type MockProfilerCommandService_HandleCommandClient struct {
	ctrl     *gomock.Controller
	recorder *MockProfilerCommandService_HandleCommandClientMockRecorder
}

// MockProfilerCommandService_HandleCommandClientMockRecorder is the mock recorder for MockProfilerCommandService_HandleCommandClient.
type MockProfilerCommandService_HandleCommandClientMockRecorder struct {
	mock *MockProfilerCommandService_HandleCommandClient
}

// NewMockProfilerCommandService_HandleCommandClient creates a new mock instance.
func NewMockProfilerCommandService_HandleCommandClient(ctrl *gomock.Controller) *MockProfilerCommandService_HandleCommandClient {
	mock := &MockProfilerCommandService_HandleCommandClient{ctrl: ctrl}
	mock.recorder = &MockProfilerCommandService_HandleCommandClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

// MockProfilerCommandService_CommandStreamActiveThreadCountClient is a mock of ProfilerCommandService_CommandStreamActiveThreadCountClient interface.
type MockProfilerCommandService_CommandStreamActiveThreadCountClient struct {
	ctrl     *gomock.Controller
	recorder *MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder
}

// MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder is the mock recorder for MockProfilerCommandService_CommandStreamActiveThreadCountClient.
type MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder struct {
	mock *MockProfilerCommandService_CommandStreamActiveThreadCountClient
}

// NewMockProfilerCommandService_CommandStreamActiveThreadCountClient creates a new mock instance.
func NewMockProfilerCommandService_CommandStreamActiveThreadCountClient(ctrl *gomock.Controller) *MockProfilerCommandService_CommandStreamActiveThreadCountClient {
	mock := &MockProfilerCommandService_CommandStreamActiveThreadCountClient{ctrl: ctrl}
	mock.recorder = &MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

// MockProfilerCommandServiceServer is a mock of ProfilerCommandServiceServer interface.
type MockProfilerCommandServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockProfilerCommandServiceServerMockRecorder
}

// MockProfilerCommandServiceServerMockRecorder is the mock recorder for MockProfilerCommandServiceServer.
type MockProfilerCommandServiceServerMockRecorder struct {
	mock *MockProfilerCommandServiceServer
}

// NewMockProfilerCommandServiceServer creates a new mock instance.
func NewMockProfilerCommandServiceServer(ctrl *gomock.Controller) *MockProfilerCommandServiceServer {
	mock := &MockProfilerCommandServiceServer{ctrl: ctrl}
	mock.recorder = &MockProfilerCommandServiceServerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockProfilerCommandService_HandleCommandServer is a mock of ProfilerCommandService_HandleCommandServer interface.
type MockProfilerCommandService_HandleCommandServer struct {
	ctrl     *gomock.Controller
	recorder *MockProfilerCommandService_HandleCommandServerMockRecorder
}

// MockProfilerCommandService_HandleCommandServerMockRecorder is the mock recorder for MockProfilerCommandService_HandleCommandServer.
type MockProfilerCommandService_HandleCommandServerMockRecorder struct {
	mock *MockProfilerCommandService_HandleCommandServer
}

// NewMockProfilerCommandService_HandleCommandServer creates a new mock instance.
func NewMockProfilerCommandService_HandleCommandServer(ctrl *gomock.Controller) *MockProfilerCommandService_HandleCommandServer {
	mock := &MockProfilerCommandService_HandleCommandServer{ctrl: ctrl}
	mock.recorder = &MockProfilerCommandService_HandleCommandServerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockProfilerCommandService_CommandStreamActiveThreadCountServer is a mock of ProfilerCommandService_CommandStreamActiveThreadCountServer interface.
type MockProfilerCommandService_CommandStreamActiveThreadCountServer struct {
	ctrl     *gomock.Controller
	recorder *MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder
}

// MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder is the mock recorder for MockProfilerCommandService_CommandStreamActiveThreadCountServer.
type MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder struct {
	mock *MockProfilerCommandService_CommandStreamActiveThreadCountServer
}

// NewMockProfilerCommandService_CommandStreamActiveThreadCountServer creates a new mock instance.
func NewMockProfilerCommandService_CommandStreamActiveThreadCountServer(ctrl *gomock.Controller) *MockProfilerCommandService_CommandStreamActiveThreadCountServer {
	mock := &MockProfilerCommandService_CommandStreamActiveThreadCountServer{ctrl: ctrl}
	mock.recorder = &MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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