// Code generated by MockGen. DO NOT EDIT.
// Source: git_utils.go
//
// Generated by this command:
//
//	mockgen -source=git_utils.go -destination=mock/git_utils.go -typed
//

// Package mock_common is a generated GoMock package.
package mock_common

import (
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
	common "src.opensuse.org/autogits/common"
)

// MockGitSubmoduleLister is a mock of GitSubmoduleLister interface.
type MockGitSubmoduleLister struct {
	ctrl     *gomock.Controller
	recorder *MockGitSubmoduleListerMockRecorder
	isgomock struct{}
}

// MockGitSubmoduleListerMockRecorder is the mock recorder for MockGitSubmoduleLister.
type MockGitSubmoduleListerMockRecorder struct {
	mock *MockGitSubmoduleLister
}

// NewMockGitSubmoduleLister creates a new mock instance.
func NewMockGitSubmoduleLister(ctrl *gomock.Controller) *MockGitSubmoduleLister {
	mock := &MockGitSubmoduleLister{ctrl: ctrl}
	mock.recorder = &MockGitSubmoduleListerMockRecorder{mock}
	return mock
}

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

// GitSubmoduleCommitId mocks base method.
func (m *MockGitSubmoduleLister) GitSubmoduleCommitId(cwd, packageName, commitId string) (string, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitSubmoduleCommitId", cwd, packageName, commitId)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GitSubmoduleCommitId indicates an expected call of GitSubmoduleCommitId.
func (mr *MockGitSubmoduleListerMockRecorder) GitSubmoduleCommitId(cwd, packageName, commitId any) *MockGitSubmoduleListerGitSubmoduleCommitIdCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitSubmoduleCommitId", reflect.TypeOf((*MockGitSubmoduleLister)(nil).GitSubmoduleCommitId), cwd, packageName, commitId)
	return &MockGitSubmoduleListerGitSubmoduleCommitIdCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitSubmoduleListerGitSubmoduleCommitIdCall) Return(subCommitId string, valid bool) *MockGitSubmoduleListerGitSubmoduleCommitIdCall {
	c.Call = c.Call.Return(subCommitId, valid)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitSubmoduleListerGitSubmoduleCommitIdCall) Do(f func(string, string, string) (string, bool)) *MockGitSubmoduleListerGitSubmoduleCommitIdCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitSubmoduleListerGitSubmoduleCommitIdCall) DoAndReturn(f func(string, string, string) (string, bool)) *MockGitSubmoduleListerGitSubmoduleCommitIdCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitSubmoduleList mocks base method.
func (m *MockGitSubmoduleLister) GitSubmoduleList(gitPath, commitId string) (map[string]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitSubmoduleList", gitPath, commitId)
	ret0, _ := ret[0].(map[string]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitSubmoduleList indicates an expected call of GitSubmoduleList.
func (mr *MockGitSubmoduleListerMockRecorder) GitSubmoduleList(gitPath, commitId any) *MockGitSubmoduleListerGitSubmoduleListCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitSubmoduleList", reflect.TypeOf((*MockGitSubmoduleLister)(nil).GitSubmoduleList), gitPath, commitId)
	return &MockGitSubmoduleListerGitSubmoduleListCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitSubmoduleListerGitSubmoduleListCall) Return(submoduleList map[string]string, err error) *MockGitSubmoduleListerGitSubmoduleListCall {
	c.Call = c.Call.Return(submoduleList, err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitSubmoduleListerGitSubmoduleListCall) Do(f func(string, string) (map[string]string, error)) *MockGitSubmoduleListerGitSubmoduleListCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitSubmoduleListerGitSubmoduleListCall) DoAndReturn(f func(string, string) (map[string]string, error)) *MockGitSubmoduleListerGitSubmoduleListCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGitDirectoryLister is a mock of GitDirectoryLister interface.
type MockGitDirectoryLister struct {
	ctrl     *gomock.Controller
	recorder *MockGitDirectoryListerMockRecorder
	isgomock struct{}
}

// MockGitDirectoryListerMockRecorder is the mock recorder for MockGitDirectoryLister.
type MockGitDirectoryListerMockRecorder struct {
	mock *MockGitDirectoryLister
}

// NewMockGitDirectoryLister creates a new mock instance.
func NewMockGitDirectoryLister(ctrl *gomock.Controller) *MockGitDirectoryLister {
	mock := &MockGitDirectoryLister{ctrl: ctrl}
	mock.recorder = &MockGitDirectoryListerMockRecorder{mock}
	return mock
}

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

// GitDirectoryList mocks base method.
func (m *MockGitDirectoryLister) GitDirectoryList(gitPath, commitId string) (map[string]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitDirectoryList", gitPath, commitId)
	ret0, _ := ret[0].(map[string]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitDirectoryList indicates an expected call of GitDirectoryList.
func (mr *MockGitDirectoryListerMockRecorder) GitDirectoryList(gitPath, commitId any) *MockGitDirectoryListerGitDirectoryListCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitDirectoryList", reflect.TypeOf((*MockGitDirectoryLister)(nil).GitDirectoryList), gitPath, commitId)
	return &MockGitDirectoryListerGitDirectoryListCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitDirectoryListerGitDirectoryListCall) Return(dirlist map[string]string, err error) *MockGitDirectoryListerGitDirectoryListCall {
	c.Call = c.Call.Return(dirlist, err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitDirectoryListerGitDirectoryListCall) Do(f func(string, string) (map[string]string, error)) *MockGitDirectoryListerGitDirectoryListCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitDirectoryListerGitDirectoryListCall) DoAndReturn(f func(string, string) (map[string]string, error)) *MockGitDirectoryListerGitDirectoryListCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGitStatusLister is a mock of GitStatusLister interface.
type MockGitStatusLister struct {
	ctrl     *gomock.Controller
	recorder *MockGitStatusListerMockRecorder
	isgomock struct{}
}

// MockGitStatusListerMockRecorder is the mock recorder for MockGitStatusLister.
type MockGitStatusListerMockRecorder struct {
	mock *MockGitStatusLister
}

// NewMockGitStatusLister creates a new mock instance.
func NewMockGitStatusLister(ctrl *gomock.Controller) *MockGitStatusLister {
	mock := &MockGitStatusLister{ctrl: ctrl}
	mock.recorder = &MockGitStatusListerMockRecorder{mock}
	return mock
}

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

// GitStatus mocks base method.
func (m *MockGitStatusLister) GitStatus(cwd string) ([]common.GitStatusData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitStatus", cwd)
	ret0, _ := ret[0].([]common.GitStatusData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitStatus indicates an expected call of GitStatus.
func (mr *MockGitStatusListerMockRecorder) GitStatus(cwd any) *MockGitStatusListerGitStatusCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitStatus", reflect.TypeOf((*MockGitStatusLister)(nil).GitStatus), cwd)
	return &MockGitStatusListerGitStatusCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGitStatusListerGitStatusCall) Do(f func(string) ([]common.GitStatusData, error)) *MockGitStatusListerGitStatusCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitStatusListerGitStatusCall) DoAndReturn(f func(string) ([]common.GitStatusData, error)) *MockGitStatusListerGitStatusCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGitDiffLister is a mock of GitDiffLister interface.
type MockGitDiffLister struct {
	ctrl     *gomock.Controller
	recorder *MockGitDiffListerMockRecorder
	isgomock struct{}
}

// MockGitDiffListerMockRecorder is the mock recorder for MockGitDiffLister.
type MockGitDiffListerMockRecorder struct {
	mock *MockGitDiffLister
}

// NewMockGitDiffLister creates a new mock instance.
func NewMockGitDiffLister(ctrl *gomock.Controller) *MockGitDiffLister {
	mock := &MockGitDiffLister{ctrl: ctrl}
	mock.recorder = &MockGitDiffListerMockRecorder{mock}
	return mock
}

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

// GitDiff mocks base method.
func (m *MockGitDiffLister) GitDiff(cwd, base, head string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitDiff", cwd, base, head)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitDiff indicates an expected call of GitDiff.
func (mr *MockGitDiffListerMockRecorder) GitDiff(cwd, base, head any) *MockGitDiffListerGitDiffCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitDiff", reflect.TypeOf((*MockGitDiffLister)(nil).GitDiff), cwd, base, head)
	return &MockGitDiffListerGitDiffCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitDiffListerGitDiffCall) Return(arg0 string, arg1 error) *MockGitDiffListerGitDiffCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitDiffListerGitDiffCall) Do(f func(string, string, string) (string, error)) *MockGitDiffListerGitDiffCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitDiffListerGitDiffCall) DoAndReturn(f func(string, string, string) (string, error)) *MockGitDiffListerGitDiffCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGit is a mock of Git interface.
type MockGit struct {
	ctrl     *gomock.Controller
	recorder *MockGitMockRecorder
	isgomock struct{}
}

// MockGitMockRecorder is the mock recorder for MockGit.
type MockGitMockRecorder struct {
	mock *MockGit
}

// NewMockGit creates a new mock instance.
func NewMockGit(ctrl *gomock.Controller) *MockGit {
	mock := &MockGit{ctrl: ctrl}
	mock.recorder = &MockGitMockRecorder{mock}
	return mock
}

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

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

// Close indicates an expected call of Close.
func (mr *MockGitMockRecorder) Close() *MockGitCloseCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockGit)(nil).Close))
	return &MockGitCloseCall{Call: call}
}

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

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

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

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

// GetPath mocks base method.
func (m *MockGit) GetPath() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPath")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetPath indicates an expected call of GetPath.
func (mr *MockGitMockRecorder) GetPath() *MockGitGetPathCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPath", reflect.TypeOf((*MockGit)(nil).GetPath))
	return &MockGitGetPathCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGitGetPathCall) Do(f func() string) *MockGitGetPathCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGetPathCall) DoAndReturn(f func() string) *MockGitGetPathCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitBranchHead mocks base method.
func (m *MockGit) GitBranchHead(gitDir, branchName string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitBranchHead", gitDir, branchName)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitBranchHead indicates an expected call of GitBranchHead.
func (mr *MockGitMockRecorder) GitBranchHead(gitDir, branchName any) *MockGitGitBranchHeadCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitBranchHead", reflect.TypeOf((*MockGit)(nil).GitBranchHead), gitDir, branchName)
	return &MockGitGitBranchHeadCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitGitBranchHeadCall) Return(arg0 string, arg1 error) *MockGitGitBranchHeadCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitGitBranchHeadCall) Do(f func(string, string) (string, error)) *MockGitGitBranchHeadCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGitBranchHeadCall) DoAndReturn(f func(string, string) (string, error)) *MockGitGitBranchHeadCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitCatFile mocks base method.
func (m *MockGit) GitCatFile(cwd, commitId, filename string) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitCatFile", cwd, commitId, filename)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitCatFile indicates an expected call of GitCatFile.
func (mr *MockGitMockRecorder) GitCatFile(cwd, commitId, filename any) *MockGitGitCatFileCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitCatFile", reflect.TypeOf((*MockGit)(nil).GitCatFile), cwd, commitId, filename)
	return &MockGitGitCatFileCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitGitCatFileCall) Return(data []byte, err error) *MockGitGitCatFileCall {
	c.Call = c.Call.Return(data, err)
	return c
}

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

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

// GitClone mocks base method.
func (m *MockGit) GitClone(repo, branch, remoteUrl string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitClone", repo, branch, remoteUrl)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitClone indicates an expected call of GitClone.
func (mr *MockGitMockRecorder) GitClone(repo, branch, remoteUrl any) *MockGitGitCloneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitClone", reflect.TypeOf((*MockGit)(nil).GitClone), repo, branch, remoteUrl)
	return &MockGitGitCloneCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitGitCloneCall) Return(arg0 string, arg1 error) *MockGitGitCloneCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitGitCloneCall) Do(f func(string, string, string) (string, error)) *MockGitGitCloneCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGitCloneCall) DoAndReturn(f func(string, string, string) (string, error)) *MockGitGitCloneCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitDiff mocks base method.
func (m *MockGit) GitDiff(cwd, base, head string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitDiff", cwd, base, head)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitDiff indicates an expected call of GitDiff.
func (mr *MockGitMockRecorder) GitDiff(cwd, base, head any) *MockGitGitDiffCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitDiff", reflect.TypeOf((*MockGit)(nil).GitDiff), cwd, base, head)
	return &MockGitGitDiffCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitGitDiffCall) Return(arg0 string, arg1 error) *MockGitGitDiffCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitGitDiffCall) Do(f func(string, string, string) (string, error)) *MockGitGitDiffCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGitDiffCall) DoAndReturn(f func(string, string, string) (string, error)) *MockGitGitDiffCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitDirectoryList mocks base method.
func (m *MockGit) GitDirectoryList(gitPath, commitId string) (map[string]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitDirectoryList", gitPath, commitId)
	ret0, _ := ret[0].(map[string]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitDirectoryList indicates an expected call of GitDirectoryList.
func (mr *MockGitMockRecorder) GitDirectoryList(gitPath, commitId any) *MockGitGitDirectoryListCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitDirectoryList", reflect.TypeOf((*MockGit)(nil).GitDirectoryList), gitPath, commitId)
	return &MockGitGitDirectoryListCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitGitDirectoryListCall) Return(dirlist map[string]string, err error) *MockGitGitDirectoryListCall {
	c.Call = c.Call.Return(dirlist, err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitGitDirectoryListCall) Do(f func(string, string) (map[string]string, error)) *MockGitGitDirectoryListCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGitDirectoryListCall) DoAndReturn(f func(string, string) (map[string]string, error)) *MockGitGitDirectoryListCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitExec mocks base method.
func (m *MockGit) GitExec(cwd string, params ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{cwd}
	for _, a := range params {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GitExec", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// GitExec indicates an expected call of GitExec.
func (mr *MockGitMockRecorder) GitExec(cwd any, params ...any) *MockGitGitExecCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{cwd}, params...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExec", reflect.TypeOf((*MockGit)(nil).GitExec), varargs...)
	return &MockGitGitExecCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGitGitExecCall) Do(f func(string, ...string) error) *MockGitGitExecCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGitExecCall) DoAndReturn(f func(string, ...string) error) *MockGitGitExecCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitExecOrPanic mocks base method.
func (m *MockGit) GitExecOrPanic(cwd string, params ...string) {
	m.ctrl.T.Helper()
	varargs := []any{cwd}
	for _, a := range params {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "GitExecOrPanic", varargs...)
}

// GitExecOrPanic indicates an expected call of GitExecOrPanic.
func (mr *MockGitMockRecorder) GitExecOrPanic(cwd any, params ...any) *MockGitGitExecOrPanicCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{cwd}, params...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExecOrPanic", reflect.TypeOf((*MockGit)(nil).GitExecOrPanic), varargs...)
	return &MockGitGitExecOrPanicCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitGitExecOrPanicCall) Return() *MockGitGitExecOrPanicCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitGitExecOrPanicCall) Do(f func(string, ...string)) *MockGitGitExecOrPanicCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGitExecOrPanicCall) DoAndReturn(f func(string, ...string)) *MockGitGitExecOrPanicCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitExecQuietOrPanic mocks base method.
func (m *MockGit) GitExecQuietOrPanic(cwd string, params ...string) {
	m.ctrl.T.Helper()
	varargs := []any{cwd}
	for _, a := range params {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "GitExecQuietOrPanic", varargs...)
}

// GitExecQuietOrPanic indicates an expected call of GitExecQuietOrPanic.
func (mr *MockGitMockRecorder) GitExecQuietOrPanic(cwd any, params ...any) *MockGitGitExecQuietOrPanicCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{cwd}, params...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExecQuietOrPanic", reflect.TypeOf((*MockGit)(nil).GitExecQuietOrPanic), varargs...)
	return &MockGitGitExecQuietOrPanicCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitGitExecQuietOrPanicCall) Return() *MockGitGitExecQuietOrPanicCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitGitExecQuietOrPanicCall) Do(f func(string, ...string)) *MockGitGitExecQuietOrPanicCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGitExecQuietOrPanicCall) DoAndReturn(f func(string, ...string)) *MockGitGitExecQuietOrPanicCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitExecWithOutput mocks base method.
func (m *MockGit) GitExecWithOutput(cwd string, params ...string) (string, error) {
	m.ctrl.T.Helper()
	varargs := []any{cwd}
	for _, a := range params {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GitExecWithOutput", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitExecWithOutput indicates an expected call of GitExecWithOutput.
func (mr *MockGitMockRecorder) GitExecWithOutput(cwd any, params ...any) *MockGitGitExecWithOutputCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{cwd}, params...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExecWithOutput", reflect.TypeOf((*MockGit)(nil).GitExecWithOutput), varargs...)
	return &MockGitGitExecWithOutputCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitGitExecWithOutputCall) Return(arg0 string, arg1 error) *MockGitGitExecWithOutputCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitGitExecWithOutputCall) Do(f func(string, ...string) (string, error)) *MockGitGitExecWithOutputCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGitExecWithOutputCall) DoAndReturn(f func(string, ...string) (string, error)) *MockGitGitExecWithOutputCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitExecWithOutputOrPanic mocks base method.
func (m *MockGit) GitExecWithOutputOrPanic(cwd string, params ...string) string {
	m.ctrl.T.Helper()
	varargs := []any{cwd}
	for _, a := range params {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GitExecWithOutputOrPanic", varargs...)
	ret0, _ := ret[0].(string)
	return ret0
}

// GitExecWithOutputOrPanic indicates an expected call of GitExecWithOutputOrPanic.
func (mr *MockGitMockRecorder) GitExecWithOutputOrPanic(cwd any, params ...any) *MockGitGitExecWithOutputOrPanicCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{cwd}, params...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExecWithOutputOrPanic", reflect.TypeOf((*MockGit)(nil).GitExecWithOutputOrPanic), varargs...)
	return &MockGitGitExecWithOutputOrPanicCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGitGitExecWithOutputOrPanicCall) Do(f func(string, ...string) string) *MockGitGitExecWithOutputOrPanicCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGitExecWithOutputOrPanicCall) DoAndReturn(f func(string, ...string) string) *MockGitGitExecWithOutputOrPanicCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitParseCommits mocks base method.
func (m *MockGit) GitParseCommits(cwd string, commitIDs []string) ([]common.GitCommit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitParseCommits", cwd, commitIDs)
	ret0, _ := ret[0].([]common.GitCommit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitParseCommits indicates an expected call of GitParseCommits.
func (mr *MockGitMockRecorder) GitParseCommits(cwd, commitIDs any) *MockGitGitParseCommitsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitParseCommits", reflect.TypeOf((*MockGit)(nil).GitParseCommits), cwd, commitIDs)
	return &MockGitGitParseCommitsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitGitParseCommitsCall) Return(parsedCommits []common.GitCommit, err error) *MockGitGitParseCommitsCall {
	c.Call = c.Call.Return(parsedCommits, err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitGitParseCommitsCall) Do(f func(string, []string) ([]common.GitCommit, error)) *MockGitGitParseCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGitParseCommitsCall) DoAndReturn(f func(string, []string) ([]common.GitCommit, error)) *MockGitGitParseCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitRemoteHead mocks base method.
func (m *MockGit) GitRemoteHead(gitDir, remoteName, branchName string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitRemoteHead", gitDir, remoteName, branchName)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitRemoteHead indicates an expected call of GitRemoteHead.
func (mr *MockGitMockRecorder) GitRemoteHead(gitDir, remoteName, branchName any) *MockGitGitRemoteHeadCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitRemoteHead", reflect.TypeOf((*MockGit)(nil).GitRemoteHead), gitDir, remoteName, branchName)
	return &MockGitGitRemoteHeadCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitGitRemoteHeadCall) Return(arg0 string, arg1 error) *MockGitGitRemoteHeadCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitGitRemoteHeadCall) Do(f func(string, string, string) (string, error)) *MockGitGitRemoteHeadCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGitRemoteHeadCall) DoAndReturn(f func(string, string, string) (string, error)) *MockGitGitRemoteHeadCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitStatus mocks base method.
func (m *MockGit) GitStatus(cwd string) ([]common.GitStatusData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitStatus", cwd)
	ret0, _ := ret[0].([]common.GitStatusData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitStatus indicates an expected call of GitStatus.
func (mr *MockGitMockRecorder) GitStatus(cwd any) *MockGitGitStatusCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitStatus", reflect.TypeOf((*MockGit)(nil).GitStatus), cwd)
	return &MockGitGitStatusCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGitGitStatusCall) Do(f func(string) ([]common.GitStatusData, error)) *MockGitGitStatusCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGitStatusCall) DoAndReturn(f func(string) ([]common.GitStatusData, error)) *MockGitGitStatusCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitSubmoduleCommitId mocks base method.
func (m *MockGit) GitSubmoduleCommitId(cwd, packageName, commitId string) (string, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitSubmoduleCommitId", cwd, packageName, commitId)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GitSubmoduleCommitId indicates an expected call of GitSubmoduleCommitId.
func (mr *MockGitMockRecorder) GitSubmoduleCommitId(cwd, packageName, commitId any) *MockGitGitSubmoduleCommitIdCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitSubmoduleCommitId", reflect.TypeOf((*MockGit)(nil).GitSubmoduleCommitId), cwd, packageName, commitId)
	return &MockGitGitSubmoduleCommitIdCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitGitSubmoduleCommitIdCall) Return(subCommitId string, valid bool) *MockGitGitSubmoduleCommitIdCall {
	c.Call = c.Call.Return(subCommitId, valid)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitGitSubmoduleCommitIdCall) Do(f func(string, string, string) (string, bool)) *MockGitGitSubmoduleCommitIdCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGitSubmoduleCommitIdCall) DoAndReturn(f func(string, string, string) (string, bool)) *MockGitGitSubmoduleCommitIdCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GitSubmoduleList mocks base method.
func (m *MockGit) GitSubmoduleList(gitPath, commitId string) (map[string]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GitSubmoduleList", gitPath, commitId)
	ret0, _ := ret[0].(map[string]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GitSubmoduleList indicates an expected call of GitSubmoduleList.
func (mr *MockGitMockRecorder) GitSubmoduleList(gitPath, commitId any) *MockGitGitSubmoduleListCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitSubmoduleList", reflect.TypeOf((*MockGit)(nil).GitSubmoduleList), gitPath, commitId)
	return &MockGitGitSubmoduleListCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitGitSubmoduleListCall) Return(submoduleList map[string]string, err error) *MockGitGitSubmoduleListCall {
	c.Call = c.Call.Return(submoduleList, err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitGitSubmoduleListCall) Do(f func(string, string) (map[string]string, error)) *MockGitGitSubmoduleListCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitGitSubmoduleListCall) DoAndReturn(f func(string, string) (map[string]string, error)) *MockGitGitSubmoduleListCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGitHandlerGenerator is a mock of GitHandlerGenerator interface.
type MockGitHandlerGenerator struct {
	ctrl     *gomock.Controller
	recorder *MockGitHandlerGeneratorMockRecorder
	isgomock struct{}
}

// MockGitHandlerGeneratorMockRecorder is the mock recorder for MockGitHandlerGenerator.
type MockGitHandlerGeneratorMockRecorder struct {
	mock *MockGitHandlerGenerator
}

// NewMockGitHandlerGenerator creates a new mock instance.
func NewMockGitHandlerGenerator(ctrl *gomock.Controller) *MockGitHandlerGenerator {
	mock := &MockGitHandlerGenerator{ctrl: ctrl}
	mock.recorder = &MockGitHandlerGeneratorMockRecorder{mock}
	return mock
}

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

// CreateGitHandler mocks base method.
func (m *MockGitHandlerGenerator) CreateGitHandler(org string) (common.Git, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGitHandler", org)
	ret0, _ := ret[0].(common.Git)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateGitHandler indicates an expected call of CreateGitHandler.
func (mr *MockGitHandlerGeneratorMockRecorder) CreateGitHandler(org any) *MockGitHandlerGeneratorCreateGitHandlerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGitHandler", reflect.TypeOf((*MockGitHandlerGenerator)(nil).CreateGitHandler), org)
	return &MockGitHandlerGeneratorCreateGitHandlerCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitHandlerGeneratorCreateGitHandlerCall) Return(arg0 common.Git, arg1 error) *MockGitHandlerGeneratorCreateGitHandlerCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitHandlerGeneratorCreateGitHandlerCall) Do(f func(string) (common.Git, error)) *MockGitHandlerGeneratorCreateGitHandlerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitHandlerGeneratorCreateGitHandlerCall) DoAndReturn(f func(string) (common.Git, error)) *MockGitHandlerGeneratorCreateGitHandlerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ReadExistingPath mocks base method.
func (m *MockGitHandlerGenerator) ReadExistingPath(org string) (common.Git, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadExistingPath", org)
	ret0, _ := ret[0].(common.Git)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadExistingPath indicates an expected call of ReadExistingPath.
func (mr *MockGitHandlerGeneratorMockRecorder) ReadExistingPath(org any) *MockGitHandlerGeneratorReadExistingPathCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadExistingPath", reflect.TypeOf((*MockGitHandlerGenerator)(nil).ReadExistingPath), org)
	return &MockGitHandlerGeneratorReadExistingPathCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitHandlerGeneratorReadExistingPathCall) Return(arg0 common.Git, arg1 error) *MockGitHandlerGeneratorReadExistingPathCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitHandlerGeneratorReadExistingPathCall) Do(f func(string) (common.Git, error)) *MockGitHandlerGeneratorReadExistingPathCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitHandlerGeneratorReadExistingPathCall) DoAndReturn(f func(string) (common.Git, error)) *MockGitHandlerGeneratorReadExistingPathCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ReleaseLock mocks base method.
func (m *MockGitHandlerGenerator) ReleaseLock(path string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReleaseLock", path)
}

// ReleaseLock indicates an expected call of ReleaseLock.
func (mr *MockGitHandlerGeneratorMockRecorder) ReleaseLock(path any) *MockGitHandlerGeneratorReleaseLockCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseLock", reflect.TypeOf((*MockGitHandlerGenerator)(nil).ReleaseLock), path)
	return &MockGitHandlerGeneratorReleaseLockCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitHandlerGeneratorReleaseLockCall) Return() *MockGitHandlerGeneratorReleaseLockCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitHandlerGeneratorReleaseLockCall) Do(f func(string)) *MockGitHandlerGeneratorReleaseLockCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitHandlerGeneratorReleaseLockCall) DoAndReturn(f func(string)) *MockGitHandlerGeneratorReleaseLockCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}