|
|
#include "AmdaParser.h"
|
|
|
|
|
|
#include <DataSource/DataSourceItem.h>
|
|
|
|
|
|
#include <QObject>
|
|
|
#include <QtTest>
|
|
|
|
|
|
#include <QString>
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
/// Path for the tests
|
|
|
const auto TESTS_RESOURCES_PATH
|
|
|
= QFileInfo{QString{AMDA_TESTS_RESOURCES_DIR}, "TestAmdaParser"}.absoluteFilePath();
|
|
|
|
|
|
QString inputFilePath(const QString &inputFileName)
|
|
|
{
|
|
|
return QFileInfo{TESTS_RESOURCES_PATH, inputFileName}.absoluteFilePath();
|
|
|
}
|
|
|
|
|
|
struct ExpectedResults {
|
|
|
explicit ExpectedResults() = default;
|
|
|
explicit ExpectedResults(std::shared_ptr<DataSourceItem> item)
|
|
|
: m_ParsingOK{true}, m_Item{std::move(item)}
|
|
|
{
|
|
|
}
|
|
|
|
|
|
// Parsing was successfully completed
|
|
|
bool m_ParsingOK{false};
|
|
|
// Expected item after parsing
|
|
|
std::shared_ptr<DataSourceItem> m_Item{nullptr};
|
|
|
};
|
|
|
|
|
|
// ///////////////////////////////// //
|
|
|
// Set of expected results for tests //
|
|
|
// ///////////////////////////////// //
|
|
|
|
|
|
ExpectedResults validResults1()
|
|
|
{
|
|
|
auto component1 = std::make_unique<DataSourceItem>(
|
|
|
DataSourceItemType::COMPONENT,
|
|
|
QHash<QString, QVariant>{{"name", "Bx"}, {"xml:id", "ice_b_cse(0)"}});
|
|
|
auto component2 = std::make_unique<DataSourceItem>(
|
|
|
DataSourceItemType::COMPONENT,
|
|
|
QHash<QString, QVariant>{{"name", "By"}, {"xml:id", "ice_b_cse(1)"}});
|
|
|
auto component3 = std::make_unique<DataSourceItem>(
|
|
|
DataSourceItemType::COMPONENT,
|
|
|
QHash<QString, QVariant>{{"name", "Bz"}, {"xml:id", "ice_b_cse(2)"}});
|
|
|
auto parameter1 = std::make_unique<DataSourceItem>(
|
|
|
DataSourceItemType::PRODUCT,
|
|
|
QHash<QString, QVariant>{
|
|
|
{"name", "B_cse"}, {"units", "nT"}, {"display_type", ""}, {"xml:id", "ice_b_cse"}});
|
|
|
parameter1->appendChild(std::move(component1));
|
|
|
parameter1->appendChild(std::move(component2));
|
|
|
parameter1->appendChild(std::move(component3));
|
|
|
|
|
|
auto parameter2 = std::make_unique<DataSourceItem>(
|
|
|
DataSourceItemType::PRODUCT,
|
|
|
QHash<QString, QVariant>{
|
|
|
{"name", "|B|"}, {"units", "nT"}, {"display_type", ""}, {"xml:id", "ice_b_tot"}});
|
|
|
|
|
|
auto dataset = std::make_unique<DataSourceItem>(
|
|
|
DataSourceItemType::NODE, QHash<QString, QVariant>{{"att", ""},
|
|
|
{"restricted", ""},
|
|
|
{"name", "Magnetic Field"},
|
|
|
{"xml:id", "ice:mag:p21"},
|
|
|
{"sampling", "0.3s"},
|
|
|
{"maxSampling", ""},
|
|
|
{"dataStart", "1985/09/10"},
|
|
|
{"dataStop", "1985/09/14"},
|
|
|
{"dataSource", "PDS"},
|
|
|
{"target", ""}});
|
|
|
dataset->appendChild(std::move(parameter1));
|
|
|
dataset->appendChild(std::move(parameter2));
|
|
|
|
|
|
auto instrument = std::make_unique<DataSourceItem>(
|
|
|
DataSourceItemType::NODE, QHash<QString, QVariant>{{"att", ""},
|
|
|
{"name", "MAG"},
|
|
|
{"xml:id", "ICE@Giacobini-Zinner:MAG"},
|
|
|
{"desc", "Vector Helium Magnetometer"},
|
|
|
{"restricted", ""}});
|
|
|
instrument->appendChild(std::move(dataset));
|
|
|
|
|
|
auto mission = std::make_unique<DataSourceItem>(
|
|
|
DataSourceItemType::NODE,
|
|
|
QHash<QString, QVariant>{{"att", ""},
|
|
|
{"name", "ICE@Giacobini-Zinner"},
|
|
|
{"rank", "93"},
|
|
|
{"xml:id", "ICE@Giacobini-Zinner"},
|
|
|
{"desc", "International Cometary Explorer"},
|
|
|
{"target", "Comet"},
|
|
|
{"available", "1"}});
|
|
|
mission->appendChild(std::move(instrument));
|
|
|
|
|
|
auto item = std::make_shared<DataSourceItem>(DataSourceItemType::NODE,
|
|
|
QHash<QString, QVariant>{
|
|
|
{"name", "AMDA"},
|
|
|
{"desc", "AMDA_Internal_Data_Base"},
|
|
|
{"xml:id", "myLocalData-treeRootNode"},
|
|
|
});
|
|
|
item->appendChild(std::move(mission));
|
|
|
|
|
|
return ExpectedResults{item};
|
|
|
}
|
|
|
|
|
|
ExpectedResults invalidResults()
|
|
|
{
|
|
|
return ExpectedResults{};
|
|
|
}
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
Q_DECLARE_METATYPE(ExpectedResults)
|
|
|
|
|
|
class TestAmdaParser : public QObject {
|
|
|
Q_OBJECT
|
|
|
private slots:
|
|
|
/// Input test data
|
|
|
/// @sa testReadJson()
|
|
|
void testReadJson_data();
|
|
|
|
|
|
/// Tests parsing of a JSON file
|
|
|
void testReadJson();
|
|
|
};
|
|
|
|
|
|
void TestAmdaParser::testReadJson_data()
|
|
|
{
|
|
|
// ////////////// //
|
|
|
// Test structure //
|
|
|
// ////////////// //
|
|
|
|
|
|
// Name of JSON file to read
|
|
|
QTest::addColumn<QString>("inputFileName");
|
|
|
// Expected results
|
|
|
QTest::addColumn<ExpectedResults>("expectedResults");
|
|
|
|
|
|
// ////////// //
|
|
|
// Test cases //
|
|
|
// ////////// //
|
|
|
|
|
|
// Valid file
|
|
|
QTest::newRow("Valid file") << QStringLiteral("ValidFile1.json") << validResults1();
|
|
|
|
|
|
// Invalid files
|
|
|
QTest::newRow("Invalid file (unexisting file)") << QStringLiteral("UnexistingFile.json")
|
|
|
<< invalidResults();
|
|
|
QTest::newRow("Invalid file (two root objects)") << QStringLiteral("TwoRootsFile.json")
|
|
|
<< invalidResults();
|
|
|
QTest::newRow("Invalid file (wrong root key)") << QStringLiteral("WrongRootKey.json")
|
|
|
<< invalidResults();
|
|
|
QTest::newRow("Invalid file (wrong root type)") << QStringLiteral("WrongRootType.json")
|
|
|
<< invalidResults();
|
|
|
}
|
|
|
|
|
|
void TestAmdaParser::testReadJson()
|
|
|
{
|
|
|
QFETCH(QString, inputFileName);
|
|
|
QFETCH(ExpectedResults, expectedResults);
|
|
|
|
|
|
// Parses file
|
|
|
auto filePath = inputFilePath(inputFileName);
|
|
|
auto item = AmdaParser::readJson(filePath);
|
|
|
|
|
|
// Validates results
|
|
|
if (expectedResults.m_ParsingOK) {
|
|
|
QVERIFY(item != nullptr);
|
|
|
QVERIFY(expectedResults.m_Item != nullptr);
|
|
|
QVERIFY(*item == *expectedResults.m_Item);
|
|
|
}
|
|
|
else {
|
|
|
QVERIFY(item == nullptr);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
QTEST_MAIN(TestAmdaParser)
|
|
|
#include "TestAmdaParser.moc"
|
|
|
|
