// Code generated by counterfeiter. DO NOT EDIT.
package mocks

import (
	"net"
	"sync"
	"time"

	"github.com/syncthing/syncthing/lib/protocol"
)

type ConnectionInfo struct {
	CryptoStub        func() string
	cryptoMutex       sync.RWMutex
	cryptoArgsForCall []struct {
	}
	cryptoReturns struct {
		result1 string
	}
	cryptoReturnsOnCall map[int]struct {
		result1 string
	}
	EstablishedAtStub        func() time.Time
	establishedAtMutex       sync.RWMutex
	establishedAtArgsForCall []struct {
	}
	establishedAtReturns struct {
		result1 time.Time
	}
	establishedAtReturnsOnCall map[int]struct {
		result1 time.Time
	}
	PriorityStub        func() int
	priorityMutex       sync.RWMutex
	priorityArgsForCall []struct {
	}
	priorityReturns struct {
		result1 int
	}
	priorityReturnsOnCall map[int]struct {
		result1 int
	}
	RemoteAddrStub        func() net.Addr
	remoteAddrMutex       sync.RWMutex
	remoteAddrArgsForCall []struct {
	}
	remoteAddrReturns struct {
		result1 net.Addr
	}
	remoteAddrReturnsOnCall map[int]struct {
		result1 net.Addr
	}
	StringStub        func() string
	stringMutex       sync.RWMutex
	stringArgsForCall []struct {
	}
	stringReturns struct {
		result1 string
	}
	stringReturnsOnCall map[int]struct {
		result1 string
	}
	TransportStub        func() string
	transportMutex       sync.RWMutex
	transportArgsForCall []struct {
	}
	transportReturns struct {
		result1 string
	}
	transportReturnsOnCall map[int]struct {
		result1 string
	}
	TypeStub        func() string
	typeMutex       sync.RWMutex
	typeArgsForCall []struct {
	}
	typeReturns struct {
		result1 string
	}
	typeReturnsOnCall map[int]struct {
		result1 string
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *ConnectionInfo) Crypto() string {
	fake.cryptoMutex.Lock()
	ret, specificReturn := fake.cryptoReturnsOnCall[len(fake.cryptoArgsForCall)]
	fake.cryptoArgsForCall = append(fake.cryptoArgsForCall, struct {
	}{})
	stub := fake.CryptoStub
	fakeReturns := fake.cryptoReturns
	fake.recordInvocation("Crypto", []interface{}{})
	fake.cryptoMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *ConnectionInfo) CryptoCallCount() int {
	fake.cryptoMutex.RLock()
	defer fake.cryptoMutex.RUnlock()
	return len(fake.cryptoArgsForCall)
}

func (fake *ConnectionInfo) CryptoCalls(stub func() string) {
	fake.cryptoMutex.Lock()
	defer fake.cryptoMutex.Unlock()
	fake.CryptoStub = stub
}

func (fake *ConnectionInfo) CryptoReturns(result1 string) {
	fake.cryptoMutex.Lock()
	defer fake.cryptoMutex.Unlock()
	fake.CryptoStub = nil
	fake.cryptoReturns = struct {
		result1 string
	}{result1}
}

func (fake *ConnectionInfo) CryptoReturnsOnCall(i int, result1 string) {
	fake.cryptoMutex.Lock()
	defer fake.cryptoMutex.Unlock()
	fake.CryptoStub = nil
	if fake.cryptoReturnsOnCall == nil {
		fake.cryptoReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.cryptoReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *ConnectionInfo) EstablishedAt() time.Time {
	fake.establishedAtMutex.Lock()
	ret, specificReturn := fake.establishedAtReturnsOnCall[len(fake.establishedAtArgsForCall)]
	fake.establishedAtArgsForCall = append(fake.establishedAtArgsForCall, struct {
	}{})
	stub := fake.EstablishedAtStub
	fakeReturns := fake.establishedAtReturns
	fake.recordInvocation("EstablishedAt", []interface{}{})
	fake.establishedAtMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *ConnectionInfo) EstablishedAtCallCount() int {
	fake.establishedAtMutex.RLock()
	defer fake.establishedAtMutex.RUnlock()
	return len(fake.establishedAtArgsForCall)
}

func (fake *ConnectionInfo) EstablishedAtCalls(stub func() time.Time) {
	fake.establishedAtMutex.Lock()
	defer fake.establishedAtMutex.Unlock()
	fake.EstablishedAtStub = stub
}

func (fake *ConnectionInfo) EstablishedAtReturns(result1 time.Time) {
	fake.establishedAtMutex.Lock()
	defer fake.establishedAtMutex.Unlock()
	fake.EstablishedAtStub = nil
	fake.establishedAtReturns = struct {
		result1 time.Time
	}{result1}
}

func (fake *ConnectionInfo) EstablishedAtReturnsOnCall(i int, result1 time.Time) {
	fake.establishedAtMutex.Lock()
	defer fake.establishedAtMutex.Unlock()
	fake.EstablishedAtStub = nil
	if fake.establishedAtReturnsOnCall == nil {
		fake.establishedAtReturnsOnCall = make(map[int]struct {
			result1 time.Time
		})
	}
	fake.establishedAtReturnsOnCall[i] = struct {
		result1 time.Time
	}{result1}
}

func (fake *ConnectionInfo) Priority() int {
	fake.priorityMutex.Lock()
	ret, specificReturn := fake.priorityReturnsOnCall[len(fake.priorityArgsForCall)]
	fake.priorityArgsForCall = append(fake.priorityArgsForCall, struct {
	}{})
	stub := fake.PriorityStub
	fakeReturns := fake.priorityReturns
	fake.recordInvocation("Priority", []interface{}{})
	fake.priorityMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *ConnectionInfo) PriorityCallCount() int {
	fake.priorityMutex.RLock()
	defer fake.priorityMutex.RUnlock()
	return len(fake.priorityArgsForCall)
}

func (fake *ConnectionInfo) PriorityCalls(stub func() int) {
	fake.priorityMutex.Lock()
	defer fake.priorityMutex.Unlock()
	fake.PriorityStub = stub
}

func (fake *ConnectionInfo) PriorityReturns(result1 int) {
	fake.priorityMutex.Lock()
	defer fake.priorityMutex.Unlock()
	fake.PriorityStub = nil
	fake.priorityReturns = struct {
		result1 int
	}{result1}
}

func (fake *ConnectionInfo) PriorityReturnsOnCall(i int, result1 int) {
	fake.priorityMutex.Lock()
	defer fake.priorityMutex.Unlock()
	fake.PriorityStub = nil
	if fake.priorityReturnsOnCall == nil {
		fake.priorityReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.priorityReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *ConnectionInfo) RemoteAddr() net.Addr {
	fake.remoteAddrMutex.Lock()
	ret, specificReturn := fake.remoteAddrReturnsOnCall[len(fake.remoteAddrArgsForCall)]
	fake.remoteAddrArgsForCall = append(fake.remoteAddrArgsForCall, struct {
	}{})
	stub := fake.RemoteAddrStub
	fakeReturns := fake.remoteAddrReturns
	fake.recordInvocation("RemoteAddr", []interface{}{})
	fake.remoteAddrMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *ConnectionInfo) RemoteAddrCallCount() int {
	fake.remoteAddrMutex.RLock()
	defer fake.remoteAddrMutex.RUnlock()
	return len(fake.remoteAddrArgsForCall)
}

func (fake *ConnectionInfo) RemoteAddrCalls(stub func() net.Addr) {
	fake.remoteAddrMutex.Lock()
	defer fake.remoteAddrMutex.Unlock()
	fake.RemoteAddrStub = stub
}

func (fake *ConnectionInfo) RemoteAddrReturns(result1 net.Addr) {
	fake.remoteAddrMutex.Lock()
	defer fake.remoteAddrMutex.Unlock()
	fake.RemoteAddrStub = nil
	fake.remoteAddrReturns = struct {
		result1 net.Addr
	}{result1}
}

func (fake *ConnectionInfo) RemoteAddrReturnsOnCall(i int, result1 net.Addr) {
	fake.remoteAddrMutex.Lock()
	defer fake.remoteAddrMutex.Unlock()
	fake.RemoteAddrStub = nil
	if fake.remoteAddrReturnsOnCall == nil {
		fake.remoteAddrReturnsOnCall = make(map[int]struct {
			result1 net.Addr
		})
	}
	fake.remoteAddrReturnsOnCall[i] = struct {
		result1 net.Addr
	}{result1}
}

func (fake *ConnectionInfo) String() string {
	fake.stringMutex.Lock()
	ret, specificReturn := fake.stringReturnsOnCall[len(fake.stringArgsForCall)]
	fake.stringArgsForCall = append(fake.stringArgsForCall, struct {
	}{})
	stub := fake.StringStub
	fakeReturns := fake.stringReturns
	fake.recordInvocation("String", []interface{}{})
	fake.stringMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *ConnectionInfo) StringCallCount() int {
	fake.stringMutex.RLock()
	defer fake.stringMutex.RUnlock()
	return len(fake.stringArgsForCall)
}

func (fake *ConnectionInfo) StringCalls(stub func() string) {
	fake.stringMutex.Lock()
	defer fake.stringMutex.Unlock()
	fake.StringStub = stub
}

func (fake *ConnectionInfo) StringReturns(result1 string) {
	fake.stringMutex.Lock()
	defer fake.stringMutex.Unlock()
	fake.StringStub = nil
	fake.stringReturns = struct {
		result1 string
	}{result1}
}

func (fake *ConnectionInfo) StringReturnsOnCall(i int, result1 string) {
	fake.stringMutex.Lock()
	defer fake.stringMutex.Unlock()
	fake.StringStub = nil
	if fake.stringReturnsOnCall == nil {
		fake.stringReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.stringReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *ConnectionInfo) Transport() string {
	fake.transportMutex.Lock()
	ret, specificReturn := fake.transportReturnsOnCall[len(fake.transportArgsForCall)]
	fake.transportArgsForCall = append(fake.transportArgsForCall, struct {
	}{})
	stub := fake.TransportStub
	fakeReturns := fake.transportReturns
	fake.recordInvocation("Transport", []interface{}{})
	fake.transportMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *ConnectionInfo) TransportCallCount() int {
	fake.transportMutex.RLock()
	defer fake.transportMutex.RUnlock()
	return len(fake.transportArgsForCall)
}

func (fake *ConnectionInfo) TransportCalls(stub func() string) {
	fake.transportMutex.Lock()
	defer fake.transportMutex.Unlock()
	fake.TransportStub = stub
}

func (fake *ConnectionInfo) TransportReturns(result1 string) {
	fake.transportMutex.Lock()
	defer fake.transportMutex.Unlock()
	fake.TransportStub = nil
	fake.transportReturns = struct {
		result1 string
	}{result1}
}

func (fake *ConnectionInfo) TransportReturnsOnCall(i int, result1 string) {
	fake.transportMutex.Lock()
	defer fake.transportMutex.Unlock()
	fake.TransportStub = nil
	if fake.transportReturnsOnCall == nil {
		fake.transportReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.transportReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *ConnectionInfo) Type() string {
	fake.typeMutex.Lock()
	ret, specificReturn := fake.typeReturnsOnCall[len(fake.typeArgsForCall)]
	fake.typeArgsForCall = append(fake.typeArgsForCall, struct {
	}{})
	stub := fake.TypeStub
	fakeReturns := fake.typeReturns
	fake.recordInvocation("Type", []interface{}{})
	fake.typeMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *ConnectionInfo) TypeCallCount() int {
	fake.typeMutex.RLock()
	defer fake.typeMutex.RUnlock()
	return len(fake.typeArgsForCall)
}

func (fake *ConnectionInfo) TypeCalls(stub func() string) {
	fake.typeMutex.Lock()
	defer fake.typeMutex.Unlock()
	fake.TypeStub = stub
}

func (fake *ConnectionInfo) TypeReturns(result1 string) {
	fake.typeMutex.Lock()
	defer fake.typeMutex.Unlock()
	fake.TypeStub = nil
	fake.typeReturns = struct {
		result1 string
	}{result1}
}

func (fake *ConnectionInfo) TypeReturnsOnCall(i int, result1 string) {
	fake.typeMutex.Lock()
	defer fake.typeMutex.Unlock()
	fake.TypeStub = nil
	if fake.typeReturnsOnCall == nil {
		fake.typeReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.typeReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *ConnectionInfo) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.cryptoMutex.RLock()
	defer fake.cryptoMutex.RUnlock()
	fake.establishedAtMutex.RLock()
	defer fake.establishedAtMutex.RUnlock()
	fake.priorityMutex.RLock()
	defer fake.priorityMutex.RUnlock()
	fake.remoteAddrMutex.RLock()
	defer fake.remoteAddrMutex.RUnlock()
	fake.stringMutex.RLock()
	defer fake.stringMutex.RUnlock()
	fake.transportMutex.RLock()
	defer fake.transportMutex.RUnlock()
	fake.typeMutex.RLock()
	defer fake.typeMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *ConnectionInfo) recordInvocation(key string, args []interface{}) {
	fake.invocationsMutex.Lock()
	defer fake.invocationsMutex.Unlock()
	if fake.invocations == nil {
		fake.invocations = map[string][][]interface{}{}
	}
	if fake.invocations[key] == nil {
		fake.invocations[key] = [][]interface{}{}
	}
	fake.invocations[key] = append(fake.invocations[key], args)
}

var _ protocol.ConnectionInfo = new(ConnectionInfo)
