* Copyright (c) 2024 Huawei Technologies Co., Ltd.
* openUBMC is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* http://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <gtest/gtest.h>
#include <mc/exception.h>
#include <mc/memory.h>
#include <test_utilities/test_base.h>
#include <vector>
class weak_test_object : public mc::enable_shared_from_this<weak_test_object> {
public:
weak_test_object() : m_value(100) {
++s_construct_count;
}
explicit weak_test_object(int value) : m_value(value) {
++s_construct_count;
}
~weak_test_object() {
++s_destruct_count;
m_value = -1;
}
int get_value() const {
return m_value;
}
void set_value(int value) {
m_value = value;
}
static void reset_counters() {
s_construct_count = 0;
s_destruct_count = 0;
}
static int get_construct_count() {
return s_construct_count;
}
static int get_destruct_count() {
return s_destruct_count;
}
private:
int m_value;
static int s_construct_count;
static int s_destruct_count;
};
int weak_test_object::s_construct_count = 0;
int weak_test_object::s_destruct_count = 0;
class weak_derived_object : public weak_test_object {
public:
weak_derived_object() : weak_test_object(200) {
}
weak_derived_object(int value) : weak_test_object(value) {
}
int get_doubled_value() const {
return get_value() * 2;
}
};
class weak_ptr_test : public mc::test::TestBase {
protected:
void SetUp() override {
weak_test_object::reset_counters();
}
void TearDown() override {
EXPECT_EQ(weak_test_object::get_construct_count(), weak_test_object::get_destruct_count());
}
};
TEST_F(weak_ptr_test, DefaultConstruction) {
mc::weak_ptr<weak_test_object> weak;
EXPECT_FALSE(weak);
EXPECT_TRUE(weak.empty());
EXPECT_TRUE(weak.expired());
EXPECT_EQ(weak.get(), nullptr);
EXPECT_EQ(weak.use_count(), 0);
EXPECT_FALSE(weak.lock());
}
TEST_F(weak_ptr_test, NullptrConstruction) {
mc::weak_ptr<weak_test_object> weak(nullptr);
EXPECT_FALSE(weak);
EXPECT_TRUE(weak.empty());
EXPECT_TRUE(weak.expired());
EXPECT_EQ(weak.get(), nullptr);
EXPECT_EQ(weak.use_count(), 0);
}
TEST_F(weak_ptr_test, ConstructionFromSharedPtr) {
auto shared = mc::make_shared<weak_test_object>(300);
mc::weak_ptr<weak_test_object> weak(shared);
EXPECT_TRUE(weak);
EXPECT_FALSE(weak.empty());
EXPECT_FALSE(weak.expired());
EXPECT_EQ(weak.get(), shared.get());
EXPECT_EQ(weak.use_count(), 1);
auto locked = weak.lock();
EXPECT_TRUE(locked);
EXPECT_EQ(locked.get(), shared.get());
EXPECT_EQ(locked->get_value(), 300);
EXPECT_EQ(shared.use_count(), 2);
}
TEST_F(weak_ptr_test, ConstructionFromRawPointer) {
auto shared = mc::make_shared<weak_test_object>(400);
mc::weak_ptr<weak_test_object> weak(shared.get());
EXPECT_TRUE(weak);
EXPECT_FALSE(weak.empty());
EXPECT_FALSE(weak.expired());
EXPECT_EQ(weak.get(), shared.get());
EXPECT_EQ(weak.use_count(), 1);
}
TEST_F(weak_ptr_test, CopyConstruction) {
auto shared = mc::make_shared<weak_test_object>(500);
mc::weak_ptr<weak_test_object> weak1(shared);
mc::weak_ptr<weak_test_object> weak2(weak1);
EXPECT_TRUE(weak1);
EXPECT_TRUE(weak2);
EXPECT_EQ(weak1.get(), weak2.get());
EXPECT_EQ(weak1.get(), shared.get());
EXPECT_EQ(weak1.use_count(), 1);
EXPECT_EQ(weak2.use_count(), 1);
EXPECT_FALSE(weak1.expired());
EXPECT_FALSE(weak2.expired());
}
TEST_F(weak_ptr_test, MoveConstruction) {
auto shared = mc::make_shared<weak_test_object>(600);
mc::weak_ptr<weak_test_object> weak1(shared);
auto* raw_ptr = weak1.get();
mc::weak_ptr<weak_test_object> weak2(std::move(weak1));
EXPECT_FALSE(weak1);
EXPECT_TRUE(weak1.empty());
EXPECT_TRUE(weak2);
EXPECT_FALSE(weak2.empty());
EXPECT_EQ(weak1.get(), nullptr);
EXPECT_EQ(weak2.get(), raw_ptr);
EXPECT_EQ(weak2.get(), shared.get());
}
TEST_F(weak_ptr_test, TypeConversionConstruction) {
auto derived_shared = mc::make_shared<weak_derived_object>(700);
mc::weak_ptr<weak_derived_object> derived_weak(derived_shared);
mc::weak_ptr<weak_test_object> base_weak(derived_weak);
EXPECT_TRUE(base_weak);
EXPECT_EQ(base_weak.get(), derived_weak.get());
EXPECT_EQ(base_weak.get(), derived_shared.get());
EXPECT_EQ(base_weak.use_count(), 1);
auto locked = base_weak.lock();
EXPECT_TRUE(locked);
EXPECT_EQ(locked->get_value(), 700);
}
TEST_F(weak_ptr_test, CopyAssignment) {
auto shared1 = mc::make_shared<weak_test_object>(800);
auto shared2 = mc::make_shared<weak_test_object>(900);
mc::weak_ptr<weak_test_object> weak1(shared1);
mc::weak_ptr<weak_test_object> weak2(shared2);
EXPECT_NE(weak1.get(), weak2.get());
weak2 = weak1;
EXPECT_EQ(weak1.get(), weak2.get());
EXPECT_EQ(weak1.get(), shared1.get());
EXPECT_EQ(weak1.use_count(), 1);
EXPECT_EQ(weak2.use_count(), 1);
}
TEST_F(weak_ptr_test, MoveAssignment) {
auto shared1 = mc::make_shared<weak_test_object>(1000);
auto shared2 = mc::make_shared<weak_test_object>(1100);
mc::weak_ptr<weak_test_object> weak1(shared1);
mc::weak_ptr<weak_test_object> weak2(shared2);
auto* raw_ptr1 = weak1.get();
weak2 = std::move(weak1);
EXPECT_FALSE(weak1);
EXPECT_TRUE(weak1.empty());
EXPECT_TRUE(weak2);
EXPECT_EQ(weak1.get(), nullptr);
EXPECT_EQ(weak2.get(), raw_ptr1);
EXPECT_EQ(weak2.get(), shared1.get());
}
TEST_F(weak_ptr_test, AssignmentFromSharedPtr) {
auto shared = mc::make_shared<weak_test_object>(1200);
mc::weak_ptr<weak_test_object> weak;
EXPECT_TRUE(weak.empty());
weak = shared;
EXPECT_FALSE(weak.empty());
EXPECT_EQ(weak.get(), shared.get());
EXPECT_EQ(weak.use_count(), 1);
EXPECT_FALSE(weak.expired());
}
TEST_F(weak_ptr_test, TypeConversionAssignment) {
auto derived_shared = mc::make_shared<weak_derived_object>(1300);
mc::weak_ptr<weak_derived_object> derived_weak(derived_shared);
mc::weak_ptr<weak_test_object> base_weak;
base_weak = derived_weak;
EXPECT_TRUE(base_weak);
EXPECT_EQ(base_weak.get(), derived_weak.get());
EXPECT_EQ(base_weak.use_count(), 1);
mc::weak_ptr<weak_test_object> base_weak2;
mc::shared_ptr<weak_test_object> base_shared = derived_shared;
base_weak2 = base_shared;
EXPECT_TRUE(base_weak2);
EXPECT_EQ(base_weak2.get(), derived_shared.get());
}
TEST_F(weak_ptr_test, Reset) {
auto shared = mc::make_shared<weak_test_object>(1400);
mc::weak_ptr<weak_test_object> weak(shared);
EXPECT_FALSE(weak.empty());
EXPECT_FALSE(weak.expired());
weak.reset();
EXPECT_TRUE(weak.empty());
EXPECT_TRUE(weak.expired());
EXPECT_EQ(weak.get(), nullptr);
EXPECT_EQ(weak.use_count(), 0);
}
TEST_F(weak_ptr_test, Swap) {
auto shared1 = mc::make_shared<weak_test_object>(1500);
auto shared2 = mc::make_shared<weak_test_object>(1600);
mc::weak_ptr<weak_test_object> weak1(shared1);
mc::weak_ptr<weak_test_object> weak2(shared2);
auto* raw_ptr1 = weak1.get();
auto* raw_ptr2 = weak2.get();
weak1.swap(weak2);
EXPECT_EQ(weak1.get(), raw_ptr2);
EXPECT_EQ(weak2.get(), raw_ptr1);
EXPECT_EQ(weak1.get(), shared2.get());
EXPECT_EQ(weak2.get(), shared1.get());
}
TEST_F(weak_ptr_test, LockAndExpiredBasic) {
mc::weak_ptr<weak_test_object> weak;
{
auto shared = mc::make_shared<weak_test_object>(1700);
weak = shared;
EXPECT_FALSE(weak.expired());
EXPECT_EQ(weak.use_count(), 1);
auto locked = weak.lock();
EXPECT_TRUE(locked);
EXPECT_EQ(locked.get(), shared.get());
EXPECT_EQ(locked->get_value(), 1700);
EXPECT_EQ(weak.use_count(), 2);
}
EXPECT_TRUE(weak.expired());
EXPECT_EQ(weak.use_count(), 0);
auto locked = weak.lock();
EXPECT_FALSE(locked);
EXPECT_EQ(locked.get(), nullptr);
}
TEST_F(weak_ptr_test, MultipleWeakPtrs) {
auto shared = mc::make_shared<weak_test_object>(1800);
std::vector<mc::weak_ptr<weak_test_object>> weak_ptrs;
for (int i = 0; i < 10; ++i) {
weak_ptrs.emplace_back(shared);
}
for (const auto& weak : weak_ptrs) {
EXPECT_TRUE(weak);
EXPECT_FALSE(weak.expired());
EXPECT_EQ(weak.get(), shared.get());
EXPECT_EQ(weak.use_count(), 1);
auto locked = weak.lock();
EXPECT_TRUE(locked);
EXPECT_EQ(locked.get(), shared.get());
}
shared.reset();
for (const auto& weak : weak_ptrs) {
EXPECT_TRUE(weak.expired());
EXPECT_EQ(weak.use_count(), 0);
EXPECT_FALSE(weak.lock());
}
}
TEST_F(weak_ptr_test, LifecycleManagement) {
EXPECT_EQ(weak_test_object::get_construct_count(), 0);
EXPECT_EQ(weak_test_object::get_destruct_count(), 0);
mc::weak_ptr<weak_test_object> weak;
{
auto shared = mc::make_shared<weak_test_object>(1900);
weak = shared;
EXPECT_EQ(weak_test_object::get_construct_count(), 1);
EXPECT_EQ(weak_test_object::get_destruct_count(), 0);
EXPECT_FALSE(weak.expired());
{
auto locked = weak.lock();
EXPECT_TRUE(locked);
EXPECT_EQ(shared.use_count(), 2);
EXPECT_EQ(weak_test_object::get_destruct_count(), 0);
}
EXPECT_EQ(shared.use_count(), 1);
EXPECT_EQ(weak_test_object::get_destruct_count(), 0);
}
EXPECT_EQ(weak_test_object::get_construct_count(), 1);
EXPECT_EQ(weak_test_object::get_destruct_count(), 1);
EXPECT_TRUE(weak.expired());
EXPECT_FALSE(weak.lock());
}
class circular_a;
class circular_b;
class circular_a : public mc::enable_shared_from_this<circular_a> {
public:
mc::weak_ptr<circular_b> m_b_weak;
~circular_a() {
++s_destruct_count;
}
static void reset_counter() {
s_destruct_count = 0;
}
static int get_destruct_count() {
return s_destruct_count;
}
private:
static int s_destruct_count;
};
class circular_b : public mc::enable_shared_from_this<circular_b> {
public:
mc::shared_ptr<circular_a> m_a_shared;
~circular_b() {
++s_destruct_count;
}
static void reset_counter() {
s_destruct_count = 0;
}
static int get_destruct_count() {
return s_destruct_count;
}
private:
static int s_destruct_count;
};
int circular_a::s_destruct_count = 0;
int circular_b::s_destruct_count = 0;
TEST_F(weak_ptr_test, CircularReferenceResolution) {
circular_a::reset_counter();
circular_b::reset_counter();
{
auto a = mc::make_shared<circular_a>();
auto b = mc::make_shared<circular_b>();
a->m_b_weak = b;
b->m_a_shared = a;
EXPECT_EQ(a.use_count(), 2);
EXPECT_EQ(b.use_count(), 1);
EXPECT_FALSE(a->m_b_weak.expired());
auto b_locked = a->m_b_weak.lock();
EXPECT_TRUE(b_locked);
EXPECT_EQ(b_locked.get(), b.get());
EXPECT_EQ(b.use_count(), 2);
}
EXPECT_EQ(circular_a::get_destruct_count(), 1);
EXPECT_EQ(circular_b::get_destruct_count(), 1);
}
TEST_F(weak_ptr_test, ComparisonOperators) {
auto shared1 = mc::make_shared<weak_test_object>(2000);
auto shared2 = mc::make_shared<weak_test_object>(2100);
mc::weak_ptr<weak_test_object> weak1(shared1);
mc::weak_ptr<weak_test_object> weak2(shared1);
mc::weak_ptr<weak_test_object> weak3(shared2);
mc::weak_ptr<weak_test_object> weak_null;
EXPECT_TRUE(weak1 == weak2);
EXPECT_FALSE(weak1 == weak3);
EXPECT_FALSE(weak1 == weak_null);
EXPECT_TRUE(weak_null == nullptr);
EXPECT_TRUE(nullptr == weak_null);
EXPECT_FALSE(weak1 != weak2);
EXPECT_TRUE(weak1 != weak3);
EXPECT_TRUE(weak1 != weak_null);
EXPECT_FALSE(weak_null != nullptr);
}
TEST_F(weak_ptr_test, EdgeCases) {
mc::weak_ptr<weak_test_object> expired_weak;
{
auto shared = mc::make_shared<weak_test_object>(2200);
expired_weak = shared;
}
EXPECT_TRUE(expired_weak.expired());
EXPECT_EQ(expired_weak.use_count(), 0);
EXPECT_FALSE(expired_weak.lock());
mc::weak_ptr<weak_test_object> weak;
auto shared = mc::make_shared<weak_test_object>(2300);
weak = shared;
auto* original_ptr = weak.get();
weak.swap(weak);
EXPECT_EQ(weak.get(), original_ptr);
}
TEST_F(weak_ptr_test, SharedFromThisAndWeakFromThis) {
auto shared = mc::make_shared<weak_test_object>(2400);
auto shared2 = shared->shared_from_this();
EXPECT_EQ(shared.get(), shared2.get());
EXPECT_EQ(shared.use_count(), 2);
auto weak = shared->weak_from_this();
EXPECT_TRUE(weak);
EXPECT_EQ(weak.get(), shared.get());
EXPECT_FALSE(weak.expired());
EXPECT_EQ(weak.use_count(), 2);
auto locked = weak.lock();
EXPECT_TRUE(locked);
EXPECT_EQ(locked.get(), shared.get());
EXPECT_EQ(shared.use_count(), 3);
}
struct comp_object : public mc::memory::enable_shared_from_this<comp_object> {
int v{0};
};
TEST_F(weak_ptr_test, weak_ptr_competition_no_uaf) {
auto sp = mc::memory::make_shared<comp_object>();
std::vector<mc::memory::weak_ptr<comp_object>> ws;
ws.reserve(64);
for (int i = 0; i < 64; ++i) {
ws.emplace_back(sp->weak_from_this());
}
std::atomic<bool> start{false};
std::vector<std::thread> threads;
for (auto& w : ws) {
threads.emplace_back([&start, &w] {
while (!start.load()) {
}
for (int k = 0; k < 100; ++k) {
auto s = w.lock();
if (s) {
s->v += 1;
}
}
w.reset();
});
}
start.store(true);
sp.reset();
for (auto& t : threads) {
t.join();
}
SUCCEED();
}