HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1278:d3daab81283b

Move the AMDA data type to a type accessible from core

Alexandre Leroux -

r1278:d3daab81283b

parent child

Context file:

r1278:d3daab81283b

Collapse all files

core/include/Data/DataSeriesType.h created 644 +26 0

@@ -0,0 +1,26
	1	#ifndef SCIQLOP_DATASERIESTYPE_H
	2	#define SCIQLOP_DATASERIESTYPE_H
	3
	4	#include <QString>
	5
	6	enum class DataSeriesType { SCALAR, SPECTROGRAM, VECTOR, UNKNOWN };
	7
	8	struct DataSeriesTypeUtils {
	9	static DataSeriesType fromString(const QString &type)
	10	{
	11	if (type == QStringLiteral("scalar")) {
	12	return DataSeriesType::SCALAR;
	13	}
	14	else if (type == QStringLiteral("spectrogram")) {
	15	return DataSeriesType::SPECTROGRAM;
	16	}
	17	else if (type == QStringLiteral("vector")) {
	18	return DataSeriesType::VECTOR;
	19	}
	20	else {
	21	return DataSeriesType::UNKNOWN;
	22	}
	23	}
	24	};
	25
	26	#endif // SCIQLOP_DATASERIESTYPE_H

plugins/amda/include/AmdaResultParser.h +3 -3

             #ifndef SCIQLOP_AMDARESULTPARSER_H
             #define SCIQLOP_AMDARESULTPARSER_H
             #include "AmdaGlobal.h"
+            #include <Data/DataSeriesType.h>
             #include <QLoggingCategory>
             #include <memory>
             class IDataSeries;
             Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaResultParser)
             struct SCIQLOP_AMDA_EXPORT AmdaResultParser {
-                enum class ValueType { SCALAR, SPECTROGRAM, VECTOR, UNKNOWN };
                 static std::shared_ptr<IDataSeries> readTxt(const QString &filePath,
-                                                            ValueType valueType) noexcept;
+                                                            DataSeriesType valueType) noexcept;
             };
             #endif // SCIQLOP_AMDARESULTPARSER_H

plugins/amda/src/AmdaProvider.cpp +2 -16

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

plugins/amda/src/AmdaResultParser.cpp +8 -8

             #include "AmdaResultParser.h"
             #include "AmdaResultParserHelper.h"
             #include <QFile>
             #include <cmath>
             Q_LOGGING_CATEGORY(LOG_AmdaResultParser, "AmdaResultParser")
             namespace {
             /// Message in result file when the file was not found on server
             const auto FILE_NOT_FOUND_MESSAGE = QStringLiteral("Not Found");
             /// Checks if a line is a comment line
             bool isCommentLine(const QString &line)
             {
                 return line.startsWith("#");
             }
             /**
              * Creates helper that will be used to read AMDA file, according to the type passed as parameter
              * @param valueType the type of values expected in the AMDA file (scalars, vectors, spectrograms...)
              * @return the helper created
              */
-            std::unique_ptr<IAmdaResultParserHelper> createHelper(AmdaResultParser::ValueType valueType)
+            std::unique_ptr<IAmdaResultParserHelper> createHelper(DataSeriesType valueType)
             {
                 switch (valueType) {
-                    case AmdaResultParser::ValueType::SCALAR:
+                    case DataSeriesType::SCALAR:
                         return std::make_unique<ScalarParserHelper>();
-                    case AmdaResultParser::ValueType::SPECTROGRAM:
+                    case DataSeriesType::SPECTROGRAM:
                         return std::make_unique<SpectrogramParserHelper>();
-                    case AmdaResultParser::ValueType::VECTOR:
+                    case DataSeriesType::VECTOR:
                         return std::make_unique<VectorParserHelper>();
-                    case AmdaResultParser::ValueType::UNKNOWN:
+                    case DataSeriesType::UNKNOWN:
                         // Invalid case
                         break;
                 }
                 // Invalid cases
                 qCCritical(LOG_AmdaResultParser())
                     << QObject::tr("Can't create helper to read result file: unsupported type");
                 return nullptr;
             }
             /**
              * Reads properties of the stream passed as parameter
              * @param helper the helper used to read properties line by line
              * @param stream the stream to read
              */
             void readProperties(IAmdaResultParserHelper &helper, QTextStream &stream)
             {
                 // Searches properties in the comment lines (as long as the reading has not reached the data)
                 // AMDA V2: while (stream.readLineInto(&line) && !line.contains(DATA_HEADER_REGEX)) {
                 QString line{};
                 while (stream.readLineInto(&line) && isCommentLine(line)) {
                     helper.readPropertyLine(line);
                 }
             }
             /**
              * Reads results of the stream passed as parameter
              * @param helper the helper used to read results line by line
              * @param stream the stream to read
              */
             void readResults(IAmdaResultParserHelper &helper, QTextStream &stream)
             {
                 QString line{};
                 // Skip comment lines
                 while (stream.readLineInto(&line) && isCommentLine(line)) {
                 }
                 if (!stream.atEnd()) {
                     do {
                         helper.readResultLine(line);
                     } while (stream.readLineInto(&line));
                 }
             }
             } // namespace
             std::shared_ptr<IDataSeries> AmdaResultParser::readTxt(const QString &filePath,
-                                                                   ValueType valueType) noexcept
+                                                                   DataSeriesType type) noexcept
             {
-                if (valueType == ValueType::UNKNOWN) {
+                if (type == DataSeriesType::UNKNOWN) {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data: the type of values to be read is unknown");
                     return nullptr;
                 }
                 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};
                 // Checks if the file was found on the server
                 auto firstLine = stream.readLine();
                 if (firstLine.compare(FILE_NOT_FOUND_MESSAGE) == 0) {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data from file %1: file was not found on server")
                                .arg(filePath);
                     return nullptr;
                 }
-                auto helper = createHelper(valueType);
+                auto helper = createHelper(type);
                 Q_ASSERT(helper != nullptr);
                 // Reads header file to retrieve properties
                 stream.seek(0); // returns to the beginning of the file
                 readProperties(*helper, stream);
                 // Checks properties
                 if (helper->checkProperties()) {
                     // Reads results
                     // AMDA V2: remove line
                     stream.seek(0); // returns to the beginning of the file
                     readResults(*helper, stream);
                     // Creates data series
                     return helper->createSeries();
                 }
                 else {
                     return nullptr;
                 }
             }

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

             #include "AmdaProvider.h"
             #include "AmdaResultParser.h"
             #include "SqpApplication.h"
             #include <Data/DataSeries.h>
             #include <Data/IDataSeries.h>
             #include <Data/ScalarSeries.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QObject>
             #include <QtTest>
             #include <memory>
             // TEST with REF:
             // AmdaData-2012-01-01-12-00-00_2012-01-03-12-00-00
             // imf(0) - Type : Local Parameter @ CDPP/AMDA -
             // Name : bx_gse - Units : nT - Size : 1 -
             // Frame : GSE - Mission : ACE -
             // Instrument : MFI - Dataset : mfi_final-prelim
             // REFERENCE DOWNLOAD FILE =
             // http://amdatest.irap.omp.eu/php/rest/getParameter.php?startTime=2012-01-01T12:00:00&stopTime=2012-01-03T12:00:00&parameterID=imf(0)&outputFormat=ASCII&timeFormat=ISO8601&gzip=0
             namespace {
             /// Path for the tests
             const auto TESTS_RESOURCES_PATH
                 = QFileInfo{QString{AMDA_TESTS_RESOURCES_DIR}, "TestAmdaAcquisition"}.absoluteFilePath();
             /// Delay after each operation on the variable before validating it (in ms)
             const auto OPERATION_DELAY = 10000;
             template <typename T>
             bool compareDataSeries(std::shared_ptr<IDataSeries> candidate, SqpRange candidateCacheRange,
                                    std::shared_ptr<IDataSeries> reference)
             {
                 auto compareLambda = [](const auto &it1, const auto &it2) {
                     return (it1.x() == it2.x()) && (it1.value() == it2.value());
                 };
                 auto candidateDS = std::dynamic_pointer_cast<T>(candidate);
                 auto referenceDS = std::dynamic_pointer_cast<T>(reference);
                 if (candidateDS && referenceDS) {
                     auto itRefs
                         = referenceDS->xAxisRange(candidateCacheRange.m_TStart, candidateCacheRange.m_TEnd);
                     qDebug() << " DISTANCE" << std::distance(candidateDS->cbegin(), candidateDS->cend())
                              << std::distance(itRefs.first, itRefs.second);
                     return std::equal(candidateDS->cbegin(), candidateDS->cend(), itRefs.first, itRefs.second,
                                       compareLambda);
                 }
                 else {
                     return false;
                 }
             }
             }
             class TestAmdaAcquisition : public QObject {
                 Q_OBJECT
             private slots:
                 /// Input data for @sa testAcquisition()
                 void testAcquisition_data();
                 void testAcquisition();
             };
             void TestAmdaAcquisition::testAcquisition_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 QTest::addColumn<QString>("dataFilename");  // File containing expected data of acquisitions
                 QTest::addColumn<SqpRange>("initialRange"); // First acquisition
                 QTest::addColumn<std::vector<SqpRange> >("operations"); // Acquisitions to make
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 auto dateTime = [](int year, int month, int day, int hours, int minutes, int seconds) {
                     return DateUtils::secondsSinceEpoch(
                         QDateTime{{year, month, day}, {hours, minutes, seconds}, Qt::UTC});
                 };
                 QTest::newRow("amda")
                     << "AmdaData-2012-01-01-12-00-00_2012-01-03-12-00-00.txt"
                     << SqpRange{dateTime(2012, 1, 2, 2, 3, 0), dateTime(2012, 1, 2, 2, 4, 0)}
                     << std::vector<SqpRange>{
                            // 2 : pan (jump) left for two min
                            SqpRange{dateTime(2012, 1, 2, 2, 1, 0), dateTime(2012, 1, 2, 2, 2, 0)},
                            // 3 : pan (jump) right for four min
                            SqpRange{dateTime(2012, 1, 2, 2, 5, 0), dateTime(2012, 1, 2, 2, 6, 0)},
                            // 4 : pan (overlay) right for 30 sec
                            /*SqpRange{dateTime(2012, 1, 2, 2, 5, 30), dateTime(2012, 1, 2, 2, 6, 30)},
                            // 5 : pan (overlay) left for 30 sec
                            SqpRange{dateTime(2012, 1, 2, 2, 5, 0), dateTime(2012, 1, 2, 2, 6, 0)},
                     // 6 : pan (overlay) left for 30 sec - BIS
                     SqpRange{dateTime(2012, 1, 2, 2, 4, 30), dateTime(2012, 1, 2, 2, 5, 30)},
                     // 7 : Zoom in Inside 20 sec range
                     SqpRange{dateTime(2012, 1, 2, 2, 4, 50), dateTime(2012, 1, 2, 2, 5, 10)},
                     // 8 : Zoom out Inside 20 sec range
                     SqpRange{dateTime(2012, 1, 2, 2, 4, 30), dateTime(2012, 1, 2, 2, 5, 30)}*/};
             }
             void TestAmdaAcquisition::testAcquisition()
             {
                 /// @todo: update test to be compatible with AMDA v2
                 // Retrieves data file
                 QFETCH(QString, dataFilename);
                 auto filePath = QFileInfo{TESTS_RESOURCES_PATH, dataFilename}.absoluteFilePath();
-                auto results = AmdaResultParser::readTxt(filePath, AmdaResultParser::ValueType::SCALAR);
+                auto results = AmdaResultParser::readTxt(filePath, DataSeriesType::SCALAR);
                 /// Lambda used to validate a variable at each step
                 auto validateVariable = [results](std::shared_ptr<Variable> variable, const SqpRange &range) {
                     // Checks that the variable's range has changed
                     qInfo() << tr("Compare var range vs range") << variable->range() << range;
                     QCOMPARE(variable->range(), range);
                     // Checks the variable's data series
                     QVERIFY(compareDataSeries<ScalarSeries>(variable->dataSeries(), variable->cacheRange(),
                                                             results));
                     qInfo() << "\n";
                 };
                 // Creates variable
                 QFETCH(SqpRange, initialRange);
                 sqpApp->timeController().onTimeToUpdate(initialRange);
                 auto provider = std::make_shared<AmdaProvider>();
                 auto variable = sqpApp->variableController().createVariable(
                     "bx_gse", {{"dataType", "scalar"}, {"xml:id", "imf(0)"}}, provider);
                 QTest::qWait(OPERATION_DELAY);
                 validateVariable(variable, initialRange);
                 // Makes operations on the variable
                 QFETCH(std::vector<SqpRange>, operations);
                 for (const auto &operation : operations) {
                     // Asks request on the variable and waits during its execution
                     sqpApp->variableController().onRequestDataLoading({variable}, operation, false);
                     QTest::qWait(OPERATION_DELAY);
                     validateVariable(variable, operation);
                 }
             }
             int main(int argc, char *argv[])
             {
                 SqpApplication app(argc, argv);
                 app.setAttribute(Qt::AA_Use96Dpi, true);
                 TestAmdaAcquisition tc;
                 QTEST_SET_MAIN_SOURCE_PATH
                 return QTest::qExec(&tc, argc, argv);
             }
             // QTEST_MAIN(TestAmdaAcquisition)
             #include "TestAmdaAcquisition.moc"

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

             #include "AmdaResultParser.h"
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <QObject>
             #include <QtTest>
             namespace {
             /// Path for the tests
             const auto TESTS_RESOURCES_PATH
                 = QFileInfo{QString{AMDA_TESTS_RESOURCES_DIR}, "TestAmdaResultParser"}.absoluteFilePath();
             QDateTime dateTime(int year, int month, int day, int hours, int minutes, int seconds)
             {
                 return QDateTime{{year, month, day}, {hours, minutes, seconds}, Qt::UTC};
             }
             QString inputFilePath(const QString &inputFileName)
             {
                 return QFileInfo{TESTS_RESOURCES_PATH, inputFileName}.absoluteFilePath();
             }
             template <typename T>
             struct ExpectedResults {
                 ExpectedResults &setParsingOK(bool parsingOK)
                 {
                     m_ParsingOK = parsingOK;
                     return *this;
                 }
                 ExpectedResults &setXAxisUnit(Unit xAxisUnit)
                 {
                     m_XAxisUnit = std::move(xAxisUnit);
                     return *this;
                 }
                 ExpectedResults &setXAxisData(const QVector<QDateTime> &xAxisData)
                 {
                     m_XAxisData.clear();
                     // Converts QVector<QDateTime> to QVector<double>
                     std::transform(xAxisData.cbegin(), xAxisData.cend(), std::back_inserter(m_XAxisData),
                                    [](const auto &dateTime) { return dateTime.toMSecsSinceEpoch() / 1000.; });
                     return *this;
                 }
                 ExpectedResults &setValuesUnit(Unit valuesUnit)
                 {
                     m_ValuesUnit = std::move(valuesUnit);
                     return *this;
                 }
                 ExpectedResults &setValuesData(QVector<double> valuesData)
                 {
                     m_ValuesData.clear();
                     m_ValuesData.push_back(std::move(valuesData));
                     return *this;
                 }
                 ExpectedResults &setValuesData(QVector<QVector<double> > valuesData)
                 {
                     m_ValuesData = std::move(valuesData);
                     return *this;
                 }
                 ExpectedResults &setYAxisEnabled(bool yAxisEnabled)
                 {
                     m_YAxisEnabled = yAxisEnabled;
                     return *this;
                 }
                 ExpectedResults &setYAxisUnit(Unit yAxisUnit)
                 {
                     m_YAxisUnit = std::move(yAxisUnit);
                     return *this;
                 }
                 ExpectedResults &setYAxisData(QVector<double> yAxisData)
                 {
                     m_YAxisData = std::move(yAxisData);
                     return *this;
                 }
                 /**
                  * 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 dataSeries = dynamic_cast<T *>(results.get());
                         if (dataSeries == nullptr) {
                             // No unit detected, parsink ok but data is nullptr
                             // TODO, improve the test to verify that the data is null
                             return;
                         }
                         // Checks units
                         QVERIFY(dataSeries->xAxisUnit() == m_XAxisUnit);
                         QVERIFY(dataSeries->valuesUnit() == m_ValuesUnit);
                         auto verifyRange = [dataSeries](const auto &expectedData, const auto &equalFun) {
                             QVERIFY(std::equal(dataSeries->cbegin(), dataSeries->cend(), expectedData.cbegin(),
                                                expectedData.cend(),
                                                [&equalFun](const auto &dataSeriesIt, const auto &expectedX) {
                                                    return equalFun(dataSeriesIt, expectedX);
                                                }));
                         };
                         // Checks x-axis data
                         verifyRange(m_XAxisData, [](const auto &seriesIt, const auto &value) {
                             return seriesIt.x() == value;
                         });
                         // Checks values data of each component
                         for (auto i = 0; i < m_ValuesData.size(); ++i) {
                             verifyRange(m_ValuesData.at(i), [i](const auto &seriesIt, const auto &value) {
                                 auto itValue = seriesIt.value(i);
                                 return (std::isnan(itValue) && std::isnan(value)) || seriesIt.value(i) == value;
                             });
                         }
                         // Checks y-axis (if defined)
                         auto yAxis = dataSeries->yAxis();
                         QCOMPARE(yAxis.isDefined(), m_YAxisEnabled);
                         if (m_YAxisEnabled) {
                             // Unit
                             QCOMPARE(yAxis.unit(), m_YAxisUnit);
                             // Data
                             QVERIFY(std::equal(yAxis.cbegin(), yAxis.cend(), m_YAxisData.cbegin(),
                                                m_YAxisData.cend(), [](const auto &it, const auto &expectedVal) {
                                                    return it.first() == expectedVal;
                                                }));
                         }
                     }
                     else {
                         QVERIFY(results == nullptr);
                     }
                 }
                 // Parsing was successfully completed
                 bool m_ParsingOK{false};
                 // Expected x-axis unit
                 Unit m_XAxisUnit{};
                 // Expected x-axis data
                 QVector<double> m_XAxisData{};
                 // Expected values unit
                 Unit m_ValuesUnit{};
                 // Expected values data
                 QVector<QVector<double> > m_ValuesData{};
                 // Expected data series has y-axis
                 bool m_YAxisEnabled{false};
                 // Expected y-axis unit (if axis defined)
                 Unit m_YAxisUnit{};
                 // Expected y-axis data (if axis defined)
                 QVector<double> m_YAxisData{};
             };
             } // namespace
             Q_DECLARE_METATYPE(ExpectedResults<ScalarSeries>)
             Q_DECLARE_METATYPE(ExpectedResults<SpectrogramSeries>)
             Q_DECLARE_METATYPE(ExpectedResults<VectorSeries>)
             class TestAmdaResultParser : public QObject {
                 Q_OBJECT
             private:
                 template <typename T>
                 void testReadDataStructure()
                 {
                     // ////////////// //
                     // Test structure //
                     // ////////////// //
                     // Name of TXT file to read
                     QTest::addColumn<QString>("inputFileName");
                     // Expected results
                     QTest::addColumn<ExpectedResults<T> >("expectedResults");
                 }
                 template <typename T>
-                void testRead(AmdaResultParser::ValueType valueType)
+                void testRead(DataSeriesType valueType)
                 {
                     QFETCH(QString, inputFileName);
                     QFETCH(ExpectedResults<T>, expectedResults);
                     // Parses file
                     auto filePath = inputFilePath(inputFileName);
                     auto results = AmdaResultParser::readTxt(filePath, valueType);
                     // ///////////////// //
                     // Validates results //
                     // ///////////////// //
                     expectedResults.validate(results);
                 }
             private slots:
                 /// Input test data
                 /// @sa testReadScalarTxt()
                 void testReadScalarTxt_data();
                 /// Tests parsing scalar series of a TXT file
                 void testReadScalarTxt();
                 /// Input test data
                 /// @sa testReadSpectrogramTxt()
                 void testReadSpectrogramTxt_data();
                 /// Tests parsing spectrogram series of a TXT file
                 void testReadSpectrogramTxt();
                 /// Input test data
                 /// @sa testReadVectorTxt()
                 void testReadVectorTxt_data();
                 /// Tests parsing vector series of a TXT file
                 void testReadVectorTxt();
             };
             void TestAmdaResultParser::testReadScalarTxt_data()
             {
                 testReadDataStructure<ScalarSeries>();
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 // Valid files
                 QTest::newRow("Valid file")
                     << QStringLiteral("ValidScalar1.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({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)})
                            .setValuesData({-2.83950, -2.71850, -2.52150, -2.57633, -2.58050, -2.48325, -2.63025,
                                            -2.55800, -2.43250, -2.42200});
                 QTest::newRow("Valid file (value of first line is invalid but it is converted to NaN")
                     << QStringLiteral("WrongValue.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                           dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({std::numeric_limits<double>::quiet_NaN(), -2.71850, -2.52150});
                 QTest::newRow("Valid file that contains NaN values")
                     << QStringLiteral("NaNValue.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{("nT"), true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                           dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({std::numeric_limits<double>::quiet_NaN(), -2.71850, -2.52150});
                 // Valid files but with some invalid lines (wrong unit, wrong values, etc.)
                 QTest::newRow("No unit file")
                     << QStringLiteral("NoUnit.txt")
                     << ExpectedResults<ScalarSeries>{}.setParsingOK(true).setXAxisUnit(Unit{"", true});
                 QTest::newRow("Wrong unit file")
                     << QStringLiteral("WrongUnit.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                           dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({-2.83950, -2.71850, -2.52150});
                 QTest::newRow("Wrong results file (date of first line is invalid")
                     << QStringLiteral("WrongDate.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({-2.71850, -2.52150});
                 QTest::newRow("Wrong results file (too many values for first line")
                     << QStringLiteral("TooManyValues.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({-2.71850, -2.52150});
                 QTest::newRow("Wrong results file (x of first line is NaN")
                     << QStringLiteral("NaNX.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({-2.71850, -2.52150});
                 QTest::newRow("Invalid file type (vector)")
                     << QStringLiteral("ValidVector1.txt")
                     << ExpectedResults<ScalarSeries>{}.setParsingOK(true).setXAxisUnit(Unit{"nT", true});
                 // Invalid files
                 QTest::newRow("Invalid file (unexisting file)")
                     << QStringLiteral("UnexistingFile.txt")
                     << ExpectedResults<ScalarSeries>{}.setParsingOK(false);
                 QTest::newRow("Invalid file (file not found on server)")
                     << QStringLiteral("FileNotFound.txt")
                     << ExpectedResults<ScalarSeries>{}.setParsingOK(false);
             }
             void TestAmdaResultParser::testReadScalarTxt()
             {
-                testRead<ScalarSeries>(AmdaResultParser::ValueType::SCALAR);
+                testRead<ScalarSeries>(DataSeriesType::SCALAR);
             }
             void TestAmdaResultParser::testReadSpectrogramTxt_data()
             {
                 testReadDataStructure<SpectrogramSeries>();
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 // Valid files
                 QTest::newRow("Valid file (three bands)")
                     << QStringLiteral("spectro/ValidSpectrogram1.txt")
                     << ExpectedResults<SpectrogramSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"t", true})
                            .setXAxisData({dateTime(2012, 11, 6, 9, 14, 35), dateTime(2012, 11, 6, 9, 16, 10),
                                           dateTime(2012, 11, 6, 9, 17, 45), dateTime(2012, 11, 6, 9, 19, 20),
                                           dateTime(2012, 11, 6, 9, 20, 55)})
                            .setYAxisEnabled(true)
                            .setYAxisUnit(Unit{"eV"})
                            .setYAxisData({5.75, 7.6, 10.05}) // middle of the intervals of each band
                            .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
                            .setValuesData(QVector<QVector<double> >{
                                {16313.780, 12631.465, 8223.368, 27595.301, 12820.613},
                                {15405.838, 11957.925, 15026.249, 25617.533, 11179.109},
                                {8946.475, 18133.158, 10875.621, 24051.619, 19283.221}});
                 auto fourBandsResult
                     = ExpectedResults<SpectrogramSeries>{}
                           .setParsingOK(true)
                           .setXAxisUnit(Unit{"t", true})
                           .setXAxisData({dateTime(2012, 11, 6, 9, 14, 35), dateTime(2012, 11, 6, 9, 16, 10),
                                          dateTime(2012, 11, 6, 9, 17, 45), dateTime(2012, 11, 6, 9, 19, 20),
                                          dateTime(2012, 11, 6, 9, 20, 55)})
                           .setYAxisEnabled(true)
                           .setYAxisUnit(Unit{"eV"})
                           .setYAxisData({5.75, 7.6, 10.05, 13.}) // middle of the intervals of each band
                           .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
                           .setValuesData(QVector<QVector<double> >{
                               {16313.780, 12631.465, 8223.368, 27595.301, 12820.613},
                               {15405.838, 11957.925, 15026.249, 25617.533, 11179.109},
                               {8946.475, 18133.158, 10875.621, 24051.619, 19283.221},
                               {20907.664, 32076.725, 13008.381, 13142.759, 23226.998}});
                 QTest::newRow("Valid file (four bands)") << QStringLiteral("spectro/ValidSpectrogram2.txt")
                                                          << fourBandsResult;
                 QTest::newRow("Valid file (four unsorted bands)")
                     << QStringLiteral("spectro/ValidSpectrogram3.txt")
                     << fourBandsResult; // Bands and values are sorted
                 auto nan = std::numeric_limits<double>::quiet_NaN();
                 auto nanValuesResult
                     = ExpectedResults<SpectrogramSeries>{}
                           .setParsingOK(true)
                           .setXAxisUnit(Unit{"t", true})
                           .setXAxisData({dateTime(2012, 11, 6, 9, 14, 35), dateTime(2012, 11, 6, 9, 16, 10),
                                          dateTime(2012, 11, 6, 9, 17, 45), dateTime(2012, 11, 6, 9, 19, 20),
                                          dateTime(2012, 11, 6, 9, 20, 55)})
                           .setYAxisEnabled(true)
                           .setYAxisUnit(Unit{"eV"})
                           .setYAxisData({5.75, 7.6, 10.05, 13.}) // middle of the intervals of each band
                           .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
                           .setValuesData(
                               QVector<QVector<double> >{{nan, 12631.465, 8223.368, 27595.301, 12820.613},
                                                         {15405.838, nan, nan, 25617.533, 11179.109},
                                                         {8946.475, 18133.158, 10875.621, 24051.619, 19283.221},
                                                         {nan, nan, nan, nan, nan}});
                 QTest::newRow("Valid file (containing NaN values)")
                     << QStringLiteral("spectro/ValidSpectrogramNaNValues.txt") << nanValuesResult;
                 QTest::newRow("Valid file (containing fill values)")
                     << QStringLiteral("spectro/ValidSpectrogramFillValues.txt")
                     << nanValuesResult; // Fill values are replaced by NaN values in the data series
                 QTest::newRow("Valid file (containing data holes, resolution = 3 minutes)")
                     << QStringLiteral("spectro/ValidSpectrogramDataHoles.txt")
                     << ExpectedResults<SpectrogramSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"t", true})
                            .setXAxisData({dateTime(2011, 12, 10, 12, 10, 54), //
                                           dateTime(2011, 12, 10, 12, 13, 54), // Data hole
                                           dateTime(2011, 12, 10, 12, 16, 54), // Data hole
                                           dateTime(2011, 12, 10, 12, 17, 23), //
                                           dateTime(2011, 12, 10, 12, 20, 23), // Data hole
                                           dateTime(2011, 12, 10, 12, 23, 23), // Data hole
                                           dateTime(2011, 12, 10, 12, 23, 51), //
                                           dateTime(2011, 12, 10, 12, 26, 51), // Data hole
                                           dateTime(2011, 12, 10, 12, 29, 51), // Data hole
                                           dateTime(2011, 12, 10, 12, 30, 19), //
                                           dateTime(2011, 12, 10, 12, 33, 19), // Data hole
                                           dateTime(2011, 12, 10, 12, 35, 04), //
                                           dateTime(2011, 12, 10, 12, 36, 41), //
                                           dateTime(2011, 12, 10, 12, 38, 18), //
                                           dateTime(2011, 12, 10, 12, 39, 55)})
                            .setYAxisEnabled(true)
                            .setYAxisUnit(Unit{"eV"})
                            .setYAxisData({16485.85, 20996.1}) // middle of the intervals of each band
                            .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
                            .setValuesData(QVector<QVector<double> >{{2577578.000, //
                                                                      nan,         // Data hole
                                                                      nan,         // Data hole
                                                                      2314121.500, //
                                                                      nan,         // Data hole
                                                                      nan,         // Data hole
                                                                      2063608.750, //
                                                                      nan,         // Data hole
                                                                      nan,         // Data hole
                                                                      2234525.500, //
                                                                      nan,         // Data hole
                                                                      1670215.250, //
                                                                      1689243.250, //
                                                                      1654617.125, //
                                                                      1504983.750},
                                                                     {2336016.000, //
                                                                      nan,         // Data hole
                                                                      nan,         // Data hole
                                                                      1712093.125, //
                                                                      nan,         // Data hole
                                                                      nan,         // Data hole
                                                                      1614491.625, //
                                                                      nan,         // Data hole
                                                                      nan,         // Data hole
                                                                      1764516.500, //
                                                                      nan,         // Data hole
                                                                      1688078.500, //
                                                                      1743183.500, //
                                                                      1733603.250, //
                                                                      1708356.500}});
                 QTest::newRow(
                     "Valid file (containing data holes at the beginning and the end, resolution = 4 minutes)")
                     << QStringLiteral("spectro/ValidSpectrogramDataHoles2.txt")
                     << ExpectedResults<SpectrogramSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"t", true})
                            .setXAxisData({
                                dateTime(2011, 12, 10, 12, 2, 54),  // Data hole
                                dateTime(2011, 12, 10, 12, 6, 54),  // Data hole
                                dateTime(2011, 12, 10, 12, 10, 54), //
                                dateTime(2011, 12, 10, 12, 14, 54), // Data hole
                                dateTime(2011, 12, 10, 12, 17, 23), //
                                dateTime(2011, 12, 10, 12, 21, 23), // Data hole
                                dateTime(2011, 12, 10, 12, 23, 51), //
                                dateTime(2011, 12, 10, 12, 27, 51), // Data hole
                                dateTime(2011, 12, 10, 12, 30, 19), //
                                dateTime(2011, 12, 10, 12, 34, 19), // Data hole
                                dateTime(2011, 12, 10, 12, 35, 04), //
                                dateTime(2011, 12, 10, 12, 36, 41), //
                                dateTime(2011, 12, 10, 12, 38, 18), //
                                dateTime(2011, 12, 10, 12, 39, 55),
                                dateTime(2011, 12, 10, 12, 43, 55), // Data hole
                                dateTime(2011, 12, 10, 12, 47, 55), // Data hole
                                dateTime(2011, 12, 10, 12, 51, 55), // Data hole
                                dateTime(2011, 12, 10, 12, 55, 55), // Data hole
                                dateTime(2011, 12, 10, 12, 59, 55)  // Data hole
                            })
                            .setYAxisEnabled(true)
                            .setYAxisUnit(Unit{"eV"})
                            .setYAxisData({16485.85, 20996.1}) // middle of the intervals of each band
                            .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
                            .setValuesData(QVector<QVector<double> >{{
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         2577578.000, //
                                                                         nan,         // Data hole
                                                                         2314121.500, //
                                                                         nan,         // Data hole
                                                                         2063608.750, //
                                                                         nan,         // Data hole
                                                                         2234525.500, //
                                                                         nan,         // Data hole
                                                                         1670215.250, //
                                                                         1689243.250, //
                                                                         1654617.125, //
                                                                         1504983.750, //
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         nan          // Data hole
                                                                     },
                                                                     {
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         2336016.000, //
                                                                         nan,         // Data hole
                                                                         1712093.125, //
                                                                         nan,         // Data hole
                                                                         1614491.625, //
                                                                         nan,         // Data hole
                                                                         1764516.500, //
                                                                         nan,         // Data hole
                                                                         1688078.500, //
                                                                         1743183.500, //
                                                                         1733603.250, //
                                                                         1708356.500, //
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         nan          // Data hole
                                                                     }});
                 // Invalid files
                 QTest::newRow("Invalid file (inconsistent bands)")
                     << QStringLiteral("spectro/InvalidSpectrogramWrongBands.txt")
                     << ExpectedResults<SpectrogramSeries>{}.setParsingOK(false);
             }
             void TestAmdaResultParser::testReadSpectrogramTxt()
             {
-                testRead<SpectrogramSeries>(AmdaResultParser::ValueType::SPECTROGRAM);
+                testRead<SpectrogramSeries>(DataSeriesType::SPECTROGRAM);
             }
             void TestAmdaResultParser::testReadVectorTxt_data()
             {
                 testReadDataStructure<VectorSeries>();
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 // Valid files
                 QTest::newRow("Valid file")
                     << QStringLiteral("ValidVector1.txt")
                     << ExpectedResults<VectorSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 7, 2, 9, 13, 50), dateTime(2013, 7, 2, 9, 14, 6),
                                           dateTime(2013, 7, 2, 9, 14, 22), dateTime(2013, 7, 2, 9, 14, 38),
                                           dateTime(2013, 7, 2, 9, 14, 54), dateTime(2013, 7, 2, 9, 15, 10),
                                           dateTime(2013, 7, 2, 9, 15, 26), dateTime(2013, 7, 2, 9, 15, 42),
                                           dateTime(2013, 7, 2, 9, 15, 58), dateTime(2013, 7, 2, 9, 16, 14)})
                            .setValuesData(
                                {{-0.332, -1.011, -1.457, -1.293, -1.217, -1.443, -1.278, -1.202, -1.22, -1.259},
                                 {3.206, 2.999, 2.785, 2.736, 2.612, 2.564, 2.892, 2.862, 2.859, 2.764},
                                 {0.058, 0.496, 1.018, 1.485, 1.662, 1.505, 1.168, 1.244, 1.15, 1.358}});
                 // Valid files but with some invalid lines (wrong unit, wrong values, etc.)
                 QTest::newRow("Invalid file type (scalar)")
                     << QStringLiteral("ValidScalar1.txt")
                     << ExpectedResults<VectorSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({})
                            .setValuesData(QVector<QVector<double> >{{}, {}, {}});
             }
             void TestAmdaResultParser::testReadVectorTxt()
             {
-                testRead<VectorSeries>(AmdaResultParser::ValueType::VECTOR);
+                testRead<VectorSeries>(DataSeriesType::VECTOR);
             }
             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