##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SCIQLOP-Initialisation
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

correction clang format
perrinel -
r342:df6a5b97d490
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,176 +1,176
1 #include "AmdaParser.h"
1 #include "AmdaParser.h"
2
2
3 #include <DataSource/DataSourceItem.h>
3 #include <DataSource/DataSourceItem.h>
4
4
5 #include <QObject>
5 #include <QObject>
6 #include <QtTest>
6 #include <QtTest>
7
7
8 #include <QString>
8 #include <QString>
9
9
10 namespace {
10 namespace {
11
11
12 /// Path for the tests
12 /// Path for the tests
13 const auto TESTS_RESOURCES_PATH
13 const auto TESTS_RESOURCES_PATH
14 = QFileInfo{QString{AMDA_TESTS_RESOURCES_DIR}, "TestAmdaParser"}.absoluteFilePath();
14 = QFileInfo{QString{AMDA_TESTS_RESOURCES_DIR}, "TestAmdaParser"}.absoluteFilePath();
15
15
16 QString inputFilePath(const QString &inputFileName)
16 QString inputFilePath(const QString &inputFileName)
17 {
17 {
18 return QFileInfo{TESTS_RESOURCES_PATH, inputFileName}.absoluteFilePath();
18 return QFileInfo{TESTS_RESOURCES_PATH, inputFileName}.absoluteFilePath();
19 }
19 }
20
20
21 struct ExpectedResults {
21 struct ExpectedResults {
22 explicit ExpectedResults() = default;
22 explicit ExpectedResults() = default;
23 explicit ExpectedResults(std::shared_ptr<DataSourceItem> item)
23 explicit ExpectedResults(std::shared_ptr<DataSourceItem> item)
24 : m_ParsingOK{true}, m_Item{std::move(item)}
24 : m_ParsingOK{true}, m_Item{std::move(item)}
25 {
25 {
26 }
26 }
27
27
28 // Parsing was successfully completed
28 // Parsing was successfully completed
29 bool m_ParsingOK{false};
29 bool m_ParsingOK{false};
30 // Expected item after parsing
30 // Expected item after parsing
31 std::shared_ptr<DataSourceItem> m_Item{nullptr};
31 std::shared_ptr<DataSourceItem> m_Item{nullptr};
32 };
32 };
33
33
34 // ///////////////////////////////// //
34 // ///////////////////////////////// //
35 // Set of expected results for tests //
35 // Set of expected results for tests //
36 // ///////////////////////////////// //
36 // ///////////////////////////////// //
37
37
38 ExpectedResults validResults1()
38 ExpectedResults validResults1()
39 {
39 {
40 auto component1 = std::make_unique<DataSourceItem>(
40 auto component1 = std::make_unique<DataSourceItem>(
41 DataSourceItemType::COMPONENT,
41 DataSourceItemType::COMPONENT,
42 QHash<QString, QVariant>{{"name", "Bx"}, {"xml:id", "ice_b_cse(0)"}});
42 QHash<QString, QVariant>{{"name", "Bx"}, {"xml:id", "ice_b_cse(0)"}});
43 auto component2 = std::make_unique<DataSourceItem>(
43 auto component2 = std::make_unique<DataSourceItem>(
44 DataSourceItemType::COMPONENT,
44 DataSourceItemType::COMPONENT,
45 QHash<QString, QVariant>{{"name", "By"}, {"xml:id", "ice_b_cse(1)"}});
45 QHash<QString, QVariant>{{"name", "By"}, {"xml:id", "ice_b_cse(1)"}});
46 auto component3 = std::make_unique<DataSourceItem>(
46 auto component3 = std::make_unique<DataSourceItem>(
47 DataSourceItemType::COMPONENT,
47 DataSourceItemType::COMPONENT,
48 QHash<QString, QVariant>{{"name", "Bz"}, {"xml:id", "ice_b_cse(2)"}});
48 QHash<QString, QVariant>{{"name", "Bz"}, {"xml:id", "ice_b_cse(2)"}});
49 auto parameter1 = std::make_unique<DataSourceItem>(
49 auto parameter1 = std::make_unique<DataSourceItem>(
50 DataSourceItemType::PRODUCT,
50 DataSourceItemType::PRODUCT,
51 QHash<QString, QVariant>{
51 QHash<QString, QVariant>{
52 {"name", "B_cse"}, {"units", "nT"}, {"display_type", ""}, {"xml:id", "ice_b_cse"}});
52 {"name", "B_cse"}, {"units", "nT"}, {"display_type", ""}, {"xml:id", "ice_b_cse"}});
53 parameter1->appendChild(std::move(component1));
53 parameter1->appendChild(std::move(component1));
54 parameter1->appendChild(std::move(component2));
54 parameter1->appendChild(std::move(component2));
55 parameter1->appendChild(std::move(component3));
55 parameter1->appendChild(std::move(component3));
56
56
57 auto parameter2 = std::make_unique<DataSourceItem>(
57 auto parameter2 = std::make_unique<DataSourceItem>(
58 DataSourceItemType::PRODUCT,
58 DataSourceItemType::PRODUCT,
59 QHash<QString, QVariant>{
59 QHash<QString, QVariant>{
60 {"name", "|B|"}, {"units", "nT"}, {"display_type", ""}, {"xml:id", "ice_b_tot"}});
60 {"name", "|B|"}, {"units", "nT"}, {"display_type", ""}, {"xml:id", "ice_b_tot"}});
61
61
62 auto dataset = std::make_unique<DataSourceItem>(
62 auto dataset = std::make_unique<DataSourceItem>(
63 DataSourceItemType::NODE, QHash<QString, QVariant>{{"att", ""},
63 DataSourceItemType::NODE, QHash<QString, QVariant>{{"att", ""},
64 {"restricted", ""},
64 {"restricted", ""},
65 {"name", "Magnetic Field"},
65 {"name", "Magnetic Field"},
66 {"xml:id", "ice:mag:p21"},
66 {"xml:id", "ice:mag:p21"},
67 {"sampling", "0.3s"},
67 {"sampling", "0.3s"},
68 {"maxSampling", ""},
68 {"maxSampling", ""},
69 {"dataStart", "1985/09/10"},
69 {"dataStart", "1985/09/10"},
70 {"dataStop", "1985/09/14"},
70 {"dataStop", "1985/09/14"},
71 {"dataSource", "PDS"},
71 {"dataSource", "PDS"},
72 {"target", ""}});
72 {"target", ""}});
73 dataset->appendChild(std::move(parameter1));
73 dataset->appendChild(std::move(parameter1));
74 dataset->appendChild(std::move(parameter2));
74 dataset->appendChild(std::move(parameter2));
75
75
76 auto instrument = std::make_unique<DataSourceItem>(
76 auto instrument = std::make_unique<DataSourceItem>(
77 DataSourceItemType::NODE, QHash<QString, QVariant>{{"att", ""},
77 DataSourceItemType::NODE, QHash<QString, QVariant>{{"att", ""},
78 {"name", "MAG"},
78 {"name", "MAG"},
79 {"xml:id", "ICE@Giacobini-Zinner:MAG"},
79 {"xml:id", "ICE@Giacobini-Zinner:MAG"},
80 {"desc", "Vector Helium Magnetometer"},
80 {"desc", "Vector Helium Magnetometer"},
81 {"restricted", ""}});
81 {"restricted", ""}});
82 instrument->appendChild(std::move(dataset));
82 instrument->appendChild(std::move(dataset));
83
83
84 auto mission = std::make_unique<DataSourceItem>(
84 auto mission = std::make_unique<DataSourceItem>(
85 DataSourceItemType::NODE,
85 DataSourceItemType::NODE,
86 QHash<QString, QVariant>{{"att", ""},
86 QHash<QString, QVariant>{{"att", ""},
87 {"name", "ICE@Giacobini-Zinner"},
87 {"name", "ICE@Giacobini-Zinner"},
88 {"rank", "93"},
88 {"rank", "93"},
89 {"xml:id", "ICE@Giacobini-Zinner"},
89 {"xml:id", "ICE@Giacobini-Zinner"},
90 {"desc", "International Cometary Explorer"},
90 {"desc", "International Cometary Explorer"},
91 {"target", "Comet"},
91 {"target", "Comet"},
92 {"available", "1"}});
92 {"available", "1"}});
93 mission->appendChild(std::move(instrument));
93 mission->appendChild(std::move(instrument));
94
94
95 auto item = std::make_shared<DataSourceItem>(DataSourceItemType::NODE,
95 auto item = std::make_shared<DataSourceItem>(DataSourceItemType::NODE,
96 QHash<QString, QVariant>{
96 QHash<QString, QVariant>{
97 {"name", "AMDA"},
97 {"name", "AMDA"},
98 {"desc", "AMDA_Internal_Data_Base"},
98 {"desc", "AMDA_Internal_Data_Base"},
99 {"xml:id", "myLocalData-treeRootNode"},
99 {"xml:id", "myLocalData-treeRootNode"},
100 });
100 });
101 item->appendChild(std::move(mission));
101 item->appendChild(std::move(mission));
102
102
103 return ExpectedResults{item};
103 return ExpectedResults{item};
104 }
104 }
105
105
106 ExpectedResults invalidResults()
106 ExpectedResults invalidResults()
107 {
107 {
108 return ExpectedResults{};
108 return ExpectedResults{};
109 }
109 }
110
110
111 } // namespace
111 } // namespace
112
112
113 Q_DECLARE_METATYPE(ExpectedResults)
113 Q_DECLARE_METATYPE(ExpectedResults)
114
114
115 class TestAmdaParser : public QObject {
115 class TestAmdaParser : public QObject {
116 Q_OBJECT
116 Q_OBJECT
117 private slots:
117 private slots:
118 /// Input test data
118 /// Input test data
119 /// @sa testReadJson()
119 /// @sa testReadJson()
120 void testReadJson_data();
120 void testReadJson_data();
121
121
122 /// Tests parsing of a JSON file
122 /// Tests parsing of a JSON file
123 void testReadJson();
123 void testReadJson();
124 };
124 };
125
125
126 void TestAmdaParser::testReadJson_data()
126 void TestAmdaParser::testReadJson_data()
127 {
127 {
128 // ////////////// //
128 // ////////////// //
129 // Test structure //
129 // Test structure //
130 // ////////////// //
130 // ////////////// //
131
131
132 // Name of JSON file to read
132 // Name of JSON file to read
133 QTest::addColumn<QString>("inputFileName");
133 QTest::addColumn<QString>("inputFileName");
134 // Expected results
134 // Expected results
135 QTest::addColumn<ExpectedResults>("expectedResults");
135 QTest::addColumn<ExpectedResults>("expectedResults");
136
136
137 // ////////// //
137 // ////////// //
138 // Test cases //
138 // Test cases //
139 // ////////// //
139 // ////////// //
140
140
141 // Valid file
141 // Valid file
142 QTest::newRow("Valid file") << QStringLiteral("ValidFile1.json") << validResults1();
142 QTest::newRow("Valid file") << QStringLiteral("ValidFile1.json") << validResults1();
143
143
144 // Invalid files
144 // Invalid files
145 QTest::newRow("Invalid file (unexisting file)")
145 QTest::newRow("Invalid file (unexisting file)") << QStringLiteral("UnexistingFile.json")
146 << QStringLiteral("UnexistingFile.json") << invalidResults();
146 << invalidResults();
147 QTest::newRow("Invalid file (two root objects)")
147 QTest::newRow("Invalid file (two root objects)") << QStringLiteral("TwoRootsFile.json")
148 << QStringLiteral("TwoRootsFile.json") << invalidResults();
148 << invalidResults();
149 QTest::newRow("Invalid file (wrong root key)")
149 QTest::newRow("Invalid file (wrong root key)") << QStringLiteral("WrongRootKey.json")
150 << QStringLiteral("WrongRootKey.json") << invalidResults();
150 << invalidResults();
151 QTest::newRow("Invalid file (wrong root type)")
151 QTest::newRow("Invalid file (wrong root type)") << QStringLiteral("WrongRootType.json")
152 << QStringLiteral("WrongRootType.json") << invalidResults();
152 << invalidResults();
153 }
153 }
154
154
155 void TestAmdaParser::testReadJson()
155 void TestAmdaParser::testReadJson()
156 {
156 {
157 QFETCH(QString, inputFileName);
157 QFETCH(QString, inputFileName);
158 QFETCH(ExpectedResults, expectedResults);
158 QFETCH(ExpectedResults, expectedResults);
159
159
160 // Parses file
160 // Parses file
161 auto filePath = inputFilePath(inputFileName);
161 auto filePath = inputFilePath(inputFileName);
162 auto item = AmdaParser::readJson(filePath);
162 auto item = AmdaParser::readJson(filePath);
163
163
164 // Validates results
164 // Validates results
165 if (expectedResults.m_ParsingOK) {
165 if (expectedResults.m_ParsingOK) {
166 QVERIFY(item != nullptr);
166 QVERIFY(item != nullptr);
167 QVERIFY(expectedResults.m_Item != nullptr);
167 QVERIFY(expectedResults.m_Item != nullptr);
168 QVERIFY(*item == *expectedResults.m_Item);
168 QVERIFY(*item == *expectedResults.m_Item);
169 }
169 }
170 else {
170 else {
171 QVERIFY(item == nullptr);
171 QVERIFY(item == nullptr);
172 }
172 }
173 }
173 }
174
174
175 QTEST_MAIN(TestAmdaParser)
175 QTEST_MAIN(TestAmdaParser)
176 #include "TestAmdaParser.moc"
176 #include "TestAmdaParser.moc"
General Comments 0
You need to be logged in to leave comments. Login now