create a separate unit-tests dir

unit-tests/block_t.cc

@@ -0,0 +1,197 @@
+#include "block.h"
+
+#define BOOST_TEST_MODULE BlockManagerTests
+#include <boost/test/included/unit_test.hpp>
+
+using namespace std;
+
+//----------------------------------------------------------------
+
+namespace {
+	block_manager<4096>::ptr create_bm(block_address nr = 1024) {
+		return block_manager<4096>::ptr(new block_manager<4096>("./test.data", nr));
+	}
+
+	template <uint32_t BlockSize>
+	void check_all_bytes(typename block_manager<BlockSize>::read_ref const &rr, int v) {
+		auto data = rr.data();
+		for (unsigned b = 0; b < BlockSize; b++)
+			BOOST_CHECK_EQUAL(data[b], v);
+	}
+
+	template <uint32_t BlockSize>
+	class zero_validator : public block_manager<BlockSize>::validator {
+		void check(block_manager<4096>::block const &blk) const {
+			for (unsigned b = 0; b < BlockSize; b++)
+				if (blk.data_[b] != 0)
+					throw runtime_error("validator check zero");
+		}
+
+		void prepare(block_manager<4096>::block &blk) const {
+			for (unsigned b = 0; b < BlockSize; b++)
+				blk.data_[b] = 0;
+		}
+	};
+}
+
+//----------------------------------------------------------------
+
+BOOST_AUTO_TEST_CASE(bad_path)
+{
+	BOOST_CHECK_THROW(block_manager<4096>("/bogus/bogus/bogus", 1234), runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(out_of_range_access)
+{
+	auto bm = create_bm(1024);
+	BOOST_CHECK_THROW(bm->read_lock(1024), runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(read_lock_all_blocks)
+{
+	block_address const nr = 64;
+	auto bm = create_bm(nr);
+	for (unsigned i = 0; i < nr; i++)
+		bm->read_lock(i);
+}
+
+BOOST_AUTO_TEST_CASE(write_lock_all_blocks)
+{
+	block_address const nr = 64;
+	auto bm = create_bm(nr);
+	for (unsigned i = 0; i < nr; i++)
+		bm->write_lock(i);
+}
+
+BOOST_AUTO_TEST_CASE(writes_persist)
+{
+	block_address const nr = 64;
+	auto bm = create_bm(nr);
+	for (unsigned i = 0; i < nr; i++) {
+		auto wr = bm->write_lock(i);
+		::memset(wr.data(), i, 4096);
+	}
+
+	for (unsigned i = 0; i < nr; i++) {
+		auto rr = bm->read_lock(i);
+		check_all_bytes<4096>(rr, i % 256);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(write_lock_zero_zeroes)
+{
+	auto bm = create_bm(64);
+	check_all_bytes<4096>(bm->write_lock_zero(23), 0);
+}
+
+BOOST_AUTO_TEST_CASE(different_block_sizes)
+{
+	{
+		block_manager<4096> bm("./test.data", 64);
+		auto rr = bm.read_lock(0);
+		BOOST_CHECK_EQUAL(sizeof(rr.data()), 4096);
+	}
+
+	{
+		block_manager<64 * 1024> bm("./test.data", 64);
+		auto rr = bm.read_lock(0);
+		BOOST_CHECK_EQUAL(sizeof(rr.data()), 64 * 1024);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(read_validator_works)
+{
+	typename block_manager<4096>::block_manager::validator::ptr v(new zero_validator<4096>());
+	auto bm = create_bm(64);
+	bm->write_lock_zero(0);
+	bm->read_lock(0, v);
+}
+
+BOOST_AUTO_TEST_CASE(write_validator_works)
+{
+	auto bm = create_bm(64);
+	typename block_manager<4096>::block_manager::validator::ptr v(new zero_validator<4096>());
+
+	{
+		auto wr = bm->write_lock(0, v);
+		::memset(wr.data(), 23, sizeof(wr.data()));
+	}
+
+	check_all_bytes<4096>(bm->read_lock(0), 0);
+}
+
+BOOST_AUTO_TEST_CASE(cannot_have_two_superblocks)
+{
+	auto bm = create_bm();
+	auto superblock = bm->superblock(0);
+	BOOST_CHECK_THROW(bm->superblock(1), runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(can_have_subsequent_superblocks)
+{
+	auto bm = create_bm();
+	{ auto superblock = bm->superblock(0); }
+	{ auto superblock = bm->superblock(0); }
+}
+
+BOOST_AUTO_TEST_CASE(superblocks_can_change_address)
+{
+	auto bm = create_bm();
+	{ auto superblock = bm->superblock(0); }
+	{ auto superblock = bm->superblock(1); }
+}
+
+BOOST_AUTO_TEST_CASE(superblock_must_be_last)
+{
+	auto bm = create_bm();
+	{
+		auto rr = bm->read_lock(63);
+		{
+			BOOST_CHECK_THROW(bm->superblock(0), runtime_error);
+		}
+	}
+}
+
+BOOST_AUTO_TEST_CASE(references_can_be_copied)
+{
+	auto bm = create_bm();
+	auto wr1 = bm->write_lock(0);
+	auto wr2(wr1);
+}
+
+BOOST_AUTO_TEST_CASE(flush_throws_if_held_locks)
+{
+	auto bm = create_bm();
+	auto wr = bm->write_lock(0);
+	BOOST_CHECK_THROW(bm->flush(), runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(no_concurrent_write_locks)
+{
+	auto bm = create_bm();
+	auto wr = bm->write_lock(0);
+	BOOST_CHECK_THROW(bm->write_lock(0), runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(concurrent_read_locks)
+{
+	auto bm = create_bm();
+	auto rr = bm->read_lock(0);
+	bm->read_lock(0);
+}
+
+BOOST_AUTO_TEST_CASE(read_then_write)
+{
+	auto bm = create_bm();
+	bm->read_lock(0);
+	bm->write_lock(0);
+}
+
+BOOST_AUTO_TEST_CASE(write_then_read)
+{
+	auto bm = create_bm();
+	bm->write_lock(0);
+	bm->read_lock(0);
+}
+
+//----------------------------------------------------------------

unit-tests/btree_t.cc

@@ -0,0 +1,63 @@
+#include "transaction_manager.h"
+#include "core_map.h"
+#include "btree.h"
+
+#define BOOST_TEST_MODULE BTreeTests
+#include <boost/test/included/unit_test.hpp>
+
+using namespace std;
+using namespace boost;
+using namespace persistent_data;
+
+//----------------------------------------------------------------
+
+namespace {
+	block_address const NR_BLOCKS = 102400;
+
+	transaction_manager<4096>::ptr
+	create_tm() {
+		block_manager<4096>::ptr bm(new block_manager<4096>("./test.data", NR_BLOCKS));
+		space_map::ptr sm(new core_map(NR_BLOCKS));
+		transaction_manager<4096>::ptr tm(new transaction_manager<4096>(bm, sm));
+		return tm;
+	}
+
+	btree<1, uint64_traits, 4096>::ptr
+	create_btree() {
+		typename uint64_traits::ref_counter rc;
+
+		return btree<1, uint64_traits, 4096>::ptr(
+			new btree<1, uint64_traits, 4096>(
+				create_tm(), rc));
+	}
+}
+
+//----------------------------------------------------------------
+
+BOOST_AUTO_TEST_CASE(empty_btree_contains_nothing)
+{
+	auto tree = create_btree();
+
+	for (uint64_t i = 0; i < 1000; i++) {
+		uint64_t key[1] = {i};
+		BOOST_CHECK(!tree->lookup(key));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(insert_works)
+{
+	unsigned const COUNT = 1000000;
+
+	auto tree = create_btree();
+	for (uint64_t i = 0; i < COUNT; i++) {
+		uint64_t key[1] = {i * 7};
+		uint64_t value = i;
+		tree->insert(key, value);
+
+		auto l = tree->lookup(key);
+		BOOST_CHECK(l);
+		BOOST_CHECK_EQUAL(*l, i);
+	}
+}
+
+//----------------------------------------------------------------

unit-tests/endian_t.cc

@@ -0,0 +1,62 @@
+#include "space_map_disk.h"
+#include "core_map.h"
+
+#define BOOST_TEST_MODULE EndianTests
+#include <boost/test/included/unit_test.hpp>
+
+using namespace base;
+using namespace boost;
+using namespace persistent_data;
+using namespace std;
+
+//----------------------------------------------------------------
+
+BOOST_AUTO_TEST_CASE(bitmaps)
+{
+	unsigned NR_BITS = 10247;
+	vector<uint64_t> data((NR_BITS + 63) / 64, 0);
+
+	// check all bits are zero
+	void *bits = &data[0];
+	for (unsigned i = 0; i < NR_BITS; i++)
+		BOOST_CHECK(!test_bit_le(bits, i));
+
+	// set all bits to one
+	for (unsigned i = 0; i < NR_BITS; i++)
+		set_bit_le(bits, i);
+
+	// check they're all 1 now
+	for (unsigned i = 0; i < NR_BITS; i++)
+		BOOST_CHECK(test_bit_le(bits, i));
+
+	// clear every third bit
+	for (unsigned i = 0; i < NR_BITS; i += 3)
+		clear_bit_le(bits, i);
+
+	// check everything is as we expect
+	for (unsigned i = 0; i < NR_BITS; i++) {
+		if ((i % 3) == 0)
+			BOOST_CHECK(!test_bit_le(bits, i));
+		else
+			BOOST_CHECK(test_bit_le(bits, i));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(bitmaps_alternate_words)
+{
+	unsigned NR_BITS = 10247;
+	vector<uint64_t> data((NR_BITS + 63) / 64, 0);
+
+	// check all bits are zero
+	void *bits = &data[0];
+	for (unsigned i = 0; i < 128; i++)
+		BOOST_CHECK(!test_bit_le(bits, i));
+
+	for (unsigned i = 0; i < 64; i++)
+		set_bit_le(bits, i);
+
+	for (unsigned i = 64; i < 128; i++)
+		BOOST_CHECK(!test_bit_le(bits, i));
+}
+
+//----------------------------------------------------------------

unit-tests/metadata_t.cc

@@ -0,0 +1,41 @@
+#include "metadata.h"
+#include "core_map.h"
+
+#define BOOST_TEST_MODULE MetadataTests
+#include <boost/test/included/unit_test.hpp>
+
+using namespace std;
+using namespace boost;
+using namespace persistent_data;
+using namespace thin_provisioning;
+
+//----------------------------------------------------------------
+
+namespace {
+	block_address const NR_BLOCKS = 1024;
+	block_address const SUPERBLOCK = 0;
+
+	transaction_manager<4096>::ptr
+	create_tm() {
+		block_manager<4096>::ptr bm(new block_manager<4096>("./test.data", NR_BLOCKS));
+		space_map::ptr sm(new core_map(NR_BLOCKS));
+		transaction_manager<4096>::ptr tm(new transaction_manager<4096>(bm, sm));
+		return tm;
+	}
+
+	metadata::ptr
+	create_metadata() {
+		auto tm = create_tm();
+		return metadata::ptr(
+			new metadata(tm, 0, 128, 1024000, true));
+	}
+}
+
+//----------------------------------------------------------------
+
+BOOST_AUTO_TEST_CASE(create_metadata_object)
+{
+	auto m = create_metadata();
+}
+
+//----------------------------------------------------------------

unit-tests/space_map_disk_t.cc

@@ -0,0 +1,146 @@
+#include "space_map_disk.h"
+#include "core_map.h"
+
+#define BOOST_TEST_MODULE SpaceMapDiskTests
+#include <boost/test/included/unit_test.hpp>
+
+using namespace std;
+using namespace boost;
+using namespace persistent_data;
+
+//----------------------------------------------------------------
+
+namespace {
+	block_address const NR_BLOCKS = 10237;
+	block_address const SUPERBLOCK = 0;
+	unsigned const BLOCK_SIZE = 4096;
+
+	transaction_manager<BLOCK_SIZE>::ptr
+	create_tm() {
+		block_manager<BLOCK_SIZE>::ptr bm(
+			new block_manager<BLOCK_SIZE>("./test.data", NR_BLOCKS));
+		space_map::ptr sm(new core_map(1024));
+		transaction_manager<BLOCK_SIZE>::ptr tm(
+			new transaction_manager<BLOCK_SIZE>(bm, sm));
+		return tm;
+	}
+
+	persistent_space_map::ptr
+	create_sm_disk() {
+		auto tm = create_tm();
+		return persistent_data::create_disk_sm<BLOCK_SIZE>(tm, NR_BLOCKS);
+	}
+}
+
+//----------------------------------------------------------------
+
+BOOST_AUTO_TEST_CASE(reopen_an_sm)
+{
+	auto sm = create_sm_disk();
+}
+
+BOOST_AUTO_TEST_CASE(test_get_nr_blocks)
+{
+	auto sm = create_sm_disk();
+	BOOST_CHECK_EQUAL(sm->get_nr_blocks(), NR_BLOCKS);
+}
+
+BOOST_AUTO_TEST_CASE(test_get_nr_free)
+{
+	auto sm = create_sm_disk();
+	BOOST_CHECK_EQUAL(sm->get_nr_free(), NR_BLOCKS);
+
+	for (unsigned i = 0; i < NR_BLOCKS; i++) {
+		sm->new_block();
+		BOOST_CHECK_EQUAL(sm->get_nr_free(), NR_BLOCKS - i - 1);
+	}
+
+	for (unsigned i = 0; i < NR_BLOCKS; i++) {
+		sm->dec(i);
+		BOOST_CHECK_EQUAL(sm->get_nr_free(), i + 1);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(test_throws_no_space)
+{
+	auto sm = create_sm_disk();
+	for (unsigned i = 0; i < NR_BLOCKS; i++)
+		sm->new_block();
+
+	BOOST_CHECK_THROW(sm->new_block(), std::runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(test_inc_and_dec)
+{
+	auto sm = create_sm_disk();
+	block_address b = 63;
+
+	for (unsigned i = 0; i < 50; i++) {
+		BOOST_CHECK_EQUAL(sm->get_count(b), i);
+		sm->inc(b);
+	}
+
+	for (unsigned i = 50; i > 0; i--) {
+		BOOST_CHECK_EQUAL(sm->get_count(b), i);
+		sm->dec(b);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(test_not_allocated_twice)
+{
+	auto sm = create_sm_disk();
+	block_address b = sm->new_block();
+
+	try {
+		for (;;)
+			BOOST_CHECK(sm->new_block() != b);
+	} catch (...) {
+	}
+}
+
+BOOST_AUTO_TEST_CASE(test_set_count)
+{
+	auto sm = create_sm_disk();
+	sm->set_count(43, 5);
+	BOOST_CHECK_EQUAL(sm->get_count(43), 5);
+}
+
+BOOST_AUTO_TEST_CASE(test_set_effects_nr_allocated)
+{
+	auto sm = create_sm_disk();
+	for (unsigned i = 0; i < NR_BLOCKS; i++) {
+		sm->set_count(i, 1);
+		BOOST_CHECK_EQUAL(sm->get_nr_free(), NR_BLOCKS - i - 1);
+	}
+
+	for (unsigned i = 0; i < NR_BLOCKS; i++) {
+		sm->set_count(i, 0);
+		BOOST_CHECK_EQUAL(sm->get_nr_free(), i + 1);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(test_reopen)
+{
+	unsigned char buffer[128];
+
+	{
+		auto sm = create_sm_disk();
+		for (unsigned i = 0, step = 1; i < NR_BLOCKS; i += step, step++) {
+			sm->inc(i);
+		}
+
+		BOOST_CHECK(sm->root_size() <= sizeof(buffer));
+
+		sm->copy_root(buffer, sizeof(buffer));
+	}
+
+	{
+		auto tm = create_tm();
+		auto sm = persistent_data::open_disk_sm<BLOCK_SIZE>(tm, buffer);
+
+		for (unsigned i = 0, step = 1; i < NR_BLOCKS; i += step, step++)
+			BOOST_CHECK_EQUAL(sm->get_count(i), 1);
+	}
+}
+
+//----------------------------------------------------------------

unit-tests/space_map_t.cc

@@ -0,0 +1,78 @@
+#include "space_map.h"
+#include "core_map.h"
+
+#define BOOST_TEST_MODULE SpaceMapTests
+#include <boost/test/included/unit_test.hpp>
+
+using namespace std;
+using namespace boost;
+
+unsigned const NR_BLOCKS = 1024;
+
+//----------------------------------------------------------------
+
+BOOST_AUTO_TEST_CASE(test_get_nr_blocks)
+{
+	core_map sm(NR_BLOCKS);
+	BOOST_CHECK_EQUAL(sm.get_nr_blocks(), NR_BLOCKS);
+}
+
+BOOST_AUTO_TEST_CASE(test_get_nr_free)
+{
+	core_map sm(NR_BLOCKS);
+	BOOST_CHECK_EQUAL(sm.get_nr_free(), NR_BLOCKS);
+
+	for (unsigned i = 0; i < NR_BLOCKS; i++) {
+		sm.new_block();
+		BOOST_CHECK_EQUAL(sm.get_nr_free(), NR_BLOCKS - i - 1);
+	}
+
+	for (unsigned i = 0; i < NR_BLOCKS; i++) {
+		sm.dec(i);
+		BOOST_CHECK_EQUAL(sm.get_nr_free(), i + 1);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(test_throws_no_space)
+{
+	core_map sm(NR_BLOCKS);
+	for (unsigned i = 0; i < NR_BLOCKS; i++)
+		sm.new_block();
+
+	BOOST_CHECK_THROW(sm.new_block(), std::runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(test_inc_and_dec)
+{
+	core_map sm(NR_BLOCKS);
+	block_address b = 63;
+
+	for (unsigned i = 0; i < 50; i++) {
+		BOOST_CHECK_EQUAL(sm.get_count(b), i);
+		sm.inc(b);
+	}
+
+	for (unsigned i = 50; i > 0; i--) {
+		BOOST_CHECK_EQUAL(sm.get_count(b), i);
+		sm.dec(b);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(test_not_allocated_twice)
+{
+	core_map sm(NR_BLOCKS);
+	block_address b = sm.new_block();
+
+	try {
+		for (;;)
+			BOOST_CHECK(sm.new_block() != b);
+	} catch (...) {
+	}
+}
+
+BOOST_AUTO_TEST_CASE(test_set_count)
+{
+	core_map sm(NR_BLOCKS);
+	sm.set_count(43, 5);
+	BOOST_CHECK_EQUAL(sm.get_count(43), 5);
+}

unit-tests/transaction_manager_t.cc

@@ -0,0 +1,99 @@
+#include "transaction_manager.h"
+#include "core_map.h"
+
+#define BOOST_TEST_MODULE TransactionManagerTests
+#include <boost/test/included/unit_test.hpp>
+
+using namespace std;
+using namespace boost;
+using namespace persistent_data;
+
+//----------------------------------------------------------------
+
+namespace {
+	block_address const NR_BLOCKS = 1024;
+
+	transaction_manager<4096>::ptr
+	create_tm() {
+		block_manager<4096>::ptr bm(new block_manager<4096>("./test.data", NR_BLOCKS));
+		space_map::ptr sm(new core_map(NR_BLOCKS));
+		transaction_manager<4096>::ptr tm(new transaction_manager<4096>(bm, sm));
+		tm->get_sm()->inc(0);
+		return tm;
+	}
+}
+
+//----------------------------------------------------------------
+
+BOOST_AUTO_TEST_CASE(commit_succeeds)
+{
+	auto tm = create_tm();
+	tm->begin(0);
+}
+
+BOOST_AUTO_TEST_CASE(shadowing)
+{
+	auto tm = create_tm();
+	auto superblock = tm->begin(0);
+
+	auto sm = tm->get_sm();
+	sm->inc(1);
+	block_address b;
+
+	{
+		auto p = tm->shadow(1);
+		b = p.first.get_location();
+		BOOST_CHECK(b != 1);
+		BOOST_CHECK(!p.second);
+		BOOST_CHECK(sm->get_count(1) == 0);
+	}
+
+	{
+		auto p = tm->shadow(b);
+		BOOST_CHECK(p.first.get_location() == b);
+		BOOST_CHECK(!p.second);
+	}
+
+	sm->inc(b);
+
+	{
+		auto p = tm->shadow(b);
+		BOOST_CHECK(p.first.get_location() != b);
+		BOOST_CHECK(p.second);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(multiple_shadowing)
+{
+	auto tm = create_tm();
+	auto superblock = tm->begin(0);
+
+	auto sm = tm->get_sm();
+	sm->set_count(1, 3);
+
+	auto p = tm->shadow(1);
+	auto b = p.first.get_location();
+	BOOST_CHECK(b != 1);
+	BOOST_CHECK(p.second);
+
+	p = tm->shadow(1);
+	auto b2 = p.first.get_location();
+	BOOST_CHECK(b2 != 1);
+	BOOST_CHECK(b2 != b);
+	BOOST_CHECK(p.second);
+
+	p = tm->shadow(1);
+	auto b3 = p.first.get_location();
+	BOOST_CHECK(b3 != b2);
+	BOOST_CHECK(b3 != b);
+	BOOST_CHECK(b3 != 1);
+	BOOST_CHECK(!p.second);
+}
+
+BOOST_AUTO_TEST_CASE(shadow_free_block_fails)
+{
+	auto tm = create_tm();
+	auto superblock = tm->begin(0);
+	BOOST_CHECK_THROW(tm->shadow(1), runtime_error);
+}
+