mock_storage.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/google/trillian/storage (interfaces: AdminStorage,AdminTX,LogStorage,LogTreeTX,MapStorage,MapTreeTX,ReadOnlyAdminTX,ReadOnlyLogTX,ReadOnlyLogTreeTX,ReadOnlyMapTreeTX)

// Package storage is a generated GoMock package.
package storage

import (
	context "context"
	gomock "github.com/golang/mock/gomock"
	trillian "github.com/google/trillian"
	reflect "reflect"
	time "time"
)

// MockAdminStorage is a mock of AdminStorage interface
type MockAdminStorage struct {
	ctrl     *gomock.Controller
	recorder *MockAdminStorageMockRecorder
}

// MockAdminStorageMockRecorder is the mock recorder for MockAdminStorage
type MockAdminStorageMockRecorder struct {
	mock *MockAdminStorage
}

// NewMockAdminStorage creates a new mock instance
func NewMockAdminStorage(ctrl *gomock.Controller) *MockAdminStorage {
	mock := &MockAdminStorage{ctrl: ctrl}
	mock.recorder = &MockAdminStorageMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockAdminStorage) EXPECT() *MockAdminStorageMockRecorder {
	return m.recorder
}

// Begin mocks base method
func (m *MockAdminStorage) Begin(arg0 context.Context) (AdminTX, error) {
	ret := m.ctrl.Call(m, "Begin", arg0)
	ret0, _ := ret[0].(AdminTX)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Begin indicates an expected call of Begin
func (mr *MockAdminStorageMockRecorder) Begin(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Begin", reflect.TypeOf((*MockAdminStorage)(nil).Begin), arg0)
}

// CheckDatabaseAccessible mocks base method
func (m *MockAdminStorage) CheckDatabaseAccessible(arg0 context.Context) error {
	ret := m.ctrl.Call(m, "CheckDatabaseAccessible", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckDatabaseAccessible indicates an expected call of CheckDatabaseAccessible
func (mr *MockAdminStorageMockRecorder) CheckDatabaseAccessible(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckDatabaseAccessible", reflect.TypeOf((*MockAdminStorage)(nil).CheckDatabaseAccessible), arg0)
}

// Snapshot mocks base method
func (m *MockAdminStorage) Snapshot(arg0 context.Context) (ReadOnlyAdminTX, error) {
	ret := m.ctrl.Call(m, "Snapshot", arg0)
	ret0, _ := ret[0].(ReadOnlyAdminTX)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Snapshot indicates an expected call of Snapshot
func (mr *MockAdminStorageMockRecorder) Snapshot(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Snapshot", reflect.TypeOf((*MockAdminStorage)(nil).Snapshot), arg0)
}

// MockAdminTX is a mock of AdminTX interface
type MockAdminTX struct {
	ctrl     *gomock.Controller
	recorder *MockAdminTXMockRecorder
}

// MockAdminTXMockRecorder is the mock recorder for MockAdminTX
type MockAdminTXMockRecorder struct {
	mock *MockAdminTX
}

// NewMockAdminTX creates a new mock instance
func NewMockAdminTX(ctrl *gomock.Controller) *MockAdminTX {
	mock := &MockAdminTX{ctrl: ctrl}
	mock.recorder = &MockAdminTXMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockAdminTX) EXPECT() *MockAdminTXMockRecorder {
	return m.recorder
}

// Close mocks base method
func (m *MockAdminTX) Close() error {
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockAdminTXMockRecorder) Close() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockAdminTX)(nil).Close))
}

// Commit mocks base method
func (m *MockAdminTX) Commit() error {
	ret := m.ctrl.Call(m, "Commit")
	ret0, _ := ret[0].(error)
	return ret0
}

// Commit indicates an expected call of Commit
func (mr *MockAdminTXMockRecorder) Commit() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockAdminTX)(nil).Commit))
}

// CreateTree mocks base method
func (m *MockAdminTX) CreateTree(arg0 context.Context, arg1 *trillian.Tree) (*trillian.Tree, error) {
	ret := m.ctrl.Call(m, "CreateTree", arg0, arg1)
	ret0, _ := ret[0].(*trillian.Tree)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTree indicates an expected call of CreateTree
func (mr *MockAdminTXMockRecorder) CreateTree(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTree", reflect.TypeOf((*MockAdminTX)(nil).CreateTree), arg0, arg1)
}

// GetTree mocks base method
func (m *MockAdminTX) GetTree(arg0 context.Context, arg1 int64) (*trillian.Tree, error) {
	ret := m.ctrl.Call(m, "GetTree", arg0, arg1)
	ret0, _ := ret[0].(*trillian.Tree)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTree indicates an expected call of GetTree
func (mr *MockAdminTXMockRecorder) GetTree(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTree", reflect.TypeOf((*MockAdminTX)(nil).GetTree), arg0, arg1)
}

// HardDeleteTree mocks base method
func (m *MockAdminTX) HardDeleteTree(arg0 context.Context, arg1 int64) error {
	ret := m.ctrl.Call(m, "HardDeleteTree", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// HardDeleteTree indicates an expected call of HardDeleteTree
func (mr *MockAdminTXMockRecorder) HardDeleteTree(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HardDeleteTree", reflect.TypeOf((*MockAdminTX)(nil).HardDeleteTree), arg0, arg1)
}

// IsClosed mocks base method
func (m *MockAdminTX) IsClosed() bool {
	ret := m.ctrl.Call(m, "IsClosed")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsClosed indicates an expected call of IsClosed
func (mr *MockAdminTXMockRecorder) IsClosed() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsClosed", reflect.TypeOf((*MockAdminTX)(nil).IsClosed))
}

// ListTreeIDs mocks base method
func (m *MockAdminTX) ListTreeIDs(arg0 context.Context, arg1 bool) ([]int64, error) {
	ret := m.ctrl.Call(m, "ListTreeIDs", arg0, arg1)
	ret0, _ := ret[0].([]int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTreeIDs indicates an expected call of ListTreeIDs
func (mr *MockAdminTXMockRecorder) ListTreeIDs(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTreeIDs", reflect.TypeOf((*MockAdminTX)(nil).ListTreeIDs), arg0, arg1)
}

// ListTrees mocks base method
func (m *MockAdminTX) ListTrees(arg0 context.Context, arg1 bool) ([]*trillian.Tree, error) {
	ret := m.ctrl.Call(m, "ListTrees", arg0, arg1)
	ret0, _ := ret[0].([]*trillian.Tree)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrees indicates an expected call of ListTrees
func (mr *MockAdminTXMockRecorder) ListTrees(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrees", reflect.TypeOf((*MockAdminTX)(nil).ListTrees), arg0, arg1)
}

// Rollback mocks base method
func (m *MockAdminTX) Rollback() error {
	ret := m.ctrl.Call(m, "Rollback")
	ret0, _ := ret[0].(error)
	return ret0
}

// Rollback indicates an expected call of Rollback
func (mr *MockAdminTXMockRecorder) Rollback() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockAdminTX)(nil).Rollback))
}

// SoftDeleteTree mocks base method
func (m *MockAdminTX) SoftDeleteTree(arg0 context.Context, arg1 int64) (*trillian.Tree, error) {
	ret := m.ctrl.Call(m, "SoftDeleteTree", arg0, arg1)
	ret0, _ := ret[0].(*trillian.Tree)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SoftDeleteTree indicates an expected call of SoftDeleteTree
func (mr *MockAdminTXMockRecorder) SoftDeleteTree(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SoftDeleteTree", reflect.TypeOf((*MockAdminTX)(nil).SoftDeleteTree), arg0, arg1)
}

// UndeleteTree mocks base method
func (m *MockAdminTX) UndeleteTree(arg0 context.Context, arg1 int64) (*trillian.Tree, error) {
	ret := m.ctrl.Call(m, "UndeleteTree", arg0, arg1)
	ret0, _ := ret[0].(*trillian.Tree)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UndeleteTree indicates an expected call of UndeleteTree
func (mr *MockAdminTXMockRecorder) UndeleteTree(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UndeleteTree", reflect.TypeOf((*MockAdminTX)(nil).UndeleteTree), arg0, arg1)
}

// UpdateTree mocks base method
func (m *MockAdminTX) UpdateTree(arg0 context.Context, arg1 int64, arg2 func(*trillian.Tree)) (*trillian.Tree, error) {
	ret := m.ctrl.Call(m, "UpdateTree", arg0, arg1, arg2)
	ret0, _ := ret[0].(*trillian.Tree)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTree indicates an expected call of UpdateTree
func (mr *MockAdminTXMockRecorder) UpdateTree(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTree", reflect.TypeOf((*MockAdminTX)(nil).UpdateTree), arg0, arg1, arg2)
}

// MockLogStorage is a mock of LogStorage interface
type MockLogStorage struct {
	ctrl     *gomock.Controller
	recorder *MockLogStorageMockRecorder
}

// MockLogStorageMockRecorder is the mock recorder for MockLogStorage
type MockLogStorageMockRecorder struct {
	mock *MockLogStorage
}

// NewMockLogStorage creates a new mock instance
func NewMockLogStorage(ctrl *gomock.Controller) *MockLogStorage {
	mock := &MockLogStorage{ctrl: ctrl}
	mock.recorder = &MockLogStorageMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockLogStorage) EXPECT() *MockLogStorageMockRecorder {
	return m.recorder
}

// BeginForTree mocks base method
func (m *MockLogStorage) BeginForTree(arg0 context.Context, arg1 int64) (LogTreeTX, error) {
	ret := m.ctrl.Call(m, "BeginForTree", arg0, arg1)
	ret0, _ := ret[0].(LogTreeTX)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BeginForTree indicates an expected call of BeginForTree
func (mr *MockLogStorageMockRecorder) BeginForTree(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginForTree", reflect.TypeOf((*MockLogStorage)(nil).BeginForTree), arg0, arg1)
}

// CheckDatabaseAccessible mocks base method
func (m *MockLogStorage) CheckDatabaseAccessible(arg0 context.Context) error {
	ret := m.ctrl.Call(m, "CheckDatabaseAccessible", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckDatabaseAccessible indicates an expected call of CheckDatabaseAccessible
func (mr *MockLogStorageMockRecorder) CheckDatabaseAccessible(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckDatabaseAccessible", reflect.TypeOf((*MockLogStorage)(nil).CheckDatabaseAccessible), arg0)
}

// Snapshot mocks base method
func (m *MockLogStorage) Snapshot(arg0 context.Context) (ReadOnlyLogTX, error) {
	ret := m.ctrl.Call(m, "Snapshot", arg0)
	ret0, _ := ret[0].(ReadOnlyLogTX)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Snapshot indicates an expected call of Snapshot
func (mr *MockLogStorageMockRecorder) Snapshot(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Snapshot", reflect.TypeOf((*MockLogStorage)(nil).Snapshot), arg0)
}

// SnapshotForTree mocks base method
func (m *MockLogStorage) SnapshotForTree(arg0 context.Context, arg1 int64) (ReadOnlyLogTreeTX, error) {
	ret := m.ctrl.Call(m, "SnapshotForTree", arg0, arg1)
	ret0, _ := ret[0].(ReadOnlyLogTreeTX)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SnapshotForTree indicates an expected call of SnapshotForTree
func (mr *MockLogStorageMockRecorder) SnapshotForTree(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SnapshotForTree", reflect.TypeOf((*MockLogStorage)(nil).SnapshotForTree), arg0, arg1)
}

// MockLogTreeTX is a mock of LogTreeTX interface
type MockLogTreeTX struct {
	ctrl     *gomock.Controller
	recorder *MockLogTreeTXMockRecorder
}

// MockLogTreeTXMockRecorder is the mock recorder for MockLogTreeTX
type MockLogTreeTXMockRecorder struct {
	mock *MockLogTreeTX
}

// NewMockLogTreeTX creates a new mock instance
func NewMockLogTreeTX(ctrl *gomock.Controller) *MockLogTreeTX {
	mock := &MockLogTreeTX{ctrl: ctrl}
	mock.recorder = &MockLogTreeTXMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockLogTreeTX) EXPECT() *MockLogTreeTXMockRecorder {
	return m.recorder
}

// Close mocks base method
func (m *MockLogTreeTX) Close() error {
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockLogTreeTXMockRecorder) Close() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockLogTreeTX)(nil).Close))
}

// Commit mocks base method
func (m *MockLogTreeTX) Commit() error {
	ret := m.ctrl.Call(m, "Commit")
	ret0, _ := ret[0].(error)
	return ret0
}

// Commit indicates an expected call of Commit
func (mr *MockLogTreeTXMockRecorder) Commit() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockLogTreeTX)(nil).Commit))
}

// DequeueLeaves mocks base method
func (m *MockLogTreeTX) DequeueLeaves(arg0 context.Context, arg1 int, arg2 time.Time) ([]*trillian.LogLeaf, error) {
	ret := m.ctrl.Call(m, "DequeueLeaves", arg0, arg1, arg2)
	ret0, _ := ret[0].([]*trillian.LogLeaf)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DequeueLeaves indicates an expected call of DequeueLeaves
func (mr *MockLogTreeTXMockRecorder) DequeueLeaves(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DequeueLeaves", reflect.TypeOf((*MockLogTreeTX)(nil).DequeueLeaves), arg0, arg1, arg2)
}

// GetLeavesByHash mocks base method
func (m *MockLogTreeTX) GetLeavesByHash(arg0 context.Context, arg1 [][]byte, arg2 bool) ([]*trillian.LogLeaf, error) {
	ret := m.ctrl.Call(m, "GetLeavesByHash", arg0, arg1, arg2)
	ret0, _ := ret[0].([]*trillian.LogLeaf)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLeavesByHash indicates an expected call of GetLeavesByHash
func (mr *MockLogTreeTXMockRecorder) GetLeavesByHash(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLeavesByHash", reflect.TypeOf((*MockLogTreeTX)(nil).GetLeavesByHash), arg0, arg1, arg2)
}

// GetLeavesByIndex mocks base method
func (m *MockLogTreeTX) GetLeavesByIndex(arg0 context.Context, arg1 []int64) ([]*trillian.LogLeaf, error) {
	ret := m.ctrl.Call(m, "GetLeavesByIndex", arg0, arg1)
	ret0, _ := ret[0].([]*trillian.LogLeaf)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLeavesByIndex indicates an expected call of GetLeavesByIndex
func (mr *MockLogTreeTXMockRecorder) GetLeavesByIndex(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLeavesByIndex", reflect.TypeOf((*MockLogTreeTX)(nil).GetLeavesByIndex), arg0, arg1)
}

// GetMerkleNodes mocks base method
func (m *MockLogTreeTX) GetMerkleNodes(arg0 context.Context, arg1 int64, arg2 []NodeID) ([]Node, error) {
	ret := m.ctrl.Call(m, "GetMerkleNodes", arg0, arg1, arg2)
	ret0, _ := ret[0].([]Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMerkleNodes indicates an expected call of GetMerkleNodes
func (mr *MockLogTreeTXMockRecorder) GetMerkleNodes(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMerkleNodes", reflect.TypeOf((*MockLogTreeTX)(nil).GetMerkleNodes), arg0, arg1, arg2)
}

// GetSequencedLeafCount mocks base method
func (m *MockLogTreeTX) GetSequencedLeafCount(arg0 context.Context) (int64, error) {
	ret := m.ctrl.Call(m, "GetSequencedLeafCount", arg0)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSequencedLeafCount indicates an expected call of GetSequencedLeafCount
func (mr *MockLogTreeTXMockRecorder) GetSequencedLeafCount(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSequencedLeafCount", reflect.TypeOf((*MockLogTreeTX)(nil).GetSequencedLeafCount), arg0)
}

// IsOpen mocks base method
func (m *MockLogTreeTX) IsOpen() bool {
	ret := m.ctrl.Call(m, "IsOpen")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsOpen indicates an expected call of IsOpen
func (mr *MockLogTreeTXMockRecorder) IsOpen() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsOpen", reflect.TypeOf((*MockLogTreeTX)(nil).IsOpen))
}

// LatestSignedLogRoot mocks base method
func (m *MockLogTreeTX) LatestSignedLogRoot(arg0 context.Context) (trillian.SignedLogRoot, error) {
	ret := m.ctrl.Call(m, "LatestSignedLogRoot", arg0)
	ret0, _ := ret[0].(trillian.SignedLogRoot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LatestSignedLogRoot indicates an expected call of LatestSignedLogRoot
func (mr *MockLogTreeTXMockRecorder) LatestSignedLogRoot(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestSignedLogRoot", reflect.TypeOf((*MockLogTreeTX)(nil).LatestSignedLogRoot), arg0)
}

// QueueLeaves mocks base method
func (m *MockLogTreeTX) QueueLeaves(arg0 context.Context, arg1 []*trillian.LogLeaf, arg2 time.Time) ([]*trillian.LogLeaf, error) {
	ret := m.ctrl.Call(m, "QueueLeaves", arg0, arg1, arg2)
	ret0, _ := ret[0].([]*trillian.LogLeaf)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueueLeaves indicates an expected call of QueueLeaves
func (mr *MockLogTreeTXMockRecorder) QueueLeaves(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueLeaves", reflect.TypeOf((*MockLogTreeTX)(nil).QueueLeaves), arg0, arg1, arg2)
}

// ReadRevision mocks base method
func (m *MockLogTreeTX) ReadRevision() int64 {
	ret := m.ctrl.Call(m, "ReadRevision")
	ret0, _ := ret[0].(int64)
	return ret0
}

// ReadRevision indicates an expected call of ReadRevision
func (mr *MockLogTreeTXMockRecorder) ReadRevision() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadRevision", reflect.TypeOf((*MockLogTreeTX)(nil).ReadRevision))
}

// Rollback mocks base method
func (m *MockLogTreeTX) Rollback() error {
	ret := m.ctrl.Call(m, "Rollback")
	ret0, _ := ret[0].(error)
	return ret0
}

// Rollback indicates an expected call of Rollback
func (mr *MockLogTreeTXMockRecorder) Rollback() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockLogTreeTX)(nil).Rollback))
}

// SetMerkleNodes mocks base method
func (m *MockLogTreeTX) SetMerkleNodes(arg0 context.Context, arg1 []Node) error {
	ret := m.ctrl.Call(m, "SetMerkleNodes", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetMerkleNodes indicates an expected call of SetMerkleNodes
func (mr *MockLogTreeTXMockRecorder) SetMerkleNodes(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMerkleNodes", reflect.TypeOf((*MockLogTreeTX)(nil).SetMerkleNodes), arg0, arg1)
}

// StoreSignedLogRoot mocks base method
func (m *MockLogTreeTX) StoreSignedLogRoot(arg0 context.Context, arg1 trillian.SignedLogRoot) error {
	ret := m.ctrl.Call(m, "StoreSignedLogRoot", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// StoreSignedLogRoot indicates an expected call of StoreSignedLogRoot
func (mr *MockLogTreeTXMockRecorder) StoreSignedLogRoot(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreSignedLogRoot", reflect.TypeOf((*MockLogTreeTX)(nil).StoreSignedLogRoot), arg0, arg1)
}

// UpdateSequencedLeaves mocks base method
func (m *MockLogTreeTX) UpdateSequencedLeaves(arg0 context.Context, arg1 []*trillian.LogLeaf) error {
	ret := m.ctrl.Call(m, "UpdateSequencedLeaves", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateSequencedLeaves indicates an expected call of UpdateSequencedLeaves
func (mr *MockLogTreeTXMockRecorder) UpdateSequencedLeaves(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSequencedLeaves", reflect.TypeOf((*MockLogTreeTX)(nil).UpdateSequencedLeaves), arg0, arg1)
}

// WriteRevision mocks base method
func (m *MockLogTreeTX) WriteRevision() int64 {
	ret := m.ctrl.Call(m, "WriteRevision")
	ret0, _ := ret[0].(int64)
	return ret0
}

// WriteRevision indicates an expected call of WriteRevision
func (mr *MockLogTreeTXMockRecorder) WriteRevision() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteRevision", reflect.TypeOf((*MockLogTreeTX)(nil).WriteRevision))
}

// MockMapStorage is a mock of MapStorage interface
type MockMapStorage struct {
	ctrl     *gomock.Controller
	recorder *MockMapStorageMockRecorder
}

// MockMapStorageMockRecorder is the mock recorder for MockMapStorage
type MockMapStorageMockRecorder struct {
	mock *MockMapStorage
}

// NewMockMapStorage creates a new mock instance
func NewMockMapStorage(ctrl *gomock.Controller) *MockMapStorage {
	mock := &MockMapStorage{ctrl: ctrl}
	mock.recorder = &MockMapStorageMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockMapStorage) EXPECT() *MockMapStorageMockRecorder {
	return m.recorder
}

// BeginForTree mocks base method
func (m *MockMapStorage) BeginForTree(arg0 context.Context, arg1 int64) (MapTreeTX, error) {
	ret := m.ctrl.Call(m, "BeginForTree", arg0, arg1)
	ret0, _ := ret[0].(MapTreeTX)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BeginForTree indicates an expected call of BeginForTree
func (mr *MockMapStorageMockRecorder) BeginForTree(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginForTree", reflect.TypeOf((*MockMapStorage)(nil).BeginForTree), arg0, arg1)
}

// CheckDatabaseAccessible mocks base method
func (m *MockMapStorage) CheckDatabaseAccessible(arg0 context.Context) error {
	ret := m.ctrl.Call(m, "CheckDatabaseAccessible", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckDatabaseAccessible indicates an expected call of CheckDatabaseAccessible
func (mr *MockMapStorageMockRecorder) CheckDatabaseAccessible(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckDatabaseAccessible", reflect.TypeOf((*MockMapStorage)(nil).CheckDatabaseAccessible), arg0)
}

// Snapshot mocks base method
func (m *MockMapStorage) Snapshot(arg0 context.Context) (ReadOnlyMapTX, error) {
	ret := m.ctrl.Call(m, "Snapshot", arg0)
	ret0, _ := ret[0].(ReadOnlyMapTX)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Snapshot indicates an expected call of Snapshot
func (mr *MockMapStorageMockRecorder) Snapshot(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Snapshot", reflect.TypeOf((*MockMapStorage)(nil).Snapshot), arg0)
}

// SnapshotForTree mocks base method
func (m *MockMapStorage) SnapshotForTree(arg0 context.Context, arg1 int64) (ReadOnlyMapTreeTX, error) {
	ret := m.ctrl.Call(m, "SnapshotForTree", arg0, arg1)
	ret0, _ := ret[0].(ReadOnlyMapTreeTX)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SnapshotForTree indicates an expected call of SnapshotForTree
func (mr *MockMapStorageMockRecorder) SnapshotForTree(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SnapshotForTree", reflect.TypeOf((*MockMapStorage)(nil).SnapshotForTree), arg0, arg1)
}

// MockMapTreeTX is a mock of MapTreeTX interface
type MockMapTreeTX struct {
	ctrl     *gomock.Controller
	recorder *MockMapTreeTXMockRecorder
}

// MockMapTreeTXMockRecorder is the mock recorder for MockMapTreeTX
type MockMapTreeTXMockRecorder struct {
	mock *MockMapTreeTX
}

// NewMockMapTreeTX creates a new mock instance
func NewMockMapTreeTX(ctrl *gomock.Controller) *MockMapTreeTX {
	mock := &MockMapTreeTX{ctrl: ctrl}
	mock.recorder = &MockMapTreeTXMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockMapTreeTX) EXPECT() *MockMapTreeTXMockRecorder {
	return m.recorder
}

// Close mocks base method
func (m *MockMapTreeTX) Close() error {
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockMapTreeTXMockRecorder) Close() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockMapTreeTX)(nil).Close))
}

// Commit mocks base method
func (m *MockMapTreeTX) Commit() error {
	ret := m.ctrl.Call(m, "Commit")
	ret0, _ := ret[0].(error)
	return ret0
}

// Commit indicates an expected call of Commit
func (mr *MockMapTreeTXMockRecorder) Commit() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockMapTreeTX)(nil).Commit))
}

// Get mocks base method
func (m *MockMapTreeTX) Get(arg0 context.Context, arg1 int64, arg2 [][]byte) ([]trillian.MapLeaf, error) {
	ret := m.ctrl.Call(m, "Get", arg0, arg1, arg2)
	ret0, _ := ret[0].([]trillian.MapLeaf)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get
func (mr *MockMapTreeTXMockRecorder) Get(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockMapTreeTX)(nil).Get), arg0, arg1, arg2)
}

// GetMerkleNodes mocks base method
func (m *MockMapTreeTX) GetMerkleNodes(arg0 context.Context, arg1 int64, arg2 []NodeID) ([]Node, error) {
	ret := m.ctrl.Call(m, "GetMerkleNodes", arg0, arg1, arg2)
	ret0, _ := ret[0].([]Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMerkleNodes indicates an expected call of GetMerkleNodes
func (mr *MockMapTreeTXMockRecorder) GetMerkleNodes(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMerkleNodes", reflect.TypeOf((*MockMapTreeTX)(nil).GetMerkleNodes), arg0, arg1, arg2)
}

// GetSignedMapRoot mocks base method
func (m *MockMapTreeTX) GetSignedMapRoot(arg0 context.Context, arg1 int64) (trillian.SignedMapRoot, error) {
	ret := m.ctrl.Call(m, "GetSignedMapRoot", arg0, arg1)
	ret0, _ := ret[0].(trillian.SignedMapRoot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSignedMapRoot indicates an expected call of GetSignedMapRoot
func (mr *MockMapTreeTXMockRecorder) GetSignedMapRoot(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignedMapRoot", reflect.TypeOf((*MockMapTreeTX)(nil).GetSignedMapRoot), arg0, arg1)
}

// IsOpen mocks base method
func (m *MockMapTreeTX) IsOpen() bool {
	ret := m.ctrl.Call(m, "IsOpen")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsOpen indicates an expected call of IsOpen
func (mr *MockMapTreeTXMockRecorder) IsOpen() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsOpen", reflect.TypeOf((*MockMapTreeTX)(nil).IsOpen))
}

// LatestSignedMapRoot mocks base method
func (m *MockMapTreeTX) LatestSignedMapRoot(arg0 context.Context) (trillian.SignedMapRoot, error) {
	ret := m.ctrl.Call(m, "LatestSignedMapRoot", arg0)
	ret0, _ := ret[0].(trillian.SignedMapRoot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LatestSignedMapRoot indicates an expected call of LatestSignedMapRoot
func (mr *MockMapTreeTXMockRecorder) LatestSignedMapRoot(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestSignedMapRoot", reflect.TypeOf((*MockMapTreeTX)(nil).LatestSignedMapRoot), arg0)
}

// ReadRevision mocks base method
func (m *MockMapTreeTX) ReadRevision() int64 {
	ret := m.ctrl.Call(m, "ReadRevision")
	ret0, _ := ret[0].(int64)
	return ret0
}

// ReadRevision indicates an expected call of ReadRevision
func (mr *MockMapTreeTXMockRecorder) ReadRevision() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadRevision", reflect.TypeOf((*MockMapTreeTX)(nil).ReadRevision))
}

// Rollback mocks base method
func (m *MockMapTreeTX) Rollback() error {
	ret := m.ctrl.Call(m, "Rollback")
	ret0, _ := ret[0].(error)
	return ret0
}

// Rollback indicates an expected call of Rollback
func (mr *MockMapTreeTXMockRecorder) Rollback() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockMapTreeTX)(nil).Rollback))
}

// Set mocks base method
func (m *MockMapTreeTX) Set(arg0 context.Context, arg1 []byte, arg2 trillian.MapLeaf) error {
	ret := m.ctrl.Call(m, "Set", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Set indicates an expected call of Set
func (mr *MockMapTreeTXMockRecorder) Set(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockMapTreeTX)(nil).Set), arg0, arg1, arg2)
}

// SetMerkleNodes mocks base method
func (m *MockMapTreeTX) SetMerkleNodes(arg0 context.Context, arg1 []Node) error {
	ret := m.ctrl.Call(m, "SetMerkleNodes", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetMerkleNodes indicates an expected call of SetMerkleNodes
func (mr *MockMapTreeTXMockRecorder) SetMerkleNodes(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMerkleNodes", reflect.TypeOf((*MockMapTreeTX)(nil).SetMerkleNodes), arg0, arg1)
}

// StoreSignedMapRoot mocks base method
func (m *MockMapTreeTX) StoreSignedMapRoot(arg0 context.Context, arg1 trillian.SignedMapRoot) error {
	ret := m.ctrl.Call(m, "StoreSignedMapRoot", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// StoreSignedMapRoot indicates an expected call of StoreSignedMapRoot
func (mr *MockMapTreeTXMockRecorder) StoreSignedMapRoot(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreSignedMapRoot", reflect.TypeOf((*MockMapTreeTX)(nil).StoreSignedMapRoot), arg0, arg1)
}

// WriteRevision mocks base method
func (m *MockMapTreeTX) WriteRevision() int64 {
	ret := m.ctrl.Call(m, "WriteRevision")
	ret0, _ := ret[0].(int64)
	return ret0
}

// WriteRevision indicates an expected call of WriteRevision
func (mr *MockMapTreeTXMockRecorder) WriteRevision() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteRevision", reflect.TypeOf((*MockMapTreeTX)(nil).WriteRevision))
}

// MockReadOnlyAdminTX is a mock of ReadOnlyAdminTX interface
type MockReadOnlyAdminTX struct {
	ctrl     *gomock.Controller
	recorder *MockReadOnlyAdminTXMockRecorder
}

// MockReadOnlyAdminTXMockRecorder is the mock recorder for MockReadOnlyAdminTX
type MockReadOnlyAdminTXMockRecorder struct {
	mock *MockReadOnlyAdminTX
}

// NewMockReadOnlyAdminTX creates a new mock instance
func NewMockReadOnlyAdminTX(ctrl *gomock.Controller) *MockReadOnlyAdminTX {
	mock := &MockReadOnlyAdminTX{ctrl: ctrl}
	mock.recorder = &MockReadOnlyAdminTXMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockReadOnlyAdminTX) EXPECT() *MockReadOnlyAdminTXMockRecorder {
	return m.recorder
}

// Close mocks base method
func (m *MockReadOnlyAdminTX) Close() error {
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockReadOnlyAdminTXMockRecorder) Close() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockReadOnlyAdminTX)(nil).Close))
}

// Commit mocks base method
func (m *MockReadOnlyAdminTX) Commit() error {
	ret := m.ctrl.Call(m, "Commit")
	ret0, _ := ret[0].(error)
	return ret0
}

// Commit indicates an expected call of Commit
func (mr *MockReadOnlyAdminTXMockRecorder) Commit() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockReadOnlyAdminTX)(nil).Commit))
}

// GetTree mocks base method
func (m *MockReadOnlyAdminTX) GetTree(arg0 context.Context, arg1 int64) (*trillian.Tree, error) {
	ret := m.ctrl.Call(m, "GetTree", arg0, arg1)
	ret0, _ := ret[0].(*trillian.Tree)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTree indicates an expected call of GetTree
func (mr *MockReadOnlyAdminTXMockRecorder) GetTree(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTree", reflect.TypeOf((*MockReadOnlyAdminTX)(nil).GetTree), arg0, arg1)
}

// IsClosed mocks base method
func (m *MockReadOnlyAdminTX) IsClosed() bool {
	ret := m.ctrl.Call(m, "IsClosed")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsClosed indicates an expected call of IsClosed
func (mr *MockReadOnlyAdminTXMockRecorder) IsClosed() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsClosed", reflect.TypeOf((*MockReadOnlyAdminTX)(nil).IsClosed))
}

// ListTreeIDs mocks base method
func (m *MockReadOnlyAdminTX) ListTreeIDs(arg0 context.Context, arg1 bool) ([]int64, error) {
	ret := m.ctrl.Call(m, "ListTreeIDs", arg0, arg1)
	ret0, _ := ret[0].([]int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTreeIDs indicates an expected call of ListTreeIDs
func (mr *MockReadOnlyAdminTXMockRecorder) ListTreeIDs(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTreeIDs", reflect.TypeOf((*MockReadOnlyAdminTX)(nil).ListTreeIDs), arg0, arg1)
}

// ListTrees mocks base method
func (m *MockReadOnlyAdminTX) ListTrees(arg0 context.Context, arg1 bool) ([]*trillian.Tree, error) {
	ret := m.ctrl.Call(m, "ListTrees", arg0, arg1)
	ret0, _ := ret[0].([]*trillian.Tree)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrees indicates an expected call of ListTrees
func (mr *MockReadOnlyAdminTXMockRecorder) ListTrees(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrees", reflect.TypeOf((*MockReadOnlyAdminTX)(nil).ListTrees), arg0, arg1)
}

// Rollback mocks base method
func (m *MockReadOnlyAdminTX) Rollback() error {
	ret := m.ctrl.Call(m, "Rollback")
	ret0, _ := ret[0].(error)
	return ret0
}

// Rollback indicates an expected call of Rollback
func (mr *MockReadOnlyAdminTXMockRecorder) Rollback() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockReadOnlyAdminTX)(nil).Rollback))
}

// MockReadOnlyLogTX is a mock of ReadOnlyLogTX interface
type MockReadOnlyLogTX struct {
	ctrl     *gomock.Controller
	recorder *MockReadOnlyLogTXMockRecorder
}

// MockReadOnlyLogTXMockRecorder is the mock recorder for MockReadOnlyLogTX
type MockReadOnlyLogTXMockRecorder struct {
	mock *MockReadOnlyLogTX
}

// NewMockReadOnlyLogTX creates a new mock instance
func NewMockReadOnlyLogTX(ctrl *gomock.Controller) *MockReadOnlyLogTX {
	mock := &MockReadOnlyLogTX{ctrl: ctrl}
	mock.recorder = &MockReadOnlyLogTXMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockReadOnlyLogTX) EXPECT() *MockReadOnlyLogTXMockRecorder {
	return m.recorder
}

// Close mocks base method
func (m *MockReadOnlyLogTX) Close() error {
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockReadOnlyLogTXMockRecorder) Close() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockReadOnlyLogTX)(nil).Close))
}

// Commit mocks base method
func (m *MockReadOnlyLogTX) Commit() error {
	ret := m.ctrl.Call(m, "Commit")
	ret0, _ := ret[0].(error)
	return ret0
}

// Commit indicates an expected call of Commit
func (mr *MockReadOnlyLogTXMockRecorder) Commit() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockReadOnlyLogTX)(nil).Commit))
}

// GetActiveLogIDs mocks base method
func (m *MockReadOnlyLogTX) GetActiveLogIDs(arg0 context.Context) ([]int64, error) {
	ret := m.ctrl.Call(m, "GetActiveLogIDs", arg0)
	ret0, _ := ret[0].([]int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetActiveLogIDs indicates an expected call of GetActiveLogIDs
func (mr *MockReadOnlyLogTXMockRecorder) GetActiveLogIDs(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActiveLogIDs", reflect.TypeOf((*MockReadOnlyLogTX)(nil).GetActiveLogIDs), arg0)
}

// GetUnsequencedCounts mocks base method
func (m *MockReadOnlyLogTX) GetUnsequencedCounts(arg0 context.Context) (CountByLogID, error) {
	ret := m.ctrl.Call(m, "GetUnsequencedCounts", arg0)
	ret0, _ := ret[0].(CountByLogID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUnsequencedCounts indicates an expected call of GetUnsequencedCounts
func (mr *MockReadOnlyLogTXMockRecorder) GetUnsequencedCounts(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUnsequencedCounts", reflect.TypeOf((*MockReadOnlyLogTX)(nil).GetUnsequencedCounts), arg0)
}

// Rollback mocks base method
func (m *MockReadOnlyLogTX) Rollback() error {
	ret := m.ctrl.Call(m, "Rollback")
	ret0, _ := ret[0].(error)
	return ret0
}

// Rollback indicates an expected call of Rollback
func (mr *MockReadOnlyLogTXMockRecorder) Rollback() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockReadOnlyLogTX)(nil).Rollback))
}

// MockReadOnlyLogTreeTX is a mock of ReadOnlyLogTreeTX interface
type MockReadOnlyLogTreeTX struct {
	ctrl     *gomock.Controller
	recorder *MockReadOnlyLogTreeTXMockRecorder
}

// MockReadOnlyLogTreeTXMockRecorder is the mock recorder for MockReadOnlyLogTreeTX
type MockReadOnlyLogTreeTXMockRecorder struct {
	mock *MockReadOnlyLogTreeTX
}

// NewMockReadOnlyLogTreeTX creates a new mock instance
func NewMockReadOnlyLogTreeTX(ctrl *gomock.Controller) *MockReadOnlyLogTreeTX {
	mock := &MockReadOnlyLogTreeTX{ctrl: ctrl}
	mock.recorder = &MockReadOnlyLogTreeTXMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockReadOnlyLogTreeTX) EXPECT() *MockReadOnlyLogTreeTXMockRecorder {
	return m.recorder
}

// Close mocks base method
func (m *MockReadOnlyLogTreeTX) Close() error {
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockReadOnlyLogTreeTXMockRecorder) Close() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockReadOnlyLogTreeTX)(nil).Close))
}

// Commit mocks base method
func (m *MockReadOnlyLogTreeTX) Commit() error {
	ret := m.ctrl.Call(m, "Commit")
	ret0, _ := ret[0].(error)
	return ret0
}

// Commit indicates an expected call of Commit
func (mr *MockReadOnlyLogTreeTXMockRecorder) Commit() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockReadOnlyLogTreeTX)(nil).Commit))
}

// GetLeavesByHash mocks base method
func (m *MockReadOnlyLogTreeTX) GetLeavesByHash(arg0 context.Context, arg1 [][]byte, arg2 bool) ([]*trillian.LogLeaf, error) {
	ret := m.ctrl.Call(m, "GetLeavesByHash", arg0, arg1, arg2)
	ret0, _ := ret[0].([]*trillian.LogLeaf)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLeavesByHash indicates an expected call of GetLeavesByHash
func (mr *MockReadOnlyLogTreeTXMockRecorder) GetLeavesByHash(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLeavesByHash", reflect.TypeOf((*MockReadOnlyLogTreeTX)(nil).GetLeavesByHash), arg0, arg1, arg2)
}

// GetLeavesByIndex mocks base method
func (m *MockReadOnlyLogTreeTX) GetLeavesByIndex(arg0 context.Context, arg1 []int64) ([]*trillian.LogLeaf, error) {
	ret := m.ctrl.Call(m, "GetLeavesByIndex", arg0, arg1)
	ret0, _ := ret[0].([]*trillian.LogLeaf)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLeavesByIndex indicates an expected call of GetLeavesByIndex
func (mr *MockReadOnlyLogTreeTXMockRecorder) GetLeavesByIndex(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLeavesByIndex", reflect.TypeOf((*MockReadOnlyLogTreeTX)(nil).GetLeavesByIndex), arg0, arg1)
}

// GetMerkleNodes mocks base method
func (m *MockReadOnlyLogTreeTX) GetMerkleNodes(arg0 context.Context, arg1 int64, arg2 []NodeID) ([]Node, error) {
	ret := m.ctrl.Call(m, "GetMerkleNodes", arg0, arg1, arg2)
	ret0, _ := ret[0].([]Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMerkleNodes indicates an expected call of GetMerkleNodes
func (mr *MockReadOnlyLogTreeTXMockRecorder) GetMerkleNodes(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMerkleNodes", reflect.TypeOf((*MockReadOnlyLogTreeTX)(nil).GetMerkleNodes), arg0, arg1, arg2)
}

// GetSequencedLeafCount mocks base method
func (m *MockReadOnlyLogTreeTX) GetSequencedLeafCount(arg0 context.Context) (int64, error) {
	ret := m.ctrl.Call(m, "GetSequencedLeafCount", arg0)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSequencedLeafCount indicates an expected call of GetSequencedLeafCount
func (mr *MockReadOnlyLogTreeTXMockRecorder) GetSequencedLeafCount(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSequencedLeafCount", reflect.TypeOf((*MockReadOnlyLogTreeTX)(nil).GetSequencedLeafCount), arg0)
}

// IsOpen mocks base method
func (m *MockReadOnlyLogTreeTX) IsOpen() bool {
	ret := m.ctrl.Call(m, "IsOpen")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsOpen indicates an expected call of IsOpen
func (mr *MockReadOnlyLogTreeTXMockRecorder) IsOpen() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsOpen", reflect.TypeOf((*MockReadOnlyLogTreeTX)(nil).IsOpen))
}

// LatestSignedLogRoot mocks base method
func (m *MockReadOnlyLogTreeTX) LatestSignedLogRoot(arg0 context.Context) (trillian.SignedLogRoot, error) {
	ret := m.ctrl.Call(m, "LatestSignedLogRoot", arg0)
	ret0, _ := ret[0].(trillian.SignedLogRoot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LatestSignedLogRoot indicates an expected call of LatestSignedLogRoot
func (mr *MockReadOnlyLogTreeTXMockRecorder) LatestSignedLogRoot(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestSignedLogRoot", reflect.TypeOf((*MockReadOnlyLogTreeTX)(nil).LatestSignedLogRoot), arg0)
}

// ReadRevision mocks base method
func (m *MockReadOnlyLogTreeTX) ReadRevision() int64 {
	ret := m.ctrl.Call(m, "ReadRevision")
	ret0, _ := ret[0].(int64)
	return ret0
}

// ReadRevision indicates an expected call of ReadRevision
func (mr *MockReadOnlyLogTreeTXMockRecorder) ReadRevision() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadRevision", reflect.TypeOf((*MockReadOnlyLogTreeTX)(nil).ReadRevision))
}

// Rollback mocks base method
func (m *MockReadOnlyLogTreeTX) Rollback() error {
	ret := m.ctrl.Call(m, "Rollback")
	ret0, _ := ret[0].(error)
	return ret0
}

// Rollback indicates an expected call of Rollback
func (mr *MockReadOnlyLogTreeTXMockRecorder) Rollback() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockReadOnlyLogTreeTX)(nil).Rollback))
}

// MockReadOnlyMapTreeTX is a mock of ReadOnlyMapTreeTX interface
type MockReadOnlyMapTreeTX struct {
	ctrl     *gomock.Controller
	recorder *MockReadOnlyMapTreeTXMockRecorder
}

// MockReadOnlyMapTreeTXMockRecorder is the mock recorder for MockReadOnlyMapTreeTX
type MockReadOnlyMapTreeTXMockRecorder struct {
	mock *MockReadOnlyMapTreeTX
}

// NewMockReadOnlyMapTreeTX creates a new mock instance
func NewMockReadOnlyMapTreeTX(ctrl *gomock.Controller) *MockReadOnlyMapTreeTX {
	mock := &MockReadOnlyMapTreeTX{ctrl: ctrl}
	mock.recorder = &MockReadOnlyMapTreeTXMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockReadOnlyMapTreeTX) EXPECT() *MockReadOnlyMapTreeTXMockRecorder {
	return m.recorder
}

// Close mocks base method
func (m *MockReadOnlyMapTreeTX) Close() error {
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockReadOnlyMapTreeTXMockRecorder) Close() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockReadOnlyMapTreeTX)(nil).Close))
}

// Commit mocks base method
func (m *MockReadOnlyMapTreeTX) Commit() error {
	ret := m.ctrl.Call(m, "Commit")
	ret0, _ := ret[0].(error)
	return ret0
}

// Commit indicates an expected call of Commit
func (mr *MockReadOnlyMapTreeTXMockRecorder) Commit() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockReadOnlyMapTreeTX)(nil).Commit))
}

// Get mocks base method
func (m *MockReadOnlyMapTreeTX) Get(arg0 context.Context, arg1 int64, arg2 [][]byte) ([]trillian.MapLeaf, error) {
	ret := m.ctrl.Call(m, "Get", arg0, arg1, arg2)
	ret0, _ := ret[0].([]trillian.MapLeaf)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get
func (mr *MockReadOnlyMapTreeTXMockRecorder) Get(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockReadOnlyMapTreeTX)(nil).Get), arg0, arg1, arg2)
}

// GetMerkleNodes mocks base method
func (m *MockReadOnlyMapTreeTX) GetMerkleNodes(arg0 context.Context, arg1 int64, arg2 []NodeID) ([]Node, error) {
	ret := m.ctrl.Call(m, "GetMerkleNodes", arg0, arg1, arg2)
	ret0, _ := ret[0].([]Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMerkleNodes indicates an expected call of GetMerkleNodes
func (mr *MockReadOnlyMapTreeTXMockRecorder) GetMerkleNodes(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMerkleNodes", reflect.TypeOf((*MockReadOnlyMapTreeTX)(nil).GetMerkleNodes), arg0, arg1, arg2)
}

// GetSignedMapRoot mocks base method
func (m *MockReadOnlyMapTreeTX) GetSignedMapRoot(arg0 context.Context, arg1 int64) (trillian.SignedMapRoot, error) {
	ret := m.ctrl.Call(m, "GetSignedMapRoot", arg0, arg1)
	ret0, _ := ret[0].(trillian.SignedMapRoot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSignedMapRoot indicates an expected call of GetSignedMapRoot
func (mr *MockReadOnlyMapTreeTXMockRecorder) GetSignedMapRoot(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignedMapRoot", reflect.TypeOf((*MockReadOnlyMapTreeTX)(nil).GetSignedMapRoot), arg0, arg1)
}

// IsOpen mocks base method
func (m *MockReadOnlyMapTreeTX) IsOpen() bool {
	ret := m.ctrl.Call(m, "IsOpen")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsOpen indicates an expected call of IsOpen
func (mr *MockReadOnlyMapTreeTXMockRecorder) IsOpen() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsOpen", reflect.TypeOf((*MockReadOnlyMapTreeTX)(nil).IsOpen))
}

// LatestSignedMapRoot mocks base method
func (m *MockReadOnlyMapTreeTX) LatestSignedMapRoot(arg0 context.Context) (trillian.SignedMapRoot, error) {
	ret := m.ctrl.Call(m, "LatestSignedMapRoot", arg0)
	ret0, _ := ret[0].(trillian.SignedMapRoot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LatestSignedMapRoot indicates an expected call of LatestSignedMapRoot
func (mr *MockReadOnlyMapTreeTXMockRecorder) LatestSignedMapRoot(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestSignedMapRoot", reflect.TypeOf((*MockReadOnlyMapTreeTX)(nil).LatestSignedMapRoot), arg0)
}

// ReadRevision mocks base method
func (m *MockReadOnlyMapTreeTX) ReadRevision() int64 {
	ret := m.ctrl.Call(m, "ReadRevision")
	ret0, _ := ret[0].(int64)
	return ret0
}

// ReadRevision indicates an expected call of ReadRevision
func (mr *MockReadOnlyMapTreeTXMockRecorder) ReadRevision() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadRevision", reflect.TypeOf((*MockReadOnlyMapTreeTX)(nil).ReadRevision))
}

// Rollback mocks base method
func (m *MockReadOnlyMapTreeTX) Rollback() error {
	ret := m.ctrl.Call(m, "Rollback")
	ret0, _ := ret[0].(error)
	return ret0
}

// Rollback indicates an expected call of Rollback
func (mr *MockReadOnlyMapTreeTXMockRecorder) Rollback() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockReadOnlyMapTreeTX)(nil).Rollback))
}