This is an automated email from the ASF dual-hosted git repository.
tison pushed a commit to branch unstable
in repository https://gitbox.apache.org/repos/asf/incubator-kvrocks.git
The following commit(s) were added to refs/heads/unstable by this push:
new 777f0f2a Use make_unique/make_shared from STL (#1011)
777f0f2a is described below
commit 777f0f2a3047ede0e52518f157c6ba36ec341117
Author: Yaroslav <[email protected]>
AuthorDate: Wed Oct 19 04:53:06 2022 +0300
Use make_unique/make_shared from STL (#1011)
---
src/cluster/cluster.cc | 4 ++--
src/cluster/slot_migrate.cc | 2 +-
src/common/util.cc | 4 ++--
src/common/util.h | 15 ++-------------
src/server/server.cc | 12 ++++++------
src/storage/storage.cc | 4 ++--
src/storage/table_properties_collector.cc | 3 ++-
src/types/redis_set.cc | 2 +-
src/types/redis_stream.cc | 4 ++--
src/types/redis_zset.cc | 6 +++---
tests/cppunit/compact_test.cc | 6 +++---
tests/cppunit/cron_test.cc | 2 +-
tests/cppunit/disk_test.cc | 32 +++++++++++++++----------------
tests/cppunit/t_bitmap_test.cc | 2 +-
tests/cppunit/t_geo_test.cc | 2 +-
tests/cppunit/t_hash_test.cc | 2 +-
tests/cppunit/t_list_test.cc | 2 +-
tests/cppunit/t_metadata_test.cc | 4 ++--
tests/cppunit/t_set_test.cc | 2 +-
tests/cppunit/t_sortedint_test.cc | 2 +-
tests/cppunit/t_string_test.cc | 2 +-
tests/cppunit/t_zset_test.cc | 2 +-
22 files changed, 53 insertions(+), 63 deletions(-)
diff --git a/src/cluster/cluster.cc b/src/cluster/cluster.cc
index e1152f31..3447e98c 100644
--- a/src/cluster/cluster.cc
+++ b/src/cluster/cluster.cc
@@ -560,7 +560,7 @@ Status Cluster::ParseClusterNodes(const std::string
&nodes_str, ClusterNodes *no
return Status(Status::ClusterInvalidInfo, errInvalidClusterNodeInfo);
} else {
// Create slave node
- (*nodes)[id] = Util::MakeShared<ClusterNode>(id, host, port, role,
master_id, slots);
+ (*nodes)[id] = std::make_shared<ClusterNode>(id, host, port, role,
master_id, slots);
continue;
}
}
@@ -608,7 +608,7 @@ Status Cluster::ParseClusterNodes(const std::string
&nodes_str, ClusterNodes *no
}
// Create master node
- (*nodes)[id] = Util::MakeShared<ClusterNode>(id, host, port, role,
master_id, slots);
+ (*nodes)[id] = std::make_shared<ClusterNode>(id, host, port, role,
master_id, slots);
}
return Status::OK();
}
diff --git a/src/cluster/slot_migrate.cc b/src/cluster/slot_migrate.cc
index 12c273bf..90f11311 100644
--- a/src/cluster/slot_migrate.cc
+++ b/src/cluster/slot_migrate.cc
@@ -108,7 +108,7 @@ Status SlotMigrate::MigrateStart(Server *svr, const
std::string &node_id, const
dst_node_ = node_id;
// Create migration job
- auto job = Util::MakeUnique<SlotMigrateJob>(slot, dst_ip, dst_port, speed,
pipeline_size, seq_gap);
+ auto job = std::make_unique<SlotMigrateJob>(slot, dst_ip, dst_port, speed,
pipeline_size, seq_gap);
{
std::lock_guard<std::mutex> guard(job_mutex_);
slot_job_ = std::move(job);
diff --git a/src/common/util.cc b/src/common/util.cc
index a29025c3..5886d5a2 100644
--- a/src/common/util.cc
+++ b/src/common/util.cc
@@ -673,13 +673,13 @@ int aeWait(int fd, int mask, uint64_t timeout) {
}
}
-uint64_t GetTimeStampMS(void) {
+uint64_t GetTimeStampMS() {
auto tp =
std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now());
auto ts =
std::chrono::duration_cast<std::chrono::milliseconds>(tp.time_since_epoch());
return ts.count();
}
-uint64_t GetTimeStampUS(void) {
+uint64_t GetTimeStampUS() {
auto tp =
std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
auto ts =
std::chrono::duration_cast<std::chrono::microseconds>(tp.time_since_epoch());
return ts.count();
diff --git a/src/common/util.h b/src/common/util.h
index 38bd1145..7f789d3f 100644
--- a/src/common/util.h
+++ b/src/common/util.h
@@ -68,18 +68,7 @@ std::vector<std::string> TokenizeRedisProtocol(const
std::string &value);
void ThreadSetName(const char *name);
int aeWait(int fd, int mask, uint64_t milliseconds);
-uint64_t GetTimeStampMS(void);
-uint64_t GetTimeStampUS(void);
+uint64_t GetTimeStampMS();
+uint64_t GetTimeStampUS();
-// define std::make_unique in c++14
-// refer to https://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique
-template <typename T, typename... Args>
-std::unique_ptr<T> MakeUnique(Args &&...args) {
- return std::make_unique<T>(std::forward<Args>(args)...);
-}
-
-template <typename T, typename... Args>
-std::shared_ptr<T> MakeShared(Args &&...args) {
- return std::make_shared<T>(std::forward<Args>(args)...);
-}
} // namespace Util
diff --git a/src/server/server.cc b/src/server/server.cc
index c447c836..15799c17 100644
--- a/src/server/server.cc
+++ b/src/server/server.cc
@@ -62,10 +62,10 @@ Server::Server(Engine::Storage *storage, Config *config) :
storage_(storage), co
#endif
// Init cluster
- cluster_ = Util::MakeUnique<Cluster>(this, config_->binds, config_->port);
+ cluster_ = std::make_unique<Cluster>(this, config_->binds, config_->port);
for (int i = 0; i < config->workers; i++) {
- auto worker = Util::MakeUnique<Worker>(this, config);
+ auto worker = std::make_unique<Worker>(this, config);
// multiple workers can't listen to the same unix socket, so
// listen unix socket only from a single worker - the first one
if (!config->unixsocket.empty() && i == 0) {
@@ -77,7 +77,7 @@ Server::Server(Engine::Storage *storage, Config *config) :
storage_(storage), co
}
LOG(INFO) << "[server] Listening on unix socket: " << config->unixsocket;
}
-
worker_threads_.emplace_back(Util::MakeUnique<WorkerThread>(std::move(worker)));
+
worker_threads_.emplace_back(std::make_unique<WorkerThread>(std::move(worker)));
}
AdjustOpenFilesLimit();
slow_log_.SetMaxEntries(config->slowlog_max_len);
@@ -132,7 +132,7 @@ Status Server::Start() {
if (config_->cluster_enabled) {
// Create objects used for slot migration
slot_migrate_ =
- Util::MakeUnique<SlotMigrate>(this, config_->migrate_speed,
config_->pipeline_size, config_->sequence_gap);
+ std::make_unique<SlotMigrate>(this, config_->migrate_speed,
config_->pipeline_size, config_->sequence_gap);
slot_import_ = new SlotImport(this);
// Create migrating thread
auto s = slot_migrate_->CreateMigrateHandleThread();
@@ -587,11 +587,11 @@ int Server::IncrBlockedClientNum() { return
blocked_clients_.fetch_add(1, std::m
int Server::DecrBlockedClientNum() { return blocked_clients_.fetch_sub(1,
std::memory_order_relaxed); }
std::unique_ptr<RWLock::ReadLock> Server::WorkConcurrencyGuard() {
- return Util::MakeUnique<RWLock::ReadLock>(works_concurrency_rw_lock_);
+ return std::make_unique<RWLock::ReadLock>(works_concurrency_rw_lock_);
}
std::unique_ptr<RWLock::WriteLock> Server::WorkExclusivityGuard() {
- return Util::MakeUnique<RWLock::WriteLock>(works_concurrency_rw_lock_);
+ return std::make_unique<RWLock::WriteLock>(works_concurrency_rw_lock_);
}
std::atomic<uint64_t> *Server::GetClientID() { return &client_id_; }
diff --git a/src/storage/storage.cc b/src/storage/storage.cc
index e2fc881e..dae958f6 100644
--- a/src/storage/storage.cc
+++ b/src/storage/storage.cc
@@ -717,10 +717,10 @@ std::string Storage::GetReplIdFromDbEngine(void) {
return replid_in_db;
}
-std::unique_ptr<RWLock::ReadLock> Storage::ReadLockGuard() { return
Util::MakeUnique<RWLock::ReadLock>(db_rw_lock_); }
+std::unique_ptr<RWLock::ReadLock> Storage::ReadLockGuard() { return
std::make_unique<RWLock::ReadLock>(db_rw_lock_); }
std::unique_ptr<RWLock::WriteLock> Storage::WriteLockGuard() {
- return Util::MakeUnique<RWLock::WriteLock>(db_rw_lock_);
+ return std::make_unique<RWLock::WriteLock>(db_rw_lock_);
}
Status Storage::ReplDataManager::GetFullReplDataInfo(Storage *storage,
std::string *files) {
diff --git a/src/storage/table_properties_collector.cc
b/src/storage/table_properties_collector.cc
index d046cff2..73543d43 100644
--- a/src/storage/table_properties_collector.cc
+++ b/src/storage/table_properties_collector.cc
@@ -93,7 +93,8 @@ rocksdb::TablePropertiesCollector
*CompactOnExpiredTableCollectorFactory::Create
rocksdb::TablePropertiesCollectorFactory::Context context) {
return new CompactOnExpiredCollector(cf_name_, trigger_threshold_);
}
+
std::shared_ptr<CompactOnExpiredTableCollectorFactory>
NewCompactOnExpiredTableCollectorFactory(
const std::string &cf_name, float trigger_threshold) {
- return Util::MakeShared<CompactOnExpiredTableCollectorFactory>(cf_name,
trigger_threshold);
+ return std::make_shared<CompactOnExpiredTableCollectorFactory>(cf_name,
trigger_threshold);
}
diff --git a/src/types/redis_set.cc b/src/types/redis_set.cc
index 3f0d7d05..061f51d9 100644
--- a/src/types/redis_set.cc
+++ b/src/types/redis_set.cc
@@ -206,7 +206,7 @@ rocksdb::Status Set::Take(const Slice &user_key,
std::vector<std::string> *membe
AppendNamespacePrefix(user_key, &ns_key);
std::unique_ptr<LockGuard> lock_guard;
- if (pop) lock_guard =
Util::MakeUnique<LockGuard>(storage_->GetLockManager(), ns_key);
+ if (pop) lock_guard =
std::make_unique<LockGuard>(storage_->GetLockManager(), ns_key);
SetMetadata metadata(false);
rocksdb::Status s = GetMetadata(ns_key, &metadata);
diff --git a/src/types/redis_stream.cc b/src/types/redis_stream.cc
index b457ad42..dc511792 100644
--- a/src/types/redis_stream.cc
+++ b/src/types/redis_stream.cc
@@ -447,7 +447,7 @@ rocksdb::Status Stream::GetStreamInfo(const rocksdb::Slice
&stream_name, bool fu
return rocksdb::Status::InvalidArgument(rv.Msg());
}
- info->first_entry =
Util::MakeUnique<StreamEntry>(metadata.first_entry_id.ToString(),
std::move(values));
+ info->first_entry =
std::make_unique<StreamEntry>(metadata.first_entry_id.ToString(),
std::move(values));
std::string last_value;
s = getEntryRawValue(ns_key, metadata, metadata.last_entry_id,
&last_value);
@@ -460,7 +460,7 @@ rocksdb::Status Stream::GetStreamInfo(const rocksdb::Slice
&stream_name, bool fu
return rocksdb::Status::InvalidArgument(rv.Msg());
}
- info->last_entry =
Util::MakeUnique<StreamEntry>(metadata.last_entry_id.ToString(),
std::move(values));
+ info->last_entry =
std::make_unique<StreamEntry>(metadata.last_entry_id.ToString(),
std::move(values));
}
return rocksdb::Status::OK();
diff --git a/src/types/redis_zset.cc b/src/types/redis_zset.cc
index ce0fb8e8..fca4b2e3 100644
--- a/src/types/redis_zset.cc
+++ b/src/types/redis_zset.cc
@@ -216,7 +216,7 @@ rocksdb::Status ZSet::Range(const Slice &user_key, int
start, int stop, uint8_t
bool reversed = (flags & (uint8_t)kZSetReversed) != 0;
std::unique_ptr<LockGuard> lock_guard;
- if (removed) lock_guard =
Util::MakeUnique<LockGuard>(storage_->GetLockManager(), ns_key);
+ if (removed) lock_guard =
std::make_unique<LockGuard>(storage_->GetLockManager(), ns_key);
ZSetMetadata metadata(false);
rocksdb::Status s = GetMetadata(ns_key, &metadata);
if (!s.ok()) return s.IsNotFound() ? rocksdb::Status::OK() : s;
@@ -290,7 +290,7 @@ rocksdb::Status ZSet::RangeByScore(const Slice &user_key,
ZRangeSpec spec, std::
AppendNamespacePrefix(user_key, &ns_key);
std::unique_ptr<LockGuard> lock_guard;
- if (spec.removed) lock_guard =
Util::MakeUnique<LockGuard>(storage_->GetLockManager(), ns_key);
+ if (spec.removed) lock_guard =
std::make_unique<LockGuard>(storage_->GetLockManager(), ns_key);
ZSetMetadata metadata(false);
rocksdb::Status s = GetMetadata(ns_key, &metadata);
if (!s.ok()) return s.IsNotFound() ? rocksdb::Status::OK() : s;
@@ -410,7 +410,7 @@ rocksdb::Status ZSet::RangeByLex(const Slice &user_key,
ZRangeLexSpec spec, std:
std::unique_ptr<LockGuard> lock_guard;
if (spec.removed) {
- lock_guard = Util::MakeUnique<LockGuard>(storage_->GetLockManager(),
ns_key);
+ lock_guard = std::make_unique<LockGuard>(storage_->GetLockManager(),
ns_key);
}
ZSetMetadata metadata(false);
rocksdb::Status s = GetMetadata(ns_key, &metadata);
diff --git a/tests/cppunit/compact_test.cc b/tests/cppunit/compact_test.cc
index 163417a8..4042e885 100644
--- a/tests/cppunit/compact_test.cc
+++ b/tests/cppunit/compact_test.cc
@@ -32,13 +32,13 @@ TEST(Compact, Filter) {
config.backup_dir = "compactdb/backup";
config.slot_id_encoded = false;
- auto storage_ = Util::MakeUnique<Engine::Storage>(&config);
+ auto storage_ = std::make_unique<Engine::Storage>(&config);
Status s = storage_->Open();
assert(s.IsOK());
int ret;
std::string ns = "test_compact";
- auto hash = Util::MakeUnique<Redis::Hash>(storage_.get(), ns);
+ auto hash = std::make_unique<Redis::Hash>(storage_.get(), ns);
std::string expired_hash_key = "expire_hash_key";
std::string live_hash_key = "live_hash_key";
hash->Set(expired_hash_key, "f1", "v1", &ret);
@@ -72,7 +72,7 @@ TEST(Compact, Filter) {
EXPECT_EQ(ikey.GetKey().ToString(), live_hash_key);
}
- auto zset = Util::MakeUnique<Redis::ZSet>(storage_.get(), ns);
+ auto zset = std::make_unique<Redis::ZSet>(storage_.get(), ns);
std::string expired_zset_key = "expire_zset_key";
std::vector<MemberScore> member_scores = {MemberScore{"z1", 1.1},
MemberScore{"z2", 0.4}};
zset->Add(expired_zset_key, 0, &member_scores, &ret);
diff --git a/tests/cppunit/cron_test.cc b/tests/cppunit/cron_test.cc
index 83ac24b2..9c3f3bd3 100644
--- a/tests/cppunit/cron_test.cc
+++ b/tests/cppunit/cron_test.cc
@@ -29,7 +29,7 @@
class CronTest : public testing::Test {
protected:
explicit CronTest() {
- cron = Util::MakeUnique<Cron>();
+ cron = std::make_unique<Cron>();
std::vector<std::string> schedule{"*", "3", "*", "*", "*"};
cron->SetScheduleTime(schedule);
}
diff --git a/tests/cppunit/disk_test.cc b/tests/cppunit/disk_test.cc
index d4061c13..ca252df4 100644
--- a/tests/cppunit/disk_test.cc
+++ b/tests/cppunit/disk_test.cc
@@ -58,8 +58,8 @@ class RedisDiskTest : public TestBase {
TEST_F(RedisDiskTest, StringDisk) {
key_ = "stringdisk_key";
- std::unique_ptr<Redis::String> string =
Util::MakeUnique<Redis::String>(storage_, "disk_ns_string");
- std::unique_ptr<Redis::Disk> disk = Util::MakeUnique<Redis::Disk>(storage_,
"disk_ns_string");
+ 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::vector<int> value_size{1024 * 1024};
EXPECT_TRUE(string->Set(key_, std::string(value_size[0], 'a')).ok());
uint64_t result = 0;
@@ -70,8 +70,8 @@ TEST_F(RedisDiskTest, StringDisk) {
}
TEST_F(RedisDiskTest, HashDisk) {
- std::unique_ptr<Redis::Hash> hash = Util::MakeUnique<Redis::Hash>(storage_,
"disk_ns_hash");
- std::unique_ptr<Redis::Disk> disk = Util::MakeUnique<Redis::Disk>(storage_,
"disk_ns_hash");
+ 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");
key_ = "hashdisk_key";
fields_ = {"hashdisk_kkey1", "hashdisk_kkey2", "hashdisk_kkey3",
"hashdisk_kkey4", "hashdisk_kkey5"};
values_.resize(5);
@@ -92,8 +92,8 @@ TEST_F(RedisDiskTest, HashDisk) {
}
TEST_F(RedisDiskTest, SetDisk) {
- std::unique_ptr<Redis::Set> set = Util::MakeUnique<Redis::Set>(storage_,
"disk_ns_set");
- std::unique_ptr<Redis::Disk> disk = Util::MakeUnique<Redis::Disk>(storage_,
"disk_ns_set");
+ 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");
key_ = "setdisk_key";
values_.resize(5);
uint64_t approximate_size = 0;
@@ -115,8 +115,8 @@ TEST_F(RedisDiskTest, SetDisk) {
}
TEST_F(RedisDiskTest, ListDisk) {
- std::unique_ptr<Redis::List> list = Util::MakeUnique<Redis::List>(storage_,
"disk_ns_list");
- std::unique_ptr<Redis::Disk> disk = Util::MakeUnique<Redis::Disk>(storage_,
"disk_ns_list");
+ 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");
key_ = "listdisk_key";
values_.resize(5);
std::vector<int> value_size{1024, 1024, 1024, 1024, 1024};
@@ -136,8 +136,8 @@ TEST_F(RedisDiskTest, ListDisk) {
}
TEST_F(RedisDiskTest, ZsetDisk) {
- std::unique_ptr<Redis::ZSet> zset = Util::MakeUnique<Redis::ZSet>(storage_,
"disk_ns_zet");
- std::unique_ptr<Redis::Disk> disk = Util::MakeUnique<Redis::Disk>(storage_,
"disk_ns_zet");
+ 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");
key_ = "zsetdisk_key";
int ret = 0;
uint64_t approximate_size = 0;
@@ -158,8 +158,8 @@ TEST_F(RedisDiskTest, ZsetDisk) {
}
TEST_F(RedisDiskTest, BitmapDisk) {
- std::unique_ptr<Redis::Bitmap> bitmap =
Util::MakeUnique<Redis::Bitmap>(storage_, "disk_ns_bitmap");
- std::unique_ptr<Redis::Disk> disk = Util::MakeUnique<Redis::Disk>(storage_,
"disk_ns_bitmap");
+ 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");
key_ = "bitmapdisk_key";
bool bit = false;
uint64_t approximate_size = 0;
@@ -175,8 +175,8 @@ TEST_F(RedisDiskTest, BitmapDisk) {
}
TEST_F(RedisDiskTest, SortedintDisk) {
- std::unique_ptr<Redis::Sortedint> sortedint =
Util::MakeUnique<Redis::Sortedint>(storage_, "disk_ns_sortedint");
- std::unique_ptr<Redis::Disk> disk = Util::MakeUnique<Redis::Disk>(storage_,
"disk_ns_sortedint");
+ 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");
key_ = "sortedintdisk_key";
int ret;
uint64_t approximate_size = 0;
@@ -192,8 +192,8 @@ TEST_F(RedisDiskTest, SortedintDisk) {
}
TEST_F(RedisDiskTest, StreamDisk) {
- std::unique_ptr<Redis::Stream> stream =
Util::MakeUnique<Redis::Stream>(storage_, "disk_ns_stream");
- std::unique_ptr<Redis::Disk> disk = Util::MakeUnique<Redis::Disk>(storage_,
"disk_ns_stream");
+ 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");
key_ = "streamdisk_key";
Redis::StreamAddOptions options;
options.with_entry_id = false;
diff --git a/tests/cppunit/t_bitmap_test.cc b/tests/cppunit/t_bitmap_test.cc
index e1d05d84..f17eae6f 100644
--- a/tests/cppunit/t_bitmap_test.cc
+++ b/tests/cppunit/t_bitmap_test.cc
@@ -27,7 +27,7 @@
class RedisBitmapTest : public TestBase {
protected:
- explicit RedisBitmapTest() : TestBase() { bitmap =
Util::MakeUnique<Redis::Bitmap>(storage_, "bitmap_ns"); }
+ explicit RedisBitmapTest() : TestBase() { bitmap =
std::make_unique<Redis::Bitmap>(storage_, "bitmap_ns"); }
~RedisBitmapTest() = default;
void SetUp() override { key_ = "test_bitmap_key"; }
void TearDown() override {}
diff --git a/tests/cppunit/t_geo_test.cc b/tests/cppunit/t_geo_test.cc
index a7d067ae..b42da22e 100644
--- a/tests/cppunit/t_geo_test.cc
+++ b/tests/cppunit/t_geo_test.cc
@@ -28,7 +28,7 @@
class RedisGeoTest : public TestBase {
protected:
- RedisGeoTest() : TestBase() { geo = Util::MakeUnique<Redis::Geo>(storage_,
"geo_ns"); }
+ RedisGeoTest() : TestBase() { geo = std::make_unique<Redis::Geo>(storage_,
"geo_ns"); }
~RedisGeoTest() = default;
void SetUp() {
key_ = "test_geo_key";
diff --git a/tests/cppunit/t_hash_test.cc b/tests/cppunit/t_hash_test.cc
index 694ebdea..9f0eabd6 100644
--- a/tests/cppunit/t_hash_test.cc
+++ b/tests/cppunit/t_hash_test.cc
@@ -30,7 +30,7 @@
#include "types/redis_hash.h"
class RedisHashTest : public TestBase {
protected:
- explicit RedisHashTest() : TestBase() { hash =
Util::MakeUnique<Redis::Hash>(storage_, "hash_ns"); }
+ explicit RedisHashTest() : TestBase() { hash =
std::make_unique<Redis::Hash>(storage_, "hash_ns"); }
~RedisHashTest() = default;
void SetUp() override {
key_ = "test_hash->key";
diff --git a/tests/cppunit/t_list_test.cc b/tests/cppunit/t_list_test.cc
index a8eba456..3020a0d2 100644
--- a/tests/cppunit/t_list_test.cc
+++ b/tests/cppunit/t_list_test.cc
@@ -27,7 +27,7 @@
class RedisListTest : public TestBase {
protected:
- explicit RedisListTest() : TestBase() { list =
Util::MakeUnique<Redis::List>(storage_, "list_ns"); }
+ explicit RedisListTest() : TestBase() { list =
std::make_unique<Redis::List>(storage_, "list_ns"); }
~RedisListTest() = default;
void SetUp() override {
key_ = "test-list-key";
diff --git a/tests/cppunit/t_metadata_test.cc b/tests/cppunit/t_metadata_test.cc
index 2cfd1aa6..453038dd 100644
--- a/tests/cppunit/t_metadata_test.cc
+++ b/tests/cppunit/t_metadata_test.cc
@@ -69,8 +69,8 @@ TEST(Metadata, EncodeAndDeocde) {
class RedisTypeTest : public TestBase {
public:
RedisTypeTest() : TestBase() {
- redis = Util::MakeUnique<Redis::Database>(storage_, "default_ns");
- hash = Util::MakeUnique<Redis::Hash>(storage_, "default_ns");
+ redis = std::make_unique<Redis::Database>(storage_, "default_ns");
+ hash = std::make_unique<Redis::Hash>(storage_, "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/t_set_test.cc b/tests/cppunit/t_set_test.cc
index 3756bb22..b5090fdc 100644
--- a/tests/cppunit/t_set_test.cc
+++ b/tests/cppunit/t_set_test.cc
@@ -27,7 +27,7 @@
class RedisSetTest : public TestBase {
protected:
- explicit RedisSetTest() : TestBase() { set =
Util::MakeUnique<Redis::Set>(storage_, "set_ns"); }
+ explicit RedisSetTest() : TestBase() { set =
std::make_unique<Redis::Set>(storage_, "set_ns"); }
~RedisSetTest() = default;
void SetUp() override {
key_ = "test-set-key";
diff --git a/tests/cppunit/t_sortedint_test.cc
b/tests/cppunit/t_sortedint_test.cc
index b5aae02a..14c064a8 100644
--- a/tests/cppunit/t_sortedint_test.cc
+++ b/tests/cppunit/t_sortedint_test.cc
@@ -28,7 +28,7 @@
class RedisSortedintTest : public TestBase {
protected:
explicit RedisSortedintTest() : TestBase() {
- sortedint = Util::MakeUnique<Redis::Sortedint>(storage_, "sortedint_ns");
+ sortedint = std::make_unique<Redis::Sortedint>(storage_, "sortedint_ns");
}
~RedisSortedintTest() = default;
void SetUp() override {
diff --git a/tests/cppunit/t_string_test.cc b/tests/cppunit/t_string_test.cc
index 70c73d7d..497cb0eb 100644
--- a/tests/cppunit/t_string_test.cc
+++ b/tests/cppunit/t_string_test.cc
@@ -27,7 +27,7 @@
class RedisStringTest : public TestBase {
protected:
- explicit RedisStringTest() : TestBase() { string =
Util::MakeUnique<Redis::String>(storage_, "string_ns"); }
+ explicit RedisStringTest() : TestBase() { string =
std::make_unique<Redis::String>(storage_, "string_ns"); }
~RedisStringTest() = default;
void SetUp() override {
key_ = "test-string-key";
diff --git a/tests/cppunit/t_zset_test.cc b/tests/cppunit/t_zset_test.cc
index 4b0abdbc..d750ab0a 100644
--- a/tests/cppunit/t_zset_test.cc
+++ b/tests/cppunit/t_zset_test.cc
@@ -27,7 +27,7 @@
class RedisZSetTest : public TestBase {
protected:
- RedisZSetTest() : TestBase() { zset =
Util::MakeUnique<Redis::ZSet>(storage_, "zset_ns"); }
+ RedisZSetTest() : TestBase() { zset =
std::make_unique<Redis::ZSet>(storage_, "zset_ns"); }
~RedisZSetTest() = default;
void SetUp() {
key_ = "test_zset_key";
