fake_task_stat_metron_notifier.go

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

import (
	"os"
	"sync"
	"time"

	"code.cloudfoundry.org/bbs/metrics"
)

type FakeTaskStatMetronNotifier struct {
	RecordConvergenceDurationStub        func(time.Duration)
	recordConvergenceDurationMutex       sync.RWMutex
	recordConvergenceDurationArgsForCall []struct {
		arg1 time.Duration
	}
	RecordTaskCountsStub        func(int, int, int, int, uint64, uint64)
	recordTaskCountsMutex       sync.RWMutex
	recordTaskCountsArgsForCall []struct {
		arg1 int
		arg2 int
		arg3 int
		arg4 int
		arg5 uint64
		arg6 uint64
	}
	RecordTaskFailedStub        func(string)
	recordTaskFailedMutex       sync.RWMutex
	recordTaskFailedArgsForCall []struct {
		arg1 string
	}
	RecordTaskStartedStub        func(string)
	recordTaskStartedMutex       sync.RWMutex
	recordTaskStartedArgsForCall []struct {
		arg1 string
	}
	RecordTaskSucceededStub        func(string)
	recordTaskSucceededMutex       sync.RWMutex
	recordTaskSucceededArgsForCall []struct {
		arg1 string
	}
	RunStub        func(<-chan os.Signal, chan<- struct{}) error
	runMutex       sync.RWMutex
	runArgsForCall []struct {
		arg1 <-chan os.Signal
		arg2 chan<- struct{}
	}
	runReturns struct {
		result1 error
	}
	runReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeTaskStatMetronNotifier) RecordConvergenceDuration(arg1 time.Duration) {
	fake.recordConvergenceDurationMutex.Lock()
	fake.recordConvergenceDurationArgsForCall = append(fake.recordConvergenceDurationArgsForCall, struct {
		arg1 time.Duration
	}{arg1})
	stub := fake.RecordConvergenceDurationStub
	fake.recordInvocation("RecordConvergenceDuration", []interface{}{arg1})
	fake.recordConvergenceDurationMutex.Unlock()
	if stub != nil {
		fake.RecordConvergenceDurationStub(arg1)
	}
}

func (fake *FakeTaskStatMetronNotifier) RecordConvergenceDurationCallCount() int {
	fake.recordConvergenceDurationMutex.RLock()
	defer fake.recordConvergenceDurationMutex.RUnlock()
	return len(fake.recordConvergenceDurationArgsForCall)
}

func (fake *FakeTaskStatMetronNotifier) RecordConvergenceDurationCalls(stub func(time.Duration)) {
	fake.recordConvergenceDurationMutex.Lock()
	defer fake.recordConvergenceDurationMutex.Unlock()
	fake.RecordConvergenceDurationStub = stub
}

func (fake *FakeTaskStatMetronNotifier) RecordConvergenceDurationArgsForCall(i int) time.Duration {
	fake.recordConvergenceDurationMutex.RLock()
	defer fake.recordConvergenceDurationMutex.RUnlock()
	argsForCall := fake.recordConvergenceDurationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskCounts(arg1 int, arg2 int, arg3 int, arg4 int, arg5 uint64, arg6 uint64) {
	fake.recordTaskCountsMutex.Lock()
	fake.recordTaskCountsArgsForCall = append(fake.recordTaskCountsArgsForCall, struct {
		arg1 int
		arg2 int
		arg3 int
		arg4 int
		arg5 uint64
		arg6 uint64
	}{arg1, arg2, arg3, arg4, arg5, arg6})
	stub := fake.RecordTaskCountsStub
	fake.recordInvocation("RecordTaskCounts", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6})
	fake.recordTaskCountsMutex.Unlock()
	if stub != nil {
		fake.RecordTaskCountsStub(arg1, arg2, arg3, arg4, arg5, arg6)
	}
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskCountsCallCount() int {
	fake.recordTaskCountsMutex.RLock()
	defer fake.recordTaskCountsMutex.RUnlock()
	return len(fake.recordTaskCountsArgsForCall)
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskCountsCalls(stub func(int, int, int, int, uint64, uint64)) {
	fake.recordTaskCountsMutex.Lock()
	defer fake.recordTaskCountsMutex.Unlock()
	fake.RecordTaskCountsStub = stub
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskCountsArgsForCall(i int) (int, int, int, int, uint64, uint64) {
	fake.recordTaskCountsMutex.RLock()
	defer fake.recordTaskCountsMutex.RUnlock()
	argsForCall := fake.recordTaskCountsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskFailed(arg1 string) {
	fake.recordTaskFailedMutex.Lock()
	fake.recordTaskFailedArgsForCall = append(fake.recordTaskFailedArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.RecordTaskFailedStub
	fake.recordInvocation("RecordTaskFailed", []interface{}{arg1})
	fake.recordTaskFailedMutex.Unlock()
	if stub != nil {
		fake.RecordTaskFailedStub(arg1)
	}
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskFailedCallCount() int {
	fake.recordTaskFailedMutex.RLock()
	defer fake.recordTaskFailedMutex.RUnlock()
	return len(fake.recordTaskFailedArgsForCall)
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskFailedCalls(stub func(string)) {
	fake.recordTaskFailedMutex.Lock()
	defer fake.recordTaskFailedMutex.Unlock()
	fake.RecordTaskFailedStub = stub
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskFailedArgsForCall(i int) string {
	fake.recordTaskFailedMutex.RLock()
	defer fake.recordTaskFailedMutex.RUnlock()
	argsForCall := fake.recordTaskFailedArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskStarted(arg1 string) {
	fake.recordTaskStartedMutex.Lock()
	fake.recordTaskStartedArgsForCall = append(fake.recordTaskStartedArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.RecordTaskStartedStub
	fake.recordInvocation("RecordTaskStarted", []interface{}{arg1})
	fake.recordTaskStartedMutex.Unlock()
	if stub != nil {
		fake.RecordTaskStartedStub(arg1)
	}
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskStartedCallCount() int {
	fake.recordTaskStartedMutex.RLock()
	defer fake.recordTaskStartedMutex.RUnlock()
	return len(fake.recordTaskStartedArgsForCall)
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskStartedCalls(stub func(string)) {
	fake.recordTaskStartedMutex.Lock()
	defer fake.recordTaskStartedMutex.Unlock()
	fake.RecordTaskStartedStub = stub
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskStartedArgsForCall(i int) string {
	fake.recordTaskStartedMutex.RLock()
	defer fake.recordTaskStartedMutex.RUnlock()
	argsForCall := fake.recordTaskStartedArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskSucceeded(arg1 string) {
	fake.recordTaskSucceededMutex.Lock()
	fake.recordTaskSucceededArgsForCall = append(fake.recordTaskSucceededArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.RecordTaskSucceededStub
	fake.recordInvocation("RecordTaskSucceeded", []interface{}{arg1})
	fake.recordTaskSucceededMutex.Unlock()
	if stub != nil {
		fake.RecordTaskSucceededStub(arg1)
	}
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskSucceededCallCount() int {
	fake.recordTaskSucceededMutex.RLock()
	defer fake.recordTaskSucceededMutex.RUnlock()
	return len(fake.recordTaskSucceededArgsForCall)
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskSucceededCalls(stub func(string)) {
	fake.recordTaskSucceededMutex.Lock()
	defer fake.recordTaskSucceededMutex.Unlock()
	fake.RecordTaskSucceededStub = stub
}

func (fake *FakeTaskStatMetronNotifier) RecordTaskSucceededArgsForCall(i int) string {
	fake.recordTaskSucceededMutex.RLock()
	defer fake.recordTaskSucceededMutex.RUnlock()
	argsForCall := fake.recordTaskSucceededArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTaskStatMetronNotifier) Run(arg1 <-chan os.Signal, arg2 chan<- struct{}) error {
	fake.runMutex.Lock()
	ret, specificReturn := fake.runReturnsOnCall[len(fake.runArgsForCall)]
	fake.runArgsForCall = append(fake.runArgsForCall, struct {
		arg1 <-chan os.Signal
		arg2 chan<- struct{}
	}{arg1, arg2})
	stub := fake.RunStub
	fakeReturns := fake.runReturns
	fake.recordInvocation("Run", []interface{}{arg1, arg2})
	fake.runMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTaskStatMetronNotifier) RunCallCount() int {
	fake.runMutex.RLock()
	defer fake.runMutex.RUnlock()
	return len(fake.runArgsForCall)
}

func (fake *FakeTaskStatMetronNotifier) RunCalls(stub func(<-chan os.Signal, chan<- struct{}) error) {
	fake.runMutex.Lock()
	defer fake.runMutex.Unlock()
	fake.RunStub = stub
}

func (fake *FakeTaskStatMetronNotifier) RunArgsForCall(i int) (<-chan os.Signal, chan<- struct{}) {
	fake.runMutex.RLock()
	defer fake.runMutex.RUnlock()
	argsForCall := fake.runArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeTaskStatMetronNotifier) RunReturns(result1 error) {
	fake.runMutex.Lock()
	defer fake.runMutex.Unlock()
	fake.RunStub = nil
	fake.runReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeTaskStatMetronNotifier) RunReturnsOnCall(i int, result1 error) {
	fake.runMutex.Lock()
	defer fake.runMutex.Unlock()
	fake.RunStub = nil
	if fake.runReturnsOnCall == nil {
		fake.runReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.runReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeTaskStatMetronNotifier) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.recordConvergenceDurationMutex.RLock()
	defer fake.recordConvergenceDurationMutex.RUnlock()
	fake.recordTaskCountsMutex.RLock()
	defer fake.recordTaskCountsMutex.RUnlock()
	fake.recordTaskFailedMutex.RLock()
	defer fake.recordTaskFailedMutex.RUnlock()
	fake.recordTaskStartedMutex.RLock()
	defer fake.recordTaskStartedMutex.RUnlock()
	fake.recordTaskSucceededMutex.RLock()
	defer fake.recordTaskSucceededMutex.RUnlock()
	fake.runMutex.RLock()
	defer fake.runMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeTaskStatMetronNotifier) 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 _ metrics.TaskStatMetronNotifier = new(FakeTaskStatMetronNotifier)