/*
 * Copyright 2022 CloudWeGo Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
*/


// Code generated by MockGen. DO NOT EDIT.
// Source: ../../pkg/remote/codec.go

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

import (
	context "context"
	reflect "reflect"

	remote "github.com/cloudwego/kitex/pkg/remote"
	gomock "github.com/golang/mock/gomock"
)

// MockCodec is a mock of Codec interface.
type MockCodec struct {
	ctrl     *gomock.Controller
	recorder *MockCodecMockRecorder
}

// MockCodecMockRecorder is the mock recorder for MockCodec.
type MockCodecMockRecorder struct {
	mock *MockCodec
}

// NewMockCodec creates a new mock instance.
func NewMockCodec(ctrl *gomock.Controller) *MockCodec {
	mock := &MockCodec{ctrl: ctrl}
	mock.recorder = &MockCodecMockRecorder{mock}
	return mock
}

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

// Decode mocks base method.
func (m *MockCodec) Decode(ctx context.Context, msg remote.Message, in remote.ByteBuffer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Decode", ctx, msg, in)
	ret0, _ := ret[0].(error)
	return ret0
}

// Decode indicates an expected call of Decode.
func (mr *MockCodecMockRecorder) Decode(ctx, msg, in interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decode", reflect.TypeOf((*MockCodec)(nil).Decode), ctx, msg, in)
}

// Encode mocks base method.
func (m *MockCodec) Encode(ctx context.Context, msg remote.Message, out remote.ByteBuffer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Encode", ctx, msg, out)
	ret0, _ := ret[0].(error)
	return ret0
}

// Encode indicates an expected call of Encode.
func (mr *MockCodecMockRecorder) Encode(ctx, msg, out interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Encode", reflect.TypeOf((*MockCodec)(nil).Encode), ctx, msg, out)
}

// Name mocks base method.
func (m *MockCodec) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

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

// MockMetaEncoder is a mock of MetaEncoder interface.
type MockMetaEncoder struct {
	ctrl     *gomock.Controller
	recorder *MockMetaEncoderMockRecorder
}

// MockMetaEncoderMockRecorder is the mock recorder for MockMetaEncoder.
type MockMetaEncoderMockRecorder struct {
	mock *MockMetaEncoder
}

// NewMockMetaEncoder creates a new mock instance.
func NewMockMetaEncoder(ctrl *gomock.Controller) *MockMetaEncoder {
	mock := &MockMetaEncoder{ctrl: ctrl}
	mock.recorder = &MockMetaEncoderMockRecorder{mock}
	return mock
}

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

// EncodeMetaAndPayload mocks base method.
func (m *MockMetaEncoder) EncodeMetaAndPayload(ctx context.Context, msg remote.Message, out remote.ByteBuffer, me remote.MetaEncoder) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EncodeMetaAndPayload", ctx, msg, out, me)
	ret0, _ := ret[0].(error)
	return ret0
}

// EncodeMetaAndPayload indicates an expected call of EncodeMetaAndPayload.
func (mr *MockMetaEncoderMockRecorder) EncodeMetaAndPayload(ctx, msg, out, me interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncodeMetaAndPayload", reflect.TypeOf((*MockMetaEncoder)(nil).EncodeMetaAndPayload), ctx, msg, out, me)
}

// EncodePayload mocks base method.
func (m *MockMetaEncoder) EncodePayload(ctx context.Context, msg remote.Message, out remote.ByteBuffer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EncodePayload", ctx, msg, out)
	ret0, _ := ret[0].(error)
	return ret0
}

// EncodePayload indicates an expected call of EncodePayload.
func (mr *MockMetaEncoderMockRecorder) EncodePayload(ctx, msg, out interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncodePayload", reflect.TypeOf((*MockMetaEncoder)(nil).EncodePayload), ctx, msg, out)
}

// MockMetaDecoder is a mock of MetaDecoder interface.
type MockMetaDecoder struct {
	ctrl     *gomock.Controller
	recorder *MockMetaDecoderMockRecorder
}

// MockMetaDecoderMockRecorder is the mock recorder for MockMetaDecoder.
type MockMetaDecoderMockRecorder struct {
	mock *MockMetaDecoder
}

// NewMockMetaDecoder creates a new mock instance.
func NewMockMetaDecoder(ctrl *gomock.Controller) *MockMetaDecoder {
	mock := &MockMetaDecoder{ctrl: ctrl}
	mock.recorder = &MockMetaDecoderMockRecorder{mock}
	return mock
}

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

// DecodeMeta mocks base method.
func (m *MockMetaDecoder) DecodeMeta(ctx context.Context, msg remote.Message, in remote.ByteBuffer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecodeMeta", ctx, msg, in)
	ret0, _ := ret[0].(error)
	return ret0
}

// DecodeMeta indicates an expected call of DecodeMeta.
func (mr *MockMetaDecoderMockRecorder) DecodeMeta(ctx, msg, in interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeMeta", reflect.TypeOf((*MockMetaDecoder)(nil).DecodeMeta), ctx, msg, in)
}

// DecodePayload mocks base method.
func (m *MockMetaDecoder) DecodePayload(ctx context.Context, msg remote.Message, in remote.ByteBuffer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecodePayload", ctx, msg, in)
	ret0, _ := ret[0].(error)
	return ret0
}

// DecodePayload indicates an expected call of DecodePayload.
func (mr *MockMetaDecoderMockRecorder) DecodePayload(ctx, msg, in interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodePayload", reflect.TypeOf((*MockMetaDecoder)(nil).DecodePayload), ctx, msg, in)
}
