suyu_two/app/tests/performance_tests.cpp

#include "domain/control_logic_model.h"
#include "domain/register_repository.h"
#include "domain/virtual_register_repository.h"
#include "services/software_logic_executor.h"

#include <QTest>

#include <string>
#include <vector>

namespace
{

LogicNode contact(const std::string &id, int address)
{
    return {id,
            ContactNodeConfig{
                RegisterAddress{RegisterArea::M, address},
                ContactMode::NormallyOpen},
            true};
}

LogicNode coil(const std::string &id, int address)
{
    return {id,
            CoilNodeConfig{
                RegisterAddress{RegisterArea::M, address},
                CoilMode::Normal},
            true};
}

ControlLogic makeLogic(int index)
{
    LadderRung rung;
    rung.id = "rung-" + std::to_string(index);
    rung.name = rung.id;
    rung.condition = ConditionExpression::fromNode(
        contact("contact-" + std::to_string(index), index));
    rung.output = coil("coil-" + std::to_string(index), index + 100);
    return {"logic-" + std::to_string(index),
            "logic-" + std::to_string(index),
            {rung},
            true};
}

class PerformanceTests final : public QObject
{
    Q_OBJECT

private slots:
    void softwareExecutor_scansRepresentativeProject()
    {
        std::vector<ControlLogic> logics;
        logics.reserve(100);
        for (int index = 0; index < 100; ++index)
        {
            logics.push_back(makeLogic(index));
        }

        SoftwareLogicExecutor executor;
        VirtualRegisterRepository repository;
        QVERIFY(executor.validate(logics).succeeded);
        QVERIFY(executor.executeScan(logics, repository).succeeded);

        QBENCHMARK
        {
            executor.executeScan(logics, repository);
        }
    }

    void virtualRepository_handlesBoundaryWorkload()
    {
        VirtualRegisterRepository repository;
        for (int index = 0; index <= RegisterAddress::kMaximumIndex; ++index)
        {
            QVERIFY(repository.writeBit(
                         {RegisterArea::M, index}, (index % 2) == 0)
                         .succeeded);
            QVERIFY(repository.readBit({RegisterArea::M, index}).succeeded);
        }

        QBENCHMARK
        {
            for (int index = 0; index <= RegisterAddress::kMaximumIndex; ++index)
            {
                repository.writeBit(
                    {RegisterArea::M, index}, (index % 2) == 0);
                repository.readBit({RegisterArea::M, index});
            }
        }
    }
};

} // namespace

QTEST_APPLESS_MAIN(PerformanceTests)

#include "performance_tests.moc"