Apply clang-format to Lts/Common and DTC/enum headers

- Formatted all CodeGen module files (9 files)
- Formatted LtsAppDescriptor module files
- Formatted LtsAppManager/AppChooser files
- Applied clang-format to all DTC and enum headers across modules
- Removed coordTransTests from CommonUnitTestsPlaceholder (moved to tests/)

Cosmetic changes only, no functional modifications.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
torstenandCopilot committed 2026-08-19 14:46:29 +02:00
1 parent 1881d68aef
commit d6b6ffce7c
848 files changed
+89305 -100020

No files matched your search

+62 -86
View File
@@ -1,19 +1,15 @@
#include "data_topic_tests.h"
#include <NGLLogger/NGLLoggerBootstrap.h>
#include <DDS/QosProfile/DDS_DefaultQos.h>
#include <DDS/DTS/generic_dts_impl.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 <QtTest/QTest>
#include <QVariant>
#include <NGLLogger/NGLLoggerBootstrap.h>
#include <QThread>
#include <QVariant>
#include <QtTest/QTest>
DataTopicTests::DataTopicTests() : m_domainParticipantPub(nullptr)
, m_domainParticipantSub(nullptr)
@@ -26,129 +22,109 @@ DataTopicTests::DataTopicTests() : m_domainParticipantPub(nullptr)
, m_dtcTestPart(nullptr)
, m_mainThreadId(QThread::currentThreadId())
.getNGLLogger("UnitTests.DataTopicTests")),
m_logger(NGL::NGLLoggerBootstrap::getLogger()) {
if (!DDS::QosProfile::setDefault())
ERROR_LOG(m_logger) << "Error setting default QoS from xml-file ";
m_logger(NGL::NGLLoggerBootstrap::getLogger())
{
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;
DEBUG_LOG(m_logger) << "Main thread ID is " << m_mainThreadId;
}
DataTopicTests::~DataTopicTests()
{
delete m_testPart;
delete m_dtcTestPart;
delete m_testPart;
delete m_subscriberListener;
delete m_dtcTestPart;
delete m_subscriberListener;
}
bool DataTopicTests::initPublisher()
{
m_domainParticipantPub =
dds::domain::DomainParticipant(m_domainId,
DDS::QosProfile::domainParticipantShm());
m_domainParticipantPub = dds::domain::DomainParticipant(m_domainId, DDS::QosProfile::domainParticipantShm());
dds::pub::qos::PublisherQos publisherQos = m_domainParticipantPub.default_publisher_qos();
dds::pub::qos::PublisherQos publisherQos = m_domainParticipantPub.default_publisher_qos();
QString partition = QString::fromStdString(IDL::exercisePartition(m_partitionId));
QString partition = QString::fromStdString(IDL::exercisePartition(m_partitionId));
dds::core::policy::Partition partitionQos;
partitionQos.name( { partition.toStdString() } );
publisherQos << partitionQos;
dds::core::policy::Partition partitionQos;
partitionQos.name({partition.toStdString()});
publisherQos << partitionQos;
DEBUG_LOG(m_logger) << "Publish on partition " << partition;
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);
m_ddsPublisher = dds::pub::Publisher(m_domainParticipantPub, publisherQos);
m_testPart = new DTS::TestParticipantImpl(m_domainParticipantPub, m_ddsPublisher);
return true;
return true;
}
bool DataTopicTests::write(const DdsUnitTests::TestParticipant &data)
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();
INFO_LOG(m_logger) << "Publish topic TestParticipant ";
DEBUG_LOG(m_logger) << "ParticipantId: " << data.location().participantId()
<< ", equipNo = " << data.location().equipNo();
return m_testPart->write(data);
return m_testPart->write(data);
}
bool DataTopicTests::initSubscriber()
{
DEBUG_LOG(m_logger) << "Initialisation DDS (Subscriber/Reader)";
DEBUG_LOG(m_logger) << "Initialisation DDS (Subscriber/Reader)";
m_domainParticipantSub =
dds::domain::DomainParticipant(m_domainId,
DDS::QosProfile::domainParticipantShm());
m_domainParticipantSub = dds::domain::DomainParticipant(m_domainId, DDS::QosProfile::domainParticipantShm());
dds::sub::qos::SubscriberQos subscriberQos = m_domainParticipantSub.default_subscriber_qos();
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::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;
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());
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 =
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); } );
m_dtcTestPart->setSubscriberCallback(
[this](const DdsUnitTests::TestParticipant& data, const dds::sub::SampleInfo& si) { processData(data, si); });
return true;
return true;
}
void DataTopicTests::deleteDTC()
{
delete m_dtcTestPart;
m_dtcTestPart = nullptr;
delete m_dtcTestPart;
m_dtcTestPart = nullptr;
}
void DataTopicTests::deleteSubscriber()
{
m_ddsSubscriber = nullptr;
delete m_subscriberListener;
m_subscriberListener = nullptr;
m_ddsSubscriber = nullptr;
delete m_subscriberListener;
m_subscriberListener = nullptr;
}
void DataTopicTests::processData(const DdsUnitTests::TestParticipant &instance, const dds::sub::SampleInfo &si)
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();
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();
DEBUG_LOG(m_logger) << "participantId: " << instance.location().participantId();
DEBUG_LOG(m_logger) << "equipNo: " << instance.location().equipNo();
m_receivedParticipantData = instance;
m_receivedParticipantData = instance;
QCOMPARE(m_mainThreadId, QThread::currentThreadId());
QCOMPARE(m_mainThreadId, QThread::currentThreadId());
emit testParticipantDataArrived();
emit testParticipantDataArrived();
}
+36 -42
View File
@@ -2,64 +2,58 @@
#pragma once
#include <QObject>
#include <DDS/Generic/subscriber_listener.h>
#include <DdsUnitTests/ddsut_dtc_types.h>
#include <DdsUnitTests/ddsut_dts_types.h>
#include <QObject>
namespace NGL {
class INGLLogger;
namespace NGL
{
class INGLLogger;
}
class DataTopicTests : public QObject
{
Q_OBJECT
public:
DataTopicTests();
virtual ~DataTopicTests();
Q_OBJECT
public:
DataTopicTests();
virtual ~DataTopicTests();
bool initPublisher();
bool initSubscriber();
bool initPublisher();
bool initSubscriber();
bool write(const DdsUnitTests::TestParticipant &data);
bool write(const DdsUnitTests::TestParticipant& data);
DdsUnitTests::TestParticipant getReceivedParticipantData() const { return m_receivedParticipantData; }
void deleteDTC();
void deleteSubscriber();
DdsUnitTests::TestParticipant getReceivedParticipantData() const
{
return m_receivedParticipantData;
}
protected:
NGL::INGLLogger &m_logger;
void processData(const DdsUnitTests::TestParticipant &instance, const dds::sub::SampleInfo &si);
void deleteDTC();
void deleteSubscriber();
Q_SIGNALS:
void testParticipantDataArrived();
protected:
NGL::INGLLogger& m_logger;
void processData(const DdsUnitTests::TestParticipant& instance, const dds::sub::SampleInfo& si);
private:
dds::domain::DomainParticipant m_domainParticipantPub;
dds::domain::DomainParticipant m_domainParticipantSub;
int m_domainId;
int m_partitionId;
Q_SIGNALS:
void testParticipantDataArrived();
dds::pub::Publisher m_ddsPublisher;
DTS::TestParticipant *m_testPart;
private:
dds::domain::DomainParticipant m_domainParticipantPub;
dds::domain::DomainParticipant m_domainParticipantSub;
int m_domainId;
int m_partitionId;
dds::sub::Subscriber m_ddsSubscriber;
DDSGeneric::SubscriberListener *m_subscriberListener;
dds::pub::Publisher m_ddsPublisher;
DTS::TestParticipant* m_testPart;
DTC::SampleInfo::TestParticipant *m_dtcTestPart;
dds::sub::Subscriber m_ddsSubscriber;
DDSGeneric::SubscriberListener* m_subscriberListener;
Qt::HANDLE m_mainThreadId;
DdsUnitTests::TestParticipant m_receivedParticipantData;
DTC::SampleInfo::TestParticipant* m_dtcTestPart;
Qt::HANDLE m_mainThreadId;
DdsUnitTests::TestParticipant m_receivedParticipantData;
};
+54 -60
View File
@@ -1,102 +1,96 @@
#include "data_topic_tests_main.h"
#include "data_topic_tests.h"
#include <Lts/Common/ProjectConfig/project_defines.h>
#include <QtTest/QTest>
#include <nglapplication/nglcoreapplication.h>
#include <NGLLogger/NGLLoggerBootstrap.h>
#include <QtTest/QTest>
#include <nglapplication/nglcoreapplication.h>
int main(int argc, char *argv[])
int main(int argc, char* argv[])
{
NGLCoreApplication app(argc, argv);
app.createLogger("UnitTests", "log4cxx_ddsUnitTests.props");
NGLCoreApplication app(argc, argv);
app.createLogger("UnitTests", "log4cxx_ddsUnitTests.props");
DataTopicTestsMain *tc = new DataTopicTestsMain;
DataTopicTestsMain* tc = new DataTopicTestsMain;
int retCode = QTest::qExec(tc, argc, argv);
int retCode = QTest::qExec(tc, argc, argv);
delete tc;
delete tc;
return retCode;
return retCode;
}
DataTopicTestsMain::DataTopicTestsMain()
: m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("UnitTests.DataTopicTestsMain"))
: m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("UnitTests.DataTopicTestsMain"))
{
}
void DataTopicTestsMain::initTestCase()
{
DEBUG_LOG(m_logger) <<"DataTopicTestsMain: initTestCase";
DEBUG_LOG(m_logger) << "DataTopicTestsMain: initTestCase";
m_dtTest = new DataTopicTests();
QVERIFY2(m_dtTest, "Initialisation of DataTopicTest failed");
QVERIFY2(m_dtTest->initPublisher(), "Initialisation Publisher failed");
QVERIFY2(m_dtTest->initSubscriber(), "Initialisation Subscriber failed");
m_dtTest = new DataTopicTests();
QVERIFY2(m_dtTest, "Initialisation of DataTopicTest failed");
QVERIFY2(m_dtTest->initPublisher(), "Initialisation Publisher failed");
QVERIFY2(m_dtTest->initSubscriber(), "Initialisation Subscriber failed");
m_participantDataArrivedSpy = new QSignalSpy(m_dtTest, &DataTopicTests::testParticipantDataArrived);
m_participantDataArrivedSpy = new QSignalSpy(m_dtTest, &DataTopicTests::testParticipantDataArrived);
}
void DataTopicTestsMain::publishTestCase()
{
DEBUG_LOG(m_logger) <<"DataTopicTestsMain: publish TestParticipant";
m_sentParticipantData.location().participantId(100);
m_sentParticipantData.location().equipNo(1010);
m_sentParticipantData.testId(100);
QVERIFY2(m_dtTest->write(m_sentParticipantData), "Publishing Topic TestParticipant failed");
{
DEBUG_LOG(m_logger) << "DataTopicTestsMain: publish TestParticipant";
DEBUG_LOG(m_logger) <<"DataTopicTestsMain: publish ready";
m_sentParticipantData.location().participantId(100);
m_sentParticipantData.location().equipNo(1010);
m_sentParticipantData.testId(100);
QVERIFY2(m_dtTest->write(m_sentParticipantData), "Publishing Topic TestParticipant failed");
DEBUG_LOG(m_logger) << "DataTopicTestsMain: publish ready";
}
void DataTopicTestsMain::subscribeTestCase()
{
DEBUG_LOG(m_logger) << "IN subscribeTestCase";
DEBUG_LOG(m_logger) << "IN subscribeTestCase";
QTRY_COMPARE(m_participantDataArrivedSpy->count(), 1);
QTRY_COMPARE(m_participantDataArrivedSpy->count(), 1);
DdsUnitTests::TestParticipant recvPartiticpant = m_dtTest->getReceivedParticipantData();
DdsUnitTests::TestParticipant recvPartiticpant = m_dtTest->getReceivedParticipantData();
QCOMPARE(recvPartiticpant.location().participantId(), m_sentParticipantData.location().participantId());
QCOMPARE(recvPartiticpant.location().equipNo(), m_sentParticipantData.location().equipNo());
QCOMPARE(recvPartiticpant.location().participantId(), m_sentParticipantData.location().participantId());
QCOMPARE(recvPartiticpant.location().equipNo(), m_sentParticipantData.location().equipNo());
}
void DataTopicTestsMain::deleteDataReaderTestCase()
{
DdsUnitTests::TestParticipant data;
for (int i = 0; i < 1000; ++i)
{
m_sentParticipantData.id(i);
m_dtTest->write(m_sentParticipantData);
}
m_dtTest->deleteDTC();
for (int i = 0; i < 1000; ++i)
{
m_sentParticipantData.id(i);
m_dtTest->write(m_sentParticipantData);
}
m_dtTest->deleteSubscriber();
for (int i = 0; i < 1000; ++i)
{
m_sentParticipantData.id(i);
m_dtTest->write(m_sentParticipantData);
}
DdsUnitTests::TestParticipant data;
for (int i = 0; i < 1000; ++i)
{
m_sentParticipantData.id(i);
m_dtTest->write(m_sentParticipantData);
}
m_dtTest->deleteDTC();
for (int i = 0; i < 1000; ++i)
{
m_sentParticipantData.id(i);
m_dtTest->write(m_sentParticipantData);
}
m_dtTest->deleteSubscriber();
for (int i = 0; i < 1000; ++i)
{
m_sentParticipantData.id(i);
m_dtTest->write(m_sentParticipantData);
}
}
void DataTopicTestsMain::cleanupTestCase()
{
DEBUG_LOG(m_logger) <<"DataTopicTestsMain: cleanupTestCase";
delete m_dtTest; m_dtTest = nullptr;
delete m_participantDataArrivedSpy; m_participantDataArrivedSpy = nullptr;
DEBUG_LOG(m_logger) << "DataTopicTestsMain: cleanupTestCase";
delete m_dtTest;
m_dtTest = nullptr;
delete m_participantDataArrivedSpy;
m_participantDataArrivedSpy = nullptr;
}
+17 -18
View File
@@ -2,37 +2,36 @@
#pragma once
#include <DdsUnitTests/ddsut_dtc_types.h>
#include <QObject>
#include <QSignalSpy>
#include <DdsUnitTests/ddsut_dtc_types.h>
namespace NGL
{
class INGLLogger;
class INGLLogger;
}
class DataTopicTests;
class DataTopicTestsMain : public QObject
{
Q_OBJECT
Q_OBJECT
public:
DataTopicTestsMain();
public:
DataTopicTestsMain();
private Q_SLOTS:
void initTestCase();
void publishTestCase();
void subscribeTestCase();
void deleteDataReaderTestCase();
void cleanupTestCase();
private Q_SLOTS:
void initTestCase();
void publishTestCase();
void subscribeTestCase();
void deleteDataReaderTestCase();
void cleanupTestCase();
protected:
protected:
NGL::INGLLogger& m_logger;
NGL::INGLLogger &m_logger;
private:
DdsUnitTests::TestParticipant m_sentParticipantData;
QSignalSpy *m_participantDataArrivedSpy = nullptr;
DataTopicTests *m_dtTest = nullptr;
private:
DdsUnitTests::TestParticipant m_sentParticipantData;
QSignalSpy* m_participantDataArrivedSpy = nullptr;
DataTopicTests* m_dtTest = nullptr;
};
+151 -167
View File
@@ -1,256 +1,240 @@
#include "function_topic_tests.h"
#include <Lts/Common/ProjectConfig/project_defines.h>
#include <DDS/DDSConnector/subscriber.h>
#include <DDS/DDSConnector/publisher.h>
#include <QtTest/QTest>
#include <nglapplication/nglcoreapplication.h>
#include <DDS/DDSConnector/subscriber.h>
#include <Lts/Common/ProjectConfig/project_defines.h>
#include <NGLLogger/INGLLogger.h>
#include <QtTest/QTest>
#include <nglapplication/nglcoreapplication.h>
int main(int argc, char *argv[])
int main(int argc, char* argv[])
{
NGLCoreApplication app(argc, argv);
app.createLogger("UnitTests", "log4cxx_ddsUnitTests.props");
NGLCoreApplication app(argc, argv);
app.createLogger("UnitTests", "log4cxx_ddsUnitTests.props");
FunctionTopicTests *tc = new FunctionTopicTests;
FunctionTopicTests* tc = new FunctionTopicTests;
int retCode = QTest::qExec(tc, argc, argv);
int retCode = QTest::qExec(tc, argc, argv);
delete tc;
delete tc;
return retCode;
return retCode;
}
FunctionTopicTests::FunctionTopicTests() : m_mainThreadId(QThread::currentThreadId())
.getNGLLogger("UnitTests.FunctionTopicTests")),
m_logger(NGL::NGLLoggerBootstrap::getLogger()) {
qRegisterMetaType<DdsUnitTests::FunctionReply>("DdsUnitTests::FunctionReply");
qRegisterMetaType<DdsUnitTests::FunctionReplyWithState>("DdsUnitTests::FunctionReplyWithState");
m_logger(NGL::NGLLoggerBootstrap::getLogger())
{
qRegisterMetaType<DdsUnitTests::FunctionReply>("DdsUnitTests::FunctionReply");
qRegisterMetaType<DdsUnitTests::FunctionReplyWithState>("DdsUnitTests::FunctionReplyWithState");
}
void FunctionTopicTests::initTestCase()
{
DEBUG_LOG(m_logger) <<"FunctionTopicTests: initTestCase";
DEBUG_LOG(m_logger) << "FunctionTopicTests: initTestCase";
const int domainId = 0;
const int domainId = 0;
m_ddsConnectorClient = std::make_shared<DDSConnector::DdsConnector>(domainId, IDL::PartitionType::Global);
QVERIFY2(m_ddsConnectorClient->init(), "Initialisation of ddsconnector (Client) failed");
m_ddsConnectorClient->initSubscriber();
QVERIFY2(m_ddsConnectorClient->getSubscriber(), "Initialisation of Subscriber (DdsConnectorClient) failed");
m_ddsConnectorClient->initPublisher();
QVERIFY2(m_ddsConnectorClient->getPublisher(), "Initialisation of Publisher (DdsConnectorClient) failed");
m_ddsConnectorClient = std::make_shared<DDSConnector::DdsConnector>(domainId, IDL::PartitionType::Global);
QVERIFY2(m_ddsConnectorClient->init(), "Initialisation of ddsconnector (Client) failed");
m_ddsConnectorClient->initSubscriber();
QVERIFY2(m_ddsConnectorClient->getSubscriber(), "Initialisation of Subscriber (DdsConnectorClient) failed");
m_ddsConnectorClient->initPublisher();
QVERIFY2(m_ddsConnectorClient->getPublisher(), "Initialisation of Publisher (DdsConnectorClient) failed");
m_ddsConnectorServer = std::make_shared<DDSConnector::DdsConnector>(domainId, IDL::PartitionType::Global);
QVERIFY2(m_ddsConnectorServer->init(), "Initialisation of ddsconnector (Server) failed");
m_ddsConnectorServer->initSubscriber();
QVERIFY2(m_ddsConnectorServer->getSubscriber(), "Initialisation of Subscriber (DdsConnectorServer) failed");
m_ddsConnectorServer->initPublisher();
QVERIFY2(m_ddsConnectorServer->getPublisher(), "Initialisation of Publisher (DdsConnectorServer) failed");
m_ddsConnectorServer = std::make_shared<DDSConnector::DdsConnector>(domainId, IDL::PartitionType::Global);
QVERIFY2(m_ddsConnectorServer->init(), "Initialisation of ddsconnector (Server) failed");
m_ddsConnectorServer->initSubscriber();
QVERIFY2(m_ddsConnectorServer->getSubscriber(), "Initialisation of Subscriber (DdsConnectorServer) failed");
m_ddsConnectorServer->initPublisher();
QVERIFY2(m_ddsConnectorServer->getPublisher(), "Initialisation of Publisher (DdsConnectorServer) failed");
}
void FunctionTopicTests::initFTSTestCase()
{
m_fts.reset(m_ddsConnectorServer->createFTS<FTS::FunctionTopicTest>());
QVERIFY2(m_fts.get(), "Initialisation of FTS Replier failed");
m_fts->setSubscriberCallback([this](const rti::core::SampleIdentity &identity, const DdsUnitTests::FunctionRequest &request) { this->onFunctionTopicRequest(identity, request);});
m_ftsWS.reset(m_ddsConnectorServer->createFTS<FTS::FunctionTopicTestWithState>());
QVERIFY2(m_ftsWS.get(), "Initialisation of FTS Replier failed");
m_ftsWS->setSubscriberCallback([this](const rti::core::SampleIdentity &identity, const DdsUnitTests::FunctionRequestWithState &request) { this->onFunctionTopicRequest(identity, request);});
m_fts.reset(m_ddsConnectorServer->createFTS<FTS::FunctionTopicTest>());
QVERIFY2(m_fts.get(), "Initialisation of FTS Replier failed");
m_fts->setSubscriberCallback(
[this](const rti::core::SampleIdentity& identity, const DdsUnitTests::FunctionRequest& request) {
this->onFunctionTopicRequest(identity, request);
});
m_ftsWS.reset(m_ddsConnectorServer->createFTS<FTS::FunctionTopicTestWithState>());
QVERIFY2(m_ftsWS.get(), "Initialisation of FTS Replier failed");
m_ftsWS->setSubscriberCallback(
[this](const rti::core::SampleIdentity& identity, const DdsUnitTests::FunctionRequestWithState& request) {
this->onFunctionTopicRequest(identity, request);
});
}
void FunctionTopicTests::initFTCTestCase()
{
m_ftc.reset(m_ddsConnectorClient->createFTC<FTC::FunctionTopicTest>(this));
QVERIFY2(m_ftc.get(), "Initialisation of FTC Requester failed");
m_ftcWS.reset(m_ddsConnectorClient->createFTC<FTC::FunctionTopicTestWithState>(this));
QVERIFY2(m_ftc.get(), "Initialisation of FTC Requester failed");
m_ftc.reset(m_ddsConnectorClient->createFTC<FTC::FunctionTopicTest>(this));
QVERIFY2(m_ftc.get(), "Initialisation of FTC Requester failed");
m_ftcWS.reset(m_ddsConnectorClient->createFTC<FTC::FunctionTopicTestWithState>(this));
QVERIFY2(m_ftc.get(), "Initialisation of FTC Requester failed");
}
void FunctionTopicTests::requestTestCase1()
{
requestWithState();
QCOMPARE(m_ddsConnectorServer->getWaitSetHandler()->attachedConditionCount(), 3);
requestWithState();
QCOMPARE(m_ddsConnectorServer->getWaitSetHandler()->attachedConditionCount(), 3);
}
requestWithState();
QCOMPARE(m_ddsConnectorServer->getWaitSetHandler()->attachedConditionCount(), 3);
requestWithState();
QCOMPARE(m_ddsConnectorServer->getWaitSetHandler()->attachedConditionCount(), 3);
}
void FunctionTopicTests::requestWithState()
{
QSignalSpy spyRequest(this, &FunctionTopicTests::functionTopicRequestFinished);
QSignalSpy spyReply(this, &FunctionTopicTests::functionTopicReply);
DEBUG_LOG(m_logger) <<"FunctionTopicTests: request";
QSignalSpy spyRequest(this, &FunctionTopicTests::functionTopicRequestFinished);
QSignalSpy spyReply(this, &FunctionTopicTests::functionTopicReply);
DdsUnitTests::FunctionRequestWithState data;
DEBUG_LOG(m_logger) << "FunctionTopicTests: request";
data.id(1);
data.info(std::string("Test request"));
data.value(1000.0);
DdsUnitTests::FunctionRequestWithState data;
int uniqueId = 0;
bool bRet = m_ftcWS->requestDataClassic(data,
SLOT(slotRequestedData(DdsUnitTests::FunctionTopicTestWithStateReply,int,bool)),
SLOT(slotRequestedDataError(int,int,int)),
uniqueId);
data.id(1);
data.info(std::string("Test request"));
data.value(1000.0);
QVERIFY2(bRet, "Could not request data!");
int uniqueId = 0;
bool bRet = m_ftcWS->requestDataClassic(
data, SLOT(slotRequestedData(DdsUnitTests::FunctionTopicTestWithStateReply, int, bool)),
SLOT(slotRequestedDataError(int, int, int)), uniqueId);
QTRY_COMPARE(spyRequest.count(), 1);
QTRY_COMPARE(spyReply.count(), 2);
QVERIFY2(bRet, "Could not request data!");
QTRY_COMPARE(spyRequest.count(), 1);
QTRY_COMPARE(spyReply.count(), 2);
}
void FunctionTopicTests::requestTestCase2()
{
QSignalSpy spyRequest(this, &FunctionTopicTests::functionTopicRequestFinished);
QSignalSpy spyReply(this, &FunctionTopicTests::functionTopicReply);
DEBUG_LOG(m_logger) <<"FunctionTopicTests: request";
QSignalSpy spyRequest(this, &FunctionTopicTests::functionTopicRequestFinished);
QSignalSpy spyReply(this, &FunctionTopicTests::functionTopicReply);
DdsUnitTests::FunctionRequest data;
DEBUG_LOG(m_logger) << "FunctionTopicTests: request";
data.id(1);
data.info(std::string("Test request"));
data.value(1000.0);
DdsUnitTests::FunctionRequest data;
int uniqueId = 0;
bool bRet = m_ftc->requestDataClassic(data,
SLOT(slotRequestedData(DdsUnitTests::FunctionTopicTestReply,int,bool)),
SLOT(slotRequestedDataError(int,int,int)),
uniqueId);
data.id(1);
data.info(std::string("Test request"));
data.value(1000.0);
QVERIFY2(bRet, "Could not request data!");
int uniqueId = 0;
bool bRet =
m_ftc->requestDataClassic(data, SLOT(slotRequestedData(DdsUnitTests::FunctionTopicTestReply, int, bool)),
SLOT(slotRequestedDataError(int, int, int)), uniqueId);
QTRY_COMPARE(spyRequest.count(), 1);
QTRY_COMPARE(spyReply.count(), 1);
QVERIFY2(bRet, "Could not request data!");
QTRY_COMPARE(spyRequest.count(), 1);
QTRY_COMPARE(spyReply.count(), 1);
}
void FunctionTopicTests::cleanupTestCase()
{
DEBUG_LOG(m_logger) <<"FunctionTopicTests: cleanupTestCase";
DEBUG_LOG(m_logger) << "FunctionTopicTests: cleanupTestCase";
m_fts = nullptr;
m_ftc = nullptr;
m_ftsWS = nullptr;
m_ftcWS = nullptr;
m_ddsConnectorServer = nullptr;
m_ddsConnectorClient = nullptr;
m_fts = nullptr;
m_ftc = nullptr;
m_ftsWS = nullptr;
m_ftcWS = nullptr;
m_ddsConnectorServer = nullptr;
m_ddsConnectorClient = nullptr;
}
void FunctionTopicTests::onFunctionTopicRequest(const rti::core::SampleIdentity &sampleId,
const DdsUnitTests::FunctionRequestWithState &request)
void FunctionTopicTests::onFunctionTopicRequest(const rti::core::SampleIdentity& sampleId,
const DdsUnitTests::FunctionRequestWithState& request)
{
QCOMPARE(m_mainThreadId, QThread::currentThreadId());
QCOMPARE(m_mainThreadId, QThread::currentThreadId());
INFO_LOG(m_logger) << "Got function topic request (with status member)";
m_requestTopicWithState = request;
QCOMPARE(m_requestTopicWithState.id(), 1);
QCOMPARE(m_requestTopicWithState.info().get(), std::string("Test request"));
QCOMPARE(m_requestTopicWithState.value(), 1000.0);
INFO_LOG(m_logger) << "Got function topic request (with status member)";
m_requestTopicWithState = request;
QCOMPARE(m_requestTopicWithState.id(), 1);
QCOMPARE(m_requestTopicWithState.info().get(), std::string("Test request"));
QCOMPARE(m_requestTopicWithState.value(), 1000.0);
DdsUnitTests::FunctionReplyWithState reply;
DdsUnitTests::FunctionReplyWithState reply;
DEBUG_LOG(m_logger) << "Send sample with status REPLY_COMPLETED";
reply.id(1);
reply.errorString("Hello");
reply.replyState(Core::FtReplyState::Completed);
DEBUG_LOG(m_logger) << "Send sample with status REPLY_COMPLETED";
reply.id(1);
reply.errorString("Hello");
reply.replyState(Core::FtReplyState::Completed);
bool bRet = m_ftsWS->sendReply(sampleId, reply);
QVERIFY2(bRet, "Sending Reply failed");
bool bRet = m_ftsWS->sendReply(sampleId, reply);
QVERIFY2(bRet, "Sending Reply failed");
emit functionTopicRequestFinished();
emit functionTopicRequestFinished();
}
void FunctionTopicTests::onFunctionTopicRequest(const rti::core::SampleIdentity &sampleId,
const DdsUnitTests::FunctionRequest &request)
void FunctionTopicTests::onFunctionTopicRequest(const rti::core::SampleIdentity& sampleId,
const DdsUnitTests::FunctionRequest& request)
{
QCOMPARE(m_mainThreadId, QThread::currentThreadId());
QCOMPARE(m_mainThreadId, QThread::currentThreadId());
INFO_LOG(m_logger) << "Got function topic request (without status member)";
INFO_LOG(m_logger) << "Got function topic request (without status member)";
m_requestTopic = request;
m_requestTopic = request;
DdsUnitTests::FunctionReply reply;
DdsUnitTests::FunctionReply reply;
reply.id(2);
reply.errorString("What?");
reply.id(2);
reply.errorString("What?");
bool bRet = m_fts->sendReply(sampleId, reply);
QVERIFY2(bRet, "Sending Reply failed");
bool bRet = m_fts->sendReply(sampleId, reply);
QVERIFY2(bRet, "Sending Reply failed");
emit functionTopicRequestFinished();
emit functionTopicRequestFinished();
}
void FunctionTopicTests::slotRequestedData(const DdsUnitTests::FunctionTopicTestWithStateReply &reply,
int seqNo, bool bFinished)
void FunctionTopicTests::slotRequestedData(const DdsUnitTests::FunctionTopicTestWithStateReply& reply, int seqNo,
bool bFinished)
{
Q_UNUSED(seqNo);
QCOMPARE(m_mainThreadId, QThread::currentThreadId());
Q_UNUSED(seqNo);
QCOMPARE(m_mainThreadId, QThread::currentThreadId());
INFO_LOG(m_logger) << "Got reply from FTS: " << reply.replyState();
INFO_LOG(m_logger) << "Got reply from FTS: " << reply.replyState();
m_replyTopicWithState = reply;
m_replyTopicWithState = reply;
if (m_replyTopicWithState.replyState() == Core::FtReplyState::InProgress)
{
QVERIFY(!bFinished);
QCOMPARE(m_replyTopicWithState.id(), 0);
}
else
{
if (m_replyTopicWithState.replyState() == Core::FtReplyState::InProgress)
{
QVERIFY(!bFinished);
QCOMPARE(m_replyTopicWithState.id(), 0);
}
else
{
QVERIFY(bFinished);
QCOMPARE(m_replyTopicWithState.id(), 1);
QCOMPARE(m_replyTopicWithState.errorString(), std::string("Hello"));
QCOMPARE(m_replyTopicWithState.replyState().underlying(), Core::FtReplyState::Completed);
}
emit functionTopicReply();
}
void FunctionTopicTests::slotRequestedData(const DdsUnitTests::FunctionTopicTestReply& reply, int seqNo, bool bFinished)
{
Q_UNUSED(seqNo);
QVERIFY(bFinished);
QCOMPARE(m_replyTopicWithState.id(), 1);
QCOMPARE(m_replyTopicWithState.errorString(), std::string("Hello"));
QCOMPARE(m_replyTopicWithState.replyState().underlying(), Core::FtReplyState::Completed);
}
emit functionTopicReply();
QCOMPARE(m_mainThreadId, QThread::currentThreadId());
m_replyTopic = reply;
QCOMPARE(m_replyTopic.id(), 2);
QCOMPARE(m_replyTopic.errorString(), std::string("What?"));
emit functionTopicReply();
}
void FunctionTopicTests::slotRequestedData(const DdsUnitTests::FunctionTopicTestReply &reply,
int seqNo, bool bFinished)
{
Q_UNUSED(seqNo);
QVERIFY(bFinished);
QCOMPARE(m_mainThreadId, QThread::currentThreadId());
m_replyTopic = reply;
QCOMPARE(m_replyTopic.id(), 2);
QCOMPARE(m_replyTopic.errorString(), std::string("What?"));
emit functionTopicReply();
}
void FunctionTopicTests::slotRequestedDataError(int reason, int seqNo, int requestId)
{
Q_UNUSED(seqNo);
Q_UNUSED(requestId);
QFAIL(qPrintable(QStringLiteral("Error when trying to request data: %1").arg(reason)));
Q_UNUSED(seqNo);
Q_UNUSED(requestId);
QFAIL(qPrintable(QStringLiteral("Error when trying to request data: %1").arg(reason)));
}
+47 -49
View File
@@ -2,72 +2,70 @@
#pragma once
#include <DDS/DDSConnector/dds_connector.h>
#include <DDS/FTC/generic_ftc_impl.h>
#include <DDS/FTS/generic_fts_impl.h>
#include <DdsUnitTests/ddsut.hpp>
#include <DdsUnitTests/ddsut_ftc_types.h>
#include <DdsUnitTests/ddsut_fts_types.h>
#include <QObject>
#include <QSignalSpy>
#include <QThread>
#include <DdsUnitTests/ddsut.hpp>
#include <DdsUnitTests/ddsut_ftc_types.h>
#include <DdsUnitTests/ddsut_fts_types.h>
#include <DDS/DDSConnector/dds_connector.h>
#include <DDS/FTC/generic_ftc_impl.h>
#include <DDS/FTS/generic_fts_impl.h>
namespace NGL
{
class INGLLogger;
class INGLLogger;
}
class FunctionTopicTests : public QObject
{
Q_OBJECT
Q_OBJECT
public:
FunctionTopicTests();
public:
FunctionTopicTests();
private Q_SLOTS:
void initTestCase();
void initFTSTestCase();
void initFTCTestCase();
void requestTestCase1();
void requestTestCase2();
void cleanupTestCase();
private Q_SLOTS:
void initTestCase();
void initFTSTestCase();
void initFTCTestCase();
void requestTestCase1();
void requestTestCase2();
void cleanupTestCase();
Q_SIGNALS:
void functionTopicRequestFinished();
void functionTopicReply();
protected Q_SLOTS:
void slotRequestedData(const DdsUnitTests::FunctionTopicTestReply &reply, int seqNo, bool bFinished);
void slotRequestedData(const DdsUnitTests::FunctionTopicTestWithStateReply &reply, int seqNo, bool bFinished);
void slotRequestedDataError(int reason, int seqNo, int requestId);
void onFunctionTopicRequest(const rti::core::SampleIdentity &sampleId,
const DdsUnitTests::FunctionRequest &request);
void onFunctionTopicRequest(const rti::core::SampleIdentity &sampleId,
const DdsUnitTests::FunctionRequestWithState &request);
Q_SIGNALS:
void functionTopicRequestFinished();
void functionTopicReply();
protected Q_SLOTS:
private:
NGL::INGLLogger &m_logger;
void requestWithState();
private:
NGL::INGLLogger &m_logger;
std::unique_ptr<FTS::FunctionTopicTest> m_fts;
std::unique_ptr<FTS::FunctionTopicTestWithState> m_ftsWS;
std::unique_ptr<FTC::FunctionTopicTest> m_ftc;
std::unique_ptr<FTC::FunctionTopicTestWithState> m_ftcWS;
void slotRequestedData(const DdsUnitTests::FunctionTopicTestReply& reply, int seqNo, bool bFinished);
void slotRequestedData(const DdsUnitTests::FunctionTopicTestWithStateReply& reply, int seqNo, bool bFinished);
void slotRequestedDataError(int reason, int seqNo, int requestId);
std::shared_ptr<DDSConnector::DdsConnector> m_ddsConnectorClient;
std::shared_ptr<DDSConnector::DdsConnector> m_ddsConnectorServer;
void onFunctionTopicRequest(const rti::core::SampleIdentity& sampleId,
const DdsUnitTests::FunctionRequest& request);
void onFunctionTopicRequest(const rti::core::SampleIdentity& sampleId,
const DdsUnitTests::FunctionRequestWithState& request);
private:
NGL::INGLLogger& m_logger;
void requestWithState();
DdsUnitTests::FunctionRequest m_requestTopic;
DdsUnitTests::FunctionReply m_replyTopic;
private:
NGL::INGLLogger& m_logger;
std::unique_ptr<FTS::FunctionTopicTest> m_fts;
std::unique_ptr<FTS::FunctionTopicTestWithState> m_ftsWS;
DdsUnitTests::FunctionRequestWithState m_requestTopicWithState;
DdsUnitTests::FunctionReplyWithState m_replyTopicWithState;
std::unique_ptr<FTC::FunctionTopicTest> m_ftc;
std::unique_ptr<FTC::FunctionTopicTestWithState> m_ftcWS;
Qt::HANDLE m_mainThreadId;
std::shared_ptr<DDSConnector::DdsConnector> m_ddsConnectorClient;
std::shared_ptr<DDSConnector::DdsConnector> m_ddsConnectorServer;
DdsUnitTests::FunctionRequest m_requestTopic;
DdsUnitTests::FunctionReply m_replyTopic;
DdsUnitTests::FunctionRequestWithState m_requestTopicWithState;
DdsUnitTests::FunctionReplyWithState m_replyTopicWithState;
Qt::HANDLE m_mainThreadId;
};
+146 -153
View File
@@ -1,226 +1,219 @@
#include "generic_data_tests.h"
#include <Lts/Common/ProjectConfig/project_defines.h>
#include <DDS/Generic/generic_data_reader.h>
#include <DDS/Generic/generic_data_writer.h>
#include <QtTest/QTest>
#include <nglapplication/nglcoreapplication.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[])
int main(int argc, char* argv[])
{
NGLCoreApplication app(argc, argv);
app.createLogger("UnitTests", "log4cxx_ddsUnitTests.props");
NGLCoreApplication app(argc, argv);
app.createLogger("UnitTests", "log4cxx_ddsUnitTests.props");
GenericDataTests *tc = new GenericDataTests;
GenericDataTests* tc = new GenericDataTests;
int retCode = QTest::qExec(tc, argc, argv);
int retCode = QTest::qExec(tc, argc, argv);
delete tc;
delete tc;
return retCode;
return retCode;
}
GenericDataTests::GenericDataTests()
: m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("UnitTests.GenericDataTests"))
: m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("UnitTests.GenericDataTests"))
{
m_spatialData.equipNo(0);
m_testPart.location().equipNo(0);
m_testPart.location().participantId(0);
m_spatialData.equipNo(0);
m_testPart.location().equipNo(0);
m_testPart.location().participantId(0);
}
void GenericDataTests::initTestCase()
{
DEBUG_LOG(m_logger) <<"GenericDataTests: initTestCase";
DEBUG_LOG(m_logger) << "GenericDataTests: initTestCase";
m_init = new Initialisation();
m_init = new Initialisation();
int domainId = 0;
int exerciseId = 2;
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, "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");
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_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);
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_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");
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";
DEBUG_LOG(m_logger) << "GenericDataTests: dataWriter";
DdsUnitTests::SpatialData data;
DdsUnitTests::SpatialData data;
data.participantId(100);
data.equipNo(999);
data.gpsPosition().lon(70000);
data.gpsPosition().lat(90000);
data.gpsPosition().z(10);
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.orientation().heave(10);
data.orientation().pitch(10);
data.orientation().roll(10);
data.velocity().x(10);
data.velocity().y(2);
data.velocity().z(1);
data.velocity().x(10);
data.velocity().y(2);
data.velocity().z(1);
data.changedAt(11111);
data.changedAt(11111);
QVERIFY2(m_dataWriterSd->write(data), "Publishing Topic (SpatialData) failed");
QVERIFY2(m_dataWriterSd->write(data), "Publishing Topic (SpatialData) failed");
DdsUnitTests::TestParticipant allData;
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.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);
allData.id(11111);
QVERIFY2(m_dataWriter->write(allData), "Publishing Topic (TestParticipant) failed");
QVERIFY2(m_dataWriter->write(allData), "Publishing Topic (TestParticipant) failed");
}
void GenericDataTests::dataReaderTestCase()
{
DEBUG_LOG(m_logger) << "GenericDataTests: dataReader";
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);
QTRY_COMPARE(m_spatialData.equipNo(), 999);
QCOMPARE(m_spatialData.changedAt(), 11111);
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);
QTRY_COMPARE(m_testPart.location().equipNo(), 999);
QCOMPARE(m_testPart.location().participantId(), 100);
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);
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);
}
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();
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)
void GenericDataTests::processData(const DdsUnitTests::SpatialData& data, DataModification modType)
{
DEBUG_LOG(m_logger) << "SpatialData: equipNo = " << data.equipNo() << " modType: " << modType;
m_spatialData = data;
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)
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;
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)
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); } );
}
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); });
}
}
+38 -42
View File
@@ -2,67 +2,63 @@
#pragma once
#include <QObject>
#include "initialisation.h"
#include <DDS/Generic/subscriber_listener.h>
#include <DdsUnitTests/ddsut_dtc_types.h>
#include <DdsUnitTests/ddsut_dts_types.h>
#include <DDS/Generic/subscriber_listener.h>
#include <LtsUtilsCore/data_modification_enum.h>
#include <QObject>
namespace NGL
{
class INGLLogger;
class INGLLogger;
}
class GenericDataTests : public DDSGeneric::SubscriberListenerCallback
{
Q_OBJECT
Q_OBJECT
public:
GenericDataTests();
public:
GenericDataTests();
private Q_SLOTS:
void initTestCase();
void initDRTestCase();
void initDWTestCase();
void dataWriterTestCase();
void dataReaderTestCase();
void deleteDataReaderTestCase();
void cleanupTestCase();
private Q_SLOTS:
void initTestCase();
void initDRTestCase();
void initDWTestCase();
void dataWriterTestCase();
void dataReaderTestCase();
void deleteDataReaderTestCase();
void cleanupTestCase();
protected:
NGL::INGLLogger &m_logger;
void droDataAvailable(const std::string &topicType, const std::string &topicName) override;
void noWriterAnymore(const std::string &topicType, const std::string &topicName) override
{
Q_UNUSED(topicType);
Q_UNUSED(topicName);
}
protected:
NGL::INGLLogger& m_logger;
void droDataAvailable(const std::string& topicType, const std::string& topicName) override;
void writerAvailable(const std::string &topicType, const std::string &topicName) override
{
Q_UNUSED(topicType);
Q_UNUSED(topicName);
}
void noWriterAnymore(const std::string& topicType, const std::string& topicName) override
{
Q_UNUSED(topicType);
Q_UNUSED(topicName);
}
void processData(const DdsUnitTests::TestParticipant &data, const dds::sub::SampleInfo &si);
void processData(const DdsUnitTests::SpatialData &data, DataModification modType);
void writerAvailable(const std::string& topicType, const std::string& topicName) override
{
Q_UNUSED(topicType);
Q_UNUSED(topicName);
}
private:
Initialisation *m_init = nullptr;
void processData(const DdsUnitTests::TestParticipant& data, const dds::sub::SampleInfo& si);
void processData(const DdsUnitTests::SpatialData& data, DataModification modType);
DTS::DwoTestParticipant *m_dataWriter = nullptr;
DTC::DroTestParticipant *m_dataReader = nullptr;
private:
Initialisation* m_init = nullptr;
DTS::DwoSpatialData *m_dataWriterSd = nullptr;
DTC::DroSpatialData *m_dataReaderSd = nullptr;
DTS::DwoTestParticipant* m_dataWriter = nullptr;
DTC::DroTestParticipant* m_dataReader = nullptr;
DdsUnitTests::SpatialData m_spatialData;
DdsUnitTests::TestParticipant m_testPart;
DTS::DwoSpatialData* m_dataWriterSd = nullptr;
DTC::DroSpatialData* m_dataReaderSd = nullptr;
DdsUnitTests::SpatialData m_spatialData;
DdsUnitTests::TestParticipant m_testPart;
};
+47 -58
View File
@@ -2,11 +2,9 @@
#include "initialisation.h"
#include <NGLLogger/NGLLoggerBootstrap.h>
#include <DDS/QosProfile/DDS_DefaultQos.h>
#include <Lts/Common/ProjectConfig/project_defines.h>
#include <NGLLogger/NGLLoggerBootstrap.h>
Initialisation::Initialisation() : m_domainParticipant(nullptr)
, m_domainParticipantSub(nullptr)
@@ -16,81 +14,72 @@ Initialisation::Initialisation() : m_domainParticipant(nullptr)
, m_ddsSubscriber(nullptr)
, m_subListener(new DDSGeneric::SubscriberListener)
.getNGLLogger("UnitTests.Initialisation")),
m_logger(NGL::NGLLoggerBootstrap::getLogger()) {
if (!DDS::QosProfile::setDefault())
ERROR_LOG(m_logger) << "Error setting default QoS from xml-file ";
m_logger(NGL::NGLLoggerBootstrap::getLogger())
{
if (!DDS::QosProfile::setDefault())
ERROR_LOG(m_logger) << "Error setting default QoS from xml-file ";
}
Initialisation::~Initialisation()
{
cleanupSubscriberListener();
m_ddsSubscriber = nullptr;
m_ddsPublisher = nullptr;
cleanupSubscriberListener();
m_ddsSubscriber = nullptr;
m_ddsPublisher = nullptr;
}
void Initialisation::cleanupSubscriberListener()
{
if (m_ddsSubscriber != nullptr && m_subListener != nullptr)
{
m_ddsSubscriber.listener(nullptr, dds::core::status::StatusMask::none());
delete m_subListener;
m_subListener = nullptr;
}
if (m_ddsSubscriber != nullptr && m_subListener != nullptr)
{
m_ddsSubscriber.listener(nullptr, dds::core::status::StatusMask::none());
delete m_subListener;
m_subListener = nullptr;
}
}
bool Initialisation::initDDS(int domainId, int exerciseId, PubSub pubsub)
{
if (m_domainParticipant == nullptr)
m_domainParticipant = dds::domain::DomainParticipant(domainId, DDS::QosProfile::domainParticipantShm());
if (m_domainParticipant == nullptr)
m_domainParticipant = dds::domain::DomainParticipant(domainId, DDS::QosProfile::domainParticipantShm());
if (pubsub == USE_PUBLISHER || pubsub == USE_PUB_SUB)
{
dds::pub::qos::PublisherQos publisherQos = m_domainParticipant.default_publisher_qos();
DEBUG_LOG(m_logger) << "Publish on partition " << IDL::exercisePartition(exerciseId);
dds::core::policy::Partition partitionQos;
partitionQos.name( { IDL::exercisePartition(exerciseId) } );
publisherQos << partitionQos;
m_ddsPublisher = dds::pub::Publisher(m_domainParticipant,
publisherQos);
}
if (pubsub == USE_SUBSCRIBER || pubsub == USE_PUB_SUB)
{
dds::domain::DomainParticipant domainPart = m_domainParticipant;
if ( domainPart == nullptr || m_domainParticipantSub == nullptr)
if (pubsub == USE_PUBLISHER || pubsub == USE_PUB_SUB)
{
m_domainParticipantSub = dds::domain::DomainParticipant(domainId, DDS::QosProfile::domainParticipantShm());
domainPart = m_domainParticipantSub;
dds::pub::qos::PublisherQos publisherQos = m_domainParticipant.default_publisher_qos();
DEBUG_LOG(m_logger) << "Publish on partition " << IDL::exercisePartition(exerciseId);
dds::core::policy::Partition partitionQos;
partitionQos.name({IDL::exercisePartition(exerciseId)});
publisherQos << partitionQos;
m_ddsPublisher = dds::pub::Publisher(m_domainParticipant, publisherQos);
}
dds::sub::qos::SubscriberQos subscriberQos = domainPart.default_subscriber_qos();
if (pubsub == USE_SUBSCRIBER || pubsub == USE_PUB_SUB)
{
dds::domain::DomainParticipant domainPart = m_domainParticipant;
if (domainPart == nullptr || m_domainParticipantSub == nullptr)
{
m_domainParticipantSub = dds::domain::DomainParticipant(domainId, DDS::QosProfile::domainParticipantShm());
domainPart = m_domainParticipantSub;
}
DEBUG_LOG(m_logger) << "Subsribing on partition " << IDL::exercisePartition(exerciseId);
dds::sub::qos::SubscriberQos subscriberQos = domainPart.default_subscriber_qos();
dds::core::policy::Partition partitionQos;
partitionQos.name( { IDL::exercisePartition(exerciseId) } );
subscriberQos << partitionQos;
DEBUG_LOG(m_logger) << "Subsribing on partition " << IDL::exercisePartition(exerciseId);
m_ddsSubscriber = dds::sub::Subscriber(domainPart,
subscriberQos,
m_subListener,
m_subListener->mask());
}
dds::core::policy::Partition partitionQos;
partitionQos.name({IDL::exercisePartition(exerciseId)});
subscriberQos << partitionQos;
if (m_domainId == 0)
m_domainId = domainId;
m_ddsSubscriber = dds::sub::Subscriber(domainPart, subscriberQos, m_subListener, m_subListener->mask());
}
if (m_exerciseId < 0)
m_exerciseId = exerciseId;
if (m_domainId == 0)
m_domainId = domainId;
return true;
if (m_exerciseId < 0)
m_exerciseId = exerciseId;
return true;
}
+42 -31
View File
@@ -5,43 +5,54 @@
#include <DDS/Generic/generic_base.h>
#include <DDS/Generic/subscriber_listener.h>
namespace NGL {
class INGLLogger;
namespace NGL
{
class INGLLogger;
}
class Initialisation
{
public:
Initialisation();
virtual ~Initialisation();
public:
Initialisation();
virtual ~Initialisation();
enum PubSub
{
USE_PUBLISHER = 1,
USE_SUBSCRIBER = 2,
USE_PUB_SUB = 4
};
enum PubSub { USE_PUBLISHER = 1, USE_SUBSCRIBER = 2, USE_PUB_SUB = 4 };
bool initDDS(int domainId, int exerciseId, PubSub pubsub = USE_PUBLISHER);
void cleanupSubscriberListener();
bool initDDS(int domainId, int exerciseId, PubSub pubsub = USE_PUBLISHER);
void cleanupSubscriberListener();
dds::domain::DomainParticipant getDomainParticipant() { return m_domainParticipant; }
dds::domain::DomainParticipant getDomainParticipantSub() { return m_domainParticipantSub != nullptr ? m_domainParticipantSub : m_domainParticipant; }
dds::pub::Publisher getDDSPublisher() { return m_ddsPublisher; }
dds::sub::Subscriber getDDSSubscriber() { return m_ddsSubscriber; }
DDSGeneric::SubscriberListener *getSubscriberListener() { return m_subListener; }
dds::domain::DomainParticipant getDomainParticipant()
{
return m_domainParticipant;
}
private:
NGL::INGLLogger &m_logger;
dds::domain::DomainParticipant m_domainParticipant;
dds::domain::DomainParticipant m_domainParticipantSub;
int m_domainId;
int m_exerciseId;
dds::pub::Publisher m_ddsPublisher;
dds::sub::Subscriber m_ddsSubscriber;
DDSGeneric::SubscriberListener *m_subListener;
dds::domain::DomainParticipant getDomainParticipantSub()
{
return m_domainParticipantSub != nullptr ? m_domainParticipantSub : m_domainParticipant;
}
dds::pub::Publisher getDDSPublisher()
{
return m_ddsPublisher;
}
dds::sub::Subscriber getDDSSubscriber()
{
return m_ddsSubscriber;
}
DDSGeneric::SubscriberListener* getSubscriberListener()
{
return m_subListener;
}
private:
NGL::INGLLogger& m_logger;
dds::domain::DomainParticipant m_domainParticipant;
dds::domain::DomainParticipant m_domainParticipantSub;
int m_domainId;
int m_exerciseId;
dds::pub::Publisher m_ddsPublisher;
dds::sub::Subscriber m_ddsSubscriber;
DDSGeneric::SubscriberListener* m_subListener;
};