From a949ab2edc7d6446eb33ae8fbc98a7e9297e7779 Mon Sep 17 00:00:00 2001 From: bandl <1658002533@qq.com> Date: Mon, 29 Nov 2021 23:34:14 +0800 Subject: [PATCH] chore(mock): update mock --- mock/storage/mock_client.gen.go | 175 ++++++++++++++++++++++++++++++++ 1 file changed, 175 insertions(+) diff --git a/mock/storage/mock_client.gen.go b/mock/storage/mock_client.gen.go index 32988a2..1859154 100644 --- a/mock/storage/mock_client.gen.go +++ b/mock/storage/mock_client.gen.go @@ -56,6 +56,106 @@ func (mr *MockCommServerClientMockRecorder) Add(ctx, in interface{}, opts ...int 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() @@ -954,6 +1054,81 @@ func (mr *MockCommServerServerMockRecorder) Add(arg0, arg1 interface{}) *gomock. 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()