repo_description: A fast, cross-platform build tool inspired by Make, designed for modern workflows.
repo_topics: build-tool devops go make makefile task task-runner taskfile
code: // Code generated by mockery; DO NOT EDIT.
  // github.com/vektra/mockery
  // template: testify
  
  package fingerprint
  
  import (
  	"context"
  
  	"github.com/go-task/task/v3/taskfile/ast"
  	mock "github.com/stretchr/testify/mock"
  )
  
  // NewMockStatusCheckable creates a new instance of MockStatusCheckable. 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 NewMockStatusCheckable(t interface {
  	mock.TestingT
  	Cleanup(func())
  }) *MockStatusCheckable {
  	mock := &MockStatusCheckable{}
  	mock.Mock.Test(t)
  
  	t.Cleanup(func() { mock.AssertExpectations(t) })
  
  	return mock
  }
  
  // MockStatusCheckable is an autogenerated mock type for the StatusCheckable type
  type MockStatusCheckable struct {
  	mock.Mock
  }
  
  type MockStatusCheckable_Expecter struct {
  	mock *mock.Mock
  }
  
  func (_m *MockStatusCheckable) EXPECT() *MockStatusCheckable_Expecter {
  	return &MockStatusCheckable_Expecter{mock: &_m.Mock}
  }
  
  // IsUpToDate provides a mock function for the type MockStatusCheckable
  func (_mock *MockStatusCheckable) IsUpToDate(ctx context.Context, t *ast.Task) (bool, error) {
  	ret := _mock.Called(ctx, t)
  
  	if len(ret) == 0 {
  		panic("no return value specified for IsUpToDate")
  	}
  
  	var r0 bool
  	var r1 error
  	if returnFunc, ok := ret.Get(0).(func(context.Context, *ast.Task) (bool, error)); ok {
  		return returnFunc(ctx, t)
  	}
  	if returnFunc, ok := ret.Get(0).(func(context.Context, *ast.Task) bool); ok {
  		r0 = returnFunc(ctx, t)
  	} else {
  		r0 = ret.Get(0).(bool)
  	}
  	if returnFunc, ok := ret.Get(1).(func(context.Context, *ast.Task) error); ok {
  		r1 = returnFunc(ctx, t)
  	} else {
  		r1 = ret.Error(1)
  	}
  	return r0, r1
  }
  
  // MockStatusCheckable_IsUpToDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUpToDate'
  type MockStatusCheckable_IsUpToDate_Call struct {
  	*mock.Call
  }
  
  // IsUpToDate is a helper method to define mock.On call
  //   - ctx
  //   - t
  func (_e *MockStatusCheckable_Expecter) IsUpToDate(ctx interface{}, t interface{}) *MockStatusCheckable_IsUpToDate_Call {
  	return &MockStatusCheckable_IsUpToDate_Call{Call: _e.mock.On("IsUpToDate", ctx, t)}
  }
  
  func (_c *MockStatusCheckable_IsUpToDate_Call) Run(run func(ctx context.Context, t *ast.Task)) *MockStatusCheckable_IsUpToDate_Call {
  	_c.Call.Run(func(args mock.Arguments) {
  		run(args[0].(context.Context), args[1].(*ast.Task))
  	})
  	return _c
  }
  
  func (_c *MockStatusCheckable_IsUpToDate_Call) Return(b bool, err error) *MockStatusCheckable_IsUpToDate_Call {
  	_c.Call.Return(b, err)
  	return _c
  }
  
  func (_c *MockStatusCheckable_IsUpToDate_Call) RunAndReturn(run func(ctx context.Context, t *ast.Task) (bool, error)) *MockStatusCheckable_IsUpToDate_Call {
  	_c.Call.Return(run)
  	return _c
  }
  
  // NewMockSourcesCheckable creates a new instance of MockSourcesCheckable. 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 NewMockSourcesCheckable(t interface {
  	mock.TestingT
  	Cleanup(func())
  }) *MockSourcesCheckable {
  	mock := &MockSourcesCheckable{}
  	mock.Mock.Test(t)
  
  	t.Cleanup(func() { mock.AssertExpectations(t) })
  
  	return mock
  }
  
  // MockSourcesCheckable is an autogenerated mock type for the SourcesCheckable type
  type MockSourcesCheckable struct {
  	mock.Mock
  }
  
  type MockSourcesCheckable_Expecter struct {
  	mock *mock.Mock
  }
  
  func (_m *MockSourcesCheckable) EXPECT() *MockSourcesCheckable_Expecter {
  	return &MockSourcesCheckable_Expecter{mock: &_m.Mock}
  }
  
  // IsUpToDate provides a mock function for the type MockSourcesCheckable
  func (_mock *MockSourcesCheckable) IsUpToDate(t *ast.Task) (bool, error) {
  	ret := _mock.Called(t)
  
  	if len(ret) == 0 {
  		panic("no return value specified for IsUpToDate")
  	}
  
  	var r0 bool
  	var r1 error
  	if returnFunc, ok := ret.Get(0).(func(*ast.Task) (bool, error)); ok {
  		return returnFunc(t)
  	}
  	if returnFunc, ok := ret.Get(0).(func(*ast.Task) bool); ok {
  		r0 = returnFunc(t)
  	} else {
  		r0 = ret.Get(0).(bool)
  	}
  	if returnFunc, ok := ret.Get(1).(func(*ast.Task) error); ok {
  		r1 = returnFunc(t)
  	} else {
  		r1 = ret.Error(1)
  	}
  	return r0, r1
  }
  
  // MockSourcesCheckable_IsUpToDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUpToDate'
  type MockSourcesCheckable_IsUpToDate_Call struct {
  	*mock.Call
  }
  
  // IsUpToDate is a helper method to define mock.On call
  //   - t
  func (_e *MockSourcesCheckable_Expecter) IsUpToDate(t interface{}) *MockSourcesCheckable_IsUpToDate_Call {
  	return &MockSourcesCheckable_IsUpToDate_Call{Call: _e.mock.On("IsUpToDate", t)}
  }
  
  func (_c *MockSourcesCheckable_IsUpToDate_Call) Run(run func(t *ast.Task)) *MockSourcesCheckable_IsUpToDate_Call {
  	_c.Call.Run(func(args mock.Arguments) {
  		run(args[0].(*ast.Task))
  	})
  	return _c
  }
  
  func (_c *MockSourcesCheckable_IsUpToDate_Call) Return(b bool, err error) *MockSourcesCheckable_IsUpToDate_Call {
  	_c.Call.Return(b, err)
  	return _c
  }
  
  func (_c *MockSourcesCheckable_IsUpToDate_Call) RunAndReturn(run func(t *ast.Task) (bool, error)) *MockSourcesCheckable_IsUpToDate_Call {
  	_c.Call.Return(run)
  	return _c
  }
  
  // Kind provides a mock function for the type MockSourcesCheckable
  func (_mock *MockSourcesCheckable) Kind() string {
  	ret := _mock.Called()
  
  	if len(ret) == 0 {
  		panic("no return value specified for Kind")
  	}
  
  	var r0 string
  	if returnFunc, ok := ret.Get(0).(func() string); ok {
  		r0 = returnFunc()
  	} else {
  		r0 = ret.Get(0).(string)
  	}
  	return r0
  }
  
  // MockSourcesCheckable_Kind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Kind'
  type MockSourcesCheckable_Kind_Call struct {
  	*mock.Call
  }
  
  // Kind is a helper method to define mock.On call
  func (_e *MockSourcesCheckable_Expecter) Kind() *MockSourcesCheckable_Kind_Call {
  	return &MockSourcesCheckable_Kind_Call{Call: _e.mock.On("Kind")}
  }
  
  func (_c *MockSourcesCheckable_Kind_Call) Run(run func()) *MockSourcesCheckable_Kind_Call {
  	_c.Call.Run(func(args mock.Arguments) {
  		run()
  	})
  	return _c
  }
  
  func (_c *MockSourcesCheckable_Kind_Call) Return(s string) *MockSourcesCheckable_Kind_Call {
  	_c.Call.Return(s)
  	return _c
  }
  
  func (_c *MockSourcesCheckable_Kind_Call) RunAndReturn(run func() string) *MockSourcesCheckable_Kind_Call {
  	_c.Call.Return(run)
  	return _c
  }
  
  // OnError provides a mock function for the type MockSourcesCheckable
  func (_mock *MockSourcesCheckable) OnError(t *ast.Task) error {
  	ret := _mock.Called(t)
  
  	if len(ret) == 0 {
  		panic("no return value specified for OnError")
  	}
  
  	var r0 error
  	if returnFunc, ok := ret.Get(0).(func(*ast.Task) error); ok {
  		r0 = returnFunc(t)
  	} else {
  		r0 = ret.Error(0)
  	}
  	return r0
  }
  
  // MockSourcesCheckable_OnError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnError'
  type MockSourcesCheckable_OnError_Call struct {
  	*mock.Call
  }
  
  // OnError is a helper method to define mock.On call
  //   - t
  func (_e *MockSourcesCheckable_Expecter) OnError(t interface{}) *MockSourcesCheckable_OnError_Call {
  	return &MockSourcesCheckable_OnError_Call{Call: _e.mock.On("OnError", t)}
  }
  
  func (_c *MockSourcesCheckable_OnError_Call) Run(run func(t *ast.Task)) *MockSourcesCheckable_OnError_Call {
  	_c.Call.Run(func(args mock.Arguments) {
  		run(args[0].(*ast.Task))
  	})
  	return _c
  }
  
  func (_c *MockSourcesCheckable_OnError_Call) Return(err error) *MockSourcesCheckable_OnError_Call {
  	_c.Call.Return(err)
  	return _c
  }
  
  func (_c *MockSourcesCheckable_OnError_Call) RunAndReturn(run func(t *ast.Task) error) *MockSourcesCheckable_OnError_Call {
  	_c.Call.Return(run)
  	return _c
  }
  
  // Value provides a mock function for the type MockSourcesCheckable
  func (_mock *MockSourcesCheckable) Value(t *ast.Task) (any, error) {
  	ret := _mock.Called(t)
  
  	if len(ret) == 0 {
  		panic("no return value specified for Value")
  	}
  
  	var r0 any
  	var r1 error
  	if returnFunc, ok := ret.Get(0).(func(*ast.Task) (any, error)); ok {
  		return returnFunc(t)
  	}
  	if returnFunc, ok := ret.Get(0).(func(*ast.Task) any); ok {
  		r0 = returnFunc(t)
  	} else {
  		if ret.Get(0) != nil {
  			r0 = ret.Get(0).(any)
  		}
  	}
  	if returnFunc, ok := ret.Get(1).(func(*ast.Task) error); ok {
  		r1 = returnFunc(t)
  	} else {
  		r1 = ret.Error(1)
  	}
  	return r0, r1
  }
  
  // MockSourcesCheckable_Value_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Value'
  type MockSourcesCheckable_Value_Call struct {
  	*mock.Call
  }
  
  // Value is a helper method to define mock.On call
  //   - t
  func (_e *MockSourcesCheckable_Expecter) Value(t interface{}) *MockSourcesCheckable_Value_Call {
  	return &MockSourcesCheckable_Value_Call{Call: _e.mock.On("Value", t)}
  }
  
  func (_c *MockSourcesCheckable_Value_Call) Run(run func(t *ast.Task)) *MockSourcesCheckable_Value_Call {
  	_c.Call.Run(func(args mock.Arguments) {
  		run(args[0].(*ast.Task))
  	})
  	return _c
  }
  
  func (_c *MockSourcesCheckable_Value_Call) Return(v any, err error) *MockSourcesCheckable_Value_Call {
  	_c.Call.Return(v, err)
  	return _c
  }
  
  func (_c *MockSourcesCheckable_Value_Call) RunAndReturn(run func(t *ast.Task) (any, error)) *MockSourcesCheckable_Value_Call {
  	_c.Call.Return(run)
  	return _c
  }
  