Initial commit

Lts/Services/AreaEffectSimulation/ModuleTests/aes_test_explosion_area.cpp

@@ -0,0 +1,428 @@
+/**
+  * AES Function Topic Client test executable
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "aes_test_explosion_area.h"
+#include <QCoreApplication>
+#include <QTimer>
+#include <QTest>
+
+namespace AreaEffectSimulation
+{
+
+// must be in pdm.pdm_charge_type
+static const int s_ChargeTypeId1 = 371;
+static const int s_ChargeTypeId2 = 372;
+
+TestExplosionArea::TestExplosionArea(QObject *parent)
+  : TestBase("Test.ExplosionArea", parent)
+{}
+
+bool TestExplosionArea::init(int domainId, int exerciseId, int testId)
+{
+  if (!TestBase::init(domainId, exerciseId, testId))
+    return false;
+
+  m_dtc->waitForHistoricalDataExplosionArea();
+  m_eaData.id(-1);
+
+  connect(m_dtc.get(), &AreaEffectSimulation::Interface::Dtc::explosionAreaChanged,
+          this, &TestExplosionArea::explosionAreaChanged);
+  connect(m_dtc.get(), &AreaEffectSimulation::Interface::Dtc::triggeredImpactsChanged,
+          this, &TestExplosionArea::triggeredImpactsChanged);
+
+  return true;
+}
+
+bool TestExplosionArea::checkBaseData(const AreaEffectSimulation::ExplosionArea &a,
+                           const AreaEffectSimulation::ExplosionArea &b) const
+{
+  if (!checkAesItem(a, b))
+    return false;
+
+  if (a.area() != b.area())
+  {
+    WARNING_LOG(m_logger) << "area does not match: " << a.area() << " - " << b.area();
+    return false;
+  }
+  if (a.cannonCount() != b.cannonCount())
+  {
+    WARNING_LOG(m_logger) << "cannonCount does not match: " << a.cannonCount() << " - " << b.cannonCount();
+    return false;
+  }
+  if (a.cannonRounds() != b.cannonRounds())
+  {
+    WARNING_LOG(m_logger) << "cannonCount does not match: " << a.cannonCount() << " - " << b.cannonCount();
+    return false;
+  }
+  return true;
+}
+
+void TestExplosionArea::tryCreateExplosionArea()
+{
+  INFO_LOG(m_logger) << "tryCreateExplosionArea start";
+  m_eaData = AreaEffectSimulation::ExplosionArea();
+  AreaEffectSimulation::ExplosionArea eaData;
+  eaData.id(0);
+  eaData.name("af1");
+  eaData.effectStart((time(nullptr) + 4) * 1000);  // msec
+  eaData.effectDuration(10000);  // 10 seconds
+  eaData.chargeStruct().chargeTypeId(345863487);
+  eaData.area(AreaEffectSimulation::Area(Core::GeoPosition2D(0.16, 0.92), 50, 60, 70));
+  eaData.partyId(2);
+  eaData.participantId(1234);
+  eaData.cannonCount(1);
+  eaData.cannonRounds(2);
+  eaData.externalId(2);
+
+  INFO_LOG(m_logger) << "trying to send explosionAreaCreateRequest()";
+  m_replyError = false;
+  m_bExpectedFailure = true;
+  m_bIsCreatedRequest = true;
+  if (!m_ftc->explosionAreaModifyRequest(
+        ExplosionAreaModifyRequest(
+          0,
+          eaData.name(),
+          eaData.effectStart(),
+          eaData.effectDuration(),
+          eaData.effectSourceId(),
+          eaData.chargeStruct().chargeTypeId(),
+          eaData.area(),
+          eaData.partyId(),
+          eaData.participantId(),
+          eaData.cannonCount(),
+          eaData.cannonRounds(),
+          eaData.fireRequestTime(),
+          eaData.altitude(),
+          eaData.purpose(),
+          eaData.effectMarkingInTa(),
+          eaData.externalId()
+          ),
+        this))
+  {
+    ERROR_LOG(m_logger) << "Error during explosionAreaCreateRequest()";
+    failExit();
+    return;
+  }
+  // since the chargeTypeId is not valid, we should get an error
+  if (!waitForData([this]() { return m_replyError == true; }))
+  {
+    ERROR_LOG(m_logger) << "Error creating area explosion object (try with error)";
+    failExit();
+    return;
+  }
+
+  // now with correct charge type
+  m_bExpectedFailure = false;
+  m_expectedAesId = -1;
+
+  eaData.chargeStruct().chargeTypeId(s_ChargeTypeId1);
+  m_bIsCreatedRequest = true;
+  if (!m_ftc->explosionAreaModifyRequest(
+        ExplosionAreaModifyRequest(
+          0,
+          eaData.name(),
+          eaData.effectStart(),
+          eaData.effectDuration(),
+          eaData.effectSourceId(),
+          eaData.chargeStruct().chargeTypeId(),
+          eaData.area(),
+          eaData.partyId(),
+          eaData.participantId(),
+          eaData.cannonCount(),
+          eaData.cannonRounds(),
+          eaData.fireRequestTime(),
+          eaData.altitude(),
+          eaData.purpose(),
+          eaData.effectMarkingInTa(),
+          eaData.externalId()),
+        this))
+  {
+    ERROR_LOG(m_logger) << "Error during explosionAreaCreateRequest()";
+    failExit();
+    return;
+  }
+
+  if (!waitForData([this]() { return m_eaData.id() == m_expectedAesId; }))
+  {
+    ERROR_LOG(m_logger) << "Error creating area explosion object";
+    failExit();
+    return;
+  }
+  if (!checkBaseData(m_eaData, eaData))
+  {
+    ERROR_LOG(m_logger) << "Creation data does not match published data";
+    failExit();
+    return;
+  }
+  QTimer::singleShot(0, this, &TestExplosionArea::tryModifyExplosionArea);
+  INFO_LOG(m_logger) << "tryCreateExplosionArea successful";
+}
+
+
+void TestExplosionArea::tryModifyExplosionArea()
+{
+  INFO_LOG(m_logger) << "tryModifyExplosionArea start";
+  m_eaData.name("af2");
+  m_eaData.effectStart(m_eaData.effectStart().get() + 3000);
+  m_eaData.effectDuration(9000);  // 9 sec
+  m_eaData.chargeStruct().chargeTypeId(s_ChargeTypeId2);
+  m_eaData.area(AreaEffectSimulation::Area(Core::GeoPosition2D(0.165, 0.921), 50, 60, 70));
+  m_eaData.partyId(3);
+  m_eaData.participantId(1235);
+  m_eaData.cannonCount(2);
+  m_eaData.cannonRounds(2);
+  m_eaData.effectMarkingInTa(true);
+
+  const AreaEffectSimulation::ExplosionArea eaData(m_eaData);
+  m_eaData = AreaEffectSimulation::ExplosionArea();
+  m_eaData.id(eaData.id());
+  m_bIsCreatedRequest = false;
+
+  if (!m_ftc->explosionAreaModifyRequest(
+        ExplosionAreaModifyRequest(
+          eaData.id(),
+          eaData.name(),
+          eaData.effectStart(),
+          eaData.effectDuration(),
+          eaData.effectSourceId(),
+          eaData.chargeStruct().chargeTypeId(),
+          eaData.area(),
+          eaData.partyId(),
+          eaData.participantId(),
+          eaData.cannonCount(),
+          eaData.cannonRounds(),
+          eaData.fireRequestTime(),
+          eaData.altitude(),
+          eaData.purpose(),
+          eaData.effectMarkingInTa(),
+          eaData.externalId()),
+        this))
+  {
+    ERROR_LOG(m_logger) << "Error requesting modify data";
+    failExit();
+    return;
+  }
+  if (!waitForData([this]() { return m_eaData.chargeStruct().chargeTypeId() == s_ChargeTypeId2; }))
+  {
+    ERROR_LOG(m_logger) << "Error updating area explosion object";
+    failExit();
+    return;
+  }
+  if (!checkBaseData(m_eaData, eaData))
+  {
+    ERROR_LOG(m_logger) << "Modify data does not match published data";
+    failExit();
+    return;
+  }
+  QTimer::singleShot(0, this, &TestExplosionArea::tryWaitForActivationExplosionArea);
+  INFO_LOG(m_logger) << "tryModifyExplosionArea successful";
+}
+
+
+void TestExplosionArea::tryWaitForActivationExplosionArea()
+{
+  INFO_LOG(m_logger) << "tryWaitForActivationExplosionArea start";
+
+  if (!waitForData([this]() { return m_eaData.effectStateId() == AreaEffectSimulation::AesEffectState::EsActivated; }))
+  {
+    DEBUG_LOG(m_logger) << "Effect State = " << m_eaData.effectStateId();
+    ERROR_LOG(m_logger) << "Error while waiting for activation of area explosion";
+    failExit();
+    return;
+  }
+  QTimer::singleShot(0, this, &TestExplosionArea::tryPauseResumeExplosionArea);
+  INFO_LOG(m_logger) << "tryWaitForActivationExplosionArea end";
+}
+
+void TestExplosionArea::tryPauseResumeExplosionArea()
+{
+  INFO_LOG(m_logger) << "tryPauseResumeExplosionArea start";
+  // try to resume but is already active -> expected error
+  m_replyError = false;
+  m_bExpectedFailure = true;
+  if (!m_ftc->explosionAreaPauseResumeRequest(
+        ExplosionAreaPauseResumeRequest(
+          m_eaData.id(),
+          true,
+          dds::core::optional<rti::core::int64>(),
+          dds::core::optional<int32_t>(),
+          dds::core::optional<int32_t>()),
+        this))
+  {
+    ERROR_LOG(m_logger) << "Error calling explosionAreaPauseResumeRequest(true)";
+    failExit();
+    return;
+  }
+  if (!waitForData([this]() { return m_replyError == true; }))
+  {
+    ERROR_LOG(m_logger) << "Error waiting for reply error while switching to pause of area explosion";
+    failExit();
+    return;
+  }
+
+  // and now pause
+  m_bExpectedFailure = false;
+  if (!m_ftc->explosionAreaPauseResumeRequest(
+        ExplosionAreaPauseResumeRequest(
+          m_eaData.id(),
+          false,
+          dds::core::optional<rti::core::int64>(),
+          dds::core::optional<int32_t>(),
+          dds::core::optional<int32_t>()),
+        this))
+  {
+    ERROR_LOG(m_logger) << "Error calling explosionAreaPauseResumeRequest(false)";
+    failExit();
+    return;
+  }
+  if (!waitForData([this]() { return m_eaData.effectStateId() == AreaEffectSimulation::AesEffectState::EsPaused; }))
+  {
+    ERROR_LOG(m_logger) << "Error while waiting for pause of area explosion";
+    failExit();
+    return;
+  }
+
+  // pause again -> expected error
+  m_replyError = false;
+  m_bExpectedFailure = true;
+  if (!m_ftc->explosionAreaPauseResumeRequest(
+        ExplosionAreaPauseResumeRequest(
+          m_eaData.id(),
+          false,
+          dds::core::optional<rti::core::int64>(),
+          dds::core::optional<int32_t>(),
+          dds::core::optional<int32_t>()),
+        this))
+  {
+    ERROR_LOG(m_logger) << "Error calling explosionAreaPauseResumeRequest(false)";
+    failExit();
+    return;
+  }
+  if (!waitForData([this]() { return m_replyError == true; }))
+  {
+    ERROR_LOG(m_logger) << "Error creating single explosion object (try with error)";
+    failExit();
+    return;
+  }
+
+  // and resume execution
+  m_bExpectedFailure = false;
+  if (!m_ftc->explosionAreaPauseResumeRequest(
+        ExplosionAreaPauseResumeRequest(
+          m_eaData.id(),
+          true,
+          dds::core::optional<rti::core::int64>(),
+          dds::core::optional<int32_t>(),
+          dds::core::optional<int32_t>()),
+        this))
+  {
+    ERROR_LOG(m_logger) << "Error calling explosionAreaPauseResumeRequest(true)";
+    failExit();
+    return;
+  }
+  if (!waitForData([this]() { return m_eaData.effectStateId() == AreaEffectSimulation::AesEffectState::EsActivated; }))
+  {
+    ERROR_LOG(m_logger) << "Error while waiting for activation of area explosion";
+    failExit();
+    return;
+  }
+  INFO_LOG(m_logger) << "tryPauseResumeExplosionArea end";
+  QTimer::singleShot(0, this, &TestExplosionArea::checkTriggeredExplosions);
+}
+
+void TestExplosionArea::checkTriggeredExplosions()
+{
+  INFO_LOG(m_logger) << "checkTriggeredExplosions start";
+
+  // first we should wait for Activation
+  if (!waitForData([this]() { return m_eaData.effectStateId() == AreaEffectSimulation::AesEffectState::EsActivated; }))
+  {
+    ERROR_LOG(m_logger) << "Error while waiting for activation of area explosion";
+    failExit();
+    return;
+  }
+
+  // attn: msb is bit 7
+  checkTriggeredExplosionsHelper(0x70); // 0b01110000
+  checkTriggeredExplosionsHelper(0x30); // 0b00110000
+  checkTriggeredExplosionsHelper(0x10); // 0b00010000
+  checkTriggeredExplosionsHelper(0x00); // 0b00000000
+
+  // last step: wait for expiry
+  if (!waitForData([this]() { return m_eaData.effectStateId() == AreaEffectSimulation::AesEffectState::EsExpired; }))
+  {
+    ERROR_LOG(m_logger) << "Error while waiting for expiring of area explosion";
+    failExit();
+    return;
+  }
+
+  QTimer::singleShot(0, qApp, &QCoreApplication::quit);
+  INFO_LOG(m_logger) << "checkTriggeredExplosions end";
+}
+
+void TestExplosionArea::checkTriggeredExplosionsHelper(int bitfield)
+{
+  // since we've 9 seconds duration and the first hit is at 0, every 2.5sec should be a new TriggeredExplosions telegram
+  QElapsedTimer et;
+  et.start();
+  if (!waitForData([this, bitfield]() { return m_tiData.bitfield()[0] == bitfield; }))
+  {
+    ERROR_LOG(m_logger) << "Error while waiting for triggered explosison telegram with bitfield 0x" << QByteArray::number(bitfield, 16);
+    failExit();
+    return;
+  }
+  // 500ms delay through dds allowed :)
+  if (et.elapsed() > 3000)
+  {
+    ERROR_LOG(m_logger) << "Something went wrong - waited more than 3 seconds for next impact trigger";
+    failExit();
+  }
+}
+
+
+void TestExplosionArea::explosionAreaChanged(const AreaEffectSimulation::ExplosionArea &data, DataModification modType)
+{
+  if (m_eaData.id() == -1)
+    return;
+  onAesChanged(data, modType, m_eaData);
+}
+
+void TestExplosionArea::triggeredImpactsChanged(const AreaEffectSimulation::TriggeredImpacts &data, DataModification modType)
+{
+  if (m_eaData.id() != data.aesItemId() || modType == DataModification::eRemoved)
+    return;
+  INFO_LOG(m_logger) << "Got TriggeredImpacts data - bitfield[0] = 0x" << QByteArray::number(static_cast<int>(data.bitfield()[0]), 16);
+  m_tiData = data;
+}
+
+void TestExplosionArea::onExplosionAreaModifyReply(const Core::FunctionReplyObject &replyObject)
+{
+  if (m_bIsCreatedRequest)
+    onAesCreateReply(replyObject);
+  else
+    onAesModifyReply(replyObject);
+}
+
+void TestExplosionArea::onExplosionAreaPauseResumeReply(const Core::FunctionReplyObject &replyObject)
+{
+  INFO_LOG(m_logger) << "Got pause/resume reply explosion area with id " << replyObject.id()
+                     << ", error = " << replyObject.error()
+                     << " and errorString = '" << replyObject.translated() << "'";
+  m_replyError = replyObject.error();
+  if (m_replyError && !m_bExpectedFailure)
+    ERROR_LOG(m_logger) << "Got pause/resume reply explosion area error: " << replyObject();
+}
+
+} // namespace AreaEffectSimulation
+
+
+// ------------------------------------------------------------------
+int main(int argc, char **argv)
+{
+  return AreaEffectSimulation::mainBase(argc, argv, []() { return new AreaEffectSimulation::TestExplosionArea; });
+}
+