diff options
Diffstat (limited to 'vespalib/src/tests')
4 files changed, 163 insertions, 137 deletions
diff --git a/vespalib/src/tests/util/generation_holder/CMakeLists.txt b/vespalib/src/tests/util/generation_holder/CMakeLists.txt new file mode 100644 index 00000000000..8acf9fadaff --- /dev/null +++ b/vespalib/src/tests/util/generation_holder/CMakeLists.txt @@ -0,0 +1,9 @@ +# Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +vespa_add_executable(vespalib_generation_holder_test_app TEST + SOURCES + generation_holder_test.cpp + DEPENDS + vespalib + GTest::GTest +) +vespa_add_test(NAME vespalib_generation_holder_test_app COMMAND vespalib_generation_holder_test_app) diff --git a/vespalib/src/tests/util/generation_holder/generation_holder_test.cpp b/vespalib/src/tests/util/generation_holder/generation_holder_test.cpp new file mode 100644 index 00000000000..97c3330ac9e --- /dev/null +++ b/vespalib/src/tests/util/generation_holder/generation_holder_test.cpp @@ -0,0 +1,38 @@ +// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. + +#include <vespa/vespalib/gtest/gtest.h> +#include <vespa/vespalib/util/generationholder.h> + +using vespalib::GenerationHolder; +using MyHeld = vespalib::GenerationHeldBase; + +TEST(GenerationHolderTest, basic_tracking) +{ + GenerationHolder gh; + gh.hold(std::make_unique<MyHeld>(sizeof(int32_t))); + gh.transferHoldLists(0); + gh.hold(std::make_unique<MyHeld>(sizeof(int32_t))); + gh.transferHoldLists(1); + gh.hold(std::make_unique<MyHeld>(sizeof(int32_t))); + gh.transferHoldLists(2); + gh.hold(std::make_unique<MyHeld>(sizeof(int32_t))); + gh.transferHoldLists(4); + EXPECT_EQ(4u * sizeof(int32_t), gh.getHeldBytes()); + gh.trimHoldLists(0); + EXPECT_EQ(4u * sizeof(int32_t), gh.getHeldBytes()); + gh.trimHoldLists(1); + EXPECT_EQ(3u * sizeof(int32_t), gh.getHeldBytes()); + gh.trimHoldLists(2); + EXPECT_EQ(2u * sizeof(int32_t), gh.getHeldBytes()); + gh.hold(std::make_unique<MyHeld>(sizeof(int32_t))); + gh.transferHoldLists(6); + EXPECT_EQ(3u * sizeof(int32_t), gh.getHeldBytes()); + gh.trimHoldLists(6); + EXPECT_EQ(1u * sizeof(int32_t), gh.getHeldBytes()); + gh.trimHoldLists(7); + EXPECT_EQ(0u * sizeof(int32_t), gh.getHeldBytes()); + gh.trimHoldLists(7); + EXPECT_EQ(0u * sizeof(int32_t), gh.getHeldBytes()); +} + +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/vespalib/src/tests/util/rcuvector/CMakeLists.txt b/vespalib/src/tests/util/rcuvector/CMakeLists.txt index 60e8dc60d43..6b29b73305b 100644 --- a/vespalib/src/tests/util/rcuvector/CMakeLists.txt +++ b/vespalib/src/tests/util/rcuvector/CMakeLists.txt @@ -4,5 +4,6 @@ vespa_add_executable(vespalib_rcuvector_test_app TEST rcuvector_test.cpp DEPENDS vespalib + GTest::GTest ) vespa_add_test(NAME vespalib_rcuvector_test_app COMMAND vespalib_rcuvector_test_app) diff --git a/vespalib/src/tests/util/rcuvector/rcuvector_test.cpp b/vespalib/src/tests/util/rcuvector/rcuvector_test.cpp index e36d7da7b6a..58256a96dac 100644 --- a/vespalib/src/tests/util/rcuvector/rcuvector_test.cpp +++ b/vespalib/src/tests/util/rcuvector/rcuvector_test.cpp @@ -1,6 +1,6 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/vespalib/testkit/testapp.h> +#include <vespa/vespalib/gtest/gtest.h> #include <vespa/vespalib/test/memory_allocator_observer.h> #include <vespa/vespalib/util/rcuvector.h> #include <vespa/vespalib/util/round_up_to_page_size.h> @@ -17,100 +17,71 @@ bool assertUsage(const MemoryUsage & exp, const MemoryUsage & act) { bool retval = true; - if (!EXPECT_EQUAL(exp.allocatedBytes(), act.allocatedBytes())) retval = false; - if (!EXPECT_EQUAL(exp.usedBytes(), act.usedBytes())) retval = false; - if (!EXPECT_EQUAL(exp.deadBytes(), act.deadBytes())) retval = false; - if (!EXPECT_EQUAL(exp.allocatedBytesOnHold(), act.allocatedBytesOnHold())) retval = false; + EXPECT_EQ(exp.allocatedBytes(), act.allocatedBytes()) << (retval = false, ""); + EXPECT_EQ(exp.usedBytes(), act.usedBytes()) << (retval = false, ""); + EXPECT_EQ(exp.deadBytes(), act.deadBytes()) << (retval = false, ""); + EXPECT_EQ(exp.allocatedBytesOnHold(), act.allocatedBytesOnHold()) << ( retval = false, ""); return retval; } -TEST("test generation holder") -{ - GenerationHolder gh; - gh.hold(std::make_unique<RcuVectorHeld<int32_t>>(sizeof(int32_t), 0)); - gh.transferHoldLists(0); - gh.hold(std::make_unique<RcuVectorHeld<int32_t>>(sizeof(int32_t), 1)); - gh.transferHoldLists(1); - gh.hold(std::make_unique<RcuVectorHeld<int32_t>>(sizeof(int32_t), 2)); - gh.transferHoldLists(2); - gh.hold(std::make_unique<RcuVectorHeld<int32_t>>(sizeof(int32_t), 4)); - gh.transferHoldLists(4); - EXPECT_EQUAL(4u * sizeof(int32_t), gh.getHeldBytes()); - gh.trimHoldLists(0); - EXPECT_EQUAL(4u * sizeof(int32_t), gh.getHeldBytes()); - gh.trimHoldLists(1); - EXPECT_EQUAL(3u * sizeof(int32_t), gh.getHeldBytes()); - gh.trimHoldLists(2); - EXPECT_EQUAL(2u * sizeof(int32_t), gh.getHeldBytes()); - gh.hold(std::make_unique<RcuVectorHeld<int32_t>>(sizeof(int32_t), 6)); - gh.transferHoldLists(6); - EXPECT_EQUAL(3u * sizeof(int32_t), gh.getHeldBytes()); - gh.trimHoldLists(6); - EXPECT_EQUAL(1u * sizeof(int32_t), gh.getHeldBytes()); - gh.trimHoldLists(7); - EXPECT_EQUAL(0u * sizeof(int32_t), gh.getHeldBytes()); - gh.trimHoldLists(7); - EXPECT_EQUAL(0u * sizeof(int32_t), gh.getHeldBytes()); -} - -TEST("test basic") +TEST(RcuVectorTest, basic) { { // insert RcuVector<int32_t> v(4, 0, 4); for (int32_t i = 0; i < 100; ++i) { v.push_back(i); - EXPECT_EQUAL(i, v[i]); - EXPECT_EQUAL((size_t)i + 1, v.size()); + EXPECT_EQ(i, v[i]); + EXPECT_EQ((size_t)i + 1, v.size()); } for (int32_t i = 0; i < 100; ++i) { v[i] = i + 1; - EXPECT_EQUAL(i + 1, v[i]); - EXPECT_EQUAL(100u, v.size()); + EXPECT_EQ(i + 1, v[i]); + EXPECT_EQ(100u, v.size()); } } } -TEST("test resize") +TEST(RcuVectorTest, resize) { { // resize percent RcuVector<int32_t> v(2, 50, 0); - EXPECT_EQUAL(2u, v.capacity()); + EXPECT_EQ(2u, v.capacity()); v.push_back(0); - EXPECT_EQUAL(2u, v.capacity()); + EXPECT_EQ(2u, v.capacity()); v.push_back(0); - EXPECT_EQUAL(2u, v.capacity()); + EXPECT_EQ(2u, v.capacity()); EXPECT_TRUE(v.isFull()); v.push_back(0); - EXPECT_EQUAL(3u, v.capacity()); + EXPECT_EQ(3u, v.capacity()); EXPECT_TRUE(v.isFull()); } { // resize delta RcuVector<int32_t> v(1, 0, 3); - EXPECT_EQUAL(1u, v.capacity()); + EXPECT_EQ(1u, v.capacity()); v.push_back(0); - EXPECT_EQUAL(1u, v.capacity()); + EXPECT_EQ(1u, v.capacity()); EXPECT_TRUE(v.isFull()); v.push_back(0); - EXPECT_EQUAL(4u, v.capacity()); + EXPECT_EQ(4u, v.capacity()); EXPECT_TRUE(!v.isFull()); } { // resize both RcuVector<int32_t> v(2, 200, 3); - EXPECT_EQUAL(2u, v.capacity()); + EXPECT_EQ(2u, v.capacity()); v.push_back(0); - EXPECT_EQUAL(2u, v.capacity()); + EXPECT_EQ(2u, v.capacity()); v.push_back(0); - EXPECT_EQUAL(2u, v.capacity()); + EXPECT_EQ(2u, v.capacity()); EXPECT_TRUE(v.isFull()); v.push_back(0); - EXPECT_EQUAL(9u, v.capacity()); + EXPECT_EQ(9u, v.capacity()); EXPECT_TRUE(!v.isFull()); } { // reserve RcuVector<int32_t> v(2, 0, 0); - EXPECT_EQUAL(2u, v.capacity()); + EXPECT_EQ(2u, v.capacity()); v.unsafe_reserve(8); - EXPECT_EQUAL(8u, v.capacity()); + EXPECT_EQ(8u, v.capacity()); } { // explicit resize GenerationHolder g; @@ -120,71 +91,72 @@ TEST("test resize") g.transferHoldLists(0); g.trimHoldLists(1); const int8_t *old = &v[0]; - EXPECT_EQUAL(16u, v.capacity()); - EXPECT_EQUAL(2u, v.size()); + EXPECT_EQ(16u, v.capacity()); + EXPECT_EQ(2u, v.size()); v.ensure_size(32, 3); v[0] = 3; v[1] = 3; g.transferHoldLists(1); - EXPECT_EQUAL(1, old[0]); - EXPECT_EQUAL(2, old[1]); - EXPECT_EQUAL(3, v[0]); - EXPECT_EQUAL(3, v[1]); - EXPECT_EQUAL(3, v[2]); - EXPECT_EQUAL(3, v[31]); - EXPECT_EQUAL(64u, v.capacity()); - EXPECT_EQUAL(32u, v.size()); + EXPECT_EQ(1, old[0]); + EXPECT_EQ(2, old[1]); + EXPECT_EQ(3, v[0]); + EXPECT_EQ(3, v[1]); + EXPECT_EQ(3, v[2]); + EXPECT_EQ(3, v[31]); + EXPECT_EQ(64u, v.capacity()); + EXPECT_EQ(32u, v.size()); g.trimHoldLists(2); } } -TEST("test generation handling") +TEST(RcuVectorTest, generation_handling) { RcuVector<int32_t> v(2, 0, 2); v.push_back(0); v.push_back(10); - EXPECT_EQUAL(0u, v.getMemoryUsage().allocatedBytesOnHold()); + EXPECT_EQ(0u, v.getMemoryUsage().allocatedBytesOnHold()); v.push_back(20); // new array - EXPECT_EQUAL(8u, v.getMemoryUsage().allocatedBytesOnHold()); + EXPECT_EQ(8u, v.getMemoryUsage().allocatedBytesOnHold()); v.setGeneration(1); v.push_back(30); - EXPECT_EQUAL(8u, v.getMemoryUsage().allocatedBytesOnHold()); + EXPECT_EQ(8u, v.getMemoryUsage().allocatedBytesOnHold()); v.push_back(40); // new array - EXPECT_EQUAL(24u, v.getMemoryUsage().allocatedBytesOnHold()); + EXPECT_EQ(24u, v.getMemoryUsage().allocatedBytesOnHold()); v.setGeneration(2); v.push_back(50); v.removeOldGenerations(3); - EXPECT_EQUAL(0u, v.getMemoryUsage().allocatedBytesOnHold()); + EXPECT_EQ(0u, v.getMemoryUsage().allocatedBytesOnHold()); v.push_back(60); // new array - EXPECT_EQUAL(24u, v.getMemoryUsage().allocatedBytesOnHold()); + EXPECT_EQ(24u, v.getMemoryUsage().allocatedBytesOnHold()); } -TEST("test reserve") { +TEST(RcuVectorTest, reserve) +{ RcuVector<int32_t> v(2, 0, 2); - EXPECT_EQUAL(2u, v.capacity()); - EXPECT_EQUAL(0u, v.size()); + EXPECT_EQ(2u, v.capacity()); + EXPECT_EQ(0u, v.size()); v.push_back(0); v.push_back(10); - EXPECT_EQUAL(2u, v.size()); - EXPECT_EQUAL(2u, v.capacity()); - EXPECT_EQUAL(0u, v.getMemoryUsage().allocatedBytesOnHold()); + EXPECT_EQ(2u, v.size()); + EXPECT_EQ(2u, v.capacity()); + EXPECT_EQ(0u, v.getMemoryUsage().allocatedBytesOnHold()); v.reserve(30); - EXPECT_EQUAL(2u, v.size()); - EXPECT_EQUAL(32u, v.capacity()); - EXPECT_EQUAL(8u, v.getMemoryUsage().allocatedBytesOnHold()); + EXPECT_EQ(2u, v.size()); + EXPECT_EQ(32u, v.capacity()); + EXPECT_EQ(8u, v.getMemoryUsage().allocatedBytesOnHold()); v.reserve(32); - EXPECT_EQUAL(2u, v.size()); - EXPECT_EQUAL(32u, v.capacity()); - EXPECT_EQUAL(8u, v.getMemoryUsage().allocatedBytesOnHold()); + EXPECT_EQ(2u, v.size()); + EXPECT_EQ(32u, v.capacity()); + EXPECT_EQ(8u, v.getMemoryUsage().allocatedBytesOnHold()); v.reserve(100); - EXPECT_EQUAL(2u, v.size()); - EXPECT_EQUAL(102u, v.capacity()); - EXPECT_EQUAL(8u + 32u*4u, v.getMemoryUsage().allocatedBytesOnHold()); + EXPECT_EQ(2u, v.size()); + EXPECT_EQ(102u, v.capacity()); + EXPECT_EQ(8u + 32u*4u, v.getMemoryUsage().allocatedBytesOnHold()); } -TEST("test memory usage") +TEST(RcuVectorTest, memory_usage) { RcuVector<int8_t> v(2, 0, 2); EXPECT_TRUE(assertUsage(MemoryUsage(2,0,0,0), v.getMemoryUsage())); @@ -202,7 +174,7 @@ TEST("test memory usage") EXPECT_TRUE(assertUsage(MemoryUsage(6,5,0,0), v.getMemoryUsage())); } -TEST("test shrink() with buffer copying") +TEST(RcuVectorTest, shrink_with_buffer_copying) { GenerationHolder g; RcuVectorBase<int8_t> v(16, 100, 0, g); @@ -216,24 +188,24 @@ TEST("test shrink() with buffer copying") mu = v.getMemoryUsage(); mu.incAllocatedBytesOnHold(g.getHeldBytes()); EXPECT_TRUE(assertUsage(MemoryUsage(16, 4, 0, 0), mu)); - EXPECT_EQUAL(4u, v.size()); - EXPECT_EQUAL(16u, v.capacity()); - EXPECT_EQUAL(1, v[0]); - EXPECT_EQUAL(2, v[1]); - EXPECT_EQUAL(3, v[2]); - EXPECT_EQUAL(4, v[3]); + EXPECT_EQ(4u, v.size()); + EXPECT_EQ(16u, v.capacity()); + EXPECT_EQ(1, v[0]); + EXPECT_EQ(2, v[1]); + EXPECT_EQ(3, v[2]); + EXPECT_EQ(4, v[3]); const int8_t *old = &v[0]; v.shrink(2); g.transferHoldLists(1); - EXPECT_EQUAL(2u, v.size()); - EXPECT_EQUAL(4u, v.capacity()); - EXPECT_EQUAL(1, v[0]); - EXPECT_EQUAL(2, v[1]); - EXPECT_EQUAL(1, old[0]); - EXPECT_EQUAL(2, old[1]); + EXPECT_EQ(2u, v.size()); + EXPECT_EQ(4u, v.capacity()); + EXPECT_EQ(1, v[0]); + EXPECT_EQ(2, v[1]); + EXPECT_EQ(1, old[0]); + EXPECT_EQ(2, old[1]); g.trimHoldLists(2); - EXPECT_EQUAL(1, v[0]); - EXPECT_EQUAL(2, v[1]); + EXPECT_EQ(1, v[0]); + EXPECT_EQ(2, v[1]); mu = v.getMemoryUsage(); mu.incAllocatedBytesOnHold(g.getHeldBytes()); EXPECT_TRUE(assertUsage(MemoryUsage(4, 2, 0, 0), mu)); @@ -253,51 +225,53 @@ struct ShrinkFixture { for (size_t i = 0; i < initial_size; ++i) { vec.push_back(7); } - EXPECT_EQUAL(initial_size, vec.size()); - EXPECT_EQUAL(initial_capacity, vec.capacity()); + EXPECT_EQ(initial_size, vec.size()); + EXPECT_EQ(initial_capacity, vec.capacity()); assertEmptyHoldList(); oldPtr = &vec[0]; } void assertOldEqualNewBuffer() { - EXPECT_EQUAL(oldPtr, &vec[0]); + EXPECT_EQ(oldPtr, &vec[0]); } void assertEmptyHoldList() { - EXPECT_EQUAL(0u, g.getHeldBytes()); + EXPECT_EQ(0u, g.getHeldBytes()); } static size_t page_ints() { return round_up_to_page_size(1) / sizeof(int); } }; -TEST_F("require that shrink() does not increase allocated memory", ShrinkFixture) +TEST(RcuVectorTest, shrink_does_not_increase_allocated_memory) { + ShrinkFixture f; size_t shrink_size = f.initial_capacity * 2 / 3 + 2; f.vec.shrink(shrink_size); - EXPECT_EQUAL(shrink_size, f.vec.size()); - EXPECT_EQUAL(f.initial_capacity, f.vec.capacity()); - TEST_DO(f.assertOldEqualNewBuffer()); - TEST_DO(f.assertEmptyHoldList()); + EXPECT_EQ(shrink_size, f.vec.size()); + EXPECT_EQ(f.initial_capacity, f.vec.capacity()); + f.assertOldEqualNewBuffer(); + f.assertEmptyHoldList(); } -TEST_F("require that shrink() can shrink mmap allocation", ShrinkFixture) +TEST(RcuVectorTest, shrink_can_shrink_mmap_allocation) { + ShrinkFixture f; f.vec.shrink(2 * f.page_ints()); - EXPECT_EQUAL(2 * f.page_ints(), f.vec.size()); - EXPECT_EQUAL(3 * f.page_ints(), f.vec.capacity()); - TEST_DO(f.assertOldEqualNewBuffer()); - TEST_DO(f.assertEmptyHoldList()); + EXPECT_EQ(2 * f.page_ints(), f.vec.size()); + EXPECT_EQ(3 * f.page_ints(), f.vec.capacity()); + f.assertOldEqualNewBuffer(); + f.assertEmptyHoldList(); } -TEST("test small expand") +TEST(RcuVectorTest, small_expand) { GenerationHolder g; RcuVectorBase<int8_t> v(1, 50, 0, g); - EXPECT_EQUAL(1u, v.capacity()); - EXPECT_EQUAL(0u, v.size()); + EXPECT_EQ(1u, v.capacity()); + EXPECT_EQ(0u, v.size()); v.push_back(1); - EXPECT_EQUAL(1u, v.capacity()); - EXPECT_EQUAL(1u, v.size()); + EXPECT_EQ(1u, v.capacity()); + EXPECT_EQ(1u, v.size()); v.push_back(2); - EXPECT_EQUAL(2u, v.capacity()); - EXPECT_EQUAL(2u, v.size()); + EXPECT_EQ(2u, v.capacity()); + EXPECT_EQ(2u, v.size()); g.transferHoldLists(1); g.trimHoldLists(2); } @@ -332,40 +306,44 @@ Fixture::Fixture() Fixture::~Fixture() = default; -TEST_F("require that memory allocator can be set", Fixture) +TEST(RcuVectorTest, memory_allocator_can_be_set) { - EXPECT_EQUAL(AllocStats(2, 0), f.stats); + Fixture f; + EXPECT_EQ(AllocStats(2, 0), f.stats); f.transfer_and_trim(1, 2); - EXPECT_EQUAL(AllocStats(2, 1), f.stats); + EXPECT_EQ(AllocStats(2, 1), f.stats); } -TEST_F("require that memory allocator is preserved across reset", Fixture) +TEST(RcuVectorTest, memory_allocator_is_preserved_across_reset) { + Fixture f; f.arr.reset(); f.arr.reserve(100); - EXPECT_EQUAL(AllocStats(4, 1), f.stats); + EXPECT_EQ(AllocStats(4, 1), f.stats); f.transfer_and_trim(1, 2); - EXPECT_EQUAL(AllocStats(4, 3), f.stats); + EXPECT_EQ(AllocStats(4, 3), f.stats); } -TEST_F("require that created replacement vector uses same memory allocator", Fixture) +TEST(RcuVectorTest, created_replacement_vector_uses_same_memory_allocator) { + Fixture f; auto arr2 = f.arr.create_replacement_vector(); - EXPECT_EQUAL(AllocStats(2, 0), f.stats); + EXPECT_EQ(AllocStats(2, 0), f.stats); arr2.reserve(100); - EXPECT_EQUAL(AllocStats(3, 0), f.stats); + EXPECT_EQ(AllocStats(3, 0), f.stats); f.transfer_and_trim(1, 2); - EXPECT_EQUAL(AllocStats(3, 1), f.stats); + EXPECT_EQ(AllocStats(3, 1), f.stats); } -TEST_F("require that ensure_size and shrink use same memory allocator", Fixture) +TEST(RcuVectorTest, ensure_size_and_shrink_use_same_memory_allocator) { + Fixture f; f.arr.ensure_size(2000); - EXPECT_EQUAL(AllocStats(3, 0), f.stats); + EXPECT_EQ(AllocStats(3, 0), f.stats); f.arr.shrink(1000); - EXPECT_EQUAL(AllocStats(4, 0), f.stats); + EXPECT_EQ(AllocStats(4, 0), f.stats); f.transfer_and_trim(1, 2); - EXPECT_EQUAL(AllocStats(4, 3), f.stats); + EXPECT_EQ(AllocStats(4, 3), f.stats); } -TEST_MAIN() { TEST_RUN_ALL(); } +GTEST_MAIN_RUN_ALL_TESTS() |