func (mmSetAttributes *OpentelemetrySpanMock) SetAttributesAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmSetAttributes.afterSetAttributesCounter)
}
SetAttributesAfterCounter returns a count of finished OpentelemetrySpanMock.SetAttributes invocations
package templatestests
import (
	"sync"
	mm_atomic "sync/atomic"
	mm_time "time"
	"github.com/gojuno/minimock/v3"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/codes"
	mm_trace "go.opentelemetry.io/otel/trace"
)
type OpentelemetrySpanMock struct {
	t minimock.Tester
	funcAddEvent          func(name string, options ...mm_trace.EventOption)
	inspectFuncAddEvent   func(name string, options ...mm_trace.EventOption)
	afterAddEventCounter  uint64
	beforeAddEventCounter uint64
	AddEventMock          mOpentelemetrySpanMockAddEvent
	funcEnd          func(options ...mm_trace.SpanEndOption)
	inspectFuncEnd   func(options ...mm_trace.SpanEndOption)
	afterEndCounter  uint64
	beforeEndCounter uint64
	EndMock          mOpentelemetrySpanMockEnd
	funcIsRecording          func() (b1 bool)
	inspectFuncIsRecording   func()
	afterIsRecordingCounter  uint64
	beforeIsRecordingCounter uint64
	IsRecordingMock          mOpentelemetrySpanMockIsRecording
	funcRecordError          func(err error, options ...mm_trace.EventOption)
	inspectFuncRecordError   func(err error, options ...mm_trace.EventOption)
	afterRecordErrorCounter  uint64
	beforeRecordErrorCounter uint64
	RecordErrorMock          mOpentelemetrySpanMockRecordError
	funcSetAttributes          func(kv ...attribute.KeyValue)
	inspectFuncSetAttributes   func(kv ...attribute.KeyValue)
	afterSetAttributesCounter  uint64
	beforeSetAttributesCounter uint64
	SetAttributesMock          mOpentelemetrySpanMockSetAttributes
	funcSetName          func(name string)
	inspectFuncSetName   func(name string)
	afterSetNameCounter  uint64
	beforeSetNameCounter uint64
	SetNameMock          mOpentelemetrySpanMockSetName
	funcSetStatus          func(code codes.Code, description string)
	inspectFuncSetStatus   func(code codes.Code, description string)
	afterSetStatusCounter  uint64
	beforeSetStatusCounter uint64
	SetStatusMock          mOpentelemetrySpanMockSetStatus
	funcSpanContext          func() (s1 mm_trace.SpanContext)
	inspectFuncSpanContext   func()
	afterSpanContextCounter  uint64
	beforeSpanContextCounter uint64
	SpanContextMock          mOpentelemetrySpanMockSpanContext
	funcTracerProvider          func() (t1 mm_trace.TracerProvider)
	inspectFuncTracerProvider   func()
	afterTracerProviderCounter  uint64
	beforeTracerProviderCounter uint64
	TracerProviderMock          mOpentelemetrySpanMockTracerProvider
}
func NewOpentelemetrySpanMock(t minimock.Tester) *OpentelemetrySpanMock {
	m := &OpentelemetrySpanMock{t: t}
	if controller, ok := t.(minimock.MockController); ok {
		controller.RegisterMocker(m)
	}
	m.AddEventMock = mOpentelemetrySpanMockAddEvent{mock: m}
	m.AddEventMock.callArgs = []*OpentelemetrySpanMockAddEventParams{}
	m.EndMock = mOpentelemetrySpanMockEnd{mock: m}
	m.EndMock.callArgs = []*OpentelemetrySpanMockEndParams{}
	m.IsRecordingMock = mOpentelemetrySpanMockIsRecording{mock: m}
	m.RecordErrorMock = mOpentelemetrySpanMockRecordError{mock: m}
	m.RecordErrorMock.callArgs = []*OpentelemetrySpanMockRecordErrorParams{}
	m.SetAttributesMock = mOpentelemetrySpanMockSetAttributes{mock: m}
	m.SetAttributesMock.callArgs = []*OpentelemetrySpanMockSetAttributesParams{}
	m.SetNameMock = mOpentelemetrySpanMockSetName{mock: m}
	m.SetNameMock.callArgs = []*OpentelemetrySpanMockSetNameParams{}
	m.SetStatusMock = mOpentelemetrySpanMockSetStatus{mock: m}
	m.SetStatusMock.callArgs = []*OpentelemetrySpanMockSetStatusParams{}
	m.SpanContextMock = mOpentelemetrySpanMockSpanContext{mock: m}
	m.TracerProviderMock = mOpentelemetrySpanMockTracerProvider{mock: m}
	return m
}
type mOpentelemetrySpanMockAddEvent struct {
	mock               *OpentelemetrySpanMock
	defaultExpectation *OpentelemetrySpanMockAddEventExpectation
	expectations       []*OpentelemetrySpanMockAddEventExpectation
	callArgs []*OpentelemetrySpanMockAddEventParams
	mutex    sync.RWMutex
}
type OpentelemetrySpanMockAddEventExpectation struct {
	mock   *OpentelemetrySpanMock
	params *OpentelemetrySpanMockAddEventParams
	Counter uint64
}
type OpentelemetrySpanMockAddEventParams struct {
	name    string
	options []mm_trace.EventOption
}
func (mmAddEvent *mOpentelemetrySpanMockAddEvent) Expect(name string, options ...mm_trace.EventOption) *mOpentelemetrySpanMockAddEvent {
	if mmAddEvent.mock.funcAddEvent != nil {
		mmAddEvent.mock.t.Fatalf("OpentelemetrySpanMock.AddEvent mock is already set by Set")
	}
	if mmAddEvent.defaultExpectation == nil {
		mmAddEvent.defaultExpectation = &OpentelemetrySpanMockAddEventExpectation{}
	}
	mmAddEvent.defaultExpectation.params = &OpentelemetrySpanMockAddEventParams{name, options}
	for _, e := range mmAddEvent.expectations {
		if minimock.Equal(e.params, mmAddEvent.defaultExpectation.params) {
			mmAddEvent.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmAddEvent.defaultExpectation.params)
		}
	}
	return mmAddEvent
}
func (mmAddEvent *mOpentelemetrySpanMockAddEvent) Inspect(f func(name string, options ...mm_trace.EventOption)) *mOpentelemetrySpanMockAddEvent {
	if mmAddEvent.mock.inspectFuncAddEvent != nil {
		mmAddEvent.mock.t.Fatalf("Inspect function is already set for OpentelemetrySpanMock.AddEvent")
	}
	mmAddEvent.mock.inspectFuncAddEvent = f
	return mmAddEvent
}
func (mmAddEvent *mOpentelemetrySpanMockAddEvent) Return() *OpentelemetrySpanMock {
	if mmAddEvent.mock.funcAddEvent != nil {
		mmAddEvent.mock.t.Fatalf("OpentelemetrySpanMock.AddEvent mock is already set by Set")
	}
	if mmAddEvent.defaultExpectation == nil {
		mmAddEvent.defaultExpectation = &OpentelemetrySpanMockAddEventExpectation{mock: mmAddEvent.mock}
	}
	return mmAddEvent.mock
}
func (mmAddEvent *mOpentelemetrySpanMockAddEvent) Set(f func(name string, options ...mm_trace.EventOption)) *OpentelemetrySpanMock {
	if mmAddEvent.defaultExpectation != nil {
		mmAddEvent.mock.t.Fatalf("Default expectation is already set for the Span.AddEvent method")
	}
	if len(mmAddEvent.expectations) > 0 {
		mmAddEvent.mock.t.Fatalf("Some expectations are already set for the Span.AddEvent method")
	}
	mmAddEvent.mock.funcAddEvent = f
	return mmAddEvent.mock
}
func (mmAddEvent *OpentelemetrySpanMock) AddEvent(name string, options ...mm_trace.EventOption) {
	mm_atomic.AddUint64(&mmAddEvent.beforeAddEventCounter, 1)
	defer mm_atomic.AddUint64(&mmAddEvent.afterAddEventCounter, 1)
	if mmAddEvent.inspectFuncAddEvent != nil {
		mmAddEvent.inspectFuncAddEvent(name, options...)
	}
	mm_params := &OpentelemetrySpanMockAddEventParams{name, options}
	mmAddEvent.AddEventMock.mutex.Lock()
	mmAddEvent.AddEventMock.callArgs = append(mmAddEvent.AddEventMock.callArgs, mm_params)
	mmAddEvent.AddEventMock.mutex.Unlock()
	for _, e := range mmAddEvent.AddEventMock.expectations {
		if minimock.Equal(e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return
		}
	}
	if mmAddEvent.AddEventMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmAddEvent.AddEventMock.defaultExpectation.Counter, 1)
		mm_want := mmAddEvent.AddEventMock.defaultExpectation.params
		mm_got := OpentelemetrySpanMockAddEventParams{name, options}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmAddEvent.t.Errorf("OpentelemetrySpanMock.AddEvent got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}
		return
	}
	if mmAddEvent.funcAddEvent != nil {
		mmAddEvent.funcAddEvent(name, options...)
		return
	}
	mmAddEvent.t.Fatalf("Unexpected call to OpentelemetrySpanMock.AddEvent. %v %v", name, options)
}
func (mmAddEvent *OpentelemetrySpanMock) AddEventAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmAddEvent.afterAddEventCounter)
}
func (mmAddEvent *OpentelemetrySpanMock) AddEventBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmAddEvent.beforeAddEventCounter)
}
func (mmAddEvent *mOpentelemetrySpanMockAddEvent) Calls() []*OpentelemetrySpanMockAddEventParams {
	mmAddEvent.mutex.RLock()
	argCopy := make([]*OpentelemetrySpanMockAddEventParams, len(mmAddEvent.callArgs))
	copy(argCopy, mmAddEvent.callArgs)
	mmAddEvent.mutex.RUnlock()
	return argCopy
}
func (m *OpentelemetrySpanMock) MinimockAddEventDone() bool {
	for _, e := range m.AddEventMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}
	if m.AddEventMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterAddEventCounter) < 1 {
		return false
	}
	if m.funcAddEvent != nil && mm_atomic.LoadUint64(&m.afterAddEventCounter) < 1 {
		return false
	}
	return true
}
func (m *OpentelemetrySpanMock) MinimockAddEventInspect() {
	for _, e := range m.AddEventMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to OpentelemetrySpanMock.AddEvent with params: %#v", *e.params)
		}
	}
	if m.AddEventMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterAddEventCounter) < 1 {
		if m.AddEventMock.defaultExpectation.params == nil {
			m.t.Error("Expected call to OpentelemetrySpanMock.AddEvent")
		} else {
			m.t.Errorf("Expected call to OpentelemetrySpanMock.AddEvent with params: %#v", *m.AddEventMock.defaultExpectation.params)
		}
	}
	if m.funcAddEvent != nil && mm_atomic.LoadUint64(&m.afterAddEventCounter) < 1 {
		m.t.Error("Expected call to OpentelemetrySpanMock.AddEvent")
	}
}
type mOpentelemetrySpanMockEnd struct {
	mock               *OpentelemetrySpanMock
	defaultExpectation *OpentelemetrySpanMockEndExpectation
	expectations       []*OpentelemetrySpanMockEndExpectation
	callArgs []*OpentelemetrySpanMockEndParams
	mutex    sync.RWMutex
}
type OpentelemetrySpanMockEndExpectation struct {
	mock   *OpentelemetrySpanMock
	params *OpentelemetrySpanMockEndParams
	Counter uint64
}
type OpentelemetrySpanMockEndParams struct {
	options []mm_trace.SpanEndOption
}
func (mmEnd *mOpentelemetrySpanMockEnd) Expect(options ...mm_trace.SpanEndOption) *mOpentelemetrySpanMockEnd {
	if mmEnd.mock.funcEnd != nil {
		mmEnd.mock.t.Fatalf("OpentelemetrySpanMock.End mock is already set by Set")
	}
	if mmEnd.defaultExpectation == nil {
		mmEnd.defaultExpectation = &OpentelemetrySpanMockEndExpectation{}
	}
	mmEnd.defaultExpectation.params = &OpentelemetrySpanMockEndParams{options}
	for _, e := range mmEnd.expectations {
		if minimock.Equal(e.params, mmEnd.defaultExpectation.params) {
			mmEnd.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmEnd.defaultExpectation.params)
		}
	}
	return mmEnd
}
func (mmEnd *mOpentelemetrySpanMockEnd) Inspect(f func(options ...mm_trace.SpanEndOption)) *mOpentelemetrySpanMockEnd {
	if mmEnd.mock.inspectFuncEnd != nil {
		mmEnd.mock.t.Fatalf("Inspect function is already set for OpentelemetrySpanMock.End")
	}
	mmEnd.mock.inspectFuncEnd = f
	return mmEnd
}
func (mmEnd *mOpentelemetrySpanMockEnd) Return() *OpentelemetrySpanMock {
	if mmEnd.mock.funcEnd != nil {
		mmEnd.mock.t.Fatalf("OpentelemetrySpanMock.End mock is already set by Set")
	}
	if mmEnd.defaultExpectation == nil {
		mmEnd.defaultExpectation = &OpentelemetrySpanMockEndExpectation{mock: mmEnd.mock}
	}
	return mmEnd.mock
}
func (mmEnd *mOpentelemetrySpanMockEnd) Set(f func(options ...mm_trace.SpanEndOption)) *OpentelemetrySpanMock {
	if mmEnd.defaultExpectation != nil {
		mmEnd.mock.t.Fatalf("Default expectation is already set for the Span.End method")
	}
	if len(mmEnd.expectations) > 0 {
		mmEnd.mock.t.Fatalf("Some expectations are already set for the Span.End method")
	}
	mmEnd.mock.funcEnd = f
	return mmEnd.mock
}
func (mmEnd *OpentelemetrySpanMock) End(options ...mm_trace.SpanEndOption) {
	mm_atomic.AddUint64(&mmEnd.beforeEndCounter, 1)
	defer mm_atomic.AddUint64(&mmEnd.afterEndCounter, 1)
	if mmEnd.inspectFuncEnd != nil {
		mmEnd.inspectFuncEnd(options...)
	}
	mm_params := &OpentelemetrySpanMockEndParams{options}
	mmEnd.EndMock.mutex.Lock()
	mmEnd.EndMock.callArgs = append(mmEnd.EndMock.callArgs, mm_params)
	mmEnd.EndMock.mutex.Unlock()
	for _, e := range mmEnd.EndMock.expectations {
		if minimock.Equal(e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return
		}
	}
	if mmEnd.EndMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmEnd.EndMock.defaultExpectation.Counter, 1)
		mm_want := mmEnd.EndMock.defaultExpectation.params
		mm_got := OpentelemetrySpanMockEndParams{options}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmEnd.t.Errorf("OpentelemetrySpanMock.End got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}
		return
	}
	if mmEnd.funcEnd != nil {
		mmEnd.funcEnd(options...)
		return
	}
	mmEnd.t.Fatalf("Unexpected call to OpentelemetrySpanMock.End. %v", options)
}
func (mmEnd *OpentelemetrySpanMock) EndAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmEnd.afterEndCounter)
}
func (mmEnd *OpentelemetrySpanMock) EndBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmEnd.beforeEndCounter)
}
func (mmEnd *mOpentelemetrySpanMockEnd) Calls() []*OpentelemetrySpanMockEndParams {
	mmEnd.mutex.RLock()
	argCopy := make([]*OpentelemetrySpanMockEndParams, len(mmEnd.callArgs))
	copy(argCopy, mmEnd.callArgs)
	mmEnd.mutex.RUnlock()
	return argCopy
}
func (m *OpentelemetrySpanMock) MinimockEndDone() bool {
	for _, e := range m.EndMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}
	if m.EndMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterEndCounter) < 1 {
		return false
	}
	if m.funcEnd != nil && mm_atomic.LoadUint64(&m.afterEndCounter) < 1 {
		return false
	}
	return true
}
func (m *OpentelemetrySpanMock) MinimockEndInspect() {
	for _, e := range m.EndMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to OpentelemetrySpanMock.End with params: %#v", *e.params)
		}
	}
	if m.EndMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterEndCounter) < 1 {
		if m.EndMock.defaultExpectation.params == nil {
			m.t.Error("Expected call to OpentelemetrySpanMock.End")
		} else {
			m.t.Errorf("Expected call to OpentelemetrySpanMock.End with params: %#v", *m.EndMock.defaultExpectation.params)
		}
	}
	if m.funcEnd != nil && mm_atomic.LoadUint64(&m.afterEndCounter) < 1 {
		m.t.Error("Expected call to OpentelemetrySpanMock.End")
	}
}
type mOpentelemetrySpanMockIsRecording struct {
	mock               *OpentelemetrySpanMock
	defaultExpectation *OpentelemetrySpanMockIsRecordingExpectation
	expectations       []*OpentelemetrySpanMockIsRecordingExpectation
}
type OpentelemetrySpanMockIsRecordingExpectation struct {
	mock *OpentelemetrySpanMock
	results *OpentelemetrySpanMockIsRecordingResults
	Counter uint64
}
type OpentelemetrySpanMockIsRecordingResults struct {
	b1 bool
}
func (mmIsRecording *mOpentelemetrySpanMockIsRecording) Expect() *mOpentelemetrySpanMockIsRecording {
	if mmIsRecording.mock.funcIsRecording != nil {
		mmIsRecording.mock.t.Fatalf("OpentelemetrySpanMock.IsRecording mock is already set by Set")
	}
	if mmIsRecording.defaultExpectation == nil {
		mmIsRecording.defaultExpectation = &OpentelemetrySpanMockIsRecordingExpectation{}
	}
	return mmIsRecording
}
func (mmIsRecording *mOpentelemetrySpanMockIsRecording) Inspect(f func()) *mOpentelemetrySpanMockIsRecording {
	if mmIsRecording.mock.inspectFuncIsRecording != nil {
		mmIsRecording.mock.t.Fatalf("Inspect function is already set for OpentelemetrySpanMock.IsRecording")
	}
	mmIsRecording.mock.inspectFuncIsRecording = f
	return mmIsRecording
}
func (mmIsRecording *mOpentelemetrySpanMockIsRecording) Return(b1 bool) *OpentelemetrySpanMock {
	if mmIsRecording.mock.funcIsRecording != nil {
		mmIsRecording.mock.t.Fatalf("OpentelemetrySpanMock.IsRecording mock is already set by Set")
	}
	if mmIsRecording.defaultExpectation == nil {
		mmIsRecording.defaultExpectation = &OpentelemetrySpanMockIsRecordingExpectation{mock: mmIsRecording.mock}
	}
	mmIsRecording.defaultExpectation.results = &OpentelemetrySpanMockIsRecordingResults{b1}
	return mmIsRecording.mock
}
func (mmIsRecording *mOpentelemetrySpanMockIsRecording) Set(f func() (b1 bool)) *OpentelemetrySpanMock {
	if mmIsRecording.defaultExpectation != nil {
		mmIsRecording.mock.t.Fatalf("Default expectation is already set for the Span.IsRecording method")
	}
	if len(mmIsRecording.expectations) > 0 {
		mmIsRecording.mock.t.Fatalf("Some expectations are already set for the Span.IsRecording method")
	}
	mmIsRecording.mock.funcIsRecording = f
	return mmIsRecording.mock
}
func (mmIsRecording *OpentelemetrySpanMock) IsRecording() (b1 bool) {
	mm_atomic.AddUint64(&mmIsRecording.beforeIsRecordingCounter, 1)
	defer mm_atomic.AddUint64(&mmIsRecording.afterIsRecordingCounter, 1)
	if mmIsRecording.inspectFuncIsRecording != nil {
		mmIsRecording.inspectFuncIsRecording()
	}
	if mmIsRecording.IsRecordingMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmIsRecording.IsRecordingMock.defaultExpectation.Counter, 1)
		mm_results := mmIsRecording.IsRecordingMock.defaultExpectation.results
		if mm_results == nil {
			mmIsRecording.t.Fatal("No results are set for the OpentelemetrySpanMock.IsRecording")
		}
		return (*mm_results).b1
	}
	if mmIsRecording.funcIsRecording != nil {
		return mmIsRecording.funcIsRecording()
	}
	mmIsRecording.t.Fatalf("Unexpected call to OpentelemetrySpanMock.IsRecording.")
	return
}
func (mmIsRecording *OpentelemetrySpanMock) IsRecordingAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmIsRecording.afterIsRecordingCounter)
}
func (mmIsRecording *OpentelemetrySpanMock) IsRecordingBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmIsRecording.beforeIsRecordingCounter)
}
func (m *OpentelemetrySpanMock) MinimockIsRecordingDone() bool {
	for _, e := range m.IsRecordingMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}
	if m.IsRecordingMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterIsRecordingCounter) < 1 {
		return false
	}
	if m.funcIsRecording != nil && mm_atomic.LoadUint64(&m.afterIsRecordingCounter) < 1 {
		return false
	}
	return true
}
func (m *OpentelemetrySpanMock) MinimockIsRecordingInspect() {
	for _, e := range m.IsRecordingMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Error("Expected call to OpentelemetrySpanMock.IsRecording")
		}
	}
	if m.IsRecordingMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterIsRecordingCounter) < 1 {
		m.t.Error("Expected call to OpentelemetrySpanMock.IsRecording")
	}
	if m.funcIsRecording != nil && mm_atomic.LoadUint64(&m.afterIsRecordingCounter) < 1 {
		m.t.Error("Expected call to OpentelemetrySpanMock.IsRecording")
	}
}
type mOpentelemetrySpanMockRecordError struct {
	mock               *OpentelemetrySpanMock
	defaultExpectation *OpentelemetrySpanMockRecordErrorExpectation
	expectations       []*OpentelemetrySpanMockRecordErrorExpectation
	callArgs []*OpentelemetrySpanMockRecordErrorParams
	mutex    sync.RWMutex
}
type OpentelemetrySpanMockRecordErrorExpectation struct {
	mock   *OpentelemetrySpanMock
	params *OpentelemetrySpanMockRecordErrorParams
	Counter uint64
}
type OpentelemetrySpanMockRecordErrorParams struct {
	err     error
	options []mm_trace.EventOption
}
func (mmRecordError *mOpentelemetrySpanMockRecordError) Expect(err error, options ...mm_trace.EventOption) *mOpentelemetrySpanMockRecordError {
	if mmRecordError.mock.funcRecordError != nil {
		mmRecordError.mock.t.Fatalf("OpentelemetrySpanMock.RecordError mock is already set by Set")
	}
	if mmRecordError.defaultExpectation == nil {
		mmRecordError.defaultExpectation = &OpentelemetrySpanMockRecordErrorExpectation{}
	}
	mmRecordError.defaultExpectation.params = &OpentelemetrySpanMockRecordErrorParams{err, options}
	for _, e := range mmRecordError.expectations {
		if minimock.Equal(e.params, mmRecordError.defaultExpectation.params) {
			mmRecordError.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmRecordError.defaultExpectation.params)
		}
	}
	return mmRecordError
}
func (mmRecordError *mOpentelemetrySpanMockRecordError) Inspect(f func(err error, options ...mm_trace.EventOption)) *mOpentelemetrySpanMockRecordError {
	if mmRecordError.mock.inspectFuncRecordError != nil {
		mmRecordError.mock.t.Fatalf("Inspect function is already set for OpentelemetrySpanMock.RecordError")
	}
	mmRecordError.mock.inspectFuncRecordError = f
	return mmRecordError
}
func (mmRecordError *mOpentelemetrySpanMockRecordError) Return() *OpentelemetrySpanMock {
	if mmRecordError.mock.funcRecordError != nil {
		mmRecordError.mock.t.Fatalf("OpentelemetrySpanMock.RecordError mock is already set by Set")
	}
	if mmRecordError.defaultExpectation == nil {
		mmRecordError.defaultExpectation = &OpentelemetrySpanMockRecordErrorExpectation{mock: mmRecordError.mock}
	}
	return mmRecordError.mock
}
func (mmRecordError *mOpentelemetrySpanMockRecordError) Set(f func(err error, options ...mm_trace.EventOption)) *OpentelemetrySpanMock {
	if mmRecordError.defaultExpectation != nil {
		mmRecordError.mock.t.Fatalf("Default expectation is already set for the Span.RecordError method")
	}
	if len(mmRecordError.expectations) > 0 {
		mmRecordError.mock.t.Fatalf("Some expectations are already set for the Span.RecordError method")
	}
	mmRecordError.mock.funcRecordError = f
	return mmRecordError.mock
}
func (mmRecordError *OpentelemetrySpanMock) RecordError(err error, options ...mm_trace.EventOption) {
	mm_atomic.AddUint64(&mmRecordError.beforeRecordErrorCounter, 1)
	defer mm_atomic.AddUint64(&mmRecordError.afterRecordErrorCounter, 1)
	if mmRecordError.inspectFuncRecordError != nil {
		mmRecordError.inspectFuncRecordError(err, options...)
	}
	mm_params := &OpentelemetrySpanMockRecordErrorParams{err, options}
	mmRecordError.RecordErrorMock.mutex.Lock()
	mmRecordError.RecordErrorMock.callArgs = append(mmRecordError.RecordErrorMock.callArgs, mm_params)
	mmRecordError.RecordErrorMock.mutex.Unlock()
	for _, e := range mmRecordError.RecordErrorMock.expectations {
		if minimock.Equal(e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return
		}
	}
	if mmRecordError.RecordErrorMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmRecordError.RecordErrorMock.defaultExpectation.Counter, 1)
		mm_want := mmRecordError.RecordErrorMock.defaultExpectation.params
		mm_got := OpentelemetrySpanMockRecordErrorParams{err, options}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmRecordError.t.Errorf("OpentelemetrySpanMock.RecordError got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}
		return
	}
	if mmRecordError.funcRecordError != nil {
		mmRecordError.funcRecordError(err, options...)
		return
	}
	mmRecordError.t.Fatalf("Unexpected call to OpentelemetrySpanMock.RecordError. %v %v", err, options)
}
func (mmRecordError *OpentelemetrySpanMock) RecordErrorAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmRecordError.afterRecordErrorCounter)
}
func (mmRecordError *OpentelemetrySpanMock) RecordErrorBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmRecordError.beforeRecordErrorCounter)
}
func (mmRecordError *mOpentelemetrySpanMockRecordError) Calls() []*OpentelemetrySpanMockRecordErrorParams {
	mmRecordError.mutex.RLock()
	argCopy := make([]*OpentelemetrySpanMockRecordErrorParams, len(mmRecordError.callArgs))
	copy(argCopy, mmRecordError.callArgs)
	mmRecordError.mutex.RUnlock()
	return argCopy
}
func (m *OpentelemetrySpanMock) MinimockRecordErrorDone() bool {
	for _, e := range m.RecordErrorMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}
	if m.RecordErrorMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterRecordErrorCounter) < 1 {
		return false
	}
	if m.funcRecordError != nil && mm_atomic.LoadUint64(&m.afterRecordErrorCounter) < 1 {
		return false
	}
	return true
}
func (m *OpentelemetrySpanMock) MinimockRecordErrorInspect() {
	for _, e := range m.RecordErrorMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to OpentelemetrySpanMock.RecordError with params: %#v", *e.params)
		}
	}
	if m.RecordErrorMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterRecordErrorCounter) < 1 {
		if m.RecordErrorMock.defaultExpectation.params == nil {
			m.t.Error("Expected call to OpentelemetrySpanMock.RecordError")
		} else {
			m.t.Errorf("Expected call to OpentelemetrySpanMock.RecordError with params: %#v", *m.RecordErrorMock.defaultExpectation.params)
		}
	}
	if m.funcRecordError != nil && mm_atomic.LoadUint64(&m.afterRecordErrorCounter) < 1 {
		m.t.Error("Expected call to OpentelemetrySpanMock.RecordError")
	}
}
type mOpentelemetrySpanMockSetAttributes struct {
	mock               *OpentelemetrySpanMock
	defaultExpectation *OpentelemetrySpanMockSetAttributesExpectation
	expectations       []*OpentelemetrySpanMockSetAttributesExpectation
	callArgs []*OpentelemetrySpanMockSetAttributesParams
	mutex    sync.RWMutex
}
type OpentelemetrySpanMockSetAttributesExpectation struct {
	mock   *OpentelemetrySpanMock
	params *OpentelemetrySpanMockSetAttributesParams
	Counter uint64
}
type OpentelemetrySpanMockSetAttributesParams struct {
	kv []attribute.KeyValue
}
func (mmSetAttributes *mOpentelemetrySpanMockSetAttributes) Expect(kv ...attribute.KeyValue) *mOpentelemetrySpanMockSetAttributes {
	if mmSetAttributes.mock.funcSetAttributes != nil {
		mmSetAttributes.mock.t.Fatalf("OpentelemetrySpanMock.SetAttributes mock is already set by Set")
	}
	if mmSetAttributes.defaultExpectation == nil {
		mmSetAttributes.defaultExpectation = &OpentelemetrySpanMockSetAttributesExpectation{}
	}
	mmSetAttributes.defaultExpectation.params = &OpentelemetrySpanMockSetAttributesParams{kv}
	for _, e := range mmSetAttributes.expectations {
		if minimock.Equal(e.params, mmSetAttributes.defaultExpectation.params) {
			mmSetAttributes.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmSetAttributes.defaultExpectation.params)
		}
	}
	return mmSetAttributes
}
func (mmSetAttributes *mOpentelemetrySpanMockSetAttributes) Inspect(f func(kv ...attribute.KeyValue)) *mOpentelemetrySpanMockSetAttributes {
	if mmSetAttributes.mock.inspectFuncSetAttributes != nil {
		mmSetAttributes.mock.t.Fatalf("Inspect function is already set for OpentelemetrySpanMock.SetAttributes")
	}
	mmSetAttributes.mock.inspectFuncSetAttributes = f
	return mmSetAttributes
}
func (mmSetAttributes *mOpentelemetrySpanMockSetAttributes) Return() *OpentelemetrySpanMock {
	if mmSetAttributes.mock.funcSetAttributes != nil {
		mmSetAttributes.mock.t.Fatalf("OpentelemetrySpanMock.SetAttributes mock is already set by Set")
	}
	if mmSetAttributes.defaultExpectation == nil {
		mmSetAttributes.defaultExpectation = &OpentelemetrySpanMockSetAttributesExpectation{mock: mmSetAttributes.mock}
	}
	return mmSetAttributes.mock
}
func (mmSetAttributes *mOpentelemetrySpanMockSetAttributes) Set(f func(kv ...attribute.KeyValue)) *OpentelemetrySpanMock {
	if mmSetAttributes.defaultExpectation != nil {
		mmSetAttributes.mock.t.Fatalf("Default expectation is already set for the Span.SetAttributes method")
	}
	if len(mmSetAttributes.expectations) > 0 {
		mmSetAttributes.mock.t.Fatalf("Some expectations are already set for the Span.SetAttributes method")
	}
	mmSetAttributes.mock.funcSetAttributes = f
	return mmSetAttributes.mock
}
func (mmSetAttributes *OpentelemetrySpanMock) SetAttributes(kv ...attribute.KeyValue) {
	mm_atomic.AddUint64(&mmSetAttributes.beforeSetAttributesCounter, 1)
	defer mm_atomic.AddUint64(&mmSetAttributes.afterSetAttributesCounter, 1)
	if mmSetAttributes.inspectFuncSetAttributes != nil {
		mmSetAttributes.inspectFuncSetAttributes(kv...)
	}
	mm_params := &OpentelemetrySpanMockSetAttributesParams{kv}
	mmSetAttributes.SetAttributesMock.mutex.Lock()
	mmSetAttributes.SetAttributesMock.callArgs = append(mmSetAttributes.SetAttributesMock.callArgs, mm_params)
	mmSetAttributes.SetAttributesMock.mutex.Unlock()
	for _, e := range mmSetAttributes.SetAttributesMock.expectations {
		if minimock.Equal(e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return
		}
	}
	if mmSetAttributes.SetAttributesMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmSetAttributes.SetAttributesMock.defaultExpectation.Counter, 1)
		mm_want := mmSetAttributes.SetAttributesMock.defaultExpectation.params
		mm_got := OpentelemetrySpanMockSetAttributesParams{kv}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmSetAttributes.t.Errorf("OpentelemetrySpanMock.SetAttributes got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}
		return
	}
	if mmSetAttributes.funcSetAttributes != nil {
		mmSetAttributes.funcSetAttributes(kv...)
		return
	}
	mmSetAttributes.t.Fatalf("Unexpected call to OpentelemetrySpanMock.SetAttributes. %v", kv)
}