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

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

import (
	context "context"
	net "net"
	reflect "reflect"

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

// MockBoundHandler is a mock of BoundHandler interface.
type MockBoundHandler struct {
	ctrl     *gomock.Controller
	recorder *MockBoundHandlerMockRecorder
}

// MockBoundHandlerMockRecorder is the mock recorder for MockBoundHandler.
type MockBoundHandlerMockRecorder struct {
	mock *MockBoundHandler
}

// NewMockBoundHandler creates a new mock instance.
func NewMockBoundHandler(ctrl *gomock.Controller) *MockBoundHandler {
	mock := &MockBoundHandler{ctrl: ctrl}
	mock.recorder = &MockBoundHandlerMockRecorder{mock}
	return mock
}

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

// MockOutboundHandler is a mock of OutboundHandler interface.
type MockOutboundHandler struct {
	ctrl     *gomock.Controller
	recorder *MockOutboundHandlerMockRecorder
}

// MockOutboundHandlerMockRecorder is the mock recorder for MockOutboundHandler.
type MockOutboundHandlerMockRecorder struct {
	mock *MockOutboundHandler
}

// NewMockOutboundHandler creates a new mock instance.
func NewMockOutboundHandler(ctrl *gomock.Controller) *MockOutboundHandler {
	mock := &MockOutboundHandler{ctrl: ctrl}
	mock.recorder = &MockOutboundHandlerMockRecorder{mock}
	return mock
}

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

// Write mocks base method.
func (m *MockOutboundHandler) Write(ctx context.Context, conn net.Conn, send remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", ctx, conn, send)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Write indicates an expected call of Write.
func (mr *MockOutboundHandlerMockRecorder) Write(ctx, conn, send interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockOutboundHandler)(nil).Write), ctx, conn, send)
}

// MockInboundHandler is a mock of InboundHandler interface.
type MockInboundHandler struct {
	ctrl     *gomock.Controller
	recorder *MockInboundHandlerMockRecorder
}

// MockInboundHandlerMockRecorder is the mock recorder for MockInboundHandler.
type MockInboundHandlerMockRecorder struct {
	mock *MockInboundHandler
}

// NewMockInboundHandler creates a new mock instance.
func NewMockInboundHandler(ctrl *gomock.Controller) *MockInboundHandler {
	mock := &MockInboundHandler{ctrl: ctrl}
	mock.recorder = &MockInboundHandlerMockRecorder{mock}
	return mock
}

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

// OnActive mocks base method.
func (m *MockInboundHandler) OnActive(ctx context.Context, conn net.Conn) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnActive", ctx, conn)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// OnInactive mocks base method.
func (m *MockInboundHandler) OnInactive(ctx context.Context, conn net.Conn) context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnInactive", ctx, conn)
	ret0, _ := ret[0].(context.Context)
	return ret0
}

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

// OnMessage mocks base method.
func (m *MockInboundHandler) OnMessage(ctx context.Context, args, result remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnMessage", ctx, args, result)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OnMessage indicates an expected call of OnMessage.
func (mr *MockInboundHandlerMockRecorder) OnMessage(ctx, args, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnMessage", reflect.TypeOf((*MockInboundHandler)(nil).OnMessage), ctx, args, result)
}

// OnRead mocks base method.
func (m *MockInboundHandler) OnRead(ctx context.Context, conn net.Conn) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnRead", ctx, conn)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockDuplexBoundHandler is a mock of DuplexBoundHandler interface.
type MockDuplexBoundHandler struct {
	ctrl     *gomock.Controller
	recorder *MockDuplexBoundHandlerMockRecorder
}

// MockDuplexBoundHandlerMockRecorder is the mock recorder for MockDuplexBoundHandler.
type MockDuplexBoundHandlerMockRecorder struct {
	mock *MockDuplexBoundHandler
}

// NewMockDuplexBoundHandler creates a new mock instance.
func NewMockDuplexBoundHandler(ctrl *gomock.Controller) *MockDuplexBoundHandler {
	mock := &MockDuplexBoundHandler{ctrl: ctrl}
	mock.recorder = &MockDuplexBoundHandlerMockRecorder{mock}
	return mock
}

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

// OnActive mocks base method.
func (m *MockDuplexBoundHandler) OnActive(ctx context.Context, conn net.Conn) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnActive", ctx, conn)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// OnInactive mocks base method.
func (m *MockDuplexBoundHandler) OnInactive(ctx context.Context, conn net.Conn) context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnInactive", ctx, conn)
	ret0, _ := ret[0].(context.Context)
	return ret0
}

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

// OnMessage mocks base method.
func (m *MockDuplexBoundHandler) OnMessage(ctx context.Context, args, result remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnMessage", ctx, args, result)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OnMessage indicates an expected call of OnMessage.
func (mr *MockDuplexBoundHandlerMockRecorder) OnMessage(ctx, args, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnMessage", reflect.TypeOf((*MockDuplexBoundHandler)(nil).OnMessage), ctx, args, result)
}

// OnRead mocks base method.
func (m *MockDuplexBoundHandler) OnRead(ctx context.Context, conn net.Conn) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnRead", ctx, conn)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Write mocks base method.
func (m *MockDuplexBoundHandler) Write(ctx context.Context, conn net.Conn, send remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", ctx, conn, send)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Write indicates an expected call of Write.
func (mr *MockDuplexBoundHandlerMockRecorder) Write(ctx, conn, send interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockDuplexBoundHandler)(nil).Write), ctx, conn, send)
}
