/**
 * @RDE_HEADER@
 * Moduletest
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "situation_map_test_main.h"


#include <NGLLogger/INGLLogger.h>
#include <nglapplication/nglapplication.h>

#include "sit_map.h"
#include <cmath>

#include <Map/map.h>
#include <Map/map_notifier.h>
#include <Map/situation_map_utils.h>
#include <Map/object_factory.h>
#include <Map/coord_translation_functor.h>
#include <MapImpl/overlay_handler_impl.h>
#include <GeometryModel/geometry_model_factory.h>
#include <MapImpl/map_impl.h>
#include <MapImpl/layer_factory_impl.h>
#include <MapImpl/location_to_elevation_bulk.h>
#include <MapObjectsImpl/building_outline_impl.h>
#include <MapObjectsImpl/biological_agent_impl.h>
#include <MapObjectsImpl/chemical_agent_impl.h>
#include <MapObjectsImpl/danger_area_impl.h>
#include <MapObjectsImpl/participant_impl.h>
#include <Symbology/sidc_codec.h>


#include <GraphicalObjects/graphical_object_ellipse.h>
#include <GraphicalObjects/graphical_object_path.h>
//#include <GraphicalObjects/graphical_object_multi_path.h>
#include <GraphicalObjects/tactical_appearance.h>

#include <Symbology/sidc_codec.h>

#include <Common/exception.h>

#include <Rubberbands/rubberband_factory.h>

//ESRI
#include <arcgis/Map.h>
#include <arcgis/GraphicsOverlayListModel.h>
#include <arcgis/Point.h>
#include <arcgis/GeometryEngine.h>
#include <arcgis/PictureMarkerSymbol.h>
//#include <arcgis/CoordinateConversion.h>


//Qt
#include <QCoreApplication>
#include <QGraphicsView>
#include <QTimer>
#include <QtTest/QTest>
#include <QtTest/QSignalSpy>
#include <QDebug>


#include <iostream>
#include <LtsCoordTrans/lts_coord_trans.h>

static LtsCoordTrans::UtmCoordinate s_basePoint;

const int timeToDelay = 0; // suggestion: 2000

using namespace SituationMap;  // 'enable' operator<< (QPointF etc.)

bool fuzzyCompare(const Point3D &p1, const Point3D &p2)
{
  const Point3D &diff = p1 - p2;
  return (diff.x() < 0.00001) &&
      (diff.y() < 0.00001) &&
      (diff.z() < 0.00001);
}

bool fuzzyCompare(const PositionCont &p1, const PositionCont &p2)
{
  if (p1.size() != p2.size())
    return false;

  for(int i=0; i<p1.size(); ++i)
  {
    if (!fuzzyCompare(p1[i], p2[i]))
      return false;
  }
  return true;
}


//-------------------------------------------------------------------------------------------------------
int main(int argc, char *argv[])
{

  //  QCoreApplication app(argc, argv);
  NGLApplication app(argc, argv);
  app.createLogger("SitMapModuleTest", "log4cxxSituationMapModuleTests.props");

  // under windows for ArcGIS 10.2.6 and higher
#ifdef Q_OS_WIN
  QCoreApplication::setAttribute(Qt::AA_UseOpenGLES);
#endif

  QDir::setSearchPaths(QLatin1String("icon"), QStringList(QLatin1String(":/icons/light")));

  s_basePoint = LtsCoordTrans::UtmCoordinate::fromMgrs(QLatin1String("32UMD000000000000"));


  AdvancedSymbology::SymbologyType symbologyType = AdvancedSymbology::SymbologyType::MIL2525C;

  if (argc < 2)
  {
    // usage:
    std::cout << argv[0]
              << std::endl
              << " usage:  append 'mil' | 'app' to argumentlist" << std::endl
              << "   e.g   " << argv[0] << " [QTest options] [testfunction] none" << std::endl
              << "   e.g   " << argv[0] << " [QTest options] [testfunction] app6D" << std::endl
              << "   e.g   " << argv[0] << " [QTest options] [testfunction] app6B" << std::endl
              << "   e.g   " << argv[0] << " [QTest options] [testfunction] mil2525D" << std::endl
              << "   e.g   " << argv[0] << " [QTest options] [testfunction] mil2525C" << std::endl
              << std::endl;

    return -1;
  }

  const QString strSymType = app.arguments().constLast(); // the last argument
  if (strSymType.compare(QLatin1String("none"), Qt::CaseInsensitive) == 0)
    symbologyType = AdvancedSymbology::SymbologyType::None;
  else if (strSymType.compare(QLatin1String("app6B"), Qt::CaseInsensitive) == 0)
    symbologyType = AdvancedSymbology::SymbologyType::APP6B;
  else if (strSymType.compare(QLatin1String("app6D"), Qt::CaseInsensitive) == 0)
    symbologyType = AdvancedSymbology::SymbologyType::APP6D;
  else if (strSymType.compare(QLatin1String("mil2525D"), Qt::CaseInsensitive) == 0)
    symbologyType = AdvancedSymbology::SymbologyType::MIL2525D;
  else if (strSymType.compare(QLatin1String("mil2525C"), Qt::CaseInsensitive) == 0)
    symbologyType = AdvancedSymbology::SymbologyType::MIL2525C;

  argc -= 1; // remove last argument for QTest::qExec

  // Init the logger
  SituationMapTestsMain *tc = new SituationMapTestsMain(symbologyType);

  int retCode = QTest::qExec(tc, argc, argv);

  std::cout << "  symbologyType = " << symbologyType
            << std::endl;

  delete tc;

  return retCode;
}



class SituationMapTestsMain::Private
{
public:

  Private()
  {}

  ~Private()
  {}


  // OWN data:
  AdvancedSymbology::SymbologyType         m_symbologyType;
  SitMap                                  *m_sitMap = nullptr;
  SituationMap::Map                       *m_map    = nullptr;
  QPointF                                  m_geoOff;
  int                                      m_basemapCountRef = 0;

}; // class Private
//-----------------------------------------------------------------------------


SituationMapTestsMain::SituationMapTestsMain(AdvancedSymbology::SymbologyType symbologyType)
  : m_logger(SituationMap::getLogger("SituationMapTestsMain"))
  , d(new Private)
{
  d->m_symbologyType = symbologyType;
}

SituationMapTestsMain::~SituationMapTestsMain()
{
  delete d;
}


//-------------------------------------------------------------------------------------------------------


void SituationMapTestsMain::initTestCase()
{
  DEBUG_LOG(m_logger) << LOGFUNCTION;

  if (d->m_sitMap)
    d->m_sitMap->close();

  delete d->m_sitMap;

  LayerFactoryImpl::setForceCreationOfGraphicsOverlay(false); // false => createLayerOnDemand


  d->m_sitMap = new SitMap(d->m_symbologyType);
  QVERIFY2(d->m_sitMap, "Initialisation of SituationMap failed");

  connect(d->m_sitMap, &SitMap::mapReadyAndSymbolDictionaryLoaded, [&]()
  {
//    INFO_LOG(m_logger) << LOGFUNCTION << " got mapReady ";
  });

  d->m_sitMap->setMinimumWidth(1100);
  d->m_sitMap->setMinimumHeight(1100);

  d->m_sitMap->show();

  d->m_map = d->m_sitMap->map();
  d->m_geoOff = QPointF( s_basePoint.x,s_basePoint.y );

  SituationMap::LayerFactory &layerFac = d->m_map->layerFactory();
  QString msg = QStringLiteral("layerFactory: count failed (%1)").arg(layerFac.count());
  QVERIFY2((layerFac.count() >= 3) && (layerFac.count() <= 16) , msg.toStdString().c_str());

  QSignalSpy spy(d->m_sitMap, &SitMap::mapReady);
  QTRY_VERIFY(d->m_sitMap->isReady());
  QTRY_VERIFY2(spy.count() == 1, "mapReadyEmitted not emitted");

  QVERIFY2(d->m_sitMap->isReady() , "map is NOT READY");


  // Wait also for Dictionary (since it´s done within a WorkerThread)
  AdvancedSymbology::SymbolDictionary &dict = d->m_map->symbolDictionary();
  QTRY_VERIFY2(dict.isLoaded(), "dict is NOT Loaded");

  QTest::qWait(1000);
}


void SituationMapTestsMain::checkMapReady()
{
  if (! d->m_sitMap->isReady())
  {
    QSignalSpy spy(d->m_sitMap, &SitMap::mapReadyAndSymbolDictionaryLoaded);
    QTRY_VERIFY2(spy.count() > 0, "mapReady not received");
  }
}

void SituationMapTestsMain::checkMapNotifier()
{
  QPointer<MapNotifier> mapNotifier = d->m_sitMap->map()->createMapNotifier();
  QVERIFY2(mapNotifier.isNull() == false, "no MapNotifier");

  QSignalSpy spy1(mapNotifier.data(), &MapNotifier::mapReady);
  QSignalSpy spy2(mapNotifier.data(), &MapNotifier::mapReadyAndSymbolDictionaryLoaded);

  mapNotifier->run();

  QTRY_VERIFY2(spy1.count() == 1, "mapReady not received");
  QTRY_VERIFY2(spy2.count() == 1, "mapReadyAndSymbolDictionaryLoaded not received");
}

void SituationMapTestsMain::checkCenter()
{
  QTest::qWait(timeToDelay);

  int scaleSAVE      = d->m_map->scale();
  QPointF centerSAVE = d->m_map->centerPoint();

  {
    // real check:
    QPointF center(LtsCoordTrans::geographicFromMgrs(QStringLiteral("32UMD9100084500"))); // Bremen motorway junction

    // double xmin, double ymin, double xmax, double ymax
    d->m_map->setExtent(center.x() - 0.01, center.y() - 0.01,
                        center.x() + 0.01, center.y() + 0.01);

    QPointF readCenter = d->m_map->centerPoint();
    DEBUG_LOG(m_logger) << "Center: " << center << " got: " << readCenter;

    QPointF dist = center - readCenter;

    INFO_LOG(m_logger) << LOGFUNCTION
                       << " center =" << center
                       << " read center =" << readCenter
                       << " dist.manhattanLength=" << dist.manhattanLength();

    QVERIFY2(dist.manhattanLength() < 10, "checkCenter failed");
    //  QVERIFY2(center.toPoint()==QPoint(5500, 5500), "checkCenter failed");

    QTest::qWait(timeToDelay);
  }

  // restore old values:
  d->m_map->setScale(scaleSAVE);
  d->m_map->setCenterPoint(centerSAVE);
  QTest::qWait(timeToDelay);
}

void SituationMapTestsMain::checkExtent()
{
  const QPointF centerPnt(LtsCoordTrans::geographicFromMgrs(QStringLiteral("32UMD9100084500"))); // Bremen motorway junction

  d->m_map->setCenterPoint(centerPnt, 500000); // what is the useful
  QTest::qWait(1000); // Let map react

  // some 'reference' values:
  QPointF center     = d->m_map->centerPoint();
  QRectF  extent     = d->m_map->extent();
//  QRectF  fullExtent = d->m_map->fullExtent();

  INFO_LOG(m_logger) << LOGFUNCTION << " center      = " << center;
  INFO_LOG(m_logger) << LOGFUNCTION << " extent      = " << extent;
//  INFO_LOG(m_logger) << LOGFUNCTION << " fullExtent  = " << fullExtent;

  QVERIFY2(extent.    contains(center), "extent.contains failed");
//  QVERIFY2(fullExtent.contains(center), "fullExtent.contains failed");
//  QVERIFY2(fullExtent.contains(extent.topLeft()),     "fullExtent.contains failed");
//  QVERIFY2(fullExtent.contains(extent.topRight()),    "fullExtent.contains failed");
//  QVERIFY2(fullExtent.contains(extent.bottomLeft()),  "fullExtent.contains failed");
//  QVERIFY2(fullExtent.contains(extent.bottomRight()), "fullExtent.contains failed");
  QTest::qWait(1000); // Let map react

  INFO_LOG(m_logger) << LOGFUNCTION << " set identical values now....";

  // I
  // set extent (as QRectF)
  QTest::qWait(1000); // Let map react
  d->m_map->setExtent(extent);
  QTest::qWait(1000); // Let map react

  // reference extent and new extent should be identical:
  QRectF  newExtent = d->m_map->extent();
  QCOMPARE(newExtent.x(), extent.x());
  QCOMPARE(newExtent.y(), extent.y());
  QCOMPARE(newExtent.width(), extent.width());
  QCOMPARE(newExtent.height(), extent.height());


/*
  // III
  // set fullExtent (as QRectF)
  QTest::qWait(1000); // Let map react
  d->m_map->setFullExtent(fullExtent);
  QTest::qWait(1000); // Let map react

  // reference fullExtent and new fullExtent should be identical:
  QRectF  newFullExtent = d->m_map->fullExtent();
  QCOMPARE(newFullExtent.x(), fullExtent.x());
  QCOMPARE(newFullExtent.y(), fullExtent.y());
  QCOMPARE(newFullExtent.width(), fullExtent.width());
  QCOMPARE(newFullExtent.height(), fullExtent.height());
*/
}



void SituationMapTestsMain::checkMapIsUTM()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  if (d->m_map->layerFactory().isUsingBaseMapBuiltIn())
  {
    #ifdef Q_OS_WIN
      NOTICE_LOG(m_logger) << LOGFUNCTION << "***** !!! skipping test - isUsingBaseMapBuiltIn() = true !!! *****";
    #else
      // Escape sequenz \e[31m should provide a red colored log output but doesn't work for all compilers and terminal types!!! JT 2016/07/13
      NOTICE_LOG(m_logger) << LOGFUNCTION << "\e[31m !!! skipping test - isUsingBaseMapBuiltIn() = true !!! \e[0m";
      NOTICE_LOG(m_logger) << LOGFUNCTION << "\e[31m !!! skipping test - isUsingBaseMapBuiltIn() = true !!! \e[0m";
      NOTICE_LOG(m_logger) << LOGFUNCTION << "\e[31m !!! skipping test - isUsingBaseMapBuiltIn() = true !!! \e[0m";
      NOTICE_LOG(m_logger) << LOGFUNCTION << "\e[31m !!! skipping test - isUsingBaseMapBuiltIn() = true !!! \e[0m";
      NOTICE_LOG(m_logger) << LOGFUNCTION << "\e[31m !!! skipping test - isUsingBaseMapBuiltIn() = true !!! \e[0m";
    #endif
    return;
  }

  int currentWkid = d->m_map->wkid();

  INFO_LOG(m_logger) << LOGFUNCTION
                     << " currentWkid = " << currentWkid;

  char wkidInfo[50];
  sprintf(&wkidInfo[0], "wkid failed (wkid = %d)", currentWkid);

  QVERIFY2(currentWkid == 32632, &wkidInfo[0]);   // wkid=32632 (UTM Zone 32 N WGS 84) / Bremen


  // SimCoords:
  QPointF simPosTopLeft     = d->m_map->viewPortWindowPointToGeoCoordinate(QPoint(0, 0));
  QPointF simPosBottomLeft  = d->m_map->viewPortWindowPointToGeoCoordinate(QPoint(0, 1000));

  QPointF simPosTopRight    = d->m_map->viewPortWindowPointToGeoCoordinate(QPoint(1000, 0));
  QPointF simPosBottomRight = d->m_map->viewPortWindowPointToGeoCoordinate(QPoint(1000, 1000));

  INFO_LOG(m_logger) << LOGFUNCTION << " tl = " << simPosTopLeft    << " tr = " << simPosTopRight;
  INFO_LOG(m_logger) << LOGFUNCTION << " bl = " << simPosBottomLeft << " br = " << simPosBottomRight;

//  2015-11-17 tl = QPointF(75954.216#96400.032) tr = QPointF(107704.280#96400.032)
//  2015-11-17 bl = QPointF(75954.216#64649.968) br = QPointF(107704.280#64649.968)

  double distXLeft   = simPosTopLeft.x()    - simPosBottomLeft.x();
  double distXRight  = simPosTopRight.x()   - simPosBottomRight.x();
  double distYTop    = simPosTopLeft.y()    - simPosTopRight.y();
  double distYBottom = simPosBottomLeft.y() - simPosBottomRight.y();

  INFO_LOG(m_logger) << LOGFUNCTION
                     << " distXLeft = " << distXLeft
                     << " distXRight = " << distXRight
                     << " distYTop = " << distYTop
                     << " distYBottom = " << distYBottom;

  const double allowError = 1;  //meter
  QVERIFY2(fabs(distXLeft)   < allowError, "distXLeft failed");
  QVERIFY2(fabs(distXRight)  < allowError, "distXRight failed");
  QVERIFY2(fabs(distYTop)    < allowError, "distYTop failed");
  QVERIFY2(fabs(distYBottom) < allowError, "distYBottom failed");

  {
    double distHor = simPosTopLeft.x() - simPosTopRight.x();   // horizontal
    double distVer = simPosTopLeft.y() - simPosBottomLeft.y(); // vertical

    INFO_LOG(m_logger) << LOGFUNCTION
                       << " distHor = " << fabs(distHor)
                       << " distVer = " << fabs(distVer);

    QVERIFY2((fabs(distHor) - fabs(distVer)) < allowError, "dist12 failed");
  }

  QTest::qWait(timeToDelay);
} // SituationMapTestsMain::checkMapIsUTM


void SituationMapTestsMain::convertUTMBasePoint()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();


  double simX = 94500;
  double simY = 81500;

  // here add offset for 32U MD

  double UTMx = simX +  400000 ; // offset M
  double UTMy = simY + 5800000 ; // offset for D

  Esri::ArcGISRuntime::SpatialReference UTMsr(32632);   // UTM Zone 32 N WGS 84

  Esri::ArcGISRuntime::Point UTMbasePoint(UTMx, UTMy, UTMsr);

  Esri::ArcGISRuntime::Point basePointMap = Esri::ArcGISRuntime::GeometryEngine::project(UTMbasePoint,  Esri::ArcGISRuntime::SpatialReference(d->m_map->wkid()));

  INFO_LOG(m_logger) << LOGFUNCTION
                     << " UTMbasePoint, x=" << QString::number(UTMbasePoint.x(), 'f', 9)
                     << " ; " << QString::number(UTMbasePoint.y(), 'f', 9)
                     << " basePointMap, x=" << QString::number(basePointMap.x(), 'f', 9)
                     << " ; " << QString::number(basePointMap.y(), 'f', 9);

  // __asm int 3
} // SituationMapTestsMain::convertUTMBasePoint

void SituationMapTestsMain::checkOriginTranslated()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  CoordTranslationFunctor *coordTransFunctor = d->m_map->coordTranslationFunctor();
  QVERIFY2(coordTransFunctor, "OriginTranslated: coordTransFunctor failed");

  {
    const Point3D pRef(70000, 70000, .0);

    SituationMap::OriginTranslated oTrans;
    oTrans.setCoordTransFunctor(coordTransFunctor);

    // do
    oTrans.setOrigin(pRef);

    // verify
    QVERIFY2(oTrans.isEmpty() == false, "OriginTranslated: isEmpty failed");

    const Point3D originOut = oTrans.origin();
    QVERIFY2(pRef == originOut, "OriginTranslated: origin failed");

    const Point3D originMapOut = oTrans.originTranslated();
    QVERIFY2(pRef != originMapOut, "OriginTranslated: originTranslated failed");

    // Copy
    SituationMap::OriginTranslated oTransCopy;
    QVERIFY2(oTransCopy.isEmpty()   == true,  "OriginTranslated: isEmpty failed");
    QVERIFY2((oTrans == oTransCopy) == false, "OriginTranslated: operator== failed");
    QVERIFY2((oTrans != oTransCopy) == true,  "OriginTranslated: operator!= failed");

    oTransCopy = oTrans;
    QVERIFY2(oTransCopy.isEmpty()   == false, "OriginTranslated: isEmpty failed");
    QVERIFY2((oTrans == oTransCopy) == true,  "OriginTranslated: operator== failed");
    QVERIFY2((oTrans != oTransCopy) == false, "OriginTranslated: operator!= failed");
  }
}


class MyPositionsTranslated : public SituationMap::PositionsTranslated
{
public:
  void setPositionsTranslated(const PositionCont &posCont)
  {
    SituationMap::PositionsTranslated::setPositionsTranslated(posCont);
  }
};

void SituationMapTestsMain::checkPositionsTranslated()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  CoordTranslationFunctor *coordTransFunctor = d->m_map->coordTranslationFunctor();
  QVERIFY2(coordTransFunctor, "OriginTranslated: coordTransFunctor failed");

  const QPointF pRef1_2D(LtsCoordTrans::geographicFromMgrs(QStringLiteral("32UMD7000070000")));
  const QPointF pRef2_2D(LtsCoordTrans::geographicFromMgrs(QStringLiteral("32UMD8000080000")));

  const Point3D pRef1(pRef1_2D.x(), pRef1_2D.y(), .0);
  const Point3D pRef2(pRef2_2D.x(), pRef2_2D.y(), .0);

  SituationMap::PositionCont posContRef;
  posContRef << pRef1 << pRef2;

  SituationMap::PositionCont positionsMapOutRef;

  {
    SituationMap::PositionsTranslated pTrans;
    pTrans.setCoordTransFunctor(coordTransFunctor);

    coordTransFunctor->resetProjectionCounter();
    QCOMPARE(coordTransFunctor->projectionCounter(), 0);


    // setPositions
    pTrans.setPositions(posContRef);

    // verify
    QVERIFY2(pTrans.isEmpty()      == false, "PositionsTranslated: isEmpty failed");
    QVERIFY2(pTrans.isTranslated() == false, "PositionsTranslated: isTranslated failed");
    QCOMPARE(pTrans.size(), 2);

    QCOMPARE(pTrans.first(), pRef1);
    QCOMPARE(pTrans.last(), pRef2);

    const SituationMap::PositionCont positionsOut = pTrans.positions();

    QCOMPARE(posContRef, positionsOut);

    positionsMapOutRef = pTrans.positionsTranslated();
    QVERIFY2(pTrans.isTranslated() == true, "PositionsTranslated: isTranslated failed");
    QVERIFY2(posContRef != positionsMapOutRef, "PositionsTranslated: originTranslated failed");

    QCOMPARE(coordTransFunctor->projectionCounter(), 2);

    // Copy -> not allowed
    SituationMap::PositionsTranslated pTransCopy;
    // pTransCopy = pTrans;                        // Compiler error :-)


    // angle are verified within the UnitTest

    // clear
    pTrans.clear();

    // verify
    QVERIFY2(pTrans.isEmpty() == true, "PositionsTranslated: isEmpty failed");
    QVERIFY2(pTrans.size()                       == 0, "PositionsTranslated: size failed");
    QVERIFY2(pTrans.positions().size()           == 0, "PositionsTranslated: size failed");
    QVERIFY2(pTrans.isTranslated() == false, "PositionsTranslated: isTranslated failed");
    QVERIFY2(pTrans.positionsTranslated().size() == 0, "PositionsTranslated: size failed");
    QVERIFY2(pTrans.isTranslated() == true, "PositionsTranslated: isTranslated failed");
    QVERIFY2(coordTransFunctor->projectionCounter() == 2, "OriginTranslated: projectionCounter failed");
  }

  {
    MyPositionsTranslated pTrans;
    pTrans.setCoordTransFunctor(coordTransFunctor);

    coordTransFunctor->resetProjectionCounter();
    QVERIFY2(coordTransFunctor->projectionCounter() == 0, "OriginTranslated: projectionCounter failed");


    // setPositionsTranslated
    pTrans.setPositionsTranslated(positionsMapOutRef);

    // verify
    QVERIFY2(pTrans.isEmpty() == false, "PositionsTranslated: isEmpty failed");
    QVERIFY2(pTrans.isTranslated() == true, "PositionsTranslated: isTranslated failed");
    QCOMPARE(pTrans.size(), 2);

    QVERIFY2( fuzzyCompare(pTrans.first(), pRef1), "PositionsTranslated: verify failed");
    QVERIFY2( fuzzyCompare(pTrans.last(),  pRef2), "PositionsTranslated: verify failed");

    const SituationMap::PositionCont &positionsOut = pTrans.positions();
    QVERIFY2( fuzzyCompare(posContRef, positionsOut), "PositionsTranslated: verify failed");

    QCOMPARE(coordTransFunctor->projectionCounter(), 2);


    // try calling setPositionsTranslated with different values:
    {
      SituationMap::PositionCont positionsMapOutRefCopy = positionsMapOutRef;
      positionsMapOutRefCopy.append(positionsMapOutRefCopy.first());

      pTrans.setPositionsTranslated(positionsMapOutRefCopy);

      qCritical() << " size = " << pTrans.size();
      QVERIFY2(pTrans.isEmpty() == false, "PositionsTranslated: isEmpty failed");
      QVERIFY2(pTrans.isTranslated() == true, "PositionsTranslated: isTranslated failed");
      QCOMPARE(pTrans.size(), 3);

      const SituationMap::PositionCont &positionsOut = pTrans.positions();
      QCOMPARE(positionsOut.size(), 3);

      QVERIFY2( fuzzyCompare(positionsOut.first(), pRef1), "PositionsTranslated: verify failed");
      QVERIFY2( fuzzyCompare(positionsOut[1],      pRef2), "PositionsTranslated: verify failed");
      QVERIFY2( fuzzyCompare(positionsOut.last(),  pRef1), "PositionsTranslated: verify failed");
    }
  }

  // setPositions and then addSinglePosition
  {
    SituationMap::PositionsTranslated pTrans;
    pTrans.setCoordTransFunctor(coordTransFunctor);

    coordTransFunctor->resetProjectionCounter();
    QCOMPARE(coordTransFunctor->projectionCounter(), 0);


    // setPositions
    pTrans.setPositions(posContRef);

    // verify
    QVERIFY2(pTrans.isEmpty() == false, "PositionsTranslated: isEmpty failed");
    QCOMPARE(pTrans.size(), 2);
    QVERIFY2(pTrans.isTranslated() == false, "PositionsTranslated: isTranslated failed");

    // add single position:
    pTrans.addSinglePosition(pRef1);
    QVERIFY2(pTrans.isEmpty() == false, "PositionsTranslated: isEmpty failed");
    QCOMPARE(pTrans.size(), 3);
    QVERIFY2(pTrans.isTranslated() == false, "PositionsTranslated: isTranslated failed");

    QCOMPARE(pTrans.first(), pRef1);
    QCOMPARE(pTrans.last(), pRef1);

    // verify
    const SituationMap::PositionCont positionsOut = pTrans.positions();
    QCOMPARE(positionsOut.size(), 3);
    QCOMPARE(pRef1, positionsOut[2]);
    QVERIFY2(pTrans.isTranslated() == false, "PositionsTranslated: isTranslated failed");

    const SituationMap::PositionCont positionsMapOut333 = pTrans.positionsTranslated();
    QCOMPARE(pTrans.size(), 3);
    QCOMPARE(positionsMapOutRef[0], positionsMapOut333[0]);
    QCOMPARE(positionsMapOutRef[0], positionsMapOut333[2]);
    QVERIFY2(pTrans.isTranslated() == true, "PositionsTranslated: isTranslated failed");
    QCOMPARE(coordTransFunctor->projectionCounter(), 3);


    // setPositions (to original)
    pTrans.setPositions(posContRef);

    // verify
    QVERIFY2(pTrans.isEmpty() == false, "PositionsTranslated: isEmpty failed");
    QCOMPARE(pTrans.size(), 2);
    QVERIFY2(pTrans.isTranslated() == false, "PositionsTranslated: isTranslated failed");

    QCOMPARE(pTrans.first(), pRef1);
    QCOMPARE(pTrans.last(), pRef2);

    const SituationMap::PositionCont positionsMapOut222 = pTrans.positionsTranslated();
    QCOMPARE(pTrans.size(), 2);
    QCOMPARE(positionsMapOutRef, positionsMapOut222);
    QVERIFY2(pTrans.isTranslated() == true, "PositionsTranslated: isTranslated failed");
    QCOMPARE(coordTransFunctor->projectionCounter(), 5);

    // clear
    pTrans.clear();

    // verify
    QVERIFY2(pTrans.isEmpty() == true, "PositionsTranslated: isEmpty failed");
    QVERIFY2(pTrans.size()                       == 0, "PositionsTranslated: size failed");
    QVERIFY2(pTrans.positions().size()           == 0, "PositionsTranslated: size failed");
    QVERIFY2(pTrans.isTranslated() == false, "PositionsTranslated: isTranslated failed");
    QVERIFY2(pTrans.positionsTranslated().size() == 0, "PositionsTranslated: size failed");
    QVERIFY2(pTrans.isTranslated() == true, "PositionsTranslated: isTranslated failed");
    QVERIFY2(coordTransFunctor->projectionCounter() == 5, "OriginTranslated: projectionCounter failed");
  }

  // addSinglePosition
  {
    SituationMap::PositionsTranslated pTrans;
    pTrans.setCoordTransFunctor(coordTransFunctor);

    coordTransFunctor->resetProjectionCounter();
    QVERIFY2(coordTransFunctor->projectionCounter() == 0, "OriginTranslated: projectionCounter failed");


    // verify
    QVERIFY2(pTrans.isEmpty() == true, "PositionsTranslated: isEmpty failed");
    QVERIFY2(pTrans.size()                       == 0, "PositionsTranslated: size failed");
    QVERIFY2(pTrans.positions().size()           == 0, "PositionsTranslated: size failed");
    QVERIFY2(pTrans.isTranslated() == false, "PositionsTranslated: isTranslated failed");
    if (d->m_symbologyType != AdvancedSymbology::SymbologyType::None)   // diversify flow
    {
      QVERIFY2(pTrans.positionsTranslated().size() == 0, "PositionsTranslated: size failed");
      QVERIFY2(pTrans.isTranslated() == true, "PositionsTranslated: isTranslated failed");
    }

    // add single position:
    pTrans.addSinglePosition(pRef1);
    QVERIFY2(pTrans.isEmpty() == false, "PositionsTranslated: isEmpty failed");
    QVERIFY2(pTrans.size() == 1, "PositionsTranslated: size failed");
    QVERIFY2(pTrans.isTranslated() == false, "PositionsTranslated: isTranslated failed");

    QVERIFY2(pTrans.first() == pRef1, "PositionsTranslated: first failed");


    // verify
    const SituationMap::PositionCont positionsOut = pTrans.positions();
    QVERIFY2(positionsOut.size() == 1, "PositionsTranslated: positions failed");
    QVERIFY2(pRef1 == positionsOut[0], "PositionsTranslated: positions failed");
    QVERIFY2(pTrans.isTranslated() == false, "PositionsTranslated: isTranslated failed");

    const SituationMap::PositionCont positionsMapOut333 = pTrans.positionsTranslated();
    QVERIFY2(positionsMapOut333.size() == 1, "PositionsTranslated: size failed");
    QVERIFY2(positionsMapOutRef[0] == positionsMapOut333[0], "PositionsTranslated: positionsTranslated failed");
    QVERIFY2(pTrans.isTranslated() == true, "PositionsTranslated: isTranslated failed");
    QVERIFY2(coordTransFunctor->projectionCounter() == 1, "OriginTranslated: projectionCounter failed");


    // setPositions (to original)
    pTrans.setPositions(posContRef);

    // verify
    QVERIFY2(pTrans.isEmpty() == false, "PositionsTranslated: isEmpty failed");
    QVERIFY2(pTrans.size() == 2, "PositionsTranslated: size failed");
    QVERIFY2(pTrans.isTranslated() == false, "PositionsTranslated: isTranslated failed");

    const SituationMap::PositionCont positionsMapOut222 = pTrans.positionsTranslated();
    QVERIFY2(pTrans.size() == 2, "PositionsTranslated: size failed");
    QVERIFY2(positionsMapOutRef == positionsMapOut222, "PositionsTranslated: positionsTranslated failed");
    QVERIFY2(pTrans.isTranslated() == true, "PositionsTranslated: isTranslated failed");
    QVERIFY2(coordTransFunctor->projectionCounter() == 3, "OriginTranslated: projectionCounter failed");

    // clear
    pTrans.clear();

    // verify
    QVERIFY2(pTrans.isEmpty() == true, "PositionsTranslated: isEmpty failed");
    QVERIFY2(pTrans.size()                       == 0, "PositionsTranslated: size failed");
    QVERIFY2(pTrans.positions().size()           == 0, "PositionsTranslated: size failed");
    QVERIFY2(pTrans.isTranslated() == false, "PositionsTranslated: isTranslated failed");
    QVERIFY2(pTrans.positionsTranslated().size() == 0, "PositionsTranslated: size failed");
    QVERIFY2(pTrans.isTranslated() == true, "PositionsTranslated: isTranslated failed");
    QVERIFY2(coordTransFunctor->projectionCounter() == 3, "OriginTranslated: projectionCounter failed");
  }
}

void SituationMapTestsMain::checkPositionAngles()
{
  // here we check if the angle calculation works as expected
  // -> the underlying coord system used for calculation must be orthogonal - e.g. UTM

  CoordTranslationFunctor *coordTransFunctor = d->m_map->coordTranslationFunctor();
  SituationMap::PositionsTranslated pTrans;
  pTrans.setCoordTransFunctor(coordTransFunctor);

  {
    // first check: we use an orthogonal triangle --> 0,0, 0,4 3,4
    QList<QPointF> posCont2D({LtsCoordTrans::geographicFromMgrs(QStringLiteral("32UMD8000080000")),   // p0
                                        LtsCoordTrans::geographicFromMgrs(QStringLiteral("32UMD8000080004")),   // p1
                                        LtsCoordTrans::geographicFromMgrs(QStringLiteral("32UMD8000380004"))}); // p2
    SituationMap::PositionCont posCont = SituationMap::convert2D3D(posCont2D);

    pTrans.setPositions(posCont);
    const double start = 0;
    //const double close = 210;  // p2 -> p0
    // calculated value:
    const double close = 216.86989765331455;  // p2 -> p0
    const double end = 90;    // p1 -> p2

    const double angleStart = pTrans.angleOfStartSegment();
    const double angleClose = pTrans.angleOfClosingSegment();
    const double angleEnd = pTrans.angleOfEndSegment();
    qDebug("Start: %20.15lf, Close: %20.15lf, End: %20.15lf", angleStart, angleClose, angleEnd);
    QVERIFY2(qFuzzyCompare(angleStart, start), qPrintable(QStringLiteral("Start angle is not %1 degrees").arg(start)));
    QVERIFY2(qFuzzyCompare(angleClose, close), qPrintable(QStringLiteral("Close angle is not %1 degrees").arg(close)));
    QVERIFY2(qFuzzyCompare(angleEnd,     end), qPrintable(QStringLiteral("End angle is not %1 degrees").arg(end)));
  }

  {
    // second check: a 'normal' triangle
    QList<QPointF> posCont2D({LtsCoordTrans::geographicFromMgrs(QStringLiteral("32UMD8000080000")),
                                        LtsCoordTrans::geographicFromMgrs(QStringLiteral("32UMD8000080004")),
                                        LtsCoordTrans::geographicFromMgrs(QStringLiteral("32UMD8000480004"))});
    SituationMap::PositionCont posCont = SituationMap::convert2D3D(posCont2D);


    pTrans.setPositions(posCont);
    const double start = 0;
    const double close = 225.00000000667;  // should be not correct
    const double end   = 90;

    const double angleStart = pTrans.angleOfStartSegment();
    const double angleClose = pTrans.angleOfClosingSegment();
    const double angleEnd = pTrans.angleOfEndSegment();
    qDebug("Start: %20.15lf, Close: %20.15lf, End: %20.15lf", angleStart, angleClose, angleEnd);
    QVERIFY2(qFuzzyCompare(angleStart, start), qPrintable(QStringLiteral("Start angle is not %1 degrees").arg(start)));
    QVERIFY2(qFuzzyCompare(angleClose, close), qPrintable(QStringLiteral("Close angle is not %1 degrees").arg(close)));
    QVERIFY2(qFuzzyCompare(angleEnd, end), qPrintable(QStringLiteral("End angle is not %1 degrees").arg(end)));
  }
}



void SituationMapTestsMain::measureProject()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  QElapsedTimer timer;
  int wkid = d->m_map->wkid();
  if (wkid >= 0)
  {
    Esri::ArcGISRuntime::SpatialReference sr(wkid);

    int jMax = 10000;

    //--------------------------------------------------------------------------
    // create SpatialReference by wkid
    //--------------------------------------------------------------------------
    int wkid = 102100;
    timer.start();
    for (int j = 0; j < jMax; ++j)
    {
      Esri::ArcGISRuntime::SpatialReference temp(wkid);
      int help = temp.wkid();
      Q_UNUSED(help);
    }
    qint64 msec = timer.elapsed();
    qDebug() << " create SpatialReference by wkid (" << wkid << "): " << jMax <<  " operations took " << msec << "ms";

    //--------------------------------------------------------------------------
    // create SpatialReference by wkt
    //--------------------------------------------------------------------------
    QLatin1String SpatialReferenceWkt(
      "PROJCS[\"WGS_1984_Web_Mercator_Auxiliary_Sphere\",\
        GEOGCS[\"GCS_WGS_1984\",\
        DATUM[\"D_WGS_1984\",\
        SPHEROID[\"WGS_1984\",6378137.0,298.257223563]],\
        PRIMEM[\"Greenwich\",0.0],\
        UNIT[\"Degree\",0.0174532925199433]],\
        PROJECTION[\"Mercator_Auxiliary_Sphere\"],\
        PARAMETER[\"False_Easting\",0.0],\
        PARAMETER[\"False_Northing\",0.0],\
        PARAMETER[\"Central_Meridian\",0.0],\
        PARAMETER[\"Standard_Parallel_1\",0.0],\
        PARAMETER[\"Auxiliary_Sphere_Type\",0.0],\
        UNIT[\"Meter\",1.0]]\"");
    timer.restart();
    for (int j = 0; j < jMax; ++j)
    {
      Esri::ArcGISRuntime::SpatialReference temp(SpatialReferenceWkt);
      int help = temp.wkid();
      Q_UNUSED(help);
    }
    msec = timer.elapsed();
    qDebug() << " create SpatialReference by wkt (" << wkid << "): " << jMax <<  " operations took " << msec << "ms";


    //--------------------------------------------------------------------------
    // null projection map to map
    //--------------------------------------------------------------------------
    timer.restart();
    for (int j = 0; j < jMax; ++j)
    {
      Esri::ArcGISRuntime::Point source(1000000, 1000000 + j, sr);
      Esri::ArcGISRuntime::Point bremenPoint = Esri::ArcGISRuntime::GeometryEngine::project(source, sr);
      Q_UNUSED(bremenPoint);
    }
    msec = timer.elapsed();
    qDebug() << " null projection (" << wkid << "): " << jMax <<  " operations took " << msec << "ms";


    //--------------------------------------------------------------------------
    // project sim to map (BREMEN)
    //--------------------------------------------------------------------------
    timer.restart();
    const Esri::ArcGISRuntime::SpatialReference &destSR = sr;
    // Bremen: basePoint='32UMD 00000 00000' offset x=400000 (M) ; 5800000 (D) ; wkid=32632 (UTM Zone 32 N WGS 84)
    const Esri::ArcGISRuntime::SpatialReference  sourceSR(32632);
    for (int j = 0; j < jMax; ++j)
    {
      Esri::ArcGISRuntime::Point simPoint(90000, 78000 + j, sourceSR);
      Esri::ArcGISRuntime::Point mapPoint = Esri::ArcGISRuntime::GeometryEngine::project(simPoint, destSR);
      Q_UNUSED(mapPoint);
    }
    msec = timer.elapsed();
    qDebug() << " simple sim2Map: " << jMax <<  " operations took " << msec << "ms";



    {
      //--------------------------------------------------------------------------
      // project lat/long to map (WGS84 to map) 1
      //--------------------------------------------------------------------------
      timer.restart();
      for (int j = 0; j < jMax; ++j)
      {
        // Esri::ArcGISRuntime::SpatialReference sr(4236);  // EPSG:4236 = WGS84
        Esri::ArcGISRuntime::SpatialReference sr = static_cast<MapImpl*>(d->m_map)->getEsriSpatialReference();
        Esri::ArcGISRuntime::Point myPoint(0.155, 0.926 + (j * 0.001), sr);
        Esri::ArcGISRuntime::Point bremenPoint = Esri::ArcGISRuntime::GeometryEngine::project(myPoint, sr);
        Q_UNUSED(bremenPoint);
      }
      msec = timer.elapsed();
      qDebug() << " Lat/Long (WGS84) to map 1 (" << wkid << "): " << jMax <<  " operations took " << msec << "ms";


      //--------------------------------------------------------------------------
      // project lat/long to map (WGS84 to map) geographicToMap 2D
      //--------------------------------------------------------------------------
      timer.restart();
      CoordTranslationFunctor *coordFunc = d->m_map->coordTranslationFunctor();
      for (int j = 0; j < jMax; ++j)
      {
        const QPointF &res = coordFunc->geographicToMap(QPointF(0.155, 0.926 + (j * 0.001)));
        Q_UNUSED(res);
      }
      msec = timer.elapsed();
      qDebug() << " Lat/Long (WGS84) to map (geographicToMap 2D) " << jMax <<  " operations took " << msec << "ms";


      //--------------------------------------------------------------------------
      // project lat/long to map (WGS84 to map) geographicToMap Point3D
      //--------------------------------------------------------------------------
      timer.restart();
      for (int j = 0; j < jMax; ++j)
      {
        const Point3D &res = coordFunc->geographicToMap(Point3D(0.155, 0.926 + (j * 0.001), 1.23456));
        Q_UNUSED(res);
      }
      msec = timer.elapsed();
      qDebug() << " Lat/Long (WGS84) to map (geographicToMap Point3D) " << jMax <<  " operations took " << msec << "ms";
    }


    //--------------------------------------------------------------------------
    // project FalseEasting/Northing to map (to map)
    //--------------------------------------------------------------------------
    QLatin1String myWkt(
      "PROJCS[\"WGS_1984_Web_Mercator_Auxiliary_Sphere\",\
        GEOGCS[\"GCS_WGS_1984\",\
        DATUM[\"D_WGS_1984\",\
        SPHEROID[\"WGS_1984\",6378137.0,298.257223563]],\
        PRIMEM[\"Greenwich\",0.0],\
        UNIT[\"Degree\",0.0174532925199433]],\
        PROJECTION[\"Mercator_Auxiliary_Sphere\"],\
        PARAMETER[\"False_Easting\",1000000.0],\
        PARAMETER[\"False_Northing\",1000000.0],\
        PARAMETER[\"Central_Meridian\",0.0],\
        PARAMETER[\"Standard_Parallel_1\",0.0],\
        PARAMETER[\"Auxiliary_Sphere_Type\",0.0],\
        UNIT[\"Meter\",1.0]]\"");

    int i = 1000000;

    {
      Esri::ArcGISRuntime::SpatialReference mySR(myWkt);

      timer.restart();
      for (int j = 0; j < jMax; ++j)
      {
        Esri::ArcGISRuntime::Point myPoint(i, i + j, mySR);
        Esri::ArcGISRuntime::Point projPoint = Esri::ArcGISRuntime::GeometryEngine::project(myPoint, sr);
        Q_UNUSED(projPoint);
      }
      msec = timer.elapsed();
    }
    qDebug() << " FalseEasting/Northing to map (" << wkid << "): " << jMax <<  " operations took " << msec << "ms";
  }
  else
    ERROR_LOG(m_logger) << " wkid invalid";
}

void SituationMapTestsMain::measurceLocationToElevationBulk()
{
  SituationMap::LayerFactory &layerFac = d->m_map->layerFactory();
  SituationMap::LayerFactoryImpl *layerFacImpl = dynamic_cast<SituationMap::LayerFactoryImpl *>(&layerFac);

  MapImpl *mapImpl = static_cast<SituationMap::MapImpl *>(d->m_map);

  LocationToElevationBulk leBulk;
  leBulk.init(d->m_map, layerFacImpl->baseSurface());

  leBulk.addLocation(Esri::ArcGISRuntime::Point(495000, 5880000, mapImpl->getEsriSpatialReference()));
  leBulk.addLocation(Esri::ArcGISRuntime::Point(495100, 5881000, mapImpl->getEsriSpatialReference()));

  QSignalSpy spy(&leBulk, &LocationToElevationBulk::locationsToElevationsCompleted);

  leBulk.start();

  QTRY_VERIFY2(spy.count() == 1, "LocationToElevationBulk: signalCount failed,");
}

void SituationMapTestsMain::checkMapObjectProperties()
{
  SituationMap::RefPointer<SituationMap::BuildingOutline> mapObject =
    d->m_map->objectFactory().create<SituationMap::BuildingOutline>(QLatin1String("AES"), QLatin1String("checkMapObjectPropertiesDebugInfo"));

  QVariant variant;
  bool success;

  // check property
  variant = mapObject->property("propA");
  QVERIFY2(!variant.isValid(), "variant should be INVALID");

  // check setProperty
  // set to '4711'
  variant.setValue(4711);
  QVERIFY2(variant.isValid(), "variant should be ok");

  success = mapObject->setProperty("propA", variant);
  QVERIFY2(success, "setProperty failed");

  // get property '4711'
  variant.clear();
  variant = mapObject->property("propA");
  QVERIFY2(variant.isValid(), "property should be ok");
  QVERIFY2(variant.toInt() == 4711, "property failed");

  // change to '4712'
  variant.setValue(4712);
  QVERIFY2(variant.isValid(), "variant should be ok");
  success = mapObject->setProperty("propA", variant);
  QVERIFY2(success, "setProperty failed");

  // get property '4712'
  variant.clear();
  variant = mapObject->property("propA");
  QVERIFY2(variant.isValid(), "property failed");
  QVERIFY2(variant.toInt() == 4712, "property failed");


  //*******************
  // invalid QVariant:
  //*******************
  QVariant variantInvalid;
  QVERIFY2(!variantInvalid.isValid(), "variantInvalid failed");
  success = mapObject->setProperty("propA", variantInvalid);    // to remove property
  QVERIFY2(success, "setProperty failed");

  variant.clear();
  variant = mapObject->property("propA");                       // get non-existing property
  QVERIFY2(!variant.isValid(), "variant should be INVALID");


  success = mapObject->setProperty("doesNotExist", variantInvalid);    // use non-existing propertyName
  QVERIFY2(!success, "setProperty failed");

  //*******************
  // Two Properties:
  //*******************
  success = mapObject->setProperty("propA", 4711);
  QVERIFY2(success, "setPropertyA failed");
  success = mapObject->setProperty("propB", 4712);
  QVERIFY2(success, "setPropertyB failed");

  variant.clear();
  variant = mapObject->property("propA");
  QVERIFY2(variant.toInt() == 4711, "property failed");

  variant.clear();
  variant = mapObject->property("propB");
  QVERIFY2(variant.toInt() == 4712, "property failed");



  //************************
  // Removing / Destroying
  //************************
  mapObject->removeMySelf();

}

void SituationMapTestsMain::checkObjectFactoryContainer()
{
  QElapsedTimer timer;
  timer.start();

  uint buildingId = 0;
  uint bAgentId   = 0;

  // mapObject 'BuildingOutline' -> 10
  for (int i = 0; i < 10; ++i)
  {
    SituationMap::RefPointer<SituationMap::BuildingOutline> building =
      d->m_map->objectFactory().create<SituationMap::BuildingOutline>(QLatin1String("AES"));
    QVERIFY2(building != nullptr, "create failed");
    building->setDebugInfo(QStringLiteral("building_%1").arg(i));

    buildingId = building->uniqueMapId();
  }

  // mapObject 'BiologicalAgent' -> 100
  for (int i = 0; i < 100; ++i)
  {
    SituationMap::RefPointer<SituationMap::BiologicalAgent> biologicalAgent =
      d->m_map->objectFactory().create<SituationMap::BiologicalAgent>(QLatin1String("AES"));
    QVERIFY2(biologicalAgent != nullptr, "create failed");
    biologicalAgent->setDebugInfo(QStringLiteral("biologicalAgent_%1").arg(i));

    biologicalAgent->setProperty("TYPE", QLatin1String("BiologicalAgent"));
    bAgentId = biologicalAgent->uniqueMapId();
  }

  // mapObject 'Participant' -> 1000
  for (int i = 0; i < 1000; ++i)
  {
    SituationMap::RefPointer<SituationMap::Participant> participant =
      d->m_map->objectFactory().create<SituationMap::Participant>(QLatin1String("Participants"));
    QVERIFY2(participant != nullptr, "create failed");
    participant->setDebugInfo(QStringLiteral("participant_%1").arg(i));
  }


  quint32 countUsedIds = d->m_map->objectFactory().count();
  QVERIFY2(countUsedIds == 1110, "wrong number of objects");

  bool contains = false;

  // simple contains
  contains = d->m_map->objectFactory().contains(11); // random select
  QVERIFY2(contains, "contains failed");

  contains = d->m_map->objectFactory().contains(123456789); // random select
  QVERIFY2(!contains, "contains failed");


  // assume, that '5' is a building:

  // simple contains
  contains = d->m_map->objectFactory().contains(buildingId);
  QVERIFY2(contains, "contains failed");

  // typed contains
  contains = d->m_map->objectFactory().contains<SituationMap::BiologicalAgent>(buildingId);
  QVERIFY2(!contains, "typed contains failed");

  // get
  {
    SituationMap::RefPointer<SituationMap::AbstractMapObject> obj = d->m_map->objectFactory().get(buildingId);
    QVERIFY2(obj != nullptr, "get failed");
    QVERIFY2(obj.get(), "get failed");
    QVERIFY2(obj->uniqueMapId() == buildingId, "get failed");
    int compare = obj->debugInfo().compare(QStringLiteral("building_9"), Qt::CaseInsensitive);
    QVERIFY2(compare == 0, "get failed");
  }



  // get
  {
    SituationMap::RefPointer<SituationMap::AbstractMapObject> obj = d->m_map->objectFactory().get(123456789);
    QVERIFY2(obj == nullptr, "get failed");
    QVERIFY2(!obj.get(), "get failed");
  }


  // typed get
  {
    SituationMap::RefPointer<SituationMap::BiologicalAgent>bAgent
        = d->m_map->objectFactory().get<SituationMap::BiologicalAgent>(bAgentId);
    QVERIFY2(bAgent != nullptr, "typed get#1 failed");
    QVERIFY2(bAgent.get(), "typed get#2 failed");
    QVERIFY2(bAgent->uniqueMapId() == bAgentId, "get failed");
  }


  {
    QElapsedTimer innerTimer;
    innerTimer.start();

    for (int j = 0; j < 100; ++j)
    {
      int found = 0;
      for (int i = 1000; i > 0; --i)
      {
        // get
        SituationMap::RefPointer<SituationMap::AbstractMapObject> mapObj
          = d->m_map->objectFactory().get(i);
        if (mapObj.valid())
          ++found;
      }
      QVERIFY2(found == 1000, "typed get#3 failed");
    }

    INFO_LOG(m_logger) << " get (base type)          took " << innerTimer.elapsed() << "ms";
  }
  {
    QElapsedTimer innerTimer;
    innerTimer.start();

    for (int j = 0; j < 100; ++j)
    {
      int found = 0;
      for (int i = 1000; i > 0; --i)
      {
        // typed get
        SituationMap::RefPointer<SituationMap::BiologicalAgent>bAgent
          = d->m_map->objectFactory().get<SituationMap::BiologicalAgent>(i);
        if (bAgent.valid())
          ++found;
      }
      QVERIFY2(found == 100, "typed get#3 failed");
    }

    INFO_LOG(m_logger) << " get (selected by type)   took " << innerTimer.elapsed() << "ms";
  }
  {
    QElapsedTimer innerTimer;
    innerTimer.start();

    for (int j = 0; j < 100; ++j)
    {
      int found = 0;
      for (int i = 1000; i > 0; --i)
      {
        // get
        SituationMap::RefPointer<SituationMap::AbstractMapObject> mapObj
          = d->m_map->objectFactory().get(i);
        if (mapObj.valid() && mapObj->property("TYPE").toString().compare(QLatin1String("BiologicalAgent")) == 0)
          ++found;
      }
      QVERIFY2(found == 100, "typed get#3 failed");
    }

    INFO_LOG(m_logger) << " get (selected by QLatin1String) took " << innerTimer.elapsed() << "ms";
  }

  INFO_LOG(m_logger) << " checkObjectFactoryContainer took " << timer.elapsed() << "ms";

}

void SituationMapTestsMain::checkObjectAndLayerFactory()
{
  // Preperations:
  bool success = false;

  initTestCase();
  checkMapReady();

  SituationMap::LayerFactory &layerFac = d->m_map->layerFactory();
  SituationMap::ObjectFactory &objFac = d->m_map->objectFactory();

  {

    INFO_LOG(m_logger) << " technicalLayerCount = " << d->m_map->technicalLayerCount();


    INFO_LOG(m_logger) << " layernames = " << layerFac.layernames().join(QLatin1String(";"));
    int basemapCount        = layerFac.layernames(LayerType::Basemap).count();
    int jumpPointLayerCount = layerFac.layernames(LayerType::JumpPoint).count();
    int objectLayerCount    = layerFac.layernames(LayerType::Operational).count();
    QVERIFY2((1 <= basemapCount) && (basemapCount <= 3), "layerFactory: count failed");
    QVERIFY2(objectLayerCount == 13, QString(QStringLiteral("layerFactory: count failed (is %1)")).arg(objectLayerCount).toStdString().c_str());

    QVERIFY2(d->m_map->technicalLayerCount() == basemapCount ,   "layerFactory: technicalLayerCount failed");
    QVERIFY2(layerFac.count() == basemapCount + jumpPointLayerCount + objectLayerCount , "layerFactory: count failed");

    INFO_LOG(m_logger) << " objFac.count() ="  << objFac.count();



    qDebug() << " technicalLayerCount =" << d->m_map->technicalLayerCount();

    int initialObjCount = objFac.count();

    // use an LOGICAL layer (not basemap)
    QStringList layernames = layerFac.layernames(LayerType::Operational);
    QString layername = layernames[0];
    QVERIFY2(layername.isEmpty() == false, "objectFactory: count failed");

    // real test
    QVERIFY2(objFac.count() == 0, "objectFactory: count failed");
    QVERIFY2(d->m_map->technicalLayerCount() == basemapCount , "layerFactory: technicalLayerCount failed");

    SituationMap::RefPointer<SituationMap::Participant> objPtr1;
    objPtr1 = objFac.create<SituationMap::Participant>(layername, QLatin1String("UnitTestId1"));
    QVERIFY2(objPtr1.valid() == true , "objectFactory: create11 failed");

    SituationMap::RefPointer<SituationMap::BiologicalAgent> objPtr2;
    objPtr2 = objFac.create<SituationMap::BiologicalAgent>(layername, QLatin1String("UnitTestId2"));
    QVERIFY2(objPtr2.valid() == true , "objectFactory: create22 failed");

    SituationMap::RefPointer<SituationMap::BuildingOutline> objPtr3;
    objPtr3 = objFac.create<SituationMap::BuildingOutline>(layername, QLatin1String("UnitTestId3"));
    QVERIFY2(objPtr3.valid() == true , "objectFactory: create33 failed");

    SituationMap::RefPointer<SituationMap::DangerArea> objPtr4;
    objPtr4 = objFac.create<SituationMap::DangerArea>(layername, QLatin1String("UnitTestId4"));
    QVERIFY2(objPtr4.valid() == true , "objectFactory: create44 failed");

    QVERIFY2(objFac.count() == (initialObjCount + 4) , "objectFactory: count failed");


    // now set required parameters:
    QPointF offset = QPointF(50000, 50000);
    int extent = 30000;
    QList<QPointF> posCont2D;
    posCont2D << s_basePoint.geographic( offset - QPointF(     0,      0) );
    posCont2D << s_basePoint.geographic( offset - QPointF(extent,      0) );
    posCont2D << s_basePoint.geographic( offset - QPointF(extent, extent) );
    posCont2D << s_basePoint.geographic( offset - QPointF(     0, extent) );

    objPtr3->setPositions(convert2D3D(posCont2D));

    // => technicalLayerCount increases by 1/one, caused by objFac.create<>)
    QVERIFY2(d->m_map->technicalLayerCount() == basemapCount + 1 , "layerFactory: technicalLayerCount failed");

    // now update the objects (to let layerFactory create  MessageGroupLayer implicit/onDemand)
    success = objPtr3->updateView();
    QVERIFY2(success , "object: updateView failed");


    qDebug() << " technicalLayerCount =" << d->m_map->technicalLayerCount();

    if (d->m_symbologyType != AdvancedSymbology::SymbologyType::None)
    {
      // in the meantime, the corresponding technicalLayer (MessageGroup) for the objects is created
      // => technicalLayerCount increases again by 1/one, caused by objFac.updateView)
//      QVERIFY2(d->m_map->technicalLayerCount() == basemapCount + 1 , "layerFactory: technicalLayerCount failed");
      // => technicalLayerCount increases again by 2/two, caused by objFac.updateView)
      QVERIFY2(d->m_map->technicalLayerCount() == basemapCount + 2 , "layerFactory: technicalLayerCount failed");
    }
    else
      QVERIFY2(d->m_map->technicalLayerCount() == basemapCount + 1 , "layerFactory: technicalLayerCount failed");

  }

  //
  // End of scope -> local RefPointer should be destroyed now:
  //


  //************************
  // Removing / Destroying
  //************************
  const QList<UniqueMapId> allUniqueIds = objFac.getAllKeys();
  qDebug() << " remove, current size()=" << allUniqueIds.size();
  QVERIFY2(objFac.count() == allUniqueIds.size(), "objectFactory: count/size/... inkonsistent");

  int numberRemoved = 0;
  for (SituationMap::UniqueMapId uniqueId : allUniqueIds)
  {
    qDebug() << " remove uniqueId=" << uniqueId << "...";
    {
      RefPointer<AbstractMapObject> mapObj = objFac.get(uniqueId);
      if (mapObj)
      {
        mapObj->removeMySelf();
        ++numberRemoved;
      }
      else
        qWarning() << " uniqueId=" << uniqueId << " not found";
    }
    // End of Scope....
    qDebug() << " remove uniqueId=" << uniqueId << "... Done";
  }
  qDebug() << " remove finished, current size()=" << objFac.count();

  QVERIFY2(allUniqueIds.size() == numberRemoved , "objectFactory: at least one failure");
  QVERIFY2(objFac.count() == 0 , "objectFactory: count failed");
} // checkObjectAndLayerFactory


void SituationMapTestsMain::checkOverlayHandler1()
{
  // use nullptr as map:
  SituationMap::Map *map = nullptr;

  SituationMap::OverlayHandlerImpl oh(map);

  QVERIFY2(oh.overlayCount() == 0 , "OverlayHandler: overlayCount failed");
  QVERIFY2(oh.containsOverlay(123456789) == false , "OverlayHandler: containsOverlay failed");

  bool success = false;

  success = oh.setOverlay(1234, QStringLiteral("OverlayDisplayname"), QByteArray("myInvalidOverlayData"));
  QVERIFY2(success == 0 , "OverlayHandler: setOverlay failed");
  QVERIFY2(oh.overlayCount() == 0 , "OverlayHandler: overlayCount failed");
  QVERIFY2(oh.containsOverlay(1234) == false , "OverlayHandler: containsOverlay failed");
}

void SituationMapTestsMain::checkOverlayHandler2()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  {
    SituationMap::OverlayHandler &oh = d->m_map->overlayHandler();

    QVERIFY2(oh.overlayCount() == 0 , "OverlayHandler: overlayCount failed");
    QVERIFY2(oh.containsOverlay(123456789) == false , "OverlayHandler: containsOverlay failed");

    bool success = false;

    // add invalid data:
    qWarning() << " add invalid data:";
    {
      int layerCountBEFORE = d->m_map->layerFactory().count();

      success = oh.setOverlay(1234, QStringLiteral("OverlayDisplayname"), QByteArray("myInvalidOverlayData"));
      QVERIFY2(success == false, "OverlayHandler: setOverlay failed");
      QVERIFY2(oh.overlayCount() == 0, "OverlayHandler: overlayCount failed");
      QVERIFY2(oh.containsOverlay(1234) == false, "OverlayHandler: containsOverlay failed");

      int layerCountAFTER = d->m_map->layerFactory().count();
      QVERIFY2((layerCountAFTER - layerCountBEFORE) == 0, "OverlayHandler: layerCountDiff failed");

      QSignalSpy spy(d->m_map, &SituationMap::Map::layerOrderChanged);
      QVERIFY2(spy.count() == 0, "OverlayHandler: signalCount failed, layerOrderChanged");
    }
  }
}


void SituationMapTestsMain::checkOverlayHandler3()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  SituationMap::OverlayHandler &oh = d->m_map->overlayHandler();
  QVERIFY2(oh.overlayCount() == 0 , "OverlayHandler: overlayCount failed");
  QVERIFY2(oh.containsOverlay(123456789) == false , "OverlayHandler: containsOverlay failed");

  bool success = false;


  //
  // create PlanData 1:
  //
  QScopedPointer<GeometryModel> geoModel(GeometryModelFactory::singleton()->create());
  QVERIFY2((geoModel != nullptr), "OverlayHandler: Creating empty GeometryModel failed.");

  QList<QPointF>                                    vertexList;
  vertexList << QPointF(0.15, 0.9) << QPointF(0.151, 0.901); // area Bremen

  QList<QPair<GeometryModel::Attribute, QVariant>>  attrList;
  attrList +=  QPair<GeometryModel::Attribute, QVariant>(GeometryModel::Attribute::Color, QVariant(QColor("red")));

  const GeometryModel::Node &node1 = geoModel->addPrimitive(GeometryModel::PrimitiveType::Line, vertexList, attrList);
  QVERIFY2((node1.isValid()), "OverlayHandler: node invalid.");

  QByteArray planData1 = geoModel->toByteArray();
  DEBUG_LOG(m_logger) << LOGFUNCTION << " planData1=" << planData1;


  //
  // create PlanData 2:
  //
  vertexList.clear();
  vertexList << QPointF(0.1511, 0.911) << QPointF(0.15111, 0.9011); // area Bremen
  const GeometryModel::Node &node2 = geoModel->addPrimitive(GeometryModel::PrimitiveType::Line, vertexList, attrList);
  QVERIFY2((node2.isValid()), "OverlayHandler: node invalid.");

  QByteArray planData2 = geoModel->toByteArray();
  DEBUG_LOG(m_logger) << LOGFUNCTION << " planData2=" << planData2;


  //
  // add valid data / planData 1:
  //
  qWarning() << " add valid data / planData 1:";
  {
    int layerCountBEFORE = d->m_map->layerFactory().count();


    QSignalSpy spy(d->m_map, &SituationMap::Map::layerOrderChanged);

    success = oh.setOverlay(1234, QStringLiteral("OverlayDisplayname"), planData1);
    QVERIFY2(success                  == true, "OverlayHandler: setOverlay failed");
    QVERIFY2(oh.overlayCount()        == 1, "OverlayHandler: overlayCount failed");
    QVERIFY2(oh.containsOverlay(1234) == true, "OverlayHandler: containsOverlay failed");
    QVERIFY2(spy.count()              == 1, "signalCount failed, layerOrderChanged");


    int layerCountAFTER = d->m_map->layerFactory().count();
    QVERIFY2((layerCountAFTER - layerCountBEFORE) == 1, "OverlayHandler: layerCountDiff failed");
    DEBUG_LOG(m_logger) << LOGFUNCTION << " ln=" << d->m_map->layerFactory().layernames().join(QLatin1String(";"));


    // verify objCount on EsriLayer
    SituationMap::LayerFactoryImpl *layFacImpl = dynamic_cast<SituationMap::LayerFactoryImpl *>(&d->m_map->layerFactory());
    QVERIFY2((layFacImpl) , "OverlayHandler: layFacImpl failed");
    Esri::ArcGISRuntime::GraphicsOverlay *graphicsLayer = layFacImpl->getGraphicsLayer(QLatin1String("OverlayLayer_1234"));
    QVERIFY2((layFacImpl) , "OverlayHandler: EsriLayer failed");
    int numberOfObjects = graphicsLayer->graphics()->size();
    DEBUG_LOG(m_logger) << LOGFUNCTION << " planData1 -> numberOfObjects=" << numberOfObjects;
    QVERIFY2(numberOfObjects == 1 , "OverlayHandler: numberOfObjects on EsriLayer failed");
  }


  //
  // updateOverlay with planData 2:
  //
  qWarning() << " add valid data / planData 2:";
  {
    QSignalSpy spy(d->m_map, &SituationMap::Map::layerOrderChanged);

    success = oh.setOverlay(1234, QStringLiteral("OverlayDisplayname"), planData2);
    QVERIFY2(success == true, "OverlayHandler: setOverlay failed");

    success = oh.setOverlay(1234, QStringLiteral("OverlayDisplayname"), planData2);
    QVERIFY2(success == true, "OverlayHandler: setOverlay failed");
    QVERIFY2(oh.overlayCount() == 1, "OverlayHandler: overlayCount failed");
    QVERIFY2(oh.containsOverlay(1234) == true, "OverlayHandler: containsOverlay failed");
    QVERIFY2(spy.count() == 0, "signalCount failed, layerOrderChanged");  // == 0 because layer already exists

    // verify objCount on EsriLayer
    SituationMap::LayerFactoryImpl *layFacImpl = dynamic_cast<SituationMap::LayerFactoryImpl *>(&d->m_map->layerFactory());
    QVERIFY2((layFacImpl) , "OverlayHandler: layFacImpl failed");
    Esri::ArcGISRuntime::GraphicsOverlay *graphicsLayer = layFacImpl->getGraphicsLayer(QLatin1String("OverlayLayer_1234"));
    QVERIFY2((layFacImpl) , "OverlayHandler: EsriLayer failed");
    int numberOfObjects = graphicsLayer->graphics()->size();
    DEBUG_LOG(m_logger) << LOGFUNCTION << " planData2 -> numberOfObjects=" << numberOfObjects;
    QVERIFY2(numberOfObjects == 2 , "OverlayHandler: numberOfObjects on EsriLayer failed");
  }


  //
  // check order:
  // OverlayLayer shall be directly on top of the basemaps
  //
  if (1) {
    const QStringList &layerNames = d->m_map->layerFactory().layernames();
    const int layerCount = layerNames.count();
    const int basemapCount = d->m_map->layerFactory().layernames(LayerType::Basemap).count();
    QVERIFY2((layerCount - basemapCount) > 0 , "Order of Layer: count failed"); // preCondition

    const QString &ovlName = layerNames[basemapCount]; // access to successor of basemaps
    const bool match = ovlName.startsWith(QLatin1String("OverlayLayer"));
    QVERIFY2(match == true , "Order of Layer: OverlayLayer is NOT successor of basemaps"); // preCondition
  }


  // removeOverlay
  {
    QSignalSpy spy(d->m_map, &SituationMap::Map::layerOrderChanged);

    int layerCountBEFORE = d->m_map->layerFactory().count();

    bool success = oh.removeOverlay(1234);
    QVERIFY2(success == true, "OverlayHandler: removeOverlay failed");
    QVERIFY2(oh.overlayCount() == 0, "OverlayHandler: overlayCount failed");
    QVERIFY2(oh.containsOverlay(1234) == false, "OverlayHandler: containsOverlay failed");

    QVERIFY2(spy.count() == 1, "signalCount failed, layerOrderChanged");

    int layerCountAFTER = d->m_map->layerFactory().count();
    QVERIFY2((layerCountAFTER - layerCountBEFORE) == -1, "OverlayHandler: layerCountDiff failed");
    DEBUG_LOG(m_logger) << LOGFUNCTION << " ln=" << d->m_map->layerFactory().layernames().join(QLatin1String(";"));
  }

}

/*
void SituationMapTestsMain::checkRubberbandFactory()
{
  initTestCase();
  checkMapReady();

  SituationMap::RB::RubberbandPointFeature *rbandPt = d->m_map->rubberbandFactory().create<SituationMap::RB::RubberbandPointFeature>();

  QVERIFY2(rbandPt != nullptr, "RubberbandFactory::create failed for SituationMap::RB::RubberbandPointFeature");

  SituationMap::RB::RubberbandMultiPointFeature *rbandMPt = d->m_map->rubberbandFactory().create<SituationMap::RB::RubberbandMultiPointFeature>();

  QVERIFY2(rbandMPt == nullptr, "RubberbandFactory::create failed for second rubberband at time");

  if (rbandPt) delete rbandPt;    // here it is ok to use delete directly
  if (rbandMPt) delete rbandMPt;

  rbandMPt = d->m_map->rubberbandFactory().create<SituationMap::RB::RubberbandMultiPointFeature>();

  QVERIFY2(rbandMPt != nullptr, "RubberbandFactory::create failed for SituationMap::RB::RubberbandMultiPointFeature");
  if (rbandMPt) delete rbandMPt;

  // check creating other rubberbands with factory
  SituationMap::RB::Rubberband *rband = d->m_map->rubberbandFactory().create<SituationMap::RB::RubberbandPointCluster>();

  QVERIFY2(rband != nullptr, "RubberbandFactory::create failed for SituationMap::RB::RubberbandPointCluster");
  if (rband) delete rband;

  rband = d->m_map->rubberbandFactory().create<SituationMap::RB::RubberbandArrow>();

  QVERIFY2(rband != nullptr, "RubberbandFactory::create failed for SituationMap::RB::RubberbandArrow");
  if (rband) delete rband;

  rband = d->m_map->rubberbandFactory().create<SituationMap::RB::RubberbandCorridor>();

  QVERIFY2(rband != nullptr, "RubberbandFactory::create failed for SituationMap::RB::RubberbandCorridor");
  if (rband) delete rband;

  rband = d->m_map->rubberbandFactory().create<SituationMap::RB::RubberbandEllipse>();

  QVERIFY2(rband != nullptr, "RubberbandFactory::create failed for SituationMap::RB::RubberbandEllipse");
  if (rband) delete rband;

  rband = d->m_map->rubberbandFactory().create<SituationMap::RB::RubberbandRectangle>();

  QVERIFY2(rband != nullptr, "RubberbandFactory::create failed for SituationMap::RB::RubberbandRectangle");
  if (rband) delete rband;

  rband = d->m_map->rubberbandFactory().create<SituationMap::RB::RubberbandSmoothLine>();

  QVERIFY2(rband != nullptr, "RubberbandFactory::create failed for SituationMap::RB::RubberbandSmoothLine");
  if (rband) delete rband;

} // SituationMapTestsMain::checkRubberbandFactory
*/

void SituationMapTestsMain::measureCoordTranslationFunctor()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  // Bremen: basePoint='32UMD 00000 00000' offset x=400000 (M) ; 5800000 (D) ; wkid=32632 (UTM Zone 32 N WGS 84)
  d->m_map->initCoordTranslationFunctor();

  SituationMap::CoordTranslationFunctor *functor = d->m_map->coordTranslationFunctor();
  QVERIFY2(functor != nullptr, "CoordTranslationFunctor falied");

  QElapsedTimer timer;

  int jMax = 1000;
  {
    timer.start();
    for (int j = 0; j < jMax; ++j)
    {
      QPointF point(0.01, 0.08 + j * 0.0001);
      QPointF ret = functor->geographicToMap(point);
      Q_UNUSED(ret);
    }
    INFO_LOG(m_logger) << " simToMap " << jMax <<  " operations took " << timer.elapsed() << "ms";
  }

  {
    timer.restart();
    for (int j = 0; j < jMax; ++j)
    {
      QPointF point(850000, 6880000 + j);
      QPointF ret = functor->mapToGeographic(point);
      Q_UNUSED(ret);
    }
    INFO_LOG(m_logger) << " mapToSim " << jMax <<  " operations took " << timer.elapsed() << "ms";
  }

} // SituationMapTestsMain::checkRubberbandFactory


void SituationMapTestsMain::checkCoordinateConversion()
{
  // Karte laden fehlt hier noch, nach meinem Urlaub geht's weiter ... JT
  initTestCase();

  checkMapReady();
  checkCenter();

  // d->m_map->setExtent(100000, 100000, 10000000, 10000000);

  QPoint windowPos(400, 200);

  QPointF mapPos = d->m_map->viewPortWindowPointToMapCoordinate(windowPos);
  QPointF geoPos = d->m_map->viewPortWindowPointToGeoCoordinate(windowPos);

  QPointF windowPosMap = d->m_map->mapCoordinateToViewPortWindowPoint(mapPos);
  QPointF windowPosGeo = d->m_map->geoCoordinateToViewPortWindowPoint(geoPos);

  qDebug() << LOGFUNCTION << "ConversionCheck with windowPos " << windowPos;
  qDebug() << "mapPos" << mapPos << " ---> winPos " << windowPosMap;
  qDebug() << "geoPos" << geoPos << " ---> winPos " << windowPosGeo;

  QVERIFY2((windowPos - windowPosMap).manhattanLength() < 5, "Coordinate conversion for map coordinates failed.");
  QVERIFY2((windowPos - windowPosGeo).manhattanLength() < 5, "Coordinate conversion for geo coordinates failed.");

  // define a square
  QPoint wrp1(100, 100);
  QPoint wrp2(300, 100);
  QPoint wrp3(300, 300);
  QPoint wrp4(100, 300);

  QPointF srp1 = d->m_map->viewPortWindowPointToGeoCoordinate(wrp1);
  QPointF srp2 = d->m_map->viewPortWindowPointToGeoCoordinate(wrp2);
  QPointF srp3 = d->m_map->viewPortWindowPointToGeoCoordinate(wrp3);
  QPointF srp4 = d->m_map->viewPortWindowPointToGeoCoordinate(wrp4);

  qreal w1 = srp2.x() - srp1.x();
  qreal w2 = srp3.x() - srp4.x();
  qreal h1 = srp1.y() - srp4.y();
  qreal h2 = srp2.y() - srp3.y();

  QString msg;
  msg = QStringLiteral("Rectangle seems not to be a rectangle under current coordinate projections. (cur wkid=%1").arg(d->m_map->wkid());
  QVERIFY2(fabs(w1 - w2) < 0.1, msg.toUtf8().data());
  QVERIFY2(fabs(h1 - h2) < 0.1, msg.toUtf8().data());

  msg = QStringLiteral("Square seems not to be a square under current coordinate projections. (cur wkid=%1").arg(d->m_map->wkid());
  QVERIFY2(fabs(h1 - w1) < 0.1, msg.toUtf8().data());

  // d->m_map->layerFactory().initializeBasemaps( QStringList(QLatin1String("http://192.168.133.88:6080/arcgis/rest/services/BremenGeoTiffUTM/MapServer"))
  //                                            , AdvancedSymbology::SymbologyType::MIL2525C );

} /* SituationMapTestsMain::checkCoordinateConversion  */


#ifdef CrashUnderWindows
void SituationMapTestsMain::checkCreationAndRemoveMySelf()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  SituationMap::ObjectFactory &objFac   = d->m_map->objectFactory();
  SituationMap::LayerFactory  &layerFac = d->m_map->layerFactory();

  int initialObjCount = objFac.count();

  // use an LOGICAL layer (not basemap)
  QStringList layernames = layerFac.layernames();
  QString layername = layernames[1];

  // real test
  QVERIFY2(objFac.count() == 0, "objectFactory: count failed");

  {
    QList<SituationMap::RefPointer<SituationMap::AbstractMapObject> > objList;

    SituationMap::RefPointer<SituationMap::Participant> objPtr1;
    objPtr1 = objFac.create<SituationMap::Participant>(layername, QLatin1String("UnitTestId1"));
    QVERIFY2(objPtr1.valid() == true , "objectFactory: create11 failed");
    objList.append(SituationMap::RefPointer<SituationMap::AbstractMapObject> (objPtr1.get()));

    SituationMap::RefPointer<SituationMap::BiologicalAgent> objPtr2;
    objPtr2 = objFac.create<SituationMap::BiologicalAgent>(layername, QLatin1String("UnitTestId2"));
    QVERIFY2(objPtr2.valid() == true , "objectFactory: create22 failed");
    objList.append(SituationMap::RefPointer<SituationMap::AbstractMapObject> (objPtr2.get()));

    SituationMap::RefPointer<SituationMap::BuildingOutline> objPtr3;
    objPtr3 = objFac.create<SituationMap::BuildingOutline>(layername, QLatin1String("UnitTestId3"));
    QVERIFY2(objPtr3.valid() == true , "objectFactory: create33 failed");
    objList.append(SituationMap::RefPointer<SituationMap::AbstractMapObject> (objPtr3.get()));

    SituationMap::RefPointer<SituationMap::DangerArea> objPtr4;
    objPtr4 = objFac.create<SituationMap::DangerArea>(layername, QLatin1String("UnitTestId4"));
    QVERIFY2(objPtr4.valid() == true , "objectFactory: create44 failed");
    objList.append(SituationMap::RefPointer<SituationMap::AbstractMapObject> (objPtr4.get()));

    QVERIFY2(objList.count() == 4 , "objList: count failed");
    QVERIFY2(objFac.count() == (initialObjCount + 4) , "objectFactory: count failed");

    // remove all:
    for (SituationMap::RefPointer<SituationMap::AbstractMapObject> item : qAsConst(objList))
      item->removeMySelf();
  }

  QVERIFY2(objFac.count() == 0, "objectFactory: count failed");
}
#endif

//-------------------------------------------------------------------------------------------------------

#define QVERIFY3(statement, description, context) \
  { \
    QString myDesc = QString( QLatin1String("%1:%2") ).arg(context, QLatin1String(description) ); \
    QVERIFY2(statement, myDesc.toUtf8().data()); \
  }


template<class TYPE>
void checkGraphicalObjectVisibility(const QScopedPointer<TYPE> &go, const QString &objName)
{
  // Check visibility:

  // hide:
  go->setVisibility(false);
  QVERIFY3(go->updateView() == true, "updateView failed", objName);

  Esri::ArcGISRuntime::Graphic *graphic = go->graphic();
  QVERIFY3(graphic, "graphic failed", objName);

  // 1
  QVERIFY3(graphic->isVisible() == false, "isVisible failed1", objName);

  // show:
  go->setVisibility(true);
  QVERIFY3(go->updateView() == true, "updateView failed", objName);
  QVERIFY3(go->changed() == false, "changed failed", objName);
  QVERIFY3(graphic->isVisible() == true, "isVisible failed2", objName);

  // hide again:
  go->setVisibility(false);
  QVERIFY3(go->updateView() == true, "updateView failed", objName);
  QVERIFY3(go->changed() == false, "changed failed", objName);
  QVERIFY3(graphic->isVisible() == false, "isVisible failed3", objName);
}


class GraphObj : public SituationMap::AbstractGraphicalObject
{
  using BaseClass = AbstractGraphicalObject;
public:
  using BaseClass::BaseClass;
  using BaseClass::changed;
  using BaseClass::resetChanged;

  bool updateViewImpl() override
  {
    return true;
  }
  bool create() override
  {
    return true;
  }
};

#ifdef CrashUnderWindows
void SituationMapTestsMain::checkGraphicalObject()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  SituationMap::LayerFactory  &layerFac = d->m_map->layerFactory();
  MapImpl *mapImpl = static_cast<SituationMap::MapImpl *>(d->m_map);


  // use an LOGICAL layer (not basemap)
  QStringList layernames = layerFac.layernames();
  QString layername = layernames[1];

  // real test
  static_cast<SituationMap::MapImpl *>(d->m_map)->getGraphicsLayer(layername);


  QScopedPointer<GraphObj> go(new GraphObj(mapImpl->getEsriGeoView(),
                              mapImpl->getGraphicsLayer(layername),
                              QLatin1String("TacticalAppearanceModuleTest"),
                              4712));
  QVERIFY2(go, "objectFactory: GraphObj failed");

  QVERIFY2(go->changed() == true, "GraphObj: changed failed");
  go->resetChanged();
  QVERIFY2(go->changed() == false, "GraphObj: changed failed");

  QVERIFY2(go->isSinglePoint() == false, "GraphObj: isSinglePoint failed");
  QVERIFY2(go->isMultiPoint()  == false, "GraphObj: isMultiPoint failed");
  QVERIFY2(go->isArea()        == false, "GraphObj: isArea failed");
}
#endif

//-------------------------------------------------------------------------------------------------------
class GraphObjEllipse : public SituationMap::GraphicalObjectEllipse
{
  using BaseClass = GraphicalObjectEllipse;

public:
  using BaseClass::BaseClass;
  using BaseClass::changed;
  using BaseClass::resetChanged;
};

void SituationMapTestsMain::checkGraphicalObjectEllipse()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  SituationMap::LayerFactory  &layerFac = d->m_map->layerFactory();
  MapImpl *mapImpl = static_cast<SituationMap::MapImpl *>(d->m_map);

  // use an LOGICAL layer (not basemap)
  QStringList layernames = layerFac.layernames();
  QString layername = layernames[1];

  // real test
  mapImpl->getGraphicsLayer(layername);

  QScopedPointer<GraphObjEllipse> go(new GraphObjEllipse(mapImpl->getEsriGeoView(),
                                                         mapImpl->getGraphicsLayer(layername),
                                                         QLatin1String("TacticalAppearanceModuleTest"),
                                                         4712));
  QVERIFY2(go, "objectFactory: GraphObjEllipse failed");

  QVERIFY2(go->changed() == true, "GraphObjEllipse: changed failed");
  go->resetChanged();
  QVERIFY2(go->changed() == false, "GraphObjEllipse: changed failed");

  QVERIFY2(go->isSinglePoint() == false, "GraphObjEllipse: isSinglePoint failed");
  QVERIFY2(go->isMultiPoint()  == false, "GraphObjEllipse: isMultiPoint failed");
  QVERIFY2(go->isArea()        == false, "GraphObjEllipse: isArea failed");

  go->setOrigin(Point3D(94000, 78000, .0));
  QVERIFY2(go->isSinglePoint() == true, "GraphObjEllipse: isSinglePoint failed");

  SituationMap::EllipseParameters ellipsePara;
  ellipsePara.setLengthX(1000);
  ellipsePara.setLengthY(1000);
  //  ellipsePara.setDirectionDegree(0);   // circle -> irrelevant
  //  ellipsePara.setMaxSegmentLength(10); // use default

  go->setEllipseParameters(ellipsePara);
  QVERIFY2(go->changed() == true, "GraphObjEllipse: changed failed");

  bool success = go->updateView();
  QVERIFY2(success == true, "GraphObjEllipse: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjEllipse: changed failed");

  success = go->updateView();
  QVERIFY2(success == true, "GraphObjEllipse: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjEllipse: changed failed");

  // Check visibility:
  checkGraphicalObjectVisibility(go, QStringLiteral("GraphObjEllipse"));
}

//-------------------------------------------------------------------------------------------------------
class GraphObjPath : public SituationMap::GraphicalObjectPath
{
  using BaseClass = GraphicalObjectPath;

public:
  using BaseClass::BaseClass;
  using BaseClass::changed;
  using BaseClass::resetChanged;
};

template<class TYPE>
void runGraphicalObjectPath(SituationMap::Map *map,
                            const SituationMap::GraphicalObjectPathType type)
{
  SituationMap::LayerFactory  &layerFac = map->layerFactory();
  MapImpl *mapImpl = static_cast<SituationMap::MapImpl *>(map);

  // use an LOGICAL layer (not basemap)
  QStringList layernames = layerFac.layernames();
  QString layername = layernames[1];

  mapImpl->getGraphicsLayer(layername);

  QScopedPointer<TYPE> go(new TYPE(type,
                                   mapImpl->getEsriGeoView(),
                                   mapImpl->getGraphicsLayer(layername),
                                   QLatin1String("TacticalAppearanceModuleTest"),
                                   4712));
  QVERIFY2(go, "objectFactory: GraphObjPath failed");

  QVERIFY2(go->changed() == true, "GraphObjPath: changed failed");
  go->resetChanged();
  QVERIFY2(go->changed() == false, "GraphObjPath: changed failed");

  QVERIFY2(go->isSinglePoint() == false, "GraphObjPath: isSinglePoint failed");
  QVERIFY2(go->isMultiPoint()  == false, "GraphObjPath: isMultiPoint failed");
  QVERIFY2(go->isArea()        == false, "GraphObjPath: isArea failed");

  // With coordinates
  PositionCont posCont;
  posCont << Point3D(94000, 78000, .0);
  posCont << Point3D(95000, 70000, .0);
  posCont << Point3D(94500, 78500, .0);
  go->setPositions(posCont);
  QVERIFY2(go->isSinglePoint() == false, "GraphObjPath: isSinglePoint failed");
  QVERIFY2(go->isMultiPoint()  == true, "GraphObjPath: isSinglePoint failed");
  QVERIFY2(go->isArea()        == true, "GraphObjPath: isSinglePoint failed");

  QVERIFY2(go->changed() == true, "GraphObjPath: changed failed");

  bool success = go->updateView();
  QVERIFY2(success == true, "GraphObjPath: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjPath: changed failed");

  success = go->updateView();
  QVERIFY2(success == true, "GraphObjPath: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjPath: changed failed");

  // check incorrect positions:

  // check doubled start and end position:
  {
    // set positions:
    SituationMap::PositionCont posCont;
    QPointF center = map->centerPoint();
    Point3D center3D(center.x(), center.y(), .0);

    posCont << center3D + Point3D(   0,    0, .0);
    posCont << center3D + Point3D(   0, 5000, .0);
    posCont << center3D + Point3D(5000, 5000, .0);
    posCont << center3D + Point3D(   0,    0, .0);
    go->setPositions(posCont);

    bool success = go->updateView();
    QVERIFY2(success == true, "GraphObjPath: updateView failed");
    success = go->updateView();
    QVERIFY2(success == true, "GraphObjPath: updateView failed");
  }

  // check doubled positions:
  {
    // set positions:
    SituationMap::PositionCont posCont;
    QPointF center = map->centerPoint();
    Point3D center3D(center.x(), center.y(), .0);

    posCont << center3D + Point3D(   0,    0, .0);
    posCont << center3D + Point3D(   0,    0, .0);
    posCont << center3D + Point3D(   0,    0, .0);
    posCont << center3D + Point3D(5000,    0, .0);
    posCont << center3D + Point3D(5000, 5000, .0);
    posCont << center3D + Point3D(   0,    0, .0);
    posCont << center3D + Point3D(   0,    0, .0);
    go->setPositions(posCont);

    bool success = go->updateView();
    QVERIFY2(success == true, "GraphObjPath: updateView failed");
    success = go->updateView();
    QVERIFY2(success == true, "GraphObjPath: updateView failed");
  }

  // Check visibility:
  checkGraphicalObjectVisibility(go, QStringLiteral("GraphObjPath"));
}

void SituationMapTestsMain::checkGraphicalObjectPath()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  // real test
  runGraphicalObjectPath<GraphObjPath>(d->m_map, SituationMap::GraphicalObjectPathType::Polyline);
  runGraphicalObjectPath<GraphObjPath>(d->m_map, SituationMap::GraphicalObjectPathType::Polygon);
}





//-------------------------------------------------------------------------------------------------------
class GraphObjPictureMarker : public SituationMap::GraphicalObjectPictureMarker
{
  using BaseClass = GraphicalObjectPictureMarker;

public:
  using BaseClass::BaseClass;
  using BaseClass::changed;
  using BaseClass::resetChanged;

  int scaleCounter() const
  {
    return m_scaleCounter4Moduletest;
  }

  bool imageDefaultSizeChanged() const
  {
    return m_imageDefaultSize.changed();
  }

  QSize esriPictureMarkerSize() const
  {
    if (!m_pictureMarkerSymbol)
      return QSize();
    return QSize(m_pictureMarkerSymbol->width(), m_pictureMarkerSymbol->height());
  }

};


void runGraphicalObjectPictureMarker(SituationMap::Map *map,
                                     const SituationMap::MarkerSymbolType markerType)
{
  SituationMap::LayerFactory  &layerFac = map->layerFactory();
  MapImpl *mapImpl = static_cast<SituationMap::MapImpl *>(map);

  // use an LOGICAL layer (not basemap)
  QStringList layernames = layerFac.layernames();
  QString layername = layernames[1];

  // real test
  QScopedPointer<GraphObjPictureMarker> go(new GraphObjPictureMarker(mapImpl->getEsriGeoView(),
                                                                     mapImpl->getGraphicsLayer(layername),
                                                                     QLatin1String("TacticalAppearanceModuleTest"),
                                                                     4712));
  QVERIFY2(go, "objectFactory: GraphObjPictureMarker failed");

  QVERIFY2(go->changed() == true, "GraphObjPictureMarker: changed failed");
  go->resetChanged();
  QVERIFY2(go->changed() == false, "GraphObjPictureMarker: changed failed");

  QVERIFY2(go->isSinglePoint() == false, "GraphObjPictureMarker: isSinglePoint failed");
  QVERIFY2(go->isMultiPoint()  == false, "GraphObjPictureMarker: isMultiPoint failed");
  QVERIFY2(go->isArea()        == false, "GraphObjPictureMarker: isArea failed");

  go->setOrigin(Point3D(94000, 78000, .0));
  QVERIFY2(go->isSinglePoint() == true, "GraphObjPictureMarker: isSinglePoint failed");
  QVERIFY2(go->changed() == true, "GraphObjPictureMarker: changed failed");

  go->setMarkerSymbol(markerType, 100);
  QVERIFY2(go->changed() == true, "GraphObjPictureMarker: changed failed");

  bool success = go->updateView();
  QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjPictureMarker: changed failed");

  success = go->updateView();
  QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjPictureMarker: changed failed");

  // Change:
  QImage image(100, 100, QImage::Format_ARGB32);
  image.fill(Qt::transparent);

  go->setImage(image);
  QVERIFY2(go->changed() == true, "GraphObjPictureMarker: changed failed");

  success = go->updateView();
  QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjPictureMarker: changed failed");

  success = go->updateView();
  QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjPictureMarker: changed failed");
}


void SituationMapTestsMain::checkGraphicalObjectPictureMarker1()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  runGraphicalObjectPictureMarker(d->m_map, SituationMap::MarkerSymbolType::Circle);
  runGraphicalObjectPictureMarker(d->m_map, SituationMap::MarkerSymbolType::Square);

  runGraphicalObjectPictureMarker(d->m_map, SituationMap::MarkerSymbolType::PushPin2D);
}

void SituationMapTestsMain::checkGraphicalObjectPictureMarker2()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  SituationMap::LayerFactory  &layerFac = d->m_map->layerFactory();
  MapImpl *mapImpl = static_cast<SituationMap::MapImpl *>(d->m_map);

  // use an LOGICAL layer (not basemap)
  QStringList layernames = layerFac.layernames();
  QString layername = layernames[1];

  // real test
  QScopedPointer<GraphObjPictureMarker> go(new GraphObjPictureMarker(mapImpl->getEsriGeoView(),
                                                                     mapImpl->getGraphicsLayer(layername),
                                                                     QLatin1String("TacticalAppearanceModuleTest"),
                                                                     4712));
  QVERIFY2(go, "objectFactory: GraphObjPictureMarker failed");

  QVERIFY2(go->changed() == true, "GraphObjPictureMarker: changed failed");
  go->resetChanged();
  QVERIFY2(go->changed() == false, "GraphObjPictureMarker: changed failed");

  QVERIFY2(go->isSinglePoint() == false, "GraphObjPictureMarker: isSinglePoint failed");
  QVERIFY2(go->isMultiPoint()  == false, "GraphObjPictureMarker: isMultiPoint failed");
  QVERIFY2(go->isArea()        == false, "GraphObjPictureMarker: isArea failed");

  go->setOrigin(Point3D(94000, 78000, .0));
  QVERIFY2(go->isSinglePoint() == true, "GraphObjPictureMarker: isSinglePoint failed");

  QImage image(100, 100, QImage::Format_ARGB32);
  image.fill(Qt::transparent);

  go->setImage(image);
  QVERIFY2(go->changed() == true, "GraphObjPictureMarker: changed failed");

  bool success = go->updateView();
  QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjPictureMarker: changed failed");

  success = go->updateView();
  QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjPictureMarker: changed failed");

  // Change:
  go->setMarkerSymbol(SituationMap::MarkerSymbolType::Cross, 100);
  QVERIFY2(go->changed() == true, "GraphObjPictureMarker: changed failed");

  success = go->updateView();
  QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjPictureMarker: changed failed");

  success = go->updateView();
  QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjPictureMarker: changed failed");

  // Check visibility:
  checkGraphicalObjectVisibility(go, QStringLiteral("GraphObjPictureMarker"));
}


//-------------------------------------------------------------------------------------------------------
void SituationMapTestsMain::checkGraphicalObjectPictureMarker3()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  SituationMap::LayerFactory  &layerFac = d->m_map->layerFactory();
  MapImpl *mapImpl = static_cast<SituationMap::MapImpl *>(d->m_map);

  // use an LOGICAL layer (not basemap)
  QStringList layernames = layerFac.layernames();
  QString layername = layernames[1];

  // real test
  QScopedPointer<GraphObjPictureMarker> go(new GraphObjPictureMarker(mapImpl->getEsriGeoView(),
                                                                     mapImpl->getGraphicsLayer(layername),
                                                                     QLatin1String("TacticalAppearanceModuleTest"),
                                                                     4712));
  QVERIFY2(go, "objectFactory: GraphObjPictureMarker failed");

  go->setOrigin(Point3D(94000, 78000, .0));
  QVERIFY2(go->isSinglePoint() == true, "GraphObjPictureMarker: isSinglePoint failed");

  QImage image(100, 100, QImage::Format_ARGB32);
  image.fill(Qt::red);

  bool success = false;

  qCritical() << " Goo   !!!!";


  // Set image first time
  {
    go->setImage(image);
    QVERIFY2(go->changed()                 == true, "GraphObjPictureMarker: changed failed");
    QVERIFY2(go->imageDefaultSizeChanged() == true, "GraphObjPictureMarker: imageDefaultSizeChanged failed");

    success = go->updateView();
    QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
    QVERIFY2(go->changed()                 == false, "GraphObjPictureMarker: changed failed");
    QVERIFY2(go->imageDefaultSizeChanged() == false, "GraphObjPictureMarker: imageDefaultSizeChanged failed");
    qCritical() << " scaleCounter1a=" << go->scaleCounter();
    QVERIFY2(go->scaleCounter() == 0, "GraphObjPictureMarker: scaleCounter failed");


    success = go->updateView();
    QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
    QVERIFY2(go->changed()                 == false, "GraphObjPictureMarker: changed failed");
    QVERIFY2(go->imageDefaultSizeChanged() == false, "GraphObjPictureMarker: imageDefaultSizeChanged failed");
    qCritical() << " scaleCounter1b=" << go->scaleCounter();
    QVERIFY2(go->scaleCounter() == 0, "GraphObjPictureMarker: scaleCounter failed");

    QVERIFY2(go->currentSize() == QSize(100, 100), "GraphObjPictureMarker: esriPictureMarkerSize failed");
  }

  // Set identical image again, nothing changed
  {
    go->setImage(image);
    QVERIFY2(go->changed()                 == false, "GraphObjPictureMarker: changed failed");
    QVERIFY2(go->imageDefaultSizeChanged() == false, "GraphObjPictureMarker: imageDefaultSizeChanged failed");

    success = go->updateView();
    QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
    QVERIFY2(go->changed()                 == false, "GraphObjPictureMarker: changed failed");
    QVERIFY2(go->imageDefaultSizeChanged() == false, "GraphObjPictureMarker: imageDefaultSizeChanged failed");
    qCritical() << " scaleCounter2=" << go->scaleCounter();
    QVERIFY2(go->scaleCounter() == 0, "GraphObjPictureMarker: scaleCounter failed");

    QVERIFY2(go->currentSize() == QSize(100, 100), "GraphObjPictureMarker: esriPictureMarkerSize failed");
  }

  // Set different image
  {
    QImage image2(200, 200, QImage::Format_ARGB32);
    image2.fill(Qt::red);

    go->setImage(image2);
    QVERIFY2(go->changed()                 == true, "GraphObjPictureMarker: changed failed");
    QVERIFY2(go->imageDefaultSizeChanged() == false, "GraphObjPictureMarker: imageDefaultSizeChanged failed");

    success = go->updateView();
    QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
    QVERIFY2(go->changed()                 == false, "GraphObjPictureMarker: changed failed");
    QVERIFY2(go->imageDefaultSizeChanged() == false, "GraphObjPictureMarker: imageDefaultSizeChanged failed");
    qCritical() << " scaleCounter3=" << go->scaleCounter();
    QVERIFY2(go->scaleCounter() == 0, "GraphObjPictureMarker: scaleCounter failed");

    QVERIFY2(go->currentSize() == QSize(200, 200), "GraphObjPictureMarker: esriPictureMarkerSize failed");
  }

  //
  // use value for defaultSize:
  //
  {
    const QSize myDefaultSize(50, 50);

    // Set image first time
    {
      go->setImage(image, myDefaultSize);
      QVERIFY2(go->changed()                 == true, "GraphObjPictureMarker: changed failed");
      QVERIFY2(go->imageDefaultSizeChanged() == true, "GraphObjPictureMarker: imageDefaultSizeChanged failed");

      success = go->updateView();
      QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
      QVERIFY2(go->changed()                 == false, "GraphObjPictureMarker: changed failed");
      QVERIFY2(go->imageDefaultSizeChanged() == false, "GraphObjPictureMarker: imageDefaultSizeChanged failed");
      qCritical() << " scaleCounter11a=" << go->scaleCounter();
      QVERIFY2(go->scaleCounter() == 1, "GraphObjPictureMarker: scaleCounter failed");


      success = go->updateView();
      QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
      QVERIFY2(go->changed()                 == false, "GraphObjPictureMarker: changed failed");
      QVERIFY2(go->imageDefaultSizeChanged() == false, "GraphObjPictureMarker: imageDefaultSizeChanged failed");
      qCritical() << " scaleCounter11b=" << go->scaleCounter();
      QVERIFY2(go->scaleCounter() == 1, "GraphObjPictureMarker: scaleCounter failed");

      QVERIFY2(go->currentSize() == myDefaultSize, "GraphObjPictureMarker: esriPictureMarkerSize failed");
    }

    // Set different image, but keep value for defaultSize
    {
      QImage image2(200, 200, QImage::Format_ARGB32);
      image2.fill(Qt::red);

      go->setImage(image2, myDefaultSize);
      QVERIFY2(go->changed()                 == true, "GraphObjPictureMarker: changed failed");
      QVERIFY2(go->imageDefaultSizeChanged() == false, "GraphObjPictureMarker: imageDefaultSizeChanged failed");

      success = go->updateView();
      QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
      QVERIFY2(go->changed()                 == false, "GraphObjPictureMarker: changed failed");
      QVERIFY2(go->imageDefaultSizeChanged() == false, "GraphObjPictureMarker: imageDefaultSizeChanged failed");
      qCritical() << " scaleCounter12=" << go->scaleCounter();
      QVERIFY2(go->scaleCounter() == 2, "GraphObjPictureMarker: scaleCounter failed");

      QVERIFY2(go->currentSize() == myDefaultSize, "GraphObjPictureMarker: esriPictureMarkerSize failed");
    }
  }

  //
  // take scale into account:
  //
  {
    QVERIFY2(go->changed()                 == false, "GraphObjPictureMarker: changed failed");
    QVERIFY2(go->imageDefaultSizeChanged() == false, "GraphObjPictureMarker: imageDefaultSizeChanged failed");

    go->setScale(0.5);

    success = go->updateView();
    QVERIFY2(success == true, "GraphObjPictureMarker: updateView failed");
    QVERIFY2(go->changed()                 == false, "GraphObjPictureMarker: changed failed");
    QVERIFY2(go->imageDefaultSizeChanged() == false, "GraphObjPictureMarker: imageDefaultSizeChanged failed");
    qCritical() << " scaleCounter21=" << go->scaleCounter();
    QVERIFY2(go->scaleCounter() == 3, "GraphObjPictureMarker: scaleCounter failed");

    QVERIFY2(go->currentSize() == QSize(25, 25), "GraphObjPictureMarker: esriPictureMarkerSize failed");
  }
}


//-------------------------------------------------------------------------------------------------------
class GraphObjRange : public SituationMap::GraphicalObjectRange
{
  using BaseClass = GraphicalObjectRange;

public:
  using BaseClass::BaseClass;
  using BaseClass::changed;
  using BaseClass::resetChanged;
};

void SituationMapTestsMain::checkGraphicalObjectRange()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  SituationMap::LayerFactory  &layerFac = d->m_map->layerFactory();
  MapImpl *mapImpl = static_cast<SituationMap::MapImpl *>(d->m_map);

  // use an LOGICAL layer (not basemap)
  QStringList layernames = layerFac.layernames();
  QString layername = layernames[1];

  // real test
  QScopedPointer<GraphObjRange> go(new GraphObjRange(mapImpl->getEsriGeoView(),
                                                     mapImpl->getGraphicsLayer(layername),
                                                     QLatin1String("TacticalAppearanceModuleTest"),
                                                     4712));
  QVERIFY2(go, "objectFactory: GraphObjRange failed");

  QVERIFY2(go->changed() == true, "GraphObjRange: changed failed");
  go->resetChanged();
  QVERIFY2(go->changed() == false, "GraphObjRange: changed failed");

  QVERIFY2(go->isSinglePoint() == false, "GraphObjRange: isSinglePoint failed");
  QVERIFY2(go->isMultiPoint()  == false, "GraphObjRange: isMultiPoint failed");
  QVERIFY2(go->isArea()        == false, "GraphObjRange: isArea failed");

  go->setOrigin(Point3D(94000, 78000, .0));
  QVERIFY2(go->isSinglePoint() == true, "GraphObjRange: isSinglePoint failed");

  // set value:
  go->setRange(1000, 15);
  QVERIFY2(go->changed() == true, "GraphObjRange: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjRange: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjRange: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjRange: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjRange: changed failed");

  // Change:
  go->setRange(2000, 15);
  QVERIFY2(go->changed() == true, "GraphObjRange: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjRange: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjRange: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjRange: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjRange: changed failed");

  // Change:
  go->setRange(2000, -15);
  QVERIFY2(go->changed() == true, "GraphObjRange: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjRange: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjRange: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjRange: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjRange: changed failed");

  // Check visibility:
  checkGraphicalObjectVisibility(go, QStringLiteral("GraphObjRange"));
}


//-------------------------------------------------------------------------------------------------------
class GraphObjText : public SituationMap::GraphicalObjectText
{
  using BaseClass = GraphicalObjectText;

public:
  using BaseClass::BaseClass;
  using BaseClass::changed;
  using BaseClass::resetChanged;
};

void SituationMapTestsMain::checkGraphicalObjectText()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  SituationMap::LayerFactory  &layerFac = d->m_map->layerFactory();
  MapImpl *mapImpl = static_cast<SituationMap::MapImpl *>(d->m_map);

  // use an LOGICAL layer (not basemap)
  QStringList layernames = layerFac.layernames();
  QVERIFY(layernames.size() > 1);
  QString layername = layernames[1];

  // real test
  QScopedPointer<GraphObjText> go(new GraphObjText(mapImpl->getEsriGeoView(),
                                                   mapImpl->getGraphicsLayer(layername),
                                                   QLatin1String("TacticalAppearanceModuleTest"),
                                                   4712));
  QVERIFY2(go, "objectFactory: GraphObjText failed");

  QVERIFY2(go->changed() == true, "GraphObjText: changed failed");
  go->resetChanged();
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  QVERIFY2(go->isSinglePoint() == false, "GraphObjText: isSinglePoint failed");
  QVERIFY2(go->isMultiPoint()  == false, "GraphObjText: isMultiPoint failed");
  QVERIFY2(go->isArea()        == false, "GraphObjText: isArea failed");

  go->setOrigin(Point3D(94000, 78000, .0));
  QVERIFY2(go->isSinglePoint() == true, "GraphObjText: isSinglePoint failed");

  // set value:

  //
  // Text1
  //
  go->setText(QLatin1String("myDummyText"));
  QVERIFY2(go->changed() == true, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  // Text2
  go->setText(QLatin1String("myDummyTextMODIFIED"));
  QVERIFY2(go->changed() == true, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  //
  // textStyle1
  //
  go->rTextStyle().setSize(11.23456f);
  QVERIFY2(go->changed() == true, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  // set identical value again -> not changed
  const TextStyle ts =  go->textStyle();
  go->setTextStyle(ts);
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");
  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");


  // textStyle2
  go->rTextStyle().setSize(111.9876f);
  QVERIFY2(go->changed() == true, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  //
  // setXOffset1
  //
  go->setXOffset(10.876f);
  QVERIFY2(go->changed() == true, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  // set identical value again -> not changed
  go->setXOffset(10.876f);
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");
  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  // setXOffset2
  go->setXOffset(10.123f);
  QVERIFY2(go->changed() == true, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  //
  // setYOffset1
  //
  go->setYOffset(222.876f);
  QVERIFY2(go->changed() == true, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  // set identical value again -> not changed
  go->setYOffset(222.876f);
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");
  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  // setYOffset2
  go->setYOffset(222.123f);
  QVERIFY2(go->changed() == true, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  QVERIFY2(go->updateView() == true, "GraphObjText: updateView failed");
  QVERIFY2(go->changed() == false, "GraphObjText: changed failed");

  // Check visibility:
  checkGraphicalObjectVisibility(go, QStringLiteral("GraphObjText"));
}

//-------------------------------------------------------------------------------------------------------
class GraphObjTactApp : public SituationMap::TacticalAppearance
{
  using BaseClass = TacticalAppearance;

public:
  using BaseClass::BaseClass;
  using BaseClass::changed;
  using BaseClass::resetChanged;
};

void SituationMapTestsMain::checkGraphicalObjectTacticalAppearance()
{
  if (d->m_symbologyType == AdvancedSymbology::SymbologyType::None)
    return;

  // Preperations:
  reInitTestCaseUntilSetCenter();

  SituationMap::LayerFactory  &layerFac = d->m_map->layerFactory();

  // use an LOGICAL layer (not basemap)
  QStringList layernames = layerFac.layernames();
  QString layername = layernames[1];

  // real test
  GraphObjTactApp *go = new GraphObjTactApp(static_cast<SituationMap::MapImpl *>(d->m_map),
                                            layername,
                                            QLatin1String("TacticalAppearanceModuleTest"),
                                            4711);
  QVERIFY2(go->changed() == true, "TacticalAppearance: changed failed");
  go->resetChanged();
  QVERIFY2(go->changed() == false, "TacticalAppearance: changed failed");

  QVERIFY2(go->isSinglePoint() == false, "TacticalAppearance: isSinglePoint failed");
  QVERIFY2(go->isMultiPoint()  == false, "TacticalAppearance: isMultiPoint failed");
  QVERIFY2(go->isArea()        == false, "TacticalAppearance: isArea failed");

  // set value:

  go->setUniqueDesignation(QLatin1String("uniquDesignation"));
  go->setVisibility(true);
  go->setSelected(false);
  go->setPickable(false);
  go->setScale(2.34f);
  QVERIFY2(go->changed() == true, "TacticalAppearance: changed failed");

  SituationMap::SymbolData symbolData;

  //
  // Check SINGLE-POINTSYMBOL
  //
  {
    switch (d->m_symbologyType)
    {
    case AdvancedSymbology::SymbologyType::APP6D:
    case AdvancedSymbology::SymbologyType::MIL2525D:
      symbolData.sidc = AdvancedSymbology::SidcCodec::encodeComplete( d->m_symbologyType, "10051000001213030000" );
      break;
    case AdvancedSymbology::SymbologyType::MIL2525C:
    case AdvancedSymbology::SymbologyType::APP6B:
      symbolData.sidc =  AdvancedSymbology::SidcCodec::encodeComplete( d->m_symbologyType, "SFGPUCD---");  // PointSymbol
      break;
    case AdvancedSymbology::SymbologyType::None:
      break;
    }
    go->setSymbol(symbolData);

    QVERIFY2(go->changed() == true, "TacticalAppearance: changed failed");

    // no origin/position
    QVERIFY2(go->updateView() == false, "TacticalAppearance: updateView failed");    // -> 3 * ERROR-msg
    QVERIFY2(go->changed() == false, "TacticalAppearance: changed failed");

    // with origin/position
    QPointF origin = s_basePoint.geographic( QPointF(94000, 78000) );
    go->setOrigin(Point3D(origin.x(), origin.y(), .0));
    QVERIFY2(go->changed() == true, "TacticalAppearance: changed failed");
    QVERIFY2(go->updateView() == true, "TacticalAppearance: updateView failed");
    QVERIFY2(go->updateView() == true, "TacticalAppearance: updateView failed");
    QVERIFY2(go->changed() == false, "TacticalAppearance: changed failed");
  }

  //
  // Check MULTI-POINTSYMBOL
  //
  {
    switch (d->m_symbologyType)
    {
    case AdvancedSymbology::SymbologyType::APP6D:
    case AdvancedSymbology::SymbologyType::MIL2525D:
      symbolData.sidc = AdvancedSymbology::SidcCodec::encodeComplete(d->m_symbologyType, "10042500002701000000"); // 01042500002701000000 -> SymbolSet = 25 270100 (obstacle)
      break;
    case AdvancedSymbology::SymbologyType::MIL2525C:
      symbolData.sidc = AdvancedSymbology::SidcCodec::encodeComplete(AdvancedSymbology::SymbologyType::MIL2525C, "GUMPNB----");  // MIL2525: 1100, GHSPAR----, Forward Arming and Refueling Area H -> Polygon
      break;
    case AdvancedSymbology::SymbologyType::APP6B:
      symbolData.sidc = AdvancedSymbology::SidcCodec::encodeComplete(AdvancedSymbology::SymbologyType::APP6B, "GHTPGC----");  // App6B: 3370, GHTPGC----, Task - Canalize H, -> Polyline
      break;
    case AdvancedSymbology::SymbologyType::None:
      break;
    }

    if (! symbolData.sidc.isEmpty())
    {
      go->setSymbol(symbolData);

      // With ONE coordinate
      QVERIFY2(go->updateView() == true, "TacticalAppearance: updateView failed");
      QVERIFY2(go->changed()    == false, "TacticalAppearance: changed failed");

      // With coordinates
      QList<QPointF> posCont2D;
      posCont2D << s_basePoint.geographic( QPointF(94000, 78000) );
      posCont2D << s_basePoint.geographic( QPointF(95000, 70000) );
      posCont2D << s_basePoint.geographic( QPointF(94500, 78500) );
      go->setPositions(convert2D3D(posCont2D));

      QVERIFY2(go->changed()    == true, "TacticalAppearance: changed failed");
      QVERIFY2(go->updateView() == true, "TacticalAppearance: updateView failed");
      QVERIFY2(go->updateView() == true, "TacticalAppearance: updateView failed");
      QVERIFY2(go->changed()    == false, "TacticalAppearance: changed failed");
    }
  }

  // cleanup:
  delete go;
}

//-------------------------------------------------------------------------------------------------------
class BasePathObjImp : public SituationMap::BasicPathObjectImpl
{
  using BaseClass = BasicPathObjectImpl;

public:
  using BaseClass::BaseClass;
  using BaseClass::init;
};



void SituationMapTestsMain::checkBasicPathObjectImpl()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  SituationMap::LayerFactory  &layerFac = d->m_map->layerFactory();
  SituationMap::ObjectFactory &objFac   = d->m_map->objectFactory();

  // use an LOGICAL layer (not basemap)
  const QStringList layernames = layerFac.layernames();
  QVERIFY(layernames.size() > 1);
  QString layername = layernames[1];

  // real test
  BasePathObjImp *pathObj = new BasePathObjImp(QLatin1String("BasicPathObjectModuleTest"));
  bool initOk = pathObj->init(static_cast<SituationMap::MapImpl *>(d->m_map),
                              layername,
                              SituationMap::GraphicalObjectPathType::Polygon);
  QVERIFY2(initOk == true, "BasicPathObjectImpl: init failed");

  // set positions:
  SituationMap::PositionCont posCont;
  // check empty container:
  pathObj->setPositions(posCont);
  bool success = pathObj->updateView();
  QVERIFY2(success == false, "BasicPathObjectImpl: updateView failed");


  // check empty container with ArrowHeads
  pathObj->setArrowHeadStart(true);
  pathObj->setArrowHeadEnd(true);
  success = pathObj->updateView();
  QVERIFY2(success == false, "BasicPathObjectImpl: updateView failed");


  // check container without ArrowHeads
  pathObj->setArrowHeadStart(false);
  pathObj->setArrowHeadEnd(false);
  QPointF center = d->m_map->centerPoint();

  QList<QPointF> posCont2D;
  posCont2D << s_basePoint.geographic( center + QPointF(   0,    0) );
  posCont2D << s_basePoint.geographic( center + QPointF(   0, 5000) );
  posCont2D << s_basePoint.geographic( center + QPointF(5000, 5000) );
  posCont2D << s_basePoint.geographic( center + QPointF(5000,    0) );
  pathObj->setPositions(convert2D3D(posCont2D));

  success = pathObj->updateView();
  QVERIFY2(success == true, "BasicPathObjectImpl: updateView failed");
  int numberOfValuesChanged = pathObj->numberOfValuesChanged();
  INFO_LOG(m_logger) << " numberOfValuesChanged = "  << numberOfValuesChanged;
  QVERIFY2(numberOfValuesChanged == 0, "BasicPathObject: numberOfValuesChanged failed");

  success = pathObj->updateView();
  QVERIFY2(success == true, "BasicPathObjectImpl: updateView failed");
  numberOfValuesChanged = pathObj->numberOfValuesChanged();
  INFO_LOG(m_logger) << " numberOfValuesChanged = "  << numberOfValuesChanged;
  QVERIFY2(numberOfValuesChanged == 0, "BasicPathObject: numberOfValuesChanged failed");

  QTest::qWait(timeToDelay);


  pathObj->setArrowHeadStart(true);
  pathObj->setArrowHeadEnd(true);
  success = pathObj->updateView();
  QVERIFY2(success == true, "BasicPathObjectImpl: updateView failed");
  numberOfValuesChanged = pathObj->numberOfValuesChanged();
  INFO_LOG(m_logger) << " numberOfValuesChanged = "  << numberOfValuesChanged;
  QVERIFY2(numberOfValuesChanged == 0, "BasicPathObject: numberOfValuesChanged failed");

  for (int i = 0; i < 2; ++i)
    pathObj->setTextOnSegment(i, QStringLiteral("segText_%1").arg(i));
  success = pathObj->updateView();
  QVERIFY2(success == true, "BasicPathObjectImpl: updateView failed");
  numberOfValuesChanged = pathObj->numberOfValuesChanged();
  INFO_LOG(m_logger) << " numberOfValuesChanged = "  << numberOfValuesChanged;
  QVERIFY2(numberOfValuesChanged == 0, "BasicPathObject: numberOfValuesChanged failed");

  QTest::qWait(timeToDelay);


//  QSignalSpy spy(d->m_sitMap, SIGNAL(mapReady()));
//  spy.wait(5000);

  // set origin/radius:
  // !!!arrowHeads will disappear!!!
  QPointF center2D = s_basePoint.geographic(center);
  pathObj->setOrigin(Point3D(center2D.x(), center2D.y(), .0));
  pathObj->setRadius(2000);
  success = pathObj->updateView();
  QVERIFY2(success == true, "BasicPathObjectImpl: updateView failed");
  numberOfValuesChanged = pathObj->numberOfValuesChanged();
  INFO_LOG(m_logger) << " numberOfValuesChanged = "  << numberOfValuesChanged;
  QVERIFY2(numberOfValuesChanged == 0, "BasicPathObject: numberOfValuesChanged failed");


  // setIdentifierVisible
  pathObj->setIdentifierVisible(true);
  success = pathObj->updateView();
  QVERIFY2(success == true, "BasicPathObjectImpl: updateView failed");
  numberOfValuesChanged = pathObj->numberOfValuesChanged();
  INFO_LOG(m_logger) << " numberOfValuesChanged = "  << numberOfValuesChanged;
  QVERIFY2(numberOfValuesChanged == 0, "BasicPathObject: numberOfValuesChanged failed");

  QTest::qWait(timeToDelay);

#ifdef SUPPORT_SUBSIDIARY_LINES
  //
  // Subsidiary:
  //
  QList<int> subsidiaryIdxInUse;

  // check pathIndexInUse:
  subsidiaryIdxInUse = pathObj->subsidiaryPathIndexInUse();
  QVERIFY2(subsidiaryIdxInUse.size() == 0 , "BasicPathObjectImpl: subsidiaryPathIndexInUse failed");

  // check non-existing:
  SituationMap::PositionCont retrieved;
  retrieved = pathObj->subsidiaryPositions(12345);
  QVERIFY2(retrieved.size() == 0 , "BasicPathObjectImpl: subsidiaryPositions failed");

  // set path:
  SituationMap::PositionCont posCont2;
  posCont2 << center + QPointF(0,    0);
  posCont2 << center + QPointF(0, 3000);
  posCont2 << center + QPointF(3000, 3000);

  pathObj->setSubsidiaryPositions(12, posCont2);
  const SituationMap::PositionCont &posContTemp = pathObj->subsidiaryPositions(12);
  QVERIFY2(posContTemp == posContTemp, "BasicPathObjectImpl: subsidiaryPositions failed");


  success = pathObj->updateView();
  QVERIFY2(success == true, "BasicPathObjectImpl: updateView (setSubsidiaryPositions) failed");
  numberOfValuesChanged = pathObj->numberOfValuesChanged();
  INFO_LOG(m_logger) << " numberOfValuesChanged = "  << numberOfValuesChanged;
  QVERIFY2(numberOfValuesChanged == 0, "BasicPathObject: numberOfValuesChanged failed");

  // Overlapping polygons (with fillpattern solid) will NOT show an fillpattern within the onverlapping area!!!
  // Reason: ???
  // 2015-11-19, Version 10.2.6)

  QTest::qWait(timeToDelay);


  subsidiaryIdxInUse = pathObj->subsidiaryPathIndexInUse();
  QVERIFY2(subsidiaryIdxInUse.size() == 1 , "BasicPathObjectImpl: subsidiaryPathIndexInUse failed");

  // retrieve:
  retrieved = pathObj->subsidiaryPositions(12);
  QVERIFY2(posCont2 == retrieved , "BasicPathObjectImpl: subsidiaryPositions failed");

  // clear:
  pathObj->clearSubsidiaryPositions();
  subsidiaryIdxInUse = pathObj->subsidiaryPathIndexInUse();
  QVERIFY2(subsidiaryIdxInUse.size() == 0 , "BasicPathObjectImpl: subsidiaryPathIndexInUse failed");
#endif // SUPPORT_SUBSIDIARY_LINES


  // cleanup:
  delete pathObj;
  QVERIFY2(objFac.count() == 0 , "objectFactory: count failed");


  //
  // check identical positions:
  //

  {
    // real test
    QScopedPointer<BasePathObjImp> pathObj(new BasePathObjImp(QLatin1String("BasicPathObjectModuleTest")));
    bool initOk = pathObj->init(static_cast<SituationMap::MapImpl *>(d->m_map),
                                layername,
                                SituationMap::GraphicalObjectPathType::Polygon);
    QVERIFY2(initOk == true, "BasicPathObjectImpl: init failed");

    // check doubled start and end position:
    {
      // set positions:
      QList<QPointF> posCont;
      QPointF center = d->m_map->centerPoint();
      qWarning() << " center=" << center;
      posCont << center + QPointF(0,     0);
      posCont << center + QPointF(0,     0.001);
      posCont << center + QPointF(0.001, 0.001);
      posCont << center + QPointF(0,     0);
      pathObj->setPositions(convert2D3D(posCont2D));

      bool success = pathObj->updateView();
      QVERIFY2(success == true, "BasicPathObjectImpl: updateView failed");
      success = pathObj->updateView();
      QVERIFY2(success == true, "BasicPathObjectImpl: updateView failed");

      QTest::qWait(timeToDelay);
    }

    // check doubled positions:
    {
      // set positions:
      SituationMap::PositionCont posCont;
      QPointF center2D = d->m_map->centerPoint();
      Point3D center(center2D.x(), center2D.y(), .0);

      posCont << center + Point3D(0,         0, .0);
      posCont << center + Point3D(0,         0, .0);
      posCont << center + Point3D(0,         0, .0);
      posCont << center + Point3D(0.001,     0, .0);
      posCont << center + Point3D(0.001, 0.001, .0);
      posCont << center + Point3D(0,         0, .0);
      posCont << center + Point3D(0,         0, .0);
      pathObj->setPositions(posCont);

      bool success = pathObj->updateView();
      QVERIFY2(success == true, "BasicPathObjectImpl: updateView failed");
      success = pathObj->updateView();
      QVERIFY2(success == true, "BasicPathObjectImpl: updateView failed");
      QTest::qWait(timeToDelay);
    }

  }

}

void SituationMapTestsMain::checkChemicalAgent()
{
  // Preperations:
  reInitTestCaseUntilSetCenter();

  SituationMap::ObjectFactory &objFac   = d->m_map->objectFactory();
  SituationMap::LayerFactory  &layerFac = d->m_map->layerFactory();

  // use an LOGICAL layer (not basemap)
  QStringList layernames = layerFac.layernames();
  QString layername = layernames[1];

  // real test

  SituationMap::RefPointer<SituationMap::ChemicalAgent> cAgent;
  cAgent = objFac.create<SituationMap::ChemicalAgent>(layername, QLatin1String("ChemAgentId1"));
  QVERIFY2(cAgent.valid() == true , "objectFactory: create failed");

  QVERIFY2(objFac.count() == 1 , "objectFactory: count failed");

  QList<QPointF> posCont2D;
  posCont2D << s_basePoint.geographic( QPointF( 1000,  1000) );
  posCont2D << s_basePoint.geographic( QPointF(85000, 70000) );
  posCont2D << s_basePoint.geographic( QPointF(84500, 78500) );
  cAgent->setPositions(convert2D3D(posCont2D));

  bool success = cAgent->updateView();
  QVERIFY2(success == true, "ChemicalAgent: updateView failed");
  success = cAgent->updateView();
  QVERIFY2(success == true, "ChemicalAgent: updateView failed");

  QTest::qWait(timeToDelay);

  QPointF origin = s_basePoint.geographic( QPointF(0, 1000) );
  cAgent->setOrigin(Point3D::fromQPointF(origin));

  cAgent->setRadius(20000);
  success = cAgent->updateView();
  QVERIFY2(success == true, "ChemicalAgent: updateView failed");

}

void SituationMapTestsMain::checkParticipant()
{
  if (d->m_symbologyType == AdvancedSymbology::SymbologyType::None)

    return;



  // Preperations:
  reInitTestCaseUntilSetCenter();

  SituationMap::ObjectFactory &objFac   = d->m_map->objectFactory();
  SituationMap::LayerFactory  &layerFac = d->m_map->layerFactory();

  // use an LOGICAL layer (not basemap)
  QStringList layernames = layerFac.layernames();
  QString layername = layernames[1];

  // real test

  SituationMap::RefPointer<SituationMap::Participant> objPtr1;
  objPtr1 = objFac.create<SituationMap::Participant>(layername, QLatin1String("UnitTestId1"));
  QVERIFY2(objPtr1.valid() == true , "objectFactory: create failed");

  QVERIFY2(objFac.count() == 1 , "objectFactory: count failed");

  objPtr1->setTextModifier(SituationMap::Participant::TextModifier::EF_ReinforcedReduced, QLatin1String("EF_ReinforcedReduced"));
  objPtr1->setTextModifier(SituationMap::Participant::TextModifier::M_HigherFormation,    QLatin1String("M_HigherFormation"));
  objPtr1->setTextModifier(SituationMap::Participant::TextModifier::T_UniqueDesignation,  QLatin1String("T_UniqueDesignation"));
  objPtr1->setTextModifier(SituationMap::Participant::TextModifier::W_DateTimeGroup,      QLatin1String("W_DateTimeGroup"));

  objPtr1->setVisibility(true);
//  objPtr1->setVisibility(SituationMap::ObjectAppearance::Technical, false); // no sense


  SituationMap::SymbolData symData;
  symData.sidc = QLatin1String("SUGPUSAJ--****X");
  //                            123456789012345

  symData.color = Qt::cyan; // Will be overwritten via partyId.
  symData.size  = 0.5;

  objPtr1->setSymbol(symData);
  objPtr1->setScale(2.0);
  objPtr1->setPartyId(4);

  QPointF origin = s_basePoint.geographic( QPointF(94000, 78003) );
  objPtr1->setOrigin(Point3D::fromQPointF(origin));

  objPtr1->setInjury(SituationMap::Injury::TotalKill, 3);

  objPtr1->setAdditionalSymbol(SituationMap::AdditionalSymbolType::NbcProtection, true);
  objPtr1->setAdditionalSymbol(SituationMap::AdditionalSymbolType::Manipulation, true);
  objPtr1->setAdditionalSymbol(SituationMap::AdditionalSymbolType::NoPosition, true);
  objPtr1->setAdditionalSymbol(SituationMap::AdditionalSymbolType::BiteError, true);

  objPtr1->setMarked(false);

  objPtr1->setRanges(QVector<int>() << 1000 << 10000);

  bool success = objPtr1->updateView();
  QVERIFY2(success == true, "participant: updateView failed");

  SituationMap::ParticipantImpl *partiImpl = dynamic_cast<SituationMap::ParticipantImpl *>(objPtr1.get());

  if (partiImpl)
  {
    int numberOfValuesChanged = partiImpl->numberOfValuesChanged();
    INFO_LOG(m_logger) << " numberOfValuesChanged = "  << numberOfValuesChanged;
    QVERIFY2(numberOfValuesChanged == 0, "participant: numberOfValuesChanged failed");

    bool success2 = objPtr1->updateView();
    QVERIFY2(success2 == true, "participant: updateView failed");

    int numberOfValuesChanged2 = partiImpl->numberOfValuesChanged();
    INFO_LOG(m_logger) << " numberOfValuesChanged2 = "  << numberOfValuesChanged2;
    QVERIFY2(numberOfValuesChanged2 == 0, "participant: numberOfValuesChanged2 failed");

  }

  // remove:
  objPtr1->removeMySelf();
  QVERIFY2(objFac.count() == 0, "objectFactory: count failed");

}


void SituationMapTestsMain::checkEventDispatcher()
{
  reInitTestCaseUntilSetCenter();

  QGraphicsView * mapWidget = d->m_map->getQGraphicsView();

  SituationMap::RB::EventDispatcher * dispatcher1 = new SituationMap::RB::EventDispatcher( static_cast<QWidget*>(mapWidget->viewport()) );
  unsigned int  noOfDisp1 = dispatcher1->numberOfEventDispatcher();

  SituationMap::RB::EventDispatcher * dispatcher2 = new SituationMap::RB::EventDispatcher( static_cast<QWidget*>(mapWidget->viewport()) );
  unsigned int  noOfDisp2 = dispatcher1->numberOfEventDispatcher();

  QVERIFY2( noOfDisp1 == 2          , "wrong number of event dispatcher (first test)");
  QVERIFY2( noOfDisp2 == noOfDisp1+1, "wrong number of event dispatcher (second test)");

  delete dispatcher2;

  noOfDisp2 = dispatcher1->numberOfEventDispatcher();
  QVERIFY2(noOfDisp2 == noOfDisp1, "wrong number of event dispatcher (third test)");

} // SituationMapTestsMain::checkEventDispatcher



static  bool            rubberbandcheckIsComplete = false;
static QVector<QPointF> rubberbandVertexList;

template<class RubberbandClass> void SituationMapTestsMain::checkRubberband(const char *className)
{
  reInitTestCaseUntilSetCenter();

  static  bool  testok = true;

  auto slotFunc = [ = ](SituationMap::RB::RubberbandBase * rubberband)
  {
    if (rubberband->coordinatesAreValid())
    {
      QVector<QPointF> coordinateVector = rubberband->coordinateVector();
      if (coordinateVector.size() == rubberbandVertexList.size())
      {
        for (int i = 0; i < coordinateVector.size(); ++i)
        {
          QPointF simPoint = coordinateVector[i];
          QPointF p        = rubberbandVertexList[i];
          if ((fabs(simPoint.x() - p.x()) > d->m_map->pixelSizeMeter()) || (fabs(simPoint.y() - p.y()) > d->m_map->pixelSizeMeter()))
            testok = false;
        }
      }
      else testok = false;
    }
    rubberbandcheckIsComplete = true;
  }; // slotFunc


  rubberbandcheckIsComplete = false;
  testok                    = true;

  RubberbandClass   *rband = d->m_map->rubberbandFactory().create<RubberbandClass>();

  static char msg[200];

  if (rband == nullptr)
  {
    sprintf(msg, "%s rubberband factory failure", className);
    QVERIFY2(false, msg);
  }
  else
  {
    rband->setCoordinateVector(rubberbandVertexList);

    connect(rband, &SituationMap::RB::Rubberband::apply, slotFunc);
    connect(rband, &SituationMap::RB::Rubberband::abort, slotFunc);

    QTimer::singleShot(200, this, [ = ]()
    {
      rband->applyAndEndAction(nullptr, 0, 0);
    });

    // Wait for finish Rubberband
    while (!rubberbandcheckIsComplete)
      QCoreApplication::processEvents();

    delete rband; rband = nullptr; // here it is ok to use delete directly

    sprintf(msg, "%s coordinate test failed", className);
    QVERIFY2(testok, msg);
  }
} // SituationMapTestsMain::checkRubberband



void SituationMapTestsMain::checkRubberbandMultiPointFeature()
{
  SituationMap::CoordTranslationFunctor * ct = d->m_map->coordTranslationFunctor();
  rubberbandVertexList.clear();

  if (ct)
  {
    rubberbandVertexList << ct->mapToGeographic(QPointF(-338163  ,  168551  )+d->m_geoOff)
                         << ct->mapToGeographic(QPointF( 154770  ,  168551  )+d->m_geoOff)
                         << ct->mapToGeographic(QPointF( 154770  , - 71025  )+d->m_geoOff)
                         << ct->mapToGeographic(QPointF(-338163  , - 71025  )+d->m_geoOff)
                         << ct->mapToGeographic(QPointF( 36042.4 ,   38162.5)+d->m_geoOff)
                         << ct->mapToGeographic(QPointF( 302120  , - 46643.1)+d->m_geoOff)
                         << ct->mapToGeographic(QPointF( 244876  , -224735  )+d->m_geoOff)
                         << ct->mapToGeographic(QPointF(- 21201.4, -139929  )+d->m_geoOff)
                         ;
  }
  else
  {
    rubberbandVertexList << QPointF(-338163  ,  168551  )+d->m_geoOff
                         << QPointF( 154770  ,  168551  )+d->m_geoOff
                         << QPointF( 154770  , - 71025  )+d->m_geoOff
                         << QPointF(-338163  , - 71025  )+d->m_geoOff
                         << QPointF( 36042.4 ,   38162.5)+d->m_geoOff
                         << QPointF( 302120  , - 46643.1)+d->m_geoOff
                         << QPointF( 244876  , -224735  )+d->m_geoOff
                         << QPointF(- 21201.4, -139929  )+d->m_geoOff
                         ;
  }

  checkRubberband<SituationMap::RB::RubberbandMultiPointFeature>("RubberbandMultiPointFeature");

} // SituationMapTestsMain::checkRubberbandMultiPointFeature



void SituationMapTestsMain::checkRubberbandRectangle()
{
  SituationMap::CoordTranslationFunctor * ct = d->m_map->coordTranslationFunctor();
  rubberbandVertexList.clear();

  if (ct)
  {
    rubberbandVertexList << ct->mapToGeographic( QPointF (154770 , 168551)+d->m_geoOff)
                         << ct->mapToGeographic(QPointF( 154770 , - 71025)+d->m_geoOff)
                         << ct->mapToGeographic(QPointF(-338163 , - 71025)+d->m_geoOff)
                         << ct->mapToGeographic(QPointF(-338163 ,  168551)+d->m_geoOff)
                         ;
  }
  else
  {
    rubberbandVertexList << QPointF (154770 ,  168551)+d->m_geoOff
                         << QPointF( 154770 , - 71025)+d->m_geoOff
                         << QPointF(-338163 , - 71025)+d->m_geoOff
                         << QPointF(-338163 ,  168551)+d->m_geoOff
                         ;
  }

  reInitTestCaseUntilSetCenter();

  static  bool  testok = true;

  auto slotFunc = [ = ](SituationMap::RB::RubberbandBase * rubberband)
  {
    // check if coordinates of rubberband and input vector are remaining identical
    if (rubberband->coordinatesAreValid())
    {
      const QVector<QPointF> & coordinateVector = rubberband->coordinateVector();
      if (coordinateVector.size() == rubberbandVertexList.size())
      {
        double mapPixelSize = d->m_map->pixelSizeMeter();

        for (int i = 0; i < coordinateVector.size(); ++i)
        {
          const QPointF &simPoint   = coordinateVector[i];
          int     matchCount = 0;
          for (int j = 0; j < rubberbandVertexList.size(); ++j)
          {
            QPointF p = rubberbandVertexList[j];
            double dx = fabs(simPoint.x() - p.x());
            double dy = fabs(simPoint.y() - p.y());
            if ((dx < mapPixelSize) && (dy < mapPixelSize))
            {
              ++matchCount;
            }
          }
          if (matchCount != coordinateVector.size()) testok = false;
        }
      }
      else testok = false;
    }
    rubberbandcheckIsComplete = true;
  }; // slotFunc


  rubberbandcheckIsComplete = false;
  testok                    = true;

  SituationMap::RB::RubberbandRectangle   *rband = d->m_map->rubberbandFactory().create<SituationMap::RB::RubberbandRectangle>();

  if (rband == nullptr)
    QVERIFY2(false, "RubberbandRectangle rubberband factory failure");
  else
  {
    rband->setCoordinateVector(rubberbandVertexList);

    connect(rband, &SituationMap::RB::Rubberband::apply, slotFunc);
    connect(rband, &SituationMap::RB::Rubberband::abort, slotFunc);

    QTimer::singleShot(200, this, [ = ]()
    {
      rband->applyAndEndAction(nullptr, 0, 0);
    });

    // Wait for finish Rubberband
    while (!rubberbandcheckIsComplete)
      QCoreApplication::processEvents();

    delete rband; rband = nullptr; // here it is ok to use delete directly

    QVERIFY2(testok, "RubberbandRectangle coordinate test failed");

  }
} // SituationMapTestsMain::checkRubberbandRectangle


void SituationMapTestsMain::checkRubberbandRectangleIndex()
{
  SituationMap::CoordTranslationFunctor * ct = d->m_map->coordTranslationFunctor();
  rubberbandVertexList.clear();

  if (ct)
  {
    rubberbandVertexList << ct->mapToGeographic( QPointF (154770 , 168551)+d->m_geoOff)
                         << ct->mapToGeographic(QPointF( 154770 , - 71025)+d->m_geoOff)
                         << ct->mapToGeographic(QPointF(-338163 , - 71025)+d->m_geoOff)
                         <<ct->mapToGeographic( QPointF(-338163 ,  168551)+d->m_geoOff)
                         ;
  }
  else
  {
     rubberbandVertexList << QPointF (154770 ,  168551)+d->m_geoOff
                          << QPointF( 154770 , - 71025)+d->m_geoOff
                          << QPointF(-338163 , - 71025)+d->m_geoOff
                          << QPointF(-338163 ,  168551)+d->m_geoOff
                          ;
  }

  reInitTestCaseUntilSetCenter();

  static  bool  testok = true;

  auto slotFunc = [ = ](SituationMap::RB::RubberbandBase *rubberband)
  {
    if (rubberband->coordinatesAreValid())
    {
      QVector<QPointF> coordinateVector = rubberband->coordinateVector();
      if (coordinateVector.size() == rubberbandVertexList.size())
      {
        for (int i = 0; i < coordinateVector.size(); ++i)
        {
          const QPointF & simPoint = coordinateVector[i];
          const QPointF & p        = rubberbandVertexList[i];
          if ((fabs(simPoint.x() - p.x()) > d->m_map->pixelSizeMeter()) && (fabs(simPoint.y() - p.y()) > d->m_map->pixelSizeMeter()))
          {
            testok = false;
          }
        }
      }
      else testok = false;
    }
    rubberbandcheckIsComplete = true;
  }; // slotFunc


  rubberbandcheckIsComplete = false;
  testok                    = true;

  SituationMap::RB::RubberbandRectangle   *rband = d->m_map->rubberbandFactory().create<SituationMap::RB::RubberbandRectangle>();

  if (rband == nullptr)
    QVERIFY2(false, "RubberbandRectangle rubberband factory failure");
  else
  {
    rband->setCoordinateVector(rubberbandVertexList);

    connect(rband, &SituationMap::RB::Rubberband::apply, slotFunc);
    connect(rband, &SituationMap::RB::Rubberband::abort, slotFunc);

    QTimer::singleShot(200, this, [ = ]()
    {
      rband->applyAndEndAction(nullptr, 0, 0);
    });

    // Wait for finish Rubberband
    while (!rubberbandcheckIsComplete)
      QCoreApplication::processEvents();

    delete rband; rband = nullptr; // here it is ok to use delete directly

    QVERIFY2(testok, "RubberbandRectangle coordinate index test failed");
  }
} // SituationMapTestsMain::checkRubberbandRectangleIndex


void SituationMapTestsMain::checkRubberbandCorridor()
{
  rubberbandVertexList.clear();

   checkRubberband<SituationMap::RB::RubberbandCorridor>( "RubberbandCorridor" );
} // SituationMapTestsMain::checkRubberbandCorridor


template<class RubberbandClass> void SituationMapTestsMain::checkRubberbandProjection(const char *className)
{
  reInitTestCaseUntilSetCenter();

  SituationMap::CoordTranslationFunctor * ct = d->m_map->coordTranslationFunctor();
  rubberbandVertexList.clear();

  if (ct)
  {
    rubberbandVertexList << ct->mapToGeographic(QPointF( 154770 ,  168551)+d->m_geoOff)
                         << ct->mapToGeographic(QPointF(-338163 ,  168551)+d->m_geoOff)
                         << ct->mapToGeographic(QPointF( 154770 , - 71025)+d->m_geoOff)
                         ;
  }
  else
  {
    rubberbandVertexList << QPointF (154770 ,  168551)+d->m_geoOff
                         << QPointF(-338163 ,  168551)+d->m_geoOff
                         << QPointF( 154770 , - 71025)+d->m_geoOff
                         ;
  }

  SituationMap::RB::Rubberband *rband = d->m_map->rubberbandFactory().create<SituationMap::RB::RubberbandPointCluster>();

  if (rband)
  {
    rband->setCoordinateVector(rubberbandVertexList);
    bool             mismatch   = false;
    QVector<QPointF> vertexList = rband->coordinateVector();

    for (int i = 0; i < vertexList.size(); ++i)
    {
      qreal dx = fabs(vertexList[i].x() - rubberbandVertexList[i].x());
      qreal dy = fabs(vertexList[i].y() - rubberbandVertexList[i].y());

      if ((dx > 0.001) && (dy > 0.001)) mismatch = true;
    }

    delete rband;

    static char msg[200];

    sprintf(msg, "%s oordinate projection failed.", className);
    QVERIFY2((!mismatch), msg);
  }
} // SituationMapTestsMain::checkRubberbandProjection


void SituationMapTestsMain::checkRubberCoordinateProjection()
{
  checkRubberbandProjection<SituationMap::RB::RubberbandPointCluster>("RubberbandPointCluster");
  checkRubberbandProjection<SituationMap::RB::RubberbandPointCluster>("RubberbandMultiPointFeature");
} // SituationMapTestsMain::checkRubberCoordinateProjection


//-------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------

void SituationMapTestsMain::reInitTestCaseUntilSetCenter()
{
  // Preperations:
  initTestCase();
  checkMapReady();
// //  checkCenter();

  SituationMap::LayerFactory &layerFac = d->m_map->layerFactory();
  INFO_LOG(m_logger) << " layernames = " << layerFac.layernames().join(QLatin1String(";"));


  if (layerFac.isUsingBaseMapBuiltIn())
  {
    d->m_basemapCountRef = 1;
  } else {
    d->m_basemapCountRef = 1; // maybe '2', depending on ini
  }


#ifdef CHECK_LAYER
  int basemapCount = layerFac.layernames(LayerType::Basemap).count();
  int jumpPointLayerCount = 0;
  jumpPointLayerCount = layerFac.layernames(LayerType::JumpPoint).count();
  QVERIFY2(jumpPointLayerCount == 1 , "layerFactory: count failed");

  int operationalLayerCount = layerFac.layernames(LayerType::Operational).count();
  QVERIFY2(basemapCount == d->m_basemapCountRef , "layerFactory: count failed");
  QVERIFY2(operationalLayerCount == 9 , "layerFactory: count failed");       // AES, Participants

  int technLayerCount = d->m_map->technicalLayerCount();
  INFO_LOG(m_logger) << " technicalLayerCount = "  << technLayerCount;
  QVERIFY2(technLayerCount == basemapCount, "objectFactory: count failed");

  INFO_LOG(m_logger) << " basemapCount = " << basemapCount;
  INFO_LOG(m_logger) << " jumpPointLayerCount = " << jumpPointLayerCount;
  INFO_LOG(m_logger) << " operationalLayerCount = " << operationalLayerCount;
  QVERIFY2(layerFac.count() == basemapCount + jumpPointLayerCount + operationalLayerCount , "layerFactory: count failed");

  SituationMap::ObjectFactory &objFac = d->m_map->objectFactory();
  INFO_LOG(m_logger) << " objFac.count() ="  << objFac.count();

  QVERIFY2(objFac.count() == 0, "objectFactory: count failed");
#endif
}


//-------------------------------------------------------------------------------------------------------
void SituationMapTestsMain::cleanupTestCase()
{
  DEBUG_LOG(m_logger) << LOGFUNCTION;
  delete d->m_sitMap;
  DEBUG_LOG(m_logger) << LOGFUNCTION;
}