lib/go/test/tests/protocol_mock.go

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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.
 */

// Automatically generated by MockGen. DO NOT EDIT!
// Source: thrift (interfaces: TProtocol)

package tests

import (
	"context"
	thrift "thrift"

	gomock "github.com/golang/mock/gomock"
)

// Mock of TProtocol interface
type MockTProtocol struct {
	ctrl     *gomock.Controller
	recorder *_MockTProtocolRecorder
}

// Recorder for MockTProtocol (not exported)
type _MockTProtocolRecorder struct {
	mock *MockTProtocol
}

func NewMockTProtocol(ctrl *gomock.Controller) *MockTProtocol {
	mock := &MockTProtocol{ctrl: ctrl}
	mock.recorder = &_MockTProtocolRecorder{mock}
	return mock
}

func (_m *MockTProtocol) EXPECT() *_MockTProtocolRecorder {
	return _m.recorder
}

func (_m *MockTProtocol) Flush(ctx context.Context) error {
	ret := _m.ctrl.Call(_m, "Flush")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) Flush(ctx context.Context) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Flush")
}

func (_m *MockTProtocol) ReadBinary() ([]byte, error) {
	ret := _m.ctrl.Call(_m, "ReadBinary")
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTProtocolRecorder) ReadBinary() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadBinary")
}

func (_m *MockTProtocol) ReadBool() (bool, error) {
	ret := _m.ctrl.Call(_m, "ReadBool")
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTProtocolRecorder) ReadBool() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadBool")
}

func (_m *MockTProtocol) ReadByte() (int8, error) {
	ret := _m.ctrl.Call(_m, "ReadByte")
	ret0, _ := ret[0].(int8)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTProtocolRecorder) ReadByte() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadByte")
}

func (_m *MockTProtocol) ReadDouble() (float64, error) {
	ret := _m.ctrl.Call(_m, "ReadDouble")
	ret0, _ := ret[0].(float64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTProtocolRecorder) ReadDouble() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadDouble")
}

func (_m *MockTProtocol) ReadFieldBegin() (string, thrift.TType, int16, error) {
	ret := _m.ctrl.Call(_m, "ReadFieldBegin")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(thrift.TType)
	ret2, _ := ret[2].(int16)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

func (_mr *_MockTProtocolRecorder) ReadFieldBegin() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadFieldBegin")
}

func (_m *MockTProtocol) ReadFieldEnd() error {
	ret := _m.ctrl.Call(_m, "ReadFieldEnd")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) ReadFieldEnd() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadFieldEnd")
}

func (_m *MockTProtocol) ReadI16() (int16, error) {
	ret := _m.ctrl.Call(_m, "ReadI16")
	ret0, _ := ret[0].(int16)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTProtocolRecorder) ReadI16() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadI16")
}

func (_m *MockTProtocol) ReadI32() (int32, error) {
	ret := _m.ctrl.Call(_m, "ReadI32")
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTProtocolRecorder) ReadI32() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadI32")
}

func (_m *MockTProtocol) ReadI64() (int64, error) {
	ret := _m.ctrl.Call(_m, "ReadI64")
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTProtocolRecorder) ReadI64() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadI64")
}

func (_m *MockTProtocol) ReadListBegin() (thrift.TType, int, error) {
	ret := _m.ctrl.Call(_m, "ReadListBegin")
	ret0, _ := ret[0].(thrift.TType)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

func (_mr *_MockTProtocolRecorder) ReadListBegin() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadListBegin")
}

func (_m *MockTProtocol) ReadListEnd() error {
	ret := _m.ctrl.Call(_m, "ReadListEnd")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) ReadListEnd() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadListEnd")
}

func (_m *MockTProtocol) ReadMapBegin() (thrift.TType, thrift.TType, int, error) {
	ret := _m.ctrl.Call(_m, "ReadMapBegin")
	ret0, _ := ret[0].(thrift.TType)
	ret1, _ := ret[1].(thrift.TType)
	ret2, _ := ret[2].(int)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

func (_mr *_MockTProtocolRecorder) ReadMapBegin() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadMapBegin")
}

func (_m *MockTProtocol) ReadMapEnd() error {
	ret := _m.ctrl.Call(_m, "ReadMapEnd")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) ReadMapEnd() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadMapEnd")
}

func (_m *MockTProtocol) ReadMessageBegin() (string, thrift.TMessageType, int32, error) {
	ret := _m.ctrl.Call(_m, "ReadMessageBegin")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(thrift.TMessageType)
	ret2, _ := ret[2].(int32)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

func (_mr *_MockTProtocolRecorder) ReadMessageBegin() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadMessageBegin")
}

func (_m *MockTProtocol) ReadMessageEnd() error {
	ret := _m.ctrl.Call(_m, "ReadMessageEnd")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) ReadMessageEnd() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadMessageEnd")
}

func (_m *MockTProtocol) ReadSetBegin() (thrift.TType, int, error) {
	ret := _m.ctrl.Call(_m, "ReadSetBegin")
	ret0, _ := ret[0].(thrift.TType)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

func (_mr *_MockTProtocolRecorder) ReadSetBegin() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadSetBegin")
}

func (_m *MockTProtocol) ReadSetEnd() error {
	ret := _m.ctrl.Call(_m, "ReadSetEnd")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) ReadSetEnd() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadSetEnd")
}

func (_m *MockTProtocol) ReadString() (string, error) {
	ret := _m.ctrl.Call(_m, "ReadString")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTProtocolRecorder) ReadString() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadString")
}

func (_m *MockTProtocol) ReadStructBegin() (string, error) {
	ret := _m.ctrl.Call(_m, "ReadStructBegin")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTProtocolRecorder) ReadStructBegin() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadStructBegin")
}

func (_m *MockTProtocol) ReadStructEnd() error {
	ret := _m.ctrl.Call(_m, "ReadStructEnd")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) ReadStructEnd() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadStructEnd")
}

func (_m *MockTProtocol) Skip(_param0 thrift.TType) error {
	ret := _m.ctrl.Call(_m, "Skip", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) Skip(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Skip", arg0)
}

func (_m *MockTProtocol) Transport() thrift.TTransport {
	ret := _m.ctrl.Call(_m, "Transport")
	ret0, _ := ret[0].(thrift.TTransport)
	return ret0
}

func (_mr *_MockTProtocolRecorder) Transport() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Transport")
}

func (_m *MockTProtocol) WriteBinary(_param0 []byte) error {
	ret := _m.ctrl.Call(_m, "WriteBinary", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteBinary(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteBinary", arg0)
}

func (_m *MockTProtocol) WriteBool(_param0 bool) error {
	ret := _m.ctrl.Call(_m, "WriteBool", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteBool(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteBool", arg0)
}

func (_m *MockTProtocol) WriteByte(_param0 int8) error {
	ret := _m.ctrl.Call(_m, "WriteByte", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteByte(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteByte", arg0)
}

func (_m *MockTProtocol) WriteDouble(_param0 float64) error {
	ret := _m.ctrl.Call(_m, "WriteDouble", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteDouble(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteDouble", arg0)
}

func (_m *MockTProtocol) WriteFieldBegin(_param0 string, _param1 thrift.TType, _param2 int16) error {
	ret := _m.ctrl.Call(_m, "WriteFieldBegin", _param0, _param1, _param2)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteFieldBegin(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteFieldBegin", arg0, arg1, arg2)
}

func (_m *MockTProtocol) WriteFieldEnd() error {
	ret := _m.ctrl.Call(_m, "WriteFieldEnd")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteFieldEnd() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteFieldEnd")
}

func (_m *MockTProtocol) WriteFieldStop() error {
	ret := _m.ctrl.Call(_m, "WriteFieldStop")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteFieldStop() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteFieldStop")
}

func (_m *MockTProtocol) WriteI16(_param0 int16) error {
	ret := _m.ctrl.Call(_m, "WriteI16", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteI16(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteI16", arg0)
}

func (_m *MockTProtocol) WriteI32(_param0 int32) error {
	ret := _m.ctrl.Call(_m, "WriteI32", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteI32(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteI32", arg0)
}

func (_m *MockTProtocol) WriteI64(_param0 int64) error {
	ret := _m.ctrl.Call(_m, "WriteI64", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteI64(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteI64", arg0)
}

func (_m *MockTProtocol) WriteListBegin(_param0 thrift.TType, _param1 int) error {
	ret := _m.ctrl.Call(_m, "WriteListBegin", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteListBegin(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteListBegin", arg0, arg1)
}

func (_m *MockTProtocol) WriteListEnd() error {
	ret := _m.ctrl.Call(_m, "WriteListEnd")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteListEnd() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteListEnd")
}

func (_m *MockTProtocol) WriteMapBegin(_param0 thrift.TType, _param1 thrift.TType, _param2 int) error {
	ret := _m.ctrl.Call(_m, "WriteMapBegin", _param0, _param1, _param2)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteMapBegin(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMapBegin", arg0, arg1, arg2)
}

func (_m *MockTProtocol) WriteMapEnd() error {
	ret := _m.ctrl.Call(_m, "WriteMapEnd")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteMapEnd() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMapEnd")
}

func (_m *MockTProtocol) WriteMessageBegin(_param0 string, _param1 thrift.TMessageType, _param2 int32) error {
	ret := _m.ctrl.Call(_m, "WriteMessageBegin", _param0, _param1, _param2)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteMessageBegin(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMessageBegin", arg0, arg1, arg2)
}

func (_m *MockTProtocol) WriteMessageEnd() error {
	ret := _m.ctrl.Call(_m, "WriteMessageEnd")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteMessageEnd() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMessageEnd")
}

func (_m *MockTProtocol) WriteSetBegin(_param0 thrift.TType, _param1 int) error {
	ret := _m.ctrl.Call(_m, "WriteSetBegin", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteSetBegin(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteSetBegin", arg0, arg1)
}

func (_m *MockTProtocol) WriteSetEnd() error {
	ret := _m.ctrl.Call(_m, "WriteSetEnd")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteSetEnd() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteSetEnd")
}

func (_m *MockTProtocol) WriteString(_param0 string) error {
	ret := _m.ctrl.Call(_m, "WriteString", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteString(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteString", arg0)
}

func (_m *MockTProtocol) WriteStructBegin(_param0 string) error {
	ret := _m.ctrl.Call(_m, "WriteStructBegin", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteStructBegin(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteStructBegin", arg0)
}

func (_m *MockTProtocol) WriteStructEnd() error {
	ret := _m.ctrl.Call(_m, "WriteStructEnd")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTProtocolRecorder) WriteStructEnd() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteStructEnd")
}