func (mmStartSpan *mTracerOpenCensusMockStartSpan) Set(f func(ctx context.Context, name string, o ...mm_trace.StartOption) (c2 context.Context, sp1 *mm_trace.Span)) *TracerOpenCensusMock {
	if mmStartSpan.defaultExpectation != nil {
		mmStartSpan.mock.t.Fatalf("Default expectation is already set for the Tracer.StartSpan method")
	}
	if len(mmStartSpan.expectations) > 0 {
		mmStartSpan.mock.t.Fatalf("Some expectations are already set for the Tracer.StartSpan method")
	}
	mmStartSpan.mock.funcStartSpan = f
	return mmStartSpan.mock
}
Set uses given function f to mock the Tracer.StartSpan method
package templatestests
import (
	"context"
	"sync"
	mm_atomic "sync/atomic"
	mm_time "time"
	"github.com/gojuno/minimock/v3"
	mm_trace "go.opencensus.io/trace"
)
type TracerOpenCensusMock struct {
	t minimock.Tester
	funcFromContext          func(ctx context.Context) (sp1 *mm_trace.Span)
	inspectFuncFromContext   func(ctx context.Context)
	afterFromContextCounter  uint64
	beforeFromContextCounter uint64
	FromContextMock          mTracerOpenCensusMockFromContext
	funcNewContext          func(ctx context.Context, s *mm_trace.Span) (c1 context.Context)
	inspectFuncNewContext   func(ctx context.Context, s *mm_trace.Span)
	afterNewContextCounter  uint64
	beforeNewContextCounter uint64
	NewContextMock          mTracerOpenCensusMockNewContext
	funcStartSpan          func(ctx context.Context, name string, o ...mm_trace.StartOption) (c2 context.Context, sp1 *mm_trace.Span)
	inspectFuncStartSpan   func(ctx context.Context, name string, o ...mm_trace.StartOption)
	afterStartSpanCounter  uint64
	beforeStartSpanCounter uint64
	StartSpanMock          mTracerOpenCensusMockStartSpan
	funcStartSpanWithRemoteParent          func(ctx context.Context, name string, parent mm_trace.SpanContext, o ...mm_trace.StartOption) (c2 context.Context, sp1 *mm_trace.Span)
	inspectFuncStartSpanWithRemoteParent   func(ctx context.Context, name string, parent mm_trace.SpanContext, o ...mm_trace.StartOption)
	afterStartSpanWithRemoteParentCounter  uint64
	beforeStartSpanWithRemoteParentCounter uint64
	StartSpanWithRemoteParentMock          mTracerOpenCensusMockStartSpanWithRemoteParent
}
func NewTracerOpenCensusMock(t minimock.Tester) *TracerOpenCensusMock {
	m := &TracerOpenCensusMock{t: t}
	if controller, ok := t.(minimock.MockController); ok {
		controller.RegisterMocker(m)
	}
	m.FromContextMock = mTracerOpenCensusMockFromContext{mock: m}
	m.FromContextMock.callArgs = []*TracerOpenCensusMockFromContextParams{}
	m.NewContextMock = mTracerOpenCensusMockNewContext{mock: m}
	m.NewContextMock.callArgs = []*TracerOpenCensusMockNewContextParams{}
	m.StartSpanMock = mTracerOpenCensusMockStartSpan{mock: m}
	m.StartSpanMock.callArgs = []*TracerOpenCensusMockStartSpanParams{}
	m.StartSpanWithRemoteParentMock = mTracerOpenCensusMockStartSpanWithRemoteParent{mock: m}
	m.StartSpanWithRemoteParentMock.callArgs = []*TracerOpenCensusMockStartSpanWithRemoteParentParams{}
	return m
}
type mTracerOpenCensusMockFromContext struct {
	mock               *TracerOpenCensusMock
	defaultExpectation *TracerOpenCensusMockFromContextExpectation
	expectations       []*TracerOpenCensusMockFromContextExpectation
	callArgs []*TracerOpenCensusMockFromContextParams
	mutex    sync.RWMutex
}
type TracerOpenCensusMockFromContextExpectation struct {
	mock    *TracerOpenCensusMock
	params  *TracerOpenCensusMockFromContextParams
	results *TracerOpenCensusMockFromContextResults
	Counter uint64
}
type TracerOpenCensusMockFromContextParams struct {
	ctx context.Context
}
type TracerOpenCensusMockFromContextResults struct {
	sp1 *mm_trace.Span
}
func (mmFromContext *mTracerOpenCensusMockFromContext) Expect(ctx context.Context) *mTracerOpenCensusMockFromContext {
	if mmFromContext.mock.funcFromContext != nil {
		mmFromContext.mock.t.Fatalf("TracerOpenCensusMock.FromContext mock is already set by Set")
	}
	if mmFromContext.defaultExpectation == nil {
		mmFromContext.defaultExpectation = &TracerOpenCensusMockFromContextExpectation{}
	}
	mmFromContext.defaultExpectation.params = &TracerOpenCensusMockFromContextParams{ctx}
	for _, e := range mmFromContext.expectations {
		if minimock.Equal(e.params, mmFromContext.defaultExpectation.params) {
			mmFromContext.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmFromContext.defaultExpectation.params)
		}
	}
	return mmFromContext
}
func (mmFromContext *mTracerOpenCensusMockFromContext) Inspect(f func(ctx context.Context)) *mTracerOpenCensusMockFromContext {
	if mmFromContext.mock.inspectFuncFromContext != nil {
		mmFromContext.mock.t.Fatalf("Inspect function is already set for TracerOpenCensusMock.FromContext")
	}
	mmFromContext.mock.inspectFuncFromContext = f
	return mmFromContext
}
func (mmFromContext *mTracerOpenCensusMockFromContext) Return(sp1 *mm_trace.Span) *TracerOpenCensusMock {
	if mmFromContext.mock.funcFromContext != nil {
		mmFromContext.mock.t.Fatalf("TracerOpenCensusMock.FromContext mock is already set by Set")
	}
	if mmFromContext.defaultExpectation == nil {
		mmFromContext.defaultExpectation = &TracerOpenCensusMockFromContextExpectation{mock: mmFromContext.mock}
	}
	mmFromContext.defaultExpectation.results = &TracerOpenCensusMockFromContextResults{sp1}
	return mmFromContext.mock
}
func (mmFromContext *mTracerOpenCensusMockFromContext) Set(f func(ctx context.Context) (sp1 *mm_trace.Span)) *TracerOpenCensusMock {
	if mmFromContext.defaultExpectation != nil {
		mmFromContext.mock.t.Fatalf("Default expectation is already set for the Tracer.FromContext method")
	}
	if len(mmFromContext.expectations) > 0 {
		mmFromContext.mock.t.Fatalf("Some expectations are already set for the Tracer.FromContext method")
	}
	mmFromContext.mock.funcFromContext = f
	return mmFromContext.mock
}
func (mmFromContext *mTracerOpenCensusMockFromContext) When(ctx context.Context) *TracerOpenCensusMockFromContextExpectation {
	if mmFromContext.mock.funcFromContext != nil {
		mmFromContext.mock.t.Fatalf("TracerOpenCensusMock.FromContext mock is already set by Set")
	}
	expectation := &TracerOpenCensusMockFromContextExpectation{
		mock:   mmFromContext.mock,
		params: &TracerOpenCensusMockFromContextParams{ctx},
	}
	mmFromContext.expectations = append(mmFromContext.expectations, expectation)
	return expectation
}
func (e *TracerOpenCensusMockFromContextExpectation) Then(sp1 *mm_trace.Span) *TracerOpenCensusMock {
	e.results = &TracerOpenCensusMockFromContextResults{sp1}
	return e.mock
}
func (mmFromContext *TracerOpenCensusMock) FromContext(ctx context.Context) (sp1 *mm_trace.Span) {
	mm_atomic.AddUint64(&mmFromContext.beforeFromContextCounter, 1)
	defer mm_atomic.AddUint64(&mmFromContext.afterFromContextCounter, 1)
	if mmFromContext.inspectFuncFromContext != nil {
		mmFromContext.inspectFuncFromContext(ctx)
	}
	mm_params := &TracerOpenCensusMockFromContextParams{ctx}
	mmFromContext.FromContextMock.mutex.Lock()
	mmFromContext.FromContextMock.callArgs = append(mmFromContext.FromContextMock.callArgs, mm_params)
	mmFromContext.FromContextMock.mutex.Unlock()
	for _, e := range mmFromContext.FromContextMock.expectations {
		if minimock.Equal(e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.sp1
		}
	}
	if mmFromContext.FromContextMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmFromContext.FromContextMock.defaultExpectation.Counter, 1)
		mm_want := mmFromContext.FromContextMock.defaultExpectation.params
		mm_got := TracerOpenCensusMockFromContextParams{ctx}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmFromContext.t.Errorf("TracerOpenCensusMock.FromContext got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}
		mm_results := mmFromContext.FromContextMock.defaultExpectation.results
		if mm_results == nil {
			mmFromContext.t.Fatal("No results are set for the TracerOpenCensusMock.FromContext")
		}
		return (*mm_results).sp1
	}
	if mmFromContext.funcFromContext != nil {
		return mmFromContext.funcFromContext(ctx)
	}
	mmFromContext.t.Fatalf("Unexpected call to TracerOpenCensusMock.FromContext. %v", ctx)
	return
}
func (mmFromContext *TracerOpenCensusMock) FromContextAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmFromContext.afterFromContextCounter)
}
func (mmFromContext *TracerOpenCensusMock) FromContextBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmFromContext.beforeFromContextCounter)
}
func (mmFromContext *mTracerOpenCensusMockFromContext) Calls() []*TracerOpenCensusMockFromContextParams {
	mmFromContext.mutex.RLock()
	argCopy := make([]*TracerOpenCensusMockFromContextParams, len(mmFromContext.callArgs))
	copy(argCopy, mmFromContext.callArgs)
	mmFromContext.mutex.RUnlock()
	return argCopy
}
func (m *TracerOpenCensusMock) MinimockFromContextDone() bool {
	for _, e := range m.FromContextMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}
	if m.FromContextMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterFromContextCounter) < 1 {
		return false
	}
	if m.funcFromContext != nil && mm_atomic.LoadUint64(&m.afterFromContextCounter) < 1 {
		return false
	}
	return true
}
func (m *TracerOpenCensusMock) MinimockFromContextInspect() {
	for _, e := range m.FromContextMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to TracerOpenCensusMock.FromContext with params: %#v", *e.params)
		}
	}
	if m.FromContextMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterFromContextCounter) < 1 {
		if m.FromContextMock.defaultExpectation.params == nil {
			m.t.Error("Expected call to TracerOpenCensusMock.FromContext")
		} else {
			m.t.Errorf("Expected call to TracerOpenCensusMock.FromContext with params: %#v", *m.FromContextMock.defaultExpectation.params)
		}
	}
	if m.funcFromContext != nil && mm_atomic.LoadUint64(&m.afterFromContextCounter) < 1 {
		m.t.Error("Expected call to TracerOpenCensusMock.FromContext")
	}
}
type mTracerOpenCensusMockNewContext struct {
	mock               *TracerOpenCensusMock
	defaultExpectation *TracerOpenCensusMockNewContextExpectation
	expectations       []*TracerOpenCensusMockNewContextExpectation
	callArgs []*TracerOpenCensusMockNewContextParams
	mutex    sync.RWMutex
}
type TracerOpenCensusMockNewContextExpectation struct {
	mock    *TracerOpenCensusMock
	params  *TracerOpenCensusMockNewContextParams
	results *TracerOpenCensusMockNewContextResults
	Counter uint64
}
type TracerOpenCensusMockNewContextParams struct {
	ctx context.Context
	s   *mm_trace.Span
}
type TracerOpenCensusMockNewContextResults struct {
	c1 context.Context
}
func (mmNewContext *mTracerOpenCensusMockNewContext) Expect(ctx context.Context, s *mm_trace.Span) *mTracerOpenCensusMockNewContext {
	if mmNewContext.mock.funcNewContext != nil {
		mmNewContext.mock.t.Fatalf("TracerOpenCensusMock.NewContext mock is already set by Set")
	}
	if mmNewContext.defaultExpectation == nil {
		mmNewContext.defaultExpectation = &TracerOpenCensusMockNewContextExpectation{}
	}
	mmNewContext.defaultExpectation.params = &TracerOpenCensusMockNewContextParams{ctx, s}
	for _, e := range mmNewContext.expectations {
		if minimock.Equal(e.params, mmNewContext.defaultExpectation.params) {
			mmNewContext.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmNewContext.defaultExpectation.params)
		}
	}
	return mmNewContext
}
func (mmNewContext *mTracerOpenCensusMockNewContext) Inspect(f func(ctx context.Context, s *mm_trace.Span)) *mTracerOpenCensusMockNewContext {
	if mmNewContext.mock.inspectFuncNewContext != nil {
		mmNewContext.mock.t.Fatalf("Inspect function is already set for TracerOpenCensusMock.NewContext")
	}
	mmNewContext.mock.inspectFuncNewContext = f
	return mmNewContext
}
func (mmNewContext *mTracerOpenCensusMockNewContext) Return(c1 context.Context) *TracerOpenCensusMock {
	if mmNewContext.mock.funcNewContext != nil {
		mmNewContext.mock.t.Fatalf("TracerOpenCensusMock.NewContext mock is already set by Set")
	}
	if mmNewContext.defaultExpectation == nil {
		mmNewContext.defaultExpectation = &TracerOpenCensusMockNewContextExpectation{mock: mmNewContext.mock}
	}
	mmNewContext.defaultExpectation.results = &TracerOpenCensusMockNewContextResults{c1}
	return mmNewContext.mock
}
func (mmNewContext *mTracerOpenCensusMockNewContext) Set(f func(ctx context.Context, s *mm_trace.Span) (c1 context.Context)) *TracerOpenCensusMock {
	if mmNewContext.defaultExpectation != nil {
		mmNewContext.mock.t.Fatalf("Default expectation is already set for the Tracer.NewContext method")
	}
	if len(mmNewContext.expectations) > 0 {
		mmNewContext.mock.t.Fatalf("Some expectations are already set for the Tracer.NewContext method")
	}
	mmNewContext.mock.funcNewContext = f
	return mmNewContext.mock
}
func (mmNewContext *mTracerOpenCensusMockNewContext) When(ctx context.Context, s *mm_trace.Span) *TracerOpenCensusMockNewContextExpectation {
	if mmNewContext.mock.funcNewContext != nil {
		mmNewContext.mock.t.Fatalf("TracerOpenCensusMock.NewContext mock is already set by Set")
	}
	expectation := &TracerOpenCensusMockNewContextExpectation{
		mock:   mmNewContext.mock,
		params: &TracerOpenCensusMockNewContextParams{ctx, s},
	}
	mmNewContext.expectations = append(mmNewContext.expectations, expectation)
	return expectation
}
func (e *TracerOpenCensusMockNewContextExpectation) Then(c1 context.Context) *TracerOpenCensusMock {
	e.results = &TracerOpenCensusMockNewContextResults{c1}
	return e.mock
}
func (mmNewContext *TracerOpenCensusMock) NewContext(ctx context.Context, s *mm_trace.Span) (c1 context.Context) {
	mm_atomic.AddUint64(&mmNewContext.beforeNewContextCounter, 1)
	defer mm_atomic.AddUint64(&mmNewContext.afterNewContextCounter, 1)
	if mmNewContext.inspectFuncNewContext != nil {
		mmNewContext.inspectFuncNewContext(ctx, s)
	}
	mm_params := &TracerOpenCensusMockNewContextParams{ctx, s}
	mmNewContext.NewContextMock.mutex.Lock()
	mmNewContext.NewContextMock.callArgs = append(mmNewContext.NewContextMock.callArgs, mm_params)
	mmNewContext.NewContextMock.mutex.Unlock()
	for _, e := range mmNewContext.NewContextMock.expectations {
		if minimock.Equal(e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.c1
		}
	}
	if mmNewContext.NewContextMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmNewContext.NewContextMock.defaultExpectation.Counter, 1)
		mm_want := mmNewContext.NewContextMock.defaultExpectation.params
		mm_got := TracerOpenCensusMockNewContextParams{ctx, s}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmNewContext.t.Errorf("TracerOpenCensusMock.NewContext got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}
		mm_results := mmNewContext.NewContextMock.defaultExpectation.results
		if mm_results == nil {
			mmNewContext.t.Fatal("No results are set for the TracerOpenCensusMock.NewContext")
		}
		return (*mm_results).c1
	}
	if mmNewContext.funcNewContext != nil {
		return mmNewContext.funcNewContext(ctx, s)
	}
	mmNewContext.t.Fatalf("Unexpected call to TracerOpenCensusMock.NewContext. %v %v", ctx, s)
	return
}
func (mmNewContext *TracerOpenCensusMock) NewContextAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmNewContext.afterNewContextCounter)
}
func (mmNewContext *TracerOpenCensusMock) NewContextBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmNewContext.beforeNewContextCounter)
}
func (mmNewContext *mTracerOpenCensusMockNewContext) Calls() []*TracerOpenCensusMockNewContextParams {
	mmNewContext.mutex.RLock()
	argCopy := make([]*TracerOpenCensusMockNewContextParams, len(mmNewContext.callArgs))
	copy(argCopy, mmNewContext.callArgs)
	mmNewContext.mutex.RUnlock()
	return argCopy
}
func (m *TracerOpenCensusMock) MinimockNewContextDone() bool {
	for _, e := range m.NewContextMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}
	if m.NewContextMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterNewContextCounter) < 1 {
		return false
	}
	if m.funcNewContext != nil && mm_atomic.LoadUint64(&m.afterNewContextCounter) < 1 {
		return false
	}
	return true
}
func (m *TracerOpenCensusMock) MinimockNewContextInspect() {
	for _, e := range m.NewContextMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to TracerOpenCensusMock.NewContext with params: %#v", *e.params)
		}
	}
	if m.NewContextMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterNewContextCounter) < 1 {
		if m.NewContextMock.defaultExpectation.params == nil {
			m.t.Error("Expected call to TracerOpenCensusMock.NewContext")
		} else {
			m.t.Errorf("Expected call to TracerOpenCensusMock.NewContext with params: %#v", *m.NewContextMock.defaultExpectation.params)
		}
	}
	if m.funcNewContext != nil && mm_atomic.LoadUint64(&m.afterNewContextCounter) < 1 {
		m.t.Error("Expected call to TracerOpenCensusMock.NewContext")
	}
}
type mTracerOpenCensusMockStartSpan struct {
	mock               *TracerOpenCensusMock
	defaultExpectation *TracerOpenCensusMockStartSpanExpectation
	expectations       []*TracerOpenCensusMockStartSpanExpectation
	callArgs []*TracerOpenCensusMockStartSpanParams
	mutex    sync.RWMutex
}
type TracerOpenCensusMockStartSpanExpectation struct {
	mock    *TracerOpenCensusMock
	params  *TracerOpenCensusMockStartSpanParams
	results *TracerOpenCensusMockStartSpanResults
	Counter uint64
}
type TracerOpenCensusMockStartSpanParams struct {
	ctx  context.Context
	name string
	o    []mm_trace.StartOption
}
type TracerOpenCensusMockStartSpanResults struct {
	c2  context.Context
	sp1 *mm_trace.Span
}
func (mmStartSpan *mTracerOpenCensusMockStartSpan) Expect(ctx context.Context, name string, o ...mm_trace.StartOption) *mTracerOpenCensusMockStartSpan {
	if mmStartSpan.mock.funcStartSpan != nil {
		mmStartSpan.mock.t.Fatalf("TracerOpenCensusMock.StartSpan mock is already set by Set")
	}
	if mmStartSpan.defaultExpectation == nil {
		mmStartSpan.defaultExpectation = &TracerOpenCensusMockStartSpanExpectation{}
	}
	mmStartSpan.defaultExpectation.params = &TracerOpenCensusMockStartSpanParams{ctx, name, o}
	for _, e := range mmStartSpan.expectations {
		if minimock.Equal(e.params, mmStartSpan.defaultExpectation.params) {
			mmStartSpan.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmStartSpan.defaultExpectation.params)
		}
	}
	return mmStartSpan
}
func (mmStartSpan *mTracerOpenCensusMockStartSpan) Inspect(f func(ctx context.Context, name string, o ...mm_trace.StartOption)) *mTracerOpenCensusMockStartSpan {
	if mmStartSpan.mock.inspectFuncStartSpan != nil {
		mmStartSpan.mock.t.Fatalf("Inspect function is already set for TracerOpenCensusMock.StartSpan")
	}
	mmStartSpan.mock.inspectFuncStartSpan = f
	return mmStartSpan
}
func (mmStartSpan *mTracerOpenCensusMockStartSpan) Return(c2 context.Context, sp1 *mm_trace.Span) *TracerOpenCensusMock {
	if mmStartSpan.mock.funcStartSpan != nil {
		mmStartSpan.mock.t.Fatalf("TracerOpenCensusMock.StartSpan mock is already set by Set")
	}
	if mmStartSpan.defaultExpectation == nil {
		mmStartSpan.defaultExpectation = &TracerOpenCensusMockStartSpanExpectation{mock: mmStartSpan.mock}
	}
	mmStartSpan.defaultExpectation.results = &TracerOpenCensusMockStartSpanResults{c2, sp1}
	return mmStartSpan.mock
}