func (m *mSpanMockFinishWithOptions) Return() *SpanMock {
	m.mock.FinishWithOptionsFunc = func(p opentracing.FinishOptions) {
		return
	}
	return m.mock
}
Return sets up a mock for Span.FinishWithOptions to return Return's arguments
package templatestests
import (
	"sync/atomic"
	"time"
	minimock "github.com/gojuno/minimock/v3"
	opentracing "github.com/opentracing/opentracing-go"
	log "github.com/opentracing/opentracing-go/log"
	testify_assert "github.com/stretchr/testify/assert"
)
type SpanMock struct {
	t minimock.Tester
	BaggageItemFunc       func(p string) (r string)
	BaggageItemCounter    uint64
	BaggageItemPreCounter uint64
	BaggageItemMock       mSpanMockBaggageItem
	ContextFunc       func() (r opentracing.SpanContext)
	ContextCounter    uint64
	ContextPreCounter uint64
	ContextMock       mSpanMockContext
	FinishFunc       func()
	FinishCounter    uint64
	FinishPreCounter uint64
	FinishMock       mSpanMockFinish
	FinishWithOptionsFunc       func(p opentracing.FinishOptions)
	FinishWithOptionsCounter    uint64
	FinishWithOptionsPreCounter uint64
	FinishWithOptionsMock       mSpanMockFinishWithOptions
	LogFunc       func(p opentracing.LogData)
	LogCounter    uint64
	LogPreCounter uint64
	LogMock       mSpanMockLog
	LogEventFunc       func(p string)
	LogEventCounter    uint64
	LogEventPreCounter uint64
	LogEventMock       mSpanMockLogEvent
	LogEventWithPayloadFunc       func(p string, p1 interface{})
	LogEventWithPayloadCounter    uint64
	LogEventWithPayloadPreCounter uint64
	LogEventWithPayloadMock       mSpanMockLogEventWithPayload
	LogFieldsFunc       func(p ...log.Field)
	LogFieldsCounter    uint64
	LogFieldsPreCounter uint64
	LogFieldsMock       mSpanMockLogFields
	LogKVFunc       func(p ...interface{})
	LogKVCounter    uint64
	LogKVPreCounter uint64
	LogKVMock       mSpanMockLogKV
	SetBaggageItemFunc       func(p string, p1 string) (r opentracing.Span)
	SetBaggageItemCounter    uint64
	SetBaggageItemPreCounter uint64
	SetBaggageItemMock       mSpanMockSetBaggageItem
	SetOperationNameFunc       func(p string) (r opentracing.Span)
	SetOperationNameCounter    uint64
	SetOperationNamePreCounter uint64
	SetOperationNameMock       mSpanMockSetOperationName
	SetTagFunc       func(p string, p1 interface{}) (r opentracing.Span)
	SetTagCounter    uint64
	SetTagPreCounter uint64
	SetTagMock       mSpanMockSetTag
	TracerFunc       func() (r opentracing.Tracer)
	TracerCounter    uint64
	TracerPreCounter uint64
	TracerMock       mSpanMockTracer
}
func NewSpanMock(t minimock.Tester) *SpanMock {
	m := &SpanMock{t: t}
	if controller, ok := t.(minimock.MockController); ok {
		controller.RegisterMocker(m)
	}
	m.BaggageItemMock = mSpanMockBaggageItem{mock: m}
	m.ContextMock = mSpanMockContext{mock: m}
	m.FinishMock = mSpanMockFinish{mock: m}
	m.FinishWithOptionsMock = mSpanMockFinishWithOptions{mock: m}
	m.LogMock = mSpanMockLog{mock: m}
	m.LogEventMock = mSpanMockLogEvent{mock: m}
	m.LogEventWithPayloadMock = mSpanMockLogEventWithPayload{mock: m}
	m.LogFieldsMock = mSpanMockLogFields{mock: m}
	m.LogKVMock = mSpanMockLogKV{mock: m}
	m.SetBaggageItemMock = mSpanMockSetBaggageItem{mock: m}
	m.SetOperationNameMock = mSpanMockSetOperationName{mock: m}
	m.SetTagMock = mSpanMockSetTag{mock: m}
	m.TracerMock = mSpanMockTracer{mock: m}
	return m
}
type mSpanMockBaggageItem struct {
	mock             *SpanMock
	mockExpectations *SpanMockBaggageItemParams
}
type SpanMockBaggageItemParams struct {
	p string
}
func (m *mSpanMockBaggageItem) Expect(p string) *mSpanMockBaggageItem {
	m.mockExpectations = &SpanMockBaggageItemParams{p}
	return m
}
func (m *mSpanMockBaggageItem) Return(r string) *SpanMock {
	m.mock.BaggageItemFunc = func(p string) string {
		return r
	}
	return m.mock
}
func (m *mSpanMockBaggageItem) Set(f func(p string) (r string)) *SpanMock {
	m.mock.BaggageItemFunc = f
	return m.mock
}
func (m *SpanMock) BaggageItem(p string) (r string) {
	atomic.AddUint64(&m.BaggageItemPreCounter, 1)
	defer atomic.AddUint64(&m.BaggageItemCounter, 1)
	if m.BaggageItemMock.mockExpectations != nil {
		testify_assert.Equal(m.t, *m.BaggageItemMock.mockExpectations, SpanMockBaggageItemParams{p},
			"Span.BaggageItem got unexpected parameters")
		if m.BaggageItemFunc == nil {
			m.t.Fatal("No results are set for the SpanMock.BaggageItem")
			return
		}
	}
	if m.BaggageItemFunc == nil {
		m.t.Fatal("Unexpected call to SpanMock.BaggageItem")
		return
	}
	return m.BaggageItemFunc(p)
}
func (m *SpanMock) BaggageItemMinimockCounter() uint64 {
	return atomic.LoadUint64(&m.BaggageItemCounter)
}
func (m *SpanMock) BaggageItemMinimockPreCounter() uint64 {
	return atomic.LoadUint64(&m.BaggageItemPreCounter)
}
type mSpanMockContext struct {
	mock *SpanMock
}
func (m *mSpanMockContext) Return(r opentracing.SpanContext) *SpanMock {
	m.mock.ContextFunc = func() opentracing.SpanContext {
		return r
	}
	return m.mock
}
func (m *mSpanMockContext) Set(f func() (r opentracing.SpanContext)) *SpanMock {
	m.mock.ContextFunc = f
	return m.mock
}
func (m *SpanMock) Context() (r opentracing.SpanContext) {
	atomic.AddUint64(&m.ContextPreCounter, 1)
	defer atomic.AddUint64(&m.ContextCounter, 1)
	if m.ContextFunc == nil {
		m.t.Fatal("Unexpected call to SpanMock.Context")
		return
	}
	return m.ContextFunc()
}
func (m *SpanMock) ContextMinimockCounter() uint64 {
	return atomic.LoadUint64(&m.ContextCounter)
}
func (m *SpanMock) ContextMinimockPreCounter() uint64 {
	return atomic.LoadUint64(&m.ContextPreCounter)
}
type mSpanMockFinish struct {
	mock *SpanMock
}
func (m *mSpanMockFinish) Return() *SpanMock {
	m.mock.FinishFunc = func() {
		return
	}
	return m.mock
}
func (m *mSpanMockFinish) Set(f func()) *SpanMock {
	m.mock.FinishFunc = f
	return m.mock
}
func (m *SpanMock) Finish() {
	atomic.AddUint64(&m.FinishPreCounter, 1)
	defer atomic.AddUint64(&m.FinishCounter, 1)
	if m.FinishFunc == nil {
		m.t.Fatal("Unexpected call to SpanMock.Finish")
		return
	}
	m.FinishFunc()
}
func (m *SpanMock) FinishMinimockCounter() uint64 {
	return atomic.LoadUint64(&m.FinishCounter)
}
func (m *SpanMock) FinishMinimockPreCounter() uint64 {
	return atomic.LoadUint64(&m.FinishPreCounter)
}
type mSpanMockFinishWithOptions struct {
	mock             *SpanMock
	mockExpectations *SpanMockFinishWithOptionsParams
}
type SpanMockFinishWithOptionsParams struct {
	p opentracing.FinishOptions
}
func (m *mSpanMockFinishWithOptions) Expect(p opentracing.FinishOptions) *mSpanMockFinishWithOptions {
	m.mockExpectations = &SpanMockFinishWithOptionsParams{p}
	return m
}