lib/go/test/tests/protocol_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/apache/thrift/lib/go/thrift (interfaces: TProtocol)

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

import (
	context "context"
	reflect "reflect"

	thrift "github.com/apache/thrift/lib/go/thrift"
	gomock "github.com/golang/mock/gomock"
)

// MockTProtocol is a mock of TProtocol interface.
type MockTProtocol struct {
	ctrl     *gomock.Controller
	recorder *MockTProtocolMockRecorder
}

// MockTProtocolMockRecorder is the mock recorder for MockTProtocol.
type MockTProtocolMockRecorder struct {
	mock *MockTProtocol
}

// NewMockTProtocol creates a new mock instance.
func NewMockTProtocol(ctrl *gomock.Controller) *MockTProtocol {
	mock := &MockTProtocol{ctrl: ctrl}
	mock.recorder = &MockTProtocolMockRecorder{mock}
	return mock
}

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

// Flush mocks base method.
func (m *MockTProtocol) Flush(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Flush", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ReadBinary mocks base method.
func (m *MockTProtocol) ReadBinary(arg0 context.Context) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadBinary", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReadBool mocks base method.
func (m *MockTProtocol) ReadBool(arg0 context.Context) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadBool", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReadByte mocks base method.
func (m *MockTProtocol) ReadByte(arg0 context.Context) (int8, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadByte", arg0)
	ret0, _ := ret[0].(int8)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReadDouble mocks base method.
func (m *MockTProtocol) ReadDouble(arg0 context.Context) (float64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadDouble", arg0)
	ret0, _ := ret[0].(float64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReadFieldBegin mocks base method.
func (m *MockTProtocol) ReadFieldBegin(arg0 context.Context) (string, thrift.TType, int16, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadFieldBegin", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(thrift.TType)
	ret2, _ := ret[2].(int16)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

// ReadFieldEnd mocks base method.
func (m *MockTProtocol) ReadFieldEnd(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadFieldEnd", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ReadI16 mocks base method.
func (m *MockTProtocol) ReadI16(arg0 context.Context) (int16, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadI16", arg0)
	ret0, _ := ret[0].(int16)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReadI32 mocks base method.
func (m *MockTProtocol) ReadI32(arg0 context.Context) (int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadI32", arg0)
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReadI64 mocks base method.
func (m *MockTProtocol) ReadI64(arg0 context.Context) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadI64", arg0)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReadListBegin mocks base method.
func (m *MockTProtocol) ReadListBegin(arg0 context.Context) (thrift.TType, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadListBegin", arg0)
	ret0, _ := ret[0].(thrift.TType)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// ReadListEnd mocks base method.
func (m *MockTProtocol) ReadListEnd(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadListEnd", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ReadMapBegin mocks base method.
func (m *MockTProtocol) ReadMapBegin(arg0 context.Context) (thrift.TType, thrift.TType, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadMapBegin", arg0)
	ret0, _ := ret[0].(thrift.TType)
	ret1, _ := ret[1].(thrift.TType)
	ret2, _ := ret[2].(int)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

// ReadMapEnd mocks base method.
func (m *MockTProtocol) ReadMapEnd(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadMapEnd", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ReadMessageBegin mocks base method.
func (m *MockTProtocol) ReadMessageBegin(arg0 context.Context) (string, thrift.TMessageType, int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadMessageBegin", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(thrift.TMessageType)
	ret2, _ := ret[2].(int32)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

// ReadMessageEnd mocks base method.
func (m *MockTProtocol) ReadMessageEnd(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadMessageEnd", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ReadSetBegin mocks base method.
func (m *MockTProtocol) ReadSetBegin(arg0 context.Context) (thrift.TType, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadSetBegin", arg0)
	ret0, _ := ret[0].(thrift.TType)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// ReadSetEnd mocks base method.
func (m *MockTProtocol) ReadSetEnd(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadSetEnd", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ReadString mocks base method.
func (m *MockTProtocol) ReadString(arg0 context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadString", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReadStructBegin mocks base method.
func (m *MockTProtocol) ReadStructBegin(arg0 context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadStructBegin", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReadStructEnd mocks base method.
func (m *MockTProtocol) ReadStructEnd(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadStructEnd", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ReadUUID mocks base method.
func (m *MockTProtocol) ReadUUID(arg0 context.Context) (thrift.Tuuid, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadUUID", arg0)
	ret0, _ := ret[0].(thrift.Tuuid)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Skip mocks base method.
func (m *MockTProtocol) Skip(arg0 context.Context, arg1 thrift.TType) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Skip", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Transport mocks base method.
func (m *MockTProtocol) Transport() thrift.TTransport {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Transport")
	ret0, _ := ret[0].(thrift.TTransport)
	return ret0
}

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

// WriteBinary mocks base method.
func (m *MockTProtocol) WriteBinary(arg0 context.Context, arg1 []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteBinary", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteBool mocks base method.
func (m *MockTProtocol) WriteBool(arg0 context.Context, arg1 bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteBool", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteByte mocks base method.
func (m *MockTProtocol) WriteByte(arg0 context.Context, arg1 int8) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteByte", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteDouble mocks base method.
func (m *MockTProtocol) WriteDouble(arg0 context.Context, arg1 float64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteDouble", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteFieldBegin mocks base method.
func (m *MockTProtocol) WriteFieldBegin(arg0 context.Context, arg1 string, arg2 thrift.TType, arg3 int16) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteFieldBegin", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteFieldBegin indicates an expected call of WriteFieldBegin.
func (mr *MockTProtocolMockRecorder) WriteFieldBegin(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteFieldBegin", reflect.TypeOf((*MockTProtocol)(nil).WriteFieldBegin), arg0, arg1, arg2, arg3)
}

// WriteFieldEnd mocks base method.
func (m *MockTProtocol) WriteFieldEnd(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteFieldEnd", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteFieldStop mocks base method.
func (m *MockTProtocol) WriteFieldStop(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteFieldStop", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteI16 mocks base method.
func (m *MockTProtocol) WriteI16(arg0 context.Context, arg1 int16) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteI16", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteI32 mocks base method.
func (m *MockTProtocol) WriteI32(arg0 context.Context, arg1 int32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteI32", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteI64 mocks base method.
func (m *MockTProtocol) WriteI64(arg0 context.Context, arg1 int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteI64", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteListBegin mocks base method.
func (m *MockTProtocol) WriteListBegin(arg0 context.Context, arg1 thrift.TType, arg2 int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteListBegin", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteListEnd mocks base method.
func (m *MockTProtocol) WriteListEnd(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteListEnd", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteMapBegin mocks base method.
func (m *MockTProtocol) WriteMapBegin(arg0 context.Context, arg1, arg2 thrift.TType, arg3 int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteMapBegin", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteMapBegin indicates an expected call of WriteMapBegin.
func (mr *MockTProtocolMockRecorder) WriteMapBegin(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteMapBegin", reflect.TypeOf((*MockTProtocol)(nil).WriteMapBegin), arg0, arg1, arg2, arg3)
}

// WriteMapEnd mocks base method.
func (m *MockTProtocol) WriteMapEnd(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteMapEnd", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteMessageBegin mocks base method.
func (m *MockTProtocol) WriteMessageBegin(arg0 context.Context, arg1 string, arg2 thrift.TMessageType, arg3 int32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteMessageBegin", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteMessageBegin indicates an expected call of WriteMessageBegin.
func (mr *MockTProtocolMockRecorder) WriteMessageBegin(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteMessageBegin", reflect.TypeOf((*MockTProtocol)(nil).WriteMessageBegin), arg0, arg1, arg2, arg3)
}

// WriteMessageEnd mocks base method.
func (m *MockTProtocol) WriteMessageEnd(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteMessageEnd", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteSetBegin mocks base method.
func (m *MockTProtocol) WriteSetBegin(arg0 context.Context, arg1 thrift.TType, arg2 int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteSetBegin", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteSetEnd mocks base method.
func (m *MockTProtocol) WriteSetEnd(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteSetEnd", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteString mocks base method.
func (m *MockTProtocol) WriteString(arg0 context.Context, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteString", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteStructBegin mocks base method.
func (m *MockTProtocol) WriteStructBegin(arg0 context.Context, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteStructBegin", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteStructEnd mocks base method.
func (m *MockTProtocol) WriteStructEnd(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteStructEnd", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteUUID mocks base method.
func (m *MockTProtocol) WriteUUID(arg0 context.Context, arg1 thrift.Tuuid) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteUUID", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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