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

package process

import (
	"os"

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

// NewMockCommander creates a new instance of MockCommander. 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 NewMockCommander(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockCommander {
	mock := &MockCommander{}
	mock.Mock.Test(t)

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

	return mock
}

// MockCommander is an autogenerated mock type for the Commander type
type MockCommander struct {
	mock.Mock
}

type MockCommander_Expecter struct {
	mock *mock.Mock
}

func (_m *MockCommander) EXPECT() *MockCommander_Expecter {
	return &MockCommander_Expecter{mock: &_m.Mock}
}

// Process provides a mock function for the type MockCommander
func (_mock *MockCommander) Process() *os.Process {
	ret := _mock.Called()

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

	var r0 *os.Process
	if returnFunc, ok := ret.Get(0).(func() *os.Process); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*os.Process)
		}
	}
	return r0
}

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

// Process is a helper method to define mock.On call
func (_e *MockCommander_Expecter) Process() *MockCommander_Process_Call {
	return &MockCommander_Process_Call{Call: _e.mock.On("Process")}
}

func (_c *MockCommander_Process_Call) Run(run func()) *MockCommander_Process_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockCommander_Process_Call) Return(process *os.Process) *MockCommander_Process_Call {
	_c.Call.Return(process)
	return _c
}

func (_c *MockCommander_Process_Call) RunAndReturn(run func() *os.Process) *MockCommander_Process_Call {
	_c.Call.Return(run)
	return _c
}

// Start provides a mock function for the type MockCommander
func (_mock *MockCommander) Start() error {
	ret := _mock.Called()

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func() error); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Start is a helper method to define mock.On call
func (_e *MockCommander_Expecter) Start() *MockCommander_Start_Call {
	return &MockCommander_Start_Call{Call: _e.mock.On("Start")}
}

func (_c *MockCommander_Start_Call) Run(run func()) *MockCommander_Start_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockCommander_Start_Call) Return(err error) *MockCommander_Start_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockCommander_Start_Call) RunAndReturn(run func() error) *MockCommander_Start_Call {
	_c.Call.Return(run)
	return _c
}

// Wait provides a mock function for the type MockCommander
func (_mock *MockCommander) Wait() error {
	ret := _mock.Called()

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func() error); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Wait is a helper method to define mock.On call
func (_e *MockCommander_Expecter) Wait() *MockCommander_Wait_Call {
	return &MockCommander_Wait_Call{Call: _e.mock.On("Wait")}
}

func (_c *MockCommander_Wait_Call) Run(run func()) *MockCommander_Wait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockCommander_Wait_Call) Return(err error) *MockCommander_Wait_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockCommander_Wait_Call) RunAndReturn(run func() error) *MockCommander_Wait_Call {
	_c.Call.Return(run)
	return _c
}

// newMockKiller creates a new instance of mockKiller. 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 newMockKiller(t interface {
	mock.TestingT
	Cleanup(func())
}) *mockKiller {
	mock := &mockKiller{}
	mock.Mock.Test(t)

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

	return mock
}

// mockKiller is an autogenerated mock type for the killer type
type mockKiller struct {
	mock.Mock
}

type mockKiller_Expecter struct {
	mock *mock.Mock
}

func (_m *mockKiller) EXPECT() *mockKiller_Expecter {
	return &mockKiller_Expecter{mock: &_m.Mock}
}

// ForceKill provides a mock function for the type mockKiller
func (_mock *mockKiller) ForceKill() {
	_mock.Called()
	return
}

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

// ForceKill is a helper method to define mock.On call
func (_e *mockKiller_Expecter) ForceKill() *mockKiller_ForceKill_Call {
	return &mockKiller_ForceKill_Call{Call: _e.mock.On("ForceKill")}
}

func (_c *mockKiller_ForceKill_Call) Run(run func()) *mockKiller_ForceKill_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

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

func (_c *mockKiller_ForceKill_Call) RunAndReturn(run func()) *mockKiller_ForceKill_Call {
	_c.Run(run)
	return _c
}

// Terminate provides a mock function for the type mockKiller
func (_mock *mockKiller) Terminate() {
	_mock.Called()
	return
}

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

// Terminate is a helper method to define mock.On call
func (_e *mockKiller_Expecter) Terminate() *mockKiller_Terminate_Call {
	return &mockKiller_Terminate_Call{Call: _e.mock.On("Terminate")}
}

func (_c *mockKiller_Terminate_Call) Run(run func()) *mockKiller_Terminate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

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

func (_c *mockKiller_Terminate_Call) RunAndReturn(run func()) *mockKiller_Terminate_Call {
	_c.Run(run)
	return _c
}

// NewMockKillWaiter creates a new instance of MockKillWaiter. 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 NewMockKillWaiter(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockKillWaiter {
	mock := &MockKillWaiter{}
	mock.Mock.Test(t)

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

	return mock
}

// MockKillWaiter is an autogenerated mock type for the KillWaiter type
type MockKillWaiter struct {
	mock.Mock
}

type MockKillWaiter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockKillWaiter) EXPECT() *MockKillWaiter_Expecter {
	return &MockKillWaiter_Expecter{mock: &_m.Mock}
}

// KillAndWait provides a mock function for the type MockKillWaiter
func (_mock *MockKillWaiter) KillAndWait(command Commander, waitCh chan error) error {
	ret := _mock.Called(command, waitCh)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(Commander, chan error) error); ok {
		r0 = returnFunc(command, waitCh)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// KillAndWait is a helper method to define mock.On call
//   - command Commander
//   - waitCh chan error
func (_e *MockKillWaiter_Expecter) KillAndWait(command interface{}, waitCh interface{}) *MockKillWaiter_KillAndWait_Call {
	return &MockKillWaiter_KillAndWait_Call{Call: _e.mock.On("KillAndWait", command, waitCh)}
}

func (_c *MockKillWaiter_KillAndWait_Call) Run(run func(command Commander, waitCh chan error)) *MockKillWaiter_KillAndWait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 Commander
		if args[0] != nil {
			arg0 = args[0].(Commander)
		}
		var arg1 chan error
		if args[1] != nil {
			arg1 = args[1].(chan error)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockKillWaiter_KillAndWait_Call) Return(err error) *MockKillWaiter_KillAndWait_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockKillWaiter_KillAndWait_Call) RunAndReturn(run func(command Commander, waitCh chan error) error) *MockKillWaiter_KillAndWait_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockLogger creates a new instance of MockLogger. 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 NewMockLogger(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockLogger {
	mock := &MockLogger{}
	mock.Mock.Test(t)

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

	return mock
}

// MockLogger is an autogenerated mock type for the Logger type
type MockLogger struct {
	mock.Mock
}

type MockLogger_Expecter struct {
	mock *mock.Mock
}

func (_m *MockLogger) EXPECT() *MockLogger_Expecter {
	return &MockLogger_Expecter{mock: &_m.Mock}
}

// Warn provides a mock function for the type MockLogger
func (_mock *MockLogger) Warn(args ...interface{}) {
	var _ca []interface{}
	_ca = append(_ca, args...)
	_mock.Called(_ca...)
	return
}

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

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

func (_c *MockLogger_Warn_Call) Run(run func(args ...interface{})) *MockLogger_Warn_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		variadicArgs := make([]interface{}, len(args)-0)
		for i, a := range args[0:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

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

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

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

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

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

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

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

func (_c *MockLogger_WithFields_Call) Run(run func(fields logrus.Fields)) *MockLogger_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 *MockLogger_WithFields_Call) Return(logger Logger) *MockLogger_WithFields_Call {
	_c.Call.Return(logger)
	return _c
}

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