GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r403:756d172725c6

Merge pull request from SCIQLOP-Initialisation develop...

leroux -

r403:756d172725c6

parent child

Context file:

r403:756d172725c6

Collapse all files

core/include/Network/NetworkController.h +4 -1

             #ifndef SCIQLOP_NETWORKCONTROLLER_H
             #define SCIQLOP_NETWORKCONTROLLER_H
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             #include <functional>
             Q_DECLARE_LOGGING_CATEGORY(LOG_NetworkController)
             class QNetworkReply;
             class QNetworkRequest;
             /**
              * @brief The NetworkController class aims to handle all network connection of SciQlop.
              */
             class NetworkController : public QObject {
                 Q_OBJECT
             public:
                 explicit NetworkController(QObject *parent = 0);
                 void initialize();
                 void finalize();
             public slots:
+                /// Execute request and call callback when the reply is finished. Identifier is attached to the
+                /// callback
                 void onProcessRequested(const QNetworkRequest &request, QUuid identifier,
                                         std::function<void(QNetworkReply *, QUuid)> callback);
+                /// Cancel the request of identifier
                 void onReplyCanceled(QUuid identifier);
             signals:
                 void replyFinished(QNetworkReply *reply, QUuid identifier);
-                void replyDownloadProgress(QUuid identifier);
+                void replyDownloadProgress(QUuid identifier, double progress);
             private:
                 void waitForFinish();
                 class NetworkControllerPrivate;
                 spimpl::unique_impl_ptr<NetworkControllerPrivate> impl;
             };
             #endif // SCIQLOP_NETWORKCONTROLLER_H

core/include/Variable/VariableController.h +3 0

             #ifndef SCIQLOP_VARIABLECONTROLLER_H
             #define SCIQLOP_VARIABLECONTROLLER_H
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             class IDataProvider;
             class QItemSelectionModel;
             class TimeController;
             class Variable;
             class VariableModel;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
             /**
              * @brief The VariableController class aims to handle the variables in SciQlop.
              */
             class VariableController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableController(QObject *parent = 0);
                 virtual ~VariableController();
                 VariableModel *variableModel() noexcept;
                 QItemSelectionModel *variableSelectionModel() noexcept;
                 void setTimeController(TimeController *timeController) noexcept;
                 /**
                  * Deletes from the controller the variable passed in parameter.
                  *
                  * Delete a variable includes:
                  * - the deletion of the various references to the variable in SciQlop
                  * - the deletion of the model variable
                  * - the deletion of the provider associated with the variable
                  * - removing the cache associated with the variable
                  *
                  * @param variable the variable to delete from the controller.
                  */
                 void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
                 /**
                  * Deletes from the controller the variables passed in parameter.
                  * @param variables the variables to delete from the controller.
                  * @sa deleteVariable()
                  */
                 void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
             signals:
                 /// Signal emitted when a variable is about to be deleted from the controller
                 void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
             public slots:
                 /// Request the data loading of the variable whithin dateTime
                 void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
                 /**
                  * Creates a new variable and adds it to the model
                  * @param name the name of the new variable
                  * @param provider the data provider for the new variable
                  */
                 void createVariable(const QString &name, std::shared_ptr<IDataProvider> provider) noexcept;
                 /// Update the temporal parameters of every selected variable to dateTime
                 void onDateTimeOnSelection(const SqpDateTime &dateTime);
+                void onVariableRetrieveDataInProgress(QUuid identifier, double progress);
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class VariableControllerPrivate;
                 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECONTROLLER_H

core/include/Variable/VariableModel.h +7 0

             #ifndef SCIQLOP_VARIABLEMODEL_H
             #define SCIQLOP_VARIABLEMODEL_H
             #include <Data/SqpDateTime.h>
             #include <QAbstractTableModel>
             #include <QLoggingCategory>
             #include <Common/MetaTypes.h>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
+            enum VariableRoles { ProgressRole = Qt::UserRole };
             class IDataSeries;
             class Variable;
             /**
              * @brief The VariableModel class aims to hold the variables that have been created in SciQlop
              */
             class VariableModel : public QAbstractTableModel {
             public:
                 explicit VariableModel(QObject *parent = nullptr);
                 /**
                  * Creates a new variable in the model
                  * @param name the name of the new variable
                  * @param dateTime the dateTime of the new variable
                  * @return the pointer to the new variable
                  */
                 std::shared_ptr<Variable> createVariable(const QString &name,
                                                          const SqpDateTime &dateTime) noexcept;
                 /**
                  * Deletes a variable from the model, if it exists
                  * @param variable the variable to delete
                  */
                 void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
                 std::shared_ptr<Variable> variable(int index) const;
+                void setDataProgress(std::shared_ptr<Variable> variable, double progress);
                 // /////////////////////////// //
                 // QAbstractTableModel methods //
                 // /////////////////////////// //
                 virtual int columnCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual int rowCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
                 virtual QVariant headerData(int section, Qt::Orientation orientation,
                                             int role = Qt::DisplayRole) const override;
             private:
                 class VariableModelPrivate;
                 spimpl::unique_impl_ptr<VariableModelPrivate> impl;
             private slots:
                 /// Slot called when data of a variable has been updated
                 void onVariableUpdated() noexcept;
             };
             // Registers QVector<int> metatype so it can be used in VariableModel::dataChanged() signal
             SCIQLOP_REGISTER_META_TYPE(QVECTOR_INT_REGISTRY, QVector<int>)
             #endif // SCIQLOP_VARIABLEMODEL_H

core/src/Network/NetworkController.cpp +6 -7

             #include "Network/NetworkController.h"
             #include <QMutex>
             #include <QNetworkAccessManager>
             #include <QNetworkReply>
             #include <QNetworkRequest>
             #include <QThread>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_NetworkController, "NetworkController")
             struct NetworkController::NetworkControllerPrivate {
                 explicit NetworkControllerPrivate(NetworkController *parent) : m_WorkingMutex{} {}
                 QMutex m_WorkingMutex;
                 std::unordered_map<QNetworkReply *, QUuid> m_NetworkReplyToVariableId;
                 std::unique_ptr<QNetworkAccessManager> m_AccessManager{nullptr};
             };
             NetworkController::NetworkController(QObject *parent)
                     : QObject(parent), impl{spimpl::make_unique_impl<NetworkControllerPrivate>(this)}
             {
             }
             void NetworkController::onProcessRequested(const QNetworkRequest &request, QUuid identifier,
                                                        std::function<void(QNetworkReply *, QUuid)> callback)
             {
-                qCDebug(LOG_NetworkController()) << tr("NetworkController registered")
+                qCInfo(LOG_NetworkController()) << tr("NetworkController registered")
                                                 << QThread::currentThread();
                 auto reply = impl->m_AccessManager->get(request);
                 // Store the couple reply id
                 impl->m_NetworkReplyToVariableId[reply] = identifier;
                 auto onReplyFinished = [reply, this, identifier, callback]() {
-                    qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished")
+                    qCInfo(LOG_NetworkController()) << tr("NetworkController onReplyFinished")
                                                     << QThread::currentThread();
                     auto it = impl->m_NetworkReplyToVariableId.find(reply);
                     if (it != impl->m_NetworkReplyToVariableId.cend()) {
                         callback(reply, identifier);
                     }
                 };
-                auto onReplyDownloadProgress = [reply, this]() {
+                auto onReplyProgress = [reply, this](qint64 bytesRead, qint64 totalBytes) {
-                    qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyDownloadProgress")
+                    double progress = (bytesRead * 100.0) / totalBytes;
-                                                     << QThread::currentThread();
                     auto it = impl->m_NetworkReplyToVariableId.find(reply);
                     if (it != impl->m_NetworkReplyToVariableId.cend()) {
-                        emit this->replyDownloadProgress(it->second);
+                        emit this->replyDownloadProgress(it->second, progress);
                     }
                 };
                 connect(reply, &QNetworkReply::finished, this, onReplyFinished);
-                connect(reply, &QNetworkReply::downloadProgress, this, onReplyDownloadProgress);
+                connect(reply, &QNetworkReply::downloadProgress, this, onReplyProgress);
             }
             void NetworkController::initialize()
             {
                 qCDebug(LOG_NetworkController()) << tr("NetworkController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
                 qCDebug(LOG_NetworkController()) << tr("NetworkController init END");
             }
             void NetworkController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void NetworkController::onReplyCanceled(QUuid identifier)
             {
                 auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
                 auto end = impl->m_NetworkReplyToVariableId.cend();
                 auto it = std::find_if(impl->m_NetworkReplyToVariableId.cbegin(), end, findReply);
                 if (it != end) {
                     it->first->abort();
                 }
             }
             void NetworkController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

core/src/Variable/VariableController.cpp +11 0

             #include <Variable/Variable.h>
             #include <Variable/VariableCacheController.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Time/TimeController.h>
             #include <QDateTime>
             #include <QMutex>
             #include <QThread>
             #include <QUuid>
             #include <QtCore/QItemSelectionModel>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
                           m_VariableCacheController{std::make_unique<VariableCacheController>()}
                 {
                 }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheController> m_VariableCacheController;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
                 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifier;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
             }
             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;
             }
             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);
                 // 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));
                 // Clears cache
                 impl->m_VariableCacheController->clear(variable);
                 // 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);
                 }
             }
             void VariableController::createVariable(const QString &name,
                                                     std::shared_ptr<IDataProvider> provider) noexcept
             {
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return;
                 }
                 /// @todo : for the moment :
                 /// - the provider is only used to retrieve data from the variable for its initialization, but
                 /// it will be retained later
                 /// - default data are generated for the variable, without taking into account the timerange set
                 /// in sciqlop
                 auto dateTime = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime)) {
                     auto identifier = QUuid::createUuid();
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     impl->m_VariableToIdentifier[newVariable] = identifier;
                     auto addDateTimeAcquired = [ this, varW = std::weak_ptr<Variable>{newVariable} ](
                         QUuid identifier, auto dataSeriesAcquired, auto dateTimeToPutInCache)
                     {
                         if (auto variable = varW.lock()) {
                             auto varIdentifier = impl->m_VariableToIdentifier.at(variable);
                             if (varIdentifier == identifier) {
                                 impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
                                 variable->setDataSeries(dataSeriesAcquired);
                             }
                         }
                     };
                     connect(provider.get(), &IDataProvider::dataProvided, addDateTimeAcquired);
                     this->onRequestDataLoading(newVariable, dateTime);
                 }
             }
             void VariableController::onDateTimeOnSelection(const SqpDateTime &dateTime)
             {
                 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
                                                   << QThread::currentThread()->objectName();
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
                         selectedVariable->setDateTime(dateTime);
                         this->onRequestDataLoading(selectedVariable, dateTime);
                     }
                 }
             }
+            void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
+            {
+                auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
+                auto end = impl->m_VariableToIdentifier.cend();
+                auto it = std::find_if(impl->m_VariableToIdentifier.cbegin(), end, findReply);
+                if (it != end) {
+                    impl->m_VariableModel->setDataProgress(it->first, progress);
+                }
+            }
             void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
                                                           const SqpDateTime &dateTime)
             {
                 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
                                                   << QThread::currentThread()->objectName();
                 // we want to load data of the variable for the dateTime.
                 // First we check if the cache contains some of them.
                 // For the other, we ask the provider to give them.
                 if (variable) {
                     auto dateTimeListNotInCache
                         = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
                     if (!dateTimeListNotInCache.empty()) {
                         // Ask the provider for each data on the dateTimeListNotInCache
                         auto identifier = impl->m_VariableToIdentifier.at(variable);
                         impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
                             identifier, std::move(dateTimeListNotInCache));
                     }
                     else {
                         emit variable->updated();
                     }
                 }
                 else {
                     qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
                 }
             }
             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};
             }

core/src/Variable/VariableModel.cpp +44 -8

             #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
             #include <Data/IDataSeries.h>
             #include <QDateTime>
             #include <QSize>
+            #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto TSTART_COLUMN = 1;
             const auto TEND_COLUMN = 2;
             const auto NB_COLUMNS = 3;
             // Column properties
             const auto DEFAULT_HEIGHT = 25;
             const auto DEFAULT_WIDTH = 100;
             struct ColumnProperties {
                 ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
                                  int height = DEFAULT_HEIGHT)
                         : m_Name{name}, m_Width{width}, m_Height{height}
                 {
                 }
                 QString m_Name;
                 int m_Width;
                 int m_Height;
             };
             const auto COLUMN_PROPERTIES
                 = QHash<int, ColumnProperties>{{NAME_COLUMN, {QObject::tr("Name")}},
                                                {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
                                                {TEND_COLUMN, {QObject::tr("tEnd"), 180}}};
             /// Format for datetimes
             const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
             } // namespace
             struct VariableModel::VariableModelPrivate {
                 /// Variables created in SciQlop
                 std::vector<std::shared_ptr<Variable> > m_Variables;
+                std::unordered_map<std::shared_ptr<Variable>, double> m_VariableToProgress;
+                /// Return the row index of the variable. -1 if it's not found
+                int indexOfVariable(Variable *variable) const noexcept;
             };
             VariableModel::VariableModel(QObject *parent)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
             }
             std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
                                                                     const SqpDateTime &dateTime) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
                 /// @todo For the moment, the other data of the variable is initialized with default values
                 auto variable = std::make_shared<Variable>(name, QStringLiteral("unit"),
                                                            QStringLiteral("mission"), dateTime);
                 impl->m_Variables.push_back(variable);
                 connect(variable.get(), &Variable::updated, this, &VariableModel::onVariableUpdated);
                 endInsertRows();
                 return variable;
             }
             void VariableModel::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_Variable()) << "Can't delete a null variable from the model";
                     return;
                 }
                 // Finds variable in the model
                 auto begin = impl->m_Variables.cbegin();
                 auto end = impl->m_Variables.cend();
                 auto it = std::find(begin, end, variable);
                 if (it != end) {
                     auto removeIndex = std::distance(begin, it);
                     // Deletes variable
                     beginRemoveRows({}, removeIndex, removeIndex);
                     impl->m_Variables.erase(it);
                     endRemoveRows();
                 }
                 else {
                     qCritical(LOG_VariableModel())
                         << tr("Can't delete variable %1 from the model: the variable is not in the model")
                                .arg(variable->name());
                 }
             }
             std::shared_ptr<Variable> VariableModel::variable(int index) const
             {
                 return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
             }
+            void VariableModel::setDataProgress(std::shared_ptr<Variable> variable, double progress)
+            {
+                impl->m_VariableToProgress[variable] = progress;
+                auto modelIndex = createIndex(impl->indexOfVariable(variable.get()), NAME_COLUMN);
+                emit dataChanged(modelIndex, modelIndex);
+            }
             int VariableModel::columnCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return NB_COLUMNS;
             }
             int VariableModel::rowCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return impl->m_Variables.size();
             }
             QVariant VariableModel::data(const QModelIndex &index, int role) const
             {
                 if (!index.isValid()) {
                     return QVariant{};
                 }
                 if (index.row() < 0 || index.row() >= rowCount()) {
                     return QVariant{};
                 }
                 if (role == Qt::DisplayRole) {
                     if (auto variable = impl->m_Variables.at(index.row()).get()) {
                         /// Lambda function that builds the variant to return for a time value
                         auto dateTimeVariant = [](double time) {
                             auto dateTime = QDateTime::fromMSecsSinceEpoch(time * 1000.);
                             return dateTime.toString(DATETIME_FORMAT);
                         };
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case TSTART_COLUMN:
                                 return dateTimeVariant(variable->dateTime().m_TStart);
                             case TEND_COLUMN:
                                 return dateTimeVariant(variable->dateTime().m_TEnd);
                             default:
                                 // No action
                                 break;
                         }
                         qWarning(LOG_VariableModel())
                             << tr("Can't get data (unknown column %1)").arg(index.column());
                     }
                     else {
                         qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
                     }
                 }
+                else if (role == VariableRoles::ProgressRole) {
+                    if (auto variable = impl->m_Variables.at(index.row())) {
+                        auto it = impl->m_VariableToProgress.find(variable);
+                        if (it != impl->m_VariableToProgress.cend()) {
+                            return it->second;
+                        }
+                    }
+                }
                 return QVariant{};
             }
             QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
                     return QVariant{};
                 }
                 if (orientation == Qt::Horizontal) {
                     auto propertiesIt = COLUMN_PROPERTIES.find(section);
                     if (propertiesIt != COLUMN_PROPERTIES.cend()) {
                         // Role is either DisplayRole or SizeHintRole
                         return (role == Qt::DisplayRole)
                                    ? QVariant{propertiesIt->m_Name}
                                    : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
                     }
                     else {
                         qWarning(LOG_VariableModel())
                             << tr("Can't get header data (unknown column %1)").arg(section);
                     }
                 }
                 return QVariant{};
             }
             void VariableModel::onVariableUpdated() noexcept
             {
                 // Finds variable that has been updated in the model
                 if (auto updatedVariable = dynamic_cast<Variable *>(sender())) {
-                    auto begin = std::cbegin(impl->m_Variables);
+                    auto updatedVariableIndex = impl->indexOfVariable(updatedVariable);
-                    auto end = std::cend(impl->m_Variables);
-                    auto it = std::find_if(begin, end, [updatedVariable](const auto &variable) {
+                    if (updatedVariableIndex > -1) {
-                        return variable.get() == updatedVariable;
+                        emit dataChanged(createIndex(updatedVariableIndex, 0),
-                    });
+                                         createIndex(updatedVariableIndex, columnCount() - 1));
+                    }
+                }
+            }
+            int VariableModel::VariableModelPrivate::indexOfVariable(Variable *variable) const noexcept
+            {
+                auto begin = std::cbegin(m_Variables);
+                auto end = std::cend(m_Variables);
+                auto it
+                    = std::find_if(begin, end, [variable](const auto &var) { return var.get() == variable; });
                 if (it != end) {
                     // Gets the index of the variable in the model: we assume here that views have the same
                     // order as the model
-                        auto updateVariableIndex = std::distance(begin, it);
+                    return std::distance(begin, it);
-                        emit dataChanged(createIndex(updateVariableIndex, 0),
-                                         createIndex(updateVariableIndex, columnCount() - 1));
                 }
+                else {
+                    return -1;
                 }
             }

gui/include/Variable/VariableInspectorWidget.h +4 0

             #ifndef SCIQLOP_VARIABLEINSPECTORWIDGET_H
             #define SCIQLOP_VARIABLEINSPECTORWIDGET_H
             #include <QLoggingCategory>
             #include <QMenu>
             #include <QWidget>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableInspectorWidget)
             class Variable;
+            class QProgressBarItemDelegate;
             namespace Ui {
             class VariableInspectorWidget;
             } // Ui
             /**
              * @brief The VariableInspectorWidget class representes represents the variable inspector, from
              * which it is possible to view the loaded variables, handle them or trigger their display in
              * visualization
              */
             class VariableInspectorWidget : public QWidget {
                 Q_OBJECT
             public:
                 explicit VariableInspectorWidget(QWidget *parent = 0);
                 virtual ~VariableInspectorWidget();
             signals:
                 /**
                  * Signal emitted before a menu concerning variables is displayed. It is used for other widgets
                  * to complete the menu.
                  * @param tableMenu the menu to be completed
                  * @param variables the variables concerned by the menu
                  * @remarks To make the dynamic addition of menus work, the connections to this signal must be
                  * in Qt :: DirectConnection
                  */
                 void tableMenuAboutToBeDisplayed(QMenu *tableMenu,
                                                  const QVector<std::shared_ptr<Variable> > &variables);
             private:
                 Ui::VariableInspectorWidget *ui;
+                QProgressBarItemDelegate *m_ProgressBarItemDelegate;
             private slots:
                 /// Slot called when right clicking on an variable in the table (displays a menu)
                 void onTableMenuRequested(const QPoint &pos) noexcept;
                 /// Refreshes instantly the variable view
                 void refresh() noexcept;
             };
             #endif // SCIQLOP_VARIABLEINSPECTORWIDGET_H

gui/src/SqpApplication.cpp +5 0

             #include "SqpApplication.h"
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <Network/NetworkController.h>
             #include <QThread>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
                         : m_DataSourceController{std::make_unique<DataSourceController>()},
                           m_NetworkController{std::make_unique<NetworkController>()},
                           m_TimeController{std::make_unique<TimeController>()},
                           m_VariableController{std::make_unique<VariableController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()}
                 {
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
                     connect(m_DataSourceController.get(),
                             SIGNAL(variableCreationRequested(const QString &, std::shared_ptr<IDataProvider>)),
                             m_VariableController.get(),
                             SLOT(createVariable(const QString &, std::shared_ptr<IDataProvider>)));
                     // VariableController <-> VisualizationController
                     connect(m_VariableController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
                             m_VisualizationController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                     m_NetworkController->moveToThread(&m_NetworkControllerThread);
                     m_VariableController->moveToThread(&m_VariableControllerThread);
                     m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                     // Additionnal init
                     m_VariableController->setTimeController(m_TimeController.get());
                 }
                 virtual ~SqpApplicationPrivate()
                 {
                     qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.wait();
                     m_NetworkControllerThread.quit();
                     m_NetworkControllerThread.wait();
                     m_VariableControllerThread.quit();
                     m_VariableControllerThread.wait();
                     m_VisualizationControllerThread.quit();
                     m_VisualizationControllerThread.wait();
                 }
                 std::unique_ptr<DataSourceController> m_DataSourceController;
                 std::unique_ptr<VariableController> m_VariableController;
                 std::unique_ptr<TimeController> m_TimeController;
                 std::unique_ptr<NetworkController> m_NetworkController;
                 std::unique_ptr<VisualizationController> m_VisualizationController;
                 QThread m_DataSourceControllerThread;
                 QThread m_NetworkControllerThread;
                 QThread m_VariableControllerThread;
                 QThread m_VisualizationControllerThread;
             };
             SqpApplication::SqpApplication(int &argc, char **argv)
                     : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
                 qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         impl->m_DataSourceController.get(), &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                         impl->m_DataSourceController.get(), &DataSourceController::finalize);
                 connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
                         &NetworkController::initialize);
                 connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
                         &NetworkController::finalize);
                 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
                         &VariableController::initialize);
                 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
                         &VariableController::finalize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::started,
                         impl->m_VisualizationController.get(), &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                         impl->m_VisualizationController.get(), &VisualizationController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_NetworkControllerThread.start();
                 impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
+                // Core connections:
+                // NetworkController <-> VariableController
+                connect(&sqpApp->networkController(), &NetworkController::replyDownloadProgress,
+                        &sqpApp->variableController(), &VariableController::onVariableRetrieveDataInProgress);
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {
                 return *impl->m_DataSourceController;
             }
             NetworkController &SqpApplication::networkController() noexcept
             {
                 return *impl->m_NetworkController;
             }
             TimeController &SqpApplication::timeController() noexcept
             {
                 return *impl->m_TimeController;
             }
             VariableController &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
             VisualizationController &SqpApplication::visualizationController() noexcept
             {
                 return *impl->m_VisualizationController;
             }

gui/src/Variable/VariableInspectorWidget.cpp +40 -1

             #include <Variable/VariableController.h>
             #include <Variable/VariableInspectorWidget.h>
             #include <Variable/VariableMenuHeaderWidget.h>
             #include <Variable/VariableModel.h>
             #include <ui_VariableInspectorWidget.h>
             #include <QSortFilterProxyModel>
+            #include <QStyledItemDelegate>
             #include <QWidgetAction>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_VariableInspectorWidget, "VariableInspectorWidget")
+            class QProgressBarItemDelegate : public QStyledItemDelegate {
+            public:
+                QProgressBarItemDelegate(QObject *parent) : QStyledItemDelegate{parent} {}
+                void paint(QPainter *painter, const QStyleOptionViewItem &option,
+                           const QModelIndex &index) const
+                {
+                    auto data = index.data(Qt::DisplayRole);
+                    auto progressData = index.data(VariableRoles::ProgressRole);
+                    if (data.isValid() && progressData.isValid()) {
+                        auto name = data.value<QString>();
+                        auto progress = progressData.value<double>();
+                        if (progress >= 0) {
+                            auto progressBarOption = QStyleOptionProgressBar{};
+                            progressBarOption.rect = option.rect;
+                            progressBarOption.minimum = 0;
+                            progressBarOption.maximum = 100;
+                            progressBarOption.progress = progress;
+                            progressBarOption.text
+                                = QString("%1 %2").arg(name).arg(QString::number(progress, 'f', 2) + "%");
+                            progressBarOption.textVisible = true;
+                            progressBarOption.textAlignment = Qt::AlignCenter;
+                            QApplication::style()->drawControl(QStyle::CE_ProgressBar, &progressBarOption,
+                                                               painter);
+                        }
+                    }
+                    else {
+                        QStyledItemDelegate::paint(painter, option, index);
+                    }
+                }
+            };
             VariableInspectorWidget::VariableInspectorWidget(QWidget *parent)
-                    : QWidget{parent}, ui{new Ui::VariableInspectorWidget}
+                    : QWidget{parent},
+                      ui{new Ui::VariableInspectorWidget},
+                      m_ProgressBarItemDelegate{new QProgressBarItemDelegate{this}}
             {
                 ui->setupUi(this);
                 // Sets model for table
                 //    auto sortFilterModel = new QSortFilterProxyModel{this};
                 //    sortFilterModel->setSourceModel(sqpApp->variableController().variableModel());
                 auto variableModel = sqpApp->variableController().variableModel();
                 ui->tableView->setModel(variableModel);
                 // Adds extra signal/slot between view and model, so the view can be updated instantly when
                 // there is a change of data in the model
                 connect(variableModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this,
                         SLOT(refresh()));
                 ui->tableView->setSelectionModel(sqpApp->variableController().variableSelectionModel());
+                ui->tableView->setItemDelegateForColumn(0, m_ProgressBarItemDelegate);
                 // Fixes column sizes
                 auto model = ui->tableView->model();
                 const auto count = model->columnCount();
                 for (auto i = 0; i < count; ++i) {
                     ui->tableView->setColumnWidth(
                         i, model->headerData(i, Qt::Horizontal, Qt::SizeHintRole).toSize().width());
                 }
                 // Sets selection options
                 ui->tableView->setSelectionBehavior(QTableView::SelectRows);
                 ui->tableView->setSelectionMode(QTableView::ExtendedSelection);
                 // Connection to show a menu when right clicking on the tree
                 ui->tableView->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->tableView, &QTableView::customContextMenuRequested, this,
                         &VariableInspectorWidget::onTableMenuRequested);
             }
             VariableInspectorWidget::~VariableInspectorWidget()
             {
                 delete ui;
             }
             void VariableInspectorWidget::onTableMenuRequested(const QPoint &pos) noexcept
             {
                 auto selectedRows = ui->tableView->selectionModel()->selectedRows();
                 // Gets the model to retrieve the underlying selected variables
                 auto model = sqpApp->variableController().variableModel();
                 auto selectedVariables = QVector<std::shared_ptr<Variable> >{};
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = model->variable(selectedRow.row())) {
                         selectedVariables.push_back(selectedVariable);
                     }
                 }
                 QMenu tableMenu{};
                 // Emits a signal so that potential receivers can populate the menu before displaying it
                 emit tableMenuAboutToBeDisplayed(&tableMenu, selectedVariables);
                 // Adds menu-specific actions
                 if (!selectedVariables.isEmpty()) {
                     // 'Delete' action
                     auto deleteFun = [&selectedVariables]() {
                         sqpApp->variableController().deleteVariables(selectedVariables);
                     };
                     tableMenu.addSeparator();
                     tableMenu.addAction(QIcon{":/icones/delete.png"}, tr("Delete"), deleteFun);
                 }
                 if (!tableMenu.isEmpty()) {
                     // Generates menu header (inserted before first action)
                     auto firstAction = tableMenu.actions().first();
                     auto headerAction = new QWidgetAction{&tableMenu};
                     headerAction->setDefaultWidget(new VariableMenuHeaderWidget{selectedVariables, &tableMenu});
                     tableMenu.insertAction(firstAction, headerAction);
                     // Displays menu
                     tableMenu.exec(mapToGlobal(pos));
                 }
             }
             void VariableInspectorWidget::refresh() noexcept
             {
                 ui->tableView->viewport()->update();
             }

plugins/amda/src/AmdaResultParser.cpp +2 0

             #include "AmdaResultParser.h"
             #include <Data/ScalarSeries.h>
             #include <QDateTime>
             #include <QFile>
             #include <QRegularExpression>
+            #include <cmath>
             Q_LOGGING_CATEGORY(LOG_AmdaResultParser, "AmdaResultParser")
             namespace {
             /// Format for dates in result files
             const auto DATE_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss.zzz");
             /// Separator between values in a result line
             const auto RESULT_LINE_SEPARATOR = QRegularExpression{QStringLiteral("\\s+")};
             /// Regex to find unit in a line. Examples of valid lines:
             /// ... - Units : nT - ...
             /// ... -Units:nT- ...
             /// ... -Units:   m²- ...
             /// ... - Units : m/s - ...
             const auto UNIT_REGEX = QRegularExpression{QStringLiteral("-\\s*Units\\s*:\\s*(.+?)\\s*-")};
             /// Converts a string date to a double date
             /// @return a double that represents the date in seconds, NaN if the string date can't be converted
             double doubleDate(const QString &stringDate) noexcept
             {
                 auto dateTime = QDateTime::fromString(stringDate, DATE_FORMAT);
                 return dateTime.isValid() ? (dateTime.toMSecsSinceEpoch() / 1000.)
                                           : std::numeric_limits<double>::quiet_NaN();
             }
             /**
              * Reads stream to retrieve x-axis unit
              * @param stream the stream to read
              * @return the unit that has been read in the stream, a default unit (time unit with no label) if an
              * error occured during reading
              */
             Unit readXAxisUnit(QTextStream &stream)
             {
                 QString line{};
                 if (stream.readLineInto(&line)) {
                     auto match = UNIT_REGEX.match(line);
                     if (match.hasMatch()) {
                         return Unit{match.captured(1), true};
                     }
                     else {
                         qCWarning(LOG_AmdaResultParser())
                             << QObject::tr("Can't read unit: invalid line %1").arg(line);
                     }
                 }
                 else {
                     qCWarning(LOG_AmdaResultParser()) << QObject::tr("Can't read unit: end of file");
                 }
                 // Error cases
                 return Unit{{}, true};
             }
             /**
              * Reads stream to retrieve results
              * @param stream the stream to read
              * @return the pair of vectors x-axis data/values data that has been read in the stream
              */
             QPair<QVector<double>, QVector<double> > readResults(QTextStream &stream)
             {
                 auto xData = QVector<double>{};
                 auto valuesData = QVector<double>{};
                 QString line{};
                 while (stream.readLineInto(&line)) {
                     auto lineData = line.split(RESULT_LINE_SEPARATOR, QString::SkipEmptyParts);
                     if (lineData.size() == 2) {
                         // X : the data is converted from date to double (in secs)
                         auto x = doubleDate(lineData.at(0));
                         // Value
                         bool valueOk;
                         auto value = lineData.at(1).toDouble(&valueOk);
                         // Adds result only if x and value are valid
                         if (!std::isnan(x) && !std::isnan(value) && valueOk) {
                             xData.push_back(x);
                             valuesData.push_back(value);
                         }
                         else {
                             qCWarning(LOG_AmdaResultParser())
                                 << QObject::tr(
                                        "Can't retrieve results from line %1: x and/or value are invalid")
                                        .arg(line);
                         }
                     }
                     else {
                         qCWarning(LOG_AmdaResultParser())
                             << QObject::tr("Can't retrieve results from line %1: invalid line").arg(line);
                     }
                 }
                 return qMakePair(std::move(xData), std::move(valuesData));
             }
             } // namespace
             std::shared_ptr<IDataSeries> AmdaResultParser::readTxt(const QString &filePath) noexcept
             {
                 QFile file{filePath};
                 if (!file.open(QFile::ReadOnly | QIODevice::Text)) {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data from file %1: %2")
                                .arg(filePath, file.errorString());
                     return nullptr;
                 }
                 QTextStream stream{&file};
                 // Ignore first two lines (comments lines)
                 stream.readLine();
                 stream.readLine();
                 // Reads x-axis unit
                 auto xAxisUnit = readXAxisUnit(stream);
                 // Reads results
                 auto results = readResults(stream);
                 return std::make_shared<ScalarSeries>(std::move(results.first), std::move(results.second),
                                                       xAxisUnit, Unit{});
             }

plugins/amda/tests/TestAmdaResultParser.cpp +2 -2

             #include "AmdaResultParser.h"
             #include <Data/ScalarSeries.h>
             #include <QObject>
             #include <QtTest>
             namespace {
             /// Path for the tests
             const auto TESTS_RESOURCES_PATH
                 = QFileInfo{QString{AMDA_TESTS_RESOURCES_DIR}, "TestAmdaResultParser"}.absoluteFilePath();
             QString inputFilePath(const QString &inputFileName)
             {
                 return QFileInfo{TESTS_RESOURCES_PATH, inputFileName}.absoluteFilePath();
             }
             struct ExpectedResults {
                 explicit ExpectedResults() = default;
                 /// Ctor with QVector<QDateTime> as x-axis data. Datetimes are converted to doubles
                 explicit ExpectedResults(Unit xAxisUnit, Unit valuesUnit, const QVector<QDateTime> &xAxisData,
                                          QVector<double> valuesData)
                         : m_ParsingOK{true},
                           m_XAxisUnit{xAxisUnit},
                           m_ValuesUnit{valuesUnit},
                           m_XAxisData{},
                           m_ValuesData{std::move(valuesData)}
                 {
                     // Converts QVector<QDateTime> to QVector<double>
                     std::transform(xAxisData.cbegin(), xAxisData.cend(), std::back_inserter(m_XAxisData),
                                    [](const auto &dateTime) { return dateTime.toMSecsSinceEpoch() / 1000.; });
                 }
                 /**
                  * Validates a DataSeries compared to the expected results
                  * @param results the DataSeries to validate
                  */
                 void validate(std::shared_ptr<IDataSeries> results)
                 {
                     if (m_ParsingOK) {
                         auto scalarSeries = dynamic_cast<ScalarSeries *>(results.get());
                         QVERIFY(scalarSeries != nullptr);
                         // Checks units
                         QVERIFY(scalarSeries->xAxisUnit() == m_XAxisUnit);
                         QVERIFY(scalarSeries->valuesUnit() == m_ValuesUnit);
                         // Checks values
                         QVERIFY(scalarSeries->xAxisData()->data() == m_XAxisData);
                         QVERIFY(scalarSeries->valuesData()->data() == m_ValuesData);
                     }
                     else {
                         QVERIFY(results == nullptr);
                     }
                 }
                 // Parsing was successfully completed
                 bool m_ParsingOK{false};
                 // Expected x-axis unit
                 Unit m_XAxisUnit{};
                 // Expected values unit
                 Unit m_ValuesUnit{};
                 // Expected x-axis data
                 QVector<double> m_XAxisData{};
                 // Expected values data
                 QVector<double> m_ValuesData{};
             };
             } // namespace
             Q_DECLARE_METATYPE(ExpectedResults)
             class TestAmdaResultParser : public QObject {
                 Q_OBJECT
             private slots:
                 /// Input test data
                 /// @sa testTxtJson()
                 void testReadTxt_data();
                 /// Tests parsing of a TXT file
                 void testReadTxt();
             };
             void TestAmdaResultParser::testReadTxt_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 // Name of TXT file to read
                 QTest::addColumn<QString>("inputFileName");
                 // Expected results
                 QTest::addColumn<ExpectedResults>("expectedResults");
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 auto dateTime = [](int year, int month, int day, int hours, int minutes, int seconds) {
                     return QDateTime{{year, month, day}, {hours, minutes, seconds}};
                 };
                 // Valid file
                 QTest::newRow("Valid file")
                     << QStringLiteral("ValidScalar1.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                               dateTime(2013, 9, 23, 9, 2, 30), dateTime(2013, 9, 23, 9, 3, 30),
                                               dateTime(2013, 9, 23, 9, 4, 30), dateTime(2013, 9, 23, 9, 5, 30),
                                               dateTime(2013, 9, 23, 9, 6, 30), dateTime(2013, 9, 23, 9, 7, 30),
                                               dateTime(2013, 9, 23, 9, 8, 30), dateTime(2013, 9, 23, 9, 9, 30)},
                            QVector<double>{-2.83950, -2.71850, -2.52150, -2.57633, -2.58050, -2.48325, -2.63025,
                                            -2.55800, -2.43250, -2.42200}};
                 // Valid files but with some invalid lines (wrong unit, wrong values, etc.)
                 QTest::newRow("No unit file") << QStringLiteral("NoUnit.txt")
                                               << ExpectedResults{Unit{QStringLiteral(""), true}, Unit{},
                                                                  QVector<QDateTime>{}, QVector<double>{}};
                 QTest::newRow("Wrong unit file")
                     << QStringLiteral("WrongUnit.txt")
                     << ExpectedResults{Unit{QStringLiteral(""), true}, Unit{},
                                        QVector<QDateTime>{dateTime(2013, 9, 23, 9, 0, 30),
                                                           dateTime(2013, 9, 23, 9, 1, 30),
                                                           dateTime(2013, 9, 23, 9, 2, 30)},
                                        QVector<double>{-2.83950, -2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (date of first line is invalid")
                     << QStringLiteral("WrongDate.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (too many values for first line")
                     << QStringLiteral("TooManyValues.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (value of first line is invalid")
                     << QStringLiteral("WrongValue.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (value of first line is NaN")
                     << QStringLiteral("NaNValue.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 // Invalid file
-                QTest::newRow("Invalid file (unexisting file)")
+                QTest::newRow("Invalid file (unexisting file)") << QStringLiteral("UnexistingFile.txt")
-                    << QStringLiteral("UnexistingFile.txt") << ExpectedResults{};
+                                                                << ExpectedResults{};
             }
             void TestAmdaResultParser::testReadTxt()
             {
                 QFETCH(QString, inputFileName);
                 QFETCH(ExpectedResults, expectedResults);
                 // Parses file
                 auto filePath = inputFilePath(inputFileName);
                 auto results = AmdaResultParser::readTxt(filePath);
                 // ///////////////// //
                 // Validates results //
                 // ///////////////// //
                 expectedResults.validate(results);
             }
             QTEST_MAIN(TestAmdaResultParser)
             #include "TestAmdaResultParser.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