summaryrefslogtreecommitdiffstats
path: root/src/rocksdb/table/cleanable_test.cc
diff options
context:
space:
mode:
Diffstat (limited to 'src/rocksdb/table/cleanable_test.cc')
-rw-r--r--src/rocksdb/table/cleanable_test.cc390
1 files changed, 390 insertions, 0 deletions
diff --git a/src/rocksdb/table/cleanable_test.cc b/src/rocksdb/table/cleanable_test.cc
new file mode 100644
index 000000000..b58eb7dc6
--- /dev/null
+++ b/src/rocksdb/table/cleanable_test.cc
@@ -0,0 +1,390 @@
+// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
+// This source code is licensed under both the GPLv2 (found in the
+// COPYING file in the root directory) and Apache 2.0 License
+// (found in the LICENSE.Apache file in the root directory).
+
+#include "rocksdb/cleanable.h"
+
+#include <gtest/gtest.h>
+
+#include <functional>
+
+#include "port/port.h"
+#include "port/stack_trace.h"
+#include "rocksdb/iostats_context.h"
+#include "rocksdb/perf_context.h"
+#include "test_util/testharness.h"
+#include "test_util/testutil.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+class CleanableTest : public testing::Test {};
+
+// Use this to keep track of the cleanups that were actually performed
+void Multiplier(void* arg1, void* arg2) {
+ int* res = reinterpret_cast<int*>(arg1);
+ int* num = reinterpret_cast<int*>(arg2);
+ *res *= *num;
+}
+
+// the first Cleanup is on stack and the rest on heap, so test with both cases
+TEST_F(CleanableTest, Register) {
+ int n2 = 2, n3 = 3;
+ int res = 1;
+ { Cleanable c1; }
+ // ~Cleanable
+ ASSERT_EQ(1, res);
+
+ res = 1;
+ {
+ Cleanable c1;
+ c1.RegisterCleanup(Multiplier, &res, &n2); // res = 2;
+ }
+ // ~Cleanable
+ ASSERT_EQ(2, res);
+
+ res = 1;
+ {
+ Cleanable c1;
+ c1.RegisterCleanup(Multiplier, &res, &n2); // res = 2;
+ c1.RegisterCleanup(Multiplier, &res, &n3); // res = 2 * 3;
+ }
+ // ~Cleanable
+ ASSERT_EQ(6, res);
+
+ // Test the Reset does cleanup
+ res = 1;
+ {
+ Cleanable c1;
+ c1.RegisterCleanup(Multiplier, &res, &n2); // res = 2;
+ c1.RegisterCleanup(Multiplier, &res, &n3); // res = 2 * 3;
+ c1.Reset();
+ ASSERT_EQ(6, res);
+ }
+ // ~Cleanable
+ ASSERT_EQ(6, res);
+
+ // Test Clenable is usable after Reset
+ res = 1;
+ {
+ Cleanable c1;
+ c1.RegisterCleanup(Multiplier, &res, &n2); // res = 2;
+ c1.Reset();
+ ASSERT_EQ(2, res);
+ c1.RegisterCleanup(Multiplier, &res, &n3); // res = 2 * 3;
+ }
+ // ~Cleanable
+ ASSERT_EQ(6, res);
+}
+
+// the first Cleanup is on stack and the rest on heap,
+// so test all the combinations of them
+TEST_F(CleanableTest, Delegation) {
+ int n2 = 2, n3 = 3, n5 = 5, n7 = 7;
+ int res = 1;
+ {
+ Cleanable c2;
+ {
+ Cleanable c1;
+ c1.RegisterCleanup(Multiplier, &res, &n2); // res = 2;
+ c1.DelegateCleanupsTo(&c2);
+ }
+ // ~Cleanable
+ ASSERT_EQ(1, res);
+ }
+ // ~Cleanable
+ ASSERT_EQ(2, res);
+
+ res = 1;
+ {
+ Cleanable c2;
+ {
+ Cleanable c1;
+ c1.DelegateCleanupsTo(&c2);
+ }
+ // ~Cleanable
+ ASSERT_EQ(1, res);
+ }
+ // ~Cleanable
+ ASSERT_EQ(1, res);
+
+ res = 1;
+ {
+ Cleanable c2;
+ {
+ Cleanable c1;
+ c1.RegisterCleanup(Multiplier, &res, &n2); // res = 2;
+ c1.RegisterCleanup(Multiplier, &res, &n3); // res = 2 * 3;
+ c1.DelegateCleanupsTo(&c2);
+ }
+ // ~Cleanable
+ ASSERT_EQ(1, res);
+ }
+ // ~Cleanable
+ ASSERT_EQ(6, res);
+
+ res = 1;
+ {
+ Cleanable c2;
+ c2.RegisterCleanup(Multiplier, &res, &n5); // res = 5;
+ {
+ Cleanable c1;
+ c1.RegisterCleanup(Multiplier, &res, &n2); // res = 2;
+ c1.RegisterCleanup(Multiplier, &res, &n3); // res = 2 * 3;
+ c1.DelegateCleanupsTo(&c2); // res = 2 * 3 * 5;
+ }
+ // ~Cleanable
+ ASSERT_EQ(1, res);
+ }
+ // ~Cleanable
+ ASSERT_EQ(30, res);
+
+ res = 1;
+ {
+ Cleanable c2;
+ c2.RegisterCleanup(Multiplier, &res, &n5); // res = 5;
+ c2.RegisterCleanup(Multiplier, &res, &n7); // res = 5 * 7;
+ {
+ Cleanable c1;
+ c1.RegisterCleanup(Multiplier, &res, &n2); // res = 2;
+ c1.RegisterCleanup(Multiplier, &res, &n3); // res = 2 * 3;
+ c1.DelegateCleanupsTo(&c2); // res = 2 * 3 * 5 * 7;
+ }
+ // ~Cleanable
+ ASSERT_EQ(1, res);
+ }
+ // ~Cleanable
+ ASSERT_EQ(210, res);
+
+ res = 1;
+ {
+ Cleanable c2;
+ c2.RegisterCleanup(Multiplier, &res, &n5); // res = 5;
+ c2.RegisterCleanup(Multiplier, &res, &n7); // res = 5 * 7;
+ {
+ Cleanable c1;
+ c1.RegisterCleanup(Multiplier, &res, &n2); // res = 2;
+ c1.DelegateCleanupsTo(&c2); // res = 2 * 5 * 7;
+ }
+ // ~Cleanable
+ ASSERT_EQ(1, res);
+ }
+ // ~Cleanable
+ ASSERT_EQ(70, res);
+
+ res = 1;
+ {
+ Cleanable c2;
+ c2.RegisterCleanup(Multiplier, &res, &n5); // res = 5;
+ c2.RegisterCleanup(Multiplier, &res, &n7); // res = 5 * 7;
+ {
+ Cleanable c1;
+ c1.DelegateCleanupsTo(&c2); // res = 5 * 7;
+ }
+ // ~Cleanable
+ ASSERT_EQ(1, res);
+ }
+ // ~Cleanable
+ ASSERT_EQ(35, res);
+
+ res = 1;
+ {
+ Cleanable c2;
+ c2.RegisterCleanup(Multiplier, &res, &n5); // res = 5;
+ {
+ Cleanable c1;
+ c1.DelegateCleanupsTo(&c2); // res = 5;
+ }
+ // ~Cleanable
+ ASSERT_EQ(1, res);
+ }
+ // ~Cleanable
+ ASSERT_EQ(5, res);
+}
+
+static void ReleaseStringHeap(void* s, void*) {
+ delete reinterpret_cast<const std::string*>(s);
+}
+
+class PinnableSlice4Test : public PinnableSlice {
+ public:
+ void TestStringIsRegistered(std::string* s) {
+ ASSERT_TRUE(cleanup_.function == ReleaseStringHeap);
+ ASSERT_EQ(cleanup_.arg1, s);
+ ASSERT_EQ(cleanup_.arg2, nullptr);
+ ASSERT_EQ(cleanup_.next, nullptr);
+ }
+};
+
+// Putting the PinnableSlice tests here due to similarity to Cleanable tests
+TEST_F(CleanableTest, PinnableSlice) {
+ int n2 = 2;
+ int res = 1;
+ const std::string const_str = "123";
+
+ {
+ res = 1;
+ PinnableSlice4Test value;
+ Slice slice(const_str);
+ value.PinSlice(slice, Multiplier, &res, &n2);
+ std::string str;
+ str.assign(value.data(), value.size());
+ ASSERT_EQ(const_str, str);
+ }
+ // ~Cleanable
+ ASSERT_EQ(2, res);
+
+ {
+ res = 1;
+ PinnableSlice4Test value;
+ Slice slice(const_str);
+ {
+ Cleanable c1;
+ c1.RegisterCleanup(Multiplier, &res, &n2); // res = 2;
+ value.PinSlice(slice, &c1);
+ }
+ // ~Cleanable
+ ASSERT_EQ(1, res); // cleanups must have be delegated to value
+ std::string str;
+ str.assign(value.data(), value.size());
+ ASSERT_EQ(const_str, str);
+ }
+ // ~Cleanable
+ ASSERT_EQ(2, res);
+
+ {
+ PinnableSlice4Test value;
+ Slice slice(const_str);
+ value.PinSelf(slice);
+ std::string str;
+ str.assign(value.data(), value.size());
+ ASSERT_EQ(const_str, str);
+ }
+
+ {
+ PinnableSlice4Test value;
+ std::string* self_str_ptr = value.GetSelf();
+ self_str_ptr->assign(const_str);
+ value.PinSelf();
+ std::string str;
+ str.assign(value.data(), value.size());
+ ASSERT_EQ(const_str, str);
+ }
+}
+
+static void Decrement(void* intptr, void*) { --*static_cast<int*>(intptr); }
+
+// Allow unit testing moved-from data
+template <class T>
+void MarkInitializedForClangAnalyze(T& t) {
+ // No net effect, but confuse analyzer. (Published advice doesn't work.)
+ char* p = reinterpret_cast<char*>(&t);
+ std::swap(*p, *p);
+}
+
+TEST_F(CleanableTest, SharedWrapCleanables) {
+ int val = 5;
+ Cleanable c1, c2;
+ c1.RegisterCleanup(&Decrement, &val, nullptr);
+ c1.RegisterCleanup(&Decrement, &val, nullptr);
+ ASSERT_TRUE(c1.HasCleanups());
+ ASSERT_FALSE(c2.HasCleanups());
+
+ SharedCleanablePtr scp1;
+ ASSERT_EQ(scp1.get(), nullptr);
+
+ // No-ops
+ scp1.RegisterCopyWith(&c2);
+ scp1.MoveAsCleanupTo(&c2);
+
+ ASSERT_FALSE(c2.HasCleanups());
+ c2.RegisterCleanup(&Decrement, &val, nullptr);
+ c2.RegisterCleanup(&Decrement, &val, nullptr);
+ c2.RegisterCleanup(&Decrement, &val, nullptr);
+
+ scp1.Allocate();
+ ASSERT_NE(scp1.get(), nullptr);
+ ASSERT_FALSE(scp1->HasCleanups());
+
+ // Copy ctor (alias scp2 = scp1)
+ SharedCleanablePtr scp2{scp1};
+ ASSERT_EQ(scp1.get(), scp2.get());
+
+ c1.DelegateCleanupsTo(&*scp1);
+ ASSERT_TRUE(scp1->HasCleanups());
+ ASSERT_TRUE(scp2->HasCleanups());
+ ASSERT_FALSE(c1.HasCleanups());
+
+ SharedCleanablePtr scp3;
+ ASSERT_EQ(scp3.get(), nullptr);
+
+ // Copy operator (alias scp3 = scp2 = scp1)
+ scp3 = scp2;
+
+ // Make scp2 point elsewhere
+ scp2.Allocate();
+ c2.DelegateCleanupsTo(&*scp2);
+
+ ASSERT_EQ(val, 5);
+ // Move operator, invoke old c2 cleanups
+ scp2 = std::move(scp1);
+ ASSERT_EQ(val, 2);
+ MarkInitializedForClangAnalyze(scp1);
+ ASSERT_EQ(scp1.get(), nullptr);
+
+ // Move ctor
+ {
+ SharedCleanablePtr scp4{std::move(scp3)};
+ MarkInitializedForClangAnalyze(scp3);
+ ASSERT_EQ(scp3.get(), nullptr);
+ ASSERT_EQ(scp4.get(), scp2.get());
+
+ scp2.Reset();
+ ASSERT_EQ(val, 2);
+ // invoke old c1 cleanups
+ }
+ ASSERT_EQ(val, 0);
+}
+
+TEST_F(CleanableTest, CleanableWrapShared) {
+ int val = 5;
+ SharedCleanablePtr scp1, scp2;
+ scp1.Allocate();
+ scp1->RegisterCleanup(&Decrement, &val, nullptr);
+ scp1->RegisterCleanup(&Decrement, &val, nullptr);
+
+ scp2.Allocate();
+ scp2->RegisterCleanup(&Decrement, &val, nullptr);
+ scp2->RegisterCleanup(&Decrement, &val, nullptr);
+ scp2->RegisterCleanup(&Decrement, &val, nullptr);
+
+ {
+ Cleanable c1;
+ {
+ Cleanable c2, c3;
+ scp1.RegisterCopyWith(&c1);
+ scp1.MoveAsCleanupTo(&c2);
+ ASSERT_TRUE(c1.HasCleanups());
+ ASSERT_TRUE(c2.HasCleanups());
+ ASSERT_EQ(scp1.get(), nullptr);
+ scp2.MoveAsCleanupTo(&c3);
+ ASSERT_TRUE(c3.HasCleanups());
+ ASSERT_EQ(scp2.get(), nullptr);
+ c2.Reset();
+ ASSERT_FALSE(c2.HasCleanups());
+ ASSERT_EQ(val, 5);
+ // invoke cleanups from scp2
+ }
+ ASSERT_EQ(val, 2);
+ // invoke cleanups from scp1
+ }
+ ASSERT_EQ(val, 0);
+}
+
+} // namespace ROCKSDB_NAMESPACE
+
+int main(int argc, char** argv) {
+ ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
+ ::testing::InitGoogleTest(&argc, argv);
+ return RUN_ALL_TESTS();
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-05 01:30:50 +0000