fake_statter.go

// This file was generated by counterfeiter
package statsdfakes

import (
	"sync"
	"time"

	"github.com/cactus/go-statsd-client/statsd"
)

type FakeStatter struct {
	IncStub        func(string, int64, float32) error
	incMutex       sync.RWMutex
	incArgsForCall []struct {
		arg1 string
		arg2 int64
		arg3 float32
	}
	incReturns struct {
		result1 error
	}
	DecStub        func(string, int64, float32) error
	decMutex       sync.RWMutex
	decArgsForCall []struct {
		arg1 string
		arg2 int64
		arg3 float32
	}
	decReturns struct {
		result1 error
	}
	GaugeStub        func(string, int64, float32) error
	gaugeMutex       sync.RWMutex
	gaugeArgsForCall []struct {
		arg1 string
		arg2 int64
		arg3 float32
	}
	gaugeReturns struct {
		result1 error
	}
	GaugeDeltaStub        func(string, int64, float32) error
	gaugeDeltaMutex       sync.RWMutex
	gaugeDeltaArgsForCall []struct {
		arg1 string
		arg2 int64
		arg3 float32
	}
	gaugeDeltaReturns struct {
		result1 error
	}
	TimingStub        func(string, int64, float32) error
	timingMutex       sync.RWMutex
	timingArgsForCall []struct {
		arg1 string
		arg2 int64
		arg3 float32
	}
	timingReturns struct {
		result1 error
	}
	TimingDurationStub        func(string, time.Duration, float32) error
	timingDurationMutex       sync.RWMutex
	timingDurationArgsForCall []struct {
		arg1 string
		arg2 time.Duration
		arg3 float32
	}
	timingDurationReturns struct {
		result1 error
	}
	SetStub        func(string, string, float32) error
	setMutex       sync.RWMutex
	setArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 float32
	}
	setReturns struct {
		result1 error
	}
	SetIntStub        func(string, int64, float32) error
	setIntMutex       sync.RWMutex
	setIntArgsForCall []struct {
		arg1 string
		arg2 int64
		arg3 float32
	}
	setIntReturns struct {
		result1 error
	}
	RawStub        func(string, string, float32) error
	rawMutex       sync.RWMutex
	rawArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 float32
	}
	rawReturns struct {
		result1 error
	}
	NewSubStatterStub        func(string) statsd.SubStatter
	newSubStatterMutex       sync.RWMutex
	newSubStatterArgsForCall []struct {
		arg1 string
	}
	newSubStatterReturns struct {
		result1 statsd.SubStatter
	}
	SetPrefixStub        func(string)
	setPrefixMutex       sync.RWMutex
	setPrefixArgsForCall []struct {
		arg1 string
	}
	CloseStub        func() error
	closeMutex       sync.RWMutex
	closeArgsForCall []struct{}
	closeReturns     struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeStatter) Inc(arg1 string, arg2 int64, arg3 float32) error {
	fake.incMutex.Lock()
	fake.incArgsForCall = append(fake.incArgsForCall, struct {
		arg1 string
		arg2 int64
		arg3 float32
	}{arg1, arg2, arg3})
	fake.recordInvocation("Inc", []interface{}{arg1, arg2, arg3})
	fake.incMutex.Unlock()
	if fake.IncStub != nil {
		return fake.IncStub(arg1, arg2, arg3)
	} else {
		return fake.incReturns.result1
	}
}

func (fake *FakeStatter) IncCallCount() int {
	fake.incMutex.RLock()
	defer fake.incMutex.RUnlock()
	return len(fake.incArgsForCall)
}

func (fake *FakeStatter) IncArgsForCall(i int) (string, int64, float32) {
	fake.incMutex.RLock()
	defer fake.incMutex.RUnlock()
	return fake.incArgsForCall[i].arg1, fake.incArgsForCall[i].arg2, fake.incArgsForCall[i].arg3
}

func (fake *FakeStatter) IncReturns(result1 error) {
	fake.IncStub = nil
	fake.incReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStatter) Dec(arg1 string, arg2 int64, arg3 float32) error {
	fake.decMutex.Lock()
	fake.decArgsForCall = append(fake.decArgsForCall, struct {
		arg1 string
		arg2 int64
		arg3 float32
	}{arg1, arg2, arg3})
	fake.recordInvocation("Dec", []interface{}{arg1, arg2, arg3})
	fake.decMutex.Unlock()
	if fake.DecStub != nil {
		return fake.DecStub(arg1, arg2, arg3)
	} else {
		return fake.decReturns.result1
	}
}

func (fake *FakeStatter) DecCallCount() int {
	fake.decMutex.RLock()
	defer fake.decMutex.RUnlock()
	return len(fake.decArgsForCall)
}

func (fake *FakeStatter) DecArgsForCall(i int) (string, int64, float32) {
	fake.decMutex.RLock()
	defer fake.decMutex.RUnlock()
	return fake.decArgsForCall[i].arg1, fake.decArgsForCall[i].arg2, fake.decArgsForCall[i].arg3
}

func (fake *FakeStatter) DecReturns(result1 error) {
	fake.DecStub = nil
	fake.decReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStatter) Gauge(arg1 string, arg2 int64, arg3 float32) error {
	fake.gaugeMutex.Lock()
	fake.gaugeArgsForCall = append(fake.gaugeArgsForCall, struct {
		arg1 string
		arg2 int64
		arg3 float32
	}{arg1, arg2, arg3})
	fake.recordInvocation("Gauge", []interface{}{arg1, arg2, arg3})
	fake.gaugeMutex.Unlock()
	if fake.GaugeStub != nil {
		return fake.GaugeStub(arg1, arg2, arg3)
	} else {
		return fake.gaugeReturns.result1
	}
}

func (fake *FakeStatter) GaugeCallCount() int {
	fake.gaugeMutex.RLock()
	defer fake.gaugeMutex.RUnlock()
	return len(fake.gaugeArgsForCall)
}

func (fake *FakeStatter) GaugeArgsForCall(i int) (string, int64, float32) {
	fake.gaugeMutex.RLock()
	defer fake.gaugeMutex.RUnlock()
	return fake.gaugeArgsForCall[i].arg1, fake.gaugeArgsForCall[i].arg2, fake.gaugeArgsForCall[i].arg3
}

func (fake *FakeStatter) GaugeReturns(result1 error) {
	fake.GaugeStub = nil
	fake.gaugeReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStatter) GaugeDelta(arg1 string, arg2 int64, arg3 float32) error {
	fake.gaugeDeltaMutex.Lock()
	fake.gaugeDeltaArgsForCall = append(fake.gaugeDeltaArgsForCall, struct {
		arg1 string
		arg2 int64
		arg3 float32
	}{arg1, arg2, arg3})
	fake.recordInvocation("GaugeDelta", []interface{}{arg1, arg2, arg3})
	fake.gaugeDeltaMutex.Unlock()
	if fake.GaugeDeltaStub != nil {
		return fake.GaugeDeltaStub(arg1, arg2, arg3)
	} else {
		return fake.gaugeDeltaReturns.result1
	}
}

func (fake *FakeStatter) GaugeDeltaCallCount() int {
	fake.gaugeDeltaMutex.RLock()
	defer fake.gaugeDeltaMutex.RUnlock()
	return len(fake.gaugeDeltaArgsForCall)
}

func (fake *FakeStatter) GaugeDeltaArgsForCall(i int) (string, int64, float32) {
	fake.gaugeDeltaMutex.RLock()
	defer fake.gaugeDeltaMutex.RUnlock()
	return fake.gaugeDeltaArgsForCall[i].arg1, fake.gaugeDeltaArgsForCall[i].arg2, fake.gaugeDeltaArgsForCall[i].arg3
}

func (fake *FakeStatter) GaugeDeltaReturns(result1 error) {
	fake.GaugeDeltaStub = nil
	fake.gaugeDeltaReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStatter) Timing(arg1 string, arg2 int64, arg3 float32) error {
	fake.timingMutex.Lock()
	fake.timingArgsForCall = append(fake.timingArgsForCall, struct {
		arg1 string
		arg2 int64
		arg3 float32
	}{arg1, arg2, arg3})
	fake.recordInvocation("Timing", []interface{}{arg1, arg2, arg3})
	fake.timingMutex.Unlock()
	if fake.TimingStub != nil {
		return fake.TimingStub(arg1, arg2, arg3)
	} else {
		return fake.timingReturns.result1
	}
}

func (fake *FakeStatter) TimingCallCount() int {
	fake.timingMutex.RLock()
	defer fake.timingMutex.RUnlock()
	return len(fake.timingArgsForCall)
}

func (fake *FakeStatter) TimingArgsForCall(i int) (string, int64, float32) {
	fake.timingMutex.RLock()
	defer fake.timingMutex.RUnlock()
	return fake.timingArgsForCall[i].arg1, fake.timingArgsForCall[i].arg2, fake.timingArgsForCall[i].arg3
}

func (fake *FakeStatter) TimingReturns(result1 error) {
	fake.TimingStub = nil
	fake.timingReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStatter) TimingDuration(arg1 string, arg2 time.Duration, arg3 float32) error {
	fake.timingDurationMutex.Lock()
	fake.timingDurationArgsForCall = append(fake.timingDurationArgsForCall, struct {
		arg1 string
		arg2 time.Duration
		arg3 float32
	}{arg1, arg2, arg3})
	fake.recordInvocation("TimingDuration", []interface{}{arg1, arg2, arg3})
	fake.timingDurationMutex.Unlock()
	if fake.TimingDurationStub != nil {
		return fake.TimingDurationStub(arg1, arg2, arg3)
	} else {
		return fake.timingDurationReturns.result1
	}
}

func (fake *FakeStatter) TimingDurationCallCount() int {
	fake.timingDurationMutex.RLock()
	defer fake.timingDurationMutex.RUnlock()
	return len(fake.timingDurationArgsForCall)
}

func (fake *FakeStatter) TimingDurationArgsForCall(i int) (string, time.Duration, float32) {
	fake.timingDurationMutex.RLock()
	defer fake.timingDurationMutex.RUnlock()
	return fake.timingDurationArgsForCall[i].arg1, fake.timingDurationArgsForCall[i].arg2, fake.timingDurationArgsForCall[i].arg3
}

func (fake *FakeStatter) TimingDurationReturns(result1 error) {
	fake.TimingDurationStub = nil
	fake.timingDurationReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStatter) Set(arg1 string, arg2 string, arg3 float32) error {
	fake.setMutex.Lock()
	fake.setArgsForCall = append(fake.setArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 float32
	}{arg1, arg2, arg3})
	fake.recordInvocation("Set", []interface{}{arg1, arg2, arg3})
	fake.setMutex.Unlock()
	if fake.SetStub != nil {
		return fake.SetStub(arg1, arg2, arg3)
	} else {
		return fake.setReturns.result1
	}
}

func (fake *FakeStatter) SetCallCount() int {
	fake.setMutex.RLock()
	defer fake.setMutex.RUnlock()
	return len(fake.setArgsForCall)
}

func (fake *FakeStatter) SetArgsForCall(i int) (string, string, float32) {
	fake.setMutex.RLock()
	defer fake.setMutex.RUnlock()
	return fake.setArgsForCall[i].arg1, fake.setArgsForCall[i].arg2, fake.setArgsForCall[i].arg3
}

func (fake *FakeStatter) SetReturns(result1 error) {
	fake.SetStub = nil
	fake.setReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStatter) SetInt(arg1 string, arg2 int64, arg3 float32) error {
	fake.setIntMutex.Lock()
	fake.setIntArgsForCall = append(fake.setIntArgsForCall, struct {
		arg1 string
		arg2 int64
		arg3 float32
	}{arg1, arg2, arg3})
	fake.recordInvocation("SetInt", []interface{}{arg1, arg2, arg3})
	fake.setIntMutex.Unlock()
	if fake.SetIntStub != nil {
		return fake.SetIntStub(arg1, arg2, arg3)
	} else {
		return fake.setIntReturns.result1
	}
}

func (fake *FakeStatter) SetIntCallCount() int {
	fake.setIntMutex.RLock()
	defer fake.setIntMutex.RUnlock()
	return len(fake.setIntArgsForCall)
}

func (fake *FakeStatter) SetIntArgsForCall(i int) (string, int64, float32) {
	fake.setIntMutex.RLock()
	defer fake.setIntMutex.RUnlock()
	return fake.setIntArgsForCall[i].arg1, fake.setIntArgsForCall[i].arg2, fake.setIntArgsForCall[i].arg3
}

func (fake *FakeStatter) SetIntReturns(result1 error) {
	fake.SetIntStub = nil
	fake.setIntReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStatter) Raw(arg1 string, arg2 string, arg3 float32) error {
	fake.rawMutex.Lock()
	fake.rawArgsForCall = append(fake.rawArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 float32
	}{arg1, arg2, arg3})
	fake.recordInvocation("Raw", []interface{}{arg1, arg2, arg3})
	fake.rawMutex.Unlock()
	if fake.RawStub != nil {
		return fake.RawStub(arg1, arg2, arg3)
	} else {
		return fake.rawReturns.result1
	}
}

func (fake *FakeStatter) RawCallCount() int {
	fake.rawMutex.RLock()
	defer fake.rawMutex.RUnlock()
	return len(fake.rawArgsForCall)
}

func (fake *FakeStatter) RawArgsForCall(i int) (string, string, float32) {
	fake.rawMutex.RLock()
	defer fake.rawMutex.RUnlock()
	return fake.rawArgsForCall[i].arg1, fake.rawArgsForCall[i].arg2, fake.rawArgsForCall[i].arg3
}

func (fake *FakeStatter) RawReturns(result1 error) {
	fake.RawStub = nil
	fake.rawReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStatter) NewSubStatter(arg1 string) statsd.SubStatter {
	fake.newSubStatterMutex.Lock()
	fake.newSubStatterArgsForCall = append(fake.newSubStatterArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("NewSubStatter", []interface{}{arg1})
	fake.newSubStatterMutex.Unlock()
	if fake.NewSubStatterStub != nil {
		return fake.NewSubStatterStub(arg1)
	} else {
		return fake.newSubStatterReturns.result1
	}
}

func (fake *FakeStatter) NewSubStatterCallCount() int {
	fake.newSubStatterMutex.RLock()
	defer fake.newSubStatterMutex.RUnlock()
	return len(fake.newSubStatterArgsForCall)
}

func (fake *FakeStatter) NewSubStatterArgsForCall(i int) string {
	fake.newSubStatterMutex.RLock()
	defer fake.newSubStatterMutex.RUnlock()
	return fake.newSubStatterArgsForCall[i].arg1
}

func (fake *FakeStatter) NewSubStatterReturns(result1 statsd.SubStatter) {
	fake.NewSubStatterStub = nil
	fake.newSubStatterReturns = struct {
		result1 statsd.SubStatter
	}{result1}
}

func (fake *FakeStatter) SetPrefix(arg1 string) {
	fake.setPrefixMutex.Lock()
	fake.setPrefixArgsForCall = append(fake.setPrefixArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetPrefix", []interface{}{arg1})
	fake.setPrefixMutex.Unlock()
	if fake.SetPrefixStub != nil {
		fake.SetPrefixStub(arg1)
	}
}

func (fake *FakeStatter) SetPrefixCallCount() int {
	fake.setPrefixMutex.RLock()
	defer fake.setPrefixMutex.RUnlock()
	return len(fake.setPrefixArgsForCall)
}

func (fake *FakeStatter) SetPrefixArgsForCall(i int) string {
	fake.setPrefixMutex.RLock()
	defer fake.setPrefixMutex.RUnlock()
	return fake.setPrefixArgsForCall[i].arg1
}

func (fake *FakeStatter) Close() error {
	fake.closeMutex.Lock()
	fake.closeArgsForCall = append(fake.closeArgsForCall, struct{}{})
	fake.recordInvocation("Close", []interface{}{})
	fake.closeMutex.Unlock()
	if fake.CloseStub != nil {
		return fake.CloseStub()
	} else {
		return fake.closeReturns.result1
	}
}

func (fake *FakeStatter) CloseCallCount() int {
	fake.closeMutex.RLock()
	defer fake.closeMutex.RUnlock()
	return len(fake.closeArgsForCall)
}

func (fake *FakeStatter) CloseReturns(result1 error) {
	fake.CloseStub = nil
	fake.closeReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStatter) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.incMutex.RLock()
	defer fake.incMutex.RUnlock()
	fake.decMutex.RLock()
	defer fake.decMutex.RUnlock()
	fake.gaugeMutex.RLock()
	defer fake.gaugeMutex.RUnlock()
	fake.gaugeDeltaMutex.RLock()
	defer fake.gaugeDeltaMutex.RUnlock()
	fake.timingMutex.RLock()
	defer fake.timingMutex.RUnlock()
	fake.timingDurationMutex.RLock()
	defer fake.timingDurationMutex.RUnlock()
	fake.setMutex.RLock()
	defer fake.setMutex.RUnlock()
	fake.setIntMutex.RLock()
	defer fake.setIntMutex.RUnlock()
	fake.rawMutex.RLock()
	defer fake.rawMutex.RUnlock()
	fake.newSubStatterMutex.RLock()
	defer fake.newSubStatterMutex.RUnlock()
	fake.setPrefixMutex.RLock()
	defer fake.setPrefixMutex.RUnlock()
	fake.closeMutex.RLock()
	defer fake.closeMutex.RUnlock()
	return fake.invocations
}

func (fake *FakeStatter) 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 _ statsd.Statter = new(FakeStatter)