GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1398:8cb3639e4927

Fix bug in acquisition !. Test fuzzing with 30 var in 8 group

perrinel -

r1398:8cb3639e4927

parent child

Context file:

r1398:8cb3639e4927

core/src/Variable/VariableAcquisitionWorker.cpp +2 -20

             #include "Variable/VariableAcquisitionWorker.h"
             #include "Variable/Variable.h"
             #include <Data/AcquisitionRequest.h>
             #include <Data/SqpRange.h>
             #include <unordered_map>
             #include <utility>
             #include <QMutex>
             #include <QReadWriteLock>
             #include <QThread>
             #include <cmath>
             Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")
             struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
                 explicit VariableAcquisitionWorkerPrivate(VariableAcquisitionWorker *parent)
                         : m_Lock{QReadWriteLock::Recursive}, q{parent}
                 {
                 }
                 void lockRead() { m_Lock.lockForRead(); }
                 void lockWrite() { m_Lock.lockForWrite(); }
                 void unlock() { m_Lock.unlock(); }
                 void removeVariableRequest(QUuid vIdentifier);
                 /// Remove and/or abort all AcqRequest in link with varRequestId
                 void cancelVarRequest(QUuid varRequestId);
                 void removeAcqRequest(QUuid acqRequestId);
                 QMutex m_WorkingMutex;
                 QReadWriteLock m_Lock;
                 std::map<QUuid, QVector<AcquisitionDataPacket> > m_AcqIdentifierToAcqDataPacketVectorMap;
                 std::map<QUuid, AcquisitionRequest> m_AcqIdentifierToAcqRequestMap;
                 std::map<QUuid, QUuid> m_VIdentifierToCurrrentAcqIdMap;
                 VariableAcquisitionWorker *q;
             };
             VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>(this)}
             {
             }
             VariableAcquisitionWorker::~VariableAcquisitionWorker()
             {
                 qCInfo(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker destruction")
                                                         << QThread::currentThread();
                 this->waitForFinish();
             }
             QUuid VariableAcquisitionWorker::pushVariableRequest(QUuid varRequestId, QUuid vIdentifier,
                                                                  DataProviderParameters parameters,
                                                                  std::shared_ptr<IDataProvider> provider)
             {
                 qCDebug(LOG_VariableAcquisitionWorker())
                     << tr("TORM VariableAcquisitionWorker::pushVariableRequest varRequestId: ") << varRequestId
                     << "vId: " << vIdentifier;
                 auto varRequestIdCanceled = QUuid();
                 // Request creation
                 auto acqRequest = AcquisitionRequest{};
                 acqRequest.m_VarRequestId = varRequestId;
                 acqRequest.m_vIdentifier = vIdentifier;
                 acqRequest.m_DataProviderParameters = parameters;
                 acqRequest.m_Size = parameters.m_Times.size();
                 acqRequest.m_Provider = provider;
                 qCInfo(LOG_VariableAcquisitionWorker()) << tr("Add acqRequest ") << acqRequest.m_AcqIdentifier
                                                         << acqRequest.m_Size;
                 // Register request
                 impl->lockWrite();
                 impl->m_AcqIdentifierToAcqRequestMap.insert(
                     std::make_pair(acqRequest.m_AcqIdentifier, acqRequest));
                 auto it = impl->m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
                 if (it != impl->m_VIdentifierToCurrrentAcqIdMap.cend()) {
                     // A current request already exists, we can cancel it
                     // remove old acqIdentifier from the worker
                     auto oldAcqId = it->second;
                     auto acqIdentifierToAcqRequestMapIt = impl->m_AcqIdentifierToAcqRequestMap.find(oldAcqId);
                     if (acqIdentifierToAcqRequestMapIt != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                         auto oldAcqRequest = acqIdentifierToAcqRequestMapIt->second;
                         varRequestIdCanceled = oldAcqRequest.m_VarRequestId;
                     }
                     impl->unlock();
                     impl->cancelVarRequest(varRequestIdCanceled);
                 }
                 else {
                     impl->unlock();
                 }
                 // Request for the variable, it must be stored and executed
                 impl->lockWrite();
                 impl->m_VIdentifierToCurrrentAcqIdMap.insert(
                     std::make_pair(vIdentifier, acqRequest.m_AcqIdentifier));
                 impl->unlock();
                 QMetaObject::invokeMethod(this, "onExecuteRequest", Qt::QueuedConnection,
                                           Q_ARG(QUuid, acqRequest.m_AcqIdentifier));
                 return varRequestIdCanceled;
             }
             void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
             {
                 impl->lockRead();
                 auto it = impl->m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
                 if (it != impl->m_VIdentifierToCurrrentAcqIdMap.cend()) {
                     auto currentAcqId = it->second;
                     auto it = impl->m_AcqIdentifierToAcqRequestMap.find(currentAcqId);
                     if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                         auto request = it->second;
                         impl->unlock();
                         // notify the request aborting to the provider
                         request.m_Provider->requestDataAborting(currentAcqId);
                     }
                     else {
                         impl->unlock();
                         qCWarning(LOG_VariableAcquisitionWorker())
                             << tr("Impossible to abort an unknown acquisition request") << currentAcqId;
                     }
                 }
                 else {
                     impl->unlock();
                 }
             }
             void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
                                                                              double progress)
             {
-                qCInfo(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
+                qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
                                                          << QThread::currentThread()->objectName()
                                                          << acqIdentifier << progress;
                 impl->lockRead();
                 auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
                 if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                     auto progressPartSize
                         = (aIdToARit->second.m_Size != 0) ? 100 / aIdToARit->second.m_Size : 0;
                     auto currentPartProgress
                         = std::isnan(progress) ? 0.0 : (progress * progressPartSize) / 100.0;
                     // We can only give an approximation of the currentProgression since its upgrade is async.
-                    qCInfo(LOG_VariableAcquisitionWorker())
-                        << tr("Progression: ") << aIdToARit->second.m_Progression << aIdToARit->second.m_Size;
                     auto currentProgression = aIdToARit->second.m_Progression;
                     if (currentProgression == aIdToARit->second.m_Size) {
                         currentProgression = aIdToARit->second.m_Size - 1;
                     }
                     auto currentAlreadyProgress = progressPartSize * currentProgression;
                     auto finalProgression = currentAlreadyProgress + currentPartProgress;
                     emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, finalProgression);
-                    qCInfo(LOG_VariableAcquisitionWorker())
-                        << tr("TORM: onVariableRetrieveDataInProgress ")
-                        << QThread::currentThread()->objectName() << aIdToARit->second.m_vIdentifier
-                        << progressPartSize << currentAlreadyProgress << currentPartProgress
-                        << finalProgression;
                     if (finalProgression == 100.0) {
-                        qCInfo(LOG_VariableAcquisitionWorker())
-                            << tr("TORM: onVariableRetrieveDataInProgress : finished : 0.0 ");
                         emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, 0.0);
                     }
                 }
                 impl->unlock();
             }
             void VariableAcquisitionWorker::onVariableAcquisitionFailed(QUuid acqIdentifier)
             {
                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
                                                          << QThread::currentThread();
                 impl->lockRead();
                 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
                 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                     auto request = it->second;
                     impl->unlock();
-                    qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
-                                                             << acqIdentifier << request.m_vIdentifier
-                                                             << QThread::currentThread();
                     emit variableCanceledRequested(request.m_vIdentifier);
                 }
                 else {
                     impl->unlock();
-                    // TODO log no acqIdentifier recognized
                 }
             }
             void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
                                                                    std::shared_ptr<IDataSeries> dataSeries,
                                                                    SqpRange dataRangeAcquired)
             {
                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableDataAcquired on range ")
                                                          << acqIdentifier << dataRangeAcquired;
                 impl->lockWrite();
                 auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
                 if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                     // Store the result
                     auto dataPacket = AcquisitionDataPacket{};
                     dataPacket.m_Range = dataRangeAcquired;
                     dataPacket.m_DateSeries = dataSeries;
                     auto aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
                     if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
                         // A current request result already exists, we can update it
                         aIdToADPVit->second.push_back(dataPacket);
                     }
                     else {
                         // First request result for the variable, it must be stored
                         impl->m_AcqIdentifierToAcqDataPacketVectorMap.insert(
                             std::make_pair(acqIdentifier, QVector<AcquisitionDataPacket>() << dataPacket));
                     }
                     // Decrement the counter of the request
                     auto &acqRequest = aIdToARit->second;
-                    qCInfo(LOG_VariableAcquisitionWorker()) << tr("TORM: +1 update progresson  ")
-                                                            << acqIdentifier;
                     acqRequest.m_Progression = acqRequest.m_Progression + 1;
                     // if the counter is 0, we can return data then run the next request if it exists and
                     // removed the finished request
                     if (acqRequest.m_Size == acqRequest.m_Progression) {
                         auto varId = acqRequest.m_vIdentifier;
                         // Return the data
                         aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
                         if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
                             emit dataProvided(varId, aIdToADPVit->second);
                         }
                         impl->unlock();
                     }
                     else {
                         impl->unlock();
                     }
                 }
                 else {
                     impl->unlock();
                     qCWarning(LOG_VariableAcquisitionWorker())
                         << tr("Impossible to retrieve AcquisitionRequest for the incoming data.");
                 }
             }
             void VariableAcquisitionWorker::onExecuteRequest(QUuid acqIdentifier)
             {
                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("onExecuteRequest") << QThread::currentThread();
                 impl->lockRead();
                 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
                 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                     auto request = it->second;
                     impl->unlock();
                     emit variableRequestInProgress(request.m_vIdentifier, 0.1);
                     qCDebug(LOG_VariableAcquisitionWorker()) << tr("Start request 10%") << acqIdentifier
                                                              << QThread::currentThread();
                     request.m_Provider->requestDataLoading(acqIdentifier, request.m_DataProviderParameters);
                 }
                 else {
                     impl->unlock();
                     // TODO log no acqIdentifier recognized
                 }
             }
             void VariableAcquisitionWorker::initialize()
             {
                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init")
                                                          << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init END");
             }
             void VariableAcquisitionWorker::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableAcquisitionWorker::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }
             void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::removeVariableRequest(
                 QUuid vIdentifier)
             {
                 lockWrite();
                 auto it = m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
                 if (it != m_VIdentifierToCurrrentAcqIdMap.cend()) {
                     // A current request already exists, we can replace the next one
                     qCDebug(LOG_VariableAcquisitionWorker())
                         << "VariableAcquisitionWorkerPrivate::removeVariableRequest "
                         << QThread::currentThread()->objectName() << it->second;
                     m_AcqIdentifierToAcqRequestMap.erase(it->second);
                     m_AcqIdentifierToAcqDataPacketVectorMap.erase(it->second);
                 }
                 // stop any progression
                 emit q->variableRequestInProgress(vIdentifier, 0.0);
                 m_VIdentifierToCurrrentAcqIdMap.erase(vIdentifier);
                 unlock();
             }
             void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::cancelVarRequest(
                 QUuid varRequestId)
             {
                 qCDebug(LOG_VariableAcquisitionWorker())
-                    << "VariableAcquisitionWorkerPrivate::cancelVarRequest 0";
+                    << "VariableAcquisitionWorkerPrivate::cancelVarRequest start";
                 lockRead();
                 // get all AcqIdentifier in link with varRequestId
                 QVector<QUuid> acqIdsToRm;
                 auto cend = m_AcqIdentifierToAcqRequestMap.cend();
                 for (auto it = m_AcqIdentifierToAcqRequestMap.cbegin(); it != cend; ++it) {
                     if (it->second.m_VarRequestId == varRequestId) {
                         acqIdsToRm << it->first;
                     }
                 }
                 unlock();
                 // run aborting or removing of acqIdsToRm
                 for (auto acqId : acqIdsToRm) {
                     removeAcqRequest(acqId);
                 }
                 qCDebug(LOG_VariableAcquisitionWorker())
                     << "VariableAcquisitionWorkerPrivate::cancelVarRequest end";
             }
             void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::removeAcqRequest(
                 QUuid acqRequestId)
             {
                 qCDebug(LOG_VariableAcquisitionWorker())
                     << "VariableAcquisitionWorkerPrivate::removeAcqRequest";
                 QUuid vIdentifier;
                 std::shared_ptr<IDataProvider> provider;
                 lockRead();
                 auto acqIt = m_AcqIdentifierToAcqRequestMap.find(acqRequestId);
                 if (acqIt != m_AcqIdentifierToAcqRequestMap.cend()) {
                     vIdentifier = acqIt->second.m_vIdentifier;
                     provider = acqIt->second.m_Provider;
                     auto it = m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
                     if (it != m_VIdentifierToCurrrentAcqIdMap.cend()) {
                         if (it->second == acqRequestId) {
                             // acqRequest is currently running -> let's aborting it
                             unlock();
                             // notify the request aborting to the provider
                             provider->requestDataAborting(acqRequestId);
                         }
                         else {
                             unlock();
                         }
                     }
                     else {
                         unlock();
                     }
                 }
                 else {
                     unlock();
                 }
                 lockWrite();
-                qCDebug(LOG_VariableAcquisitionWorker())
-                    << "VariableAcquisitionWorkerPrivate::updateToNextRequest removeAcqRequest: "
-                    << acqRequestId;
                 m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqRequestId);
                 m_AcqIdentifierToAcqRequestMap.erase(acqRequestId);
                 unlock();
                 qCDebug(LOG_VariableAcquisitionWorker())
                     << "VariableAcquisitionWorkerPrivate::removeAcqRequest END";
             }

core/src/Variable/VariableController.cpp +14 -7

             #include <Variable/Variable.h>
             #include <Variable/VariableAcquisitionWorker.h>
             #include <Variable/VariableCacheStrategy.h>
             #include <Variable/VariableCacheStrategyFactory.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Variable/VariableSynchronizationGroup.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Data/VariableRequest.h>
             #include <Time/TimeController.h>
             #include <QDataStream>
             #include <QMutex>
             #include <QThread>
             #include <QUuid>
             #include <QtCore/QItemSelectionModel>
             #include <deque>
             #include <set>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,
                                                   const SqpRange &oldGraphRange)
             {
                 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                 auto varRangeRequested = varRange;
                 switch (zoomType) {
                     case AcquisitionZoomType::ZoomIn: {
                         auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                         auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaLeft;
                         varRangeRequested.m_TEnd -= deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::ZoomOut: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart -= deltaLeft;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanRight: {
                         auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaLeft;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanLeft: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                         varRangeRequested.m_TStart -= deltaLeft;
                         varRangeRequested.m_TEnd -= deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::Unknown: {
                         qCCritical(LOG_VariableController())
                             << VariableController::tr("Impossible to synchronize: zoom type unknown");
                         break;
                     }
                     default:
                         qCCritical(LOG_VariableController()) << VariableController::tr(
                             "Impossible to synchronize: zoom type not take into account");
                         // No action
                         break;
                 }
                 return varRangeRequested;
             }
             }
             enum class VariableRequestHandlerState { OFF, RUNNING, PENDING };
             struct VariableRequestHandler {
                 VariableRequestHandler()
                 {
                     m_CanUpdate = false;
                     m_State = VariableRequestHandlerState::OFF;
                 }
                 QUuid m_VarId;
                 VariableRequest m_RunningVarRequest;
                 VariableRequest m_PendingVarRequest;
                 VariableRequestHandlerState m_State;
                 bool m_CanUpdate;
             };
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
                           // m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
                           m_VariableCacheStrategy{VariableCacheStrategyFactory::createCacheStrategy(
                               CacheStrategy::SingleThreshold)},
                           m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
                           q{parent}
                 {
                     m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);
                     m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");
                 }
                 virtual ~VariableControllerPrivate()
                 {
                     qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");
                     m_VariableAcquisitionWorkerThread.quit();
                     m_VariableAcquisitionWorkerThread.wait();
                 }
                 void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,
                                     QUuid varRequestId);
                 std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
                 std::shared_ptr<IDataSeries>
                 retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);
                 void registerProvider(std::shared_ptr<IDataProvider> provider);
                 void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);
                 QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);
                 void updateVariables(QUuid varRequestId);
                 void updateVariableRequest(QUuid varRequestId);
                 void cancelVariableRequest(QUuid varRequestId);
                 void executeVarRequest(std::shared_ptr<Variable> var, VariableRequest &varRequest);
                 template <typename VariableIterator>
                 void desynchronize(VariableIterator variableIt, const QUuid &syncGroupId);
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
                 std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
                 QThread m_VariableAcquisitionWorkerThread;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
                 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
                 std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >
                     m_GroupIdToVariableSynchronizationGroupMap;
                 std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
                 std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
                 std::map<QUuid, std::list<QUuid> > m_VarGroupIdToVarIds;
                 std::map<QUuid, std::unique_ptr<VariableRequestHandler> > m_VarIdToVarRequestHandler;
                 VariableController *q;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
                 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
                         &VariableController::onAbortProgressRequested);
                 connect(impl->m_VariableAcquisitionWorker.get(),
                         &VariableAcquisitionWorker::variableCanceledRequested, this,
                         &VariableController::onAbortAcquisitionRequested);
                 connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,
                         &VariableController::onDataProvided);
                 connect(impl->m_VariableAcquisitionWorker.get(),
                         &VariableAcquisitionWorker::variableRequestInProgress, this,
                         &VariableController::onVariableRetrieveDataInProgress);
                 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,
                         impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);
                 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,
                         impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::finalize);
                 connect(impl->m_VariableModel, &VariableModel::requestVariableRangeUpdate, this,
                         &VariableController::onUpdateDateTime);
                 impl->m_VariableAcquisitionWorkerThread.start();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
             QItemSelectionModel *VariableController::variableSelectionModel() noexcept
             {
                 return impl->m_VariableSelectionModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             std::shared_ptr<Variable>
             VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (impl->m_VariableModel->containsVariable(variable)) {
                     // Clones variable
                     auto duplicate = variable->clone();
                     // Adds clone to model
                     impl->m_VariableModel->addVariable(duplicate);
                     // Generates clone identifier
                     impl->m_VariableToIdentifierMap[duplicate] = QUuid::createUuid();
                     // Registers provider
                     auto variableProvider = impl->m_VariableToProviderMap.at(variable);
                     auto duplicateProvider = variableProvider != nullptr ? variableProvider->clone() : nullptr;
                     impl->m_VariableToProviderMap[duplicate] = duplicateProvider;
                     if (duplicateProvider) {
                         impl->registerProvider(duplicateProvider);
                     }
                     return duplicate;
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Can't create duplicate of variable %1: variable not registered in the model")
                                .arg(variable->name());
                     return nullptr;
                 }
             }
             void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
                     return;
                 }
                 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
                 // make some treatments before the deletion
                 emit variableAboutToBeDeleted(variable);
                 auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
                 Q_ASSERT(variableIt != impl->m_VariableToIdentifierMap.cend());
                 auto variableId = variableIt->second;
                 // Removes variable's handler
                 impl->m_VarIdToVarRequestHandler.erase(variableId);
                 // Desynchronizes variable (if the variable is in a sync group)
                 auto syncGroupIt = impl->m_VariableIdGroupIdMap.find(variableId);
                 if (syncGroupIt != impl->m_VariableIdGroupIdMap.cend()) {
                     impl->desynchronize(variableIt, syncGroupIt->second);
                 }
                 // Deletes identifier
                 impl->m_VariableToIdentifierMap.erase(variableIt);
                 // Deletes provider
                 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
                 qCDebug(LOG_VariableController())
                     << tr("Number of providers deleted for variable %1: %2")
                            .arg(variable->name(), QString::number(nbProvidersDeleted));
                 // Deletes from model
                 impl->m_VariableModel->deleteVariable(variable);
             }
             void VariableController::deleteVariables(
                 const QVector<std::shared_ptr<Variable> > &variables) noexcept
             {
                 for (auto variable : qAsConst(variables)) {
                     deleteVariable(variable);
                 }
             }
             QByteArray
             VariableController::mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const
             {
                 auto encodedData = QByteArray{};
                 QVariantList ids;
                 for (auto &var : variables) {
                     auto itVar = impl->m_VariableToIdentifierMap.find(var);
                     if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                         qCCritical(LOG_VariableController())
                             << tr("Impossible to find the data for an unknown variable.");
                     }
                     ids << itVar->second.toByteArray();
                 }
                 QDataStream stream{&encodedData, QIODevice::WriteOnly};
                 stream << ids;
                 return encodedData;
             }
             QList<std::shared_ptr<Variable> >
             VariableController::variablesForMimeData(const QByteArray &mimeData) const
             {
                 auto variables = QList<std::shared_ptr<Variable> >{};
                 QDataStream stream{mimeData};
                 QVariantList ids;
                 stream >> ids;
                 for (auto id : ids) {
                     auto uuid = QUuid{id.toByteArray()};
                     auto var = impl->findVariable(uuid);
                     variables << var;
                 }
                 return variables;
             }
             std::shared_ptr<Variable>
             VariableController::createVariable(const QString &name, const QVariantHash &metadata,
                                                std::shared_ptr<IDataProvider> provider) noexcept
             {
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return nullptr;
                 }
                 auto range = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {
                     auto varId = QUuid::createUuid();
                     // Create the handler
                     auto varRequestHandler = std::make_unique<VariableRequestHandler>();
                     varRequestHandler->m_VarId = varId;
                     impl->m_VarIdToVarRequestHandler.insert(
                         std::make_pair(varId, std::move(varRequestHandler)));
                     // store the provider
                     impl->registerProvider(provider);
                     // Associate the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     impl->m_VariableToIdentifierMap[newVariable] = varId;
                     this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{newVariable}, range, false);
                     emit variableAdded(newVariable);
                     return newVariable;
                 }
                 qCCritical(LOG_VariableController()) << tr("Impossible to create variable");
                 return nullptr;
             }
             void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
             {
                 // NOTE: Even if acquisition request is aborting, the graphe range will be changed
                 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
                                                   << QThread::currentThread()->objectName();
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 // NOTE we only permit the time modification for one variable
                 if (selectedRows.size() == 1) {
                     if (auto selectedVariable
                         = impl->m_VariableModel->variable(qAsConst(selectedRows).first().row())) {
                         onUpdateDateTime(selectedVariable, dateTime);
                     }
                 }
                 else if (selectedRows.size() > 1) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to set time for more than 1 variable in the same time");
                 }
                 else {
                     qCWarning(LOG_VariableController())
                         << tr("There is no variable selected to set the time one");
                 }
             }
             void VariableController::onUpdateDateTime(std::shared_ptr<Variable> variable,
                                                       const SqpRange &dateTime)
             {
                 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
                 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to onDateTimeOnSelection request for unknown variable");
                     return;
                 }
                 // notify that rescale operation has to be done
                 emit rangeChanged(variable, dateTime);
                 auto synchro
                     = impl->m_VariableIdGroupIdMap.find(itVar->second) != impl->m_VariableIdGroupIdMap.cend();
                 this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{variable}, dateTime, synchro);
             }
             void VariableController::onDataProvided(QUuid vIdentifier,
                                                     QVector<AcquisitionDataPacket> dataAcquired)
             {
                 qCDebug(LOG_VariableController()) << tr("onDataProvided") << QThread::currentThread();
                 auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
                 auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);
                 if (!varRequestId.isNull()) {
                     impl->updateVariables(varRequestId);
                 }
             }
             void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
             {
                 qCDebug(LOG_VariableController())
                     << "TORM: variableController::onVariableRetrieveDataInProgress"
                     << QThread::currentThread()->objectName() << progress;
                 if (auto var = impl->findVariable(identifier)) {
                     qCDebug(LOG_VariableController())
                         << "TORM: variableController::onVariableRetrieveDataInProgress FOUND";
                     impl->m_VariableModel->setDataProgress(var, progress);
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to notify progression of a null variable");
                 }
             }
             void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
             {
                 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortProgressRequested"
                                                   << QThread::currentThread()->objectName() << variable->name();
                 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
                 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to onAbortProgressRequested request for unknown variable");
                     return;
                 }
                 auto varId = itVar->second;
                 auto itVarHandler = impl->m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == impl->m_VarIdToVarRequestHandler.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to onAbortProgressRequested for variable with unknown handler");
                     return;
                 }
                 auto varHandler = itVarHandler->second.get();
                 // case where a variable has a running request
                 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
                     impl->cancelVariableRequest(varHandler->m_RunningVarRequest.m_VariableGroupId);
                 }
             }
             void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)
             {
                 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortAcquisitionRequested"
                                                   << QThread::currentThread()->objectName() << vIdentifier;
                 if (auto var = impl->findVariable(vIdentifier)) {
                     this->onAbortProgressRequested(var);
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to abort Acquisition Requestof a null variable");
                 }
             }
             void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
             {
                 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
                                                   << QThread::currentThread()->objectName()
                                                   << synchronizationGroupId;
                 auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
                 impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
                     std::make_pair(synchronizationGroupId, vSynchroGroup));
             }
             void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)
             {
                 impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);
             }
             void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
                                                        QUuid synchronizationGroupId)
             {
                 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
                                                   << synchronizationGroupId;
                 auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
                 if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
                     auto groupIdToVSGIt
                         = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
                     if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
                         impl->m_VariableIdGroupIdMap.insert(
                             std::make_pair(varToVarIdIt->second, synchronizationGroupId));
                         groupIdToVSGIt->second->addVariableId(varToVarIdIt->second);
                     }
                     else {
                         qCCritical(LOG_VariableController())
                             << tr("Impossible to synchronize a variable with an unknown sycnhronization group")
                             << variable->name();
                     }
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to synchronize a variable with no identifier") << variable->name();
                 }
             }
             void VariableController::desynchronize(std::shared_ptr<Variable> variable,
                                                    QUuid synchronizationGroupId)
             {
                 // Gets variable id
                 auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
                 if (variableIt == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Can't desynchronize variable %1: variable identifier not found")
                                .arg(variable->name());
                     return;
                 }
                 impl->desynchronize(variableIt, synchronizationGroupId);
             }
             void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
                                                           const SqpRange &range, bool synchronise)
             {
                 // variables is assumed synchronized
                 // TODO: Asser variables synchronization
                 // we want to load data of the variable for the dateTime.
                 if (variables.isEmpty()) {
                     return;
                 }
                 auto varRequestId = QUuid::createUuid();
                 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
                                                   << QThread::currentThread()->objectName() << varRequestId
                                                   << range << synchronise;
                 if (!synchronise) {
                     auto varIds = std::list<QUuid>{};
                     for (const auto &var : variables) {
                         auto vId = impl->m_VariableToIdentifierMap.at(var);
                         varIds.push_back(vId);
                     }
                     impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
                     for (const auto &var : variables) {
-                        qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId
+                        qCDebug(LOG_VariableController()) << "onRequestDataLoading: for" << varRequestId
                                                           << varIds.size();
                         impl->processRequest(var, range, varRequestId);
                     }
                 }
                 else {
                     auto vId = impl->m_VariableToIdentifierMap.at(variables.first());
                     auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
                     if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
                         auto groupId = varIdToGroupIdIt->second;
                         auto vSynchronizationGroup
                             = impl->m_GroupIdToVariableSynchronizationGroupMap.at(groupId);
                         auto vSyncIds = vSynchronizationGroup->getIds();
                         auto varIds = std::list<QUuid>{};
                         for (auto vId : vSyncIds) {
                             varIds.push_back(vId);
                         }
+                        qCDebug(LOG_VariableController()) << "onRequestDataLoading sync: for" << varRequestId
+                                                          << varIds.size();
                         impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
                         for (auto vId : vSyncIds) {
                             auto var = impl->findVariable(vId);
                             // Don't process already processed var
                             if (var != nullptr) {
                                 qCDebug(LOG_VariableController()) << "processRequest synchro for" << var->name()
                                                                   << varRequestId;
                                 auto vSyncRangeRequested
                                     = variables.contains(var)
                                           ? range
                                           : computeSynchroRangeRequested(var->range(), range,
                                                                          variables.first()->range());
                                 qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
                                 impl->processRequest(var, vSyncRangeRequested, varRequestId);
                             }
                             else {
                                 qCCritical(LOG_VariableController())
                                     << tr("Impossible to synchronize a null variable");
                             }
                         }
                     }
                 }
                 impl->updateVariables(varRequestId);
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }
             AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
             {
                 // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
                 auto zoomType = AcquisitionZoomType::Unknown;
                 if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: ZoomOut";
                     zoomType = AcquisitionZoomType::ZoomOut;
                 }
                 else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: PanRight";
                     zoomType = AcquisitionZoomType::PanRight;
                 }
                 else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: PanLeft";
                     zoomType = AcquisitionZoomType::PanLeft;
                 }
                 else if (range.m_TStart >= oldRange.m_TStart && oldRange.m_TEnd >= range.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: ZoomIn";
                     zoomType = AcquisitionZoomType::ZoomIn;
                 }
                 else {
                     qCDebug(LOG_VariableController()) << "getZoomType: Unknown type detected";
                 }
                 return zoomType;
             }
             void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
                                                                                const SqpRange &rangeRequested,
                                                                                QUuid varRequestId)
             {
                 auto itVar = m_VariableToIdentifierMap.find(var);
                 if (itVar == m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to process request for unknown variable");
                     return;
                 }
                 auto varId = itVar->second;
                 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to process request for variable with unknown handler");
                     return;
                 }
                 auto oldRange = var->range();
                 auto varHandler = itVarHandler->second.get();
                 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
                     oldRange = varHandler->m_RunningVarRequest.m_RangeRequested;
                 }
                 auto varRequest = VariableRequest{};
                 varRequest.m_VariableGroupId = varRequestId;
                 auto varStrategyRangesRequested
                     = m_VariableCacheStrategy->computeRange(oldRange, rangeRequested);
                 varRequest.m_RangeRequested = varStrategyRangesRequested.first;
                 varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
                 switch (varHandler->m_State) {
                     case VariableRequestHandlerState::OFF: {
                         qCDebug(LOG_VariableController()) << tr("Process Request OFF")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         varHandler->m_RunningVarRequest = varRequest;
                         varHandler->m_State = VariableRequestHandlerState::RUNNING;
                         executeVarRequest(var, varRequest);
                         break;
                     }
                     case VariableRequestHandlerState::RUNNING: {
                         qCDebug(LOG_VariableController()) << tr("Process Request RUNNING")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         varHandler->m_State = VariableRequestHandlerState::PENDING;
                         varHandler->m_PendingVarRequest = varRequest;
                         break;
                     }
                     case VariableRequestHandlerState::PENDING: {
                         qCDebug(LOG_VariableController()) << tr("Process Request PENDING")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         auto variableGroupIdToCancel = varHandler->m_PendingVarRequest.m_VariableGroupId;
                         cancelVariableRequest(variableGroupIdToCancel);
                         // Cancel variable can make state downgrade
                         varHandler->m_State = VariableRequestHandlerState::PENDING;
                         varHandler->m_PendingVarRequest = varRequest;
                         break;
                     }
                     default:
                         qCCritical(LOG_VariableController())
                             << QObject::tr("Unknown VariableRequestHandlerState");
                 }
             }
             std::shared_ptr<Variable>
             VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
             {
                 std::shared_ptr<Variable> var;
                 auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
                 auto end = m_VariableToIdentifierMap.cend();
                 auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
                 if (it != end) {
                     var = it->first;
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to find the variable with the identifier: ") << vIdentifier;
                 }
                 return var;
             }
             std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
                 const QVector<AcquisitionDataPacket> acqDataPacketVector)
             {
                 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
                                                   << acqDataPacketVector.size();
                 std::shared_ptr<IDataSeries> dataSeries;
                 if (!acqDataPacketVector.isEmpty()) {
                     dataSeries = acqDataPacketVector[0].m_DateSeries;
                     for (int i = 1; i < acqDataPacketVector.size(); ++i) {
                         dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
                     }
                 }
                 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
                                                   << acqDataPacketVector.size();
                 return dataSeries;
             }
             void VariableController::VariableControllerPrivate::registerProvider(
                 std::shared_ptr<IDataProvider> provider)
             {
                 if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
                     qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
                                                       << provider->objectName();
                     m_ProviderSet.insert(provider);
                     connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableDataAcquired);
                     connect(provider.get(), &IDataProvider::dataProvidedProgress,
                             m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
                     connect(provider.get(), &IDataProvider::dataProvidedFailed,
                             m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableAcquisitionFailed);
                 }
                 else {
                     qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
                 }
             }
             QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
                 QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
             {
                 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
                     return QUuid();
                 }
                 auto varHandler = itVarHandler->second.get();
                 if (varHandler->m_State == VariableRequestHandlerState::OFF) {
                     qCCritical(LOG_VariableController())
                         << tr("acceptVariableRequest impossible on a variable with OFF state");
                 }
                 varHandler->m_RunningVarRequest.m_DataSeries = dataSeries;
                 varHandler->m_CanUpdate = true;
                 // Element traité, on a déjà toutes les données necessaires
                 auto varGroupId = varHandler->m_RunningVarRequest.m_VariableGroupId;
                 qCDebug(LOG_VariableController()) << "Variable::acceptVariableRequest" << varGroupId
                                                   << m_VarGroupIdToVarIds.size();
                 return varHandler->m_RunningVarRequest.m_VariableGroupId;
             }
             void VariableController::VariableControllerPrivate::updateVariables(QUuid varRequestId)
             {
                 qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
                                                   << QThread::currentThread()->objectName() << varRequestId;
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCWarning(LOG_VariableController())
                         << tr("Impossible to updateVariables of unknown variables") << varRequestId;
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 bool processVariableUpdate = true;
-                qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
-                                                  << varRequestId << varIds.size();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd) && processVariableUpdate;
                      ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         processVariableUpdate &= itVarHandler->second->m_CanUpdate;
                     }
                 }
                 if (processVariableUpdate) {
-                    qCDebug(LOG_VariableController()) << "Final update OK for the var request" << varIds.size();
                     for (auto varIdsIt = varIds.begin(); varIdsIt != varIdsEnd; ++varIdsIt) {
                         auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                         if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                             if (auto var = findVariable(*varIdsIt)) {
                                 auto &varRequest = itVarHandler->second->m_RunningVarRequest;
                                 var->setRange(varRequest.m_RangeRequested);
                                 var->setCacheRange(varRequest.m_CacheRangeRequested);
                                 qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
                                                                   << varRequest.m_RangeRequested
                                                                   << varRequest.m_CacheRangeRequested;
                                 qCDebug(LOG_VariableController()) << tr("2: onDataProvided var points before")
                                                                   << var->nbPoints()
                                                                   << varRequest.m_DataSeries->nbPoints();
                                 var->mergeDataSeries(varRequest.m_DataSeries);
                                 qCDebug(LOG_VariableController()) << tr("3: onDataProvided var points after")
                                                                   << var->nbPoints();
                                 emit var->updated();
-                                qCDebug(LOG_VariableController()) << tr("Update OK");
                             }
                             else {
                                 qCCritical(LOG_VariableController())
                                     << tr("Impossible to update data to a null variable");
                             }
                         }
                     }
                     updateVariableRequest(varRequestId);
                     // cleaning varRequestId
                     qCDebug(LOG_VariableController()) << tr("m_VarGroupIdToVarIds erase") << varRequestId;
                     m_VarGroupIdToVarIds.erase(varRequestId);
                     if (m_VarGroupIdToVarIds.empty()) {
                         emit q->acquisitionFinished();
                     }
                 }
             }
             void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)
             {
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCCritical(LOG_VariableController()) << QObject::tr(
                         "Impossible to updateVariableRequest since varGroupdId isn't here anymore");
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
+                // First pass all canUpdate of handler to false
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         auto varHandler = itVarHandler->second.get();
                         varHandler->m_CanUpdate = false;
+                    }
+                }
+                // Second update requests of handler
+                for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
+                    auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
+                    if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
+                        auto varHandler = itVarHandler->second.get();
                         switch (varHandler->m_State) {
                             case VariableRequestHandlerState::OFF: {
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Impossible to update a variable with handler in OFF state");
                             } break;
                             case VariableRequestHandlerState::RUNNING: {
                                 varHandler->m_State = VariableRequestHandlerState::OFF;
                                 varHandler->m_RunningVarRequest = VariableRequest{};
                                 break;
                             }
                             case VariableRequestHandlerState::PENDING: {
                                 varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                 varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
                                 varHandler->m_PendingVarRequest = VariableRequest{};
                                 auto var = findVariable(itVarHandler->first);
                                 executeVarRequest(var, varHandler->m_RunningVarRequest);
                                 updateVariables(varHandler->m_RunningVarRequest.m_VariableGroupId);
                                 break;
                             }
                             default:
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Unknown VariableRequestHandlerState");
                         }
                     }
                 }
             }
             void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)
             {
                 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest") << varRequestId;
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to cancelVariableRequest for unknown varGroupdId") << varRequestId;
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         auto varHandler = itVarHandler->second.get();
                         varHandler->m_VarId = QUuid{};
                         switch (varHandler->m_State) {
                             case VariableRequestHandlerState::OFF: {
                                 qCWarning(LOG_VariableController())
                                     << QObject::tr("Impossible to cancel a variable with no running request");
                                 break;
                             }
                             case VariableRequestHandlerState::RUNNING: {
                                 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
                                     auto var = findVariable(itVarHandler->first);
                                     auto varProvider = m_VariableToProviderMap.at(var);
                                     if (varProvider != nullptr) {
                                         m_VariableAcquisitionWorker->abortProgressRequested(
                                             itVarHandler->first);
                                     }
                                     m_VariableModel->setDataProgress(var, 0.0);
                                     varHandler->m_CanUpdate = false;
                                     varHandler->m_State = VariableRequestHandlerState::OFF;
                                     varHandler->m_RunningVarRequest = VariableRequest{};
                                 }
                                 else {
                                     // TODO: log Impossible to cancel the running variable request beacause its
                                     // varRequestId isn't not the canceled one
                                 }
                                 break;
                             }
                             case VariableRequestHandlerState::PENDING: {
                                 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
                                     auto var = findVariable(itVarHandler->first);
                                     auto varProvider = m_VariableToProviderMap.at(var);
                                     if (varProvider != nullptr) {
                                         m_VariableAcquisitionWorker->abortProgressRequested(
                                             itVarHandler->first);
                                     }
                                     m_VariableModel->setDataProgress(var, 0.0);
                                     varHandler->m_CanUpdate = false;
                                     varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                     varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
                                     varHandler->m_PendingVarRequest = VariableRequest{};
                                     executeVarRequest(var, varHandler->m_RunningVarRequest);
                                 }
                                 else if (varHandler->m_PendingVarRequest.m_VariableGroupId == varRequestId) {
                                     varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                     varHandler->m_PendingVarRequest = VariableRequest{};
                                 }
                                 else {
                                     // TODO: log Impossible to cancel the variable request beacause its
                                     // varRequestId isn't not the canceled one
                                 }
                                 break;
                             }
                             default:
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Unknown VariableRequestHandlerState");
                         }
                     }
                 }
                 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest: erase") << varRequestId;
                 m_VarGroupIdToVarIds.erase(varRequestId);
                 if (m_VarGroupIdToVarIds.empty()) {
                     emit q->acquisitionFinished();
                 }
             }
             void VariableController::VariableControllerPrivate::executeVarRequest(std::shared_ptr<Variable> var,
                                                                                   VariableRequest &varRequest)
             {
-                qCDebug(LOG_VariableController()) << tr("TORM: executeVarRequest");
                 auto varIdIt = m_VariableToIdentifierMap.find(var);
                 if (varIdIt == m_VariableToIdentifierMap.cend()) {
                     qCWarning(LOG_VariableController()) << tr(
                         "Can't execute request of a variable that is not registered (may has been deleted)");
                     return;
                 }
                 auto varId = varIdIt->second;
                 auto varCacheRange = var->cacheRange();
                 auto varCacheRangeRequested = varRequest.m_CacheRangeRequested;
                 auto notInCacheRangeList
                     = Variable::provideNotInCacheRangeList(varCacheRange, varCacheRangeRequested);
                 auto inCacheRangeList
                     = Variable::provideInCacheRangeList(varCacheRange, varCacheRangeRequested);
                 if (!notInCacheRangeList.empty()) {
                     auto varProvider = m_VariableToProviderMap.at(var);
                     if (varProvider != nullptr) {
                         qCDebug(LOG_VariableController()) << "executeVarRequest " << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         m_VariableAcquisitionWorker->pushVariableRequest(
                             varRequest.m_VariableGroupId, varId,
                             DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
                             varProvider);
                     }
                     else {
                         qCCritical(LOG_VariableController())
                             << "Impossible to provide data with a null provider";
                     }
                     if (!inCacheRangeList.empty()) {
                         emit q->updateVarDisplaying(var, inCacheRangeList.first());
                     }
                 }
                 else {
+                    qCDebug(LOG_VariableController()) << "All already in the cache "
+                                                      << varRequest.m_RangeRequested;
                     acceptVariableRequest(varId,
                                           var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));
                 }
             }
             template <typename VariableIterator>
             void VariableController::VariableControllerPrivate::desynchronize(VariableIterator variableIt,
                                                                               const QUuid &syncGroupId)
             {
                 const auto &variable = variableIt->first;
                 const auto &variableId = variableIt->second;
                 // Gets synchronization group
                 auto groupIt = m_GroupIdToVariableSynchronizationGroupMap.find(syncGroupId);
                 if (groupIt == m_GroupIdToVariableSynchronizationGroupMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Can't desynchronize variable %1: unknown synchronization group")
                                .arg(variable->name());
                     return;
                 }
                 // Removes variable from synchronization group
                 auto synchronizationGroup = groupIt->second;
                 synchronizationGroup->removeVariableId(variableId);
                 // Removes link between variable and synchronization group
                 m_VariableIdGroupIdMap.erase(variableId);
             }

gui/src/Visualization/VisualizationGraphWidget.cpp 0 0

NO CONTENT: modified file

plugins/amda/src/AmdaProvider.cpp +7 -6

             #include "AmdaProvider.h"
             #include "AmdaDefs.h"
             #include "AmdaResultParser.h"
             #include "AmdaServer.h"
             #include <Common/DateUtils.h>
             #include <Data/DataProviderParameters.h>
             #include <Network/NetworkController.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <QNetworkAccessManager>
             #include <QNetworkReply>
             #include <QTemporaryFile>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
             namespace {
             /// URL format for a request on AMDA server. The parameters are as follows:
             /// - %1: server URL
             /// - %2: start date
             /// - %3: end date
             /// - %4: parameter id
             /// AMDA V2: http://amdatest.irap.omp.eu/php/rest/
             const auto AMDA_URL_FORMAT = QStringLiteral(
                 "http://%1/php/rest/"
                 "getParameter.php?startTime=%2&stopTime=%3&parameterID=%4&outputFormat=ASCII&"
                 "timeFormat=ISO8601&gzip=0");
             /// Dates format passed in the URL (e.g 2013-09-23T09:00)
             const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
             /// Formats a time to a date that can be passed in URL
             QString dateFormat(double sqpRange) noexcept
             {
                 auto dateTime = DateUtils::dateTime(sqpRange);
                 return dateTime.toString(AMDA_TIME_FORMAT);
             }
             } // namespace
             AmdaProvider::AmdaProvider()
             {
                 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     connect(this, SIGNAL(requestConstructed(std::shared_ptr<QNetworkRequest>, QUuid,
                                                             std::function<void(QNetworkReply *, QUuid)>)),
                             &networkController,
                             SLOT(onProcessRequested(std::shared_ptr<QNetworkRequest>, QUuid,
                                                     std::function<void(QNetworkReply *, QUuid)>)));
                     connect(&sqpApp->networkController(),
                             SIGNAL(replyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)),
                             this,
                             SLOT(onReplyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)));
                 }
             }
             std::shared_ptr<IDataProvider> AmdaProvider::clone() const
             {
                 // No copy is made in the clone
                 return std::make_shared<AmdaProvider>();
             }
             void AmdaProvider::requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters)
             {
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 const auto data = parameters.m_Data;
                 for (const auto &dateTime : qAsConst(times)) {
                     qCDebug(LOG_AmdaProvider()) << tr("TORM AmdaProvider::requestDataLoading ") << acqIdentifier
                                                 << dateTime;
                     this->retrieveData(acqIdentifier, dateTime, data);
                     // TORM when AMDA will support quick asynchrone request
                     QThread::msleep(1000);
                 }
             }
             void AmdaProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     networkController.onReplyCanceled(acqIdentifier);
                 }
             }
             void AmdaProvider::onReplyDownloadProgress(QUuid acqIdentifier,
                                                        std::shared_ptr<QNetworkRequest> networkRequest,
                                                        double progress)
             {
                 qCDebug(LOG_AmdaProvider()) << tr("onReplyDownloadProgress") << acqIdentifier
                                             << networkRequest.get() << progress;
                 auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                     // Update the progression for the current request
                     auto requestPtr = networkRequest;
                     auto findRequest = [requestPtr](const auto &entry) { return requestPtr == entry.first; };
                     auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                     auto requestProgressMapEnd = requestProgressMap.end();
                     auto requestProgressMapIt
                         = std::find_if(requestProgressMap.begin(), requestProgressMapEnd, findRequest);
                     if (requestProgressMapIt != requestProgressMapEnd) {
                         requestProgressMapIt->second = progress;
                     }
                     else {
                         // This case can happened when a progression is send after the request has been
                         // finished.
                         // Generaly the case when aborting a request
                         qCDebug(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress") << acqIdentifier
                                                     << networkRequest.get() << progress;
                     }
                     // Compute the current final progress and notify it
                     double finalProgress = 0.0;
                     auto fraq = requestProgressMap.size();
                     for (auto requestProgress : requestProgressMap) {
                         finalProgress += requestProgress.second;
                         qCDebug(LOG_AmdaProvider()) << tr("Current final progress without fraq:")
                                                     << finalProgress << requestProgress.second;
                     }
                     if (fraq > 0) {
                         finalProgress = finalProgress / fraq;
                     }
-                    qCDebug(LOG_AmdaProvider()) << tr("Current final progress: ") << fraq << finalProgress;
+                    qCDebug(LOG_AmdaProvider()) << tr("final progress:  ")
+                                                << QThread::currentThread()->objectName() << acqIdentifier
+                                                << fraq << finalProgress;
                     emit dataProvidedProgress(acqIdentifier, finalProgress);
                 }
                 else {
                     // This case can happened when a progression is send after the request has been finished.
                     // Generaly the case when aborting a request
+                    qCDebug(LOG_AmdaProvider()) << tr("Acquisition request not found: final progress: 100 : ")
+                                                << QThread::currentThread()->objectName() << acqIdentifier;
                     emit dataProvidedProgress(acqIdentifier, 100.0);
                 }
             }
             void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)
             {
                 // Retrieves product ID from data: if the value is invalid, no request is made
                 auto productId = data.value(AMDA_XML_ID_KEY).toString();
                 if (productId.isNull()) {
                     qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
                     return;
                 }
                 // Retrieves the data type that determines whether the expected format for the result file is
                 // scalar, vector...
                 auto productValueType
                     = DataSeriesTypeUtils::fromString(data.value(AMDA_DATA_TYPE_KEY).toString());
                 // /////////// //
                 // Creates URL //
                 // /////////// //
                 auto startDate = dateFormat(dateTime.m_TStart);
                 auto endDate = dateFormat(dateTime.m_TEnd);
                 QVariantHash urlProperties{{AMDA_SERVER_KEY, data.value(AMDA_SERVER_KEY)}};
                 auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(AmdaServer::instance().url(urlProperties),
                                                              startDate, endDate, productId)};
-                qCInfo(LOG_AmdaProvider()) << tr("TORM AmdaProvider::retrieveData url:") << url;
                 auto tempFile = std::make_shared<QTemporaryFile>();
                 // LAMBDA
                 auto httpDownloadFinished = [this, dateTime, tempFile,
                                              productValueType](QNetworkReply *reply, QUuid dataId) noexcept {
                     // Don't do anything if the reply was abort
                     if (reply->error() == QNetworkReply::NoError) {
                         if (tempFile) {
                             auto replyReadAll = reply->readAll();
                             if (!replyReadAll.isEmpty()) {
                                 tempFile->write(replyReadAll);
                             }
                             tempFile->close();
                             // Parse results file
                             if (auto dataSeries
                                 = AmdaResultParser::readTxt(tempFile->fileName(), productValueType)) {
                                 emit dataProvided(dataId, dataSeries, dateTime);
                             }
                             else {
                                 /// @todo ALX : debug
                                 emit dataProvidedFailed(dataId);
                             }
                         }
                         m_AcqIdToRequestProgressMap.erase(dataId);
                     }
                     else {
                         qCCritical(LOG_AmdaProvider()) << tr("httpDownloadFinished ERROR");
                         emit dataProvidedFailed(dataId);
                     }
                 };
                 auto httpFinishedLambda
                     = [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
                           // Don't do anything if the reply was abort
                           if (reply->error() == QNetworkReply::NoError) {
                               auto downloadFileUrl = QUrl{QString{reply->readAll()}.trimmed()};
-                              qCInfo(LOG_AmdaProvider())
+                              qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData downloadFileUrl:")
-                                  << tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;
+                                                          << downloadFileUrl;
                               // Executes request for downloading file //
                               // Creates destination file
                               if (tempFile->open()) {
                                   // Executes request and store the request for progression
                                   auto request = std::make_shared<QNetworkRequest>(downloadFileUrl);
                                   updateRequestProgress(dataId, request, 0.0);
                                   emit requestConstructed(request, dataId, httpDownloadFinished);
                               }
                               else {
                                   emit dataProvidedFailed(dataId);
                               }
                           }
                           else {
                               qCCritical(LOG_AmdaProvider()) << tr("httpFinishedLambda ERROR");
                               m_AcqIdToRequestProgressMap.erase(dataId);
                               emit dataProvidedFailed(dataId);
                           }
                       };
                 // //////////////// //
                 // Executes request //
                 // //////////////// //
                 auto request = std::make_shared<QNetworkRequest>(url);
-                qCDebug(LOG_AmdaProvider()) << tr("First Request creation") << request.get();
                 updateRequestProgress(token, request, 0.0);
                 emit requestConstructed(request, token, httpFinishedLambda);
             }
             void AmdaProvider::updateRequestProgress(QUuid acqIdentifier,
                                                      std::shared_ptr<QNetworkRequest> request, double progress)
             {
-                qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress request") << request.get();
                 auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                     auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                     auto requestProgressMapIt = requestProgressMap.find(request);
                     if (requestProgressMapIt != requestProgressMap.end()) {
                         requestProgressMapIt->second = progress;
                         qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new progress for request")
                                                     << acqIdentifier << request.get() << progress;
                     }
                     else {
                         qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new request") << acqIdentifier
                                                     << request.get() << progress;
                         acqIdToRequestProgressMapIt->second.insert(std::make_pair(request, progress));
                     }
                 }
                 else {
                     qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new acqIdentifier")
                                                 << acqIdentifier << request.get() << progress;
                     auto requestProgressMap = std::map<std::shared_ptr<QNetworkRequest>, double>{};
                     requestProgressMap.insert(std::make_pair(request, progress));
                     m_AcqIdToRequestProgressMap.insert(
                         std::make_pair(acqIdentifier, std::move(requestProgressMap)));
                 }
             }

plugins/amda/tests/FuzzingOperations.cpp +1 -1

             #include "FuzzingOperations.h"
             #include "FuzzingUtils.h"
             #include <Data/IDataProvider.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QUuid>
             #include <functional>
             Q_LOGGING_CATEGORY(LOG_FuzzingOperations, "FuzzingOperations")
             namespace {
             struct CreateOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     // A variable can be created only if it doesn't exist yet
                     return fuzzingState.variableState(variableId).m_Variable == nullptr;
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController,
                              const Properties &properties) const override
                 {
                     // Retrieves metadata pool from properties, and choose one of the metadata entries to
                     // associate it with the variable
                     auto metaDataPool = properties.value(METADATA_POOL_PROPERTY).value<MetadataPool>();
                     auto variableMetadata = RandomGenerator::instance().randomChoice(metaDataPool);
                     // Retrieves provider
                     auto variableProvider
                         = properties.value(PROVIDER_PROPERTY).value<std::shared_ptr<IDataProvider> >();
                     auto variableName = QString{"Var_%1"}.arg(QUuid::createUuid().toString());
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Creating variable" << variableName
                                                               << "(metadata:" << variableMetadata << ")...";
                     auto newVariable
                         = variableController.createVariable(variableName, variableMetadata, variableProvider);
                     // Updates variable's state
                     auto &variableState = fuzzingState.variableState(variableId);
                     variableState.m_Range = properties.value(INITIAL_RANGE_PROPERTY).value<SqpRange>();
                     std::swap(variableState.m_Variable, newVariable);
                 }
             };
             struct DeleteOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     // A variable can be delete only if it exists
                     return fuzzingState.variableState(variableId).m_Variable != nullptr;
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController, const Properties &) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Deleting variable"
                                                               << variableState.m_Variable->name() << "...";
                     variableController.deleteVariable(variableState.m_Variable);
                     // Updates variable's state
                     variableState.m_Range = INVALID_RANGE;
                     variableState.m_Variable = nullptr;
                     // Desynchronizes the variable if it was in a sync group
                     auto syncGroupId = fuzzingState.syncGroupId(variableId);
                     fuzzingState.desynchronizeVariable(variableId, syncGroupId);
                 }
             };
             /**
              * Defines a move operation through a range.
              *
              * A move operation is determined by three functions:
              * - Two 'move' functions, used to indicate in which direction the beginning and the end of a range
              * are going during the operation. These functions will be:
              * -- {<- / <-} for pan left
              * -- {-> / ->} for pan right
              * -- {-> / <-} for zoom in
              * -- {<- / ->} for zoom out
              * - One 'max move' functions, used to compute the max delta at which the operation can move a
              * range, according to a max range. For exemple, for a range of {1, 5} and a max range of {0, 10},
              * max deltas will be:
              * -- {0, 4} for pan left
              * -- {6, 10} for pan right
              * -- {3, 3} for zoom in
              * -- {0, 6} for zoom out (same spacing left and right)
              */
             struct MoveOperation : public IFuzzingOperation {
                 using MoveFunction = std::function<double(double currentValue, double maxValue)>;
                 using MaxMoveFunction = std::function<double(const SqpRange &range, const SqpRange &maxRange)>;
                 explicit MoveOperation(MoveFunction rangeStartMoveFun, MoveFunction rangeEndMoveFun,
                                        MaxMoveFunction maxMoveFun,
                                        const QString &label = QStringLiteral("Move operation"))
                         : m_RangeStartMoveFun{std::move(rangeStartMoveFun)},
                           m_RangeEndMoveFun{std::move(rangeEndMoveFun)},
                           m_MaxMoveFun{std::move(maxMoveFun)},
                           m_Label{label}
                 {
                 }
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     return fuzzingState.variableState(variableId).m_Variable != nullptr;
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController,
                              const Properties &properties) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     auto variable = variableState.m_Variable;
                     // Gets the max range defined
                     auto maxRange = properties.value(MAX_RANGE_PROPERTY, QVariant::fromValue(INVALID_RANGE))
                                         .value<SqpRange>();
                     auto variableRange = variableState.m_Range;
                     if (maxRange == INVALID_RANGE || variableRange.m_TStart < maxRange.m_TStart
                         || variableRange.m_TEnd > maxRange.m_TEnd) {
                         qCWarning(LOG_FuzzingOperations()) << "Can't execute operation: invalid max range";
                         return;
                     }
                     // Computes the max delta at which the variable can move, up to the limits of the max range
                     auto deltaMax = m_MaxMoveFun(variableRange, maxRange);
                     // Generates random delta that will be used to move variable
                     auto delta = RandomGenerator::instance().generateDouble(0, deltaMax);
                     // Moves variable to its new range
                     auto isSynchronized = !fuzzingState.syncGroupId(variableId).isNull();
                     auto newVariableRange = SqpRange{m_RangeStartMoveFun(variableRange.m_TStart, delta),
                                                      m_RangeEndMoveFun(variableRange.m_TEnd, delta)};
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Performing" << m_Label << "on"
                                                               << variable->name() << "(from" << variableRange
                                                               << "to" << newVariableRange << ")...";
                     variableController.onRequestDataLoading({variable}, newVariableRange, isSynchronized);
                     // Updates state
                     fuzzingState.updateRanges(variableId, newVariableRange);
                 }
                 MoveFunction m_RangeStartMoveFun;
                 MoveFunction m_RangeEndMoveFun;
                 MaxMoveFunction m_MaxMoveFun;
                 QString m_Label;
             };
             struct SynchronizeOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     auto variable = fuzzingState.variableState(variableId).m_Variable;
                     return variable != nullptr && !fuzzingState.m_SyncGroupsPool.empty()
                            && fuzzingState.syncGroupId(variableId).isNull();
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController, const Properties &) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     // Chooses a random synchronization group and adds the variable into sync group
                     auto syncGroupId = RandomGenerator::instance().randomChoice(fuzzingState.syncGroupsIds());
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Adding" << variableState.m_Variable->name()
                                                               << "into synchronization group" << syncGroupId
                                                               << "...";
                     variableController.onAddSynchronized(variableState.m_Variable, syncGroupId);
                     // Updates state
                     fuzzingState.synchronizeVariable(variableId, syncGroupId);
                     variableController.onRequestDataLoading({variableState.m_Variable}, variableState.m_Range,
-                                                            false);
+                                                            true);
                 }
             };
             struct DesynchronizeOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     auto variable = fuzzingState.variableState(variableId).m_Variable;
                     return variable != nullptr && !fuzzingState.syncGroupId(variableId).isNull();
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController, const Properties &) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     // Gets the sync group of the variable
                     auto syncGroupId = fuzzingState.syncGroupId(variableId);
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Removing" << variableState.m_Variable->name()
                                                               << "from synchronization group" << syncGroupId
                                                               << "...";
                     variableController.desynchronize(variableState.m_Variable, syncGroupId);
                     // Updates state
                     fuzzingState.desynchronizeVariable(variableId, syncGroupId);
                 }
             };
             struct UnknownOperation : public IFuzzingOperation {
                 bool canExecute(VariableId, const FuzzingState &) const override { return false; }
                 void execute(VariableId, FuzzingState &, VariableController &,
                              const Properties &) const override
                 {
                 }
             };
             } // namespace
             std::unique_ptr<IFuzzingOperation> FuzzingOperationFactory::create(FuzzingOperationType type)
             {
                 switch (type) {
                     case FuzzingOperationType::CREATE:
                         return std::make_unique<CreateOperation>();
                     case FuzzingOperationType::DELETE:
                         return std::make_unique<DeleteOperation>();
                     case FuzzingOperationType::PAN_LEFT:
                         return std::make_unique<MoveOperation>(
                             std::minus<double>(), std::minus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 return range.m_TStart - maxRange.m_TStart;
                             },
                             QStringLiteral("Pan left operation"));
                     case FuzzingOperationType::PAN_RIGHT:
                         return std::make_unique<MoveOperation>(
                             std::plus<double>(), std::plus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 return maxRange.m_TEnd - range.m_TEnd;
                             },
                             QStringLiteral("Pan right operation"));
                     case FuzzingOperationType::ZOOM_IN:
                         return std::make_unique<MoveOperation>(
                             std::plus<double>(), std::minus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 Q_UNUSED(maxRange)
                                 return range.m_TEnd - (range.m_TStart + range.m_TEnd) / 2.;
                             },
                             QStringLiteral("Zoom in operation"));
                     case FuzzingOperationType::ZOOM_OUT:
                         return std::make_unique<MoveOperation>(
                             std::minus<double>(), std::plus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 return std::min(range.m_TStart - maxRange.m_TStart,
                                                 maxRange.m_TEnd - range.m_TEnd);
                             },
                             QStringLiteral("Zoom out operation"));
                     case FuzzingOperationType::SYNCHRONIZE:
                         return std::make_unique<SynchronizeOperation>();
                     case FuzzingOperationType::DESYNCHRONIZE:
                         return std::make_unique<DesynchronizeOperation>();
                     default:
                         // Default case returns unknown operation
                         break;
                 }
                 return std::make_unique<UnknownOperation>();
             }

plugins/amda/tests/TestAmdaFuzzing.cpp +23 -21

             #include "FuzzingDefs.h"
             #include "FuzzingOperations.h"
             #include "FuzzingUtils.h"
             #include "FuzzingValidators.h"
             #include "AmdaProvider.h"
             #include <Common/SignalWaiter.h>
             #include <Network/NetworkController.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QtTest>
             #include <memory>
             Q_LOGGING_CATEGORY(LOG_TestAmdaFuzzing, "TestAmdaFuzzing")
             /**
              * Macro used to generate a getter for a property in @sa FuzzingTest. The macro generates a static
              * attribute that is initialized by searching in properties the property and use a default value if
              * it's not present. Macro arguments are:
              * - GETTER_NAME : name of the getter
              * - PROPERTY_NAME: used to generate constants for property's name ({PROPERTY_NAME}_PROPERTY) and
              * default value ({PROPERTY_NAME}_DEFAULT_VALUE)
              * - TYPE : return type of the getter
              */
             // clang-format off
             #define DECLARE_PROPERTY_GETTER(GETTER_NAME, PROPERTY_NAME, TYPE)  \
             TYPE GETTER_NAME() const \
             { \
                 static auto result = m_Properties.value(PROPERTY_NAME##_PROPERTY, PROPERTY_NAME##_DEFAULT_VALUE).value<TYPE>(); \
                 return result; \
             } \
             // clang-format on
             namespace {
             // /////// //
             // Aliases //
             // /////// //
             using IntPair = std::pair<int, int>;
             using Weight = double;
             using Weights = std::vector<Weight>;
             struct OperationProperty {
                 Weight m_Weight{1.};
                 bool m_WaitAcquisition{false};
             };
             using VariableOperation = std::pair<VariableId, std::shared_ptr<IFuzzingOperation> >;
             using VariablesOperations = std::vector<VariableOperation>;
             struct CustomVariableOperation {
                 VariableOperation m_VariableOperation{};
                 bool m_WaitAcquisition{false};
             };
             using CustomVariablesOperations = std::vector<CustomVariableOperation>;
             using OperationsTypes = std::map<FuzzingOperationType, OperationProperty>;
             using OperationsPool = std::map<std::shared_ptr<IFuzzingOperation>, OperationProperty>;
             using Validators = std::vector<std::shared_ptr<IFuzzingValidator> >;
             // ///////// //
             // Constants //
             // ///////// //
             // Defaults values used when the associated properties have not been set for the test
-            const auto ACQUISITION_TIMEOUT_DEFAULT_VALUE = 30000;
+            const auto ACQUISITION_TIMEOUT_DEFAULT_VALUE = 100000;
-            const auto NB_MAX_OPERATIONS_DEFAULT_VALUE = 100;
+            const auto NB_MAX_OPERATIONS_DEFAULT_VALUE = 160;
-            const auto NB_MAX_SYNC_GROUPS_DEFAULT_VALUE = 1;
+            const auto NB_MAX_SYNC_GROUPS_DEFAULT_VALUE = 8;
-            const auto NB_MAX_VARIABLES_DEFAULT_VALUE = 2;
+            const auto NB_MAX_VARIABLES_DEFAULT_VALUE = 30;
             const auto AVAILABLE_OPERATIONS_DEFAULT_VALUE = QVariant::fromValue(
-                OperationsTypes{{FuzzingOperationType::CREATE, {400., true}},
+                OperationsTypes{{FuzzingOperationType::CREATE, {40000., true}},
                                 {FuzzingOperationType::DELETE, {0.0}}, // Delete operation is less frequent
                                 {FuzzingOperationType::PAN_LEFT, {1.}},
                                 {FuzzingOperationType::PAN_RIGHT, {1.}},
-                                {FuzzingOperationType::ZOOM_IN, {0.}},
+                                {FuzzingOperationType::ZOOM_IN, {1.}},
-                                {FuzzingOperationType::ZOOM_OUT, {0.}},
+                                {FuzzingOperationType::ZOOM_OUT, {1.}},
-                                {FuzzingOperationType::SYNCHRONIZE, {4000.0}},
+                                {FuzzingOperationType::SYNCHRONIZE, {500.0}},
-                                {FuzzingOperationType::DESYNCHRONIZE, {0.4}}});
+                                {FuzzingOperationType::DESYNCHRONIZE, {0.0}}});
             const auto CACHE_TOLERANCE_DEFAULT_VALUE = 0.2;
             /// Min/max delays between each operation (in ms)
-            const auto OPERATION_DELAY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(20, 20));
+            const auto OPERATION_DELAY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(20, 3000));
             /// Validators for the tests (executed in the order in which they're defined)
             const auto VALIDATORS_DEFAULT_VALUE = QVariant::fromValue(
                 ValidatorsTypes{{FuzzingValidatorType::RANGE, FuzzingValidatorType::DATA}});
             /// Min/max number of operations to execute before calling validation
-            const auto VALIDATION_FREQUENCY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(2, 2));
+            const auto VALIDATION_FREQUENCY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(2, 10));
             // /////// //////
             // CUSTOM CASE //
             // /////// //////
             auto op = [](auto type){
                 return FuzzingOperationFactory::create(type);
             };
             const QVariant CUSTOM_CASE_ONE =QVariant::fromValue(CustomVariablesOperations{{{0, op(FuzzingOperationType::CREATE)}, true},
                                                                                           {{0, op(FuzzingOperationType::SYNCHRONIZE)}},
                                                                                           {{1, op(FuzzingOperationType::CREATE)}, true},
                                                                                           {{1, op(FuzzingOperationType::SYNCHRONIZE)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                                           {{0, op(FuzzingOperationType::PAN_LEFT)}},
                                                                                           {{1, op(FuzzingOperationType::PAN_RIGHT)}},
                                                                 });
             const QVariant CUSTOM_CASE_TWO =QVariant::fromValue(CustomVariablesOperations{{{0, op(FuzzingOperationType::CREATE)}, true},
                                                                                           {{0, op(FuzzingOperationType::SYNCHRONIZE)}},
                                                                                           {{1, op(FuzzingOperationType::CREATE)}, true},
                                                                                           {{1, op(FuzzingOperationType::SYNCHRONIZE)}},
                                                                                           {{1, op(FuzzingOperationType::ZOOM_OUT)}},
                                                                                           {{1, op(FuzzingOperationType::ZOOM_IN)}},
                                                                 });
             // /////// //
             // Methods //
             // /////// //
             /// Goes through the variables pool and operations pool to determine the set of {variable/operation}
             /// pairs that are valid (i.e. operation that can be executed on variable)
             std::pair<VariablesOperations, Weights> availableOperations(const FuzzingState &fuzzingState,
                                                                         const OperationsPool &operationsPool)
             {
                 VariablesOperations result{};
                 Weights weights{};
                 for (const auto &variablesPoolEntry : fuzzingState.m_VariablesPool) {
                     auto variableId = variablesPoolEntry.first;
                     for (const auto &operationsPoolEntry : operationsPool) {
                         auto operation = operationsPoolEntry.first;
                         auto operationProperty = operationsPoolEntry.second;
                         // A pair is valid if the current operation can be executed on the current variable
                         if (operation->canExecute(variableId, fuzzingState)) {
                             result.push_back({variableId, operation});
                             weights.push_back(operationProperty.m_Weight);
                         }
                     }
                 }
                 return {result, weights};
             }
             OperationsPool createOperationsPool(const OperationsTypes &types)
             {
                 OperationsPool result{};
                 std::transform(
                     types.cbegin(), types.cend(), std::inserter(result, result.end()), [](const auto &type) {
                         return std::make_pair(FuzzingOperationFactory::create(type.first), type.second);
                     });
                 return result;
             }
             Validators createValidators(const ValidatorsTypes &types)
             {
                 Validators result{};
                 std::transform(types.cbegin(), types.cend(), std::inserter(result, result.end()),
                                [](const auto &type) { return FuzzingValidatorFactory::create(type); });
                 return result;
             }
             /**
              * Validates all the variables' states passed in parameter, according to a set of validators
              * @param variablesPool the variables' states
              * @param validators the validators used for validation
              */
             void validate(const VariablesPool &variablesPool, const Validators &validators)
             {
                 for (const auto &variablesPoolEntry : variablesPool) {
                     auto variableId = variablesPoolEntry.first;
                     const auto &variableState = variablesPoolEntry.second;
                     auto variableMessage = variableState.m_Variable ? variableState.m_Variable->name()
                                                                     : QStringLiteral("null variable");
                     qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Validating state of variable at index"
                                                             << variableId << "(" << variableMessage << ")...";
                     for (const auto &validator : validators) {
                         validator->validate(VariableState{variableState});
                     }
                     qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Validation completed.";
                 }
             }
             /**
              * Class to run random tests
              */
             class FuzzingTest {
             public:
                 explicit FuzzingTest(VariableController &variableController, Properties properties)
                         : m_VariableController{variableController},
                           m_Properties{std::move(properties)},
                           m_FuzzingState{}
                 {
                     // Inits variables pool: at init, all variables are null
                     for (auto variableId = 0; variableId < nbMaxVariables(); ++variableId) {
                         m_FuzzingState.m_VariablesPool[variableId] = VariableState{};
                     }
                     // Inits sync groups and registers them into the variable controller
                     for (auto i = 0; i < nbMaxSyncGroups(); ++i) {
                         auto syncGroupId = SyncGroupId::createUuid();
                         variableController.onAddSynchronizationGroupId(syncGroupId);
                         m_FuzzingState.m_SyncGroupsPool[syncGroupId] = SyncGroup{};
                     }
                 }
                 void execute()
                 {
                     // Inits the count of the number of operations before the next validation
                     int nextValidationCounter = 0;
                     auto updateValidationCounter = [this, &nextValidationCounter]() {
                         nextValidationCounter = RandomGenerator::instance().generateInt(
                             validationFrequencies().first, validationFrequencies().second);
                         qCInfo(LOG_TestAmdaFuzzing()).noquote()
                             << "Next validation in " << nextValidationCounter << "operation(s)...";
                     };
                     updateValidationCounter();
                     // Get custom operations
                     auto customOperations = m_Properties.value(CUSTOM_OPERATIONS_PROPERTY).value<CustomVariablesOperations>();
                     auto isCustomTest = !customOperations.empty();
                     auto nbOperations = isCustomTest ? customOperations.size() : nbMaxOperations();
                     qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Running" << nbOperations << "operations on"
                                                             << nbMaxVariables() << "variable(s)...";
                     auto canExecute = true;
                     for (auto i = 0; i < nbOperations && canExecute; ++i) {
                         VariableOperation variableOperation{};
                         auto forceWait = false;
                         if(isCustomTest){
                             auto customOperation = customOperations.front();
                             variableOperation = customOperation.m_VariableOperation;
                             customOperations.erase(customOperations.begin());
                             canExecute = variableOperation.second->canExecute(variableOperation.first, m_FuzzingState);
                             forceWait = customOperation.m_WaitAcquisition;
                         } else {
                             // Retrieves all operations that can be executed in the current context
                             VariablesOperations variableOperations{};
                             Weights weights{};
                             std::tie(variableOperations, weights)
                                 = availableOperations(m_FuzzingState, operationsPool());
                             // Of the operations available, chooses a random operation and executes it
                             variableOperation
                                 = RandomGenerator::instance().randomChoice(variableOperations, weights);
                             canExecute = !variableOperations.empty();
                             forceWait = operationsPool().at(variableOperation.second).m_WaitAcquisition;
                         }
                         if (canExecute) {
                             --nextValidationCounter;
                             auto variableId = variableOperation.first;
                             auto fuzzingOperation = variableOperation.second;
                             auto waitAcquisition = nextValidationCounter == 0
                                                    || forceWait;
+                            qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Operation :" << i +1 << " on"
+                                                                    << nbOperations;
                             fuzzingOperation->execute(variableId, m_FuzzingState, m_VariableController,
                                                       m_Properties);
                             if (waitAcquisition) {
                                 qCDebug(LOG_TestAmdaFuzzing()) << "Waiting for acquisition to finish...";
                                 SignalWaiter{m_VariableController, SIGNAL(acquisitionFinished())}.wait(
                                     acquisitionTimeout());
                                 // Validates variables
                                 if (nextValidationCounter == 0) {
                                     validate(m_FuzzingState.m_VariablesPool, validators());
                                     updateValidationCounter();
                                 }
                             }
                             else {
                                 // Delays the next operation with a randomly generated time
                                 auto delay = RandomGenerator::instance().generateInt(operationDelays().first,
                                                                                      operationDelays().second);
                                 qCDebug(LOG_TestAmdaFuzzing())
                                     << "Waiting " << delay << "ms before the next operation...";
                                 QTest::qWait(delay);
                             }
                         }
                         else {
                             qCInfo(LOG_TestAmdaFuzzing()).noquote()
                                 << "No more operations are available, the execution of the test will stop...";
                         }
                     }
                     qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Execution of the test completed.";
                 }
             private:
                 OperationsPool operationsPool() const
                 {
                     static auto result = createOperationsPool(
                         m_Properties.value(AVAILABLE_OPERATIONS_PROPERTY, AVAILABLE_OPERATIONS_DEFAULT_VALUE)
                             .value<OperationsTypes>());
                     return result;
                 }
                 Validators validators() const
                 {
                     static auto result
                         = createValidators(m_Properties.value(VALIDATORS_PROPERTY, VALIDATORS_DEFAULT_VALUE)
                                                .value<ValidatorsTypes>());
                     return result;
                 }
                 DECLARE_PROPERTY_GETTER(nbMaxOperations, NB_MAX_OPERATIONS, int)
                 DECLARE_PROPERTY_GETTER(nbMaxSyncGroups, NB_MAX_SYNC_GROUPS, int)
                 DECLARE_PROPERTY_GETTER(nbMaxVariables, NB_MAX_VARIABLES, int)
                 DECLARE_PROPERTY_GETTER(operationDelays, OPERATION_DELAY_BOUNDS, IntPair)
                 DECLARE_PROPERTY_GETTER(validationFrequencies, VALIDATION_FREQUENCY_BOUNDS, IntPair)
                 DECLARE_PROPERTY_GETTER(acquisitionTimeout, ACQUISITION_TIMEOUT, int)
                 VariableController &m_VariableController;
                 Properties m_Properties;
                 FuzzingState m_FuzzingState;
             };
             } // namespace
             Q_DECLARE_METATYPE(OperationsTypes)
             Q_DECLARE_METATYPE(CustomVariablesOperations)
             class TestAmdaFuzzing : public QObject {
                 Q_OBJECT
             private slots:
                 /// Input data for @sa testFuzzing()
                 void testFuzzing_data();
                 void testFuzzing();
             };
             void TestAmdaFuzzing::testFuzzing_data()
             {
                 // Note: Comment this line to run fuzzing tests
             //    QSKIP("Fuzzing tests are disabled by default");
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 QTest::addColumn<Properties>("properties"); // Properties for random test
                 // ////////// //
                 // Test cases //
                 // ////////// //
-                auto maxRange = SqpRange::fromDateTime({2017, 1, 3}, {0, 0}, {2017, 1, 5}, {0, 0});
+                auto maxRange = SqpRange::fromDateTime({2017, 1, 5}, {8, 0}, {2017, 1, 5}, {16, 0});
                 MetadataPool metadataPool{{{"dataType", "vector"}, {"xml:id", "c1_b"}}};
                 // Note: we don't use auto here as we want to pass std::shared_ptr<IDataProvider> as is in the
                 // QVariant
                 std::shared_ptr<IDataProvider> provider = std::make_shared<AmdaProvider>();
                 // Case Custom one : Only lot of pan on two variables synchronized
             //    QTest::newRow("fuzzingTestPan") << Properties{
             //    {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
             //    {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
             //    {PROVIDER_PROPERTY, QVariant::fromValue(provider)},
             //    {CUSTOM_OPERATIONS_PROPERTY, CUSTOM_CASE_ONE}};
-                QTest::newRow("fuzzingTestZoom") << Properties{
+            //    QTest::newRow("fuzzingTestZoom") << Properties{
-                {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
+            //    {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
-                {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
+            //    {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
-                {PROVIDER_PROPERTY, QVariant::fromValue(provider)},
+            //    {PROVIDER_PROPERTY, QVariant::fromValue(provider)},
-                {CUSTOM_OPERATIONS_PROPERTY, CUSTOM_CASE_TWO}};
+            //    {CUSTOM_OPERATIONS_PROPERTY, CUSTOM_CASE_TWO}};
             ////     Fuzzing
-            //    QTest::newRow("fuzzingTest") << Properties{
+                QTest::newRow("fuzzingTest") << Properties{
-            //    {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
+                {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
-            //    {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
+                {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
-            //    {PROVIDER_PROPERTY, QVariant::fromValue(provider)}};
+                {PROVIDER_PROPERTY, QVariant::fromValue(provider)}};
             }
             void TestAmdaFuzzing::testFuzzing()
             {
                 QFETCH(Properties, properties);
                 // Sets cache property
                 QSettings settings{};
                 auto cacheTolerance = properties.value(CACHE_TOLERANCE_PROPERTY, CACHE_TOLERANCE_DEFAULT_VALUE);
                 settings.setValue(GENERAL_TOLERANCE_AT_INIT_KEY, cacheTolerance);
                 settings.setValue(GENERAL_TOLERANCE_AT_UPDATE_KEY, cacheTolerance);
                 auto &variableController = sqpApp->variableController();
                 auto &timeController = sqpApp->timeController();
                 // Generates random initial range (bounded to max range)
                 auto maxRange = properties.value(MAX_RANGE_PROPERTY, QVariant::fromValue(INVALID_RANGE))
                                     .value<SqpRange>();
                 QVERIFY(maxRange != INVALID_RANGE);
                 auto initialRangeStart
                     = RandomGenerator::instance().generateDouble(maxRange.m_TStart, maxRange.m_TEnd);
                 auto initialRangeEnd
                     = RandomGenerator::instance().generateDouble(maxRange.m_TStart, maxRange.m_TEnd);
                 if (initialRangeStart > initialRangeEnd) {
                     std::swap(initialRangeStart, initialRangeEnd);
                 }
                 // Sets initial range on time controller
                 SqpRange initialRange{initialRangeStart, initialRangeEnd};
                 qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Setting initial range to" << initialRange << "...";
                 timeController.onTimeToUpdate(initialRange);
                 properties.insert(INITIAL_RANGE_PROPERTY, QVariant::fromValue(initialRange));
                 FuzzingTest test{variableController, properties};
                 test.execute();
             }
             int main(int argc, char *argv[])
             {
                 // Increases the test function timeout (which is 5 minutes by default) to 12 hours
                 // https://stackoverflow.com/questions/42655932/setting-timeout-to-qt-test
                 qputenv("QTEST_FUNCTION_TIMEOUT", QByteArray::number(12*60*60*1000));
                 QLoggingCategory::setFilterRules(
                     "*.warning=false\n"
                     "*.info=false\n"
                     "*.debug=false\n"
                     "FuzzingOperations.info=true\n"
                     "FuzzingValidators.info=true\n"
                     "TestAmdaFuzzing.info=true\n");
                 SqpApplication app{argc, argv};
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop-TestFuzzing");
                 app.setAttribute(Qt::AA_Use96Dpi, true);
                 TestAmdaFuzzing testObject{};
                 QTEST_SET_MAIN_SOURCE_PATH
                 return QTest::qExec(&testObject, argc, argv);
             }
             #include "TestAmdaFuzzing.moc"

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages