qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/DDS/DdsUnitTests/generic_data_tests.cpp

#include "generic_data_tests.h"

#include <DDS/Generic/generic_data_reader.h>
#include <DDS/Generic/generic_data_writer.h>
#include <Lts/Common/ProjectConfig/project_defines.h>
#include <NGLLogger/NGLLoggerBootstrap.h>
#include <QtTest/QTest>
#include <nglapplication/nglcoreapplication.h>

int main(int argc, char* argv[])
{
    NGLCoreApplication app(argc, argv);
    app.createLogger("UnitTests", "log4cxx_ddsUnitTests.props");

    GenericDataTests* tc = new GenericDataTests;

    int retCode = QTest::qExec(tc, argc, argv);

    delete tc;

    return retCode;
}

GenericDataTests::GenericDataTests()
    : m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("UnitTests.GenericDataTests"))
{
    m_spatialData.equipNo(0);
    m_testPart.location().equipNo(0);
    m_testPart.location().participantId(0);
}

void GenericDataTests::initTestCase()
{
    DEBUG_LOG(m_logger) << "GenericDataTests: initTestCase";

    m_init = new Initialisation();

    int domainId = 0;
    int exerciseId = 2;

    QVERIFY2(m_init, "Initialisation failed");
    QVERIFY2(m_init->initDDS(domainId, exerciseId, Initialisation::USE_PUBLISHER), "Initialisation (Publisher) failed");
    QVERIFY2(m_init->initDDS(domainId, exerciseId, Initialisation::USE_SUBSCRIBER),
             "Initialisation (Subscriber) failed");

    QVERIFY2(m_init->getSubscriberListener(), "Initialisation SubscriberListener failed");
}

void GenericDataTests::initDRTestCase()
{
    m_dataReader = new DTC::DroTestParticipant;
    QVERIFY2(m_dataReader, "Initialisation of GenericDataReader(TestParticipant) failed");
    QVERIFY2(m_dataReader->create(m_init->getDomainParticipantSub(), m_init->getDDSSubscriber()),
             "Creating DataReader (TestParticipant) failed");
    m_init->getSubscriberListener()->addCallback(m_dataReader->getDataReader(), this);

    m_dataReaderSd = new DTC::DroSpatialData;
    QVERIFY2(m_dataReaderSd, "Initialisation of GenericDataReader(SpatialData) failed");
    QVERIFY2(m_dataReaderSd->create(m_init->getDomainParticipantSub(), m_init->getDDSSubscriber()),
             "Creating DataReader (SpatialData) failed");
    m_init->getSubscriberListener()->addCallback(m_dataReaderSd->getDataReader(), this);
}

void GenericDataTests::initDWTestCase()
{
    m_dataWriter = new DTS::DwoTestParticipant();
    QVERIFY2(m_dataWriter, "Initialisation of GenericDataWriter(TestParticipant) failed");
    QVERIFY2(m_dataWriter->create(m_init->getDomainParticipant(), m_init->getDDSPublisher()),
             "Creating DataWriter (TestParticipant) failed");

    m_dataWriterSd = new DTS::DwoSpatialData();
    QVERIFY2(m_dataWriterSd, "Initialisation of GenericDataWriter(SpatialData) failed");
    QVERIFY2(m_dataWriterSd->create(m_init->getDomainParticipant(), m_init->getDDSPublisher()),
             "Creating DataWriter (SpatialData) failed");
}

void GenericDataTests::dataWriterTestCase()
{
    DEBUG_LOG(m_logger) << "GenericDataTests: dataWriter";

    DdsUnitTests::SpatialData data;

    data.participantId(100);
    data.equipNo(999);
    data.gpsPosition().lon(70000);
    data.gpsPosition().lat(90000);
    data.gpsPosition().z(10);

    data.orientation().heave(10);
    data.orientation().pitch(10);
    data.orientation().roll(10);

    data.velocity().x(10);
    data.velocity().y(2);
    data.velocity().z(1);

    data.changedAt(11111);

    QVERIFY2(m_dataWriterSd->write(data), "Publishing Topic (SpatialData) failed");

    DdsUnitTests::TestParticipant allData;

    allData.name("************************ Name of TestParticpant ***********************");
    allData.location() = data;
    allData.id(10000);
    QVERIFY2(m_dataWriter->write(allData), "Publishing Topic (TestParticipant) failed");
    allData.id(11000);
    QVERIFY2(m_dataWriter->write(allData), "Publishing Topic (TestParticipant) failed");
    allData.id(11100);
    QVERIFY2(m_dataWriter->write(allData), "Publishing Topic (TestParticipant) failed");
    allData.id(11110);
    QVERIFY2(m_dataWriter->write(allData), "Publishing Topic (TestParticipant) failed");

    allData.id(11111);

    QVERIFY2(m_dataWriter->write(allData), "Publishing Topic (TestParticipant) failed");
}

void GenericDataTests::dataReaderTestCase()
{
    DEBUG_LOG(m_logger) << "GenericDataTests: dataReader";

    QTRY_COMPARE(m_spatialData.equipNo(), 999);
    QCOMPARE(m_spatialData.changedAt(), 11111);

    QTRY_COMPARE(m_testPart.location().equipNo(), 999);
    QCOMPARE(m_testPart.location().participantId(), 100);

    bool bSeenUnreadSamples = false;
    dds::sub::LoanedSamples<DdsUnitTests::TestParticipant> vecTp = m_dataReader->readAlive(bSeenUnreadSamples);
    INFO_LOG(m_logger) << "vecTp size: " << vecTp.length();
    QCOMPARE(vecTp.length(), static_cast<decltype(vecTp.length())>(5));
    QCOMPARE(vecTp[0].data().id(), 10000);
    QCOMPARE(vecTp[1].data().id(), 11000);
    QCOMPARE(vecTp[2].data().id(), 11100);
    QCOMPARE(vecTp[3].data().id(), 11110);
    QCOMPARE(vecTp[4].data().id(), 11111);

    dds::sub::LoanedSamples<DdsUnitTests::TestParticipant> vecTpLoaned = m_dataReader->takeAlive(bSeenUnreadSamples);
    INFO_LOG(m_logger) << "vecTpLoaned size: " << vecTp.length();
    QCOMPARE(vecTpLoaned.length(), static_cast<decltype(vecTpLoaned.length())>(5));
    QCOMPARE(vecTpLoaned[0].data().id(), 10000);
    QCOMPARE(vecTpLoaned[1].data().id(), 11000);
    QCOMPARE(vecTpLoaned[2].data().id(), 11100);
    QCOMPARE(vecTpLoaned[3].data().id(), 11110);
    QCOMPARE(vecTpLoaned[4].data().id(), 11111);
}

void GenericDataTests::deleteDataReaderTestCase()
{
    DdsUnitTests::TestParticipant data;
    for (int i = 0; i < 1000; ++i)
    {
        data.id(i);
        m_dataWriter->write(data);
    }
    m_init->getSubscriberListener()->removeCallback(m_dataReader->getDataReader(), this);
    delete m_dataReader;
    m_dataReader = nullptr;
    for (int i = 0; i < 1000; ++i)
    {
        data.id(i);
        m_dataWriter->write(data);
    }
}

void GenericDataTests::cleanupTestCase()
{
    DEBUG_LOG(m_logger) << "GenericDataTests: cleanupTestCase";
    if (m_dataReader)
    {
        m_init->getSubscriberListener()->removeCallback(m_dataReader->getDataReader(), this);
        delete m_dataReader;
    }
    if (m_dataReaderSd)
    {
        m_init->getSubscriberListener()->removeCallback(m_dataReaderSd->getDataReader(), this);
        delete m_dataReaderSd;
    }
    m_init->cleanupSubscriberListener();
    delete m_dataWriter;
    delete m_dataWriterSd;
    delete m_init;
    deleteLater();
}

void GenericDataTests::processData(const DdsUnitTests::SpatialData& data, DataModification modType)
{
    DEBUG_LOG(m_logger) << "SpatialData: equipNo = " << data.equipNo() << " modType: " << modType;
    m_spatialData = data;
}

void GenericDataTests::processData(const DdsUnitTests::TestParticipant& data, const dds::sub::SampleInfo& si)
{
    Q_UNUSED(si);
    DEBUG_LOG(m_logger) << "TestParticipant: equipNo = " << data.location().equipNo();
    m_testPart = data;
}

void GenericDataTests::droDataAvailable(const std::string& topicType, const std::string& topicName)
{
    Q_UNUSED(topicName)
    DEBUG_LOG(m_logger) << "IN  droDataAvailable: type = " << topicType;
    if (topicType == "DdsUnitTests::TestParticipant")
    {
        m_init->getSubscriberListener()->enableCallback(m_dataReader->getDataReader(), this);
        m_dataReader->read([this](const DdsUnitTests::TestParticipant& data, const dds::sub::SampleInfo& si) {
            processData(data, si);
        });
    }
    else if (topicType == "DdsUnitTests::SpatialData")
    {
        m_init->getSubscriberListener()->enableCallback(m_dataReaderSd->getDataReader(), this);
        m_dataReaderSd->read(
            [this](const DdsUnitTests::SpatialData& data, DataModification modType) { processData(data, modType); });
    }
}