Function FL_TEST_FILE

tests/fl/stl/shared_ptr.cpp:8–527

#include "fl/stl/vector.h"

FL_TEST_FILE(FL_FILEPATH) {

namespace shared_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) {}
    TestClass(int a, int b) : mValue(a + b), 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;
};

// Derived class for testing polymorphism
class DerivedTestClass : public TestClass {
public:
    DerivedTestClass() : TestClass(), mExtraValue(0) {}
    DerivedTestClass(int value, int extra) : TestClass(value), mExtraValue(extra) {}

    int getExtraValue() const { return mExtraValue; }

private:
    int mExtraValue;
};

// Custom deleter for testing
struct CustomDeleter {
    mutable fl::shared_ptr<bool> called_flag;

    CustomDeleter() : called_flag(fl::make_shared<bool>(false)) {}

    void operator()(TestClass* ptr) const {
        *called_flag = true;
        delete ptr;  // ok bare allocation
    }

    bool called() const { return *called_flag; }
};

FL_TEST_CASE("fl::shared_ptr default construction") {
    fl::shared_ptr<TestClass> ptr;
    FL_CHECK(!ptr);
    FL_CHECK_EQ(ptr.get(), nullptr);