github.com/cloudwego/kitex@v0.9.0/internal/mocks/remote/bytebuf.go

/*
 * 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/bytebuf.go

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

import (
	net "net"
	reflect "reflect"

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

// MockByteBufferFactory is a mock of ByteBufferFactory interface.
type MockByteBufferFactory struct {
	ctrl     *gomock.Controller
	recorder *MockByteBufferFactoryMockRecorder
}

// MockByteBufferFactoryMockRecorder is the mock recorder for MockByteBufferFactory.
type MockByteBufferFactoryMockRecorder struct {
	mock *MockByteBufferFactory
}

// NewMockByteBufferFactory creates a new mock instance.
func NewMockByteBufferFactory(ctrl *gomock.Controller) *MockByteBufferFactory {
	mock := &MockByteBufferFactory{ctrl: ctrl}
	mock.recorder = &MockByteBufferFactoryMockRecorder{mock}
	return mock
}

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

// NewByteBuffer mocks base method.
func (m *MockByteBufferFactory) NewByteBuffer(conn net.Conn) (remote.ByteBuffer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewByteBuffer", conn)
	ret0, _ := ret[0].(remote.ByteBuffer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewByteBuffer indicates an expected call of NewByteBuffer.
func (mr *MockByteBufferFactoryMockRecorder) NewByteBuffer(conn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewByteBuffer", reflect.TypeOf((*MockByteBufferFactory)(nil).NewByteBuffer), conn)
}

// MockNocopyWrite is a mock of NocopyWrite interface.
type MockNocopyWrite struct {
	ctrl     *gomock.Controller
	recorder *MockNocopyWriteMockRecorder
}

// MockNocopyWriteMockRecorder is the mock recorder for MockNocopyWrite.
type MockNocopyWriteMockRecorder struct {
	mock *MockNocopyWrite
}

// NewMockNocopyWrite creates a new mock instance.
func NewMockNocopyWrite(ctrl *gomock.Controller) *MockNocopyWrite {
	mock := &MockNocopyWrite{ctrl: ctrl}
	mock.recorder = &MockNocopyWriteMockRecorder{mock}
	return mock
}

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

// WriteDirect mocks base method.
func (m *MockNocopyWrite) WriteDirect(buf []byte, remainCap int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteDirect", buf, remainCap)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteDirect indicates an expected call of WriteDirect.
func (mr *MockNocopyWriteMockRecorder) WriteDirect(buf, remainCap interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteDirect", reflect.TypeOf((*MockNocopyWrite)(nil).WriteDirect), buf, remainCap)
}

// MockFrameWrite is a mock of FrameWrite interface.
type MockFrameWrite struct {
	ctrl     *gomock.Controller
	recorder *MockFrameWriteMockRecorder
}

// MockFrameWriteMockRecorder is the mock recorder for MockFrameWrite.
type MockFrameWriteMockRecorder struct {
	mock *MockFrameWrite
}

// NewMockFrameWrite creates a new mock instance.
func NewMockFrameWrite(ctrl *gomock.Controller) *MockFrameWrite {
	mock := &MockFrameWrite{ctrl: ctrl}
	mock.recorder = &MockFrameWriteMockRecorder{mock}
	return mock
}

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

// WriteData mocks base method.
func (m *MockFrameWrite) WriteData(buf []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteData", buf)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteData indicates an expected call of WriteData.
func (mr *MockFrameWriteMockRecorder) WriteData(buf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteData", reflect.TypeOf((*MockFrameWrite)(nil).WriteData), buf)
}

// WriteHeader mocks base method.
func (m *MockFrameWrite) WriteHeader(buf []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteHeader", buf)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteHeader indicates an expected call of WriteHeader.
func (mr *MockFrameWriteMockRecorder) WriteHeader(buf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteHeader", reflect.TypeOf((*MockFrameWrite)(nil).WriteHeader), buf)
}

// MockByteBuffer is a mock of ByteBuffer interface.
type MockByteBuffer struct {
	ctrl     *gomock.Controller
	recorder *MockByteBufferMockRecorder
}

// MockByteBufferMockRecorder is the mock recorder for MockByteBuffer.
type MockByteBufferMockRecorder struct {
	mock *MockByteBuffer
}

// NewMockByteBuffer creates a new mock instance.
func NewMockByteBuffer(ctrl *gomock.Controller) *MockByteBuffer {
	mock := &MockByteBuffer{ctrl: ctrl}
	mock.recorder = &MockByteBufferMockRecorder{mock}
	return mock
}

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

// AppendBuffer mocks base method.
func (m *MockByteBuffer) AppendBuffer(buf remote.ByteBuffer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppendBuffer", buf)
	ret0, _ := ret[0].(error)
	return ret0
}

// AppendBuffer indicates an expected call of AppendBuffer.
func (mr *MockByteBufferMockRecorder) AppendBuffer(buf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendBuffer", reflect.TypeOf((*MockByteBuffer)(nil).AppendBuffer), buf)
}

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

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

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

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

// Malloc mocks base method.
func (m *MockByteBuffer) Malloc(n int) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Malloc", n)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Malloc indicates an expected call of Malloc.
func (mr *MockByteBufferMockRecorder) Malloc(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Malloc", reflect.TypeOf((*MockByteBuffer)(nil).Malloc), n)
}

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

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

// NewBuffer mocks base method.
func (m *MockByteBuffer) NewBuffer() remote.ByteBuffer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewBuffer")
	ret0, _ := ret[0].(remote.ByteBuffer)
	return ret0
}

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

// Next mocks base method.
func (m *MockByteBuffer) Next(n int) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Next", n)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Next indicates an expected call of Next.
func (mr *MockByteBufferMockRecorder) Next(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockByteBuffer)(nil).Next), n)
}

// Peek mocks base method.
func (m *MockByteBuffer) Peek(n int) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Peek", n)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Peek indicates an expected call of Peek.
func (mr *MockByteBufferMockRecorder) Peek(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Peek", reflect.TypeOf((*MockByteBuffer)(nil).Peek), n)
}

// Read mocks base method.
func (m *MockByteBuffer) Read(p []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", p)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockByteBufferMockRecorder) Read(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockByteBuffer)(nil).Read), p)
}

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

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

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

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

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

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

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

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

// Release mocks base method.
func (m *MockByteBuffer) Release(e error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Release", e)
	ret0, _ := ret[0].(error)
	return ret0
}

// Release indicates an expected call of Release.
func (mr *MockByteBufferMockRecorder) Release(e interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Release", reflect.TypeOf((*MockByteBuffer)(nil).Release), e)
}

// Skip mocks base method.
func (m *MockByteBuffer) Skip(n int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Skip", n)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Write mocks base method.
func (m *MockByteBuffer) Write(p []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", p)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Write indicates an expected call of Write.
func (mr *MockByteBufferMockRecorder) Write(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockByteBuffer)(nil).Write), p)
}

// WriteBinary mocks base method.
func (m *MockByteBuffer) WriteBinary(b []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteBinary", b)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// WriteString mocks base method.
func (m *MockByteBuffer) WriteString(s string) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteString", s)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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