// Code generated by mockery v2.46.0. DO NOT EDIT. package mock_storage import ( context "context" mmap "golang.org/x/exp/mmap" mock "github.com/stretchr/testify/mock" storage "github.com/milvus-io/milvus/internal/storage" ) // MockChunkManager is an autogenerated mock type for the ChunkManager type type MockChunkManager struct { mock.Mock } type MockChunkManager_Expecter struct { mock *mock.Mock } func (_m *MockChunkManager) EXPECT() *MockChunkManager_Expecter { return &MockChunkManager_Expecter{mock: &_m.Mock} } // Exist provides a mock function with given fields: ctx, filePath func (_m *MockChunkManager) Exist(ctx context.Context, filePath string) (bool, error) { ret := _m.Called(ctx, filePath) if len(ret) == 0 { panic("no return value specified for Exist") } var r0 bool var r1 error if rf, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok { return rf(ctx, filePath) } if rf, ok := ret.Get(0).(func(context.Context, string) bool); ok { r0 = rf(ctx, filePath) } else { r0 = ret.Get(0).(bool) } if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { r1 = rf(ctx, filePath) } else { r1 = ret.Error(1) } return r0, r1 } // MockChunkManager_Exist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exist' type MockChunkManager_Exist_Call struct { *mock.Call } // Exist is a helper method to define mock.On call // - ctx context.Context // - filePath string func (_e *MockChunkManager_Expecter) Exist(ctx interface{}, filePath interface{}) *MockChunkManager_Exist_Call { return &MockChunkManager_Exist_Call{Call: _e.mock.On("Exist", ctx, filePath)} } func (_c *MockChunkManager_Exist_Call) Run(run func(ctx context.Context, filePath string)) *MockChunkManager_Exist_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].(string)) }) return _c } func (_c *MockChunkManager_Exist_Call) Return(_a0 bool, _a1 error) *MockChunkManager_Exist_Call { _c.Call.Return(_a0, _a1) return _c } func (_c *MockChunkManager_Exist_Call) RunAndReturn(run func(context.Context, string) (bool, error)) *MockChunkManager_Exist_Call { _c.Call.Return(run) return _c } // Mmap provides a mock function with given fields: ctx, filePath func (_m *MockChunkManager) Mmap(ctx context.Context, filePath string) (*mmap.ReaderAt, error) { ret := _m.Called(ctx, filePath) if len(ret) == 0 { panic("no return value specified for Mmap") } var r0 *mmap.ReaderAt var r1 error if rf, ok := ret.Get(0).(func(context.Context, string) (*mmap.ReaderAt, error)); ok { return rf(ctx, filePath) } if rf, ok := ret.Get(0).(func(context.Context, string) *mmap.ReaderAt); ok { r0 = rf(ctx, filePath) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*mmap.ReaderAt) } } if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { r1 = rf(ctx, filePath) } else { r1 = ret.Error(1) } return r0, r1 } // MockChunkManager_Mmap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Mmap' type MockChunkManager_Mmap_Call struct { *mock.Call } // Mmap is a helper method to define mock.On call // - ctx context.Context // - filePath string func (_e *MockChunkManager_Expecter) Mmap(ctx interface{}, filePath interface{}) *MockChunkManager_Mmap_Call { return &MockChunkManager_Mmap_Call{Call: _e.mock.On("Mmap", ctx, filePath)} } func (_c *MockChunkManager_Mmap_Call) Run(run func(ctx context.Context, filePath string)) *MockChunkManager_Mmap_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].(string)) }) return _c } func (_c *MockChunkManager_Mmap_Call) Return(_a0 *mmap.ReaderAt, _a1 error) *MockChunkManager_Mmap_Call { _c.Call.Return(_a0, _a1) return _c } func (_c *MockChunkManager_Mmap_Call) RunAndReturn(run func(context.Context, string) (*mmap.ReaderAt, error)) *MockChunkManager_Mmap_Call { _c.Call.Return(run) return _c } // MultiRead provides a mock function with given fields: ctx, filePaths func (_m *MockChunkManager) MultiRead(ctx context.Context, filePaths []string) ([][]byte, error) { ret := _m.Called(ctx, filePaths) if len(ret) == 0 { panic("no return value specified for MultiRead") } var r0 [][]byte var r1 error if rf, ok := ret.Get(0).(func(context.Context, []string) ([][]byte, error)); ok { return rf(ctx, filePaths) } if rf, ok := ret.Get(0).(func(context.Context, []string) [][]byte); ok { r0 = rf(ctx, filePaths) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([][]byte) } } if rf, ok := ret.Get(1).(func(context.Context, []string) error); ok { r1 = rf(ctx, filePaths) } else { r1 = ret.Error(1) } return r0, r1 } // MockChunkManager_MultiRead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiRead' type MockChunkManager_MultiRead_Call struct { *mock.Call } // MultiRead is a helper method to define mock.On call // - ctx context.Context // - filePaths []string func (_e *MockChunkManager_Expecter) MultiRead(ctx interface{}, filePaths interface{}) *MockChunkManager_MultiRead_Call { return &MockChunkManager_MultiRead_Call{Call: _e.mock.On("MultiRead", ctx, filePaths)} } func (_c *MockChunkManager_MultiRead_Call) Run(run func(ctx context.Context, filePaths []string)) *MockChunkManager_MultiRead_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].([]string)) }) return _c } func (_c *MockChunkManager_MultiRead_Call) Return(_a0 [][]byte, _a1 error) *MockChunkManager_MultiRead_Call { _c.Call.Return(_a0, _a1) return _c } func (_c *MockChunkManager_MultiRead_Call) RunAndReturn(run func(context.Context, []string) ([][]byte, error)) *MockChunkManager_MultiRead_Call { _c.Call.Return(run) return _c } // MultiRemove provides a mock function with given fields: ctx, filePaths func (_m *MockChunkManager) MultiRemove(ctx context.Context, filePaths []string) error { ret := _m.Called(ctx, filePaths) if len(ret) == 0 { panic("no return value specified for MultiRemove") } var r0 error if rf, ok := ret.Get(0).(func(context.Context, []string) error); ok { r0 = rf(ctx, filePaths) } else { r0 = ret.Error(0) } return r0 } // MockChunkManager_MultiRemove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiRemove' type MockChunkManager_MultiRemove_Call struct { *mock.Call } // MultiRemove is a helper method to define mock.On call // - ctx context.Context // - filePaths []string func (_e *MockChunkManager_Expecter) MultiRemove(ctx interface{}, filePaths interface{}) *MockChunkManager_MultiRemove_Call { return &MockChunkManager_MultiRemove_Call{Call: _e.mock.On("MultiRemove", ctx, filePaths)} } func (_c *MockChunkManager_MultiRemove_Call) Run(run func(ctx context.Context, filePaths []string)) *MockChunkManager_MultiRemove_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].([]string)) }) return _c } func (_c *MockChunkManager_MultiRemove_Call) Return(_a0 error) *MockChunkManager_MultiRemove_Call { _c.Call.Return(_a0) return _c } func (_c *MockChunkManager_MultiRemove_Call) RunAndReturn(run func(context.Context, []string) error) *MockChunkManager_MultiRemove_Call { _c.Call.Return(run) return _c } // MultiWrite provides a mock function with given fields: ctx, contents func (_m *MockChunkManager) MultiWrite(ctx context.Context, contents map[string][]byte) error { ret := _m.Called(ctx, contents) if len(ret) == 0 { panic("no return value specified for MultiWrite") } var r0 error if rf, ok := ret.Get(0).(func(context.Context, map[string][]byte) error); ok { r0 = rf(ctx, contents) } else { r0 = ret.Error(0) } return r0 } // MockChunkManager_MultiWrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiWrite' type MockChunkManager_MultiWrite_Call struct { *mock.Call } // MultiWrite is a helper method to define mock.On call // - ctx context.Context // - contents map[string][]byte func (_e *MockChunkManager_Expecter) MultiWrite(ctx interface{}, contents interface{}) *MockChunkManager_MultiWrite_Call { return &MockChunkManager_MultiWrite_Call{Call: _e.mock.On("MultiWrite", ctx, contents)} } func (_c *MockChunkManager_MultiWrite_Call) Run(run func(ctx context.Context, contents map[string][]byte)) *MockChunkManager_MultiWrite_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].(map[string][]byte)) }) return _c } func (_c *MockChunkManager_MultiWrite_Call) Return(_a0 error) *MockChunkManager_MultiWrite_Call { _c.Call.Return(_a0) return _c } func (_c *MockChunkManager_MultiWrite_Call) RunAndReturn(run func(context.Context, map[string][]byte) error) *MockChunkManager_MultiWrite_Call { _c.Call.Return(run) return _c } // Path provides a mock function with given fields: ctx, filePath func (_m *MockChunkManager) Path(ctx context.Context, filePath string) (string, error) { ret := _m.Called(ctx, filePath) if len(ret) == 0 { panic("no return value specified for Path") } var r0 string var r1 error if rf, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok { return rf(ctx, filePath) } if rf, ok := ret.Get(0).(func(context.Context, string) string); ok { r0 = rf(ctx, filePath) } else { r0 = ret.Get(0).(string) } if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { r1 = rf(ctx, filePath) } else { r1 = ret.Error(1) } return r0, r1 } // MockChunkManager_Path_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Path' type MockChunkManager_Path_Call struct { *mock.Call } // Path is a helper method to define mock.On call // - ctx context.Context // - filePath string func (_e *MockChunkManager_Expecter) Path(ctx interface{}, filePath interface{}) *MockChunkManager_Path_Call { return &MockChunkManager_Path_Call{Call: _e.mock.On("Path", ctx, filePath)} } func (_c *MockChunkManager_Path_Call) Run(run func(ctx context.Context, filePath string)) *MockChunkManager_Path_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].(string)) }) return _c } func (_c *MockChunkManager_Path_Call) Return(_a0 string, _a1 error) *MockChunkManager_Path_Call { _c.Call.Return(_a0, _a1) return _c } func (_c *MockChunkManager_Path_Call) RunAndReturn(run func(context.Context, string) (string, error)) *MockChunkManager_Path_Call { _c.Call.Return(run) return _c } // Read provides a mock function with given fields: ctx, filePath func (_m *MockChunkManager) Read(ctx context.Context, filePath string) ([]byte, error) { ret := _m.Called(ctx, filePath) if len(ret) == 0 { panic("no return value specified for Read") } var r0 []byte var r1 error if rf, ok := ret.Get(0).(func(context.Context, string) ([]byte, error)); ok { return rf(ctx, filePath) } if rf, ok := ret.Get(0).(func(context.Context, string) []byte); ok { r0 = rf(ctx, filePath) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]byte) } } if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { r1 = rf(ctx, filePath) } else { r1 = ret.Error(1) } return r0, r1 } // MockChunkManager_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' type MockChunkManager_Read_Call struct { *mock.Call } // Read is a helper method to define mock.On call // - ctx context.Context // - filePath string func (_e *MockChunkManager_Expecter) Read(ctx interface{}, filePath interface{}) *MockChunkManager_Read_Call { return &MockChunkManager_Read_Call{Call: _e.mock.On("Read", ctx, filePath)} } func (_c *MockChunkManager_Read_Call) Run(run func(ctx context.Context, filePath string)) *MockChunkManager_Read_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].(string)) }) return _c } func (_c *MockChunkManager_Read_Call) Return(_a0 []byte, _a1 error) *MockChunkManager_Read_Call { _c.Call.Return(_a0, _a1) return _c } func (_c *MockChunkManager_Read_Call) RunAndReturn(run func(context.Context, string) ([]byte, error)) *MockChunkManager_Read_Call { _c.Call.Return(run) return _c } // ReadAt provides a mock function with given fields: ctx, filePath, off, length func (_m *MockChunkManager) ReadAt(ctx context.Context, filePath string, off int64, length int64) ([]byte, error) { ret := _m.Called(ctx, filePath, off, length) if len(ret) == 0 { panic("no return value specified for ReadAt") } var r0 []byte var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) ([]byte, error)); ok { return rf(ctx, filePath, off, length) } if rf, ok := ret.Get(0).(func(context.Context, string, int64, int64) []byte); ok { r0 = rf(ctx, filePath, off, length) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]byte) } } if rf, ok := ret.Get(1).(func(context.Context, string, int64, int64) error); ok { r1 = rf(ctx, filePath, off, length) } else { r1 = ret.Error(1) } return r0, r1 } // MockChunkManager_ReadAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadAt' type MockChunkManager_ReadAt_Call struct { *mock.Call } // ReadAt is a helper method to define mock.On call // - ctx context.Context // - filePath string // - off int64 // - length int64 func (_e *MockChunkManager_Expecter) ReadAt(ctx interface{}, filePath interface{}, off interface{}, length interface{}) *MockChunkManager_ReadAt_Call { return &MockChunkManager_ReadAt_Call{Call: _e.mock.On("ReadAt", ctx, filePath, off, length)} } func (_c *MockChunkManager_ReadAt_Call) Run(run func(ctx context.Context, filePath string, off int64, length int64)) *MockChunkManager_ReadAt_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(int64)) }) return _c } func (_c *MockChunkManager_ReadAt_Call) Return(p []byte, err error) *MockChunkManager_ReadAt_Call { _c.Call.Return(p, err) return _c } func (_c *MockChunkManager_ReadAt_Call) RunAndReturn(run func(context.Context, string, int64, int64) ([]byte, error)) *MockChunkManager_ReadAt_Call { _c.Call.Return(run) return _c } // Reader provides a mock function with given fields: ctx, filePath func (_m *MockChunkManager) Reader(ctx context.Context, filePath string) (storage.FileReader, error) { ret := _m.Called(ctx, filePath) if len(ret) == 0 { panic("no return value specified for Reader") } var r0 storage.FileReader var r1 error if rf, ok := ret.Get(0).(func(context.Context, string) (storage.FileReader, error)); ok { return rf(ctx, filePath) } if rf, ok := ret.Get(0).(func(context.Context, string) storage.FileReader); ok { r0 = rf(ctx, filePath) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(storage.FileReader) } } if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { r1 = rf(ctx, filePath) } else { r1 = ret.Error(1) } return r0, r1 } // MockChunkManager_Reader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reader' type MockChunkManager_Reader_Call struct { *mock.Call } // Reader is a helper method to define mock.On call // - ctx context.Context // - filePath string func (_e *MockChunkManager_Expecter) Reader(ctx interface{}, filePath interface{}) *MockChunkManager_Reader_Call { return &MockChunkManager_Reader_Call{Call: _e.mock.On("Reader", ctx, filePath)} } func (_c *MockChunkManager_Reader_Call) Run(run func(ctx context.Context, filePath string)) *MockChunkManager_Reader_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].(string)) }) return _c } func (_c *MockChunkManager_Reader_Call) Return(_a0 storage.FileReader, _a1 error) *MockChunkManager_Reader_Call { _c.Call.Return(_a0, _a1) return _c } func (_c *MockChunkManager_Reader_Call) RunAndReturn(run func(context.Context, string) (storage.FileReader, error)) *MockChunkManager_Reader_Call { _c.Call.Return(run) return _c } // Remove provides a mock function with given fields: ctx, filePath func (_m *MockChunkManager) Remove(ctx context.Context, filePath string) error { ret := _m.Called(ctx, filePath) if len(ret) == 0 { panic("no return value specified for Remove") } var r0 error if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { r0 = rf(ctx, filePath) } else { r0 = ret.Error(0) } return r0 } // MockChunkManager_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove' type MockChunkManager_Remove_Call struct { *mock.Call } // Remove is a helper method to define mock.On call // - ctx context.Context // - filePath string func (_e *MockChunkManager_Expecter) Remove(ctx interface{}, filePath interface{}) *MockChunkManager_Remove_Call { return &MockChunkManager_Remove_Call{Call: _e.mock.On("Remove", ctx, filePath)} } func (_c *MockChunkManager_Remove_Call) Run(run func(ctx context.Context, filePath string)) *MockChunkManager_Remove_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].(string)) }) return _c } func (_c *MockChunkManager_Remove_Call) Return(_a0 error) *MockChunkManager_Remove_Call { _c.Call.Return(_a0) return _c } func (_c *MockChunkManager_Remove_Call) RunAndReturn(run func(context.Context, string) error) *MockChunkManager_Remove_Call { _c.Call.Return(run) return _c } // RemoveWithPrefix provides a mock function with given fields: ctx, prefix func (_m *MockChunkManager) RemoveWithPrefix(ctx context.Context, prefix string) error { ret := _m.Called(ctx, prefix) if len(ret) == 0 { panic("no return value specified for RemoveWithPrefix") } var r0 error if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { r0 = rf(ctx, prefix) } else { r0 = ret.Error(0) } return r0 } // MockChunkManager_RemoveWithPrefix_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveWithPrefix' type MockChunkManager_RemoveWithPrefix_Call struct { *mock.Call } // RemoveWithPrefix is a helper method to define mock.On call // - ctx context.Context // - prefix string func (_e *MockChunkManager_Expecter) RemoveWithPrefix(ctx interface{}, prefix interface{}) *MockChunkManager_RemoveWithPrefix_Call { return &MockChunkManager_RemoveWithPrefix_Call{Call: _e.mock.On("RemoveWithPrefix", ctx, prefix)} } func (_c *MockChunkManager_RemoveWithPrefix_Call) Run(run func(ctx context.Context, prefix string)) *MockChunkManager_RemoveWithPrefix_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].(string)) }) return _c } func (_c *MockChunkManager_RemoveWithPrefix_Call) Return(_a0 error) *MockChunkManager_RemoveWithPrefix_Call { _c.Call.Return(_a0) return _c } func (_c *MockChunkManager_RemoveWithPrefix_Call) RunAndReturn(run func(context.Context, string) error) *MockChunkManager_RemoveWithPrefix_Call { _c.Call.Return(run) return _c } // RootPath provides a mock function with given fields: func (_m *MockChunkManager) RootPath() string { ret := _m.Called() if len(ret) == 0 { panic("no return value specified for RootPath") } var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() } else { r0 = ret.Get(0).(string) } return r0 } // MockChunkManager_RootPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RootPath' type MockChunkManager_RootPath_Call struct { *mock.Call } // RootPath is a helper method to define mock.On call func (_e *MockChunkManager_Expecter) RootPath() *MockChunkManager_RootPath_Call { return &MockChunkManager_RootPath_Call{Call: _e.mock.On("RootPath")} } func (_c *MockChunkManager_RootPath_Call) Run(run func()) *MockChunkManager_RootPath_Call { _c.Call.Run(func(args mock.Arguments) { run() }) return _c } func (_c *MockChunkManager_RootPath_Call) Return(_a0 string) *MockChunkManager_RootPath_Call { _c.Call.Return(_a0) return _c } func (_c *MockChunkManager_RootPath_Call) RunAndReturn(run func() string) *MockChunkManager_RootPath_Call { _c.Call.Return(run) return _c } // Size provides a mock function with given fields: ctx, filePath func (_m *MockChunkManager) Size(ctx context.Context, filePath string) (int64, error) { ret := _m.Called(ctx, filePath) if len(ret) == 0 { panic("no return value specified for Size") } var r0 int64 var r1 error if rf, ok := ret.Get(0).(func(context.Context, string) (int64, error)); ok { return rf(ctx, filePath) } if rf, ok := ret.Get(0).(func(context.Context, string) int64); ok { r0 = rf(ctx, filePath) } else { r0 = ret.Get(0).(int64) } if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { r1 = rf(ctx, filePath) } else { r1 = ret.Error(1) } return r0, r1 } // MockChunkManager_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size' type MockChunkManager_Size_Call struct { *mock.Call } // Size is a helper method to define mock.On call // - ctx context.Context // - filePath string func (_e *MockChunkManager_Expecter) Size(ctx interface{}, filePath interface{}) *MockChunkManager_Size_Call { return &MockChunkManager_Size_Call{Call: _e.mock.On("Size", ctx, filePath)} } func (_c *MockChunkManager_Size_Call) Run(run func(ctx context.Context, filePath string)) *MockChunkManager_Size_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].(string)) }) return _c } func (_c *MockChunkManager_Size_Call) Return(_a0 int64, _a1 error) *MockChunkManager_Size_Call { _c.Call.Return(_a0, _a1) return _c } func (_c *MockChunkManager_Size_Call) RunAndReturn(run func(context.Context, string) (int64, error)) *MockChunkManager_Size_Call { _c.Call.Return(run) return _c } // WalkWithPrefix provides a mock function with given fields: ctx, prefix, recursive, walkFunc func (_m *MockChunkManager) WalkWithPrefix(ctx context.Context, prefix string, recursive bool, walkFunc storage.ChunkObjectWalkFunc) error { ret := _m.Called(ctx, prefix, recursive, walkFunc) if len(ret) == 0 { panic("no return value specified for WalkWithPrefix") } var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, bool, storage.ChunkObjectWalkFunc) error); ok { r0 = rf(ctx, prefix, recursive, walkFunc) } else { r0 = ret.Error(0) } return r0 } // MockChunkManager_WalkWithPrefix_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WalkWithPrefix' type MockChunkManager_WalkWithPrefix_Call struct { *mock.Call } // WalkWithPrefix is a helper method to define mock.On call // - ctx context.Context // - prefix string // - recursive bool // - walkFunc storage.ChunkObjectWalkFunc func (_e *MockChunkManager_Expecter) WalkWithPrefix(ctx interface{}, prefix interface{}, recursive interface{}, walkFunc interface{}) *MockChunkManager_WalkWithPrefix_Call { return &MockChunkManager_WalkWithPrefix_Call{Call: _e.mock.On("WalkWithPrefix", ctx, prefix, recursive, walkFunc)} } func (_c *MockChunkManager_WalkWithPrefix_Call) Run(run func(ctx context.Context, prefix string, recursive bool, walkFunc storage.ChunkObjectWalkFunc)) *MockChunkManager_WalkWithPrefix_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].(string), args[2].(bool), args[3].(storage.ChunkObjectWalkFunc)) }) return _c } func (_c *MockChunkManager_WalkWithPrefix_Call) Return(_a0 error) *MockChunkManager_WalkWithPrefix_Call { _c.Call.Return(_a0) return _c } func (_c *MockChunkManager_WalkWithPrefix_Call) RunAndReturn(run func(context.Context, string, bool, storage.ChunkObjectWalkFunc) error) *MockChunkManager_WalkWithPrefix_Call { _c.Call.Return(run) return _c } // Write provides a mock function with given fields: ctx, filePath, content func (_m *MockChunkManager) Write(ctx context.Context, filePath string, content []byte) error { ret := _m.Called(ctx, filePath, content) if len(ret) == 0 { panic("no return value specified for Write") } var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, []byte) error); ok { r0 = rf(ctx, filePath, content) } else { r0 = ret.Error(0) } return r0 } // MockChunkManager_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write' type MockChunkManager_Write_Call struct { *mock.Call } // Write is a helper method to define mock.On call // - ctx context.Context // - filePath string // - content []byte func (_e *MockChunkManager_Expecter) Write(ctx interface{}, filePath interface{}, content interface{}) *MockChunkManager_Write_Call { return &MockChunkManager_Write_Call{Call: _e.mock.On("Write", ctx, filePath, content)} } func (_c *MockChunkManager_Write_Call) Run(run func(ctx context.Context, filePath string, content []byte)) *MockChunkManager_Write_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].(string), args[2].([]byte)) }) return _c } func (_c *MockChunkManager_Write_Call) Return(_a0 error) *MockChunkManager_Write_Call { _c.Call.Return(_a0) return _c } func (_c *MockChunkManager_Write_Call) RunAndReturn(run func(context.Context, string, []byte) error) *MockChunkManager_Write_Call { _c.Call.Return(run) return _c } // NewMockChunkManager creates a new instance of MockChunkManager. 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 NewMockChunkManager(t interface { mock.TestingT Cleanup(func()) }) *MockChunkManager { mock := &MockChunkManager{} mock.Mock.Test(t) t.Cleanup(func() { mock.AssertExpectations(t) }) return mock }