func (mr *MockManifestMockRecorder) DefaultVersion(depName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultVersion", reflect.TypeOf((*MockManifest)(nil).DefaultVersion), depName)
}
DefaultVersion indicates an expected call of DefaultVersion.
package supply_test
import (
	io "io"
	exec "os/exec"
	reflect "reflect"
	libbuildpack "github.com/cloudfoundry/libbuildpack"
	gomock "github.com/golang/mock/gomock"
)
type MockCommand struct {
	ctrl     *gomock.Controller
	recorder *MockCommandMockRecorder
}
type MockCommandMockRecorder struct {
	mock *MockCommand
}
func NewMockCommand(ctrl *gomock.Controller) *MockCommand {
	mock := &MockCommand{ctrl: ctrl}
	mock.recorder = &MockCommandMockRecorder{mock}
	return mock
}
func (m *MockCommand) EXPECT() *MockCommandMockRecorder {
	return m.recorder
}
func (m *MockCommand) Execute(arg0 string, arg1, arg2 io.Writer, arg3 string, arg4 ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Execute", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockCommandMockRecorder) Execute(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Execute", reflect.TypeOf((*MockCommand)(nil).Execute), varargs...)
}
func (m *MockCommand) Output(arg0, arg1 string, arg2 ...string) (string, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Output", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockCommandMockRecorder) Output(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Output", reflect.TypeOf((*MockCommand)(nil).Output), varargs...)
}
func (m *MockCommand) Run(cmd *exec.Cmd) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Run", cmd)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockCommandMockRecorder) Run(cmd interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockCommand)(nil).Run), cmd)
}
type MockManifest struct {
	ctrl     *gomock.Controller
	recorder *MockManifestMockRecorder
}
type MockManifestMockRecorder struct {
	mock *MockManifest
}
func NewMockManifest(ctrl *gomock.Controller) *MockManifest {
	mock := &MockManifest{ctrl: ctrl}
	mock.recorder = &MockManifestMockRecorder{mock}
	return mock
}
func (m *MockManifest) EXPECT() *MockManifestMockRecorder {
	return m.recorder
}
func (m *MockManifest) AllDependencyVersions(arg0 string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllDependencyVersions", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}
func (mr *MockManifestMockRecorder) AllDependencyVersions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllDependencyVersions", reflect.TypeOf((*MockManifest)(nil).AllDependencyVersions), arg0)
}
func (m *MockManifest) DefaultVersion(depName string) (libbuildpack.Dependency, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DefaultVersion", depName)
	ret0, _ := ret[0].(libbuildpack.Dependency)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}