mock_stream.go

// Code generated by MockGen. DO NOT EDIT.
// Source: vendor/github.com/libp2p/go-libp2p-net/interface.go

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

import (
	context "context"
	reflect "reflect"
	time "time"

	gomock "github.com/golang/mock/gomock"
	goprocess "github.com/jbenet/goprocess"
	go_libp2p_crypto "github.com/libp2p/go-libp2p-crypto"
	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"
)

// MockStream is a mock of Stream interface
type MockStream struct {
	ctrl     *gomock.Controller
	recorder *MockStreamMockRecorder
}

// MockStreamMockRecorder is the mock recorder for MockStream
type MockStreamMockRecorder struct {
	mock *MockStream
}

// NewMockStream creates a new mock instance
func NewMockStream(ctrl *gomock.Controller) *MockStream {
	mock := &MockStream{ctrl: ctrl}
	mock.recorder = &MockStreamMockRecorder{mock}
	return mock
}

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

// Read mocks base method
func (m *MockStream) Read(p []byte) (int, error) {
	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 *MockStreamMockRecorder) Read(p interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockStream)(nil).Read), p)
}

// Write mocks base method
func (m *MockStream) Write(p []byte) (int, error) {
	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 *MockStreamMockRecorder) Write(p interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockStream)(nil).Write), p)
}

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

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

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

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

// SetDeadline mocks base method
func (m *MockStream) SetDeadline(arg0 time.Time) error {
	ret := m.ctrl.Call(m, "SetDeadline", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetDeadline indicates an expected call of SetDeadline
func (mr *MockStreamMockRecorder) SetDeadline(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDeadline", reflect.TypeOf((*MockStream)(nil).SetDeadline), arg0)
}

// SetReadDeadline mocks base method
func (m *MockStream) SetReadDeadline(arg0 time.Time) error {
	ret := m.ctrl.Call(m, "SetReadDeadline", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetReadDeadline indicates an expected call of SetReadDeadline
func (mr *MockStreamMockRecorder) SetReadDeadline(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockStream)(nil).SetReadDeadline), arg0)
}

// SetWriteDeadline mocks base method
func (m *MockStream) SetWriteDeadline(arg0 time.Time) error {
	ret := m.ctrl.Call(m, "SetWriteDeadline", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetWriteDeadline indicates an expected call of SetWriteDeadline
func (mr *MockStreamMockRecorder) SetWriteDeadline(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockStream)(nil).SetWriteDeadline), arg0)
}

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

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

// SetProtocol mocks base method
func (m *MockStream) SetProtocol(arg0 go_libp2p_protocol.ID) {
	m.ctrl.Call(m, "SetProtocol", arg0)
}

// SetProtocol indicates an expected call of SetProtocol
func (mr *MockStreamMockRecorder) SetProtocol(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProtocol", reflect.TypeOf((*MockStream)(nil).SetProtocol), arg0)
}

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

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

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

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

// MockConnSecurity is a mock of ConnSecurity interface
type MockConnSecurity struct {
	ctrl     *gomock.Controller
	recorder *MockConnSecurityMockRecorder
}

// MockConnSecurityMockRecorder is the mock recorder for MockConnSecurity
type MockConnSecurityMockRecorder struct {
	mock *MockConnSecurity
}

// NewMockConnSecurity creates a new mock instance
func NewMockConnSecurity(ctrl *gomock.Controller) *MockConnSecurity {
	mock := &MockConnSecurity{ctrl: ctrl}
	mock.recorder = &MockConnSecurityMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// MockConnMultiaddrs is a mock of ConnMultiaddrs interface
type MockConnMultiaddrs struct {
	ctrl     *gomock.Controller
	recorder *MockConnMultiaddrsMockRecorder
}

// MockConnMultiaddrsMockRecorder is the mock recorder for MockConnMultiaddrs
type MockConnMultiaddrsMockRecorder struct {
	mock *MockConnMultiaddrs
}

// NewMockConnMultiaddrs creates a new mock instance
func NewMockConnMultiaddrs(ctrl *gomock.Controller) *MockConnMultiaddrs {
	mock := &MockConnMultiaddrs{ctrl: ctrl}
	mock.recorder = &MockConnMultiaddrsMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockConn is a mock of Conn interface
type MockConn struct {
	ctrl     *gomock.Controller
	recorder *MockConnMockRecorder
}

// MockConnMockRecorder is the mock recorder for MockConn
type MockConnMockRecorder struct {
	mock *MockConn
}

// NewMockConn creates a new mock instance
func NewMockConn(ctrl *gomock.Controller) *MockConn {
	mock := &MockConn{ctrl: ctrl}
	mock.recorder = &MockConnMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// NewStream mocks base method
func (m *MockConn) NewStream() (go_libp2p_net.Stream, error) {
	ret := m.ctrl.Call(m, "NewStream")
	ret0, _ := ret[0].(go_libp2p_net.Stream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// MockNetwork is a mock of Network interface
type MockNetwork struct {
	ctrl     *gomock.Controller
	recorder *MockNetworkMockRecorder
}

// MockNetworkMockRecorder is the mock recorder for MockNetwork
type MockNetworkMockRecorder struct {
	mock *MockNetwork
}

// NewMockNetwork creates a new mock instance
func NewMockNetwork(ctrl *gomock.Controller) *MockNetwork {
	mock := &MockNetwork{ctrl: ctrl}
	mock.recorder = &MockNetworkMockRecorder{mock}
	return mock
}

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

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

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

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

// DialPeer mocks base method
func (m *MockNetwork) DialPeer(arg0 context.Context, arg1 go_libp2p_peer.ID) (go_libp2p_net.Conn, error) {
	ret := m.ctrl.Call(m, "DialPeer", arg0, arg1)
	ret0, _ := ret[0].(go_libp2p_net.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// ClosePeer indicates an expected call of ClosePeer
func (mr *MockNetworkMockRecorder) ClosePeer(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClosePeer", reflect.TypeOf((*MockNetwork)(nil).ClosePeer), arg0)
}

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

// Connectedness indicates an expected call of Connectedness
func (mr *MockNetworkMockRecorder) Connectedness(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connectedness", reflect.TypeOf((*MockNetwork)(nil).Connectedness), arg0)
}

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

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

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

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

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

// ConnsToPeer indicates an expected call of ConnsToPeer
func (mr *MockNetworkMockRecorder) ConnsToPeer(p interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnsToPeer", reflect.TypeOf((*MockNetwork)(nil).ConnsToPeer), p)
}

// Notify mocks base method
func (m *MockNetwork) Notify(arg0 go_libp2p_net.Notifiee) {
	m.ctrl.Call(m, "Notify", arg0)
}

// Notify indicates an expected call of Notify
func (mr *MockNetworkMockRecorder) Notify(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Notify", reflect.TypeOf((*MockNetwork)(nil).Notify), arg0)
}

// StopNotify mocks base method
func (m *MockNetwork) StopNotify(arg0 go_libp2p_net.Notifiee) {
	m.ctrl.Call(m, "StopNotify", arg0)
}

// StopNotify indicates an expected call of StopNotify
func (mr *MockNetworkMockRecorder) StopNotify(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopNotify", reflect.TypeOf((*MockNetwork)(nil).StopNotify), arg0)
}

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

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

// SetStreamHandler mocks base method
func (m *MockNetwork) SetStreamHandler(arg0 go_libp2p_net.StreamHandler) {
	m.ctrl.Call(m, "SetStreamHandler", arg0)
}

// SetStreamHandler indicates an expected call of SetStreamHandler
func (mr *MockNetworkMockRecorder) SetStreamHandler(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStreamHandler", reflect.TypeOf((*MockNetwork)(nil).SetStreamHandler), arg0)
}

// SetConnHandler mocks base method
func (m *MockNetwork) SetConnHandler(arg0 go_libp2p_net.ConnHandler) {
	m.ctrl.Call(m, "SetConnHandler", arg0)
}

// SetConnHandler indicates an expected call of SetConnHandler
func (mr *MockNetworkMockRecorder) SetConnHandler(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConnHandler", reflect.TypeOf((*MockNetwork)(nil).SetConnHandler), arg0)
}

// NewStream mocks base method
func (m *MockNetwork) NewStream(arg0 context.Context, arg1 go_libp2p_peer.ID) (go_libp2p_net.Stream, error) {
	ret := m.ctrl.Call(m, "NewStream", arg0, arg1)
	ret0, _ := ret[0].(go_libp2p_net.Stream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Listen mocks base method
func (m *MockNetwork) Listen(arg0 ...go_multiaddr.Multiaddr) error {
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Listen", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Listen indicates an expected call of Listen
func (mr *MockNetworkMockRecorder) Listen(arg0 ...interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Listen", reflect.TypeOf((*MockNetwork)(nil).Listen), arg0...)
}

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

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

// InterfaceListenAddresses mocks base method
func (m *MockNetwork) InterfaceListenAddresses() ([]go_multiaddr.Multiaddr, error) {
	ret := m.ctrl.Call(m, "InterfaceListenAddresses")
	ret0, _ := ret[0].([]go_multiaddr.Multiaddr)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockDialer is a mock of Dialer interface
type MockDialer struct {
	ctrl     *gomock.Controller
	recorder *MockDialerMockRecorder
}

// MockDialerMockRecorder is the mock recorder for MockDialer
type MockDialerMockRecorder struct {
	mock *MockDialer
}

// NewMockDialer creates a new mock instance
func NewMockDialer(ctrl *gomock.Controller) *MockDialer {
	mock := &MockDialer{ctrl: ctrl}
	mock.recorder = &MockDialerMockRecorder{mock}
	return mock
}

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

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

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

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

// DialPeer mocks base method
func (m *MockDialer) DialPeer(arg0 context.Context, arg1 go_libp2p_peer.ID) (go_libp2p_net.Conn, error) {
	ret := m.ctrl.Call(m, "DialPeer", arg0, arg1)
	ret0, _ := ret[0].(go_libp2p_net.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// ClosePeer indicates an expected call of ClosePeer
func (mr *MockDialerMockRecorder) ClosePeer(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClosePeer", reflect.TypeOf((*MockDialer)(nil).ClosePeer), arg0)
}

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

// Connectedness indicates an expected call of Connectedness
func (mr *MockDialerMockRecorder) Connectedness(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connectedness", reflect.TypeOf((*MockDialer)(nil).Connectedness), arg0)
}

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

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

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

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

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

// ConnsToPeer indicates an expected call of ConnsToPeer
func (mr *MockDialerMockRecorder) ConnsToPeer(p interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnsToPeer", reflect.TypeOf((*MockDialer)(nil).ConnsToPeer), p)
}

// Notify mocks base method
func (m *MockDialer) Notify(arg0 go_libp2p_net.Notifiee) {
	m.ctrl.Call(m, "Notify", arg0)
}

// Notify indicates an expected call of Notify
func (mr *MockDialerMockRecorder) Notify(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Notify", reflect.TypeOf((*MockDialer)(nil).Notify), arg0)
}

// StopNotify mocks base method
func (m *MockDialer) StopNotify(arg0 go_libp2p_net.Notifiee) {
	m.ctrl.Call(m, "StopNotify", arg0)
}

// StopNotify indicates an expected call of StopNotify
func (mr *MockDialerMockRecorder) StopNotify(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopNotify", reflect.TypeOf((*MockDialer)(nil).StopNotify), arg0)
}

// MockNotifiee is a mock of Notifiee interface
type MockNotifiee struct {
	ctrl     *gomock.Controller
	recorder *MockNotifieeMockRecorder
}

// MockNotifieeMockRecorder is the mock recorder for MockNotifiee
type MockNotifieeMockRecorder struct {
	mock *MockNotifiee
}

// NewMockNotifiee creates a new mock instance
func NewMockNotifiee(ctrl *gomock.Controller) *MockNotifiee {
	mock := &MockNotifiee{ctrl: ctrl}
	mock.recorder = &MockNotifieeMockRecorder{mock}
	return mock
}

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

// Listen mocks base method
func (m *MockNotifiee) Listen(arg0 go_libp2p_net.Network, arg1 go_multiaddr.Multiaddr) {
	m.ctrl.Call(m, "Listen", arg0, arg1)
}

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

// ListenClose mocks base method
func (m *MockNotifiee) ListenClose(arg0 go_libp2p_net.Network, arg1 go_multiaddr.Multiaddr) {
	m.ctrl.Call(m, "ListenClose", arg0, arg1)
}

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

// Connected mocks base method
func (m *MockNotifiee) Connected(arg0 go_libp2p_net.Network, arg1 go_libp2p_net.Conn) {
	m.ctrl.Call(m, "Connected", arg0, arg1)
}

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

// Disconnected mocks base method
func (m *MockNotifiee) Disconnected(arg0 go_libp2p_net.Network, arg1 go_libp2p_net.Conn) {
	m.ctrl.Call(m, "Disconnected", arg0, arg1)
}

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

// OpenedStream mocks base method
func (m *MockNotifiee) OpenedStream(arg0 go_libp2p_net.Network, arg1 go_libp2p_net.Stream) {
	m.ctrl.Call(m, "OpenedStream", arg0, arg1)
}

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

// ClosedStream mocks base method
func (m *MockNotifiee) ClosedStream(arg0 go_libp2p_net.Network, arg1 go_libp2p_net.Stream) {
	m.ctrl.Call(m, "ClosedStream", arg0, arg1)
}

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