github.com/pf-qiu/concourse/v6@v6.7.3-0.20201207032516-1f455d73275f/atc/metric/emitter/emitterfakes/fake_prometheus_garbage_collectable.go

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

import (
	"sync"

	"github.com/pf-qiu/concourse/v6/atc/metric/emitter"
	"github.com/prometheus/client_golang/prometheus"
)

type FakePrometheusGarbageCollectable struct {
	WorkerContainersStub        func() *prometheus.GaugeVec
	workerContainersMutex       sync.RWMutex
	workerContainersArgsForCall []struct {
	}
	workerContainersReturns struct {
		result1 *prometheus.GaugeVec
	}
	workerContainersReturnsOnCall map[int]struct {
		result1 *prometheus.GaugeVec
	}
	WorkerContainersLabelsStub        func() map[string]map[string]prometheus.Labels
	workerContainersLabelsMutex       sync.RWMutex
	workerContainersLabelsArgsForCall []struct {
	}
	workerContainersLabelsReturns struct {
		result1 map[string]map[string]prometheus.Labels
	}
	workerContainersLabelsReturnsOnCall map[int]struct {
		result1 map[string]map[string]prometheus.Labels
	}
	WorkerTasksStub        func() *prometheus.GaugeVec
	workerTasksMutex       sync.RWMutex
	workerTasksArgsForCall []struct {
	}
	workerTasksReturns struct {
		result1 *prometheus.GaugeVec
	}
	workerTasksReturnsOnCall map[int]struct {
		result1 *prometheus.GaugeVec
	}
	WorkerTasksLabelsStub        func() map[string]map[string]prometheus.Labels
	workerTasksLabelsMutex       sync.RWMutex
	workerTasksLabelsArgsForCall []struct {
	}
	workerTasksLabelsReturns struct {
		result1 map[string]map[string]prometheus.Labels
	}
	workerTasksLabelsReturnsOnCall map[int]struct {
		result1 map[string]map[string]prometheus.Labels
	}
	WorkerVolumesStub        func() *prometheus.GaugeVec
	workerVolumesMutex       sync.RWMutex
	workerVolumesArgsForCall []struct {
	}
	workerVolumesReturns struct {
		result1 *prometheus.GaugeVec
	}
	workerVolumesReturnsOnCall map[int]struct {
		result1 *prometheus.GaugeVec
	}
	WorkerVolumesLabelsStub        func() map[string]map[string]prometheus.Labels
	workerVolumesLabelsMutex       sync.RWMutex
	workerVolumesLabelsArgsForCall []struct {
	}
	workerVolumesLabelsReturns struct {
		result1 map[string]map[string]prometheus.Labels
	}
	workerVolumesLabelsReturnsOnCall map[int]struct {
		result1 map[string]map[string]prometheus.Labels
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakePrometheusGarbageCollectable) WorkerContainers() *prometheus.GaugeVec {
	fake.workerContainersMutex.Lock()
	ret, specificReturn := fake.workerContainersReturnsOnCall[len(fake.workerContainersArgsForCall)]
	fake.workerContainersArgsForCall = append(fake.workerContainersArgsForCall, struct {
	}{})
	fake.recordInvocation("WorkerContainers", []interface{}{})
	fake.workerContainersMutex.Unlock()
	if fake.WorkerContainersStub != nil {
		return fake.WorkerContainersStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.workerContainersReturns
	return fakeReturns.result1
}

func (fake *FakePrometheusGarbageCollectable) WorkerContainersCallCount() int {
	fake.workerContainersMutex.RLock()
	defer fake.workerContainersMutex.RUnlock()
	return len(fake.workerContainersArgsForCall)
}

func (fake *FakePrometheusGarbageCollectable) WorkerContainersCalls(stub func() *prometheus.GaugeVec) {
	fake.workerContainersMutex.Lock()
	defer fake.workerContainersMutex.Unlock()
	fake.WorkerContainersStub = stub
}

func (fake *FakePrometheusGarbageCollectable) WorkerContainersReturns(result1 *prometheus.GaugeVec) {
	fake.workerContainersMutex.Lock()
	defer fake.workerContainersMutex.Unlock()
	fake.WorkerContainersStub = nil
	fake.workerContainersReturns = struct {
		result1 *prometheus.GaugeVec
	}{result1}
}

func (fake *FakePrometheusGarbageCollectable) WorkerContainersReturnsOnCall(i int, result1 *prometheus.GaugeVec) {
	fake.workerContainersMutex.Lock()
	defer fake.workerContainersMutex.Unlock()
	fake.WorkerContainersStub = nil
	if fake.workerContainersReturnsOnCall == nil {
		fake.workerContainersReturnsOnCall = make(map[int]struct {
			result1 *prometheus.GaugeVec
		})
	}
	fake.workerContainersReturnsOnCall[i] = struct {
		result1 *prometheus.GaugeVec
	}{result1}
}

func (fake *FakePrometheusGarbageCollectable) WorkerContainersLabels() map[string]map[string]prometheus.Labels {
	fake.workerContainersLabelsMutex.Lock()
	ret, specificReturn := fake.workerContainersLabelsReturnsOnCall[len(fake.workerContainersLabelsArgsForCall)]
	fake.workerContainersLabelsArgsForCall = append(fake.workerContainersLabelsArgsForCall, struct {
	}{})
	fake.recordInvocation("WorkerContainersLabels", []interface{}{})
	fake.workerContainersLabelsMutex.Unlock()
	if fake.WorkerContainersLabelsStub != nil {
		return fake.WorkerContainersLabelsStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.workerContainersLabelsReturns
	return fakeReturns.result1
}

func (fake *FakePrometheusGarbageCollectable) WorkerContainersLabelsCallCount() int {
	fake.workerContainersLabelsMutex.RLock()
	defer fake.workerContainersLabelsMutex.RUnlock()
	return len(fake.workerContainersLabelsArgsForCall)
}

func (fake *FakePrometheusGarbageCollectable) WorkerContainersLabelsCalls(stub func() map[string]map[string]prometheus.Labels) {
	fake.workerContainersLabelsMutex.Lock()
	defer fake.workerContainersLabelsMutex.Unlock()
	fake.WorkerContainersLabelsStub = stub
}

func (fake *FakePrometheusGarbageCollectable) WorkerContainersLabelsReturns(result1 map[string]map[string]prometheus.Labels) {
	fake.workerContainersLabelsMutex.Lock()
	defer fake.workerContainersLabelsMutex.Unlock()
	fake.WorkerContainersLabelsStub = nil
	fake.workerContainersLabelsReturns = struct {
		result1 map[string]map[string]prometheus.Labels
	}{result1}
}

func (fake *FakePrometheusGarbageCollectable) WorkerContainersLabelsReturnsOnCall(i int, result1 map[string]map[string]prometheus.Labels) {
	fake.workerContainersLabelsMutex.Lock()
	defer fake.workerContainersLabelsMutex.Unlock()
	fake.WorkerContainersLabelsStub = nil
	if fake.workerContainersLabelsReturnsOnCall == nil {
		fake.workerContainersLabelsReturnsOnCall = make(map[int]struct {
			result1 map[string]map[string]prometheus.Labels
		})
	}
	fake.workerContainersLabelsReturnsOnCall[i] = struct {
		result1 map[string]map[string]prometheus.Labels
	}{result1}
}

func (fake *FakePrometheusGarbageCollectable) WorkerTasks() *prometheus.GaugeVec {
	fake.workerTasksMutex.Lock()
	ret, specificReturn := fake.workerTasksReturnsOnCall[len(fake.workerTasksArgsForCall)]
	fake.workerTasksArgsForCall = append(fake.workerTasksArgsForCall, struct {
	}{})
	fake.recordInvocation("WorkerTasks", []interface{}{})
	fake.workerTasksMutex.Unlock()
	if fake.WorkerTasksStub != nil {
		return fake.WorkerTasksStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.workerTasksReturns
	return fakeReturns.result1
}

func (fake *FakePrometheusGarbageCollectable) WorkerTasksCallCount() int {
	fake.workerTasksMutex.RLock()
	defer fake.workerTasksMutex.RUnlock()
	return len(fake.workerTasksArgsForCall)
}

func (fake *FakePrometheusGarbageCollectable) WorkerTasksCalls(stub func() *prometheus.GaugeVec) {
	fake.workerTasksMutex.Lock()
	defer fake.workerTasksMutex.Unlock()
	fake.WorkerTasksStub = stub
}

func (fake *FakePrometheusGarbageCollectable) WorkerTasksReturns(result1 *prometheus.GaugeVec) {
	fake.workerTasksMutex.Lock()
	defer fake.workerTasksMutex.Unlock()
	fake.WorkerTasksStub = nil
	fake.workerTasksReturns = struct {
		result1 *prometheus.GaugeVec
	}{result1}
}

func (fake *FakePrometheusGarbageCollectable) WorkerTasksReturnsOnCall(i int, result1 *prometheus.GaugeVec) {
	fake.workerTasksMutex.Lock()
	defer fake.workerTasksMutex.Unlock()
	fake.WorkerTasksStub = nil
	if fake.workerTasksReturnsOnCall == nil {
		fake.workerTasksReturnsOnCall = make(map[int]struct {
			result1 *prometheus.GaugeVec
		})
	}
	fake.workerTasksReturnsOnCall[i] = struct {
		result1 *prometheus.GaugeVec
	}{result1}
}

func (fake *FakePrometheusGarbageCollectable) WorkerTasksLabels() map[string]map[string]prometheus.Labels {
	fake.workerTasksLabelsMutex.Lock()
	ret, specificReturn := fake.workerTasksLabelsReturnsOnCall[len(fake.workerTasksLabelsArgsForCall)]
	fake.workerTasksLabelsArgsForCall = append(fake.workerTasksLabelsArgsForCall, struct {
	}{})
	fake.recordInvocation("WorkerTasksLabels", []interface{}{})
	fake.workerTasksLabelsMutex.Unlock()
	if fake.WorkerTasksLabelsStub != nil {
		return fake.WorkerTasksLabelsStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.workerTasksLabelsReturns
	return fakeReturns.result1
}

func (fake *FakePrometheusGarbageCollectable) WorkerTasksLabelsCallCount() int {
	fake.workerTasksLabelsMutex.RLock()
	defer fake.workerTasksLabelsMutex.RUnlock()
	return len(fake.workerTasksLabelsArgsForCall)
}

func (fake *FakePrometheusGarbageCollectable) WorkerTasksLabelsCalls(stub func() map[string]map[string]prometheus.Labels) {
	fake.workerTasksLabelsMutex.Lock()
	defer fake.workerTasksLabelsMutex.Unlock()
	fake.WorkerTasksLabelsStub = stub
}

func (fake *FakePrometheusGarbageCollectable) WorkerTasksLabelsReturns(result1 map[string]map[string]prometheus.Labels) {
	fake.workerTasksLabelsMutex.Lock()
	defer fake.workerTasksLabelsMutex.Unlock()
	fake.WorkerTasksLabelsStub = nil
	fake.workerTasksLabelsReturns = struct {
		result1 map[string]map[string]prometheus.Labels
	}{result1}
}

func (fake *FakePrometheusGarbageCollectable) WorkerTasksLabelsReturnsOnCall(i int, result1 map[string]map[string]prometheus.Labels) {
	fake.workerTasksLabelsMutex.Lock()
	defer fake.workerTasksLabelsMutex.Unlock()
	fake.WorkerTasksLabelsStub = nil
	if fake.workerTasksLabelsReturnsOnCall == nil {
		fake.workerTasksLabelsReturnsOnCall = make(map[int]struct {
			result1 map[string]map[string]prometheus.Labels
		})
	}
	fake.workerTasksLabelsReturnsOnCall[i] = struct {
		result1 map[string]map[string]prometheus.Labels
	}{result1}
}

func (fake *FakePrometheusGarbageCollectable) WorkerVolumes() *prometheus.GaugeVec {
	fake.workerVolumesMutex.Lock()
	ret, specificReturn := fake.workerVolumesReturnsOnCall[len(fake.workerVolumesArgsForCall)]
	fake.workerVolumesArgsForCall = append(fake.workerVolumesArgsForCall, struct {
	}{})
	fake.recordInvocation("WorkerVolumes", []interface{}{})
	fake.workerVolumesMutex.Unlock()
	if fake.WorkerVolumesStub != nil {
		return fake.WorkerVolumesStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.workerVolumesReturns
	return fakeReturns.result1
}

func (fake *FakePrometheusGarbageCollectable) WorkerVolumesCallCount() int {
	fake.workerVolumesMutex.RLock()
	defer fake.workerVolumesMutex.RUnlock()
	return len(fake.workerVolumesArgsForCall)
}

func (fake *FakePrometheusGarbageCollectable) WorkerVolumesCalls(stub func() *prometheus.GaugeVec) {
	fake.workerVolumesMutex.Lock()
	defer fake.workerVolumesMutex.Unlock()
	fake.WorkerVolumesStub = stub
}

func (fake *FakePrometheusGarbageCollectable) WorkerVolumesReturns(result1 *prometheus.GaugeVec) {
	fake.workerVolumesMutex.Lock()
	defer fake.workerVolumesMutex.Unlock()
	fake.WorkerVolumesStub = nil
	fake.workerVolumesReturns = struct {
		result1 *prometheus.GaugeVec
	}{result1}
}

func (fake *FakePrometheusGarbageCollectable) WorkerVolumesReturnsOnCall(i int, result1 *prometheus.GaugeVec) {
	fake.workerVolumesMutex.Lock()
	defer fake.workerVolumesMutex.Unlock()
	fake.WorkerVolumesStub = nil
	if fake.workerVolumesReturnsOnCall == nil {
		fake.workerVolumesReturnsOnCall = make(map[int]struct {
			result1 *prometheus.GaugeVec
		})
	}
	fake.workerVolumesReturnsOnCall[i] = struct {
		result1 *prometheus.GaugeVec
	}{result1}
}

func (fake *FakePrometheusGarbageCollectable) WorkerVolumesLabels() map[string]map[string]prometheus.Labels {
	fake.workerVolumesLabelsMutex.Lock()
	ret, specificReturn := fake.workerVolumesLabelsReturnsOnCall[len(fake.workerVolumesLabelsArgsForCall)]
	fake.workerVolumesLabelsArgsForCall = append(fake.workerVolumesLabelsArgsForCall, struct {
	}{})
	fake.recordInvocation("WorkerVolumesLabels", []interface{}{})
	fake.workerVolumesLabelsMutex.Unlock()
	if fake.WorkerVolumesLabelsStub != nil {
		return fake.WorkerVolumesLabelsStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.workerVolumesLabelsReturns
	return fakeReturns.result1
}

func (fake *FakePrometheusGarbageCollectable) WorkerVolumesLabelsCallCount() int {
	fake.workerVolumesLabelsMutex.RLock()
	defer fake.workerVolumesLabelsMutex.RUnlock()
	return len(fake.workerVolumesLabelsArgsForCall)
}

func (fake *FakePrometheusGarbageCollectable) WorkerVolumesLabelsCalls(stub func() map[string]map[string]prometheus.Labels) {
	fake.workerVolumesLabelsMutex.Lock()
	defer fake.workerVolumesLabelsMutex.Unlock()
	fake.WorkerVolumesLabelsStub = stub
}

func (fake *FakePrometheusGarbageCollectable) WorkerVolumesLabelsReturns(result1 map[string]map[string]prometheus.Labels) {
	fake.workerVolumesLabelsMutex.Lock()
	defer fake.workerVolumesLabelsMutex.Unlock()
	fake.WorkerVolumesLabelsStub = nil
	fake.workerVolumesLabelsReturns = struct {
		result1 map[string]map[string]prometheus.Labels
	}{result1}
}

func (fake *FakePrometheusGarbageCollectable) WorkerVolumesLabelsReturnsOnCall(i int, result1 map[string]map[string]prometheus.Labels) {
	fake.workerVolumesLabelsMutex.Lock()
	defer fake.workerVolumesLabelsMutex.Unlock()
	fake.WorkerVolumesLabelsStub = nil
	if fake.workerVolumesLabelsReturnsOnCall == nil {
		fake.workerVolumesLabelsReturnsOnCall = make(map[int]struct {
			result1 map[string]map[string]prometheus.Labels
		})
	}
	fake.workerVolumesLabelsReturnsOnCall[i] = struct {
		result1 map[string]map[string]prometheus.Labels
	}{result1}
}

func (fake *FakePrometheusGarbageCollectable) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.workerContainersMutex.RLock()
	defer fake.workerContainersMutex.RUnlock()
	fake.workerContainersLabelsMutex.RLock()
	defer fake.workerContainersLabelsMutex.RUnlock()
	fake.workerTasksMutex.RLock()
	defer fake.workerTasksMutex.RUnlock()
	fake.workerTasksLabelsMutex.RLock()
	defer fake.workerTasksLabelsMutex.RUnlock()
	fake.workerVolumesMutex.RLock()
	defer fake.workerVolumesMutex.RUnlock()
	fake.workerVolumesLabelsMutex.RLock()
	defer fake.workerVolumesLabelsMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakePrometheusGarbageCollectable) 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 _ emitter.PrometheusGarbageCollectable = new(FakePrometheusGarbageCollectable)