emo/thin-provisioning-tools
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rename range<> -> run<>

Browse Source
This commit is contained in:
Joe Thornber
2013-05-28 12:20:05 +01:00
parent 83d6b609eb
commit e64dda95f6
11 changed files with 83 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
unit-tests/btree_damage_visitor_t.cc
View File

@@ -6,7 +6,9 @@
#include "persistent-data/endian_utils.h"
#include "persistent-data/space-maps/core.h"
#include "persistent-data/transaction_manager.h"
#include "persistent-data/run.h"
using namespace base;
using namespace std;
using namespace persistent_data;
using namespace test;
@@ -71,7 +73,7 @@ namespace {
bool leaf;
unsigned depth;
block_address b;
range<uint64_t> keys;
run<uint64_t> keys;
};
ostream &operator <<(ostream &out, node_info const &ni) {
@@ -227,12 +229,12 @@ namespace {
ni->b = n.get_location();
if (n.get_nr_entries())
ni->keys = range<uint64_t>(n.key_at(0));
ni->keys = run<uint64_t>(n.key_at(0));
else {
if (loc.key)
ni->keys = range<uint64_t>(*loc.key);
ni->keys = run<uint64_t>(*loc.key);
else
ni->keys = range<uint64_t>();
ni->keys = run<uint64_t>();
}
if (last_node_at_depth_.size() > loc.depth) {
@@ -349,7 +351,7 @@ namespace {
}
}
void expect_value_range(uint64_t begin, uint64_t end) {
void expect_value_run(uint64_t begin, uint64_t end) {
while (begin < end) {
btree_path path;
path.push_back(begin);
@@ -359,7 +361,7 @@ namespace {
}
void expect_nr_values(unsigned nr) {
expect_value_range(0, nr);
expect_value_run(0, nr);
}
void expect_value(uint64_t n) {
@@ -368,7 +370,7 @@ namespace {
EXPECT_CALL(value_visitor_, visit(Eq(path), Eq(thing(n, n + 1234)))).Times(1);
}
void expect_damage(range<uint64_t> keys) {
void expect_damage(base::run<uint64_t> const &keys) {
EXPECT_CALL(damage_visitor_, visit(EmptyPath(), DamagedKeys(keys))).Times(1);
}
@@ -426,13 +428,13 @@ namespace {
}
void expect_values_except(unsigned nr_sub_trees, unsigned nr_values,
btree_path const &path, range<uint64_t> keys) {
btree_path const &path, base::run<uint64_t> keys) {
for (unsigned i = 0; i < nr_sub_trees; i++)
expect_sub_tree_values_except(i, nr_values, path, keys);
}
void expect_sub_tree_values_except(unsigned sub_tree, unsigned nr_values,
btree_path const &path, range<uint64_t> keys) {
btree_path const &path, base::run<uint64_t> keys) {
for (unsigned i = 0; i < nr_values; i++) {
uint64_t key[2] = {sub_tree, i};
@@ -446,7 +448,7 @@ namespace {
}
}
void expect_damage(btree_path path, range<uint64_t> keys) {
void expect_damage(btree_path path, base::run<uint64_t> keys) {
EXPECT_CALL(damage_visitor_, visit(Eq(path), DamagedKeys(keys))).Times(1);
}
@@ -485,7 +487,7 @@ TEST_F(BTreeDamageVisitorTests, tree_with_a_trashed_root)
trash_block(tree_->get_root());
expect_no_values();
expect_damage(range<uint64_t>(0ull));
expect_damage(base::run<uint64_t>(0ull));
run();
}
@@ -508,8 +510,8 @@ TEST_F(BTreeDamageVisitorTests, populated_tree_with_a_damaged_leaf_node)
node_info n = layout_->random_node(is_leaf);
trash_block(n.b);
expect_value_range(0, *n.keys.begin_);
expect_value_range(*n.keys.end_, 10000);
expect_value_run(0, *n.keys.begin_);
expect_value_run(*n.keys.end_, 10000);
expect_damage(n.keys);
run();
@@ -529,9 +531,9 @@ TEST_F(BTreeDamageVisitorTests, populated_tree_with_a_sequence_of_damaged_leaf_n
block_address begin = *nodes[0].keys.begin_;
block_address end = *nodes[COUNT - 1].keys.end_;
expect_value_range(0, *nodes[0].keys.begin_);
expect_value_range(*nodes[COUNT - 1].keys.end_, 10000);
expect_damage(range<block_address>(begin, end));
expect_value_run(0, *nodes[0].keys.begin_);
expect_value_run(*nodes[COUNT - 1].keys.end_, 10000);
expect_damage(base::run<block_address>(begin, end));
run();
}
@@ -546,8 +548,8 @@ TEST_F(BTreeDamageVisitorTests, damaged_first_leaf)
block_address end = *n.keys.end_;
trash_block(n.b);
expect_damage(range<block_address>(0ull, end));
expect_value_range(end, 10000);
expect_damage(base::run<block_address>(0ull, end));
expect_value_run(end, 10000);
run();
}
@@ -563,8 +565,8 @@ TEST_F(BTreeDamageVisitorTests, damaged_last_leaf)
block_address begin = *n.keys.begin_;
trash_block(n.b);
expect_value_range(0, begin);
expect_damage(range<block_address>(begin));
expect_value_run(0, begin);
expect_damage(base::run<block_address>(begin));
run();
}
@@ -581,11 +583,11 @@ TEST_F(BTreeDamageVisitorTests, damaged_internal)
trash_block(n.b);
expect_value_range(0, *begin);
expect_damage(range<block_address>(begin, end));
expect_value_run(0, *begin);
expect_damage(base::run<block_address>(begin, end));
if (end)
expect_value_range(*end, 10000);
expect_value_run(*end, 10000);
run();
}
@@ -609,7 +611,7 @@ TEST_F(BTreeDamageVisitor2Tests, tree_with_a_trashed_root)
expect_no_values();
btree_path path;
expect_damage(path, range<uint64_t>(0ull));
expect_damage(path, base::run<uint64_t>(0ull));
run();
}

24
unit-tests/damage_tracker_t.cc
View File

@@ -12,8 +12,8 @@ using namespace testing;
//----------------------------------------------------------------
namespace {
typedef range<block_address> range64;
typedef damage_tracker::maybe_range64 mr64;
typedef run<block_address> run64;
typedef damage_tracker::maybe_run64 mr64;
class DamageTrackerTests : public Test {
public:
@@ -21,7 +21,7 @@ namespace {
ASSERT_THAT(mr, Eq(mr64()));
}
void assert_damage(mr64 const &mr, range64 const &expected) const {
void assert_damage(mr64 const &mr, run64 const &expected) const {
ASSERT_THAT(mr, Eq(mr64(expected)));
}
@@ -40,27 +40,27 @@ TEST_F(DamageTrackerTests, good_leaf)
TEST_F(DamageTrackerTests, bad_node)
{
dt.bad_node();
assert_damage(dt.end(), range64(0ull));
assert_damage(dt.end(), run64(0ull));
}
TEST_F(DamageTrackerTests, good_bad)
{
dt.good_leaf(0, 10);
dt.bad_node();
assert_damage(dt.end(), range64(10ull));
assert_damage(dt.end(), run64(10ull));
}
TEST_F(DamageTrackerTests, bad_good)
{
dt.bad_node();
assert_damage(dt.good_leaf(10, 20), range64(0ull, 10ull));
assert_damage(dt.good_leaf(10, 20), run64(0ull, 10ull));
}
TEST_F(DamageTrackerTests, good_bad_good)
{
dt.good_leaf(0, 10);
dt.bad_node();
assert_damage(dt.good_leaf(20, 30), range64(10ull, 20ull));
assert_damage(dt.good_leaf(20, 30), run64(10ull, 20ull));
assert_no_damage(dt.end());
}
@@ -69,14 +69,14 @@ TEST_F(DamageTrackerTests, bad_good_bad)
dt.bad_node();
dt.good_leaf(10, 20);
dt.bad_node();
assert_damage(dt.end(), range64(20ull));
assert_damage(dt.end(), run64(20ull));
}
TEST_F(DamageTrackerTests, gi_bl_gl)
{
dt.good_internal(0);
dt.bad_node();
assert_damage(dt.good_leaf(10, 20), range64(0ull, 10ull));
assert_damage(dt.good_leaf(10, 20), run64(0ull, 10ull));
assert_no_damage(dt.end());
}
@@ -86,16 +86,16 @@ TEST_F(DamageTrackerTests, gi_gl_bl_bi)
dt.good_leaf(0, 10);
dt.bad_node();
dt.bad_node();
assert_damage(dt.end(), range64(10ull));
assert_damage(dt.end(), run64(10ull));
}
TEST_F(DamageTrackerTests, gi_bi_gi_bl_gl)
{
dt.good_internal(0);
dt.bad_node();
assert_damage(dt.good_internal(10), range64(0ull, 10ull));
assert_damage(dt.good_internal(10), run64(0ull, 10ull));
dt.bad_node();
assert_damage(dt.good_leaf(15, 20), range64(10ull, 15ull));
assert_damage(dt.good_leaf(15, 20), run64(10ull, 15ull));
}
//----------------------------------------------------------------