metric

package
v1.4.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 10, 2025 License: MIT Imports: 4 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MockAddOption 

type MockAddOption struct {
	mock.Mock
}

MockAddOption is an autogenerated mock type for the AddOption type

func NewMockAddOption 

func NewMockAddOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAddOption

NewMockAddOption creates a new instance of MockAddOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockAddOption) EXPECT 

func (_m *MockAddOption) EXPECT() *MockAddOption_Expecter

type MockAddOption_Expecter 

type MockAddOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockAddOption_applyAdd_Call 

type MockAddOption_applyAdd_Call struct {
	*mock.Call
}

MockAddOption_applyAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyAdd'

func (*MockAddOption_applyAdd_Call) Return 

func (_c *MockAddOption_applyAdd_Call) Return(_a0 metric.AddConfig) *MockAddOption_applyAdd_Call

func (*MockAddOption_applyAdd_Call) Run 

func (_c *MockAddOption_applyAdd_Call) Run(run func(_a0 metric.AddConfig)) *MockAddOption_applyAdd_Call

func (*MockAddOption_applyAdd_Call) RunAndReturn 

func (_c *MockAddOption_applyAdd_Call) RunAndReturn(run func(metric.AddConfig) metric.AddConfig) *MockAddOption_applyAdd_Call

type MockCallback 

type MockCallback struct {
	mock.Mock
}

MockCallback is an autogenerated mock type for the Callback type

func NewMockCallback 

func NewMockCallback(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockCallback

NewMockCallback creates a new instance of MockCallback. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockCallback) EXPECT 

func (_m *MockCallback) EXPECT() *MockCallback_Expecter

func (*MockCallback) Execute 

func (_m *MockCallback) Execute(_a0 context.Context, _a1 metric.Observer) error

Execute provides a mock function with given fields: _a0, _a1

type MockCallback_Execute_Call 

type MockCallback_Execute_Call struct {
	*mock.Call
}

MockCallback_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'

func (*MockCallback_Execute_Call) Return 

func (_c *MockCallback_Execute_Call) Return(_a0 error) *MockCallback_Execute_Call

func (*MockCallback_Execute_Call) Run 

func (_c *MockCallback_Execute_Call) Run(run func(_a0 context.Context, _a1 metric.Observer)) *MockCallback_Execute_Call

func (*MockCallback_Execute_Call) RunAndReturn 

func (_c *MockCallback_Execute_Call) RunAndReturn(run func(context.Context, metric.Observer) error) *MockCallback_Execute_Call

type MockCallback_Expecter 

type MockCallback_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockCallback_Expecter) Execute 

func (_e *MockCallback_Expecter) Execute(_a0 interface{}, _a1 interface{}) *MockCallback_Execute_Call

Execute is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 metric.Observer

type MockFloat64Callback 

type MockFloat64Callback struct {
	mock.Mock
}

MockFloat64Callback is an autogenerated mock type for the Float64Callback type

func NewMockFloat64Callback 

func NewMockFloat64Callback(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64Callback

NewMockFloat64Callback creates a new instance of MockFloat64Callback. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64Callback) EXPECT 

func (_m *MockFloat64Callback) EXPECT() *MockFloat64Callback_Expecter

func (*MockFloat64Callback) Execute 

func (_m *MockFloat64Callback) Execute(_a0 context.Context, _a1 metric.Float64Observer) error

Execute provides a mock function with given fields: _a0, _a1

type MockFloat64Callback_Execute_Call 

type MockFloat64Callback_Execute_Call struct {
	*mock.Call
}

MockFloat64Callback_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'

func (*MockFloat64Callback_Execute_Call) Return 

func (_c *MockFloat64Callback_Execute_Call) Return(_a0 error) *MockFloat64Callback_Execute_Call

func (*MockFloat64Callback_Execute_Call) Run 

func (_c *MockFloat64Callback_Execute_Call) Run(run func(_a0 context.Context, _a1 metric.Float64Observer)) *MockFloat64Callback_Execute_Call

func (*MockFloat64Callback_Execute_Call) RunAndReturn 

func (_c *MockFloat64Callback_Execute_Call) RunAndReturn(run func(context.Context, metric.Float64Observer) error) *MockFloat64Callback_Execute_Call

type MockFloat64Callback_Expecter 

type MockFloat64Callback_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockFloat64Callback_Expecter) Execute 

func (_e *MockFloat64Callback_Expecter) Execute(_a0 interface{}, _a1 interface{}) *MockFloat64Callback_Execute_Call

Execute is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 metric.Float64Observer

type MockFloat64Counter 

type MockFloat64Counter struct {
	mock.Mock
}

MockFloat64Counter is an autogenerated mock type for the Float64Counter type

func NewMockFloat64Counter 

func NewMockFloat64Counter(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64Counter

NewMockFloat64Counter creates a new instance of MockFloat64Counter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64Counter) Add 

func (_m *MockFloat64Counter) Add(ctx context.Context, incr float64, options ...metric.AddOption)

Add provides a mock function with given fields: ctx, incr, options

func (*MockFloat64Counter) EXPECT 

func (_m *MockFloat64Counter) EXPECT() *MockFloat64Counter_Expecter

type MockFloat64CounterOption 

type MockFloat64CounterOption struct {
	mock.Mock
}

MockFloat64CounterOption is an autogenerated mock type for the Float64CounterOption type

func NewMockFloat64CounterOption 

func NewMockFloat64CounterOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64CounterOption

NewMockFloat64CounterOption creates a new instance of MockFloat64CounterOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64CounterOption) EXPECT 

func (_m *MockFloat64CounterOption) EXPECT() *MockFloat64CounterOption_Expecter

type MockFloat64CounterOption_Expecter 

type MockFloat64CounterOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockFloat64CounterOption_applyFloat64Counter_Call 

type MockFloat64CounterOption_applyFloat64Counter_Call struct {
	*mock.Call
}

MockFloat64CounterOption_applyFloat64Counter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64Counter'

func (*MockFloat64CounterOption_applyFloat64Counter_Call) Return 

func (_c *MockFloat64CounterOption_applyFloat64Counter_Call) Return(_a0 metric.Float64CounterConfig) *MockFloat64CounterOption_applyFloat64Counter_Call

func (*MockFloat64CounterOption_applyFloat64Counter_Call) Run 

func (_c *MockFloat64CounterOption_applyFloat64Counter_Call) Run(run func(_a0 metric.Float64CounterConfig)) *MockFloat64CounterOption_applyFloat64Counter_Call

func (*MockFloat64CounterOption_applyFloat64Counter_Call) RunAndReturn 

func (_c *MockFloat64CounterOption_applyFloat64Counter_Call) RunAndReturn(run func(metric.Float64CounterConfig) metric.Float64CounterConfig) *MockFloat64CounterOption_applyFloat64Counter_Call

type MockFloat64Counter_Add_Call 

type MockFloat64Counter_Add_Call struct {
	*mock.Call
}

MockFloat64Counter_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add'

func (*MockFloat64Counter_Add_Call) Return 

func (_c *MockFloat64Counter_Add_Call) Return() *MockFloat64Counter_Add_Call

func (*MockFloat64Counter_Add_Call) Run 

func (_c *MockFloat64Counter_Add_Call) Run(run func(ctx context.Context, incr float64, options ...metric.AddOption)) *MockFloat64Counter_Add_Call

func (*MockFloat64Counter_Add_Call) RunAndReturn 

func (_c *MockFloat64Counter_Add_Call) RunAndReturn(run func(context.Context, float64, ...metric.AddOption)) *MockFloat64Counter_Add_Call

type MockFloat64Counter_Expecter 

type MockFloat64Counter_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockFloat64Counter_Expecter) Add 

func (_e *MockFloat64Counter_Expecter) Add(ctx interface{}, incr interface{}, options ...interface{}) *MockFloat64Counter_Add_Call

Add is a helper method to define mock.On call

  • ctx context.Context
  • incr float64
  • options ...metric.AddOption

type MockFloat64Counter_float64Counter_Call 

type MockFloat64Counter_float64Counter_Call struct {
	*mock.Call
}

MockFloat64Counter_float64Counter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'float64Counter'

func (*MockFloat64Counter_float64Counter_Call) Return 

func (_c *MockFloat64Counter_float64Counter_Call) Return() *MockFloat64Counter_float64Counter_Call

func (*MockFloat64Counter_float64Counter_Call) Run 

func (_c *MockFloat64Counter_float64Counter_Call) Run(run func()) *MockFloat64Counter_float64Counter_Call

func (*MockFloat64Counter_float64Counter_Call) RunAndReturn 

func (_c *MockFloat64Counter_float64Counter_Call) RunAndReturn(run func()) *MockFloat64Counter_float64Counter_Call

type MockFloat64Gauge 

type MockFloat64Gauge struct {
	mock.Mock
}

MockFloat64Gauge is an autogenerated mock type for the Float64Gauge type

func NewMockFloat64Gauge 

func NewMockFloat64Gauge(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64Gauge

NewMockFloat64Gauge creates a new instance of MockFloat64Gauge. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64Gauge) EXPECT 

func (_m *MockFloat64Gauge) EXPECT() *MockFloat64Gauge_Expecter

func (*MockFloat64Gauge) Record 

func (_m *MockFloat64Gauge) Record(ctx context.Context, value float64, options ...metric.RecordOption)

Record provides a mock function with given fields: ctx, value, options

type MockFloat64GaugeOption 

type MockFloat64GaugeOption struct {
	mock.Mock
}

MockFloat64GaugeOption is an autogenerated mock type for the Float64GaugeOption type

func NewMockFloat64GaugeOption 

func NewMockFloat64GaugeOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64GaugeOption

NewMockFloat64GaugeOption creates a new instance of MockFloat64GaugeOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64GaugeOption) EXPECT 

func (_m *MockFloat64GaugeOption) EXPECT() *MockFloat64GaugeOption_Expecter

type MockFloat64GaugeOption_Expecter 

type MockFloat64GaugeOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockFloat64GaugeOption_applyFloat64Gauge_Call 

type MockFloat64GaugeOption_applyFloat64Gauge_Call struct {
	*mock.Call
}

MockFloat64GaugeOption_applyFloat64Gauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64Gauge'

func (*MockFloat64GaugeOption_applyFloat64Gauge_Call) Return 

func (_c *MockFloat64GaugeOption_applyFloat64Gauge_Call) Return(_a0 metric.Float64GaugeConfig) *MockFloat64GaugeOption_applyFloat64Gauge_Call

func (*MockFloat64GaugeOption_applyFloat64Gauge_Call) Run 

func (_c *MockFloat64GaugeOption_applyFloat64Gauge_Call) Run(run func(_a0 metric.Float64GaugeConfig)) *MockFloat64GaugeOption_applyFloat64Gauge_Call

func (*MockFloat64GaugeOption_applyFloat64Gauge_Call) RunAndReturn 

func (_c *MockFloat64GaugeOption_applyFloat64Gauge_Call) RunAndReturn(run func(metric.Float64GaugeConfig) metric.Float64GaugeConfig) *MockFloat64GaugeOption_applyFloat64Gauge_Call

type MockFloat64Gauge_Expecter 

type MockFloat64Gauge_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockFloat64Gauge_Expecter) Record 

func (_e *MockFloat64Gauge_Expecter) Record(ctx interface{}, value interface{}, options ...interface{}) *MockFloat64Gauge_Record_Call

Record is a helper method to define mock.On call

  • ctx context.Context
  • value float64
  • options ...metric.RecordOption

type MockFloat64Gauge_Record_Call 

type MockFloat64Gauge_Record_Call struct {
	*mock.Call
}

MockFloat64Gauge_Record_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Record'

func (*MockFloat64Gauge_Record_Call) Return 

func (_c *MockFloat64Gauge_Record_Call) Return() *MockFloat64Gauge_Record_Call

func (*MockFloat64Gauge_Record_Call) Run 

func (_c *MockFloat64Gauge_Record_Call) Run(run func(ctx context.Context, value float64, options ...metric.RecordOption)) *MockFloat64Gauge_Record_Call

func (*MockFloat64Gauge_Record_Call) RunAndReturn 

func (_c *MockFloat64Gauge_Record_Call) RunAndReturn(run func(context.Context, float64, ...metric.RecordOption)) *MockFloat64Gauge_Record_Call

type MockFloat64Gauge_float64Gauge_Call 

type MockFloat64Gauge_float64Gauge_Call struct {
	*mock.Call
}

MockFloat64Gauge_float64Gauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'float64Gauge'

func (*MockFloat64Gauge_float64Gauge_Call) Return 

func (_c *MockFloat64Gauge_float64Gauge_Call) Return() *MockFloat64Gauge_float64Gauge_Call

func (*MockFloat64Gauge_float64Gauge_Call) Run 

func (_c *MockFloat64Gauge_float64Gauge_Call) Run(run func()) *MockFloat64Gauge_float64Gauge_Call

func (*MockFloat64Gauge_float64Gauge_Call) RunAndReturn 

func (_c *MockFloat64Gauge_float64Gauge_Call) RunAndReturn(run func()) *MockFloat64Gauge_float64Gauge_Call

type MockFloat64Histogram 

type MockFloat64Histogram struct {
	mock.Mock
	embedded.Float64Histogram
}

MockFloat64Histogram is an autogenerated mock type for the Float64Histogram type

func NewMockFloat64Histogram 

func NewMockFloat64Histogram(t interface {
	mock.TestingT
	Cleanup(func())
},
) *MockFloat64Histogram

NewMockFloat64Histogram creates a new instance of MockFloat64Histogram. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64Histogram) EXPECT 

func (_m *MockFloat64Histogram) EXPECT() *MockFloat64Histogram_Expecter

func (*MockFloat64Histogram) Record 

func (_m *MockFloat64Histogram) Record(ctx context.Context, incr float64, options ...metric.RecordOption)

Record provides a mock function with given fields: ctx, incr, options

type MockFloat64HistogramOption 

type MockFloat64HistogramOption struct {
	mock.Mock
}

MockFloat64HistogramOption is an autogenerated mock type for the Float64HistogramOption type

func NewMockFloat64HistogramOption 

func NewMockFloat64HistogramOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64HistogramOption

NewMockFloat64HistogramOption creates a new instance of MockFloat64HistogramOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64HistogramOption) EXPECT 

func (_m *MockFloat64HistogramOption) EXPECT() *MockFloat64HistogramOption_Expecter

type MockFloat64HistogramOption_Expecter 

type MockFloat64HistogramOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockFloat64HistogramOption_applyFloat64Histogram_Call 

type MockFloat64HistogramOption_applyFloat64Histogram_Call struct {
	*mock.Call
}

MockFloat64HistogramOption_applyFloat64Histogram_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64Histogram'

func (*MockFloat64HistogramOption_applyFloat64Histogram_Call) Return 

func (_c *MockFloat64HistogramOption_applyFloat64Histogram_Call) Return(_a0 metric.Float64HistogramConfig) *MockFloat64HistogramOption_applyFloat64Histogram_Call

func (*MockFloat64HistogramOption_applyFloat64Histogram_Call) Run 

func (_c *MockFloat64HistogramOption_applyFloat64Histogram_Call) Run(run func(_a0 metric.Float64HistogramConfig)) *MockFloat64HistogramOption_applyFloat64Histogram_Call

func (*MockFloat64HistogramOption_applyFloat64Histogram_Call) RunAndReturn 

func (_c *MockFloat64HistogramOption_applyFloat64Histogram_Call) RunAndReturn(run func(metric.Float64HistogramConfig) metric.Float64HistogramConfig) *MockFloat64HistogramOption_applyFloat64Histogram_Call

type MockFloat64Histogram_Expecter 

type MockFloat64Histogram_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockFloat64Histogram_Expecter) Record 

func (_e *MockFloat64Histogram_Expecter) Record(ctx interface{}, incr interface{}, options ...interface{}) *MockFloat64Histogram_Record_Call

Record is a helper method to define mock.On call

  • ctx context.Context
  • incr float64
  • options ...metric.RecordOption

type MockFloat64Histogram_Record_Call 

type MockFloat64Histogram_Record_Call struct {
	*mock.Call
}

MockFloat64Histogram_Record_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Record'

func (*MockFloat64Histogram_Record_Call) Return 

func (_c *MockFloat64Histogram_Record_Call) Return() *MockFloat64Histogram_Record_Call

func (*MockFloat64Histogram_Record_Call) Run 

func (_c *MockFloat64Histogram_Record_Call) Run(run func(ctx context.Context, incr float64, options ...metric.RecordOption)) *MockFloat64Histogram_Record_Call

func (*MockFloat64Histogram_Record_Call) RunAndReturn 

func (_c *MockFloat64Histogram_Record_Call) RunAndReturn(run func(context.Context, float64, ...metric.RecordOption)) *MockFloat64Histogram_Record_Call

type MockFloat64Histogram_float64Histogram_Call 

type MockFloat64Histogram_float64Histogram_Call struct {
	*mock.Call
}

MockFloat64Histogram_float64Histogram_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'float64Histogram'

func (*MockFloat64Histogram_float64Histogram_Call) Return 

func (_c *MockFloat64Histogram_float64Histogram_Call) Return() *MockFloat64Histogram_float64Histogram_Call

func (*MockFloat64Histogram_float64Histogram_Call) Run 

func (_c *MockFloat64Histogram_float64Histogram_Call) Run(run func()) *MockFloat64Histogram_float64Histogram_Call

func (*MockFloat64Histogram_float64Histogram_Call) RunAndReturn 

func (_c *MockFloat64Histogram_float64Histogram_Call) RunAndReturn(run func()) *MockFloat64Histogram_float64Histogram_Call

type MockFloat64Observable 

type MockFloat64Observable struct {
	mock.Mock
}

MockFloat64Observable is an autogenerated mock type for the Float64Observable type

func NewMockFloat64Observable 

func NewMockFloat64Observable(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64Observable

NewMockFloat64Observable creates a new instance of MockFloat64Observable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64Observable) EXPECT 

func (_m *MockFloat64Observable) EXPECT() *MockFloat64Observable_Expecter

type MockFloat64ObservableCounter 

type MockFloat64ObservableCounter struct {
	mock.Mock
}

MockFloat64ObservableCounter is an autogenerated mock type for the Float64ObservableCounter type

func NewMockFloat64ObservableCounter 

func NewMockFloat64ObservableCounter(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64ObservableCounter

NewMockFloat64ObservableCounter creates a new instance of MockFloat64ObservableCounter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64ObservableCounter) EXPECT 

func (_m *MockFloat64ObservableCounter) EXPECT() *MockFloat64ObservableCounter_Expecter

type MockFloat64ObservableCounterOption 

type MockFloat64ObservableCounterOption struct {
	mock.Mock
}

MockFloat64ObservableCounterOption is an autogenerated mock type for the Float64ObservableCounterOption type

func NewMockFloat64ObservableCounterOption 

func NewMockFloat64ObservableCounterOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64ObservableCounterOption

NewMockFloat64ObservableCounterOption creates a new instance of MockFloat64ObservableCounterOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64ObservableCounterOption) EXPECT 

func (_m *MockFloat64ObservableCounterOption) EXPECT() *MockFloat64ObservableCounterOption_Expecter

type MockFloat64ObservableCounterOption_Expecter 

type MockFloat64ObservableCounterOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockFloat64ObservableCounterOption_applyFloat64ObservableCounter_Call 

type MockFloat64ObservableCounterOption_applyFloat64ObservableCounter_Call struct {
	*mock.Call
}

MockFloat64ObservableCounterOption_applyFloat64ObservableCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64ObservableCounter'

func (*MockFloat64ObservableCounterOption_applyFloat64ObservableCounter_Call) Return 

func (_c *MockFloat64ObservableCounterOption_applyFloat64ObservableCounter_Call) Return(_a0 metric.Float64ObservableCounterConfig) *MockFloat64ObservableCounterOption_applyFloat64ObservableCounter_Call

func (*MockFloat64ObservableCounterOption_applyFloat64ObservableCounter_Call) Run 

func (_c *MockFloat64ObservableCounterOption_applyFloat64ObservableCounter_Call) Run(run func(_a0 metric.Float64ObservableCounterConfig)) *MockFloat64ObservableCounterOption_applyFloat64ObservableCounter_Call

func (*MockFloat64ObservableCounterOption_applyFloat64ObservableCounter_Call) RunAndReturn 

func (_c *MockFloat64ObservableCounterOption_applyFloat64ObservableCounter_Call) RunAndReturn(run func(metric.Float64ObservableCounterConfig) metric.Float64ObservableCounterConfig) *MockFloat64ObservableCounterOption_applyFloat64ObservableCounter_Call

type MockFloat64ObservableCounter_Expecter 

type MockFloat64ObservableCounter_Expecter struct {
	// contains filtered or unexported fields
}

type MockFloat64ObservableCounter_float64ObservableCounter_Call 

type MockFloat64ObservableCounter_float64ObservableCounter_Call struct {
	*mock.Call
}

MockFloat64ObservableCounter_float64ObservableCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'float64ObservableCounter'

func (*MockFloat64ObservableCounter_float64ObservableCounter_Call) Return 

func (_c *MockFloat64ObservableCounter_float64ObservableCounter_Call) Return() *MockFloat64ObservableCounter_float64ObservableCounter_Call

func (*MockFloat64ObservableCounter_float64ObservableCounter_Call) Run 

func (_c *MockFloat64ObservableCounter_float64ObservableCounter_Call) Run(run func()) *MockFloat64ObservableCounter_float64ObservableCounter_Call

func (*MockFloat64ObservableCounter_float64ObservableCounter_Call) RunAndReturn 

func (_c *MockFloat64ObservableCounter_float64ObservableCounter_Call) RunAndReturn(run func()) *MockFloat64ObservableCounter_float64ObservableCounter_Call

type MockFloat64ObservableCounter_float64Observable_Call 

type MockFloat64ObservableCounter_float64Observable_Call struct {
	*mock.Call
}

MockFloat64ObservableCounter_float64Observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'float64Observable'

func (*MockFloat64ObservableCounter_float64Observable_Call) Return 

func (_c *MockFloat64ObservableCounter_float64Observable_Call) Return() *MockFloat64ObservableCounter_float64Observable_Call

func (*MockFloat64ObservableCounter_float64Observable_Call) Run 

func (_c *MockFloat64ObservableCounter_float64Observable_Call) Run(run func()) *MockFloat64ObservableCounter_float64Observable_Call

func (*MockFloat64ObservableCounter_float64Observable_Call) RunAndReturn 

func (_c *MockFloat64ObservableCounter_float64Observable_Call) RunAndReturn(run func()) *MockFloat64ObservableCounter_float64Observable_Call

type MockFloat64ObservableCounter_observable_Call 

type MockFloat64ObservableCounter_observable_Call struct {
	*mock.Call
}

MockFloat64ObservableCounter_observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'observable'

func (*MockFloat64ObservableCounter_observable_Call) Return 

func (_c *MockFloat64ObservableCounter_observable_Call) Return() *MockFloat64ObservableCounter_observable_Call

func (*MockFloat64ObservableCounter_observable_Call) Run 

func (_c *MockFloat64ObservableCounter_observable_Call) Run(run func()) *MockFloat64ObservableCounter_observable_Call

func (*MockFloat64ObservableCounter_observable_Call) RunAndReturn 

func (_c *MockFloat64ObservableCounter_observable_Call) RunAndReturn(run func()) *MockFloat64ObservableCounter_observable_Call

type MockFloat64ObservableGauge 

type MockFloat64ObservableGauge struct {
	mock.Mock
}

MockFloat64ObservableGauge is an autogenerated mock type for the Float64ObservableGauge type

func NewMockFloat64ObservableGauge 

func NewMockFloat64ObservableGauge(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64ObservableGauge

NewMockFloat64ObservableGauge creates a new instance of MockFloat64ObservableGauge. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64ObservableGauge) EXPECT 

func (_m *MockFloat64ObservableGauge) EXPECT() *MockFloat64ObservableGauge_Expecter

type MockFloat64ObservableGaugeOption 

type MockFloat64ObservableGaugeOption struct {
	mock.Mock
}

MockFloat64ObservableGaugeOption is an autogenerated mock type for the Float64ObservableGaugeOption type

func NewMockFloat64ObservableGaugeOption 

func NewMockFloat64ObservableGaugeOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64ObservableGaugeOption

NewMockFloat64ObservableGaugeOption creates a new instance of MockFloat64ObservableGaugeOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64ObservableGaugeOption) EXPECT 

func (_m *MockFloat64ObservableGaugeOption) EXPECT() *MockFloat64ObservableGaugeOption_Expecter

type MockFloat64ObservableGaugeOption_Expecter 

type MockFloat64ObservableGaugeOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockFloat64ObservableGaugeOption_applyFloat64ObservableGauge_Call 

type MockFloat64ObservableGaugeOption_applyFloat64ObservableGauge_Call struct {
	*mock.Call
}

MockFloat64ObservableGaugeOption_applyFloat64ObservableGauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64ObservableGauge'

func (*MockFloat64ObservableGaugeOption_applyFloat64ObservableGauge_Call) Return 

func (_c *MockFloat64ObservableGaugeOption_applyFloat64ObservableGauge_Call) Return(_a0 metric.Float64ObservableGaugeConfig) *MockFloat64ObservableGaugeOption_applyFloat64ObservableGauge_Call

func (*MockFloat64ObservableGaugeOption_applyFloat64ObservableGauge_Call) Run 

func (_c *MockFloat64ObservableGaugeOption_applyFloat64ObservableGauge_Call) Run(run func(_a0 metric.Float64ObservableGaugeConfig)) *MockFloat64ObservableGaugeOption_applyFloat64ObservableGauge_Call

func (*MockFloat64ObservableGaugeOption_applyFloat64ObservableGauge_Call) RunAndReturn 

func (_c *MockFloat64ObservableGaugeOption_applyFloat64ObservableGauge_Call) RunAndReturn(run func(metric.Float64ObservableGaugeConfig) metric.Float64ObservableGaugeConfig) *MockFloat64ObservableGaugeOption_applyFloat64ObservableGauge_Call

type MockFloat64ObservableGauge_Expecter 

type MockFloat64ObservableGauge_Expecter struct {
	// contains filtered or unexported fields
}

type MockFloat64ObservableGauge_float64ObservableGauge_Call 

type MockFloat64ObservableGauge_float64ObservableGauge_Call struct {
	*mock.Call
}

MockFloat64ObservableGauge_float64ObservableGauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'float64ObservableGauge'

func (*MockFloat64ObservableGauge_float64ObservableGauge_Call) Return 

func (_c *MockFloat64ObservableGauge_float64ObservableGauge_Call) Return() *MockFloat64ObservableGauge_float64ObservableGauge_Call

func (*MockFloat64ObservableGauge_float64ObservableGauge_Call) Run 

func (_c *MockFloat64ObservableGauge_float64ObservableGauge_Call) Run(run func()) *MockFloat64ObservableGauge_float64ObservableGauge_Call

func (*MockFloat64ObservableGauge_float64ObservableGauge_Call) RunAndReturn 

func (_c *MockFloat64ObservableGauge_float64ObservableGauge_Call) RunAndReturn(run func()) *MockFloat64ObservableGauge_float64ObservableGauge_Call

type MockFloat64ObservableGauge_float64Observable_Call 

type MockFloat64ObservableGauge_float64Observable_Call struct {
	*mock.Call
}

MockFloat64ObservableGauge_float64Observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'float64Observable'

func (*MockFloat64ObservableGauge_float64Observable_Call) Return 

func (_c *MockFloat64ObservableGauge_float64Observable_Call) Return() *MockFloat64ObservableGauge_float64Observable_Call

func (*MockFloat64ObservableGauge_float64Observable_Call) Run 

func (_c *MockFloat64ObservableGauge_float64Observable_Call) Run(run func()) *MockFloat64ObservableGauge_float64Observable_Call

func (*MockFloat64ObservableGauge_float64Observable_Call) RunAndReturn 

func (_c *MockFloat64ObservableGauge_float64Observable_Call) RunAndReturn(run func()) *MockFloat64ObservableGauge_float64Observable_Call

type MockFloat64ObservableGauge_observable_Call 

type MockFloat64ObservableGauge_observable_Call struct {
	*mock.Call
}

MockFloat64ObservableGauge_observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'observable'

func (*MockFloat64ObservableGauge_observable_Call) Return 

func (_c *MockFloat64ObservableGauge_observable_Call) Return() *MockFloat64ObservableGauge_observable_Call

func (*MockFloat64ObservableGauge_observable_Call) Run 

func (_c *MockFloat64ObservableGauge_observable_Call) Run(run func()) *MockFloat64ObservableGauge_observable_Call

func (*MockFloat64ObservableGauge_observable_Call) RunAndReturn 

func (_c *MockFloat64ObservableGauge_observable_Call) RunAndReturn(run func()) *MockFloat64ObservableGauge_observable_Call

type MockFloat64ObservableOption 

type MockFloat64ObservableOption struct {
	mock.Mock
}

MockFloat64ObservableOption is an autogenerated mock type for the Float64ObservableOption type

func NewMockFloat64ObservableOption 

func NewMockFloat64ObservableOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64ObservableOption

NewMockFloat64ObservableOption creates a new instance of MockFloat64ObservableOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64ObservableOption) EXPECT 

func (_m *MockFloat64ObservableOption) EXPECT() *MockFloat64ObservableOption_Expecter

type MockFloat64ObservableOption_Expecter 

type MockFloat64ObservableOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockFloat64ObservableOption_applyFloat64ObservableCounter_Call 

type MockFloat64ObservableOption_applyFloat64ObservableCounter_Call struct {
	*mock.Call
}

MockFloat64ObservableOption_applyFloat64ObservableCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64ObservableCounter'

func (*MockFloat64ObservableOption_applyFloat64ObservableCounter_Call) Return 

func (_c *MockFloat64ObservableOption_applyFloat64ObservableCounter_Call) Return(_a0 metric.Float64ObservableCounterConfig) *MockFloat64ObservableOption_applyFloat64ObservableCounter_Call

func (*MockFloat64ObservableOption_applyFloat64ObservableCounter_Call) Run 

func (_c *MockFloat64ObservableOption_applyFloat64ObservableCounter_Call) Run(run func(_a0 metric.Float64ObservableCounterConfig)) *MockFloat64ObservableOption_applyFloat64ObservableCounter_Call

func (*MockFloat64ObservableOption_applyFloat64ObservableCounter_Call) RunAndReturn 

func (_c *MockFloat64ObservableOption_applyFloat64ObservableCounter_Call) RunAndReturn(run func(metric.Float64ObservableCounterConfig) metric.Float64ObservableCounterConfig) *MockFloat64ObservableOption_applyFloat64ObservableCounter_Call

type MockFloat64ObservableOption_applyFloat64ObservableGauge_Call 

type MockFloat64ObservableOption_applyFloat64ObservableGauge_Call struct {
	*mock.Call
}

MockFloat64ObservableOption_applyFloat64ObservableGauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64ObservableGauge'

func (*MockFloat64ObservableOption_applyFloat64ObservableGauge_Call) Return 

func (_c *MockFloat64ObservableOption_applyFloat64ObservableGauge_Call) Return(_a0 metric.Float64ObservableGaugeConfig) *MockFloat64ObservableOption_applyFloat64ObservableGauge_Call

func (*MockFloat64ObservableOption_applyFloat64ObservableGauge_Call) Run 

func (_c *MockFloat64ObservableOption_applyFloat64ObservableGauge_Call) Run(run func(_a0 metric.Float64ObservableGaugeConfig)) *MockFloat64ObservableOption_applyFloat64ObservableGauge_Call

func (*MockFloat64ObservableOption_applyFloat64ObservableGauge_Call) RunAndReturn 

func (_c *MockFloat64ObservableOption_applyFloat64ObservableGauge_Call) RunAndReturn(run func(metric.Float64ObservableGaugeConfig) metric.Float64ObservableGaugeConfig) *MockFloat64ObservableOption_applyFloat64ObservableGauge_Call

type MockFloat64ObservableOption_applyFloat64ObservableUpDownCounter_Call 

type MockFloat64ObservableOption_applyFloat64ObservableUpDownCounter_Call struct {
	*mock.Call
}

MockFloat64ObservableOption_applyFloat64ObservableUpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64ObservableUpDownCounter'

func (*MockFloat64ObservableOption_applyFloat64ObservableUpDownCounter_Call) Return 

func (_c *MockFloat64ObservableOption_applyFloat64ObservableUpDownCounter_Call) Return(_a0 metric.Float64ObservableUpDownCounterConfig) *MockFloat64ObservableOption_applyFloat64ObservableUpDownCounter_Call

func (*MockFloat64ObservableOption_applyFloat64ObservableUpDownCounter_Call) Run 

func (_c *MockFloat64ObservableOption_applyFloat64ObservableUpDownCounter_Call) Run(run func(_a0 metric.Float64ObservableUpDownCounterConfig)) *MockFloat64ObservableOption_applyFloat64ObservableUpDownCounter_Call

func (*MockFloat64ObservableOption_applyFloat64ObservableUpDownCounter_Call) RunAndReturn 

func (_c *MockFloat64ObservableOption_applyFloat64ObservableUpDownCounter_Call) RunAndReturn(run func(metric.Float64ObservableUpDownCounterConfig) metric.Float64ObservableUpDownCounterConfig) *MockFloat64ObservableOption_applyFloat64ObservableUpDownCounter_Call

type MockFloat64ObservableUpDownCounter 

type MockFloat64ObservableUpDownCounter struct {
	mock.Mock
}

MockFloat64ObservableUpDownCounter is an autogenerated mock type for the Float64ObservableUpDownCounter type

func NewMockFloat64ObservableUpDownCounter 

func NewMockFloat64ObservableUpDownCounter(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64ObservableUpDownCounter

NewMockFloat64ObservableUpDownCounter creates a new instance of MockFloat64ObservableUpDownCounter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64ObservableUpDownCounter) EXPECT 

func (_m *MockFloat64ObservableUpDownCounter) EXPECT() *MockFloat64ObservableUpDownCounter_Expecter

type MockFloat64ObservableUpDownCounterOption 

type MockFloat64ObservableUpDownCounterOption struct {
	mock.Mock
}

MockFloat64ObservableUpDownCounterOption is an autogenerated mock type for the Float64ObservableUpDownCounterOption type

func NewMockFloat64ObservableUpDownCounterOption 

func NewMockFloat64ObservableUpDownCounterOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64ObservableUpDownCounterOption

NewMockFloat64ObservableUpDownCounterOption creates a new instance of MockFloat64ObservableUpDownCounterOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64ObservableUpDownCounterOption) EXPECT 

func (_m *MockFloat64ObservableUpDownCounterOption) EXPECT() *MockFloat64ObservableUpDownCounterOption_Expecter

type MockFloat64ObservableUpDownCounterOption_Expecter 

type MockFloat64ObservableUpDownCounterOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockFloat64ObservableUpDownCounterOption_applyFloat64ObservableUpDownCounter_Call 

type MockFloat64ObservableUpDownCounterOption_applyFloat64ObservableUpDownCounter_Call struct {
	*mock.Call
}

MockFloat64ObservableUpDownCounterOption_applyFloat64ObservableUpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64ObservableUpDownCounter'

func (*MockFloat64ObservableUpDownCounterOption_applyFloat64ObservableUpDownCounter_Call) Return 

func (_c *MockFloat64ObservableUpDownCounterOption_applyFloat64ObservableUpDownCounter_Call) Return(_a0 metric.Float64ObservableUpDownCounterConfig) *MockFloat64ObservableUpDownCounterOption_applyFloat64ObservableUpDownCounter_Call

func (*MockFloat64ObservableUpDownCounterOption_applyFloat64ObservableUpDownCounter_Call) Run 

func (_c *MockFloat64ObservableUpDownCounterOption_applyFloat64ObservableUpDownCounter_Call) Run(run func(_a0 metric.Float64ObservableUpDownCounterConfig)) *MockFloat64ObservableUpDownCounterOption_applyFloat64ObservableUpDownCounter_Call

func (*MockFloat64ObservableUpDownCounterOption_applyFloat64ObservableUpDownCounter_Call) RunAndReturn 

func (_c *MockFloat64ObservableUpDownCounterOption_applyFloat64ObservableUpDownCounter_Call) RunAndReturn(run func(metric.Float64ObservableUpDownCounterConfig) metric.Float64ObservableUpDownCounterConfig) *MockFloat64ObservableUpDownCounterOption_applyFloat64ObservableUpDownCounter_Call

type MockFloat64ObservableUpDownCounter_Expecter 

type MockFloat64ObservableUpDownCounter_Expecter struct {
	// contains filtered or unexported fields
}

type MockFloat64ObservableUpDownCounter_float64ObservableUpDownCounter_Call 

type MockFloat64ObservableUpDownCounter_float64ObservableUpDownCounter_Call struct {
	*mock.Call
}

MockFloat64ObservableUpDownCounter_float64ObservableUpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'float64ObservableUpDownCounter'

func (*MockFloat64ObservableUpDownCounter_float64ObservableUpDownCounter_Call) Return 

func (_c *MockFloat64ObservableUpDownCounter_float64ObservableUpDownCounter_Call) Return() *MockFloat64ObservableUpDownCounter_float64ObservableUpDownCounter_Call

func (*MockFloat64ObservableUpDownCounter_float64ObservableUpDownCounter_Call) Run 

func (_c *MockFloat64ObservableUpDownCounter_float64ObservableUpDownCounter_Call) Run(run func()) *MockFloat64ObservableUpDownCounter_float64ObservableUpDownCounter_Call

func (*MockFloat64ObservableUpDownCounter_float64ObservableUpDownCounter_Call) RunAndReturn 

func (_c *MockFloat64ObservableUpDownCounter_float64ObservableUpDownCounter_Call) RunAndReturn(run func()) *MockFloat64ObservableUpDownCounter_float64ObservableUpDownCounter_Call

type MockFloat64ObservableUpDownCounter_float64Observable_Call 

type MockFloat64ObservableUpDownCounter_float64Observable_Call struct {
	*mock.Call
}

MockFloat64ObservableUpDownCounter_float64Observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'float64Observable'

func (*MockFloat64ObservableUpDownCounter_float64Observable_Call) Return 

func (_c *MockFloat64ObservableUpDownCounter_float64Observable_Call) Return() *MockFloat64ObservableUpDownCounter_float64Observable_Call

func (*MockFloat64ObservableUpDownCounter_float64Observable_Call) Run 

func (_c *MockFloat64ObservableUpDownCounter_float64Observable_Call) Run(run func()) *MockFloat64ObservableUpDownCounter_float64Observable_Call

func (*MockFloat64ObservableUpDownCounter_float64Observable_Call) RunAndReturn 

func (_c *MockFloat64ObservableUpDownCounter_float64Observable_Call) RunAndReturn(run func()) *MockFloat64ObservableUpDownCounter_float64Observable_Call

type MockFloat64ObservableUpDownCounter_observable_Call 

type MockFloat64ObservableUpDownCounter_observable_Call struct {
	*mock.Call
}

MockFloat64ObservableUpDownCounter_observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'observable'

func (*MockFloat64ObservableUpDownCounter_observable_Call) Return 

func (_c *MockFloat64ObservableUpDownCounter_observable_Call) Return() *MockFloat64ObservableUpDownCounter_observable_Call

func (*MockFloat64ObservableUpDownCounter_observable_Call) Run 

func (_c *MockFloat64ObservableUpDownCounter_observable_Call) Run(run func()) *MockFloat64ObservableUpDownCounter_observable_Call

func (*MockFloat64ObservableUpDownCounter_observable_Call) RunAndReturn 

func (_c *MockFloat64ObservableUpDownCounter_observable_Call) RunAndReturn(run func()) *MockFloat64ObservableUpDownCounter_observable_Call

type MockFloat64Observable_Expecter 

type MockFloat64Observable_Expecter struct {
	// contains filtered or unexported fields
}

type MockFloat64Observable_float64Observable_Call 

type MockFloat64Observable_float64Observable_Call struct {
	*mock.Call
}

MockFloat64Observable_float64Observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'float64Observable'

func (*MockFloat64Observable_float64Observable_Call) Return 

func (_c *MockFloat64Observable_float64Observable_Call) Return() *MockFloat64Observable_float64Observable_Call

func (*MockFloat64Observable_float64Observable_Call) Run 

func (_c *MockFloat64Observable_float64Observable_Call) Run(run func()) *MockFloat64Observable_float64Observable_Call

func (*MockFloat64Observable_float64Observable_Call) RunAndReturn 

func (_c *MockFloat64Observable_float64Observable_Call) RunAndReturn(run func()) *MockFloat64Observable_float64Observable_Call

type MockFloat64Observable_observable_Call 

type MockFloat64Observable_observable_Call struct {
	*mock.Call
}

MockFloat64Observable_observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'observable'

func (*MockFloat64Observable_observable_Call) Return 

func (_c *MockFloat64Observable_observable_Call) Return() *MockFloat64Observable_observable_Call

func (*MockFloat64Observable_observable_Call) Run 

func (_c *MockFloat64Observable_observable_Call) Run(run func()) *MockFloat64Observable_observable_Call

func (*MockFloat64Observable_observable_Call) RunAndReturn 

func (_c *MockFloat64Observable_observable_Call) RunAndReturn(run func()) *MockFloat64Observable_observable_Call

type MockFloat64Observer 

type MockFloat64Observer struct {
	mock.Mock
}

MockFloat64Observer is an autogenerated mock type for the Float64Observer type

func NewMockFloat64Observer 

func NewMockFloat64Observer(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64Observer

NewMockFloat64Observer creates a new instance of MockFloat64Observer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64Observer) EXPECT 

func (_m *MockFloat64Observer) EXPECT() *MockFloat64Observer_Expecter

func (*MockFloat64Observer) Observe 

func (_m *MockFloat64Observer) Observe(value float64, options ...metric.ObserveOption)

Observe provides a mock function with given fields: value, options

type MockFloat64Observer_Expecter 

type MockFloat64Observer_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockFloat64Observer_Expecter) Observe 

func (_e *MockFloat64Observer_Expecter) Observe(value interface{}, options ...interface{}) *MockFloat64Observer_Observe_Call

Observe is a helper method to define mock.On call

  • value float64
  • options ...metric.ObserveOption

type MockFloat64Observer_Observe_Call 

type MockFloat64Observer_Observe_Call struct {
	*mock.Call
}

MockFloat64Observer_Observe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Observe'

func (*MockFloat64Observer_Observe_Call) Return 

func (_c *MockFloat64Observer_Observe_Call) Return() *MockFloat64Observer_Observe_Call

func (*MockFloat64Observer_Observe_Call) Run 

func (_c *MockFloat64Observer_Observe_Call) Run(run func(value float64, options ...metric.ObserveOption)) *MockFloat64Observer_Observe_Call

func (*MockFloat64Observer_Observe_Call) RunAndReturn 

func (_c *MockFloat64Observer_Observe_Call) RunAndReturn(run func(float64, ...metric.ObserveOption)) *MockFloat64Observer_Observe_Call

type MockFloat64Observer_float64Observer_Call 

type MockFloat64Observer_float64Observer_Call struct {
	*mock.Call
}

MockFloat64Observer_float64Observer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'float64Observer'

func (*MockFloat64Observer_float64Observer_Call) Return 

func (_c *MockFloat64Observer_float64Observer_Call) Return() *MockFloat64Observer_float64Observer_Call

func (*MockFloat64Observer_float64Observer_Call) Run 

func (_c *MockFloat64Observer_float64Observer_Call) Run(run func()) *MockFloat64Observer_float64Observer_Call

func (*MockFloat64Observer_float64Observer_Call) RunAndReturn 

func (_c *MockFloat64Observer_float64Observer_Call) RunAndReturn(run func()) *MockFloat64Observer_float64Observer_Call

type MockFloat64UpDownCounter 

type MockFloat64UpDownCounter struct {
	mock.Mock
}

MockFloat64UpDownCounter is an autogenerated mock type for the Float64UpDownCounter type

func NewMockFloat64UpDownCounter 

func NewMockFloat64UpDownCounter(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64UpDownCounter

NewMockFloat64UpDownCounter creates a new instance of MockFloat64UpDownCounter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64UpDownCounter) Add 

func (_m *MockFloat64UpDownCounter) Add(ctx context.Context, incr float64, options ...metric.AddOption)

Add provides a mock function with given fields: ctx, incr, options

func (*MockFloat64UpDownCounter) EXPECT 

func (_m *MockFloat64UpDownCounter) EXPECT() *MockFloat64UpDownCounter_Expecter

type MockFloat64UpDownCounterOption 

type MockFloat64UpDownCounterOption struct {
	mock.Mock
}

MockFloat64UpDownCounterOption is an autogenerated mock type for the Float64UpDownCounterOption type

func NewMockFloat64UpDownCounterOption 

func NewMockFloat64UpDownCounterOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFloat64UpDownCounterOption

NewMockFloat64UpDownCounterOption creates a new instance of MockFloat64UpDownCounterOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFloat64UpDownCounterOption) EXPECT 

func (_m *MockFloat64UpDownCounterOption) EXPECT() *MockFloat64UpDownCounterOption_Expecter

type MockFloat64UpDownCounterOption_Expecter 

type MockFloat64UpDownCounterOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockFloat64UpDownCounterOption_applyFloat64UpDownCounter_Call 

type MockFloat64UpDownCounterOption_applyFloat64UpDownCounter_Call struct {
	*mock.Call
}

MockFloat64UpDownCounterOption_applyFloat64UpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64UpDownCounter'

func (*MockFloat64UpDownCounterOption_applyFloat64UpDownCounter_Call) Return 

func (_c *MockFloat64UpDownCounterOption_applyFloat64UpDownCounter_Call) Return(_a0 metric.Float64UpDownCounterConfig) *MockFloat64UpDownCounterOption_applyFloat64UpDownCounter_Call

func (*MockFloat64UpDownCounterOption_applyFloat64UpDownCounter_Call) Run 

func (_c *MockFloat64UpDownCounterOption_applyFloat64UpDownCounter_Call) Run(run func(_a0 metric.Float64UpDownCounterConfig)) *MockFloat64UpDownCounterOption_applyFloat64UpDownCounter_Call

func (*MockFloat64UpDownCounterOption_applyFloat64UpDownCounter_Call) RunAndReturn 

func (_c *MockFloat64UpDownCounterOption_applyFloat64UpDownCounter_Call) RunAndReturn(run func(metric.Float64UpDownCounterConfig) metric.Float64UpDownCounterConfig) *MockFloat64UpDownCounterOption_applyFloat64UpDownCounter_Call

type MockFloat64UpDownCounter_Add_Call 

type MockFloat64UpDownCounter_Add_Call struct {
	*mock.Call
}

MockFloat64UpDownCounter_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add'

func (*MockFloat64UpDownCounter_Add_Call) Return 

func (_c *MockFloat64UpDownCounter_Add_Call) Return() *MockFloat64UpDownCounter_Add_Call

func (*MockFloat64UpDownCounter_Add_Call) Run 

func (_c *MockFloat64UpDownCounter_Add_Call) Run(run func(ctx context.Context, incr float64, options ...metric.AddOption)) *MockFloat64UpDownCounter_Add_Call

func (*MockFloat64UpDownCounter_Add_Call) RunAndReturn 

func (_c *MockFloat64UpDownCounter_Add_Call) RunAndReturn(run func(context.Context, float64, ...metric.AddOption)) *MockFloat64UpDownCounter_Add_Call

type MockFloat64UpDownCounter_Expecter 

type MockFloat64UpDownCounter_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockFloat64UpDownCounter_Expecter) Add 

func (_e *MockFloat64UpDownCounter_Expecter) Add(ctx interface{}, incr interface{}, options ...interface{}) *MockFloat64UpDownCounter_Add_Call

Add is a helper method to define mock.On call

  • ctx context.Context
  • incr float64
  • options ...metric.AddOption

type MockFloat64UpDownCounter_float64UpDownCounter_Call 

type MockFloat64UpDownCounter_float64UpDownCounter_Call struct {
	*mock.Call
}

MockFloat64UpDownCounter_float64UpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'float64UpDownCounter'

func (*MockFloat64UpDownCounter_float64UpDownCounter_Call) Return 

func (_c *MockFloat64UpDownCounter_float64UpDownCounter_Call) Return() *MockFloat64UpDownCounter_float64UpDownCounter_Call

func (*MockFloat64UpDownCounter_float64UpDownCounter_Call) Run 

func (_c *MockFloat64UpDownCounter_float64UpDownCounter_Call) Run(run func()) *MockFloat64UpDownCounter_float64UpDownCounter_Call

func (*MockFloat64UpDownCounter_float64UpDownCounter_Call) RunAndReturn 

func (_c *MockFloat64UpDownCounter_float64UpDownCounter_Call) RunAndReturn(run func()) *MockFloat64UpDownCounter_float64UpDownCounter_Call

type MockHistogramOption 

type MockHistogramOption struct {
	mock.Mock
}

MockHistogramOption is an autogenerated mock type for the HistogramOption type

func NewMockHistogramOption 

func NewMockHistogramOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockHistogramOption

NewMockHistogramOption creates a new instance of MockHistogramOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockHistogramOption) EXPECT 

func (_m *MockHistogramOption) EXPECT() *MockHistogramOption_Expecter

type MockHistogramOption_Expecter 

type MockHistogramOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockHistogramOption_applyFloat64Histogram_Call 

type MockHistogramOption_applyFloat64Histogram_Call struct {
	*mock.Call
}

MockHistogramOption_applyFloat64Histogram_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64Histogram'

func (*MockHistogramOption_applyFloat64Histogram_Call) Return 

func (_c *MockHistogramOption_applyFloat64Histogram_Call) Return(_a0 metric.Float64HistogramConfig) *MockHistogramOption_applyFloat64Histogram_Call

func (*MockHistogramOption_applyFloat64Histogram_Call) Run 

func (_c *MockHistogramOption_applyFloat64Histogram_Call) Run(run func(_a0 metric.Float64HistogramConfig)) *MockHistogramOption_applyFloat64Histogram_Call

func (*MockHistogramOption_applyFloat64Histogram_Call) RunAndReturn 

func (_c *MockHistogramOption_applyFloat64Histogram_Call) RunAndReturn(run func(metric.Float64HistogramConfig) metric.Float64HistogramConfig) *MockHistogramOption_applyFloat64Histogram_Call

type MockHistogramOption_applyInt64Histogram_Call 

type MockHistogramOption_applyInt64Histogram_Call struct {
	*mock.Call
}

MockHistogramOption_applyInt64Histogram_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64Histogram'

func (*MockHistogramOption_applyInt64Histogram_Call) Return 

func (_c *MockHistogramOption_applyInt64Histogram_Call) Return(_a0 metric.Int64HistogramConfig) *MockHistogramOption_applyInt64Histogram_Call

func (*MockHistogramOption_applyInt64Histogram_Call) Run 

func (_c *MockHistogramOption_applyInt64Histogram_Call) Run(run func(_a0 metric.Int64HistogramConfig)) *MockHistogramOption_applyInt64Histogram_Call

func (*MockHistogramOption_applyInt64Histogram_Call) RunAndReturn 

func (_c *MockHistogramOption_applyInt64Histogram_Call) RunAndReturn(run func(metric.Int64HistogramConfig) metric.Int64HistogramConfig) *MockHistogramOption_applyInt64Histogram_Call

type MockInstrumentOption 

type MockInstrumentOption struct {
	mock.Mock
}

MockInstrumentOption is an autogenerated mock type for the InstrumentOption type

func NewMockInstrumentOption 

func NewMockInstrumentOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInstrumentOption

NewMockInstrumentOption creates a new instance of MockInstrumentOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInstrumentOption) EXPECT 

func (_m *MockInstrumentOption) EXPECT() *MockInstrumentOption_Expecter

type MockInstrumentOption_Expecter 

type MockInstrumentOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockInstrumentOption_applyFloat64Counter_Call 

type MockInstrumentOption_applyFloat64Counter_Call struct {
	*mock.Call
}

MockInstrumentOption_applyFloat64Counter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64Counter'

func (*MockInstrumentOption_applyFloat64Counter_Call) Return 

func (_c *MockInstrumentOption_applyFloat64Counter_Call) Return(_a0 metric.Float64CounterConfig) *MockInstrumentOption_applyFloat64Counter_Call

func (*MockInstrumentOption_applyFloat64Counter_Call) Run 

func (_c *MockInstrumentOption_applyFloat64Counter_Call) Run(run func(_a0 metric.Float64CounterConfig)) *MockInstrumentOption_applyFloat64Counter_Call

func (*MockInstrumentOption_applyFloat64Counter_Call) RunAndReturn 

func (_c *MockInstrumentOption_applyFloat64Counter_Call) RunAndReturn(run func(metric.Float64CounterConfig) metric.Float64CounterConfig) *MockInstrumentOption_applyFloat64Counter_Call

type MockInstrumentOption_applyFloat64Gauge_Call 

type MockInstrumentOption_applyFloat64Gauge_Call struct {
	*mock.Call
}

MockInstrumentOption_applyFloat64Gauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64Gauge'

func (*MockInstrumentOption_applyFloat64Gauge_Call) Return 

func (_c *MockInstrumentOption_applyFloat64Gauge_Call) Return(_a0 metric.Float64GaugeConfig) *MockInstrumentOption_applyFloat64Gauge_Call

func (*MockInstrumentOption_applyFloat64Gauge_Call) Run 

func (_c *MockInstrumentOption_applyFloat64Gauge_Call) Run(run func(_a0 metric.Float64GaugeConfig)) *MockInstrumentOption_applyFloat64Gauge_Call

func (*MockInstrumentOption_applyFloat64Gauge_Call) RunAndReturn 

func (_c *MockInstrumentOption_applyFloat64Gauge_Call) RunAndReturn(run func(metric.Float64GaugeConfig) metric.Float64GaugeConfig) *MockInstrumentOption_applyFloat64Gauge_Call

type MockInstrumentOption_applyFloat64Histogram_Call 

type MockInstrumentOption_applyFloat64Histogram_Call struct {
	*mock.Call
}

MockInstrumentOption_applyFloat64Histogram_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64Histogram'

func (*MockInstrumentOption_applyFloat64Histogram_Call) Return 

func (_c *MockInstrumentOption_applyFloat64Histogram_Call) Return(_a0 metric.Float64HistogramConfig) *MockInstrumentOption_applyFloat64Histogram_Call

func (*MockInstrumentOption_applyFloat64Histogram_Call) Run 

func (_c *MockInstrumentOption_applyFloat64Histogram_Call) Run(run func(_a0 metric.Float64HistogramConfig)) *MockInstrumentOption_applyFloat64Histogram_Call

func (*MockInstrumentOption_applyFloat64Histogram_Call) RunAndReturn 

func (_c *MockInstrumentOption_applyFloat64Histogram_Call) RunAndReturn(run func(metric.Float64HistogramConfig) metric.Float64HistogramConfig) *MockInstrumentOption_applyFloat64Histogram_Call

type MockInstrumentOption_applyFloat64ObservableCounter_Call 

type MockInstrumentOption_applyFloat64ObservableCounter_Call struct {
	*mock.Call
}

MockInstrumentOption_applyFloat64ObservableCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64ObservableCounter'

func (*MockInstrumentOption_applyFloat64ObservableCounter_Call) Return 

func (_c *MockInstrumentOption_applyFloat64ObservableCounter_Call) Return(_a0 metric.Float64ObservableCounterConfig) *MockInstrumentOption_applyFloat64ObservableCounter_Call

func (*MockInstrumentOption_applyFloat64ObservableCounter_Call) Run 

func (_c *MockInstrumentOption_applyFloat64ObservableCounter_Call) Run(run func(_a0 metric.Float64ObservableCounterConfig)) *MockInstrumentOption_applyFloat64ObservableCounter_Call

func (*MockInstrumentOption_applyFloat64ObservableCounter_Call) RunAndReturn 

func (_c *MockInstrumentOption_applyFloat64ObservableCounter_Call) RunAndReturn(run func(metric.Float64ObservableCounterConfig) metric.Float64ObservableCounterConfig) *MockInstrumentOption_applyFloat64ObservableCounter_Call

type MockInstrumentOption_applyFloat64ObservableGauge_Call 

type MockInstrumentOption_applyFloat64ObservableGauge_Call struct {
	*mock.Call
}

MockInstrumentOption_applyFloat64ObservableGauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64ObservableGauge'

func (*MockInstrumentOption_applyFloat64ObservableGauge_Call) Return 

func (_c *MockInstrumentOption_applyFloat64ObservableGauge_Call) Return(_a0 metric.Float64ObservableGaugeConfig) *MockInstrumentOption_applyFloat64ObservableGauge_Call

func (*MockInstrumentOption_applyFloat64ObservableGauge_Call) Run 

func (_c *MockInstrumentOption_applyFloat64ObservableGauge_Call) Run(run func(_a0 metric.Float64ObservableGaugeConfig)) *MockInstrumentOption_applyFloat64ObservableGauge_Call

func (*MockInstrumentOption_applyFloat64ObservableGauge_Call) RunAndReturn 

func (_c *MockInstrumentOption_applyFloat64ObservableGauge_Call) RunAndReturn(run func(metric.Float64ObservableGaugeConfig) metric.Float64ObservableGaugeConfig) *MockInstrumentOption_applyFloat64ObservableGauge_Call

type MockInstrumentOption_applyFloat64ObservableUpDownCounter_Call 

type MockInstrumentOption_applyFloat64ObservableUpDownCounter_Call struct {
	*mock.Call
}

MockInstrumentOption_applyFloat64ObservableUpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64ObservableUpDownCounter'

func (*MockInstrumentOption_applyFloat64ObservableUpDownCounter_Call) Return 

func (_c *MockInstrumentOption_applyFloat64ObservableUpDownCounter_Call) Return(_a0 metric.Float64ObservableUpDownCounterConfig) *MockInstrumentOption_applyFloat64ObservableUpDownCounter_Call

func (*MockInstrumentOption_applyFloat64ObservableUpDownCounter_Call) Run 

func (_c *MockInstrumentOption_applyFloat64ObservableUpDownCounter_Call) Run(run func(_a0 metric.Float64ObservableUpDownCounterConfig)) *MockInstrumentOption_applyFloat64ObservableUpDownCounter_Call

func (*MockInstrumentOption_applyFloat64ObservableUpDownCounter_Call) RunAndReturn 

func (_c *MockInstrumentOption_applyFloat64ObservableUpDownCounter_Call) RunAndReturn(run func(metric.Float64ObservableUpDownCounterConfig) metric.Float64ObservableUpDownCounterConfig) *MockInstrumentOption_applyFloat64ObservableUpDownCounter_Call

type MockInstrumentOption_applyFloat64UpDownCounter_Call 

type MockInstrumentOption_applyFloat64UpDownCounter_Call struct {
	*mock.Call
}

MockInstrumentOption_applyFloat64UpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyFloat64UpDownCounter'

func (*MockInstrumentOption_applyFloat64UpDownCounter_Call) Return 

func (_c *MockInstrumentOption_applyFloat64UpDownCounter_Call) Return(_a0 metric.Float64UpDownCounterConfig) *MockInstrumentOption_applyFloat64UpDownCounter_Call

func (*MockInstrumentOption_applyFloat64UpDownCounter_Call) Run 

func (_c *MockInstrumentOption_applyFloat64UpDownCounter_Call) Run(run func(_a0 metric.Float64UpDownCounterConfig)) *MockInstrumentOption_applyFloat64UpDownCounter_Call

func (*MockInstrumentOption_applyFloat64UpDownCounter_Call) RunAndReturn 

func (_c *MockInstrumentOption_applyFloat64UpDownCounter_Call) RunAndReturn(run func(metric.Float64UpDownCounterConfig) metric.Float64UpDownCounterConfig) *MockInstrumentOption_applyFloat64UpDownCounter_Call

type MockInstrumentOption_applyInt64Counter_Call 

type MockInstrumentOption_applyInt64Counter_Call struct {
	*mock.Call
}

MockInstrumentOption_applyInt64Counter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64Counter'

func (*MockInstrumentOption_applyInt64Counter_Call) Return 

func (_c *MockInstrumentOption_applyInt64Counter_Call) Return(_a0 metric.Int64CounterConfig) *MockInstrumentOption_applyInt64Counter_Call

func (*MockInstrumentOption_applyInt64Counter_Call) Run 

func (_c *MockInstrumentOption_applyInt64Counter_Call) Run(run func(_a0 metric.Int64CounterConfig)) *MockInstrumentOption_applyInt64Counter_Call

func (*MockInstrumentOption_applyInt64Counter_Call) RunAndReturn 

func (_c *MockInstrumentOption_applyInt64Counter_Call) RunAndReturn(run func(metric.Int64CounterConfig) metric.Int64CounterConfig) *MockInstrumentOption_applyInt64Counter_Call

type MockInstrumentOption_applyInt64Gauge_Call 

type MockInstrumentOption_applyInt64Gauge_Call struct {
	*mock.Call
}

MockInstrumentOption_applyInt64Gauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64Gauge'

func (*MockInstrumentOption_applyInt64Gauge_Call) Return 

func (_c *MockInstrumentOption_applyInt64Gauge_Call) Return(_a0 metric.Int64GaugeConfig) *MockInstrumentOption_applyInt64Gauge_Call

func (*MockInstrumentOption_applyInt64Gauge_Call) Run 

func (_c *MockInstrumentOption_applyInt64Gauge_Call) Run(run func(_a0 metric.Int64GaugeConfig)) *MockInstrumentOption_applyInt64Gauge_Call

func (*MockInstrumentOption_applyInt64Gauge_Call) RunAndReturn 

func (_c *MockInstrumentOption_applyInt64Gauge_Call) RunAndReturn(run func(metric.Int64GaugeConfig) metric.Int64GaugeConfig) *MockInstrumentOption_applyInt64Gauge_Call

type MockInstrumentOption_applyInt64Histogram_Call 

type MockInstrumentOption_applyInt64Histogram_Call struct {
	*mock.Call
}

MockInstrumentOption_applyInt64Histogram_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64Histogram'

func (*MockInstrumentOption_applyInt64Histogram_Call) Return 

func (_c *MockInstrumentOption_applyInt64Histogram_Call) Return(_a0 metric.Int64HistogramConfig) *MockInstrumentOption_applyInt64Histogram_Call

func (*MockInstrumentOption_applyInt64Histogram_Call) Run 

func (_c *MockInstrumentOption_applyInt64Histogram_Call) Run(run func(_a0 metric.Int64HistogramConfig)) *MockInstrumentOption_applyInt64Histogram_Call

func (*MockInstrumentOption_applyInt64Histogram_Call) RunAndReturn 

func (_c *MockInstrumentOption_applyInt64Histogram_Call) RunAndReturn(run func(metric.Int64HistogramConfig) metric.Int64HistogramConfig) *MockInstrumentOption_applyInt64Histogram_Call

type MockInstrumentOption_applyInt64ObservableCounter_Call 

type MockInstrumentOption_applyInt64ObservableCounter_Call struct {
	*mock.Call
}

MockInstrumentOption_applyInt64ObservableCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64ObservableCounter'

func (*MockInstrumentOption_applyInt64ObservableCounter_Call) Return 

func (_c *MockInstrumentOption_applyInt64ObservableCounter_Call) Return(_a0 metric.Int64ObservableCounterConfig) *MockInstrumentOption_applyInt64ObservableCounter_Call

func (*MockInstrumentOption_applyInt64ObservableCounter_Call) Run 

func (_c *MockInstrumentOption_applyInt64ObservableCounter_Call) Run(run func(_a0 metric.Int64ObservableCounterConfig)) *MockInstrumentOption_applyInt64ObservableCounter_Call

func (*MockInstrumentOption_applyInt64ObservableCounter_Call) RunAndReturn 

func (_c *MockInstrumentOption_applyInt64ObservableCounter_Call) RunAndReturn(run func(metric.Int64ObservableCounterConfig) metric.Int64ObservableCounterConfig) *MockInstrumentOption_applyInt64ObservableCounter_Call

type MockInstrumentOption_applyInt64ObservableGauge_Call 

type MockInstrumentOption_applyInt64ObservableGauge_Call struct {
	*mock.Call
}

MockInstrumentOption_applyInt64ObservableGauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64ObservableGauge'

func (*MockInstrumentOption_applyInt64ObservableGauge_Call) Return 

func (_c *MockInstrumentOption_applyInt64ObservableGauge_Call) Return(_a0 metric.Int64ObservableGaugeConfig) *MockInstrumentOption_applyInt64ObservableGauge_Call

func (*MockInstrumentOption_applyInt64ObservableGauge_Call) Run 

func (_c *MockInstrumentOption_applyInt64ObservableGauge_Call) Run(run func(_a0 metric.Int64ObservableGaugeConfig)) *MockInstrumentOption_applyInt64ObservableGauge_Call

func (*MockInstrumentOption_applyInt64ObservableGauge_Call) RunAndReturn 

func (_c *MockInstrumentOption_applyInt64ObservableGauge_Call) RunAndReturn(run func(metric.Int64ObservableGaugeConfig) metric.Int64ObservableGaugeConfig) *MockInstrumentOption_applyInt64ObservableGauge_Call

type MockInstrumentOption_applyInt64ObservableUpDownCounter_Call 

type MockInstrumentOption_applyInt64ObservableUpDownCounter_Call struct {
	*mock.Call
}

MockInstrumentOption_applyInt64ObservableUpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64ObservableUpDownCounter'

func (*MockInstrumentOption_applyInt64ObservableUpDownCounter_Call) Return 

func (_c *MockInstrumentOption_applyInt64ObservableUpDownCounter_Call) Return(_a0 metric.Int64ObservableUpDownCounterConfig) *MockInstrumentOption_applyInt64ObservableUpDownCounter_Call

func (*MockInstrumentOption_applyInt64ObservableUpDownCounter_Call) Run 

func (_c *MockInstrumentOption_applyInt64ObservableUpDownCounter_Call) Run(run func(_a0 metric.Int64ObservableUpDownCounterConfig)) *MockInstrumentOption_applyInt64ObservableUpDownCounter_Call

func (*MockInstrumentOption_applyInt64ObservableUpDownCounter_Call) RunAndReturn 

func (_c *MockInstrumentOption_applyInt64ObservableUpDownCounter_Call) RunAndReturn(run func(metric.Int64ObservableUpDownCounterConfig) metric.Int64ObservableUpDownCounterConfig) *MockInstrumentOption_applyInt64ObservableUpDownCounter_Call

type MockInstrumentOption_applyInt64UpDownCounter_Call 

type MockInstrumentOption_applyInt64UpDownCounter_Call struct {
	*mock.Call
}

MockInstrumentOption_applyInt64UpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64UpDownCounter'

func (*MockInstrumentOption_applyInt64UpDownCounter_Call) Return 

func (_c *MockInstrumentOption_applyInt64UpDownCounter_Call) Return(_a0 metric.Int64UpDownCounterConfig) *MockInstrumentOption_applyInt64UpDownCounter_Call

func (*MockInstrumentOption_applyInt64UpDownCounter_Call) Run 

func (_c *MockInstrumentOption_applyInt64UpDownCounter_Call) Run(run func(_a0 metric.Int64UpDownCounterConfig)) *MockInstrumentOption_applyInt64UpDownCounter_Call

func (*MockInstrumentOption_applyInt64UpDownCounter_Call) RunAndReturn 

func (_c *MockInstrumentOption_applyInt64UpDownCounter_Call) RunAndReturn(run func(metric.Int64UpDownCounterConfig) metric.Int64UpDownCounterConfig) *MockInstrumentOption_applyInt64UpDownCounter_Call

type MockInt64Callback 

type MockInt64Callback struct {
	mock.Mock
}

MockInt64Callback is an autogenerated mock type for the Int64Callback type

func NewMockInt64Callback 

func NewMockInt64Callback(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64Callback

NewMockInt64Callback creates a new instance of MockInt64Callback. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64Callback) EXPECT 

func (_m *MockInt64Callback) EXPECT() *MockInt64Callback_Expecter

func (*MockInt64Callback) Execute 

func (_m *MockInt64Callback) Execute(_a0 context.Context, _a1 metric.Int64Observer) error

Execute provides a mock function with given fields: _a0, _a1

type MockInt64Callback_Execute_Call 

type MockInt64Callback_Execute_Call struct {
	*mock.Call
}

MockInt64Callback_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'

func (*MockInt64Callback_Execute_Call) Return 

func (_c *MockInt64Callback_Execute_Call) Return(_a0 error) *MockInt64Callback_Execute_Call

func (*MockInt64Callback_Execute_Call) Run 

func (_c *MockInt64Callback_Execute_Call) Run(run func(_a0 context.Context, _a1 metric.Int64Observer)) *MockInt64Callback_Execute_Call

func (*MockInt64Callback_Execute_Call) RunAndReturn 

func (_c *MockInt64Callback_Execute_Call) RunAndReturn(run func(context.Context, metric.Int64Observer) error) *MockInt64Callback_Execute_Call

type MockInt64Callback_Expecter 

type MockInt64Callback_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockInt64Callback_Expecter) Execute 

func (_e *MockInt64Callback_Expecter) Execute(_a0 interface{}, _a1 interface{}) *MockInt64Callback_Execute_Call

Execute is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 metric.Int64Observer

type MockInt64Counter 

type MockInt64Counter struct {
	mock.Mock
}

MockInt64Counter is an autogenerated mock type for the Int64Counter type

func NewMockInt64Counter 

func NewMockInt64Counter(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64Counter

NewMockInt64Counter creates a new instance of MockInt64Counter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64Counter) Add 

func (_m *MockInt64Counter) Add(ctx context.Context, incr int64, options ...metric.AddOption)

Add provides a mock function with given fields: ctx, incr, options

func (*MockInt64Counter) EXPECT 

func (_m *MockInt64Counter) EXPECT() *MockInt64Counter_Expecter

type MockInt64CounterOption 

type MockInt64CounterOption struct {
	mock.Mock
}

MockInt64CounterOption is an autogenerated mock type for the Int64CounterOption type

func NewMockInt64CounterOption 

func NewMockInt64CounterOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64CounterOption

NewMockInt64CounterOption creates a new instance of MockInt64CounterOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64CounterOption) EXPECT 

func (_m *MockInt64CounterOption) EXPECT() *MockInt64CounterOption_Expecter

type MockInt64CounterOption_Expecter 

type MockInt64CounterOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockInt64CounterOption_applyInt64Counter_Call 

type MockInt64CounterOption_applyInt64Counter_Call struct {
	*mock.Call
}

MockInt64CounterOption_applyInt64Counter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64Counter'

func (*MockInt64CounterOption_applyInt64Counter_Call) Return 

func (_c *MockInt64CounterOption_applyInt64Counter_Call) Return(_a0 metric.Int64CounterConfig) *MockInt64CounterOption_applyInt64Counter_Call

func (*MockInt64CounterOption_applyInt64Counter_Call) Run 

func (_c *MockInt64CounterOption_applyInt64Counter_Call) Run(run func(_a0 metric.Int64CounterConfig)) *MockInt64CounterOption_applyInt64Counter_Call

func (*MockInt64CounterOption_applyInt64Counter_Call) RunAndReturn 

func (_c *MockInt64CounterOption_applyInt64Counter_Call) RunAndReturn(run func(metric.Int64CounterConfig) metric.Int64CounterConfig) *MockInt64CounterOption_applyInt64Counter_Call

type MockInt64Counter_Add_Call 

type MockInt64Counter_Add_Call struct {
	*mock.Call
}

MockInt64Counter_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add'

func (*MockInt64Counter_Add_Call) Return 

func (_c *MockInt64Counter_Add_Call) Return() *MockInt64Counter_Add_Call

func (*MockInt64Counter_Add_Call) Run 

func (_c *MockInt64Counter_Add_Call) Run(run func(ctx context.Context, incr int64, options ...metric.AddOption)) *MockInt64Counter_Add_Call

func (*MockInt64Counter_Add_Call) RunAndReturn 

func (_c *MockInt64Counter_Add_Call) RunAndReturn(run func(context.Context, int64, ...metric.AddOption)) *MockInt64Counter_Add_Call

type MockInt64Counter_Expecter 

type MockInt64Counter_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockInt64Counter_Expecter) Add 

func (_e *MockInt64Counter_Expecter) Add(ctx interface{}, incr interface{}, options ...interface{}) *MockInt64Counter_Add_Call

Add is a helper method to define mock.On call

  • ctx context.Context
  • incr int64
  • options ...metric.AddOption

type MockInt64Counter_int64Counter_Call 

type MockInt64Counter_int64Counter_Call struct {
	*mock.Call
}

MockInt64Counter_int64Counter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'int64Counter'

func (*MockInt64Counter_int64Counter_Call) Return 

func (_c *MockInt64Counter_int64Counter_Call) Return() *MockInt64Counter_int64Counter_Call

func (*MockInt64Counter_int64Counter_Call) Run 

func (_c *MockInt64Counter_int64Counter_Call) Run(run func()) *MockInt64Counter_int64Counter_Call

func (*MockInt64Counter_int64Counter_Call) RunAndReturn 

func (_c *MockInt64Counter_int64Counter_Call) RunAndReturn(run func()) *MockInt64Counter_int64Counter_Call

type MockInt64Gauge 

type MockInt64Gauge struct {
	mock.Mock
}

MockInt64Gauge is an autogenerated mock type for the Int64Gauge type

func NewMockInt64Gauge 

func NewMockInt64Gauge(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64Gauge

NewMockInt64Gauge creates a new instance of MockInt64Gauge. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64Gauge) EXPECT 

func (_m *MockInt64Gauge) EXPECT() *MockInt64Gauge_Expecter

func (*MockInt64Gauge) Record 

func (_m *MockInt64Gauge) Record(ctx context.Context, value int64, options ...metric.RecordOption)

Record provides a mock function with given fields: ctx, value, options

type MockInt64GaugeOption 

type MockInt64GaugeOption struct {
	mock.Mock
}

MockInt64GaugeOption is an autogenerated mock type for the Int64GaugeOption type

func NewMockInt64GaugeOption 

func NewMockInt64GaugeOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64GaugeOption

NewMockInt64GaugeOption creates a new instance of MockInt64GaugeOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64GaugeOption) EXPECT 

func (_m *MockInt64GaugeOption) EXPECT() *MockInt64GaugeOption_Expecter

type MockInt64GaugeOption_Expecter 

type MockInt64GaugeOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockInt64GaugeOption_applyInt64Gauge_Call 

type MockInt64GaugeOption_applyInt64Gauge_Call struct {
	*mock.Call
}

MockInt64GaugeOption_applyInt64Gauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64Gauge'

func (*MockInt64GaugeOption_applyInt64Gauge_Call) Return 

func (_c *MockInt64GaugeOption_applyInt64Gauge_Call) Return(_a0 metric.Int64GaugeConfig) *MockInt64GaugeOption_applyInt64Gauge_Call

func (*MockInt64GaugeOption_applyInt64Gauge_Call) Run 

func (_c *MockInt64GaugeOption_applyInt64Gauge_Call) Run(run func(_a0 metric.Int64GaugeConfig)) *MockInt64GaugeOption_applyInt64Gauge_Call

func (*MockInt64GaugeOption_applyInt64Gauge_Call) RunAndReturn 

func (_c *MockInt64GaugeOption_applyInt64Gauge_Call) RunAndReturn(run func(metric.Int64GaugeConfig) metric.Int64GaugeConfig) *MockInt64GaugeOption_applyInt64Gauge_Call

type MockInt64Gauge_Expecter 

type MockInt64Gauge_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockInt64Gauge_Expecter) Record 

func (_e *MockInt64Gauge_Expecter) Record(ctx interface{}, value interface{}, options ...interface{}) *MockInt64Gauge_Record_Call

Record is a helper method to define mock.On call

  • ctx context.Context
  • value int64
  • options ...metric.RecordOption

type MockInt64Gauge_Record_Call 

type MockInt64Gauge_Record_Call struct {
	*mock.Call
}

MockInt64Gauge_Record_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Record'

func (*MockInt64Gauge_Record_Call) Return 

func (_c *MockInt64Gauge_Record_Call) Return() *MockInt64Gauge_Record_Call

func (*MockInt64Gauge_Record_Call) Run 

func (_c *MockInt64Gauge_Record_Call) Run(run func(ctx context.Context, value int64, options ...metric.RecordOption)) *MockInt64Gauge_Record_Call

func (*MockInt64Gauge_Record_Call) RunAndReturn 

func (_c *MockInt64Gauge_Record_Call) RunAndReturn(run func(context.Context, int64, ...metric.RecordOption)) *MockInt64Gauge_Record_Call

type MockInt64Gauge_int64Gauge_Call 

type MockInt64Gauge_int64Gauge_Call struct {
	*mock.Call
}

MockInt64Gauge_int64Gauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'int64Gauge'

func (*MockInt64Gauge_int64Gauge_Call) Return 

func (_c *MockInt64Gauge_int64Gauge_Call) Return() *MockInt64Gauge_int64Gauge_Call

func (*MockInt64Gauge_int64Gauge_Call) Run 

func (_c *MockInt64Gauge_int64Gauge_Call) Run(run func()) *MockInt64Gauge_int64Gauge_Call

func (*MockInt64Gauge_int64Gauge_Call) RunAndReturn 

func (_c *MockInt64Gauge_int64Gauge_Call) RunAndReturn(run func()) *MockInt64Gauge_int64Gauge_Call

type MockInt64Histogram 

type MockInt64Histogram struct {
	mock.Mock
}

MockInt64Histogram is an autogenerated mock type for the Int64Histogram type

func NewMockInt64Histogram 

func NewMockInt64Histogram(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64Histogram

NewMockInt64Histogram creates a new instance of MockInt64Histogram. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64Histogram) EXPECT 

func (_m *MockInt64Histogram) EXPECT() *MockInt64Histogram_Expecter

func (*MockInt64Histogram) Record 

func (_m *MockInt64Histogram) Record(ctx context.Context, incr int64, options ...metric.RecordOption)

Record provides a mock function with given fields: ctx, incr, options

type MockInt64HistogramOption 

type MockInt64HistogramOption struct {
	mock.Mock
}

MockInt64HistogramOption is an autogenerated mock type for the Int64HistogramOption type

func NewMockInt64HistogramOption 

func NewMockInt64HistogramOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64HistogramOption

NewMockInt64HistogramOption creates a new instance of MockInt64HistogramOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64HistogramOption) EXPECT 

func (_m *MockInt64HistogramOption) EXPECT() *MockInt64HistogramOption_Expecter

type MockInt64HistogramOption_Expecter 

type MockInt64HistogramOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockInt64HistogramOption_applyInt64Histogram_Call 

type MockInt64HistogramOption_applyInt64Histogram_Call struct {
	*mock.Call
}

MockInt64HistogramOption_applyInt64Histogram_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64Histogram'

func (*MockInt64HistogramOption_applyInt64Histogram_Call) Return 

func (_c *MockInt64HistogramOption_applyInt64Histogram_Call) Return(_a0 metric.Int64HistogramConfig) *MockInt64HistogramOption_applyInt64Histogram_Call

func (*MockInt64HistogramOption_applyInt64Histogram_Call) Run 

func (_c *MockInt64HistogramOption_applyInt64Histogram_Call) Run(run func(_a0 metric.Int64HistogramConfig)) *MockInt64HistogramOption_applyInt64Histogram_Call

func (*MockInt64HistogramOption_applyInt64Histogram_Call) RunAndReturn 

func (_c *MockInt64HistogramOption_applyInt64Histogram_Call) RunAndReturn(run func(metric.Int64HistogramConfig) metric.Int64HistogramConfig) *MockInt64HistogramOption_applyInt64Histogram_Call

type MockInt64Histogram_Expecter 

type MockInt64Histogram_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockInt64Histogram_Expecter) Record 

func (_e *MockInt64Histogram_Expecter) Record(ctx interface{}, incr interface{}, options ...interface{}) *MockInt64Histogram_Record_Call

Record is a helper method to define mock.On call

  • ctx context.Context
  • incr int64
  • options ...metric.RecordOption

type MockInt64Histogram_Record_Call 

type MockInt64Histogram_Record_Call struct {
	*mock.Call
}

MockInt64Histogram_Record_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Record'

func (*MockInt64Histogram_Record_Call) Return 

func (_c *MockInt64Histogram_Record_Call) Return() *MockInt64Histogram_Record_Call

func (*MockInt64Histogram_Record_Call) Run 

func (_c *MockInt64Histogram_Record_Call) Run(run func(ctx context.Context, incr int64, options ...metric.RecordOption)) *MockInt64Histogram_Record_Call

func (*MockInt64Histogram_Record_Call) RunAndReturn 

func (_c *MockInt64Histogram_Record_Call) RunAndReturn(run func(context.Context, int64, ...metric.RecordOption)) *MockInt64Histogram_Record_Call

type MockInt64Histogram_int64Histogram_Call 

type MockInt64Histogram_int64Histogram_Call struct {
	*mock.Call
}

MockInt64Histogram_int64Histogram_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'int64Histogram'

func (*MockInt64Histogram_int64Histogram_Call) Return 

func (_c *MockInt64Histogram_int64Histogram_Call) Return() *MockInt64Histogram_int64Histogram_Call

func (*MockInt64Histogram_int64Histogram_Call) Run 

func (_c *MockInt64Histogram_int64Histogram_Call) Run(run func()) *MockInt64Histogram_int64Histogram_Call

func (*MockInt64Histogram_int64Histogram_Call) RunAndReturn 

func (_c *MockInt64Histogram_int64Histogram_Call) RunAndReturn(run func()) *MockInt64Histogram_int64Histogram_Call

type MockInt64Observable 

type MockInt64Observable struct {
	mock.Mock
}

MockInt64Observable is an autogenerated mock type for the Int64Observable type

func NewMockInt64Observable 

func NewMockInt64Observable(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64Observable

NewMockInt64Observable creates a new instance of MockInt64Observable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64Observable) EXPECT 

func (_m *MockInt64Observable) EXPECT() *MockInt64Observable_Expecter

type MockInt64ObservableCounter 

type MockInt64ObservableCounter struct {
	mock.Mock
}

MockInt64ObservableCounter is an autogenerated mock type for the Int64ObservableCounter type

func NewMockInt64ObservableCounter 

func NewMockInt64ObservableCounter(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64ObservableCounter

NewMockInt64ObservableCounter creates a new instance of MockInt64ObservableCounter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64ObservableCounter) EXPECT 

func (_m *MockInt64ObservableCounter) EXPECT() *MockInt64ObservableCounter_Expecter

type MockInt64ObservableCounterOption 

type MockInt64ObservableCounterOption struct {
	mock.Mock
}

MockInt64ObservableCounterOption is an autogenerated mock type for the Int64ObservableCounterOption type

func NewMockInt64ObservableCounterOption 

func NewMockInt64ObservableCounterOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64ObservableCounterOption

NewMockInt64ObservableCounterOption creates a new instance of MockInt64ObservableCounterOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64ObservableCounterOption) EXPECT 

func (_m *MockInt64ObservableCounterOption) EXPECT() *MockInt64ObservableCounterOption_Expecter

type MockInt64ObservableCounterOption_Expecter 

type MockInt64ObservableCounterOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockInt64ObservableCounterOption_applyInt64ObservableCounter_Call 

type MockInt64ObservableCounterOption_applyInt64ObservableCounter_Call struct {
	*mock.Call
}

MockInt64ObservableCounterOption_applyInt64ObservableCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64ObservableCounter'

func (*MockInt64ObservableCounterOption_applyInt64ObservableCounter_Call) Return 

func (_c *MockInt64ObservableCounterOption_applyInt64ObservableCounter_Call) Return(_a0 metric.Int64ObservableCounterConfig) *MockInt64ObservableCounterOption_applyInt64ObservableCounter_Call

func (*MockInt64ObservableCounterOption_applyInt64ObservableCounter_Call) Run 

func (_c *MockInt64ObservableCounterOption_applyInt64ObservableCounter_Call) Run(run func(_a0 metric.Int64ObservableCounterConfig)) *MockInt64ObservableCounterOption_applyInt64ObservableCounter_Call

func (*MockInt64ObservableCounterOption_applyInt64ObservableCounter_Call) RunAndReturn 

func (_c *MockInt64ObservableCounterOption_applyInt64ObservableCounter_Call) RunAndReturn(run func(metric.Int64ObservableCounterConfig) metric.Int64ObservableCounterConfig) *MockInt64ObservableCounterOption_applyInt64ObservableCounter_Call

type MockInt64ObservableCounter_Expecter 

type MockInt64ObservableCounter_Expecter struct {
	// contains filtered or unexported fields
}

type MockInt64ObservableCounter_int64ObservableCounter_Call 

type MockInt64ObservableCounter_int64ObservableCounter_Call struct {
	*mock.Call
}

MockInt64ObservableCounter_int64ObservableCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'int64ObservableCounter'

func (*MockInt64ObservableCounter_int64ObservableCounter_Call) Return 

func (_c *MockInt64ObservableCounter_int64ObservableCounter_Call) Return() *MockInt64ObservableCounter_int64ObservableCounter_Call

func (*MockInt64ObservableCounter_int64ObservableCounter_Call) Run 

func (_c *MockInt64ObservableCounter_int64ObservableCounter_Call) Run(run func()) *MockInt64ObservableCounter_int64ObservableCounter_Call

func (*MockInt64ObservableCounter_int64ObservableCounter_Call) RunAndReturn 

func (_c *MockInt64ObservableCounter_int64ObservableCounter_Call) RunAndReturn(run func()) *MockInt64ObservableCounter_int64ObservableCounter_Call

type MockInt64ObservableCounter_int64Observable_Call 

type MockInt64ObservableCounter_int64Observable_Call struct {
	*mock.Call
}

MockInt64ObservableCounter_int64Observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'int64Observable'

func (*MockInt64ObservableCounter_int64Observable_Call) Return 

func (_c *MockInt64ObservableCounter_int64Observable_Call) Return() *MockInt64ObservableCounter_int64Observable_Call

func (*MockInt64ObservableCounter_int64Observable_Call) Run 

func (_c *MockInt64ObservableCounter_int64Observable_Call) Run(run func()) *MockInt64ObservableCounter_int64Observable_Call

func (*MockInt64ObservableCounter_int64Observable_Call) RunAndReturn 

func (_c *MockInt64ObservableCounter_int64Observable_Call) RunAndReturn(run func()) *MockInt64ObservableCounter_int64Observable_Call

type MockInt64ObservableCounter_observable_Call 

type MockInt64ObservableCounter_observable_Call struct {
	*mock.Call
}

MockInt64ObservableCounter_observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'observable'

func (*MockInt64ObservableCounter_observable_Call) Return 

func (_c *MockInt64ObservableCounter_observable_Call) Return() *MockInt64ObservableCounter_observable_Call

func (*MockInt64ObservableCounter_observable_Call) Run 

func (_c *MockInt64ObservableCounter_observable_Call) Run(run func()) *MockInt64ObservableCounter_observable_Call

func (*MockInt64ObservableCounter_observable_Call) RunAndReturn 

func (_c *MockInt64ObservableCounter_observable_Call) RunAndReturn(run func()) *MockInt64ObservableCounter_observable_Call

type MockInt64ObservableGauge 

type MockInt64ObservableGauge struct {
	mock.Mock
}

MockInt64ObservableGauge is an autogenerated mock type for the Int64ObservableGauge type

func NewMockInt64ObservableGauge 

func NewMockInt64ObservableGauge(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64ObservableGauge

NewMockInt64ObservableGauge creates a new instance of MockInt64ObservableGauge. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64ObservableGauge) EXPECT 

func (_m *MockInt64ObservableGauge) EXPECT() *MockInt64ObservableGauge_Expecter

type MockInt64ObservableGaugeOption 

type MockInt64ObservableGaugeOption struct {
	mock.Mock
}

MockInt64ObservableGaugeOption is an autogenerated mock type for the Int64ObservableGaugeOption type

func NewMockInt64ObservableGaugeOption 

func NewMockInt64ObservableGaugeOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64ObservableGaugeOption

NewMockInt64ObservableGaugeOption creates a new instance of MockInt64ObservableGaugeOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64ObservableGaugeOption) EXPECT 

func (_m *MockInt64ObservableGaugeOption) EXPECT() *MockInt64ObservableGaugeOption_Expecter

type MockInt64ObservableGaugeOption_Expecter 

type MockInt64ObservableGaugeOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockInt64ObservableGaugeOption_applyInt64ObservableGauge_Call 

type MockInt64ObservableGaugeOption_applyInt64ObservableGauge_Call struct {
	*mock.Call
}

MockInt64ObservableGaugeOption_applyInt64ObservableGauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64ObservableGauge'

func (*MockInt64ObservableGaugeOption_applyInt64ObservableGauge_Call) Return 

func (_c *MockInt64ObservableGaugeOption_applyInt64ObservableGauge_Call) Return(_a0 metric.Int64ObservableGaugeConfig) *MockInt64ObservableGaugeOption_applyInt64ObservableGauge_Call

func (*MockInt64ObservableGaugeOption_applyInt64ObservableGauge_Call) Run 

func (_c *MockInt64ObservableGaugeOption_applyInt64ObservableGauge_Call) Run(run func(_a0 metric.Int64ObservableGaugeConfig)) *MockInt64ObservableGaugeOption_applyInt64ObservableGauge_Call

func (*MockInt64ObservableGaugeOption_applyInt64ObservableGauge_Call) RunAndReturn 

func (_c *MockInt64ObservableGaugeOption_applyInt64ObservableGauge_Call) RunAndReturn(run func(metric.Int64ObservableGaugeConfig) metric.Int64ObservableGaugeConfig) *MockInt64ObservableGaugeOption_applyInt64ObservableGauge_Call

type MockInt64ObservableGauge_Expecter 

type MockInt64ObservableGauge_Expecter struct {
	// contains filtered or unexported fields
}

type MockInt64ObservableGauge_int64ObservableGauge_Call 

type MockInt64ObservableGauge_int64ObservableGauge_Call struct {
	*mock.Call
}

MockInt64ObservableGauge_int64ObservableGauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'int64ObservableGauge'

func (*MockInt64ObservableGauge_int64ObservableGauge_Call) Return 

func (_c *MockInt64ObservableGauge_int64ObservableGauge_Call) Return() *MockInt64ObservableGauge_int64ObservableGauge_Call

func (*MockInt64ObservableGauge_int64ObservableGauge_Call) Run 

func (_c *MockInt64ObservableGauge_int64ObservableGauge_Call) Run(run func()) *MockInt64ObservableGauge_int64ObservableGauge_Call

func (*MockInt64ObservableGauge_int64ObservableGauge_Call) RunAndReturn 

func (_c *MockInt64ObservableGauge_int64ObservableGauge_Call) RunAndReturn(run func()) *MockInt64ObservableGauge_int64ObservableGauge_Call

type MockInt64ObservableGauge_int64Observable_Call 

type MockInt64ObservableGauge_int64Observable_Call struct {
	*mock.Call
}

MockInt64ObservableGauge_int64Observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'int64Observable'

func (*MockInt64ObservableGauge_int64Observable_Call) Return 

func (_c *MockInt64ObservableGauge_int64Observable_Call) Return() *MockInt64ObservableGauge_int64Observable_Call

func (*MockInt64ObservableGauge_int64Observable_Call) Run 

func (_c *MockInt64ObservableGauge_int64Observable_Call) Run(run func()) *MockInt64ObservableGauge_int64Observable_Call

func (*MockInt64ObservableGauge_int64Observable_Call) RunAndReturn 

func (_c *MockInt64ObservableGauge_int64Observable_Call) RunAndReturn(run func()) *MockInt64ObservableGauge_int64Observable_Call

type MockInt64ObservableGauge_observable_Call 

type MockInt64ObservableGauge_observable_Call struct {
	*mock.Call
}

MockInt64ObservableGauge_observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'observable'

func (*MockInt64ObservableGauge_observable_Call) Return 

func (_c *MockInt64ObservableGauge_observable_Call) Return() *MockInt64ObservableGauge_observable_Call

func (*MockInt64ObservableGauge_observable_Call) Run 

func (_c *MockInt64ObservableGauge_observable_Call) Run(run func()) *MockInt64ObservableGauge_observable_Call

func (*MockInt64ObservableGauge_observable_Call) RunAndReturn 

func (_c *MockInt64ObservableGauge_observable_Call) RunAndReturn(run func()) *MockInt64ObservableGauge_observable_Call

type MockInt64ObservableOption 

type MockInt64ObservableOption struct {
	mock.Mock
}

MockInt64ObservableOption is an autogenerated mock type for the Int64ObservableOption type

func NewMockInt64ObservableOption 

func NewMockInt64ObservableOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64ObservableOption

NewMockInt64ObservableOption creates a new instance of MockInt64ObservableOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64ObservableOption) EXPECT 

func (_m *MockInt64ObservableOption) EXPECT() *MockInt64ObservableOption_Expecter

type MockInt64ObservableOption_Expecter 

type MockInt64ObservableOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockInt64ObservableOption_applyInt64ObservableCounter_Call 

type MockInt64ObservableOption_applyInt64ObservableCounter_Call struct {
	*mock.Call
}

MockInt64ObservableOption_applyInt64ObservableCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64ObservableCounter'

func (*MockInt64ObservableOption_applyInt64ObservableCounter_Call) Return 

func (_c *MockInt64ObservableOption_applyInt64ObservableCounter_Call) Return(_a0 metric.Int64ObservableCounterConfig) *MockInt64ObservableOption_applyInt64ObservableCounter_Call

func (*MockInt64ObservableOption_applyInt64ObservableCounter_Call) Run 

func (_c *MockInt64ObservableOption_applyInt64ObservableCounter_Call) Run(run func(_a0 metric.Int64ObservableCounterConfig)) *MockInt64ObservableOption_applyInt64ObservableCounter_Call

func (*MockInt64ObservableOption_applyInt64ObservableCounter_Call) RunAndReturn 

func (_c *MockInt64ObservableOption_applyInt64ObservableCounter_Call) RunAndReturn(run func(metric.Int64ObservableCounterConfig) metric.Int64ObservableCounterConfig) *MockInt64ObservableOption_applyInt64ObservableCounter_Call

type MockInt64ObservableOption_applyInt64ObservableGauge_Call 

type MockInt64ObservableOption_applyInt64ObservableGauge_Call struct {
	*mock.Call
}

MockInt64ObservableOption_applyInt64ObservableGauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64ObservableGauge'

func (*MockInt64ObservableOption_applyInt64ObservableGauge_Call) Return 

func (_c *MockInt64ObservableOption_applyInt64ObservableGauge_Call) Return(_a0 metric.Int64ObservableGaugeConfig) *MockInt64ObservableOption_applyInt64ObservableGauge_Call

func (*MockInt64ObservableOption_applyInt64ObservableGauge_Call) Run 

func (_c *MockInt64ObservableOption_applyInt64ObservableGauge_Call) Run(run func(_a0 metric.Int64ObservableGaugeConfig)) *MockInt64ObservableOption_applyInt64ObservableGauge_Call

func (*MockInt64ObservableOption_applyInt64ObservableGauge_Call) RunAndReturn 

func (_c *MockInt64ObservableOption_applyInt64ObservableGauge_Call) RunAndReturn(run func(metric.Int64ObservableGaugeConfig) metric.Int64ObservableGaugeConfig) *MockInt64ObservableOption_applyInt64ObservableGauge_Call

type MockInt64ObservableOption_applyInt64ObservableUpDownCounter_Call 

type MockInt64ObservableOption_applyInt64ObservableUpDownCounter_Call struct {
	*mock.Call
}

MockInt64ObservableOption_applyInt64ObservableUpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64ObservableUpDownCounter'

func (*MockInt64ObservableOption_applyInt64ObservableUpDownCounter_Call) Return 

func (_c *MockInt64ObservableOption_applyInt64ObservableUpDownCounter_Call) Return(_a0 metric.Int64ObservableUpDownCounterConfig) *MockInt64ObservableOption_applyInt64ObservableUpDownCounter_Call

func (*MockInt64ObservableOption_applyInt64ObservableUpDownCounter_Call) Run 

func (_c *MockInt64ObservableOption_applyInt64ObservableUpDownCounter_Call) Run(run func(_a0 metric.Int64ObservableUpDownCounterConfig)) *MockInt64ObservableOption_applyInt64ObservableUpDownCounter_Call

func (*MockInt64ObservableOption_applyInt64ObservableUpDownCounter_Call) RunAndReturn 

func (_c *MockInt64ObservableOption_applyInt64ObservableUpDownCounter_Call) RunAndReturn(run func(metric.Int64ObservableUpDownCounterConfig) metric.Int64ObservableUpDownCounterConfig) *MockInt64ObservableOption_applyInt64ObservableUpDownCounter_Call

type MockInt64ObservableUpDownCounter 

type MockInt64ObservableUpDownCounter struct {
	mock.Mock
}

MockInt64ObservableUpDownCounter is an autogenerated mock type for the Int64ObservableUpDownCounter type

func NewMockInt64ObservableUpDownCounter 

func NewMockInt64ObservableUpDownCounter(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64ObservableUpDownCounter

NewMockInt64ObservableUpDownCounter creates a new instance of MockInt64ObservableUpDownCounter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64ObservableUpDownCounter) EXPECT 

func (_m *MockInt64ObservableUpDownCounter) EXPECT() *MockInt64ObservableUpDownCounter_Expecter

type MockInt64ObservableUpDownCounterOption 

type MockInt64ObservableUpDownCounterOption struct {
	mock.Mock
}

MockInt64ObservableUpDownCounterOption is an autogenerated mock type for the Int64ObservableUpDownCounterOption type

func NewMockInt64ObservableUpDownCounterOption 

func NewMockInt64ObservableUpDownCounterOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64ObservableUpDownCounterOption

NewMockInt64ObservableUpDownCounterOption creates a new instance of MockInt64ObservableUpDownCounterOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64ObservableUpDownCounterOption) EXPECT 

func (_m *MockInt64ObservableUpDownCounterOption) EXPECT() *MockInt64ObservableUpDownCounterOption_Expecter

type MockInt64ObservableUpDownCounterOption_Expecter 

type MockInt64ObservableUpDownCounterOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockInt64ObservableUpDownCounterOption_applyInt64ObservableUpDownCounter_Call 

type MockInt64ObservableUpDownCounterOption_applyInt64ObservableUpDownCounter_Call struct {
	*mock.Call
}

MockInt64ObservableUpDownCounterOption_applyInt64ObservableUpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64ObservableUpDownCounter'

func (*MockInt64ObservableUpDownCounterOption_applyInt64ObservableUpDownCounter_Call) Return 

func (_c *MockInt64ObservableUpDownCounterOption_applyInt64ObservableUpDownCounter_Call) Return(_a0 metric.Int64ObservableUpDownCounterConfig) *MockInt64ObservableUpDownCounterOption_applyInt64ObservableUpDownCounter_Call

func (*MockInt64ObservableUpDownCounterOption_applyInt64ObservableUpDownCounter_Call) Run 

func (_c *MockInt64ObservableUpDownCounterOption_applyInt64ObservableUpDownCounter_Call) Run(run func(_a0 metric.Int64ObservableUpDownCounterConfig)) *MockInt64ObservableUpDownCounterOption_applyInt64ObservableUpDownCounter_Call

func (*MockInt64ObservableUpDownCounterOption_applyInt64ObservableUpDownCounter_Call) RunAndReturn 

func (_c *MockInt64ObservableUpDownCounterOption_applyInt64ObservableUpDownCounter_Call) RunAndReturn(run func(metric.Int64ObservableUpDownCounterConfig) metric.Int64ObservableUpDownCounterConfig) *MockInt64ObservableUpDownCounterOption_applyInt64ObservableUpDownCounter_Call

type MockInt64ObservableUpDownCounter_Expecter 

type MockInt64ObservableUpDownCounter_Expecter struct {
	// contains filtered or unexported fields
}

type MockInt64ObservableUpDownCounter_int64ObservableUpDownCounter_Call 

type MockInt64ObservableUpDownCounter_int64ObservableUpDownCounter_Call struct {
	*mock.Call
}

MockInt64ObservableUpDownCounter_int64ObservableUpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'int64ObservableUpDownCounter'

func (*MockInt64ObservableUpDownCounter_int64ObservableUpDownCounter_Call) Return 

func (_c *MockInt64ObservableUpDownCounter_int64ObservableUpDownCounter_Call) Return() *MockInt64ObservableUpDownCounter_int64ObservableUpDownCounter_Call

func (*MockInt64ObservableUpDownCounter_int64ObservableUpDownCounter_Call) Run 

func (_c *MockInt64ObservableUpDownCounter_int64ObservableUpDownCounter_Call) Run(run func()) *MockInt64ObservableUpDownCounter_int64ObservableUpDownCounter_Call

func (*MockInt64ObservableUpDownCounter_int64ObservableUpDownCounter_Call) RunAndReturn 

func (_c *MockInt64ObservableUpDownCounter_int64ObservableUpDownCounter_Call) RunAndReturn(run func()) *MockInt64ObservableUpDownCounter_int64ObservableUpDownCounter_Call

type MockInt64ObservableUpDownCounter_int64Observable_Call 

type MockInt64ObservableUpDownCounter_int64Observable_Call struct {
	*mock.Call
}

MockInt64ObservableUpDownCounter_int64Observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'int64Observable'

func (*MockInt64ObservableUpDownCounter_int64Observable_Call) Return 

func (_c *MockInt64ObservableUpDownCounter_int64Observable_Call) Return() *MockInt64ObservableUpDownCounter_int64Observable_Call

func (*MockInt64ObservableUpDownCounter_int64Observable_Call) Run 

func (_c *MockInt64ObservableUpDownCounter_int64Observable_Call) Run(run func()) *MockInt64ObservableUpDownCounter_int64Observable_Call

func (*MockInt64ObservableUpDownCounter_int64Observable_Call) RunAndReturn 

func (_c *MockInt64ObservableUpDownCounter_int64Observable_Call) RunAndReturn(run func()) *MockInt64ObservableUpDownCounter_int64Observable_Call

type MockInt64ObservableUpDownCounter_observable_Call 

type MockInt64ObservableUpDownCounter_observable_Call struct {
	*mock.Call
}

MockInt64ObservableUpDownCounter_observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'observable'

func (*MockInt64ObservableUpDownCounter_observable_Call) Return 

func (_c *MockInt64ObservableUpDownCounter_observable_Call) Return() *MockInt64ObservableUpDownCounter_observable_Call

func (*MockInt64ObservableUpDownCounter_observable_Call) Run 

func (_c *MockInt64ObservableUpDownCounter_observable_Call) Run(run func()) *MockInt64ObservableUpDownCounter_observable_Call

func (*MockInt64ObservableUpDownCounter_observable_Call) RunAndReturn 

func (_c *MockInt64ObservableUpDownCounter_observable_Call) RunAndReturn(run func()) *MockInt64ObservableUpDownCounter_observable_Call

type MockInt64Observable_Expecter 

type MockInt64Observable_Expecter struct {
	// contains filtered or unexported fields
}

type MockInt64Observable_int64Observable_Call 

type MockInt64Observable_int64Observable_Call struct {
	*mock.Call
}

MockInt64Observable_int64Observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'int64Observable'

func (*MockInt64Observable_int64Observable_Call) Return 

func (_c *MockInt64Observable_int64Observable_Call) Return() *MockInt64Observable_int64Observable_Call

func (*MockInt64Observable_int64Observable_Call) Run 

func (_c *MockInt64Observable_int64Observable_Call) Run(run func()) *MockInt64Observable_int64Observable_Call

func (*MockInt64Observable_int64Observable_Call) RunAndReturn 

func (_c *MockInt64Observable_int64Observable_Call) RunAndReturn(run func()) *MockInt64Observable_int64Observable_Call

type MockInt64Observable_observable_Call 

type MockInt64Observable_observable_Call struct {
	*mock.Call
}

MockInt64Observable_observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'observable'

func (*MockInt64Observable_observable_Call) Return 

func (_c *MockInt64Observable_observable_Call) Return() *MockInt64Observable_observable_Call

func (*MockInt64Observable_observable_Call) Run 

func (_c *MockInt64Observable_observable_Call) Run(run func()) *MockInt64Observable_observable_Call

func (*MockInt64Observable_observable_Call) RunAndReturn 

func (_c *MockInt64Observable_observable_Call) RunAndReturn(run func()) *MockInt64Observable_observable_Call

type MockInt64Observer 

type MockInt64Observer struct {
	mock.Mock
}

MockInt64Observer is an autogenerated mock type for the Int64Observer type

func NewMockInt64Observer 

func NewMockInt64Observer(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64Observer

NewMockInt64Observer creates a new instance of MockInt64Observer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64Observer) EXPECT 

func (_m *MockInt64Observer) EXPECT() *MockInt64Observer_Expecter

func (*MockInt64Observer) Observe 

func (_m *MockInt64Observer) Observe(value int64, options ...metric.ObserveOption)

Observe provides a mock function with given fields: value, options

type MockInt64Observer_Expecter 

type MockInt64Observer_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockInt64Observer_Expecter) Observe 

func (_e *MockInt64Observer_Expecter) Observe(value interface{}, options ...interface{}) *MockInt64Observer_Observe_Call

Observe is a helper method to define mock.On call

  • value int64
  • options ...metric.ObserveOption

type MockInt64Observer_Observe_Call 

type MockInt64Observer_Observe_Call struct {
	*mock.Call
}

MockInt64Observer_Observe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Observe'

func (*MockInt64Observer_Observe_Call) Return 

func (_c *MockInt64Observer_Observe_Call) Return() *MockInt64Observer_Observe_Call

func (*MockInt64Observer_Observe_Call) Run 

func (_c *MockInt64Observer_Observe_Call) Run(run func(value int64, options ...metric.ObserveOption)) *MockInt64Observer_Observe_Call

func (*MockInt64Observer_Observe_Call) RunAndReturn 

func (_c *MockInt64Observer_Observe_Call) RunAndReturn(run func(int64, ...metric.ObserveOption)) *MockInt64Observer_Observe_Call

type MockInt64Observer_int64Observer_Call 

type MockInt64Observer_int64Observer_Call struct {
	*mock.Call
}

MockInt64Observer_int64Observer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'int64Observer'

func (*MockInt64Observer_int64Observer_Call) Return 

func (_c *MockInt64Observer_int64Observer_Call) Return() *MockInt64Observer_int64Observer_Call

func (*MockInt64Observer_int64Observer_Call) Run 

func (_c *MockInt64Observer_int64Observer_Call) Run(run func()) *MockInt64Observer_int64Observer_Call

func (*MockInt64Observer_int64Observer_Call) RunAndReturn 

func (_c *MockInt64Observer_int64Observer_Call) RunAndReturn(run func()) *MockInt64Observer_int64Observer_Call

type MockInt64UpDownCounter 

type MockInt64UpDownCounter struct {
	mock.Mock
}

MockInt64UpDownCounter is an autogenerated mock type for the Int64UpDownCounter type

func NewMockInt64UpDownCounter 

func NewMockInt64UpDownCounter(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64UpDownCounter

NewMockInt64UpDownCounter creates a new instance of MockInt64UpDownCounter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64UpDownCounter) Add 

func (_m *MockInt64UpDownCounter) Add(ctx context.Context, incr int64, options ...metric.AddOption)

Add provides a mock function with given fields: ctx, incr, options

func (*MockInt64UpDownCounter) EXPECT 

func (_m *MockInt64UpDownCounter) EXPECT() *MockInt64UpDownCounter_Expecter

type MockInt64UpDownCounterOption 

type MockInt64UpDownCounterOption struct {
	mock.Mock
}

MockInt64UpDownCounterOption is an autogenerated mock type for the Int64UpDownCounterOption type

func NewMockInt64UpDownCounterOption 

func NewMockInt64UpDownCounterOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInt64UpDownCounterOption

NewMockInt64UpDownCounterOption creates a new instance of MockInt64UpDownCounterOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInt64UpDownCounterOption) EXPECT 

func (_m *MockInt64UpDownCounterOption) EXPECT() *MockInt64UpDownCounterOption_Expecter

type MockInt64UpDownCounterOption_Expecter 

type MockInt64UpDownCounterOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockInt64UpDownCounterOption_applyInt64UpDownCounter_Call 

type MockInt64UpDownCounterOption_applyInt64UpDownCounter_Call struct {
	*mock.Call
}

MockInt64UpDownCounterOption_applyInt64UpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyInt64UpDownCounter'

func (*MockInt64UpDownCounterOption_applyInt64UpDownCounter_Call) Return 

func (_c *MockInt64UpDownCounterOption_applyInt64UpDownCounter_Call) Return(_a0 metric.Int64UpDownCounterConfig) *MockInt64UpDownCounterOption_applyInt64UpDownCounter_Call

func (*MockInt64UpDownCounterOption_applyInt64UpDownCounter_Call) Run 

func (_c *MockInt64UpDownCounterOption_applyInt64UpDownCounter_Call) Run(run func(_a0 metric.Int64UpDownCounterConfig)) *MockInt64UpDownCounterOption_applyInt64UpDownCounter_Call

func (*MockInt64UpDownCounterOption_applyInt64UpDownCounter_Call) RunAndReturn 

func (_c *MockInt64UpDownCounterOption_applyInt64UpDownCounter_Call) RunAndReturn(run func(metric.Int64UpDownCounterConfig) metric.Int64UpDownCounterConfig) *MockInt64UpDownCounterOption_applyInt64UpDownCounter_Call

type MockInt64UpDownCounter_Add_Call 

type MockInt64UpDownCounter_Add_Call struct {
	*mock.Call
}

MockInt64UpDownCounter_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add'

func (*MockInt64UpDownCounter_Add_Call) Return 

func (_c *MockInt64UpDownCounter_Add_Call) Return() *MockInt64UpDownCounter_Add_Call

func (*MockInt64UpDownCounter_Add_Call) Run 

func (_c *MockInt64UpDownCounter_Add_Call) Run(run func(ctx context.Context, incr int64, options ...metric.AddOption)) *MockInt64UpDownCounter_Add_Call

func (*MockInt64UpDownCounter_Add_Call) RunAndReturn 

func (_c *MockInt64UpDownCounter_Add_Call) RunAndReturn(run func(context.Context, int64, ...metric.AddOption)) *MockInt64UpDownCounter_Add_Call

type MockInt64UpDownCounter_Expecter 

type MockInt64UpDownCounter_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockInt64UpDownCounter_Expecter) Add 

func (_e *MockInt64UpDownCounter_Expecter) Add(ctx interface{}, incr interface{}, options ...interface{}) *MockInt64UpDownCounter_Add_Call

Add is a helper method to define mock.On call

  • ctx context.Context
  • incr int64
  • options ...metric.AddOption

type MockInt64UpDownCounter_int64UpDownCounter_Call 

type MockInt64UpDownCounter_int64UpDownCounter_Call struct {
	*mock.Call
}

MockInt64UpDownCounter_int64UpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'int64UpDownCounter'

func (*MockInt64UpDownCounter_int64UpDownCounter_Call) Return 

func (_c *MockInt64UpDownCounter_int64UpDownCounter_Call) Return() *MockInt64UpDownCounter_int64UpDownCounter_Call

func (*MockInt64UpDownCounter_int64UpDownCounter_Call) Run 

func (_c *MockInt64UpDownCounter_int64UpDownCounter_Call) Run(run func()) *MockInt64UpDownCounter_int64UpDownCounter_Call

func (*MockInt64UpDownCounter_int64UpDownCounter_Call) RunAndReturn 

func (_c *MockInt64UpDownCounter_int64UpDownCounter_Call) RunAndReturn(run func()) *MockInt64UpDownCounter_int64UpDownCounter_Call

type MockMeasurementOption 

type MockMeasurementOption struct {
	mock.Mock
}

MockMeasurementOption is an autogenerated mock type for the MeasurementOption type

func NewMockMeasurementOption 

func NewMockMeasurementOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockMeasurementOption

NewMockMeasurementOption creates a new instance of MockMeasurementOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockMeasurementOption) EXPECT 

func (_m *MockMeasurementOption) EXPECT() *MockMeasurementOption_Expecter

type MockMeasurementOption_Expecter 

type MockMeasurementOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockMeasurementOption_applyAdd_Call 

type MockMeasurementOption_applyAdd_Call struct {
	*mock.Call
}

MockMeasurementOption_applyAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyAdd'

func (*MockMeasurementOption_applyAdd_Call) Return 

func (_c *MockMeasurementOption_applyAdd_Call) Return(_a0 metric.AddConfig) *MockMeasurementOption_applyAdd_Call

func (*MockMeasurementOption_applyAdd_Call) Run 

func (_c *MockMeasurementOption_applyAdd_Call) Run(run func(_a0 metric.AddConfig)) *MockMeasurementOption_applyAdd_Call

func (*MockMeasurementOption_applyAdd_Call) RunAndReturn 

func (_c *MockMeasurementOption_applyAdd_Call) RunAndReturn(run func(metric.AddConfig) metric.AddConfig) *MockMeasurementOption_applyAdd_Call

type MockMeasurementOption_applyObserve_Call 

type MockMeasurementOption_applyObserve_Call struct {
	*mock.Call
}

MockMeasurementOption_applyObserve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyObserve'

func (*MockMeasurementOption_applyObserve_Call) Return 

func (_c *MockMeasurementOption_applyObserve_Call) Return(_a0 metric.ObserveConfig) *MockMeasurementOption_applyObserve_Call

func (*MockMeasurementOption_applyObserve_Call) Run 

func (_c *MockMeasurementOption_applyObserve_Call) Run(run func(_a0 metric.ObserveConfig)) *MockMeasurementOption_applyObserve_Call

func (*MockMeasurementOption_applyObserve_Call) RunAndReturn 

func (_c *MockMeasurementOption_applyObserve_Call) RunAndReturn(run func(metric.ObserveConfig) metric.ObserveConfig) *MockMeasurementOption_applyObserve_Call

type MockMeasurementOption_applyRecord_Call 

type MockMeasurementOption_applyRecord_Call struct {
	*mock.Call
}

MockMeasurementOption_applyRecord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyRecord'

func (*MockMeasurementOption_applyRecord_Call) Return 

func (_c *MockMeasurementOption_applyRecord_Call) Return(_a0 metric.RecordConfig) *MockMeasurementOption_applyRecord_Call

func (*MockMeasurementOption_applyRecord_Call) Run 

func (_c *MockMeasurementOption_applyRecord_Call) Run(run func(_a0 metric.RecordConfig)) *MockMeasurementOption_applyRecord_Call

func (*MockMeasurementOption_applyRecord_Call) RunAndReturn 

func (_c *MockMeasurementOption_applyRecord_Call) RunAndReturn(run func(metric.RecordConfig) metric.RecordConfig) *MockMeasurementOption_applyRecord_Call

type MockMeter 

type MockMeter struct {
	mock.Mock
	embedded.Meter
}

MockMeter is an autogenerated mock type for the Meter type

func NewMockMeter 

func NewMockMeter(t interface {
	mock.TestingT
	Cleanup(func())
},
) *MockMeter

NewMockMeter creates a new instance of MockMeter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockMeter) EXPECT 

func (_m *MockMeter) EXPECT() *MockMeter_Expecter

func (*MockMeter) Float64Counter 

func (_m *MockMeter) Float64Counter(name string, options ...metric.Float64CounterOption) (metric.Float64Counter, error)

Float64Counter provides a mock function with given fields: name, options

func (*MockMeter) Float64Gauge 

func (_m *MockMeter) Float64Gauge(name string, options ...metric.Float64GaugeOption) (metric.Float64Gauge, error)

Float64Gauge provides a mock function with given fields: name, options

func (*MockMeter) Float64Histogram 

func (_m *MockMeter) Float64Histogram(name string, options ...metric.Float64HistogramOption) (metric.Float64Histogram, error)

Float64Histogram provides a mock function with given fields: name, options

func (*MockMeter) Float64ObservableCounter 

func (_m *MockMeter) Float64ObservableCounter(name string, options ...metric.Float64ObservableCounterOption) (metric.Float64ObservableCounter, error)

Float64ObservableCounter provides a mock function with given fields: name, options

func (*MockMeter) Float64ObservableGauge 

func (_m *MockMeter) Float64ObservableGauge(name string, options ...metric.Float64ObservableGaugeOption) (metric.Float64ObservableGauge, error)

Float64ObservableGauge provides a mock function with given fields: name, options

func (*MockMeter) Float64ObservableUpDownCounter 

func (_m *MockMeter) Float64ObservableUpDownCounter(name string, options ...metric.Float64ObservableUpDownCounterOption) (metric.Float64ObservableUpDownCounter, error)

Float64ObservableUpDownCounter provides a mock function with given fields: name, options

func (*MockMeter) Float64UpDownCounter 

func (_m *MockMeter) Float64UpDownCounter(name string, options ...metric.Float64UpDownCounterOption) (metric.Float64UpDownCounter, error)

Float64UpDownCounter provides a mock function with given fields: name, options

func (*MockMeter) Int64Counter 

func (_m *MockMeter) Int64Counter(name string, options ...metric.Int64CounterOption) (metric.Int64Counter, error)

Int64Counter provides a mock function with given fields: name, options

func (*MockMeter) Int64Gauge 

func (_m *MockMeter) Int64Gauge(name string, options ...metric.Int64GaugeOption) (metric.Int64Gauge, error)

Int64Gauge provides a mock function with given fields: name, options

func (*MockMeter) Int64Histogram 

func (_m *MockMeter) Int64Histogram(name string, options ...metric.Int64HistogramOption) (metric.Int64Histogram, error)

Int64Histogram provides a mock function with given fields: name, options

func (*MockMeter) Int64ObservableCounter 

func (_m *MockMeter) Int64ObservableCounter(name string, options ...metric.Int64ObservableCounterOption) (metric.Int64ObservableCounter, error)

Int64ObservableCounter provides a mock function with given fields: name, options

func (*MockMeter) Int64ObservableGauge 

func (_m *MockMeter) Int64ObservableGauge(name string, options ...metric.Int64ObservableGaugeOption) (metric.Int64ObservableGauge, error)

Int64ObservableGauge provides a mock function with given fields: name, options

func (*MockMeter) Int64ObservableUpDownCounter 

func (_m *MockMeter) Int64ObservableUpDownCounter(name string, options ...metric.Int64ObservableUpDownCounterOption) (metric.Int64ObservableUpDownCounter, error)

Int64ObservableUpDownCounter provides a mock function with given fields: name, options

func (*MockMeter) Int64UpDownCounter 

func (_m *MockMeter) Int64UpDownCounter(name string, options ...metric.Int64UpDownCounterOption) (metric.Int64UpDownCounter, error)

Int64UpDownCounter provides a mock function with given fields: name, options

func (*MockMeter) RegisterCallback 

func (_m *MockMeter) RegisterCallback(f metric.Callback, instruments ...metric.Observable) (metric.Registration, error)

RegisterCallback provides a mock function with given fields: f, instruments

type MockMeterOption 

type MockMeterOption struct {
	mock.Mock
}

MockMeterOption is an autogenerated mock type for the MeterOption type

func NewMockMeterOption 

func NewMockMeterOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockMeterOption

NewMockMeterOption creates a new instance of MockMeterOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockMeterOption) EXPECT 

func (_m *MockMeterOption) EXPECT() *MockMeterOption_Expecter

type MockMeterOption_Expecter 

type MockMeterOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockMeterOption_applyMeter_Call 

type MockMeterOption_applyMeter_Call struct {
	*mock.Call
}

MockMeterOption_applyMeter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyMeter'

func (*MockMeterOption_applyMeter_Call) Return 

func (_c *MockMeterOption_applyMeter_Call) Return(_a0 metric.MeterConfig) *MockMeterOption_applyMeter_Call

func (*MockMeterOption_applyMeter_Call) Run 

func (_c *MockMeterOption_applyMeter_Call) Run(run func(_a0 metric.MeterConfig)) *MockMeterOption_applyMeter_Call

func (*MockMeterOption_applyMeter_Call) RunAndReturn 

func (_c *MockMeterOption_applyMeter_Call) RunAndReturn(run func(metric.MeterConfig) metric.MeterConfig) *MockMeterOption_applyMeter_Call

type MockMeterProvider 

type MockMeterProvider struct {
	mock.Mock
	embedded.MeterProvider
}

MockMeterProvider is an autogenerated mock type for the MeterProvider type

func NewMockMeterProvider 

func NewMockMeterProvider(t interface {
	mock.TestingT
	Cleanup(func())
},
) *MockMeterProvider

NewMockMeterProvider creates a new instance of MockMeterProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockMeterProvider) EXPECT 

func (_m *MockMeterProvider) EXPECT() *MockMeterProvider_Expecter

func (*MockMeterProvider) Meter 

func (_m *MockMeterProvider) Meter(name string, opts ...metric.MeterOption) metric.Meter

Meter provides a mock function with given fields: name, opts

type MockMeterProvider_Expecter 

type MockMeterProvider_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockMeterProvider_Expecter) Meter 

func (_e *MockMeterProvider_Expecter) Meter(name interface{}, opts ...interface{}) *MockMeterProvider_Meter_Call

Meter is a helper method to define mock.On call

  • name string
  • opts ...metric.MeterOption

type MockMeterProvider_Meter_Call 

type MockMeterProvider_Meter_Call struct {
	*mock.Call
}

MockMeterProvider_Meter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Meter'

func (*MockMeterProvider_Meter_Call) Return 

func (_c *MockMeterProvider_Meter_Call) Return(_a0 metric.Meter) *MockMeterProvider_Meter_Call

func (*MockMeterProvider_Meter_Call) Run 

func (_c *MockMeterProvider_Meter_Call) Run(run func(name string, opts ...metric.MeterOption)) *MockMeterProvider_Meter_Call

func (*MockMeterProvider_Meter_Call) RunAndReturn 

func (_c *MockMeterProvider_Meter_Call) RunAndReturn(run func(string, ...metric.MeterOption) metric.Meter) *MockMeterProvider_Meter_Call

type MockMeterProvider_meterProvider_Call 

type MockMeterProvider_meterProvider_Call struct {
	*mock.Call
}

MockMeterProvider_meterProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'meterProvider'

func (*MockMeterProvider_meterProvider_Call) Return 

func (_c *MockMeterProvider_meterProvider_Call) Return() *MockMeterProvider_meterProvider_Call

func (*MockMeterProvider_meterProvider_Call) Run 

func (_c *MockMeterProvider_meterProvider_Call) Run(run func()) *MockMeterProvider_meterProvider_Call

func (*MockMeterProvider_meterProvider_Call) RunAndReturn 

func (_c *MockMeterProvider_meterProvider_Call) RunAndReturn(run func()) *MockMeterProvider_meterProvider_Call

type MockMeter_Expecter 

type MockMeter_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockMeter_Expecter) Float64Counter 

func (_e *MockMeter_Expecter) Float64Counter(name interface{}, options ...interface{}) *MockMeter_Float64Counter_Call

Float64Counter is a helper method to define mock.On call

  • name string
  • options ...metric.Float64CounterOption

func (*MockMeter_Expecter) Float64Gauge 

func (_e *MockMeter_Expecter) Float64Gauge(name interface{}, options ...interface{}) *MockMeter_Float64Gauge_Call

Float64Gauge is a helper method to define mock.On call

  • name string
  • options ...metric.Float64GaugeOption

func (*MockMeter_Expecter) Float64Histogram 

func (_e *MockMeter_Expecter) Float64Histogram(name interface{}, options ...interface{}) *MockMeter_Float64Histogram_Call

Float64Histogram is a helper method to define mock.On call

  • name string
  • options ...metric.Float64HistogramOption

func (*MockMeter_Expecter) Float64ObservableCounter 

func (_e *MockMeter_Expecter) Float64ObservableCounter(name interface{}, options ...interface{}) *MockMeter_Float64ObservableCounter_Call

Float64ObservableCounter is a helper method to define mock.On call

  • name string
  • options ...metric.Float64ObservableCounterOption

func (*MockMeter_Expecter) Float64ObservableGauge 

func (_e *MockMeter_Expecter) Float64ObservableGauge(name interface{}, options ...interface{}) *MockMeter_Float64ObservableGauge_Call

Float64ObservableGauge is a helper method to define mock.On call

  • name string
  • options ...metric.Float64ObservableGaugeOption

func (*MockMeter_Expecter) Float64ObservableUpDownCounter 

func (_e *MockMeter_Expecter) Float64ObservableUpDownCounter(name interface{}, options ...interface{}) *MockMeter_Float64ObservableUpDownCounter_Call

Float64ObservableUpDownCounter is a helper method to define mock.On call

  • name string
  • options ...metric.Float64ObservableUpDownCounterOption

func (*MockMeter_Expecter) Float64UpDownCounter 

func (_e *MockMeter_Expecter) Float64UpDownCounter(name interface{}, options ...interface{}) *MockMeter_Float64UpDownCounter_Call

Float64UpDownCounter is a helper method to define mock.On call

  • name string
  • options ...metric.Float64UpDownCounterOption

func (*MockMeter_Expecter) Int64Counter 

func (_e *MockMeter_Expecter) Int64Counter(name interface{}, options ...interface{}) *MockMeter_Int64Counter_Call

Int64Counter is a helper method to define mock.On call

  • name string
  • options ...metric.Int64CounterOption

func (*MockMeter_Expecter) Int64Gauge 

func (_e *MockMeter_Expecter) Int64Gauge(name interface{}, options ...interface{}) *MockMeter_Int64Gauge_Call

Int64Gauge is a helper method to define mock.On call

  • name string
  • options ...metric.Int64GaugeOption

func (*MockMeter_Expecter) Int64Histogram 

func (_e *MockMeter_Expecter) Int64Histogram(name interface{}, options ...interface{}) *MockMeter_Int64Histogram_Call

Int64Histogram is a helper method to define mock.On call

  • name string
  • options ...metric.Int64HistogramOption

func (*MockMeter_Expecter) Int64ObservableCounter 

func (_e *MockMeter_Expecter) Int64ObservableCounter(name interface{}, options ...interface{}) *MockMeter_Int64ObservableCounter_Call

Int64ObservableCounter is a helper method to define mock.On call

  • name string
  • options ...metric.Int64ObservableCounterOption

func (*MockMeter_Expecter) Int64ObservableGauge 

func (_e *MockMeter_Expecter) Int64ObservableGauge(name interface{}, options ...interface{}) *MockMeter_Int64ObservableGauge_Call

Int64ObservableGauge is a helper method to define mock.On call

  • name string
  • options ...metric.Int64ObservableGaugeOption

func (*MockMeter_Expecter) Int64ObservableUpDownCounter 

func (_e *MockMeter_Expecter) Int64ObservableUpDownCounter(name interface{}, options ...interface{}) *MockMeter_Int64ObservableUpDownCounter_Call

Int64ObservableUpDownCounter is a helper method to define mock.On call

  • name string
  • options ...metric.Int64ObservableUpDownCounterOption

func (*MockMeter_Expecter) Int64UpDownCounter 

func (_e *MockMeter_Expecter) Int64UpDownCounter(name interface{}, options ...interface{}) *MockMeter_Int64UpDownCounter_Call

Int64UpDownCounter is a helper method to define mock.On call

  • name string
  • options ...metric.Int64UpDownCounterOption

func (*MockMeter_Expecter) RegisterCallback 

func (_e *MockMeter_Expecter) RegisterCallback(f interface{}, instruments ...interface{}) *MockMeter_RegisterCallback_Call

RegisterCallback is a helper method to define mock.On call

  • f metric.Callback
  • instruments ...metric.Observable

type MockMeter_Float64Counter_Call 

type MockMeter_Float64Counter_Call struct {
	*mock.Call
}

MockMeter_Float64Counter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Float64Counter'

func (*MockMeter_Float64Counter_Call) Return 

func (_c *MockMeter_Float64Counter_Call) Return(_a0 metric.Float64Counter, _a1 error) *MockMeter_Float64Counter_Call

func (*MockMeter_Float64Counter_Call) Run 

func (_c *MockMeter_Float64Counter_Call) Run(run func(name string, options ...metric.Float64CounterOption)) *MockMeter_Float64Counter_Call

func (*MockMeter_Float64Counter_Call) RunAndReturn 

func (_c *MockMeter_Float64Counter_Call) RunAndReturn(run func(string, ...metric.Float64CounterOption) (metric.Float64Counter, error)) *MockMeter_Float64Counter_Call

type MockMeter_Float64Gauge_Call 

type MockMeter_Float64Gauge_Call struct {
	*mock.Call
}

MockMeter_Float64Gauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Float64Gauge'

func (*MockMeter_Float64Gauge_Call) Return 

func (_c *MockMeter_Float64Gauge_Call) Return(_a0 metric.Float64Gauge, _a1 error) *MockMeter_Float64Gauge_Call

func (*MockMeter_Float64Gauge_Call) Run 

func (_c *MockMeter_Float64Gauge_Call) Run(run func(name string, options ...metric.Float64GaugeOption)) *MockMeter_Float64Gauge_Call

func (*MockMeter_Float64Gauge_Call) RunAndReturn 

func (_c *MockMeter_Float64Gauge_Call) RunAndReturn(run func(string, ...metric.Float64GaugeOption) (metric.Float64Gauge, error)) *MockMeter_Float64Gauge_Call

type MockMeter_Float64Histogram_Call 

type MockMeter_Float64Histogram_Call struct {
	*mock.Call
}

MockMeter_Float64Histogram_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Float64Histogram'

func (*MockMeter_Float64Histogram_Call) Return 

func (_c *MockMeter_Float64Histogram_Call) Return(_a0 metric.Float64Histogram, _a1 error) *MockMeter_Float64Histogram_Call

func (*MockMeter_Float64Histogram_Call) Run 

func (_c *MockMeter_Float64Histogram_Call) Run(run func(name string, options ...metric.Float64HistogramOption)) *MockMeter_Float64Histogram_Call

func (*MockMeter_Float64Histogram_Call) RunAndReturn 

func (_c *MockMeter_Float64Histogram_Call) RunAndReturn(run func(string, ...metric.Float64HistogramOption) (metric.Float64Histogram, error)) *MockMeter_Float64Histogram_Call

type MockMeter_Float64ObservableCounter_Call 

type MockMeter_Float64ObservableCounter_Call struct {
	*mock.Call
}

MockMeter_Float64ObservableCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Float64ObservableCounter'

func (*MockMeter_Float64ObservableCounter_Call) Return 

func (_c *MockMeter_Float64ObservableCounter_Call) Return(_a0 metric.Float64ObservableCounter, _a1 error) *MockMeter_Float64ObservableCounter_Call

func (*MockMeter_Float64ObservableCounter_Call) Run 

func (_c *MockMeter_Float64ObservableCounter_Call) Run(run func(name string, options ...metric.Float64ObservableCounterOption)) *MockMeter_Float64ObservableCounter_Call

func (*MockMeter_Float64ObservableCounter_Call) RunAndReturn 

func (_c *MockMeter_Float64ObservableCounter_Call) RunAndReturn(run func(string, ...metric.Float64ObservableCounterOption) (metric.Float64ObservableCounter, error)) *MockMeter_Float64ObservableCounter_Call

type MockMeter_Float64ObservableGauge_Call 

type MockMeter_Float64ObservableGauge_Call struct {
	*mock.Call
}

MockMeter_Float64ObservableGauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Float64ObservableGauge'

func (*MockMeter_Float64ObservableGauge_Call) Return 

func (_c *MockMeter_Float64ObservableGauge_Call) Return(_a0 metric.Float64ObservableGauge, _a1 error) *MockMeter_Float64ObservableGauge_Call

func (*MockMeter_Float64ObservableGauge_Call) Run 

func (_c *MockMeter_Float64ObservableGauge_Call) Run(run func(name string, options ...metric.Float64ObservableGaugeOption)) *MockMeter_Float64ObservableGauge_Call

func (*MockMeter_Float64ObservableGauge_Call) RunAndReturn 

func (_c *MockMeter_Float64ObservableGauge_Call) RunAndReturn(run func(string, ...metric.Float64ObservableGaugeOption) (metric.Float64ObservableGauge, error)) *MockMeter_Float64ObservableGauge_Call

type MockMeter_Float64ObservableUpDownCounter_Call 

type MockMeter_Float64ObservableUpDownCounter_Call struct {
	*mock.Call
}

MockMeter_Float64ObservableUpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Float64ObservableUpDownCounter'

func (*MockMeter_Float64ObservableUpDownCounter_Call) Return 

func (_c *MockMeter_Float64ObservableUpDownCounter_Call) Return(_a0 metric.Float64ObservableUpDownCounter, _a1 error) *MockMeter_Float64ObservableUpDownCounter_Call

func (*MockMeter_Float64ObservableUpDownCounter_Call) Run 

func (_c *MockMeter_Float64ObservableUpDownCounter_Call) Run(run func(name string, options ...metric.Float64ObservableUpDownCounterOption)) *MockMeter_Float64ObservableUpDownCounter_Call

func (*MockMeter_Float64ObservableUpDownCounter_Call) RunAndReturn 

func (_c *MockMeter_Float64ObservableUpDownCounter_Call) RunAndReturn(run func(string, ...metric.Float64ObservableUpDownCounterOption) (metric.Float64ObservableUpDownCounter, error)) *MockMeter_Float64ObservableUpDownCounter_Call

type MockMeter_Float64UpDownCounter_Call 

type MockMeter_Float64UpDownCounter_Call struct {
	*mock.Call
}

MockMeter_Float64UpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Float64UpDownCounter'

func (*MockMeter_Float64UpDownCounter_Call) Return 

func (_c *MockMeter_Float64UpDownCounter_Call) Return(_a0 metric.Float64UpDownCounter, _a1 error) *MockMeter_Float64UpDownCounter_Call

func (*MockMeter_Float64UpDownCounter_Call) Run 

func (_c *MockMeter_Float64UpDownCounter_Call) Run(run func(name string, options ...metric.Float64UpDownCounterOption)) *MockMeter_Float64UpDownCounter_Call

func (*MockMeter_Float64UpDownCounter_Call) RunAndReturn 

func (_c *MockMeter_Float64UpDownCounter_Call) RunAndReturn(run func(string, ...metric.Float64UpDownCounterOption) (metric.Float64UpDownCounter, error)) *MockMeter_Float64UpDownCounter_Call

type MockMeter_Int64Counter_Call 

type MockMeter_Int64Counter_Call struct {
	*mock.Call
}

MockMeter_Int64Counter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Int64Counter'

func (*MockMeter_Int64Counter_Call) Return 

func (_c *MockMeter_Int64Counter_Call) Return(_a0 metric.Int64Counter, _a1 error) *MockMeter_Int64Counter_Call

func (*MockMeter_Int64Counter_Call) Run 

func (_c *MockMeter_Int64Counter_Call) Run(run func(name string, options ...metric.Int64CounterOption)) *MockMeter_Int64Counter_Call

func (*MockMeter_Int64Counter_Call) RunAndReturn 

func (_c *MockMeter_Int64Counter_Call) RunAndReturn(run func(string, ...metric.Int64CounterOption) (metric.Int64Counter, error)) *MockMeter_Int64Counter_Call

type MockMeter_Int64Gauge_Call 

type MockMeter_Int64Gauge_Call struct {
	*mock.Call
}

MockMeter_Int64Gauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Int64Gauge'

func (*MockMeter_Int64Gauge_Call) Return 

func (_c *MockMeter_Int64Gauge_Call) Return(_a0 metric.Int64Gauge, _a1 error) *MockMeter_Int64Gauge_Call

func (*MockMeter_Int64Gauge_Call) Run 

func (_c *MockMeter_Int64Gauge_Call) Run(run func(name string, options ...metric.Int64GaugeOption)) *MockMeter_Int64Gauge_Call

func (*MockMeter_Int64Gauge_Call) RunAndReturn 

func (_c *MockMeter_Int64Gauge_Call) RunAndReturn(run func(string, ...metric.Int64GaugeOption) (metric.Int64Gauge, error)) *MockMeter_Int64Gauge_Call

type MockMeter_Int64Histogram_Call 

type MockMeter_Int64Histogram_Call struct {
	*mock.Call
}

MockMeter_Int64Histogram_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Int64Histogram'

func (*MockMeter_Int64Histogram_Call) Return 

func (_c *MockMeter_Int64Histogram_Call) Return(_a0 metric.Int64Histogram, _a1 error) *MockMeter_Int64Histogram_Call

func (*MockMeter_Int64Histogram_Call) Run 

func (_c *MockMeter_Int64Histogram_Call) Run(run func(name string, options ...metric.Int64HistogramOption)) *MockMeter_Int64Histogram_Call

func (*MockMeter_Int64Histogram_Call) RunAndReturn 

func (_c *MockMeter_Int64Histogram_Call) RunAndReturn(run func(string, ...metric.Int64HistogramOption) (metric.Int64Histogram, error)) *MockMeter_Int64Histogram_Call

type MockMeter_Int64ObservableCounter_Call 

type MockMeter_Int64ObservableCounter_Call struct {
	*mock.Call
}

MockMeter_Int64ObservableCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Int64ObservableCounter'

func (*MockMeter_Int64ObservableCounter_Call) Return 

func (_c *MockMeter_Int64ObservableCounter_Call) Return(_a0 metric.Int64ObservableCounter, _a1 error) *MockMeter_Int64ObservableCounter_Call

func (*MockMeter_Int64ObservableCounter_Call) Run 

func (_c *MockMeter_Int64ObservableCounter_Call) Run(run func(name string, options ...metric.Int64ObservableCounterOption)) *MockMeter_Int64ObservableCounter_Call

func (*MockMeter_Int64ObservableCounter_Call) RunAndReturn 

func (_c *MockMeter_Int64ObservableCounter_Call) RunAndReturn(run func(string, ...metric.Int64ObservableCounterOption) (metric.Int64ObservableCounter, error)) *MockMeter_Int64ObservableCounter_Call

type MockMeter_Int64ObservableGauge_Call 

type MockMeter_Int64ObservableGauge_Call struct {
	*mock.Call
}

MockMeter_Int64ObservableGauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Int64ObservableGauge'

func (*MockMeter_Int64ObservableGauge_Call) Return 

func (_c *MockMeter_Int64ObservableGauge_Call) Return(_a0 metric.Int64ObservableGauge, _a1 error) *MockMeter_Int64ObservableGauge_Call

func (*MockMeter_Int64ObservableGauge_Call) Run 

func (_c *MockMeter_Int64ObservableGauge_Call) Run(run func(name string, options ...metric.Int64ObservableGaugeOption)) *MockMeter_Int64ObservableGauge_Call

func (*MockMeter_Int64ObservableGauge_Call) RunAndReturn 

func (_c *MockMeter_Int64ObservableGauge_Call) RunAndReturn(run func(string, ...metric.Int64ObservableGaugeOption) (metric.Int64ObservableGauge, error)) *MockMeter_Int64ObservableGauge_Call

type MockMeter_Int64ObservableUpDownCounter_Call 

type MockMeter_Int64ObservableUpDownCounter_Call struct {
	*mock.Call
}

MockMeter_Int64ObservableUpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Int64ObservableUpDownCounter'

func (*MockMeter_Int64ObservableUpDownCounter_Call) Return 

func (_c *MockMeter_Int64ObservableUpDownCounter_Call) Return(_a0 metric.Int64ObservableUpDownCounter, _a1 error) *MockMeter_Int64ObservableUpDownCounter_Call

func (*MockMeter_Int64ObservableUpDownCounter_Call) Run 

func (_c *MockMeter_Int64ObservableUpDownCounter_Call) Run(run func(name string, options ...metric.Int64ObservableUpDownCounterOption)) *MockMeter_Int64ObservableUpDownCounter_Call

func (*MockMeter_Int64ObservableUpDownCounter_Call) RunAndReturn 

func (_c *MockMeter_Int64ObservableUpDownCounter_Call) RunAndReturn(run func(string, ...metric.Int64ObservableUpDownCounterOption) (metric.Int64ObservableUpDownCounter, error)) *MockMeter_Int64ObservableUpDownCounter_Call

type MockMeter_Int64UpDownCounter_Call 

type MockMeter_Int64UpDownCounter_Call struct {
	*mock.Call
}

MockMeter_Int64UpDownCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Int64UpDownCounter'

func (*MockMeter_Int64UpDownCounter_Call) Return 

func (_c *MockMeter_Int64UpDownCounter_Call) Return(_a0 metric.Int64UpDownCounter, _a1 error) *MockMeter_Int64UpDownCounter_Call

func (*MockMeter_Int64UpDownCounter_Call) Run 

func (_c *MockMeter_Int64UpDownCounter_Call) Run(run func(name string, options ...metric.Int64UpDownCounterOption)) *MockMeter_Int64UpDownCounter_Call

func (*MockMeter_Int64UpDownCounter_Call) RunAndReturn 

func (_c *MockMeter_Int64UpDownCounter_Call) RunAndReturn(run func(string, ...metric.Int64UpDownCounterOption) (metric.Int64UpDownCounter, error)) *MockMeter_Int64UpDownCounter_Call

type MockMeter_RegisterCallback_Call 

type MockMeter_RegisterCallback_Call struct {
	*mock.Call
}

MockMeter_RegisterCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterCallback'

func (*MockMeter_RegisterCallback_Call) Return 

func (_c *MockMeter_RegisterCallback_Call) Return(_a0 metric.Registration, _a1 error) *MockMeter_RegisterCallback_Call

func (*MockMeter_RegisterCallback_Call) Run 

func (_c *MockMeter_RegisterCallback_Call) Run(run func(f metric.Callback, instruments ...metric.Observable)) *MockMeter_RegisterCallback_Call

func (*MockMeter_RegisterCallback_Call) RunAndReturn 

func (_c *MockMeter_RegisterCallback_Call) RunAndReturn(run func(metric.Callback, ...metric.Observable) (metric.Registration, error)) *MockMeter_RegisterCallback_Call

type MockMeter_meter_Call 

type MockMeter_meter_Call struct {
	*mock.Call
}

MockMeter_meter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'meter'

func (*MockMeter_meter_Call) Return 

func (_c *MockMeter_meter_Call) Return() *MockMeter_meter_Call

func (*MockMeter_meter_Call) Run 

func (_c *MockMeter_meter_Call) Run(run func()) *MockMeter_meter_Call

func (*MockMeter_meter_Call) RunAndReturn 

func (_c *MockMeter_meter_Call) RunAndReturn(run func()) *MockMeter_meter_Call

type MockObservable 

type MockObservable struct {
	mock.Mock
}

MockObservable is an autogenerated mock type for the Observable type

func NewMockObservable 

func NewMockObservable(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockObservable

NewMockObservable creates a new instance of MockObservable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockObservable) EXPECT 

func (_m *MockObservable) EXPECT() *MockObservable_Expecter

type MockObservable_Expecter 

type MockObservable_Expecter struct {
	// contains filtered or unexported fields
}

type MockObservable_observable_Call 

type MockObservable_observable_Call struct {
	*mock.Call
}

MockObservable_observable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'observable'

func (*MockObservable_observable_Call) Return 

func (_c *MockObservable_observable_Call) Return() *MockObservable_observable_Call

func (*MockObservable_observable_Call) Run 

func (_c *MockObservable_observable_Call) Run(run func()) *MockObservable_observable_Call

func (*MockObservable_observable_Call) RunAndReturn 

func (_c *MockObservable_observable_Call) RunAndReturn(run func()) *MockObservable_observable_Call

type MockObserveOption 

type MockObserveOption struct {
	mock.Mock
}

MockObserveOption is an autogenerated mock type for the ObserveOption type

func NewMockObserveOption 

func NewMockObserveOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockObserveOption

NewMockObserveOption creates a new instance of MockObserveOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockObserveOption) EXPECT 

func (_m *MockObserveOption) EXPECT() *MockObserveOption_Expecter

type MockObserveOption_Expecter 

type MockObserveOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockObserveOption_applyObserve_Call 

type MockObserveOption_applyObserve_Call struct {
	*mock.Call
}

MockObserveOption_applyObserve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyObserve'

func (*MockObserveOption_applyObserve_Call) Return 

func (_c *MockObserveOption_applyObserve_Call) Return(_a0 metric.ObserveConfig) *MockObserveOption_applyObserve_Call

func (*MockObserveOption_applyObserve_Call) Run 

func (_c *MockObserveOption_applyObserve_Call) Run(run func(_a0 metric.ObserveConfig)) *MockObserveOption_applyObserve_Call

func (*MockObserveOption_applyObserve_Call) RunAndReturn 

func (_c *MockObserveOption_applyObserve_Call) RunAndReturn(run func(metric.ObserveConfig) metric.ObserveConfig) *MockObserveOption_applyObserve_Call

type MockObserver 

type MockObserver struct {
	mock.Mock
}

MockObserver is an autogenerated mock type for the Observer type

func NewMockObserver 

func NewMockObserver(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockObserver

NewMockObserver creates a new instance of MockObserver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockObserver) EXPECT 

func (_m *MockObserver) EXPECT() *MockObserver_Expecter

func (*MockObserver) ObserveFloat64 

func (_m *MockObserver) ObserveFloat64(obsrv metric.Float64Observable, value float64, opts ...metric.ObserveOption)

ObserveFloat64 provides a mock function with given fields: obsrv, value, opts

func (*MockObserver) ObserveInt64 

func (_m *MockObserver) ObserveInt64(obsrv metric.Int64Observable, value int64, opts ...metric.ObserveOption)

ObserveInt64 provides a mock function with given fields: obsrv, value, opts

type MockObserver_Expecter 

type MockObserver_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockObserver_Expecter) ObserveFloat64 

func (_e *MockObserver_Expecter) ObserveFloat64(obsrv interface{}, value interface{}, opts ...interface{}) *MockObserver_ObserveFloat64_Call

ObserveFloat64 is a helper method to define mock.On call

  • obsrv metric.Float64Observable
  • value float64
  • opts ...metric.ObserveOption

func (*MockObserver_Expecter) ObserveInt64 

func (_e *MockObserver_Expecter) ObserveInt64(obsrv interface{}, value interface{}, opts ...interface{}) *MockObserver_ObserveInt64_Call

ObserveInt64 is a helper method to define mock.On call

  • obsrv metric.Int64Observable
  • value int64
  • opts ...metric.ObserveOption

type MockObserver_ObserveFloat64_Call 

type MockObserver_ObserveFloat64_Call struct {
	*mock.Call
}

MockObserver_ObserveFloat64_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObserveFloat64'

func (*MockObserver_ObserveFloat64_Call) Return 

func (_c *MockObserver_ObserveFloat64_Call) Return() *MockObserver_ObserveFloat64_Call

func (*MockObserver_ObserveFloat64_Call) Run 

func (_c *MockObserver_ObserveFloat64_Call) Run(run func(obsrv metric.Float64Observable, value float64, opts ...metric.ObserveOption)) *MockObserver_ObserveFloat64_Call

func (*MockObserver_ObserveFloat64_Call) RunAndReturn 

func (_c *MockObserver_ObserveFloat64_Call) RunAndReturn(run func(metric.Float64Observable, float64, ...metric.ObserveOption)) *MockObserver_ObserveFloat64_Call

type MockObserver_ObserveInt64_Call 

type MockObserver_ObserveInt64_Call struct {
	*mock.Call
}

MockObserver_ObserveInt64_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObserveInt64'

func (*MockObserver_ObserveInt64_Call) Return 

func (_c *MockObserver_ObserveInt64_Call) Return() *MockObserver_ObserveInt64_Call

func (*MockObserver_ObserveInt64_Call) Run 

func (_c *MockObserver_ObserveInt64_Call) Run(run func(obsrv metric.Int64Observable, value int64, opts ...metric.ObserveOption)) *MockObserver_ObserveInt64_Call

func (*MockObserver_ObserveInt64_Call) RunAndReturn 

func (_c *MockObserver_ObserveInt64_Call) RunAndReturn(run func(metric.Int64Observable, int64, ...metric.ObserveOption)) *MockObserver_ObserveInt64_Call

type MockObserver_observer_Call 

type MockObserver_observer_Call struct {
	*mock.Call
}

MockObserver_observer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'observer'

func (*MockObserver_observer_Call) Return 

func (_c *MockObserver_observer_Call) Return() *MockObserver_observer_Call

func (*MockObserver_observer_Call) Run 

func (_c *MockObserver_observer_Call) Run(run func()) *MockObserver_observer_Call

func (*MockObserver_observer_Call) RunAndReturn 

func (_c *MockObserver_observer_Call) RunAndReturn(run func()) *MockObserver_observer_Call

type MockRecordOption 

type MockRecordOption struct {
	mock.Mock
}

MockRecordOption is an autogenerated mock type for the RecordOption type

func NewMockRecordOption 

func NewMockRecordOption(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRecordOption

NewMockRecordOption creates a new instance of MockRecordOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockRecordOption) EXPECT 

func (_m *MockRecordOption) EXPECT() *MockRecordOption_Expecter

type MockRecordOption_Expecter 

type MockRecordOption_Expecter struct {
	// contains filtered or unexported fields
}

type MockRecordOption_applyRecord_Call 

type MockRecordOption_applyRecord_Call struct {
	*mock.Call
}

MockRecordOption_applyRecord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'applyRecord'

func (*MockRecordOption_applyRecord_Call) Return 

func (_c *MockRecordOption_applyRecord_Call) Return(_a0 metric.RecordConfig) *MockRecordOption_applyRecord_Call

func (*MockRecordOption_applyRecord_Call) Run 

func (_c *MockRecordOption_applyRecord_Call) Run(run func(_a0 metric.RecordConfig)) *MockRecordOption_applyRecord_Call

func (*MockRecordOption_applyRecord_Call) RunAndReturn 

func (_c *MockRecordOption_applyRecord_Call) RunAndReturn(run func(metric.RecordConfig) metric.RecordConfig) *MockRecordOption_applyRecord_Call

type MockRegistration 

type MockRegistration struct {
	mock.Mock
}

MockRegistration is an autogenerated mock type for the Registration type

func NewMockRegistration 

func NewMockRegistration(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRegistration

NewMockRegistration creates a new instance of MockRegistration. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockRegistration) EXPECT 

func (_m *MockRegistration) EXPECT() *MockRegistration_Expecter

func (*MockRegistration) Unregister 

func (_m *MockRegistration) Unregister() error

Unregister provides a mock function with no fields

type MockRegistration_Expecter 

type MockRegistration_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRegistration_Expecter) Unregister 

func (_e *MockRegistration_Expecter) Unregister() *MockRegistration_Unregister_Call

Unregister is a helper method to define mock.On call

type MockRegistration_Unregister_Call 

type MockRegistration_Unregister_Call struct {
	*mock.Call
}

MockRegistration_Unregister_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unregister'

func (*MockRegistration_Unregister_Call) Return 

func (_c *MockRegistration_Unregister_Call) Return(_a0 error) *MockRegistration_Unregister_Call

func (*MockRegistration_Unregister_Call) Run 

func (_c *MockRegistration_Unregister_Call) Run(run func()) *MockRegistration_Unregister_Call

func (*MockRegistration_Unregister_Call) RunAndReturn 

func (_c *MockRegistration_Unregister_Call) RunAndReturn(run func() error) *MockRegistration_Unregister_Call

type MockRegistration_registration_Call 

type MockRegistration_registration_Call struct {
	*mock.Call
}

MockRegistration_registration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'registration'

func (*MockRegistration_registration_Call) Return 

func (_c *MockRegistration_registration_Call) Return() *MockRegistration_registration_Call

func (*MockRegistration_registration_Call) Run 

func (_c *MockRegistration_registration_Call) Run(run func()) *MockRegistration_registration_Call

func (*MockRegistration_registration_Call) RunAndReturn 

func (_c *MockRegistration_registration_Call) RunAndReturn(run func()) *MockRegistration_registration_Call

type MockmeterOptionFunc 

type MockmeterOptionFunc struct {
	mock.Mock
}

MockmeterOptionFunc is an autogenerated mock type for the meterOptionFunc type

func NewMockmeterOptionFunc 

func NewMockmeterOptionFunc(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockmeterOptionFunc

NewMockmeterOptionFunc creates a new instance of MockmeterOptionFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockmeterOptionFunc) EXPECT 

func (_m *MockmeterOptionFunc) EXPECT() *MockmeterOptionFunc_Expecter

func (*MockmeterOptionFunc) Execute 

func (_m *MockmeterOptionFunc) Execute(_a0 metric.MeterConfig) metric.MeterConfig

Execute provides a mock function with given fields: _a0

type MockmeterOptionFunc_Execute_Call 

type MockmeterOptionFunc_Execute_Call struct {
	*mock.Call
}

MockmeterOptionFunc_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'

func (*MockmeterOptionFunc_Execute_Call) Return 

func (_c *MockmeterOptionFunc_Execute_Call) Return(_a0 metric.MeterConfig) *MockmeterOptionFunc_Execute_Call

func (*MockmeterOptionFunc_Execute_Call) Run 

func (_c *MockmeterOptionFunc_Execute_Call) Run(run func(_a0 metric.MeterConfig)) *MockmeterOptionFunc_Execute_Call

func (*MockmeterOptionFunc_Execute_Call) RunAndReturn 

func (_c *MockmeterOptionFunc_Execute_Call) RunAndReturn(run func(metric.MeterConfig) metric.MeterConfig) *MockmeterOptionFunc_Execute_Call

type MockmeterOptionFunc_Expecter 

type MockmeterOptionFunc_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockmeterOptionFunc_Expecter) Execute 

func (_e *MockmeterOptionFunc_Expecter) Execute(_a0 interface{}) *MockmeterOptionFunc_Execute_Call

Execute is a helper method to define mock.On call

  • _a0 metric.MeterConfig

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.