/*
 * Copyright 2021 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: /Users/bytedance/go/pkg/mod/github.com/cloudwego/netpoll@v0.2.6/nocopy.go

// Package mocks is a generated GoMock package.
package netpoll

import (
	reflect "reflect"

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

// MockReader is a mock of Reader interface.
type MockReader struct {
	ctrl     *gomock.Controller
	recorder *MockReaderMockRecorder
}

// MockReaderMockRecorder is the mock recorder for MockReader.
type MockReaderMockRecorder struct {
	mock *MockReader
}

// NewMockReader creates a new mock instance.
func NewMockReader(ctrl *gomock.Controller) *MockReader {
	mock := &MockReader{ctrl: ctrl}
	mock.recorder = &MockReaderMockRecorder{mock}
	return mock
}

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

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

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

// Next mocks base method.
func (m *MockReader) 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 *MockReaderMockRecorder) Next(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockReader)(nil).Next), n)
}

// Peek mocks base method.
func (m *MockReader) 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 *MockReaderMockRecorder) Peek(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Peek", reflect.TypeOf((*MockReader)(nil).Peek), n)
}

// ReadBinary mocks base method.
func (m *MockReader) 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 *MockReaderMockRecorder) ReadBinary(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadBinary", reflect.TypeOf((*MockReader)(nil).ReadBinary), n)
}

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

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

// ReadString mocks base method.
func (m *MockReader) 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 *MockReaderMockRecorder) ReadString(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadString", reflect.TypeOf((*MockReader)(nil).ReadString), n)
}

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

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

// Skip mocks base method.
func (m *MockReader) 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 *MockReaderMockRecorder) Skip(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Skip", reflect.TypeOf((*MockReader)(nil).Skip), n)
}

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

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

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

// Until indicates an expected call of Until.
func (mr *MockReaderMockRecorder) Until(delim interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Until", reflect.TypeOf((*MockReader)(nil).Until), delim)
}

// MockWriter is a mock of Writer interface.
type MockWriter struct {
	ctrl     *gomock.Controller
	recorder *MockWriterMockRecorder
}

// MockWriterMockRecorder is the mock recorder for MockWriter.
type MockWriterMockRecorder struct {
	mock *MockWriter
}

// NewMockWriter creates a new mock instance.
func NewMockWriter(ctrl *gomock.Controller) *MockWriter {
	mock := &MockWriter{ctrl: ctrl}
	mock.recorder = &MockWriterMockRecorder{mock}
	return mock
}

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

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

// Append indicates an expected call of Append.
func (mr *MockWriterMockRecorder) Append(w interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockWriter)(nil).Append), w)
}

// Flush mocks base method.
func (m *MockWriter) 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 *MockWriterMockRecorder) Flush() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Flush", reflect.TypeOf((*MockWriter)(nil).Flush))
}

// Malloc mocks base method.
func (m *MockWriter) 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 *MockWriterMockRecorder) Malloc(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Malloc", reflect.TypeOf((*MockWriter)(nil).Malloc), n)
}

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

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

// MallocLen mocks base method.
func (m *MockWriter) 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 *MockWriterMockRecorder) MallocLen() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MallocLen", reflect.TypeOf((*MockWriter)(nil).MallocLen))
}

// WriteBinary mocks base method.
func (m *MockWriter) 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 *MockWriterMockRecorder) WriteBinary(b interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteBinary", reflect.TypeOf((*MockWriter)(nil).WriteBinary), b)
}

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

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

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

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

// WriteString mocks base method.
func (m *MockWriter) 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 *MockWriterMockRecorder) WriteString(s interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteString", reflect.TypeOf((*MockWriter)(nil).WriteString), s)
}

// MockReadWriter is a mock of ReadWriter interface.
type MockReadWriter struct {
	ctrl     *gomock.Controller
	recorder *MockReadWriterMockRecorder
}

// MockReadWriterMockRecorder is the mock recorder for MockReadWriter.
type MockReadWriterMockRecorder struct {
	mock *MockReadWriter
}

// NewMockReadWriter creates a new mock instance.
func NewMockReadWriter(ctrl *gomock.Controller) *MockReadWriter {
	mock := &MockReadWriter{ctrl: ctrl}
	mock.recorder = &MockReadWriterMockRecorder{mock}
	return mock
}

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

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

// Append indicates an expected call of Append.
func (mr *MockReadWriterMockRecorder) Append(w interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockReadWriter)(nil).Append), w)
}

// Flush mocks base method.
func (m *MockReadWriter) 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 *MockReadWriterMockRecorder) Flush() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Flush", reflect.TypeOf((*MockReadWriter)(nil).Flush))
}

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

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

// Malloc mocks base method.
func (m *MockReadWriter) 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 *MockReadWriterMockRecorder) Malloc(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Malloc", reflect.TypeOf((*MockReadWriter)(nil).Malloc), n)
}

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

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

// MallocLen mocks base method.
func (m *MockReadWriter) 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 *MockReadWriterMockRecorder) MallocLen() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MallocLen", reflect.TypeOf((*MockReadWriter)(nil).MallocLen))
}

// Next mocks base method.
func (m *MockReadWriter) 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 *MockReadWriterMockRecorder) Next(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockReadWriter)(nil).Next), n)
}

// Peek mocks base method.
func (m *MockReadWriter) 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 *MockReadWriterMockRecorder) Peek(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Peek", reflect.TypeOf((*MockReadWriter)(nil).Peek), n)
}

// ReadBinary mocks base method.
func (m *MockReadWriter) 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 *MockReadWriterMockRecorder) ReadBinary(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadBinary", reflect.TypeOf((*MockReadWriter)(nil).ReadBinary), n)
}

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

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

// ReadString mocks base method.
func (m *MockReadWriter) 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 *MockReadWriterMockRecorder) ReadString(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadString", reflect.TypeOf((*MockReadWriter)(nil).ReadString), n)
}

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

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

// Skip mocks base method.
func (m *MockReadWriter) 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 *MockReadWriterMockRecorder) Skip(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Skip", reflect.TypeOf((*MockReadWriter)(nil).Skip), n)
}

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

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

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

// Until indicates an expected call of Until.
func (mr *MockReadWriterMockRecorder) Until(delim interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Until", reflect.TypeOf((*MockReadWriter)(nil).Until), delim)
}

// WriteBinary mocks base method.
func (m *MockReadWriter) 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 *MockReadWriterMockRecorder) WriteBinary(b interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteBinary", reflect.TypeOf((*MockReadWriter)(nil).WriteBinary), b)
}

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

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

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

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

// WriteString mocks base method.
func (m *MockReadWriter) 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 *MockReadWriterMockRecorder) WriteString(s interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteString", reflect.TypeOf((*MockReadWriter)(nil).WriteString), s)
}
