392 lines
14 KiB
C++
Executable File
392 lines
14 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* UnitTests for ExerciseManagement (EXM)
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Philipp Dassow, SLEA, 2017-05-29
|
|
*/
|
|
|
|
#include "gmp_minefieldInterpreter_test.h"
|
|
|
|
#include <QCoreApplication>
|
|
#include <QDateTime>
|
|
#include <QtTest/QTest>
|
|
|
|
#include <NGLLogger/NGLLoggerBootstrap.h>
|
|
|
|
Q_DECLARE_METATYPE(wirkfeld_minensperre_rt)
|
|
Q_DECLARE_METATYPE(ausstossart_et)
|
|
Q_DECLARE_METATYPE(Segment_rt)
|
|
typedef QPair<int, int> Coordinate;
|
|
Q_DECLARE_METATYPE(Coordinate)
|
|
|
|
//-------------------------------------------------------------------------------------------------------
|
|
int main(int argc, char *argv[])
|
|
{
|
|
QCoreApplication app(argc, argv);
|
|
|
|
// Init the logger
|
|
NGL::NGLLoggerBootstrap::createNGLRootLogger("log4cxx_gmp_tests.props", true);
|
|
GmpMinefieldInterpreterTestsMain *tc = new GmpMinefieldInterpreterTestsMain;
|
|
|
|
int retCode = QTest::qExec(tc, argc, argv);
|
|
|
|
delete tc;
|
|
|
|
return retCode;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------
|
|
GmpMinefieldInterpreterTestsMain::GmpMinefieldInterpreterTestsMain()
|
|
: m_minefieldInterpreter(nullptr)
|
|
, m_receivedMinefield()
|
|
, m_receivedVeType(0)
|
|
, m_minefieldInterpreterTimer(nullptr)
|
|
, m_minefieldSpy(nullptr)
|
|
, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("Tests.GmpMinefieldInterpreterTest"))
|
|
{
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------
|
|
void GmpMinefieldInterpreterTestsMain::initTestCase()
|
|
{
|
|
DEBUG_LOG(m_logger) << "GmpMinefieldInterpreterTestsMain: initTestCase";
|
|
|
|
m_minefieldInterpreter = new GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter();
|
|
QVERIFY2(m_minefieldInterpreter, "Initialisation of GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter failed");
|
|
|
|
// connect to minefield generator
|
|
connect(m_minefieldInterpreter, &GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::sendeWirkfeld, this, &GmpMinefieldInterpreterTestsMain::onSendMinefield);
|
|
|
|
// set up signal spy
|
|
qRegisterMetaType<wirkfeld_minensperre_rt>();
|
|
m_minefieldSpy = new QSignalSpy(m_minefieldInterpreter, &GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::sendeWirkfeld);
|
|
|
|
// start interpreter
|
|
m_minefieldInterpreterTimer = new QTimer();
|
|
connect(m_minefieldInterpreterTimer, &QTimer::timeout, m_minefieldInterpreter, &GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::processData);
|
|
m_minefieldInterpreterTimer->start(m_minefieldInterpreter->triggerIntervall * 1000);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------
|
|
void GmpMinefieldInterpreterTestsMain::minefieldTestCase_data()
|
|
{
|
|
// define set of data needed
|
|
QTest::addColumn<QVector<int>>("identities");
|
|
QTest::addColumn<uint32_t>("effectDuration");
|
|
QTest::addColumn<int>("operationalState");
|
|
QTest::addColumn<int>("barrierId");
|
|
QTest::addColumn<unsigned short>("mineType");
|
|
QTest::addColumn<short>("mineCount");
|
|
QTest::addColumn<int>("mineLayingDensity");
|
|
QTest::addColumn<QVector<ausstossart_et>>("throwingTypes");
|
|
QTest::addColumn<QVector <QVector<Coordinate>>>("coordinates"); // (Coordinate == QPair) is interpreted as utm_north, utm_east
|
|
QTest::addColumn<int>("identityResult");
|
|
QTest::addColumn<short>("mineCountResult");
|
|
QTest::addColumn<int>("mineDensityResult");
|
|
QTest::addColumn<uint32_t>("layingDepth");
|
|
QTest::addColumn<QVector<Segment_rt>>("segmentsResult");
|
|
|
|
// data set: minefield with mutltiple laying vehicles
|
|
// identities
|
|
QVector <int> identities({4000, 4010, 4020});
|
|
|
|
uint32_t effectDuration = 10;
|
|
int operationalState = 98;
|
|
int barrierId = 43;
|
|
unsigned short mineType = 214;
|
|
short mineCount = 12;
|
|
int mineLayingDensity = 1;
|
|
|
|
QVector<ausstossart_et> throwingTypes({rechts_und_links, links, rechts});
|
|
|
|
// List of coordinates for the lane data
|
|
// QPair is utm_north, utm_east
|
|
QVector<Coordinate> coordinates1, coordinates2, coordinates3;
|
|
coordinates1 << QPair<int, int>(79500, 94200);
|
|
coordinates2 << QPair<int, int>(79540, 94200);
|
|
coordinates3 << QPair<int, int>(79460, 94200);
|
|
coordinates1 << QPair<int, int>(79500, 94220);
|
|
coordinates2 << QPair<int, int>(79540, 94220);
|
|
coordinates3 << QPair<int, int>(79460, 94220);
|
|
coordinates1 << QPair<int, int>(79500, 94240);
|
|
coordinates2 << QPair<int, int>(79540, 94240);
|
|
coordinates3 << QPair<int, int>(79460, 94240);
|
|
coordinates1 << QPair<int, int>(79500, 94260);
|
|
coordinates2 << QPair<int, int>(79540, 94260);
|
|
coordinates3 << QPair<int, int>(79460, 94260);
|
|
QVector <QVector<Coordinate>> coordinates;
|
|
coordinates << coordinates1 << coordinates2 << coordinates3;
|
|
|
|
// result data
|
|
int identityResult = 4010;
|
|
short mineCountResult = mineCount * 3;
|
|
int mineDensityResult = 60;
|
|
uint32_t layingDepth = 128;
|
|
QVector<Segment_rt> segmentsResult;
|
|
Segment_rt segment;
|
|
segment.anzahl = mineCountResult;
|
|
segment.drehwinkel = 0;
|
|
segment.startpunkt.utm_nordwert = 79500;
|
|
segment.startpunkt.utm_ostwert = 94200;
|
|
segmentsResult << segment;
|
|
|
|
QTest::newRow("minefield from multiple vehicles")
|
|
<< identities
|
|
<< effectDuration
|
|
<< operationalState
|
|
<< barrierId
|
|
<< mineType
|
|
<< mineCount
|
|
<< mineLayingDensity
|
|
<< throwingTypes
|
|
<< coordinates
|
|
<< identityResult
|
|
<< mineCountResult
|
|
<< mineDensityResult
|
|
<< layingDepth
|
|
<< segmentsResult;
|
|
|
|
// clear lists
|
|
identities.clear();
|
|
throwingTypes.clear();
|
|
coordinates1.clear();
|
|
coordinates2.clear();
|
|
coordinates3.clear();
|
|
coordinates.clear();
|
|
segmentsResult.clear();
|
|
|
|
// data set: minefield with 1 laying vehicle and 5 segments
|
|
identities << 4000;
|
|
effectDuration = 6;
|
|
operationalState = 98;
|
|
barrierId = 42;
|
|
mineType = 215;
|
|
mineCount = 111;
|
|
mineLayingDensity = 4;
|
|
|
|
throwingTypes << mitte;
|
|
|
|
//coordinates
|
|
coordinates1 << QPair<int, int>(79100, 94100);
|
|
coordinates1 << QPair<int, int>(79120, 94110);
|
|
coordinates1 << QPair<int, int>(79140, 94120);
|
|
coordinates1 << QPair<int, int>(79140, 94140);
|
|
coordinates1 << QPair<int, int>(79130, 94160);
|
|
coordinates1 << QPair<int, int>(79110, 94170);
|
|
coordinates1 << QPair<int, int>(79090, 94160);
|
|
coordinates1 << QPair<int, int>(79080, 94140);
|
|
coordinates1 << QPair<int, int>(79080, 94120);
|
|
coordinates1 << QPair<int, int>(79070, 94100);
|
|
coordinates1 << QPair<int, int>(79080, 94080);
|
|
coordinates1 << QPair<int, int>(79100, 94070);
|
|
coordinates1 << QPair<int, int>(79120, 94060);
|
|
coordinates1 << QPair<int, int>(79130, 94040);
|
|
coordinates << coordinates1;
|
|
|
|
// result data
|
|
identityResult = 4000;
|
|
mineCountResult = mineCount;
|
|
mineDensityResult = 41;
|
|
layingDepth = 12;
|
|
// segment 0
|
|
segment.anzahl = 18;
|
|
segment.drehwinkel = 6343;
|
|
segment.startpunkt.utm_nordwert = 79100;
|
|
segment.startpunkt.utm_ostwert = 94100;
|
|
segmentsResult << segment;
|
|
// segment 1
|
|
segment.anzahl = 17;
|
|
segment.drehwinkel = 34596;
|
|
segment.startpunkt.utm_nordwert = 79140;
|
|
segment.startpunkt.utm_ostwert = 94120;
|
|
segmentsResult << segment;
|
|
// segment 2
|
|
segment.anzahl = 16;
|
|
segment.drehwinkel = 27000;
|
|
segment.startpunkt.utm_nordwert = 79130;
|
|
segment.startpunkt.utm_ostwert = 94160;
|
|
segmentsResult << segment;
|
|
// segment 3
|
|
segment.anzahl = 26;
|
|
segment.drehwinkel = 19843;
|
|
segment.startpunkt.utm_nordwert = 79090;
|
|
segment.startpunkt.utm_ostwert = 94160;
|
|
segmentsResult << segment;
|
|
// segment 4
|
|
segment.anzahl = 34;
|
|
segment.drehwinkel = 13500;
|
|
segment.startpunkt.utm_nordwert = 79070;
|
|
segment.startpunkt.utm_ostwert = 94100;
|
|
segmentsResult << segment;
|
|
|
|
QTest::newRow("minefield from 1 vehicle with 5 segments")
|
|
<< identities
|
|
<< effectDuration
|
|
<< operationalState
|
|
<< barrierId
|
|
<< mineType
|
|
<< mineCount
|
|
<< mineLayingDensity
|
|
<< throwingTypes
|
|
<< coordinates
|
|
<< identityResult
|
|
<< mineCountResult
|
|
<< mineDensityResult
|
|
<< layingDepth
|
|
<< segmentsResult;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------
|
|
void GmpMinefieldInterpreterTestsMain::minefieldTestCase()
|
|
{
|
|
DEBUG_LOG(m_logger) << "GmpMinefieldInterpreterTestsMain: multiLaneMinefieldTestCase";
|
|
NOTICE_LOG(m_logger) << "this may take a while.. don't worry";
|
|
|
|
uint64_t timeStamp = QDateTime::currentSecsSinceEpoch();
|
|
uint32_t effectStart = timeStamp + 100;
|
|
|
|
QFETCH(int, barrierId);
|
|
QFETCH(unsigned short, mineType);
|
|
|
|
// inserting start minelayer data
|
|
VERLEGEDATEN_INTERN verlegedaten_intern;
|
|
VERLEGEDATEN_KEY verlegekey_intern;
|
|
verlegedaten_intern.daten.gps_zeit.gps_zeit = timeStamp;
|
|
verlegedaten_intern.daten.verlegedaten.sperren_id = barrierId;
|
|
verlegedaten_intern.daten.verlegedaten.verlegedichte = 0;
|
|
verlegedaten_intern.daten.verlegedaten.wirkbeginn.gps_zeit = effectStart;
|
|
verlegedaten_intern.daten.verlegedaten.wirkzeit = 0;
|
|
verlegedaten_intern.daten.verlegedaten.minentyp = mineType;
|
|
verlegedaten_intern.daten.verlegedaten.anzahl_verlegter_minen = 0;
|
|
|
|
verlegekey_intern.zeitpunkt.gps_zeit = timeStamp;
|
|
|
|
QFETCH(QVector<int>, identities);
|
|
QFETCH(QVector<QVector<Coordinate>>, coordinates);
|
|
QFETCH(QVector<ausstossart_et>, throwingTypes);
|
|
|
|
for (int i = 0; i < identities.size(); ++i)
|
|
{
|
|
verlegekey_intern.fz_id = identities.at(i);
|
|
verlegedaten_intern.daten.header.identitaet = identities.at(i);
|
|
verlegedaten_intern.daten.gps_position.utm_nordwert = coordinates.at(i).first().first;
|
|
verlegedaten_intern.daten.gps_position.utm_ostwert = coordinates.at(i).first().second;
|
|
verlegedaten_intern.daten.verlegedaten.ausstossart = throwingTypes.at(i);
|
|
interne_datenbasis_Verlegedaten.eintrag_container(
|
|
verlegekey_intern, verlegedaten_intern);
|
|
}
|
|
|
|
QFETCH(int, operationalState);
|
|
|
|
// inserting lane data timed
|
|
FAHRSPUR_INTERN daten_intern;
|
|
VERLEGEDATEN_KEY key_intern;
|
|
//Interpretationsstatus auf 0 setzen
|
|
daten_intern.intstat = 0;
|
|
daten_intern.daten.ss_betriebszustand = operationalState;
|
|
|
|
|
|
// for each coordinate
|
|
for (int i = 0; i < coordinates.first().size(); ++i)
|
|
{
|
|
key_intern.zeitpunkt.gps_zeit = timeStamp;
|
|
daten_intern.daten.gps_zeit.gps_zeit = timeStamp;
|
|
|
|
// for each identity
|
|
for (int j = 0; j < identities.size(); ++j)
|
|
{
|
|
daten_intern.daten.header.identitaet = identities.at(j);
|
|
daten_intern.daten.gps_position.utm_nordwert = coordinates.at(j).at(i).first;
|
|
daten_intern.daten.gps_position.utm_ostwert = coordinates.at(j).at(i).second;
|
|
|
|
key_intern.fz_id = identities.at(j);
|
|
|
|
interne_datenbasis_Fahrspur.eintrag_container(
|
|
key_intern, daten_intern);
|
|
}
|
|
NOTICE_LOG(m_logger) << "... waiting for next coordinate input";
|
|
QTest::qWait(5000);
|
|
timeStamp += 5;
|
|
}
|
|
NOTICE_LOG(m_logger) << "finished!";
|
|
|
|
QFETCH(short, mineCount);
|
|
QFETCH(uint32_t, effectDuration);
|
|
QFETCH(int, mineLayingDensity);
|
|
|
|
// inserting end minelayer data
|
|
timeStamp -= 5;
|
|
|
|
verlegedaten_intern.daten.gps_zeit.gps_zeit = timeStamp;
|
|
verlegedaten_intern.daten.verlegedaten.sperren_id = barrierId;
|
|
verlegedaten_intern.daten.verlegedaten.verlegedichte = mineLayingDensity;
|
|
verlegedaten_intern.daten.verlegedaten.wirkbeginn.gps_zeit = effectStart;
|
|
verlegedaten_intern.daten.verlegedaten.wirkzeit = effectDuration;
|
|
verlegedaten_intern.daten.verlegedaten.anzahl_verlegter_minen = mineCount;
|
|
|
|
verlegekey_intern.zeitpunkt.gps_zeit = timeStamp;
|
|
|
|
for (int i = 0; i < identities.size(); ++i)
|
|
{
|
|
verlegekey_intern.fz_id = identities.at(i);
|
|
verlegedaten_intern.daten.header.identitaet = identities.at(i);
|
|
verlegedaten_intern.daten.gps_position.utm_nordwert = coordinates.at(i).last().first;
|
|
verlegedaten_intern.daten.gps_position.utm_ostwert = coordinates.at(i).last().second;
|
|
verlegedaten_intern.daten.verlegedaten.ausstossart = throwingTypes.at(i);
|
|
interne_datenbasis_Verlegedaten.eintrag_container(
|
|
verlegekey_intern, verlegedaten_intern);
|
|
}
|
|
|
|
// the interpreter/generator waits for 240 seconds before processing the data
|
|
NOTICE_LOG(m_logger) << "Now we have to wait for minefield generation timeout (270s) ...";
|
|
QVERIFY2(m_minefieldSpy->wait(270 * 1000), "Generation of minefield timed out");
|
|
|
|
QFETCH(int, identityResult);
|
|
QFETCH(short, mineCountResult);
|
|
QFETCH(int, mineDensityResult);
|
|
QFETCH(uint32_t, layingDepth);
|
|
QFETCH(QVector<Segment_rt>, segmentsResult);
|
|
|
|
// check for correct minefield data
|
|
QCOMPARE(m_receivedMinefield.header.identitaet, identityResult);
|
|
QCOMPARE(m_receivedMinefield.beschreibung.kennung, barrierId);
|
|
QCOMPARE(m_receivedMinefield.beschreibung.wirkbeginn.gps_zeit, effectStart);
|
|
QCOMPARE(m_receivedMinefield.beschreibung.wirkdauer, effectDuration);
|
|
QCOMPARE(m_receivedMinefield.beschreibung.minentyp, mineType);
|
|
QCOMPARE(m_receivedMinefield.beschreibung.minenanzahl, mineCountResult);
|
|
QCOMPARE(m_receivedMinefield.beschreibung.verlegedichte, mineDensityResult);
|
|
QCOMPARE(m_receivedMinefield.beschreibung.verlegetiefe, layingDepth);
|
|
QCOMPARE(m_receivedMinefield.beschreibung.segmente.size(), static_cast<size_t>(segmentsResult.size()));
|
|
// Segments
|
|
for (size_t i = 0; i < m_receivedMinefield.beschreibung.segmente.size(); ++i)
|
|
{
|
|
QCOMPARE(m_receivedMinefield.beschreibung.segmente.at(i).anzahl, segmentsResult.at(i).anzahl);
|
|
QCOMPARE(m_receivedMinefield.beschreibung.segmente.at(i).drehwinkel, segmentsResult.at(i).drehwinkel);
|
|
QCOMPARE(m_receivedMinefield.beschreibung.segmente.at(i).startpunkt.utm_nordwert, segmentsResult.at(i).startpunkt.utm_nordwert);
|
|
QCOMPARE(m_receivedMinefield.beschreibung.segmente.at(i).startpunkt.utm_ostwert, segmentsResult.at(i).startpunkt.utm_ostwert);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------
|
|
void GmpMinefieldInterpreterTestsMain::cleanupTestCase()
|
|
{
|
|
DEBUG_LOG(m_logger) << "GmpMinefieldInterpreterTestsMain: cleanupTestCase";
|
|
m_minefieldInterpreterTimer->stop();
|
|
m_minefieldInterpreterTimer->deleteLater();
|
|
|
|
delete m_minefieldInterpreter;
|
|
|
|
delete m_minefieldSpy;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------
|
|
void GmpMinefieldInterpreterTestsMain::onSendMinefield(const wirkfeld_minensperre_rt &minefield, int veType)
|
|
{
|
|
m_receivedMinefield = minefield;
|
|
m_receivedVeType = veType;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------
|