// Code generated by MockGen. DO NOT EDIT.
// Source: cmd.go
//
// Generated by this command:
//
//	mockgen -source=cmd.go -destination=mock_cmd_test.go -package=git -mock_names=execer=MockExecer -write_package_comment=false -typed
//

package git

import (
	exec "os/exec"
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

// MockExecer is a mock of execer interface.
type MockExecer struct {
	ctrl     *gomock.Controller
	recorder *MockExecerMockRecorder
	isgomock struct{}
}

// MockExecerMockRecorder is the mock recorder for MockExecer.
type MockExecerMockRecorder struct {
	mock *MockExecer
}

// NewMockExecer creates a new mock instance.
func NewMockExecer(ctrl *gomock.Controller) *MockExecer {
	mock := &MockExecer{ctrl: ctrl}
	mock.recorder = &MockExecerMockRecorder{mock}
	return mock
}

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

// Kill mocks base method.
func (m *MockExecer) Kill(arg0 *exec.Cmd) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Kill", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Kill indicates an expected call of Kill.
func (mr *MockExecerMockRecorder) Kill(arg0 any) *MockExecerKillCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Kill", reflect.TypeOf((*MockExecer)(nil).Kill), arg0)
	return &MockExecerKillCall{Call: call}
}

// MockExecerKillCall wrap *gomock.Call
type MockExecerKillCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExecerKillCall) Return(arg0 error) *MockExecerKillCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExecerKillCall) Do(f func(*exec.Cmd) error) *MockExecerKillCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExecerKillCall) DoAndReturn(f func(*exec.Cmd) error) *MockExecerKillCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Output mocks base method.
func (m *MockExecer) Output(arg0 *exec.Cmd) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Output", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Output indicates an expected call of Output.
func (mr *MockExecerMockRecorder) Output(arg0 any) *MockExecerOutputCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Output", reflect.TypeOf((*MockExecer)(nil).Output), arg0)
	return &MockExecerOutputCall{Call: call}
}

// MockExecerOutputCall wrap *gomock.Call
type MockExecerOutputCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExecerOutputCall) Return(arg0 []byte, arg1 error) *MockExecerOutputCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExecerOutputCall) Do(f func(*exec.Cmd) ([]byte, error)) *MockExecerOutputCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExecerOutputCall) DoAndReturn(f func(*exec.Cmd) ([]byte, error)) *MockExecerOutputCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Run mocks base method.
func (m *MockExecer) Run(arg0 *exec.Cmd) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Run", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Run indicates an expected call of Run.
func (mr *MockExecerMockRecorder) Run(arg0 any) *MockExecerRunCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockExecer)(nil).Run), arg0)
	return &MockExecerRunCall{Call: call}
}

// MockExecerRunCall wrap *gomock.Call
type MockExecerRunCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExecerRunCall) Return(arg0 error) *MockExecerRunCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExecerRunCall) Do(f func(*exec.Cmd) error) *MockExecerRunCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExecerRunCall) DoAndReturn(f func(*exec.Cmd) error) *MockExecerRunCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Start mocks base method.
func (m *MockExecer) Start(arg0 *exec.Cmd) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Start", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Start indicates an expected call of Start.
func (mr *MockExecerMockRecorder) Start(arg0 any) *MockExecerStartCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockExecer)(nil).Start), arg0)
	return &MockExecerStartCall{Call: call}
}

// MockExecerStartCall wrap *gomock.Call
type MockExecerStartCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExecerStartCall) Return(arg0 error) *MockExecerStartCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExecerStartCall) Do(f func(*exec.Cmd) error) *MockExecerStartCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExecerStartCall) DoAndReturn(f func(*exec.Cmd) error) *MockExecerStartCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Wait mocks base method.
func (m *MockExecer) Wait(arg0 *exec.Cmd) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Wait", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Wait indicates an expected call of Wait.
func (mr *MockExecerMockRecorder) Wait(arg0 any) *MockExecerWaitCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Wait", reflect.TypeOf((*MockExecer)(nil).Wait), arg0)
	return &MockExecerWaitCall{Call: call}
}

// MockExecerWaitCall wrap *gomock.Call
type MockExecerWaitCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExecerWaitCall) Return(arg0 error) *MockExecerWaitCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExecerWaitCall) Do(f func(*exec.Cmd) error) *MockExecerWaitCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExecerWaitCall) DoAndReturn(f func(*exec.Cmd) error) *MockExecerWaitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
