mock_networktransport.go

// Code generated by MockGen. DO NOT EDIT.
// Source: p2p/networktransport.go

// Package mock_p2p is a generated GoMock package.
package p2pmock

import (
	"context"
	"reflect"
	"time"

	"github.com/aergoio/aergo/p2p/p2pcommon"
	"github.com/aergoio/aergo/types"
	"github.com/golang/mock/gomock"
	go_libp2p_crypto "github.com/libp2p/go-libp2p-crypto"
	go_libp2p_interface_connmgr "github.com/libp2p/go-libp2p-interface-connmgr"
	go_libp2p_net "github.com/libp2p/go-libp2p-net"
	go_libp2p_peer "github.com/libp2p/go-libp2p-peer"
	go_libp2p_peerstore "github.com/libp2p/go-libp2p-peerstore"
	go_libp2p_protocol "github.com/libp2p/go-libp2p-protocol"
	go_multiaddr "github.com/multiformats/go-multiaddr"
	go_multistream "github.com/multiformats/go-multistream"
)

// MockNTContainer is a mock of NTContainer interface
type MockNTContainer struct {
	ctrl     *gomock.Controller
	recorder *MockNTContainerMockRecorder
}

// MockNTContainerMockRecorder is the mock recorder for MockNTContainer
type MockNTContainerMockRecorder struct {
	mock *MockNTContainer
}

// NewMockNTContainer creates a new mock instance
func NewMockNTContainer(ctrl *gomock.Controller) *MockNTContainer {
	mock := &MockNTContainer{ctrl: ctrl}
	mock.recorder = &MockNTContainerMockRecorder{mock}
	return mock
}

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

// GetNetworkTransport mocks base method
func (m *MockNTContainer) GetNetworkTransport() p2pcommon.NetworkTransport {
	ret := m.ctrl.Call(m, "GetNetworkTransport")
	ret0, _ := ret[0].(p2pcommon.NetworkTransport)
	return ret0
}

// GetNetworkTransport indicates an expected call of GetNetworkTransport
func (mr *MockNTContainerMockRecorder) GetNetworkTransport() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkTransport", reflect.TypeOf((*MockNTContainer)(nil).GetNetworkTransport))
}

// ChainID mocks base method
func (m *MockNTContainer) ChainID() *types.ChainID {
	ret := m.ctrl.Call(m, "ChainID")
	ret0, _ := ret[0].(*types.ChainID)
	return ret0
}

// ChainID indicates an expected call of ChainID
func (mr *MockNTContainerMockRecorder) ChainID() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainID", reflect.TypeOf((*MockNTContainer)(nil).ChainID))
}

// MockNetworkTransport is a mock of NetworkTransport interface
type MockNetworkTransport struct {
	ctrl     *gomock.Controller
	recorder *MockNetworkTransportMockRecorder
}

// MockNetworkTransportMockRecorder is the mock recorder for MockNetworkTransport
type MockNetworkTransportMockRecorder struct {
	mock *MockNetworkTransport
}

// NewMockNetworkTransport creates a new mock instance
func NewMockNetworkTransport(ctrl *gomock.Controller) *MockNetworkTransport {
	mock := &MockNetworkTransport{ctrl: ctrl}
	mock.recorder = &MockNetworkTransportMockRecorder{mock}
	return mock
}

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

// ID mocks base method
func (m *MockNetworkTransport) ID() go_libp2p_peer.ID {
	ret := m.ctrl.Call(m, "ID")
	ret0, _ := ret[0].(go_libp2p_peer.ID)
	return ret0
}

// ID indicates an expected call of ID
func (mr *MockNetworkTransportMockRecorder) ID() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockNetworkTransport)(nil).ID))
}

// Peerstore mocks base method
func (m *MockNetworkTransport) Peerstore() go_libp2p_peerstore.Peerstore {
	ret := m.ctrl.Call(m, "Peerstore")
	ret0, _ := ret[0].(go_libp2p_peerstore.Peerstore)
	return ret0
}

// Peerstore indicates an expected call of Peerstore
func (mr *MockNetworkTransportMockRecorder) Peerstore() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Peerstore", reflect.TypeOf((*MockNetworkTransport)(nil).Peerstore))
}

// Addrs mocks base method
func (m *MockNetworkTransport) Addrs() []go_multiaddr.Multiaddr {
	ret := m.ctrl.Call(m, "Addrs")
	ret0, _ := ret[0].([]go_multiaddr.Multiaddr)
	return ret0
}

// Addrs indicates an expected call of Addrs
func (mr *MockNetworkTransportMockRecorder) Addrs() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Addrs", reflect.TypeOf((*MockNetworkTransport)(nil).Addrs))
}

// Network mocks base method
func (m *MockNetworkTransport) Network() go_libp2p_net.Network {
	ret := m.ctrl.Call(m, "Network")
	ret0, _ := ret[0].(go_libp2p_net.Network)
	return ret0
}

// Network indicates an expected call of Network
func (mr *MockNetworkTransportMockRecorder) Network() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Network", reflect.TypeOf((*MockNetworkTransport)(nil).Network))
}

// Mux mocks base method
func (m *MockNetworkTransport) Mux() *go_multistream.MultistreamMuxer {
	ret := m.ctrl.Call(m, "Mux")
	ret0, _ := ret[0].(*go_multistream.MultistreamMuxer)
	return ret0
}

// Mux indicates an expected call of Mux
func (mr *MockNetworkTransportMockRecorder) Mux() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Mux", reflect.TypeOf((*MockNetworkTransport)(nil).Mux))
}

// Connect mocks base method
func (m *MockNetworkTransport) Connect(ctx context.Context, pi go_libp2p_peerstore.PeerInfo) error {
	ret := m.ctrl.Call(m, "Connect", ctx, pi)
	ret0, _ := ret[0].(error)
	return ret0
}

// Connect indicates an expected call of Connect
func (mr *MockNetworkTransportMockRecorder) Connect(ctx, pi interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockNetworkTransport)(nil).Connect), ctx, pi)
}

// SetStreamHandler mocks base method
func (m *MockNetworkTransport) SetStreamHandler(pid go_libp2p_protocol.ID, handler go_libp2p_net.StreamHandler) {
	m.ctrl.Call(m, "SetStreamHandler", pid, handler)
}

// SetStreamHandler indicates an expected call of SetStreamHandler
func (mr *MockNetworkTransportMockRecorder) SetStreamHandler(pid, handler interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStreamHandler", reflect.TypeOf((*MockNetworkTransport)(nil).SetStreamHandler), pid, handler)
}

// SetStreamHandlerMatch mocks base method
func (m *MockNetworkTransport) SetStreamHandlerMatch(arg0 go_libp2p_protocol.ID, arg1 func(string) bool, arg2 go_libp2p_net.StreamHandler) {
	m.ctrl.Call(m, "SetStreamHandlerMatch", arg0, arg1, arg2)
}

// SetStreamHandlerMatch indicates an expected call of SetStreamHandlerMatch
func (mr *MockNetworkTransportMockRecorder) SetStreamHandlerMatch(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStreamHandlerMatch", reflect.TypeOf((*MockNetworkTransport)(nil).SetStreamHandlerMatch), arg0, arg1, arg2)
}

// RemoveStreamHandler mocks base method
func (m *MockNetworkTransport) RemoveStreamHandler(pid go_libp2p_protocol.ID) {
	m.ctrl.Call(m, "RemoveStreamHandler", pid)
}

// RemoveStreamHandler indicates an expected call of RemoveStreamHandler
func (mr *MockNetworkTransportMockRecorder) RemoveStreamHandler(pid interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveStreamHandler", reflect.TypeOf((*MockNetworkTransport)(nil).RemoveStreamHandler), pid)
}

// NewStream mocks base method
func (m *MockNetworkTransport) NewStream(ctx context.Context, p go_libp2p_peer.ID, pids ...go_libp2p_protocol.ID) (go_libp2p_net.Stream, error) {
	varargs := []interface{}{ctx, p}
	for _, a := range pids {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NewStream", varargs...)
	ret0, _ := ret[0].(go_libp2p_net.Stream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewStream indicates an expected call of NewStream
func (mr *MockNetworkTransportMockRecorder) NewStream(ctx, p interface{}, pids ...interface{}) *gomock.Call {
	varargs := append([]interface{}{ctx, p}, pids...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewStream", reflect.TypeOf((*MockNetworkTransport)(nil).NewStream), varargs...)
}

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

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

// ConnManager mocks base method
func (m *MockNetworkTransport) ConnManager() go_libp2p_interface_connmgr.ConnManager {
	ret := m.ctrl.Call(m, "ConnManager")
	ret0, _ := ret[0].(go_libp2p_interface_connmgr.ConnManager)
	return ret0
}

// ConnManager indicates an expected call of ConnManager
func (mr *MockNetworkTransportMockRecorder) ConnManager() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnManager", reflect.TypeOf((*MockNetworkTransport)(nil).ConnManager))
}

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

// Start indicates an expected call of Start
func (mr *MockNetworkTransportMockRecorder) Start() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockNetworkTransport)(nil).Start))
}

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

// Stop indicates an expected call of Stop
func (mr *MockNetworkTransportMockRecorder) Stop() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockNetworkTransport)(nil).Stop))
}

// PrivateKey mocks base method
func (m *MockNetworkTransport) PrivateKey() go_libp2p_crypto.PrivKey {
	ret := m.ctrl.Call(m, "PrivateKey")
	ret0, _ := ret[0].(go_libp2p_crypto.PrivKey)
	return ret0
}

// PrivateKey indicates an expected call of PrivateKey
func (mr *MockNetworkTransportMockRecorder) PrivateKey() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrivateKey", reflect.TypeOf((*MockNetworkTransport)(nil).PrivateKey))
}

// PublicKey mocks base method
func (m *MockNetworkTransport) PublicKey() go_libp2p_crypto.PubKey {
	ret := m.ctrl.Call(m, "PublicKey")
	ret0, _ := ret[0].(go_libp2p_crypto.PubKey)
	return ret0
}

// PublicKey indicates an expected call of PublicKey
func (mr *MockNetworkTransportMockRecorder) PublicKey() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublicKey", reflect.TypeOf((*MockNetworkTransport)(nil).PublicKey))
}

// SelfMeta mocks base method
func (m *MockNetworkTransport) SelfMeta() p2pcommon.PeerMeta {
	ret := m.ctrl.Call(m, "SelfMeta")
	ret0, _ := ret[0].(p2pcommon.PeerMeta)
	return ret0
}

// SelfMeta indicates an expected call of SelfMeta
func (mr *MockNetworkTransportMockRecorder) SelfMeta() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelfMeta", reflect.TypeOf((*MockNetworkTransport)(nil).SelfMeta))
}

// SelfNodeID mocks base method
func (m *MockNetworkTransport) SelfNodeID() go_libp2p_peer.ID {
	ret := m.ctrl.Call(m, "SelfNodeID")
	ret0, _ := ret[0].(go_libp2p_peer.ID)
	return ret0
}

// SelfNodeID indicates an expected call of SelfNodeID
func (mr *MockNetworkTransportMockRecorder) SelfNodeID() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelfNodeID", reflect.TypeOf((*MockNetworkTransport)(nil).SelfNodeID))
}

// GetAddressesOfPeer mocks base method
func (m *MockNetworkTransport) GetAddressesOfPeer(peerID go_libp2p_peer.ID) []string {
	ret := m.ctrl.Call(m, "GetAddressesOfPeer", peerID)
	ret0, _ := ret[0].([]string)
	return ret0
}

// GetAddressesOfPeer indicates an expected call of GetAddressesOfPeer
func (mr *MockNetworkTransportMockRecorder) GetAddressesOfPeer(peerID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddressesOfPeer", reflect.TypeOf((*MockNetworkTransport)(nil).GetAddressesOfPeer), peerID)
}

// AddStreamHandler mocks base method
func (m *MockNetworkTransport) AddStreamHandler(pid go_libp2p_protocol.ID, handler go_libp2p_net.StreamHandler) {
	m.ctrl.Call(m, "AddStreamHandler", pid, handler)
}

// AddStreamHandler indicates an expected call of AddStreamHandler
func (mr *MockNetworkTransportMockRecorder) AddStreamHandler(pid, handler interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddStreamHandler", reflect.TypeOf((*MockNetworkTransport)(nil).AddStreamHandler), pid, handler)
}

// GetOrCreateStream mocks base method
func (m *MockNetworkTransport) GetOrCreateStream(meta p2pcommon.PeerMeta, protocolID go_libp2p_protocol.ID) (go_libp2p_net.Stream, error) {
	ret := m.ctrl.Call(m, "GetOrCreateStream", meta, protocolID)
	ret0, _ := ret[0].(go_libp2p_net.Stream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrCreateStream indicates an expected call of GetOrCreateStream
func (mr *MockNetworkTransportMockRecorder) GetOrCreateStream(meta, protocolID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrCreateStream", reflect.TypeOf((*MockNetworkTransport)(nil).GetOrCreateStream), meta, protocolID)
}

// GetOrCreateStreamWithTTL mocks base method
func (m *MockNetworkTransport) GetOrCreateStreamWithTTL(meta p2pcommon.PeerMeta, protocolID go_libp2p_protocol.ID, ttl time.Duration) (go_libp2p_net.Stream, error) {
	ret := m.ctrl.Call(m, "GetOrCreateStreamWithTTL", meta, protocolID, ttl)
	ret0, _ := ret[0].(go_libp2p_net.Stream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrCreateStreamWithTTL indicates an expected call of GetOrCreateStreamWithTTL
func (mr *MockNetworkTransportMockRecorder) GetOrCreateStreamWithTTL(meta, protocolID, ttl interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrCreateStreamWithTTL", reflect.TypeOf((*MockNetworkTransport)(nil).GetOrCreateStreamWithTTL), meta, protocolID, ttl)
}

// FindPeer mocks base method
func (m *MockNetworkTransport) FindPeer(peerID go_libp2p_peer.ID) bool {
	ret := m.ctrl.Call(m, "FindPeer", peerID)
	ret0, _ := ret[0].(bool)
	return ret0
}

// FindPeer indicates an expected call of FindPeer
func (mr *MockNetworkTransportMockRecorder) FindPeer(peerID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindPeer", reflect.TypeOf((*MockNetworkTransport)(nil).FindPeer), peerID)
}

// ClosePeerConnection mocks base method
func (m *MockNetworkTransport) ClosePeerConnection(peerID go_libp2p_peer.ID) bool {
	ret := m.ctrl.Call(m, "ClosePeerConnection", peerID)
	ret0, _ := ret[0].(bool)
	return ret0
}

// ClosePeerConnection indicates an expected call of ClosePeerConnection
func (mr *MockNetworkTransportMockRecorder) ClosePeerConnection(peerID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClosePeerConnection", reflect.TypeOf((*MockNetworkTransport)(nil).ClosePeerConnection), peerID)
}