Initial commit

Lts/Services/AreaEffectSimulation/ModuleTests/aes_test_off_route_mine.cpp

@@ -0,0 +1,313 @@
+/**
+  * AES Function Topic Client test executable
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "aes_test_off_route_mine.h"
+#include <QCoreApplication>
+#include <QTest>
+#include <QTimer>
+
+namespace AreaEffectSimulation
+{
+
+// must be in pdm.pdm_charge_type
+static const int s_ChargeTypeId1 = 253;
+static const int s_ChargeTypeId2 = 254;
+
+TestOffRouteMine::TestOffRouteMine(QObject *parent)
+  : TestBase("Test.OffRouteMine", parent)
+{}
+
+bool TestOffRouteMine::init(int domainId, int exerciseId, int testId)
+{
+  if (!TestBase::init(domainId, exerciseId, testId))
+    return false;
+
+  m_dtc->waitForHistoricalDataOffRouteMine();
+  m_ormData.id(-1);
+  connect(m_dtc.get(), &AreaEffectSimulation::Interface::Dtc::offRouteMineChanged,
+          this, &TestOffRouteMine::offRouteMineChanged);
+
+  return true;
+}
+
+bool TestOffRouteMine::checkBaseData(const AreaEffectSimulation::OffRouteMine &a,
+                                        const AreaEffectSimulation::OffRouteMine &b) const
+{
+  if (!checkAesItem(a, b))
+    return false;
+
+  if (a.area().cornerBottomLeft() != b.area().cornerBottomLeft())
+  {
+    WARNING_LOG(m_logger) << "cornerBottomLeft does not match: " << a.area().cornerBottomLeft() << " - " << b.area().cornerBottomLeft();
+    return false;
+  }
+  if (a.impactRadius() != b.impactRadius())
+  {
+    WARNING_LOG(m_logger) << "impactRadius does not match: " << a.impactRadius() << " - " << b.impactRadius();
+    return false;
+  }
+  return true;
+}
+
+//
+// OffRouteMine
+//
+void TestOffRouteMine::tryCreateOffRouteMine()
+{
+  m_ormData = AreaEffectSimulation::OffRouteMine();
+  AreaEffectSimulation::OffRouteMine ormData;
+
+  ormData.id(0);
+  ormData.name("OffRouteMine1");
+  ormData.effectStart((time(nullptr) + 4) * 1000);  // msec
+  ormData.effectDuration(10234); // msec
+  ormData.chargeStruct().chargeTypeId(3456789);
+  ormData.area().cornerBottomLeft(Core::GeoPosition2D(0.154, 0.926));
+  ormData.area().width(1000);//(20);
+  ormData.area().height(200);//(15);
+  ormData.area().rotation(0.0);//(20.5);
+  ormData.impactRadius(100); // 100m
+  ormData.partyId(2);
+  //ormData.participantId(1234);
+
+  INFO_LOG(m_logger) << "trying to send OffRouteMineCreateRequest()";
+  m_replyError = false;
+  m_bExpectedFailure = true;
+  m_bIsCreatedRequest = true;
+  m_expectedAesId = -1;
+
+  if (!m_ftc->offRouteMineModifyRequest(
+        OffRouteMineModifyRequest(
+          0,
+          ormData.name(),
+          ormData.effectDuration(),
+          ormData.chargeStruct().chargeTypeId(),
+          ormData.area(),
+          ormData.impactRadius().get(),
+          ormData.effectStart().get(),
+          ormData.partyId().get()),
+        this))
+  {
+    ERROR_LOG(m_logger) << "Error during OffRouteMineCreateRequest()";
+    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 off route mine object (try with error)";
+    failExit();
+    return;
+  }
+
+  // now with correct charge type
+  m_bExpectedFailure = false;
+  m_bIsCreatedRequest = true;
+  m_expectedAesId = -1;
+
+  ormData.chargeStruct().chargeTypeId(s_ChargeTypeId1);
+  if (!m_ftc->offRouteMineModifyRequest(
+        OffRouteMineModifyRequest(
+          0,
+          ormData.name(),
+          ormData.effectDuration(),
+          ormData.chargeStruct().chargeTypeId(),
+          ormData.area(),
+          ormData.impactRadius().get(),
+          ormData.effectStart().get(),
+          ormData.partyId().get()),
+        this))
+  {
+    ERROR_LOG(m_logger) << "Error during OffRouteMineCreateRequest()";
+    failExit();
+    return;
+  }
+
+  if (!waitForData([this]() { return m_ormData.id() == m_expectedAesId; }))
+  {
+    ERROR_LOG(m_logger) << "Error creating off route mine object";
+    failExit();
+    return;
+  }
+  if (!checkBaseData(m_ormData, ormData))
+  {
+    ERROR_LOG(m_logger) << "Creation data does not match published data";
+    failExit();
+    return;
+  }
+  QTimer::singleShot(0, this, &TestOffRouteMine::tryModifyOffRouteMine);
+  INFO_LOG(m_logger) << "tryCreateOffRouteMine successful";
+}
+
+void TestOffRouteMine::tryModifyOffRouteMine()
+{
+  INFO_LOG(m_logger) << "trying to send modify request";
+  m_ormData.name("OffRouteMine 2");
+  m_ormData.effectStart(m_ormData.effectStart().get() + 2000);
+  m_ormData.effectDuration(3200); // msec
+  m_ormData.chargeStruct().chargeTypeId(s_ChargeTypeId2);
+  m_ormData.area().cornerBottomLeft(Core::GeoPosition2D(0.154, 0.926));
+  m_ormData.area().width(1000);//(50);
+  m_ormData.area().height(200);//(25);
+  m_ormData.area().rotation(90);//(20.5);
+  m_ormData.partyId(3);
+  //m_ormData.participantId(1235);
+  const AreaEffectSimulation::OffRouteMine ormData(m_ormData);
+  m_ormData = AreaEffectSimulation::OffRouteMine();
+  m_ormData.id(ormData.id());
+
+  m_bIsCreatedRequest = false;
+  if (!m_ftc->offRouteMineModifyRequest(
+        OffRouteMineModifyRequest(
+          ormData.id(),
+          ormData.name(),
+          ormData.effectDuration(),
+          ormData.chargeStruct().chargeTypeId(),
+          ormData.area(),
+          ormData.impactRadius().get(),
+          ormData.effectStart().get(),
+          ormData.partyId().get()),
+        this))
+  {
+    ERROR_LOG(m_logger) << "Error requesting modify data";
+    failExit();
+    return;
+  }
+  if (!waitForData([this]() { return m_ormData.chargeStruct().chargeTypeId() == s_ChargeTypeId2;}))
+  {
+    ERROR_LOG(m_logger) << "Error updating off route mine object";
+    failExit();
+    return;
+  }
+  if (!checkBaseData(m_ormData, ormData))
+  {
+    ERROR_LOG(m_logger) << "Modify data does not match published data";
+    failExit();
+    return;
+  }
+  QTimer::singleShot(0, this, &TestOffRouteMine::tryTriggerOffRouteMine);
+  INFO_LOG(m_logger) << "tryModifyOffRouteMine successful";
+}
+
+void TestOffRouteMine::tryTriggerOffRouteMine()
+{
+  INFO_LOG(m_logger) << "trigger off route mine  -> expires";
+
+  OffRouteMineTriggerRequest req;
+  req.id(m_ormData.id());
+  req.triggered(true);
+  if (!m_ftc->offRouteMineTriggerRequest(req, this))
+  {
+    ERROR_LOG(m_logger) << "Error requesting trigger data";
+    failExit();
+    return;
+  }
+
+  QTimer::singleShot(0, this, &TestOffRouteMine::waitExpireOffRouteMine);
+  INFO_LOG(m_logger) << "waitExpireBoobyTrap successful";
+}
+void TestOffRouteMine::waitExpireOffRouteMine()
+{
+  INFO_LOG(m_logger) << "waiting until off route mine expires";
+
+  if (!waitForData([this]() { return m_ormData.effectStateId() == AreaEffectSimulation::AesEffectState::EsExpired;}))
+  {
+    ERROR_LOG(m_logger) << "Timeout waiting for expiry of off route mine with id " << m_ormData.id();
+    failExit();
+    return;
+  }
+
+  //QTimer::singleShot(0, this, &TestOffRouteMine::tryRemoveOffRouteMine);
+  INFO_LOG(m_logger) << "waitExpireOffRouteMine successful";
+}
+
+void TestOffRouteMine::tryRemoveOffRouteMine()
+{
+  INFO_LOG(m_logger) << "tryRemoveOffRouteMine start";
+
+  AreaEffectSimulation::OffRouteMine ormData(m_ormData);
+  ormData.name("RemoveTest");
+  ormData.effectStart(0);  // not set
+  m_ormData = AreaEffectSimulation::OffRouteMine();
+  m_expectedAesId = -1;
+  m_bIsCreatedRequest = true;
+
+  if (!m_ftc->offRouteMineModifyRequest(
+        OffRouteMineModifyRequest(
+          0,
+          ormData.name(),
+          ormData.effectDuration(),
+          ormData.chargeStruct().chargeTypeId(),
+          ormData.area(),
+          ormData.impactRadius().get(),
+          ormData.effectStart().get(),
+          ormData.partyId().get()),
+        this))
+  {
+    ERROR_LOG(m_logger) << "Error during OffRouteMineModifyRequest()";
+    failExit();
+    return;
+  }
+
+  if (!waitForData([this]() { return m_ormData.id() == m_expectedAesId; }))
+  {
+    ERROR_LOG(m_logger) << "Error creating off route mine object";
+    failExit();
+    return;
+  }
+
+  m_expectedAesId = -1;
+  if (!m_ftc->offRouteMineRemoveRequest(Core::RemoveElementRequest(m_ormData.id()), this))
+  {
+    ERROR_LOG(m_logger) << "Error during OffRouteMineRemoveRequest()";
+    failExit();
+    return;
+  }
+
+  if (!waitForData([this]() { return m_ormData.id() == m_expectedAesId; }))
+  {
+    ERROR_LOG(m_logger) << "Error removing off route mine object";
+    failExit();
+    return;
+  }
+
+  QTimer::singleShot(0, qApp, &QCoreApplication::quit);
+  INFO_LOG(m_logger) << "tryRemoveOffRouteMine successful";
+}
+
+void TestOffRouteMine::offRouteMineChanged(const AreaEffectSimulation::OffRouteMine &data, DataModification modType)
+{
+  if (m_ormData.id() == -1)
+    return;
+  onAesChanged(data, modType, m_ormData);
+}
+
+void TestOffRouteMine::onOffRouteMineModifyReply(const Core::FunctionReplyObject &replyObject)
+{
+  if (m_bIsCreatedRequest)
+    onAesCreateReply(replyObject);
+  else
+    onAesModifyReply(replyObject);
+}
+
+void TestOffRouteMine::onOffRouteMineRemoveReply(const Core::FunctionReplyObject &replyObject)
+{
+  onAesRemoveReply(replyObject);
+}
+
+void TestOffRouteMine::onOffRouteMineTriggerReply(const Core::FunctionReplyObject &replyObject)
+{
+  onAesTriggerReply(replyObject);
+}
+
+} // namespace AreaEffectSimulation
+
+// ------------------------------------------------------------------
+int main(int argc, char **argv)
+{
+  return AreaEffectSimulation::mainBase(argc, argv, []() { return new AreaEffectSimulation::TestOffRouteMine; });
+}