mirror of
https://github.com/filecoin-project/lotus.git
synced 2025-08-06 16:41:19 +08:00
312fa3a5cc
The changes here simplify the string of targets executed as part of `make gen`. The simplifications include: * parallelised code generation whenever possible * re-implementation of documentation generation for a significant simplification and improved readability. * unified mocks generation to avoid multiple slow calls to `go run` per package. Note, the changes introduced here are purely mechanical and do not alter the Lotus node functionality. Fixes #8392
451 lines
19 KiB
Go
451 lines
19 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: github.com/filecoin-project/lotus/storage/paths (interfaces: SectorIndex,PartialFileHandler,Store)
|
|
|
|
// Package mocks is a generated GoMock package.
|
|
package mocks
|
|
|
|
import (
|
|
context "context"
|
|
io "io"
|
|
reflect "reflect"
|
|
|
|
gomock "github.com/golang/mock/gomock"
|
|
cid "github.com/ipfs/go-cid"
|
|
|
|
abi "github.com/filecoin-project/go-state-types/abi"
|
|
|
|
fsutil "github.com/filecoin-project/lotus/storage/sealer/fsutil"
|
|
partialfile "github.com/filecoin-project/lotus/storage/sealer/partialfile"
|
|
storiface "github.com/filecoin-project/lotus/storage/sealer/storiface"
|
|
)
|
|
|
|
// MockSectorIndex is a mock of SectorIndex interface.
|
|
type MockSectorIndex struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockSectorIndexMockRecorder
|
|
}
|
|
|
|
// MockSectorIndexMockRecorder is the mock recorder for MockSectorIndex.
|
|
type MockSectorIndexMockRecorder struct {
|
|
mock *MockSectorIndex
|
|
}
|
|
|
|
// NewMockSectorIndex creates a new mock instance.
|
|
func NewMockSectorIndex(ctrl *gomock.Controller) *MockSectorIndex {
|
|
mock := &MockSectorIndex{ctrl: ctrl}
|
|
mock.recorder = &MockSectorIndexMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockSectorIndex) EXPECT() *MockSectorIndexMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// StorageAttach mocks base method.
|
|
func (m *MockSectorIndex) StorageAttach(arg0 context.Context, arg1 storiface.StorageInfo, arg2 fsutil.FsStat) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StorageAttach", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// StorageAttach indicates an expected call of StorageAttach.
|
|
func (mr *MockSectorIndexMockRecorder) StorageAttach(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageAttach", reflect.TypeOf((*MockSectorIndex)(nil).StorageAttach), arg0, arg1, arg2)
|
|
}
|
|
|
|
// StorageBestAlloc mocks base method.
|
|
func (m *MockSectorIndex) StorageBestAlloc(arg0 context.Context, arg1 storiface.SectorFileType, arg2 abi.SectorSize, arg3 storiface.PathType, arg4 abi.ActorID) ([]storiface.StorageInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StorageBestAlloc", arg0, arg1, arg2, arg3, arg4)
|
|
ret0, _ := ret[0].([]storiface.StorageInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StorageBestAlloc indicates an expected call of StorageBestAlloc.
|
|
func (mr *MockSectorIndexMockRecorder) StorageBestAlloc(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageBestAlloc", reflect.TypeOf((*MockSectorIndex)(nil).StorageBestAlloc), arg0, arg1, arg2, arg3, arg4)
|
|
}
|
|
|
|
// StorageDeclareSector mocks base method.
|
|
func (m *MockSectorIndex) StorageDeclareSector(arg0 context.Context, arg1 storiface.ID, arg2 abi.SectorID, arg3 storiface.SectorFileType, arg4 bool) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StorageDeclareSector", arg0, arg1, arg2, arg3, arg4)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// StorageDeclareSector indicates an expected call of StorageDeclareSector.
|
|
func (mr *MockSectorIndexMockRecorder) StorageDeclareSector(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageDeclareSector", reflect.TypeOf((*MockSectorIndex)(nil).StorageDeclareSector), arg0, arg1, arg2, arg3, arg4)
|
|
}
|
|
|
|
// StorageDetach mocks base method.
|
|
func (m *MockSectorIndex) StorageDetach(arg0 context.Context, arg1 storiface.ID, arg2 string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StorageDetach", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// StorageDetach indicates an expected call of StorageDetach.
|
|
func (mr *MockSectorIndexMockRecorder) StorageDetach(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageDetach", reflect.TypeOf((*MockSectorIndex)(nil).StorageDetach), arg0, arg1, arg2)
|
|
}
|
|
|
|
// StorageDropSector mocks base method.
|
|
func (m *MockSectorIndex) StorageDropSector(arg0 context.Context, arg1 storiface.ID, arg2 abi.SectorID, arg3 storiface.SectorFileType) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StorageDropSector", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// StorageDropSector indicates an expected call of StorageDropSector.
|
|
func (mr *MockSectorIndexMockRecorder) StorageDropSector(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageDropSector", reflect.TypeOf((*MockSectorIndex)(nil).StorageDropSector), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// StorageFindSector mocks base method.
|
|
func (m *MockSectorIndex) StorageFindSector(arg0 context.Context, arg1 abi.SectorID, arg2 storiface.SectorFileType, arg3 abi.SectorSize, arg4 bool) ([]storiface.SectorStorageInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StorageFindSector", arg0, arg1, arg2, arg3, arg4)
|
|
ret0, _ := ret[0].([]storiface.SectorStorageInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StorageFindSector indicates an expected call of StorageFindSector.
|
|
func (mr *MockSectorIndexMockRecorder) StorageFindSector(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageFindSector", reflect.TypeOf((*MockSectorIndex)(nil).StorageFindSector), arg0, arg1, arg2, arg3, arg4)
|
|
}
|
|
|
|
// StorageGetLocks mocks base method.
|
|
func (m *MockSectorIndex) StorageGetLocks(arg0 context.Context) (storiface.SectorLocks, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StorageGetLocks", arg0)
|
|
ret0, _ := ret[0].(storiface.SectorLocks)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StorageGetLocks indicates an expected call of StorageGetLocks.
|
|
func (mr *MockSectorIndexMockRecorder) StorageGetLocks(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageGetLocks", reflect.TypeOf((*MockSectorIndex)(nil).StorageGetLocks), arg0)
|
|
}
|
|
|
|
// StorageInfo mocks base method.
|
|
func (m *MockSectorIndex) StorageInfo(arg0 context.Context, arg1 storiface.ID) (storiface.StorageInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StorageInfo", arg0, arg1)
|
|
ret0, _ := ret[0].(storiface.StorageInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StorageInfo indicates an expected call of StorageInfo.
|
|
func (mr *MockSectorIndexMockRecorder) StorageInfo(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageInfo", reflect.TypeOf((*MockSectorIndex)(nil).StorageInfo), arg0, arg1)
|
|
}
|
|
|
|
// StorageList mocks base method.
|
|
func (m *MockSectorIndex) StorageList(arg0 context.Context) (map[storiface.ID][]storiface.Decl, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StorageList", arg0)
|
|
ret0, _ := ret[0].(map[storiface.ID][]storiface.Decl)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StorageList indicates an expected call of StorageList.
|
|
func (mr *MockSectorIndexMockRecorder) StorageList(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageList", reflect.TypeOf((*MockSectorIndex)(nil).StorageList), arg0)
|
|
}
|
|
|
|
// StorageLock mocks base method.
|
|
func (m *MockSectorIndex) StorageLock(arg0 context.Context, arg1 abi.SectorID, arg2, arg3 storiface.SectorFileType) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StorageLock", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// StorageLock indicates an expected call of StorageLock.
|
|
func (mr *MockSectorIndexMockRecorder) StorageLock(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageLock", reflect.TypeOf((*MockSectorIndex)(nil).StorageLock), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// StorageReportHealth mocks base method.
|
|
func (m *MockSectorIndex) StorageReportHealth(arg0 context.Context, arg1 storiface.ID, arg2 storiface.HealthReport) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StorageReportHealth", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// StorageReportHealth indicates an expected call of StorageReportHealth.
|
|
func (mr *MockSectorIndexMockRecorder) StorageReportHealth(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageReportHealth", reflect.TypeOf((*MockSectorIndex)(nil).StorageReportHealth), arg0, arg1, arg2)
|
|
}
|
|
|
|
// StorageTryLock mocks base method.
|
|
func (m *MockSectorIndex) StorageTryLock(arg0 context.Context, arg1 abi.SectorID, arg2, arg3 storiface.SectorFileType) (bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StorageTryLock", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StorageTryLock indicates an expected call of StorageTryLock.
|
|
func (mr *MockSectorIndexMockRecorder) StorageTryLock(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageTryLock", reflect.TypeOf((*MockSectorIndex)(nil).StorageTryLock), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// MockPartialFileHandler is a mock of PartialFileHandler interface.
|
|
type MockPartialFileHandler struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockPartialFileHandlerMockRecorder
|
|
}
|
|
|
|
// MockPartialFileHandlerMockRecorder is the mock recorder for MockPartialFileHandler.
|
|
type MockPartialFileHandlerMockRecorder struct {
|
|
mock *MockPartialFileHandler
|
|
}
|
|
|
|
// NewMockPartialFileHandler creates a new mock instance.
|
|
func NewMockPartialFileHandler(ctrl *gomock.Controller) *MockPartialFileHandler {
|
|
mock := &MockPartialFileHandler{ctrl: ctrl}
|
|
mock.recorder = &MockPartialFileHandlerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockPartialFileHandler) EXPECT() *MockPartialFileHandlerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Close mocks base method.
|
|
func (m *MockPartialFileHandler) Close(arg0 *partialfile.PartialFile) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Close", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Close indicates an expected call of Close.
|
|
func (mr *MockPartialFileHandlerMockRecorder) Close(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPartialFileHandler)(nil).Close), arg0)
|
|
}
|
|
|
|
// HasAllocated mocks base method.
|
|
func (m *MockPartialFileHandler) HasAllocated(arg0 *partialfile.PartialFile, arg1 storiface.UnpaddedByteIndex, arg2 abi.UnpaddedPieceSize) (bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HasAllocated", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// HasAllocated indicates an expected call of HasAllocated.
|
|
func (mr *MockPartialFileHandlerMockRecorder) HasAllocated(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasAllocated", reflect.TypeOf((*MockPartialFileHandler)(nil).HasAllocated), arg0, arg1, arg2)
|
|
}
|
|
|
|
// OpenPartialFile mocks base method.
|
|
func (m *MockPartialFileHandler) OpenPartialFile(arg0 abi.PaddedPieceSize, arg1 string) (*partialfile.PartialFile, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "OpenPartialFile", arg0, arg1)
|
|
ret0, _ := ret[0].(*partialfile.PartialFile)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// OpenPartialFile indicates an expected call of OpenPartialFile.
|
|
func (mr *MockPartialFileHandlerMockRecorder) OpenPartialFile(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenPartialFile", reflect.TypeOf((*MockPartialFileHandler)(nil).OpenPartialFile), arg0, arg1)
|
|
}
|
|
|
|
// Reader mocks base method.
|
|
func (m *MockPartialFileHandler) Reader(arg0 *partialfile.PartialFile, arg1 storiface.PaddedByteIndex, arg2 abi.PaddedPieceSize) (io.Reader, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Reader", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(io.Reader)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Reader indicates an expected call of Reader.
|
|
func (mr *MockPartialFileHandlerMockRecorder) Reader(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reader", reflect.TypeOf((*MockPartialFileHandler)(nil).Reader), arg0, arg1, arg2)
|
|
}
|
|
|
|
// MockStore is a mock of Store interface.
|
|
type MockStore struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockStoreMockRecorder
|
|
}
|
|
|
|
// MockStoreMockRecorder is the mock recorder for MockStore.
|
|
type MockStoreMockRecorder struct {
|
|
mock *MockStore
|
|
}
|
|
|
|
// NewMockStore creates a new mock instance.
|
|
func NewMockStore(ctrl *gomock.Controller) *MockStore {
|
|
mock := &MockStore{ctrl: ctrl}
|
|
mock.recorder = &MockStoreMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockStore) EXPECT() *MockStoreMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// AcquireSector mocks base method.
|
|
func (m *MockStore) AcquireSector(arg0 context.Context, arg1 storiface.SectorRef, arg2, arg3 storiface.SectorFileType, arg4 storiface.PathType, arg5 storiface.AcquireMode, arg6 ...storiface.AcquireOption) (storiface.SectorPaths, storiface.SectorPaths, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2, arg3, arg4, arg5}
|
|
for _, a := range arg6 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "AcquireSector", varargs...)
|
|
ret0, _ := ret[0].(storiface.SectorPaths)
|
|
ret1, _ := ret[1].(storiface.SectorPaths)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// AcquireSector indicates an expected call of AcquireSector.
|
|
func (mr *MockStoreMockRecorder) AcquireSector(arg0, arg1, arg2, arg3, arg4, arg5 interface{}, arg6 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5}, arg6...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcquireSector", reflect.TypeOf((*MockStore)(nil).AcquireSector), varargs...)
|
|
}
|
|
|
|
// FsStat mocks base method.
|
|
func (m *MockStore) FsStat(arg0 context.Context, arg1 storiface.ID) (fsutil.FsStat, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FsStat", arg0, arg1)
|
|
ret0, _ := ret[0].(fsutil.FsStat)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FsStat indicates an expected call of FsStat.
|
|
func (mr *MockStoreMockRecorder) FsStat(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FsStat", reflect.TypeOf((*MockStore)(nil).FsStat), arg0, arg1)
|
|
}
|
|
|
|
// GeneratePoRepVanillaProof mocks base method.
|
|
func (m *MockStore) GeneratePoRepVanillaProof(arg0 context.Context, arg1 storiface.SectorRef, arg2, arg3 cid.Cid, arg4 abi.SealRandomness, arg5 abi.InteractiveSealRandomness) ([]byte, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GeneratePoRepVanillaProof", arg0, arg1, arg2, arg3, arg4, arg5)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GeneratePoRepVanillaProof indicates an expected call of GeneratePoRepVanillaProof.
|
|
func (mr *MockStoreMockRecorder) GeneratePoRepVanillaProof(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeneratePoRepVanillaProof", reflect.TypeOf((*MockStore)(nil).GeneratePoRepVanillaProof), arg0, arg1, arg2, arg3, arg4, arg5)
|
|
}
|
|
|
|
// GenerateSingleVanillaProof mocks base method.
|
|
func (m *MockStore) GenerateSingleVanillaProof(arg0 context.Context, arg1 abi.ActorID, arg2 storiface.PostSectorChallenge, arg3 abi.RegisteredPoStProof) ([]byte, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GenerateSingleVanillaProof", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GenerateSingleVanillaProof indicates an expected call of GenerateSingleVanillaProof.
|
|
func (mr *MockStoreMockRecorder) GenerateSingleVanillaProof(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateSingleVanillaProof", reflect.TypeOf((*MockStore)(nil).GenerateSingleVanillaProof), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// MoveStorage mocks base method.
|
|
func (m *MockStore) MoveStorage(arg0 context.Context, arg1 storiface.SectorRef, arg2 storiface.SectorFileType, arg3 ...storiface.AcquireOption) error {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "MoveStorage", varargs...)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// MoveStorage indicates an expected call of MoveStorage.
|
|
func (mr *MockStoreMockRecorder) MoveStorage(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveStorage", reflect.TypeOf((*MockStore)(nil).MoveStorage), varargs...)
|
|
}
|
|
|
|
// Remove mocks base method.
|
|
func (m *MockStore) Remove(arg0 context.Context, arg1 abi.SectorID, arg2 storiface.SectorFileType, arg3 bool, arg4 []storiface.ID) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Remove", arg0, arg1, arg2, arg3, arg4)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Remove indicates an expected call of Remove.
|
|
func (mr *MockStoreMockRecorder) Remove(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockStore)(nil).Remove), arg0, arg1, arg2, arg3, arg4)
|
|
}
|
|
|
|
// RemoveCopies mocks base method.
|
|
func (m *MockStore) RemoveCopies(arg0 context.Context, arg1 abi.SectorID, arg2 storiface.SectorFileType) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RemoveCopies", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// RemoveCopies indicates an expected call of RemoveCopies.
|
|
func (mr *MockStoreMockRecorder) RemoveCopies(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveCopies", reflect.TypeOf((*MockStore)(nil).RemoveCopies), arg0, arg1, arg2)
|
|
}
|
|
|
|
// Reserve mocks base method.
|
|
func (m *MockStore) Reserve(arg0 context.Context, arg1 storiface.SectorRef, arg2 storiface.SectorFileType, arg3 storiface.SectorPaths, arg4 map[storiface.SectorFileType]int, arg5 float64) (func(), error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Reserve", arg0, arg1, arg2, arg3, arg4, arg5)
|
|
ret0, _ := ret[0].(func())
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Reserve indicates an expected call of Reserve.
|
|
func (mr *MockStoreMockRecorder) Reserve(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reserve", reflect.TypeOf((*MockStore)(nil).Reserve), arg0, arg1, arg2, arg3, arg4, arg5)
|
|
}
|