// Code generated by MockGen. DO NOT EDIT.
// Source: ./pkg/proto/storage.pb.go

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

import (
	context "context"
	reflect "reflect"

	proto "gitee.com/wheat-os/wheatCache/pkg/proto"
	gomock "github.com/golang/mock/gomock"
	grpc "google.golang.org/grpc"
)

// MockCommServerClient is a mock of CommServerClient interface.
type MockCommServerClient struct {
	ctrl     *gomock.Controller
	recorder *MockCommServerClientMockRecorder
}

// MockCommServerClientMockRecorder is the mock recorder for MockCommServerClient.
type MockCommServerClientMockRecorder struct {
	mock *MockCommServerClient
}

// NewMockCommServerClient creates a new mock instance.
func NewMockCommServerClient(ctrl *gomock.Controller) *MockCommServerClient {
	mock := &MockCommServerClient{ctrl: ctrl}
	mock.recorder = &MockCommServerClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockCommServerServer is a mock of CommServerServer interface.
type MockCommServerServer struct {
	ctrl     *gomock.Controller
	recorder *MockCommServerServerMockRecorder
}

// MockCommServerServerMockRecorder is the mock recorder for MockCommServerServer.
type MockCommServerServerMockRecorder struct {
	mock *MockCommServerServer
}

// NewMockCommServerServer creates a new mock instance.
func NewMockCommServerServer(ctrl *gomock.Controller) *MockCommServerServer {
	mock := &MockCommServerServer{ctrl: ctrl}
	mock.recorder = &MockCommServerServerMockRecorder{mock}
	return mock
}

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

// Add mocks base method.
func (m *MockCommServerServer) Add(arg0 context.Context, arg1 *proto.AddRequest) (*proto.AddResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Add", arg0, arg1)
	ret0, _ := ret[0].(*proto.AddResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CClean mocks base method.
func (m *MockCommServerServer) CClean(arg0 context.Context, arg1 *proto.CCleanRequest) (*proto.CCleanResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CClean", arg0, arg1)
	ret0, _ := ret[0].(*proto.CCleanResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CLen mocks base method.
func (m *MockCommServerServer) CLen(arg0 context.Context, arg1 *proto.CLenRequest) (*proto.CLenResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CLen", arg0, arg1)
	ret0, _ := ret[0].(*proto.CLenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CMake mocks base method.
func (m *MockCommServerServer) CMake(arg0 context.Context, arg1 *proto.CMakeRequest) (*proto.CMakeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CMake", arg0, arg1)
	ret0, _ := ret[0].(*proto.CMakeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CPop mocks base method.
func (m *MockCommServerServer) CPop(arg0 context.Context, arg1 *proto.CPopRequest) (*proto.CPopResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CPop", arg0, arg1)
	ret0, _ := ret[0].(*proto.CPopResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CPush mocks base method.
func (m *MockCommServerServer) CPush(arg0 context.Context, arg1 *proto.CPushRequest) (*proto.CPushResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CPush", arg0, arg1)
	ret0, _ := ret[0].(*proto.CPushResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Get mocks base method.
func (m *MockCommServerServer) Get(arg0 context.Context, arg1 *proto.GetRequest) (*proto.GetResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", arg0, arg1)
	ret0, _ := ret[0].(*proto.GetResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBit mocks base method.
func (m *MockCommServerServer) GetBit(arg0 context.Context, arg1 *proto.GetBitRequest) (*proto.GetBitResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBit", arg0, arg1)
	ret0, _ := ret[0].(*proto.GetBitResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRange mocks base method.
func (m *MockCommServerServer) GetRange(arg0 context.Context, arg1 *proto.GetRangeRequest) (*proto.GetRangeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRange", arg0, arg1)
	ret0, _ := ret[0].(*proto.GetRangeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSet mocks base method.
func (m *MockCommServerServer) GetSet(arg0 context.Context, arg1 *proto.GetSetRequest) (*proto.GetSetResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSet", arg0, arg1)
	ret0, _ := ret[0].(*proto.GetSetResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// HDel mocks base method.
func (m *MockCommServerServer) HDel(arg0 context.Context, arg1 *proto.HDelRequest) (*proto.HDelResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HDel", arg0, arg1)
	ret0, _ := ret[0].(*proto.HDelResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// HExists mocks base method.
func (m *MockCommServerServer) HExists(arg0 context.Context, arg1 *proto.HExistsRequest) (*proto.HExistsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HExists", arg0, arg1)
	ret0, _ := ret[0].(*proto.HExistsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// HGet mocks base method.
func (m *MockCommServerServer) HGet(arg0 context.Context, arg1 *proto.HGetRequest) (*proto.HGetResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HGet", arg0, arg1)
	ret0, _ := ret[0].(*proto.HGetResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// HGetAll mocks base method.
func (m *MockCommServerServer) HGetAll(arg0 context.Context, arg1 *proto.HGetAllRequest) (*proto.HGetAllResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HGetAll", arg0, arg1)
	ret0, _ := ret[0].(*proto.HGetAllResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// HIncrBy mocks base method.
func (m *MockCommServerServer) HIncrBy(arg0 context.Context, arg1 *proto.HIncrByRequest) (*proto.HIncrByResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HIncrBy", arg0, arg1)
	ret0, _ := ret[0].(*proto.HIncrByResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// HKeys mocks base method.
func (m *MockCommServerServer) HKeys(arg0 context.Context, arg1 *proto.HKeysRequest) (*proto.HKeysResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HKeys", arg0, arg1)
	ret0, _ := ret[0].(*proto.HKeysResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// HLen mocks base method.
func (m *MockCommServerServer) HLen(arg0 context.Context, arg1 *proto.HLenRequest) (*proto.HLenResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HLen", arg0, arg1)
	ret0, _ := ret[0].(*proto.HLenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// HSet mocks base method.
func (m *MockCommServerServer) HSet(arg0 context.Context, arg1 *proto.HSetRequest) (*proto.HSetResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HSet", arg0, arg1)
	ret0, _ := ret[0].(*proto.HSetResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// HSetX mocks base method.
func (m *MockCommServerServer) HSetX(arg0 context.Context, arg1 *proto.HSetXRequest) (*proto.HSetXResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HSetX", arg0, arg1)
	ret0, _ := ret[0].(*proto.HSetXResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LIndex mocks base method.
func (m *MockCommServerServer) LIndex(arg0 context.Context, arg1 *proto.LIndexRequest) (*proto.LIndexResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LIndex", arg0, arg1)
	ret0, _ := ret[0].(*proto.LIndexResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LLen mocks base method.
func (m *MockCommServerServer) LLen(arg0 context.Context, arg1 *proto.LLenRequest) (*proto.LLenResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LLen", arg0, arg1)
	ret0, _ := ret[0].(*proto.LLenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LPop mocks base method.
func (m *MockCommServerServer) LPop(arg0 context.Context, arg1 *proto.LPopRequest) (*proto.LPopResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LPop", arg0, arg1)
	ret0, _ := ret[0].(*proto.LPopResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LPush mocks base method.
func (m *MockCommServerServer) LPush(arg0 context.Context, arg1 *proto.LPushRequest) (*proto.LPushResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LPush", arg0, arg1)
	ret0, _ := ret[0].(*proto.LPushResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LPushX mocks base method.
func (m *MockCommServerServer) LPushX(arg0 context.Context, arg1 *proto.LPushXRequest) (*proto.LPushXResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LPushX", arg0, arg1)
	ret0, _ := ret[0].(*proto.LPushXResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LRange mocks base method.
func (m *MockCommServerServer) LRange(arg0 context.Context, arg1 *proto.LRangeRequest) (*proto.LRangeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LRange", arg0, arg1)
	ret0, _ := ret[0].(*proto.LRangeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LRem mocks base method.
func (m *MockCommServerServer) LRem(arg0 context.Context, arg1 *proto.LRemRequest) (*proto.LRemResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LRem", arg0, arg1)
	ret0, _ := ret[0].(*proto.LRemResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LSet mocks base method.
func (m *MockCommServerServer) LSet(arg0 context.Context, arg1 *proto.LSetRequest) (*proto.LSetResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LSet", arg0, arg1)
	ret0, _ := ret[0].(*proto.LSetResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LTrim mocks base method.
func (m *MockCommServerServer) LTrim(arg0 context.Context, arg1 *proto.LTrimRequest) (*proto.LTrimResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LTrim", arg0, arg1)
	ret0, _ := ret[0].(*proto.LTrimResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RPop mocks base method.
func (m *MockCommServerServer) RPop(arg0 context.Context, arg1 *proto.RPopRequest) (*proto.RPopResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RPop", arg0, arg1)
	ret0, _ := ret[0].(*proto.RPopResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RPush mocks base method.
func (m *MockCommServerServer) RPush(arg0 context.Context, arg1 *proto.RPushRequest) (*proto.RPushResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RPush", arg0, arg1)
	ret0, _ := ret[0].(*proto.RPushResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RPushX mocks base method.
func (m *MockCommServerServer) RPushX(arg0 context.Context, arg1 *proto.RPushXRequest) (*proto.RPushXResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RPushX", arg0, arg1)
	ret0, _ := ret[0].(*proto.RPushXResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Reduce mocks base method.
func (m *MockCommServerServer) Reduce(arg0 context.Context, arg1 *proto.ReduceRequest) (*proto.ReduceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reduce", arg0, arg1)
	ret0, _ := ret[0].(*proto.ReduceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SAdd mocks base method.
func (m *MockCommServerServer) SAdd(arg0 context.Context, arg1 *proto.SAddRequest) (*proto.SAddResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SAdd", arg0, arg1)
	ret0, _ := ret[0].(*proto.SAddResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SCard mocks base method.
func (m *MockCommServerServer) SCard(arg0 context.Context, arg1 *proto.SCardRequest) (*proto.SCardResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SCard", arg0, arg1)
	ret0, _ := ret[0].(*proto.SCardResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SDiff mocks base method.
func (m *MockCommServerServer) SDiff(arg0 context.Context, arg1 *proto.SDiffRequest) (*proto.SDiffResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SDiff", arg0, arg1)
	ret0, _ := ret[0].(*proto.SDiffResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SDiffStore mocks base method.
func (m *MockCommServerServer) SDiffStore(arg0 context.Context, arg1 *proto.SDiffStoreRequest) (*proto.SDiffStoreResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SDiffStore", arg0, arg1)
	ret0, _ := ret[0].(*proto.SDiffStoreResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SInter mocks base method.
func (m *MockCommServerServer) SInter(arg0 context.Context, arg1 *proto.SInterRequest) (*proto.SInterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SInter", arg0, arg1)
	ret0, _ := ret[0].(*proto.SInterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SInterStore mocks base method.
func (m *MockCommServerServer) SInterStore(arg0 context.Context, arg1 *proto.SInterStoreRequest) (*proto.SInterStoreResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SInterStore", arg0, arg1)
	ret0, _ := ret[0].(*proto.SInterStoreResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SIsMember mocks base method.
func (m *MockCommServerServer) SIsMember(arg0 context.Context, arg1 *proto.SIsMemberRequest) (*proto.SIsMemberResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SIsMember", arg0, arg1)
	ret0, _ := ret[0].(*proto.SIsMemberResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SMove mocks base method.
func (m *MockCommServerServer) SMove(arg0 context.Context, arg1 *proto.SMoveRequest) (*proto.SMoveResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SMove", arg0, arg1)
	ret0, _ := ret[0].(*proto.SMoveResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SPop mocks base method.
func (m *MockCommServerServer) SPop(arg0 context.Context, arg1 *proto.SPopRequest) (*proto.SPopResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SPop", arg0, arg1)
	ret0, _ := ret[0].(*proto.SPopResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SRem mocks base method.
func (m *MockCommServerServer) SRem(arg0 context.Context, arg1 *proto.SRemRequest) (*proto.SRemResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SRem", arg0, arg1)
	ret0, _ := ret[0].(*proto.SRemResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SScan mocks base method.
func (m *MockCommServerServer) SScan(arg0 context.Context, arg1 *proto.SScanRequest) (*proto.SScanResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SScan", arg0, arg1)
	ret0, _ := ret[0].(*proto.SScanResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SUnion mocks base method.
func (m *MockCommServerServer) SUnion(arg0 context.Context, arg1 *proto.SUnionRequest) (*proto.SUnionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SUnion", arg0, arg1)
	ret0, _ := ret[0].(*proto.SUnionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SUnionStore mocks base method.
func (m *MockCommServerServer) SUnionStore(arg0 context.Context, arg1 *proto.SUnionStoreRequest) (*proto.SUnionStoreResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SUnionStore", arg0, arg1)
	ret0, _ := ret[0].(*proto.SUnionStoreResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Set mocks base method.
func (m *MockCommServerServer) Set(arg0 context.Context, arg1 *proto.SetRequest) (*proto.SetResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", arg0, arg1)
	ret0, _ := ret[0].(*proto.SetResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetBit mocks base method.
func (m *MockCommServerServer) SetBit(arg0 context.Context, arg1 *proto.SetBitRequest) (*proto.SetBitResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetBit", arg0, arg1)
	ret0, _ := ret[0].(*proto.SetBitResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Setnx mocks base method.
func (m *MockCommServerServer) Setnx(arg0 context.Context, arg1 *proto.SetnxRequest) (*proto.SetnxResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Setnx", arg0, arg1)
	ret0, _ := ret[0].(*proto.SetnxResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StrLen mocks base method.
func (m *MockCommServerServer) StrLen(arg0 context.Context, arg1 *proto.StrLenRequest) (*proto.StrLenResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StrLen", arg0, arg1)
	ret0, _ := ret[0].(*proto.StrLenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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