mock_stats.go

// Code generated by MockGen. DO NOT EDIT.
// Source: stats.go

package stats

import (
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
	time "time"
)

// MockStats is a mock of Stats interface
type MockStats struct {
	ctrl     *gomock.Controller
	recorder *MockStatsMockRecorder
}

// MockStatsMockRecorder is the mock recorder for MockStats
type MockStatsMockRecorder struct {
	mock *MockStats
}

// NewMockStats creates a new mock instance
func NewMockStats(ctrl *gomock.Controller) *MockStats {
	mock := &MockStats{ctrl: ctrl}
	mock.recorder = &MockStatsMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockStats) EXPECT() *MockStatsMockRecorder {
	return m.recorder
}

// Gauge mocks base method
func (m *MockStats) Gauge(stat string, value float64, tags ...Tag) {
	varargs := []interface{}{stat, value}
	for _, a := range tags {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Gauge", varargs...)
}

// Gauge indicates an expected call of Gauge
func (mr *MockStatsMockRecorder) Gauge(stat, value interface{}, tags ...interface{}) *gomock.Call {
	varargs := append([]interface{}{stat, value}, tags...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Gauge", reflect.TypeOf((*MockStats)(nil).Gauge), varargs...)
}

// Count mocks base method
func (m *MockStats) Count(stat string, count float64, tags ...Tag) {
	varargs := []interface{}{stat, count}
	for _, a := range tags {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Count", varargs...)
}

// Count indicates an expected call of Count
func (mr *MockStatsMockRecorder) Count(stat, count interface{}, tags ...interface{}) *gomock.Call {
	varargs := append([]interface{}{stat, count}, tags...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockStats)(nil).Count), varargs...)
}

// Histogram mocks base method
func (m *MockStats) Histogram(stat string, value float64, tags ...Tag) {
	varargs := []interface{}{stat, value}
	for _, a := range tags {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Histogram", varargs...)
}

// Histogram indicates an expected call of Histogram
func (mr *MockStatsMockRecorder) Histogram(stat, value interface{}, tags ...interface{}) *gomock.Call {
	varargs := append([]interface{}{stat, value}, tags...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Histogram", reflect.TypeOf((*MockStats)(nil).Histogram), varargs...)
}

// Timing mocks base method
func (m *MockStats) Timing(stat string, value time.Duration, tags ...Tag) {
	varargs := []interface{}{stat, value}
	for _, a := range tags {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Timing", varargs...)
}

// Timing indicates an expected call of Timing
func (mr *MockStatsMockRecorder) Timing(stat, value interface{}, tags ...interface{}) *gomock.Call {
	varargs := append([]interface{}{stat, value}, tags...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timing", reflect.TypeOf((*MockStats)(nil).Timing), varargs...)
}

// Event mocks base method
func (m *MockStats) Event(stat string, fields ...Field) {
	varargs := []interface{}{stat}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Event", varargs...)
}

// Event indicates an expected call of Event
func (mr *MockStatsMockRecorder) Event(stat interface{}, fields ...interface{}) *gomock.Call {
	varargs := append([]interface{}{stat}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Event", reflect.TypeOf((*MockStats)(nil).Event), varargs...)
}

// AddTags mocks base method
func (m *MockStats) AddTags(tags ...Tag) {
	varargs := []interface{}{}
	for _, a := range tags {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "AddTags", varargs...)
}

// AddTags indicates an expected call of AddTags
func (mr *MockStatsMockRecorder) AddTags(tags ...interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTags", reflect.TypeOf((*MockStats)(nil).AddTags), tags...)
}

// Scope mocks base method
func (m *MockStats) Scope(scope string, scopes ...string) Stats {
	varargs := []interface{}{scope}
	for _, a := range scopes {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Scope", varargs...)
	ret0, _ := ret[0].(Stats)
	return ret0
}

// Scope indicates an expected call of Scope
func (mr *MockStatsMockRecorder) Scope(scope interface{}, scopes ...interface{}) *gomock.Call {
	varargs := append([]interface{}{scope}, scopes...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scope", reflect.TypeOf((*MockStats)(nil).Scope), varargs...)
}

// Close mocks base method
func (m *MockStats) Close() error {
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockStatsMockRecorder) Close() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStats)(nil).Close))
}