/*
 * 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/connpool.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"
)

// MockConnPool is a mock of ConnPool interface.
type MockConnPool struct {
	ctrl     *gomock.Controller
	recorder *MockConnPoolMockRecorder
}

// MockConnPoolMockRecorder is the mock recorder for MockConnPool.
type MockConnPoolMockRecorder struct {
	mock *MockConnPool
}

// NewMockConnPool creates a new mock instance.
func NewMockConnPool(ctrl *gomock.Controller) *MockConnPool {
	mock := &MockConnPool{ctrl: ctrl}
	mock.recorder = &MockConnPoolMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Get mocks base method.
func (m *MockConnPool) Get(ctx context.Context, network, address string, opt remote.ConnOption) (net.Conn, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, network, address, opt)
	ret0, _ := ret[0].(net.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockConnPoolMockRecorder) Get(ctx, network, address, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockConnPool)(nil).Get), ctx, network, address, opt)
}

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

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

// MockLongConnPool is a mock of LongConnPool interface.
type MockLongConnPool struct {
	ctrl     *gomock.Controller
	recorder *MockLongConnPoolMockRecorder
}

// MockLongConnPoolMockRecorder is the mock recorder for MockLongConnPool.
type MockLongConnPoolMockRecorder struct {
	mock *MockLongConnPool
}

// NewMockLongConnPool creates a new mock instance.
func NewMockLongConnPool(ctrl *gomock.Controller) *MockLongConnPool {
	mock := &MockLongConnPool{ctrl: ctrl}
	mock.recorder = &MockLongConnPoolMockRecorder{mock}
	return mock
}

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

// Clean mocks base method.
func (m *MockLongConnPool) Clean(network, address string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Clean", network, address)
}

// Clean indicates an expected call of Clean.
func (mr *MockLongConnPoolMockRecorder) Clean(network, address interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clean", reflect.TypeOf((*MockLongConnPool)(nil).Clean), network, address)
}

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

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

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

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

// Get mocks base method.
func (m *MockLongConnPool) Get(ctx context.Context, network, address string, opt remote.ConnOption) (net.Conn, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, network, address, opt)
	ret0, _ := ret[0].(net.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockLongConnPoolMockRecorder) Get(ctx, network, address, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockLongConnPool)(nil).Get), ctx, network, address, opt)
}

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

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

// MockConnPoolReporter is a mock of ConnPoolReporter interface.
type MockConnPoolReporter struct {
	ctrl     *gomock.Controller
	recorder *MockConnPoolReporterMockRecorder
}

// MockConnPoolReporterMockRecorder is the mock recorder for MockConnPoolReporter.
type MockConnPoolReporterMockRecorder struct {
	mock *MockConnPoolReporter
}

// NewMockConnPoolReporter creates a new mock instance.
func NewMockConnPoolReporter(ctrl *gomock.Controller) *MockConnPoolReporter {
	mock := &MockConnPoolReporter{ctrl: ctrl}
	mock.recorder = &MockConnPoolReporterMockRecorder{mock}
	return mock
}

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

// EnableReporter mocks base method.
func (m *MockConnPoolReporter) EnableReporter() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EnableReporter")
}

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

// MockRawConn is a mock of RawConn interface.
type MockRawConn struct {
	ctrl     *gomock.Controller
	recorder *MockRawConnMockRecorder
}

// MockRawConnMockRecorder is the mock recorder for MockRawConn.
type MockRawConnMockRecorder struct {
	mock *MockRawConn
}

// NewMockRawConn creates a new mock instance.
func NewMockRawConn(ctrl *gomock.Controller) *MockRawConn {
	mock := &MockRawConn{ctrl: ctrl}
	mock.recorder = &MockRawConnMockRecorder{mock}
	return mock
}

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

// RawConn mocks base method.
func (m *MockRawConn) RawConn() net.Conn {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RawConn")
	ret0, _ := ret[0].(net.Conn)
	return ret0
}

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

// MockIsActive is a mock of IsActive interface.
type MockIsActive struct {
	ctrl     *gomock.Controller
	recorder *MockIsActiveMockRecorder
}

// MockIsActiveMockRecorder is the mock recorder for MockIsActive.
type MockIsActiveMockRecorder struct {
	mock *MockIsActive
}

// NewMockIsActive creates a new mock instance.
func NewMockIsActive(ctrl *gomock.Controller) *MockIsActive {
	mock := &MockIsActive{ctrl: ctrl}
	mock.recorder = &MockIsActiveMockRecorder{mock}
	return mock
}

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

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

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