func (mmAddMessageReceiveEvent *SpanInterfaceMock) AddMessageReceiveEvent(messageID int64, uncompressedByteSize int64, compressedByteSize int64) {
	mm_atomic.AddUint64(&mmAddMessageReceiveEvent.beforeAddMessageReceiveEventCounter, 1)
	defer mm_atomic.AddUint64(&mmAddMessageReceiveEvent.afterAddMessageReceiveEventCounter, 1)
	if mmAddMessageReceiveEvent.inspectFuncAddMessageReceiveEvent != nil {
		mmAddMessageReceiveEvent.inspectFuncAddMessageReceiveEvent(messageID, uncompressedByteSize, compressedByteSize)
	}
	mm_params := &SpanInterfaceMockAddMessageReceiveEventParams{messageID, uncompressedByteSize, compressedByteSize}
	mmAddMessageReceiveEvent.AddMessageReceiveEventMock.mutex.Lock()
	mmAddMessageReceiveEvent.AddMessageReceiveEventMock.callArgs = append(mmAddMessageReceiveEvent.AddMessageReceiveEventMock.callArgs, mm_params)
	mmAddMessageReceiveEvent.AddMessageReceiveEventMock.mutex.Unlock()
	for _, e := range mmAddMessageReceiveEvent.AddMessageReceiveEventMock.expectations {
		if minimock.Equal(e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return
		}
	}
	if mmAddMessageReceiveEvent.AddMessageReceiveEventMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmAddMessageReceiveEvent.AddMessageReceiveEventMock.defaultExpectation.Counter, 1)
		mm_want := mmAddMessageReceiveEvent.AddMessageReceiveEventMock.defaultExpectation.params
		mm_got := SpanInterfaceMockAddMessageReceiveEventParams{messageID, uncompressedByteSize, compressedByteSize}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmAddMessageReceiveEvent.t.Errorf("SpanInterfaceMock.AddMessageReceiveEvent got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}
		return
	}
	if mmAddMessageReceiveEvent.funcAddMessageReceiveEvent != nil {
		mmAddMessageReceiveEvent.funcAddMessageReceiveEvent(messageID, uncompressedByteSize, compressedByteSize)
		return
	}
	mmAddMessageReceiveEvent.t.Fatalf("Unexpected call to SpanInterfaceMock.AddMessageReceiveEvent. %v %v %v", messageID, uncompressedByteSize, compressedByteSize)
}
AddMessageReceiveEvent implements trace.SpanInterface
package templatestests
import (
	"sync"
	mm_atomic "sync/atomic"
	mm_time "time"
	"github.com/gojuno/minimock/v3"
	mm_trace "go.opencensus.io/trace"
)
type SpanInterfaceMock struct {
	t minimock.Tester
	funcAddAttributes          func(attributes ...mm_trace.Attribute)
	inspectFuncAddAttributes   func(attributes ...mm_trace.Attribute)
	afterAddAttributesCounter  uint64
	beforeAddAttributesCounter uint64
	AddAttributesMock          mSpanInterfaceMockAddAttributes
	funcAddLink          func(l mm_trace.Link)
	inspectFuncAddLink   func(l mm_trace.Link)
	afterAddLinkCounter  uint64
	beforeAddLinkCounter uint64
	AddLinkMock          mSpanInterfaceMockAddLink
	funcAddMessageReceiveEvent          func(messageID int64, uncompressedByteSize int64, compressedByteSize int64)
	inspectFuncAddMessageReceiveEvent   func(messageID int64, uncompressedByteSize int64, compressedByteSize int64)
	afterAddMessageReceiveEventCounter  uint64
	beforeAddMessageReceiveEventCounter uint64
	AddMessageReceiveEventMock          mSpanInterfaceMockAddMessageReceiveEvent
	funcAddMessageSendEvent          func(messageID int64, uncompressedByteSize int64, compressedByteSize int64)
	inspectFuncAddMessageSendEvent   func(messageID int64, uncompressedByteSize int64, compressedByteSize int64)
	afterAddMessageSendEventCounter  uint64
	beforeAddMessageSendEventCounter uint64
	AddMessageSendEventMock          mSpanInterfaceMockAddMessageSendEvent
	funcAnnotate          func(attributes []mm_trace.Attribute, str string)
	inspectFuncAnnotate   func(attributes []mm_trace.Attribute, str string)
	afterAnnotateCounter  uint64
	beforeAnnotateCounter uint64
	AnnotateMock          mSpanInterfaceMockAnnotate
	funcAnnotatef          func(attributes []mm_trace.Attribute, format string, a ...interface{})
	inspectFuncAnnotatef   func(attributes []mm_trace.Attribute, format string, a ...interface{})
	afterAnnotatefCounter  uint64
	beforeAnnotatefCounter uint64
	AnnotatefMock          mSpanInterfaceMockAnnotatef
	funcEnd          func()
	inspectFuncEnd   func()
	afterEndCounter  uint64
	beforeEndCounter uint64
	EndMock          mSpanInterfaceMockEnd
	funcIsRecordingEvents          func() (b1 bool)
	inspectFuncIsRecordingEvents   func()
	afterIsRecordingEventsCounter  uint64
	beforeIsRecordingEventsCounter uint64
	IsRecordingEventsMock          mSpanInterfaceMockIsRecordingEvents
	funcSetName          func(name string)
	inspectFuncSetName   func(name string)
	afterSetNameCounter  uint64
	beforeSetNameCounter uint64
	SetNameMock          mSpanInterfaceMockSetName
	funcSetStatus          func(status mm_trace.Status)
	inspectFuncSetStatus   func(status mm_trace.Status)
	afterSetStatusCounter  uint64
	beforeSetStatusCounter uint64
	SetStatusMock          mSpanInterfaceMockSetStatus
	funcSpanContext          func() (s1 mm_trace.SpanContext)
	inspectFuncSpanContext   func()
	afterSpanContextCounter  uint64
	beforeSpanContextCounter uint64
	SpanContextMock          mSpanInterfaceMockSpanContext
	funcString          func() (s1 string)
	inspectFuncString   func()
	afterStringCounter  uint64
	beforeStringCounter uint64
	StringMock          mSpanInterfaceMockString
}
func NewSpanInterfaceMock(t minimock.Tester) *SpanInterfaceMock {
	m := &SpanInterfaceMock{t: t}
	if controller, ok := t.(minimock.MockController); ok {
		controller.RegisterMocker(m)
	}
	m.AddAttributesMock = mSpanInterfaceMockAddAttributes{mock: m}
	m.AddAttributesMock.callArgs = []*SpanInterfaceMockAddAttributesParams{}
	m.AddLinkMock = mSpanInterfaceMockAddLink{mock: m}
	m.AddLinkMock.callArgs = []*SpanInterfaceMockAddLinkParams{}
	m.AddMessageReceiveEventMock = mSpanInterfaceMockAddMessageReceiveEvent{mock: m}
	m.AddMessageReceiveEventMock.callArgs = []*SpanInterfaceMockAddMessageReceiveEventParams{}
	m.AddMessageSendEventMock = mSpanInterfaceMockAddMessageSendEvent{mock: m}
	m.AddMessageSendEventMock.callArgs = []*SpanInterfaceMockAddMessageSendEventParams{}
	m.AnnotateMock = mSpanInterfaceMockAnnotate{mock: m}
	m.AnnotateMock.callArgs = []*SpanInterfaceMockAnnotateParams{}
	m.AnnotatefMock = mSpanInterfaceMockAnnotatef{mock: m}
	m.AnnotatefMock.callArgs = []*SpanInterfaceMockAnnotatefParams{}
	m.EndMock = mSpanInterfaceMockEnd{mock: m}
	m.IsRecordingEventsMock = mSpanInterfaceMockIsRecordingEvents{mock: m}
	m.SetNameMock = mSpanInterfaceMockSetName{mock: m}
	m.SetNameMock.callArgs = []*SpanInterfaceMockSetNameParams{}
	m.SetStatusMock = mSpanInterfaceMockSetStatus{mock: m}
	m.SetStatusMock.callArgs = []*SpanInterfaceMockSetStatusParams{}
	m.SpanContextMock = mSpanInterfaceMockSpanContext{mock: m}
	m.StringMock = mSpanInterfaceMockString{mock: m}
	return m
}
type mSpanInterfaceMockAddAttributes struct {
	mock               *SpanInterfaceMock
	defaultExpectation *SpanInterfaceMockAddAttributesExpectation
	expectations       []*SpanInterfaceMockAddAttributesExpectation
	callArgs []*SpanInterfaceMockAddAttributesParams
	mutex    sync.RWMutex
}
type SpanInterfaceMockAddAttributesExpectation struct {
	mock   *SpanInterfaceMock
	params *SpanInterfaceMockAddAttributesParams
	Counter uint64
}
type SpanInterfaceMockAddAttributesParams struct {
	attributes []mm_trace.Attribute
}
func (mmAddAttributes *mSpanInterfaceMockAddAttributes) Expect(attributes ...mm_trace.Attribute) *mSpanInterfaceMockAddAttributes {
	if mmAddAttributes.mock.funcAddAttributes != nil {
		mmAddAttributes.mock.t.Fatalf("SpanInterfaceMock.AddAttributes mock is already set by Set")
	}
	if mmAddAttributes.defaultExpectation == nil {
		mmAddAttributes.defaultExpectation = &SpanInterfaceMockAddAttributesExpectation{}
	}
	mmAddAttributes.defaultExpectation.params = &SpanInterfaceMockAddAttributesParams{attributes}
	for _, e := range mmAddAttributes.expectations {
		if minimock.Equal(e.params, mmAddAttributes.defaultExpectation.params) {
			mmAddAttributes.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmAddAttributes.defaultExpectation.params)
		}
	}
	return mmAddAttributes
}
func (mmAddAttributes *mSpanInterfaceMockAddAttributes) Inspect(f func(attributes ...mm_trace.Attribute)) *mSpanInterfaceMockAddAttributes {
	if mmAddAttributes.mock.inspectFuncAddAttributes != nil {
		mmAddAttributes.mock.t.Fatalf("Inspect function is already set for SpanInterfaceMock.AddAttributes")
	}
	mmAddAttributes.mock.inspectFuncAddAttributes = f
	return mmAddAttributes
}
func (mmAddAttributes *mSpanInterfaceMockAddAttributes) Return() *SpanInterfaceMock {
	if mmAddAttributes.mock.funcAddAttributes != nil {
		mmAddAttributes.mock.t.Fatalf("SpanInterfaceMock.AddAttributes mock is already set by Set")
	}
	if mmAddAttributes.defaultExpectation == nil {
		mmAddAttributes.defaultExpectation = &SpanInterfaceMockAddAttributesExpectation{mock: mmAddAttributes.mock}
	}
	return mmAddAttributes.mock
}
func (mmAddAttributes *mSpanInterfaceMockAddAttributes) Set(f func(attributes ...mm_trace.Attribute)) *SpanInterfaceMock {
	if mmAddAttributes.defaultExpectation != nil {
		mmAddAttributes.mock.t.Fatalf("Default expectation is already set for the SpanInterface.AddAttributes method")
	}
	if len(mmAddAttributes.expectations) > 0 {
		mmAddAttributes.mock.t.Fatalf("Some expectations are already set for the SpanInterface.AddAttributes method")
	}
	mmAddAttributes.mock.funcAddAttributes = f
	return mmAddAttributes.mock
}
func (mmAddAttributes *SpanInterfaceMock) AddAttributes(attributes ...mm_trace.Attribute) {
	mm_atomic.AddUint64(&mmAddAttributes.beforeAddAttributesCounter, 1)
	defer mm_atomic.AddUint64(&mmAddAttributes.afterAddAttributesCounter, 1)
	if mmAddAttributes.inspectFuncAddAttributes != nil {
		mmAddAttributes.inspectFuncAddAttributes(attributes...)
	}
	mm_params := &SpanInterfaceMockAddAttributesParams{attributes}
	mmAddAttributes.AddAttributesMock.mutex.Lock()
	mmAddAttributes.AddAttributesMock.callArgs = append(mmAddAttributes.AddAttributesMock.callArgs, mm_params)
	mmAddAttributes.AddAttributesMock.mutex.Unlock()
	for _, e := range mmAddAttributes.AddAttributesMock.expectations {
		if minimock.Equal(e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return
		}
	}
	if mmAddAttributes.AddAttributesMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmAddAttributes.AddAttributesMock.defaultExpectation.Counter, 1)
		mm_want := mmAddAttributes.AddAttributesMock.defaultExpectation.params
		mm_got := SpanInterfaceMockAddAttributesParams{attributes}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmAddAttributes.t.Errorf("SpanInterfaceMock.AddAttributes got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}
		return
	}
	if mmAddAttributes.funcAddAttributes != nil {
		mmAddAttributes.funcAddAttributes(attributes...)
		return
	}
	mmAddAttributes.t.Fatalf("Unexpected call to SpanInterfaceMock.AddAttributes. %v", attributes)
}
func (mmAddAttributes *SpanInterfaceMock) AddAttributesAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmAddAttributes.afterAddAttributesCounter)
}
func (mmAddAttributes *SpanInterfaceMock) AddAttributesBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmAddAttributes.beforeAddAttributesCounter)
}
func (mmAddAttributes *mSpanInterfaceMockAddAttributes) Calls() []*SpanInterfaceMockAddAttributesParams {
	mmAddAttributes.mutex.RLock()
	argCopy := make([]*SpanInterfaceMockAddAttributesParams, len(mmAddAttributes.callArgs))
	copy(argCopy, mmAddAttributes.callArgs)
	mmAddAttributes.mutex.RUnlock()
	return argCopy
}
func (m *SpanInterfaceMock) MinimockAddAttributesDone() bool {
	for _, e := range m.AddAttributesMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}
	if m.AddAttributesMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterAddAttributesCounter) < 1 {
		return false
	}
	if m.funcAddAttributes != nil && mm_atomic.LoadUint64(&m.afterAddAttributesCounter) < 1 {
		return false
	}
	return true
}
func (m *SpanInterfaceMock) MinimockAddAttributesInspect() {
	for _, e := range m.AddAttributesMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to SpanInterfaceMock.AddAttributes with params: %#v", *e.params)
		}
	}
	if m.AddAttributesMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterAddAttributesCounter) < 1 {
		if m.AddAttributesMock.defaultExpectation.params == nil {
			m.t.Error("Expected call to SpanInterfaceMock.AddAttributes")
		} else {
			m.t.Errorf("Expected call to SpanInterfaceMock.AddAttributes with params: %#v", *m.AddAttributesMock.defaultExpectation.params)
		}
	}
	if m.funcAddAttributes != nil && mm_atomic.LoadUint64(&m.afterAddAttributesCounter) < 1 {
		m.t.Error("Expected call to SpanInterfaceMock.AddAttributes")
	}
}
type mSpanInterfaceMockAddLink struct {
	mock               *SpanInterfaceMock
	defaultExpectation *SpanInterfaceMockAddLinkExpectation
	expectations       []*SpanInterfaceMockAddLinkExpectation
	callArgs []*SpanInterfaceMockAddLinkParams
	mutex    sync.RWMutex
}
type SpanInterfaceMockAddLinkExpectation struct {
	mock   *SpanInterfaceMock
	params *SpanInterfaceMockAddLinkParams
	Counter uint64
}
type SpanInterfaceMockAddLinkParams struct {
	l mm_trace.Link
}
func (mmAddLink *mSpanInterfaceMockAddLink) Expect(l mm_trace.Link) *mSpanInterfaceMockAddLink {
	if mmAddLink.mock.funcAddLink != nil {
		mmAddLink.mock.t.Fatalf("SpanInterfaceMock.AddLink mock is already set by Set")
	}
	if mmAddLink.defaultExpectation == nil {
		mmAddLink.defaultExpectation = &SpanInterfaceMockAddLinkExpectation{}
	}
	mmAddLink.defaultExpectation.params = &SpanInterfaceMockAddLinkParams{l}
	for _, e := range mmAddLink.expectations {
		if minimock.Equal(e.params, mmAddLink.defaultExpectation.params) {
			mmAddLink.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmAddLink.defaultExpectation.params)
		}
	}
	return mmAddLink
}
func (mmAddLink *mSpanInterfaceMockAddLink) Inspect(f func(l mm_trace.Link)) *mSpanInterfaceMockAddLink {
	if mmAddLink.mock.inspectFuncAddLink != nil {
		mmAddLink.mock.t.Fatalf("Inspect function is already set for SpanInterfaceMock.AddLink")
	}
	mmAddLink.mock.inspectFuncAddLink = f
	return mmAddLink
}
func (mmAddLink *mSpanInterfaceMockAddLink) Return() *SpanInterfaceMock {
	if mmAddLink.mock.funcAddLink != nil {
		mmAddLink.mock.t.Fatalf("SpanInterfaceMock.AddLink mock is already set by Set")
	}
	if mmAddLink.defaultExpectation == nil {
		mmAddLink.defaultExpectation = &SpanInterfaceMockAddLinkExpectation{mock: mmAddLink.mock}
	}
	return mmAddLink.mock
}
func (mmAddLink *mSpanInterfaceMockAddLink) Set(f func(l mm_trace.Link)) *SpanInterfaceMock {
	if mmAddLink.defaultExpectation != nil {
		mmAddLink.mock.t.Fatalf("Default expectation is already set for the SpanInterface.AddLink method")
	}
	if len(mmAddLink.expectations) > 0 {
		mmAddLink.mock.t.Fatalf("Some expectations are already set for the SpanInterface.AddLink method")
	}
	mmAddLink.mock.funcAddLink = f
	return mmAddLink.mock
}
func (mmAddLink *SpanInterfaceMock) AddLink(l mm_trace.Link) {
	mm_atomic.AddUint64(&mmAddLink.beforeAddLinkCounter, 1)
	defer mm_atomic.AddUint64(&mmAddLink.afterAddLinkCounter, 1)
	if mmAddLink.inspectFuncAddLink != nil {
		mmAddLink.inspectFuncAddLink(l)
	}
	mm_params := &SpanInterfaceMockAddLinkParams{l}
	mmAddLink.AddLinkMock.mutex.Lock()
	mmAddLink.AddLinkMock.callArgs = append(mmAddLink.AddLinkMock.callArgs, mm_params)
	mmAddLink.AddLinkMock.mutex.Unlock()
	for _, e := range mmAddLink.AddLinkMock.expectations {
		if minimock.Equal(e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return
		}
	}
	if mmAddLink.AddLinkMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmAddLink.AddLinkMock.defaultExpectation.Counter, 1)
		mm_want := mmAddLink.AddLinkMock.defaultExpectation.params
		mm_got := SpanInterfaceMockAddLinkParams{l}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmAddLink.t.Errorf("SpanInterfaceMock.AddLink got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}
		return
	}
	if mmAddLink.funcAddLink != nil {
		mmAddLink.funcAddLink(l)
		return
	}
	mmAddLink.t.Fatalf("Unexpected call to SpanInterfaceMock.AddLink. %v", l)
}
func (mmAddLink *SpanInterfaceMock) AddLinkAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmAddLink.afterAddLinkCounter)
}
func (mmAddLink *SpanInterfaceMock) AddLinkBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmAddLink.beforeAddLinkCounter)
}
func (mmAddLink *mSpanInterfaceMockAddLink) Calls() []*SpanInterfaceMockAddLinkParams {
	mmAddLink.mutex.RLock()
	argCopy := make([]*SpanInterfaceMockAddLinkParams, len(mmAddLink.callArgs))
	copy(argCopy, mmAddLink.callArgs)
	mmAddLink.mutex.RUnlock()
	return argCopy
}
func (m *SpanInterfaceMock) MinimockAddLinkDone() bool {
	for _, e := range m.AddLinkMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}
	if m.AddLinkMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterAddLinkCounter) < 1 {
		return false
	}
	if m.funcAddLink != nil && mm_atomic.LoadUint64(&m.afterAddLinkCounter) < 1 {
		return false
	}
	return true
}
func (m *SpanInterfaceMock) MinimockAddLinkInspect() {
	for _, e := range m.AddLinkMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to SpanInterfaceMock.AddLink with params: %#v", *e.params)
		}
	}
	if m.AddLinkMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterAddLinkCounter) < 1 {
		if m.AddLinkMock.defaultExpectation.params == nil {
			m.t.Error("Expected call to SpanInterfaceMock.AddLink")
		} else {
			m.t.Errorf("Expected call to SpanInterfaceMock.AddLink with params: %#v", *m.AddLinkMock.defaultExpectation.params)
		}
	}
	if m.funcAddLink != nil && mm_atomic.LoadUint64(&m.afterAddLinkCounter) < 1 {
		m.t.Error("Expected call to SpanInterfaceMock.AddLink")
	}
}
type mSpanInterfaceMockAddMessageReceiveEvent struct {
	mock               *SpanInterfaceMock
	defaultExpectation *SpanInterfaceMockAddMessageReceiveEventExpectation
	expectations       []*SpanInterfaceMockAddMessageReceiveEventExpectation
	callArgs []*SpanInterfaceMockAddMessageReceiveEventParams
	mutex    sync.RWMutex
}
type SpanInterfaceMockAddMessageReceiveEventExpectation struct {
	mock   *SpanInterfaceMock
	params *SpanInterfaceMockAddMessageReceiveEventParams
	Counter uint64
}
type SpanInterfaceMockAddMessageReceiveEventParams struct {
	messageID            int64
	uncompressedByteSize int64
	compressedByteSize   int64
}
func (mmAddMessageReceiveEvent *mSpanInterfaceMockAddMessageReceiveEvent) Expect(messageID int64, uncompressedByteSize int64, compressedByteSize int64) *mSpanInterfaceMockAddMessageReceiveEvent {
	if mmAddMessageReceiveEvent.mock.funcAddMessageReceiveEvent != nil {
		mmAddMessageReceiveEvent.mock.t.Fatalf("SpanInterfaceMock.AddMessageReceiveEvent mock is already set by Set")
	}
	if mmAddMessageReceiveEvent.defaultExpectation == nil {
		mmAddMessageReceiveEvent.defaultExpectation = &SpanInterfaceMockAddMessageReceiveEventExpectation{}
	}
	mmAddMessageReceiveEvent.defaultExpectation.params = &SpanInterfaceMockAddMessageReceiveEventParams{messageID, uncompressedByteSize, compressedByteSize}
	for _, e := range mmAddMessageReceiveEvent.expectations {
		if minimock.Equal(e.params, mmAddMessageReceiveEvent.defaultExpectation.params) {
			mmAddMessageReceiveEvent.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmAddMessageReceiveEvent.defaultExpectation.params)
		}
	}
	return mmAddMessageReceiveEvent
}
func (mmAddMessageReceiveEvent *mSpanInterfaceMockAddMessageReceiveEvent) Inspect(f func(messageID int64, uncompressedByteSize int64, compressedByteSize int64)) *mSpanInterfaceMockAddMessageReceiveEvent {
	if mmAddMessageReceiveEvent.mock.inspectFuncAddMessageReceiveEvent != nil {
		mmAddMessageReceiveEvent.mock.t.Fatalf("Inspect function is already set for SpanInterfaceMock.AddMessageReceiveEvent")
	}
	mmAddMessageReceiveEvent.mock.inspectFuncAddMessageReceiveEvent = f
	return mmAddMessageReceiveEvent
}
func (mmAddMessageReceiveEvent *mSpanInterfaceMockAddMessageReceiveEvent) Return() *SpanInterfaceMock {
	if mmAddMessageReceiveEvent.mock.funcAddMessageReceiveEvent != nil {
		mmAddMessageReceiveEvent.mock.t.Fatalf("SpanInterfaceMock.AddMessageReceiveEvent mock is already set by Set")
	}
	if mmAddMessageReceiveEvent.defaultExpectation == nil {
		mmAddMessageReceiveEvent.defaultExpectation = &SpanInterfaceMockAddMessageReceiveEventExpectation{mock: mmAddMessageReceiveEvent.mock}
	}
	return mmAddMessageReceiveEvent.mock
}
func (mmAddMessageReceiveEvent *mSpanInterfaceMockAddMessageReceiveEvent) Set(f func(messageID int64, uncompressedByteSize int64, compressedByteSize int64)) *SpanInterfaceMock {
	if mmAddMessageReceiveEvent.defaultExpectation != nil {
		mmAddMessageReceiveEvent.mock.t.Fatalf("Default expectation is already set for the SpanInterface.AddMessageReceiveEvent method")
	}
	if len(mmAddMessageReceiveEvent.expectations) > 0 {
		mmAddMessageReceiveEvent.mock.t.Fatalf("Some expectations are already set for the SpanInterface.AddMessageReceiveEvent method")
	}
	mmAddMessageReceiveEvent.mock.funcAddMessageReceiveEvent = f
	return mmAddMessageReceiveEvent.mock
}