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

#include "data_topic_tests.h"

#include <DDS/DTC/generic_dtc_impl.h>
#include <DDS/DTS/generic_dts_impl.h>
#include <DDS/QosProfile/DDS_DefaultQos.h>
#include <Lts/Common/ProjectConfig/project_defines.h>
#include <NGLLogger/NGLLoggerBootstrap.h>
#include <QThread>
#include <QVariant>
#include <QtTest/QTest>

DataTopicTests::DataTopicTests() : m_domainParticipantPub(nullptr)
  , m_domainParticipantSub(nullptr)
  , m_domainId(0)
  , m_partitionId(1)
  , m_ddsPublisher(nullptr)
  , m_testPart(nullptr)
  , m_ddsSubscriber(nullptr)
  , m_subscriberListener(nullptr)
  , m_dtcTestPart(nullptr)
  , m_mainThreadId(QThread::currentThreadId())
  .getNGLLogger("UnitTests.DataTopicTests")),
    m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
{
    if (!DDS::QosProfile::setDefault())
        ERROR_LOG(m_logger) << "Error setting default QoS from xml-file ";

    DEBUG_LOG(m_logger) << "Main thread ID is " << m_mainThreadId;
}

DataTopicTests::~DataTopicTests()
{

    delete m_testPart;

    delete m_dtcTestPart;

    delete m_subscriberListener;
}

bool DataTopicTests::initPublisher()
{
    m_domainParticipantPub = dds::domain::DomainParticipant(m_domainId, DDS::QosProfile::domainParticipantShm());

    dds::pub::qos::PublisherQos publisherQos = m_domainParticipantPub.default_publisher_qos();

    QString partition = QString::fromStdString(IDL::exercisePartition(m_partitionId));

    dds::core::policy::Partition partitionQos;
    partitionQos.name({partition.toStdString()});
    publisherQos << partitionQos;

    DEBUG_LOG(m_logger) << "Publish on partition " << partition;

    m_ddsPublisher = dds::pub::Publisher(m_domainParticipantPub, publisherQos);
    m_testPart = new DTS::TestParticipantImpl(m_domainParticipantPub, m_ddsPublisher);

    return true;
}

bool DataTopicTests::write(const DdsUnitTests::TestParticipant& data)
{
    INFO_LOG(m_logger) << "Publish topic TestParticipant ";
    DEBUG_LOG(m_logger) << "ParticipantId: " << data.location().participantId()
                        << ", equipNo = " << data.location().equipNo();

    return m_testPart->write(data);
}

bool DataTopicTests::initSubscriber()
{
    DEBUG_LOG(m_logger) << "Initialisation DDS (Subscriber/Reader)";

    m_domainParticipantSub = dds::domain::DomainParticipant(m_domainId, DDS::QosProfile::domainParticipantShm());

    dds::sub::qos::SubscriberQos subscriberQos = m_domainParticipantSub.default_subscriber_qos();

    dds::core::StringSeq partitions;
    partitions.reserve(1);
    for (int partitionId : {1})
    {
        partitions.push_back(IDL::exercisePartition(partitionId));
    }

    dds::core::policy::Partition partitionQos;
    partitionQos.name(partitions);
    subscriberQos << partitionQos;

    DEBUG_LOG(m_logger) << "Initialise DTC::SubscriberListener";
    m_subscriberListener = new DDSGeneric::SubscriberListener();
    m_ddsSubscriber = dds::sub::Subscriber(m_domainParticipantSub, subscriberQos, m_subscriberListener,
                                           DDSGeneric::SubscriberListener::mask());

    m_dtcTestPart =
        new DTC::SampleInfo::TestParticipantImpl(m_domainParticipantSub, m_ddsSubscriber, m_subscriberListener);

    m_dtcTestPart->setSubscriberCallback(
        [this](const DdsUnitTests::TestParticipant& data, const dds::sub::SampleInfo& si) { processData(data, si); });

    return true;
}

void DataTopicTests::deleteDTC()
{
    delete m_dtcTestPart;
    m_dtcTestPart = nullptr;
}

void DataTopicTests::deleteSubscriber()
{
    m_ddsSubscriber = nullptr;
    delete m_subscriberListener;
    m_subscriberListener = nullptr;
}

void DataTopicTests::processData(const DdsUnitTests::TestParticipant& instance, const dds::sub::SampleInfo& si)
{
    INFO_LOG(m_logger) << "process data in topic TestParticipant, Sampleinfo: " << si.source_timestamp().sec();

    DEBUG_LOG(m_logger) << "participantId: " << instance.location().participantId();
    DEBUG_LOG(m_logger) << "equipNo: " << instance.location().equipNo();

    m_receivedParticipantData = instance;

    QCOMPARE(m_mainThreadId, QThread::currentThreadId());

    emit testParticipantDataArrived();
}