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