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

package common

import (
	"context"
	"io"
	"time"

	mock "github.com/stretchr/testify/mock"
	"github.com/urfave/cli"
)

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

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

	return mock
}

// MockWithContext is an autogenerated mock type for the WithContext type
type MockWithContext struct {
	mock.Mock
}

type MockWithContext_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWithContext) EXPECT() *MockWithContext_Expecter {
	return &MockWithContext_Expecter{mock: &_m.Mock}
}

// WithContext provides a mock function for the type MockWithContext
func (_mock *MockWithContext) WithContext(context1 context.Context) (context.Context, context.CancelFunc) {
	ret := _mock.Called(context1)

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

	var r0 context.Context
	var r1 context.CancelFunc
	if returnFunc, ok := ret.Get(0).(func(context.Context) (context.Context, context.CancelFunc)); ok {
		return returnFunc(context1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) context.Context); ok {
		r0 = returnFunc(context1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(context.Context)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) context.CancelFunc); ok {
		r1 = returnFunc(context1)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(context.CancelFunc)
		}
	}
	return r0, r1
}

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

// WithContext is a helper method to define mock.On call
//   - context1 context.Context
func (_e *MockWithContext_Expecter) WithContext(context1 interface{}) *MockWithContext_WithContext_Call {
	return &MockWithContext_WithContext_Call{Call: _e.mock.On("WithContext", context1)}
}

func (_c *MockWithContext_WithContext_Call) Run(run func(context1 context.Context)) *MockWithContext_WithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWithContext_WithContext_Call) Return(context11 context.Context, cancelFunc context.CancelFunc) *MockWithContext_WithContext_Call {
	_c.Call.Return(context11, cancelFunc)
	return _c
}

func (_c *MockWithContext_WithContext_Call) RunAndReturn(run func(context1 context.Context) (context.Context, context.CancelFunc)) *MockWithContext_WithContext_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// mockUrlHelper is an autogenerated mock type for the urlHelper type
type mockUrlHelper struct {
	mock.Mock
}

type mockUrlHelper_Expecter struct {
	mock *mock.Mock
}

func (_m *mockUrlHelper) EXPECT() *mockUrlHelper_Expecter {
	return &mockUrlHelper_Expecter{mock: &_m.Mock}
}

// GetRemoteURL provides a mock function for the type mockUrlHelper
func (_mock *mockUrlHelper) GetRemoteURL() (string, error) {
	ret := _mock.Called()

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

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

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

// GetRemoteURL is a helper method to define mock.On call
func (_e *mockUrlHelper_Expecter) GetRemoteURL() *mockUrlHelper_GetRemoteURL_Call {
	return &mockUrlHelper_GetRemoteURL_Call{Call: _e.mock.On("GetRemoteURL")}
}

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

func (_c *mockUrlHelper_GetRemoteURL_Call) Return(s string, err error) *mockUrlHelper_GetRemoteURL_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *mockUrlHelper_GetRemoteURL_Call) RunAndReturn(run func() (string, error)) *mockUrlHelper_GetRemoteURL_Call {
	_c.Call.Return(run)
	return _c
}

// GetURLInsteadOfArgs provides a mock function for the type mockUrlHelper
func (_mock *mockUrlHelper) GetURLInsteadOfArgs() ([]string, error) {
	ret := _mock.Called()

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

	var r0 []string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() ([]string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []string); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetURLInsteadOfArgs is a helper method to define mock.On call
func (_e *mockUrlHelper_Expecter) GetURLInsteadOfArgs() *mockUrlHelper_GetURLInsteadOfArgs_Call {
	return &mockUrlHelper_GetURLInsteadOfArgs_Call{Call: _e.mock.On("GetURLInsteadOfArgs")}
}

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

func (_c *mockUrlHelper_GetURLInsteadOfArgs_Call) Return(strings []string, err error) *mockUrlHelper_GetURLInsteadOfArgs_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *mockUrlHelper_GetURLInsteadOfArgs_Call) RunAndReturn(run func() ([]string, error)) *mockUrlHelper_GetURLInsteadOfArgs_Call {
	_c.Call.Return(run)
	return _c
}

// 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}
}

// Execute provides a mock function for the type MockCommander
func (_mock *MockCommander) Execute(c *cli.Context) {
	_mock.Called(c)
	return
}

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

// Execute is a helper method to define mock.On call
//   - c *cli.Context
func (_e *MockCommander_Expecter) Execute(c interface{}) *MockCommander_Execute_Call {
	return &MockCommander_Execute_Call{Call: _e.mock.On("Execute", c)}
}

func (_c *MockCommander_Execute_Call) Run(run func(c *cli.Context)) *MockCommander_Execute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *cli.Context
		if args[0] != nil {
			arg0 = args[0].(*cli.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockCommander_Execute_Call) RunAndReturn(run func(c *cli.Context)) *MockCommander_Execute_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockConfigSaver is an autogenerated mock type for the ConfigSaver type
type MockConfigSaver struct {
	mock.Mock
}

type MockConfigSaver_Expecter struct {
	mock *mock.Mock
}

func (_m *MockConfigSaver) EXPECT() *MockConfigSaver_Expecter {
	return &MockConfigSaver_Expecter{mock: &_m.Mock}
}

// Save provides a mock function for the type MockConfigSaver
func (_mock *MockConfigSaver) Save(filePath string, data []byte) error {
	ret := _mock.Called(filePath, data)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, []byte) error); ok {
		r0 = returnFunc(filePath, data)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - filePath string
//   - data []byte
func (_e *MockConfigSaver_Expecter) Save(filePath interface{}, data interface{}) *MockConfigSaver_Save_Call {
	return &MockConfigSaver_Save_Call{Call: _e.mock.On("Save", filePath, data)}
}

func (_c *MockConfigSaver_Save_Call) Run(run func(filePath string, data []byte)) *MockConfigSaver_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []byte
		if args[1] != nil {
			arg1 = args[1].([]byte)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockConfigSaver_Save_Call) RunAndReturn(run func(filePath string, data []byte) error) *MockConfigSaver_Save_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockExecutorData is an autogenerated mock type for the ExecutorData type
type MockExecutorData struct {
	mock.Mock
}

type MockExecutorData_Expecter struct {
	mock *mock.Mock
}

func (_m *MockExecutorData) EXPECT() *MockExecutorData_Expecter {
	return &MockExecutorData_Expecter{mock: &_m.Mock}
}

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

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

	return mock
}

// MockExecutor is an autogenerated mock type for the Executor type
type MockExecutor struct {
	mock.Mock
}

type MockExecutor_Expecter struct {
	mock *mock.Mock
}

func (_m *MockExecutor) EXPECT() *MockExecutor_Expecter {
	return &MockExecutor_Expecter{mock: &_m.Mock}
}

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

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

// Cleanup is a helper method to define mock.On call
func (_e *MockExecutor_Expecter) Cleanup() *MockExecutor_Cleanup_Call {
	return &MockExecutor_Cleanup_Call{Call: _e.mock.On("Cleanup")}
}

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

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

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

// Finish provides a mock function for the type MockExecutor
func (_mock *MockExecutor) Finish(err error) {
	_mock.Called(err)
	return
}

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

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

func (_c *MockExecutor_Finish_Call) Run(run func(err error)) *MockExecutor_Finish_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 *MockExecutor_Finish_Call) Return() *MockExecutor_Finish_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockExecutor_Finish_Call) RunAndReturn(run func(err error)) *MockExecutor_Finish_Call {
	_c.Run(run)
	return _c
}

// GetCurrentStage provides a mock function for the type MockExecutor
func (_mock *MockExecutor) GetCurrentStage() ExecutorStage {
	ret := _mock.Called()

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

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

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

// GetCurrentStage is a helper method to define mock.On call
func (_e *MockExecutor_Expecter) GetCurrentStage() *MockExecutor_GetCurrentStage_Call {
	return &MockExecutor_GetCurrentStage_Call{Call: _e.mock.On("GetCurrentStage")}
}

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

func (_c *MockExecutor_GetCurrentStage_Call) Return(executorStage ExecutorStage) *MockExecutor_GetCurrentStage_Call {
	_c.Call.Return(executorStage)
	return _c
}

func (_c *MockExecutor_GetCurrentStage_Call) RunAndReturn(run func() ExecutorStage) *MockExecutor_GetCurrentStage_Call {
	_c.Call.Return(run)
	return _c
}

// Prepare provides a mock function for the type MockExecutor
func (_mock *MockExecutor) Prepare(options ExecutorPrepareOptions) error {
	ret := _mock.Called(options)

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

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

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

// Prepare is a helper method to define mock.On call
//   - options ExecutorPrepareOptions
func (_e *MockExecutor_Expecter) Prepare(options interface{}) *MockExecutor_Prepare_Call {
	return &MockExecutor_Prepare_Call{Call: _e.mock.On("Prepare", options)}
}

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

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

func (_c *MockExecutor_Prepare_Call) RunAndReturn(run func(options ExecutorPrepareOptions) error) *MockExecutor_Prepare_Call {
	_c.Call.Return(run)
	return _c
}

// Run provides a mock function for the type MockExecutor
func (_mock *MockExecutor) Run(cmd ExecutorCommand) error {
	ret := _mock.Called(cmd)

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

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

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

// Run is a helper method to define mock.On call
//   - cmd ExecutorCommand
func (_e *MockExecutor_Expecter) Run(cmd interface{}) *MockExecutor_Run_Call {
	return &MockExecutor_Run_Call{Call: _e.mock.On("Run", cmd)}
}

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

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

func (_c *MockExecutor_Run_Call) RunAndReturn(run func(cmd ExecutorCommand) error) *MockExecutor_Run_Call {
	_c.Call.Return(run)
	return _c
}

// SetCurrentStage provides a mock function for the type MockExecutor
func (_mock *MockExecutor) SetCurrentStage(stage ExecutorStage) {
	_mock.Called(stage)
	return
}

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

// SetCurrentStage is a helper method to define mock.On call
//   - stage ExecutorStage
func (_e *MockExecutor_Expecter) SetCurrentStage(stage interface{}) *MockExecutor_SetCurrentStage_Call {
	return &MockExecutor_SetCurrentStage_Call{Call: _e.mock.On("SetCurrentStage", stage)}
}

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

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

func (_c *MockExecutor_SetCurrentStage_Call) RunAndReturn(run func(stage ExecutorStage)) *MockExecutor_SetCurrentStage_Call {
	_c.Run(run)
	return _c
}

// Shell provides a mock function for the type MockExecutor
func (_mock *MockExecutor) Shell() *ShellScriptInfo {
	ret := _mock.Called()

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

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

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

// Shell is a helper method to define mock.On call
func (_e *MockExecutor_Expecter) Shell() *MockExecutor_Shell_Call {
	return &MockExecutor_Shell_Call{Call: _e.mock.On("Shell")}
}

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

func (_c *MockExecutor_Shell_Call) Return(shellScriptInfo *ShellScriptInfo) *MockExecutor_Shell_Call {
	_c.Call.Return(shellScriptInfo)
	return _c
}

func (_c *MockExecutor_Shell_Call) RunAndReturn(run func() *ShellScriptInfo) *MockExecutor_Shell_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockManagedExecutorProvider is an autogenerated mock type for the ManagedExecutorProvider type
type MockManagedExecutorProvider struct {
	mock.Mock
}

type MockManagedExecutorProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockManagedExecutorProvider) EXPECT() *MockManagedExecutorProvider_Expecter {
	return &MockManagedExecutorProvider_Expecter{mock: &_m.Mock}
}

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

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

// Init is a helper method to define mock.On call
func (_e *MockManagedExecutorProvider_Expecter) Init() *MockManagedExecutorProvider_Init_Call {
	return &MockManagedExecutorProvider_Init_Call{Call: _e.mock.On("Init")}
}

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

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

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

// Shutdown provides a mock function for the type MockManagedExecutorProvider
func (_mock *MockManagedExecutorProvider) Shutdown(ctx context.Context) {
	_mock.Called(ctx)
	return
}

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

// Shutdown is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockManagedExecutorProvider_Expecter) Shutdown(ctx interface{}) *MockManagedExecutorProvider_Shutdown_Call {
	return &MockManagedExecutorProvider_Shutdown_Call{Call: _e.mock.On("Shutdown", ctx)}
}

func (_c *MockManagedExecutorProvider_Shutdown_Call) Run(run func(ctx context.Context)) *MockManagedExecutorProvider_Shutdown_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockManagedExecutorProvider_Shutdown_Call) RunAndReturn(run func(ctx context.Context)) *MockManagedExecutorProvider_Shutdown_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockExecutorProvider is an autogenerated mock type for the ExecutorProvider type
type MockExecutorProvider struct {
	mock.Mock
}

type MockExecutorProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockExecutorProvider) EXPECT() *MockExecutorProvider_Expecter {
	return &MockExecutorProvider_Expecter{mock: &_m.Mock}
}

// Acquire provides a mock function for the type MockExecutorProvider
func (_mock *MockExecutorProvider) Acquire(config *RunnerConfig) (ExecutorData, error) {
	ret := _mock.Called(config)

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

	var r0 ExecutorData
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(*RunnerConfig) (ExecutorData, error)); ok {
		return returnFunc(config)
	}
	if returnFunc, ok := ret.Get(0).(func(*RunnerConfig) ExecutorData); ok {
		r0 = returnFunc(config)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ExecutorData)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(*RunnerConfig) error); ok {
		r1 = returnFunc(config)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Acquire is a helper method to define mock.On call
//   - config *RunnerConfig
func (_e *MockExecutorProvider_Expecter) Acquire(config interface{}) *MockExecutorProvider_Acquire_Call {
	return &MockExecutorProvider_Acquire_Call{Call: _e.mock.On("Acquire", config)}
}

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

func (_c *MockExecutorProvider_Acquire_Call) Return(executorData ExecutorData, err error) *MockExecutorProvider_Acquire_Call {
	_c.Call.Return(executorData, err)
	return _c
}

func (_c *MockExecutorProvider_Acquire_Call) RunAndReturn(run func(config *RunnerConfig) (ExecutorData, error)) *MockExecutorProvider_Acquire_Call {
	_c.Call.Return(run)
	return _c
}

// CanCreate provides a mock function for the type MockExecutorProvider
func (_mock *MockExecutorProvider) CanCreate() bool {
	ret := _mock.Called()

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

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

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

// CanCreate is a helper method to define mock.On call
func (_e *MockExecutorProvider_Expecter) CanCreate() *MockExecutorProvider_CanCreate_Call {
	return &MockExecutorProvider_CanCreate_Call{Call: _e.mock.On("CanCreate")}
}

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

func (_c *MockExecutorProvider_CanCreate_Call) Return(b bool) *MockExecutorProvider_CanCreate_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockExecutorProvider_CanCreate_Call) RunAndReturn(run func() bool) *MockExecutorProvider_CanCreate_Call {
	_c.Call.Return(run)
	return _c
}

// Create provides a mock function for the type MockExecutorProvider
func (_mock *MockExecutorProvider) Create() Executor {
	ret := _mock.Called()

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

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

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

// Create is a helper method to define mock.On call
func (_e *MockExecutorProvider_Expecter) Create() *MockExecutorProvider_Create_Call {
	return &MockExecutorProvider_Create_Call{Call: _e.mock.On("Create")}
}

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

func (_c *MockExecutorProvider_Create_Call) Return(executor Executor) *MockExecutorProvider_Create_Call {
	_c.Call.Return(executor)
	return _c
}

func (_c *MockExecutorProvider_Create_Call) RunAndReturn(run func() Executor) *MockExecutorProvider_Create_Call {
	_c.Call.Return(run)
	return _c
}

// GetConfigInfo provides a mock function for the type MockExecutorProvider
func (_mock *MockExecutorProvider) GetConfigInfo(input *RunnerConfig, output *ConfigInfo) {
	_mock.Called(input, output)
	return
}

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

// GetConfigInfo is a helper method to define mock.On call
//   - input *RunnerConfig
//   - output *ConfigInfo
func (_e *MockExecutorProvider_Expecter) GetConfigInfo(input interface{}, output interface{}) *MockExecutorProvider_GetConfigInfo_Call {
	return &MockExecutorProvider_GetConfigInfo_Call{Call: _e.mock.On("GetConfigInfo", input, output)}
}

func (_c *MockExecutorProvider_GetConfigInfo_Call) Run(run func(input *RunnerConfig, output *ConfigInfo)) *MockExecutorProvider_GetConfigInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *RunnerConfig
		if args[0] != nil {
			arg0 = args[0].(*RunnerConfig)
		}
		var arg1 *ConfigInfo
		if args[1] != nil {
			arg1 = args[1].(*ConfigInfo)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockExecutorProvider_GetConfigInfo_Call) RunAndReturn(run func(input *RunnerConfig, output *ConfigInfo)) *MockExecutorProvider_GetConfigInfo_Call {
	_c.Run(run)
	return _c
}

// GetDefaultShell provides a mock function for the type MockExecutorProvider
func (_mock *MockExecutorProvider) GetDefaultShell() string {
	ret := _mock.Called()

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

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

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

// GetDefaultShell is a helper method to define mock.On call
func (_e *MockExecutorProvider_Expecter) GetDefaultShell() *MockExecutorProvider_GetDefaultShell_Call {
	return &MockExecutorProvider_GetDefaultShell_Call{Call: _e.mock.On("GetDefaultShell")}
}

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

func (_c *MockExecutorProvider_GetDefaultShell_Call) Return(s string) *MockExecutorProvider_GetDefaultShell_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockExecutorProvider_GetDefaultShell_Call) RunAndReturn(run func() string) *MockExecutorProvider_GetDefaultShell_Call {
	_c.Call.Return(run)
	return _c
}

// GetFeatures provides a mock function for the type MockExecutorProvider
func (_mock *MockExecutorProvider) GetFeatures(features *FeaturesInfo) error {
	ret := _mock.Called(features)

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

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

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

// GetFeatures is a helper method to define mock.On call
//   - features *FeaturesInfo
func (_e *MockExecutorProvider_Expecter) GetFeatures(features interface{}) *MockExecutorProvider_GetFeatures_Call {
	return &MockExecutorProvider_GetFeatures_Call{Call: _e.mock.On("GetFeatures", features)}
}

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

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

func (_c *MockExecutorProvider_GetFeatures_Call) RunAndReturn(run func(features *FeaturesInfo) error) *MockExecutorProvider_GetFeatures_Call {
	_c.Call.Return(run)
	return _c
}

// Release provides a mock function for the type MockExecutorProvider
func (_mock *MockExecutorProvider) Release(config *RunnerConfig, data ExecutorData) {
	_mock.Called(config, data)
	return
}

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

// Release is a helper method to define mock.On call
//   - config *RunnerConfig
//   - data ExecutorData
func (_e *MockExecutorProvider_Expecter) Release(config interface{}, data interface{}) *MockExecutorProvider_Release_Call {
	return &MockExecutorProvider_Release_Call{Call: _e.mock.On("Release", config, data)}
}

func (_c *MockExecutorProvider_Release_Call) Run(run func(config *RunnerConfig, data ExecutorData)) *MockExecutorProvider_Release_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *RunnerConfig
		if args[0] != nil {
			arg0 = args[0].(*RunnerConfig)
		}
		var arg1 ExecutorData
		if args[1] != nil {
			arg1 = args[1].(ExecutorData)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockExecutorProvider_Release_Call) RunAndReturn(run func(config *RunnerConfig, data ExecutorData)) *MockExecutorProvider_Release_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockContentProvider is an autogenerated mock type for the ContentProvider type
type MockContentProvider struct {
	mock.Mock
}

type MockContentProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockContentProvider) EXPECT() *MockContentProvider_Expecter {
	return &MockContentProvider_Expecter{mock: &_m.Mock}
}

// GetContentLength provides a mock function for the type MockContentProvider
func (_mock *MockContentProvider) GetContentLength() (int64, bool) {
	ret := _mock.Called()

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

	var r0 int64
	var r1 bool
	if returnFunc, ok := ret.Get(0).(func() (int64, bool)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() int64); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int64)
	}
	if returnFunc, ok := ret.Get(1).(func() bool); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Get(1).(bool)
	}
	return r0, r1
}

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

// GetContentLength is a helper method to define mock.On call
func (_e *MockContentProvider_Expecter) GetContentLength() *MockContentProvider_GetContentLength_Call {
	return &MockContentProvider_GetContentLength_Call{Call: _e.mock.On("GetContentLength")}
}

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

func (_c *MockContentProvider_GetContentLength_Call) Return(n int64, b bool) *MockContentProvider_GetContentLength_Call {
	_c.Call.Return(n, b)
	return _c
}

func (_c *MockContentProvider_GetContentLength_Call) RunAndReturn(run func() (int64, bool)) *MockContentProvider_GetContentLength_Call {
	_c.Call.Return(run)
	return _c
}

// GetReader provides a mock function for the type MockContentProvider
func (_mock *MockContentProvider) GetReader() (io.ReadCloser, error) {
	ret := _mock.Called()

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

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (io.ReadCloser, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() io.ReadCloser); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetReader is a helper method to define mock.On call
func (_e *MockContentProvider_Expecter) GetReader() *MockContentProvider_GetReader_Call {
	return &MockContentProvider_GetReader_Call{Call: _e.mock.On("GetReader")}
}

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

func (_c *MockContentProvider_GetReader_Call) Return(readCloser io.ReadCloser, err error) *MockContentProvider_GetReader_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *MockContentProvider_GetReader_Call) RunAndReturn(run func() (io.ReadCloser, error)) *MockContentProvider_GetReader_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockFailuresCollector is an autogenerated mock type for the FailuresCollector type
type MockFailuresCollector struct {
	mock.Mock
}

type MockFailuresCollector_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFailuresCollector) EXPECT() *MockFailuresCollector_Expecter {
	return &MockFailuresCollector_Expecter{mock: &_m.Mock}
}

// RecordFailure provides a mock function for the type MockFailuresCollector
func (_mock *MockFailuresCollector) RecordFailure(reason JobFailureReason, runnerConfig RunnerConfig) {
	_mock.Called(reason, runnerConfig)
	return
}

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

// RecordFailure is a helper method to define mock.On call
//   - reason JobFailureReason
//   - runnerConfig RunnerConfig
func (_e *MockFailuresCollector_Expecter) RecordFailure(reason interface{}, runnerConfig interface{}) *MockFailuresCollector_RecordFailure_Call {
	return &MockFailuresCollector_RecordFailure_Call{Call: _e.mock.On("RecordFailure", reason, runnerConfig)}
}

func (_c *MockFailuresCollector_RecordFailure_Call) Run(run func(reason JobFailureReason, runnerConfig RunnerConfig)) *MockFailuresCollector_RecordFailure_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 JobFailureReason
		if args[0] != nil {
			arg0 = args[0].(JobFailureReason)
		}
		var arg1 RunnerConfig
		if args[1] != nil {
			arg1 = args[1].(RunnerConfig)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockFailuresCollector_RecordFailure_Call) RunAndReturn(run func(reason JobFailureReason, runnerConfig RunnerConfig)) *MockFailuresCollector_RecordFailure_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockSupportedFailureReasonMapper is an autogenerated mock type for the SupportedFailureReasonMapper type
type MockSupportedFailureReasonMapper struct {
	mock.Mock
}

type MockSupportedFailureReasonMapper_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSupportedFailureReasonMapper) EXPECT() *MockSupportedFailureReasonMapper_Expecter {
	return &MockSupportedFailureReasonMapper_Expecter{mock: &_m.Mock}
}

// Map provides a mock function for the type MockSupportedFailureReasonMapper
func (_mock *MockSupportedFailureReasonMapper) Map(fr JobFailureReason) JobFailureReason {
	ret := _mock.Called(fr)

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

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

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

// Map is a helper method to define mock.On call
//   - fr JobFailureReason
func (_e *MockSupportedFailureReasonMapper_Expecter) Map(fr interface{}) *MockSupportedFailureReasonMapper_Map_Call {
	return &MockSupportedFailureReasonMapper_Map_Call{Call: _e.mock.On("Map", fr)}
}

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

func (_c *MockSupportedFailureReasonMapper_Map_Call) Return(jobFailureReason JobFailureReason) *MockSupportedFailureReasonMapper_Map_Call {
	_c.Call.Return(jobFailureReason)
	return _c
}

func (_c *MockSupportedFailureReasonMapper_Map_Call) RunAndReturn(run func(fr JobFailureReason) JobFailureReason) *MockSupportedFailureReasonMapper_Map_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockJobTrace is an autogenerated mock type for the JobTrace type
type MockJobTrace struct {
	mock.Mock
}

type MockJobTrace_Expecter struct {
	mock *mock.Mock
}

func (_m *MockJobTrace) EXPECT() *MockJobTrace_Expecter {
	return &MockJobTrace_Expecter{mock: &_m.Mock}
}

// Abort provides a mock function for the type MockJobTrace
func (_mock *MockJobTrace) Abort() bool {
	ret := _mock.Called()

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

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

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

// Abort is a helper method to define mock.On call
func (_e *MockJobTrace_Expecter) Abort() *MockJobTrace_Abort_Call {
	return &MockJobTrace_Abort_Call{Call: _e.mock.On("Abort")}
}

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

func (_c *MockJobTrace_Abort_Call) Return(b bool) *MockJobTrace_Abort_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockJobTrace_Abort_Call) RunAndReturn(run func() bool) *MockJobTrace_Abort_Call {
	_c.Call.Return(run)
	return _c
}

// Cancel provides a mock function for the type MockJobTrace
func (_mock *MockJobTrace) Cancel() bool {
	ret := _mock.Called()

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

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

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

// Cancel is a helper method to define mock.On call
func (_e *MockJobTrace_Expecter) Cancel() *MockJobTrace_Cancel_Call {
	return &MockJobTrace_Cancel_Call{Call: _e.mock.On("Cancel")}
}

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

func (_c *MockJobTrace_Cancel_Call) Return(b bool) *MockJobTrace_Cancel_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockJobTrace_Cancel_Call) RunAndReturn(run func() bool) *MockJobTrace_Cancel_Call {
	_c.Call.Return(run)
	return _c
}

// Fail provides a mock function for the type MockJobTrace
func (_mock *MockJobTrace) Fail(err error, failureData JobFailureData) error {
	ret := _mock.Called(err, failureData)

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

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

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

// Fail is a helper method to define mock.On call
//   - err error
//   - failureData JobFailureData
func (_e *MockJobTrace_Expecter) Fail(err interface{}, failureData interface{}) *MockJobTrace_Fail_Call {
	return &MockJobTrace_Fail_Call{Call: _e.mock.On("Fail", err, failureData)}
}

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

func (_c *MockJobTrace_Fail_Call) Return(err1 error) *MockJobTrace_Fail_Call {
	_c.Call.Return(err1)
	return _c
}

func (_c *MockJobTrace_Fail_Call) RunAndReturn(run func(err error, failureData JobFailureData) error) *MockJobTrace_Fail_Call {
	_c.Call.Return(run)
	return _c
}

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

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

// Finish is a helper method to define mock.On call
func (_e *MockJobTrace_Expecter) Finish() *MockJobTrace_Finish_Call {
	return &MockJobTrace_Finish_Call{Call: _e.mock.On("Finish")}
}

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

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

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

// IsStdout provides a mock function for the type MockJobTrace
func (_mock *MockJobTrace) IsStdout() bool {
	ret := _mock.Called()

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

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

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

// IsStdout is a helper method to define mock.On call
func (_e *MockJobTrace_Expecter) IsStdout() *MockJobTrace_IsStdout_Call {
	return &MockJobTrace_IsStdout_Call{Call: _e.mock.On("IsStdout")}
}

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

func (_c *MockJobTrace_IsStdout_Call) Return(b bool) *MockJobTrace_IsStdout_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockJobTrace_IsStdout_Call) RunAndReturn(run func() bool) *MockJobTrace_IsStdout_Call {
	_c.Call.Return(run)
	return _c
}

// SetAbortFunc provides a mock function for the type MockJobTrace
func (_mock *MockJobTrace) SetAbortFunc(abortFunc context.CancelFunc) {
	_mock.Called(abortFunc)
	return
}

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

// SetAbortFunc is a helper method to define mock.On call
//   - abortFunc context.CancelFunc
func (_e *MockJobTrace_Expecter) SetAbortFunc(abortFunc interface{}) *MockJobTrace_SetAbortFunc_Call {
	return &MockJobTrace_SetAbortFunc_Call{Call: _e.mock.On("SetAbortFunc", abortFunc)}
}

func (_c *MockJobTrace_SetAbortFunc_Call) Run(run func(abortFunc context.CancelFunc)) *MockJobTrace_SetAbortFunc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.CancelFunc
		if args[0] != nil {
			arg0 = args[0].(context.CancelFunc)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockJobTrace_SetAbortFunc_Call) RunAndReturn(run func(abortFunc context.CancelFunc)) *MockJobTrace_SetAbortFunc_Call {
	_c.Run(run)
	return _c
}

// SetCancelFunc provides a mock function for the type MockJobTrace
func (_mock *MockJobTrace) SetCancelFunc(cancelFunc context.CancelFunc) {
	_mock.Called(cancelFunc)
	return
}

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

// SetCancelFunc is a helper method to define mock.On call
//   - cancelFunc context.CancelFunc
func (_e *MockJobTrace_Expecter) SetCancelFunc(cancelFunc interface{}) *MockJobTrace_SetCancelFunc_Call {
	return &MockJobTrace_SetCancelFunc_Call{Call: _e.mock.On("SetCancelFunc", cancelFunc)}
}

func (_c *MockJobTrace_SetCancelFunc_Call) Run(run func(cancelFunc context.CancelFunc)) *MockJobTrace_SetCancelFunc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.CancelFunc
		if args[0] != nil {
			arg0 = args[0].(context.CancelFunc)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockJobTrace_SetCancelFunc_Call) RunAndReturn(run func(cancelFunc context.CancelFunc)) *MockJobTrace_SetCancelFunc_Call {
	_c.Run(run)
	return _c
}

// SetDebugModeEnabled provides a mock function for the type MockJobTrace
func (_mock *MockJobTrace) SetDebugModeEnabled(isEnabled bool) {
	_mock.Called(isEnabled)
	return
}

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

// SetDebugModeEnabled is a helper method to define mock.On call
//   - isEnabled bool
func (_e *MockJobTrace_Expecter) SetDebugModeEnabled(isEnabled interface{}) *MockJobTrace_SetDebugModeEnabled_Call {
	return &MockJobTrace_SetDebugModeEnabled_Call{Call: _e.mock.On("SetDebugModeEnabled", isEnabled)}
}

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

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

func (_c *MockJobTrace_SetDebugModeEnabled_Call) RunAndReturn(run func(isEnabled bool)) *MockJobTrace_SetDebugModeEnabled_Call {
	_c.Run(run)
	return _c
}

// SetFailuresCollector provides a mock function for the type MockJobTrace
func (_mock *MockJobTrace) SetFailuresCollector(fc FailuresCollector) {
	_mock.Called(fc)
	return
}

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

// SetFailuresCollector is a helper method to define mock.On call
//   - fc FailuresCollector
func (_e *MockJobTrace_Expecter) SetFailuresCollector(fc interface{}) *MockJobTrace_SetFailuresCollector_Call {
	return &MockJobTrace_SetFailuresCollector_Call{Call: _e.mock.On("SetFailuresCollector", fc)}
}

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

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

func (_c *MockJobTrace_SetFailuresCollector_Call) RunAndReturn(run func(fc FailuresCollector)) *MockJobTrace_SetFailuresCollector_Call {
	_c.Run(run)
	return _c
}

// SetSupportedFailureReasonMapper provides a mock function for the type MockJobTrace
func (_mock *MockJobTrace) SetSupportedFailureReasonMapper(f SupportedFailureReasonMapper) {
	_mock.Called(f)
	return
}

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

// SetSupportedFailureReasonMapper is a helper method to define mock.On call
//   - f SupportedFailureReasonMapper
func (_e *MockJobTrace_Expecter) SetSupportedFailureReasonMapper(f interface{}) *MockJobTrace_SetSupportedFailureReasonMapper_Call {
	return &MockJobTrace_SetSupportedFailureReasonMapper_Call{Call: _e.mock.On("SetSupportedFailureReasonMapper", f)}
}

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

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

func (_c *MockJobTrace_SetSupportedFailureReasonMapper_Call) RunAndReturn(run func(f SupportedFailureReasonMapper)) *MockJobTrace_SetSupportedFailureReasonMapper_Call {
	_c.Run(run)
	return _c
}

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

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

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

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

// Success is a helper method to define mock.On call
func (_e *MockJobTrace_Expecter) Success() *MockJobTrace_Success_Call {
	return &MockJobTrace_Success_Call{Call: _e.mock.On("Success")}
}

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

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

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

// Write provides a mock function for the type MockJobTrace
func (_mock *MockJobTrace) Write(p []byte) (int, error) {
	ret := _mock.Called(p)

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

	var r0 int
	var r1 error
	if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
		return returnFunc(p)
	}
	if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
		r0 = returnFunc(p)
	} else {
		r0 = ret.Get(0).(int)
	}
	if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
		r1 = returnFunc(p)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Write is a helper method to define mock.On call
//   - p []byte
func (_e *MockJobTrace_Expecter) Write(p interface{}) *MockJobTrace_Write_Call {
	return &MockJobTrace_Write_Call{Call: _e.mock.On("Write", p)}
}

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

func (_c *MockJobTrace_Write_Call) Return(n int, err error) *MockJobTrace_Write_Call {
	_c.Call.Return(n, err)
	return _c
}

func (_c *MockJobTrace_Write_Call) RunAndReturn(run func(p []byte) (int, error)) *MockJobTrace_Write_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockNetwork is an autogenerated mock type for the Network type
type MockNetwork struct {
	mock.Mock
}

type MockNetwork_Expecter struct {
	mock *mock.Mock
}

func (_m *MockNetwork) EXPECT() *MockNetwork_Expecter {
	return &MockNetwork_Expecter{mock: &_m.Mock}
}

// DownloadArtifacts provides a mock function for the type MockNetwork
func (_mock *MockNetwork) DownloadArtifacts(config JobCredentials, artifactsFile io.WriteCloser, directDownload *bool) DownloadState {
	ret := _mock.Called(config, artifactsFile, directDownload)

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

	var r0 DownloadState
	if returnFunc, ok := ret.Get(0).(func(JobCredentials, io.WriteCloser, *bool) DownloadState); ok {
		r0 = returnFunc(config, artifactsFile, directDownload)
	} else {
		r0 = ret.Get(0).(DownloadState)
	}
	return r0
}

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

// DownloadArtifacts is a helper method to define mock.On call
//   - config JobCredentials
//   - artifactsFile io.WriteCloser
//   - directDownload *bool
func (_e *MockNetwork_Expecter) DownloadArtifacts(config interface{}, artifactsFile interface{}, directDownload interface{}) *MockNetwork_DownloadArtifacts_Call {
	return &MockNetwork_DownloadArtifacts_Call{Call: _e.mock.On("DownloadArtifacts", config, artifactsFile, directDownload)}
}

func (_c *MockNetwork_DownloadArtifacts_Call) Run(run func(config JobCredentials, artifactsFile io.WriteCloser, directDownload *bool)) *MockNetwork_DownloadArtifacts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 JobCredentials
		if args[0] != nil {
			arg0 = args[0].(JobCredentials)
		}
		var arg1 io.WriteCloser
		if args[1] != nil {
			arg1 = args[1].(io.WriteCloser)
		}
		var arg2 *bool
		if args[2] != nil {
			arg2 = args[2].(*bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockNetwork_DownloadArtifacts_Call) Return(downloadState DownloadState) *MockNetwork_DownloadArtifacts_Call {
	_c.Call.Return(downloadState)
	return _c
}

func (_c *MockNetwork_DownloadArtifacts_Call) RunAndReturn(run func(config JobCredentials, artifactsFile io.WriteCloser, directDownload *bool) DownloadState) *MockNetwork_DownloadArtifacts_Call {
	_c.Call.Return(run)
	return _c
}

// PatchTrace provides a mock function for the type MockNetwork
func (_mock *MockNetwork) PatchTrace(config RunnerConfig, jobCredentials *JobCredentials, content []byte, startOffset int, debugModeEnabled bool) PatchTraceResult {
	ret := _mock.Called(config, jobCredentials, content, startOffset, debugModeEnabled)

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

	var r0 PatchTraceResult
	if returnFunc, ok := ret.Get(0).(func(RunnerConfig, *JobCredentials, []byte, int, bool) PatchTraceResult); ok {
		r0 = returnFunc(config, jobCredentials, content, startOffset, debugModeEnabled)
	} else {
		r0 = ret.Get(0).(PatchTraceResult)
	}
	return r0
}

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

// PatchTrace is a helper method to define mock.On call
//   - config RunnerConfig
//   - jobCredentials *JobCredentials
//   - content []byte
//   - startOffset int
//   - debugModeEnabled bool
func (_e *MockNetwork_Expecter) PatchTrace(config interface{}, jobCredentials interface{}, content interface{}, startOffset interface{}, debugModeEnabled interface{}) *MockNetwork_PatchTrace_Call {
	return &MockNetwork_PatchTrace_Call{Call: _e.mock.On("PatchTrace", config, jobCredentials, content, startOffset, debugModeEnabled)}
}

func (_c *MockNetwork_PatchTrace_Call) Run(run func(config RunnerConfig, jobCredentials *JobCredentials, content []byte, startOffset int, debugModeEnabled bool)) *MockNetwork_PatchTrace_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 RunnerConfig
		if args[0] != nil {
			arg0 = args[0].(RunnerConfig)
		}
		var arg1 *JobCredentials
		if args[1] != nil {
			arg1 = args[1].(*JobCredentials)
		}
		var arg2 []byte
		if args[2] != nil {
			arg2 = args[2].([]byte)
		}
		var arg3 int
		if args[3] != nil {
			arg3 = args[3].(int)
		}
		var arg4 bool
		if args[4] != nil {
			arg4 = args[4].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MockNetwork_PatchTrace_Call) Return(patchTraceResult PatchTraceResult) *MockNetwork_PatchTrace_Call {
	_c.Call.Return(patchTraceResult)
	return _c
}

func (_c *MockNetwork_PatchTrace_Call) RunAndReturn(run func(config RunnerConfig, jobCredentials *JobCredentials, content []byte, startOffset int, debugModeEnabled bool) PatchTraceResult) *MockNetwork_PatchTrace_Call {
	_c.Call.Return(run)
	return _c
}

// ProcessJob provides a mock function for the type MockNetwork
func (_mock *MockNetwork) ProcessJob(config RunnerConfig, buildCredentials *JobCredentials) (JobTrace, error) {
	ret := _mock.Called(config, buildCredentials)

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

	var r0 JobTrace
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(RunnerConfig, *JobCredentials) (JobTrace, error)); ok {
		return returnFunc(config, buildCredentials)
	}
	if returnFunc, ok := ret.Get(0).(func(RunnerConfig, *JobCredentials) JobTrace); ok {
		r0 = returnFunc(config, buildCredentials)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(JobTrace)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(RunnerConfig, *JobCredentials) error); ok {
		r1 = returnFunc(config, buildCredentials)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProcessJob is a helper method to define mock.On call
//   - config RunnerConfig
//   - buildCredentials *JobCredentials
func (_e *MockNetwork_Expecter) ProcessJob(config interface{}, buildCredentials interface{}) *MockNetwork_ProcessJob_Call {
	return &MockNetwork_ProcessJob_Call{Call: _e.mock.On("ProcessJob", config, buildCredentials)}
}

func (_c *MockNetwork_ProcessJob_Call) Run(run func(config RunnerConfig, buildCredentials *JobCredentials)) *MockNetwork_ProcessJob_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 RunnerConfig
		if args[0] != nil {
			arg0 = args[0].(RunnerConfig)
		}
		var arg1 *JobCredentials
		if args[1] != nil {
			arg1 = args[1].(*JobCredentials)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockNetwork_ProcessJob_Call) Return(jobTrace JobTrace, err error) *MockNetwork_ProcessJob_Call {
	_c.Call.Return(jobTrace, err)
	return _c
}

func (_c *MockNetwork_ProcessJob_Call) RunAndReturn(run func(config RunnerConfig, buildCredentials *JobCredentials) (JobTrace, error)) *MockNetwork_ProcessJob_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterRunner provides a mock function for the type MockNetwork
func (_mock *MockNetwork) RegisterRunner(config RunnerCredentials, parameters RegisterRunnerParameters) *RegisterRunnerResponse {
	ret := _mock.Called(config, parameters)

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

	var r0 *RegisterRunnerResponse
	if returnFunc, ok := ret.Get(0).(func(RunnerCredentials, RegisterRunnerParameters) *RegisterRunnerResponse); ok {
		r0 = returnFunc(config, parameters)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*RegisterRunnerResponse)
		}
	}
	return r0
}

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

// RegisterRunner is a helper method to define mock.On call
//   - config RunnerCredentials
//   - parameters RegisterRunnerParameters
func (_e *MockNetwork_Expecter) RegisterRunner(config interface{}, parameters interface{}) *MockNetwork_RegisterRunner_Call {
	return &MockNetwork_RegisterRunner_Call{Call: _e.mock.On("RegisterRunner", config, parameters)}
}

func (_c *MockNetwork_RegisterRunner_Call) Run(run func(config RunnerCredentials, parameters RegisterRunnerParameters)) *MockNetwork_RegisterRunner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 RunnerCredentials
		if args[0] != nil {
			arg0 = args[0].(RunnerCredentials)
		}
		var arg1 RegisterRunnerParameters
		if args[1] != nil {
			arg1 = args[1].(RegisterRunnerParameters)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockNetwork_RegisterRunner_Call) Return(registerRunnerResponse *RegisterRunnerResponse) *MockNetwork_RegisterRunner_Call {
	_c.Call.Return(registerRunnerResponse)
	return _c
}

func (_c *MockNetwork_RegisterRunner_Call) RunAndReturn(run func(config RunnerCredentials, parameters RegisterRunnerParameters) *RegisterRunnerResponse) *MockNetwork_RegisterRunner_Call {
	_c.Call.Return(run)
	return _c
}

// RequestJob provides a mock function for the type MockNetwork
func (_mock *MockNetwork) RequestJob(ctx context.Context, config RunnerConfig, sessionInfo *SessionInfo) (*JobResponse, bool) {
	ret := _mock.Called(ctx, config, sessionInfo)

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

	var r0 *JobResponse
	var r1 bool
	if returnFunc, ok := ret.Get(0).(func(context.Context, RunnerConfig, *SessionInfo) (*JobResponse, bool)); ok {
		return returnFunc(ctx, config, sessionInfo)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, RunnerConfig, *SessionInfo) *JobResponse); ok {
		r0 = returnFunc(ctx, config, sessionInfo)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*JobResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, RunnerConfig, *SessionInfo) bool); ok {
		r1 = returnFunc(ctx, config, sessionInfo)
	} else {
		r1 = ret.Get(1).(bool)
	}
	return r0, r1
}

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

// RequestJob is a helper method to define mock.On call
//   - ctx context.Context
//   - config RunnerConfig
//   - sessionInfo *SessionInfo
func (_e *MockNetwork_Expecter) RequestJob(ctx interface{}, config interface{}, sessionInfo interface{}) *MockNetwork_RequestJob_Call {
	return &MockNetwork_RequestJob_Call{Call: _e.mock.On("RequestJob", ctx, config, sessionInfo)}
}

func (_c *MockNetwork_RequestJob_Call) Run(run func(ctx context.Context, config RunnerConfig, sessionInfo *SessionInfo)) *MockNetwork_RequestJob_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 RunnerConfig
		if args[1] != nil {
			arg1 = args[1].(RunnerConfig)
		}
		var arg2 *SessionInfo
		if args[2] != nil {
			arg2 = args[2].(*SessionInfo)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockNetwork_RequestJob_Call) Return(jobResponse *JobResponse, b bool) *MockNetwork_RequestJob_Call {
	_c.Call.Return(jobResponse, b)
	return _c
}

func (_c *MockNetwork_RequestJob_Call) RunAndReturn(run func(ctx context.Context, config RunnerConfig, sessionInfo *SessionInfo) (*JobResponse, bool)) *MockNetwork_RequestJob_Call {
	_c.Call.Return(run)
	return _c
}

// ResetToken provides a mock function for the type MockNetwork
func (_mock *MockNetwork) ResetToken(runner RunnerCredentials, systemID string) *ResetTokenResponse {
	ret := _mock.Called(runner, systemID)

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

	var r0 *ResetTokenResponse
	if returnFunc, ok := ret.Get(0).(func(RunnerCredentials, string) *ResetTokenResponse); ok {
		r0 = returnFunc(runner, systemID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ResetTokenResponse)
		}
	}
	return r0
}

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

// ResetToken is a helper method to define mock.On call
//   - runner RunnerCredentials
//   - systemID string
func (_e *MockNetwork_Expecter) ResetToken(runner interface{}, systemID interface{}) *MockNetwork_ResetToken_Call {
	return &MockNetwork_ResetToken_Call{Call: _e.mock.On("ResetToken", runner, systemID)}
}

func (_c *MockNetwork_ResetToken_Call) Run(run func(runner RunnerCredentials, systemID string)) *MockNetwork_ResetToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 RunnerCredentials
		if args[0] != nil {
			arg0 = args[0].(RunnerCredentials)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockNetwork_ResetToken_Call) Return(resetTokenResponse *ResetTokenResponse) *MockNetwork_ResetToken_Call {
	_c.Call.Return(resetTokenResponse)
	return _c
}

func (_c *MockNetwork_ResetToken_Call) RunAndReturn(run func(runner RunnerCredentials, systemID string) *ResetTokenResponse) *MockNetwork_ResetToken_Call {
	_c.Call.Return(run)
	return _c
}

// ResetTokenWithPAT provides a mock function for the type MockNetwork
func (_mock *MockNetwork) ResetTokenWithPAT(runner RunnerCredentials, systemID string, pat string) *ResetTokenResponse {
	ret := _mock.Called(runner, systemID, pat)

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

	var r0 *ResetTokenResponse
	if returnFunc, ok := ret.Get(0).(func(RunnerCredentials, string, string) *ResetTokenResponse); ok {
		r0 = returnFunc(runner, systemID, pat)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ResetTokenResponse)
		}
	}
	return r0
}

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

// ResetTokenWithPAT is a helper method to define mock.On call
//   - runner RunnerCredentials
//   - systemID string
//   - pat string
func (_e *MockNetwork_Expecter) ResetTokenWithPAT(runner interface{}, systemID interface{}, pat interface{}) *MockNetwork_ResetTokenWithPAT_Call {
	return &MockNetwork_ResetTokenWithPAT_Call{Call: _e.mock.On("ResetTokenWithPAT", runner, systemID, pat)}
}

func (_c *MockNetwork_ResetTokenWithPAT_Call) Run(run func(runner RunnerCredentials, systemID string, pat string)) *MockNetwork_ResetTokenWithPAT_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 RunnerCredentials
		if args[0] != nil {
			arg0 = args[0].(RunnerCredentials)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockNetwork_ResetTokenWithPAT_Call) Return(resetTokenResponse *ResetTokenResponse) *MockNetwork_ResetTokenWithPAT_Call {
	_c.Call.Return(resetTokenResponse)
	return _c
}

func (_c *MockNetwork_ResetTokenWithPAT_Call) RunAndReturn(run func(runner RunnerCredentials, systemID string, pat string) *ResetTokenResponse) *MockNetwork_ResetTokenWithPAT_Call {
	_c.Call.Return(run)
	return _c
}

// SetConnectionMaxAge provides a mock function for the type MockNetwork
func (_mock *MockNetwork) SetConnectionMaxAge(duration time.Duration) {
	_mock.Called(duration)
	return
}

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

// SetConnectionMaxAge is a helper method to define mock.On call
//   - duration time.Duration
func (_e *MockNetwork_Expecter) SetConnectionMaxAge(duration interface{}) *MockNetwork_SetConnectionMaxAge_Call {
	return &MockNetwork_SetConnectionMaxAge_Call{Call: _e.mock.On("SetConnectionMaxAge", duration)}
}

func (_c *MockNetwork_SetConnectionMaxAge_Call) Run(run func(duration time.Duration)) *MockNetwork_SetConnectionMaxAge_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 time.Duration
		if args[0] != nil {
			arg0 = args[0].(time.Duration)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockNetwork_SetConnectionMaxAge_Call) RunAndReturn(run func(duration time.Duration)) *MockNetwork_SetConnectionMaxAge_Call {
	_c.Run(run)
	return _c
}

// UnregisterRunner provides a mock function for the type MockNetwork
func (_mock *MockNetwork) UnregisterRunner(config RunnerCredentials) bool {
	ret := _mock.Called(config)

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

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

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

// UnregisterRunner is a helper method to define mock.On call
//   - config RunnerCredentials
func (_e *MockNetwork_Expecter) UnregisterRunner(config interface{}) *MockNetwork_UnregisterRunner_Call {
	return &MockNetwork_UnregisterRunner_Call{Call: _e.mock.On("UnregisterRunner", config)}
}

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

func (_c *MockNetwork_UnregisterRunner_Call) Return(b bool) *MockNetwork_UnregisterRunner_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockNetwork_UnregisterRunner_Call) RunAndReturn(run func(config RunnerCredentials) bool) *MockNetwork_UnregisterRunner_Call {
	_c.Call.Return(run)
	return _c
}

// UnregisterRunnerManager provides a mock function for the type MockNetwork
func (_mock *MockNetwork) UnregisterRunnerManager(config RunnerCredentials, systemID string) bool {
	ret := _mock.Called(config, systemID)

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

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(RunnerCredentials, string) bool); ok {
		r0 = returnFunc(config, systemID)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

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

// UnregisterRunnerManager is a helper method to define mock.On call
//   - config RunnerCredentials
//   - systemID string
func (_e *MockNetwork_Expecter) UnregisterRunnerManager(config interface{}, systemID interface{}) *MockNetwork_UnregisterRunnerManager_Call {
	return &MockNetwork_UnregisterRunnerManager_Call{Call: _e.mock.On("UnregisterRunnerManager", config, systemID)}
}

func (_c *MockNetwork_UnregisterRunnerManager_Call) Run(run func(config RunnerCredentials, systemID string)) *MockNetwork_UnregisterRunnerManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 RunnerCredentials
		if args[0] != nil {
			arg0 = args[0].(RunnerCredentials)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockNetwork_UnregisterRunnerManager_Call) Return(b bool) *MockNetwork_UnregisterRunnerManager_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockNetwork_UnregisterRunnerManager_Call) RunAndReturn(run func(config RunnerCredentials, systemID string) bool) *MockNetwork_UnregisterRunnerManager_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateJob provides a mock function for the type MockNetwork
func (_mock *MockNetwork) UpdateJob(config RunnerConfig, jobCredentials *JobCredentials, jobInfo UpdateJobInfo) UpdateJobResult {
	ret := _mock.Called(config, jobCredentials, jobInfo)

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

	var r0 UpdateJobResult
	if returnFunc, ok := ret.Get(0).(func(RunnerConfig, *JobCredentials, UpdateJobInfo) UpdateJobResult); ok {
		r0 = returnFunc(config, jobCredentials, jobInfo)
	} else {
		r0 = ret.Get(0).(UpdateJobResult)
	}
	return r0
}

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

// UpdateJob is a helper method to define mock.On call
//   - config RunnerConfig
//   - jobCredentials *JobCredentials
//   - jobInfo UpdateJobInfo
func (_e *MockNetwork_Expecter) UpdateJob(config interface{}, jobCredentials interface{}, jobInfo interface{}) *MockNetwork_UpdateJob_Call {
	return &MockNetwork_UpdateJob_Call{Call: _e.mock.On("UpdateJob", config, jobCredentials, jobInfo)}
}

func (_c *MockNetwork_UpdateJob_Call) Run(run func(config RunnerConfig, jobCredentials *JobCredentials, jobInfo UpdateJobInfo)) *MockNetwork_UpdateJob_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 RunnerConfig
		if args[0] != nil {
			arg0 = args[0].(RunnerConfig)
		}
		var arg1 *JobCredentials
		if args[1] != nil {
			arg1 = args[1].(*JobCredentials)
		}
		var arg2 UpdateJobInfo
		if args[2] != nil {
			arg2 = args[2].(UpdateJobInfo)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockNetwork_UpdateJob_Call) Return(updateJobResult UpdateJobResult) *MockNetwork_UpdateJob_Call {
	_c.Call.Return(updateJobResult)
	return _c
}

func (_c *MockNetwork_UpdateJob_Call) RunAndReturn(run func(config RunnerConfig, jobCredentials *JobCredentials, jobInfo UpdateJobInfo) UpdateJobResult) *MockNetwork_UpdateJob_Call {
	_c.Call.Return(run)
	return _c
}

// UploadRawArtifacts provides a mock function for the type MockNetwork
func (_mock *MockNetwork) UploadRawArtifacts(config JobCredentials, bodyProvider ContentProvider, options ArtifactsOptions) (UploadState, string) {
	ret := _mock.Called(config, bodyProvider, options)

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

	var r0 UploadState
	var r1 string
	if returnFunc, ok := ret.Get(0).(func(JobCredentials, ContentProvider, ArtifactsOptions) (UploadState, string)); ok {
		return returnFunc(config, bodyProvider, options)
	}
	if returnFunc, ok := ret.Get(0).(func(JobCredentials, ContentProvider, ArtifactsOptions) UploadState); ok {
		r0 = returnFunc(config, bodyProvider, options)
	} else {
		r0 = ret.Get(0).(UploadState)
	}
	if returnFunc, ok := ret.Get(1).(func(JobCredentials, ContentProvider, ArtifactsOptions) string); ok {
		r1 = returnFunc(config, bodyProvider, options)
	} else {
		r1 = ret.Get(1).(string)
	}
	return r0, r1
}

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

// UploadRawArtifacts is a helper method to define mock.On call
//   - config JobCredentials
//   - bodyProvider ContentProvider
//   - options ArtifactsOptions
func (_e *MockNetwork_Expecter) UploadRawArtifacts(config interface{}, bodyProvider interface{}, options interface{}) *MockNetwork_UploadRawArtifacts_Call {
	return &MockNetwork_UploadRawArtifacts_Call{Call: _e.mock.On("UploadRawArtifacts", config, bodyProvider, options)}
}

func (_c *MockNetwork_UploadRawArtifacts_Call) Run(run func(config JobCredentials, bodyProvider ContentProvider, options ArtifactsOptions)) *MockNetwork_UploadRawArtifacts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 JobCredentials
		if args[0] != nil {
			arg0 = args[0].(JobCredentials)
		}
		var arg1 ContentProvider
		if args[1] != nil {
			arg1 = args[1].(ContentProvider)
		}
		var arg2 ArtifactsOptions
		if args[2] != nil {
			arg2 = args[2].(ArtifactsOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockNetwork_UploadRawArtifacts_Call) Return(uploadState UploadState, s string) *MockNetwork_UploadRawArtifacts_Call {
	_c.Call.Return(uploadState, s)
	return _c
}

func (_c *MockNetwork_UploadRawArtifacts_Call) RunAndReturn(run func(config JobCredentials, bodyProvider ContentProvider, options ArtifactsOptions) (UploadState, string)) *MockNetwork_UploadRawArtifacts_Call {
	_c.Call.Return(run)
	return _c
}

// VerifyRunner provides a mock function for the type MockNetwork
func (_mock *MockNetwork) VerifyRunner(config RunnerCredentials, systemID string) *VerifyRunnerResponse {
	ret := _mock.Called(config, systemID)

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

	var r0 *VerifyRunnerResponse
	if returnFunc, ok := ret.Get(0).(func(RunnerCredentials, string) *VerifyRunnerResponse); ok {
		r0 = returnFunc(config, systemID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*VerifyRunnerResponse)
		}
	}
	return r0
}

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

// VerifyRunner is a helper method to define mock.On call
//   - config RunnerCredentials
//   - systemID string
func (_e *MockNetwork_Expecter) VerifyRunner(config interface{}, systemID interface{}) *MockNetwork_VerifyRunner_Call {
	return &MockNetwork_VerifyRunner_Call{Call: _e.mock.On("VerifyRunner", config, systemID)}
}

func (_c *MockNetwork_VerifyRunner_Call) Run(run func(config RunnerCredentials, systemID string)) *MockNetwork_VerifyRunner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 RunnerCredentials
		if args[0] != nil {
			arg0 = args[0].(RunnerCredentials)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockNetwork_VerifyRunner_Call) Return(verifyRunnerResponse *VerifyRunnerResponse) *MockNetwork_VerifyRunner_Call {
	_c.Call.Return(verifyRunnerResponse)
	return _c
}

func (_c *MockNetwork_VerifyRunner_Call) RunAndReturn(run func(config RunnerCredentials, systemID string) *VerifyRunnerResponse) *MockNetwork_VerifyRunner_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}
}

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

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

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

func (_c *mockLogger_Println_Call) Run(run func(args ...interface{})) *mockLogger_Println_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_Println_Call) Return() *mockLogger_Println_Call {
	_c.Call.Return()
	return _c
}

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

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

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

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

func (_c *mockLogger_Warningln_Call) Run(run func(args ...interface{})) *mockLogger_Warningln_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_Warningln_Call) Return() *mockLogger_Warningln_Call {
	_c.Call.Return()
	return _c
}

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

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

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

	return mock
}

// MockSecretsResolver is an autogenerated mock type for the SecretsResolver type
type MockSecretsResolver struct {
	mock.Mock
}

type MockSecretsResolver_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSecretsResolver) EXPECT() *MockSecretsResolver_Expecter {
	return &MockSecretsResolver_Expecter{mock: &_m.Mock}
}

// Resolve provides a mock function for the type MockSecretsResolver
func (_mock *MockSecretsResolver) Resolve(secrets Secrets) (JobVariables, error) {
	ret := _mock.Called(secrets)

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

	var r0 JobVariables
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(Secrets) (JobVariables, error)); ok {
		return returnFunc(secrets)
	}
	if returnFunc, ok := ret.Get(0).(func(Secrets) JobVariables); ok {
		r0 = returnFunc(secrets)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(JobVariables)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(Secrets) error); ok {
		r1 = returnFunc(secrets)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Resolve is a helper method to define mock.On call
//   - secrets Secrets
func (_e *MockSecretsResolver_Expecter) Resolve(secrets interface{}) *MockSecretsResolver_Resolve_Call {
	return &MockSecretsResolver_Resolve_Call{Call: _e.mock.On("Resolve", secrets)}
}

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

func (_c *MockSecretsResolver_Resolve_Call) Return(jobVariables JobVariables, err error) *MockSecretsResolver_Resolve_Call {
	_c.Call.Return(jobVariables, err)
	return _c
}

func (_c *MockSecretsResolver_Resolve_Call) RunAndReturn(run func(secrets Secrets) (JobVariables, error)) *MockSecretsResolver_Resolve_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockSecretResolverRegistry is an autogenerated mock type for the SecretResolverRegistry type
type MockSecretResolverRegistry struct {
	mock.Mock
}

type MockSecretResolverRegistry_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSecretResolverRegistry) EXPECT() *MockSecretResolverRegistry_Expecter {
	return &MockSecretResolverRegistry_Expecter{mock: &_m.Mock}
}

// GetFor provides a mock function for the type MockSecretResolverRegistry
func (_mock *MockSecretResolverRegistry) GetFor(secret Secret) (SecretResolver, error) {
	ret := _mock.Called(secret)

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

	var r0 SecretResolver
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(Secret) (SecretResolver, error)); ok {
		return returnFunc(secret)
	}
	if returnFunc, ok := ret.Get(0).(func(Secret) SecretResolver); ok {
		r0 = returnFunc(secret)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(SecretResolver)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(Secret) error); ok {
		r1 = returnFunc(secret)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetFor is a helper method to define mock.On call
//   - secret Secret
func (_e *MockSecretResolverRegistry_Expecter) GetFor(secret interface{}) *MockSecretResolverRegistry_GetFor_Call {
	return &MockSecretResolverRegistry_GetFor_Call{Call: _e.mock.On("GetFor", secret)}
}

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

func (_c *MockSecretResolverRegistry_GetFor_Call) Return(secretResolver SecretResolver, err error) *MockSecretResolverRegistry_GetFor_Call {
	_c.Call.Return(secretResolver, err)
	return _c
}

func (_c *MockSecretResolverRegistry_GetFor_Call) RunAndReturn(run func(secret Secret) (SecretResolver, error)) *MockSecretResolverRegistry_GetFor_Call {
	_c.Call.Return(run)
	return _c
}

// Register provides a mock function for the type MockSecretResolverRegistry
func (_mock *MockSecretResolverRegistry) Register(f secretResolverFactory) {
	_mock.Called(f)
	return
}

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

// Register is a helper method to define mock.On call
//   - f secretResolverFactory
func (_e *MockSecretResolverRegistry_Expecter) Register(f interface{}) *MockSecretResolverRegistry_Register_Call {
	return &MockSecretResolverRegistry_Register_Call{Call: _e.mock.On("Register", f)}
}

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

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

func (_c *MockSecretResolverRegistry_Register_Call) RunAndReturn(run func(f secretResolverFactory)) *MockSecretResolverRegistry_Register_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockSecretResolver is an autogenerated mock type for the SecretResolver type
type MockSecretResolver struct {
	mock.Mock
}

type MockSecretResolver_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSecretResolver) EXPECT() *MockSecretResolver_Expecter {
	return &MockSecretResolver_Expecter{mock: &_m.Mock}
}

// IsSupported provides a mock function for the type MockSecretResolver
func (_mock *MockSecretResolver) IsSupported() bool {
	ret := _mock.Called()

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

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

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

// IsSupported is a helper method to define mock.On call
func (_e *MockSecretResolver_Expecter) IsSupported() *MockSecretResolver_IsSupported_Call {
	return &MockSecretResolver_IsSupported_Call{Call: _e.mock.On("IsSupported")}
}

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

func (_c *MockSecretResolver_IsSupported_Call) Return(b bool) *MockSecretResolver_IsSupported_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockSecretResolver_IsSupported_Call) RunAndReturn(run func() bool) *MockSecretResolver_IsSupported_Call {
	_c.Call.Return(run)
	return _c
}

// Name provides a mock function for the type MockSecretResolver
func (_mock *MockSecretResolver) Name() string {
	ret := _mock.Called()

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

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

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

// Name is a helper method to define mock.On call
func (_e *MockSecretResolver_Expecter) Name() *MockSecretResolver_Name_Call {
	return &MockSecretResolver_Name_Call{Call: _e.mock.On("Name")}
}

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

func (_c *MockSecretResolver_Name_Call) Return(s string) *MockSecretResolver_Name_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockSecretResolver_Name_Call) RunAndReturn(run func() string) *MockSecretResolver_Name_Call {
	_c.Call.Return(run)
	return _c
}

// Resolve provides a mock function for the type MockSecretResolver
func (_mock *MockSecretResolver) Resolve() (string, error) {
	ret := _mock.Called()

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

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

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

// Resolve is a helper method to define mock.On call
func (_e *MockSecretResolver_Expecter) Resolve() *MockSecretResolver_Resolve_Call {
	return &MockSecretResolver_Resolve_Call{Call: _e.mock.On("Resolve")}
}

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

func (_c *MockSecretResolver_Resolve_Call) Return(s string, err error) *MockSecretResolver_Resolve_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockSecretResolver_Resolve_Call) RunAndReturn(run func() (string, error)) *MockSecretResolver_Resolve_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockShell is an autogenerated mock type for the Shell type
type MockShell struct {
	mock.Mock
}

type MockShell_Expecter struct {
	mock *mock.Mock
}

func (_m *MockShell) EXPECT() *MockShell_Expecter {
	return &MockShell_Expecter{mock: &_m.Mock}
}

// GenerateSaveScript provides a mock function for the type MockShell
func (_mock *MockShell) GenerateSaveScript(info ShellScriptInfo, scriptPath string, script string) (string, error) {
	ret := _mock.Called(info, scriptPath, script)

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

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(ShellScriptInfo, string, string) (string, error)); ok {
		return returnFunc(info, scriptPath, script)
	}
	if returnFunc, ok := ret.Get(0).(func(ShellScriptInfo, string, string) string); ok {
		r0 = returnFunc(info, scriptPath, script)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(ShellScriptInfo, string, string) error); ok {
		r1 = returnFunc(info, scriptPath, script)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GenerateSaveScript is a helper method to define mock.On call
//   - info ShellScriptInfo
//   - scriptPath string
//   - script string
func (_e *MockShell_Expecter) GenerateSaveScript(info interface{}, scriptPath interface{}, script interface{}) *MockShell_GenerateSaveScript_Call {
	return &MockShell_GenerateSaveScript_Call{Call: _e.mock.On("GenerateSaveScript", info, scriptPath, script)}
}

func (_c *MockShell_GenerateSaveScript_Call) Run(run func(info ShellScriptInfo, scriptPath string, script string)) *MockShell_GenerateSaveScript_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ShellScriptInfo
		if args[0] != nil {
			arg0 = args[0].(ShellScriptInfo)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockShell_GenerateSaveScript_Call) Return(s string, err error) *MockShell_GenerateSaveScript_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockShell_GenerateSaveScript_Call) RunAndReturn(run func(info ShellScriptInfo, scriptPath string, script string) (string, error)) *MockShell_GenerateSaveScript_Call {
	_c.Call.Return(run)
	return _c
}

// GenerateScript provides a mock function for the type MockShell
func (_mock *MockShell) GenerateScript(ctx context.Context, buildStage BuildStage, info ShellScriptInfo) (string, error) {
	ret := _mock.Called(ctx, buildStage, info)

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

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, BuildStage, ShellScriptInfo) (string, error)); ok {
		return returnFunc(ctx, buildStage, info)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, BuildStage, ShellScriptInfo) string); ok {
		r0 = returnFunc(ctx, buildStage, info)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, BuildStage, ShellScriptInfo) error); ok {
		r1 = returnFunc(ctx, buildStage, info)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GenerateScript is a helper method to define mock.On call
//   - ctx context.Context
//   - buildStage BuildStage
//   - info ShellScriptInfo
func (_e *MockShell_Expecter) GenerateScript(ctx interface{}, buildStage interface{}, info interface{}) *MockShell_GenerateScript_Call {
	return &MockShell_GenerateScript_Call{Call: _e.mock.On("GenerateScript", ctx, buildStage, info)}
}

func (_c *MockShell_GenerateScript_Call) Run(run func(ctx context.Context, buildStage BuildStage, info ShellScriptInfo)) *MockShell_GenerateScript_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 BuildStage
		if args[1] != nil {
			arg1 = args[1].(BuildStage)
		}
		var arg2 ShellScriptInfo
		if args[2] != nil {
			arg2 = args[2].(ShellScriptInfo)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockShell_GenerateScript_Call) Return(s string, err error) *MockShell_GenerateScript_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockShell_GenerateScript_Call) RunAndReturn(run func(ctx context.Context, buildStage BuildStage, info ShellScriptInfo) (string, error)) *MockShell_GenerateScript_Call {
	_c.Call.Return(run)
	return _c
}

// GetConfiguration provides a mock function for the type MockShell
func (_mock *MockShell) GetConfiguration(info ShellScriptInfo) (*ShellConfiguration, error) {
	ret := _mock.Called(info)

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

	var r0 *ShellConfiguration
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(ShellScriptInfo) (*ShellConfiguration, error)); ok {
		return returnFunc(info)
	}
	if returnFunc, ok := ret.Get(0).(func(ShellScriptInfo) *ShellConfiguration); ok {
		r0 = returnFunc(info)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ShellConfiguration)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(ShellScriptInfo) error); ok {
		r1 = returnFunc(info)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetConfiguration is a helper method to define mock.On call
//   - info ShellScriptInfo
func (_e *MockShell_Expecter) GetConfiguration(info interface{}) *MockShell_GetConfiguration_Call {
	return &MockShell_GetConfiguration_Call{Call: _e.mock.On("GetConfiguration", info)}
}

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

func (_c *MockShell_GetConfiguration_Call) Return(shellConfiguration *ShellConfiguration, err error) *MockShell_GetConfiguration_Call {
	_c.Call.Return(shellConfiguration, err)
	return _c
}

func (_c *MockShell_GetConfiguration_Call) RunAndReturn(run func(info ShellScriptInfo) (*ShellConfiguration, error)) *MockShell_GetConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// GetEntrypointCommand provides a mock function for the type MockShell
func (_mock *MockShell) GetEntrypointCommand(info ShellScriptInfo, probeFile string) []string {
	ret := _mock.Called(info, probeFile)

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

	var r0 []string
	if returnFunc, ok := ret.Get(0).(func(ShellScriptInfo, string) []string); ok {
		r0 = returnFunc(info, probeFile)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	return r0
}

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

// GetEntrypointCommand is a helper method to define mock.On call
//   - info ShellScriptInfo
//   - probeFile string
func (_e *MockShell_Expecter) GetEntrypointCommand(info interface{}, probeFile interface{}) *MockShell_GetEntrypointCommand_Call {
	return &MockShell_GetEntrypointCommand_Call{Call: _e.mock.On("GetEntrypointCommand", info, probeFile)}
}

func (_c *MockShell_GetEntrypointCommand_Call) Run(run func(info ShellScriptInfo, probeFile string)) *MockShell_GetEntrypointCommand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ShellScriptInfo
		if args[0] != nil {
			arg0 = args[0].(ShellScriptInfo)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockShell_GetEntrypointCommand_Call) Return(strings []string) *MockShell_GetEntrypointCommand_Call {
	_c.Call.Return(strings)
	return _c
}

func (_c *MockShell_GetEntrypointCommand_Call) RunAndReturn(run func(info ShellScriptInfo, probeFile string) []string) *MockShell_GetEntrypointCommand_Call {
	_c.Call.Return(run)
	return _c
}

// GetFeatures provides a mock function for the type MockShell
func (_mock *MockShell) GetFeatures(features *FeaturesInfo) {
	_mock.Called(features)
	return
}

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

// GetFeatures is a helper method to define mock.On call
//   - features *FeaturesInfo
func (_e *MockShell_Expecter) GetFeatures(features interface{}) *MockShell_GetFeatures_Call {
	return &MockShell_GetFeatures_Call{Call: _e.mock.On("GetFeatures", features)}
}

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

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

func (_c *MockShell_GetFeatures_Call) RunAndReturn(run func(features *FeaturesInfo)) *MockShell_GetFeatures_Call {
	_c.Run(run)
	return _c
}

// GetName provides a mock function for the type MockShell
func (_mock *MockShell) GetName() string {
	ret := _mock.Called()

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

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

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

// GetName is a helper method to define mock.On call
func (_e *MockShell_Expecter) GetName() *MockShell_GetName_Call {
	return &MockShell_GetName_Call{Call: _e.mock.On("GetName")}
}

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

func (_c *MockShell_GetName_Call) Return(s string) *MockShell_GetName_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockShell_GetName_Call) RunAndReturn(run func() string) *MockShell_GetName_Call {
	_c.Call.Return(run)
	return _c
}

// IsDefault provides a mock function for the type MockShell
func (_mock *MockShell) IsDefault() bool {
	ret := _mock.Called()

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

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

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

// IsDefault is a helper method to define mock.On call
func (_e *MockShell_Expecter) IsDefault() *MockShell_IsDefault_Call {
	return &MockShell_IsDefault_Call{Call: _e.mock.On("IsDefault")}
}

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

func (_c *MockShell_IsDefault_Call) Return(b bool) *MockShell_IsDefault_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockShell_IsDefault_Call) RunAndReturn(run func() bool) *MockShell_IsDefault_Call {
	_c.Call.Return(run)
	return _c
}
