qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Services/AreaEffectSimulation/ModuleTests/aes_test_ncontamination.cpp

/**
  * AES Function Topic Client test executable
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "aes_test_ncontamination.h"
#include <QtCore/QCoreApplication>
#include <QtTest/QTest>
#include <QtCore/QTimer>

namespace AreaEffectSimulation
{

// must be in pdm.pdm_charge_type
static const int s_ChargeTypeId1 = 321;

TestNContamination::TestNContamination(QObject *parent)
  : TestBase("Test.NContamination", parent)
{}

bool TestNContamination::init(int domainId, int exerciseId, int testId)
{
  if (!TestBase::init(domainId, exerciseId, testId))
    return false;

  m_dtc->waitForHistoricalDataNContamination();
  m_ncData.id(-1);
  connect(m_dtc.get(), &AreaEffectSimulation::Interface::Dtc::nContaminationChanged,
          this, &TestNContamination::nContaminationChanged);

  return true;
}

bool TestNContamination::checkBaseData(const AreaEffectSimulation::NContamination &a,
                           const AreaEffectSimulation::NContamination &b) const
{
  if (!checkAesItem(a, b))
    return false;

  if (a.impactPosition() != b.impactPosition())
  {
    WARNING_LOG(m_logger) << "impactPosition does not match: " << a.impactPosition() << " - " << b.impactPosition();
    return false;
  }
  return true;
}

//
// NContamination
//
void TestNContamination::tryCreateNContamination()
{
  m_ncData = AreaEffectSimulation::NContamination();
  AreaEffectSimulation::NContamination ncData;
  ncData.id(0);
  ncData.name("ncont1");
  ncData.effectStart((time(nullptr) + 4) * 1000);  // msec
  ncData.effectDuration(10000); // 10 sec
  ncData.chargeStruct().chargeTypeId(345863487);
  ncData.impactPosition(Core::GeoPosition2D(0.16, 0.92));
  ncData.borderLengthInner(1000); // 1km
  ncData.borderLengthOuter(2000); // 2km
  ncData.impactRadius(500); // 500m
  ncData.spanAngle(31);
  ncData.rotationAngle(57);
  ncData.detonationValue(1000); // kt, only cosmetical
  ncData.partyId(7);
  ncData.participantId(1234);

  INFO_LOG(m_logger) << "trying to send NContaminationCreateRequest()";
  m_replyError = false;
  m_bExpectedFailure = true;
  m_bIsCreatedRequest = true;
  if (!m_ftc->nContaminationModifyRequest(
        NContaminationModifyRequest(
          0,
          ncData.name(),
          ncData.effectStart(),
          ncData.effectDuration(),
          ncData.chargeStruct().chargeTypeId(),
          ncData.impactPosition(),
          ncData.borderLengthInner(),
          ncData.borderLengthOuter(),
          ncData.impactRadius(),
          ncData.spanAngle(),
          ncData.rotationAngle(),
          ncData.detonationValue(),
          ncData.weatherSource(),
          ncData.partyId(),
          ncData.participantId(),
          ncData.externalId()),
        this))
  {
    ERROR_LOG(m_logger) << "Error during NContaminationCreateRequest()";
    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 ncontamination object (try with error)";
    failExit();
    return;
  }

  m_bExpectedFailure = false;
  m_expectedAesId = -1;
  m_bIsCreatedRequest = true;
  // now with correct charge type
  ncData.chargeStruct().chargeTypeId(s_ChargeTypeId1);
  if (!m_ftc->nContaminationModifyRequest(
        NContaminationModifyRequest(
          0,
          ncData.name(),
          ncData.effectStart(),
          ncData.effectDuration(),
          ncData.chargeStruct().chargeTypeId(),
          ncData.impactPosition(),
          ncData.borderLengthInner(),
          ncData.borderLengthOuter(),
          ncData.impactRadius(),
          ncData.spanAngle(),
          ncData.rotationAngle(),
          ncData.detonationValue(),
          ncData.weatherSource(),
          ncData.partyId(),
          ncData.participantId(),
          ncData.externalId()),
        this))
  {
    ERROR_LOG(m_logger) << "Error during NContaminationCreateRequest()";
    failExit();
    return;
  }

  if (!waitForData([this]() { return m_ncData.id() == m_expectedAesId; }))
  {
    ERROR_LOG(m_logger) << "Error creating ncontamination object";
    failExit();
    return;
  }
  if (!checkBaseData(m_ncData, ncData))
  {
    ERROR_LOG(m_logger) << "Creation data does not match published data";
    failExit();
    return;
  }
  QTimer::singleShot(0, this, &TestNContamination::tryModifyNContamination);
  INFO_LOG(m_logger) << "tryCreateNContamination successful";
}

void TestNContamination::tryModifyNContamination()
{
  INFO_LOG(m_logger) << "trying to send modify request";
  m_ncData.name("ncont2");
  m_ncData.effectStart((time(nullptr) + 4) * 1000);  // msec
  m_ncData.effectDuration(3000); // 3 sec
  m_ncData.chargeStruct().chargeTypeId(s_ChargeTypeId1);
  m_ncData.impactPosition(Core::GeoPosition2D(0.162, 0.925));
  m_ncData.borderLengthInner(1100); // 1.1km
  m_ncData.borderLengthOuter(1800); // 1.8km
  m_ncData.impactRadius(600); // 600m
  m_ncData.spanAngle(14);
  m_ncData.rotationAngle(187);
  m_ncData.detonationValue(2000); // kt, only cosmetical
  m_ncData.partyId(3);
  m_ncData.participantId(1235);
  const AreaEffectSimulation::NContamination ncData(m_ncData);
  m_ncData = AreaEffectSimulation::NContamination();
  m_ncData.id(ncData.id());

  m_bIsCreatedRequest = false;
  if (!m_ftc->nContaminationModifyRequest(
        NContaminationModifyRequest(
          ncData.id(),
          ncData.name(),
          ncData.effectStart(),
          ncData.effectDuration(),
          ncData.chargeStruct().chargeTypeId(),
          ncData.impactPosition(),
          ncData.borderLengthInner(),
          ncData.borderLengthOuter(),
          ncData.impactRadius(),
          ncData.spanAngle(),
          ncData.rotationAngle(),
          ncData.detonationValue(),
          ncData.weatherSource(),
          ncData.partyId(),
          ncData.participantId(),
          ncData.externalId()),
        this))
  {
    ERROR_LOG(m_logger) << "Error requesting modify data";
    failExit();
    return;
  }
  if (!waitForData([this]() { return m_ncData.partyId() == 3;}))
  {
    ERROR_LOG(m_logger) << "Error updating ncontamination object";
    failExit();
    return;
  }
  if (!checkBaseData(m_ncData, ncData))
  {
    ERROR_LOG(m_logger) << "Modify data does not match published data";
    failExit();
    return;
  }
  QTimer::singleShot(0, this, &TestNContamination::waitExpireNContamination);
  INFO_LOG(m_logger) << "tryModifyNContamination successful";
}

void TestNContamination::waitExpireNContamination()
{
  INFO_LOG(m_logger) << "waiting until ncontamination expires";

  if (!waitForData([this]() { return m_ncData.effectStateId() == AreaEffectSimulation::AesEffectState::EsExpired;}))
  {
    ERROR_LOG(m_logger) << "Timeout waiting for expiry of ncontamination with id " << m_ncData.id();
    failExit();
    return;
  }

  QTimer::singleShot(0, this, &TestNContamination::tryRemoveNContamination);
  INFO_LOG(m_logger) << "waitExpireNContamination successful";
}

void TestNContamination::tryRemoveNContamination()
{
  INFO_LOG(m_logger) << "tryRemoveNContamination start";

  AreaEffectSimulation::NContamination ncData(m_ncData);
  ncData.name("RemoveTest");
  ncData.effectStart(0);  // not set
  m_ncData = AreaEffectSimulation::NContamination();
  m_expectedAesId = -1;
  m_bIsCreatedRequest = true;

  if (!m_ftc->nContaminationModifyRequest(
        NContaminationModifyRequest(
          0,
          ncData.name(),
          ncData.effectStart(),
          ncData.effectDuration(),
          ncData.chargeStruct().chargeTypeId(),
          ncData.impactPosition(),
          ncData.borderLengthInner(),
          ncData.borderLengthOuter(),
          ncData.impactRadius(),
          ncData.spanAngle(),
          ncData.rotationAngle(),
          ncData.detonationValue(),
          ncData.weatherSource(),
          ncData.partyId(),
          ncData.participantId(),
          ncData.externalId()),
        this))
  {
    ERROR_LOG(m_logger) << "Error during NContaminationCreateRequest()";
    failExit();
    return;
  }

  if (!waitForData([this]() { return m_ncData.id() == m_expectedAesId; }))
  {
    ERROR_LOG(m_logger) << "Error creating ncontamination object";
    failExit();
    return;
  }

  m_expectedAesId = -1;
  if (!m_ftc->nContaminationRemoveRequest(Core::RemoveElementRequest(m_ncData.id()), this))
  {
    ERROR_LOG(m_logger) << "Error during NContaminationRemoveRequest()";
    failExit();
    return;
  }

  if (!waitForData([this]() { return m_ncData.id() == m_expectedAesId; }))
  {
    ERROR_LOG(m_logger) << "Error removing ncontamination object";
    failExit();
    return;
  }

  QTimer::singleShot(0, qApp, &QCoreApplication::quit);
  INFO_LOG(m_logger) << "tryRemoveNContamination successful";
}


void TestNContamination::nContaminationChanged(const AreaEffectSimulation::NContamination &data, DataModification modType)
{
  if (m_ncData.id() == -1)
    return;
  onAesChanged(data, modType, m_ncData);
}

void TestNContamination::onNContaminationModifyReply(const Core::FunctionReplyObject &replyObject)
{
  if (m_bIsCreatedRequest)
    onAesCreateReply(replyObject);
  else
    onAesModifyReply(replyObject);
}

void TestNContamination::onNContaminationRemoveReply(const Core::FunctionReplyObject &replyObject)
{
  onAesRemoveReply(replyObject);
}

} // namespace AreaEffectSimulation

// ------------------------------------------------------------------
int main(int argc, char **argv)
{
  return AreaEffectSimulation::mainBase(argc, argv, []() { return new AreaEffectSimulation::TestNContamination; });
}