Method testReturnValueVariable

plugins/debuggercommon/tests/debuggertestbase.cpp:2184–2312

}

void DebuggerTestBase::testReturnValueVariable()
{
    struct ReturnValue
    {
        QString type;
        QString value;
    };

    const auto verifyReturnValueVariable = [this](const std::optional<ReturnValue>& expectedReturnValue = {}) {
        const auto watchesIndex = variableCollection()->index(0, 0);
        COMPARE_DATA(watchesIndex, Watches::sectionTitle());
        if (isLldb() && expectedReturnValue) {
            // NOTE: the Abort mode merely returns from this lambda to prevent a crash; the test proceeds then.
            QEXPECT_FAIL("", "LLDB-MI never sends a field \"gdb-result-var\"", Abort);
        }
        QCOMPARE_EQ(variableCollection()->rowCount(watchesIndex), expectedReturnValue.has_value());
        if (expectedReturnValue) {
            const auto returnValueVariableIndex = [&watchesIndex, this](int column) {
                return variableCollection()->index(0, column, watchesIndex);
            };

            QCOMPARE_NE(variableCollection()->watches()->returnValueVariable(), nullptr);
            QCOMPARE_EQ(variableCollection()->watches()->returnValueVariable(),
                        variableCollection()->itemForIndex(returnValueVariableIndex(0)));
            COMPARE_DATA(returnValueVariableIndex(0), Watches::returnValueVariableDisplayName());
            COMPARE_DATA(returnValueVariableIndex(1), expectedReturnValue->value);
            COMPARE_DATA(returnValueVariableIndex(2), expectedReturnValue->type);
        }
    };

#define VERIFY_RETURN_VALUE_VARIABLE(...)                                                                              \
    do {                                                                                                               \
        verifyReturnValueVariable(__VA_ARGS__);                                                                        \
        RETURN_IF_TEST_FAILED();                                                                                       \
    } while (false)

    auto* const session = createTestDebugSession();
    TestLaunchConfiguration cfg("debuggee_debugeereturnvalues");
    const auto fileUrl = QUrl::fromLocalFile(findSourceFile("debugeereturnvalues.cpp"));

    constexpr std::array functionBodyLines{13, 18};
    for (const auto miLine : functionBodyLines) {
        breakpoints()->addCodeBreakpoint(fileUrl, miLine - 1);
    }

    constexpr auto secondFunctionStepOutLine = 40;
    breakpoints()->addCodeBreakpoint(fileUrl, secondFunctionStepOutLine - 1);

    ActiveStateSessionSpy sessionSpy(session);
    START_DEBUGGING_AND_WAIT_FOR_PAUSED_STATE_E(session, cfg, sessionSpy);
    QCOMPARE(currentMiLine(session), functionBodyLines[0]);
    // Initially a return value variable does not exist.
    VERIFY_RETURN_VALUE_VARIABLE();

    STEP_OUT_AND_WAIT_FOR_PAUSED_STATE(session, sessionSpy);
    QCOMPARE(currentMiLine(session), 39);
    // KDevelop creates a return value variable after stepping out of a non-void function.
    VERIFY_RETURN_VALUE_VARIABLE(ReturnValue{"int", "5"});