store.go

// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"

	"github.com/evstack/ev-node/pkg/store"
	"github.com/evstack/ev-node/types"
	mock "github.com/stretchr/testify/mock"
)

// NewMockStore creates a new instance of MockStore. 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 NewMockStore(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockStore {
	mock := &MockStore{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockStore is an autogenerated mock type for the Store type
type MockStore struct {
	mock.Mock
}

type MockStore_Expecter struct {
	mock *mock.Mock
}

func (_m *MockStore) EXPECT() *MockStore_Expecter {
	return &MockStore_Expecter{mock: &_m.Mock}
}

// Close provides a mock function for the type MockStore
func (_mock *MockStore) Close() error {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for Close")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func() error); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockStore_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
type MockStore_Close_Call struct {
	*mock.Call
}

// Close is a helper method to define mock.On call
func (_e *MockStore_Expecter) Close() *MockStore_Close_Call {
	return &MockStore_Close_Call{Call: _e.mock.On("Close")}
}

func (_c *MockStore_Close_Call) Run(run func()) *MockStore_Close_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockStore_Close_Call) Return(err error) *MockStore_Close_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockStore_Close_Call) RunAndReturn(run func() error) *MockStore_Close_Call {
	_c.Call.Return(run)
	return _c
}

// GetBlockByHash provides a mock function for the type MockStore
func (_mock *MockStore) GetBlockByHash(ctx context.Context, hash []byte) (*types.SignedHeader, *types.Data, error) {
	ret := _mock.Called(ctx, hash)

	if len(ret) == 0 {
		panic("no return value specified for GetBlockByHash")
	}

	var r0 *types.SignedHeader
	var r1 *types.Data
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte) (*types.SignedHeader, *types.Data, error)); ok {
		return returnFunc(ctx, hash)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte) *types.SignedHeader); ok {
		r0 = returnFunc(ctx, hash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.SignedHeader)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []byte) *types.Data); ok {
		r1 = returnFunc(ctx, hash)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*types.Data)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, []byte) error); ok {
		r2 = returnFunc(ctx, hash)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockStore_GetBlockByHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlockByHash'
type MockStore_GetBlockByHash_Call struct {
	*mock.Call
}

// GetBlockByHash is a helper method to define mock.On call
//   - ctx context.Context
//   - hash []byte
func (_e *MockStore_Expecter) GetBlockByHash(ctx interface{}, hash interface{}) *MockStore_GetBlockByHash_Call {
	return &MockStore_GetBlockByHash_Call{Call: _e.mock.On("GetBlockByHash", ctx, hash)}
}

func (_c *MockStore_GetBlockByHash_Call) Run(run func(ctx context.Context, hash []byte)) *MockStore_GetBlockByHash_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []byte
		if args[1] != nil {
			arg1 = args[1].([]byte)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockStore_GetBlockByHash_Call) Return(signedHeader *types.SignedHeader, data *types.Data, err error) *MockStore_GetBlockByHash_Call {
	_c.Call.Return(signedHeader, data, err)
	return _c
}

func (_c *MockStore_GetBlockByHash_Call) RunAndReturn(run func(ctx context.Context, hash []byte) (*types.SignedHeader, *types.Data, error)) *MockStore_GetBlockByHash_Call {
	_c.Call.Return(run)
	return _c
}

// GetBlockData provides a mock function for the type MockStore
func (_mock *MockStore) GetBlockData(ctx context.Context, height uint64) (*types.SignedHeader, *types.Data, error) {
	ret := _mock.Called(ctx, height)

	if len(ret) == 0 {
		panic("no return value specified for GetBlockData")
	}

	var r0 *types.SignedHeader
	var r1 *types.Data
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint64) (*types.SignedHeader, *types.Data, error)); ok {
		return returnFunc(ctx, height)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint64) *types.SignedHeader); ok {
		r0 = returnFunc(ctx, height)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.SignedHeader)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint64) *types.Data); ok {
		r1 = returnFunc(ctx, height)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*types.Data)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, uint64) error); ok {
		r2 = returnFunc(ctx, height)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockStore_GetBlockData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlockData'
type MockStore_GetBlockData_Call struct {
	*mock.Call
}

// GetBlockData is a helper method to define mock.On call
//   - ctx context.Context
//   - height uint64
func (_e *MockStore_Expecter) GetBlockData(ctx interface{}, height interface{}) *MockStore_GetBlockData_Call {
	return &MockStore_GetBlockData_Call{Call: _e.mock.On("GetBlockData", ctx, height)}
}

func (_c *MockStore_GetBlockData_Call) Run(run func(ctx context.Context, height uint64)) *MockStore_GetBlockData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint64
		if args[1] != nil {
			arg1 = args[1].(uint64)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockStore_GetBlockData_Call) Return(signedHeader *types.SignedHeader, data *types.Data, err error) *MockStore_GetBlockData_Call {
	_c.Call.Return(signedHeader, data, err)
	return _c
}

func (_c *MockStore_GetBlockData_Call) RunAndReturn(run func(ctx context.Context, height uint64) (*types.SignedHeader, *types.Data, error)) *MockStore_GetBlockData_Call {
	_c.Call.Return(run)
	return _c
}

// GetHeader provides a mock function for the type MockStore
func (_mock *MockStore) GetHeader(ctx context.Context, height uint64) (*types.SignedHeader, error) {
	ret := _mock.Called(ctx, height)

	if len(ret) == 0 {
		panic("no return value specified for GetHeader")
	}

	var r0 *types.SignedHeader
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint64) (*types.SignedHeader, error)); ok {
		return returnFunc(ctx, height)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint64) *types.SignedHeader); ok {
		r0 = returnFunc(ctx, height)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.SignedHeader)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint64) error); ok {
		r1 = returnFunc(ctx, height)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockStore_GetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHeader'
type MockStore_GetHeader_Call struct {
	*mock.Call
}

// GetHeader is a helper method to define mock.On call
//   - ctx context.Context
//   - height uint64
func (_e *MockStore_Expecter) GetHeader(ctx interface{}, height interface{}) *MockStore_GetHeader_Call {
	return &MockStore_GetHeader_Call{Call: _e.mock.On("GetHeader", ctx, height)}
}

func (_c *MockStore_GetHeader_Call) Run(run func(ctx context.Context, height uint64)) *MockStore_GetHeader_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint64
		if args[1] != nil {
			arg1 = args[1].(uint64)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockStore_GetHeader_Call) Return(signedHeader *types.SignedHeader, err error) *MockStore_GetHeader_Call {
	_c.Call.Return(signedHeader, err)
	return _c
}

func (_c *MockStore_GetHeader_Call) RunAndReturn(run func(ctx context.Context, height uint64) (*types.SignedHeader, error)) *MockStore_GetHeader_Call {
	_c.Call.Return(run)
	return _c
}

// GetMetadata provides a mock function for the type MockStore
func (_mock *MockStore) GetMetadata(ctx context.Context, key string) ([]byte, error) {
	ret := _mock.Called(ctx, key)

	if len(ret) == 0 {
		panic("no return value specified for GetMetadata")
	}

	var r0 []byte
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]byte, error)); ok {
		return returnFunc(ctx, key)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []byte); ok {
		r0 = returnFunc(ctx, key)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, key)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockStore_GetMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMetadata'
type MockStore_GetMetadata_Call struct {
	*mock.Call
}

// GetMetadata is a helper method to define mock.On call
//   - ctx context.Context
//   - key string
func (_e *MockStore_Expecter) GetMetadata(ctx interface{}, key interface{}) *MockStore_GetMetadata_Call {
	return &MockStore_GetMetadata_Call{Call: _e.mock.On("GetMetadata", ctx, key)}
}

func (_c *MockStore_GetMetadata_Call) Run(run func(ctx context.Context, key string)) *MockStore_GetMetadata_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockStore_GetMetadata_Call) Return(bytes []byte, err error) *MockStore_GetMetadata_Call {
	_c.Call.Return(bytes, err)
	return _c
}

func (_c *MockStore_GetMetadata_Call) RunAndReturn(run func(ctx context.Context, key string) ([]byte, error)) *MockStore_GetMetadata_Call {
	_c.Call.Return(run)
	return _c
}

// GetSignature provides a mock function for the type MockStore
func (_mock *MockStore) GetSignature(ctx context.Context, height uint64) (*types.Signature, error) {
	ret := _mock.Called(ctx, height)

	if len(ret) == 0 {
		panic("no return value specified for GetSignature")
	}

	var r0 *types.Signature
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint64) (*types.Signature, error)); ok {
		return returnFunc(ctx, height)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint64) *types.Signature); ok {
		r0 = returnFunc(ctx, height)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Signature)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint64) error); ok {
		r1 = returnFunc(ctx, height)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockStore_GetSignature_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSignature'
type MockStore_GetSignature_Call struct {
	*mock.Call
}

// GetSignature is a helper method to define mock.On call
//   - ctx context.Context
//   - height uint64
func (_e *MockStore_Expecter) GetSignature(ctx interface{}, height interface{}) *MockStore_GetSignature_Call {
	return &MockStore_GetSignature_Call{Call: _e.mock.On("GetSignature", ctx, height)}
}

func (_c *MockStore_GetSignature_Call) Run(run func(ctx context.Context, height uint64)) *MockStore_GetSignature_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint64
		if args[1] != nil {
			arg1 = args[1].(uint64)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockStore_GetSignature_Call) Return(signature *types.Signature, err error) *MockStore_GetSignature_Call {
	_c.Call.Return(signature, err)
	return _c
}

func (_c *MockStore_GetSignature_Call) RunAndReturn(run func(ctx context.Context, height uint64) (*types.Signature, error)) *MockStore_GetSignature_Call {
	_c.Call.Return(run)
	return _c
}

// GetSignatureByHash provides a mock function for the type MockStore
func (_mock *MockStore) GetSignatureByHash(ctx context.Context, hash []byte) (*types.Signature, error) {
	ret := _mock.Called(ctx, hash)

	if len(ret) == 0 {
		panic("no return value specified for GetSignatureByHash")
	}

	var r0 *types.Signature
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte) (*types.Signature, error)); ok {
		return returnFunc(ctx, hash)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte) *types.Signature); ok {
		r0 = returnFunc(ctx, hash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Signature)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []byte) error); ok {
		r1 = returnFunc(ctx, hash)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockStore_GetSignatureByHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSignatureByHash'
type MockStore_GetSignatureByHash_Call struct {
	*mock.Call
}

// GetSignatureByHash is a helper method to define mock.On call
//   - ctx context.Context
//   - hash []byte
func (_e *MockStore_Expecter) GetSignatureByHash(ctx interface{}, hash interface{}) *MockStore_GetSignatureByHash_Call {
	return &MockStore_GetSignatureByHash_Call{Call: _e.mock.On("GetSignatureByHash", ctx, hash)}
}

func (_c *MockStore_GetSignatureByHash_Call) Run(run func(ctx context.Context, hash []byte)) *MockStore_GetSignatureByHash_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []byte
		if args[1] != nil {
			arg1 = args[1].([]byte)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockStore_GetSignatureByHash_Call) Return(signature *types.Signature, err error) *MockStore_GetSignatureByHash_Call {
	_c.Call.Return(signature, err)
	return _c
}

func (_c *MockStore_GetSignatureByHash_Call) RunAndReturn(run func(ctx context.Context, hash []byte) (*types.Signature, error)) *MockStore_GetSignatureByHash_Call {
	_c.Call.Return(run)
	return _c
}

// GetState provides a mock function for the type MockStore
func (_mock *MockStore) GetState(ctx context.Context) (types.State, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetState")
	}

	var r0 types.State
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (types.State, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) types.State); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(types.State)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockStore_GetState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetState'
type MockStore_GetState_Call struct {
	*mock.Call
}

// GetState is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockStore_Expecter) GetState(ctx interface{}) *MockStore_GetState_Call {
	return &MockStore_GetState_Call{Call: _e.mock.On("GetState", ctx)}
}

func (_c *MockStore_GetState_Call) Run(run func(ctx context.Context)) *MockStore_GetState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockStore_GetState_Call) Return(state types.State, err error) *MockStore_GetState_Call {
	_c.Call.Return(state, err)
	return _c
}

func (_c *MockStore_GetState_Call) RunAndReturn(run func(ctx context.Context) (types.State, error)) *MockStore_GetState_Call {
	_c.Call.Return(run)
	return _c
}

// GetStateAtHeight provides a mock function for the type MockStore
func (_mock *MockStore) GetStateAtHeight(ctx context.Context, height uint64) (types.State, error) {
	ret := _mock.Called(ctx, height)

	if len(ret) == 0 {
		panic("no return value specified for GetStateAtHeight")
	}

	var r0 types.State
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint64) (types.State, error)); ok {
		return returnFunc(ctx, height)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint64) types.State); ok {
		r0 = returnFunc(ctx, height)
	} else {
		r0 = ret.Get(0).(types.State)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint64) error); ok {
		r1 = returnFunc(ctx, height)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockStore_GetStateAtHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStateAtHeight'
type MockStore_GetStateAtHeight_Call struct {
	*mock.Call
}

// GetStateAtHeight is a helper method to define mock.On call
//   - ctx context.Context
//   - height uint64
func (_e *MockStore_Expecter) GetStateAtHeight(ctx interface{}, height interface{}) *MockStore_GetStateAtHeight_Call {
	return &MockStore_GetStateAtHeight_Call{Call: _e.mock.On("GetStateAtHeight", ctx, height)}
}

func (_c *MockStore_GetStateAtHeight_Call) Run(run func(ctx context.Context, height uint64)) *MockStore_GetStateAtHeight_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint64
		if args[1] != nil {
			arg1 = args[1].(uint64)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockStore_GetStateAtHeight_Call) Return(state types.State, err error) *MockStore_GetStateAtHeight_Call {
	_c.Call.Return(state, err)
	return _c
}

func (_c *MockStore_GetStateAtHeight_Call) RunAndReturn(run func(ctx context.Context, height uint64) (types.State, error)) *MockStore_GetStateAtHeight_Call {
	_c.Call.Return(run)
	return _c
}

// Height provides a mock function for the type MockStore
func (_mock *MockStore) Height(ctx context.Context) (uint64, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Height")
	}

	var r0 uint64
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (uint64, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) uint64); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(uint64)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockStore_Height_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Height'
type MockStore_Height_Call struct {
	*mock.Call
}

// Height is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockStore_Expecter) Height(ctx interface{}) *MockStore_Height_Call {
	return &MockStore_Height_Call{Call: _e.mock.On("Height", ctx)}
}

func (_c *MockStore_Height_Call) Run(run func(ctx context.Context)) *MockStore_Height_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockStore_Height_Call) Return(v uint64, err error) *MockStore_Height_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *MockStore_Height_Call) RunAndReturn(run func(ctx context.Context) (uint64, error)) *MockStore_Height_Call {
	_c.Call.Return(run)
	return _c
}

// NewBatch provides a mock function for the type MockStore
func (_mock *MockStore) NewBatch(ctx context.Context) (store.Batch, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for NewBatch")
	}

	var r0 store.Batch
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (store.Batch, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) store.Batch); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(store.Batch)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockStore_NewBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewBatch'
type MockStore_NewBatch_Call struct {
	*mock.Call
}

// NewBatch is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockStore_Expecter) NewBatch(ctx interface{}) *MockStore_NewBatch_Call {
	return &MockStore_NewBatch_Call{Call: _e.mock.On("NewBatch", ctx)}
}

func (_c *MockStore_NewBatch_Call) Run(run func(ctx context.Context)) *MockStore_NewBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockStore_NewBatch_Call) Return(batch store.Batch, err error) *MockStore_NewBatch_Call {
	_c.Call.Return(batch, err)
	return _c
}

func (_c *MockStore_NewBatch_Call) RunAndReturn(run func(ctx context.Context) (store.Batch, error)) *MockStore_NewBatch_Call {
	_c.Call.Return(run)
	return _c
}

// Rollback provides a mock function for the type MockStore
func (_mock *MockStore) Rollback(ctx context.Context, height uint64, aggregator bool) error {
	ret := _mock.Called(ctx, height, aggregator)

	if len(ret) == 0 {
		panic("no return value specified for Rollback")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint64, bool) error); ok {
		r0 = returnFunc(ctx, height, aggregator)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockStore_Rollback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Rollback'
type MockStore_Rollback_Call struct {
	*mock.Call
}

// Rollback is a helper method to define mock.On call
//   - ctx context.Context
//   - height uint64
//   - aggregator bool
func (_e *MockStore_Expecter) Rollback(ctx interface{}, height interface{}, aggregator interface{}) *MockStore_Rollback_Call {
	return &MockStore_Rollback_Call{Call: _e.mock.On("Rollback", ctx, height, aggregator)}
}

func (_c *MockStore_Rollback_Call) Run(run func(ctx context.Context, height uint64, aggregator bool)) *MockStore_Rollback_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint64
		if args[1] != nil {
			arg1 = args[1].(uint64)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockStore_Rollback_Call) Return(err error) *MockStore_Rollback_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockStore_Rollback_Call) RunAndReturn(run func(ctx context.Context, height uint64, aggregator bool) error) *MockStore_Rollback_Call {
	_c.Call.Return(run)
	return _c
}

// SetMetadata provides a mock function for the type MockStore
func (_mock *MockStore) SetMetadata(ctx context.Context, key string, value []byte) error {
	ret := _mock.Called(ctx, key, value)

	if len(ret) == 0 {
		panic("no return value specified for SetMetadata")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []byte) error); ok {
		r0 = returnFunc(ctx, key, value)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockStore_SetMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMetadata'
type MockStore_SetMetadata_Call struct {
	*mock.Call
}

// SetMetadata is a helper method to define mock.On call
//   - ctx context.Context
//   - key string
//   - value []byte
func (_e *MockStore_Expecter) SetMetadata(ctx interface{}, key interface{}, value interface{}) *MockStore_SetMetadata_Call {
	return &MockStore_SetMetadata_Call{Call: _e.mock.On("SetMetadata", ctx, key, value)}
}

func (_c *MockStore_SetMetadata_Call) Run(run func(ctx context.Context, key string, value []byte)) *MockStore_SetMetadata_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []byte
		if args[2] != nil {
			arg2 = args[2].([]byte)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockStore_SetMetadata_Call) Return(err error) *MockStore_SetMetadata_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockStore_SetMetadata_Call) RunAndReturn(run func(ctx context.Context, key string, value []byte) error) *MockStore_SetMetadata_Call {
	_c.Call.Return(run)
	return _c
}

// Sync provides a mock function for the type MockStore
func (_mock *MockStore) Sync(ctx context.Context) error {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Sync")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockStore_Sync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sync'
type MockStore_Sync_Call struct {
	*mock.Call
}

// Sync is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockStore_Expecter) Sync(ctx interface{}) *MockStore_Sync_Call {
	return &MockStore_Sync_Call{Call: _e.mock.On("Sync", ctx)}
}

func (_c *MockStore_Sync_Call) Run(run func(ctx context.Context)) *MockStore_Sync_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockStore_Sync_Call) Return(err error) *MockStore_Sync_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockStore_Sync_Call) RunAndReturn(run func(ctx context.Context) error) *MockStore_Sync_Call {
	_c.Call.Return(run)
	return _c
}