tst_qobjecttreemodel.cpp

#include "qobjecttreemodel.h"

#include <algorithm>
#include <array>
#include <memory>
#include <vector>

#include <QtCore/QCoreApplication>
#include <QtCore/QThread>
#include <QtCore/QVariant>
#include <QtCore/private/qobject_p.h>
#include <QtCore/qnamespace.h>
#include <QtTest/QAbstractItemModelTester>
#include <QtTest/QSignalSpy>
#include <QtTest/QTest>

#if QT_CONFIG(widgets)
#include <QtWidgets/QWidget>
#endif

using namespace Qt::Literals::StringLiterals;

namespace {
const QString kRootName{u"Root"_s};

/**
 * Verifies signal args for:
 * - rowsAboutToBeRemoved
 * - rowsRemoved
 * - rowsAboutToBeInserted
 * - rowsInserted
 *
 * Expected args: (QModelIndex parent, int first, int last)
 *
 * Returns an empty string on success, or a diagnostic message describing
 * the first mismatch on failure.  Use via the VERIFY_SIGNAL_ARGS macro.
 **/
QString describeSignalArgsMismatch(const QList<QVariant> &args, void *parent, int first, int last)
{
    if (args.count() != 3)
        return u"arg count: expected 3, got %1"_s.arg(args.count());

    QModelIndex parentIndex = args[0].toModelIndex();
    if (parentIndex.internalPointer() != parent)
        return u"parent internalPointer: expected 0x%1, got 0x%2"_s
            .arg(reinterpret_cast<quintptr>(parent), 0, 16)
            .arg(reinterpret_cast<quintptr>(parentIndex.internalPointer()), 0, 16);

    if (args[1].toInt() != first)
        return u"first: expected %1, got %2"_s.arg(first).arg(args[1].toInt());

    if (args[2].toInt() != last)
        return u"last: expected %1, got %2"_s.arg(last).arg(args[2].toInt());

    return {};
}

/**
 * Verifies signal args for:
 * - rowsAboutToBeMoved
 * - rowsMoved
 *
 * Expected args: (QModelIndex sourceParent, int sourceFirst, int sourceLast,
 *                 QModelIndex destinationParent, int destinationRow)
 *
 * Returns an empty string on success, or a diagnostic message describing
 * the first mismatch on failure.  Use via the VERIFY_MOVE_SIGNAL_ARGS macro.
 **/
QString describeMoveSignalArgsMismatch(const QList<QVariant> &args,
                                       void *sourceParent,
                                       int sourceFirst,
                                       int sourceLast,
                                       void *destinationParent,
                                       int destinationRow)
{
    if (args.count() != 5)
        return u"arg count: expected 5, got %1"_s.arg(args.count());

    QModelIndex sourceParentIndex = args[0].toModelIndex();
    if (sourceParentIndex.internalPointer() != sourceParent)
        return u"sourceParent internalPointer: expected 0x%1, got 0x%2"_s
            .arg(reinterpret_cast<quintptr>(sourceParent), 0, 16)
            .arg(reinterpret_cast<quintptr>(sourceParentIndex.internalPointer()), 0, 16);

    if (args[1].toInt() != sourceFirst)
        return u"sourceFirst: expected %1, got %2"_s.arg(sourceFirst).arg(args[1].toInt());

    if (args[2].toInt() != sourceLast)
        return u"sourceLast: expected %1, got %2"_s.arg(sourceLast).arg(args[2].toInt());

    QModelIndex destParentIndex = args[3].toModelIndex();
    if (destParentIndex.internalPointer() != destinationParent)
        return u"destinationParent internalPointer: expected 0x%1, got 0x%2"_s
            .arg(reinterpret_cast<quintptr>(destinationParent), 0, 16)
            .arg(reinterpret_cast<quintptr>(destParentIndex.internalPointer()), 0, 16);

    if (args[4].toInt() != destinationRow)
        return u"destinationRow: expected %1, got %2"_s.arg(destinationRow).arg(args[4].toInt());

    return {};
}

// Convenience macros that expand QVERIFY2 at the call site so that file/line
// information points to the test, not the helper.
#define VERIFY_SIGNAL_ARGS(args, parent, first, last) \
    do { \
        const QString _err = describeSignalArgsMismatch(args, parent, first, last); \
        QVERIFY2(_err.isEmpty(), qPrintable(_err)); \
    } while (false)

#define VERIFY_MOVE_SIGNAL_ARGS(args, srcParent, srcFirst, srcLast, dstParent, dstRow) \
    do { \
        const QString _err = describeMoveSignalArgsMismatch(args, \
                                                            srcParent, \
                                                            srcFirst, \
                                                            srcLast, \
                                                            dstParent, \
                                                            dstRow); \
        QVERIFY2(_err.isEmpty(), qPrintable(_err)); \
    } while (false)

/**
 * Bundles the six standard QAbstractItemModel row-mutation signal spies that
 * many tests need to monitor. Construct with a model pointer; each spy is
 * automatically verified as valid.
 **/
struct ModelSignalSpies
{
    explicit ModelSignalSpies(QAbstractItemModel *model)
        : rowsAboutToBeRemoved(model, &QAbstractItemModel::rowsAboutToBeRemoved)
        , rowsRemoved(model, &QAbstractItemModel::rowsRemoved)
        , rowsAboutToBeInserted(model, &QAbstractItemModel::rowsAboutToBeInserted)
        , rowsInserted(model, &QAbstractItemModel::rowsInserted)
        , rowsAboutToBeMoved(model, &QAbstractItemModel::rowsAboutToBeMoved)
        , rowsMoved(model, &QAbstractItemModel::rowsMoved)
    {
        Q_ASSERT(rowsAboutToBeRemoved.isValid());
        Q_ASSERT(rowsRemoved.isValid());
        Q_ASSERT(rowsAboutToBeInserted.isValid());
        Q_ASSERT(rowsInserted.isValid());
        Q_ASSERT(rowsAboutToBeMoved.isValid());
        Q_ASSERT(rowsMoved.isValid());
    }

    /** Verify that no row-mutation signals were emitted. **/
    void verifyNoSignals() const
    {
        QCOMPARE(rowsAboutToBeRemoved.count(), 0);
        QCOMPARE(rowsRemoved.count(), 0);
        QCOMPARE(rowsAboutToBeInserted.count(), 0);
        QCOMPARE(rowsInserted.count(), 0);
        QCOMPARE(rowsAboutToBeMoved.count(), 0);
        QCOMPARE(rowsMoved.count(), 0);
    }

    /**
     * Verify that exactly @p removeCount rowsAboutToBeRemoved / rowsRemoved
     * pairs fired and no insert or move signals were emitted.
     **/
    void verifyRemoveOnly(int removeCount) const
    {
        QCOMPARE(rowsAboutToBeRemoved.count(), removeCount);
        QCOMPARE(rowsRemoved.count(), removeCount);
        QCOMPARE(rowsAboutToBeInserted.count(), 0);
        QCOMPARE(rowsInserted.count(), 0);
        QCOMPARE(rowsAboutToBeMoved.count(), 0);
        QCOMPARE(rowsMoved.count(), 0);
    }

    QSignalSpy rowsAboutToBeRemoved;
    QSignalSpy rowsRemoved;
    QSignalSpy rowsAboutToBeInserted;
    QSignalSpy rowsInserted;
    QSignalSpy rowsAboutToBeMoved;
    QSignalSpy rowsMoved;
};

/**
 * Convenience wrapper: creates a QSignalSpy on QObject::destroyed for each
 * object in @p objects and verifies they are valid. Use verifyNoneDestroyed()
 * to assert that none of the spies have fired.
 **/
struct DestroyedSpies
{
    explicit DestroyedSpies(std::initializer_list<QObject *> objects)
    {
        spies.reserve(objects.size());
        for (QObject *o : objects) {
            spies.push_back(std::make_unique<QSignalSpy>(o, &QObject::destroyed));
            Q_ASSERT(spies.back()->isValid());
        }
    }

    void verifyNoneDestroyed() const
    {
        for (qsizetype i = 0; i < qsizetype(spies.size()); ++i)
            QCOMPARE(spies[i]->count(), 0);
    }

    const QSignalSpy &operator[](qsizetype i) const { return *spies[i]; }
    qsizetype size() const { return qsizetype(spies.size()); }

    // QSignalSpy is non-copyable and non-movable, so we heap-allocate each spy.
    std::vector<std::unique_ptr<QSignalSpy>> spies;
};

} // namespace

class QObjectTreeModelTest : public QObject
{
    Q_OBJECT
public:
    QObjectTreeModelTest() = default;
    ~QObjectTreeModelTest() override = default;

private slots:
    void TestModelRootReturnsCorrectObject();
    void TestIndexForObjectOfRootReturnsCorrectIndex();
    void TestGetObjectWithInvalidIndexReturnsNullptr();
    void TestGetObjectWithForeignModelIndexReturnsNullptr();
    void TestIndexOutOfBoundsReturnsInvalid();
    void TestColumnCountIsAlwaysOne();
    void TestMetaTypeNameRoleReturnsClassName();
    void TestRoleNamesContainsExpectedKeys();
    void TestItemDataReturnsAllRolesForValidIndex();
    void TestDataReturnsInvalidVariantForEdgeCases();
    void TestParentOfRootIndexIsInvalid();
    void TestRowCountOfRootObjectWithNoChildren();
    void TestHasChildrenMatchesRowCount();
    void TestRowCountOfRootObjectWithChild();
    void TestRowCountOfRootObjectWithChildren();
    void TestRowCountOfChildObjectWithNoChildren();
    void TestRowCountOfChildObjectWithChild();
    void TestRowCountOfChildObjectWithChildren();
    void TestInsertionViaCreatingChildParentedToModelRoot();
    void TestInsertionViaParentingExistingQObjectToModelRoot();
    void TestInsertionExistingDeletedLaterQObjectToModelRoot();
    void TestInsertedChildrenHaveCorrectModelIndex();
    void TestInsertedSubChildrenHaveCorrectModelIndex();
    void TestInsertedSubTreeHasCorrectModelIndices();
    void TestRemovalFromChildDeletion();
    void TestRemovalFromChildRawDelete();
    void TestRemovalFromSubChildDeletion();
    void TestRemovalFromSubtreeRootDeletion();

    // Raw delete tests — verify that `delete` (as opposed to `deleteLater`)
    // correctly removes objects from the model without use-after-free.
    // Qt's ~QObject destroys children depth-first and emits ChildRemoved for
    // each, so the model cleans up incrementally bottom-up.
    void TestRawDeleteChildWithOneChild();
    void TestRawDeleteChildWithGrandchildren();
    void TestRawDeleteChildWithWideFlatSubtree();
    void TestRawDeleteMiddleChildLeavingSiblings();
    void TestRemovalFromChildReparent();
    void TestRemovalFromSubChildReparent();
    void TestRemovalFromSubTreeReparent();
    void TestChildMovedViaSetParentToEndOfDifferentRow();
    void TestSubTreeMovedViaSetParentToEndOfDifferentRow();
    void TestMoveChild();
    void TestMoveRow();
    void TestDataChangedEmittedOnNameChange();
    void TestParentReturnsInvalidModelIndexForRootObject();
    void TestParentReturnsInvalidModelIndexForInvalidParent();
    void TestTakeRowsWithNegativeCountAlwaysFails();
    void TestTakeRowsWithZeroCountDoesNothing();
    void TestTakeRowsCannotRemoveRootObject();
    void TestTakeRowsWithNegativeRowDoesNothingIfCountIsGreaterThanZero();
    void TestTakeRowsFailsIfRowPlusCountGoesOutsideRange();
    void TestTakeRowsCanReturnFirstRow();
    void TestTakeRowsCanTakeSecondRow();
    void TestTakeRowsCanTakeLastRowAndSubTree();
    void TestTakeRowsCanTakeAllRowsForParent();
    void TestTakeRowsCanTakeRowSubsetForParent();
    void TestTakeAllRowsReturnsAllChildrenForRoot();
    void TestTakeAllRowsReturnsEmptyForParentWithNoChildren();
    void TestTakeAllRowsReturnsChildrenForNonRootParent();
    void TestTakeAllRowsPreservesSubtrees();
    void TestInsertingLargeQObjectTreeIntoModel();

    // setRoot tests
    void TestSetRootWithNullptrCreatesInternalRoot();
    void TestSetRootWithExternalObject();
    void TestSetRootWithSameRootIsNoOp();
    void TestSetRootEmitsRootChangedSignal();
    void TestSetRootFromExternalToExternalReplacesModel();
    void TestSetRootFromInternalToExternalCleansUpInternalRoot();
    void TestSetRootWithDescendantOfInternalRootDoesNotDangle();
    void TestSetRootFromExternalToNullptrCreatesNewInternalRoot();
    void TestSetRootDisconnectsOldObjectEventFilters();
    void TestSetRootDisconnectsOldObjectSignalConnections();
    void TestSetRootOldTreeObjectsNotTrackedByModel();

    // removeRows tests
    void TestRemoveRowsWithNegativeCountFails();
    void TestRemoveRowsWithNegativeRowFails();
    void TestRemoveRowsWithZeroCountSucceeds();
    void TestRemoveRowsCannotRemoveRoot();
    void TestRemoveRowsFailsIfRangeExceedsRowCount();
    void TestRemoveRowsCanRemoveFirstRow();
    void TestRemoveRowsCanRemoveLastRow();
    void TestRemoveRowsCanRemoveMiddleRow();
    void TestRemoveRowsCanRemoveMultipleContiguousRows();
    void TestRemoveRowsCanRemoveAllChildren();
    void TestRemoveRowsDeletesRemovedObjects();
    void TestRemoveRowsDeletesSubTree();
    void TestRemoveRowsEmitsCorrectSignals();
    void TestRemoveRowsDisconnectsRemovedObjects();
    void TestRemoveRowsWithForeignModelIndexFails();

    // moveRows tests
    void TestMoveRowsWithCountNotOneReturnsFalse();
    void TestMoveRowsWithInvalidSourceParentFails();
    void TestMoveRowsWithInvalidDestinationParentFails();
    void TestMoveRowsWithNegativeSourceRowFails();
    void TestMoveRowsWithNegativeDestinationRowFails();
    void TestMoveRowsWithSourceRowOutOfRangeFails();
    void TestMoveRowsWithDestinationRowOutOfRangeFails();
    void TestMoveRowsWithForeignModelIndexFails();
    void TestMoveRowsMovesWithinSameParent();
    void TestMoveRowsMovesBetweenDifferentParents();

    // Root destruction tests — verify that destroying the root QObject while
    // the model is alive leaves the model in a valid, usable state.
    void TestRawDeleteExternalRootResetsModel();
    void TestDeleteLaterExternalRootResetsModel();
    void TestExternalRootWithSubtreeDestroyedResetsModel();
    void TestModelUsableAfterExternalRootDestroyed();

    // Thread affinity tests — verify the model enforces same-thread affinity
    // and gracefully handles cross-thread scenarios.
    void TestSetRootWithCrossThreadObjectIsNoOp();
    void TestSetRootWithCrossThreadObjectPreservesExistingRoot();
    void TestMoveExternalRootToOtherThreadResetsModel();
    void TestMoveExternalRootToOtherThreadModelRemainsUsable();
    void TestMoveExternalRootWithSubtreeToOtherThreadResetsModel();

    // Destructor tests
    void TestDestructorCleansUpEventFiltersOnLiveRoot();

    // QWidget tests — verify the model correctly tracks QWidget children
    // through SetParent, QWidget::setParent, and QObject::setParent.
    // These cover the ChildAdded suppression issue for widgets in
    // QObjectPrivate::setParent_helper.
    void TestSetParentWithQWidgetChildTracksCorrectly();
    void TestSetParentMoveQWidgetBetweenParents();
    void TestQWidgetSetParentTrackedByModel();
    void TestNewQWidgetChildTrackedByModel();
    void TestQWidgetSubtreeTrackedViaSetParent();
    void TestQWidgetMoveViaQWidgetSetParentDetectedByModel();
    void TestQWidgetReparentToNullptrViaQWidgetSetParent();
    void TestQWidgetReparentToUntrackedParentViaQWidgetSetParent();
    void TestQObjectSetParentOnQWidgetCausesDesync();

    // IsAncestorOf tests
    void TestIsAncestorOfReturnsFalseForNullArguments();
    void TestIsAncestorOfReturnsTrueForSelf();
    void TestIsAncestorOfReturnsTrueForDirectParent();
    void TestIsAncestorOfReturnsTrueForGrandparent();
    void TestIsAncestorOfReturnsFalseForChild();
    void TestIsAncestorOfReturnsFalseForUnrelatedObjects();
};

void QObjectTreeModelTest::TestModelRootReturnsCorrectObject()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QCOMPARE(model.root(), &root);
}

void QObjectTreeModelTest::TestIndexForObjectOfRootReturnsCorrectIndex()
{
    QObject root;
    root.setObjectName(kRootName);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());
    QCOMPARE(rootIndex.internalPointer(), &root);
    QCOMPARE(rootIndex.row(), 0);
    QCOMPARE(rootIndex.column(), 0);
    QCOMPARE(rootIndex.data(Qt::DisplayRole).toString(), kRootName);
    QCOMPARE(rootIndex.data(static_cast<int>(QObjectTreeModel::Roles::ObjectName)).toString(),
             kRootName);
    QCOMPARE(model.objectFromIndex(rootIndex), &root);
}

void QObjectTreeModelTest::TestGetObjectWithInvalidIndexReturnsNullptr()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QCOMPARE(model.objectFromIndex(QModelIndex()), nullptr);
}

void QObjectTreeModelTest::TestGetObjectWithForeignModelIndexReturnsNullptr()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Create a second, independent model whose indices are foreign to `model`.
    QObject otherRoot;
    auto otherModel_ptr = QObjectTreeModel::CreateWithRoot(&otherRoot);
    auto &otherModel = *otherModel_ptr;
    QModelIndex foreignIndex = otherModel.indexOf(&otherRoot);
    QVERIFY(foreignIndex.isValid());

    QCOMPARE(model.objectFromIndex(foreignIndex), nullptr);
}

void QObjectTreeModelTest::TestParentOfRootIndexIsInvalid()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QModelIndex parentIndex = rootIndex.parent();

    QCOMPARE(parentIndex.isValid(), false);
    QCOMPARE(parentIndex.row(), -1);
    QCOMPARE(parentIndex.column(), -1);
    QCOMPARE(parentIndex.internalPointer(), nullptr);
}

void QObjectTreeModelTest::TestIndexOutOfBoundsReturnsInvalid()
{
    QObject root;
    root.setObjectName(u"root"_s);

    auto *child1 = new QObject(&root);
    child1->setObjectName(u"child1"_s);
    auto *child2 = new QObject(&root);
    child2->setObjectName(u"child2"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    // The root sits at row 0 under the invalid (virtual) parent index.
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    // The root has 2 children, so valid rows are 0 and 1.
    QCOMPARE(model.rowCount(rootIndex), 2);

    // Negative row must return invalid.
    QVERIFY2(!model.index(-1, 0, rootIndex).isValid(), "Negative row must return an invalid index");

    // Row equal to rowCount (one past the end) must return invalid.
    QVERIFY2(!model.index(model.rowCount(rootIndex), 0, rootIndex).isValid(),
             "Row == rowCount must return an invalid index");

    // Large out-of-range row must return invalid.
    QVERIFY2(!model.index(100, 0, rootIndex).isValid(),
             "Large out-of-range row must return an invalid index");

    // Negative column must return invalid.
    QVERIFY2(!model.index(0, -1, rootIndex).isValid(),
             "Negative column must return an invalid index");

    // Column equal to columnCount (model only has 1 column) must return invalid.
    QVERIFY2(!model.index(0, model.columnCount(rootIndex), rootIndex).isValid(),
             "Column == columnCount must return an invalid index");

    // Both row and column out of range must return invalid.
    QVERIFY2(!model.index(-1, -1, rootIndex).isValid(),
             "Both row and column negative must return an invalid index");

    // Out-of-bounds under a leaf node (child with no children).
    QModelIndex child1Index = model.indexOf(child1);
    QVERIFY(child1Index.isValid());
    QCOMPARE(model.rowCount(child1Index), 0);
    QVERIFY2(!model.index(0, 0, child1Index).isValid(),
             "Row 0 under a leaf node (no children) must return an invalid index");

    // Out-of-bounds under the virtual root (invalid parent index).
    // The virtual root has exactly one child (the root object) at row 0.
    QVERIFY2(!model.index(-1, 0, QModelIndex()).isValid(),
             "Negative row under the virtual root must return an invalid index");
    QVERIFY2(!model.index(1, 0, QModelIndex()).isValid(),
             "Row past the single root under the virtual root must return an invalid index");
}

void QObjectTreeModelTest::TestColumnCountIsAlwaysOne()
{
    QObject root;
    new QObject(&root); // Give root a child.

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    // The model exposes a single data column regardless of the parent.
    QCOMPARE(model.columnCount(QModelIndex()), 1);
    QCOMPARE(model.columnCount(rootIndex), 1);

    // A child node should also report one column.
    QModelIndex childIndex = model.index(0, 0, rootIndex);
    QVERIFY(childIndex.isValid());
    QCOMPARE(model.columnCount(childIndex), 1);

    // An index from a foreign model must return 0.
    QObject otherRoot;
    auto otherModel_ptr = QObjectTreeModel::CreateWithRoot(&otherRoot);
    auto &otherModel = *otherModel_ptr;
    QModelIndex foreignIndex = otherModel.indexOf(&otherRoot);
    QVERIFY(foreignIndex.isValid());
    QCOMPARE(model.columnCount(foreignIndex), 0);
}

void QObjectTreeModelTest::TestMetaTypeNameRoleReturnsClassName()
{
    QObject root;
    root.setObjectName(u"root"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    // The root is a plain QObject — MetaTypeName should return "QObject".
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());
    QCOMPARE(rootIndex.data(static_cast<int>(QObjectTreeModel::Roles::MetaTypeName)).toString(),
             u"QObject"_s);

    // Add a QObjectTreeModel as a child — its MetaTypeName should reflect the
    // derived class name.
    auto *childModel = new QObjectTreeModel(&root);
    childModel->setObjectName(u"childModel"_s);
    QModelIndex childIndex = model.indexOf(childModel);
    QVERIFY(childIndex.isValid());
    QCOMPARE(childIndex.data(static_cast<int>(QObjectTreeModel::Roles::MetaTypeName)).toString(),
             u"QObjectTreeModel"_s);

    // An invalid index should return an invalid QVariant.
    QVERIFY(!QModelIndex().data(static_cast<int>(QObjectTreeModel::Roles::MetaTypeName)).isValid());
}

void QObjectTreeModelTest::TestRoleNamesContainsExpectedKeys()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    const QHash<int, QByteArray> roles = model.roleNames();

    // Custom roles must be present with their expected byte-array names.
    QVERIFY(roles.contains(static_cast<int>(QObjectTreeModel::Roles::ObjectName)));
    QCOMPARE(roles.value(static_cast<int>(QObjectTreeModel::Roles::ObjectName)), "objectName");

    QVERIFY(roles.contains(static_cast<int>(QObjectTreeModel::Roles::MetaTypeName)));
    QCOMPARE(roles.value(static_cast<int>(QObjectTreeModel::Roles::MetaTypeName)), "metaTypeName");
}

void QObjectTreeModelTest::TestItemDataReturnsAllRolesForValidIndex()
{
    QObject root;
    root.setObjectName(u"root"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    const QMap<int, QVariant> allData = model.itemData(rootIndex);

    // itemData must contain every role for which data() returns a valid value.
    QVERIFY(allData.contains(Qt::DisplayRole));
    QCOMPARE(allData.value(Qt::DisplayRole).toString(), u"root"_s);

    QVERIFY(allData.contains(static_cast<int>(QObjectTreeModel::Roles::ObjectName)));
    QCOMPARE(allData.value(static_cast<int>(QObjectTreeModel::Roles::ObjectName)).toString(),
             u"root"_s);

    QVERIFY(allData.contains(static_cast<int>(QObjectTreeModel::Roles::MetaTypeName)));
    QCOMPARE(allData.value(static_cast<int>(QObjectTreeModel::Roles::MetaTypeName)).toString(),
             u"QObject"_s);

    // Roles for which data() returns an invalid QVariant (the model only
    // handles DisplayRole, ObjectName, and MetaTypeName) must NOT appear in
    // the map — QAbstractItemModel::itemData filters them out.
    QVERIFY(!allData.contains(Qt::DecorationRole));
    QVERIFY(!allData.contains(Qt::ToolTipRole));

    // An invalid index must return an empty map.
    QVERIFY(model.itemData(QModelIndex()).isEmpty());
}

void QObjectTreeModelTest::TestDataReturnsInvalidVariantForEdgeCases()
{
    QObject root;
    root.setObjectName(u"root"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    // 1. An invalid QModelIndex must return an invalid QVariant for every role.
    QVERIFY(!model.data(QModelIndex(), Qt::DisplayRole).isValid());
    QVERIFY(
        !model.data(QModelIndex(), static_cast<int>(QObjectTreeModel::Roles::ObjectName)).isValid());
    QVERIFY(!model.data(QModelIndex(), static_cast<int>(QObjectTreeModel::Roles::MetaTypeName))
                 .isValid());

    // 2. An unrecognized / unsupported role must return an invalid QVariant.
    QVERIFY(!model.data(rootIndex, Qt::DecorationRole).isValid());
    QVERIFY(!model.data(rootIndex, Qt::ToolTipRole).isValid());
    QVERIFY(!model.data(rootIndex, Qt::UserRole + 9999).isValid());

    // 3. An index from a different model must return an invalid QVariant.
    QObject otherRoot;
    otherRoot.setObjectName(u"otherRoot"_s);
    auto otherModel_ptr = QObjectTreeModel::CreateWithRoot(&otherRoot);
    auto &otherModel = *otherModel_ptr;
    QAbstractItemModelTester tester_other(&otherModel,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex foreignIndex = otherModel.indexOf(&otherRoot);
    QVERIFY(foreignIndex.isValid());

    QVERIFY(!model.data(foreignIndex, Qt::DisplayRole).isValid());
    QVERIFY(
        !model.data(foreignIndex, static_cast<int>(QObjectTreeModel::Roles::ObjectName)).isValid());
    QVERIFY(!model.data(foreignIndex, static_cast<int>(QObjectTreeModel::Roles::MetaTypeName))
                 .isValid());
}

void QObjectTreeModelTest::TestHasChildrenMatchesRowCount()
{
    QObject root;
    root.setObjectName(u"root"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);

    // Root with no children.
    QCOMPARE(model.hasChildren(rootIndex), false);

    // Add a child — root should now have children.
    auto *child = new QObject(&root);
    child->setObjectName(u"child"_s);
    QCOMPARE(model.hasChildren(rootIndex), true);

    QModelIndex childIndex = model.indexOf(child);
    QVERIFY(childIndex.isValid());

    // Leaf node should have no children.
    QCOMPARE(model.hasChildren(childIndex), false);

    // Add a grandchild — child should now have children.
    auto *grandchild = new QObject(child);
    grandchild->setObjectName(u"grandchild"_s);
    QCOMPARE(model.hasChildren(childIndex), true);

    // Invalid model index: the default parent represents the invisible root
    // which always has the root object as its child.
    QCOMPARE(model.hasChildren(QModelIndex()), true);
}

void QObjectTreeModelTest::TestRowCountOfRootObjectWithNoChildren()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QCOMPARE(model.rowCount(rootIndex), 0);
}

void QObjectTreeModelTest::TestRowCountOfRootObjectWithChild()
{
    QObject root;       // Create root.
    new QObject(&root); // Create child.

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QCOMPARE(model.rowCount(rootIndex), 1);
}

void QObjectTreeModelTest::TestRowCountOfRootObjectWithChildren()
{
    QObject root;
    new QObject(&root);
    new QObject(&root);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QCOMPARE(model.rowCount(rootIndex), 2);
}

void QObjectTreeModelTest::TestRowCountOfChildObjectWithNoChildren()
{
    QObject root;
    QObject *child = new QObject(&root);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QModelIndex childIndex = model.indexOf(child);

    QCOMPARE(model.rowCount(rootIndex), 1);
    QCOMPARE(model.rowCount(childIndex), 0);
}

void QObjectTreeModelTest::TestRowCountOfChildObjectWithChild()
{
    QObject root;
    QObject *child = new QObject(&root);
    new QObject(child);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QModelIndex childIndex = model.indexOf(child);

    QCOMPARE(model.rowCount(rootIndex), 1);
    QCOMPARE(model.rowCount(childIndex), 1);
}

void QObjectTreeModelTest::TestRowCountOfChildObjectWithChildren()
{
    QObject root;
    QObject *child = new QObject(&root);
    new QObject(child);
    new QObject(child);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QModelIndex childIndex = model.indexOf(child);

    QCOMPARE(model.rowCount(rootIndex), 1);
    QCOMPARE(model.rowCount(childIndex), 2);
}

void QObjectTreeModelTest::TestInsertionViaCreatingChildParentedToModelRoot()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    // Check that the root has no children to begin with.
    QCOMPARE(model.rowCount(rootIndex), 0);

    QSignalSpy rowsAboutToBeInsertedSpy(&model, &QAbstractItemModel::rowsAboutToBeInserted);
    QVERIFY(rowsAboutToBeInsertedSpy.isValid());

    QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
    QVERIFY(rowsInsertedSpy.isValid());

    // Add a child to the root.
    QObject *child = new QObject(&root);
    QCOMPARE(child->parent(), &root);

    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 1);
    if (rowsAboutToBeInsertedSpy.count()) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeInsertedSpy.takeFirst(), &root, 0, 0);
    }

    QCOMPARE(rowsInsertedSpy.count(), 1);
    if (rowsInsertedSpy.count()) {
        VERIFY_SIGNAL_ARGS(rowsInsertedSpy.takeFirst(), &root, 0, 0);
    }

    QModelIndex childIndex = model.indexOf(child);

    // check child index is correct
    QVERIFY(childIndex.isValid());
    QCOMPARE(childIndex.internalPointer(), child);

    QCOMPARE(model.rowCount(rootIndex), 1);  // Root should now have one child.
    QCOMPARE(model.rowCount(childIndex), 0); // child should have no children.
}

void QObjectTreeModelTest::TestInsertionViaParentingExistingQObjectToModelRoot()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    // Check that the root has no children to begin with.
    QCOMPARE(model.rowCount(rootIndex), 0);

    QSignalSpy rowsAboutToBeInsertedSpy(&model, &QAbstractItemModel::rowsAboutToBeInserted);
    QVERIFY(rowsAboutToBeInsertedSpy.isValid());

    QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
    QVERIFY(rowsInsertedSpy.isValid());

    // Add a child to the root.
    QObject *child = new QObject(nullptr);
    child->setParent(&root);
    QCOMPARE(child->parent(), &root);

    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 1);
    if (rowsAboutToBeInsertedSpy.count()) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeInsertedSpy.takeFirst(), &root, 0, 0);
    }

    QCOMPARE(rowsInsertedSpy.count(), 1);
    if (rowsInsertedSpy.count()) {
        VERIFY_SIGNAL_ARGS(rowsInsertedSpy.takeFirst(), &root, 0, 0);
    }

    QModelIndex childIndex = model.indexOf(child);

    // check child index is correct
    QVERIFY(childIndex.isValid());
    QCOMPARE(childIndex.internalPointer(), child);

    QCOMPARE(model.rowCount(rootIndex), 1);  // Root should now have one child.
    QCOMPARE(model.rowCount(childIndex), 0); // child should have no children.
}

// Do not insert a QObject if deleteLater has already been called on it.
void QObjectTreeModelTest::TestInsertionExistingDeletedLaterQObjectToModelRoot()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    // Check that the root has no children to begin with.
    QCOMPARE(model.rowCount(rootIndex), 0);

    QSignalSpy rowsAboutToBeInsertedSpy(&model, &QAbstractItemModel::rowsAboutToBeInserted);
    QVERIFY(rowsAboutToBeInsertedSpy.isValid());

    QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
    QVERIFY(rowsInsertedSpy.isValid());

    // Add a child to the root.
    QObject *child = new QObject(nullptr);
    child->deleteLater();
    child->setParent(&root);
    QCOMPARE(child->parent(), &root);

    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);
    QCOMPARE(model.rowCount(rootIndex), 0); // Root should still have no children.
}

void QObjectTreeModelTest::TestInsertedChildrenHaveCorrectModelIndex()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    // Check that the root has no children to begin with.
    QCOMPARE(model.rowCount(rootIndex), 0);

    QSignalSpy rowsAboutToBeInsertedSpy(&model, &QAbstractItemModel::rowsAboutToBeInserted);
    QVERIFY(rowsAboutToBeInsertedSpy.isValid());

    QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
    QVERIFY(rowsInsertedSpy.isValid());

    // Add a child to the root.
    int expectedChildCount{10};
    for (int i = 0; i < expectedChildCount; i++) {
        QObject *child = new QObject(nullptr);
        child->setObjectName(u"child "_s + QString::number(i));
        child->setParent(&root);
    }

    QCOMPARE(rowsAboutToBeInsertedSpy.count(), expectedChildCount);
    for (int i = 0; !rowsAboutToBeInsertedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeInsertedSpy.takeFirst(), &root, i, i);
    }

    QCOMPARE(rowsInsertedSpy.count(), expectedChildCount);
    for (int i = 0; !rowsInsertedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsInsertedSpy.takeFirst(), &root, i, i);
    }

    // As a final check test the index of the new children.
    for (int i = 0; i < expectedChildCount; i++) {
        auto childIndex = model.indexOf(root.children()[i]);
        QCOMPARE(childIndex.row(), i);
        QCOMPARE(childIndex.column(), 0);
    }

    QCOMPARE(model.rowCount(rootIndex), expectedChildCount);
}

void QObjectTreeModelTest::TestInsertedSubChildrenHaveCorrectModelIndex()
{
    QObject root;
    QObject *subRoot = new QObject(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex subRootIndex = model.indexOf(subRoot);

    // Check that the root has no children to begin with.
    QCOMPARE(model.rowCount(subRootIndex), 0);

    QSignalSpy rowsAboutToBeInsertedSpy(&model, &QAbstractItemModel::rowsAboutToBeInserted);
    QVERIFY(rowsAboutToBeInsertedSpy.isValid());

    QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
    QVERIFY(rowsInsertedSpy.isValid());

    // Add a child to the root.
    int expectedChildCount{10};
    for (int i = 0; i < expectedChildCount; i++) {
        QObject *child = new QObject(nullptr);
        child->setObjectName(u"child "_s + QString::number(i));
        child->setParent(subRoot);
    }

    QCOMPARE(rowsAboutToBeInsertedSpy.count(), expectedChildCount);
    for (int i = 0; !rowsAboutToBeInsertedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeInsertedSpy.takeFirst(), subRoot, i, i);
    }

    QCOMPARE(rowsInsertedSpy.count(), expectedChildCount);
    for (int i = 0; !rowsInsertedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsInsertedSpy.takeFirst(), subRoot, i, i);
    }

    // As a final check test the index of the new children.
    for (int i = 0; i < expectedChildCount; i++) {
        auto childIndex = model.indexOf(subRoot->children()[i]);
        QCOMPARE(childIndex.row(), i);
        QCOMPARE(childIndex.column(), 0);
    }

    QCOMPARE(model.rowCount(subRootIndex), expectedChildCount);
}

void QObjectTreeModelTest::TestInsertedSubTreeHasCorrectModelIndices()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    // Create a simple subtree of QObjects.
    QObject *subTree = new QObject();
    int expectedChildCount{10};
    int subTreeDepth{2};
    for (int i = 0; i < expectedChildCount; i++) {
        QObject *child = new QObject(nullptr);
        child->setObjectName(u"child "_s + QString::number(i));
        child->setParent(subTree);
    }

    // Check that the root has no children to begin with.
    QCOMPARE(model.rowCount(rootIndex), 0);

    QSignalSpy rowsAboutToBeInsertedSpy(&model, &QAbstractItemModel::rowsAboutToBeInserted);
    QVERIFY(rowsAboutToBeInsertedSpy.isValid());

    QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
    QVERIFY(rowsInsertedSpy.isValid());

    // Parent the subtree to the root item of the model.
    subTree->setParent(&root);
    QModelIndex subTreeIndex = model.indexOf(subTree);

    // Check that the root now has one child (i.e. subTree).
    QCOMPARE(model.rowCount(rootIndex), 1);

    QCOMPARE(rowsAboutToBeInsertedSpy.count(), subTreeDepth);
    if (rowsAboutToBeInsertedSpy.count()) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeInsertedSpy.takeFirst(), &root, 0, 0);
        VERIFY_SIGNAL_ARGS(rowsAboutToBeInsertedSpy.takeFirst(), subTree, 0, expectedChildCount - 1);
    }

    QCOMPARE(rowsInsertedSpy.count(), subTreeDepth);
    if (rowsInsertedSpy.count()) {
        VERIFY_SIGNAL_ARGS(rowsInsertedSpy.takeFirst(), &root, 0, 0);
        VERIFY_SIGNAL_ARGS(rowsInsertedSpy.takeFirst(), subTree, 0, expectedChildCount - 1);
    }

    // As a final check test the index of the new children.
    for (int i = 0; i < expectedChildCount; i++) {
        auto childIndex = model.indexOf(subTree->children()[i]);
        QCOMPARE(childIndex.row(), i);
        QCOMPARE(childIndex.column(), 0);
        QCOMPARE(childIndex.parent().internalPointer(), subTree);
    }

    QCOMPARE(model.rowCount(subTreeIndex), expectedChildCount);
}

void QObjectTreeModelTest::TestRemovalFromChildDeletion()
{
    QObject root;
    QObject *child = new QObject(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    // Check that the root has one child.
    QCOMPARE(model.rowCount(rootIndex), 1);

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsRemovedSpy.isValid());

    // Delete the child.
    child->deleteLater();

    rowsAboutToBeRemovedSpy.wait(250);
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeRemovedSpy.takeFirst(), &root, 0, 0);
    }

    QCOMPARE(rowsRemovedSpy.count(), 1);
    for (int i = 0; !rowsRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsRemovedSpy.takeFirst(), &root, 0, 0);
    }

    // Check that the root now has no children.
    QCOMPARE(model.rowCount(rootIndex), 0);
}

// Test that deleting a QObject via delete works (even if not recommended).
void QObjectTreeModelTest::TestRemovalFromChildRawDelete()
{
    QObject root;
    QObject *child = new QObject(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    // Check that the root has one child.
    QCOMPARE(model.rowCount(rootIndex), 1);

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsRemovedSpy.isValid());

    // Delete the child. The destroyed signal fires synchronously during
    // delete so no event loop spin is needed.
    delete child;

    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeRemovedSpy.takeFirst(), &root, 0, 0);
    }

    QCOMPARE(rowsRemovedSpy.count(), 1);
    for (int i = 0; !rowsRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsRemovedSpy.takeFirst(), &root, 0, 0);
    }

    // Check that the root now has no children.
    QCOMPARE(model.rowCount(rootIndex), 0);
}

void QObjectTreeModelTest::TestRemovalFromSubChildDeletion()
{
    QObject root;
    QObject *child = new QObject(&root);
    QObject *subChild = new QObject(child);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QModelIndex childIndex = model.indexOf(child);
    QModelIndex subChildIndex = model.indexOf(subChild);

    // Check that all objects have the correct number of children.
    QCOMPARE(model.rowCount(rootIndex), 1);
    QCOMPARE(model.rowCount(childIndex), 1);
    QCOMPARE(model.rowCount(subChildIndex), 0);

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsRemovedSpy.isValid());

    // Delete the subChild.
    subChild->deleteLater();

    rowsAboutToBeRemovedSpy.wait(250);
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeRemovedSpy.takeFirst(), child, 0, 0);
    }

    QCOMPARE(rowsRemovedSpy.count(), 1);
    for (int i = 0; !rowsRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsRemovedSpy.takeFirst(), child, 0, 0);
    }

    // Verify that the child's rowCount is now zero.
    QCOMPARE(model.rowCount(rootIndex), 1);
    QCOMPARE(model.rowCount(childIndex), 0);
}

void QObjectTreeModelTest::TestRemovalFromSubtreeRootDeletion()
{
    QObject root;

    // Create a simple subtree of QObjects.
    QObject *subTree = new QObject(&root);
    int expectedChildCount{10};
    for (int i = 0; i < expectedChildCount; i++) {
        QObject *child = new QObject(nullptr);
        child->setObjectName(u"child "_s + QString::number(i));
        child->setParent(subTree);
    }

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QModelIndex rootTreeIndex = model.indexOf(subTree);

    // Check that the subTree has the expected number of children.
    QCOMPARE(model.rowCount(rootTreeIndex), expectedChildCount);

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsRemovedSpy.isValid());

    // Delete the subtree.
    subTree->deleteLater();

    rowsAboutToBeRemovedSpy.wait(250);
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeRemovedSpy.takeFirst(), &root, 0, 0);
    }

    QCOMPARE(rowsRemovedSpy.count(), 1);
    for (int i = 0; !rowsRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsRemovedSpy.takeFirst(), &root, 0, 0);
    }

    // Check that the root now has no children.
    QCOMPARE(model.rowCount(rootIndex), 0);
}

// Raw delete a child that itself has one child. The destroyed signal fires at
// the start of ~QObject while both objects are still alive, so the model removes
// the entire subtree in a single beginRemoveRows/endRemoveRows. The subsequent
// ChildRemoved events from ~QObject are then no-ops.
void QObjectTreeModelTest::TestRawDeleteChildWithOneChild()
{
    QObject root;
    QObject *child = new QObject(&root);
    QObject *grandchild = new QObject(child);
    Q_UNUSED(grandchild);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QModelIndex childIndex = model.indexOf(child);

    QCOMPARE(model.rowCount(rootIndex), 1);
    QCOMPARE(model.rowCount(childIndex), 1);

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsRemovedSpy.isValid());

    // Raw delete — destroyed(child) fires first, model removes child + grandchild
    // as a single subtree. ~QObject then proceeds to deleteChildren/setParent but
    // the model has already cleaned everything up.
    delete child;

    // One removal signal for the subtree root (child removed from root).
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
    QCOMPARE(rowsRemovedSpy.count(), 1);
    VERIFY_SIGNAL_ARGS(rowsAboutToBeRemovedSpy.takeFirst(), &root, 0, 0);

    QCOMPARE(model.rowCount(rootIndex), 0);

    // Internal maps should only contain the root.
    QCOMPARE(model.m_childParentMap.size(), 1);
    QVERIFY(model.m_childParentMap.contains(&root));
}

// Raw delete a child that has grandchildren and great-grandchildren (3 levels
// deep). The destroyed signal lets the model remove the entire subtree in one
// operation while all objects are still alive.
void QObjectTreeModelTest::TestRawDeleteChildWithGrandchildren()
{
    QObject root;
    QObject *child = new QObject(&root);
    child->setObjectName(u"child"_s);
    QObject *grandchild = new QObject(child);
    grandchild->setObjectName(u"grandchild"_s);
    QObject *greatGrandchild = new QObject(grandchild);
    greatGrandchild->setObjectName(u"greatGrandchild"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QCOMPARE(model.rowCount(rootIndex), 1);
    QCOMPARE(model.rowCount(model.indexOf(child)), 1);
    QCOMPARE(model.rowCount(model.indexOf(grandchild)), 1);
    QCOMPARE(model.rowCount(model.indexOf(greatGrandchild)), 0);

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsRemovedSpy.isValid());

    delete child;

    // Single removal signal: the entire subtree is removed at once via
    // destroyed(child), before ~QObject touches any descendants.
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
    QCOMPARE(rowsRemovedSpy.count(), 1);
    VERIFY_SIGNAL_ARGS(rowsAboutToBeRemovedSpy.takeFirst(), &root, 0, 0);

    QCOMPARE(model.rowCount(rootIndex), 0);
    QCOMPARE(model.m_childParentMap.size(), 1);
    QVERIFY(model.m_childParentMap.contains(&root));
}

// Raw delete a child that has many direct children (flat subtree). The entire
// subtree is removed in one operation via the destroyed signal.
void QObjectTreeModelTest::TestRawDeleteChildWithWideFlatSubtree()
{
    QObject root;
    QObject *child = new QObject(&root);
    child->setObjectName(u"child"_s);

    constexpr int kGrandchildCount = 5;
    for (int i = 0; i < kGrandchildCount; ++i) {
        auto *gc = new QObject(child);
        gc->setObjectName(u"gc"_s + QString::number(i));
    }

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QModelIndex childIndex = model.indexOf(child);

    QCOMPARE(model.rowCount(rootIndex), 1);
    QCOMPARE(model.rowCount(childIndex), kGrandchildCount);

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsRemovedSpy.isValid());

    delete child;

    // Single removal signal — all grandchildren are cleaned up internally by
    // removeAndDisconnectSubtree, only the top-level child emits model signals.
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
    QCOMPARE(rowsRemovedSpy.count(), 1);
    VERIFY_SIGNAL_ARGS(rowsAboutToBeRemovedSpy.takeFirst(), &root, 0, 0);

    QCOMPARE(model.rowCount(rootIndex), 0);
    QCOMPARE(model.m_childParentMap.size(), 1);
}

// Raw delete a middle child while siblings on either side survive. The model
// must only remove the deleted child (and its subtree) and leave the remaining
// siblings intact with correct indices.
void QObjectTreeModelTest::TestRawDeleteMiddleChildLeavingSiblings()
{
    QObject root;
    QObject *child0 = new QObject(&root);
    child0->setObjectName(u"child0"_s);
    QObject *child1 = new QObject(&root);
    child1->setObjectName(u"child1"_s);
    QObject *child2 = new QObject(&root);
    child2->setObjectName(u"child2"_s);

    // Give child1 a subtree so we also exercise nested cleanup.
    QObject *grandchild = new QObject(child1);
    grandchild->setObjectName(u"grandchild"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QCOMPARE(model.rowCount(rootIndex), 3);
    QCOMPARE(model.rowCount(model.indexOf(child1)), 1);

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    // Delete the middle child.
    delete child1;

    // Single signal: child1 (at row 1) removed from root. The grandchild is
    // cleaned up internally by removeAndDisconnectSubtree.
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
    VERIFY_SIGNAL_ARGS(rowsAboutToBeRemovedSpy.takeFirst(), &root, 1, 1);

    // Siblings survive and re-index correctly.
    QCOMPARE(model.rowCount(rootIndex), 2);

    QModelIndex child0Index = model.indexOf(child0);
    QVERIFY(child0Index.isValid());
    QCOMPARE(child0Index.row(), 0);

    QModelIndex child2Index = model.indexOf(child2);
    QVERIFY(child2Index.isValid());
    QCOMPARE(child2Index.row(), 1);

    // Internal maps: root + child0 + child2 = 3 entries.
    QCOMPARE(model.m_childParentMap.size(), 3);
    QVERIFY(!model.m_childParentMap.contains(child1));
}

void QObjectTreeModelTest::TestRemovalFromChildReparent()
{
    QObject root;
    QObject child(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    // Check that the root has one child.
    QCOMPARE(model.rowCount(rootIndex), 1);

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsRemovedSpy.isValid());

    // Remove the child via reparenting. setParent fires the ChildRemoved
    // event synchronously so no event loop spin is needed.
    child.setParent(nullptr);

    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeRemovedSpy.takeFirst(), &root, 0, 0);
    }

    QCOMPARE(rowsRemovedSpy.count(), 1);
    for (int i = 0; !rowsRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsRemovedSpy.takeFirst(), &root, 0, 0);
    }

    // Check that the root now has no children.
    QCOMPARE(model.rowCount(rootIndex), 0);
}

void QObjectTreeModelTest::TestRemovalFromSubChildReparent()
{
    QObject root;
    QObject *child = new QObject(&root);
    QObject subChild(child);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QModelIndex childIndex = model.indexOf(child);
    QModelIndex subChildIndex = model.indexOf(&subChild);

    // Check that all objects have the correct number of children.
    QCOMPARE(model.rowCount(rootIndex), 1);
    QCOMPARE(model.rowCount(childIndex), 1);
    QCOMPARE(model.rowCount(subChildIndex), 0);

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsRemovedSpy.isValid());

    // Remove the subchild via reparenting. setParent fires the ChildRemoved
    // event synchronously so no event loop spin is needed.
    subChild.setParent(nullptr);

    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeRemovedSpy.takeFirst(), child, 0, 0);
    }

    QCOMPARE(rowsRemovedSpy.count(), 1);
    for (int i = 0; !rowsRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsRemovedSpy.takeFirst(), child, 0, 0);
    }

    // Verify that the child's rowCount is now zero.
    QCOMPARE(model.rowCount(rootIndex), 1);
    QCOMPARE(model.rowCount(childIndex), 0);
}

void QObjectTreeModelTest::TestRemovalFromSubTreeReparent()
{
    QObject root;

    // Create a simple subtree of QObjects.
    QObject subTree(&root);
    int expectedChildCount{10};
    for (int i = 0; i < expectedChildCount; i++) {
        QObject *child = new QObject(nullptr);
        child->setObjectName(u"child "_s + QString::number(i));
        child->setParent(&subTree);
    }

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QModelIndex rootTreeIndex = model.indexOf(&subTree);

    // Check that the subTree has the expected number of children.
    QCOMPARE(model.rowCount(rootTreeIndex), expectedChildCount);

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsRemovedSpy.isValid());

    // Remove the subTree via reparenting. setParent fires the ChildRemoved
    // event synchronously so no event loop spin is needed.
    subTree.setParent(nullptr);

    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeRemovedSpy.takeFirst(), &root, 0, 0);
    }

    QCOMPARE(rowsRemovedSpy.count(), 1);
    for (int i = 0; !rowsRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsRemovedSpy.takeFirst(), &root, 0, 0);
    }

    // Check that the root now has no children.
    QCOMPARE(model.rowCount(rootIndex), 0);
}

void QObjectTreeModelTest::TestChildMovedViaSetParentToEndOfDifferentRow()
{
    QObject root;

    QObject *row1 = new QObject(&root);
    QObject *child1 = new QObject(row1);
    [[maybe_unused]] QObject *child2 = new QObject(row1);

    QObject *row2 = new QObject(&root);
    [[maybe_unused]] QObject *child3 = new QObject(row2);
    [[maybe_unused]] QObject *child4 = new QObject(row2);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QModelIndex row1Index = model.indexOf(row1);
    QModelIndex row2Index = model.indexOf(row2);

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 2);
    QCOMPARE(model.rowCount(row1Index), 2);
    QCOMPARE(model.rowCount(row2Index), 2);

    QSignalSpy rowsAboutToBeInsertedSpy(&model, &QAbstractItemModel::rowsAboutToBeInserted);
    QVERIFY(rowsAboutToBeInsertedSpy.isValid());

    QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
    QVERIFY(rowsInsertedSpy.isValid());

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsRemovedSpy.isValid());

    QSignalSpy rowsAboutToBeMovedSpy(&model, &QAbstractItemModel::rowsAboutToBeMoved);
    QVERIFY(rowsAboutToBeMovedSpy.isValid());

    QSignalSpy rowsMovedSpy(&model, &QAbstractItemModel::rowsMoved);
    QVERIFY(rowsMovedSpy.isValid());

    // Move child1 to row2 via setParent.
    child1->setParent(row2);

    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeRemovedSpy.takeFirst(), row1, 0, 0);
    }

    QCOMPARE(rowsRemovedSpy.count(), 1);
    for (int i = 0; !rowsRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsRemovedSpy.takeFirst(), row1, 0, 0);
    }

    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeInsertedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeInsertedSpy.takeFirst(), row2, 2, 2);
    }

    QCOMPARE(rowsInsertedSpy.count(), 1);
    for (int i = 0; !rowsInsertedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsInsertedSpy.takeFirst(), row2, 2, 2);
    }

    // QObject::setParent moves are not supported.
    QCOMPARE(rowsAboutToBeMovedSpy.count(), 0);
    QCOMPARE(rowsMovedSpy.count(), 0);

    QCOMPARE(model.rowCount(rootIndex), 2);
    QCOMPARE(model.rowCount(row1Index), 1);
    QCOMPARE(model.rowCount(row2Index), 3);
}

void QObjectTreeModelTest::TestSubTreeMovedViaSetParentToEndOfDifferentRow()
{
    QObject root;

    QObject *row1 = new QObject(&root);
    [[maybe_unused]] QObject *child1 = new QObject(row1);

    // Create a simple subtree of QObjects.
    QObject *subTree = new QObject(row1);
    int expectedChildCount{10};
    int subTreeDepth{2};
    for (int i = 0; i < expectedChildCount; i++) {
        QObject *child = new QObject(nullptr);
        child->setObjectName(u"child "_s + QString::number(i));
        child->setParent(subTree);
    }

    QObject *row2 = new QObject(&root);
    [[maybe_unused]] QObject *child3 = new QObject(row2);
    [[maybe_unused]] QObject *child4 = new QObject(row2);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QModelIndex row1Index = model.indexOf(row1);
    QModelIndex row2Index = model.indexOf(row2);

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 2);
    QCOMPARE(model.rowCount(row1Index), 2);
    QCOMPARE(model.rowCount(row2Index), 2);

    QSignalSpy rowsAboutToBeInsertedSpy(&model, &QAbstractItemModel::rowsAboutToBeInserted);
    QVERIFY(rowsAboutToBeInsertedSpy.isValid());

    QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
    QVERIFY(rowsInsertedSpy.isValid());

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsRemovedSpy.isValid());

    QSignalSpy rowsAboutToBeMovedSpy(&model, &QAbstractItemModel::rowsAboutToBeMoved);
    QVERIFY(rowsAboutToBeMovedSpy.isValid());

    QSignalSpy rowsMovedSpy(&model, &QAbstractItemModel::rowsMoved);
    QVERIFY(rowsMovedSpy.isValid());

    // Move subTree to row2 via setParent.
    subTree->setParent(row2);

    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeRemovedSpy.takeFirst(), row1, 1, 1);
    }

    QCOMPARE(rowsRemovedSpy.count(), 1);
    for (int i = 0; !rowsRemovedSpy.isEmpty(); i++) {
        VERIFY_SIGNAL_ARGS(rowsRemovedSpy.takeFirst(), row1, 1, 1);
    }

    QCOMPARE(rowsAboutToBeInsertedSpy.count(), subTreeDepth);
    if (rowsAboutToBeInsertedSpy.count()) {
        VERIFY_SIGNAL_ARGS(rowsAboutToBeInsertedSpy.takeFirst(), row2, 2, 2);
        VERIFY_SIGNAL_ARGS(rowsAboutToBeInsertedSpy.takeFirst(), subTree, 0, expectedChildCount - 1);
    }

    QCOMPARE(rowsInsertedSpy.count(), subTreeDepth);
    if (rowsInsertedSpy.count()) {
        VERIFY_SIGNAL_ARGS(rowsInsertedSpy.takeFirst(), row2, 2, 2);
        VERIFY_SIGNAL_ARGS(rowsInsertedSpy.takeFirst(), subTree, 0, expectedChildCount - 1);
    }

    // QObject::setParent moves are not supported.
    QCOMPARE(rowsAboutToBeMovedSpy.count(), 0);
    QCOMPARE(rowsMovedSpy.count(), 0);

    QCOMPARE(model.rowCount(rootIndex), 2);
    QCOMPARE(model.rowCount(row1Index), 1);
    QCOMPARE(model.rowCount(row2Index), 3);
}

void QObjectTreeModelTest::TestMoveChild()
{
    QObject root;

    QObject *child1 = new QObject(&root);
    [[maybe_unused]] QObject *child2 = new QObject(&root);
    [[maybe_unused]] QObject *child3 = new QObject(&root);
    [[maybe_unused]] QObject *child4 = new QObject(&root);
    QObject *child5 = new QObject(&root);
    QObject *subchild1 = new QObject(child5);
    subchild1->setObjectName("subchild1");
    [[maybe_unused]] QObject *subchild2 = new QObject(child5);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 5);

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsRemovedSpy.isValid());

    QSignalSpy rowsAboutToBeInsertedSpy(&model, &QAbstractItemModel::rowsAboutToBeInserted);
    QVERIFY(rowsAboutToBeInsertedSpy.isValid());

    QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
    QVERIFY(rowsInsertedSpy.isValid());

    QSignalSpy rowsAboutToBeMovedSpy(&model, &QAbstractItemModel::rowsAboutToBeMoved);
    QVERIFY(rowsAboutToBeMovedSpy.isValid());

    QSignalSpy rowsMovedSpy(&model, &QAbstractItemModel::rowsMoved);
    QVERIFY(rowsMovedSpy.isValid());

    // Check that moving child1 to its current index does nothing.
    QObjectTreeModel::SetParent(child1, &root, 0);
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeMovedSpy.count(), 0);
    QCOMPARE(rowsMovedSpy.count(), 0);

    // Check that moving child1 to element 1 works as expected.
    QObjectTreeModel::SetParent(child1, &root, 1);
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);

    QCOMPARE(rowsAboutToBeMovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsAboutToBeMovedSpy.takeFirst(), &root, 0, 0, &root, 2);
    }

    QCOMPARE(rowsMovedSpy.count(), 1);
    for (int i = 0; !rowsMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsMovedSpy.takeFirst(), &root, 0, 0, &root, 2);
    }

    // Check that moving child1 to the second element in the list works.
    QObjectTreeModel::SetParent(child1, &root, 2);
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);

    QCOMPARE(rowsAboutToBeMovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsAboutToBeMovedSpy.takeFirst(), &root, 1, 1, &root, 3);
    }

    QCOMPARE(rowsMovedSpy.count(), 1);
    for (int i = 0; !rowsMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsMovedSpy.takeFirst(), &root, 1, 1, &root, 3);
    }

    // Test moving child1 to the end of the list.
    QObjectTreeModel::SetParent(child1, &root, 5);
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);

    QCOMPARE(rowsAboutToBeMovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsAboutToBeMovedSpy.takeFirst(), &root, 2, 2, &root, 5);
    }

    QCOMPARE(rowsMovedSpy.count(), 1);
    for (int i = 0; !rowsMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsMovedSpy.takeFirst(), &root, 2, 2, &root, 5);
    }

    // Test moving child1 to the last element in the list when we're already there.
    QObjectTreeModel::SetParent(child1, &root, -1);
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeMovedSpy.count(), 0);
    QCOMPARE(rowsMovedSpy.count(), 0);

    // Test moving child1 to and index that is beyond the end of the list does nothing
    QObjectTreeModel::SetParent(child1, &root, 99);
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeMovedSpy.count(), 0);
    QCOMPARE(rowsMovedSpy.count(), 0);

    // Test moving child1 to the second last element in the list.
    QObjectTreeModel::SetParent(child1, &root, -3);
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);

    QCOMPARE(rowsAboutToBeMovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsAboutToBeMovedSpy.takeFirst(), &root, 4, 4, &root, 2);
    }

    QCOMPARE(rowsMovedSpy.count(), 1);
    for (int i = 0; !rowsMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsMovedSpy.takeFirst(), &root, 4, 4, &root, 2);
    }

    // Test moving child1 to the last element in the list when it is not already there.
    QObjectTreeModel::SetParent(child1, &root, -1);
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);

    QCOMPARE(rowsAboutToBeMovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsAboutToBeMovedSpy.takeFirst(), &root, 2, 2, &root, 5);
    }

    QCOMPARE(rowsMovedSpy.count(), 1);
    for (int i = 0; !rowsMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsMovedSpy.takeFirst(), &root, 2, 2, &root, 5);
    }

    // Test moving child1 to under a subchild works.
    QObjectTreeModel::SetParent(child1, subchild1, 0);
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);

    QCOMPARE(rowsAboutToBeMovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsAboutToBeMovedSpy.takeFirst(), &root, 4, 4, subchild1, 0);
    }

    QCOMPARE(rowsMovedSpy.count(), 1);
    for (int i = 0; !rowsMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsMovedSpy.takeFirst(), &root, 4, 4, subchild1, 0);
    }

    // Test moving child1 to the start of roots children works with a negative index.
    QObjectTreeModel::SetParent(child1, &root, -99);
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);

    QCOMPARE(rowsAboutToBeMovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsAboutToBeMovedSpy.takeFirst(), subchild1, 0, 0, &root, 0);
    }

    QCOMPARE(rowsMovedSpy.count(), 1);
    for (int i = 0; !rowsMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsMovedSpy.takeFirst(), subchild1, 0, 0, &root, 0);
    }

    // Test moving child1 to the second position in a subtree when not in the subtree to start with.
    QObjectTreeModel::SetParent(child1, child5, 1);
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);

    QCOMPARE(rowsAboutToBeMovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsAboutToBeMovedSpy.takeFirst(), &root, 0, 0, child5, 1);
    }

    QCOMPARE(rowsMovedSpy.count(), 1);
    for (int i = 0; !rowsMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsMovedSpy.takeFirst(), &root, 0, 0, child5, 1);
    }
}

void QObjectTreeModelTest::TestMoveRow()
{
    QObject root;

    QObject *child1 = new QObject(&root);
    /* QObject* child2 = */ new QObject(&root);
    /* QObject* child3 = */ new QObject(&root);
    /* QObject* child4 = */ new QObject(&root);
    QObject *child5 = new QObject(&root);
    /* QObject* subchild1 = */ new QObject(child5);
    /* QObject* subchild2 = */ new QObject(child5);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    QModelIndex childIndex = model.indexOf(child1);
    QVERIFY(childIndex.isValid());

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 5);

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());

    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsRemovedSpy.isValid());

    QSignalSpy rowsAboutToBeInsertedSpy(&model, &QAbstractItemModel::rowsAboutToBeInserted);
    QVERIFY(rowsAboutToBeInsertedSpy.isValid());

    QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
    QVERIFY(rowsInsertedSpy.isValid());

    QSignalSpy rowsAboutToBeMovedSpy(&model, &QAbstractItemModel::rowsAboutToBeMoved);
    QVERIFY(rowsAboutToBeMovedSpy.isValid());

    QSignalSpy rowsMovedSpy(&model, &QAbstractItemModel::rowsMoved);
    QVERIFY(rowsMovedSpy.isValid());

    // Test moving the first child to itself is a no-op.
    QVERIFY(!model.moveRow(rootIndex, 0, rootIndex, 0));
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeMovedSpy.count(), 0);
    QCOMPARE(rowsMovedSpy.count(), 0);
    QCOMPARE(root.children().indexOf(child1), 0);

    // Test moving the first child after itself is also a no-op.
    QVERIFY(!model.moveRow(rootIndex, 0, rootIndex, 1));
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeMovedSpy.count(), 0);
    QCOMPARE(rowsMovedSpy.count(), 0);
    QCOMPARE(root.children().indexOf(child1), 0);

    // Test moving to second element.
    QVERIFY(model.moveRow(rootIndex, 0, rootIndex, 2));
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeMovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsAboutToBeMovedSpy.takeFirst(), &root, 0, 0, &root, 2);
    }
    QCOMPARE(rowsMovedSpy.count(), 1);
    for (int i = 0; !rowsMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsMovedSpy.takeFirst(), &root, 0, 0, &root, 2);
    }
    QCOMPARE(root.children().indexOf(child1), 1);

    // Test moving from second to second is no-op.
    QVERIFY(!model.moveRow(rootIndex, 1, rootIndex, 1));
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeMovedSpy.count(), 0);
    QCOMPARE(rowsMovedSpy.count(), 0);
    QCOMPARE(root.children().indexOf(child1), 1);

    // Test moving from second to third also is no-op.
    QVERIFY(!model.moveRow(rootIndex, 1, rootIndex, 2));
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeMovedSpy.count(), 0);
    QCOMPARE(rowsMovedSpy.count(), 0);
    QCOMPARE(root.children().indexOf(child1), 1);

    // Test moving back to first.
    QVERIFY(model.moveRow(rootIndex, 1, rootIndex, 0));
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 0);
    QCOMPARE(rowsRemovedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 0);
    QCOMPARE(rowsInsertedSpy.count(), 0);
    QCOMPARE(rowsAboutToBeMovedSpy.count(), 1);
    for (int i = 0; !rowsAboutToBeMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsAboutToBeMovedSpy.takeFirst(), &root, 1, 1, &root, 0);
    }
    QCOMPARE(rowsMovedSpy.count(), 1);
    for (int i = 0; !rowsMovedSpy.isEmpty(); i++) {
        VERIFY_MOVE_SIGNAL_ARGS(rowsMovedSpy.takeFirst(), &root, 1, 1, &root, 0);
    }
    QCOMPARE(root.children().indexOf(child1), 0);

    // Test that negative destinationRow is rejected gracefully.
    QVERIFY(!model.moveRow(rootIndex, 0, rootIndex, -1));
    QCOMPARE(root.children().indexOf(child1), 0);
}

void QObjectTreeModelTest::TestDataChangedEmittedOnNameChange()
{
    QObject root;
    root.setObjectName(u"root"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QSignalSpy dataChangedSpy(&model, &QAbstractItemModel::dataChanged);
    QVERIFY(dataChangedSpy.isValid());

    QString newName{u"New Name"_s};
    root.setObjectName(newName);

    QCOMPARE(dataChangedSpy.count(), 1);
    for (int i = 0; !dataChangedSpy.isEmpty(); i++) {
        const QVariantList &args{dataChangedSpy.takeFirst()};
        QModelIndex topLeft = args[0].toModelIndex();
        QModelIndex bottomRight = args[1].toModelIndex();
        QList<int> roles{qvariant_cast<QList<int>>(args[2])};

        QCOMPARE(topLeft, rootIndex);
        QCOMPARE(bottomRight, rootIndex);
        QCOMPARE(roles.count(), 2);
        QCOMPARE(roles[0], Qt::DisplayRole);
        QCOMPARE(roles[1], static_cast<int>(QObjectTreeModel::Roles::ObjectName));
        QCOMPARE(model.data(rootIndex, Qt::DisplayRole).toString(), newName);
    }
}

// From docs:
// > If the model index specified corresponds to a top-level item in the model,
// > or if there is no valid parent item in the model, the function must return
// > an invalid model index, created with the empty QModelIndex() constructor.
// https://doc.qt.io/qt-6/model-view-programming.html#navigation-and-model-index-creation
void QObjectTreeModelTest::TestParentReturnsInvalidModelIndexForRootObject()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(!model.parent(rootIndex).isValid());
}

void QObjectTreeModelTest::TestParentReturnsInvalidModelIndexForInvalidParent()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QVERIFY(!model.parent(QModelIndex()).isValid());
}

// Test TakeRows with negative count always fails.
void QObjectTreeModelTest::TestTakeRowsWithNegativeCountAlwaysFails()
{
    QObject root;

    QObject *child1 = new QObject(&root);
    /* QObject* child2 = */ new QObject(&root);
    /* QObject* child3 = */ new QObject(&root);
    /* QObject* child4 = */ new QObject(&root);
    QObject *child5 = new QObject(&root);
    /* QObject* subchild1 = */ new QObject(child5);
    /* QObject* subchild2 = */ new QObject(child5);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    QModelIndex childIndex = model.indexOf(child1);
    QVERIFY(childIndex.isValid());

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 5);

    DestroyedSpies destroyed({child1});
    ModelSignalSpies modelSpies(&model);

    constexpr auto rowValues = std::array{0, 1, 2};
    constexpr auto countValues = std::array{-1, -2};
    const auto parentValues = std::array{QModelIndex(), rootIndex, childIndex};

    // Test remove rows
    for (const auto &rowValue : rowValues) {
        for (const auto &countValue : countValues) {
            for (const auto &parentValue : parentValues) {
                auto take_result = model.takeRows(rowValue, countValue, parentValue);
                QCOMPARE(take_result.size(), 0);
                destroyed.verifyNoneDestroyed();
                modelSpies.verifyNoSignals();
            }
        }
    }
}

// Test TakeRows with zero count does nothing.
void QObjectTreeModelTest::TestTakeRowsWithZeroCountDoesNothing()
{
    QObject root;

    QObject *child1 = new QObject(&root);
    /* QObject* child2 = */ new QObject(&root);
    /* QObject* child3 = */ new QObject(&root);
    /* QObject* child4 = */ new QObject(&root);
    QObject *child5 = new QObject(&root);
    /* QObject* subchild1 = */ new QObject(child5);
    /* QObject* subchild2 = */ new QObject(child5);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    QModelIndex childIndex = model.indexOf(child1);
    QVERIFY(childIndex.isValid());

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 5);

    DestroyedSpies destroyed({child1});
    ModelSignalSpies modelSpies(&model);

    constexpr auto rowValues = std::array{0, 1, 2};
    const auto parentValues = std::array{QModelIndex(), rootIndex, childIndex};

    // Test remove rows
    for (const auto &rowValue : rowValues) {
        for (const auto &parentValue : parentValues) {
            auto take_result = model.takeRows(rowValue, 0, parentValue);
            QCOMPARE(take_result.size(), 0);
            destroyed.verifyNoneDestroyed();
            modelSpies.verifyNoSignals();
        }
    }
}

// Test TakeRows cannot remove root object.
void QObjectTreeModelTest::TestTakeRowsCannotRemoveRootObject()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    DestroyedSpies destroyed({&root});
    ModelSignalSpies modelSpies(&model);

    auto take_result = model.takeRows(0, 1, {});
    QCOMPARE(take_result.size(), 0);
    destroyed.verifyNoneDestroyed();
    modelSpies.verifyNoSignals();
}

// Test TakeRows with negative row does nothing if count is greater than zero.
void QObjectTreeModelTest::TestTakeRowsWithNegativeRowDoesNothingIfCountIsGreaterThanZero()
{
    QObject root;

    QObject *child1 = new QObject(&root);
    /* QObject* child2 = */ new QObject(&root);
    /* QObject* child3 = */ new QObject(&root);
    /* QObject* child4 = */ new QObject(&root);
    QObject *child5 = new QObject(&root);
    /* QObject* subchild1 = */ new QObject(child5);
    /* QObject* subchild2 = */ new QObject(child5);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    QModelIndex childIndex = model.indexOf(child1);
    QVERIFY(childIndex.isValid());

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 5);

    DestroyedSpies destroyed({child1});
    ModelSignalSpies modelSpies(&model);

    constexpr auto rowValues = std::array{-1, -2};
    constexpr auto countValues = std::array{1, 2};
    const auto parentValues = std::array{QModelIndex(), rootIndex, childIndex};

    // Test remove rows
    for (const auto &rowValue : rowValues) {
        for (const auto &countValue : countValues) {
            for (const auto &parentValue : parentValues) {
                auto take_result = model.takeRows(rowValue, countValue, parentValue);
                QCOMPARE(take_result.size(), 0);
                destroyed.verifyNoneDestroyed();
                modelSpies.verifyNoSignals();
            }
        }
    }
}

// Test TakeRows fails if row + count goes outside range.
// NOTE: The original gtest version used EXPECT_CHECK_DEATH to verify Q_ASSERT fires.
// Qt Test has no built-in death test support. In debug builds this will trigger Q_ASSERT.
// This test is kept as a placeholder; to run the assertion check, use a debug build and
// verify the Q_ASSERT fires manually, or use platform-specific death test mechanisms.
void QObjectTreeModelTest::TestTakeRowsFailsIfRowPlusCountGoesOutsideRange()
{
    QObject root;

    QObject *child1 = new QObject(&root);
    /* QObject* child2 = */ new QObject(&root);
    /* QObject* child3 = */ new QObject(&root);
    /* QObject* child4 = */ new QObject(&root);
    QObject *child5 = new QObject(&root);
    /* QObject* subchild1 = */ new QObject(child5);
    /* QObject* subchild2 = */ new QObject(child5);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    QModelIndex childIndex = model.indexOf(child1);
    QVERIFY(childIndex.isValid());

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 5);

    // Verify that out-of-range takeRows returns an empty vector.
    auto result = model.takeRows(0, root.children().length() + 1, rootIndex);
    QVERIFY(result.empty());

    // Model should be unchanged.
    QCOMPARE(model.rowCount(rootIndex), 5);
}

// Test TakeRows can return first row
void QObjectTreeModelTest::TestTakeRowsCanReturnFirstRow()
{
    QObject root;

    QObject *child1 = new QObject(&root);
    QObject *child2 = new QObject(&root);
    QObject *child3 = new QObject(&root);
    QObject *child4 = new QObject(&root);
    QObject *child5 = new QObject(&root);
    QObject *subchild1 = new QObject(child4);
    QObject *subchild2 = new QObject(child4);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    QModelIndex childIndex = model.indexOf(child1);
    QVERIFY(childIndex.isValid());

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 5);

    DestroyedSpies destroyed({&root, child1, child2, child3, child4, child5, subchild1, subchild2});
    ModelSignalSpies modelSpies(&model);

    auto take_result = model.takeRows(0, 1, rootIndex);
    QCOMPARE(take_result.size(), 1);
    QCOMPARE(take_result.front(), child1);

    destroyed.verifyNoneDestroyed();
    modelSpies.verifyRemoveOnly(1);

    // Cleanup
    std::ranges::for_each(take_result, [](auto *o) { o->deleteLater(); });
}

// Test TakeRows can take second row
void QObjectTreeModelTest::TestTakeRowsCanTakeSecondRow()
{
    QObject root;

    QObject *child1 = new QObject(&root);
    QObject *child2 = new QObject(&root);
    QObject *child3 = new QObject(&root);
    QObject *child4 = new QObject(&root);
    QObject *child5 = new QObject(&root);
    QObject *subchild1 = new QObject(child5);
    QObject *subchild2 = new QObject(child5);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    QModelIndex childIndex = model.indexOf(child1);
    QVERIFY(childIndex.isValid());

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 5);

    DestroyedSpies destroyed({&root, child1, child2, child3, child4, child5, subchild1, subchild2});
    ModelSignalSpies modelSpies(&model);

    auto take_result = model.takeRows(1, 1, rootIndex);
    QCOMPARE(take_result.size(), 1);
    QCOMPARE(take_result.front(), child2);

    destroyed.verifyNoneDestroyed();
    modelSpies.verifyRemoveOnly(1);

    // Cleanup
    std::ranges::for_each(take_result, [](auto *o) { o->deleteLater(); });
}

// Test TakeRows can take last row and subtree.
void QObjectTreeModelTest::TestTakeRowsCanTakeLastRowAndSubTree()
{
    QObject root;

    QObject *child1 = new QObject(&root);
    QObject *child2 = new QObject(&root);
    QObject *child3 = new QObject(&root);
    QObject *child4 = new QObject(&root);
    QObject *child5 = new QObject(&root);
    QObject *subchild1 = new QObject(child5);
    QObject *subchild2 = new QObject(child5);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    QModelIndex childIndex = model.indexOf(child1);
    QVERIFY(childIndex.isValid());

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 5);

    DestroyedSpies destroyed({&root, child1, child2, child3, child4, child5, subchild1, subchild2});
    ModelSignalSpies modelSpies(&model);

    auto take_result = model.takeRows(root.children().length() - 1, 1, rootIndex);
    QCOMPARE(take_result.size(), 1);
    QCOMPARE(take_result.front(), child5);

    destroyed.verifyNoneDestroyed();
    modelSpies.verifyRemoveOnly(1);

    // Cleanup
    std::ranges::for_each(take_result, [](auto *o) { o->deleteLater(); });
}

// Test TakeRows can take all rows for the root object.
void QObjectTreeModelTest::TestTakeRowsCanTakeAllRowsForParent()
{
    QObject root;

    QObject *child1 = new QObject(&root);
    QObject *child2 = new QObject(&root);
    QObject *child3 = new QObject(&root);
    QObject *child4 = new QObject(&root);
    QObject *child5 = new QObject(&root);
    QObject *subchild1 = new QObject(child5);
    QObject *subchild2 = new QObject(child5);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    QModelIndex childIndex = model.indexOf(child1);
    QVERIFY(childIndex.isValid());

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 5);

    DestroyedSpies destroyed({&root, child1, child2, child3, child4, child5, subchild1, subchild2});
    ModelSignalSpies modelSpies(&model);

    auto take_result = model.takeRows(0, root.children().length(), rootIndex);
    QCOMPARE(take_result.size(), 5);
    QCOMPARE(take_result[0], child1);
    QCOMPARE(take_result[1], child2);
    QCOMPARE(take_result[2], child3);
    QCOMPARE(take_result[3], child4);
    QCOMPARE(take_result[4], child5);

    destroyed.verifyNoneDestroyed();
    modelSpies.verifyRemoveOnly(1);

    // Cleanup
    std::ranges::for_each(take_result, [](auto *o) { o->deleteLater(); });
}

// Test TakeRows can take row subset for the root object
void QObjectTreeModelTest::TestTakeRowsCanTakeRowSubsetForParent()
{
    QObject root;

    QObject *child1 = new QObject(&root);
    QObject *child2 = new QObject(&root);
    QObject *child3 = new QObject(&root);
    QObject *child4 = new QObject(&root);
    QObject *child5 = new QObject(&root);
    QObject *subchild1 = new QObject(child5);
    QObject *subchild2 = new QObject(child5);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    QModelIndex childIndex = model.indexOf(child1);
    QVERIFY(childIndex.isValid());

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 5);

    DestroyedSpies destroyed({&root, child1, child2, child3, child4, child5, subchild1, subchild2});
    ModelSignalSpies modelSpies(&model);

    auto take_result = model.takeRows(1, 3, rootIndex);
    QCOMPARE(take_result.size(), 3);
    QCOMPARE(take_result[0], child2);
    QCOMPARE(take_result[1], child3);
    QCOMPARE(take_result[2], child4);

    destroyed.verifyNoneDestroyed();
    modelSpies.verifyRemoveOnly(1);

    // Cleanup
    std::ranges::for_each(take_result, [](auto *o) { o->deleteLater(); });
}

// Test TakeAllRows returns all children for the root object.
void QObjectTreeModelTest::TestTakeAllRowsReturnsAllChildrenForRoot()
{
    QObject root;

    QObject *child1 = new QObject(&root);
    QObject *child2 = new QObject(&root);
    QObject *child3 = new QObject(&root);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 3);

    DestroyedSpies destroyed({&root, child1, child2, child3});
    ModelSignalSpies modelSpies(&model);

    auto take_result = model.takeAllRows(rootIndex);
    QCOMPARE(take_result.size(), 3);
    QCOMPARE(take_result[0], child1);
    QCOMPARE(take_result[1], child2);
    QCOMPARE(take_result[2], child3);

    // Root should now have zero children in the model.
    QCOMPARE(model.rowCount(rootIndex), 0);

    // No objects should have been destroyed — ownership transferred to caller.
    destroyed.verifyNoneDestroyed();

    // Taken objects should no longer be tracked by the model.
    QVERIFY(!model.indexOf(child1).isValid());
    QVERIFY(!model.indexOf(child2).isValid());
    QVERIFY(!model.indexOf(child3).isValid());

    modelSpies.verifyRemoveOnly(1);

    // Cleanup
    std::ranges::for_each(take_result, [](auto *o) { o->deleteLater(); });
}

// Test TakeAllRows returns an empty vector when the parent has no children.
void QObjectTreeModelTest::TestTakeAllRowsReturnsEmptyForParentWithNoChildren()
{
    QObject root;

    QObject *child1 = new QObject(&root);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    QModelIndex child1Index = model.indexOf(child1);
    QVERIFY(child1Index.isValid());

    // child1 has no children.
    QCOMPARE(model.rowCount(child1Index), 0);

    ModelSignalSpies modelSpies(&model);

    auto take_result = model.takeAllRows(child1Index);
    QVERIFY(take_result.empty());

    // No signals should have been emitted.
    QCOMPARE(modelSpies.rowsAboutToBeRemoved.count(), 0);
    QCOMPARE(modelSpies.rowsRemoved.count(), 0);

    // Model should be unchanged.
    QCOMPARE(model.rowCount(rootIndex), 1);
    QVERIFY(model.indexOf(child1).isValid());
}

// Test TakeAllRows returns children for a non-root parent, leaving the parent
// and its siblings intact.
void QObjectTreeModelTest::TestTakeAllRowsReturnsChildrenForNonRootParent()
{
    QObject root;

    QObject *child1 = new QObject(&root);
    QObject *child2 = new QObject(&root);
    QObject *subchild1 = new QObject(child1);
    QObject *subchild2 = new QObject(child1);
    QObject *subchild3 = new QObject(child1);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());

    QModelIndex child1Index = model.indexOf(child1);
    QVERIFY(child1Index.isValid());

    // Check that model is setup correctly.
    QCOMPARE(model.rowCount(rootIndex), 2);
    QCOMPARE(model.rowCount(child1Index), 3);

    DestroyedSpies destroyed({subchild1, subchild2, subchild3});
    ModelSignalSpies modelSpies(&model);

    auto take_result = model.takeAllRows(child1Index);
    QCOMPARE(take_result.size(), 3);
    QCOMPARE(take_result[0], subchild1);
    QCOMPARE(take_result[1], subchild2);
    QCOMPARE(take_result[2], subchild3);

    // child1 should now have zero children but still be in the model.
    QCOMPARE(model.rowCount(child1Index), 0);
    QVERIFY(model.indexOf(child1).isValid());

    // The root's children should be untouched.
    QCOMPARE(model.rowCount(rootIndex), 2);
    QVERIFY(model.indexOf(child2).isValid());

    // Taken objects should no longer be tracked.
    QVERIFY(!model.indexOf(subchild1).isValid());
    QVERIFY(!model.indexOf(subchild2).isValid());
    QVERIFY(!model.indexOf(subchild3).isValid());

    // No objects destroyed — ownership transferred to caller.
    destroyed.verifyNoneDestroyed();

    QCOMPARE(modelSpies.rowsAboutToBeRemoved.count(), 1);
    QCOMPARE(modelSpies.rowsRemoved.count(), 1);
    QCOMPARE(modelSpies.rowsAboutToBeInserted.count(), 0);
    QCOMPARE(modelSpies.rowsInserted.count(), 0);

    // Cleanup
    std::ranges::for_each(take_result, [](auto *o) { o->deleteLater(); });
}

// Test TakeAllRows preserves the subtrees of the taken objects. The taken
// objects should still have their children after being removed from the model.
void QObjectTreeModelTest::TestTakeAllRowsPreservesSubtrees()
{
    QObject root;

    QObject *child1 = new QObject(&root);
    child1->setObjectName(QStringLiteral("child1"));
    QObject *child2 = new QObject(&root);
    child2->setObjectName(QStringLiteral("child2"));
    QObject *subchild1 = new QObject(child1);
    subchild1->setObjectName(QStringLiteral("subchild1"));
    QObject *subchild2 = new QObject(child1);
    subchild2->setObjectName(QStringLiteral("subchild2"));
    QObject *deepchild = new QObject(subchild1);
    deepchild->setObjectName(QStringLiteral("deepchild"));

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);
    QVERIFY(rootIndex.isValid());
    QCOMPARE(model.rowCount(rootIndex), 2);

    QSignalSpy deepchildDestroyedSpy(deepchild, &QObject::destroyed);
    QVERIFY(deepchildDestroyedSpy.isValid());

    auto take_result = model.takeAllRows(rootIndex);
    QCOMPARE(take_result.size(), 2);
    QCOMPARE(take_result[0], child1);
    QCOMPARE(take_result[1], child2);

    QCOMPARE(model.rowCount(rootIndex), 0);

    // The QObject parent–child hierarchy of the taken objects should be intact.
    QCOMPARE(child1->children().size(), 2);
    QCOMPARE(child1->children().at(0), subchild1);
    QCOMPARE(child1->children().at(1), subchild2);
    QCOMPARE(subchild1->children().size(), 1);
    QCOMPARE(subchild1->children().at(0), deepchild);

    // Nothing should have been destroyed.
    QCOMPARE(deepchildDestroyedSpy.count(), 0);

    // Cleanup
    std::ranges::for_each(take_result, [](auto *o) { o->deleteLater(); });
}

// Smoke test that inserting a large number of QObjects does not cause any
// issues. If the model uses internal data structures that need to be rehashed
// or grown this can surface internal problems with iterator or reference
// invalidations.
void QObjectTreeModelTest::TestInsertingLargeQObjectTreeIntoModel()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    // QAbstractItemModelTester is intentionally omitted here. The tester
    // recursively walks the entire model on every rowsInserted signal, and
    // appendChildObjects emits that signal at each tree level during recursive
    // insertion — resulting in O(n²) (or worse) full-model traversals for the
    // 22,530-node tree below, effectively hanging the test.
    QCOMPARE(model.root(), &root);

    // Step 1: Generate a "large" tree of QObjects.
    auto *subTreeObject = new QObject();
    size_t objectCount = 0;
    std::function<void(QObject * parent, size_t childCount)> generateChildRecursively;
    generateChildRecursively = [&generateChildRecursively, &objectCount](QObject *parent,
                                                                         size_t childCount) {
        for (size_t i = 0; i < childCount; i++) {
            auto *object = new QObject(parent);
            objectCount++;
            generateChildRecursively(object, childCount / 2);
        }
    };
    generateChildRecursively(subTreeObject, 30);
    QCOMPARE(objectCount, 22530);

    // Step 2: Add the |subTreeObject| into the model.
    subTreeObject->setParent(&root);

    // Step 3: Verify that all the objects we expect to be in the model are indeed
    // in the model.
    using VerifyObjectsFunc = std::function<void(QObject *, QObjectTreeModel *)>;
    VerifyObjectsFunc verifyObjects;
    verifyObjects = [&verifyObjects](QObject *parent, QObjectTreeModel *model) {
        for (QObject *child : parent->children()) {
            QVERIFY(model->indexOf(child).isValid());
            verifyObjects(child, model);
        }
    };
    verifyObjects(&root, &model);
}

// Test that setRoot(nullptr) creates an internal root parented to the model.
void QObjectTreeModelTest::TestSetRootWithNullptrCreatesInternalRoot()
{
    QObjectTreeModel model(nullptr);
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QObject *root = model.root();
    QVERIFY(root != nullptr);
    QCOMPARE(root->parent(), &model);
    QCOMPARE(root->objectName(), u"Root"_s);

    QModelIndex rootIndex = model.indexOf(root);
    QVERIFY(rootIndex.isValid());
    QCOMPARE(model.rowCount(rootIndex), 0);
}

// Test that setRoot with an external object uses that object as the root.
void QObjectTreeModelTest::TestSetRootWithExternalObject()
{
    QObject external;
    external.setObjectName(u"External"_s);
    new QObject(&external); // Add a child.
    new QObject(&external); // Add another child.

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&external);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QCOMPARE(model.root(), &external);

    QModelIndex rootIndex = model.indexOf(&external);
    QVERIFY(rootIndex.isValid());
    QCOMPARE(model.rowCount(rootIndex), 2);
}

// Test that setRoot with the same root does nothing.
void QObjectTreeModelTest::TestSetRootWithSameRootIsNoOp()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QSignalSpy rootChangedSpy(&model, &QObjectTreeModel::rootChanged);
    QVERIFY(rootChangedSpy.isValid());
    QSignalSpy aboutToResetSpy(&model, &QAbstractItemModel::modelAboutToBeReset);
    QVERIFY(aboutToResetSpy.isValid());
    QSignalSpy resetSpy(&model, &QAbstractItemModel::modelReset);
    QVERIFY(resetSpy.isValid());

    model.setRoot(&root);

    QCOMPARE(rootChangedSpy.count(), 0);
    QCOMPARE(aboutToResetSpy.count(), 0);
    QCOMPARE(resetSpy.count(), 0);
    QCOMPARE(model.root(), &root);
}

// Test that setRoot emits rootChanged when the root actually changes.
void QObjectTreeModelTest::TestSetRootEmitsRootChangedSignal()
{
    QObject root1;
    QObject root2;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root1);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QSignalSpy rootChangedSpy(&model, &QObjectTreeModel::rootChanged);
    QVERIFY(rootChangedSpy.isValid());
    QSignalSpy aboutToResetSpy(&model, &QAbstractItemModel::modelAboutToBeReset);
    QVERIFY(aboutToResetSpy.isValid());
    QSignalSpy resetSpy(&model, &QAbstractItemModel::modelReset);
    QVERIFY(resetSpy.isValid());

    model.setRoot(&root2);
    QCOMPARE(rootChangedSpy.count(), 1);
    QCOMPARE(aboutToResetSpy.count(), 1);
    QCOMPARE(resetSpy.count(), 1);
    QCOMPARE(model.root(), &root2);

    // Changing to nullptr should also emit.
    model.setRoot(nullptr);
    QCOMPARE(rootChangedSpy.count(), 2);
    QCOMPARE(aboutToResetSpy.count(), 2);
    QCOMPARE(resetSpy.count(), 2);
    QVERIFY(model.root() != nullptr);
    QVERIFY(model.root() != &root2);
}

// Test that setRoot from one external root to another replaces the model contents.
void QObjectTreeModelTest::TestSetRootFromExternalToExternalReplacesModel()
{
    QObject root1;
    QObject *child1 = new QObject(&root1);
    new QObject(&root1);

    QObject root2;
    QObject *child2a = new QObject(&root2);
    QObject *child2b = new QObject(&root2);
    QObject *child2c = new QObject(&root2);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root1);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex root1Index = model.indexOf(&root1);
    QCOMPARE(model.rowCount(root1Index), 2);

    model.setRoot(&root2);
    QCOMPARE(model.root(), &root2);

    // Old objects should no longer be tracked.
    QVERIFY(!model.indexOf(child1).isValid());
    QVERIFY(!model.indexOf(&root1).isValid());

    // New tree should be fully populated.
    QModelIndex root2Index = model.indexOf(&root2);
    QVERIFY(root2Index.isValid());
    QCOMPARE(model.rowCount(root2Index), 3);
    QVERIFY(model.indexOf(child2a).isValid());
    QVERIFY(model.indexOf(child2b).isValid());
    QVERIFY(model.indexOf(child2c).isValid());
}

// Test that switching from an internal root (nullptr) to an external root schedules the
// internal root for deletion and doesn't leak it.
void QObjectTreeModelTest::TestSetRootFromInternalToExternalCleansUpInternalRoot()
{
    // externalRoot must outlive the model and tester so that its destruction
    // doesn't trigger model signals while the tester is still monitoring.
    QObject externalRoot;

    QObjectTreeModel model(nullptr);
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QObject *internalRoot = model.root();
    QVERIFY(internalRoot != nullptr);
    QCOMPARE(internalRoot->parent(), &model);

    QSignalSpy destroyedSpy(internalRoot, &QObject::destroyed);
    QVERIFY(destroyedSpy.isValid());

    model.setRoot(&externalRoot);
    QCOMPARE(model.root(), &externalRoot);

    // The old internal root should be scheduled for deletion via deleteLater.
    // Process deferred deletes.
    destroyedSpy.wait(250);
    QCOMPARE(destroyedSpy.count(), 1);
}

// Test that setRoot with a descendant of the current internal root does not
// produce a dangling m_root pointer. The old internal root is parented to the
// model and scheduled for deletion via deleteLater(). Without reparenting, the
// new root would be destroyed as a child of the old root.
void QObjectTreeModelTest::TestSetRootWithDescendantOfInternalRootDoesNotDangle()
{
    QObjectTreeModel model(nullptr);
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QObject *internalRoot = model.root();
    QVERIFY(internalRoot != nullptr);
    QCOMPARE(internalRoot->parent(), &model);

    // Build a small subtree under the internal root.
    QObject *child = new QObject(internalRoot);
    child->setObjectName(u"child"_s);
    QObject *grandchild = new QObject(child);
    grandchild->setObjectName(u"grandchild"_s);

    // Spy on the old internal root's destruction.
    QSignalSpy oldRootDestroyed(internalRoot, &QObject::destroyed);
    QVERIFY(oldRootDestroyed.isValid());

    // --- Direct child case ---
    model.setRoot(child);
    QCOMPARE(model.root(), child);

    // The new root must have been detached from the old internal root.
    QVERIFY(child->parent() != internalRoot);

    // Process deleteLater. The old internal root should be destroyed...
    oldRootDestroyed.wait(250);
    QCOMPARE(oldRootDestroyed.count(), 1);

    // ...but the new root and its subtree must still be alive and functional.
    QCOMPARE(model.root(), child);
    QModelIndex childIndex = model.indexOf(child);
    QVERIFY(childIndex.isValid());
    QModelIndex grandchildIndex = model.indexOf(grandchild);
    QVERIFY(grandchildIndex.isValid());
    QCOMPARE(model.rowCount(childIndex), 1);

    // --- Grandchild case: reset to a new internal root, then promote a grandchild ---
    model.setRoot(nullptr);
    QObject *internalRoot2 = model.root();
    QObject *c2 = new QObject(internalRoot2);
    c2->setObjectName(u"c2"_s);
    QObject *gc2 = new QObject(c2);
    gc2->setObjectName(u"gc2"_s);

    QSignalSpy oldRoot2Destroyed(internalRoot2, &QObject::destroyed);
    QVERIFY(oldRoot2Destroyed.isValid());

    model.setRoot(gc2);
    QCOMPARE(model.root(), gc2);
    QVERIFY(gc2->parent() != c2);

    oldRoot2Destroyed.wait(250);
    QCOMPARE(oldRoot2Destroyed.count(), 1);

    // gc2 is still alive and tracked by the model.
    QCOMPARE(model.root(), gc2);
    QVERIFY(model.indexOf(gc2).isValid());
}

// Test that switching from an external root to nullptr creates a new internal root.
void QObjectTreeModelTest::TestSetRootFromExternalToNullptrCreatesNewInternalRoot()
{
    QObject externalRoot;
    new QObject(&externalRoot);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&externalRoot);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QCOMPARE(model.root(), &externalRoot);

    model.setRoot(nullptr);

    QObject *newRoot = model.root();
    QVERIFY(newRoot != nullptr);
    QVERIFY(newRoot != &externalRoot);
    QCOMPARE(newRoot->parent(), &model);
    QCOMPARE(newRoot->objectName(), u"Root"_s);

    // The old external root's children should not be in the model.
    QVERIFY(!model.indexOf(&externalRoot).isValid());

    // The new root should be functional.
    QModelIndex rootIndex = model.indexOf(newRoot);
    QVERIFY(rootIndex.isValid());
    QCOMPARE(model.rowCount(rootIndex), 0);

    // Verify we can add children to the new internal root.
    QObject *newChild = new QObject(newRoot);
    QVERIFY(model.indexOf(newChild).isValid());
    QCOMPARE(model.rowCount(rootIndex), 1);
}

// Test that setRoot removes event filters from old objects so the model doesn't receive
// stale events from a tree it no longer tracks.
void QObjectTreeModelTest::TestSetRootDisconnectsOldObjectEventFilters()
{
    QObject root1;
    QObject *child = new QObject(&root1);
    // root2 must outlive the model and tester so that its destruction
    // doesn't trigger model signals while the tester is still monitoring.
    QObject root2;

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root1);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QVERIFY(model.indexOf(child).isValid());

    model.setRoot(&root2);

    // Adding a new child to root1 should not cause the model to track it, because
    // the event filter should have been removed from root1.
    QObject *orphanChild = new QObject(&root1);
    QVERIFY(!model.indexOf(orphanChild).isValid());

    // The model should only know about root2 and its children.
    QModelIndex root2Index = model.indexOf(&root2);
    QVERIFY(root2Index.isValid());
    QCOMPARE(model.rowCount(root2Index), 0);
}

// Test that setRoot disconnects signal connections from old objects so that
// e.g. objectNameChanged on old objects doesn't trigger dataChanged.
void QObjectTreeModelTest::TestSetRootDisconnectsOldObjectSignalConnections()
{
    QObject root1;
    root1.setObjectName(u"root1"_s);
    // root2 must outlive the model and tester so that its destruction
    // doesn't trigger model signals while the tester is still monitoring.
    QObject root2;

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root1);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    model.setRoot(&root2);

    QSignalSpy dataChangedSpy(&model, &QAbstractItemModel::dataChanged);
    QVERIFY(dataChangedSpy.isValid());

    // Changing the name of the old root should not emit dataChanged.
    root1.setObjectName(u"renamed"_s);
    QCOMPARE(dataChangedSpy.count(), 0);
}

// Test that after setRoot, none of the old tree's objects are tracked by the model's
// internal maps.
void QObjectTreeModelTest::TestSetRootOldTreeObjectsNotTrackedByModel()
{
    QObject root1;
    QObject *child1 = new QObject(&root1);
    QObject *child2 = new QObject(&root1);
    QObject *subChild = new QObject(child1);
    // root2 must outlive the model and tester so that its destruction
    // doesn't trigger model signals while the tester is still monitoring.
    QObject root2;

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root1);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QVERIFY(model.indexOf(&root1).isValid());
    QVERIFY(model.indexOf(child1).isValid());
    QVERIFY(model.indexOf(child2).isValid());
    QVERIFY(model.indexOf(subChild).isValid());

    model.setRoot(&root2);

    // Every object from the old tree should be gone.
    QVERIFY(!model.indexOf(&root1).isValid());
    QVERIFY(!model.indexOf(child1).isValid());
    QVERIFY(!model.indexOf(child2).isValid());
    QVERIFY(!model.indexOf(subChild).isValid());

    // Internal maps should only contain root2.
    QCOMPARE(model.m_childParentMap.size(), 1);
    QVERIFY(model.m_childParentMap.contains(&root2));
    // m_parentChildMap has nullptr -> [root2] and root2 -> [].
    QCOMPARE(model.m_parentChildMap.size(), 2);
    QVERIFY(model.m_parentChildMap.contains(nullptr));
    QVERIFY(model.m_parentChildMap.contains(&root2));
}

// --- removeRows tests ---

void QObjectTreeModelTest::TestRemoveRowsWithNegativeCountFails()
{
    QObject root;
    new QObject(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);
    QCOMPARE(model.removeRows(0, -1, rootIndex), false);
    QCOMPARE(model.rowCount(rootIndex), 1);
}

void QObjectTreeModelTest::TestRemoveRowsWithNegativeRowFails()
{
    QObject root;
    new QObject(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);
    QCOMPARE(model.removeRows(-1, 1, rootIndex), false);
    QCOMPARE(model.rowCount(rootIndex), 1);
}

void QObjectTreeModelTest::TestRemoveRowsWithZeroCountSucceeds()
{
    QObject root;
    new QObject(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);
    QCOMPARE(model.removeRows(0, 0, rootIndex), true);
    QCOMPARE(model.rowCount(rootIndex), 1);
}

void QObjectTreeModelTest::TestRemoveRowsCannotRemoveRoot()
{
    QObject root;
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Invalid parent (default QModelIndex) means the caller is trying to remove
    // the root, which is prohibited.
    QCOMPARE(model.removeRows(0, 1), false);
    QVERIFY(model.indexOf(&root).isValid());
}

void QObjectTreeModelTest::TestRemoveRowsFailsIfRangeExceedsRowCount()
{
    QObject root;
    new QObject(&root);
    new QObject(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);
    QCOMPARE(model.rowCount(rootIndex), 2);

    // row + count = 1 + 2 = 3 > 2
    QCOMPARE(model.removeRows(1, 2, rootIndex), false);
    QCOMPARE(model.rowCount(rootIndex), 2);
}

void QObjectTreeModelTest::TestRemoveRowsCanRemoveFirstRow()
{
    QObject root;
    QObject *child0 = new QObject(&root);
    child0->setObjectName(u"child0"_s);
    QObject *child1 = new QObject(&root);
    child1->setObjectName(u"child1"_s);
    QObject *child2 = new QObject(&root);
    child2->setObjectName(u"child2"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QCOMPARE(model.removeRows(0, 1, rootIndex), true);
    QCOMPARE(model.rowCount(rootIndex), 2);

    // child0 should be gone; child1 and child2 remain at indices 0 and 1.
    QVERIFY(!model.indexOf(child0).isValid());
    QCOMPARE(model.indexOf(child1).row(), 0);
    QCOMPARE(model.indexOf(child2).row(), 1);
}

void QObjectTreeModelTest::TestRemoveRowsCanRemoveLastRow()
{
    QObject root;
    QObject *child0 = new QObject(&root);
    child0->setObjectName(u"child0"_s);
    QObject *child1 = new QObject(&root);
    child1->setObjectName(u"child1"_s);
    QObject *child2 = new QObject(&root);
    child2->setObjectName(u"child2"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QCOMPARE(model.removeRows(2, 1, rootIndex), true);
    QCOMPARE(model.rowCount(rootIndex), 2);

    QCOMPARE(model.indexOf(child0).row(), 0);
    QCOMPARE(model.indexOf(child1).row(), 1);
    QVERIFY(!model.indexOf(child2).isValid());
}

void QObjectTreeModelTest::TestRemoveRowsCanRemoveMiddleRow()
{
    QObject root;
    QObject *child0 = new QObject(&root);
    child0->setObjectName(u"child0"_s);
    QObject *child1 = new QObject(&root);
    child1->setObjectName(u"child1"_s);
    QObject *child2 = new QObject(&root);
    child2->setObjectName(u"child2"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QCOMPARE(model.removeRows(1, 1, rootIndex), true);
    QCOMPARE(model.rowCount(rootIndex), 2);

    QCOMPARE(model.indexOf(child0).row(), 0);
    QVERIFY(!model.indexOf(child1).isValid());
    QCOMPARE(model.indexOf(child2).row(), 1);
}

void QObjectTreeModelTest::TestRemoveRowsCanRemoveMultipleContiguousRows()
{
    QObject root;
    QObject *child0 = new QObject(&root);
    child0->setObjectName(u"child0"_s);
    QObject *child1 = new QObject(&root);
    child1->setObjectName(u"child1"_s);
    QObject *child2 = new QObject(&root);
    child2->setObjectName(u"child2"_s);
    QObject *child3 = new QObject(&root);
    child3->setObjectName(u"child3"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    // Remove child1 and child2 in one call.
    QCOMPARE(model.removeRows(1, 2, rootIndex), true);
    QCOMPARE(model.rowCount(rootIndex), 2);

    QCOMPARE(model.indexOf(child0).row(), 0);
    QVERIFY(!model.indexOf(child1).isValid());
    QVERIFY(!model.indexOf(child2).isValid());
    QCOMPARE(model.indexOf(child3).row(), 1);
}

void QObjectTreeModelTest::TestRemoveRowsCanRemoveAllChildren()
{
    QObject root;
    new QObject(&root);
    new QObject(&root);
    new QObject(&root);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QCOMPARE(model.removeRows(0, 3, rootIndex), true);
    QCOMPARE(model.rowCount(rootIndex), 0);
}

void QObjectTreeModelTest::TestRemoveRowsDeletesRemovedObjects()
{
    QObject root;
    QObject *child = new QObject(&root);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QSignalSpy destroyedSpy(child, &QObject::destroyed);
    QVERIFY(destroyedSpy.isValid());

    QCOMPARE(model.removeRows(0, 1, rootIndex), true);

    // The child should be scheduled for deletion via deleteLater.
    destroyedSpy.wait(250);
    QCOMPARE(destroyedSpy.count(), 1);
}

void QObjectTreeModelTest::TestRemoveRowsDeletesSubTree()
{
    QObject root;
    QObject *child = new QObject(&root);
    QObject *subChild1 = new QObject(child);
    QObject *subChild2 = new QObject(child);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QSignalSpy childDestroyed(child, &QObject::destroyed);
    QSignalSpy subChild1Destroyed(subChild1, &QObject::destroyed);
    QSignalSpy subChild2Destroyed(subChild2, &QObject::destroyed);
    QVERIFY(childDestroyed.isValid());
    QVERIFY(subChild1Destroyed.isValid());
    QVERIFY(subChild2Destroyed.isValid());

    QCOMPARE(model.removeRows(0, 1, rootIndex), true);
    QCOMPARE(model.rowCount(rootIndex), 0);

    // The entire subtree should be destroyed.
    childDestroyed.wait(250);
    QCOMPARE(childDestroyed.count(), 1);
    QCOMPARE(subChild1Destroyed.count(), 1);
    QCOMPARE(subChild2Destroyed.count(), 1);
}

void QObjectTreeModelTest::TestRemoveRowsEmitsCorrectSignals()
{
    QObject root;
    QObject *child0 = new QObject(&root);
    child0->setObjectName(u"child0"_s);
    QObject *child1 = new QObject(&root);
    child1->setObjectName(u"child1"_s);
    QObject *child2 = new QObject(&root);
    child2->setObjectName(u"child2"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QSignalSpy rowsAboutToBeRemovedSpy(&model, &QAbstractItemModel::rowsAboutToBeRemoved);
    QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
    QVERIFY(rowsAboutToBeRemovedSpy.isValid());
    QVERIFY(rowsRemovedSpy.isValid());

    // Remove two contiguous rows (child0 and child1).
    QCOMPARE(model.removeRows(0, 2, rootIndex), true);

    // Should emit exactly one pair of signals for the batch removal.
    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
    QCOMPARE(rowsRemovedSpy.count(), 1);

    // Verify signal arguments: parent, first, last.
    VERIFY_SIGNAL_ARGS(rowsAboutToBeRemovedSpy.takeFirst(), rootIndex.internalPointer(), 0, 1);
    VERIFY_SIGNAL_ARGS(rowsRemovedSpy.takeFirst(), rootIndex.internalPointer(), 0, 1);
}

void QObjectTreeModelTest::TestRemoveRowsDisconnectsRemovedObjects()
{
    QObject root;
    QObject *child = new QObject(&root);
    child->setObjectName(u"child"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QCOMPARE(model.removeRows(0, 1, rootIndex), true);

    // Changing the name of the removed child should not emit dataChanged
    // because it has been disconnected from the model.
    QSignalSpy dataChangedSpy(&model, &QAbstractItemModel::dataChanged);
    QVERIFY(dataChangedSpy.isValid());

    child->setObjectName(u"renamed"_s);
    QCOMPARE(dataChangedSpy.count(), 0);
}

void QObjectTreeModelTest::TestRemoveRowsWithForeignModelIndexFails()
{
    QObject root1;
    new QObject(&root1);
    auto model1_ptr = QObjectTreeModel::CreateWithRoot(&root1);
    auto &model1 = *model1_ptr;
    QAbstractItemModelTester tester_model1(&model1,
                                           QAbstractItemModelTester::FailureReportingMode::Fatal);

    QObject root2;
    new QObject(&root2);
    auto model2_ptr = QObjectTreeModel::CreateWithRoot(&root2);
    auto &model2 = *model2_ptr;
    QAbstractItemModelTester tester_model2(&model2,
                                           QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Use root index from model2 as parent in model1.
    QModelIndex foreignIndex = model2.indexOf(&root2);
    QCOMPARE(model1.removeRows(0, 1, foreignIndex), false);

    // model1 should be untouched.
    QCOMPARE(model1.rowCount(model1.indexOf(&root1)), 1);
}

void QObjectTreeModelTest::TestMoveRowsWithCountNotOneReturnsFalse()
{
    QObject root;
    new QObject(&root);
    new QObject(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);
    QCOMPARE(model.moveRows(rootIndex, 0, 0, rootIndex, 0), false);
    QCOMPARE(model.moveRows(rootIndex, 0, 2, rootIndex, 0), false);
    QCOMPARE(model.moveRows(rootIndex, 0, -1, rootIndex, 0), false);
    QCOMPARE(model.rowCount(rootIndex), 2);
}

void QObjectTreeModelTest::TestMoveRowsWithInvalidSourceParentFails()
{
    QObject root;
    new QObject(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);
    QCOMPARE(model.moveRows(QModelIndex(), 0, 1, rootIndex, 0), false);
    QCOMPARE(model.rowCount(rootIndex), 1);
}

void QObjectTreeModelTest::TestMoveRowsWithInvalidDestinationParentFails()
{
    QObject root;
    new QObject(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);
    QCOMPARE(model.moveRows(rootIndex, 0, 1, QModelIndex(), 0), false);
    QCOMPARE(model.rowCount(rootIndex), 1);
}

void QObjectTreeModelTest::TestMoveRowsWithNegativeSourceRowFails()
{
    QObject root;
    new QObject(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);
    QCOMPARE(model.moveRows(rootIndex, -1, 1, rootIndex, 0), false);
    QCOMPARE(model.rowCount(rootIndex), 1);
}

void QObjectTreeModelTest::TestMoveRowsWithNegativeDestinationRowFails()
{
    QObject root;
    new QObject(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);
    QCOMPARE(model.moveRows(rootIndex, 0, 1, rootIndex, -1), false);
    QCOMPARE(model.rowCount(rootIndex), 1);
}

void QObjectTreeModelTest::TestMoveRowsWithSourceRowOutOfRangeFails()
{
    QObject root;
    new QObject(&root);
    new QObject(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);
    QCOMPARE(model.rowCount(rootIndex), 2);

    // sourceRow == rowCount is out of range (valid indices are 0..rowCount-1).
    QCOMPARE(model.moveRows(rootIndex, 2, 1, rootIndex, 0), false);
    QCOMPARE(model.moveRows(rootIndex, 5, 1, rootIndex, 0), false);
    QCOMPARE(model.rowCount(rootIndex), 2);
}

void QObjectTreeModelTest::TestMoveRowsWithDestinationRowOutOfRangeFails()
{
    QObject root;
    new QObject(&root);
    new QObject(&root);
    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);
    QCOMPARE(model.rowCount(rootIndex), 2);

    // destinationRow > rowCount is out of range (rowCount is a valid insert position).
    QCOMPARE(model.moveRows(rootIndex, 0, 1, rootIndex, 3), false);
    QCOMPARE(model.moveRows(rootIndex, 0, 1, rootIndex, 10), false);
    QCOMPARE(model.rowCount(rootIndex), 2);
}

void QObjectTreeModelTest::TestMoveRowsWithForeignModelIndexFails()
{
    QObject root1;
    new QObject(&root1);
    auto model1_ptr = QObjectTreeModel::CreateWithRoot(&root1);
    auto &model1 = *model1_ptr;
    QAbstractItemModelTester tester_model1(&model1,
                                           QAbstractItemModelTester::FailureReportingMode::Fatal);

    QObject root2;
    new QObject(&root2);
    auto model2_ptr = QObjectTreeModel::CreateWithRoot(&root2);
    auto &model2 = *model2_ptr;
    QAbstractItemModelTester tester_model2(&model2,
                                           QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex root1Index = model1.indexOf(&root1);
    QModelIndex foreignIndex = model2.indexOf(&root2);

    // Foreign source parent.
    QCOMPARE(model1.moveRows(foreignIndex, 0, 1, root1Index, 0), false);
    // Foreign destination parent.
    QCOMPARE(model1.moveRows(root1Index, 0, 1, foreignIndex, 0), false);

    QCOMPARE(model1.rowCount(root1Index), 1);
    QCOMPARE(model2.rowCount(foreignIndex), 1);
}

void QObjectTreeModelTest::TestMoveRowsMovesWithinSameParent()
{
    QObject root;
    QObject *child0 = new QObject(&root);
    child0->setObjectName(u"child0"_s);
    QObject *child1 = new QObject(&root);
    child1->setObjectName(u"child1"_s);
    QObject *child2 = new QObject(&root);
    child2->setObjectName(u"child2"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(&root);

    QSignalSpy rowsAboutToBeMovedSpy(&model, &QAbstractItemModel::rowsAboutToBeMoved);
    QSignalSpy rowsMovedSpy(&model, &QAbstractItemModel::rowsMoved);

    // Move child0 to position after child2 (end).
    QCOMPARE(model.moveRows(rootIndex, 0, 1, rootIndex, 3), true);
    QCOMPARE(rowsAboutToBeMovedSpy.count(), 1);
    QCOMPARE(rowsMovedSpy.count(), 1);

    // After the move the order should be: child1, child2, child0.
    QCOMPARE(model.indexOf(child1).row(), 0);
    QCOMPARE(model.indexOf(child2).row(), 1);
    QCOMPARE(model.indexOf(child0).row(), 2);
}

void QObjectTreeModelTest::TestMoveRowsMovesBetweenDifferentParents()
{
    QObject root;
    QObject *parentA = new QObject(&root);
    parentA->setObjectName(u"parentA"_s);
    QObject *parentB = new QObject(&root);
    parentB->setObjectName(u"parentB"_s);

    QObject *child = new QObject(parentA);
    child->setObjectName(u"child"_s);
    new QObject(parentB);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex parentAIndex = model.indexOf(parentA);
    QModelIndex parentBIndex = model.indexOf(parentB);

    QCOMPARE(model.rowCount(parentAIndex), 1);
    QCOMPARE(model.rowCount(parentBIndex), 1);

    // Move child from parentA to the end of parentB.
    QCOMPARE(model.moveRows(parentAIndex, 0, 1, parentBIndex, 1), true);

    QCOMPARE(model.rowCount(parentAIndex), 0);
    QCOMPARE(model.rowCount(parentBIndex), 2);

    QModelIndex childIndex = model.indexOf(child);
    QVERIFY(childIndex.isValid());
    QCOMPARE(childIndex.row(), 1);
    QCOMPARE(model.parent(childIndex).internalPointer(), parentB);
}

// ---------------------------------------------------------------------------
// Root destruction tests
// ---------------------------------------------------------------------------

void QObjectTreeModelTest::TestRawDeleteExternalRootResetsModel()
{
    auto *root = new QObject;
    root->setObjectName(u"ExternalRoot"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QCOMPARE(model.root(), root);

    QSignalSpy rootChangedSpy(&model, &QObjectTreeModel::rootChanged);
    QSignalSpy modelResetSpy(&model, &QAbstractItemModel::modelReset);

    // Raw-delete the root while the model is alive.
    delete root;

    // The model should have reset and created a new internal root.
    QCOMPARE(rootChangedSpy.count(), 1);
    QCOMPARE(modelResetSpy.count(), 1);
    QVERIFY(model.root() != nullptr);
    QVERIFY(model.root() != root);            // new root, not the deleted one
    QCOMPARE(model.root()->parent(), &model); // internal root is parented to model

    // The model should be in a valid state with the new empty root.
    QModelIndex rootIndex = model.indexOf(model.root());
    QVERIFY(rootIndex.isValid());
    QCOMPARE(model.rowCount(rootIndex), 0);
}

void QObjectTreeModelTest::TestDeleteLaterExternalRootResetsModel()
{
    auto *root = new QObject;
    root->setObjectName(u"ExternalRoot"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QCOMPARE(model.root(), root);

    QSignalSpy rootChangedSpy(&model, &QObjectTreeModel::rootChanged);
    QSignalSpy modelResetSpy(&model, &QAbstractItemModel::modelReset);

    // Schedule deferred deletion.
    root->deleteLater();

    // Process deferred deletes.
    QCoreApplication::sendPostedEvents(root, QEvent::DeferredDelete);

    QCOMPARE(rootChangedSpy.count(), 1);
    QCOMPARE(modelResetSpy.count(), 1);
    QVERIFY(model.root() != nullptr);
    QCOMPARE(model.root()->parent(), &model);

    QModelIndex rootIndex = model.indexOf(model.root());
    QVERIFY(rootIndex.isValid());
    QCOMPARE(model.rowCount(rootIndex), 0);
}

void QObjectTreeModelTest::TestExternalRootWithSubtreeDestroyedResetsModel()
{
    auto *root = new QObject;
    root->setObjectName(u"ExternalRoot"_s);
    auto *child1 = new QObject(root);
    child1->setObjectName(u"Child1"_s);
    auto *child2 = new QObject(root);
    child2->setObjectName(u"Child2"_s);
    auto *grandchild = new QObject(child1);
    grandchild->setObjectName(u"Grandchild"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Verify the tree was fully populated.
    QModelIndex rootIndex = model.indexOf(root);
    QCOMPARE(model.rowCount(rootIndex), 2);
    QCOMPARE(model.rowCount(model.indexOf(child1)), 1);

    QSignalSpy rootChangedSpy(&model, &QObjectTreeModel::rootChanged);

    // Raw-delete the root — this destroys the entire subtree.
    delete root;

    QCOMPARE(rootChangedSpy.count(), 1);
    QVERIFY(model.root() != nullptr);
    QCOMPARE(model.root()->parent(), &model);

    // The model should be fully reset with no children under the new root.
    QModelIndex newRootIndex = model.indexOf(model.root());
    QVERIFY(newRootIndex.isValid());
    QCOMPARE(model.rowCount(newRootIndex), 0);

    // Old objects should not be tracked.
    QVERIFY(!model.indexOf(child1).isValid());
    QVERIFY(!model.indexOf(child2).isValid());
    QVERIFY(!model.indexOf(grandchild).isValid());
}

void QObjectTreeModelTest::TestModelUsableAfterExternalRootDestroyed()
{
    auto *root = new QObject;
    root->setObjectName(u"ExternalRoot"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Destroy the root.
    delete root;

    // The model should accept new children on the replacement root.
    QObject *newChild = new QObject(model.root());
    newChild->setObjectName(u"NewChild"_s);

    QModelIndex newRootIndex = model.indexOf(model.root());
    QCOMPARE(model.rowCount(newRootIndex), 1);

    QModelIndex childIndex = model.indexOf(newChild);
    QVERIFY(childIndex.isValid());
    QCOMPARE(childIndex.data(Qt::DisplayRole).toString(), u"NewChild"_s);
}

// ---------------------------------------------------------------------------
// Thread affinity tests
// ---------------------------------------------------------------------------

void QObjectTreeModelTest::TestSetRootWithCrossThreadObjectIsNoOp()
{
#ifdef QT_NO_DEBUG
    // In release builds Q_ASSERT_X compiles away, so setRoot simply returns
    // without modifying the model.  In debug builds the unconditional
    // Q_ASSERT_X(false, ...) aborts before the early-return is reached, so
    // this test can only run in release mode.
    QObjectTreeModel model(nullptr);
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QObject *originalRoot = model.root();
    QVERIFY(originalRoot);

    QThread otherThread;
    otherThread.start();

    auto *crossThreadObj = new QObject;
    crossThreadObj->moveToThread(&otherThread);

    QSignalSpy rootChangedSpy(&model, &QObjectTreeModel::rootChanged);

    // This should be rejected — the object is on a different thread.
    model.setRoot(crossThreadObj);

    // The root should not have changed.
    QCOMPARE(model.root(), originalRoot);
    QCOMPARE(rootChangedSpy.count(), 0);

    // The model should still be fully functional.
    QModelIndex rootIndex = model.indexOf(model.root());
    QVERIFY(rootIndex.isValid());

    otherThread.quit();
    otherThread.wait();
    delete crossThreadObj;
#else
    QSKIP("This test exercises the release-build early-return path in setRoot. "
          "In debug builds the Q_ASSERT_X fires before the return is reached.");
#endif
}

void QObjectTreeModelTest::TestSetRootWithCrossThreadObjectPreservesExistingRoot()
{
#ifdef QT_NO_DEBUG
    // Same release-only reasoning as TestSetRootWithCrossThreadObjectIsNoOp.
    QObject root;
    root.setObjectName(u"ExternalRoot"_s);
    auto *child = new QObject(&root);
    child->setObjectName(u"Child"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(&root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(&root);
    QCOMPARE(model.rowCount(rootIndex), 1);

    QThread otherThread;
    otherThread.start();

    auto *crossThreadObj = new QObject;
    crossThreadObj->moveToThread(&otherThread);

    model.setRoot(crossThreadObj);

    // Original root and child should still be fully tracked.
    QCOMPARE(model.root(), &root);
    QCOMPARE(model.rowCount(rootIndex), 1);
    QVERIFY(model.indexOf(child).isValid());

    otherThread.quit();
    otherThread.wait();
    delete crossThreadObj;
#else
    QSKIP("This test exercises the release-build early-return path in setRoot. "
          "In debug builds the Q_ASSERT_X fires before the return is reached.");
#endif
}

void QObjectTreeModelTest::TestMoveExternalRootToOtherThreadResetsModel()
{
    // When an external root is moved to another thread via moveToThread(),
    // the model receives a ThreadChange event and should reset to an internal
    // root.
    auto *root = new QObject;
    root->setObjectName(u"ExternalRoot"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QCOMPARE(model.root(), root);

    QSignalSpy rootChangedSpy(&model, &QObjectTreeModel::rootChanged);
    QSignalSpy modelResetSpy(&model, &QAbstractItemModel::modelReset);

    QThread otherThread;
    otherThread.start();

    // moveToThread sends ThreadChange synchronously on the current thread
    // before the move completes, so the event filter fires inline.
    root->moveToThread(&otherThread);

    // The model should have reset to a new internal root.
    QCOMPARE(rootChangedSpy.count(), 1);
    QCOMPARE(modelResetSpy.count(), 1);
    QVERIFY(model.root() != nullptr);
    QVERIFY(model.root() != root);
    QCOMPARE(model.root()->parent(), &model);

    // The old root should no longer be tracked.
    QVERIFY(!model.indexOf(root).isValid());

    // New internal root should be valid and empty.
    QModelIndex newRootIndex = model.indexOf(model.root());
    QVERIFY(newRootIndex.isValid());
    QCOMPARE(model.rowCount(newRootIndex), 0);

    otherThread.quit();
    otherThread.wait();
    delete root;
}

void QObjectTreeModelTest::TestMoveExternalRootToOtherThreadModelRemainsUsable()
{
    // After the root is moved off-thread and the model resets, verify
    // the model accepts new children on the replacement internal root.
    auto *root = new QObject;
    root->setObjectName(u"ExternalRoot"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QThread otherThread;
    otherThread.start();

    root->moveToThread(&otherThread);

    // Model should now have an internal root — add children to it.
    auto *newChild = new QObject(model.root());
    newChild->setObjectName(u"NewChild"_s);

    QModelIndex newRootIndex = model.indexOf(model.root());
    QCOMPARE(model.rowCount(newRootIndex), 1);

    QModelIndex childIndex = model.indexOf(newChild);
    QVERIFY(childIndex.isValid());
    QCOMPARE(childIndex.data(Qt::DisplayRole).toString(), u"NewChild"_s);

    otherThread.quit();
    otherThread.wait();
    delete root;
}

void QObjectTreeModelTest::TestMoveExternalRootWithSubtreeToOtherThreadResetsModel()
{
    // An external root with children: only the root can be moved (children
    // have a parent so moveToThread on them would be a Qt error). Moving the
    // root should cleanly detach the entire tracked subtree.
    //
    // Note: Qt's moveToThread automatically moves all children along with
    // the root, so after the move the entire subtree is on the other thread.
    auto *root = new QObject;
    root->setObjectName(u"ExternalRoot"_s);
    auto *child1 = new QObject(root);
    child1->setObjectName(u"Child1"_s);
    auto *child2 = new QObject(root);
    child2->setObjectName(u"Child2"_s);
    auto *grandchild = new QObject(child1);
    grandchild->setObjectName(u"Grandchild"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(root);
    QCOMPARE(model.rowCount(rootIndex), 2);
    QCOMPARE(model.rowCount(model.indexOf(child1)), 1);

    QSignalSpy rootChangedSpy(&model, &QObjectTreeModel::rootChanged);

    QThread otherThread;
    otherThread.start();

    root->moveToThread(&otherThread);

    QCOMPARE(rootChangedSpy.count(), 1);
    QVERIFY(model.root() != root);
    QCOMPARE(model.root()->parent(), &model);

    // None of the old objects should be tracked.
    QVERIFY(!model.indexOf(root).isValid());
    QVERIFY(!model.indexOf(child1).isValid());
    QVERIFY(!model.indexOf(child2).isValid());
    QVERIFY(!model.indexOf(grandchild).isValid());

    // New root should be empty.
    QModelIndex newRootIndex = model.indexOf(model.root());
    QVERIFY(newRootIndex.isValid());
    QCOMPARE(model.rowCount(newRootIndex), 0);

    otherThread.quit();
    otherThread.wait();
    delete root;
}

// Verify that destroying the model while it tracks a live external root with
// children removes event filters from every surviving object.
void QObjectTreeModelTest::TestDestructorCleansUpEventFiltersOnLiveRoot()
{
    QObject root;
    QObject *child = new QObject(&root);
    QObject *grandchild = new QObject(child);

    // Helper: returns true if the object's event-filter list contains any
    // non-null QPointer entries — the telltale sign of a missing cleanup.
    constexpr auto hasStaleEventFilter = [](QObject *obj) -> bool {
        const auto *priv = QObjectPrivate::get(obj);
        if (!priv->extraData)
            return false;
        for (const auto &filter : priv->extraData->eventFilters) {
            if (!filter.isNull()) // Found an active event filter.
                return true;
        }
        return false;
    };

    QVERIFY2(!hasStaleEventFilter(&root),
             "Root has a stale event-filter before being inserted into the model");
    QVERIFY2(!hasStaleEventFilter(child),
             "Child has a stale event-filter before being inserted into the model");
    QVERIFY2(!hasStaleEventFilter(grandchild),
             "Grandchild has a stale event-filter before being inserted into the model");

    // Keep a raw pointer so we can inspect internals after the model is gone.
    auto model_uptr = QObjectTreeModel::CreateWithRoot(&root);
    QObjectTreeModel *model = model_uptr.get();

    // Sanity: the model is tracking everything.
    QVERIFY(model->indexOf(child).isValid());
    QVERIFY(model->indexOf(grandchild).isValid());

    // Destroy the model while root, child, and grandchild are still alive.
    model_uptr.reset();
    model = nullptr;

    QVERIFY2(!hasStaleEventFilter(&root),
             "Root has a stale event-filter entry after model destruction");
    QVERIFY2(!hasStaleEventFilter(child),
             "Child has a stale event-filter entry after model destruction");
    QVERIFY2(!hasStaleEventFilter(grandchild),
             "Grandchild has a stale event-filter entry after model destruction");

    // Signals should also be disconnected: renaming a formerly-tracked object
    // must not crash or invoke a dangling slot.
    child->setObjectName(u"renamed"_s);
    grandchild->setObjectName(u"also_renamed"_s);
}

// ---------------------------------------------------------------------------
// QWidget tests
// ---------------------------------------------------------------------------
// These tests exercise the ChildAdded suppression issue that exists for
// QWidget children inside QObjectPrivate::setParent_helper. Qt's base
// implementation suppresses ChildAdded for widgets because QWidget::setParent
// sends it at a higher layer. When bypassing the QWidget layer (e.g. via
// SetParent or QObject::setParent on a widget pointer), ChildAdded was lost
// and the model would silently desync.
//
// IMPORTANT: All tests parent QWidget children to QWidget parents. Parenting
// a QWidget to a plain QObject via SetParent bypasses QWidget::setParent's
// window-system setup, causing crashes in QWidget::~QWidget during teardown.
// ---------------------------------------------------------------------------

void QObjectTreeModelTest::TestSetParentWithQWidgetChildTracksCorrectly()
{
#if QT_CONFIG(widgets)
    // Verify that calling SetParent on a QWidget correctly updates the model.
    // Before the fix, SetParent suppressed ChildAdded for widgets (mirroring
    // setParent_helper) which meant the model never saw the addition.
    auto *root = new QWidget(nullptr);
    root->setObjectName(u"Root"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(root);
    QCOMPARE(model.rowCount(rootIndex), 0);

    QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
    QVERIFY(rowsInsertedSpy.isValid());

    // Create an unparented QWidget and use SetParent to add it to the root.
    auto *widget = new QWidget(nullptr);
    widget->setObjectName(u"Widget"_s);
    QObjectTreeModel::SetParent(widget, root, 0);

    // The model must have picked up the addition.
    QCOMPARE(rowsInsertedSpy.count(), 1);
    VERIFY_SIGNAL_ARGS(rowsInsertedSpy.takeFirst(), root, 0, 0);

    QCOMPARE(model.rowCount(rootIndex), 1);
    QModelIndex widgetIndex = model.indexOf(widget);
    QVERIFY2(widgetIndex.isValid(), "QWidget added via SetParent must be tracked by the model");
    QCOMPARE(widgetIndex.data(Qt::DisplayRole).toString(), u"Widget"_s);

    delete root;
#else
    QSKIP("This test requires QtWidgets.");
#endif
}

void QObjectTreeModelTest::TestSetParentMoveQWidgetBetweenParents()
{
#if QT_CONFIG(widgets)
    // Move a QWidget from one tracked parent to another using SetParent.
    // Note: even before the ChildAdded fix, this particular case worked
    // because handleChildRemovedEvent detects that the child's real parent
    // has changed to another tracked object and converts the removal into a
    // move. The ChildAdded event is redundant here. This test exists as a
    // regression guard.
    auto *root = new QWidget(nullptr);
    root->setObjectName(u"Root"_s);

    auto *parentA = new QWidget(root);
    parentA->setObjectName(u"ParentA"_s);
    auto *parentB = new QWidget(root);
    parentB->setObjectName(u"ParentB"_s);

    auto *widget = new QWidget(nullptr);
    widget->setObjectName(u"Widget"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Attach the widget to parentA via SetParent.
    QObjectTreeModel::SetParent(widget, parentA, 0);
    QCOMPARE(model.rowCount(model.indexOf(parentA)), 1);
    QCOMPARE(model.rowCount(model.indexOf(parentB)), 0);

    QSignalSpy rowsAboutToBeMovedSpy(&model, &QAbstractItemModel::rowsAboutToBeMoved);
    QSignalSpy rowsMovedSpy(&model, &QAbstractItemModel::rowsMoved);
    QVERIFY(rowsAboutToBeMovedSpy.isValid());
    QVERIFY(rowsMovedSpy.isValid());

    // Now move the widget from parentA to parentB via SetParent.
    QObjectTreeModel::SetParent(widget, parentB, 0);

    // SetParent sends both ChildRemoved and ChildAdded. The
    // handleChildRemovedEvent detects the reparent and emits move signals.
    QCOMPARE(rowsAboutToBeMovedSpy.count(), 1);
    VERIFY_MOVE_SIGNAL_ARGS(rowsAboutToBeMovedSpy.takeFirst(), parentA, 0, 0, parentB, 0);
    QCOMPARE(rowsMovedSpy.count(), 1);
    VERIFY_MOVE_SIGNAL_ARGS(rowsMovedSpy.takeFirst(), parentA, 0, 0, parentB, 0);

    QCOMPARE(model.rowCount(model.indexOf(parentA)), 0);
    QCOMPARE(model.rowCount(model.indexOf(parentB)), 1);

    QModelIndex widgetIndex = model.indexOf(widget);
    QVERIFY2(widgetIndex.isValid(),
             "QWidget moved via SetParent must still be tracked by the model");
    QCOMPARE(widgetIndex.data(Qt::DisplayRole).toString(), u"Widget"_s);

    delete root;
#else
    QSKIP("This test requires QtWidgets.");
#endif
}

void QObjectTreeModelTest::TestQWidgetSetParentTrackedByModel()
{
#if QT_CONFIG(widgets)
    // Verify that using QWidget::setParent (the normal widget API) to
    // reparent a QWidget into a tracked tree is correctly picked up by the
    // model. QWidget::setParent sends ChildAdded itself, so this should
    // already work. This test exists to confirm that baseline.
    auto *widgetRoot = new QWidget(nullptr);
    widgetRoot->setObjectName(u"WidgetRoot"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(widgetRoot);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(widgetRoot);
    QCOMPARE(model.rowCount(rootIndex), 0);

    QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
    QVERIFY(rowsInsertedSpy.isValid());

    // Reparent via QWidget::setParent(QWidget*).
    auto *childWidget = new QWidget(nullptr);
    childWidget->setObjectName(u"ChildWidget"_s);
    childWidget->setParent(widgetRoot);

    QCOMPARE(rowsInsertedSpy.count(), 1);
    QCOMPARE(model.rowCount(rootIndex), 1);
    QModelIndex childIndex = model.indexOf(childWidget);
    QVERIFY2(childIndex.isValid(),
             "QWidget added via QWidget::setParent must be tracked by the model");
    QCOMPARE(childIndex.data(Qt::DisplayRole).toString(), u"ChildWidget"_s);

    delete widgetRoot;
#else
    QSKIP("This test requires QtWidgets.");
#endif
}

void QObjectTreeModelTest::TestNewQWidgetChildTrackedByModel()
{
#if QT_CONFIG(widgets)
    // Verify that constructing a QWidget with a tracked parent (i.e. the
    // QWidget(QWidget *parent) constructor) is picked up by the model.
    auto *widgetRoot = new QWidget(nullptr);
    widgetRoot->setObjectName(u"WidgetRoot"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(widgetRoot);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(widgetRoot);

    QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
    QVERIFY(rowsInsertedSpy.isValid());

    // Construct a child widget directly under the root.
    auto *child = new QWidget(widgetRoot);
    child->setObjectName(u"ChildWidget"_s);

    QCOMPARE(rowsInsertedSpy.count(), 1);
    VERIFY_SIGNAL_ARGS(rowsInsertedSpy.takeFirst(), widgetRoot, 0, 0);
    QCOMPARE(model.rowCount(rootIndex), 1);

    QModelIndex childIndex = model.indexOf(child);
    QVERIFY2(childIndex.isValid(),
             "QWidget constructed with a tracked parent must be tracked by the model");

    delete widgetRoot;
#else
    QSKIP("This test requires QtWidgets.");
#endif
}

void QObjectTreeModelTest::TestQWidgetSubtreeTrackedViaSetParent()
{
#if QT_CONFIG(widgets)
    // Verify that SetParent correctly tracks a QWidget subtree (widget with
    // widget children) when grafted into the model.
    auto *root = new QWidget(nullptr);
    root->setObjectName(u"Root"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(root);

    // Build an off-model widget subtree.
    auto *subtreeRoot = new QWidget(nullptr);
    subtreeRoot->setObjectName(u"SubtreeRoot"_s);
    auto *subtreeChild1 = new QWidget(subtreeRoot);
    subtreeChild1->setObjectName(u"SubtreeChild1"_s);
    auto *subtreeChild2 = new QWidget(subtreeRoot);
    subtreeChild2->setObjectName(u"SubtreeChild2"_s);
    auto *subtreeGrandchild = new QWidget(subtreeChild1);
    subtreeGrandchild->setObjectName(u"SubtreeGrandchild"_s);

    // Graft the subtree into the model via SetParent.
    QObjectTreeModel::SetParent(subtreeRoot, root, 0);

    // The entire subtree must be tracked.
    QCOMPARE(model.rowCount(rootIndex), 1);

    QModelIndex subtreeRootIndex = model.indexOf(subtreeRoot);
    QVERIFY2(subtreeRootIndex.isValid(), "Subtree root must be tracked");
    QCOMPARE(model.rowCount(subtreeRootIndex), 2);

    QModelIndex child1Index = model.indexOf(subtreeChild1);
    QVERIFY2(child1Index.isValid(), "Subtree child1 must be tracked");
    QCOMPARE(model.rowCount(child1Index), 1);

    QModelIndex child2Index = model.indexOf(subtreeChild2);
    QVERIFY2(child2Index.isValid(), "Subtree child2 must be tracked");
    QCOMPARE(model.rowCount(child2Index), 0);

    QModelIndex grandchildIndex = model.indexOf(subtreeGrandchild);
    QVERIFY2(grandchildIndex.isValid(), "Subtree grandchild must be tracked");

    delete root;
#else
    QSKIP("This test requires QtWidgets.");
#endif
}

void QObjectTreeModelTest::TestQWidgetMoveViaQWidgetSetParentDetectedByModel()
{
#if QT_CONFIG(widgets)
    // Verify that using QWidget::setParent (the standard widget API) to move
    // a tracked QWidget from one tracked parent to another is correctly
    // detected by the model via the ParentChange event (and/or ChildRemoved,
    // depending on the platform and Qt version).
    //
    // The exact signal sequence (move vs remove+insert) is platform-dependent:
    // some Qt builds suppress ChildRemoved for widgets entirely and rely on
    // ParentChange alone (producing move signals), while others send
    // ChildRemoved before the parent pointer is updated (producing
    // remove+insert, consistent with plain QObject::setParent behaviour).
    //
    // This test therefore only verifies the final model state, not the signal
    // types. For guaranteed move signals, use QObjectTreeModel::SetParent().
    auto *root = new QWidget(nullptr);
    root->setObjectName(u"Root"_s);

    auto *parentA = new QWidget(root);
    parentA->setObjectName(u"ParentA"_s);
    auto *parentB = new QWidget(root);
    parentB->setObjectName(u"ParentB"_s);

    auto *widget = new QWidget(parentA);
    widget->setObjectName(u"Widget"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QCOMPARE(model.rowCount(model.indexOf(parentA)), 1);
    QCOMPARE(model.rowCount(model.indexOf(parentB)), 0);

    // Move the widget from parentA to parentB using the standard widget API.
    widget->setParent(parentB);

    // Verify the model reflects the new tree structure.
    QCOMPARE(model.rowCount(model.indexOf(parentA)), 0);
    QCOMPARE(model.rowCount(model.indexOf(parentB)), 1);

    QModelIndex widgetIndex = model.indexOf(widget);
    QVERIFY2(widgetIndex.isValid(),
             "QWidget moved via QWidget::setParent must still be tracked by the model");
    QCOMPARE(widgetIndex.data(Qt::DisplayRole).toString(), u"Widget"_s);

    // Verify parentage in the model matches reality.
    QModelIndex parentBIndex = model.indexOf(parentB);
    QCOMPARE(model.parent(widgetIndex), parentBIndex);

    delete root;
#else
    QSKIP("This test requires QtWidgets.");
#endif
}

void QObjectTreeModelTest::TestQWidgetReparentToNullptrViaQWidgetSetParent()
{
#if QT_CONFIG(widgets)
    // Verify that reparenting a tracked QWidget to nullptr via
    // QWidget::setParent(nullptr) correctly removes it from the model.
    auto *root = new QWidget(nullptr);
    root->setObjectName(u"Root"_s);

    auto *child = new QWidget(root);
    child->setObjectName(u"Child"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(root);
    QCOMPARE(model.rowCount(rootIndex), 1);

    ModelSignalSpies spies(&model);

    // Reparent to nullptr via the standard widget API.
    child->setParent(static_cast<QWidget *>(nullptr));

    QCOMPARE(model.rowCount(rootIndex), 0);
    QVERIFY2(!model.indexOf(child).isValid(),
             "QWidget reparented to nullptr must be removed from the model");
    spies.verifyRemoveOnly(1);

    // Clean up the now-orphaned widget.
    delete child;
    delete root;
#else
    QSKIP("This test requires QtWidgets.");
#endif
}

void QObjectTreeModelTest::TestQWidgetReparentToUntrackedParentViaQWidgetSetParent()
{
#if QT_CONFIG(widgets)
    // Verify that reparenting a tracked QWidget to an untracked QWidget via
    // QWidget::setParent removes it from the model.
    auto *root = new QWidget(nullptr);
    root->setObjectName(u"Root"_s);

    auto *child = new QWidget(root);
    child->setObjectName(u"Child"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);

    QModelIndex rootIndex = model.indexOf(root);
    QCOMPARE(model.rowCount(rootIndex), 1);

    ModelSignalSpies spies(&model);

    // Move the widget out of the tracked tree to an untracked parent.
    auto *untracked = new QWidget(nullptr);
    untracked->setObjectName(u"Untracked"_s);
    child->setParent(untracked);

    QCOMPARE(model.rowCount(rootIndex), 0);
    QVERIFY2(!model.indexOf(child).isValid(),
             "QWidget reparented to an untracked parent must be removed from the model");
    spies.verifyRemoveOnly(1);

    delete untracked;
    delete root;
#else
    QSKIP("This test requires QtWidgets.");
#endif
}

void QObjectTreeModelTest::TestQObjectSetParentOnQWidgetCausesDesync()
{
#if !QT_CONFIG(widgets)
    QSKIP("This test requires QtWidgets.");
#elif !defined(QT_NO_DEBUG)
    // In debug builds, QObject::setParent() on a QWidget hits
    // Q_ASSERT(!d->isWidget) and would abort. We can only test the desync
    // in release builds.
    QSKIP("QObject::setParent() asserts !isWidget in debug builds. "
          "This test exercises the release-build desync path.");
#else
    // In release builds, calling QObject::setParent (the base-class version)
    // on a QWidget goes through setParent_helper which suppresses ChildAdded
    // for widgets. For an unparented widget being added to a tracked parent,
    // there is no ChildRemoved from an old parent (so the model's move
    // detection in handleChildRemovedEvent never fires), and no ChildAdded
    // is sent. The model silently desyncs.
    //
    // The ParentChange event does NOT help here either: ParentChange is sent
    // by QWidgetPrivate::setParent_helper, which is only called from
    // QWidget::setParent(QWidget*). Calling QObject::setParent() bypasses
    // the widget override entirely, so no ParentChange is delivered.
    //
    // Note: if the widget already has a tracked parent, the model handles the
    // reparent correctly via ChildRemoved move detection. The desync only
    // occurs when no ChildRemoved is available (unparented or non-tracked
    // old parent).
    //
    // Qt considers calling QObject::setParent on a QWidget to be a
    // programming error (it asserts in debug). This test documents the
    // known limitation. If a ParentChange fallback is implemented, update
    // the QEXPECT_FAIL lines to regular passing assertions.
    auto *widgetRoot = new QWidget(nullptr);
    widgetRoot->setObjectName(u"WidgetRoot"_s);

    auto model_ptr = QObjectTreeModel::CreateWithRoot(root);
    auto &model = *model_ptr;
    QAbstractItemModelTester tester_model(&model,
                                          QAbstractItemModelTester::FailureReportingMode::Fatal);
    QModelIndex rootIndex = model.indexOf(widgetRoot);
    QCOMPARE(model.rowCount(rootIndex), 0);

    // Create an unparented QWidget and add it to the tracked root via the
    // base-class QObject::setParent — bypassing QWidget::setParent.
    auto *child = new QWidget(nullptr);
    child->setObjectName(u"Child"_s);
    child->QObject::setParent(widgetRoot);

    // The real QObject tree now has the child under widgetRoot.
    QCOMPARE(child->parent(), widgetRoot);

    // --- Expected desync ---
    // The model never received a ChildAdded event (suppressed for widgets in
    // setParent_helper) and there was no ChildRemoved from a previous parent
    // to trigger move detection.
    QEXPECT_FAIL("",
                 "QObject::setParent on an unparented QWidget suppresses ChildAdded. "
                 "Model desyncs without a ParentChange fallback.",
                 Continue);
    QCOMPARE(model.rowCount(rootIndex), 1);

    QEXPECT_FAIL("",
                 "QObject::setParent on an unparented QWidget suppresses ChildAdded. "
                 "Model desyncs without a ParentChange fallback.",
                 Continue);
    QVERIFY(model.indexOf(child).isValid());

    delete widgetRoot;
#endif
}

QTEST_MAIN(QObjectTreeModelTest)

void QObjectTreeModelTest::TestIsAncestorOfReturnsFalseForNullArguments()
{
    QObject obj;
    QVERIFY(!QObjectTreeModel::IsAncestorOf(nullptr, nullptr));
    QVERIFY(!QObjectTreeModel::IsAncestorOf(&obj, nullptr));
    QVERIFY(!QObjectTreeModel::IsAncestorOf(nullptr, &obj));
}

void QObjectTreeModelTest::TestIsAncestorOfReturnsTrueForSelf()
{
    QObject obj;
    QVERIFY(QObjectTreeModel::IsAncestorOf(&obj, &obj));
}

void QObjectTreeModelTest::TestIsAncestorOfReturnsTrueForDirectParent()
{
    QObject parent;
    QObject child(&parent);
    QVERIFY(QObjectTreeModel::IsAncestorOf(&parent, &child));
}

void QObjectTreeModelTest::TestIsAncestorOfReturnsTrueForGrandparent()
{
    QObject grandparent;
    QObject parent(&grandparent);
    QObject child(&parent);
    QVERIFY(QObjectTreeModel::IsAncestorOf(&grandparent, &child));
}

void QObjectTreeModelTest::TestIsAncestorOfReturnsFalseForChild()
{
    QObject parent;
    QObject child(&parent);
    QVERIFY(!QObjectTreeModel::IsAncestorOf(&child, &parent));
}

void QObjectTreeModelTest::TestIsAncestorOfReturnsFalseForUnrelatedObjects()
{
    QObject a;
    QObject b;
    QVERIFY(!QObjectTreeModel::IsAncestorOf(&a, &b));
    QVERIFY(!QObjectTreeModel::IsAncestorOf(&b, &a));
}
#include "tst_qobjecttreemodel.moc"