Function FL_TEST_FILE

tests/fl/stl/weak_ptr.cpp:10–585

#include "fl/stl/move.h"

FL_TEST_FILE(FL_FILEPATH) {

namespace weak_ptr_test {

// Test class that does NOT inherit from fl::Referent (non-intrusive)
class TestClass {
public:
    TestClass() : mValue(0), mDestructorCalled(nullptr) {}
    TestClass(int value) : mValue(value), mDestructorCalled(nullptr) {}

    // Constructor that allows tracking destructor calls
    TestClass(int value, bool* destructor_flag) : mValue(value), mDestructorCalled(destructor_flag) {}

    ~TestClass() {
        if (mDestructorCalled) {
            *mDestructorCalled = true;
        }
    }

    int getValue() const { return mValue; }
    void setValue(int value) { mValue = value; }

private:
    int mValue;
    bool* mDestructorCalled;
};

FL_TEST_CASE("fl::weak_ptr default construction") {
    fl::weak_ptr<TestClass> weak;
    FL_CHECK_EQ(weak.use_count(), 0);
    FL_CHECK(weak.expired());
    
    auto shared = weak.lock();
    FL_CHECK(!shared);
    FL_CHECK_EQ(shared.get(), nullptr);
}

FL_TEST_CASE("fl::weak_ptr construction from shared_ptr") {
    fl::shared_ptr<TestClass> shared = fl::make_shared<TestClass>(42);
    FL_CHECK_EQ(shared.use_count(), 1);
    
    fl::weak_ptr<TestClass> weak(shared);
    FL_CHECK_EQ(weak.use_count(), 1);
    FL_CHECK_EQ(shared.use_count(), 1); // weak_ptr doesn't increase shared count
    FL_CHECK(!weak.expired());
    
    auto locked = weak.lock();
    FL_CHECK(locked);
    FL_CHECK_EQ(locked.use_count(), 2); // lock() creates a shared_ptr
    FL_CHECK_EQ(locked->getValue(), 42);
}

FL_TEST_CASE("fl::weak_ptr copy construction") {
    fl::shared_ptr<TestClass> shared = fl::make_shared<TestClass>(42);
    fl::weak_ptr<TestClass> weak1(shared);
    fl::weak_ptr<TestClass> weak2(weak1);
    
    FL_CHECK_EQ(weak1.use_count(), 1);