@@ -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