ext.go

// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/test/testdata/plugins/ext/ext_grpc.pb.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	ext "github.com/rancher/opni/pkg/test/testdata/plugins/ext"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// MockExtClient is a mock of ExtClient interface.
type MockExtClient struct {
	ctrl     *gomock.Controller
	recorder *MockExtClientMockRecorder
}

// MockExtClientMockRecorder is the mock recorder for MockExtClient.
type MockExtClientMockRecorder struct {
	mock *MockExtClient
}

// NewMockExtClient creates a new mock instance.
func NewMockExtClient(ctrl *gomock.Controller) *MockExtClient {
	mock := &MockExtClient{ctrl: ctrl}
	mock.recorder = &MockExtClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockExt_ServerStreamClient is a mock of Ext_ServerStreamClient interface.
type MockExt_ServerStreamClient struct {
	ctrl     *gomock.Controller
	recorder *MockExt_ServerStreamClientMockRecorder
}

// MockExt_ServerStreamClientMockRecorder is the mock recorder for MockExt_ServerStreamClient.
type MockExt_ServerStreamClientMockRecorder struct {
	mock *MockExt_ServerStreamClient
}

// NewMockExt_ServerStreamClient creates a new mock instance.
func NewMockExt_ServerStreamClient(ctrl *gomock.Controller) *MockExt_ServerStreamClient {
	mock := &MockExt_ServerStreamClient{ctrl: ctrl}
	mock.recorder = &MockExt_ServerStreamClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// MockExt_ClientStreamClient is a mock of Ext_ClientStreamClient interface.
type MockExt_ClientStreamClient struct {
	ctrl     *gomock.Controller
	recorder *MockExt_ClientStreamClientMockRecorder
}

// MockExt_ClientStreamClientMockRecorder is the mock recorder for MockExt_ClientStreamClient.
type MockExt_ClientStreamClientMockRecorder struct {
	mock *MockExt_ClientStreamClient
}

// NewMockExt_ClientStreamClient creates a new mock instance.
func NewMockExt_ClientStreamClient(ctrl *gomock.Controller) *MockExt_ClientStreamClient {
	mock := &MockExt_ClientStreamClient{ctrl: ctrl}
	mock.recorder = &MockExt_ClientStreamClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

// MockExtServer is a mock of ExtServer interface.
type MockExtServer struct {
	ctrl     *gomock.Controller
	recorder *MockExtServerMockRecorder
}

// MockExtServerMockRecorder is the mock recorder for MockExtServer.
type MockExtServerMockRecorder struct {
	mock *MockExtServer
}

// NewMockExtServer creates a new mock instance.
func NewMockExtServer(ctrl *gomock.Controller) *MockExtServer {
	mock := &MockExtServer{ctrl: ctrl}
	mock.recorder = &MockExtServerMockRecorder{mock}
	return mock
}

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

// Bar mocks base method.
func (m *MockExtServer) Bar(arg0 context.Context, arg1 *ext.BarRequest) (*ext.BarResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Bar", arg0, arg1)
	ret0, _ := ret[0].(*ext.BarResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// Foo mocks base method.
func (m *MockExtServer) Foo(arg0 context.Context, arg1 *ext.FooRequest) (*ext.FooResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Foo", arg0, arg1)
	ret0, _ := ret[0].(*ext.FooResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ServerStream mocks base method.
func (m *MockExtServer) ServerStream(arg0 *ext.FooRequest, arg1 ext.Ext_ServerStreamServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ServerStream", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// MockUnsafeExtServer is a mock of UnsafeExtServer interface.
type MockUnsafeExtServer struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeExtServerMockRecorder
}

// MockUnsafeExtServerMockRecorder is the mock recorder for MockUnsafeExtServer.
type MockUnsafeExtServerMockRecorder struct {
	mock *MockUnsafeExtServer
}

// NewMockUnsafeExtServer creates a new mock instance.
func NewMockUnsafeExtServer(ctrl *gomock.Controller) *MockUnsafeExtServer {
	mock := &MockUnsafeExtServer{ctrl: ctrl}
	mock.recorder = &MockUnsafeExtServerMockRecorder{mock}
	return mock
}

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

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

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

// MockExt_ServerStreamServer is a mock of Ext_ServerStreamServer interface.
type MockExt_ServerStreamServer struct {
	ctrl     *gomock.Controller
	recorder *MockExt_ServerStreamServerMockRecorder
}

// MockExt_ServerStreamServerMockRecorder is the mock recorder for MockExt_ServerStreamServer.
type MockExt_ServerStreamServerMockRecorder struct {
	mock *MockExt_ServerStreamServer
}

// NewMockExt_ServerStreamServer creates a new mock instance.
func NewMockExt_ServerStreamServer(ctrl *gomock.Controller) *MockExt_ServerStreamServer {
	mock := &MockExt_ServerStreamServer{ctrl: ctrl}
	mock.recorder = &MockExt_ServerStreamServerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// MockExt_ClientStreamServer is a mock of Ext_ClientStreamServer interface.
type MockExt_ClientStreamServer struct {
	ctrl     *gomock.Controller
	recorder *MockExt_ClientStreamServerMockRecorder
}

// MockExt_ClientStreamServerMockRecorder is the mock recorder for MockExt_ClientStreamServer.
type MockExt_ClientStreamServerMockRecorder struct {
	mock *MockExt_ClientStreamServer
}

// NewMockExt_ClientStreamServer creates a new mock instance.
func NewMockExt_ClientStreamServer(ctrl *gomock.Controller) *MockExt_ClientStreamServer {
	mock := &MockExt_ClientStreamServer{ctrl: ctrl}
	mock.recorder = &MockExt_ClientStreamServerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockExt2Client is a mock of Ext2Client interface.
type MockExt2Client struct {
	ctrl     *gomock.Controller
	recorder *MockExt2ClientMockRecorder
}

// MockExt2ClientMockRecorder is the mock recorder for MockExt2Client.
type MockExt2ClientMockRecorder struct {
	mock *MockExt2Client
}

// NewMockExt2Client creates a new mock instance.
func NewMockExt2Client(ctrl *gomock.Controller) *MockExt2Client {
	mock := &MockExt2Client{ctrl: ctrl}
	mock.recorder = &MockExt2ClientMockRecorder{mock}
	return mock
}

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

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

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

// MockExt2Server is a mock of Ext2Server interface.
type MockExt2Server struct {
	ctrl     *gomock.Controller
	recorder *MockExt2ServerMockRecorder
}

// MockExt2ServerMockRecorder is the mock recorder for MockExt2Server.
type MockExt2ServerMockRecorder struct {
	mock *MockExt2Server
}

// NewMockExt2Server creates a new mock instance.
func NewMockExt2Server(ctrl *gomock.Controller) *MockExt2Server {
	mock := &MockExt2Server{ctrl: ctrl}
	mock.recorder = &MockExt2ServerMockRecorder{mock}
	return mock
}

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

// Foo mocks base method.
func (m *MockExt2Server) Foo(arg0 context.Context, arg1 *ext.FooRequest) (*ext.FooResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Foo", arg0, arg1)
	ret0, _ := ret[0].(*ext.FooResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockUnsafeExt2Server is a mock of UnsafeExt2Server interface.
type MockUnsafeExt2Server struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeExt2ServerMockRecorder
}

// MockUnsafeExt2ServerMockRecorder is the mock recorder for MockUnsafeExt2Server.
type MockUnsafeExt2ServerMockRecorder struct {
	mock *MockUnsafeExt2Server
}

// NewMockUnsafeExt2Server creates a new mock instance.
func NewMockUnsafeExt2Server(ctrl *gomock.Controller) *MockUnsafeExt2Server {
	mock := &MockUnsafeExt2Server{ctrl: ctrl}
	mock.recorder = &MockUnsafeExt2ServerMockRecorder{mock}
	return mock
}

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

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

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