func (mmAddEvent *OpentelemetrySpanMock) AddEventAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmAddEvent.afterAddEventCounter)
}
AddEventAfterCounter returns a count of finished OpentelemetrySpanMock.AddEvent 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)
}