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

package container

import (
	"context"
	"io"
	"time"

	"code.forgejo.org/forgejo/runner/v12/act/common"

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

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

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

	return mock
}

// MockContainer is an autogenerated mock type for the Container type
type MockContainer struct {
	mock.Mock
}

type MockContainer_Expecter struct {
	mock *mock.Mock
}

func (_m *MockContainer) EXPECT() *MockContainer_Expecter {
	return &MockContainer_Expecter{mock: &_m.Mock}
}

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

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

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

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

// Close is a helper method to define mock.On call
func (_e *MockContainer_Expecter) Close() *MockContainer_Close_Call {
	return &MockContainer_Close_Call{Call: _e.mock.On("Close")}
}

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

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

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

// Copy provides a mock function for the type MockContainer
func (_mock *MockContainer) Copy(destPath string, files ...*FileEntry) common.Executor {
	var tmpRet mock.Arguments
	if len(files) > 0 {
		tmpRet = _mock.Called(destPath, files)
	} else {
		tmpRet = _mock.Called(destPath)
	}
	ret := tmpRet

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

	var r0 common.Executor
	if returnFunc, ok := ret.Get(0).(func(string, ...*FileEntry) common.Executor); ok {
		r0 = returnFunc(destPath, files...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Executor)
		}
	}
	return r0
}

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

// Copy is a helper method to define mock.On call
//   - destPath string
//   - files ...*FileEntry
func (_e *MockContainer_Expecter) Copy(destPath interface{}, files ...interface{}) *MockContainer_Copy_Call {
	return &MockContainer_Copy_Call{Call: _e.mock.On("Copy",
		append([]interface{}{destPath}, files...)...)}
}

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

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

func (_c *MockContainer_Copy_Call) RunAndReturn(run func(destPath string, files ...*FileEntry) common.Executor) *MockContainer_Copy_Call {
	_c.Call.Return(run)
	return _c
}

// CopyDir provides a mock function for the type MockContainer
func (_mock *MockContainer) CopyDir(destPath string, srcPath string, useGitIgnore bool) common.Executor {
	ret := _mock.Called(destPath, srcPath, useGitIgnore)

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

	var r0 common.Executor
	if returnFunc, ok := ret.Get(0).(func(string, string, bool) common.Executor); ok {
		r0 = returnFunc(destPath, srcPath, useGitIgnore)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Executor)
		}
	}
	return r0
}

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

// CopyDir is a helper method to define mock.On call
//   - destPath string
//   - srcPath string
//   - useGitIgnore bool
func (_e *MockContainer_Expecter) CopyDir(destPath interface{}, srcPath interface{}, useGitIgnore interface{}) *MockContainer_CopyDir_Call {
	return &MockContainer_CopyDir_Call{Call: _e.mock.On("CopyDir", destPath, srcPath, useGitIgnore)}
}

func (_c *MockContainer_CopyDir_Call) Run(run func(destPath string, srcPath string, useGitIgnore bool)) *MockContainer_CopyDir_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockContainer_CopyDir_Call) RunAndReturn(run func(destPath string, srcPath string, useGitIgnore bool) common.Executor) *MockContainer_CopyDir_Call {
	_c.Call.Return(run)
	return _c
}

// CopyTarStream provides a mock function for the type MockContainer
func (_mock *MockContainer) CopyTarStream(ctx context.Context, destPath string, tarStream io.Reader) error {
	ret := _mock.Called(ctx, destPath, tarStream)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, io.Reader) error); ok {
		r0 = returnFunc(ctx, destPath, tarStream)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CopyTarStream is a helper method to define mock.On call
//   - ctx context.Context
//   - destPath string
//   - tarStream io.Reader
func (_e *MockContainer_Expecter) CopyTarStream(ctx interface{}, destPath interface{}, tarStream interface{}) *MockContainer_CopyTarStream_Call {
	return &MockContainer_CopyTarStream_Call{Call: _e.mock.On("CopyTarStream", ctx, destPath, tarStream)}
}

func (_c *MockContainer_CopyTarStream_Call) Run(run func(ctx context.Context, destPath string, tarStream io.Reader)) *MockContainer_CopyTarStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 io.Reader
		if args[2] != nil {
			arg2 = args[2].(io.Reader)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockContainer_CopyTarStream_Call) RunAndReturn(run func(ctx context.Context, destPath string, tarStream io.Reader) error) *MockContainer_CopyTarStream_Call {
	_c.Call.Return(run)
	return _c
}

// Create provides a mock function for the type MockContainer
func (_mock *MockContainer) Create(capAdd []string, capDrop []string) common.Executor {
	ret := _mock.Called(capAdd, capDrop)

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

	var r0 common.Executor
	if returnFunc, ok := ret.Get(0).(func([]string, []string) common.Executor); ok {
		r0 = returnFunc(capAdd, capDrop)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Executor)
		}
	}
	return r0
}

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

// Create is a helper method to define mock.On call
//   - capAdd []string
//   - capDrop []string
func (_e *MockContainer_Expecter) Create(capAdd interface{}, capDrop interface{}) *MockContainer_Create_Call {
	return &MockContainer_Create_Call{Call: _e.mock.On("Create", capAdd, capDrop)}
}

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

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

func (_c *MockContainer_Create_Call) RunAndReturn(run func(capAdd []string, capDrop []string) common.Executor) *MockContainer_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Exec provides a mock function for the type MockContainer
func (_mock *MockContainer) Exec(command []string, env map[string]string, user string, workdir string) common.Executor {
	ret := _mock.Called(command, env, user, workdir)

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

	var r0 common.Executor
	if returnFunc, ok := ret.Get(0).(func([]string, map[string]string, string, string) common.Executor); ok {
		r0 = returnFunc(command, env, user, workdir)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Executor)
		}
	}
	return r0
}

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

// Exec is a helper method to define mock.On call
//   - command []string
//   - env map[string]string
//   - user string
//   - workdir string
func (_e *MockContainer_Expecter) Exec(command interface{}, env interface{}, user interface{}, workdir interface{}) *MockContainer_Exec_Call {
	return &MockContainer_Exec_Call{Call: _e.mock.On("Exec", command, env, user, workdir)}
}

func (_c *MockContainer_Exec_Call) Run(run func(command []string, env map[string]string, user string, workdir string)) *MockContainer_Exec_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []string
		if args[0] != nil {
			arg0 = args[0].([]string)
		}
		var arg1 map[string]string
		if args[1] != nil {
			arg1 = args[1].(map[string]string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *MockContainer_Exec_Call) RunAndReturn(run func(command []string, env map[string]string, user string, workdir string) common.Executor) *MockContainer_Exec_Call {
	_c.Call.Return(run)
	return _c
}

// GetContainerArchive provides a mock function for the type MockContainer
func (_mock *MockContainer) GetContainerArchive(ctx context.Context, srcPath string) (io.ReadCloser, error) {
	ret := _mock.Called(ctx, srcPath)

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

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

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

// GetContainerArchive is a helper method to define mock.On call
//   - ctx context.Context
//   - srcPath string
func (_e *MockContainer_Expecter) GetContainerArchive(ctx interface{}, srcPath interface{}) *MockContainer_GetContainerArchive_Call {
	return &MockContainer_GetContainerArchive_Call{Call: _e.mock.On("GetContainerArchive", ctx, srcPath)}
}

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

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

func (_c *MockContainer_GetContainerArchive_Call) RunAndReturn(run func(ctx context.Context, srcPath string) (io.ReadCloser, error)) *MockContainer_GetContainerArchive_Call {
	_c.Call.Return(run)
	return _c
}

// IsHealthy provides a mock function for the type MockContainer
func (_mock *MockContainer) IsHealthy(ctx context.Context) (time.Duration, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockContainer_IsHealthy_Call) Run(run func(ctx context.Context)) *MockContainer_IsHealthy_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 *MockContainer_IsHealthy_Call) Return(duration time.Duration, err error) *MockContainer_IsHealthy_Call {
	_c.Call.Return(duration, err)
	return _c
}

func (_c *MockContainer_IsHealthy_Call) RunAndReturn(run func(ctx context.Context) (time.Duration, error)) *MockContainer_IsHealthy_Call {
	_c.Call.Return(run)
	return _c
}

// Pull provides a mock function for the type MockContainer
func (_mock *MockContainer) Pull(forcePull bool) common.Executor {
	ret := _mock.Called(forcePull)

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

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

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

// Pull is a helper method to define mock.On call
//   - forcePull bool
func (_e *MockContainer_Expecter) Pull(forcePull interface{}) *MockContainer_Pull_Call {
	return &MockContainer_Pull_Call{Call: _e.mock.On("Pull", forcePull)}
}

func (_c *MockContainer_Pull_Call) Run(run func(forcePull bool)) *MockContainer_Pull_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 *MockContainer_Pull_Call) Return(executor common.Executor) *MockContainer_Pull_Call {
	_c.Call.Return(executor)
	return _c
}

func (_c *MockContainer_Pull_Call) RunAndReturn(run func(forcePull bool) common.Executor) *MockContainer_Pull_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// Remove is a helper method to define mock.On call
func (_e *MockContainer_Expecter) Remove() *MockContainer_Remove_Call {
	return &MockContainer_Remove_Call{Call: _e.mock.On("Remove")}
}

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

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

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

// ReplaceLogWriter provides a mock function for the type MockContainer
func (_mock *MockContainer) ReplaceLogWriter(writer io.Writer, writer1 io.Writer) (io.Writer, io.Writer) {
	ret := _mock.Called(writer, writer1)

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

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

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

// ReplaceLogWriter is a helper method to define mock.On call
//   - writer io.Writer
//   - writer1 io.Writer
func (_e *MockContainer_Expecter) ReplaceLogWriter(writer interface{}, writer1 interface{}) *MockContainer_ReplaceLogWriter_Call {
	return &MockContainer_ReplaceLogWriter_Call{Call: _e.mock.On("ReplaceLogWriter", writer, writer1)}
}

func (_c *MockContainer_ReplaceLogWriter_Call) Run(run func(writer io.Writer, writer1 io.Writer)) *MockContainer_ReplaceLogWriter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 io.Writer
		if args[0] != nil {
			arg0 = args[0].(io.Writer)
		}
		var arg1 io.Writer
		if args[1] != nil {
			arg1 = args[1].(io.Writer)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockContainer_ReplaceLogWriter_Call) Return(writer2 io.Writer, writer3 io.Writer) *MockContainer_ReplaceLogWriter_Call {
	_c.Call.Return(writer2, writer3)
	return _c
}

func (_c *MockContainer_ReplaceLogWriter_Call) RunAndReturn(run func(writer io.Writer, writer1 io.Writer) (io.Writer, io.Writer)) *MockContainer_ReplaceLogWriter_Call {
	_c.Call.Return(run)
	return _c
}

// Start provides a mock function for the type MockContainer
func (_mock *MockContainer) Start(attach bool) common.Executor {
	ret := _mock.Called(attach)

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

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

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

// Start is a helper method to define mock.On call
//   - attach bool
func (_e *MockContainer_Expecter) Start(attach interface{}) *MockContainer_Start_Call {
	return &MockContainer_Start_Call{Call: _e.mock.On("Start", attach)}
}

func (_c *MockContainer_Start_Call) Run(run func(attach bool)) *MockContainer_Start_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 *MockContainer_Start_Call) Return(executor common.Executor) *MockContainer_Start_Call {
	_c.Call.Return(executor)
	return _c
}

func (_c *MockContainer_Start_Call) RunAndReturn(run func(attach bool) common.Executor) *MockContainer_Start_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateFromEnv provides a mock function for the type MockContainer
func (_mock *MockContainer) UpdateFromEnv(srcPath string, env *map[string]string) common.Executor {
	ret := _mock.Called(srcPath, env)

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

	var r0 common.Executor
	if returnFunc, ok := ret.Get(0).(func(string, *map[string]string) common.Executor); ok {
		r0 = returnFunc(srcPath, env)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Executor)
		}
	}
	return r0
}

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

// UpdateFromEnv is a helper method to define mock.On call
//   - srcPath string
//   - env *map[string]string
func (_e *MockContainer_Expecter) UpdateFromEnv(srcPath interface{}, env interface{}) *MockContainer_UpdateFromEnv_Call {
	return &MockContainer_UpdateFromEnv_Call{Call: _e.mock.On("UpdateFromEnv", srcPath, env)}
}

func (_c *MockContainer_UpdateFromEnv_Call) Run(run func(srcPath string, env *map[string]string)) *MockContainer_UpdateFromEnv_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 *map[string]string
		if args[1] != nil {
			arg1 = args[1].(*map[string]string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockContainer_UpdateFromEnv_Call) RunAndReturn(run func(srcPath string, env *map[string]string) common.Executor) *MockContainer_UpdateFromEnv_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateFromImageEnv provides a mock function for the type MockContainer
func (_mock *MockContainer) UpdateFromImageEnv(env *map[string]string) common.Executor {
	ret := _mock.Called(env)

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

	var r0 common.Executor
	if returnFunc, ok := ret.Get(0).(func(*map[string]string) common.Executor); ok {
		r0 = returnFunc(env)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Executor)
		}
	}
	return r0
}

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

// UpdateFromImageEnv is a helper method to define mock.On call
//   - env *map[string]string
func (_e *MockContainer_Expecter) UpdateFromImageEnv(env interface{}) *MockContainer_UpdateFromImageEnv_Call {
	return &MockContainer_UpdateFromImageEnv_Call{Call: _e.mock.On("UpdateFromImageEnv", env)}
}

func (_c *MockContainer_UpdateFromImageEnv_Call) Run(run func(env *map[string]string)) *MockContainer_UpdateFromImageEnv_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *map[string]string
		if args[0] != nil {
			arg0 = args[0].(*map[string]string)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockContainer_UpdateFromImageEnv_Call) RunAndReturn(run func(env *map[string]string) common.Executor) *MockContainer_UpdateFromImageEnv_Call {
	_c.Call.Return(run)
	return _c
}
