qt-migration-legatus/qt5-before/dlbo/Lts/DDS/DdsUnitTests/generic_data_tests.cpp

/**
  * Unit test for DDS/Generic (Writer/Reader)
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "generic_data_tests.h"
#include <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 <NGLLogger/NGLLoggerBootstrap.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");

  // Callback fuer Listener setzen
  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";

  // Topic SpatialData
  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";

  // SpatialData
  QTRY_COMPARE(m_spatialData.equipNo(), 999);
  QCOMPARE(m_spatialData.changedAt(), 11111);
  // ParticipantInExercise
  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); } );
  }
}