syncthing/lib/discover/mocks/manager.go

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

import (
	"context"
	"sync"

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

type Manager struct {
	CacheStub        func() map[protocol.DeviceID]discover.CacheEntry
	cacheMutex       sync.RWMutex
	cacheArgsForCall []struct {
	}
	cacheReturns struct {
		result1 map[protocol.DeviceID]discover.CacheEntry
	}
	cacheReturnsOnCall map[int]struct {
		result1 map[protocol.DeviceID]discover.CacheEntry
	}
	ChildErrorsStub        func() map[string]error
	childErrorsMutex       sync.RWMutex
	childErrorsArgsForCall []struct {
	}
	childErrorsReturns struct {
		result1 map[string]error
	}
	childErrorsReturnsOnCall map[int]struct {
		result1 map[string]error
	}
	ErrorStub        func() error
	errorMutex       sync.RWMutex
	errorArgsForCall []struct {
	}
	errorReturns struct {
		result1 error
	}
	errorReturnsOnCall map[int]struct {
		result1 error
	}
	LookupStub        func(context.Context, protocol.DeviceID) ([]string, error)
	lookupMutex       sync.RWMutex
	lookupArgsForCall []struct {
		arg1 context.Context
		arg2 protocol.DeviceID
	}
	lookupReturns struct {
		result1 []string
		result2 error
	}
	lookupReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	ServeStub        func(context.Context) error
	serveMutex       sync.RWMutex
	serveArgsForCall []struct {
		arg1 context.Context
	}
	serveReturns struct {
		result1 error
	}
	serveReturnsOnCall map[int]struct {
		result1 error
	}
	StringStub        func() string
	stringMutex       sync.RWMutex
	stringArgsForCall []struct {
	}
	stringReturns struct {
		result1 string
	}
	stringReturnsOnCall map[int]struct {
		result1 string
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *Manager) Cache() map[protocol.DeviceID]discover.CacheEntry {
	fake.cacheMutex.Lock()
	ret, specificReturn := fake.cacheReturnsOnCall[len(fake.cacheArgsForCall)]
	fake.cacheArgsForCall = append(fake.cacheArgsForCall, struct {
	}{})
	stub := fake.CacheStub
	fakeReturns := fake.cacheReturns
	fake.recordInvocation("Cache", []interface{}{})
	fake.cacheMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *Manager) CacheCallCount() int {
	fake.cacheMutex.RLock()
	defer fake.cacheMutex.RUnlock()
	return len(fake.cacheArgsForCall)
}

func (fake *Manager) CacheCalls(stub func() map[protocol.DeviceID]discover.CacheEntry) {
	fake.cacheMutex.Lock()
	defer fake.cacheMutex.Unlock()
	fake.CacheStub = stub
}

func (fake *Manager) CacheReturns(result1 map[protocol.DeviceID]discover.CacheEntry) {
	fake.cacheMutex.Lock()
	defer fake.cacheMutex.Unlock()
	fake.CacheStub = nil
	fake.cacheReturns = struct {
		result1 map[protocol.DeviceID]discover.CacheEntry
	}{result1}
}

func (fake *Manager) CacheReturnsOnCall(i int, result1 map[protocol.DeviceID]discover.CacheEntry) {
	fake.cacheMutex.Lock()
	defer fake.cacheMutex.Unlock()
	fake.CacheStub = nil
	if fake.cacheReturnsOnCall == nil {
		fake.cacheReturnsOnCall = make(map[int]struct {
			result1 map[protocol.DeviceID]discover.CacheEntry
		})
	}
	fake.cacheReturnsOnCall[i] = struct {
		result1 map[protocol.DeviceID]discover.CacheEntry
	}{result1}
}

func (fake *Manager) ChildErrors() map[string]error {
	fake.childErrorsMutex.Lock()
	ret, specificReturn := fake.childErrorsReturnsOnCall[len(fake.childErrorsArgsForCall)]
	fake.childErrorsArgsForCall = append(fake.childErrorsArgsForCall, struct {
	}{})
	stub := fake.ChildErrorsStub
	fakeReturns := fake.childErrorsReturns
	fake.recordInvocation("ChildErrors", []interface{}{})
	fake.childErrorsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *Manager) ChildErrorsCallCount() int {
	fake.childErrorsMutex.RLock()
	defer fake.childErrorsMutex.RUnlock()
	return len(fake.childErrorsArgsForCall)
}

func (fake *Manager) ChildErrorsCalls(stub func() map[string]error) {
	fake.childErrorsMutex.Lock()
	defer fake.childErrorsMutex.Unlock()
	fake.ChildErrorsStub = stub
}

func (fake *Manager) ChildErrorsReturns(result1 map[string]error) {
	fake.childErrorsMutex.Lock()
	defer fake.childErrorsMutex.Unlock()
	fake.ChildErrorsStub = nil
	fake.childErrorsReturns = struct {
		result1 map[string]error
	}{result1}
}

func (fake *Manager) ChildErrorsReturnsOnCall(i int, result1 map[string]error) {
	fake.childErrorsMutex.Lock()
	defer fake.childErrorsMutex.Unlock()
	fake.ChildErrorsStub = nil
	if fake.childErrorsReturnsOnCall == nil {
		fake.childErrorsReturnsOnCall = make(map[int]struct {
			result1 map[string]error
		})
	}
	fake.childErrorsReturnsOnCall[i] = struct {
		result1 map[string]error
	}{result1}
}

func (fake *Manager) Error() error {
	fake.errorMutex.Lock()
	ret, specificReturn := fake.errorReturnsOnCall[len(fake.errorArgsForCall)]
	fake.errorArgsForCall = append(fake.errorArgsForCall, struct {
	}{})
	stub := fake.ErrorStub
	fakeReturns := fake.errorReturns
	fake.recordInvocation("Error", []interface{}{})
	fake.errorMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *Manager) ErrorCallCount() int {
	fake.errorMutex.RLock()
	defer fake.errorMutex.RUnlock()
	return len(fake.errorArgsForCall)
}

func (fake *Manager) ErrorCalls(stub func() error) {
	fake.errorMutex.Lock()
	defer fake.errorMutex.Unlock()
	fake.ErrorStub = stub
}

func (fake *Manager) ErrorReturns(result1 error) {
	fake.errorMutex.Lock()
	defer fake.errorMutex.Unlock()
	fake.ErrorStub = nil
	fake.errorReturns = struct {
		result1 error
	}{result1}
}

func (fake *Manager) ErrorReturnsOnCall(i int, result1 error) {
	fake.errorMutex.Lock()
	defer fake.errorMutex.Unlock()
	fake.ErrorStub = nil
	if fake.errorReturnsOnCall == nil {
		fake.errorReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.errorReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *Manager) Lookup(arg1 context.Context, arg2 protocol.DeviceID) ([]string, error) {
	fake.lookupMutex.Lock()
	ret, specificReturn := fake.lookupReturnsOnCall[len(fake.lookupArgsForCall)]
	fake.lookupArgsForCall = append(fake.lookupArgsForCall, struct {
		arg1 context.Context
		arg2 protocol.DeviceID
	}{arg1, arg2})
	stub := fake.LookupStub
	fakeReturns := fake.lookupReturns
	fake.recordInvocation("Lookup", []interface{}{arg1, arg2})
	fake.lookupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *Manager) LookupCallCount() int {
	fake.lookupMutex.RLock()
	defer fake.lookupMutex.RUnlock()
	return len(fake.lookupArgsForCall)
}

func (fake *Manager) LookupCalls(stub func(context.Context, protocol.DeviceID) ([]string, error)) {
	fake.lookupMutex.Lock()
	defer fake.lookupMutex.Unlock()
	fake.LookupStub = stub
}

func (fake *Manager) LookupArgsForCall(i int) (context.Context, protocol.DeviceID) {
	fake.lookupMutex.RLock()
	defer fake.lookupMutex.RUnlock()
	argsForCall := fake.lookupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *Manager) LookupReturns(result1 []string, result2 error) {
	fake.lookupMutex.Lock()
	defer fake.lookupMutex.Unlock()
	fake.LookupStub = nil
	fake.lookupReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *Manager) LookupReturnsOnCall(i int, result1 []string, result2 error) {
	fake.lookupMutex.Lock()
	defer fake.lookupMutex.Unlock()
	fake.LookupStub = nil
	if fake.lookupReturnsOnCall == nil {
		fake.lookupReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.lookupReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *Manager) Serve(arg1 context.Context) error {
	fake.serveMutex.Lock()
	ret, specificReturn := fake.serveReturnsOnCall[len(fake.serveArgsForCall)]
	fake.serveArgsForCall = append(fake.serveArgsForCall, struct {
		arg1 context.Context
	}{arg1})
	stub := fake.ServeStub
	fakeReturns := fake.serveReturns
	fake.recordInvocation("Serve", []interface{}{arg1})
	fake.serveMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *Manager) ServeCallCount() int {
	fake.serveMutex.RLock()
	defer fake.serveMutex.RUnlock()
	return len(fake.serveArgsForCall)
}

func (fake *Manager) ServeCalls(stub func(context.Context) error) {
	fake.serveMutex.Lock()
	defer fake.serveMutex.Unlock()
	fake.ServeStub = stub
}

func (fake *Manager) ServeArgsForCall(i int) context.Context {
	fake.serveMutex.RLock()
	defer fake.serveMutex.RUnlock()
	argsForCall := fake.serveArgsForCall[i]
	return argsForCall.arg1
}

func (fake *Manager) ServeReturns(result1 error) {
	fake.serveMutex.Lock()
	defer fake.serveMutex.Unlock()
	fake.ServeStub = nil
	fake.serveReturns = struct {
		result1 error
	}{result1}
}

func (fake *Manager) ServeReturnsOnCall(i int, result1 error) {
	fake.serveMutex.Lock()
	defer fake.serveMutex.Unlock()
	fake.ServeStub = nil
	if fake.serveReturnsOnCall == nil {
		fake.serveReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.serveReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *Manager) 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 *Manager) StringCallCount() int {
	fake.stringMutex.RLock()
	defer fake.stringMutex.RUnlock()
	return len(fake.stringArgsForCall)
}

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

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

func (fake *Manager) 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 *Manager) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *Manager) 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 _ discover.Manager = new(Manager)