This is an automated email from the ASF dual-hosted git repository.
twice pushed a commit to branch unstable
in repository https://gitbox.apache.org/repos/asf/kvrocks.git
The following commit(s) were added to refs/heads/unstable by this push:
new 892ea915 Remove raw pointers and useless copy in TestBase (#2062)
892ea915 is described below
commit 892ea915f627c6c09b2bb81a120fe228ba10e893
Author: Twice <[email protected]>
AuthorDate: Sun Jan 28 11:03:16 2024 +0900
Remove raw pointers and useless copy in TestBase (#2062)
---
tests/cppunit/disk_test.cc | 36 +++++++-------
tests/cppunit/iterator_test.cc | 84 ++++++++++++++++-----------------
tests/cppunit/metadata_test.cc | 4 +-
tests/cppunit/namespace_test.cc | 6 +--
tests/cppunit/rdb_test.cc | 18 +++----
tests/cppunit/test_base.h | 24 +++++-----
tests/cppunit/types/bitmap_test.cc | 4 +-
tests/cppunit/types/bloom_chain_test.cc | 2 +-
tests/cppunit/types/geo_test.cc | 2 +-
tests/cppunit/types/hash_test.cc | 2 +-
tests/cppunit/types/json_test.cc | 2 +-
tests/cppunit/types/list_test.cc | 2 +-
tests/cppunit/types/set_test.cc | 2 +-
tests/cppunit/types/sortedint_test.cc | 2 +-
tests/cppunit/types/stream_test.cc | 2 +-
tests/cppunit/types/string_test.cc | 2 +-
tests/cppunit/types/zset_test.cc | 2 +-
17 files changed, 97 insertions(+), 99 deletions(-)
diff --git a/tests/cppunit/disk_test.cc b/tests/cppunit/disk_test.cc
index 124e1f81..a4cfc0df 100644
--- a/tests/cppunit/disk_test.cc
+++ b/tests/cppunit/disk_test.cc
@@ -46,8 +46,8 @@ class RedisDiskTest : public TestBase {
TEST_F(RedisDiskTest, StringDisk) {
key_ = "stringdisk_key";
- std::unique_ptr<redis::String> string =
std::make_unique<redis::String>(storage_, "disk_ns_string");
- std::unique_ptr<redis::Disk> disk = std::make_unique<redis::Disk>(storage_,
"disk_ns_string");
+ std::unique_ptr<redis::String> string =
std::make_unique<redis::String>(storage_.get(), "disk_ns_string");
+ std::unique_ptr<redis::Disk> disk =
std::make_unique<redis::Disk>(storage_.get(), "disk_ns_string");
std::vector<int> value_size{1024 * 1024};
EXPECT_TRUE(string->Set(key_, std::string(value_size[0], 'a')).ok());
uint64_t result = 0;
@@ -58,8 +58,8 @@ TEST_F(RedisDiskTest, StringDisk) {
}
TEST_F(RedisDiskTest, HashDisk) {
- std::unique_ptr<redis::Hash> hash = std::make_unique<redis::Hash>(storage_,
"disk_ns_hash");
- std::unique_ptr<redis::Disk> disk = std::make_unique<redis::Disk>(storage_,
"disk_ns_hash");
+ std::unique_ptr<redis::Hash> hash =
std::make_unique<redis::Hash>(storage_.get(), "disk_ns_hash");
+ std::unique_ptr<redis::Disk> disk =
std::make_unique<redis::Disk>(storage_.get(), "disk_ns_hash");
key_ = "hashdisk_key";
fields_ = {"hashdisk_kkey1", "hashdisk_kkey2", "hashdisk_kkey3",
"hashdisk_kkey4", "hashdisk_kkey5"};
values_.resize(5);
@@ -82,8 +82,8 @@ TEST_F(RedisDiskTest, HashDisk) {
}
TEST_F(RedisDiskTest, SetDisk) {
- std::unique_ptr<redis::Set> set = std::make_unique<redis::Set>(storage_,
"disk_ns_set");
- std::unique_ptr<redis::Disk> disk = std::make_unique<redis::Disk>(storage_,
"disk_ns_set");
+ std::unique_ptr<redis::Set> set =
std::make_unique<redis::Set>(storage_.get(), "disk_ns_set");
+ std::unique_ptr<redis::Disk> disk =
std::make_unique<redis::Disk>(storage_.get(), "disk_ns_set");
key_ = "setdisk_key";
values_.resize(5);
uint64_t approximate_size = 0;
@@ -107,8 +107,8 @@ TEST_F(RedisDiskTest, SetDisk) {
}
TEST_F(RedisDiskTest, ListDisk) {
- std::unique_ptr<redis::List> list = std::make_unique<redis::List>(storage_,
"disk_ns_list");
- std::unique_ptr<redis::Disk> disk = std::make_unique<redis::Disk>(storage_,
"disk_ns_list");
+ std::unique_ptr<redis::List> list =
std::make_unique<redis::List>(storage_.get(), "disk_ns_list");
+ std::unique_ptr<redis::Disk> disk =
std::make_unique<redis::Disk>(storage_.get(), "disk_ns_list");
key_ = "listdisk_key";
values_.resize(5);
std::vector<int> value_size{1024, 1024, 1024, 1024, 1024};
@@ -130,8 +130,8 @@ TEST_F(RedisDiskTest, ListDisk) {
}
TEST_F(RedisDiskTest, ZsetDisk) {
- std::unique_ptr<redis::ZSet> zset = std::make_unique<redis::ZSet>(storage_,
"disk_ns_zet");
- std::unique_ptr<redis::Disk> disk = std::make_unique<redis::Disk>(storage_,
"disk_ns_zet");
+ std::unique_ptr<redis::ZSet> zset =
std::make_unique<redis::ZSet>(storage_.get(), "disk_ns_zet");
+ std::unique_ptr<redis::Disk> disk =
std::make_unique<redis::Disk>(storage_.get(), "disk_ns_zet");
key_ = "zsetdisk_key";
uint64_t ret = 0;
uint64_t approximate_size = 0;
@@ -152,8 +152,8 @@ TEST_F(RedisDiskTest, ZsetDisk) {
}
TEST_F(RedisDiskTest, BitmapDisk) {
- std::unique_ptr<redis::Bitmap> bitmap =
std::make_unique<redis::Bitmap>(storage_, "disk_ns_bitmap");
- std::unique_ptr<redis::Disk> disk = std::make_unique<redis::Disk>(storage_,
"disk_ns_bitmap");
+ std::unique_ptr<redis::Bitmap> bitmap =
std::make_unique<redis::Bitmap>(storage_.get(), "disk_ns_bitmap");
+ std::unique_ptr<redis::Disk> disk =
std::make_unique<redis::Disk>(storage_.get(), "disk_ns_bitmap");
key_ = "bitmapdisk_key";
bool bit = false;
uint64_t approximate_size = 0;
@@ -172,8 +172,8 @@ TEST_F(RedisDiskTest, BitmapDisk2) {
const int64_t kGroupSize = 8192;
for (size_t num_bits : {8192, 16384}) {
for (bool set_op : {false, true}) {
- std::unique_ptr<redis::Bitmap> bitmap =
std::make_unique<redis::Bitmap>(storage_, "disk_ns_bitmap2");
- std::unique_ptr<redis::Disk> disk =
std::make_unique<redis::Disk>(storage_, "disk_ns_bitmap2");
+ std::unique_ptr<redis::Bitmap> bitmap =
std::make_unique<redis::Bitmap>(storage_.get(), "disk_ns_bitmap2");
+ std::unique_ptr<redis::Disk> disk =
std::make_unique<redis::Disk>(storage_.get(), "disk_ns_bitmap2");
key_ = "bitmapdisk_key2";
auto s = bitmap->Del(key_);
bool bit = false;
@@ -209,8 +209,8 @@ TEST_F(RedisDiskTest, BitmapDisk2) {
}
TEST_F(RedisDiskTest, SortedintDisk) {
- std::unique_ptr<redis::Sortedint> sortedint =
std::make_unique<redis::Sortedint>(storage_, "disk_ns_sortedint");
- std::unique_ptr<redis::Disk> disk = std::make_unique<redis::Disk>(storage_,
"disk_ns_sortedint");
+ std::unique_ptr<redis::Sortedint> sortedint =
std::make_unique<redis::Sortedint>(storage_.get(), "disk_ns_sortedint");
+ std::unique_ptr<redis::Disk> disk =
std::make_unique<redis::Disk>(storage_.get(), "disk_ns_sortedint");
key_ = "sortedintdisk_key";
uint64_t ret = 0;
uint64_t approximate_size = 0;
@@ -226,8 +226,8 @@ TEST_F(RedisDiskTest, SortedintDisk) {
}
TEST_F(RedisDiskTest, StreamDisk) {
- std::unique_ptr<redis::Stream> stream =
std::make_unique<redis::Stream>(storage_, "disk_ns_stream");
- std::unique_ptr<redis::Disk> disk = std::make_unique<redis::Disk>(storage_,
"disk_ns_stream");
+ std::unique_ptr<redis::Stream> stream =
std::make_unique<redis::Stream>(storage_.get(), "disk_ns_stream");
+ std::unique_ptr<redis::Disk> disk =
std::make_unique<redis::Disk>(storage_.get(), "disk_ns_stream");
key_ = "streamdisk_key";
redis::StreamAddOptions options;
options.next_id_strategy = *redis::ParseNextStreamEntryIDStrategy("*");
diff --git a/tests/cppunit/iterator_test.cc b/tests/cppunit/iterator_test.cc
index 6a2437a1..3645e59c 100644
--- a/tests/cppunit/iterator_test.cc
+++ b/tests/cppunit/iterator_test.cc
@@ -40,7 +40,7 @@ class DBIteratorTest : public TestBase {
void SetUp() override {
{ // string
- redis::String string(storage_, "test_ns0");
+ redis::String string(storage_.get(), "test_ns0");
string.Set("a", "1");
string.Set("b", "2");
string.Set("c", "3");
@@ -52,31 +52,31 @@ class DBIteratorTest : public TestBase {
{ // hash
uint64_t ret = 0;
- redis::Hash hash(storage_, "test_ns1");
+ redis::Hash hash(storage_.get(), "test_ns1");
hash.MSet("hash-1", {{"f0", "v0"}, {"f1", "v1"}, {"f2", "v2"}, {"f3",
"v3"}}, false, &ret);
}
{ // set
uint64_t ret = 0;
- redis::Set set(storage_, "test_ns2");
+ redis::Set set(storage_.get(), "test_ns2");
set.Add("set-1", {"e0", "e1", "e2"}, &ret);
}
{ // sorted set
uint64_t ret = 0;
- redis::ZSet zset(storage_, "test_ns3");
+ redis::ZSet zset(storage_.get(), "test_ns3");
auto mscores = std::vector<MemberScore>{{"z0", 0}, {"z1", 1}, {"z2", 2}};
zset.Add("zset-1", ZAddFlags(), &mscores, &ret);
}
{ // list
uint64_t ret = 0;
- redis::List list(storage_, "test_ns4");
+ redis::List list(storage_.get(), "test_ns4");
list.Push("list-1", {"l0", "l1", "l2"}, false, &ret);
}
{ // stream
- redis::Stream stream(storage_, "test_ns5");
+ redis::Stream stream(storage_.get(), "test_ns5");
redis::StreamEntryID ret;
redis::StreamAddOptions options;
options.next_id_strategy =
std::make_unique<redis::AutoGeneratedEntryID>();
@@ -87,7 +87,7 @@ class DBIteratorTest : public TestBase {
}
{ // bitmap
- redis::Bitmap bitmap(storage_, "test_ns6");
+ redis::Bitmap bitmap(storage_.get(), "test_ns6");
bool ret = false;
bitmap.SetBit("bitmap-1", 0, true, &ret);
bitmap.SetBit("bitmap-1", 8 * 1024, true, &ret);
@@ -95,7 +95,7 @@ class DBIteratorTest : public TestBase {
}
{ // json
- redis::Json json(storage_, "test_ns7");
+ redis::Json json(storage_.get(), "test_ns7");
json.Set("json-1", "$", "{\"a\": 1, \"b\": 2}");
json.Set("json-2", "$", "{\"a\": 1, \"b\": 2}");
json.Set("json-3", "$", "{\"a\": 1, \"b\": 2}");
@@ -106,7 +106,7 @@ class DBIteratorTest : public TestBase {
{
// sorted integer
- redis::Sortedint sortedint(storage_, "test_ns8");
+ redis::Sortedint sortedint(storage_.get(), "test_ns8");
uint64_t ret = 0;
sortedint.Add("sortedint-1", {1, 2, 3}, &ret);
}
@@ -114,7 +114,7 @@ class DBIteratorTest : public TestBase {
};
TEST_F(DBIteratorTest, AllKeys) {
- engine::DBIterator iter(storage_, rocksdb::ReadOptions());
+ engine::DBIterator iter(storage_.get(), rocksdb::ReadOptions());
std::vector<std::string> live_keys = {"a", "b", "d",
"hash-1", "set-1", "zset-1", "list-1",
"stream-1", "bitmap-1", "json-1",
"json-2", "json-3", "sortedint-1"};
std::reverse(live_keys.begin(), live_keys.end());
@@ -128,7 +128,7 @@ TEST_F(DBIteratorTest, AllKeys) {
}
TEST_F(DBIteratorTest, BasicString) {
- engine::DBIterator iter(storage_, rocksdb::ReadOptions());
+ engine::DBIterator iter(storage_.get(), rocksdb::ReadOptions());
std::vector<std::string> expected_keys = {"a", "b", "d"};
std::reverse(expected_keys.begin(), expected_keys.end());
@@ -150,7 +150,7 @@ TEST_F(DBIteratorTest, BasicString) {
}
TEST_F(DBIteratorTest, BasicHash) {
- engine::DBIterator iter(storage_, rocksdb::ReadOptions());
+ engine::DBIterator iter(storage_.get(), rocksdb::ReadOptions());
auto prefix = ComposeNamespaceKey("test_ns1", "",
storage_->IsSlotIdEncoded());
for (iter.Seek(prefix); iter.Valid() && iter.Key().starts_with(prefix);
iter.Next()) {
ASSERT_EQ(kRedisHash, iter.Type());
@@ -173,7 +173,7 @@ TEST_F(DBIteratorTest, BasicHash) {
}
TEST_F(DBIteratorTest, BasicSet) {
- engine::DBIterator iter(storage_, rocksdb::ReadOptions());
+ engine::DBIterator iter(storage_.get(), rocksdb::ReadOptions());
auto prefix = ComposeNamespaceKey("test_ns2", "",
storage_->IsSlotIdEncoded());
for (iter.Seek(prefix); iter.Valid() && iter.Key().starts_with(prefix);
iter.Next()) {
ASSERT_EQ(kRedisSet, iter.Type());
@@ -196,7 +196,7 @@ TEST_F(DBIteratorTest, BasicSet) {
}
TEST_F(DBIteratorTest, BasicZSet) {
- engine::DBIterator iter(storage_, rocksdb::ReadOptions());
+ engine::DBIterator iter(storage_.get(), rocksdb::ReadOptions());
auto prefix = ComposeNamespaceKey("test_ns3", "",
storage_->IsSlotIdEncoded());
for (iter.Seek(prefix); iter.Valid() && iter.Key().starts_with(prefix);
iter.Next()) {
ASSERT_EQ(kRedisZSet, iter.Type());
@@ -219,7 +219,7 @@ TEST_F(DBIteratorTest, BasicZSet) {
}
TEST_F(DBIteratorTest, BasicList) {
- engine::DBIterator iter(storage_, rocksdb::ReadOptions());
+ engine::DBIterator iter(storage_.get(), rocksdb::ReadOptions());
auto prefix = ComposeNamespaceKey("test_ns4", "",
storage_->IsSlotIdEncoded());
for (iter.Seek(prefix); iter.Valid() && iter.Key().starts_with(prefix);
iter.Next()) {
ASSERT_EQ(kRedisList, iter.Type());
@@ -242,7 +242,7 @@ TEST_F(DBIteratorTest, BasicList) {
}
TEST_F(DBIteratorTest, BasicStream) {
- engine::DBIterator iter(storage_, rocksdb::ReadOptions());
+ engine::DBIterator iter(storage_.get(), rocksdb::ReadOptions());
auto prefix = ComposeNamespaceKey("test_ns5", "",
storage_->IsSlotIdEncoded());
for (iter.Seek(prefix); iter.Valid() && iter.Key().starts_with(prefix);
iter.Next()) {
ASSERT_EQ(kRedisStream, iter.Type());
@@ -268,7 +268,7 @@ TEST_F(DBIteratorTest, BasicStream) {
}
TEST_F(DBIteratorTest, BasicBitmap) {
- engine::DBIterator iter(storage_, rocksdb::ReadOptions());
+ engine::DBIterator iter(storage_.get(), rocksdb::ReadOptions());
auto prefix = ComposeNamespaceKey("test_ns6", "",
storage_->IsSlotIdEncoded());
for (iter.Seek(prefix); iter.Valid() && iter.Key().starts_with(prefix);
iter.Next()) {
ASSERT_EQ(kRedisBitmap, iter.Type());
@@ -290,7 +290,7 @@ TEST_F(DBIteratorTest, BasicBitmap) {
}
TEST_F(DBIteratorTest, BasicJSON) {
- engine::DBIterator iter(storage_, rocksdb::ReadOptions());
+ engine::DBIterator iter(storage_.get(), rocksdb::ReadOptions());
std::vector<std::string> expected_keys = {"json-1", "json-2", "json-3"};
std::reverse(expected_keys.begin(), expected_keys.end());
@@ -312,7 +312,7 @@ TEST_F(DBIteratorTest, BasicJSON) {
}
TEST_F(DBIteratorTest, BasicSortedInt) {
- engine::DBIterator iter(storage_, rocksdb::ReadOptions());
+ engine::DBIterator iter(storage_.get(), rocksdb::ReadOptions());
auto prefix = ComposeNamespaceKey("test_ns8", "",
storage_->IsSlotIdEncoded());
for (iter.Seek(prefix); iter.Valid() && iter.Key().starts_with(prefix);
iter.Next()) {
@@ -343,7 +343,7 @@ class SlotIteratorTest : public TestBase {
};
TEST_F(SlotIteratorTest, LiveKeys) {
- redis::String string(storage_, kDefaultNamespace);
+ redis::String string(storage_.get(), kDefaultNamespace);
auto start_seq = storage_->GetDB()->GetLatestSequenceNumber();
std::vector<std::string> keys = {"{x}a", "{x}b", "{y}c", "{y}d", "{x}e"};
for (const auto &key : keys) {
@@ -357,7 +357,7 @@ TEST_F(SlotIteratorTest, LiveKeys) {
same_slot_keys.insert(key);
}
}
- engine::DBIterator iter(storage_, rocksdb::ReadOptions(), slot_id);
+ engine::DBIterator iter(storage_.get(), rocksdb::ReadOptions(), slot_id);
int count = 0;
for (iter.Seek(); iter.Valid(); iter.Next()) {
auto [_, user_key] = iter.UserKey();
@@ -366,7 +366,7 @@ TEST_F(SlotIteratorTest, LiveKeys) {
}
ASSERT_EQ(count, same_slot_keys.size());
- engine::WALIterator wal_iter(storage_, slot_id);
+ engine::WALIterator wal_iter(storage_.get(), slot_id);
count = 0;
for (wal_iter.Seek(start_seq + 1); wal_iter.Valid(); wal_iter.Next()) {
auto item = wal_iter.Item();
@@ -388,7 +388,7 @@ class WALIteratorTest : public TestBase {
TEST_F(WALIteratorTest, BasicString) {
auto start_seq = storage_->GetDB()->GetLatestSequenceNumber();
- redis::String string(storage_, "test_ns0");
+ redis::String string(storage_.get(), "test_ns0");
string.Set("a", "1");
string.MSet({{"b", "2"}, {"c", "3"}});
ASSERT_TRUE(string.Del("b").ok());
@@ -397,7 +397,7 @@ TEST_F(WALIteratorTest, BasicString) {
auto expected_put_keys = {"a", "b", "c"};
auto expected_delete_keys = {"b"};
- engine::WALIterator iter(storage_);
+ engine::WALIterator iter(storage_.get());
for (iter.Seek(start_seq + 1); iter.Valid(); iter.Next()) {
auto item = iter.Item();
@@ -432,7 +432,7 @@ TEST_F(WALIteratorTest, BasicString) {
TEST_F(WALIteratorTest, BasicHash) {
auto start_seq = storage_->GetDB()->GetLatestSequenceNumber();
- redis::Hash hash(storage_, "test_ns1");
+ redis::Hash hash(storage_.get(), "test_ns1");
uint64_t ret = 0;
hash.MSet("hash-1", {{"f0", "v0"}, {"f1", "v1"}, {"f2", "v2"}, {"f3",
"v3"}}, false, &ret);
uint64_t deleted_cnt = 0;
@@ -445,7 +445,7 @@ TEST_F(WALIteratorTest, BasicHash) {
auto expected_delete_fields = {"f0"};
std::vector<std::string> put_keys, put_fields, delete_fields;
- engine::WALIterator iter(storage_);
+ engine::WALIterator iter(storage_.get());
for (iter.Seek(start_seq + 1); iter.Valid(); iter.Next()) {
auto item = iter.Item();
@@ -488,7 +488,7 @@ TEST_F(WALIteratorTest, BasicSet) {
auto start_seq = storage_->GetDB()->GetLatestSequenceNumber();
uint64_t ret = 0;
- redis::Set set(storage_, "test_ns2");
+ redis::Set set(storage_.get(), "test_ns2");
set.Add("set-1", {"e0", "e1", "e2"}, &ret);
uint64_t removed_cnt = 0;
set.Remove("set-1", {"e0", "e1"}, &removed_cnt);
@@ -498,7 +498,7 @@ TEST_F(WALIteratorTest, BasicSet) {
auto expected_delete_members = {"e0", "e1"};
std::vector<std::string> put_keys, put_members, delete_members;
- engine::WALIterator iter(storage_);
+ engine::WALIterator iter(storage_.get());
for (iter.Seek(start_seq + 1); iter.Valid(); iter.Next()) {
auto item = iter.Item();
@@ -541,7 +541,7 @@ TEST_F(WALIteratorTest, BasicSet) {
TEST_F(WALIteratorTest, BasicZSet) {
auto start_seq = storage_->GetDB()->GetLatestSequenceNumber();
uint64_t ret = 0;
- redis::ZSet zset(storage_, "test_ns3");
+ redis::ZSet zset(storage_.get(), "test_ns3");
auto mscores = std::vector<MemberScore>{{"z0", 0}, {"z1", 1}, {"z2", 2}};
zset.Add("zset-1", ZAddFlags(), &mscores, &ret);
uint64_t removed_cnt = 0;
@@ -553,7 +553,7 @@ TEST_F(WALIteratorTest, BasicZSet) {
int expected_delete_count = 2, delete_count = 0;
std::vector<std::string> put_keys, put_members;
- engine::WALIterator iter(storage_);
+ engine::WALIterator iter(storage_.get());
for (iter.Seek(start_seq + 1); iter.Valid(); iter.Next()) {
auto item = iter.Item();
@@ -594,7 +594,7 @@ TEST_F(WALIteratorTest, BasicZSet) {
TEST_F(WALIteratorTest, BasicList) {
auto start_seq = storage_->GetDB()->GetLatestSequenceNumber();
uint64_t ret = 0;
- redis::List list(storage_, "test_ns4");
+ redis::List list(storage_.get(), "test_ns4");
list.Push("list-1", {"l0", "l1", "l2", "l3", "l4"}, false, &ret);
ASSERT_TRUE(list.Trim("list-1", 2, 4).ok());
@@ -603,7 +603,7 @@ TEST_F(WALIteratorTest, BasicList) {
auto expected_delete_count = 2, delete_count = 0;
std::vector<std::string> put_keys, put_values;
- engine::WALIterator iter(storage_);
+ engine::WALIterator iter(storage_.get());
for (iter.Seek(start_seq + 1); iter.Valid(); iter.Next()) {
auto item = iter.Item();
@@ -642,7 +642,7 @@ TEST_F(WALIteratorTest, BasicList) {
TEST_F(WALIteratorTest, BasicStream) {
auto start_seq = storage_->GetDB()->GetLatestSequenceNumber();
- redis::Stream stream(storage_, "test_ns5");
+ redis::Stream stream(storage_.get(), "test_ns5");
redis::StreamEntryID ret;
redis::StreamAddOptions options;
options.next_id_strategy = std::make_unique<redis::AutoGeneratedEntryID>();
@@ -657,7 +657,7 @@ TEST_F(WALIteratorTest, BasicStream) {
int delete_count = 0;
std::vector<std::string> put_keys, put_values;
- engine::WALIterator iter(storage_);
+ engine::WALIterator iter(storage_.get());
for (iter.Seek(start_seq + 1); iter.Valid(); iter.Next()) {
auto item = iter.Item();
@@ -700,7 +700,7 @@ TEST_F(WALIteratorTest, BasicStream) {
TEST_F(WALIteratorTest, BasicBitmap) {
auto start_seq = storage_->GetDB()->GetLatestSequenceNumber();
- redis::Bitmap bitmap(storage_, "test_ns6");
+ redis::Bitmap bitmap(storage_.get(), "test_ns6");
bool ret = false;
bitmap.SetBit("bitmap-1", 0, true, &ret);
bitmap.SetBit("bitmap-1", 8 * 1024, true, &ret);
@@ -709,7 +709,7 @@ TEST_F(WALIteratorTest, BasicBitmap) {
auto expected_put_values = {"\x1", "\x1", "\x1"};
std::vector<std::string> put_values;
- engine::WALIterator iter(storage_);
+ engine::WALIterator iter(storage_.get());
for (iter.Seek(start_seq + 1); iter.Valid(); iter.Next()) {
auto item = iter.Item();
@@ -736,7 +736,7 @@ TEST_F(WALIteratorTest, BasicBitmap) {
TEST_F(WALIteratorTest, BasicJSON) {
auto start_seq = storage_->GetDB()->GetLatestSequenceNumber();
- redis::Json json(storage_, "test_ns7");
+ redis::Json json(storage_.get(), "test_ns7");
json.Set("json-1", "$", "{\"a\": 1, \"b\": 2}");
json.Set("json-2", "$", "{\"a\": 1, \"b\": 2}");
json.Set("json-3", "$", "{\"a\": 1, \"b\": 2}");
@@ -748,7 +748,7 @@ TEST_F(WALIteratorTest, BasicJSON) {
auto expected_delete_keys = {"json-3"};
std::vector<std::string> put_keys, delete_keys;
- engine::WALIterator iter(storage_);
+ engine::WALIterator iter(storage_.get());
for (iter.Seek(start_seq + 1); iter.Valid(); iter.Next()) {
auto item = iter.Item();
@@ -786,7 +786,7 @@ TEST_F(WALIteratorTest, BasicJSON) {
TEST_F(WALIteratorTest, BasicSortedInt) {
auto start_seq = storage_->GetDB()->GetLatestSequenceNumber();
- redis::Sortedint sortedint(storage_, "test_ns8");
+ redis::Sortedint sortedint(storage_.get(), "test_ns8");
uint64_t ret = 0;
sortedint.Add("sortedint-1", {1, 2, 3}, &ret);
uint64_t removed_cnt = 0;
@@ -795,7 +795,7 @@ TEST_F(WALIteratorTest, BasicSortedInt) {
std::vector<uint64_t> expected_values = {1, 2, 3}, put_values;
std::vector<uint64_t> expected_delete_values = {2}, delete_values;
- engine::WALIterator iter(storage_);
+ engine::WALIterator iter(storage_.get());
for (iter.Seek(start_seq + 1); iter.Valid(); iter.Next()) {
auto item = iter.Item();
@@ -836,7 +836,7 @@ TEST_F(WALIteratorTest, NextSequence) {
auto start_seq = storage_->GetDB()->GetLatestSequenceNumber();
uint64_t ret = 0;
- redis::List list(storage_, "test_ns2");
+ redis::List list(storage_.get(), "test_ns2");
list.Push("list-1", {"l0", "l1", "l2", "l3", "l4"}, false, &ret);
expected_next_sequences.emplace_back(storage_->GetDB()->GetLatestSequenceNumber()
+ 1);
list.Push("list-2", {"l0", "l1", "l2"}, false, &ret);
@@ -844,7 +844,7 @@ TEST_F(WALIteratorTest, NextSequence) {
ASSERT_TRUE(list.Trim("list-1", 2, 4).ok());
expected_next_sequences.emplace_back(storage_->GetDB()->GetLatestSequenceNumber()
+ 1);
- engine::WALIterator iter(storage_);
+ engine::WALIterator iter(storage_.get());
ASSERT_EQ(iter.NextSequenceNumber(), 0);
diff --git a/tests/cppunit/metadata_test.cc b/tests/cppunit/metadata_test.cc
index e17735c3..5e3e60ee 100644
--- a/tests/cppunit/metadata_test.cc
+++ b/tests/cppunit/metadata_test.cc
@@ -69,8 +69,8 @@ TEST(Metadata, EncodeAndDecode) {
class RedisTypeTest : public TestBase {
public:
RedisTypeTest() {
- redis_ = std::make_unique<redis::Database>(storage_, "default_ns");
- hash_ = std::make_unique<redis::Hash>(storage_, "default_ns");
+ redis_ = std::make_unique<redis::Database>(storage_.get(), "default_ns");
+ hash_ = std::make_unique<redis::Hash>(storage_.get(), "default_ns");
key_ = "test-redis-type";
fields_ = {"test-hash-key-1", "test-hash-key-2", "test-hash-key-3"};
values_ = {"hash-test-value-1", "hash-test-value-2", "hash-test-value-3"};
diff --git a/tests/cppunit/namespace_test.cc b/tests/cppunit/namespace_test.cc
index 7d26a18e..c968f4ca 100644
--- a/tests/cppunit/namespace_test.cc
+++ b/tests/cppunit/namespace_test.cc
@@ -28,7 +28,7 @@
class NamespaceTest : public TestBase {
protected:
- explicit NamespaceTest() { config_->requirepass = "123"; }
+ explicit NamespaceTest() { config_.requirepass = "123"; }
void SetUp() override {}
void TearDown() override {}
@@ -36,10 +36,10 @@ class NamespaceTest : public TestBase {
TEST_F(NamespaceTest, AddAndDelete) {
for (const auto &v : {true, false}) {
- auto ns = std::make_unique<Namespace>(storage_);
+ auto ns = std::make_unique<Namespace>(storage_.get());
std::map<std::string, std::string> tokens = {
{"tokens2", "test_ns"}, {"tokens", "test_ns2"}, {"tokens3",
"test_ns3"}};
- config_->repl_namespace_enabled = v;
+ config_.repl_namespace_enabled = v;
for (const auto &iter : tokens) {
ASSERT_TRUE(ns->Add(iter.second, iter.first).IsOK());
}
diff --git a/tests/cppunit/rdb_test.cc b/tests/cppunit/rdb_test.cc
index d3a18355..87df1587 100644
--- a/tests/cppunit/rdb_test.cc
+++ b/tests/cppunit/rdb_test.cc
@@ -48,20 +48,20 @@ class RDBTest : public TestBase {
~RDBTest() override = default;
void SetUp() override { crc64_init(); }
- void TearDown() override { ASSERT_TRUE(clearDBDir(config_->db_dir)); }
+ void TearDown() override { ASSERT_TRUE(clearDBDir(config_.db_dir)); }
void loadRdb(const std::string &path) {
auto stream_ptr = std::make_unique<RdbFileStream>(path);
auto s = stream_ptr->Open();
ASSERT_TRUE(s.IsOK());
- RDB rdb(storage_, ns_, std::move(stream_ptr));
+ RDB rdb(storage_.get(), ns_, std::move(stream_ptr));
s = rdb.LoadRdb(0);
ASSERT_TRUE(s.IsOK());
}
void stringCheck(const std::string &key, const std::string &expect) {
- redis::String string_db(storage_, ns_);
+ redis::String string_db(storage_.get(), ns_);
std::string value;
auto s = string_db.Get(key, &value);
ASSERT_TRUE(s.ok());
@@ -69,7 +69,7 @@ class RDBTest : public TestBase {
}
void setCheck(const std::string &key, const std::vector<std::string>
&expect) {
- redis::Set set_db(storage_, ns_);
+ redis::Set set_db(storage_.get(), ns_);
std::vector<std::string> members;
auto s = set_db.Members(key, &members);
@@ -78,7 +78,7 @@ class RDBTest : public TestBase {
}
void hashCheck(const std::string &key, const std::map<std::string,
std::string> &expect) {
- redis::Hash hash_db(storage_, ns_);
+ redis::Hash hash_db(storage_.get(), ns_);
std::vector<FieldValue> field_values;
auto s = hash_db.GetAll(key, &field_values);
ASSERT_TRUE(s.ok());
@@ -95,7 +95,7 @@ class RDBTest : public TestBase {
}
void listCheck(const std::string &key, const std::vector<std::string>
&expect) {
- redis::List list_db(storage_, ns_);
+ redis::List list_db(storage_.get(), ns_);
std::vector<std::string> values;
auto s = list_db.Range(key, 0, -1, &values);
ASSERT_TRUE(s.ok());
@@ -103,7 +103,7 @@ class RDBTest : public TestBase {
}
void zsetCheck(const std::string &key, const std::vector<MemberScore>
&expect) {
- redis::ZSet zset_db(storage_, ns_);
+ redis::ZSet zset_db(storage_.get(), ns_);
std::vector<MemberScore> member_scores;
RangeRankSpec spec;
@@ -117,12 +117,12 @@ class RDBTest : public TestBase {
}
rocksdb::Status keyExist(const std::string &key) {
- redis::Database redis(storage_, ns_);
+ redis::Database redis(storage_.get(), ns_);
return redis.KeyExist(key);
}
void flushDB() {
- redis::Database redis(storage_, ns_);
+ redis::Database redis(storage_.get(), ns_);
auto s = redis.FlushDB();
ASSERT_TRUE(s.ok());
}
diff --git a/tests/cppunit/test_base.h b/tests/cppunit/test_base.h
index 5c46f317..6d9d6a39 100644
--- a/tests/cppunit/test_base.h
+++ b/tests/cppunit/test_base.h
@@ -30,18 +30,18 @@
class TestBase : public testing::Test { // NOLINT
protected:
- explicit TestBase() : config_(new Config()) {
+ explicit TestBase() {
const char *path = "test.conf";
unlink(path);
std::ofstream output_file(path, std::ios::out);
output_file << "";
- auto s = config_->Load(CLIOptions(path));
- config_->db_dir = "testdb";
- config_->rocks_db.compression = rocksdb::CompressionType::kNoCompression;
- config_->rocks_db.write_buffer_size = 1;
- config_->rocks_db.block_size = 100;
- storage_ = new engine::Storage(config_);
+ auto s = config_.Load(CLIOptions(path));
+ config_.db_dir = "testdb";
+ config_.rocks_db.compression = rocksdb::CompressionType::kNoCompression;
+ config_.rocks_db.write_buffer_size = 1;
+ config_.rocks_db.block_size = 100;
+ storage_ = std::make_unique<engine::Storage>(&config_);
s = storage_->Open();
if (!s.IsOK()) {
std::cout << "Failed to open the storage, encounter error: " << s.Msg()
<< std::endl;
@@ -49,12 +49,10 @@ class TestBase : public testing::Test { // NOLINT
}
}
~TestBase() override {
- auto db_dir = config_->db_dir;
- delete storage_;
- delete config_;
+ storage_.reset();
std::error_code ec;
- std::filesystem::remove_all(db_dir, ec);
+ std::filesystem::remove_all(config_.db_dir, ec);
if (ec) {
std::cout << "Encounter filesystem error: " << ec << std::endl;
}
@@ -62,8 +60,8 @@ class TestBase : public testing::Test { // NOLINT
unlink(path);
}
- engine::Storage *storage_;
- Config *config_ = nullptr;
+ std::unique_ptr<engine::Storage> storage_;
+ Config config_;
std::string key_;
std::vector<Slice> fields_;
std::vector<Slice> values_;
diff --git a/tests/cppunit/types/bitmap_test.cc
b/tests/cppunit/types/bitmap_test.cc
index 197f0ae9..4742f011 100644
--- a/tests/cppunit/types/bitmap_test.cc
+++ b/tests/cppunit/types/bitmap_test.cc
@@ -29,8 +29,8 @@
class RedisBitmapTest : public TestBase {
protected:
explicit RedisBitmapTest() {
- bitmap_ = std::make_unique<redis::Bitmap>(storage_, "bitmap_ns");
- string_ = std::make_unique<redis::String>(storage_, "bitmap_ns");
+ bitmap_ = std::make_unique<redis::Bitmap>(storage_.get(), "bitmap_ns");
+ string_ = std::make_unique<redis::String>(storage_.get(), "bitmap_ns");
}
~RedisBitmapTest() override = default;
diff --git a/tests/cppunit/types/bloom_chain_test.cc
b/tests/cppunit/types/bloom_chain_test.cc
index 904d3fbd..f99df13a 100644
--- a/tests/cppunit/types/bloom_chain_test.cc
+++ b/tests/cppunit/types/bloom_chain_test.cc
@@ -27,7 +27,7 @@
class RedisBloomChainTest : public TestBase {
protected:
- explicit RedisBloomChainTest() { sb_chain_ =
std::make_unique<redis::BloomChain>(storage_, "sb_chain_ns"); }
+ explicit RedisBloomChainTest() { sb_chain_ =
std::make_unique<redis::BloomChain>(storage_.get(), "sb_chain_ns"); }
~RedisBloomChainTest() override = default;
void SetUp() override { key_ = "test_sb_chain_key"; }
diff --git a/tests/cppunit/types/geo_test.cc b/tests/cppunit/types/geo_test.cc
index d3c7a1a2..32041f0f 100644
--- a/tests/cppunit/types/geo_test.cc
+++ b/tests/cppunit/types/geo_test.cc
@@ -28,7 +28,7 @@
class RedisGeoTest : public TestBase {
protected:
- RedisGeoTest() { geo_ = std::make_unique<redis::Geo>(storage_, "geo_ns"); }
+ RedisGeoTest() { geo_ = std::make_unique<redis::Geo>(storage_.get(),
"geo_ns"); }
~RedisGeoTest() override = default;
void SetUp() override {
diff --git a/tests/cppunit/types/hash_test.cc b/tests/cppunit/types/hash_test.cc
index 985b3289..5116f5ee 100644
--- a/tests/cppunit/types/hash_test.cc
+++ b/tests/cppunit/types/hash_test.cc
@@ -32,7 +32,7 @@
class RedisHashTest : public TestBase {
protected:
- explicit RedisHashTest() { hash_ = std::make_unique<redis::Hash>(storage_,
"hash_ns"); }
+ explicit RedisHashTest() { hash_ =
std::make_unique<redis::Hash>(storage_.get(), "hash_ns"); }
~RedisHashTest() override = default;
void SetUp() override {
diff --git a/tests/cppunit/types/json_test.cc b/tests/cppunit/types/json_test.cc
index ee76a65c..82bfa944 100644
--- a/tests/cppunit/types/json_test.cc
+++ b/tests/cppunit/types/json_test.cc
@@ -28,7 +28,7 @@
class RedisJsonTest : public TestBase {
protected:
- explicit RedisJsonTest() : json_(std::make_unique<redis::Json>(storage_,
"json_ns")) {}
+ explicit RedisJsonTest() :
json_(std::make_unique<redis::Json>(storage_.get(), "json_ns")) {}
~RedisJsonTest() override = default;
void SetUp() override { key_ = "test_json_key"; }
diff --git a/tests/cppunit/types/list_test.cc b/tests/cppunit/types/list_test.cc
index 712b9b15..643bdce9 100644
--- a/tests/cppunit/types/list_test.cc
+++ b/tests/cppunit/types/list_test.cc
@@ -27,7 +27,7 @@
class RedisListTest : public TestBase {
protected:
- explicit RedisListTest() { list_ = std::make_unique<redis::List>(storage_,
"list_ns"); }
+ explicit RedisListTest() { list_ =
std::make_unique<redis::List>(storage_.get(), "list_ns"); }
~RedisListTest() override = default;
void SetUp() override {
diff --git a/tests/cppunit/types/set_test.cc b/tests/cppunit/types/set_test.cc
index 1946458a..5e5c774b 100644
--- a/tests/cppunit/types/set_test.cc
+++ b/tests/cppunit/types/set_test.cc
@@ -27,7 +27,7 @@
class RedisSetTest : public TestBase {
protected:
- explicit RedisSetTest() { set_ = std::make_unique<redis::Set>(storage_,
"set_ns"); }
+ explicit RedisSetTest() { set_ =
std::make_unique<redis::Set>(storage_.get(), "set_ns"); }
~RedisSetTest() override = default;
void SetUp() override {
diff --git a/tests/cppunit/types/sortedint_test.cc
b/tests/cppunit/types/sortedint_test.cc
index 2ecacff8..79f0da78 100644
--- a/tests/cppunit/types/sortedint_test.cc
+++ b/tests/cppunit/types/sortedint_test.cc
@@ -27,7 +27,7 @@
class RedisSortedintTest : public TestBase {
protected:
- explicit RedisSortedintTest() { sortedint_ =
std::make_unique<redis::Sortedint>(storage_, "sortedint_ns"); }
+ explicit RedisSortedintTest() { sortedint_ =
std::make_unique<redis::Sortedint>(storage_.get(), "sortedint_ns"); }
~RedisSortedintTest() override = default;
void SetUp() override {
diff --git a/tests/cppunit/types/stream_test.cc
b/tests/cppunit/types/stream_test.cc
index 993fff0e..60d812f5 100644
--- a/tests/cppunit/types/stream_test.cc
+++ b/tests/cppunit/types/stream_test.cc
@@ -40,7 +40,7 @@ class RedisStreamTest : public TestBase { // NOLINT
}
protected:
- RedisStreamTest() : name_("test_stream") { stream_ = new
redis::Stream(storage_, "stream_ns"); }
+ RedisStreamTest() : name_("test_stream") { stream_ = new
redis::Stream(storage_.get(), "stream_ns"); }
~RedisStreamTest() override { delete stream_; }
diff --git a/tests/cppunit/types/string_test.cc
b/tests/cppunit/types/string_test.cc
index 631b4ec8..74a3d2da 100644
--- a/tests/cppunit/types/string_test.cc
+++ b/tests/cppunit/types/string_test.cc
@@ -27,7 +27,7 @@
class RedisStringTest : public TestBase {
protected:
- explicit RedisStringTest() { string_ =
std::make_unique<redis::String>(storage_, "string_ns"); }
+ explicit RedisStringTest() { string_ =
std::make_unique<redis::String>(storage_.get(), "string_ns"); }
~RedisStringTest() override = default;
void SetUp() override {
diff --git a/tests/cppunit/types/zset_test.cc b/tests/cppunit/types/zset_test.cc
index da2ce714..79c87942 100644
--- a/tests/cppunit/types/zset_test.cc
+++ b/tests/cppunit/types/zset_test.cc
@@ -27,7 +27,7 @@
class RedisZSetTest : public TestBase {
protected:
- RedisZSetTest() { zset_ = std::make_unique<redis::ZSet>(storage_,
"zset_ns"); }
+ RedisZSetTest() { zset_ = std::make_unique<redis::ZSet>(storage_.get(),
"zset_ns"); }
~RedisZSetTest() override = default;
void SetUp() override {
