// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package runner

import (
	"github.com/sirupsen/logrus"
	mock "github.com/stretchr/testify/mock"
)

// NewMockFieldLogger creates a new instance of MockFieldLogger. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockFieldLogger(t interface {
	mock.TestingT
	Cleanup(func())
},
) *MockFieldLogger {
	mock := &MockFieldLogger{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockFieldLogger is an autogenerated mock type for the FieldLogger type
type MockFieldLogger struct {
	mock.Mock
}

type MockFieldLogger_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFieldLogger) EXPECT() *MockFieldLogger_Expecter {
	return &MockFieldLogger_Expecter{mock: &_m.Mock}
}

// Debug provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Debug(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Debug_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Debug'
type MockFieldLogger_Debug_Call struct {
	*mock.Call
}

// Debug is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Debug(args ...interface{}) *MockFieldLogger_Debug_Call {
	return &MockFieldLogger_Debug_Call{Call: _e.mock.On("Debug",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Debug_Call) Run(run func(args ...interface{})) *MockFieldLogger_Debug_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Debug_Call) Return() *MockFieldLogger_Debug_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Debug_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Debug_Call {
	_c.Run(run)
	return _c
}

// Debugf provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Debugf(format string, args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(format, args)
	} else {
		_mock.Called(format)
	}

	return
}

// MockFieldLogger_Debugf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Debugf'
type MockFieldLogger_Debugf_Call struct {
	*mock.Call
}

// Debugf is a helper method to define mock.On call
//   - format string
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Debugf(format interface{}, args ...interface{}) *MockFieldLogger_Debugf_Call {
	return &MockFieldLogger_Debugf_Call{Call: _e.mock.On("Debugf",
		append([]interface{}{format}, args...)...)}
}

func (_c *MockFieldLogger_Debugf_Call) Run(run func(format string, args ...interface{})) *MockFieldLogger_Debugf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []interface{}
		var variadicArgs []interface{}
		if len(args) > 1 {
			variadicArgs = args[1].([]interface{})
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Debugf_Call) Return() *MockFieldLogger_Debugf_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Debugf_Call) RunAndReturn(run func(format string, args ...interface{})) *MockFieldLogger_Debugf_Call {
	_c.Run(run)
	return _c
}

// Debugln provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Debugln(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Debugln_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Debugln'
type MockFieldLogger_Debugln_Call struct {
	*mock.Call
}

// Debugln is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Debugln(args ...interface{}) *MockFieldLogger_Debugln_Call {
	return &MockFieldLogger_Debugln_Call{Call: _e.mock.On("Debugln",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Debugln_Call) Run(run func(args ...interface{})) *MockFieldLogger_Debugln_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Debugln_Call) Return() *MockFieldLogger_Debugln_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Debugln_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Debugln_Call {
	_c.Run(run)
	return _c
}

// Error provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Error(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Error_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Error'
type MockFieldLogger_Error_Call struct {
	*mock.Call
}

// Error is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Error(args ...interface{}) *MockFieldLogger_Error_Call {
	return &MockFieldLogger_Error_Call{Call: _e.mock.On("Error",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Error_Call) Run(run func(args ...interface{})) *MockFieldLogger_Error_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Error_Call) Return() *MockFieldLogger_Error_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Error_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Error_Call {
	_c.Run(run)
	return _c
}

// Errorf provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Errorf(format string, args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(format, args)
	} else {
		_mock.Called(format)
	}

	return
}

// MockFieldLogger_Errorf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Errorf'
type MockFieldLogger_Errorf_Call struct {
	*mock.Call
}

// Errorf is a helper method to define mock.On call
//   - format string
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Errorf(format interface{}, args ...interface{}) *MockFieldLogger_Errorf_Call {
	return &MockFieldLogger_Errorf_Call{Call: _e.mock.On("Errorf",
		append([]interface{}{format}, args...)...)}
}

func (_c *MockFieldLogger_Errorf_Call) Run(run func(format string, args ...interface{})) *MockFieldLogger_Errorf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []interface{}
		var variadicArgs []interface{}
		if len(args) > 1 {
			variadicArgs = args[1].([]interface{})
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Errorf_Call) Return() *MockFieldLogger_Errorf_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Errorf_Call) RunAndReturn(run func(format string, args ...interface{})) *MockFieldLogger_Errorf_Call {
	_c.Run(run)
	return _c
}

// Errorln provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Errorln(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Errorln_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Errorln'
type MockFieldLogger_Errorln_Call struct {
	*mock.Call
}

// Errorln is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Errorln(args ...interface{}) *MockFieldLogger_Errorln_Call {
	return &MockFieldLogger_Errorln_Call{Call: _e.mock.On("Errorln",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Errorln_Call) Run(run func(args ...interface{})) *MockFieldLogger_Errorln_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Errorln_Call) Return() *MockFieldLogger_Errorln_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Errorln_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Errorln_Call {
	_c.Run(run)
	return _c
}

// Fatal provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Fatal(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Fatal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Fatal'
type MockFieldLogger_Fatal_Call struct {
	*mock.Call
}

// Fatal is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Fatal(args ...interface{}) *MockFieldLogger_Fatal_Call {
	return &MockFieldLogger_Fatal_Call{Call: _e.mock.On("Fatal",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Fatal_Call) Run(run func(args ...interface{})) *MockFieldLogger_Fatal_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Fatal_Call) Return() *MockFieldLogger_Fatal_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Fatal_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Fatal_Call {
	_c.Run(run)
	return _c
}

// Fatalf provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Fatalf(format string, args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(format, args)
	} else {
		_mock.Called(format)
	}

	return
}

// MockFieldLogger_Fatalf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Fatalf'
type MockFieldLogger_Fatalf_Call struct {
	*mock.Call
}

// Fatalf is a helper method to define mock.On call
//   - format string
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Fatalf(format interface{}, args ...interface{}) *MockFieldLogger_Fatalf_Call {
	return &MockFieldLogger_Fatalf_Call{Call: _e.mock.On("Fatalf",
		append([]interface{}{format}, args...)...)}
}

func (_c *MockFieldLogger_Fatalf_Call) Run(run func(format string, args ...interface{})) *MockFieldLogger_Fatalf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []interface{}
		var variadicArgs []interface{}
		if len(args) > 1 {
			variadicArgs = args[1].([]interface{})
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Fatalf_Call) Return() *MockFieldLogger_Fatalf_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Fatalf_Call) RunAndReturn(run func(format string, args ...interface{})) *MockFieldLogger_Fatalf_Call {
	_c.Run(run)
	return _c
}

// Fatalln provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Fatalln(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Fatalln_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Fatalln'
type MockFieldLogger_Fatalln_Call struct {
	*mock.Call
}

// Fatalln is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Fatalln(args ...interface{}) *MockFieldLogger_Fatalln_Call {
	return &MockFieldLogger_Fatalln_Call{Call: _e.mock.On("Fatalln",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Fatalln_Call) Run(run func(args ...interface{})) *MockFieldLogger_Fatalln_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Fatalln_Call) Return() *MockFieldLogger_Fatalln_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Fatalln_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Fatalln_Call {
	_c.Run(run)
	return _c
}

// Info provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Info(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Info_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Info'
type MockFieldLogger_Info_Call struct {
	*mock.Call
}

// Info is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Info(args ...interface{}) *MockFieldLogger_Info_Call {
	return &MockFieldLogger_Info_Call{Call: _e.mock.On("Info",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Info_Call) Run(run func(args ...interface{})) *MockFieldLogger_Info_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Info_Call) Return() *MockFieldLogger_Info_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Info_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Info_Call {
	_c.Run(run)
	return _c
}

// Infof provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Infof(format string, args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(format, args)
	} else {
		_mock.Called(format)
	}

	return
}

// MockFieldLogger_Infof_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Infof'
type MockFieldLogger_Infof_Call struct {
	*mock.Call
}

// Infof is a helper method to define mock.On call
//   - format string
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Infof(format interface{}, args ...interface{}) *MockFieldLogger_Infof_Call {
	return &MockFieldLogger_Infof_Call{Call: _e.mock.On("Infof",
		append([]interface{}{format}, args...)...)}
}

func (_c *MockFieldLogger_Infof_Call) Run(run func(format string, args ...interface{})) *MockFieldLogger_Infof_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []interface{}
		var variadicArgs []interface{}
		if len(args) > 1 {
			variadicArgs = args[1].([]interface{})
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Infof_Call) Return() *MockFieldLogger_Infof_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Infof_Call) RunAndReturn(run func(format string, args ...interface{})) *MockFieldLogger_Infof_Call {
	_c.Run(run)
	return _c
}

// Infoln provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Infoln(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Infoln_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Infoln'
type MockFieldLogger_Infoln_Call struct {
	*mock.Call
}

// Infoln is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Infoln(args ...interface{}) *MockFieldLogger_Infoln_Call {
	return &MockFieldLogger_Infoln_Call{Call: _e.mock.On("Infoln",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Infoln_Call) Run(run func(args ...interface{})) *MockFieldLogger_Infoln_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Infoln_Call) Return() *MockFieldLogger_Infoln_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Infoln_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Infoln_Call {
	_c.Run(run)
	return _c
}

// Panic provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Panic(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Panic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Panic'
type MockFieldLogger_Panic_Call struct {
	*mock.Call
}

// Panic is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Panic(args ...interface{}) *MockFieldLogger_Panic_Call {
	return &MockFieldLogger_Panic_Call{Call: _e.mock.On("Panic",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Panic_Call) Run(run func(args ...interface{})) *MockFieldLogger_Panic_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Panic_Call) Return() *MockFieldLogger_Panic_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Panic_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Panic_Call {
	_c.Run(run)
	return _c
}

// Panicf provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Panicf(format string, args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(format, args)
	} else {
		_mock.Called(format)
	}

	return
}

// MockFieldLogger_Panicf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Panicf'
type MockFieldLogger_Panicf_Call struct {
	*mock.Call
}

// Panicf is a helper method to define mock.On call
//   - format string
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Panicf(format interface{}, args ...interface{}) *MockFieldLogger_Panicf_Call {
	return &MockFieldLogger_Panicf_Call{Call: _e.mock.On("Panicf",
		append([]interface{}{format}, args...)...)}
}

func (_c *MockFieldLogger_Panicf_Call) Run(run func(format string, args ...interface{})) *MockFieldLogger_Panicf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []interface{}
		var variadicArgs []interface{}
		if len(args) > 1 {
			variadicArgs = args[1].([]interface{})
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Panicf_Call) Return() *MockFieldLogger_Panicf_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Panicf_Call) RunAndReturn(run func(format string, args ...interface{})) *MockFieldLogger_Panicf_Call {
	_c.Run(run)
	return _c
}

// Panicln provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Panicln(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Panicln_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Panicln'
type MockFieldLogger_Panicln_Call struct {
	*mock.Call
}

// Panicln is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Panicln(args ...interface{}) *MockFieldLogger_Panicln_Call {
	return &MockFieldLogger_Panicln_Call{Call: _e.mock.On("Panicln",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Panicln_Call) Run(run func(args ...interface{})) *MockFieldLogger_Panicln_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Panicln_Call) Return() *MockFieldLogger_Panicln_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Panicln_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Panicln_Call {
	_c.Run(run)
	return _c
}

// Print provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Print(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Print_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Print'
type MockFieldLogger_Print_Call struct {
	*mock.Call
}

// Print is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Print(args ...interface{}) *MockFieldLogger_Print_Call {
	return &MockFieldLogger_Print_Call{Call: _e.mock.On("Print",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Print_Call) Run(run func(args ...interface{})) *MockFieldLogger_Print_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Print_Call) Return() *MockFieldLogger_Print_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Print_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Print_Call {
	_c.Run(run)
	return _c
}

// Printf provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Printf(format string, args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(format, args)
	} else {
		_mock.Called(format)
	}

	return
}

// MockFieldLogger_Printf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Printf'
type MockFieldLogger_Printf_Call struct {
	*mock.Call
}

// Printf is a helper method to define mock.On call
//   - format string
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Printf(format interface{}, args ...interface{}) *MockFieldLogger_Printf_Call {
	return &MockFieldLogger_Printf_Call{Call: _e.mock.On("Printf",
		append([]interface{}{format}, args...)...)}
}

func (_c *MockFieldLogger_Printf_Call) Run(run func(format string, args ...interface{})) *MockFieldLogger_Printf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []interface{}
		var variadicArgs []interface{}
		if len(args) > 1 {
			variadicArgs = args[1].([]interface{})
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Printf_Call) Return() *MockFieldLogger_Printf_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Printf_Call) RunAndReturn(run func(format string, args ...interface{})) *MockFieldLogger_Printf_Call {
	_c.Run(run)
	return _c
}

// Println provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Println(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Println_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Println'
type MockFieldLogger_Println_Call struct {
	*mock.Call
}

// Println is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Println(args ...interface{}) *MockFieldLogger_Println_Call {
	return &MockFieldLogger_Println_Call{Call: _e.mock.On("Println",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Println_Call) Run(run func(args ...interface{})) *MockFieldLogger_Println_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Println_Call) Return() *MockFieldLogger_Println_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Println_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Println_Call {
	_c.Run(run)
	return _c
}

// Warn provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Warn(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Warn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Warn'
type MockFieldLogger_Warn_Call struct {
	*mock.Call
}

// Warn is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Warn(args ...interface{}) *MockFieldLogger_Warn_Call {
	return &MockFieldLogger_Warn_Call{Call: _e.mock.On("Warn",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Warn_Call) Run(run func(args ...interface{})) *MockFieldLogger_Warn_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Warn_Call) Return() *MockFieldLogger_Warn_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Warn_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Warn_Call {
	_c.Run(run)
	return _c
}

// Warnf provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Warnf(format string, args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(format, args)
	} else {
		_mock.Called(format)
	}

	return
}

// MockFieldLogger_Warnf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Warnf'
type MockFieldLogger_Warnf_Call struct {
	*mock.Call
}

// Warnf is a helper method to define mock.On call
//   - format string
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Warnf(format interface{}, args ...interface{}) *MockFieldLogger_Warnf_Call {
	return &MockFieldLogger_Warnf_Call{Call: _e.mock.On("Warnf",
		append([]interface{}{format}, args...)...)}
}

func (_c *MockFieldLogger_Warnf_Call) Run(run func(format string, args ...interface{})) *MockFieldLogger_Warnf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []interface{}
		var variadicArgs []interface{}
		if len(args) > 1 {
			variadicArgs = args[1].([]interface{})
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Warnf_Call) Return() *MockFieldLogger_Warnf_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Warnf_Call) RunAndReturn(run func(format string, args ...interface{})) *MockFieldLogger_Warnf_Call {
	_c.Run(run)
	return _c
}

// Warning provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Warning(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Warning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Warning'
type MockFieldLogger_Warning_Call struct {
	*mock.Call
}

// Warning is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Warning(args ...interface{}) *MockFieldLogger_Warning_Call {
	return &MockFieldLogger_Warning_Call{Call: _e.mock.On("Warning",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Warning_Call) Run(run func(args ...interface{})) *MockFieldLogger_Warning_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Warning_Call) Return() *MockFieldLogger_Warning_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Warning_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Warning_Call {
	_c.Run(run)
	return _c
}

// Warningf provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Warningf(format string, args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(format, args)
	} else {
		_mock.Called(format)
	}

	return
}

// MockFieldLogger_Warningf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Warningf'
type MockFieldLogger_Warningf_Call struct {
	*mock.Call
}

// Warningf is a helper method to define mock.On call
//   - format string
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Warningf(format interface{}, args ...interface{}) *MockFieldLogger_Warningf_Call {
	return &MockFieldLogger_Warningf_Call{Call: _e.mock.On("Warningf",
		append([]interface{}{format}, args...)...)}
}

func (_c *MockFieldLogger_Warningf_Call) Run(run func(format string, args ...interface{})) *MockFieldLogger_Warningf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []interface{}
		var variadicArgs []interface{}
		if len(args) > 1 {
			variadicArgs = args[1].([]interface{})
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Warningf_Call) Return() *MockFieldLogger_Warningf_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Warningf_Call) RunAndReturn(run func(format string, args ...interface{})) *MockFieldLogger_Warningf_Call {
	_c.Run(run)
	return _c
}

// Warningln provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Warningln(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Warningln_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Warningln'
type MockFieldLogger_Warningln_Call struct {
	*mock.Call
}

// Warningln is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Warningln(args ...interface{}) *MockFieldLogger_Warningln_Call {
	return &MockFieldLogger_Warningln_Call{Call: _e.mock.On("Warningln",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Warningln_Call) Run(run func(args ...interface{})) *MockFieldLogger_Warningln_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Warningln_Call) Return() *MockFieldLogger_Warningln_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Warningln_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Warningln_Call {
	_c.Run(run)
	return _c
}

// Warnln provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) Warnln(args ...interface{}) {
	if len(args) > 0 {
		_mock.Called(args)
	} else {
		_mock.Called()
	}

	return
}

// MockFieldLogger_Warnln_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Warnln'
type MockFieldLogger_Warnln_Call struct {
	*mock.Call
}

// Warnln is a helper method to define mock.On call
//   - args ...interface{}
func (_e *MockFieldLogger_Expecter) Warnln(args ...interface{}) *MockFieldLogger_Warnln_Call {
	return &MockFieldLogger_Warnln_Call{Call: _e.mock.On("Warnln",
		append([]interface{}{}, args...)...)}
}

func (_c *MockFieldLogger_Warnln_Call) Run(run func(args ...interface{})) *MockFieldLogger_Warnln_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

func (_c *MockFieldLogger_Warnln_Call) Return() *MockFieldLogger_Warnln_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFieldLogger_Warnln_Call) RunAndReturn(run func(args ...interface{})) *MockFieldLogger_Warnln_Call {
	_c.Run(run)
	return _c
}

// WithError provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) WithError(err error) *logrus.Entry {
	ret := _mock.Called(err)

	if len(ret) == 0 {
		panic("no return value specified for WithError")
	}

	var r0 *logrus.Entry
	if returnFunc, ok := ret.Get(0).(func(error) *logrus.Entry); ok {
		r0 = returnFunc(err)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*logrus.Entry)
		}
	}
	return r0
}

// MockFieldLogger_WithError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithError'
type MockFieldLogger_WithError_Call struct {
	*mock.Call
}

// WithError is a helper method to define mock.On call
//   - err error
func (_e *MockFieldLogger_Expecter) WithError(err interface{}) *MockFieldLogger_WithError_Call {
	return &MockFieldLogger_WithError_Call{Call: _e.mock.On("WithError", err)}
}

func (_c *MockFieldLogger_WithError_Call) Run(run func(err error)) *MockFieldLogger_WithError_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 error
		if args[0] != nil {
			arg0 = args[0].(error)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockFieldLogger_WithError_Call) Return(entry *logrus.Entry) *MockFieldLogger_WithError_Call {
	_c.Call.Return(entry)
	return _c
}

func (_c *MockFieldLogger_WithError_Call) RunAndReturn(run func(err error) *logrus.Entry) *MockFieldLogger_WithError_Call {
	_c.Call.Return(run)
	return _c
}

// WithField provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) WithField(key string, value interface{}) *logrus.Entry {
	ret := _mock.Called(key, value)

	if len(ret) == 0 {
		panic("no return value specified for WithField")
	}

	var r0 *logrus.Entry
	if returnFunc, ok := ret.Get(0).(func(string, interface{}) *logrus.Entry); ok {
		r0 = returnFunc(key, value)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*logrus.Entry)
		}
	}
	return r0
}

// MockFieldLogger_WithField_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithField'
type MockFieldLogger_WithField_Call struct {
	*mock.Call
}

// WithField is a helper method to define mock.On call
//   - key string
//   - value interface{}
func (_e *MockFieldLogger_Expecter) WithField(key interface{}, value interface{}) *MockFieldLogger_WithField_Call {
	return &MockFieldLogger_WithField_Call{Call: _e.mock.On("WithField", key, value)}
}

func (_c *MockFieldLogger_WithField_Call) Run(run func(key string, value interface{})) *MockFieldLogger_WithField_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 interface{}
		if args[1] != nil {
			arg1 = args[1].(interface{})
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockFieldLogger_WithField_Call) Return(entry *logrus.Entry) *MockFieldLogger_WithField_Call {
	_c.Call.Return(entry)
	return _c
}

func (_c *MockFieldLogger_WithField_Call) RunAndReturn(run func(key string, value interface{}) *logrus.Entry) *MockFieldLogger_WithField_Call {
	_c.Call.Return(run)
	return _c
}

// WithFields provides a mock function for the type MockFieldLogger
func (_mock *MockFieldLogger) WithFields(fields logrus.Fields) *logrus.Entry {
	ret := _mock.Called(fields)

	if len(ret) == 0 {
		panic("no return value specified for WithFields")
	}

	var r0 *logrus.Entry
	if returnFunc, ok := ret.Get(0).(func(logrus.Fields) *logrus.Entry); ok {
		r0 = returnFunc(fields)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*logrus.Entry)
		}
	}
	return r0
}

// MockFieldLogger_WithFields_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithFields'
type MockFieldLogger_WithFields_Call struct {
	*mock.Call
}

// WithFields is a helper method to define mock.On call
//   - fields logrus.Fields
func (_e *MockFieldLogger_Expecter) WithFields(fields interface{}) *MockFieldLogger_WithFields_Call {
	return &MockFieldLogger_WithFields_Call{Call: _e.mock.On("WithFields", fields)}
}

func (_c *MockFieldLogger_WithFields_Call) Run(run func(fields logrus.Fields)) *MockFieldLogger_WithFields_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 logrus.Fields
		if args[0] != nil {
			arg0 = args[0].(logrus.Fields)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockFieldLogger_WithFields_Call) Return(entry *logrus.Entry) *MockFieldLogger_WithFields_Call {
	_c.Call.Return(entry)
	return _c
}

func (_c *MockFieldLogger_WithFields_Call) RunAndReturn(run func(fields logrus.Fields) *logrus.Entry) *MockFieldLogger_WithFields_Call {
	_c.Call.Return(run)
	return _c
}
