GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1400:a4f96b874829

Merge branch 'feature/AcquisitionTest' into develop

perrinel -

r1400:a4f96b874829

parent child

Context file:

r1400:a4f96b874829

core/include/Data/AcquisitionRequest.h 0 -2

                 QUuid m_AcqIdentifier;
                 QUuid m_vIdentifier;
                 DataProviderParameters m_DataProviderParameters;
-                SqpRange m_RangeRequested;
-                SqpRange m_CacheRangeRequested;
                 int m_Size;
                 int m_Progression;
                 std::shared_ptr<IDataProvider> m_Provider;

core/include/Variable/VariableAcquisitionWorker.h +3 -5

                 explicit VariableAcquisitionWorker(QObject *parent = 0);
                 virtual ~VariableAcquisitionWorker();
-                QUuid pushVariableRequest(QUuid varRequestId, QUuid vIdentifier, SqpRange rangeRequested,
+                QUuid pushVariableRequest(QUuid varRequestId, QUuid vIdentifier,
-                                          SqpRange cacheRangeRequested, DataProviderParameters parameters,
+                                          DataProviderParameters parameters,
                                           std::shared_ptr<IDataProvider> provider);
                 void abortProgressRequested(QUuid vIdentifier);
                 void initialize();
                 void finalize();
             signals:
-                void dataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
+                void dataProvided(QUuid vIdentifier, QVector<AcquisitionDataPacket> dataAcquired);
-                                  const SqpRange &cacheRangeRequested,
-                                  QVector<AcquisitionDataPacket> dataAcquired);
                 void variableRequestInProgress(QUuid vIdentifier, double progress);

core/include/Variable/VariableController.h +1 -3

                 void onUpdateDateTime(std::shared_ptr<Variable> variable, const SqpRange &dateTime);
-                void onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
+                void onDataProvided(QUuid vIdentifier, QVector<AcquisitionDataPacket> dataAcquired);
-                                    const SqpRange &cacheRangeRequested,
-                                    QVector<AcquisitionDataPacket> dataAcquired);
                 void onVariableRetrieveDataInProgress(QUuid identifier, double progress);

core/src/Variable/VariableAcquisitionWorker.cpp +53 -100

                 void removeVariableRequest(QUuid vIdentifier);
-                /// Remove the current request and execute the next one if exist
-                void updateToNextRequest(QUuid vIdentifier);
                 /// Remove and/or abort all AcqRequest in link with varRequestId
                 void cancelVarRequest(QUuid varRequestId);
                 void removeAcqRequest(QUuid acqRequestId);
                 std::map<QUuid, QVector<AcquisitionDataPacket> > m_AcqIdentifierToAcqDataPacketVectorMap;
                 std::map<QUuid, AcquisitionRequest> m_AcqIdentifierToAcqRequestMap;
-                std::map<QUuid, std::pair<QUuid, QUuid> > m_VIdentifierToCurrrentAcqIdNextIdPairMap;
+                std::map<QUuid, QUuid> m_VIdentifierToCurrrentAcqIdMap;
                 VariableAcquisitionWorker *q;
             };
             QUuid VariableAcquisitionWorker::pushVariableRequest(QUuid varRequestId, QUuid vIdentifier,
-                                                                 SqpRange rangeRequested,
-                                                                 SqpRange cacheRangeRequested,
                                                                  DataProviderParameters parameters,
                                                                  std::shared_ptr<IDataProvider> provider)
             {
                 qCDebug(LOG_VariableAcquisitionWorker())
-                    << tr("TORM VariableAcquisitionWorker::pushVariableRequest ") << cacheRangeRequested;
+                    << tr("TORM VariableAcquisitionWorker::pushVariableRequest varRequestId: ") << varRequestId
+                    << "vId: " << vIdentifier;
                 auto varRequestIdCanceled = QUuid();
                 // Request creation
                 auto acqRequest = AcquisitionRequest{};
-                qCDebug(LOG_VariableAcquisitionWorker()) << tr("PushVariableRequest ") << vIdentifier
-                                                         << varRequestId;
                 acqRequest.m_VarRequestId = varRequestId;
                 acqRequest.m_vIdentifier = vIdentifier;
                 acqRequest.m_DataProviderParameters = parameters;
-                acqRequest.m_RangeRequested = rangeRequested;
-                acqRequest.m_CacheRangeRequested = cacheRangeRequested;
                 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->m_AcqIdentifierToAcqRequestMap.insert(
                     std::make_pair(acqRequest.m_AcqIdentifier, acqRequest));
-                auto it = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
+                auto it = impl->m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
-                if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
+                if (it != impl->m_VIdentifierToCurrrentAcqIdMap.cend()) {
-                    // A current request already exists, we can replace the next one
+                    // A current request already exists, we can cancel it
-                    auto oldAcqId = it->second.second;
+                    // 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;
                     }
-                    it->second.second = acqRequest.m_AcqIdentifier;
                     impl->unlock();
-                    // remove old acqIdentifier from the worker
                     impl->cancelVarRequest(varRequestIdCanceled);
-                    //        impl->m_AcqIdentifierToAcqRequestMap.erase(oldAcqId);
                 }
                 else {
-                    // First request for the variable, it must be stored and executed
+                    impl->unlock();
-                    impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.insert(
-                        std::make_pair(vIdentifier, std::make_pair(acqRequest.m_AcqIdentifier, QUuid())));
+                // 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;
             }
             {
                 impl->lockRead();
-                auto it = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
+                auto it = impl->m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
-                if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
+                if (it != impl->m_VIdentifierToCurrrentAcqIdMap.cend()) {
-                    auto currentAcqId = it->second.first;
+                    auto currentAcqId = it->second;
                     auto it = impl->m_AcqIdentifierToAcqRequestMap.find(currentAcqId);
                     if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                         auto request = it->second;
                         impl->unlock();
-                        // Remove the current request from the worker
-                        impl->updateToNextRequest(vIdentifier);
                         // notify the request aborting to the provider
                         request.m_Provider->requestDataAborting(currentAcqId);
                     }
                                                                              double progress)
             {
                 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 currentPartSize = (aIdToARit->second.m_Size != 0) ? 100 / aIdToARit->second.m_Size : 0;
+                    auto progressPartSize
+                        = (aIdToARit->second.m_Size != 0) ? 100 / aIdToARit->second.m_Size : 0;
                     auto currentPartProgress
-                        = std::isnan(progress) ? 0.0 : (progress * currentPartSize) / 100.0;
+                        = std::isnan(progress) ? 0.0 : (progress * progressPartSize) / 100.0;
-                    auto currentAlreadyProgress = aIdToARit->second.m_Progression * currentPartSize;
+                    // We can only give an approximation of the currentProgression since its upgrade is async.
+                    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);
-                    qCDebug(LOG_VariableAcquisitionWorker())
-                        << tr("TORM: onVariableRetrieveDataInProgress ")
-                        << QThread::currentThread()->objectName() << aIdToARit->second.m_vIdentifier
-                        << currentPartSize << currentAlreadyProgress << currentPartProgress << finalProgression;
                     if (finalProgression == 100.0) {
                         emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, 0.0);
                     }
                 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
                 }
             }
                     // removed the finished request
                     if (acqRequest.m_Size == acqRequest.m_Progression) {
                         auto varId = acqRequest.m_vIdentifier;
-                        auto rangeRequested = acqRequest.m_RangeRequested;
-                        auto cacheRangeRequested = acqRequest.m_CacheRangeRequested;
                         // Return the data
                         aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
                         if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
-                            emit dataProvided(varId, rangeRequested, cacheRangeRequested, aIdToADPVit->second);
+                            emit dataProvided(varId, aIdToADPVit->second);
                         }
                         impl->unlock();
-                        // Update to the next request
-                        impl->updateToNextRequest(acqRequest.m_vIdentifier);
                     }
                     else {
                         impl->unlock();
                     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 {
                 QUuid vIdentifier)
             {
                 lockWrite();
-                auto it = m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
+                auto it = m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
-                if (it != m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
+                if (it != m_VIdentifierToCurrrentAcqIdMap.cend()) {
                     // A current request already exists, we can replace the next one
-                    m_AcqIdentifierToAcqRequestMap.erase(it->second.first);
+                    qCDebug(LOG_VariableAcquisitionWorker())
-                    m_AcqIdentifierToAcqDataPacketVectorMap.erase(it->second.first);
+                        << "VariableAcquisitionWorkerPrivate::removeVariableRequest "
+                        << QThread::currentThread()->objectName() << it->second;
-                    m_AcqIdentifierToAcqRequestMap.erase(it->second.second);
+                    m_AcqIdentifierToAcqRequestMap.erase(it->second);
-                    m_AcqIdentifierToAcqDataPacketVectorMap.erase(it->second.second);
+                    m_AcqIdentifierToAcqDataPacketVectorMap.erase(it->second);
-                m_VIdentifierToCurrrentAcqIdNextIdPairMap.erase(vIdentifier);
-                unlock();
                 }
-            void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::updateToNextRequest(
+                // stop any progression
-                QUuid vIdentifier)
+                emit q->variableRequestInProgress(vIdentifier, 0.0);
-                lockRead();
+                m_VIdentifierToCurrrentAcqIdMap.erase(vIdentifier);
-                auto it = m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
-                if (it != m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
-                    if (it->second.second.isNull()) {
-                        unlock();
-                        // There is no next request, we can remove the variable request
-                        removeVariableRequest(vIdentifier);
-                    else {
-                        auto acqIdentifierToRemove = it->second.first;
-                        // Move the next request to the current request
-                        auto nextRequestId = it->second.second;
-                        it->second.first = nextRequestId;
-                        it->second.second = QUuid();
-                        unlock();
-                        // Remove AcquisitionRequest and results;
-                        lockWrite();
-                        m_AcqIdentifierToAcqRequestMap.erase(acqIdentifierToRemove);
-                        m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqIdentifierToRemove);
-                        unlock();
-                        // Execute the current request
-                        QMetaObject::invokeMethod(q, "onExecuteRequest", Qt::QueuedConnection,
-                                                  Q_ARG(QUuid, nextRequestId));
-                else {
                 unlock();
-                    qCCritical(LOG_VariableAcquisitionWorker())
-                        << tr("Impossible to execute the acquisition on an unfound variable ");
             }
             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;
                     vIdentifier = acqIt->second.m_vIdentifier;
                     provider = acqIt->second.m_Provider;
-                    auto it = m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
+                    auto it = m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
-                    if (it != m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
+                    if (it != m_VIdentifierToCurrrentAcqIdMap.cend()) {
-                        if (it->second.first == acqRequestId) {
+                        if (it->second == acqRequestId) {
                             // acqRequest is currently running -> let's aborting it
                             unlock();
-                            // Remove the current request from the worker
-                            updateToNextRequest(vIdentifier);
                             // notify the request aborting to the provider
                             provider->requestDataAborting(acqRequestId);
                         }
-                        else if (it->second.second == acqRequestId) {
-                            it->second.second = QUuid();
-                            unlock();
                         else {
                             unlock();
                         }
                 m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqRequestId);
                 m_AcqIdentifierToAcqRequestMap.erase(acqRequestId);
+                m_VIdentifierToCurrrentAcqIdMap.erase(vIdentifier);
                 unlock();
                 qCDebug(LOG_VariableAcquisitionWorker())

core/src/Variable/VariableController.cpp +29 -32

                     this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{newVariable}, range, false);
-                    //        auto varRequestId = QUuid::createUuid();
-                    //        qCInfo(LOG_VariableController()) << "createVariable: " << varId << varRequestId;
-                    //        impl->processRequest(newVariable, range, varRequestId);
-                    //        impl->updateVariableRequest(varRequestId);
                     emit variableAdded(newVariable);
                     return newVariable;
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 // NOTE we only permit the time modification for one variable
-                // DEPRECATED
-                // auto variables = QVector<std::shared_ptr<Variable> >{};
-                //        for (const auto &selectedRow : qAsConst(selectedRows)) {
-                //            if (auto selectedVariable =
-                //            impl->m_VariableModel->variable(selectedRow.row())) {
-                //                variables << selectedVariable;
-                //                // notify that rescale operation has to be done
-                //                emit rangeChanged(selectedVariable, dateTime);
-                //            }
-                //        }
-                //        if (!variables.isEmpty()) {
-                //            this->onRequestDataLoading(variables, dateTime, synchro);
-                //        }
                 if (selectedRows.size() == 1) {
                     if (auto selectedVariable
                 this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{variable}, dateTime, synchro);
             }
-            void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
+            void VariableController::onDataProvided(QUuid vIdentifier,
-                                                    const SqpRange &cacheRangeRequested,
                                                     QVector<AcquisitionDataPacket> dataAcquired)
             {
                 qCDebug(LOG_VariableController()) << tr("onDataProvided") << QThread::currentThread();
                     << "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 {
                     }
                     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);
                     }
                         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 &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 (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()) {
                                                                   << var->nbPoints();
                                 emit var->updated();
-                                qCDebug(LOG_VariableController()) << tr("Update OK");
                             }
                             else {
                                 qCCritical(LOG_VariableController())
                 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: {
                 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;
+                    }
+                }
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                                             itVarHandler->first);
                                     }
                                     m_VariableModel->setDataProgress(var, 0.0);
-                                    varHandler->m_CanUpdate = false;
                                     varHandler->m_State = VariableRequestHandlerState::OFF;
                                     varHandler->m_RunningVarRequest = VariableRequest{};
                                 }
                                             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{};
             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(
                         qCDebug(LOG_VariableController()) << "executeVarRequest " << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         m_VariableAcquisitionWorker->pushVariableRequest(
-                            varRequest.m_VariableGroupId, varId, varRequest.m_RangeRequested,
+                            varRequest.m_VariableGroupId, varId,
-                            varRequest.m_CacheRangeRequested,
                             DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
                             varProvider);
                     }
                     }
                 }
                 else {
+                    qCDebug(LOG_VariableController()) << "All already in the cache "
+                                                      << varRequest.m_RangeRequested;
                     acceptVariableRequest(varId,
                                           var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));
                 }

gui/src/Visualization/VisualizationGraphWidget.cpp 0 0

NO CONTENT: modified file

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

                         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);
                 }
             }
                 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
                           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
                 // //////////////// //
                 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;

plugins/amda/tests/FuzzingDefs.cpp +1 0

             const QString OPERATION_DELAY_BOUNDS_PROPERTY = QStringLiteral("operationDelays");
             const QString VALIDATORS_PROPERTY = QStringLiteral("validators");
             const QString VALIDATION_FREQUENCY_BOUNDS_PROPERTY = QStringLiteral("validationFrequencyBounds");
+            const QString CUSTOM_OPERATIONS_PROPERTY = QStringLiteral("customOperations");
             // //////////// //
             // FuzzingState //

plugins/amda/tests/FuzzingDefs.h +3 0

             /// Min/max number of operations to execute before calling validation of the current test's state
             extern const QString VALIDATION_FREQUENCY_BOUNDS_PROPERTY;
+            /// Custom operations to execute instead of random operations
+            extern const QString CUSTOM_OPERATIONS_PROPERTY;
             // /////// //
             // Structs //
             // /////// //

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

                     fuzzingState.synchronizeVariable(variableId, syncGroupId);
                     variableController.onRequestDataLoading({variableState.m_Variable}, variableState.m_Range,
-                                                            false);
+                                                            true);
                 }
             };

plugins/amda/tests/TestAmdaFuzzing.cpp +187 -22

@@ -57,6 +57,12 struct OperationProperty {
57	using VariableOperation = std::pair<VariableId, std::shared_ptr<IFuzzingOperation> >;	57	using VariableOperation = std::pair<VariableId, std::shared_ptr<IFuzzingOperation> >;
58	using VariablesOperations = std::vector<VariableOperation>;	58	using VariablesOperations = std::vector<VariableOperation>;
59		59
		60	struct CustomVariableOperation {
		61	VariableOperation m_VariableOperation{};
		62	bool m_WaitAcquisition{false};
		63	};
		64	using CustomVariablesOperations = std::vector<CustomVariableOperation>;
		65
60	using OperationsTypes = std::map<FuzzingOperationType, OperationProperty>;	66	using OperationsTypes = std::map<FuzzingOperationType, OperationProperty>;
61	using OperationsPool = std::map<std::shared_ptr<IFuzzingOperation>, OperationProperty>;	67	using OperationsPool = std::map<std::shared_ptr<IFuzzingOperation>, OperationProperty>;
62		68
@@ -67,30 +73,150 using Validators = std::vector<std::shared_ptr<IFuzzingValidator> >;
67	// ///////// //	73	// ///////// //
68		74
69	// Defaults values used when the associated properties have not been set for the test	75	// Defaults values used when the associated properties have not been set for the test
70	const auto ACQUISITION_TIMEOUT_DEFAULT_VALUE = 30000;	76	const auto ACQUISITION_TIMEOUT_DEFAULT_VALUE = 100000;
71	const auto NB_MAX_OPERATIONS_DEFAULT_VALUE = 100;	77	const auto NB_MAX_OPERATIONS_DEFAULT_VALUE = 160;
72	const auto NB_MAX_SYNC_GROUPS_DEFAULT_VALUE = 1;	78	const auto NB_MAX_SYNC_GROUPS_DEFAULT_VALUE = 8;
73	const auto NB_MAX_VARIABLES_DEFAULT_VALUE = 1;	79	const auto NB_MAX_VARIABLES_DEFAULT_VALUE = 30;
74	const auto AVAILABLE_OPERATIONS_DEFAULT_VALUE = QVariant::fromValue(	80	const auto AVAILABLE_OPERATIONS_DEFAULT_VALUE = QVariant::fromValue(
75	OperationsTypes{{FuzzingOperationType::CREATE, {1., true}},	81	OperationsTypes{{FuzzingOperationType::CREATE, {40000., true}},
76	{FuzzingOperationType::DELETE, {0.1}}, // Delete operation is less frequent	82	{FuzzingOperationType::DELETE, {0.0}}, // Delete operation is less frequent
77	{FuzzingOperationType::PAN_LEFT, {1.}},	83	{FuzzingOperationType::PAN_LEFT, {1.}},
78	{FuzzingOperationType::PAN_RIGHT, {1.}},	84	{FuzzingOperationType::PAN_RIGHT, {1.}},
79	{FuzzingOperationType::ZOOM_IN, {1.}},	85	{FuzzingOperationType::ZOOM_IN, {1.}},
80	{FuzzingOperationType::ZOOM_OUT, {1.}},	86	{FuzzingOperationType::ZOOM_OUT, {1.}},
81	{FuzzingOperationType::SYNCHRONIZE, {~~0.8~~}},	87	{FuzzingOperationType::SYNCHRONIZE, {500.0}},
82	{FuzzingOperationType::DESYNCHRONIZE, {0.4}}});	88	{FuzzingOperationType::DESYNCHRONIZE, {0.0}}});
83	const auto CACHE_TOLERANCE_DEFAULT_VALUE = 0.2;	89	const auto CACHE_TOLERANCE_DEFAULT_VALUE = 0.2;
84		90
85	/// Min/max delays between each operation (in ms)	91	/// Min/max delays between each operation (in ms)
86	const auto OPERATION_DELAY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(100, 3000));	92	const auto OPERATION_DELAY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(20, 3000));
87		93
88	/// Validators for the tests (executed in the order in which they're defined)	94	/// Validators for the tests (executed in the order in which they're defined)
89	const auto VALIDATORS_DEFAULT_VALUE = QVariant::fromValue(	95	const auto VALIDATORS_DEFAULT_VALUE = QVariant::fromValue(
90	ValidatorsTypes{{FuzzingValidatorType::RANGE, FuzzingValidatorType::DATA}});	96	ValidatorsTypes{{FuzzingValidatorType::RANGE, FuzzingValidatorType::DATA}});
91		97
92	/// Min/max number of operations to execute before calling validation	98	/// Min/max number of operations to execute before calling validation
93	const auto VALIDATION_FREQUENCY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(1, 10));	99	const auto VALIDATION_FREQUENCY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(2, 10));
		100
		101
		102	// /////// //////
		103	// CUSTOM CASE //
		104	// /////// //////
		105
		106	auto op = [](auto type){
		107	return FuzzingOperationFactory::create(type);
		108	};
		109
		110
		111	const QVariant CUSTOM_CASE_ONE =QVariant::fromValue(CustomVariablesOperations{{{0, op(FuzzingOperationType::CREATE)}, true},
		112	{{0, op(FuzzingOperationType::SYNCHRONIZE)}},
		113	{{1, op(FuzzingOperationType::CREATE)}, true},
		114	{{1, op(FuzzingOperationType::SYNCHRONIZE)}},
		115	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		116	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		117	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		118	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		119	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		120	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		121	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		122	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		123	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		124	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		125	{{0, op(FuzzingOperationType::PAN_RIGHT)}},
		126	{{1, op(FuzzingOperationType::PAN_LEFT)}},
		127	{{0, op(FuzzingOperationType::PAN_RIGHT)}},
		128	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		129	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		130	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		131	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		132	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		133	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		134	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		135	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		136	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		137	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		138	{{1, op(FuzzingOperationType::PAN_LEFT)}},
		139	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		140	{{1, op(FuzzingOperationType::PAN_LEFT)}},
		141	{{0, op(FuzzingOperationType::PAN_RIGHT)}},
		142	{{1, op(FuzzingOperationType::PAN_LEFT)}},
		143	{{0, op(FuzzingOperationType::PAN_RIGHT)}},
		144	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		145	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		146	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		147	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		148	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		149	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		150	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		151	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		152	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		153	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		154	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		155	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		156	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		157	{{0, op(FuzzingOperationType::PAN_RIGHT)}},
		158	{{1, op(FuzzingOperationType::PAN_LEFT)}},
		159	{{0, op(FuzzingOperationType::PAN_RIGHT)}},
		160	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		161	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		162	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		163	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		164	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		165	{{0, op(FuzzingOperationType::PAN_RIGHT)}},
		166	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		167	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		168	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		169	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		170	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		171	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		172	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		173	{{0, op(FuzzingOperationType::PAN_RIGHT)}},
		174	{{1, op(FuzzingOperationType::PAN_LEFT)}},
		175	{{0, op(FuzzingOperationType::PAN_RIGHT)}},
		176	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		177	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		178	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		179	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		180	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		181	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		182	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		183	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		184	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		185	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		186	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		187	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		188	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		189	{{0, op(FuzzingOperationType::PAN_RIGHT)}},
		190	{{1, op(FuzzingOperationType::PAN_LEFT)}},
		191	{{0, op(FuzzingOperationType::PAN_RIGHT)}},
		192	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		193	{{0, op(FuzzingOperationType::PAN_RIGHT)}},
		194	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		195	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		196	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		197	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		198	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		199	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		200	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		201	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		202	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		203	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		204	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		205	{{0, op(FuzzingOperationType::PAN_RIGHT)}},
		206	{{1, op(FuzzingOperationType::PAN_LEFT)}},
		207	{{0, op(FuzzingOperationType::PAN_RIGHT)}},
		208	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		209	{{0, op(FuzzingOperationType::PAN_LEFT)}},
		210	{{1, op(FuzzingOperationType::PAN_RIGHT)}},
		211	});
		212
		213	const QVariant CUSTOM_CASE_TWO =QVariant::fromValue(CustomVariablesOperations{{{0, op(FuzzingOperationType::CREATE)}, true},
		214	{{0, op(FuzzingOperationType::SYNCHRONIZE)}},
		215	{{1, op(FuzzingOperationType::CREATE)}, true},
		216	{{1, op(FuzzingOperationType::SYNCHRONIZE)}},
		217	{{1, op(FuzzingOperationType::ZOOM_OUT)}},
		218	{{1, op(FuzzingOperationType::ZOOM_IN)}},
		219	});
94		220
95	// /////// //	221	// /////// //
96	// Methods //	222	// Methods //
@@ -193,9 +319,6 public:
193		319
194	void execute()	320	void execute()
195	{	321	{
196	qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Running" << nbMaxOperations() << "operations on"
197	<< nbMaxVariables() << "variable(s)...";
198
199		322
200	// Inits the count of the number of operations before the next validation	323	// Inits the count of the number of operations before the next validation
201	int nextValidationCounter = 0;	324	int nextValidationCounter = 0;
@@ -207,28 +330,52 public:
207	};	330	};
208	updateValidationCounter();	331	updateValidationCounter();
209		332
		333	// Get custom operations
		334	auto customOperations = m_Properties.value(CUSTOM_OPERATIONS_PROPERTY).value<CustomVariablesOperations>();
		335	auto isCustomTest = !customOperations.empty();
		336
		337	auto nbOperations = isCustomTest ? customOperations.size() : nbMaxOperations();
		338
		339	qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Running" << nbOperations << "operations on"
		340	<< nbMaxVariables() << "variable(s)...";
		341
210	auto canExecute = true;	342	auto canExecute = true;
211	for (auto i = 0; i < nb~~Max~~Operations() && canExecute; ++i) {	343	for (auto i = 0; i < nbOperations && canExecute; ++i) {
		344	VariableOperation variableOperation{};
		345	auto forceWait = false;
		346
		347	if(isCustomTest){
		348	auto customOperation = customOperations.front();
		349	variableOperation = customOperation.m_VariableOperation;
		350	customOperations.erase(customOperations.begin());
		351
		352	canExecute = variableOperation.second->canExecute(variableOperation.first, m_FuzzingState);
		353	forceWait = customOperation.m_WaitAcquisition;
		354	} else {
212	// Retrieves all operations that can be executed in the current context	355	// Retrieves all operations that can be executed in the current context
213	VariablesOperations variableOperations{};	356	VariablesOperations variableOperations{};
214	Weights weights{};	357	Weights weights{};
215	std::tie(variableOperations, weights)	358	std::tie(variableOperations, weights)
216	= availableOperations(m_FuzzingState, operationsPool());	359	= availableOperations(m_FuzzingState, operationsPool());
217		360
		361	// Of the operations available, chooses a random operation and executes it
		362	variableOperation
		363	= RandomGenerator::instance().randomChoice(variableOperations, weights);
218	canExecute = !variableOperations.empty();	364	canExecute = !variableOperations.empty();
		365	forceWait = operationsPool().at(variableOperation.second).m_WaitAcquisition;
		366	}
		367
219	if (canExecute) {	368	if (canExecute) {
220	--nextValidationCounter;	369	--nextValidationCounter;
221		370
222	// Of the operations available, chooses a random operation and executes it
223	auto variableOperation
224	= RandomGenerator::instance().randomChoice(variableOperations, weights);
225
226	auto variableId = variableOperation.first;	371	auto variableId = variableOperation.first;
227	auto fuzzingOperation = variableOperation.second;	372	auto fuzzingOperation = variableOperation.second;
228		373
229	auto waitAcquisition = nextValidationCounter == 0	374	auto waitAcquisition = nextValidationCounter == 0
230	\|\| ~~operationsPool().~~at(~~fuzzingOperation~~).~~m_WaitAcquisition~~;	375	\|\| forceWait;
231		376
		377	qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Operation :" << i +1 << " on"
		378	<< nbOperations;
232	fuzzingOperation->execute(variableId, m_FuzzingState, m_VariableController,	379	fuzzingOperation->execute(variableId, m_FuzzingState, m_VariableController,
233	m_Properties);	380	m_Properties);
234		381
@@ -293,6 +440,7 private:
293	} // namespace	440	} // namespace
294		441
295	Q_DECLARE_METATYPE(OperationsTypes)	442	Q_DECLARE_METATYPE(OperationsTypes)
		443	Q_DECLARE_METATYPE(CustomVariablesOperations)
296		444
297	class TestAmdaFuzzing : public QObject {	445	class TestAmdaFuzzing : public QObject {
298	Q_OBJECT	446	Q_OBJECT
@@ -306,7 +454,7 private slots:
306	void TestAmdaFuzzing::testFuzzing_data()	454	void TestAmdaFuzzing::testFuzzing_data()
307	{	455	{
308	// Note: Comment this line to run fuzzing tests	456	// Note: Comment this line to run fuzzing tests
309	QSKIP("Fuzzing tests are disabled by default");	457	// QSKIP("Fuzzing tests are disabled by default");
310		458
311	// ////////////// //	459	// ////////////// //
312	// Test structure //	460	// Test structure //
@@ -318,17 +466,34 void TestAmdaFuzzing::testFuzzing_data()
318	// Test cases //	466	// Test cases //
319	// ////////// //	467	// ////////// //
320		468
321	auto maxRange = SqpRange::fromDateTime({2017, 1, 1}, {0, 0}, {2017, 1, 5}, {0, 0});	469	auto maxRange = SqpRange::fromDateTime({2017, 1, 5}, {8, 0}, {2017, 1, 5}, {16, 0});
322	MetadataPool metadataPool{{{"dataType", "vector"}, {"xml:id", "~~imf~~"}}};	470	MetadataPool metadataPool{{{"dataType", "vector"}, {"xml:id", "c1_b"}}};
323		471
324	// Note: we don't use auto here as we want to pass std::shared_ptr<IDataProvider> as is in the	472	// Note: we don't use auto here as we want to pass std::shared_ptr<IDataProvider> as is in the
325	// QVariant	473	// QVariant
326	std::shared_ptr<IDataProvider> provider = std::make_shared<AmdaProvider>();	474	std::shared_ptr<IDataProvider> provider = std::make_shared<AmdaProvider>();
327		475
		476
		477	// Case Custom one : Only lot of pan on two variables synchronized
		478	// QTest::newRow("fuzzingTestPan") << Properties{
		479	// {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
		480	// {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
		481	// {PROVIDER_PROPERTY, QVariant::fromValue(provider)},
		482	// {CUSTOM_OPERATIONS_PROPERTY, CUSTOM_CASE_ONE}};
		483
		484	// QTest::newRow("fuzzingTestZoom") << Properties{
		485	// {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
		486	// {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
		487	// {PROVIDER_PROPERTY, QVariant::fromValue(provider)},
		488	// {CUSTOM_OPERATIONS_PROPERTY, CUSTOM_CASE_TWO}};
		489
		490
		491	//// Fuzzing
328	QTest::newRow("fuzzingTest") << Properties{	492	QTest::newRow("fuzzingTest") << Properties{
329	{MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},	493	{MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
330	{METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},	494	{METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
331	{PROVIDER_PROPERTY, QVariant::fromValue(provider)}};	495	{PROVIDER_PROPERTY, QVariant::fromValue(provider)}};
		496
332	}	497	}
333		498
334	void TestAmdaFuzzing::testFuzzing()	499	void TestAmdaFuzzing::testFuzzing()

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