mock_span.go

// Code generated by MockGen. DO NOT EDIT.

// Copyright (c) 2020 The Jaeger Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Source: vendor/github.com/opentracing/opentracing-go/span.go

// Package mock_opentracing is a generated GoMock package.
package mock_opentracing

import (
	gomock "github.com/golang/mock/gomock"
	opentracing "github.com/opentracing/opentracing-go"
	log "github.com/opentracing/opentracing-go/log"
	reflect "reflect"
)

// MockSpanContext is a mock of SpanContext interface
type MockSpanContext struct {
	ctrl     *gomock.Controller
	recorder *MockSpanContextMockRecorder
}

// MockSpanContextMockRecorder is the mock recorder for MockSpanContext
type MockSpanContextMockRecorder struct {
	mock *MockSpanContext
}

// NewMockSpanContext creates a new mock instance
func NewMockSpanContext(ctrl *gomock.Controller) *MockSpanContext {
	mock := &MockSpanContext{ctrl: ctrl}
	mock.recorder = &MockSpanContextMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockSpanContext) EXPECT() *MockSpanContextMockRecorder {
	return m.recorder
}

// ForeachBaggageItem mocks base method
func (m *MockSpanContext) ForeachBaggageItem(handler func(string, string) bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ForeachBaggageItem", handler)
}

// ForeachBaggageItem indicates an expected call of ForeachBaggageItem
func (mr *MockSpanContextMockRecorder) ForeachBaggageItem(handler interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForeachBaggageItem", reflect.TypeOf((*MockSpanContext)(nil).ForeachBaggageItem), handler)
}

// MockSpan is a mock of Span interface
type MockSpan struct {
	ctrl     *gomock.Controller
	recorder *MockSpanMockRecorder
}

// MockSpanMockRecorder is the mock recorder for MockSpan
type MockSpanMockRecorder struct {
	mock *MockSpan
}

// NewMockSpan creates a new mock instance
func NewMockSpan(ctrl *gomock.Controller) *MockSpan {
	mock := &MockSpan{ctrl: ctrl}
	mock.recorder = &MockSpanMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockSpan) EXPECT() *MockSpanMockRecorder {
	return m.recorder
}

// Finish mocks base method
func (m *MockSpan) Finish() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Finish")
}

// Finish indicates an expected call of Finish
func (mr *MockSpanMockRecorder) Finish() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Finish", reflect.TypeOf((*MockSpan)(nil).Finish))
}

// FinishWithOptions mocks base method
func (m *MockSpan) FinishWithOptions(opts opentracing.FinishOptions) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "FinishWithOptions", opts)
}

// FinishWithOptions indicates an expected call of FinishWithOptions
func (mr *MockSpanMockRecorder) FinishWithOptions(opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinishWithOptions", reflect.TypeOf((*MockSpan)(nil).FinishWithOptions), opts)
}

// Context mocks base method
func (m *MockSpan) Context() opentracing.SpanContext {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(opentracing.SpanContext)
	return ret0
}

// Context indicates an expected call of Context
func (mr *MockSpanMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockSpan)(nil).Context))
}

// SetOperationName mocks base method
func (m *MockSpan) SetOperationName(operationName string) opentracing.Span {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetOperationName", operationName)
	ret0, _ := ret[0].(opentracing.Span)
	return ret0
}

// SetOperationName indicates an expected call of SetOperationName
func (mr *MockSpanMockRecorder) SetOperationName(operationName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOperationName", reflect.TypeOf((*MockSpan)(nil).SetOperationName), operationName)
}

// SetTag mocks base method
func (m *MockSpan) SetTag(key string, value interface{}) opentracing.Span {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetTag", key, value)
	ret0, _ := ret[0].(opentracing.Span)
	return ret0
}

// SetTag indicates an expected call of SetTag
func (mr *MockSpanMockRecorder) SetTag(key, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTag", reflect.TypeOf((*MockSpan)(nil).SetTag), key, value)
}

// LogFields mocks base method
func (m *MockSpan) LogFields(fields ...log.Field) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "LogFields", varargs...)
}

// LogFields indicates an expected call of LogFields
func (mr *MockSpanMockRecorder) LogFields(fields ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogFields", reflect.TypeOf((*MockSpan)(nil).LogFields), fields...)
}

// LogKV mocks base method
func (m *MockSpan) LogKV(alternatingKeyValues ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range alternatingKeyValues {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "LogKV", varargs...)
}

// LogKV indicates an expected call of LogKV
func (mr *MockSpanMockRecorder) LogKV(alternatingKeyValues ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogKV", reflect.TypeOf((*MockSpan)(nil).LogKV), alternatingKeyValues...)
}

// SetBaggageItem mocks base method
func (m *MockSpan) SetBaggageItem(restrictedKey, value string) opentracing.Span {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetBaggageItem", restrictedKey, value)
	ret0, _ := ret[0].(opentracing.Span)
	return ret0
}

// SetBaggageItem indicates an expected call of SetBaggageItem
func (mr *MockSpanMockRecorder) SetBaggageItem(restrictedKey, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBaggageItem", reflect.TypeOf((*MockSpan)(nil).SetBaggageItem), restrictedKey, value)
}

// BaggageItem mocks base method
func (m *MockSpan) BaggageItem(restrictedKey string) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BaggageItem", restrictedKey)
	ret0, _ := ret[0].(string)
	return ret0
}

// BaggageItem indicates an expected call of BaggageItem
func (mr *MockSpanMockRecorder) BaggageItem(restrictedKey interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BaggageItem", reflect.TypeOf((*MockSpan)(nil).BaggageItem), restrictedKey)
}

// Tracer mocks base method
func (m *MockSpan) Tracer() opentracing.Tracer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Tracer")
	ret0, _ := ret[0].(opentracing.Tracer)
	return ret0
}

// Tracer indicates an expected call of Tracer
func (mr *MockSpanMockRecorder) Tracer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tracer", reflect.TypeOf((*MockSpan)(nil).Tracer))
}

// LogEvent mocks base method
func (m *MockSpan) LogEvent(event string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "LogEvent", event)
}

// LogEvent indicates an expected call of LogEvent
func (mr *MockSpanMockRecorder) LogEvent(event interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogEvent", reflect.TypeOf((*MockSpan)(nil).LogEvent), event)
}

// LogEventWithPayload mocks base method
func (m *MockSpan) LogEventWithPayload(event string, payload interface{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "LogEventWithPayload", event, payload)
}

// LogEventWithPayload indicates an expected call of LogEventWithPayload
func (mr *MockSpanMockRecorder) LogEventWithPayload(event, payload interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogEventWithPayload", reflect.TypeOf((*MockSpan)(nil).LogEventWithPayload), event, payload)
}

// Log mocks base method
func (m *MockSpan) Log(data opentracing.LogData) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Log", data)
}

// Log indicates an expected call of Log
func (mr *MockSpanMockRecorder) Log(data interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Log", reflect.TypeOf((*MockSpan)(nil).Log), data)
}