diff options
author | Tor Egge <Tor.Egge@online.no> | 2024-03-08 12:12:47 +0100 |
---|---|---|
committer | Tor Egge <Tor.Egge@online.no> | 2024-03-08 12:12:47 +0100 |
commit | b7a93a091c783be46e89ebed31dabac5267082fc (patch) | |
tree | 95617f25b03a30ffa75e6984bc367fed75fc168c | |
parent | 3ede5019a6fe0881917b165166f413c532fe4bc0 (diff) |
Rewrite btree aggregation unit test to gtest.
-rw-r--r-- | vespalib/src/tests/btree/CMakeLists.txt | 1 | ||||
-rw-r--r-- | vespalib/src/tests/btree/btreeaggregation_test.cpp | 378 |
2 files changed, 161 insertions, 218 deletions
diff --git a/vespalib/src/tests/btree/CMakeLists.txt b/vespalib/src/tests/btree/CMakeLists.txt index bf4edc9e5e9..3b6f012a888 100644 --- a/vespalib/src/tests/btree/CMakeLists.txt +++ b/vespalib/src/tests/btree/CMakeLists.txt @@ -20,6 +20,7 @@ vespa_add_executable(vespalib_btreeaggregation_test_app TEST btreeaggregation_test.cpp DEPENDS vespalib + GTest::gtest ) vespa_add_test(NAME vespalib_btreeaggregation_test_app COMMAND vespalib_btreeaggregation_test_app COST 30) vespa_add_executable(vespalib_iteratespeed_app diff --git a/vespalib/src/tests/btree/btreeaggregation_test.cpp b/vespalib/src/tests/btree/btreeaggregation_test.cpp index b33242b918e..34c1ca76772 100644 --- a/vespalib/src/tests/btree/btreeaggregation_test.cpp +++ b/vespalib/src/tests/btree/btreeaggregation_test.cpp @@ -16,8 +16,8 @@ #include <vespa/vespalib/btree/btreeaggregator.hpp> #include <vespa/vespalib/datastore/buffer_type.hpp> #include <vespa/vespalib/datastore/compaction_strategy.h> +#include <vespa/vespalib/gtest/gtest.h> #include <vespa/vespalib/test/btree/btree_printer.h> -#include <vespa/vespalib/testkit/testapp.h> #include <vespa/vespalib/util/rand48.h> #include <iostream> @@ -216,115 +216,95 @@ cleanup(GenerationHandler & g, cleanup(g, m); } -class Test : public vespalib::TestApp { -private: +class BTreeAggregationTest : public ::testing::Test { +protected: + BTreeAggregationTest(); + ~BTreeAggregationTest() override; template <typename Tree> bool assertTree(const std::string & exp, const Tree &t); template <typename Tree> bool - assertAggregated(const MockTree &m, const Tree &t); + assertAggregated(const MockTree &m, const Tree &t, const vespalib::string& label); template <typename TreeStore> bool - assertAggregated(const MockTree &m, const TreeStore &s, EntryRef ref); + assertAggregated(const MockTree &m, const TreeStore &s, EntryRef ref, const vespalib::string& label); void buildSubTree(const std::vector<LeafPair> &sub, size_t numEntries); - - void requireThatNodeInsertWorks(); - void keys_are_aggregated_correctly_on_node_insertions(); - void requireThatNodeSplitInsertWorks(); - void keys_are_aggregated_correctly_when_node_split_on_insert(); - void requireThatTreeInsertWorks(); - void requireThatNodeStealWorks(); - void requireThatNodeRemoveWorks(); - void keys_are_aggregated_correctly_on_node_removal(); - void requireThatWeCanInsertAndRemoveFromTree(); - void requireThatSortedTreeInsertWorks(); - void requireThatCornerCaseTreeFindWorks(); - void requireThatBasicTreeIteratorWorks(); - void requireThatTreeIteratorAssignWorks(); - void requireThatUpdateOfKeyWorks(); - void requireThatUpdateOfDataWorks(); - void requireThatFrozenViewProvidesAggregatedValues(); - - void - requireThatSmallNodesWorks(); -public: - int Main() override; }; +BTreeAggregationTest::BTreeAggregationTest() = default; +BTreeAggregationTest::~BTreeAggregationTest() = default; template<typename Tree> bool -Test::assertTree(const std::string &exp, const Tree &t) +BTreeAggregationTest::assertTree(const std::string &exp, const Tree &t) { std::stringstream ss; test::BTreePrinter<std::stringstream, typename Tree::NodeAllocatorType> printer(ss, t.getAllocator()); printer.print(t.getRoot()); - if (!EXPECT_EQUAL(exp, ss.str())) return false; - return true; + bool failed = false; + EXPECT_EQ(exp, ss.str()) << (failed = true, ""); + return !failed; } template <typename Tree> bool -Test::assertAggregated(const MockTree &m, const Tree &t) +BTreeAggregationTest::assertAggregated(const MockTree &m, const Tree &t, const vespalib::string& label) { + SCOPED_TRACE(label); const MinMaxAggregated &ta(t.getAggregated()); + bool failed = false; if (t.getRoot().valid()) { - return - EXPECT_FALSE(m._rtree.empty()) && - EXPECT_EQUAL(m._rtree.rbegin()->first, - ta.getMax()) && - EXPECT_EQUAL(m._rtree.begin()->first, - ta.getMin()); + EXPECT_FALSE(m._rtree.empty()) << (failed = true, ""); + if (failed) { + return false; + } + EXPECT_EQ(m._rtree.rbegin()->first, ta.getMax()) << (failed = true, ""); + EXPECT_EQ(m._rtree.begin()->first, ta.getMin()) << (failed = true, ""); } else { - return EXPECT_TRUE(m._rtree.empty()) && - EXPECT_EQUAL(std::numeric_limits<int32_t>::min(), - ta.getMax()) && - EXPECT_EQUAL(std::numeric_limits<int32_t>::max(), - ta.getMin()); + EXPECT_TRUE(m._rtree.empty()) << (failed = true, ""); + EXPECT_EQ(std::numeric_limits<int32_t>::min(), ta.getMax()) << (failed = true, ""); + EXPECT_EQ(std::numeric_limits<int32_t>::max(), ta.getMin()) << (failed = true, ""); } + return !failed; } template <typename TreeStore> bool -Test::assertAggregated(const MockTree &m, const TreeStore &s, EntryRef ref) +BTreeAggregationTest::assertAggregated(const MockTree &m, const TreeStore &s, EntryRef ref, const vespalib::string& label) { + SCOPED_TRACE(label); typename TreeStore::Iterator i(s.begin(ref)); MinMaxAggregated sa(s.getAggregated(ref)); const MinMaxAggregated &ia(i.getAggregated()); + bool failed = false; if (ref.valid()) { - return - EXPECT_FALSE(m._rtree.empty()) && - EXPECT_EQUAL(m._rtree.rbegin()->first, - ia.getMax()) && - EXPECT_EQUAL(m._rtree.begin()->first, - ia.getMin()) && - EXPECT_EQUAL(m._rtree.rbegin()->first, - sa.getMax()) && - EXPECT_EQUAL(m._rtree.begin()->first, - sa.getMin()); + EXPECT_FALSE(m._rtree.empty()) << (failed = true, ""); + if (failed) { + return false; + } + EXPECT_EQ(m._rtree.rbegin()->first, ia.getMax()) << (failed = true, ""); + EXPECT_EQ(m._rtree.begin()->first, ia.getMin()) << (failed = true, ""); + EXPECT_EQ(m._rtree.rbegin()->first, sa.getMax()) << (failed = true, ""); + EXPECT_EQ(m._rtree.begin()->first, sa.getMin()) << (failed = true, ""); } else { - return EXPECT_TRUE(m._rtree.empty()) && - EXPECT_EQUAL(std::numeric_limits<int32_t>::min(), - ia.getMax()) && - EXPECT_EQUAL(std::numeric_limits<int32_t>::max(), - ia.getMin()) && - EXPECT_EQUAL(std::numeric_limits<int32_t>::min(), - sa.getMax()) && - EXPECT_EQUAL(std::numeric_limits<int32_t>::max(), - sa.getMin()); + EXPECT_TRUE(m._rtree.empty()) << (failed = true, ""); + EXPECT_EQ(std::numeric_limits<int32_t>::min(), ia.getMax()) << (failed = true, ""); + EXPECT_EQ(std::numeric_limits<int32_t>::max(), ia.getMin()) << (failed = true, ""); + EXPECT_EQ(std::numeric_limits<int32_t>::min(), sa.getMax()) << (failed =true, ""); + EXPECT_EQ(std::numeric_limits<int32_t>::max(), sa.getMin()) << (failed =true, ""); } + return !failed; } -void -Test::requireThatNodeInsertWorks() +TEST_F(BTreeAggregationTest, require_that_node_insert_works) { MyTree t; t.insert(20, 102); @@ -336,7 +316,8 @@ Test::requireThatNodeInsertWorks() EXPECT_TRUE(assertTree("{{10:101,20:102,30:103,40:104[min=101,max=104]}}", t)); } -void Test::keys_are_aggregated_correctly_on_node_insertions() { +TEST_F(BTreeAggregationTest, keys_are_aggregated_correctly_on_node_insertions) +{ MyKeyAggrTree t; t.insert(20, 102); EXPECT_TRUE(assertTree("{{20:102[min=20,max=20]}}", t)); @@ -367,8 +348,7 @@ populateLeafNode(Tree &t) populateTree(t, 4, 2); } -void -Test::requireThatNodeSplitInsertWorks() +TEST_F(BTreeAggregationTest, require_that_node_split_insert_works) { { // new entry in current node MyTree t; @@ -396,7 +376,8 @@ Test::requireThatNodeSplitInsertWorks() } } -void Test::keys_are_aggregated_correctly_when_node_split_on_insert() { +TEST_F(BTreeAggregationTest, keys_are_aggregated_correctly_when_node_split_on_insert) +{ { // new entry in current node MyKeyAggrTree t; populateLeafNode(t); @@ -423,8 +404,7 @@ void Test::keys_are_aggregated_correctly_when_node_split_on_insert() { } } -void -Test::requireThatTreeInsertWorks() +TEST_F(BTreeAggregationTest, require_that_tree_insert_works) { { // multi level node split MyTree t; @@ -523,8 +503,7 @@ struct BTreeStealTraits } -void -Test::requireThatNodeStealWorks() +TEST_F(BTreeAggregationTest, require_that_node_steal_works) { typedef BTree<MyKey, int32_t, btree::MinMaxAggregated, @@ -602,8 +581,7 @@ Test::requireThatNodeStealWorks() } } -void -Test::requireThatNodeRemoveWorks() +TEST_F(BTreeAggregationTest, require_that_node_remove_works) { MyTree t; populateLeafNode(t); @@ -615,7 +593,8 @@ Test::requireThatNodeRemoveWorks() EXPECT_TRUE(assertTree("{{5:105[min=105,max=105]}}", t)); } -void Test::keys_are_aggregated_correctly_on_node_removal() { +TEST_F(BTreeAggregationTest, keys_are_aggregated_correctly_on_node_removal) +{ MyKeyAggrTree t; populateLeafNode(t); t.remove(3); @@ -640,7 +619,7 @@ generateData(std::vector<LeafPair> & data, size_t numEntries) } void -Test::buildSubTree(const std::vector<LeafPair> &sub, +BTreeAggregationTest::buildSubTree(const std::vector<LeafPair> &sub, size_t numEntries) { GenerationHandler g; @@ -660,31 +639,31 @@ Test::buildSubTree(const std::vector<LeafPair> &sub, assert(numEntries == tree.size()); assert(tree.isValid()); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, tree))); - EXPECT_EQUAL(numEntries, tree.size()); + EXPECT_TRUE(assertAggregated(mock, tree, "build_sub_tree")); + EXPECT_EQ(numEntries, tree.size()); EXPECT_TRUE(tree.isValid()); MyTree::Iterator itr = tree.begin(); MyTree::Iterator ritr = itr; if (numEntries > 0) { EXPECT_TRUE(ritr.valid()); - EXPECT_EQUAL(0u, ritr.position()); + EXPECT_EQ(0u, ritr.position()); --ritr; EXPECT_TRUE(!ritr.valid()); - EXPECT_EQUAL(numEntries, ritr.position()); + EXPECT_EQ(numEntries, ritr.position()); --ritr; EXPECT_TRUE(ritr.valid()); - EXPECT_EQUAL(numEntries - 1, ritr.position()); + EXPECT_EQ(numEntries - 1, ritr.position()); } else { EXPECT_TRUE(!ritr.valid()); - EXPECT_EQUAL(0u, ritr.position()); + EXPECT_EQ(0u, ritr.position()); --ritr; EXPECT_TRUE(!ritr.valid()); - EXPECT_EQUAL(0u, ritr.position()); + EXPECT_EQ(0u, ritr.position()); } for (size_t i = 0; i < numEntries; ++i) { EXPECT_TRUE(itr.valid()); - EXPECT_EQUAL(sorted[i].first, itr.getKey()); - EXPECT_EQUAL(sorted[i].second, itr.getData()); + EXPECT_EQ(sorted[i].first, itr.getKey()); + EXPECT_EQ(sorted[i].second, itr.getData()); ++itr; } EXPECT_TRUE(!itr.valid()); @@ -693,22 +672,21 @@ Test::buildSubTree(const std::vector<LeafPair> &sub, --ritr; for (size_t i = 0; i < numEntries; ++i) { EXPECT_TRUE(ritr.valid()); - EXPECT_EQUAL(sorted[numEntries - 1 - i].first, ritr.getKey()); - EXPECT_EQUAL(sorted[numEntries - 1 - i].second, ritr.getData()); + EXPECT_EQ(sorted[numEntries - 1 - i].first, ritr.getKey()); + EXPECT_EQ(sorted[numEntries - 1 - i].second, ritr.getData()); --ritr; } EXPECT_TRUE(!ritr.valid()); } -void -Test::requireThatWeCanInsertAndRemoveFromTree() +TEST_F(BTreeAggregationTest, require_that_we_can_insert_and_remove_from_tree) { GenerationHandler g; MyTree tree; MockTree mock; std::vector<LeafPair> exp; std::vector<LeafPair> sorted; - TEST_DO(EXPECT_TRUE(assertAggregated(mock, tree))); + EXPECT_TRUE(assertAggregated(mock, tree, "insert_and_remove_1")); size_t numEntries = 1000; generateData(exp, numEntries); sorted = exp; @@ -722,15 +700,15 @@ Test::requireThatWeCanInsertAndRemoveFromTree() EXPECT_TRUE(tree.insert(num, val)); EXPECT_TRUE(!tree.insert(num, val)); mock.insert(num, val); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, tree))); + EXPECT_TRUE(assertAggregated(mock, tree, "insert_and_remove_2")); for (size_t j = 0; j <= i; ++j) { //LOG(info, "find[%zu](%d)", j, exp[j].first._val); MyTree::Iterator itr = tree.find(exp[j].first); EXPECT_TRUE(itr.valid()); - EXPECT_EQUAL(exp[j].first, itr.getKey()); - EXPECT_EQUAL(exp[j].second, itr.getData()); + EXPECT_EQ(exp[j].first, itr.getKey()); + EXPECT_EQ(exp[j].second, itr.getData()); } - EXPECT_EQUAL(i + 1u, tree.size()); + EXPECT_EQ(i + 1u, tree.size()); EXPECT_TRUE(tree.isValid()); buildSubTree(exp, i + 1); } @@ -745,36 +723,36 @@ Test::requireThatWeCanInsertAndRemoveFromTree() ++itre; if (numEntries > 0) { EXPECT_TRUE(ritr.valid()); - EXPECT_EQUAL(0u, ritr.position()); + EXPECT_EQ(0u, ritr.position()); --ritr; EXPECT_TRUE(!ritr.valid()); - EXPECT_EQUAL(numEntries, ritr.position()); + EXPECT_EQ(numEntries, ritr.position()); --ritr; EXPECT_TRUE(ritr.valid()); - EXPECT_EQUAL(numEntries - 1, ritr.position()); + EXPECT_EQ(numEntries - 1, ritr.position()); } else { EXPECT_TRUE(!ritr.valid()); - EXPECT_EQUAL(0u, ritr.position()); + EXPECT_EQ(0u, ritr.position()); --ritr; EXPECT_TRUE(!ritr.valid()); - EXPECT_EQUAL(0u, ritr.position()); + EXPECT_EQ(0u, ritr.position()); } MyTree::Iterator pitr = itr; for (size_t i = 0; i < numEntries; ++i) { ssize_t si = i; ssize_t sileft = numEntries - i; EXPECT_TRUE(itr.valid()); - EXPECT_EQUAL(i, itr.position()); - EXPECT_EQUAL(sileft, itre - itr); - EXPECT_EQUAL(-sileft, itr - itre); - EXPECT_EQUAL(sileft, itre2 - itr); - EXPECT_EQUAL(-sileft, itr - itre2); - EXPECT_EQUAL(si, itr - tree.begin()); - EXPECT_EQUAL(-si, tree.begin() - itr); - EXPECT_EQUAL(i != 0, itr - pitr); - EXPECT_EQUAL(-(i != 0), pitr - itr); - EXPECT_EQUAL(sorted[i].first, itr.getKey()); - EXPECT_EQUAL(sorted[i].second, itr.getData()); + EXPECT_EQ(i, itr.position()); + EXPECT_EQ(sileft, itre - itr); + EXPECT_EQ(-sileft, itr - itre); + EXPECT_EQ(sileft, itre2 - itr); + EXPECT_EQ(-sileft, itr - itre2); + EXPECT_EQ(si, itr - tree.begin()); + EXPECT_EQ(-si, tree.begin() - itr); + EXPECT_EQ(i != 0, itr - pitr); + EXPECT_EQ(-(i != 0), pitr - itr); + EXPECT_EQ(sorted[i].first, itr.getKey()); + EXPECT_EQ(sorted[i].second, itr.getData()); pitr = itr; ++itr; ritr = itr; @@ -783,12 +761,12 @@ Test::requireThatWeCanInsertAndRemoveFromTree() EXPECT_TRUE(ritr == pitr); } EXPECT_TRUE(!itr.valid()); - EXPECT_EQUAL(numEntries, itr.position()); + EXPECT_EQ(numEntries, itr.position()); ssize_t sNumEntries = numEntries; - EXPECT_EQUAL(sNumEntries, itr - tree.begin()); - EXPECT_EQUAL(-sNumEntries, tree.begin() - itr); - EXPECT_EQUAL(1, itr - pitr); - EXPECT_EQUAL(-1, pitr - itr); + EXPECT_EQ(sNumEntries, itr - tree.begin()); + EXPECT_EQ(-sNumEntries, tree.begin() - itr); + EXPECT_EQ(1, itr - pitr); + EXPECT_EQ(-1, pitr - itr); } // compact full tree by calling incremental compaction methods in a loop { @@ -818,52 +796,50 @@ Test::requireThatWeCanInsertAndRemoveFromTree() EXPECT_TRUE(!tree.remove(num)); EXPECT_TRUE(tree.isValid()); mock.erase(num); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, tree))); + EXPECT_TRUE(assertAggregated(mock, tree, "insert_and_remove3")); for (size_t j = i + 1; j < numEntries; ++j) { MyTree::Iterator itr = tree.find(exp[j].first); EXPECT_TRUE(itr.valid()); - EXPECT_EQUAL(exp[j].first, itr.getKey()); - EXPECT_EQUAL(exp[j].second, itr.getData()); + EXPECT_EQ(exp[j].first, itr.getKey()); + EXPECT_EQ(exp[j].second, itr.getData()); } - EXPECT_EQUAL(numEntries - 1 - i, tree.size()); + EXPECT_EQ(numEntries - 1 - i, tree.size()); } } -void -Test::requireThatSortedTreeInsertWorks() +TEST_F(BTreeAggregationTest, require_that_sorted_tree_insert_works) { { MyTree tree; MockTree mock; - TEST_DO(EXPECT_TRUE(assertAggregated(mock, tree))); + EXPECT_TRUE(assertAggregated(mock, tree, "sorted_tree_insert1")); for (int i = 0; i < 1000; ++i) { EXPECT_TRUE(tree.insert(i, toVal(i))); mock.insert(i, toVal(i)); MyTree::Iterator itr = tree.find(i); EXPECT_TRUE(itr.valid()); - EXPECT_EQUAL(toVal(i), itr.getData()); + EXPECT_EQ(toVal(i), itr.getData()); EXPECT_TRUE(tree.isValid()); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, tree))); + EXPECT_TRUE(assertAggregated(mock, tree, "sorted_tree_insert2")); } } { MyTree tree; MockTree mock; - TEST_DO(EXPECT_TRUE(assertAggregated(mock, tree))); + EXPECT_TRUE(assertAggregated(mock, tree, "sorted_tree_insert3")); for (int i = 1000; i > 0; --i) { EXPECT_TRUE(tree.insert(i, toVal(i))); mock.insert(i, toVal(i)); MyTree::Iterator itr = tree.find(i); EXPECT_TRUE(itr.valid()); - EXPECT_EQUAL(toVal(i), itr.getData()); + EXPECT_EQ(toVal(i), itr.getData()); EXPECT_TRUE(tree.isValid()); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, tree))); + EXPECT_TRUE(assertAggregated(mock, tree, "sorted_tree_insert4")); } } } -void -Test::requireThatCornerCaseTreeFindWorks() +TEST_F(BTreeAggregationTest, require_that_corner_case_tree_find_works) { GenerationHandler g; MyTree tree; @@ -874,8 +850,7 @@ Test::requireThatCornerCaseTreeFindWorks() EXPECT_TRUE(!tree.find(1000).valid()); // higher than highest } -void -Test::requireThatBasicTreeIteratorWorks() +TEST_F(BTreeAggregationTest, require_that_basic_tree_iterator_works) { GenerationHandler g; MyTree tree; @@ -890,27 +865,24 @@ Test::requireThatBasicTreeIteratorWorks() size_t ei = 0; MyTree::Iterator itr = tree.begin(); MyTree::Iterator ritr; - EXPECT_EQUAL(1000u, itr.size()); + EXPECT_EQ(1000u, itr.size()); for (; itr.valid(); ++itr) { //LOG(info, "itr(%d, %s)", itr.getKey(), itr.getData().c_str()); - EXPECT_EQUAL(UNWRAP(exp[ei].first), UNWRAP(itr.getKey())); - EXPECT_EQUAL(exp[ei].second, itr.getData()); + EXPECT_EQ(UNWRAP(exp[ei].first), UNWRAP(itr.getKey())); + EXPECT_EQ(exp[ei].second, itr.getData()); ei++; ritr = itr; } - EXPECT_EQUAL(numEntries, ei); + EXPECT_EQ(numEntries, ei); for (; ritr.valid(); --ritr) { --ei; //LOG(info, "itr(%d, %s)", itr.getKey(), itr.getData().c_str()); - EXPECT_EQUAL(UNWRAP(exp[ei].first), UNWRAP(ritr.getKey())); - EXPECT_EQUAL(exp[ei].second, ritr.getData()); + EXPECT_EQ(UNWRAP(exp[ei].first), UNWRAP(ritr.getKey())); + EXPECT_EQ(exp[ei].second, ritr.getData()); } } - - -void -Test::requireThatTreeIteratorAssignWorks() +TEST_F(BTreeAggregationTest, require_that_tree_iterator_assign_works) { GenerationHandler g; MyTree tree; @@ -923,9 +895,9 @@ Test::requireThatTreeIteratorAssignWorks() EXPECT_TRUE(itr == itr2); int expNum = i; for (; itr2.valid(); ++itr2) { - EXPECT_EQUAL(expNum++, UNWRAP(itr2.getKey())); + EXPECT_EQ(expNum++, UNWRAP(itr2.getKey())); } - EXPECT_EQUAL(1000, expNum); + EXPECT_EQ(1000, expNum); } } @@ -940,8 +912,7 @@ struct UpdKeyComp { } }; -void -Test::requireThatUpdateOfKeyWorks() +TEST_F(BTreeAggregationTest, require_that_update_of_key_works) { using UpdKeyTree = BTree<int, BTreeNoLeafData, btree::NoAggregated, UpdKeyComp &>; using UpdKeyTreeIterator = UpdKeyTree::Iterator; @@ -951,7 +922,7 @@ Test::requireThatUpdateOfKeyWorks() for (int i = 0; i < 1000; i+=2) { EXPECT_TRUE(t.insert(i, BTreeNoLeafData(), cmp1)); } - EXPECT_EQUAL(0u, cmp1._numErrors); + EXPECT_EQ(0u, cmp1._numErrors); for (int i = 0; i < 1000; i+=2) { UpdKeyTreeIterator itr = t.find(i, cmp1); itr.writeKey(i + 1); @@ -961,23 +932,22 @@ Test::requireThatUpdateOfKeyWorks() UpdKeyTreeIterator itr = t.find(i, cmp2); EXPECT_TRUE(itr.valid()); } - EXPECT_EQUAL(0u, cmp2._numErrors); + EXPECT_EQ(0u, cmp2._numErrors); } -void -Test::requireThatUpdateOfDataWorks() +TEST_F(BTreeAggregationTest, require_that_update_of_data_works) { GenerationHandler g; MyTree t; MockTree mock; MyAggrCalc ac; MyTree::NodeAllocatorType &manager = t.getAllocator(); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, t))); + EXPECT_TRUE(assertAggregated(mock, t, "update_data1")); for (int i = 0; i < 1000; i+=2) { EXPECT_TRUE(t.insert(i, toVal(i))); mock.insert(i, toVal(i)); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, t))); + EXPECT_TRUE(assertAggregated(mock, t, "udate_data2")); } freezeTree(g, manager); for (int i = 0; i < 1000; i+=2) { @@ -985,31 +955,31 @@ Test::requireThatUpdateOfDataWorks() MyTree::Iterator itr2 = itr; t.thaw(itr); itr.updateData(toHighVal(i), ac); - EXPECT_EQUAL(toHighVal(i), itr.getData()); - EXPECT_EQUAL(toVal(i), itr2.getData()); + EXPECT_EQ(toHighVal(i), itr.getData()); + EXPECT_EQ(toVal(i), itr2.getData()); mock.erase(i); mock.insert(i, toHighVal(i)); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, t))); + EXPECT_TRUE(assertAggregated(mock, t, "update_data3")); freezeTree(g, manager); itr = t.find(i); itr2 = itr; t.thaw(itr); itr.updateData(toLowVal(i), ac); - EXPECT_EQUAL(toLowVal(i), itr.getData()); - EXPECT_EQUAL(toHighVal(i), itr2.getData()); + EXPECT_EQ(toLowVal(i), itr.getData()); + EXPECT_EQ(toHighVal(i), itr2.getData()); mock.erase(i); mock.insert(i, toLowVal(i)); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, t))); + EXPECT_TRUE(assertAggregated(mock, t, "update_data4")); freezeTree(g, manager); itr = t.find(i); itr2 = itr; t.thaw(itr); itr.updateData(toVal(i), ac); - EXPECT_EQUAL(toVal(i), itr.getData()); - EXPECT_EQUAL(toLowVal(i), itr2.getData()); + EXPECT_EQ(toVal(i), itr.getData()); + EXPECT_EQ(toLowVal(i), itr2.getData()); mock.erase(i); mock.insert(i, toVal(i)); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, t))); + EXPECT_TRUE(assertAggregated(mock, t, "update_data5")); freezeTree(g, manager); } } @@ -1030,68 +1000,67 @@ remove(MyTreeStore& s, EntryRef& root, MyTreeStore::KeyType removal) } -void -Test::requireThatSmallNodesWorks() +TEST_F(BTreeAggregationTest, require_that_small_nodes_works) { GenerationHandler g; MyTreeStore s; MockTree mock; EntryRef root; - EXPECT_EQUAL(0u, s.size(root)); + EXPECT_EQ(0u, s.size(root)); EXPECT_TRUE(s.isSmallArray(root)); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, s, root))); + EXPECT_TRUE(assertAggregated(mock, s, root, "small1")); insert(s, root, {40, toVal(40)}); mock.insert(40, toVal(40)); - EXPECT_EQUAL(1u, s.size(root)); + EXPECT_EQ(1u, s.size(root)); EXPECT_TRUE(s.isSmallArray(root)); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, s, root))); + EXPECT_TRUE(assertAggregated(mock, s, root, "small2")); insert(s, root, {20, toVal(20)}); mock.insert(20, toVal(20)); - EXPECT_EQUAL(2u, s.size(root)); + EXPECT_EQ(2u, s.size(root)); EXPECT_TRUE(s.isSmallArray(root)); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, s, root))); + EXPECT_TRUE(assertAggregated(mock, s, root, "small3")); insert(s, root, {60, toVal(60)}); mock.insert(60, toVal(60)); - EXPECT_EQUAL(3u, s.size(root)); + EXPECT_EQ(3u, s.size(root)); EXPECT_TRUE(s.isSmallArray(root)); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, s, root))); + EXPECT_TRUE(assertAggregated(mock, s, root, "small4")); insert(s, root, {50, toVal(50)}); mock.insert(50, toVal(50)); - EXPECT_EQUAL(4u, s.size(root)); + EXPECT_EQ(4u, s.size(root)); EXPECT_TRUE(s.isSmallArray(root)); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, s, root))); + EXPECT_TRUE(assertAggregated(mock, s, root, "small5")); for (uint32_t i = 0; i < 100; ++i) { insert(s, root, {int(1000 + i), 42}); mock.insert(1000 + i, 42); - EXPECT_EQUAL(5u + i, s.size(root)); - EXPECT_EQUAL(5u + i <= MyTreeStore::clusterLimit, s.isSmallArray(root)); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, s, root))); + EXPECT_EQ(5u + i, s.size(root)); + EXPECT_EQ(5u + i <= MyTreeStore::clusterLimit, s.isSmallArray(root)); + EXPECT_TRUE(assertAggregated(mock, s, root, "small6")); } remove(s, root, 40); mock.erase(40); - EXPECT_EQUAL(103u, s.size(root)); + EXPECT_EQ(103u, s.size(root)); EXPECT_TRUE(!s.isSmallArray(root)); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, s, root))); + EXPECT_TRUE(assertAggregated(mock, s, root, "small7")); remove(s, root, 20); mock.erase(20); - EXPECT_EQUAL(102u, s.size(root)); + EXPECT_EQ(102u, s.size(root)); EXPECT_TRUE(!s.isSmallArray(root)); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, s, root))); + EXPECT_TRUE(assertAggregated(mock, s, root, "small8")); remove(s, root, 50); mock.erase(50); - EXPECT_EQUAL(101u, s.size(root)); + EXPECT_EQ(101u, s.size(root)); EXPECT_TRUE(!s.isSmallArray(root)); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, s, root))); + EXPECT_TRUE(assertAggregated(mock, s, root, "small9")); for (uint32_t i = 0; i < 100; ++i) { remove(s, root, 1000 + i); mock.erase(1000 + i); - EXPECT_EQUAL(100 - i, s.size(root)); - EXPECT_EQUAL(100 - i <= MyTreeStore::clusterLimit, s.isSmallArray(root)); - TEST_DO(EXPECT_TRUE(assertAggregated(mock, s, root))); + EXPECT_EQ(100 - i, s.size(root)); + EXPECT_EQ(100 - i <= MyTreeStore::clusterLimit, s.isSmallArray(root)); + EXPECT_TRUE(assertAggregated(mock, s, root, "small10")); } - EXPECT_EQUAL(1u, s.size(root)); + EXPECT_EQ(1u, s.size(root)); EXPECT_TRUE(s.isSmallArray(root)); s.clear(root); @@ -1102,8 +1071,7 @@ Test::requireThatSmallNodesWorks() s.reclaim_memory(g.get_oldest_used_generation()); } -void -Test::requireThatFrozenViewProvidesAggregatedValues() +TEST_F(BTreeAggregationTest, require_that_frozen_view_provides_aggregated_values) { MyTree t; t.insert(20, 102); @@ -1114,39 +1082,13 @@ Test::requireThatFrozenViewProvidesAggregatedValues() t.getAllocator().freeze(); auto new_view = t.getFrozenView(); auto new_aggregated = new_view.getAggregated(); - EXPECT_EQUAL(new_aggregated.getMin(), 101); - EXPECT_EQUAL(new_aggregated.getMax(), 104); + EXPECT_EQ(new_aggregated.getMin(), 101); + EXPECT_EQ(new_aggregated.getMax(), 104); auto old_aggregated = old_view.getAggregated(); - EXPECT_EQUAL(old_aggregated.getMin(), std::numeric_limits<int32_t>::max()); - EXPECT_EQUAL(old_aggregated.getMax(), std::numeric_limits<int32_t>::min()); -} - -int -Test::Main() -{ - TEST_INIT("btreeaggregation_test"); - - requireThatNodeInsertWorks(); - keys_are_aggregated_correctly_on_node_insertions(); - requireThatNodeSplitInsertWorks(); - keys_are_aggregated_correctly_when_node_split_on_insert(); - requireThatTreeInsertWorks(); - requireThatNodeStealWorks(); - requireThatNodeRemoveWorks(); - keys_are_aggregated_correctly_on_node_removal(); - requireThatWeCanInsertAndRemoveFromTree(); - requireThatSortedTreeInsertWorks(); - requireThatCornerCaseTreeFindWorks(); - requireThatBasicTreeIteratorWorks(); - requireThatTreeIteratorAssignWorks(); - requireThatUpdateOfKeyWorks(); - requireThatUpdateOfDataWorks(); - TEST_DO(requireThatSmallNodesWorks()); - TEST_DO(requireThatFrozenViewProvidesAggregatedValues()); - - TEST_DONE(); + EXPECT_EQ(old_aggregated.getMin(), std::numeric_limits<int32_t>::max()); + EXPECT_EQ(old_aggregated.getMax(), std::numeric_limits<int32_t>::min()); } } -TEST_APPHOOK(vespalib::btree::Test); +GTEST_MAIN_RUN_ALL_TESTS() |