Merged blobstore repository

.gitignore

@@ -1,4 +1,3 @@
 /build
 /cmake
 /.idea
-

.travis.yml

@@ -36,5 +36,6 @@ script:
 - ./run_with_fuse.sh ./test/fspp/fspp-test
 - ./test/parallelaccessstore/parallelaccessstore-test
 - ./test/blockstore/blockstore-test
+- ./test/blobstore/blobstore-test
 after_script:
 - rm run_with_fuse.sh

src/CMakeLists.txt

@@ -2,4 +2,5 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 add_subdirectory(cpp-utils)
 add_subdirectory(fspp)
-add_subdirectory(blockstore)
+add_subdirectory(blockstore)
+add_subdirectory(blobstore)

src/blobstore/CMakeLists.txt

@@ -0,0 +1,29 @@
+project (blobstore)
+
+set(SOURCES
+    implementations/onblocks/parallelaccessdatatreestore/ParallelAccessDataTreeStoreAdapter.cpp
+    implementations/onblocks/parallelaccessdatatreestore/DataTreeRef.cpp
+    implementations/onblocks/parallelaccessdatatreestore/ParallelAccessDataTreeStore.cpp
+    implementations/onblocks/utils/Math.cpp
+    implementations/onblocks/BlobStoreOnBlocks.cpp
+    implementations/onblocks/datanodestore/DataNode.cpp
+    implementations/onblocks/datanodestore/DataLeafNode.cpp
+    implementations/onblocks/datanodestore/DataInnerNode.cpp
+    implementations/onblocks/datanodestore/DataNodeStore.cpp
+    implementations/onblocks/datatreestore/impl/algorithms.cpp
+    implementations/onblocks/datatreestore/DataTree.cpp
+    implementations/onblocks/datatreestore/DataTreeStore.cpp
+    implementations/onblocks/BlobOnBlocks.cpp
+)
+
+add_library(${PROJECT_NAME} STATIC ${SOURCES})
+
+# This is needed by boost thread
+if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+  target_link_libraries(${PROJECT_NAME} PRIVATE rt)
+endif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+target_link_libraries(${PROJECT_NAME} PUBLIC cpp-utils blockstore)
+
+target_add_boost(${PROJECT_NAME} filesystem system thread)
+target_enable_style_warnings(${PROJECT_NAME})
+target_activate_cpp14(${PROJECT_NAME})

src/blobstore/implementations/onblocks/BlobOnBlocks.cpp

@@ -0,0 +1,109 @@
+#include "parallelaccessdatatreestore/DataTreeRef.h"
+#include "BlobOnBlocks.h"
+
+#include "datanodestore/DataLeafNode.h"
+#include "utils/Math.h"
+#include <cmath>
+#include <messmer/cpp-utils/assert/assert.h>
+
+using std::function;
+using cpputils::unique_ref;
+using cpputils::Data;
+using blobstore::onblocks::datanodestore::DataLeafNode;
+using blobstore::onblocks::datanodestore::DataNodeLayout;
+using blockstore::Key;
+
+namespace blobstore {
+namespace onblocks {
+
+using parallelaccessdatatreestore::DataTreeRef;
+
+BlobOnBlocks::BlobOnBlocks(unique_ref<DataTreeRef> datatree)
+: _datatree(std::move(datatree)), _sizeCache(boost::none) {
+}
+
+BlobOnBlocks::~BlobOnBlocks() {
+}
+
+uint64_t BlobOnBlocks::size() const {
+  if (_sizeCache == boost::none) {
+    _sizeCache = _datatree->numStoredBytes();
+  }
+  return *_sizeCache;
+}
+
+void BlobOnBlocks::resize(uint64_t numBytes) {
+  _datatree->resizeNumBytes(numBytes);
+  _sizeCache = numBytes;
+}
+
+void BlobOnBlocks::traverseLeaves(uint64_t beginByte, uint64_t sizeBytes, function<void (uint64_t, DataLeafNode *leaf, uint32_t, uint32_t)> func) const {
+  uint64_t endByte = beginByte + sizeBytes;
+  uint32_t firstLeaf = beginByte / _datatree->maxBytesPerLeaf();
+  uint32_t endLeaf = utils::ceilDivision(endByte, _datatree->maxBytesPerLeaf());
+  bool writingOutside = size() < endByte; // TODO Calling size() is slow because it has to traverse the tree
+  _datatree->traverseLeaves(firstLeaf, endLeaf, [&func, beginByte, endByte, endLeaf, writingOutside](DataLeafNode *leaf, uint32_t leafIndex) {
+    uint64_t indexOfFirstLeafByte = leafIndex * leaf->maxStoreableBytes();
+    uint32_t dataBegin = utils::maxZeroSubtraction(beginByte, indexOfFirstLeafByte);
+    uint32_t dataEnd = std::min(leaf->maxStoreableBytes(), endByte - indexOfFirstLeafByte);
+    if (leafIndex == endLeaf-1 && writingOutside) {
+      // If we are traversing an area that didn't exist before, then the last leaf was just created with a wrong size. We have to fix it.
+      leaf->resize(dataEnd);
+    }
+    func(indexOfFirstLeafByte, leaf, dataBegin, dataEnd-dataBegin);
+  });
+  if (writingOutside) {
+    ASSERT(_datatree->numStoredBytes() == endByte, "Writing didn't grow by the correct number of bytes");
+    _sizeCache = endByte;
+  }
+}
+
+Data BlobOnBlocks::readAll() const {
+  //TODO Querying size is inefficient. Is this possible without a call to size()?
+  uint64_t count = size();
+  Data result(count);
+  _read(result.data(), 0, count);
+  return result;
+}
+
+void BlobOnBlocks::read(void *target, uint64_t offset, uint64_t count) const {
+  ASSERT(offset <= size() && offset + count <= size(), "BlobOnBlocks::read() read outside blob. Use BlobOnBlocks::tryRead() if this should be allowed.");
+  uint64_t read = tryRead(target, offset, count);
+  ASSERT(read == count, "BlobOnBlocks::read() couldn't read all requested bytes. Use BlobOnBlocks::tryRead() if this should be allowed.");
+}
+
+uint64_t BlobOnBlocks::tryRead(void *target, uint64_t offset, uint64_t count) const {
+  //TODO Quite inefficient to call size() here, because that has to traverse the tree
+  uint64_t realCount = std::max(UINT64_C(0), std::min(count, size()-offset));
+  _read(target, offset, realCount);
+  return realCount;
+}
+
+void BlobOnBlocks::_read(void *target, uint64_t offset, uint64_t count) const {
+  traverseLeaves(offset, count, [target, offset] (uint64_t indexOfFirstLeafByte, const DataLeafNode *leaf, uint32_t leafDataOffset, uint32_t leafDataSize) {
+      //TODO Simplify formula, make it easier to understand
+      leaf->read((uint8_t*)target + indexOfFirstLeafByte - offset + leafDataOffset, leafDataOffset, leafDataSize);
+  });
+}
+
+void BlobOnBlocks::write(const void *source, uint64_t offset, uint64_t count) {
+  traverseLeaves(offset, count, [source, offset] (uint64_t indexOfFirstLeafByte, DataLeafNode *leaf, uint32_t leafDataOffset, uint32_t leafDataSize) {
+    //TODO Simplify formula, make it easier to understand
+    leaf->write((uint8_t*)source + indexOfFirstLeafByte - offset + leafDataOffset, leafDataOffset, leafDataSize);
+  });
+}
+
+void BlobOnBlocks::flush() {
+  _datatree->flush();
+}
+
+const Key &BlobOnBlocks::key() const {
+  return _datatree->key();
+}
+
+unique_ref<DataTreeRef> BlobOnBlocks::releaseTree() {
+  return std::move(_datatree);
+}
+
+}
+}

src/blobstore/implementations/onblocks/BlobOnBlocks.h

@@ -0,0 +1,52 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_BLOBONBLOCKS_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_BLOBONBLOCKS_H_
+
+#include "../../interface/Blob.h"
+
+#include <memory>
+#include <boost/optional.hpp>
+
+namespace blobstore {
+namespace onblocks {
+namespace datanodestore {
+class DataLeafNode;
+}
+namespace parallelaccessdatatreestore {
+class DataTreeRef;
+}
+
+class BlobOnBlocks final: public Blob {
+public:
+  BlobOnBlocks(cpputils::unique_ref<parallelaccessdatatreestore::DataTreeRef> datatree);
+  ~BlobOnBlocks();
+
+  const blockstore::Key &key() const override;
+
+  uint64_t size() const override;
+  void resize(uint64_t numBytes) override;
+
+  cpputils::Data readAll() const override;
+  void read(void *target, uint64_t offset, uint64_t size) const override;
+  uint64_t tryRead(void *target, uint64_t offset, uint64_t size) const override;
+  void write(const void *source, uint64_t offset, uint64_t size) override;
+
+  void flush() override;
+
+  cpputils::unique_ref<parallelaccessdatatreestore::DataTreeRef> releaseTree();
+
+private:
+
+  void _read(void *target, uint64_t offset, uint64_t count) const;
+  void traverseLeaves(uint64_t offsetBytes, uint64_t sizeBytes, std::function<void (uint64_t, datanodestore::DataLeafNode *, uint32_t, uint32_t)>) const;
+
+  cpputils::unique_ref<parallelaccessdatatreestore::DataTreeRef> _datatree;
+  mutable boost::optional<uint64_t> _sizeCache;
+
+  DISALLOW_COPY_AND_ASSIGN(BlobOnBlocks);
+};
+
+}
+}
+
+#endif

src/blobstore/implementations/onblocks/BlobStoreOnBlocks.cpp

@@ -0,0 +1,56 @@
+#include "parallelaccessdatatreestore/DataTreeRef.h"
+#include "parallelaccessdatatreestore/ParallelAccessDataTreeStore.h"
+#include <messmer/blockstore/implementations/parallelaccess/ParallelAccessBlockStore.h>
+#include "datanodestore/DataLeafNode.h"
+#include "datanodestore/DataNodeStore.h"
+#include "datatreestore/DataTreeStore.h"
+#include "datatreestore/DataTree.h"
+#include "BlobStoreOnBlocks.h"
+#include "BlobOnBlocks.h"
+#include <messmer/cpp-utils/pointer/cast.h>
+#include <messmer/cpp-utils/assert/assert.h>
+
+using cpputils::unique_ref;
+using cpputils::make_unique_ref;
+
+using blockstore::BlockStore;
+using blockstore::parallelaccess::ParallelAccessBlockStore;
+using blockstore::Key;
+using cpputils::dynamic_pointer_move;
+using boost::optional;
+using boost::none;
+
+namespace blobstore {
+namespace onblocks {
+
+using datanodestore::DataNodeStore;
+using datatreestore::DataTreeStore;
+using parallelaccessdatatreestore::ParallelAccessDataTreeStore;
+
+BlobStoreOnBlocks::BlobStoreOnBlocks(unique_ref<BlockStore> blockStore, uint32_t blocksizeBytes)
+: _dataTreeStore(make_unique_ref<ParallelAccessDataTreeStore>(make_unique_ref<DataTreeStore>(make_unique_ref<DataNodeStore>(make_unique_ref<ParallelAccessBlockStore>(std::move(blockStore)), blocksizeBytes)))) {
+}
+
+BlobStoreOnBlocks::~BlobStoreOnBlocks() {
+}
+
+unique_ref<Blob> BlobStoreOnBlocks::create() {
+  return make_unique_ref<BlobOnBlocks>(_dataTreeStore->createNewTree());
+}
+
+optional<unique_ref<Blob>> BlobStoreOnBlocks::load(const Key &key) {
+  auto tree = _dataTreeStore->load(key);
+  if (tree == none) {
+  	return none;
+  }
+  return optional<unique_ref<Blob>>(make_unique_ref<BlobOnBlocks>(std::move(*tree)));
+}
+
+void BlobStoreOnBlocks::remove(unique_ref<Blob> blob) {
+  auto _blob = dynamic_pointer_move<BlobOnBlocks>(blob);
+  ASSERT(_blob != none, "Passed Blob in BlobStoreOnBlocks::remove() is not a BlobOnBlocks.");
+  _dataTreeStore->remove((*_blob)->releaseTree());
+}
+
+}
+}

src/blobstore/implementations/onblocks/BlobStoreOnBlocks.h

@@ -0,0 +1,35 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_BLOCKED_BLOBSTOREONBLOCKS_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_BLOCKED_BLOBSTOREONBLOCKS_H_
+
+#include "../../interface/BlobStore.h"
+#include "messmer/blockstore/interface/BlockStore.h"
+
+namespace blobstore {
+namespace onblocks {
+namespace parallelaccessdatatreestore {
+class ParallelAccessDataTreeStore;
+}
+
+//TODO Make blobstore able to cope with incomplete data (some blocks missing, because they're not synchronized yet) and write test cases for that
+
+class BlobStoreOnBlocks final: public BlobStore {
+public:
+  BlobStoreOnBlocks(cpputils::unique_ref<blockstore::BlockStore> blockStore, uint32_t blocksizeBytes);
+  ~BlobStoreOnBlocks();
+
+  cpputils::unique_ref<Blob> create() override;
+  boost::optional<cpputils::unique_ref<Blob>> load(const blockstore::Key &key) override;
+
+  void remove(cpputils::unique_ref<Blob> blob) override;
+
+private:
+  cpputils::unique_ref<parallelaccessdatatreestore::ParallelAccessDataTreeStore> _dataTreeStore;
+
+  DISALLOW_COPY_AND_ASSIGN(BlobStoreOnBlocks);
+};
+
+}
+}
+
+#endif

src/blobstore/implementations/onblocks/datanodestore/DataInnerNode.cpp

@@ -0,0 +1,87 @@
+#include "DataInnerNode.h"
+#include "DataNodeStore.h"
+#include <messmer/cpp-utils/assert/assert.h>
+
+using blockstore::Block;
+using cpputils::Data;
+using cpputils::unique_ref;
+using cpputils::make_unique_ref;
+using blockstore::Key;
+
+namespace blobstore {
+namespace onblocks {
+namespace datanodestore {
+
+DataInnerNode::DataInnerNode(DataNodeView view)
+: DataNode(std::move(view)) {
+  ASSERT(depth() > 0, "Inner node can't have depth 0. Is this a leaf maybe?");
+}
+
+DataInnerNode::~DataInnerNode() {
+}
+
+unique_ref<DataInnerNode> DataInnerNode::InitializeNewNode(unique_ref<Block> block, const DataNode &first_child) {
+  DataNodeView node(std::move(block));
+  node.setDepth(first_child.depth() + 1);
+  node.setSize(1);
+  auto result = make_unique_ref<DataInnerNode>(std::move(node));
+  result->ChildrenBegin()->setKey(first_child.key());
+  return result;
+}
+
+uint32_t DataInnerNode::numChildren() const {
+  return node().Size();
+}
+
+DataInnerNode::ChildEntry *DataInnerNode::ChildrenBegin() {
+  return const_cast<ChildEntry*>(const_cast<const DataInnerNode*>(this)->ChildrenBegin());
+}
+
+const DataInnerNode::ChildEntry *DataInnerNode::ChildrenBegin() const {
+  return node().DataBegin<ChildEntry>();
+}
+
+DataInnerNode::ChildEntry *DataInnerNode::ChildrenEnd() {
+  return const_cast<ChildEntry*>(const_cast<const DataInnerNode*>(this)->ChildrenEnd());
+}
+
+const DataInnerNode::ChildEntry *DataInnerNode::ChildrenEnd() const {
+  return ChildrenBegin() + node().Size();
+}
+
+DataInnerNode::ChildEntry *DataInnerNode::LastChild() {
+  return const_cast<ChildEntry*>(const_cast<const DataInnerNode*>(this)->LastChild());
+}
+
+const DataInnerNode::ChildEntry *DataInnerNode::LastChild() const {
+  return getChild(numChildren()-1);
+}
+
+DataInnerNode::ChildEntry *DataInnerNode::getChild(unsigned int index) {
+  return const_cast<ChildEntry*>(const_cast<const DataInnerNode*>(this)->getChild(index));
+}
+
+const DataInnerNode::ChildEntry *DataInnerNode::getChild(unsigned int index) const {
+  ASSERT(index < numChildren(), "Accessing child out of range");
+  return ChildrenBegin()+index;
+}
+
+void DataInnerNode::addChild(const DataNode &child) {
+  ASSERT(numChildren() < maxStoreableChildren(), "Adding more children than we can store");
+  ASSERT(child.depth() == depth()-1, "The child that should be added has wrong depth");
+  node().setSize(node().Size()+1);
+  LastChild()->setKey(child.key());
+}
+
+void DataInnerNode::removeLastChild() {
+  ASSERT(node().Size() > 1, "There is no child to remove");
+  node().setSize(node().Size()-1);
+}
+
+uint32_t DataInnerNode::maxStoreableChildren() const {
+  return node().layout().maxChildrenPerInnerNode();
+}
+
+}
+}
+}

src/blobstore/implementations/onblocks/datanodestore/DataInnerNode.h

@@ -0,0 +1,49 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATANODESTORE_DATAINNERNODE_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATANODESTORE_DATAINNERNODE_H_
+
+#include "DataNode.h"
+#include "DataInnerNode_ChildEntry.h"
+
+namespace blobstore {
+namespace onblocks {
+namespace datanodestore {
+
+class DataInnerNode final: public DataNode {
+public:
+  static cpputils::unique_ref<DataInnerNode> InitializeNewNode(cpputils::unique_ref<blockstore::Block> block, const DataNode &first_child_key);
+
+  DataInnerNode(DataNodeView block);
+  ~DataInnerNode();
+
+  using ChildEntry = DataInnerNode_ChildEntry;
+
+  uint32_t maxStoreableChildren() const;
+
+  ChildEntry *getChild(unsigned int index);
+  const ChildEntry *getChild(unsigned int index) const;
+
+  uint32_t numChildren() const;
+
+  void addChild(const DataNode &child_key);
+
+  void removeLastChild();
+
+  ChildEntry *LastChild();
+  const ChildEntry *LastChild() const;
+
+private:
+
+  ChildEntry *ChildrenBegin();
+  ChildEntry *ChildrenEnd();
+  const ChildEntry *ChildrenBegin() const;
+  const ChildEntry *ChildrenEnd() const;
+
+  DISALLOW_COPY_AND_ASSIGN(DataInnerNode);
+};
+
+}
+}
+}
+
+#endif

src/blobstore/implementations/onblocks/datanodestore/DataInnerNode_ChildEntry.h

@@ -0,0 +1,30 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATANODESTORE_DATAINNERNODE_CHILDENTRY_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATANODESTORE_DATAINNERNODE_CHILDENTRY_H_
+
+#include <messmer/cpp-utils/macros.h>
+
+namespace blobstore{
+namespace onblocks{
+namespace datanodestore{
+
+struct DataInnerNode_ChildEntry final {
+public:
+  blockstore::Key key() const {
+    return blockstore::Key::FromBinary(_keydata);
+  }
+private:
+  void setKey(const blockstore::Key &key) {
+    key.ToBinary(_keydata);
+  }
+  friend class DataInnerNode;
+  uint8_t _keydata[blockstore::Key::BINARY_LENGTH];
+
+  DISALLOW_COPY_AND_ASSIGN(DataInnerNode_ChildEntry);
+};
+
+}
+}
+}
+
+#endif

src/blobstore/implementations/onblocks/datanodestore/DataLeafNode.cpp

@@ -0,0 +1,67 @@
+#include "DataLeafNode.h"
+#include "DataInnerNode.h"
+#include <messmer/cpp-utils/assert/assert.h>
+
+using blockstore::Block;
+using cpputils::Data;
+using blockstore::Key;
+using cpputils::unique_ref;
+using cpputils::make_unique_ref;
+
+namespace blobstore {
+namespace onblocks {
+namespace datanodestore {
+
+DataLeafNode::DataLeafNode(DataNodeView view)
+: DataNode(std::move(view)) {
+  ASSERT(node().Depth() == 0, "Leaf node must have depth 0. Is it an inner node instead?");
+  ASSERT(numBytes() <= maxStoreableBytes(), "Leaf says it stores more bytes than it has space for");
+}
+
+DataLeafNode::~DataLeafNode() {
+}
+
+unique_ref<DataLeafNode> DataLeafNode::InitializeNewNode(unique_ref<Block> block) {
+  DataNodeView node(std::move(block));
+  node.setDepth(0);
+  node.setSize(0);
+  //fillDataWithZeroes(); not needed, because a newly created block will be zeroed out. DataLeafNodeTest.SpaceIsZeroFilledWhenGrowing ensures this.
+  return make_unique_ref<DataLeafNode>(std::move(node));
+}
+
+void DataLeafNode::read(void *target, uint64_t offset, uint64_t size) const {
+  ASSERT(offset <= node().Size() && offset + size <= node().Size(), "Read out of valid area"); // Also check offset, because the addition could lead to overflows
+  std::memcpy(target, (uint8_t*)node().data() + offset, size);
+}
+
+void DataLeafNode::write(const void *source, uint64_t offset, uint64_t size) {
+  ASSERT(offset <= node().Size() && offset + size <= node().Size(), "Write out of valid area"); // Also check offset, because the addition could lead to overflows
+  node().write(source, offset, size);
+}
+
+uint32_t DataLeafNode::numBytes() const {
+  return node().Size();
+}
+
+void DataLeafNode::resize(uint32_t new_size) {
+  ASSERT(new_size <= maxStoreableBytes(), "Trying to resize to a size larger than the maximal size");
+  uint32_t old_size = node().Size();
+  if (new_size < old_size) {
+    fillDataWithZeroesFromTo(new_size, old_size);
+  }
+  node().setSize(new_size);
+}
+
+void DataLeafNode::fillDataWithZeroesFromTo(off_t begin, off_t end) {
+  Data ZEROES(end-begin);
+  ZEROES.FillWithZeroes();
+  node().write(ZEROES.data(), begin, end-begin);
+}
+
+uint64_t DataLeafNode::maxStoreableBytes() const {
+  return node().layout().maxBytesPerLeaf();
+}
+
+}
+}
+}

src/blobstore/implementations/onblocks/datanodestore/DataLeafNode.h

@@ -0,0 +1,39 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATANODESTORE_DATALEAFNODE_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATANODESTORE_DATALEAFNODE_H_
+
+#include "DataNode.h"
+
+namespace blobstore {
+namespace onblocks {
+namespace datanodestore {
+class DataInnerNode;
+
+class DataLeafNode final: public DataNode {
+public:
+  static cpputils::unique_ref<DataLeafNode> InitializeNewNode(cpputils::unique_ref<blockstore::Block> block);
+
+  DataLeafNode(DataNodeView block);
+  ~DataLeafNode();
+
+  //Returning uint64_t, because calculations handling this probably need to be done in 64bit to support >4GB blobs.
+  uint64_t maxStoreableBytes() const;
+
+  void read(void *target, uint64_t offset, uint64_t size) const;
+  void write(const void *source, uint64_t offset, uint64_t size);
+
+  uint32_t numBytes() const;
+
+  void resize(uint32_t size);
+
+private:
+  void fillDataWithZeroesFromTo(off_t begin, off_t end);
+
+  DISALLOW_COPY_AND_ASSIGN(DataLeafNode);
+};
+
+}
+}
+}
+
+#endif

src/blobstore/implementations/onblocks/datanodestore/DataNode.cpp

@@ -0,0 +1,54 @@
+#include "DataInnerNode.h"
+#include "DataLeafNode.h"
+#include "DataNode.h"
+#include "DataNodeStore.h"
+#include <messmer/blockstore/utils/BlockStoreUtils.h>
+
+using blockstore::Block;
+using blockstore::Key;
+
+using std::runtime_error;
+using cpputils::unique_ref;
+
+namespace blobstore {
+namespace onblocks {
+namespace datanodestore {
+
+DataNode::DataNode(DataNodeView node)
+: _node(std::move(node)) {
+}
+
+DataNode::~DataNode() {
+}
+
+DataNodeView &DataNode::node() {
+  return const_cast<DataNodeView&>(const_cast<const DataNode*>(this)->node());
+}
+
+const DataNodeView &DataNode::node() const {
+  return _node;
+}
+
+const Key &DataNode::key() const {
+  return _node.key();
+}
+
+uint8_t DataNode::depth() const {
+  return _node.Depth();
+}
+
+unique_ref<DataInnerNode> DataNode::convertToNewInnerNode(unique_ref<DataNode> node, const DataNode &first_child) {
+  Key key = node->key();
+  auto block = node->_node.releaseBlock();
+  blockstore::utils::fillWithZeroes(block.get());
+
+  return DataInnerNode::InitializeNewNode(std::move(block), first_child);
+}
+
+void DataNode::flush() const {
+  _node.flush();
+}
+
+}
+}
+}

src/blobstore/implementations/onblocks/datanodestore/DataNode.h

@@ -0,0 +1,44 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATANODESTORE_DATANODE_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATANODESTORE_DATANODE_H_
+
+#include "DataNodeView.h"
+#include <messmer/cpp-utils/data/Data.h>
+
+namespace blobstore {
+namespace onblocks {
+namespace datanodestore {
+class DataNodeStore;
+class DataInnerNode;
+
+class DataNode {
+public:
+  virtual ~DataNode();
+
+  const blockstore::Key &key() const;
+
+  uint8_t depth() const;
+
+  static cpputils::unique_ref<DataInnerNode> convertToNewInnerNode(cpputils::unique_ref<DataNode> node, const DataNode &first_child);
+
+  void flush() const;
+
+protected:
+  DataNode(DataNodeView block);
+
+  DataNodeView &node();
+  const DataNodeView &node() const;
+  friend class DataNodeStore;
+
+private:
+  DataNodeView _node;
+
+  DISALLOW_COPY_AND_ASSIGN(DataNode);
+};
+
+}
+}
+}
+
+
+#endif

src/blobstore/implementations/onblocks/datanodestore/DataNodeStore.cpp

@@ -0,0 +1,113 @@
+#include "DataInnerNode.h"
+#include "DataLeafNode.h"
+#include "DataNodeStore.h"
+#include "messmer/blockstore/interface/BlockStore.h"
+#include "messmer/blockstore/interface/Block.h"
+#include "messmer/blockstore/utils/BlockStoreUtils.h"
+#include <messmer/cpp-utils/assert/assert.h>
+
+using blockstore::BlockStore;
+using blockstore::Block;
+using blockstore::Key;
+using cpputils::Data;
+using cpputils::unique_ref;
+using cpputils::make_unique_ref;
+using std::runtime_error;
+using boost::optional;
+using boost::none;
+
+namespace blobstore {
+namespace onblocks {
+namespace datanodestore {
+
+DataNodeStore::DataNodeStore(unique_ref<BlockStore> blockstore, uint32_t blocksizeBytes)
+: _blockstore(std::move(blockstore)), _layout(blocksizeBytes) {
+}
+
+DataNodeStore::~DataNodeStore() {
+}
+
+unique_ref<DataNode> DataNodeStore::load(unique_ref<Block> block) {
+  ASSERT(block->size() == _layout.blocksizeBytes(), "Loading block of wrong size");
+  DataNodeView node(std::move(block));
+
+  if (node.Depth() == 0) {
+    return make_unique_ref<DataLeafNode>(std::move(node));
+  } else if (node.Depth() <= MAX_DEPTH) {
+    return make_unique_ref<DataInnerNode>(std::move(node));
+  } else {
+    throw runtime_error("Tree is to deep. Data corruption?");
+  }
+}
+
+unique_ref<DataInnerNode> DataNodeStore::createNewInnerNode(const DataNode &first_child) {
+  ASSERT(first_child.node().layout().blocksizeBytes() == _layout.blocksizeBytes(), "Source node has wrong layout. Is it from the same DataNodeStore?");
+  //TODO Initialize block and then create it in the blockstore - this is more efficient than creating it and then writing to it
+  auto block = _blockstore->create(Data(_layout.blocksizeBytes()).FillWithZeroes());
+  return DataInnerNode::InitializeNewNode(std::move(block), first_child);
+}
+
+unique_ref<DataLeafNode> DataNodeStore::createNewLeafNode() {
+  //TODO Initialize block and then create it in the blockstore - this is more efficient than creating it and then writing to it
+  auto block = _blockstore->create(Data(_layout.blocksizeBytes()).FillWithZeroes());
+  return DataLeafNode::InitializeNewNode(std::move(block));
+}
+
+optional<unique_ref<DataNode>> DataNodeStore::load(const Key &key) {
+  auto block = _blockstore->load(key);
+  if (block == none) {
+    return none;
+  } else {
+    return load(std::move(*block));
+  }
+}
+
+unique_ref<DataNode> DataNodeStore::createNewNodeAsCopyFrom(const DataNode &source) {
+  ASSERT(source.node().layout().blocksizeBytes() == _layout.blocksizeBytes(), "Source node has wrong layout. Is it from the same DataNodeStore?");
+  auto newBlock = blockstore::utils::copyToNewBlock(_blockstore.get(), source.node().block());
+  return load(std::move(newBlock));
+}
+
+unique_ref<DataNode> DataNodeStore::overwriteNodeWith(unique_ref<DataNode> target, const DataNode &source) {
+  ASSERT(target->node().layout().blocksizeBytes() == _layout.blocksizeBytes(), "Target node has wrong layout. Is it from the same DataNodeStore?");
+  ASSERT(source.node().layout().blocksizeBytes() == _layout.blocksizeBytes(), "Source node has wrong layout. Is it from the same DataNodeStore?");
+  Key key = target->key();
+  {
+    auto targetBlock = target->node().releaseBlock();
+    cpputils::destruct(std::move(target)); // Call destructor
+    blockstore::utils::copyTo(targetBlock.get(), source.node().block());
+  }
+  auto loaded = load(key);
+  ASSERT(loaded != none, "Couldn't load the target node after overwriting it");
+  return std::move(*loaded);
+}
+
+void DataNodeStore::remove(unique_ref<DataNode> node) {
+  auto block = node->node().releaseBlock();
+  cpputils::destruct(std::move(node)); // Call destructor
+  _blockstore->remove(std::move(block));
+}
+
+uint64_t DataNodeStore::numNodes() const {
+  return _blockstore->numBlocks();
+}
+
+void DataNodeStore::removeSubtree(unique_ref<DataNode> node) {
+  DataInnerNode *inner = dynamic_cast<DataInnerNode*>(node.get());
+  if (inner != nullptr) {
+    for (uint32_t i = 0; i < inner->numChildren(); ++i) {
+      auto child = load(inner->getChild(i)->key());
+      ASSERT(child != none, "Couldn't load child node");
+      removeSubtree(std::move(*child));
+    }
+  }
+  remove(std::move(node));
+}
+
+DataNodeLayout DataNodeStore::layout() const {
+  return _layout;
+}
+
+}
+}
+}

src/blobstore/implementations/onblocks/datanodestore/DataNodeStore.h

@@ -0,0 +1,60 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATANODESTORE_DATANODESTORE_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATANODESTORE_DATANODESTORE_H_
+
+#include <memory>
+#include "messmer/cpp-utils/macros.h"
+#include "DataNodeView.h"
+#include <messmer/blockstore/utils/Key.h>
+
+namespace blockstore{
+class Block;
+class BlockStore;
+}
+
+namespace blobstore {
+namespace onblocks {
+namespace datanodestore {
+class DataNode;
+class DataLeafNode;
+class DataInnerNode;
+
+class DataNodeStore final {
+public:
+  DataNodeStore(cpputils::unique_ref<blockstore::BlockStore> blockstore, uint32_t blocksizeBytes);
+  ~DataNodeStore();
+
+  static constexpr uint8_t MAX_DEPTH = 10;
+
+  DataNodeLayout layout() const;
+
+  boost::optional<cpputils::unique_ref<DataNode>> load(const blockstore::Key &key);
+
+  cpputils::unique_ref<DataLeafNode> createNewLeafNode();
+  cpputils::unique_ref<DataInnerNode> createNewInnerNode(const DataNode &first_child);
+
+  cpputils::unique_ref<DataNode> createNewNodeAsCopyFrom(const DataNode &source);
+
+  cpputils::unique_ref<DataNode> overwriteNodeWith(cpputils::unique_ref<DataNode> target, const DataNode &source);
+
+  void remove(cpputils::unique_ref<DataNode> node);
+
+  void removeSubtree(cpputils::unique_ref<DataNode> node);
+
+  uint64_t numNodes() const;
+  //TODO Test overwriteNodeWith(), createNodeAsCopyFrom(), removeSubtree()
+
+private:
+  cpputils::unique_ref<DataNode> load(cpputils::unique_ref<blockstore::Block> block);
+
+  cpputils::unique_ref<blockstore::BlockStore> _blockstore;
+  const DataNodeLayout _layout;
+
+  DISALLOW_COPY_AND_ASSIGN(DataNodeStore);
+};
+
+}
+}
+}
+
+#endif

src/blobstore/implementations/onblocks/datanodestore/DataNodeView.h

@@ -0,0 +1,140 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATANODESTORE_DATANODEVIEW_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATANODESTORE_DATANODEVIEW_H_
+
+#include "messmer/blockstore/interface/Block.h"
+#include "../BlobStoreOnBlocks.h"
+#include "DataInnerNode_ChildEntry.h"
+
+#include <messmer/cpp-utils/pointer/unique_ref.h>
+
+#include <memory>
+#include <stdexcept>
+#include <type_traits>
+
+namespace blobstore {
+namespace onblocks {
+namespace datanodestore {
+
+//TODO Move DataNodeLayout into own file
+class DataNodeLayout final {
+public:
+  constexpr DataNodeLayout(uint32_t blocksizeBytes)
+    :_blocksizeBytes(
+        (HEADERSIZE_BYTES + 2*sizeof(DataInnerNode_ChildEntry) <= blocksizeBytes)
+        ? blocksizeBytes
+        : throw std::logic_error("Blocksize too small, not enough space to store two children in an inner node")) {
+  }
+
+  //Total size of the header
+  static constexpr uint32_t HEADERSIZE_BYTES = 8;
+  //Where in the header is the depth field
+  static constexpr uint32_t DEPTH_OFFSET_BYTES = 0;
+  //Where in the header is the size field (for inner nodes: number of children, for leafs: content data size)
+  static constexpr uint32_t SIZE_OFFSET_BYTES = 4;
+
+
+  //Size of a block (header + data region)
+  constexpr uint32_t blocksizeBytes() const {
+    return _blocksizeBytes;
+  }
+
+  //Number of bytes in the data region of a node
+  constexpr uint32_t datasizeBytes() const {
+    return _blocksizeBytes - HEADERSIZE_BYTES;
+  }
+
+  //Maximum number of children an inner node can store
+  constexpr uint32_t maxChildrenPerInnerNode() const {
+    return datasizeBytes() / sizeof(DataInnerNode_ChildEntry);
+  }
+
+  //Maximum number of bytes a leaf can store
+  //We are returning uint64_t here, because calculations involving maxBytesPerLeaf most probably should use 64bit integers to support blobs >4GB.
+  constexpr uint64_t maxBytesPerLeaf() const {
+    return datasizeBytes();
+  }
+private:
+  uint32_t _blocksizeBytes;
+};
+
+class DataNodeView final {
+public:
+  DataNodeView(cpputils::unique_ref<blockstore::Block> block): _block(std::move(block)) {
+  }
+  ~DataNodeView() {}
+
+  DataNodeView(DataNodeView &&rhs) = default;
+
+  uint8_t Depth() const {
+    return *((uint8_t*)_block->data()+DataNodeLayout::DEPTH_OFFSET_BYTES);
+  }
+
+  void setDepth(uint8_t value) {
+    _block->write(&value, DataNodeLayout::DEPTH_OFFSET_BYTES, sizeof(value));
+  }
+
+  uint32_t Size() const {
+    return *(uint32_t*)((uint8_t*)_block->data()+DataNodeLayout::SIZE_OFFSET_BYTES);
+  }
+
+  void setSize(uint32_t value) {
+    _block->write(&value, DataNodeLayout::SIZE_OFFSET_BYTES, sizeof(value));
+  }
+
+  const void *data() const {
+    return (uint8_t*)_block->data() + DataNodeLayout::HEADERSIZE_BYTES;
+  }
+
+  void write(const void *source, uint64_t offset, uint64_t size) {
+    _block->write(source, offset + DataNodeLayout::HEADERSIZE_BYTES, size);
+  }
+
+  template<typename Entry>
+  const Entry *DataBegin() const {
+    return GetOffset<DataNodeLayout::HEADERSIZE_BYTES, Entry>();
+  }
+
+  template<typename Entry>
+  const Entry *DataEnd() const {
+    const unsigned int NUM_ENTRIES = layout().datasizeBytes() / sizeof(Entry);
+    return DataBegin<Entry>() + NUM_ENTRIES;
+  }
+
+  DataNodeLayout layout() const {
+    return DataNodeLayout(_block->size());
+  }
+
+  cpputils::unique_ref<blockstore::Block> releaseBlock() {
+    return std::move(_block);
+  }
+
+  const blockstore::Block &block() const {
+    return *_block;
+  }
+
+  const blockstore::Key &key() const {
+    return _block->key();
+  }
+
+  void flush() const {
+    _block->flush();
+  }
+
+private:
+  template<int offset, class Type>
+  const Type *GetOffset() const {
+    return (Type*)(((const int8_t*)_block->data())+offset);
+  }
+
+  cpputils::unique_ref<blockstore::Block> _block;
+
+  DISALLOW_COPY_AND_ASSIGN(DataNodeView);
+
+};
+
+}
+}
+}
+
+#endif

src/blobstore/implementations/onblocks/datatreestore/DataTree.cpp

@@ -0,0 +1,334 @@
+#include "DataTree.h"
+
+#include "../datanodestore/DataNodeStore.h"
+#include "../datanodestore/DataInnerNode.h"
+#include "../datanodestore/DataLeafNode.h"
+#include "../utils/Math.h"
+
+#include "impl/algorithms.h"
+
+#include "messmer/cpp-utils/pointer/cast.h"
+#include "messmer/cpp-utils/pointer/optional_ownership_ptr.h"
+#include <cmath>
+#include <messmer/cpp-utils/assert/assert.h>
+
+using blockstore::Key;
+using blobstore::onblocks::datanodestore::DataNodeStore;
+using blobstore::onblocks::datanodestore::DataNode;
+using blobstore::onblocks::datanodestore::DataInnerNode;
+using blobstore::onblocks::datanodestore::DataLeafNode;
+using blobstore::onblocks::datanodestore::DataNodeLayout;
+
+using std::dynamic_pointer_cast;
+using std::function;
+using boost::shared_mutex;
+using boost::shared_lock;
+using boost::unique_lock;
+using boost::none;
+using std::vector;
+
+using cpputils::dynamic_pointer_move;
+using cpputils::optional_ownership_ptr;
+using cpputils::WithOwnership;
+using cpputils::WithoutOwnership;
+using cpputils::unique_ref;
+
+namespace blobstore {
+namespace onblocks {
+namespace datatreestore {
+
+DataTree::DataTree(DataNodeStore *nodeStore, unique_ref<DataNode> rootNode)
+  : _mutex(), _nodeStore(nodeStore), _rootNode(std::move(rootNode)) {
+}
+
+DataTree::~DataTree() {
+}
+
+void DataTree::removeLastDataLeaf() {
+  auto deletePosOrNull = algorithms::GetLowestRightBorderNodeWithMoreThanOneChildOrNull(_nodeStore, _rootNode.get());
+  ASSERT(deletePosOrNull.get() != nullptr, "Tree has only one leaf, can't shrink it.");
+
+  deleteLastChildSubtree(deletePosOrNull.get());
+
+  ifRootHasOnlyOneChildReplaceRootWithItsChild();
+}
+
+void DataTree::ifRootHasOnlyOneChildReplaceRootWithItsChild() {
+  DataInnerNode *rootNode = dynamic_cast<DataInnerNode*>(_rootNode.get());
+  ASSERT(rootNode != nullptr, "RootNode is not an inner node");
+  if (rootNode->numChildren() == 1) {
+    auto child = _nodeStore->load(rootNode->getChild(0)->key());
+    ASSERT(child != none, "Couldn't load first child of root node");
+    _rootNode = _nodeStore->overwriteNodeWith(std::move(_rootNode), **child);
+    _nodeStore->remove(std::move(*child));
+  }
+}
+
+void DataTree::deleteLastChildSubtree(DataInnerNode *node) {
+  auto lastChild = _nodeStore->load(node->LastChild()->key());
+  ASSERT(lastChild != none, "Couldn't load last child");
+  _nodeStore->removeSubtree(std::move(*lastChild));
+  node->removeLastChild();
+}
+
+unique_ref<DataLeafNode> DataTree::addDataLeaf() {
+  auto insertPosOrNull = algorithms::GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNull(_nodeStore, _rootNode.get());
+  if (insertPosOrNull) {
+    return addDataLeafAt(insertPosOrNull.get());
+  } else {
+    return addDataLeafToFullTree();
+  }
+}
+
+unique_ref<DataLeafNode> DataTree::addDataLeafAt(DataInnerNode *insertPos) {
+  auto new_leaf = _nodeStore->createNewLeafNode();
+  auto chain = createChainOfInnerNodes(insertPos->depth()-1, new_leaf.get());
+  insertPos->addChild(*chain);
+  return new_leaf;
+}
+
+optional_ownership_ptr<DataNode> DataTree::createChainOfInnerNodes(unsigned int num, DataNode *child) {
+  //TODO This function is implemented twice, once with optional_ownership_ptr, once with unique_ref. Redundancy!
+  optional_ownership_ptr<DataNode> chain = cpputils::WithoutOwnership<DataNode>(child);
+  for(unsigned int i=0; i<num; ++i) {
+    auto newnode = _nodeStore->createNewInnerNode(*chain);
+    chain = cpputils::WithOwnership<DataNode>(std::move(newnode));
+  }
+  return chain;
+}
+
+unique_ref<DataNode> DataTree::createChainOfInnerNodes(unsigned int num, unique_ref<DataNode> child) {
+  unique_ref<DataNode> chain = std::move(child);
+  for(unsigned int i=0; i<num; ++i) {
+    chain = _nodeStore->createNewInnerNode(*chain);
+  }
+  return chain;
+}
+
+DataInnerNode* DataTree::increaseTreeDepth(unsigned int levels) {
+  ASSERT(levels >= 1, "Parameter out of bounds: tried to increase tree depth by zero.");
+  auto copyOfOldRoot = _nodeStore->createNewNodeAsCopyFrom(*_rootNode);
+  auto chain = createChainOfInnerNodes(levels-1, copyOfOldRoot.get());
+  auto newRootNode = DataNode::convertToNewInnerNode(std::move(_rootNode), *chain);
+  DataInnerNode *result = newRootNode.get();
+  _rootNode = std::move(newRootNode);
+  return result;
+}
+
+unique_ref<DataLeafNode> DataTree::addDataLeafToFullTree() {
+  DataInnerNode *rootNode = increaseTreeDepth(1);
+  auto newLeaf = addDataLeafAt(rootNode);
+  return newLeaf;
+}
+
+const Key &DataTree::key() const {
+  return _rootNode->key();
+}
+
+void DataTree::flush() const {
+  // By grabbing a lock, we ensure that all modifying functions don't run currently and are therefore flushed
+  unique_lock<shared_mutex> lock(_mutex);
+  // We also have to flush the root node
+  _rootNode->flush();
+}
+
+unique_ref<DataNode> DataTree::releaseRootNode() {
+  return std::move(_rootNode);
+}
+
+//TODO Test numLeaves(), for example also two configurations with same number of bytes but different number of leaves (last leaf has 0 bytes)
+uint32_t DataTree::numLeaves() const {
+  shared_lock<shared_mutex> lock(_mutex);
+  return _numLeaves(*_rootNode);
+}
+
+uint32_t DataTree::_numLeaves(const DataNode &node) const {
+  const DataLeafNode *leaf = dynamic_cast<const DataLeafNode*>(&node);
+  if (leaf != nullptr) {
+    return 1;
+  }
+
+  const DataInnerNode &inner = dynamic_cast<const DataInnerNode&>(node);
+  uint64_t numLeavesInLeftChildren = (inner.numChildren()-1) * leavesPerFullChild(inner);
+  auto lastChild = _nodeStore->load(inner.LastChild()->key());
+  ASSERT(lastChild != none, "Couldn't load last child");
+  uint64_t numLeavesInRightChild = _numLeaves(**lastChild);
+
+  return numLeavesInLeftChildren + numLeavesInRightChild;
+}
+
+void DataTree::traverseLeaves(uint32_t beginIndex, uint32_t endIndex, function<void (DataLeafNode*, uint32_t)> func) {
+  //TODO Can we traverse in parallel?
+  unique_lock<shared_mutex> lock(_mutex); //TODO Only lock when resizing. Otherwise parallel read/write to a blob is not possible!
+  ASSERT(beginIndex <= endIndex, "Invalid parameters");
+  if (0 == endIndex) {
+    // In this case the utils::ceilLog(_, endIndex) below would fail
+    return;
+  }
+
+  uint8_t neededTreeDepth = utils::ceilLog(_nodeStore->layout().maxChildrenPerInnerNode(), endIndex);
+  uint32_t numLeaves = this->_numLeaves(*_rootNode); // TODO Querying the size causes a tree traversal down to the leaves. Possible without querying the size?
+  if (_rootNode->depth() < neededTreeDepth) {
+    //TODO Test cases that actually increase it here by 0 level / 1 level / more than 1 level
+    increaseTreeDepth(neededTreeDepth - _rootNode->depth());
+  }
+
+  if (numLeaves <= beginIndex) {
+    //TODO Test cases with numLeaves < / >= beginIndex
+    // There is a gap between the current size and the begin of the traversal
+    return _traverseLeaves(_rootNode.get(), 0, numLeaves-1, endIndex, [beginIndex, numLeaves, &func, this](DataLeafNode* node, uint32_t index) {
+      if (index >= beginIndex) {
+        func(node, index);
+      } else if (index == numLeaves - 1) {
+        // It is the old last leaf - resize it to maximum
+        node->resize(_nodeStore->layout().maxBytesPerLeaf());
+      }
+    });
+  } else if (numLeaves < endIndex) {
+    // We are starting traversal in the valid region, but traverse until after it (we grow new leaves)
+    return _traverseLeaves(_rootNode.get(), 0, beginIndex, endIndex, [numLeaves, &func, this] (DataLeafNode *node, uint32_t index) {
+      if (index == numLeaves - 1) {
+        // It is the old last leaf  - resize it to maximum
+        node->resize(_nodeStore->layout().maxBytesPerLeaf());
+      }
+      func(node, index);
+    });
+  } else {
+    //We are traversing entirely inside the valid region
+    _traverseLeaves(_rootNode.get(), 0, beginIndex, endIndex, func);
+  }
+}
+
+void DataTree::_traverseLeaves(DataNode *root, uint32_t leafOffset, uint32_t beginIndex, uint32_t endIndex, function<void (DataLeafNode*, uint32_t)> func) {
+  DataLeafNode *leaf = dynamic_cast<DataLeafNode*>(root);
+  if (leaf != nullptr) {
+    ASSERT(beginIndex <= 1 && endIndex <= 1, "If root node is a leaf, the (sub)tree has only one leaf - access indices must be 0 or 1.");
+    if (beginIndex == 0 && endIndex == 1) {
+      func(leaf, leafOffset);
+    }
+    return;
+  }
+
+  DataInnerNode *inner = dynamic_cast<DataInnerNode*>(root);
+  uint32_t leavesPerChild = leavesPerFullChild(*inner);
+  uint32_t beginChild = beginIndex/leavesPerChild;
+  uint32_t endChild = utils::ceilDivision(endIndex, leavesPerChild);
+  vector<unique_ref<DataNode>> children = getOrCreateChildren(inner, beginChild, endChild);
+
+  for (uint32_t childIndex = beginChild; childIndex < endChild; ++childIndex) {
+    uint32_t childOffset = childIndex * leavesPerChild;
+    uint32_t localBeginIndex = utils::maxZeroSubtraction(beginIndex, childOffset);
+    uint32_t localEndIndex = std::min(leavesPerChild, endIndex - childOffset);
+    auto child = std::move(children[childIndex-beginChild]);
+    _traverseLeaves(child.get(), leafOffset + childOffset, localBeginIndex, localEndIndex, func);
+  }
+}
+
+vector<unique_ref<DataNode>> DataTree::getOrCreateChildren(DataInnerNode *node, uint32_t begin, uint32_t end) {
+  vector<unique_ref<DataNode>> children;
+  children.reserve(end-begin);
+  for (uint32_t childIndex = begin; childIndex < std::min(node->numChildren(), end); ++childIndex) {
+    auto child = _nodeStore->load(node->getChild(childIndex)->key());
+    ASSERT(child != none, "Couldn't load child node");
+    children.emplace_back(std::move(*child));
+  }
+  for (uint32_t childIndex = node->numChildren(); childIndex < end; ++childIndex) {
+    //TODO This creates each child with one chain to one leaf only, and then on the next lower level it
+    //     has to create the children for the child. Would be faster to directly create full trees if necessary.
+    children.emplace_back(addChildTo(node));
+  }
+  ASSERT(children.size() == end-begin, "Number of children in the result is wrong");
+  return children;
+}
+
+unique_ref<DataNode> DataTree::addChildTo(DataInnerNode *node) {
+  auto new_leaf = _nodeStore->createNewLeafNode();
+  new_leaf->resize(_nodeStore->layout().maxBytesPerLeaf());
+  auto chain = createChainOfInnerNodes(node->depth()-1, std::move(new_leaf));
+  node->addChild(*chain);
+  return std::move(chain);
+}
+
+uint32_t DataTree::leavesPerFullChild(const DataInnerNode &root) const {
+  return utils::intPow(_nodeStore->layout().maxChildrenPerInnerNode(), (uint32_t)root.depth()-1);
+}
+
+uint64_t DataTree::numStoredBytes() const {
+  shared_lock<shared_mutex> lock(_mutex);
+  return _numStoredBytes();
+}
+
+uint64_t DataTree::_numStoredBytes() const {
+  return _numStoredBytes(*_rootNode);
+}
+
+uint64_t DataTree::_numStoredBytes(const DataNode &root) const {
+  const DataLeafNode *leaf = dynamic_cast<const DataLeafNode*>(&root);
+  if (leaf != nullptr) {
+    return leaf->numBytes();
+  }
+
+  const DataInnerNode &inner = dynamic_cast<const DataInnerNode&>(root);
+  uint64_t numBytesInLeftChildren = (inner.numChildren()-1) * leavesPerFullChild(inner) * _nodeStore->layout().maxBytesPerLeaf();
+  auto lastChild = _nodeStore->load(inner.LastChild()->key());
+  ASSERT(lastChild != none, "Couldn't load last child");
+  uint64_t numBytesInRightChild = _numStoredBytes(**lastChild);
+
+  return numBytesInLeftChildren + numBytesInRightChild;
+}
+
+void DataTree::resizeNumBytes(uint64_t newNumBytes) {
+  //TODO Can we resize in parallel? Especially creating new blocks (i.e. encrypting them) is expensive and should be done in parallel.
+  boost::upgrade_lock<shared_mutex> lock(_mutex);
+  {
+    boost::upgrade_to_unique_lock<shared_mutex> exclusiveLock(lock);
+    //TODO Faster implementation possible (no addDataLeaf()/removeLastDataLeaf() in a loop, but directly resizing)
+    LastLeaf(_rootNode.get())->resize(_nodeStore->layout().maxBytesPerLeaf());
+    uint64_t currentNumBytes = _numStoredBytes();
+    ASSERT(currentNumBytes % _nodeStore->layout().maxBytesPerLeaf() == 0, "The last leaf is not a max data leaf, although we just resized it to be one.");
+    uint32_t currentNumLeaves = currentNumBytes / _nodeStore->layout().maxBytesPerLeaf();
+    uint32_t newNumLeaves = std::max(UINT64_C(1), utils::ceilDivision(newNumBytes, _nodeStore->layout().maxBytesPerLeaf()));
+
+    for(uint32_t i = currentNumLeaves; i < newNumLeaves; ++i) {
+      addDataLeaf()->resize(_nodeStore->layout().maxBytesPerLeaf());
+    }
+    for(uint32_t i = currentNumLeaves; i > newNumLeaves; --i) {
+      removeLastDataLeaf();
+    }
+    uint32_t newLastLeafSize = newNumBytes - (newNumLeaves-1)*_nodeStore->layout().maxBytesPerLeaf();
+    LastLeaf(_rootNode.get())->resize(newLastLeafSize);
+  }
+  ASSERT(newNumBytes == _numStoredBytes(), "We resized to the wrong number of bytes ("+std::to_string(numStoredBytes())+" instead of "+std::to_string(newNumBytes)+")");
+}
+
+optional_ownership_ptr<DataLeafNode> DataTree::LastLeaf(DataNode *root) {
+  DataLeafNode *leaf = dynamic_cast<DataLeafNode*>(root);
+  if (leaf != nullptr) {
+    return WithoutOwnership(leaf);
+  }
+
+  DataInnerNode *inner = dynamic_cast<DataInnerNode*>(root);
+  auto lastChild = _nodeStore->load(inner->LastChild()->key());
+  ASSERT(lastChild != none, "Couldn't load last child");
+  return WithOwnership(LastLeaf(std::move(*lastChild)));
+}
+
+unique_ref<DataLeafNode> DataTree::LastLeaf(unique_ref<DataNode> root) {
+  auto leaf = dynamic_pointer_move<DataLeafNode>(root);
+  if (leaf != none) {
+    return std::move(*leaf);
+  }
+  auto inner = dynamic_pointer_move<DataInnerNode>(root);
+  ASSERT(inner != none, "Root node is neither a leaf nor an inner node");
+  auto child = _nodeStore->load((*inner)->LastChild()->key());
+  ASSERT(child != none, "Couldn't load last child");
+  return LastLeaf(std::move(*child));
+}
+
+uint64_t DataTree::maxBytesPerLeaf() const {
+  return _nodeStore->layout().maxBytesPerLeaf();
+}
+
+}
+}
+}

src/blobstore/implementations/onblocks/datatreestore/DataTree.h

@@ -0,0 +1,79 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATATREE_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATATREE_H_
+
+#include <memory>
+#include <messmer/cpp-utils/macros.h>
+#include <messmer/cpp-utils/pointer/optional_ownership_ptr.h>
+#include "../datanodestore/DataNodeView.h"
+//TODO Replace with C++14 once std::shared_mutex is supported
+#include <boost/thread/shared_mutex.hpp>
+#include <messmer/blockstore/utils/Key.h>
+
+namespace blobstore {
+namespace onblocks {
+namespace datanodestore {
+class DataNodeStore;
+class DataInnerNode;
+class DataLeafNode;
+class DataNode;
+}
+namespace datatreestore {
+
+//TODO It is strange that DataLeafNode is still part in the public interface of DataTree. This should be separated somehow.
+class DataTree final {
+public:
+  DataTree(datanodestore::DataNodeStore *nodeStore, cpputils::unique_ref<datanodestore::DataNode> rootNode);
+  ~DataTree();
+
+  const blockstore::Key &key() const;
+  //Returning uint64_t, because calculations handling this probably need to be done in 64bit to support >4GB blobs.
+  uint64_t maxBytesPerLeaf() const;
+
+  void traverseLeaves(uint32_t beginIndex, uint32_t endIndex, std::function<void (datanodestore::DataLeafNode*, uint32_t)> func);
+  void resizeNumBytes(uint64_t newNumBytes);
+
+  uint32_t numLeaves() const;
+  uint64_t numStoredBytes() const;
+
+  void flush() const;
+
+private:
+  mutable boost::shared_mutex _mutex;
+  datanodestore::DataNodeStore *_nodeStore;
+  cpputils::unique_ref<datanodestore::DataNode> _rootNode;
+
+  cpputils::unique_ref<datanodestore::DataLeafNode> addDataLeaf();
+  void removeLastDataLeaf();
+
+  cpputils::unique_ref<datanodestore::DataNode> releaseRootNode();
+  friend class DataTreeStore;
+
+  cpputils::unique_ref<datanodestore::DataLeafNode> addDataLeafAt(datanodestore::DataInnerNode *insertPos);
+  cpputils::optional_ownership_ptr<datanodestore::DataNode> createChainOfInnerNodes(unsigned int num, datanodestore::DataNode *child);
+  cpputils::unique_ref<datanodestore::DataNode> createChainOfInnerNodes(unsigned int num, cpputils::unique_ref<datanodestore::DataNode> child);
+  cpputils::unique_ref<datanodestore::DataLeafNode> addDataLeafToFullTree();
+
+  void deleteLastChildSubtree(datanodestore::DataInnerNode *node);
+  void ifRootHasOnlyOneChildReplaceRootWithItsChild();
+
+  //TODO Use underscore for private methods
+  void _traverseLeaves(datanodestore::DataNode *root, uint32_t leafOffset, uint32_t beginIndex, uint32_t endIndex, std::function<void (datanodestore::DataLeafNode*, uint32_t)> func);
+  uint32_t leavesPerFullChild(const datanodestore::DataInnerNode &root) const;
+  uint64_t _numStoredBytes() const;
+  uint64_t _numStoredBytes(const datanodestore::DataNode &root) const;
+  uint32_t _numLeaves(const datanodestore::DataNode &node) const;
+  cpputils::optional_ownership_ptr<datanodestore::DataLeafNode> LastLeaf(datanodestore::DataNode *root);
+  cpputils::unique_ref<datanodestore::DataLeafNode> LastLeaf(cpputils::unique_ref<datanodestore::DataNode> root);
+  datanodestore::DataInnerNode* increaseTreeDepth(unsigned int levels);
+  std::vector<cpputils::unique_ref<datanodestore::DataNode>> getOrCreateChildren(datanodestore::DataInnerNode *node, uint32_t begin, uint32_t end);
+  cpputils::unique_ref<datanodestore::DataNode> addChildTo(datanodestore::DataInnerNode *node);
+
+  DISALLOW_COPY_AND_ASSIGN(DataTree);
+};
+
+}
+}
+}
+
+#endif

src/blobstore/implementations/onblocks/datatreestore/DataTreeStore.cpp

@@ -0,0 +1,46 @@
+#include "DataTreeStore.h"
+#include "../datanodestore/DataNodeStore.h"
+#include "../datanodestore/DataLeafNode.h"
+#include "DataTree.h"
+
+using cpputils::unique_ref;
+using cpputils::make_unique_ref;
+using boost::optional;
+using boost::none;
+
+using blobstore::onblocks::datanodestore::DataNodeStore;
+using blobstore::onblocks::datanodestore::DataNode;
+
+namespace blobstore {
+namespace onblocks {
+namespace datatreestore {
+
+DataTreeStore::DataTreeStore(unique_ref<DataNodeStore> nodeStore)
+  : _nodeStore(std::move(nodeStore)) {
+}
+
+DataTreeStore::~DataTreeStore() {
+}
+
+optional<unique_ref<DataTree>> DataTreeStore::load(const blockstore::Key &key) {
+  auto node = _nodeStore->load(key);
+  if (node == none) {
+    return none;
+  }
+  return make_unique_ref<DataTree>(_nodeStore.get(), std::move(*node));
+}
+
+unique_ref<DataTree> DataTreeStore::createNewTree() {
+  auto newleaf = _nodeStore->createNewLeafNode();
+  return make_unique_ref<DataTree>(_nodeStore.get(), std::move(newleaf));
+}
+
+void DataTreeStore::remove(unique_ref<DataTree> tree) {
+  auto root = tree->releaseRootNode();
+  cpputils::destruct(std::move(tree)); // Destruct tree
+  _nodeStore->removeSubtree(std::move(root));
+}
+
+}
+}
+}

src/blobstore/implementations/onblocks/datatreestore/DataTreeStore.h

@@ -0,0 +1,40 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATATREESTORE_DATATREESTORE_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATATREESTORE_DATATREESTORE_H_
+
+#include <memory>
+#include <messmer/cpp-utils/macros.h>
+#include <messmer/cpp-utils/pointer/unique_ref.h>
+#include <messmer/blockstore/utils/Key.h>
+#include <boost/optional.hpp>
+
+namespace blobstore {
+namespace onblocks {
+namespace datanodestore {
+class DataNodeStore;
+}
+namespace datatreestore {
+class DataTree;
+
+class DataTreeStore final {
+public:
+  DataTreeStore(cpputils::unique_ref<datanodestore::DataNodeStore> nodeStore);
+  ~DataTreeStore();
+
+  boost::optional<cpputils::unique_ref<DataTree>> load(const blockstore::Key &key);
+
+  cpputils::unique_ref<DataTree> createNewTree();
+
+  void remove(cpputils::unique_ref<DataTree> tree);
+
+private:
+  cpputils::unique_ref<datanodestore::DataNodeStore> _nodeStore;
+
+  DISALLOW_COPY_AND_ASSIGN(DataTreeStore);
+};
+
+}
+}
+}
+
+#endif

src/blobstore/implementations/onblocks/datatreestore/impl/algorithms.cpp

@@ -0,0 +1,67 @@
+#include "algorithms.h"
+#include <messmer/cpp-utils/pointer/cast.h>
+#include <messmer/blockstore/utils/Key.h>
+
+#include "../../datanodestore/DataInnerNode.h"
+#include "../../datanodestore/DataNodeStore.h"
+#include <messmer/cpp-utils/assert/assert.h>
+
+using std::function;
+using cpputils::optional_ownership_ptr;
+using cpputils::dynamic_pointer_move;
+using cpputils::unique_ref;
+using blobstore::onblocks::datanodestore::DataInnerNode;
+using blobstore::onblocks::datanodestore::DataNode;
+using blobstore::onblocks::datanodestore::DataNodeStore;
+using blockstore::Key;
+using boost::optional;
+using boost::none;
+
+namespace blobstore {
+namespace onblocks {
+namespace datatreestore {
+namespace algorithms {
+
+optional<unique_ref<DataInnerNode>> getLastChildAsInnerNode(DataNodeStore *nodeStore, const DataInnerNode &node) {
+  Key key = node.LastChild()->key();
+  auto lastChild = nodeStore->load(key);
+  ASSERT(lastChild != none, "Couldn't load last child");
+  return dynamic_pointer_move<DataInnerNode>(*lastChild);
+}
+
+//Returns the lowest right border node meeting the condition specified (exclusive the leaf).
+//Returns nullptr, if no inner right border node meets the condition.
+optional_ownership_ptr<DataInnerNode> GetLowestInnerRightBorderNodeWithConditionOrNull(DataNodeStore *nodeStore, datanodestore::DataNode *rootNode, function<bool(const DataInnerNode &)> condition) {
+  optional_ownership_ptr<DataInnerNode> currentNode = cpputils::WithoutOwnership(dynamic_cast<DataInnerNode*>(rootNode));
+  optional_ownership_ptr<DataInnerNode> result = cpputils::null<DataInnerNode>();
+  for (unsigned int i=0; i < rootNode->depth(); ++i) {
+    //TODO This unnecessarily loads the leaf node in the last loop run
+    auto lastChild = getLastChildAsInnerNode(nodeStore, *currentNode);
+    if (condition(*currentNode)) {
+      result = std::move(currentNode);
+    }
+    ASSERT(lastChild != none || static_cast<int>(i) == rootNode->depth()-1, "Couldn't get last child as inner node but we're not deep enough yet for the last child to be a leaf");
+    if (lastChild != none) {
+      currentNode = cpputils::WithOwnership(std::move(*lastChild));
+    }
+  }
+
+  return result;
+}
+
+optional_ownership_ptr<DataInnerNode> GetLowestRightBorderNodeWithMoreThanOneChildOrNull(DataNodeStore *nodeStore, DataNode *rootNode) {
+  return GetLowestInnerRightBorderNodeWithConditionOrNull(nodeStore, rootNode, [] (const datanodestore::DataInnerNode &node) {
+    return node.numChildren() > 1;
+  });
+}
+
+optional_ownership_ptr<datanodestore::DataInnerNode> GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNull(datanodestore::DataNodeStore *nodeStore, datanodestore::DataNode *rootNode) {
+  return GetLowestInnerRightBorderNodeWithConditionOrNull(nodeStore, rootNode, [] (const datanodestore::DataInnerNode &node) {
+    return node.numChildren() < node.maxStoreableChildren();
+  });
+}
+
+}
+}
+}
+}

src/blobstore/implementations/onblocks/datatreestore/impl/algorithms.h

@@ -0,0 +1,30 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATATREESTORE_IMPL_ALGORITHMS_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_DATATREESTORE_IMPL_ALGORITHMS_H_
+
+#include <messmer/cpp-utils/pointer/optional_ownership_ptr.h>
+
+namespace blobstore {
+namespace onblocks {
+namespace datanodestore{
+class DataNode;
+class DataInnerNode;
+class DataNodeStore;
+}
+namespace datatreestore {
+namespace algorithms {
+
+//Returns the lowest right border node with at least two children.
+//Returns nullptr, if all right border nodes have only one child (since the root is a right border node, this means that the whole tree has exactly one leaf)
+cpputils::optional_ownership_ptr<datanodestore::DataInnerNode> GetLowestRightBorderNodeWithMoreThanOneChildOrNull(datanodestore::DataNodeStore *nodeStore, datanodestore::DataNode *rootNode);
+
+//Returns the lowest right border node with less than k children (not considering leaves).
+//Returns nullptr, if all right border nodes have k children (the tree is full)
+cpputils::optional_ownership_ptr<datanodestore::DataInnerNode> GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNull(datanodestore::DataNodeStore *nodeStore, datanodestore::DataNode *rootNode);
+
+}
+}
+}
+}
+
+#endif

src/blobstore/implementations/onblocks/parallelaccessdatatreestore/DataTreeRef.cpp

@@ -0,0 +1 @@
+#include "DataTreeRef.h"

src/blobstore/implementations/onblocks/parallelaccessdatatreestore/DataTreeRef.h

@@ -0,0 +1,55 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_PARALLELACCESSDATATREESTORE_DATATREEREF_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_PARALLELACCESSDATATREESTORE_DATATREEREF_H_
+
+#include <messmer/parallelaccessstore/ParallelAccessStore.h>
+#include "../datatreestore/DataTree.h"
+
+namespace blobstore {
+namespace onblocks {
+namespace parallelaccessdatatreestore {
+
+class DataTreeRef final: public parallelaccessstore::ParallelAccessStore<datatreestore::DataTree, DataTreeRef, blockstore::Key>::ResourceRefBase {
+public:
+  DataTreeRef(datatreestore::DataTree *baseTree): _baseTree(baseTree) {}
+
+  const blockstore::Key &key() const {
+    return _baseTree->key();
+  }
+
+  uint64_t maxBytesPerLeaf() const {
+    return _baseTree->maxBytesPerLeaf();
+  }
+
+  void traverseLeaves(uint32_t beginIndex, uint32_t endIndex, std::function<void (datanodestore::DataLeafNode*, uint32_t)> func) {
+    return _baseTree->traverseLeaves(beginIndex, endIndex, func);
+  }
+
+  uint32_t numLeaves() const {
+    return _baseTree->numLeaves();
+  }
+
+  void resizeNumBytes(uint64_t newNumBytes) {
+    return _baseTree->resizeNumBytes(newNumBytes);
+  }
+
+  uint64_t numStoredBytes() const {
+    return _baseTree->numStoredBytes();
+  }
+
+  void flush() {
+    return _baseTree->flush();
+  }
+
+private:
+
+  datatreestore::DataTree *_baseTree;
+
+  DISALLOW_COPY_AND_ASSIGN(DataTreeRef);
+};
+
+}
+}
+}
+
+#endif

src/blobstore/implementations/onblocks/parallelaccessdatatreestore/ParallelAccessDataTreeStore.cpp

@@ -0,0 +1,44 @@
+#include "DataTreeRef.h"
+#include "ParallelAccessDataTreeStore.h"
+#include "ParallelAccessDataTreeStoreAdapter.h"
+#include "../datanodestore/DataNodeStore.h"
+#include "../datanodestore/DataLeafNode.h"
+
+using cpputils::unique_ref;
+using cpputils::make_unique_ref;
+using boost::optional;
+
+using blobstore::onblocks::datatreestore::DataTreeStore;
+using blockstore::Key;
+
+namespace blobstore {
+namespace onblocks {
+using datatreestore::DataTreeStore;
+using datatreestore::DataTree;
+namespace parallelaccessdatatreestore {
+
+ParallelAccessDataTreeStore::ParallelAccessDataTreeStore(unique_ref<DataTreeStore> dataTreeStore)
+  : _dataTreeStore(std::move(dataTreeStore)), _parallelAccessStore(make_unique_ref<ParallelAccessDataTreeStoreAdapter>(_dataTreeStore.get())) {
+}
+
+ParallelAccessDataTreeStore::~ParallelAccessDataTreeStore() {
+}
+
+optional<unique_ref<DataTreeRef>> ParallelAccessDataTreeStore::load(const blockstore::Key &key) {
+  return _parallelAccessStore.load(key);
+}
+
+unique_ref<DataTreeRef> ParallelAccessDataTreeStore::createNewTree() {
+  auto dataTree = _dataTreeStore->createNewTree();
+  Key key = dataTree->key();
+  return _parallelAccessStore.add(key, std::move(dataTree));
+}
+
+void ParallelAccessDataTreeStore::remove(unique_ref<DataTreeRef> tree) {
+  Key key = tree->key();
+  return _parallelAccessStore.remove(key, std::move(tree));
+}
+
+}
+}
+}

src/blobstore/implementations/onblocks/parallelaccessdatatreestore/ParallelAccessDataTreeStore.h

@@ -0,0 +1,43 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_PARALLELACCESSDATATREESTORE_PARALLELACCESSDATATREESTORE_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_PARALLELACCESSDATATREESTORE_PARALLELACCESSDATATREESTORE_H_
+
+#include <memory>
+#include <messmer/cpp-utils/macros.h>
+#include <messmer/blockstore/utils/Key.h>
+#include <messmer/parallelaccessstore/ParallelAccessStore.h>
+
+namespace blobstore {
+namespace onblocks {
+namespace datatreestore {
+class DataTreeStore;
+class DataTree;
+}
+namespace parallelaccessdatatreestore {
+class DataTreeRef;
+
+//TODO Test CachingDataTreeStore
+
+class ParallelAccessDataTreeStore final {
+public:
+  ParallelAccessDataTreeStore(cpputils::unique_ref<datatreestore::DataTreeStore> dataTreeStore);
+  ~ParallelAccessDataTreeStore();
+
+  boost::optional<cpputils::unique_ref<DataTreeRef>> load(const blockstore::Key &key);
+
+  cpputils::unique_ref<DataTreeRef> createNewTree();
+
+  void remove(cpputils::unique_ref<DataTreeRef> tree);
+
+private:
+  cpputils::unique_ref<datatreestore::DataTreeStore> _dataTreeStore;
+  parallelaccessstore::ParallelAccessStore<datatreestore::DataTree, DataTreeRef, blockstore::Key> _parallelAccessStore;
+
+  DISALLOW_COPY_AND_ASSIGN(ParallelAccessDataTreeStore);
+};
+
+}
+}
+}
+
+#endif

src/blobstore/implementations/onblocks/parallelaccessdatatreestore/ParallelAccessDataTreeStoreAdapter.cpp

@@ -0,0 +1 @@
+#include "ParallelAccessDataTreeStoreAdapter.h"

src/blobstore/implementations/onblocks/parallelaccessdatatreestore/ParallelAccessDataTreeStoreAdapter.h

@@ -0,0 +1,38 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_PARALLELACCESSDATATREESTORE_PARALLELACCESSDATATREESTOREADAPTER_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_PARALLELACCESSDATATREESTORE_PARALLELACCESSDATATREESTOREADAPTER_H_
+
+#include <messmer/cpp-utils/macros.h>
+#include <messmer/parallelaccessstore/ParallelAccessStore.h>
+#include "../datatreestore/DataTreeStore.h"
+#include "../datatreestore/DataTree.h"
+
+namespace blobstore {
+namespace onblocks {
+namespace parallelaccessdatatreestore {
+
+class ParallelAccessDataTreeStoreAdapter final: public parallelaccessstore::ParallelAccessBaseStore<datatreestore::DataTree, blockstore::Key> {
+public:
+  ParallelAccessDataTreeStoreAdapter(datatreestore::DataTreeStore *baseDataTreeStore)
+    :_baseDataTreeStore(std::move(baseDataTreeStore)) {
+  }
+
+  boost::optional<cpputils::unique_ref<datatreestore::DataTree>> loadFromBaseStore(const blockstore::Key &key) override {
+	  return _baseDataTreeStore->load(key);
+  }
+
+  void removeFromBaseStore(cpputils::unique_ref<datatreestore::DataTree> dataTree) override {
+	  return _baseDataTreeStore->remove(std::move(dataTree));
+  }
+
+private:
+  datatreestore::DataTreeStore *_baseDataTreeStore;
+
+  DISALLOW_COPY_AND_ASSIGN(ParallelAccessDataTreeStoreAdapter);
+};
+
+}
+}
+}
+
+#endif

src/blobstore/implementations/onblocks/utils/Math.cpp

@@ -0,0 +1 @@
+#include "Math.h"

src/blobstore/implementations/onblocks/utils/Math.h

@@ -0,0 +1,43 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_UTILS_MATH_H_
+#define MESSMER_BLOBSTORE_IMPLEMENTATIONS_ONBLOCKS_UTILS_MATH_H_
+
+#include <cstdint>
+#include <cmath>
+
+namespace blobstore {
+namespace onblocks {
+namespace utils {
+
+template<typename INT_TYPE>
+inline INT_TYPE intPow(INT_TYPE base, INT_TYPE exponent) {
+    INT_TYPE result = 1;
+    for(INT_TYPE i = 0; i < exponent; ++i) {
+        result *= base;
+    }
+    return result;
+}
+
+template<typename INT_TYPE>
+inline INT_TYPE ceilDivision(INT_TYPE dividend, INT_TYPE divisor) {
+    return (dividend + divisor - 1)/divisor;
+}
+
+template<typename INT_TYPE>
+inline INT_TYPE maxZeroSubtraction(INT_TYPE minuend, INT_TYPE subtrahend) {
+    if (minuend < subtrahend) {
+        return 0u;
+    }
+    return minuend-subtrahend;
+}
+
+template<typename INT_TYPE>
+inline INT_TYPE ceilLog(INT_TYPE base, INT_TYPE value) {
+    return std::ceil((long double)std::log(value)/(long double)std::log(base));
+}
+
+}
+}
+}
+
+#endif

src/blobstore/interface/Blob.h

@@ -0,0 +1,35 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_INTERFACE_BLOB_H_
+#define MESSMER_BLOBSTORE_INTERFACE_BLOB_H_
+
+#include <cstring>
+#include <cstdint>
+#include <messmer/blockstore/utils/Key.h>
+#include <messmer/cpp-utils/data/Data.h>
+
+namespace blobstore {
+
+class Blob {
+public:
+  virtual ~Blob() {}
+
+  //TODO Use own Key class for blobstore
+  virtual const blockstore::Key &key() const = 0;
+
+  virtual uint64_t size() const = 0;
+  virtual void resize(uint64_t numBytes) = 0;
+
+  virtual cpputils::Data readAll() const = 0;
+  virtual void read(void *target, uint64_t offset, uint64_t size) const = 0;
+  virtual uint64_t tryRead(void *target, uint64_t offset, uint64_t size) const = 0;
+  virtual void write(const void *source, uint64_t offset, uint64_t size) = 0;
+
+  virtual void flush() = 0;
+
+  //TODO Test tryRead
+};
+
+}
+
+
+#endif

src/blobstore/interface/BlobStore.h

@@ -0,0 +1,25 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_INTERFACE_BLOBSTORE_H_
+#define MESSMER_BLOBSTORE_INTERFACE_BLOBSTORE_H_
+
+#include "Blob.h"
+#include <string>
+#include <memory>
+
+#include "messmer/blockstore/utils/Key.h"
+#include <messmer/cpp-utils/pointer/unique_ref.h>
+
+namespace blobstore {
+
+class BlobStore {
+public:
+  virtual ~BlobStore() {}
+
+  virtual cpputils::unique_ref<Blob> create() = 0;
+  virtual boost::optional<cpputils::unique_ref<Blob>> load(const blockstore::Key &key) = 0;
+  virtual void remove(cpputils::unique_ref<Blob> blob) = 0;
+};
+
+}
+
+#endif

src/blockstore/CMakeLists.txt

@@ -35,6 +35,7 @@ add_library(${PROJECT_NAME} STATIC ${SOURCES})
 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
   target_link_libraries(${PROJECT_NAME} PRIVATE rt)
 endif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+target_link_libraries(${PROJECT_NAME} PUBLIC cpp-utils)
 
 target_add_boost(${PROJECT_NAME} filesystem system thread)
 target_enable_style_warnings(${PROJECT_NAME})

test/CMakeLists.txt

@@ -6,4 +6,6 @@ if (BUILD_TESTING)
   add_subdirectory(cpp-utils)
   add_subdirectory(fspp)
   add_subdirectory(parallelaccessstore)
+  add_subdirectory(blockstore)
+  add_subdirectory(blobstore)
 endif(BUILD_TESTING)

test/blobstore/CMakeLists.txt

@@ -0,0 +1,33 @@
+project (blobstore-test)
+
+set(SOURCES
+    implementations/onblocks/utils/MaxZeroSubtractionTest.cpp
+    implementations/onblocks/utils/CeilDivisionTest.cpp
+    implementations/onblocks/utils/IntPowTest.cpp
+    implementations/onblocks/utils/CeilLogTest.cpp
+    implementations/onblocks/testutils/BlobStoreTest.cpp
+    implementations/onblocks/BlobStoreTest.cpp
+    implementations/onblocks/datanodestore/DataLeafNodeTest.cpp
+    implementations/onblocks/datanodestore/DataInnerNodeTest.cpp
+    implementations/onblocks/datanodestore/DataNodeViewTest.cpp
+    implementations/onblocks/datanodestore/DataNodeStoreTest.cpp
+    implementations/onblocks/datatreestore/testutils/DataTreeTest.cpp
+    implementations/onblocks/datatreestore/impl/GetLowestRightBorderNodeWithMoreThanOneChildOrNullTest.cpp
+    implementations/onblocks/datatreestore/impl/GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNullTest.cpp
+    implementations/onblocks/datatreestore/DataTreeTest_ResizeByTraversing.cpp
+    implementations/onblocks/datatreestore/DataTreeTest_NumStoredBytes.cpp
+    implementations/onblocks/datatreestore/DataTreeTest_ResizeNumBytes.cpp
+    implementations/onblocks/datatreestore/DataTreeStoreTest.cpp
+    implementations/onblocks/datatreestore/DataTreeTest_TraverseLeaves.cpp
+    implementations/onblocks/BlobSizeTest.cpp
+    implementations/onblocks/BlobReadWriteTest.cpp
+    implementations/onblocks/BigBlobsTest.cpp
+
+)
+
+add_executable(${PROJECT_NAME} ${SOURCES})
+target_link_libraries(${PROJECT_NAME} googletest blobstore)
+add_test(${PROJECT_NAME} ${PROJECT_NAME})
+
+target_enable_style_warnings(${PROJECT_NAME})
+target_activate_cpp14(${PROJECT_NAME})

test/blobstore/implementations/onblocks/BigBlobsTest.cpp

@@ -0,0 +1,135 @@
+#include <gtest/gtest.h>
+#include <messmer/blockstore/implementations/compressing/CompressingBlockStore.h>
+#include <messmer/blockstore/implementations/compressing/compressors/RunLengthEncoding.h>
+#include <messmer/blockstore/implementations/inmemory/InMemoryBlockStore.h>
+#include <messmer/blockstore/implementations/inmemory/InMemoryBlock.h>
+#include <messmer/cpp-utils/data/DataFixture.h>
+#include <messmer/cpp-utils/data/Data.h>
+#include "../../../implementations/onblocks/BlobStoreOnBlocks.h"
+#include "../../../implementations/onblocks/BlobOnBlocks.h"
+
+using namespace blobstore;
+using namespace blobstore::onblocks;
+using cpputils::unique_ref;
+using cpputils::make_unique_ref;
+using cpputils::DataFixture;
+using cpputils::Data;
+using blockstore::inmemory::InMemoryBlockStore;
+using blockstore::compressing::CompressingBlockStore;
+using blockstore::compressing::RunLengthEncoding;
+
+// Test cases, ensuring that big blobs (>4G) work (i.e. testing that we don't use any 32bit variables for blob size, etc.)
+class BigBlobsTest : public ::testing::Test {
+public:
+    static constexpr size_t BLOCKSIZE = 32 * 1024;
+    static constexpr uint64_t SMALL_BLOB_SIZE = UINT64_C(1024)*1024*1024*3.9; // 3.9 GB (<4GB)
+    static constexpr uint64_t LARGE_BLOB_SIZE = UINT64_C(1024)*1024*1024*4.1; // 4.1 GB (>4GB)
+
+    static constexpr uint64_t max_uint_32 = std::numeric_limits<uint32_t>::max();
+    static_assert(SMALL_BLOB_SIZE < max_uint_32, "LARGE_BLOB_SIZE should need 64bit or the test case is mute");
+    static_assert(LARGE_BLOB_SIZE > max_uint_32, "LARGE_BLOB_SIZE should need 64bit or the test case is mute");
+
+    unique_ref<BlobStore> blobStore = make_unique_ref<BlobStoreOnBlocks>(make_unique_ref<CompressingBlockStore<RunLengthEncoding>>(make_unique_ref<InMemoryBlockStore>()), BLOCKSIZE);
+    unique_ref<Blob> blob = blobStore->create();
+};
+
+constexpr size_t BigBlobsTest::BLOCKSIZE;
+constexpr uint64_t BigBlobsTest::SMALL_BLOB_SIZE;
+constexpr uint64_t BigBlobsTest::LARGE_BLOB_SIZE;
+
+TEST_F(BigBlobsTest, Resize) {
+    //These operations are in one test case and not in many small ones, because it takes quite long to create a >4GB blob.
+
+    //Resize to >4GB
+    blob->resize(LARGE_BLOB_SIZE);
+    EXPECT_EQ(LARGE_BLOB_SIZE, blob->size());
+
+    //Grow while >4GB
+    blob->resize(LARGE_BLOB_SIZE + 1024);
+    EXPECT_EQ(LARGE_BLOB_SIZE + 1024, blob->size());
+
+    //Shrink while >4GB
+    blob->resize(LARGE_BLOB_SIZE);
+    EXPECT_EQ(LARGE_BLOB_SIZE, blob->size());
+
+    //Shrink to <4GB
+    blob->resize(SMALL_BLOB_SIZE);
+    EXPECT_EQ(SMALL_BLOB_SIZE, blob->size());
+
+    //Grow to >4GB
+    blob->resize(LARGE_BLOB_SIZE);
+    EXPECT_EQ(LARGE_BLOB_SIZE, blob->size());
+
+    //Flush >4GB blob
+    blob->flush();
+
+    //Destruct >4GB blob
+    auto key = blob->key();
+    cpputils::destruct(std::move(blob));
+
+    //Load >4GB blob
+    blob = blobStore->load(key).value();
+
+    //Remove >4GB blob
+    blobStore->remove(std::move(blob));
+}
+
+TEST_F(BigBlobsTest, GrowByWriting_Crossing4GBBorder) {
+    Data fixture = DataFixture::generate(2*(LARGE_BLOB_SIZE-SMALL_BLOB_SIZE));
+    blob->write(fixture.data(), SMALL_BLOB_SIZE, fixture.size());
+
+    EXPECT_EQ(LARGE_BLOB_SIZE+(LARGE_BLOB_SIZE-SMALL_BLOB_SIZE), blob->size());
+
+    Data loaded(fixture.size());
+    blob->read(loaded.data(), SMALL_BLOB_SIZE, loaded.size());
+    EXPECT_EQ(0, std::memcmp(loaded.data(), fixture.data(), loaded.size()));
+}
+
+TEST_F(BigBlobsTest, GrowByWriting_Outside4GBBorder_StartingSizeZero) {
+    Data fixture = DataFixture::generate(1024);
+    blob->write(fixture.data(), LARGE_BLOB_SIZE, fixture.size());
+
+    EXPECT_EQ(LARGE_BLOB_SIZE+1024, blob->size());
+
+    Data loaded(fixture.size());
+    blob->read(loaded.data(), LARGE_BLOB_SIZE, loaded.size());
+    EXPECT_EQ(0, std::memcmp(loaded.data(), fixture.data(), loaded.size()));
+}
+
+TEST_F(BigBlobsTest, GrowByWriting_Outside4GBBorder_StartingSizeOutside4GBBorder) {
+    blob->resize(LARGE_BLOB_SIZE);
+    Data fixture = DataFixture::generate(1024);
+    blob->write(fixture.data(), LARGE_BLOB_SIZE+1024, fixture.size());
+
+    EXPECT_EQ(LARGE_BLOB_SIZE+2048, blob->size());
+
+    Data loaded(fixture.size());
+    blob->read(loaded.data(), LARGE_BLOB_SIZE+1024, loaded.size());
+    EXPECT_EQ(0, std::memcmp(loaded.data(), fixture.data(), loaded.size()));
+}
+
+TEST_F(BigBlobsTest, ReadWriteAfterGrown_Crossing4GBBorder) {
+    blob->resize(LARGE_BLOB_SIZE+(LARGE_BLOB_SIZE-SMALL_BLOB_SIZE)+1024);
+    Data fixture = DataFixture::generate(2*(LARGE_BLOB_SIZE-SMALL_BLOB_SIZE));
+    blob->write(fixture.data(), SMALL_BLOB_SIZE, fixture.size());
+
+    EXPECT_EQ(LARGE_BLOB_SIZE+(LARGE_BLOB_SIZE-SMALL_BLOB_SIZE)+1024, blob->size());
+
+    Data loaded(fixture.size());
+    blob->read(loaded.data(), SMALL_BLOB_SIZE, loaded.size());
+    EXPECT_EQ(0, std::memcmp(loaded.data(), fixture.data(), loaded.size()));
+}
+
+TEST_F(BigBlobsTest, ReadWriteAfterGrown_Outside4GBBorder) {
+    blob->resize(LARGE_BLOB_SIZE+2048);
+    Data fixture = DataFixture::generate(1024);
+    blob->write(fixture.data(), LARGE_BLOB_SIZE, fixture.size());
+
+    EXPECT_EQ(LARGE_BLOB_SIZE+2048, blob->size());
+
+    Data loaded(fixture.size());
+    blob->read(loaded.data(), LARGE_BLOB_SIZE, loaded.size());
+    EXPECT_EQ(0, std::memcmp(loaded.data(), fixture.data(), loaded.size()));
+}
+
+//TODO Test Blob::readAll (only on 64bit systems)

test/blobstore/implementations/onblocks/BlobReadWriteTest.cpp

@@ -0,0 +1,166 @@
+#include "testutils/BlobStoreTest.h"
+#include <messmer/cpp-utils/data/Data.h>
+#include <messmer/cpp-utils/data/DataFixture.h>
+#include "../../../implementations/onblocks/datanodestore/DataNodeView.h"
+
+using cpputils::unique_ref;
+using ::testing::WithParamInterface;
+using ::testing::Values;
+
+using namespace blobstore;
+using blobstore::onblocks::datanodestore::DataNodeLayout;
+using blockstore::Key;
+using cpputils::Data;
+using cpputils::DataFixture;
+
+class BlobReadWriteTest: public BlobStoreTest {
+public:
+  static constexpr uint32_t LARGE_SIZE = 10 * 1024 * 1024;
+  static constexpr DataNodeLayout LAYOUT = DataNodeLayout(BLOCKSIZE_BYTES);
+
+  BlobReadWriteTest()
+    :randomData(DataFixture::generate(LARGE_SIZE)),
+     blob(blobStore->create()) {
+  }
+
+  Data readBlob(const Blob &blob) {
+    Data data(blob.size());
+    blob.read(data.data(), 0, data.size());
+    return data;
+  }
+
+  template<class DataClass>
+  void EXPECT_DATA_READS_AS(const DataClass &expected, const Blob &actual, uint64_t offset, uint64_t size) {
+  	Data read(size);
+  	actual.read(read.data(), offset, size);
+    EXPECT_EQ(0, std::memcmp(expected.data(), read.data(), size));
+  }
+
+  Data randomData;
+  unique_ref<Blob> blob;
+};
+constexpr uint32_t BlobReadWriteTest::LARGE_SIZE;
+constexpr DataNodeLayout BlobReadWriteTest::LAYOUT;
+
+TEST_F(BlobReadWriteTest, WritingImmediatelyFlushes_SmallSize) {
+	blob->resize(5);
+	blob->write(randomData.data(), 0, 5);
+	auto loaded = loadBlob(blob->key());
+	EXPECT_DATA_READS_AS(randomData, *loaded, 0, 5);
+}
+
+TEST_F(BlobReadWriteTest, WritingImmediatelyFlushes_LargeSize) {
+	blob->resize(LARGE_SIZE);
+	blob->write(randomData.data(), 0, LARGE_SIZE);
+	auto loaded = loadBlob(blob->key());
+	EXPECT_DATA_READS_AS(randomData, *loaded, 0, LARGE_SIZE);
+}
+
+// Regression test for a strange bug we had
+TEST_F(BlobReadWriteTest, WritingCloseTo16ByteLimitDoesntDestroySize) {
+  blob->resize(1);
+  blob->write(randomData.data(), 32776, 4);
+  EXPECT_EQ(32780, blob->size());
+}
+
+struct DataRange {
+  size_t blobsize;
+  off_t offset;
+  size_t count;
+};
+class BlobReadWriteDataTest: public BlobReadWriteTest, public WithParamInterface<DataRange> {
+public:
+  Data foregroundData;
+  Data backgroundData;
+
+  BlobReadWriteDataTest()
+    : foregroundData(DataFixture::generate(GetParam().count, 0)),
+      backgroundData(DataFixture::generate(GetParam().blobsize, 1)) {
+  }
+
+  template<class DataClass>
+  void EXPECT_DATA_READS_AS_OUTSIDE_OF(const DataClass &expected, const Blob &blob, off_t start, size_t count) {
+    Data begin(start);
+    Data end(GetParam().blobsize - count - start);
+
+    std::memcpy(begin.data(), expected.data(), start);
+    std::memcpy(end.data(), (uint8_t*)expected.data()+start+count, end.size());
+
+    EXPECT_DATA_READS_AS(begin, blob, 0, start);
+    EXPECT_DATA_READS_AS(end, blob, start + count, end.size());
+  }
+
+  void EXPECT_DATA_IS_ZEROES_OUTSIDE_OF(const Blob &blob, off_t start, size_t count) {
+    Data ZEROES(GetParam().blobsize);
+    ZEROES.FillWithZeroes();
+    EXPECT_DATA_READS_AS_OUTSIDE_OF(ZEROES, blob, start, count);
+  }
+};
+INSTANTIATE_TEST_CASE_P(BlobReadWriteDataTest, BlobReadWriteDataTest, Values(
+  //Blob with only one leaf
+  DataRange{BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf(),     0,   BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf()},     // full size leaf, access beginning to end
+  DataRange{BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf(),     100, BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf()-200}, // full size leaf, access middle to middle
+  DataRange{BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf(),     0,   BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf()-100}, // full size leaf, access beginning to middle
+  DataRange{BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf(),     100, BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf()-100}, // full size leaf, access middle to end
+  DataRange{BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf()-100, 0,   BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf()-100}, // non-full size leaf, access beginning to end
+  DataRange{BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf()-100, 100, BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf()-300}, // non-full size leaf, access middle to middle
+  DataRange{BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf()-100, 0,   BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf()-200}, // non-full size leaf, access beginning to middle
+  DataRange{BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf()-100, 100, BlobReadWriteDataTest::LAYOUT.maxBytesPerLeaf()-200},  // non-full size leaf, access middle to end
+  //Larger blob
+  DataRange{BlobReadWriteDataTest::LARGE_SIZE,     0,   BlobReadWriteDataTest::LARGE_SIZE},     // access beginning to end
+  DataRange{BlobReadWriteDataTest::LARGE_SIZE,     100, BlobReadWriteDataTest::LARGE_SIZE-200}, // access middle first leaf to middle last leaf
+  DataRange{BlobReadWriteDataTest::LARGE_SIZE,     0,   BlobReadWriteDataTest::LARGE_SIZE-100}, // access beginning to middle last leaf
+  DataRange{BlobReadWriteDataTest::LARGE_SIZE,     100, BlobReadWriteDataTest::LARGE_SIZE-100}, // access middle first leaf to end
+  DataRange{BlobReadWriteDataTest::LARGE_SIZE,     BlobReadWriteDataTest::LARGE_SIZE*1/3, BlobReadWriteDataTest::LARGE_SIZE*1/3}, // access middle to middle
+  DataRange{BlobReadWriteDataTest::LARGE_SIZE,     0,   BlobReadWriteDataTest::LARGE_SIZE*2/3}, // access beginning to middle
+  DataRange{BlobReadWriteDataTest::LARGE_SIZE,     BlobReadWriteDataTest::LARGE_SIZE*1/3, BlobReadWriteDataTest::LARGE_SIZE*2/3} // access middle to end
+));
+
+TEST_P(BlobReadWriteDataTest, WritingDoesntChangeSize) {
+  blob->resize(GetParam().blobsize);
+  blob->write(this->foregroundData.data(), GetParam().offset, GetParam().count);
+  EXPECT_EQ(GetParam().blobsize, blob->size());
+}
+
+TEST_P(BlobReadWriteDataTest, WriteAndReadImmediately) {
+  blob->resize(GetParam().blobsize);
+  blob->write(this->foregroundData.data(), GetParam().offset, GetParam().count);
+
+  EXPECT_DATA_READS_AS(this->foregroundData, *blob, GetParam().offset, GetParam().count);
+  EXPECT_DATA_IS_ZEROES_OUTSIDE_OF(*blob, GetParam().offset, GetParam().count);
+}
+
+TEST_P(BlobReadWriteDataTest, WriteAndReadAfterLoading) {
+  blob->resize(GetParam().blobsize);
+  blob->write(this->foregroundData.data(), GetParam().offset, GetParam().count);
+  auto loaded = loadBlob(blob->key());
+
+  EXPECT_DATA_READS_AS(this->foregroundData, *loaded, GetParam().offset, GetParam().count);
+  EXPECT_DATA_IS_ZEROES_OUTSIDE_OF(*loaded, GetParam().offset, GetParam().count);
+}
+
+TEST_P(BlobReadWriteDataTest, OverwriteAndRead) {
+  blob->resize(GetParam().blobsize);
+  blob->write(this->backgroundData.data(), 0, GetParam().blobsize);
+  blob->write(this->foregroundData.data(), GetParam().offset, GetParam().count);
+  EXPECT_DATA_READS_AS(this->foregroundData, *blob, GetParam().offset, GetParam().count);
+  EXPECT_DATA_READS_AS_OUTSIDE_OF(this->backgroundData, *blob, GetParam().offset, GetParam().count);
+}
+
+TEST_P(BlobReadWriteDataTest, WriteWholeAndReadPart) {
+  blob->resize(GetParam().blobsize);
+  blob->write(this->backgroundData.data(), 0, GetParam().blobsize);
+  Data read(GetParam().count);
+  blob->read(read.data(), GetParam().offset, GetParam().count);
+  EXPECT_EQ(0, std::memcmp(read.data(), (uint8_t*)this->backgroundData.data()+GetParam().offset, GetParam().count));
+}
+
+TEST_P(BlobReadWriteDataTest, WritePartAndReadWhole) {
+  blob->resize(GetParam().blobsize);
+  blob->write(this->backgroundData.data(), 0, GetParam().blobsize);
+  blob->write(this->foregroundData.data(), GetParam().offset, GetParam().count);
+  Data read = readBlob(*blob);
+  EXPECT_EQ(0, std::memcmp(read.data(), this->backgroundData.data(), GetParam().offset));
+  EXPECT_EQ(0, std::memcmp((uint8_t*)read.data()+GetParam().offset, this->foregroundData.data(), GetParam().count));
+  EXPECT_EQ(0, std::memcmp((uint8_t*)read.data()+GetParam().offset+GetParam().count, (uint8_t*)this->backgroundData.data()+GetParam().offset+GetParam().count, GetParam().blobsize-GetParam().count-GetParam().offset));
+}

test/blobstore/implementations/onblocks/BlobSizeTest.cpp

@@ -0,0 +1,171 @@
+#include "testutils/BlobStoreTest.h"
+#include <messmer/cpp-utils/data/Data.h>
+#include <messmer/cpp-utils/data/DataFixture.h>
+
+using namespace blobstore;
+using blockstore::Key;
+using cpputils::Data;
+using cpputils::DataFixture;
+using cpputils::unique_ref;
+
+class BlobSizeTest: public BlobStoreTest {
+public:
+  BlobSizeTest(): blob(blobStore->create()) {}
+
+  static constexpr uint32_t MEDIUM_SIZE = 5 * 1024 * 1024;
+  static constexpr uint32_t LARGE_SIZE = 10 * 1024 * 1024;
+
+  unique_ref<Blob> blob;
+};
+constexpr uint32_t BlobSizeTest::MEDIUM_SIZE;
+constexpr uint32_t BlobSizeTest::LARGE_SIZE;
+
+TEST_F(BlobSizeTest, CreatedBlobIsEmpty) {
+  EXPECT_EQ(0, blob->size());
+}
+
+TEST_F(BlobSizeTest, Growing_1Byte) {
+  blob->resize(1);
+  EXPECT_EQ(1, blob->size());
+}
+
+TEST_F(BlobSizeTest, Growing_Large) {
+  blob->resize(LARGE_SIZE);
+  EXPECT_EQ(LARGE_SIZE, blob->size());
+}
+
+TEST_F(BlobSizeTest, Shrinking_Empty) {
+  blob->resize(LARGE_SIZE);
+  blob->resize(0);
+  EXPECT_EQ(0, blob->size());
+}
+
+TEST_F(BlobSizeTest, Shrinking_1Byte) {
+  blob->resize(LARGE_SIZE);
+  blob->resize(1);
+  EXPECT_EQ(1, blob->size());
+}
+
+TEST_F(BlobSizeTest, ResizingToItself_Empty) {
+  blob->resize(0);
+  EXPECT_EQ(0, blob->size());
+}
+
+TEST_F(BlobSizeTest, ResizingToItself_1Byte) {
+  blob->resize(1);
+  blob->resize(1);
+  EXPECT_EQ(1, blob->size());
+}
+
+TEST_F(BlobSizeTest, ResizingToItself_Large) {
+  blob->resize(LARGE_SIZE);
+  blob->resize(LARGE_SIZE);
+  EXPECT_EQ(LARGE_SIZE, blob->size());
+}
+
+TEST_F(BlobSizeTest, EmptyBlobStaysEmptyWhenLoading) {
+  Key key = blob->key();
+  reset(std::move(blob));
+  auto loaded = loadBlob(key);
+  EXPECT_EQ(0, loaded->size());
+}
+
+TEST_F(BlobSizeTest, BlobSizeStaysIntactWhenLoading) {
+  blob->resize(LARGE_SIZE);
+  Key key = blob->key();
+  reset(std::move(blob));
+  auto loaded = loadBlob(key);
+  EXPECT_EQ(LARGE_SIZE, loaded->size());
+}
+
+TEST_F(BlobSizeTest, WritingAtEndOfBlobGrowsBlob_Empty) {
+  int value;
+  blob->write(&value, 0, 4);
+  EXPECT_EQ(4, blob->size());
+}
+
+TEST_F(BlobSizeTest, WritingAfterEndOfBlobGrowsBlob_Empty) {
+  int value;
+  blob->write(&value, 2, 4);
+  EXPECT_EQ(6, blob->size());
+}
+
+TEST_F(BlobSizeTest, WritingOverEndOfBlobGrowsBlob_NonEmpty) {
+  blob->resize(1);
+  int value;
+  blob->write(&value, 0, 4);
+  EXPECT_EQ(4, blob->size());
+}
+
+TEST_F(BlobSizeTest, WritingAtEndOfBlobGrowsBlob_NonEmpty) {
+  blob->resize(1);
+  int value;
+  blob->write(&value, 1, 4);
+  EXPECT_EQ(5, blob->size());
+}
+
+TEST_F(BlobSizeTest, WritingAfterEndOfBlobGrowsBlob_NonEmpty) {
+  blob->resize(1);
+  int value;
+  blob->write(&value, 2, 4);
+  EXPECT_EQ(6, blob->size());
+}
+
+TEST_F(BlobSizeTest, ChangingSizeImmediatelyFlushes) {
+  blob->resize(LARGE_SIZE);
+  auto loaded = loadBlob(blob->key());
+  EXPECT_EQ(LARGE_SIZE, loaded->size());
+}
+
+class BlobSizeDataTest: public BlobSizeTest {
+public:
+  BlobSizeDataTest()
+    :ZEROES(LARGE_SIZE),
+     randomData(DataFixture::generate(LARGE_SIZE)) {
+    ZEROES.FillWithZeroes();
+  }
+
+  Data readBlob(const Blob &blob) {
+    Data data(blob.size());
+    blob.read(data.data(), 0, data.size());
+    return data;
+  }
+
+  Data ZEROES;
+  Data randomData;
+};
+
+TEST_F(BlobSizeDataTest, BlobIsZeroedOutAfterGrowing) {
+  blob->resize(LARGE_SIZE);
+  EXPECT_EQ(0, std::memcmp(readBlob(*blob).data(), ZEROES.data(), LARGE_SIZE));
+}
+
+TEST_F(BlobSizeDataTest, BlobIsZeroedOutAfterGrowingAndLoading) {
+  blob->resize(LARGE_SIZE);
+  auto loaded = loadBlob(blob->key());
+  EXPECT_EQ(0, std::memcmp(readBlob(*loaded).data(), ZEROES.data(), LARGE_SIZE)); 
+}
+
+TEST_F(BlobSizeDataTest, DataStaysIntactWhenGrowing) {
+  blob->resize(MEDIUM_SIZE);
+  blob->write(randomData.data(), 0, MEDIUM_SIZE);
+  blob->resize(LARGE_SIZE);
+  EXPECT_EQ(0, std::memcmp(readBlob(*blob).data(), randomData.data(), MEDIUM_SIZE));
+  EXPECT_EQ(0, std::memcmp((uint8_t*)readBlob(*blob).data() + MEDIUM_SIZE, ZEROES.data(), LARGE_SIZE-MEDIUM_SIZE));
+}
+
+TEST_F(BlobSizeDataTest, DataStaysIntactWhenShrinking) {
+  blob->resize(LARGE_SIZE);
+  blob->write(randomData.data(), 0, LARGE_SIZE);
+  blob->resize(MEDIUM_SIZE);
+  EXPECT_EQ(0, std::memcmp(readBlob(*blob).data(), randomData.data(), MEDIUM_SIZE));
+}
+
+TEST_F(BlobSizeDataTest, ChangedAreaIsZeroedOutWhenShrinkingAndRegrowing) {
+  blob->resize(LARGE_SIZE);
+  blob->write(randomData.data(), 0, LARGE_SIZE);
+  blob->resize(MEDIUM_SIZE);
+  blob->resize(LARGE_SIZE);
+  EXPECT_EQ(0, std::memcmp(readBlob(*blob).data(), randomData.data(), MEDIUM_SIZE));
+  EXPECT_EQ(0, std::memcmp((uint8_t*)readBlob(*blob).data() + MEDIUM_SIZE, ZEROES.data(), LARGE_SIZE-MEDIUM_SIZE));
+}

test/blobstore/implementations/onblocks/BlobStoreTest.cpp

@@ -0,0 +1,39 @@
+#include "testutils/BlobStoreTest.h"
+#include <messmer/cpp-utils/pointer/unique_ref_boost_optional_gtest_workaround.h>
+
+using blockstore::Key;
+using cpputils::unique_ref;
+using blobstore::Blob;
+using boost::none;
+
+TEST_F(BlobStoreTest, LoadNonexistingKeyOnEmptyBlobstore) {
+  const blockstore::Key key = blockstore::Key::FromString("1491BB4932A389EE14BC7090AC772972");
+  EXPECT_EQ(none, blobStore->load(key));
+}
+
+TEST_F(BlobStoreTest, LoadNonexistingKeyOnNonEmptyBlobstore) {
+  blobStore->create();
+  const blockstore::Key key = blockstore::Key::FromString("1491BB4932A389EE14BC7090AC772972");
+  EXPECT_EQ(none, blobStore->load(key));
+}
+
+TEST_F(BlobStoreTest, TwoCreatedBlobsHaveDifferentKeys) {
+  auto blob1 = blobStore->create();
+  auto blob2 = blobStore->create();
+  EXPECT_NE(blob1->key(), blob2->key());
+}
+
+TEST_F(BlobStoreTest, BlobIsNotLoadableAfterDeletion_DeleteDirectly) {
+  auto blob = blobStore->create();
+  Key key = blob->key();
+  blobStore->remove(std::move(blob));
+  EXPECT_FALSE((bool)blobStore->load(key));
+}
+
+TEST_F(BlobStoreTest, BlobIsNotLoadableAfterDeletion_DeleteAfterLoading) {
+  auto blob = blobStore->create();
+  Key key = blob->key();
+  reset(std::move(blob));
+  blobStore->remove(loadBlob(key));
+  EXPECT_FALSE((bool)blobStore->load(key));
+}

test/blobstore/implementations/onblocks/datanodestore/DataInnerNodeTest.cpp

@@ -0,0 +1,241 @@
+#include <google/gtest/gtest.h>
+
+#include "../../../../implementations/onblocks/datanodestore/DataInnerNode.h"
+#include "../../../../implementations/onblocks/datanodestore/DataLeafNode.h"
+#include "../../../../implementations/onblocks/datanodestore/DataNodeStore.h"
+
+#include "messmer/blockstore/implementations/testfake/FakeBlockStore.h"
+#include "messmer/blockstore/implementations/testfake/FakeBlock.h"
+
+#include <memory>
+#include "messmer/cpp-utils/pointer/cast.h"
+
+using ::testing::Test;
+
+using cpputils::dynamic_pointer_move;
+
+using blockstore::Key;
+using blockstore::testfake::FakeBlockStore;
+using blockstore::BlockStore;
+using cpputils::Data;
+using namespace blobstore;
+using namespace blobstore::onblocks;
+using namespace blobstore::onblocks::datanodestore;
+
+using cpputils::unique_ref;
+using cpputils::make_unique_ref;
+
+class DataInnerNodeTest: public Test {
+public:
+  static constexpr uint32_t BLOCKSIZE_BYTES = 1024;
+
+  DataInnerNodeTest() :
+    _blockStore(make_unique_ref<FakeBlockStore>()),
+    blockStore(_blockStore.get()),
+    nodeStore(make_unique_ref<DataNodeStore>(std::move(_blockStore), BLOCKSIZE_BYTES)),
+    ZEROES(nodeStore->layout().maxBytesPerLeaf()),
+    leaf(nodeStore->createNewLeafNode()),
+    node(nodeStore->createNewInnerNode(*leaf)) {
+
+    ZEROES.FillWithZeroes();
+  }
+
+  unique_ref<DataInnerNode> LoadInnerNode(const Key &key) {
+    auto node = nodeStore->load(key).value();
+    return dynamic_pointer_move<DataInnerNode>(node).value();
+  }
+
+  Key CreateNewInnerNodeReturnKey(const DataNode &firstChild) {
+    return nodeStore->createNewInnerNode(firstChild)->key();
+  }
+
+  unique_ref<DataInnerNode> CreateNewInnerNode() {
+    auto new_leaf = nodeStore->createNewLeafNode();
+    return nodeStore->createNewInnerNode(*new_leaf);
+  }
+
+  unique_ref<DataInnerNode> CreateAndLoadNewInnerNode(const DataNode &firstChild) {
+    auto key = CreateNewInnerNodeReturnKey(firstChild);
+    return LoadInnerNode(key);
+  }
+
+  unique_ref<DataInnerNode> CreateNewInnerNode(const DataNode &firstChild, const DataNode &secondChild) {
+    auto node = nodeStore->createNewInnerNode(firstChild);
+    node->addChild(secondChild);
+    return node;
+  }
+
+  Key CreateNewInnerNodeReturnKey(const DataNode &firstChild, const DataNode &secondChild) {
+    return CreateNewInnerNode(firstChild, secondChild)->key();
+  }
+
+  unique_ref<DataInnerNode> CreateAndLoadNewInnerNode(const DataNode &firstChild, const DataNode &secondChild) {
+    auto key = CreateNewInnerNodeReturnKey(firstChild, secondChild);
+    return LoadInnerNode(key);
+  }
+
+  Key AddALeafTo(DataInnerNode *node) {
+    auto leaf2 = nodeStore->createNewLeafNode();
+    node->addChild(*leaf2);
+    return leaf2->key();
+  }
+
+  Key CreateNodeWithDataConvertItToInnerNodeAndReturnKey() {
+    auto node = CreateNewInnerNode();
+    AddALeafTo(node.get());
+    AddALeafTo(node.get());
+    auto child = nodeStore->createNewLeafNode();
+    unique_ref<DataInnerNode> converted = DataNode::convertToNewInnerNode(std::move(node), *child);
+    return converted->key();
+  }
+
+  unique_ref<DataInnerNode> CopyInnerNode(const DataInnerNode &node) {
+    auto copied = nodeStore->createNewNodeAsCopyFrom(node);
+    return dynamic_pointer_move<DataInnerNode>(copied).value();
+  }
+
+  Key InitializeInnerNodeAddLeafReturnKey() {
+    auto node = DataInnerNode::InitializeNewNode(blockStore->create(Data(BLOCKSIZE_BYTES)), *leaf);
+    AddALeafTo(node.get());
+    return node->key();
+  }
+
+  unique_ref<BlockStore> _blockStore;
+  BlockStore *blockStore;
+  unique_ref<DataNodeStore> nodeStore;
+  Data ZEROES;
+  unique_ref<DataLeafNode> leaf;
+  unique_ref<DataInnerNode> node;
+
+private:
+
+  DISALLOW_COPY_AND_ASSIGN(DataInnerNodeTest);
+};
+
+constexpr uint32_t DataInnerNodeTest::BLOCKSIZE_BYTES;
+
+TEST_F(DataInnerNodeTest, CorrectKeyReturnedAfterInitialization) {
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  Key key = block->key();
+  auto node = DataInnerNode::InitializeNewNode(std::move(block), *leaf);
+  EXPECT_EQ(key, node->key());
+}
+
+TEST_F(DataInnerNodeTest, CorrectKeyReturnedAfterLoading) {
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  Key key = block->key();
+  DataInnerNode::InitializeNewNode(std::move(block), *leaf);
+
+  auto loaded = nodeStore->load(key).value();
+  EXPECT_EQ(key, loaded->key());
+}
+
+TEST_F(DataInnerNodeTest, InitializesCorrectly) {
+  auto node = DataInnerNode::InitializeNewNode(blockStore->create(Data(BLOCKSIZE_BYTES)), *leaf);
+
+  EXPECT_EQ(1u, node->numChildren());
+  EXPECT_EQ(leaf->key(), node->getChild(0)->key());
+}
+
+TEST_F(DataInnerNodeTest, ReinitializesCorrectly) {
+  auto key = InitializeInnerNodeAddLeafReturnKey();
+  auto node = DataInnerNode::InitializeNewNode(blockStore->load(key).value(), *leaf);
+
+  EXPECT_EQ(1u, node->numChildren());
+  EXPECT_EQ(leaf->key(), node->getChild(0)->key());
+}
+
+TEST_F(DataInnerNodeTest, IsCorrectlyInitializedAfterLoading) {
+  auto loaded = CreateAndLoadNewInnerNode(*leaf);
+
+  EXPECT_EQ(1u, loaded->numChildren());
+  EXPECT_EQ(leaf->key(), loaded->getChild(0)->key());
+}
+
+TEST_F(DataInnerNodeTest, AddingASecondLeaf) {
+  Key leaf2_key = AddALeafTo(node.get());
+
+  EXPECT_EQ(2u, node->numChildren());
+  EXPECT_EQ(leaf->key(), node->getChild(0)->key());
+  EXPECT_EQ(leaf2_key, node->getChild(1)->key());
+}
+
+TEST_F(DataInnerNodeTest, AddingASecondLeafAndReload) {
+  auto leaf2 = nodeStore->createNewLeafNode();
+  auto loaded = CreateAndLoadNewInnerNode(*leaf, *leaf2);
+
+  EXPECT_EQ(2u, loaded->numChildren());
+  EXPECT_EQ(leaf->key(), loaded->getChild(0)->key());
+  EXPECT_EQ(leaf2->key(), loaded->getChild(1)->key());
+}
+
+TEST_F(DataInnerNodeTest, BuildingAThreeLevelTree) {
+  auto node2 = CreateNewInnerNode();
+  auto parent = CreateNewInnerNode(*node, *node2);
+
+  EXPECT_EQ(2u, parent->numChildren());
+  EXPECT_EQ(node->key(), parent->getChild(0)->key());
+  EXPECT_EQ(node2->key(), parent->getChild(1)->key());
+}
+
+TEST_F(DataInnerNodeTest, BuildingAThreeLevelTreeAndReload) {
+  auto node2 = CreateNewInnerNode();
+  auto parent = CreateAndLoadNewInnerNode(*node, *node2);
+
+  EXPECT_EQ(2u, parent->numChildren());
+  EXPECT_EQ(node->key(), parent->getChild(0)->key());
+  EXPECT_EQ(node2->key(), parent->getChild(1)->key());
+}
+
+TEST_F(DataInnerNodeTest, ConvertToInternalNode) {
+  auto child = nodeStore->createNewLeafNode();
+  Key node_key = node->key();
+  unique_ref<DataInnerNode> converted = DataNode::convertToNewInnerNode(std::move(node), *child);
+
+  EXPECT_EQ(1u, converted->numChildren());
+  EXPECT_EQ(child->key(), converted->getChild(0)->key());
+  EXPECT_EQ(node_key, converted->key());
+}
+
+TEST_F(DataInnerNodeTest, ConvertToInternalNodeZeroesOutChildrenRegion) {
+  Key key = CreateNodeWithDataConvertItToInnerNodeAndReturnKey();
+
+  auto block = blockStore->load(key).value();
+  EXPECT_EQ(0, std::memcmp(ZEROES.data(), (uint8_t*)block->data()+DataNodeLayout::HEADERSIZE_BYTES+sizeof(DataInnerNode::ChildEntry), nodeStore->layout().maxBytesPerLeaf()-sizeof(DataInnerNode::ChildEntry)));
+}
+
+TEST_F(DataInnerNodeTest, CopyingCreatesNewNode) {
+  auto copied = CopyInnerNode(*node);
+  EXPECT_NE(node->key(), copied->key());
+}
+
+TEST_F(DataInnerNodeTest, CopyInnerNodeWithOneChild) {
+  auto copied = CopyInnerNode(*node);
+
+  EXPECT_EQ(node->numChildren(), copied->numChildren());
+  EXPECT_EQ(node->getChild(0)->key(), copied->getChild(0)->key());
+}
+
+TEST_F(DataInnerNodeTest, CopyInnerNodeWithTwoChildren) {
+  AddALeafTo(node.get());
+  auto copied = CopyInnerNode(*node);
+
+  EXPECT_EQ(node->numChildren(), copied->numChildren());
+  EXPECT_EQ(node->getChild(0)->key(), copied->getChild(0)->key());
+  EXPECT_EQ(node->getChild(1)->key(), copied->getChild(1)->key());
+}
+
+TEST_F(DataInnerNodeTest, LastChildWhenOneChild) {
+  EXPECT_EQ(leaf->key(), node->LastChild()->key());
+}
+
+TEST_F(DataInnerNodeTest, LastChildWhenTwoChildren) {
+  Key key = AddALeafTo(node.get());
+  EXPECT_EQ(key, node->LastChild()->key());
+}
+
+TEST_F(DataInnerNodeTest, LastChildWhenThreeChildren) {
+  AddALeafTo(node.get());
+  Key key = AddALeafTo(node.get());
+  EXPECT_EQ(key, node->LastChild()->key());
+}

test/blobstore/implementations/onblocks/datanodestore/DataLeafNodeTest.cpp

@@ -0,0 +1,357 @@
+#include "../../../../implementations/onblocks/datanodestore/DataLeafNode.h"
+#include "../../../../implementations/onblocks/datanodestore/DataInnerNode.h"
+#include "../../../../implementations/onblocks/datanodestore/DataNodeStore.h"
+#include "../../../../implementations/onblocks/BlobStoreOnBlocks.h"
+#include <google/gtest/gtest.h>
+
+#include "messmer/cpp-utils/pointer/cast.h"
+
+#include "messmer/blockstore/implementations/testfake/FakeBlockStore.h"
+#include "messmer/blockstore/implementations/testfake/FakeBlock.h"
+#include <messmer/cpp-utils/data/DataFixture.h>
+
+using ::testing::Test;
+using ::testing::WithParamInterface;
+using ::testing::Values;
+using ::testing::Combine;
+using cpputils::unique_ref;
+using cpputils::make_unique_ref;
+using std::string;
+using cpputils::DataFixture;
+
+//TODO Split into multiple files
+
+using cpputils::dynamic_pointer_move;
+
+using blockstore::BlockStore;
+using cpputils::Data;
+using blockstore::Key;
+using blockstore::testfake::FakeBlockStore;
+using namespace blobstore;
+using namespace blobstore::onblocks;
+using namespace blobstore::onblocks::datanodestore;
+
+#define EXPECT_IS_PTR_TYPE(Type, ptr) EXPECT_NE(nullptr, dynamic_cast<Type*>(ptr)) << "Given pointer cannot be cast to the given type"
+
+class DataLeafNodeTest: public Test {
+public:
+
+  static constexpr uint32_t BLOCKSIZE_BYTES = 1024;
+  static constexpr DataNodeLayout LAYOUT = DataNodeLayout(BLOCKSIZE_BYTES);
+
+  DataLeafNodeTest():
+    _blockStore(make_unique_ref<FakeBlockStore>()),
+    blockStore(_blockStore.get()),
+    nodeStore(make_unique_ref<DataNodeStore>(std::move(_blockStore), BLOCKSIZE_BYTES)),
+    ZEROES(nodeStore->layout().maxBytesPerLeaf()),
+    randomData(nodeStore->layout().maxBytesPerLeaf()),
+    leaf(nodeStore->createNewLeafNode()) {
+
+    ZEROES.FillWithZeroes();
+
+    Data dataFixture(DataFixture::generate(nodeStore->layout().maxBytesPerLeaf()));
+
+    std::memcpy(randomData.data(), dataFixture.data(), randomData.size());
+  }
+
+  Data loadData(const DataLeafNode &leaf) {
+    Data data(leaf.numBytes());
+    leaf.read(data.data(), 0, leaf.numBytes());
+    return data;
+  }
+
+  Key WriteDataToNewLeafBlockAndReturnKey() {
+    auto newleaf = nodeStore->createNewLeafNode();
+    newleaf->resize(randomData.size());
+    newleaf->write(randomData.data(), 0, randomData.size());
+    return newleaf->key();
+  }
+
+  void FillLeafBlockWithData() {
+    FillLeafBlockWithData(leaf.get());
+  }
+
+  void FillLeafBlockWithData(DataLeafNode *leaf_to_fill) {
+    leaf_to_fill->resize(randomData.size());
+    leaf_to_fill->write(randomData.data(), 0, randomData.size());
+  }
+
+  unique_ref<DataLeafNode> LoadLeafNode(const Key &key) {
+    auto leaf = nodeStore->load(key).value();
+    return dynamic_pointer_move<DataLeafNode>(leaf).value();
+  }
+
+  void ResizeLeaf(const Key &key, size_t size) {
+    auto leaf = LoadLeafNode(key);
+    EXPECT_IS_PTR_TYPE(DataLeafNode, leaf.get());
+    leaf->resize(size);
+  }
+
+  Key CreateLeafWithDataConvertItToInnerNodeAndReturnKey() {
+    auto leaf = nodeStore->createNewLeafNode();
+    FillLeafBlockWithData(leaf.get());
+    auto child = nodeStore->createNewLeafNode();
+    unique_ref<DataInnerNode> converted = DataNode::convertToNewInnerNode(std::move(leaf), *child);
+    return converted->key();
+  }
+
+  unique_ref<DataLeafNode> CopyLeafNode(const DataLeafNode &node) {
+    auto copied = nodeStore->createNewNodeAsCopyFrom(node);
+    return dynamic_pointer_move<DataLeafNode>(copied).value();
+  }
+
+  Key InitializeLeafGrowAndReturnKey() {
+    auto leaf = DataLeafNode::InitializeNewNode(blockStore->create(Data(BLOCKSIZE_BYTES)));
+    leaf->resize(5);
+    return leaf->key();
+  }
+
+  unique_ref<BlockStore> _blockStore;
+  BlockStore *blockStore;
+  unique_ref<DataNodeStore> nodeStore;
+  Data ZEROES;
+  Data randomData;
+  unique_ref<DataLeafNode> leaf;
+
+private:
+  DISALLOW_COPY_AND_ASSIGN(DataLeafNodeTest);
+};
+
+constexpr uint32_t DataLeafNodeTest::BLOCKSIZE_BYTES;
+constexpr DataNodeLayout DataLeafNodeTest::LAYOUT;
+
+TEST_F(DataLeafNodeTest, CorrectKeyReturnedAfterInitialization) {
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  Key key = block->key();
+  auto node = DataLeafNode::InitializeNewNode(std::move(block));
+  EXPECT_EQ(key, node->key());
+}
+
+TEST_F(DataLeafNodeTest, CorrectKeyReturnedAfterLoading) {
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  Key key = block->key();
+  DataLeafNode::InitializeNewNode(std::move(block));
+
+  auto loaded = nodeStore->load(key).value();
+  EXPECT_EQ(key, loaded->key());
+}
+
+TEST_F(DataLeafNodeTest, InitializesCorrectly) {
+  auto leaf = DataLeafNode::InitializeNewNode(blockStore->create(Data(BLOCKSIZE_BYTES)));
+  EXPECT_EQ(0u, leaf->numBytes());
+}
+
+TEST_F(DataLeafNodeTest, ReinitializesCorrectly) {
+  auto key = InitializeLeafGrowAndReturnKey();
+  auto leaf = DataLeafNode::InitializeNewNode(blockStore->load(key).value());
+  EXPECT_EQ(0u, leaf->numBytes());
+}
+
+TEST_F(DataLeafNodeTest, ReadWrittenDataAfterReloadingBlock) {
+  Key key = WriteDataToNewLeafBlockAndReturnKey();
+
+  auto loaded = LoadLeafNode(key);
+
+  EXPECT_EQ(randomData.size(), loaded->numBytes());
+  EXPECT_EQ(randomData, loadData(*loaded));
+}
+
+TEST_F(DataLeafNodeTest, NewLeafNodeHasSizeZero) {
+  EXPECT_EQ(0u, leaf->numBytes());
+}
+
+TEST_F(DataLeafNodeTest, NewLeafNodeHasSizeZero_AfterLoading) {
+  Key key = nodeStore->createNewLeafNode()->key();
+  auto leaf = LoadLeafNode(key);
+
+  EXPECT_EQ(0u, leaf->numBytes());
+}
+
+class DataLeafNodeSizeTest: public DataLeafNodeTest, public WithParamInterface<unsigned int> {
+public:
+  Key CreateLeafResizeItAndReturnKey() {
+    auto leaf = nodeStore->createNewLeafNode();
+    leaf->resize(GetParam());
+    return leaf->key();
+  }
+};
+INSTANTIATE_TEST_CASE_P(DataLeafNodeSizeTest, DataLeafNodeSizeTest, Values(0, 1, 5, 16, 32, 512, DataNodeLayout(DataLeafNodeTest::BLOCKSIZE_BYTES).maxBytesPerLeaf()));
+
+TEST_P(DataLeafNodeSizeTest, ResizeNode_ReadSizeImmediately) {
+  leaf->resize(GetParam());
+  EXPECT_EQ(GetParam(), leaf->numBytes());
+}
+
+TEST_P(DataLeafNodeSizeTest, ResizeNode_ReadSizeAfterLoading) {
+  Key key = CreateLeafResizeItAndReturnKey();
+
+  auto leaf = LoadLeafNode(key);
+  EXPECT_EQ(GetParam(), leaf->numBytes());
+}
+
+TEST_F(DataLeafNodeTest, SpaceIsZeroFilledWhenGrowing) {
+  leaf->resize(randomData.size());
+  EXPECT_EQ(0, std::memcmp(ZEROES.data(), loadData(*leaf).data(), randomData.size()));
+}
+
+TEST_F(DataLeafNodeTest, SpaceGetsZeroFilledWhenShrinkingAndRegrowing) {
+  FillLeafBlockWithData();
+  // resize it smaller and then back to original size
+  uint32_t smaller_size = randomData.size() - 100;
+  leaf->resize(smaller_size);
+  leaf->resize(randomData.size());
+
+  //Check that the space was filled with zeroes
+  EXPECT_EQ(0, std::memcmp(ZEROES.data(), ((uint8_t*)loadData(*leaf).data())+smaller_size, 100));
+}
+
+TEST_F(DataLeafNodeTest, DataGetsZeroFilledWhenShrinking) {
+  Key key = WriteDataToNewLeafBlockAndReturnKey();
+  uint32_t smaller_size = randomData.size() - 100;
+  {
+    //At first, we expect there to be random data in the underlying data block
+    auto block = blockStore->load(key).value();
+    EXPECT_EQ(0, std::memcmp((char*)randomData.data()+smaller_size, (uint8_t*)block->data()+DataNodeLayout::HEADERSIZE_BYTES+smaller_size, 100));
+  }
+
+  //After shrinking, we expect there to be zeroes in the underlying data block
+  ResizeLeaf(key, smaller_size);
+  {
+    auto block = blockStore->load(key).value();
+    EXPECT_EQ(0, std::memcmp(ZEROES.data(), (uint8_t*)block->data()+DataNodeLayout::HEADERSIZE_BYTES+smaller_size, 100));
+  }
+}
+
+TEST_F(DataLeafNodeTest, ShrinkingDoesntDestroyValidDataRegion) {
+  FillLeafBlockWithData();
+  uint32_t smaller_size = randomData.size() - 100;
+  leaf->resize(smaller_size);
+
+  //Check that the remaining data region is unchanged
+  EXPECT_EQ(0, std::memcmp(randomData.data(), loadData(*leaf).data(), smaller_size));
+}
+
+TEST_F(DataLeafNodeTest, ConvertToInternalNode) {
+  auto child = nodeStore->createNewLeafNode();
+  Key leaf_key = leaf->key();
+  unique_ref<DataInnerNode> converted = DataNode::convertToNewInnerNode(std::move(leaf), *child);
+
+  EXPECT_EQ(1u, converted->numChildren());
+  EXPECT_EQ(child->key(), converted->getChild(0)->key());
+  EXPECT_EQ(leaf_key, converted->key());
+}
+
+TEST_F(DataLeafNodeTest, ConvertToInternalNodeZeroesOutChildrenRegion) {
+  Key key = CreateLeafWithDataConvertItToInnerNodeAndReturnKey();
+
+  auto block = blockStore->load(key).value();
+  EXPECT_EQ(0, std::memcmp(ZEROES.data(), (uint8_t*)block->data()+DataNodeLayout::HEADERSIZE_BYTES+sizeof(DataInnerNode::ChildEntry), nodeStore->layout().maxBytesPerLeaf()-sizeof(DataInnerNode::ChildEntry)));
+}
+
+TEST_F(DataLeafNodeTest, CopyingCreatesANewLeaf) {
+  auto copied = CopyLeafNode(*leaf);
+  EXPECT_NE(leaf->key(), copied->key());
+}
+
+TEST_F(DataLeafNodeTest, CopyEmptyLeaf) {
+  auto copied = CopyLeafNode(*leaf);
+  EXPECT_EQ(leaf->numBytes(), copied->numBytes());
+}
+
+TEST_F(DataLeafNodeTest, CopyDataLeaf) {
+  FillLeafBlockWithData();
+  auto copied = CopyLeafNode(*leaf);
+
+  EXPECT_EQ(leaf->numBytes(), copied->numBytes());
+  EXPECT_EQ(0, std::memcmp(loadData(*leaf).data(), loadData(*copied).data(), leaf->numBytes()));
+
+  //Test that they have different data regions (changing the original one doesn't change the copy)
+  char data = '\0';
+  leaf->write(&data, 0, 1);
+  EXPECT_EQ(data, *(char*)loadData(*leaf).data());
+  EXPECT_NE(data, *(char*)loadData(*copied).data());
+}
+
+
+struct DataRange {
+  size_t leafsize;
+  off_t offset;
+  size_t count;
+};
+
+class DataLeafNodeDataTest: public DataLeafNodeTest, public WithParamInterface<DataRange> {
+public:
+  Data foregroundData;
+  Data backgroundData;
+
+  DataLeafNodeDataTest():
+    foregroundData(DataFixture::generate(GetParam().count, 0)),
+    backgroundData(DataFixture::generate(GetParam().leafsize, 1)) {
+  }
+
+  Key CreateLeafWriteToItAndReturnKey(const Data &to_write) {
+    auto newleaf = nodeStore->createNewLeafNode();
+
+    newleaf->resize(GetParam().leafsize);
+    newleaf->write(to_write.data(), GetParam().offset, GetParam().count);
+    return newleaf->key();
+  }
+
+  void EXPECT_DATA_READS_AS(const Data &expected, const DataLeafNode &leaf, off_t offset, size_t count) {
+    Data read(count);
+    leaf.read(read.data(), offset, count);
+    EXPECT_EQ(expected, read);
+  }
+
+  void EXPECT_DATA_READS_AS_OUTSIDE_OF(const Data &expected, const DataLeafNode &leaf, off_t start, size_t count) {
+    Data begin(start);
+    Data end(GetParam().leafsize - count - start);
+
+    std::memcpy(begin.data(), expected.data(), start);
+    std::memcpy(end.data(), (uint8_t*)expected.data()+start+count, end.size());
+
+    EXPECT_DATA_READS_AS(begin, leaf, 0, start);
+    EXPECT_DATA_READS_AS(end, leaf, start + count, end.size());
+  }
+
+  void EXPECT_DATA_IS_ZEROES_OUTSIDE_OF(const DataLeafNode &leaf, off_t start, size_t count) {
+    Data ZEROES(GetParam().leafsize);
+    ZEROES.FillWithZeroes();
+    EXPECT_DATA_READS_AS_OUTSIDE_OF(ZEROES, leaf, start, count);
+  }
+};
+INSTANTIATE_TEST_CASE_P(DataLeafNodeDataTest, DataLeafNodeDataTest, Values(
+  DataRange{DataLeafNodeTest::LAYOUT.maxBytesPerLeaf(),     0,   DataLeafNodeTest::LAYOUT.maxBytesPerLeaf()},     // full size leaf, access beginning to end
+  DataRange{DataLeafNodeTest::LAYOUT.maxBytesPerLeaf(),     100, DataLeafNodeTest::LAYOUT.maxBytesPerLeaf()-200}, // full size leaf, access middle to middle
+  DataRange{DataLeafNodeTest::LAYOUT.maxBytesPerLeaf(),     0,   DataLeafNodeTest::LAYOUT.maxBytesPerLeaf()-100}, // full size leaf, access beginning to middle
+  DataRange{DataLeafNodeTest::LAYOUT.maxBytesPerLeaf(),     100, DataLeafNodeTest::LAYOUT.maxBytesPerLeaf()-100}, // full size leaf, access middle to end
+  DataRange{DataLeafNodeTest::LAYOUT.maxBytesPerLeaf()-100, 0,   DataLeafNodeTest::LAYOUT.maxBytesPerLeaf()-100}, // non-full size leaf, access beginning to end
+  DataRange{DataLeafNodeTest::LAYOUT.maxBytesPerLeaf()-100, 100, DataLeafNodeTest::LAYOUT.maxBytesPerLeaf()-300}, // non-full size leaf, access middle to middle
+  DataRange{DataLeafNodeTest::LAYOUT.maxBytesPerLeaf()-100, 0,   DataLeafNodeTest::LAYOUT.maxBytesPerLeaf()-200}, // non-full size leaf, access beginning to middle
+  DataRange{DataLeafNodeTest::LAYOUT.maxBytesPerLeaf()-100, 100, DataLeafNodeTest::LAYOUT.maxBytesPerLeaf()-200}  // non-full size leaf, access middle to end
+));
+
+TEST_P(DataLeafNodeDataTest, WriteAndReadImmediately) {
+  leaf->resize(GetParam().leafsize);
+  leaf->write(this->foregroundData.data(), GetParam().offset, GetParam().count);
+
+  EXPECT_DATA_READS_AS(this->foregroundData, *leaf, GetParam().offset, GetParam().count);
+  EXPECT_DATA_IS_ZEROES_OUTSIDE_OF(*leaf, GetParam().offset, GetParam().count);
+}
+
+TEST_P(DataLeafNodeDataTest, WriteAndReadAfterLoading) {
+  Key key = CreateLeafWriteToItAndReturnKey(this->foregroundData);
+
+  auto loaded_leaf = LoadLeafNode(key);
+  EXPECT_DATA_READS_AS(this->foregroundData, *loaded_leaf, GetParam().offset, GetParam().count);
+  EXPECT_DATA_IS_ZEROES_OUTSIDE_OF(*loaded_leaf, GetParam().offset, GetParam().count);
+}
+
+TEST_P(DataLeafNodeDataTest, OverwriteAndRead) {
+  leaf->resize(GetParam().leafsize);
+  leaf->write(this->backgroundData.data(), 0, GetParam().leafsize);
+  leaf->write(this->foregroundData.data(), GetParam().offset, GetParam().count);
+  EXPECT_DATA_READS_AS(this->foregroundData, *leaf, GetParam().offset, GetParam().count);
+  EXPECT_DATA_READS_AS_OUTSIDE_OF(this->backgroundData, *leaf, GetParam().offset, GetParam().count);
+}
+

test/blobstore/implementations/onblocks/datanodestore/DataNodeStoreTest.cpp

@@ -0,0 +1,137 @@
+#include "../../../../implementations/onblocks/datanodestore/DataInnerNode.h"
+#include "../../../../implementations/onblocks/datanodestore/DataLeafNode.h"
+#include "../../../../implementations/onblocks/datanodestore/DataNode.h"
+#include "../../../../implementations/onblocks/datanodestore/DataNodeStore.h"
+#include "../../../../implementations/onblocks/BlobStoreOnBlocks.h"
+#include <google/gtest/gtest.h>
+
+#include "messmer/blockstore/implementations/testfake/FakeBlockStore.h"
+#include "messmer/blockstore/implementations/testfake/FakeBlock.h"
+#include <messmer/cpp-utils/pointer/unique_ref_boost_optional_gtest_workaround.h>
+
+using ::testing::Test;
+using cpputils::unique_ref;
+using cpputils::make_unique_ref;
+using std::string;
+using boost::none;
+
+using blockstore::BlockStore;
+using blockstore::testfake::FakeBlockStore;
+using blockstore::Key;
+using cpputils::Data;
+using namespace blobstore;
+using namespace blobstore::onblocks;
+using namespace blobstore::onblocks::datanodestore;
+
+class DataNodeStoreTest: public Test {
+public:
+  static constexpr uint32_t BLOCKSIZE_BYTES = 1024;
+
+  unique_ref<BlockStore> _blockStore = make_unique_ref<FakeBlockStore>();
+  BlockStore *blockStore = _blockStore.get();
+  unique_ref<DataNodeStore> nodeStore = make_unique_ref<DataNodeStore>(std::move(_blockStore), BLOCKSIZE_BYTES);
+};
+
+constexpr uint32_t DataNodeStoreTest::BLOCKSIZE_BYTES;
+
+#define EXPECT_IS_PTR_TYPE(Type, ptr) EXPECT_NE(nullptr, dynamic_cast<Type*>(ptr)) << "Given pointer cannot be cast to the given type"
+
+TEST_F(DataNodeStoreTest, CreateLeafNodeCreatesLeafNode) {
+  auto node = nodeStore->createNewLeafNode();
+  EXPECT_IS_PTR_TYPE(DataLeafNode, node.get());
+}
+
+TEST_F(DataNodeStoreTest, CreateInnerNodeCreatesInnerNode) {
+  auto leaf = nodeStore->createNewLeafNode();
+
+  auto node = nodeStore->createNewInnerNode(*leaf);
+  EXPECT_IS_PTR_TYPE(DataInnerNode, node.get());
+}
+
+TEST_F(DataNodeStoreTest, LeafNodeIsRecognizedAfterStoreAndLoad) {
+  Key key = nodeStore->createNewLeafNode()->key();
+
+  auto loaded_node = nodeStore->load(key).value();
+
+  EXPECT_IS_PTR_TYPE(DataLeafNode, loaded_node.get());
+}
+
+TEST_F(DataNodeStoreTest, InnerNodeWithDepth1IsRecognizedAfterStoreAndLoad) {
+  auto leaf = nodeStore->createNewLeafNode();
+  Key key = nodeStore->createNewInnerNode(*leaf)->key();
+
+  auto loaded_node = nodeStore->load(key).value();
+
+  EXPECT_IS_PTR_TYPE(DataInnerNode, loaded_node.get());
+}
+
+TEST_F(DataNodeStoreTest, InnerNodeWithDepth2IsRecognizedAfterStoreAndLoad) {
+  auto leaf = nodeStore->createNewLeafNode();
+  auto inner = nodeStore->createNewInnerNode(*leaf);
+  Key key = nodeStore->createNewInnerNode(*inner)->key();
+
+  auto loaded_node = nodeStore->load(key).value();
+
+  EXPECT_IS_PTR_TYPE(DataInnerNode, loaded_node.get());
+}
+
+TEST_F(DataNodeStoreTest, DataNodeCrashesOnLoadIfDepthIsTooHigh) {
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  Key key = block->key();
+  {
+    DataNodeView view(std::move(block));
+    view.setDepth(DataNodeStore::MAX_DEPTH + 1);
+  }
+
+  EXPECT_ANY_THROW(
+    nodeStore->load(key)
+  );
+}
+
+TEST_F(DataNodeStoreTest, CreatedInnerNodeIsInitialized) {
+  auto leaf = nodeStore->createNewLeafNode();
+  auto node = nodeStore->createNewInnerNode(*leaf);
+  EXPECT_EQ(1u, node->numChildren());
+  EXPECT_EQ(leaf->key(), node->getChild(0)->key());
+}
+
+TEST_F(DataNodeStoreTest, CreatedLeafNodeIsInitialized) {
+  auto leaf = nodeStore->createNewLeafNode();
+  EXPECT_EQ(0u, leaf->numBytes());
+}
+
+TEST_F(DataNodeStoreTest, NodeIsNotLoadableAfterDeleting) {
+  auto nodekey = nodeStore->createNewLeafNode()->key();
+  auto node = nodeStore->load(nodekey);
+  EXPECT_NE(none, node);
+  nodeStore->remove(std::move(*node));
+  EXPECT_EQ(none, nodeStore->load(nodekey));
+}
+
+TEST_F(DataNodeStoreTest, NumNodesIsCorrectOnEmptyNodestore) {
+  EXPECT_EQ(0, nodeStore->numNodes());
+}
+
+TEST_F(DataNodeStoreTest, NumNodesIsCorrectAfterAddingOneLeafNode) {
+  nodeStore->createNewLeafNode();
+  EXPECT_EQ(1, nodeStore->numNodes());
+}
+
+TEST_F(DataNodeStoreTest, NumNodesIsCorrectAfterRemovingTheLastNode) {
+  auto leaf = nodeStore->createNewLeafNode();
+  nodeStore->remove(std::move(leaf));
+  EXPECT_EQ(0, nodeStore->numNodes());
+}
+
+TEST_F(DataNodeStoreTest, NumNodesIsCorrectAfterAddingTwoNodes) {
+  auto leaf = nodeStore->createNewLeafNode();
+  auto node = nodeStore->createNewInnerNode(*leaf);
+  EXPECT_EQ(2, nodeStore->numNodes());
+}
+
+TEST_F(DataNodeStoreTest, NumNodesIsCorrectAfterRemovingANode) {
+  auto leaf = nodeStore->createNewLeafNode();
+  auto node = nodeStore->createNewInnerNode(*leaf);
+  nodeStore->remove(std::move(node));
+  EXPECT_EQ(1, nodeStore->numNodes());
+}

test/blobstore/implementations/onblocks/datanodestore/DataNodeViewTest.cpp

@@ -0,0 +1,150 @@
+#include "../../../../implementations/onblocks/datanodestore/DataNodeView.h"
+#include <google/gtest/gtest.h>
+
+#include "messmer/blockstore/implementations/testfake/FakeBlockStore.h"
+#include "messmer/blockstore/implementations/testfake/FakeBlock.h"
+#include "../../../../implementations/onblocks/BlobStoreOnBlocks.h"
+#include <messmer/cpp-utils/data/DataFixture.h>
+
+using ::testing::Test;
+using ::testing::WithParamInterface;
+using ::testing::Values;
+using std::string;
+
+using blockstore::BlockStore;
+using blockstore::testfake::FakeBlockStore;
+using cpputils::Data;
+using cpputils::DataFixture;
+using cpputils::unique_ref;
+using cpputils::make_unique_ref;
+using namespace blobstore;
+using namespace blobstore::onblocks;
+using namespace blobstore::onblocks::datanodestore;
+
+class DataNodeViewTest: public Test {
+public:
+  static constexpr uint32_t BLOCKSIZE_BYTES = 1024;
+  static constexpr uint32_t DATASIZE_BYTES = DataNodeLayout(DataNodeViewTest::BLOCKSIZE_BYTES).datasizeBytes();
+
+  unique_ref<BlockStore> blockStore = make_unique_ref<FakeBlockStore>();
+};
+
+class DataNodeViewDepthTest: public DataNodeViewTest, public WithParamInterface<uint8_t> {
+};
+INSTANTIATE_TEST_CASE_P(DataNodeViewDepthTest, DataNodeViewDepthTest, Values(0, 1, 3, 10, 100));
+
+TEST_P(DataNodeViewDepthTest, DepthIsStored) {
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  auto key = block->key();
+  {
+    DataNodeView view(std::move(block));
+    view.setDepth(GetParam());
+  }
+  DataNodeView view(blockStore->load(key).value());
+  EXPECT_EQ(GetParam(), view.Depth());
+}
+
+class DataNodeViewSizeTest: public DataNodeViewTest, public WithParamInterface<uint32_t> {
+};
+INSTANTIATE_TEST_CASE_P(DataNodeViewSizeTest, DataNodeViewSizeTest, Values(0, 50, 64, 1024, 1024*1024*1024));
+
+TEST_P(DataNodeViewSizeTest, SizeIsStored) {
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  auto key = block->key();
+  {
+    DataNodeView view(std::move(block));
+    view.setSize(GetParam());
+  }
+  DataNodeView view(blockStore->load(key).value());
+  EXPECT_EQ(GetParam(), view.Size());
+}
+
+TEST_F(DataNodeViewTest, DataIsStored) {
+  Data randomData = DataFixture::generate(DATASIZE_BYTES);
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  auto key = block->key();
+  {
+    DataNodeView view(std::move(block));
+    view.write(randomData.data(), 0, randomData.size());
+  }
+  DataNodeView view(blockStore->load(key).value());
+  EXPECT_EQ(0, std::memcmp(view.data(), randomData.data(), randomData.size()));
+}
+
+TEST_F(DataNodeViewTest, HeaderAndBodyDontOverlap) {
+  Data randomData = DataFixture::generate(DATASIZE_BYTES);
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  auto key = block->key();
+  {
+    DataNodeView view(std::move(block));
+    view.setDepth(3);
+    view.setSize(1000000000u);
+    view.write(randomData.data(), 0, DATASIZE_BYTES);
+  }
+  DataNodeView view(blockStore->load(key).value());
+  EXPECT_EQ(3, view.Depth());
+  EXPECT_EQ(1000000000u, view.Size());
+  EXPECT_EQ(0, std::memcmp(view.data(), randomData.data(), DATASIZE_BYTES));
+}
+
+TEST_F(DataNodeViewTest, DataBeginWorksWithOneByteEntries) {
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  uint8_t *blockBegin = (uint8_t*)block->data();
+  DataNodeView view(std::move(block));
+
+  EXPECT_EQ(blockBegin+DataNodeLayout::HEADERSIZE_BYTES, view.DataBegin<uint8_t>());
+}
+
+TEST_F(DataNodeViewTest, DataBeginWorksWithEightByteEntries) {
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  uint8_t *blockBegin = (uint8_t*)block->data();
+  DataNodeView view(std::move(block));
+
+  EXPECT_EQ(blockBegin+DataNodeLayout::HEADERSIZE_BYTES, (uint8_t*)view.DataBegin<uint64_t>());
+}
+
+TEST_F(DataNodeViewTest, DataEndWorksWithOneByteEntries) {
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  uint8_t *blockBegin = (uint8_t*)block->data();
+  DataNodeView view(std::move(block));
+
+  EXPECT_EQ(blockBegin+BLOCKSIZE_BYTES, view.DataEnd<uint8_t>());
+}
+
+TEST_F(DataNodeViewTest, DataEndWorksWithEightByteEntries) {
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  uint8_t *blockBegin = (uint8_t*)block->data();
+  DataNodeView view(std::move(block));
+
+  EXPECT_EQ(blockBegin+BLOCKSIZE_BYTES, (uint8_t*)view.DataEnd<uint64_t>());
+}
+
+struct SizedDataEntry {
+  uint8_t data[6];
+};
+BOOST_STATIC_ASSERT_MSG(DataNodeViewTest::DATASIZE_BYTES % sizeof(SizedDataEntry) != 0,
+  "This test case only makes sense, if the data entries don't fill up the whole space. "
+  "There should be some space left at the end that is not used, because it isn't enough space for a full entry. "
+  "If this static assertion fails, please use a different size for SizedDataEntry.");
+
+TEST_F(DataNodeViewTest, DataBeginWorksWithStructEntries) {
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  uint8_t *blockBegin = (uint8_t*)block->data();
+  DataNodeView view(std::move(block));
+
+  EXPECT_EQ(blockBegin+DataNodeLayout::HEADERSIZE_BYTES, (uint8_t*)view.DataBegin<SizedDataEntry>());
+}
+
+TEST_F(DataNodeViewTest, DataEndWorksWithStructByteEntries) {
+  auto block = blockStore->create(Data(BLOCKSIZE_BYTES));
+  uint8_t *blockBegin = (uint8_t*)block->data();
+  DataNodeView view(std::move(block));
+
+  unsigned int numFittingEntries = DATASIZE_BYTES / sizeof(SizedDataEntry);
+
+  uint8_t *dataEnd = (uint8_t*)view.DataEnd<SizedDataEntry>();
+  EXPECT_EQ(blockBegin+DataNodeLayout::HEADERSIZE_BYTES + numFittingEntries * sizeof(SizedDataEntry), dataEnd);
+  EXPECT_LT(dataEnd, blockBegin + BLOCKSIZE_BYTES);
+}
+
+//TODO Test that header fields (and data) are also stored over reloads

test/blobstore/implementations/onblocks/datatreestore/DataTreeStoreTest.cpp

@@ -0,0 +1,54 @@
+#include "testutils/DataTreeTest.h"
+
+#include "../../../../implementations/onblocks/datanodestore/DataNodeStore.h"
+#include "../../../../implementations/onblocks/datatreestore/DataTreeStore.h"
+#include <messmer/blockstore/implementations/testfake/FakeBlockStore.h>
+#include <messmer/cpp-utils/pointer/unique_ref_boost_optional_gtest_workaround.h>
+
+using blockstore::testfake::FakeBlockStore;
+using blockstore::Key;
+using blobstore::onblocks::datanodestore::DataNodeStore;
+using boost::none;
+
+using namespace blobstore::onblocks::datatreestore;
+
+class DataTreeStoreTest: public DataTreeTest {
+};
+
+TEST_F(DataTreeStoreTest, CorrectKeyReturned) {
+  Key key = treeStore.createNewTree()->key();
+  auto tree = treeStore.load(key).value();
+  EXPECT_EQ(key, tree->key());
+}
+
+TEST_F(DataTreeStoreTest, CreatedTreeIsLoadable) {
+  auto key = treeStore.createNewTree()->key();
+  auto loaded = treeStore.load(key);
+  EXPECT_NE(none, loaded);
+}
+
+TEST_F(DataTreeStoreTest, NewTreeIsLeafOnly) {
+  auto tree = treeStore.createNewTree();
+
+  EXPECT_IS_LEAF_NODE(tree->key());
+}
+
+TEST_F(DataTreeStoreTest, TreeIsNotLoadableAfterRemove) {
+  Key key = treeStore.createNewTree()->key();
+  auto tree = treeStore.load(key);
+  EXPECT_NE(none, tree);
+  treeStore.remove(std::move(*tree));
+  EXPECT_EQ(none, treeStore.load(key));
+}
+
+TEST_F(DataTreeStoreTest, RemovingTreeRemovesAllNodesOfTheTree) {
+  auto key = CreateThreeLevelMinData()->key();
+  auto tree1 = treeStore.load(key).value();
+  auto tree2_key = treeStore.createNewTree()->key();
+
+  treeStore.remove(std::move(tree1));
+
+  //Check that the only remaining node is tree2
+  EXPECT_EQ(1, nodeStore->numNodes());
+  EXPECT_NE(none, treeStore.load(tree2_key));
+}

test/blobstore/implementations/onblocks/datatreestore/DataTreeTest_NumStoredBytes.cpp

@@ -0,0 +1,75 @@
+#include "testutils/DataTreeTest.h"
+#include <google/gmock/gmock.h>
+
+using ::testing::_;
+using ::testing::WithParamInterface;
+using ::testing::Values;
+
+using blobstore::onblocks::datanodestore::DataLeafNode;
+using blobstore::onblocks::datanodestore::DataInnerNode;
+using blobstore::onblocks::datanodestore::DataNode;
+using blobstore::onblocks::datanodestore::DataNodeLayout;
+using blobstore::onblocks::datatreestore::DataTree;
+using blockstore::Key;
+
+class DataTreeTest_NumStoredBytes: public DataTreeTest {
+public:
+};
+
+TEST_F(DataTreeTest_NumStoredBytes, CreatedTreeIsEmpty) {
+  auto tree = treeStore.createNewTree();
+  EXPECT_EQ(0, tree->numStoredBytes());
+}
+
+class DataTreeTest_NumStoredBytes_P: public DataTreeTest_NumStoredBytes, public WithParamInterface<uint32_t> {};
+INSTANTIATE_TEST_CASE_P(EmptyLastLeaf, DataTreeTest_NumStoredBytes_P, Values(0u));
+INSTANTIATE_TEST_CASE_P(HalfFullLastLeaf, DataTreeTest_NumStoredBytes_P, Values(5u, 10u));
+INSTANTIATE_TEST_CASE_P(FullLastLeaf, DataTreeTest_NumStoredBytes_P, Values((uint32_t)DataNodeLayout(DataTreeTest_NumStoredBytes::BLOCKSIZE_BYTES).maxBytesPerLeaf()));
+
+TEST_P(DataTreeTest_NumStoredBytes_P, SingleLeaf) {
+  Key key = CreateLeafWithSize(GetParam())->key();
+  auto tree = treeStore.load(key).value();
+  EXPECT_EQ(GetParam(), tree->numStoredBytes());
+}
+
+TEST_P(DataTreeTest_NumStoredBytes_P, TwoLeafTree) {
+  Key key = CreateTwoLeafWithSecondLeafSize(GetParam())->key();
+  auto tree = treeStore.load(key).value();
+  EXPECT_EQ(nodeStore->layout().maxBytesPerLeaf() + GetParam(), tree->numStoredBytes());
+}
+
+TEST_P(DataTreeTest_NumStoredBytes_P, FullTwolevelTree) {
+  Key key = CreateFullTwoLevelWithLastLeafSize(GetParam())->key();
+  auto tree = treeStore.load(key).value();
+  EXPECT_EQ(nodeStore->layout().maxBytesPerLeaf()*(nodeStore->layout().maxChildrenPerInnerNode()-1) + GetParam(), tree->numStoredBytes());
+}
+
+TEST_P(DataTreeTest_NumStoredBytes_P, ThreeLevelTreeWithOneChild) {
+  Key key = CreateThreeLevelWithOneChildAndLastLeafSize(GetParam())->key();
+  auto tree = treeStore.load(key).value();
+  EXPECT_EQ(nodeStore->layout().maxBytesPerLeaf() + GetParam(), tree->numStoredBytes());
+}
+
+TEST_P(DataTreeTest_NumStoredBytes_P, ThreeLevelTreeWithTwoChildren) {
+  Key key = CreateThreeLevelWithTwoChildrenAndLastLeafSize(GetParam())->key();
+  auto tree = treeStore.load(key).value();
+  EXPECT_EQ(nodeStore->layout().maxBytesPerLeaf()*nodeStore->layout().maxChildrenPerInnerNode() + nodeStore->layout().maxBytesPerLeaf() + GetParam(), tree->numStoredBytes());
+}
+
+TEST_P(DataTreeTest_NumStoredBytes_P, ThreeLevelTreeWithThreeChildren) {
+  Key key = CreateThreeLevelWithThreeChildrenAndLastLeafSize(GetParam())->key();
+  auto tree = treeStore.load(key).value();
+  EXPECT_EQ(2*nodeStore->layout().maxBytesPerLeaf()*nodeStore->layout().maxChildrenPerInnerNode() + nodeStore->layout().maxBytesPerLeaf() + GetParam(), tree->numStoredBytes());
+}
+
+TEST_P(DataTreeTest_NumStoredBytes_P, FullThreeLevelTree) {
+  Key key = CreateFullThreeLevelWithLastLeafSize(GetParam())->key();
+  auto tree = treeStore.load(key).value();
+  EXPECT_EQ(nodeStore->layout().maxBytesPerLeaf()*nodeStore->layout().maxChildrenPerInnerNode()*(nodeStore->layout().maxChildrenPerInnerNode()-1) + nodeStore->layout().maxBytesPerLeaf()*(nodeStore->layout().maxChildrenPerInnerNode()-1) + GetParam(), tree->numStoredBytes());
+}
+
+TEST_P(DataTreeTest_NumStoredBytes_P, FourLevelMinDataTree) {
+  Key key = CreateFourLevelMinDataWithLastLeafSize(GetParam())->key();
+  auto tree = treeStore.load(key).value();
+  EXPECT_EQ(nodeStore->layout().maxBytesPerLeaf()*nodeStore->layout().maxChildrenPerInnerNode()*nodeStore->layout().maxChildrenPerInnerNode() + GetParam(), tree->numStoredBytes());
+}

test/blobstore/implementations/onblocks/datatreestore/DataTreeTest_ResizeByTraversing.cpp

@@ -0,0 +1,201 @@
+#include "testutils/DataTreeTest.h"
+#include "testutils/TwoLevelDataFixture.h"
+#include "../../../../implementations/onblocks/utils/Math.h"
+#include <messmer/cpp-utils/data/Data.h>
+
+#include <tuple>
+
+using ::testing::WithParamInterface;
+using ::testing::Values;
+using ::testing::Combine;
+using std::tuple;
+using std::get;
+using std::function;
+using std::mem_fn;
+using cpputils::dynamic_pointer_move;
+
+using blobstore::onblocks::datanodestore::DataLeafNode;
+using blobstore::onblocks::datanodestore::DataInnerNode;
+using blobstore::onblocks::datanodestore::DataNode;
+using blobstore::onblocks::datanodestore::DataNodeLayout;
+using blobstore::onblocks::datatreestore::DataTree;
+using blobstore::onblocks::utils::ceilDivision;
+using blockstore::Key;
+using cpputils::Data;
+using boost::none;
+
+using cpputils::unique_ref;
+
+class DataTreeTest_ResizeByTraversing: public DataTreeTest {
+public:
+  static constexpr DataNodeLayout LAYOUT = DataNodeLayout(BLOCKSIZE_BYTES);
+
+  unique_ref<DataTree> CreateTree(unique_ref<DataNode> root) {
+    Key key = root->key();
+    cpputils::destruct(std::move(root));
+    return treeStore.load(key).value();
+  }
+
+  unique_ref<DataTree> CreateLeafTreeWithSize(uint32_t size) {
+    return CreateTree(CreateLeafWithSize(size));
+  }
+
+  unique_ref<DataTree> CreateTwoLeafTreeWithSecondLeafSize(uint32_t size) {
+    return CreateTree(CreateTwoLeafWithSecondLeafSize(size));
+  }
+
+  unique_ref<DataTree> CreateFullTwoLevelTreeWithLastLeafSize(uint32_t size) {
+    return CreateTree(CreateFullTwoLevelWithLastLeafSize(size));
+  }
+
+  unique_ref<DataTree> CreateThreeLevelTreeWithTwoChildrenAndLastLeafSize(uint32_t size) {
+    return CreateTree(CreateThreeLevelWithTwoChildrenAndLastLeafSize(size));
+  }
+
+  unique_ref<DataTree> CreateThreeLevelTreeWithThreeChildrenAndLastLeafSize(uint32_t size) {
+    return CreateTree(CreateThreeLevelWithThreeChildrenAndLastLeafSize(size));
+  }
+
+  unique_ref<DataTree> CreateFullThreeLevelTreeWithLastLeafSize(uint32_t size) {
+    return CreateTree(CreateFullThreeLevelWithLastLeafSize(size));
+  }
+
+  unique_ref<DataTree> CreateFourLevelMinDataTreeWithLastLeafSize(uint32_t size) {
+    return CreateTree(CreateFourLevelMinDataWithLastLeafSize(size));
+  }
+
+  void EXPECT_IS_LEFTMAXDATA_TREE(const Key &key) {
+    auto root = nodeStore->load(key).value();
+    DataInnerNode *inner = dynamic_cast<DataInnerNode*>(root.get());
+    if (inner != nullptr) {
+      for (uint32_t i = 0; i < inner->numChildren()-1; ++i) {
+        EXPECT_IS_MAXDATA_TREE(inner->getChild(i)->key());
+      }
+      EXPECT_IS_LEFTMAXDATA_TREE(inner->LastChild()->key());
+    }
+  }
+
+  void EXPECT_IS_MAXDATA_TREE(const Key &key) {
+    auto root = nodeStore->load(key).value();
+    DataInnerNode *inner = dynamic_cast<DataInnerNode*>(root.get());
+    if (inner != nullptr) {
+      for (uint32_t i = 0; i < inner->numChildren(); ++i) {
+        EXPECT_IS_MAXDATA_TREE(inner->getChild(i)->key());
+      }
+    } else {
+      DataLeafNode *leaf = dynamic_cast<DataLeafNode*>(root.get());
+      EXPECT_EQ(nodeStore->layout().maxBytesPerLeaf(), leaf->numBytes());
+    }
+  }
+};
+constexpr DataNodeLayout DataTreeTest_ResizeByTraversing::LAYOUT;
+
+class DataTreeTest_ResizeByTraversing_P: public DataTreeTest_ResizeByTraversing, public WithParamInterface<tuple<function<unique_ref<DataTree>(DataTreeTest_ResizeByTraversing*, uint32_t)>, uint32_t, uint32_t>> {
+public:
+  DataTreeTest_ResizeByTraversing_P()
+    : oldLastLeafSize(get<1>(GetParam())),
+      tree(get<0>(GetParam())(this, oldLastLeafSize)),
+      numberOfLeavesToAdd(get<2>(GetParam())),
+      newNumberOfLeaves(tree->numLeaves()+numberOfLeavesToAdd),
+      ZEROES(LAYOUT.maxBytesPerLeaf())
+  {
+    ZEROES.FillWithZeroes();
+  }
+
+  void GrowTree(const Key &key, uint32_t numLeavesToAdd) {
+    auto tree = treeStore.load(key);
+    GrowTree(tree.get().get(), numLeavesToAdd);
+  }
+
+  void GrowTree(DataTree *tree, uint32_t numLeavesToAdd) {
+    uint32_t oldNumLeaves = tree->numLeaves();
+    uint32_t newNumLeaves = oldNumLeaves + numLeavesToAdd;
+    //TODO Test cases where beginIndex is inside of the existing leaves
+    tree->traverseLeaves(newNumLeaves-1, newNumLeaves, [] (DataLeafNode*,uint32_t){});
+    tree->flush();
+  }
+
+  unique_ref<DataLeafNode> LastLeaf(const Key &key) {
+    auto root = nodeStore->load(key).value();
+    auto leaf = dynamic_pointer_move<DataLeafNode>(root);
+    if (leaf != none) {
+      return std::move(*leaf);
+    }
+    auto inner = dynamic_pointer_move<DataInnerNode>(root).value();
+    return LastLeaf(inner->LastChild()->key());
+  }
+
+  uint32_t oldLastLeafSize;
+  unique_ref<DataTree> tree;
+  uint32_t numberOfLeavesToAdd;
+  uint32_t newNumberOfLeaves;
+  Data ZEROES;
+};
+INSTANTIATE_TEST_CASE_P(DataTreeTest_ResizeByTraversing_P, DataTreeTest_ResizeByTraversing_P,
+  Combine(
+    //Tree we're starting with
+    Values<function<unique_ref<DataTree>(DataTreeTest_ResizeByTraversing*, uint32_t)>>(
+      mem_fn(&DataTreeTest_ResizeByTraversing::CreateLeafTreeWithSize),
+      mem_fn(&DataTreeTest_ResizeByTraversing::CreateTwoLeafTreeWithSecondLeafSize),
+      mem_fn(&DataTreeTest_ResizeByTraversing::CreateFullTwoLevelTreeWithLastLeafSize),
+      mem_fn(&DataTreeTest_ResizeByTraversing::CreateThreeLevelTreeWithTwoChildrenAndLastLeafSize),
+      mem_fn(&DataTreeTest_ResizeByTraversing::CreateThreeLevelTreeWithThreeChildrenAndLastLeafSize),
+      mem_fn(&DataTreeTest_ResizeByTraversing::CreateFullThreeLevelTreeWithLastLeafSize),
+      mem_fn(&DataTreeTest_ResizeByTraversing::CreateFourLevelMinDataTreeWithLastLeafSize)
+    ),
+    //Last leaf size of the start tree
+    Values(
+      0u,
+      1u,
+      10u,
+      DataTreeTest_ResizeByTraversing::LAYOUT.maxBytesPerLeaf()
+    ),
+    //Number of leaves we're adding
+    Values(
+      1u,
+      2u,
+      DataTreeTest_ResizeByTraversing::LAYOUT.maxChildrenPerInnerNode(),  //Full two level tree
+      2* DataTreeTest_ResizeByTraversing::LAYOUT.maxChildrenPerInnerNode(), //Three level tree with two children
+      3* DataTreeTest_ResizeByTraversing::LAYOUT.maxChildrenPerInnerNode(), //Three level tree with three children
+      DataTreeTest_ResizeByTraversing::LAYOUT.maxChildrenPerInnerNode() * DataTreeTest_ResizeByTraversing::LAYOUT.maxChildrenPerInnerNode(), //Full three level tree
+      DataTreeTest_ResizeByTraversing::LAYOUT.maxChildrenPerInnerNode() * DataTreeTest_ResizeByTraversing::LAYOUT.maxChildrenPerInnerNode() + 1 //Four level mindata tree
+    )
+  )
+);
+
+TEST_P(DataTreeTest_ResizeByTraversing_P, StructureIsValid) {
+  GrowTree(tree.get(), numberOfLeavesToAdd);
+  EXPECT_IS_LEFTMAXDATA_TREE(tree->key());
+}
+
+TEST_P(DataTreeTest_ResizeByTraversing_P, NumBytesIsCorrect) {
+  GrowTree(tree.get(), numberOfLeavesToAdd);
+  // tree->numLeaves() only goes down the right border nodes and expects the tree to be a left max data tree.
+  // This is what the StructureIsValid test case is for.
+  EXPECT_EQ(newNumberOfLeaves, tree->numLeaves());
+}
+
+TEST_P(DataTreeTest_ResizeByTraversing_P, DepthFlagsAreCorrect) {
+  GrowTree(tree.get(), numberOfLeavesToAdd);
+  uint32_t depth = ceil(log(newNumberOfLeaves)/log(DataTreeTest_ResizeByTraversing::LAYOUT.maxChildrenPerInnerNode()));
+  CHECK_DEPTH(depth, tree->key());
+}
+
+TEST_P(DataTreeTest_ResizeByTraversing_P, KeyDoesntChange) {
+  Key key = tree->key();
+  tree->flush();
+  GrowTree(tree.get(), numberOfLeavesToAdd);
+  EXPECT_EQ(key, tree->key());
+}
+
+TEST_P(DataTreeTest_ResizeByTraversing_P, DataStaysIntact) {
+  uint32_t oldNumberOfLeaves = std::max(UINT64_C(1), ceilDivision(tree->numStoredBytes(), (uint64_t)nodeStore->layout().maxBytesPerLeaf()));
+  TwoLevelDataFixture data(nodeStore, TwoLevelDataFixture::SizePolicy::Unchanged);
+  Key key = tree->key();
+  cpputils::destruct(std::move(tree));
+  data.FillInto(nodeStore->load(key).get().get());
+
+  GrowTree(key, newNumberOfLeaves);
+
+  data.EXPECT_DATA_CORRECT(nodeStore->load(key).get().get(), oldNumberOfLeaves, oldLastLeafSize);
+}

test/blobstore/implementations/onblocks/datatreestore/DataTreeTest_ResizeNumBytes.cpp

@@ -0,0 +1,226 @@
+#include "testutils/DataTreeTest.h"
+#include "testutils/TwoLevelDataFixture.h"
+#include "../../../../implementations/onblocks/utils/Math.h"
+#include <messmer/cpp-utils/data/Data.h>
+
+#include <tuple>
+
+using ::testing::WithParamInterface;
+using ::testing::Values;
+using ::testing::Combine;
+using std::tuple;
+using std::get;
+using std::function;
+using std::mem_fn;
+using cpputils::dynamic_pointer_move;
+
+using blobstore::onblocks::datanodestore::DataLeafNode;
+using blobstore::onblocks::datanodestore::DataInnerNode;
+using blobstore::onblocks::datanodestore::DataNode;
+using blobstore::onblocks::datanodestore::DataNodeLayout;
+using blobstore::onblocks::datatreestore::DataTree;
+using blobstore::onblocks::utils::ceilDivision;
+using blockstore::Key;
+using cpputils::Data;
+using boost::none;
+
+using cpputils::unique_ref;
+
+class DataTreeTest_ResizeNumBytes: public DataTreeTest {
+public:
+  static constexpr DataNodeLayout LAYOUT = DataNodeLayout(BLOCKSIZE_BYTES);
+
+  unique_ref<DataTree> CreateTree(unique_ref<DataNode> root) {
+    Key key = root->key();
+    cpputils::destruct(std::move(root));
+    return treeStore.load(key).value();
+  }
+
+  unique_ref<DataTree> CreateLeafTreeWithSize(uint32_t size) {
+    return CreateTree(CreateLeafWithSize(size));
+  }
+
+  unique_ref<DataTree> CreateTwoLeafTreeWithSecondLeafSize(uint32_t size) {
+    return CreateTree(CreateTwoLeafWithSecondLeafSize(size));
+  }
+
+  unique_ref<DataTree> CreateFullTwoLevelTreeWithLastLeafSize(uint32_t size) {
+    return CreateTree(CreateFullTwoLevelWithLastLeafSize(size));
+  }
+
+  unique_ref<DataTree> CreateThreeLevelTreeWithTwoChildrenAndLastLeafSize(uint32_t size) {
+    return CreateTree(CreateThreeLevelWithTwoChildrenAndLastLeafSize(size));
+  }
+
+  unique_ref<DataTree> CreateThreeLevelTreeWithThreeChildrenAndLastLeafSize(uint32_t size) {
+    return CreateTree(CreateThreeLevelWithThreeChildrenAndLastLeafSize(size));
+  }
+
+  unique_ref<DataTree> CreateFullThreeLevelTreeWithLastLeafSize(uint32_t size) {
+    return CreateTree(CreateFullThreeLevelWithLastLeafSize(size));
+  }
+
+  unique_ref<DataTree> CreateFourLevelMinDataTreeWithLastLeafSize(uint32_t size) {
+    return CreateTree(CreateFourLevelMinDataWithLastLeafSize(size));
+  }
+
+  void EXPECT_IS_LEFTMAXDATA_TREE(const Key &key) {
+    auto root = nodeStore->load(key).value();
+    DataInnerNode *inner = dynamic_cast<DataInnerNode*>(root.get());
+    if (inner != nullptr) {
+      for (uint32_t i = 0; i < inner->numChildren()-1; ++i) {
+        EXPECT_IS_MAXDATA_TREE(inner->getChild(i)->key());
+      }
+      EXPECT_IS_LEFTMAXDATA_TREE(inner->LastChild()->key());
+    }
+  }
+
+  void EXPECT_IS_MAXDATA_TREE(const Key &key) {
+    auto root = nodeStore->load(key).value();
+    DataInnerNode *inner = dynamic_cast<DataInnerNode*>(root.get());
+    if (inner != nullptr) {
+      for (uint32_t i = 0; i < inner->numChildren(); ++i) {
+        EXPECT_IS_MAXDATA_TREE(inner->getChild(i)->key());
+      }
+    } else {
+      DataLeafNode *leaf = dynamic_cast<DataLeafNode*>(root.get());
+      EXPECT_EQ(nodeStore->layout().maxBytesPerLeaf(), leaf->numBytes());
+    }
+  }
+};
+constexpr DataNodeLayout DataTreeTest_ResizeNumBytes::LAYOUT;
+
+class DataTreeTest_ResizeNumBytes_P: public DataTreeTest_ResizeNumBytes, public WithParamInterface<tuple<function<unique_ref<DataTree>(DataTreeTest_ResizeNumBytes*, uint32_t)>, uint32_t, uint32_t, uint32_t>> {
+public:
+  DataTreeTest_ResizeNumBytes_P()
+    : oldLastLeafSize(get<1>(GetParam())),
+      tree(get<0>(GetParam())(this, oldLastLeafSize)),
+      newNumberOfLeaves(get<2>(GetParam())),
+      newLastLeafSize(get<3>(GetParam())),
+      newSize((newNumberOfLeaves-1) * LAYOUT.maxBytesPerLeaf() + newLastLeafSize),
+      ZEROES(LAYOUT.maxBytesPerLeaf())
+  {
+    ZEROES.FillWithZeroes();
+  }
+
+  void ResizeTree(const Key &key, uint64_t size) {
+    treeStore.load(key).get()->resizeNumBytes(size);
+  }
+
+  unique_ref<DataLeafNode> LastLeaf(const Key &key) {
+    auto root = nodeStore->load(key).value();
+    auto leaf = dynamic_pointer_move<DataLeafNode>(root);
+    if (leaf != none) {
+      return std::move(*leaf);
+    }
+    auto inner = dynamic_pointer_move<DataInnerNode>(root).value();
+    return LastLeaf(inner->LastChild()->key());
+  }
+
+  uint32_t oldLastLeafSize;
+  unique_ref<DataTree> tree;
+  uint32_t newNumberOfLeaves;
+  uint32_t newLastLeafSize;
+  uint64_t newSize;
+  Data ZEROES;
+};
+INSTANTIATE_TEST_CASE_P(DataTreeTest_ResizeNumBytes_P, DataTreeTest_ResizeNumBytes_P,
+  Combine(
+    //Tree we're starting with
+    Values<function<unique_ref<DataTree>(DataTreeTest_ResizeNumBytes*, uint32_t)>>(
+      mem_fn(&DataTreeTest_ResizeNumBytes::CreateLeafTreeWithSize),
+      mem_fn(&DataTreeTest_ResizeNumBytes::CreateTwoLeafTreeWithSecondLeafSize),
+      mem_fn(&DataTreeTest_ResizeNumBytes::CreateFullTwoLevelTreeWithLastLeafSize),
+      mem_fn(&DataTreeTest_ResizeNumBytes::CreateThreeLevelTreeWithTwoChildrenAndLastLeafSize),
+      mem_fn(&DataTreeTest_ResizeNumBytes::CreateThreeLevelTreeWithThreeChildrenAndLastLeafSize),
+      mem_fn(&DataTreeTest_ResizeNumBytes::CreateFullThreeLevelTreeWithLastLeafSize),
+      mem_fn(&DataTreeTest_ResizeNumBytes::CreateFourLevelMinDataTreeWithLastLeafSize)
+    ),
+    //Last leaf size of the start tree
+    Values(
+      0u,
+      1u,
+      10u,
+      DataTreeTest_ResizeNumBytes::LAYOUT.maxBytesPerLeaf()
+    ),
+    //Number of leaves we're resizing to
+    Values(
+      1u,
+      2u,
+      DataTreeTest_ResizeNumBytes::LAYOUT.maxChildrenPerInnerNode(),  //Full two level tree
+      2* DataTreeTest_ResizeNumBytes::LAYOUT.maxChildrenPerInnerNode(), //Three level tree with two children
+      3* DataTreeTest_ResizeNumBytes::LAYOUT.maxChildrenPerInnerNode(), //Three level tree with three children
+      DataTreeTest_ResizeNumBytes::LAYOUT.maxChildrenPerInnerNode() * DataTreeTest_ResizeNumBytes::LAYOUT.maxChildrenPerInnerNode(), //Full three level tree
+      DataTreeTest_ResizeNumBytes::LAYOUT.maxChildrenPerInnerNode() * DataTreeTest_ResizeNumBytes::LAYOUT.maxChildrenPerInnerNode() + 1 //Four level mindata tree
+    ),
+    //Last leaf size of the resized tree
+    Values(
+      1u,
+      10u,
+      DataTreeTest_ResizeNumBytes::LAYOUT.maxBytesPerLeaf()
+    )
+  )
+);
+
+TEST_P(DataTreeTest_ResizeNumBytes_P, StructureIsValid) {
+  tree->resizeNumBytes(newSize);
+  tree->flush();
+  EXPECT_IS_LEFTMAXDATA_TREE(tree->key());
+}
+
+TEST_P(DataTreeTest_ResizeNumBytes_P, NumBytesIsCorrect) {
+  tree->resizeNumBytes(newSize);
+  tree->flush();
+  // tree->numStoredBytes() only goes down the right border nodes and expects the tree to be a left max data tree.
+  // This is what the StructureIsValid test case is for.
+  EXPECT_EQ(newSize, tree->numStoredBytes());
+}
+
+TEST_P(DataTreeTest_ResizeNumBytes_P, DepthFlagsAreCorrect) {
+  tree->resizeNumBytes(newSize);
+  tree->flush();
+  uint32_t depth = ceil(log(newNumberOfLeaves)/log(DataTreeTest_ResizeNumBytes::LAYOUT.maxChildrenPerInnerNode()));
+  CHECK_DEPTH(depth, tree->key());
+}
+
+TEST_P(DataTreeTest_ResizeNumBytes_P, KeyDoesntChange) {
+  Key key = tree->key();
+  tree->flush();
+  tree->resizeNumBytes(newSize);
+  EXPECT_EQ(key, tree->key());
+}
+
+TEST_P(DataTreeTest_ResizeNumBytes_P, DataStaysIntact) {
+  uint32_t oldNumberOfLeaves = std::max(UINT64_C(1), ceilDivision(tree->numStoredBytes(), (uint64_t)nodeStore->layout().maxBytesPerLeaf()));
+  TwoLevelDataFixture data(nodeStore, TwoLevelDataFixture::SizePolicy::Unchanged);
+  Key key = tree->key();
+  cpputils::destruct(std::move(tree));
+  data.FillInto(nodeStore->load(key).get().get());
+
+  ResizeTree(key, newSize);
+
+  if (oldNumberOfLeaves < newNumberOfLeaves || (oldNumberOfLeaves == newNumberOfLeaves && oldLastLeafSize < newLastLeafSize)) {
+    data.EXPECT_DATA_CORRECT(nodeStore->load(key).get().get(), oldNumberOfLeaves, oldLastLeafSize);
+  } else {
+    data.EXPECT_DATA_CORRECT(nodeStore->load(key).get().get(), newNumberOfLeaves, newLastLeafSize);
+  }
+}
+
+//Resize to zero is not caught in the parametrized test above, in the following, we test it separately.
+
+TEST_F(DataTreeTest_ResizeNumBytes, ResizeToZero_NumBytesIsCorrect) {
+  auto tree = CreateThreeLevelTreeWithThreeChildrenAndLastLeafSize(10u);
+  tree->resizeNumBytes(0);
+  Key key = tree->key();
+  cpputils::destruct(std::move(tree));
+  auto leaf = LoadLeafNode(key);
+  EXPECT_EQ(0u, leaf->numBytes());
+}
+
+TEST_F(DataTreeTest_ResizeNumBytes, ResizeToZero_KeyDoesntChange) {
+  auto tree = CreateThreeLevelTreeWithThreeChildrenAndLastLeafSize(10u);
+  Key key = tree->key();
+  tree->resizeNumBytes(0);
+  tree->flush();
+  EXPECT_EQ(key, tree->key());
+}

test/blobstore/implementations/onblocks/datatreestore/DataTreeTest_TraverseLeaves.cpp

@@ -0,0 +1,386 @@
+#include "testutils/DataTreeTest.h"
+#include <google/gmock/gmock.h>
+
+using ::testing::_;
+
+using blobstore::onblocks::datanodestore::DataLeafNode;
+using blobstore::onblocks::datanodestore::DataInnerNode;
+using blobstore::onblocks::datanodestore::DataNode;
+using blobstore::onblocks::datatreestore::DataTree;
+using blockstore::Key;
+
+using cpputils::unique_ref;
+
+class TraversorMock {
+public:
+  MOCK_METHOD2(called, void(DataLeafNode*, uint32_t));
+};
+
+MATCHER_P(KeyEq, expected, "node key equals") {
+  return arg->key() == expected;
+}
+
+class DataTreeTest_TraverseLeaves: public DataTreeTest {
+public:
+  DataTreeTest_TraverseLeaves() :traversor() {}
+
+  unique_ref<DataInnerNode> CreateThreeLevel() {
+    return CreateInner({
+      CreateFullTwoLevel(),
+      CreateFullTwoLevel(),
+      CreateFullTwoLevel(),
+      CreateFullTwoLevel(),
+      CreateFullTwoLevel(),
+      CreateInner({CreateLeaf(), CreateLeaf(), CreateLeaf()})});
+  }
+
+  unique_ref<DataInnerNode> CreateFourLevel() {
+    return CreateInner({
+      CreateFullThreeLevel(),
+      CreateFullThreeLevel(),
+      CreateInner({CreateFullTwoLevel(), CreateInner({CreateLeaf()})})
+    });
+  }
+
+  void EXPECT_TRAVERSE_LEAF(const Key &key, uint32_t leafIndex) {
+    EXPECT_CALL(traversor, called(KeyEq(key), leafIndex)).Times(1);
+  }
+
+  void EXPECT_TRAVERSE_ALL_CHILDREN_OF(const DataInnerNode &node, uint32_t firstLeafIndex) {
+    for (unsigned int i = 0; i < node.numChildren(); ++i) {
+      EXPECT_TRAVERSE_LEAF(node.getChild(i)->key(), firstLeafIndex+i);
+    }
+  }
+
+  void EXPECT_DONT_TRAVERSE_ANY_LEAVES() {
+    EXPECT_CALL(traversor, called(_, _)).Times(0);
+  }
+
+  void TraverseLeaves(DataNode *root, uint32_t beginIndex, uint32_t endIndex) {
+    root->flush();
+    auto tree = treeStore.load(root->key()).value();
+    tree->traverseLeaves(beginIndex, endIndex, [this] (DataLeafNode *leaf, uint32_t nodeIndex) {
+      traversor.called(leaf, nodeIndex);
+    });
+  }
+
+  TraversorMock traversor;
+};
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseSingleLeafTree) {
+  auto root = CreateLeaf();
+  EXPECT_TRAVERSE_LEAF(root->key(), 0);
+
+  TraverseLeaves(root.get(), 0, 1);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseNothingInSingleLeafTree1) {
+  auto root = CreateLeaf();
+  EXPECT_DONT_TRAVERSE_ANY_LEAVES();
+
+  TraverseLeaves(root.get(), 0, 0);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseNothingInSingleLeafTree2) {
+  auto root = CreateLeaf();
+  EXPECT_DONT_TRAVERSE_ANY_LEAVES();
+
+  TraverseLeaves(root.get(), 1, 1);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseFirstLeafOfFullTwolevelTree) {
+  auto root = CreateFullTwoLevel();
+  EXPECT_TRAVERSE_LEAF(root->getChild(0)->key(), 0);
+
+  TraverseLeaves(root.get(), 0, 1);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseMiddleLeafOfFullTwolevelTree) {
+  auto root = CreateFullTwoLevel();
+  EXPECT_TRAVERSE_LEAF(root->getChild(5)->key(), 5);
+
+  TraverseLeaves(root.get(), 5, 6);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseLastLeafOfFullTwolevelTree) {
+  auto root = CreateFullTwoLevel();
+  EXPECT_TRAVERSE_LEAF(root->getChild(nodeStore->layout().maxChildrenPerInnerNode()-1)->key(), nodeStore->layout().maxChildrenPerInnerNode()-1);
+
+  TraverseLeaves(root.get(), nodeStore->layout().maxChildrenPerInnerNode()-1, nodeStore->layout().maxChildrenPerInnerNode());
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseNothingInFullTwolevelTree1) {
+  auto root = CreateFullTwoLevel();
+  EXPECT_DONT_TRAVERSE_ANY_LEAVES();
+
+  TraverseLeaves(root.get(), 0, 0);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseNothingInFullTwolevelTree2) {
+  auto root = CreateFullTwoLevel();
+  EXPECT_DONT_TRAVERSE_ANY_LEAVES();
+
+  TraverseLeaves(root.get(), nodeStore->layout().maxChildrenPerInnerNode(), nodeStore->layout().maxChildrenPerInnerNode());
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseFirstLeafOfThreeLevelMinDataTree) {
+  auto root = CreateThreeLevelMinData();
+  EXPECT_TRAVERSE_LEAF(LoadInnerNode(root->getChild(0)->key())->getChild(0)->key(), 0);
+
+  TraverseLeaves(root.get(), 0, 1);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseMiddleLeafOfThreeLevelMinDataTree) {
+  auto root = CreateThreeLevelMinData();
+  EXPECT_TRAVERSE_LEAF(LoadInnerNode(root->getChild(0)->key())->getChild(5)->key(), 5);
+
+  TraverseLeaves(root.get(), 5, 6);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseLastLeafOfThreeLevelMinDataTree) {
+  auto root = CreateThreeLevelMinData();
+  EXPECT_TRAVERSE_LEAF(LoadInnerNode(root->getChild(1)->key())->getChild(0)->key(), nodeStore->layout().maxChildrenPerInnerNode());
+
+  TraverseLeaves(root.get(), nodeStore->layout().maxChildrenPerInnerNode(), nodeStore->layout().maxChildrenPerInnerNode()+1);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseAllLeavesOfFullTwolevelTree) {
+  auto root = CreateFullTwoLevel();
+  EXPECT_TRAVERSE_ALL_CHILDREN_OF(*root, 0);
+
+  TraverseLeaves(root.get(), 0, nodeStore->layout().maxChildrenPerInnerNode());
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseAllLeavesOfThreelevelMinDataTree) {
+  auto root = CreateThreeLevelMinData();
+  EXPECT_TRAVERSE_ALL_CHILDREN_OF(*LoadInnerNode(root->getChild(0)->key()), 0);
+  EXPECT_TRAVERSE_LEAF(LoadInnerNode(root->getChild(1)->key())->getChild(0)->key(), nodeStore->layout().maxChildrenPerInnerNode());
+
+  TraverseLeaves(root.get(), 0, nodeStore->layout().maxChildrenPerInnerNode()+1);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseFirstChildOfThreelevelMinDataTree) {
+  auto root = CreateThreeLevelMinData();
+  EXPECT_TRAVERSE_ALL_CHILDREN_OF(*LoadInnerNode(root->getChild(0)->key()), 0);
+
+  TraverseLeaves(root.get(), 0, nodeStore->layout().maxChildrenPerInnerNode());
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseFirstPartOfFullTwolevelTree) {
+  auto root = CreateFullTwoLevel();
+  for (unsigned int i = 0; i < 5; ++i) {
+    EXPECT_TRAVERSE_LEAF(root->getChild(i)->key(), i);
+  }
+
+  TraverseLeaves(root.get(), 0, 5);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseInnerPartOfFullTwolevelTree) {
+  auto root = CreateFullTwoLevel();
+  for (unsigned int i = 5; i < 10; ++i) {
+    EXPECT_TRAVERSE_LEAF(root->getChild(i)->key(), i);
+  }
+
+  TraverseLeaves(root.get(), 5, 10);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseLastPartOfFullTwolevelTree) {
+  auto root = CreateFullTwoLevel();
+  for (unsigned int i = 5; i < nodeStore->layout().maxChildrenPerInnerNode(); ++i) {
+    EXPECT_TRAVERSE_LEAF(root->getChild(i)->key(), i);
+  }
+
+  TraverseLeaves(root.get(), 5, nodeStore->layout().maxChildrenPerInnerNode());
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseFirstPartOfThreelevelMinDataTree) {
+  auto root = CreateThreeLevelMinData();
+  auto node = LoadInnerNode(root->getChild(0)->key());
+  for (unsigned int i = 0; i < 5; ++i) {
+    EXPECT_TRAVERSE_LEAF(node->getChild(i)->key(), i);
+  }
+
+  TraverseLeaves(root.get(), 0, 5);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseInnerPartOfThreelevelMinDataTree) {
+  auto root = CreateThreeLevelMinData();
+  auto node = LoadInnerNode(root->getChild(0)->key());
+  for (unsigned int i = 5; i < 10; ++i) {
+    EXPECT_TRAVERSE_LEAF(node->getChild(i)->key(), i);
+  }
+
+  TraverseLeaves(root.get(), 5, 10);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseLastPartOfThreelevelMinDataTree) {
+  auto root = CreateThreeLevelMinData();
+  auto node = LoadInnerNode(root->getChild(0)->key());
+  for (unsigned int i = 5; i < nodeStore->layout().maxChildrenPerInnerNode(); ++i) {
+    EXPECT_TRAVERSE_LEAF(node->getChild(i)->key(), i);
+  }
+  EXPECT_TRAVERSE_LEAF(LoadInnerNode(root->getChild(1)->key())->getChild(0)->key(), nodeStore->layout().maxChildrenPerInnerNode());
+
+  TraverseLeaves(root.get(), 5, nodeStore->layout().maxChildrenPerInnerNode()+1);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseFirstLeafOfThreelevelTree) {
+  auto root = CreateThreeLevel();
+  EXPECT_TRAVERSE_LEAF(LoadInnerNode(root->getChild(0)->key())->getChild(0)->key(), 0);
+
+  TraverseLeaves(root.get(), 0, 1);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseLastLeafOfThreelevelTree) {
+  auto root = CreateThreeLevel();
+  uint32_t numLeaves = nodeStore->layout().maxChildrenPerInnerNode() * 5 + 3;
+  EXPECT_TRAVERSE_LEAF(LoadInnerNode(root->LastChild()->key())->LastChild()->key(), numLeaves-1);
+
+  TraverseLeaves(root.get(), numLeaves-1, numLeaves);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseMiddleLeafOfThreelevelTree) {
+  auto root = CreateThreeLevel();
+  uint32_t wantedLeafIndex = nodeStore->layout().maxChildrenPerInnerNode() * 2 + 5;
+  EXPECT_TRAVERSE_LEAF(LoadInnerNode(root->getChild(2)->key())->getChild(5)->key(), wantedLeafIndex);
+
+  TraverseLeaves(root.get(), wantedLeafIndex, wantedLeafIndex+1);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseFirstPartOfThreelevelTree) {
+  auto root = CreateThreeLevel();
+  //Traverse all leaves in the first two children of the root
+  for(unsigned int i = 0; i < 2; ++i) {
+    EXPECT_TRAVERSE_ALL_CHILDREN_OF(*LoadInnerNode(root->getChild(i)->key()), i * nodeStore->layout().maxChildrenPerInnerNode());
+  }
+  //Traverse some of the leaves in the third child of the root
+  auto child = LoadInnerNode(root->getChild(2)->key());
+  for(unsigned int i = 0; i < 5; ++i) {
+    EXPECT_TRAVERSE_LEAF(child->getChild(i)->key(), 2 * nodeStore->layout().maxChildrenPerInnerNode() + i);
+  }
+
+  TraverseLeaves(root.get(), 0, 2 * nodeStore->layout().maxChildrenPerInnerNode() + 5);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseMiddlePartOfThreelevelTree_OnlyFullChildren) {
+  auto root = CreateThreeLevel();
+  //Traverse some of the leaves in the second child of the root
+  auto child = LoadInnerNode(root->getChild(1)->key());
+  for(unsigned int i = 5; i < nodeStore->layout().maxChildrenPerInnerNode(); ++i) {
+    EXPECT_TRAVERSE_LEAF(child->getChild(i)->key(), nodeStore->layout().maxChildrenPerInnerNode() + i);
+  }
+  //Traverse all leaves in the third and fourth child of the root
+  for(unsigned int i = 2; i < 4; ++i) {
+    EXPECT_TRAVERSE_ALL_CHILDREN_OF(*LoadInnerNode(root->getChild(i)->key()), i * nodeStore->layout().maxChildrenPerInnerNode());
+  }
+  //Traverse some of the leaves in the fifth child of the root
+  child = LoadInnerNode(root->getChild(4)->key());
+  for(unsigned int i = 0; i < 5; ++i) {
+    EXPECT_TRAVERSE_LEAF(child->getChild(i)->key(), 4 * nodeStore->layout().maxChildrenPerInnerNode() + i);
+  }
+
+  TraverseLeaves(root.get(), nodeStore->layout().maxChildrenPerInnerNode() + 5, 4 * nodeStore->layout().maxChildrenPerInnerNode() + 5);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseMiddlePartOfThreelevelTree_AlsoLastNonfullChild) {
+  auto root = CreateThreeLevel();
+  //Traverse some of the leaves in the second child of the root
+  auto child = LoadInnerNode(root->getChild(1)->key());
+  for(unsigned int i = 5; i < nodeStore->layout().maxChildrenPerInnerNode(); ++i) {
+    EXPECT_TRAVERSE_LEAF(child->getChild(i)->key(), nodeStore->layout().maxChildrenPerInnerNode() + i);
+  }
+  //Traverse all leaves in the third, fourth and fifth child of the root
+  for(unsigned int i = 2; i < 5; ++i) {
+    EXPECT_TRAVERSE_ALL_CHILDREN_OF(*LoadInnerNode(root->getChild(i)->key()), i * nodeStore->layout().maxChildrenPerInnerNode());
+  }
+  //Traverse some of the leaves in the sixth child of the root
+  child = LoadInnerNode(root->getChild(5)->key());
+  for(unsigned int i = 0; i < 2; ++i) {
+    EXPECT_TRAVERSE_LEAF(child->getChild(i)->key(), 5 * nodeStore->layout().maxChildrenPerInnerNode() + i);
+  }
+
+  TraverseLeaves(root.get(), nodeStore->layout().maxChildrenPerInnerNode() + 5, 5 * nodeStore->layout().maxChildrenPerInnerNode() + 2);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseLastPartOfThreelevelTree) {
+  auto root = CreateThreeLevel();
+  //Traverse some of the leaves in the second child of the root
+  auto child = LoadInnerNode(root->getChild(1)->key());
+  for(unsigned int i = 5; i < nodeStore->layout().maxChildrenPerInnerNode(); ++i) {
+    EXPECT_TRAVERSE_LEAF(child->getChild(i)->key(), nodeStore->layout().maxChildrenPerInnerNode() + i);
+  }
+  //Traverse all leaves in the third, fourth and fifth child of the root
+  for(unsigned int i = 2; i < 5; ++i) {
+    EXPECT_TRAVERSE_ALL_CHILDREN_OF(*LoadInnerNode(root->getChild(i)->key()), i * nodeStore->layout().maxChildrenPerInnerNode());
+  }
+  //Traverse all of the leaves in the sixth child of the root
+  child = LoadInnerNode(root->getChild(5)->key());
+  for(unsigned int i = 0; i < child->numChildren(); ++i) {
+    EXPECT_TRAVERSE_LEAF(child->getChild(i)->key(), 5 * nodeStore->layout().maxChildrenPerInnerNode() + i);
+  }
+
+  TraverseLeaves(root.get(), nodeStore->layout().maxChildrenPerInnerNode() + 5, 5 * nodeStore->layout().maxChildrenPerInnerNode() + child->numChildren());
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseAllLeavesOfThreelevelTree) {
+  auto root = CreateThreeLevel();
+  //Traverse all leaves in the third, fourth and fifth child of the root
+  for(unsigned int i = 0; i < 5; ++i) {
+    EXPECT_TRAVERSE_ALL_CHILDREN_OF(*LoadInnerNode(root->getChild(i)->key()), i * nodeStore->layout().maxChildrenPerInnerNode());
+  }
+  //Traverse all of the leaves in the sixth child of the root
+  auto child = LoadInnerNode(root->getChild(5)->key());
+  for(unsigned int i = 0; i < child->numChildren(); ++i) {
+    EXPECT_TRAVERSE_LEAF(child->getChild(i)->key(), 5 * nodeStore->layout().maxChildrenPerInnerNode() + i);
+  }
+
+  TraverseLeaves(root.get(), 0, 5 * nodeStore->layout().maxChildrenPerInnerNode() + child->numChildren());
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseAllLeavesOfFourLevelTree) {
+  auto root = CreateFourLevel();
+  //Traverse all leaves of the full threelevel tree in the first child
+  auto firstChild = LoadInnerNode(root->getChild(0)->key());
+  for(unsigned int i = 0; i < firstChild->numChildren(); ++i) {
+    EXPECT_TRAVERSE_ALL_CHILDREN_OF(*LoadInnerNode(firstChild->getChild(i)->key()), i * nodeStore->layout().maxChildrenPerInnerNode());
+  }
+  //Traverse all leaves of the full threelevel tree in the second child
+  auto secondChild = LoadInnerNode(root->getChild(1)->key());
+  for(unsigned int i = 0; i < secondChild->numChildren(); ++i) {
+    EXPECT_TRAVERSE_ALL_CHILDREN_OF(*LoadInnerNode(secondChild->getChild(i)->key()), (nodeStore->layout().maxChildrenPerInnerNode() + i) * nodeStore->layout().maxChildrenPerInnerNode());
+  }
+  //Traverse all leaves of the non-full threelevel tree in the third child
+  auto thirdChild = LoadInnerNode(root->getChild(2)->key());
+  EXPECT_TRAVERSE_ALL_CHILDREN_OF(*LoadInnerNode(thirdChild->getChild(0)->key()), 2 * nodeStore->layout().maxChildrenPerInnerNode() * nodeStore->layout().maxChildrenPerInnerNode());
+  EXPECT_TRAVERSE_LEAF(LoadInnerNode(thirdChild->getChild(1)->key())->getChild(0)->key(), 2 * nodeStore->layout().maxChildrenPerInnerNode() * nodeStore->layout().maxChildrenPerInnerNode() + nodeStore->layout().maxChildrenPerInnerNode());
+
+  TraverseLeaves(root.get(), 0, 2*nodeStore->layout().maxChildrenPerInnerNode()*nodeStore->layout().maxChildrenPerInnerNode() + nodeStore->layout().maxChildrenPerInnerNode() + 1);
+}
+
+TEST_F(DataTreeTest_TraverseLeaves, TraverseMiddlePartOfFourLevelTree) {
+  auto root = CreateFourLevel();
+  //Traverse some leaves of the full threelevel tree in the first child
+  auto firstChild = LoadInnerNode(root->getChild(0)->key());
+  auto secondChildOfFirstChild = LoadInnerNode(firstChild->getChild(1)->key());
+  for(unsigned int i = 5; i < secondChildOfFirstChild->numChildren(); ++i) {
+    EXPECT_TRAVERSE_LEAF(secondChildOfFirstChild->getChild(i)->key(), nodeStore->layout().maxChildrenPerInnerNode()+i);
+  }
+  for(unsigned int i = 2; i < firstChild->numChildren(); ++i) {
+    EXPECT_TRAVERSE_ALL_CHILDREN_OF(*LoadInnerNode(firstChild->getChild(i)->key()), i * nodeStore->layout().maxChildrenPerInnerNode());
+  }
+  //Traverse all leaves of the full threelevel tree in the second child
+  auto secondChild = LoadInnerNode(root->getChild(1)->key());
+  for(unsigned int i = 0; i < secondChild->numChildren(); ++i) {
+    EXPECT_TRAVERSE_ALL_CHILDREN_OF(*LoadInnerNode(secondChild->getChild(i)->key()), (nodeStore->layout().maxChildrenPerInnerNode() + i) * nodeStore->layout().maxChildrenPerInnerNode());
+  }
+  //Traverse some leaves of the non-full threelevel tree in the third child
+  auto thirdChild = LoadInnerNode(root->getChild(2)->key());
+  auto firstChildOfThirdChild = LoadInnerNode(thirdChild->getChild(0)->key());
+  for(unsigned int i = 0; i < firstChildOfThirdChild->numChildren()-1; ++i) {
+    EXPECT_TRAVERSE_LEAF(firstChildOfThirdChild->getChild(i)->key(), 2 * nodeStore->layout().maxChildrenPerInnerNode()*nodeStore->layout().maxChildrenPerInnerNode()+i);
+  }
+
+  TraverseLeaves(root.get(), nodeStore->layout().maxChildrenPerInnerNode()+5, 2*nodeStore->layout().maxChildrenPerInnerNode()*nodeStore->layout().maxChildrenPerInnerNode() + nodeStore->layout().maxChildrenPerInnerNode() -1);
+}
+
+//TODO Refactor the test cases that are too long

test/blobstore/implementations/onblocks/datatreestore/impl/GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNullTest.cpp

@@ -0,0 +1,93 @@
+#include "google/gtest/gtest.h"
+
+#include "../testutils/DataTreeTest.h"
+#include "../../../../../implementations/onblocks/datatreestore/DataTree.h"
+#include "../../../../../implementations/onblocks/datanodestore/DataLeafNode.h"
+#include "../../../../../implementations/onblocks/datanodestore/DataInnerNode.h"
+#include "messmer/blockstore/implementations/testfake/FakeBlockStore.h"
+#include "../../../../../implementations/onblocks/datatreestore/impl/algorithms.h"
+
+using ::testing::Test;
+using std::pair;
+using std::make_pair;
+
+using blobstore::onblocks::datanodestore::DataNodeStore;
+using blobstore::onblocks::datanodestore::DataNode;
+using blobstore::onblocks::datanodestore::DataInnerNode;
+using blockstore::testfake::FakeBlockStore;
+using blockstore::Key;
+using namespace blobstore::onblocks::datatreestore::algorithms;
+
+class GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNullTest: public DataTreeTest {
+public:
+  struct TestData {
+    Key rootNode;
+    Key expectedResult;
+  };
+
+  void check(const TestData &testData) {
+    auto root = nodeStore->load(testData.rootNode).value();
+    auto result = GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNull(nodeStore, root.get());
+    EXPECT_EQ(testData.expectedResult, result->key());
+  }
+
+  TestData CreateTwoRightBorderNodes() {
+    auto node = CreateInner({CreateLeaf()});
+    return TestData{node->key(), node->key()};
+  }
+
+  TestData CreateThreeRightBorderNodes() {
+    auto node = CreateInner({CreateLeaf()});
+    auto root = CreateInner({node.get()});
+    return TestData{root->key(), node->key()};
+  }
+
+  TestData CreateThreeRightBorderNodes_LastFull() {
+    auto root = CreateInner({CreateFullTwoLevel()});
+    return TestData{root->key(), root->key()};
+  }
+
+  TestData CreateLargerTree() {
+    auto node = CreateInner({CreateLeaf(), CreateLeaf()});
+    auto root = CreateInner({CreateFullTwoLevel().get(), node.get()});
+    return TestData{root->key(), node->key()};
+  }
+};
+
+TEST_F(GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNullTest, Leaf) {
+  auto leaf = nodeStore->createNewLeafNode();
+  auto result = GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNull(nodeStore, leaf.get());
+  EXPECT_EQ(nullptr, result.get());
+}
+
+TEST_F(GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNullTest, TwoRightBorderNodes) {
+  auto testData = CreateTwoRightBorderNodes();
+  check(testData);
+}
+
+TEST_F(GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNullTest, ThreeRightBorderNodes) {
+  auto testData = CreateThreeRightBorderNodes();
+  check(testData);
+}
+
+TEST_F(GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNullTest, ThreeRightBorderNodes_LastFull) {
+  auto testData = CreateThreeRightBorderNodes_LastFull();
+  check(testData);
+}
+
+TEST_F(GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNullTest, LargerTree) {
+  auto testData = CreateLargerTree();
+  check(testData);
+}
+
+TEST_F(GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNullTest, FullTwoLevelTree) {
+  auto root = CreateFullTwoLevel();
+  auto result = GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNull(nodeStore, root.get());
+  EXPECT_EQ(nullptr, result.get());
+}
+
+TEST_F(GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNullTest, FullThreeLevelTree) {
+  auto root = CreateFullThreeLevel();
+  auto result = GetLowestInnerRightBorderNodeWithLessThanKChildrenOrNull(nodeStore, root.get());
+  EXPECT_EQ(nullptr, result.get());
+}

test/blobstore/implementations/onblocks/datatreestore/impl/GetLowestRightBorderNodeWithMoreThanOneChildOrNullTest.cpp

@@ -0,0 +1,126 @@
+#include "google/gtest/gtest.h"
+
+#include "../testutils/DataTreeTest.h"
+#include "../../../../../implementations/onblocks/datatreestore/DataTree.h"
+#include "../../../../../implementations/onblocks/datanodestore/DataLeafNode.h"
+#include "../../../../../implementations/onblocks/datanodestore/DataInnerNode.h"
+#include "messmer/blockstore/implementations/testfake/FakeBlockStore.h"
+#include "../../../../../implementations/onblocks/datatreestore/impl/algorithms.h"
+
+using ::testing::Test;
+using std::pair;
+using std::make_pair;
+
+using blobstore::onblocks::datanodestore::DataNodeStore;
+using blobstore::onblocks::datanodestore::DataNode;
+using blobstore::onblocks::datanodestore::DataInnerNode;
+using blockstore::testfake::FakeBlockStore;
+using blockstore::Key;
+using namespace blobstore::onblocks::datatreestore::algorithms;
+
+class GetLowestRightBorderNodeWithMoreThanOneChildOrNullTest: public DataTreeTest {
+public:
+  struct TestData {
+    Key rootNode;
+    Key expectedResult;
+  };
+
+  void check(const TestData &testData) {
+    auto root = nodeStore->load(testData.rootNode).value();
+    auto result = GetLowestRightBorderNodeWithMoreThanOneChildOrNull(nodeStore, root.get());
+    EXPECT_EQ(testData.expectedResult, result->key());
+  }
+
+  Key CreateLeafOnlyTree() {
+    return CreateLeaf()->key();
+  }
+
+  Key CreateTwoRightBorderNodes() {
+    return CreateInner({CreateLeaf()})->key();
+  }
+
+  Key CreateThreeRightBorderNodes() {
+    return CreateInner({CreateInner({CreateLeaf()})})->key();
+  }
+
+  TestData CreateThreeRightBorderNodes_LastFull() {
+    auto node = CreateFullTwoLevel();
+    auto root = CreateInner({node.get()});
+    return TestData{root->key(), node->key()};
+  }
+
+  TestData CreateLargerTree() {
+    auto node = CreateInner({CreateLeaf(), CreateLeaf()});
+    auto root = CreateInner({CreateFullTwoLevel().get(), node.get()});
+    return TestData{root->key(), node->key()};
+  }
+
+  TestData CreateThreeLevelTreeWithRightBorderSingleNodeChain() {
+    auto root = CreateInner({CreateFullTwoLevel(), CreateInner({CreateLeaf()})});
+    return TestData{root->key(), root->key()};
+  }
+
+  TestData CreateThreeLevelTree() {
+    auto node = CreateInner({CreateLeaf(), CreateLeaf()});
+    auto root = CreateInner({CreateFullTwoLevel().get(), node.get()});
+    return TestData{root->key(), node->key()};
+  }
+
+  TestData CreateFullTwoLevelTree() {
+    auto node = CreateFullTwoLevel();
+    return TestData{node->key(), node->key()};
+  }
+
+  TestData CreateFullThreeLevelTree() {
+    auto root = CreateFullThreeLevel();
+    return TestData{root->key(), root->LastChild()->key()};
+  }
+};
+
+TEST_F(GetLowestRightBorderNodeWithMoreThanOneChildOrNullTest, Leaf) {
+  auto leaf = nodeStore->load(CreateLeafOnlyTree()).value();
+  auto result = GetLowestRightBorderNodeWithMoreThanOneChildOrNull(nodeStore, leaf.get());
+  EXPECT_EQ(nullptr, result.get());
+}
+
+TEST_F(GetLowestRightBorderNodeWithMoreThanOneChildOrNullTest, TwoRightBorderNodes) {
+  auto node = nodeStore->load(CreateTwoRightBorderNodes()).value();
+  auto result = GetLowestRightBorderNodeWithMoreThanOneChildOrNull(nodeStore, node.get());
+  EXPECT_EQ(nullptr, result.get());
+}
+
+TEST_F(GetLowestRightBorderNodeWithMoreThanOneChildOrNullTest, ThreeRightBorderNodes) {
+  auto node = nodeStore->load(CreateThreeRightBorderNodes()).value();
+  auto result = GetLowestRightBorderNodeWithMoreThanOneChildOrNull(nodeStore, node.get());
+  EXPECT_EQ(nullptr, result.get());
+}
+
+TEST_F(GetLowestRightBorderNodeWithMoreThanOneChildOrNullTest, ThreeRightBorderNodes_LastFull) {
+  auto testData = CreateThreeRightBorderNodes_LastFull();
+  check(testData);
+}
+
+TEST_F(GetLowestRightBorderNodeWithMoreThanOneChildOrNullTest, LargerTree) {
+  auto testData = CreateLargerTree();
+  check(testData);
+}
+
+TEST_F(GetLowestRightBorderNodeWithMoreThanOneChildOrNullTest, FullTwoLevelTree) {
+  auto testData = CreateFullTwoLevelTree();
+  check(testData);
+}
+
+TEST_F(GetLowestRightBorderNodeWithMoreThanOneChildOrNullTest, FullThreeLevelTree) {
+  auto testData = CreateFullThreeLevelTree();
+  check(testData);
+}
+
+TEST_F(GetLowestRightBorderNodeWithMoreThanOneChildOrNullTest, ThreeLevelTreeWithRightBorderSingleNodeChain) {
+  auto testData = CreateThreeLevelTreeWithRightBorderSingleNodeChain();
+  check(testData);
+}
+
+TEST_F(GetLowestRightBorderNodeWithMoreThanOneChildOrNullTest, ThreeLevelTree) {
+  auto testData = CreateThreeLevelTree();
+  check(testData);
+}

test/blobstore/implementations/onblocks/datatreestore/testutils/DataTreeTest.cpp

@@ -0,0 +1,235 @@
+#include "DataTreeTest.h"
+
+#include "messmer/blockstore/implementations/testfake/FakeBlockStore.h"
+#include <messmer/cpp-utils/pointer/cast.h>
+#include <messmer/cpp-utils/pointer/unique_ref_boost_optional_gtest_workaround.h>
+
+using blobstore::onblocks::datanodestore::DataNodeStore;
+using blobstore::onblocks::datanodestore::DataNode;
+using blobstore::onblocks::datanodestore::DataInnerNode;
+using blobstore::onblocks::datanodestore::DataLeafNode;
+using blobstore::onblocks::datatreestore::DataTree;
+using blockstore::testfake::FakeBlockStore;
+using blockstore::Key;
+using cpputils::unique_ref;
+using cpputils::make_unique_ref;
+using std::initializer_list;
+using std::vector;
+using boost::none;
+using cpputils::dynamic_pointer_move;
+
+constexpr uint32_t DataTreeTest::BLOCKSIZE_BYTES;
+
+DataTreeTest::DataTreeTest()
+  :_nodeStore(make_unique_ref<DataNodeStore>(make_unique_ref<FakeBlockStore>(), BLOCKSIZE_BYTES)),
+   nodeStore(_nodeStore.get()),
+   treeStore(std::move(_nodeStore)) {
+}
+
+unique_ref<DataLeafNode> DataTreeTest::CreateLeaf() {
+  return nodeStore->createNewLeafNode();
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateInner(initializer_list<unique_ref<DataNode>> children) {
+  vector<const DataNode*> childrenVector(children.size());
+  std::transform(children.begin(), children.end(), childrenVector.begin(), [](const unique_ref<DataNode> &ptr) {return ptr.get();});
+  return CreateInner(childrenVector);
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateInner(initializer_list<const DataNode*> children) {
+  return CreateInner(vector<const DataNode*>(children));
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateInner(vector<const DataNode*> children) {
+  ASSERT(children.size() >= 1, "An inner node must have at least one child");
+  auto node = nodeStore->createNewInnerNode(**children.begin());
+  for(auto child = children.begin()+1; child != children.end(); ++child) {
+    node->addChild(**child);
+  }
+  return node;
+}
+
+unique_ref<DataTree> DataTreeTest::CreateLeafOnlyTree() {
+  auto key = CreateLeaf()->key();
+  return treeStore.load(key).value();
+}
+
+void DataTreeTest::FillNode(DataInnerNode *node) {
+  for(unsigned int i=node->numChildren(); i < nodeStore->layout().maxChildrenPerInnerNode(); ++i) {
+    node->addChild(*CreateLeaf());
+  }
+}
+
+void DataTreeTest::FillNodeTwoLevel(DataInnerNode *node) {
+  for(unsigned int i=node->numChildren(); i < nodeStore->layout().maxChildrenPerInnerNode(); ++i) {
+    node->addChild(*CreateFullTwoLevel());
+  }
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateFullTwoLevel() {
+  auto root = CreateInner({CreateLeaf().get()});
+  FillNode(root.get());
+  return root;
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateThreeLevelMinData() {
+  return CreateInner({
+    CreateFullTwoLevel(),
+    CreateInner({CreateLeaf()})
+  });
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateFourLevelMinData() {
+  return CreateInner({
+    CreateFullThreeLevel(),
+    CreateInner({CreateInner({CreateLeaf()})})
+  });
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateFullThreeLevel() {
+  auto root = CreateInner({CreateFullTwoLevel().get()});
+  FillNodeTwoLevel(root.get());
+  return root;
+}
+
+unique_ref<DataInnerNode> DataTreeTest::LoadInnerNode(const Key &key) {
+  auto node = nodeStore->load(key).value();
+  auto casted = dynamic_pointer_move<DataInnerNode>(node);
+  EXPECT_NE(none, casted) << "Is not an inner node";
+  return std::move(*casted);
+}
+
+unique_ref<DataLeafNode> DataTreeTest::LoadLeafNode(const Key &key) {
+  auto node = nodeStore->load(key).value();
+  auto casted =  dynamic_pointer_move<DataLeafNode>(node);
+  EXPECT_NE(none, casted) << "Is not a leaf node";
+  return std::move(*casted);
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateTwoLeaf() {
+  return CreateInner({CreateLeaf().get(), CreateLeaf().get()});
+}
+
+unique_ref<DataTree> DataTreeTest::CreateTwoLeafTree() {
+  auto key = CreateTwoLeaf()->key();
+  return treeStore.load(key).value();
+}
+
+unique_ref<DataLeafNode> DataTreeTest::CreateLeafWithSize(uint32_t size) {
+  auto leaf = CreateLeaf();
+  leaf->resize(size);
+  return leaf;
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateTwoLeafWithSecondLeafSize(uint32_t size) {
+  return CreateInner({
+    CreateLeafWithSize(nodeStore->layout().maxBytesPerLeaf()),
+    CreateLeafWithSize(size)
+  });
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateFullTwoLevelWithLastLeafSize(uint32_t size) {
+  auto root = CreateFullTwoLevel();
+  for (uint32_t i = 0; i < root->numChildren()-1; ++i) {
+    LoadLeafNode(root->getChild(i)->key())->resize(nodeStore->layout().maxBytesPerLeaf());
+  }
+  LoadLeafNode(root->LastChild()->key())->resize(size);
+  return root;
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateThreeLevelWithOneChildAndLastLeafSize(uint32_t size) {
+  return CreateInner({
+    CreateInner({
+      CreateLeafWithSize(nodeStore->layout().maxBytesPerLeaf()),
+      CreateLeafWithSize(size)
+    })
+  });
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateThreeLevelWithTwoChildrenAndLastLeafSize(uint32_t size) {
+  return CreateInner({
+    CreateFullTwoLevelWithLastLeafSize(nodeStore->layout().maxBytesPerLeaf()),
+    CreateInner({
+      CreateLeafWithSize(nodeStore->layout().maxBytesPerLeaf()),
+      CreateLeafWithSize(size)
+    })
+  });
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateThreeLevelWithThreeChildrenAndLastLeafSize(uint32_t size) {
+  return CreateInner({
+    CreateFullTwoLevelWithLastLeafSize(nodeStore->layout().maxBytesPerLeaf()),
+    CreateFullTwoLevelWithLastLeafSize(nodeStore->layout().maxBytesPerLeaf()),
+    CreateInner({
+      CreateLeafWithSize(nodeStore->layout().maxBytesPerLeaf()),
+      CreateLeafWithSize(size)
+    })
+  });
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateFullThreeLevelWithLastLeafSize(uint32_t size) {
+  auto root = CreateFullThreeLevel();
+  for (uint32_t i = 0; i < root->numChildren(); ++i) {
+    auto node = LoadInnerNode(root->getChild(i)->key());
+    for (uint32_t j = 0; j < node->numChildren(); ++j) {
+      LoadLeafNode(node->getChild(j)->key())->resize(nodeStore->layout().maxBytesPerLeaf());
+    }
+  }
+  LoadLeafNode(LoadInnerNode(root->LastChild()->key())->LastChild()->key())->resize(size);
+  return root;
+}
+
+unique_ref<DataInnerNode> DataTreeTest::CreateFourLevelMinDataWithLastLeafSize(uint32_t size) {
+  return CreateInner({
+    CreateFullThreeLevelWithLastLeafSize(nodeStore->layout().maxBytesPerLeaf()),
+    CreateInner({CreateInner({CreateLeafWithSize(size)})})
+  });
+}
+
+void DataTreeTest::EXPECT_IS_LEAF_NODE(const Key &key) {
+  auto node = LoadLeafNode(key);
+  EXPECT_NE(nullptr, node.get());
+}
+
+void DataTreeTest::EXPECT_IS_INNER_NODE(const Key &key) {
+  auto node = LoadInnerNode(key);
+  EXPECT_NE(nullptr, node.get());
+}
+
+void DataTreeTest::EXPECT_IS_TWONODE_CHAIN(const Key &key) {
+  auto node = LoadInnerNode(key);
+  EXPECT_EQ(1u, node->numChildren());
+  EXPECT_IS_LEAF_NODE(node->getChild(0)->key());
+}
+
+void DataTreeTest::EXPECT_IS_FULL_TWOLEVEL_TREE(const Key &key) {
+  auto node = LoadInnerNode(key);
+  EXPECT_EQ(nodeStore->layout().maxChildrenPerInnerNode(), node->numChildren());
+  for (unsigned int i = 0; i < node->numChildren(); ++i) {
+    EXPECT_IS_LEAF_NODE(node->getChild(i)->key());
+  }
+}
+
+void DataTreeTest::EXPECT_IS_FULL_THREELEVEL_TREE(const Key &key) {
+  auto root = LoadInnerNode(key);
+  EXPECT_EQ(nodeStore->layout().maxChildrenPerInnerNode(), root->numChildren());
+  for (unsigned int i = 0; i < root->numChildren(); ++i) {
+    auto node = LoadInnerNode(root->getChild(i)->key());
+    EXPECT_EQ(nodeStore->layout().maxChildrenPerInnerNode(), node->numChildren());
+    for (unsigned int j = 0; j < node->numChildren(); ++j) {
+      EXPECT_IS_LEAF_NODE(node->getChild(j)->key());
+    }
+  }
+}
+
+void DataTreeTest::CHECK_DEPTH(int depth, const Key &key) {
+  if (depth == 0) {
+    EXPECT_IS_LEAF_NODE(key);
+  } else {
+    auto node = LoadInnerNode(key);
+    EXPECT_EQ(depth, node->depth());
+    for (uint32_t i = 0; i < node->numChildren(); ++i) {
+      CHECK_DEPTH(depth-1, node->getChild(i)->key());
+    }
+  }
+}

test/blobstore/implementations/onblocks/datatreestore/testutils/DataTreeTest.h

@@ -0,0 +1,64 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_TEST_IMPLEMENTATIONS_ONBLOCKS_DATATREESTORE_DATATREETEST_H_
+#define MESSMER_BLOBSTORE_TEST_IMPLEMENTATIONS_ONBLOCKS_DATATREESTORE_DATATREETEST_H_
+
+#include "google/gtest/gtest.h"
+
+#include "../../../../../implementations/onblocks/datanodestore/DataNodeStore.h"
+#include "../../../../../implementations/onblocks/datanodestore/DataInnerNode.h"
+#include "../../../../../implementations/onblocks/datanodestore/DataLeafNode.h"
+#include "../../../../../implementations/onblocks/datatreestore/DataTree.h"
+#include "../../../../../implementations/onblocks/datatreestore/DataTreeStore.h"
+
+class DataTreeTest: public ::testing::Test {
+public:
+  DataTreeTest();
+
+  static constexpr uint32_t BLOCKSIZE_BYTES = 256;
+
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataLeafNode> CreateLeaf();
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateInner(std::vector<const blobstore::onblocks::datanodestore::DataNode *> children);
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateInner(std::initializer_list<const blobstore::onblocks::datanodestore::DataNode *> children);
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateInner(std::initializer_list<cpputils::unique_ref<blobstore::onblocks::datanodestore::DataNode>> children);
+
+  cpputils::unique_ref<blobstore::onblocks::datatreestore::DataTree> CreateLeafOnlyTree();
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateTwoLeaf();
+  cpputils::unique_ref<blobstore::onblocks::datatreestore::DataTree> CreateTwoLeafTree();
+  void FillNode(blobstore::onblocks::datanodestore::DataInnerNode *node);
+  void FillNodeTwoLevel(blobstore::onblocks::datanodestore::DataInnerNode *node);
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateFullTwoLevel();
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateFullThreeLevel();
+
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateThreeLevelMinData();
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateFourLevelMinData();
+
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> LoadInnerNode(const blockstore::Key &key);
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataLeafNode> LoadLeafNode(const blockstore::Key &key);
+
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataLeafNode> CreateLeafWithSize(uint32_t size);
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateTwoLeafWithSecondLeafSize(uint32_t size);
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateFullTwoLevelWithLastLeafSize(uint32_t size);
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateThreeLevelWithOneChildAndLastLeafSize(uint32_t size);
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateThreeLevelWithTwoChildrenAndLastLeafSize(uint32_t size);
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateThreeLevelWithThreeChildrenAndLastLeafSize(uint32_t size);
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateFullThreeLevelWithLastLeafSize(uint32_t size);
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataInnerNode> CreateFourLevelMinDataWithLastLeafSize(uint32_t size);
+
+  cpputils::unique_ref<blobstore::onblocks::datanodestore::DataNodeStore> _nodeStore;
+  blobstore::onblocks::datanodestore::DataNodeStore *nodeStore;
+  blobstore::onblocks::datatreestore::DataTreeStore treeStore;
+
+  void EXPECT_IS_LEAF_NODE(const blockstore::Key &key);
+  void EXPECT_IS_INNER_NODE(const blockstore::Key &key);
+  void EXPECT_IS_TWONODE_CHAIN(const blockstore::Key &key);
+  void EXPECT_IS_FULL_TWOLEVEL_TREE(const blockstore::Key &key);
+  void EXPECT_IS_FULL_THREELEVEL_TREE(const blockstore::Key &key);
+
+  void CHECK_DEPTH(int depth, const blockstore::Key &key);
+
+private:
+  DISALLOW_COPY_AND_ASSIGN(DataTreeTest);
+};
+
+
+#endif

test/blobstore/implementations/onblocks/datatreestore/testutils/LeafDataFixture.h

@@ -0,0 +1,40 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_TEST_IMPLEMENTATIONS_ONBLOCKS_DATATREESTORE_GROWING_TESTUTILS_LEAFDATAFIXTURE_H_
+#define MESSMER_BLOBSTORE_TEST_IMPLEMENTATIONS_ONBLOCKS_DATATREESTORE_GROWING_TESTUTILS_LEAFDATAFIXTURE_H_
+
+#include <google/gtest/gtest.h>
+
+#include <messmer/cpp-utils/data/DataFixture.h>
+
+// A data fixture containing data for a leaf.
+// The class can fill this data into a given leaf
+// and check, whether the data stored in a given leaf is correct.
+class LeafDataFixture {
+public:
+  LeafDataFixture(int size, int iv = 0): _data(cpputils::DataFixture::generate(size, iv)) {}
+
+  void FillInto(blobstore::onblocks::datanodestore::DataLeafNode *leaf) const {
+    leaf->resize(_data.size());
+    leaf->write(_data.data(), 0, _data.size());
+  }
+
+  void EXPECT_DATA_CORRECT(const blobstore::onblocks::datanodestore::DataLeafNode &leaf, int onlyCheckNumBytes = -1) const {
+    if (onlyCheckNumBytes == -1) {
+      EXPECT_EQ(_data.size(), leaf.numBytes());
+      EXPECT_EQ(0, std::memcmp(_data.data(), loadData(leaf).data(), _data.size()));
+    } else {
+      EXPECT_LE(onlyCheckNumBytes, (int)leaf.numBytes());
+      EXPECT_EQ(0, std::memcmp(_data.data(), loadData(leaf).data(), onlyCheckNumBytes));
+    }
+  }
+
+private:
+  static cpputils::Data loadData(const blobstore::onblocks::datanodestore::DataLeafNode &leaf) {
+    cpputils::Data data(leaf.numBytes());
+    leaf.read(data.data(), 0, leaf.numBytes());
+    return data;
+  }
+  cpputils::Data _data;
+};
+
+#endif

test/blobstore/implementations/onblocks/datatreestore/testutils/TwoLevelDataFixture.h

@@ -0,0 +1,86 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_TEST_IMPLEMENTATIONS_ONBLOCKS_DATATREESTORE_GROWING_TESTUTILS_TWOLEVELDATAFIXTURE_H_
+#define MESSMER_BLOBSTORE_TEST_IMPLEMENTATIONS_ONBLOCKS_DATATREESTORE_GROWING_TESTUTILS_TWOLEVELDATAFIXTURE_H_
+
+#include <messmer/cpp-utils/macros.h>
+#include <messmer/cpp-utils/pointer/cast.h>
+#include "LeafDataFixture.h"
+#include <messmer/cpp-utils/assert/assert.h>
+
+//TODO Rename, since we now allow any number of levels
+// A data fixture containing data for a two-level tree (one inner node with leaf children).
+// The class can fill this data into the leaf children of a given inner node
+// and given an inner node can check, whether the data stored is correct.
+class TwoLevelDataFixture {
+public:
+  enum class SizePolicy {
+    Random,
+    Full,
+    Unchanged
+  };
+  TwoLevelDataFixture(blobstore::onblocks::datanodestore::DataNodeStore *dataNodeStore, SizePolicy sizePolicy, int iv=0): _dataNodeStore(dataNodeStore), _iv(iv), _sizePolicy(sizePolicy) {}
+
+  void FillInto(blobstore::onblocks::datanodestore::DataNode *node) {
+    // _iv-1 means there is no endLeafIndex - we fill all leaves.
+    ForEachLeaf(node, _iv, _iv-1, [this] (blobstore::onblocks::datanodestore::DataLeafNode *leaf, int leafIndex) {
+      LeafDataFixture(size(leafIndex, leaf), leafIndex).FillInto(leaf);
+    });
+  }
+
+  void EXPECT_DATA_CORRECT(blobstore::onblocks::datanodestore::DataNode *node, int maxCheckedLeaves = 0, int lastLeafMaxCheckedBytes = -1) {
+    ForEachLeaf(node, _iv, _iv+maxCheckedLeaves, [this, maxCheckedLeaves, lastLeafMaxCheckedBytes] (blobstore::onblocks::datanodestore::DataLeafNode *leaf, int leafIndex) {
+      if (leafIndex == _iv+maxCheckedLeaves-1) {
+        // It is the last leaf
+        LeafDataFixture(size(leafIndex, leaf), leafIndex).EXPECT_DATA_CORRECT(*leaf, lastLeafMaxCheckedBytes);
+      } else {
+        LeafDataFixture(size(leafIndex, leaf), leafIndex).EXPECT_DATA_CORRECT(*leaf);
+      }
+    });
+  }
+
+private:
+  int ForEachLeaf(blobstore::onblocks::datanodestore::DataNode *node, int firstLeafIndex, int endLeafIndex, std::function<void (blobstore::onblocks::datanodestore::DataLeafNode*, int)> action) {
+    if (firstLeafIndex == endLeafIndex) {
+      return firstLeafIndex;
+    }
+    auto leaf = dynamic_cast<blobstore::onblocks::datanodestore::DataLeafNode*>(node);
+    if (leaf != nullptr) {
+      action(leaf, firstLeafIndex);
+      return firstLeafIndex + 1;
+    } else {
+      auto inner = dynamic_cast<blobstore::onblocks::datanodestore::DataInnerNode*>(node);
+      int leafIndex = firstLeafIndex;
+      for (uint32_t i = 0; i < inner->numChildren(); ++i) {
+        auto child = _dataNodeStore->load(inner->getChild(i)->key()).value();
+        leafIndex = ForEachLeaf(child.get(), leafIndex, endLeafIndex, action);
+      }
+      return leafIndex;
+    }
+  }
+
+  blobstore::onblocks::datanodestore::DataNodeStore *_dataNodeStore;
+  int _iv;
+  SizePolicy _sizePolicy;
+
+  int size(int childIndex, blobstore::onblocks::datanodestore::DataLeafNode *leaf) {
+    switch (_sizePolicy) {
+    case SizePolicy::Full:
+      return _dataNodeStore->layout().maxBytesPerLeaf();
+    case SizePolicy::Random:
+      return mod(_dataNodeStore->layout().maxBytesPerLeaf() - childIndex, _dataNodeStore->layout().maxBytesPerLeaf());
+    case SizePolicy::Unchanged:
+      return leaf->numBytes();
+    default:
+      ASSERT(false, "Unknown size policy");
+    }
+  }
+
+  int mod(int value, int mod) {
+    while(value < 0) {
+      value += mod;
+    }
+    return value;
+  }
+};
+
+#endif

test/blobstore/implementations/onblocks/testutils/BlobStoreTest.cpp

@@ -0,0 +1,14 @@
+#include "BlobStoreTest.h"
+
+#include <messmer/blockstore/implementations/testfake/FakeBlockStore.h>
+#include "../../../../implementations/onblocks/BlobStoreOnBlocks.h"
+
+using blobstore::onblocks::BlobStoreOnBlocks;
+using blockstore::testfake::FakeBlockStore;
+using cpputils::make_unique_ref;
+
+constexpr uint32_t BlobStoreTest::BLOCKSIZE_BYTES;
+
+BlobStoreTest::BlobStoreTest()
+  : blobStore(make_unique_ref<BlobStoreOnBlocks>(make_unique_ref<FakeBlockStore>(), BLOCKSIZE_BYTES)) {
+}

test/blobstore/implementations/onblocks/testutils/BlobStoreTest.h

@@ -0,0 +1,29 @@
+#pragma once
+#ifndef MESSMER_BLOBSTORE_TEST_IMPLEMENTATIONS_ONBLOCKS_TESTUTILS_BLOBSTORETEST_H_
+#define MESSMER_BLOBSTORE_TEST_IMPLEMENTATIONS_ONBLOCKS_TESTUTILS_BLOBSTORETEST_H_
+
+#include <google/gtest/gtest.h>
+
+#include "../../../../interface/BlobStore.h"
+
+class BlobStoreTest: public ::testing::Test {
+public:
+  BlobStoreTest();
+
+  static constexpr uint32_t BLOCKSIZE_BYTES = 4096;
+
+  cpputils::unique_ref<blobstore::BlobStore> blobStore;
+
+  cpputils::unique_ref<blobstore::Blob> loadBlob(const blockstore::Key &key) {
+    auto loaded = blobStore->load(key);
+    EXPECT_TRUE((bool)loaded);
+    return std::move(*loaded);
+  }
+
+  void reset(cpputils::unique_ref<blobstore::Blob> ref) {
+    UNUSED(ref);
+    //ref is moved into here and then destructed
+  }
+};
+
+#endif

test/blobstore/implementations/onblocks/utils/CeilDivisionTest.cpp

@@ -0,0 +1,88 @@
+#include <google/gtest/gtest.h>
+#include "../../../../implementations/onblocks/utils/Math.h"
+
+#include <limits>
+
+using namespace blobstore::onblocks::utils;
+using ::testing::Test;
+using std::numeric_limits;
+
+class CeilDivisionTest: public Test {};
+
+TEST_F(CeilDivisionTest, Divide0_4) {
+ EXPECT_EQ(0, ceilDivision(0, 4));
+}
+
+TEST_F(CeilDivisionTest, Divide1_4) {
+ EXPECT_EQ(1, ceilDivision(1, 4));
+}
+
+TEST_F(CeilDivisionTest, Divide2_4) {
+ EXPECT_EQ(1, ceilDivision(2, 4));
+}
+
+TEST_F(CeilDivisionTest, Divide3_4) {
+ EXPECT_EQ(1, ceilDivision(3, 4));
+}
+
+TEST_F(CeilDivisionTest, Divide4_4) {
+ EXPECT_EQ(1, ceilDivision(4, 4));
+}
+
+TEST_F(CeilDivisionTest, Divide5_4) {
+ EXPECT_EQ(2, ceilDivision(5, 4));
+}
+
+TEST_F(CeilDivisionTest, Divide6_4) {
+ EXPECT_EQ(2, ceilDivision(6, 4));
+}
+
+TEST_F(CeilDivisionTest, Divide7_4) {
+ EXPECT_EQ(2, ceilDivision(7, 4));
+}
+
+TEST_F(CeilDivisionTest, Divide8_4) {
+ EXPECT_EQ(2, ceilDivision(8, 4));
+}
+
+TEST_F(CeilDivisionTest, Divide9_4) {
+ EXPECT_EQ(3, ceilDivision(9, 4));
+}
+
+TEST_F(CeilDivisionTest, Divide0_1) {
+  EXPECT_EQ(0, ceilDivision(0, 1));
+}
+
+TEST_F(CeilDivisionTest, Divide5_1) {
+  EXPECT_EQ(5, ceilDivision(5, 1));
+}
+
+TEST_F(CeilDivisionTest, Divide7_2) {
+  EXPECT_EQ(4, ceilDivision(7, 2));
+}
+
+TEST_F(CeilDivisionTest, Divide8_2) {
+  EXPECT_EQ(4, ceilDivision(8, 2));
+}
+
+TEST_F(CeilDivisionTest, Divide9_2) {
+  EXPECT_EQ(5, ceilDivision(9, 2));
+}
+
+TEST_F(CeilDivisionTest, Divide1_1) {
+  EXPECT_EQ(1, ceilDivision(1, 1));
+}
+
+TEST_F(CeilDivisionTest, Divide5_5) {
+  EXPECT_EQ(1, ceilDivision(5, 5));
+}
+
+TEST_F(CeilDivisionTest, DivideLargeByItself) {
+  EXPECT_EQ(1, ceilDivision(183495303, 183495303));
+}
+
+TEST_F(CeilDivisionTest, 64bit) {
+  uint64_t base = UINT64_C(1024)*1024*1024*1024;
+  EXPECT_GT(base, std::numeric_limits<uint32_t>::max());
+  EXPECT_EQ(base/1024, ceilDivision(base, (uint64_t)1024));
+}

test/blobstore/implementations/onblocks/utils/CeilLogTest.cpp

@@ -0,0 +1,35 @@
+#include <google/gtest/gtest.h>
+#include "../../../../implementations/onblocks/utils/Math.h"
+
+#include <limits>
+
+using namespace blobstore::onblocks::utils;
+using ::testing::Test;
+using std::numeric_limits;
+
+class CeilLogTest: public Test {};
+
+TEST_F(CeilLogTest, Log3_1) {
+ EXPECT_EQ(0, ceilLog(3, 1));
+}
+
+TEST_F(CeilLogTest, Log3_2) {
+ EXPECT_EQ(1, ceilLog(3, 2));
+}
+
+TEST_F(CeilLogTest, Log3_3) {
+ EXPECT_EQ(1, ceilLog(3, 3));
+}
+
+TEST_F(CeilLogTest, Log3_4) {
+ EXPECT_EQ(2, ceilLog(3, 4));
+}
+
+TEST_F(CeilLogTest, 64bit) {
+ uint64_t value = UINT64_C(1024)*1024*1024*1024;
+ EXPECT_GT(value, std::numeric_limits<uint32_t>::max());
+ EXPECT_EQ(4, ceilLog((uint64_t)1024, value));
+}
+
+
+//TODO ...

test/blobstore/implementations/onblocks/utils/IntPowTest.cpp

@@ -0,0 +1,77 @@
+#include <google/gtest/gtest.h>
+#include "../../../../implementations/onblocks/utils/Math.h"
+
+using namespace blobstore::onblocks::utils;
+using ::testing::Test;
+
+class IntPowTest: public Test {};
+
+TEST_F(IntPowTest, ExponentAndBaseAreZero) {
+  EXPECT_EQ(1, intPow(0, 0));
+}
+
+TEST_F(IntPowTest, ExponentIsZero1) {
+  EXPECT_EQ(1, intPow(1, 0));
+}
+
+TEST_F(IntPowTest, ExponentIsZero2) {
+  EXPECT_EQ(1, intPow(1000, 0));
+}
+
+TEST_F(IntPowTest, BaseIsZero1) {
+  EXPECT_EQ(0, intPow(0, 1));
+}
+
+TEST_F(IntPowTest, BaseIsZero2) {
+  EXPECT_EQ(0, intPow(0, 1000));
+}
+
+TEST_F(IntPowTest, ExponentIsOne1) {
+  EXPECT_EQ(0, intPow(0, 1));
+}
+
+TEST_F(IntPowTest, ExponentIsOne2) {
+  EXPECT_EQ(2, intPow(2, 1));
+}
+
+TEST_F(IntPowTest, ExponentIsOne3) {
+  EXPECT_EQ(1000, intPow(1000, 1));
+}
+
+TEST_F(IntPowTest, BaseIsTwo1) {
+  EXPECT_EQ(1024, intPow(2, 10));
+}
+
+TEST_F(IntPowTest, BaseIsTwo2) {
+  EXPECT_EQ(1024*1024, intPow(2, 20));
+}
+
+TEST_F(IntPowTest, BaseIsTwo3) {
+  EXPECT_EQ(1024*1024*1024, intPow(2, 30));
+}
+
+TEST_F(IntPowTest, BaseIsTen1) {
+  EXPECT_EQ(100, intPow(10, 2));
+}
+
+TEST_F(IntPowTest, BaseIsTen2) {
+  EXPECT_EQ(1000000, intPow(10, 6));
+}
+
+TEST_F(IntPowTest, ArbitraryNumbers1) {
+  EXPECT_EQ(4096, intPow(4, 6));
+}
+
+TEST_F(IntPowTest, ArbitraryNumbers2) {
+  EXPECT_EQ(1296, intPow(6, 4));
+}
+
+TEST_F(IntPowTest, ArbitraryNumbers3) {
+  EXPECT_EQ(282475249, intPow(7, 10));
+}
+
+TEST_F(IntPowTest, 64bit) {
+  uint64_t value = UINT64_C(1024)*1024*1024*1024;
+  EXPECT_GT(value, std::numeric_limits<uint32_t>::max());
+  EXPECT_EQ(value*value*value, intPow(value, (uint64_t)3));
+}

test/blobstore/implementations/onblocks/utils/MaxZeroSubtractionTest.cpp

@@ -0,0 +1,90 @@
+#include <google/gtest/gtest.h>
+#include "../../../../implementations/onblocks/utils/Math.h"
+
+#include <limits>
+
+using namespace blobstore::onblocks::utils;
+using ::testing::Test;
+using std::numeric_limits;
+
+class MaxZeroSubtractionTest: public Test {};
+
+TEST_F(MaxZeroSubtractionTest, SubtractToZero1) {
+  EXPECT_EQ(0, maxZeroSubtraction(0, 0));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractToZero2) {
+  EXPECT_EQ(0, maxZeroSubtraction(5, 5));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractToZero3) {
+  EXPECT_EQ(0, maxZeroSubtraction(184930, 184930));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractToZero4) {
+  EXPECT_EQ(0, maxZeroSubtraction(numeric_limits<uint32_t>::max()-1, numeric_limits<uint32_t>::max()-1));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractToZero5) {
+  EXPECT_EQ(0, maxZeroSubtraction(numeric_limits<uint32_t>::max(), numeric_limits<uint32_t>::max()));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractPositive1) {
+  EXPECT_EQ(1, maxZeroSubtraction(5, 4));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractPositive2) {
+  EXPECT_EQ(181081, maxZeroSubtraction(184930, 3849));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractPositive3) {
+  EXPECT_EQ(numeric_limits<uint32_t>::max()-1, maxZeroSubtraction(numeric_limits<uint32_t>::max(), UINT32_C(1)));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractPositive4) {
+  EXPECT_EQ(5, maxZeroSubtraction(numeric_limits<uint32_t>::max(), numeric_limits<uint32_t>::max()-5));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractNegative1) {
+  EXPECT_EQ(0, maxZeroSubtraction(4, 5));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractNegative2) {
+  EXPECT_EQ(0, maxZeroSubtraction(3849, 184930));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractNegative3) {
+  EXPECT_EQ(0, maxZeroSubtraction(numeric_limits<uint32_t>::max()-1, numeric_limits<uint32_t>::max()));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractNegative4) {
+  EXPECT_EQ(0, maxZeroSubtraction(numeric_limits<uint32_t>::max()-5, numeric_limits<uint32_t>::max()));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractNegative5) {
+  EXPECT_EQ(0, maxZeroSubtraction(UINT32_C(5), numeric_limits<uint32_t>::max()));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractFromZero1) {
+  EXPECT_EQ(0, maxZeroSubtraction(0, 1));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractFromZero2) {
+  EXPECT_EQ(0, maxZeroSubtraction(0, 184930));
+}
+
+TEST_F(MaxZeroSubtractionTest, SubtractFromZero3) {
+  EXPECT_EQ(0, maxZeroSubtraction(UINT32_C(0), numeric_limits<uint32_t>::max()));
+}
+
+TEST_F(MaxZeroSubtractionTest, 64bit_valid) {
+  uint64_t value = UINT64_C(1024)*1024*1024*1024;
+  EXPECT_GT(value, std::numeric_limits<uint32_t>::max());
+  EXPECT_EQ(value*1024-value, maxZeroSubtraction(value*1024, value));
+}
+
+TEST_F(MaxZeroSubtractionTest, 64bit_zero) {
+  uint64_t value = UINT64_C(1024)*1024*1024*1024;
+  EXPECT_GT(value, std::numeric_limits<uint32_t>::max());
+  EXPECT_EQ(0, maxZeroSubtraction(value, value*1024));
+}