##// END OF EJS Templates
HG_REPOSITORIES » LPP » SciQLOP_Repos » SciQLop
RSS
Adds unit test for merge of two different series' type
Alexandre Leroux -
r798:9b2c818158c0
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,642 +1,702
1 #include "Data/DataSeries.h"
1 #include "Data/DataSeries.h"
2 #include "Data/ScalarSeries.h"
2 #include "Data/ScalarSeries.h"
3 #include "Data/VectorSeries.h"
3 #include "Data/VectorSeries.h"
4
4
5 #include <cmath>
5 #include <cmath>
6
6
7 #include <QObject>
7 #include <QObject>
8 #include <QtTest>
8 #include <QtTest>
9
9
10 Q_DECLARE_METATYPE(std::shared_ptr<ScalarSeries>)
10 Q_DECLARE_METATYPE(std::shared_ptr<ScalarSeries>)
11 Q_DECLARE_METATYPE(std::shared_ptr<VectorSeries>)
11 Q_DECLARE_METATYPE(std::shared_ptr<VectorSeries>)
12
12
13 namespace {
13 namespace {
14
14
15 using DataContainer = std::vector<double>;
15 using DataContainer = std::vector<double>;
16
16
17 void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
17 void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
18 const DataContainer &valuesData)
18 const DataContainer &valuesData)
19 {
19 {
20 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
20 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
21 [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
21 [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
22 QVERIFY(std::equal(
22 QVERIFY(std::equal(
23 first, last, valuesData.cbegin(), valuesData.cend(),
23 first, last, valuesData.cbegin(), valuesData.cend(),
24 [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
24 [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
25 }
25 }
26
26
27 void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
27 void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
28 const std::vector<DataContainer> &valuesData)
28 const std::vector<DataContainer> &valuesData)
29 {
29 {
30 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
30 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
31 [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
31 [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
32 for (auto i = 0; i < valuesData.size(); ++i) {
32 for (auto i = 0; i < valuesData.size(); ++i) {
33 auto componentData = valuesData.at(i);
33 auto componentData = valuesData.at(i);
34
34
35 QVERIFY(std::equal(
35 QVERIFY(std::equal(
36 first, last, componentData.cbegin(), componentData.cend(),
36 first, last, componentData.cbegin(), componentData.cend(),
37 [i](const auto &it, const auto &expectedVal) { return it.value(i) == expectedVal; }));
37 [i](const auto &it, const auto &expectedVal) { return it.value(i) == expectedVal; }));
38 }
38 }
39 }
39 }
40
40
41 } // namespace
41 } // namespace
42
42
43 class TestDataSeries : public QObject {
43 class TestDataSeries : public QObject {
44 Q_OBJECT
44 Q_OBJECT
45 private:
45 private:
46 template <typename T>
46 template <typename T>
47 void testValuesBoundsStructure()
47 void testValuesBoundsStructure()
48 {
48 {
49 // ////////////// //
49 // ////////////// //
50 // Test structure //
50 // Test structure //
51 // ////////////// //
51 // ////////////// //
52
52
53 // Data series to get values bounds
53 // Data series to get values bounds
54 QTest::addColumn<std::shared_ptr<T> >("dataSeries");
54 QTest::addColumn<std::shared_ptr<T> >("dataSeries");
55
55
56 // x-axis range
56 // x-axis range
57 QTest::addColumn<double>("minXAxis");
57 QTest::addColumn<double>("minXAxis");
58 QTest::addColumn<double>("maxXAxis");
58 QTest::addColumn<double>("maxXAxis");
59
59
60 // Expected results
60 // Expected results
61 QTest::addColumn<bool>(
61 QTest::addColumn<bool>(
62 "expectedOK"); // Test is expected to be ok (i.e. method doesn't return end iterators)
62 "expectedOK"); // Test is expected to be ok (i.e. method doesn't return end iterators)
63 QTest::addColumn<double>("expectedMinValue");
63 QTest::addColumn<double>("expectedMinValue");
64 QTest::addColumn<double>("expectedMaxValue");
64 QTest::addColumn<double>("expectedMaxValue");
65 }
65 }
66
66
67 template <typename T>
67 template <typename T>
68 void testValuesBounds()
68 void testValuesBounds()
69 {
69 {
70 QFETCH(std::shared_ptr<T>, dataSeries);
70 QFETCH(std::shared_ptr<T>, dataSeries);
71 QFETCH(double, minXAxis);
71 QFETCH(double, minXAxis);
72 QFETCH(double, maxXAxis);
72 QFETCH(double, maxXAxis);
73
73
74 QFETCH(bool, expectedOK);
74 QFETCH(bool, expectedOK);
75 QFETCH(double, expectedMinValue);
75 QFETCH(double, expectedMinValue);
76 QFETCH(double, expectedMaxValue);
76 QFETCH(double, expectedMaxValue);
77
77
78 auto minMaxIts = dataSeries->valuesBounds(minXAxis, maxXAxis);
78 auto minMaxIts = dataSeries->valuesBounds(minXAxis, maxXAxis);
79 auto end = dataSeries->cend();
79 auto end = dataSeries->cend();
80
80
81 // Checks iterators with expected result
81 // Checks iterators with expected result
82 QCOMPARE(expectedOK, minMaxIts.first != end && minMaxIts.second != end);
82 QCOMPARE(expectedOK, minMaxIts.first != end && minMaxIts.second != end);
83
83
84 if (expectedOK) {
84 if (expectedOK) {
85 auto compare = [](const auto &v1, const auto &v2) {
85 auto compare = [](const auto &v1, const auto &v2) {
86 return (std::isnan(v1) && std::isnan(v2)) || v1 == v2;
86 return (std::isnan(v1) && std::isnan(v2)) || v1 == v2;
87 };
87 };
88
88
89 QVERIFY(compare(expectedMinValue, minMaxIts.first->minValue()));
89 QVERIFY(compare(expectedMinValue, minMaxIts.first->minValue()));
90 QVERIFY(compare(expectedMaxValue, minMaxIts.second->maxValue()));
90 QVERIFY(compare(expectedMaxValue, minMaxIts.second->maxValue()));
91 }
91 }
92 }
92 }
93
93
94 template <typename T>
94 template <typename T>
95 void testPurgeStructure()
95 void testPurgeStructure()
96 {
96 {
97 // ////////////// //
97 // ////////////// //
98 // Test structure //
98 // Test structure //
99 // ////////////// //
99 // ////////////// //
100
100
101 // Data series to purge
101 // Data series to purge
102 QTest::addColumn<std::shared_ptr<T> >("dataSeries");
102 QTest::addColumn<std::shared_ptr<T> >("dataSeries");
103 QTest::addColumn<double>("min");
103 QTest::addColumn<double>("min");
104 QTest::addColumn<double>("max");
104 QTest::addColumn<double>("max");
105
105
106 // Expected values after purge
106 // Expected values after purge
107 QTest::addColumn<DataContainer>("expectedXAxisData");
107 QTest::addColumn<DataContainer>("expectedXAxisData");
108 QTest::addColumn<std::vector<DataContainer> >("expectedValuesData");
108 QTest::addColumn<std::vector<DataContainer> >("expectedValuesData");
109 }
109 }
110
110
111 template <typename T>
111 template <typename T>
112 void testPurge()
112 void testPurge()
113 {
113 {
114 QFETCH(std::shared_ptr<T>, dataSeries);
114 QFETCH(std::shared_ptr<T>, dataSeries);
115 QFETCH(double, min);
115 QFETCH(double, min);
116 QFETCH(double, max);
116 QFETCH(double, max);
117
117
118 dataSeries->purge(min, max);
118 dataSeries->purge(min, max);
119
119
120 // Validates results
120 // Validates results
121 QFETCH(DataContainer, expectedXAxisData);
121 QFETCH(DataContainer, expectedXAxisData);
122 QFETCH(std::vector<DataContainer>, expectedValuesData);
122 QFETCH(std::vector<DataContainer>, expectedValuesData);
123
123
124 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData,
124 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData,
125 expectedValuesData);
125 expectedValuesData);
126 }
126 }
127
127
128 template <typename SourceType, typename DestType>
129 void testMergeDifferentTypesStructure()
130 {
131 // ////////////// //
132 // Test structure //
133 // ////////////// //
134
135 // Data series to merge
136 QTest::addColumn<std::shared_ptr<DestType> >("dest");
137 QTest::addColumn<std::shared_ptr<SourceType> >("source");
138
139 // Expected values in the dest data series after merge
140 QTest::addColumn<DataContainer>("expectedXAxisData");
141 QTest::addColumn<DataContainer>("expectedValuesData");
142 }
143
144 template <typename SourceType, typename DestType>
145 void testMergeDifferentTypes()
146 {
147 // Merges series
148 QFETCH(std::shared_ptr<SourceType>, source);
149 QFETCH(std::shared_ptr<DestType>, dest);
150
151 dest->merge(source.get());
152
153 // Validates results : we check that the merge is valid and the data series is sorted on its
154 // x-axis data
155 QFETCH(DataContainer, expectedXAxisData);
156 QFETCH(DataContainer, expectedValuesData);
157
158 validateRange(dest->cbegin(), dest->cend(), expectedXAxisData, expectedValuesData);
159 }
160
128 private slots:
161 private slots:
129
162
130 /// Input test data
163 /// Input test data
131 /// @sa testCtor()
164 /// @sa testCtor()
132 void testCtor_data();
165 void testCtor_data();
133
166
134 /// Tests construction of a data series
167 /// Tests construction of a data series
135 void testCtor();
168 void testCtor();
136
169
137 /// Input test data
170 /// Input test data
138 /// @sa testMerge()
171 /// @sa testMerge()
139 void testMerge_data();
172 void testMerge_data();
140
173
141 /// Tests merge of two data series
174 /// Tests merge of two data series
142 void testMerge();
175 void testMerge();
143
176
144 /// Input test data
177 /// Input test data
178 /// @sa testMergeVectorInScalar()
179 void testMergeVectorInScalar_data();
180
181 /// Tests merge of vector series in scalar series
182 void testMergeVectorInScalar();
183
184 /// Input test data
145 /// @sa testPurgeScalar()
185 /// @sa testPurgeScalar()
146 void testPurgeScalar_data();
186 void testPurgeScalar_data();
147
187
148 /// Tests purge of a scalar series
188 /// Tests purge of a scalar series
149 void testPurgeScalar();
189 void testPurgeScalar();
150
190
151 /// Input test data
191 /// Input test data
152 /// @sa testPurgeVector()
192 /// @sa testPurgeVector()
153 void testPurgeVector_data();
193 void testPurgeVector_data();
154
194
155 /// Tests purge of a vector series
195 /// Tests purge of a vector series
156 void testPurgeVector();
196 void testPurgeVector();
157
197
158 /// Input test data
198 /// Input test data
159 /// @sa testMinXAxisData()
199 /// @sa testMinXAxisData()
160 void testMinXAxisData_data();
200 void testMinXAxisData_data();
161
201
162 /// Tests get min x-axis data of a data series
202 /// Tests get min x-axis data of a data series
163 void testMinXAxisData();
203 void testMinXAxisData();
164
204
165 /// Input test data
205 /// Input test data
166 /// @sa testMaxXAxisData()
206 /// @sa testMaxXAxisData()
167 void testMaxXAxisData_data();
207 void testMaxXAxisData_data();
168
208
169 /// Tests get max x-axis data of a data series
209 /// Tests get max x-axis data of a data series
170 void testMaxXAxisData();
210 void testMaxXAxisData();
171
211
172 /// Input test data
212 /// Input test data
173 /// @sa testXAxisRange()
213 /// @sa testXAxisRange()
174 void testXAxisRange_data();
214 void testXAxisRange_data();
175
215
176 /// Tests get x-axis range of a data series
216 /// Tests get x-axis range of a data series
177 void testXAxisRange();
217 void testXAxisRange();
178
218
179 /// Input test data
219 /// Input test data
180 /// @sa testValuesBoundsScalar()
220 /// @sa testValuesBoundsScalar()
181 void testValuesBoundsScalar_data();
221 void testValuesBoundsScalar_data();
182
222
183 /// Tests get values bounds of a scalar series
223 /// Tests get values bounds of a scalar series
184 void testValuesBoundsScalar();
224 void testValuesBoundsScalar();
185
225
186 /// Input test data
226 /// Input test data
187 /// @sa testValuesBoundsVector()
227 /// @sa testValuesBoundsVector()
188 void testValuesBoundsVector_data();
228 void testValuesBoundsVector_data();
189
229
190 /// Tests get values bounds of a vector series
230 /// Tests get values bounds of a vector series
191 void testValuesBoundsVector();
231 void testValuesBoundsVector();
192 };
232 };
193
233
194 void TestDataSeries::testCtor_data()
234 void TestDataSeries::testCtor_data()
195 {
235 {
196 // ////////////// //
236 // ////////////// //
197 // Test structure //
237 // Test structure //
198 // ////////////// //
238 // ////////////// //
199
239
200 // x-axis data
240 // x-axis data
201 QTest::addColumn<DataContainer>("xAxisData");
241 QTest::addColumn<DataContainer>("xAxisData");
202 // values data
242 // values data
203 QTest::addColumn<DataContainer>("valuesData");
243 QTest::addColumn<DataContainer>("valuesData");
204
244
205 // expected x-axis data
245 // expected x-axis data
206 QTest::addColumn<DataContainer>("expectedXAxisData");
246 QTest::addColumn<DataContainer>("expectedXAxisData");
207 // expected values data
247 // expected values data
208 QTest::addColumn<DataContainer>("expectedValuesData");
248 QTest::addColumn<DataContainer>("expectedValuesData");
209
249
210 // ////////// //
250 // ////////// //
211 // Test cases //
251 // Test cases //
212 // ////////// //
252 // ////////// //
213
253
214 QTest::newRow("invalidData (different sizes of vectors)")
254 QTest::newRow("invalidData (different sizes of vectors)")
215 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << DataContainer{}
255 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << DataContainer{}
216 << DataContainer{};
256 << DataContainer{};
217
257
218 QTest::newRow("sortedData") << DataContainer{1., 2., 3., 4., 5.}
258 QTest::newRow("sortedData") << DataContainer{1., 2., 3., 4., 5.}
219 << DataContainer{100., 200., 300., 400., 500.}
259 << DataContainer{100., 200., 300., 400., 500.}
220 << DataContainer{1., 2., 3., 4., 5.}
260 << DataContainer{1., 2., 3., 4., 5.}
221 << DataContainer{100., 200., 300., 400., 500.};
261 << DataContainer{100., 200., 300., 400., 500.};
222
262
223 QTest::newRow("unsortedData") << DataContainer{5., 4., 3., 2., 1.}
263 QTest::newRow("unsortedData") << DataContainer{5., 4., 3., 2., 1.}
224 << DataContainer{100., 200., 300., 400., 500.}
264 << DataContainer{100., 200., 300., 400., 500.}
225 << DataContainer{1., 2., 3., 4., 5.}
265 << DataContainer{1., 2., 3., 4., 5.}
226 << DataContainer{500., 400., 300., 200., 100.};
266 << DataContainer{500., 400., 300., 200., 100.};
227
267
228 QTest::newRow("unsortedData2")
268 QTest::newRow("unsortedData2")
229 << DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.}
269 << DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.}
230 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.};
270 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.};
231 }
271 }
232
272
233 void TestDataSeries::testCtor()
273 void TestDataSeries::testCtor()
234 {
274 {
235 // Creates series
275 // Creates series
236 QFETCH(DataContainer, xAxisData);
276 QFETCH(DataContainer, xAxisData);
237 QFETCH(DataContainer, valuesData);
277 QFETCH(DataContainer, valuesData);
238
278
239 auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
279 auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
240 Unit{}, Unit{});
280 Unit{}, Unit{});
241
281
242 // Validates results : we check that the data series is sorted on its x-axis data
282 // Validates results : we check that the data series is sorted on its x-axis data
243 QFETCH(DataContainer, expectedXAxisData);
283 QFETCH(DataContainer, expectedXAxisData);
244 QFETCH(DataContainer, expectedValuesData);
284 QFETCH(DataContainer, expectedValuesData);
245
285
246 validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData);
286 validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData);
247 }
287 }
248
288
249 namespace {
289 namespace {
250
290
251 std::shared_ptr<ScalarSeries> createScalarSeries(DataContainer xAxisData, DataContainer valuesData)
291 std::shared_ptr<ScalarSeries> createScalarSeries(DataContainer xAxisData, DataContainer valuesData)
252 {
292 {
253 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
293 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
254 Unit{});
294 Unit{});
255 }
295 }
256
296
257 std::shared_ptr<VectorSeries> createVectorSeries(DataContainer xAxisData, DataContainer xValuesData,
297 std::shared_ptr<VectorSeries> createVectorSeries(DataContainer xAxisData, DataContainer xValuesData,
258 DataContainer yValuesData,
298 DataContainer yValuesData,
259 DataContainer zValuesData)
299 DataContainer zValuesData)
260 {
300 {
261 return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(xValuesData),
301 return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(xValuesData),
262 std::move(yValuesData), std::move(zValuesData), Unit{},
302 std::move(yValuesData), std::move(zValuesData), Unit{},
263 Unit{});
303 Unit{});
264 }
304 }
265
305
266 } // namespace
306 } // namespace
267
307
268 void TestDataSeries::testMerge_data()
308 void TestDataSeries::testMerge_data()
269 {
309 {
270 // ////////////// //
310 // ////////////// //
271 // Test structure //
311 // Test structure //
272 // ////////////// //
312 // ////////////// //
273
313
274 // Data series to merge
314 // Data series to merge
275 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
315 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
276 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries2");
316 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries2");
277
317
278 // Expected values in the first data series after merge
318 // Expected values in the first data series after merge
279 QTest::addColumn<DataContainer>("expectedXAxisData");
319 QTest::addColumn<DataContainer>("expectedXAxisData");
280 QTest::addColumn<DataContainer>("expectedValuesData");
320 QTest::addColumn<DataContainer>("expectedValuesData");
281
321
282 // ////////// //
322 // ////////// //
283 // Test cases //
323 // Test cases //
284 // ////////// //
324 // ////////// //
285
325
286 QTest::newRow("sortedMerge")
326 QTest::newRow("sortedMerge")
287 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
327 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
288 << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
328 << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
289 << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
329 << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
290 << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
330 << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
291
331
292 QTest::newRow("unsortedMerge")
332 QTest::newRow("unsortedMerge")
293 << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
333 << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
294 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
334 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
295 << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
335 << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
296 << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
336 << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
297
337
298 QTest::newRow("unsortedMerge2 (merge not made because source is in the bounds of dest)")
338 QTest::newRow("unsortedMerge2 (merge not made because source is in the bounds of dest)")
299 << createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 800., 900., 1000.})
339 << createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 800., 900., 1000.})
300 << createScalarSeries({3., 4., 5., 6., 7.}, {300., 400., 500., 600., 700.})
340 << createScalarSeries({3., 4., 5., 6., 7.}, {300., 400., 500., 600., 700.})
301 << DataContainer{1., 2., 8., 9., 10.} << DataContainer{100., 200., 800., 900., 1000.};
341 << DataContainer{1., 2., 8., 9., 10.} << DataContainer{100., 200., 800., 900., 1000.};
302
342
303 QTest::newRow("unsortedMerge3")
343 QTest::newRow("unsortedMerge3")
304 << createScalarSeries({3., 4., 5., 7., 8}, {300., 400., 500., 700., 800.})
344 << createScalarSeries({3., 4., 5., 7., 8}, {300., 400., 500., 700., 800.})
305 << createScalarSeries({1., 2., 3., 7., 10.}, {100., 200., 333., 777., 1000.})
345 << createScalarSeries({1., 2., 3., 7., 10.}, {100., 200., 333., 777., 1000.})
306 << DataContainer{1., 2., 3., 4., 5., 7., 8., 10.}
346 << DataContainer{1., 2., 3., 4., 5., 7., 8., 10.}
307 << DataContainer{100., 200., 300., 400., 500., 700., 800., 1000.};
347 << DataContainer{100., 200., 300., 400., 500., 700., 800., 1000.};
308 }
348 }
309
349
310 void TestDataSeries::testMerge()
350 void TestDataSeries::testMerge()
311 {
351 {
312 // Merges series
352 // Merges series
313 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
353 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
314 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries2);
354 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries2);
315
355
316 dataSeries->merge(dataSeries2.get());
356 dataSeries->merge(dataSeries2.get());
317
357
318 // Validates results : we check that the merge is valid and the data series is sorted on its
358 // Validates results : we check that the merge is valid and the data series is sorted on its
319 // x-axis data
359 // x-axis data
320 QFETCH(DataContainer, expectedXAxisData);
360 QFETCH(DataContainer, expectedXAxisData);
321 QFETCH(DataContainer, expectedValuesData);
361 QFETCH(DataContainer, expectedValuesData);
322
362
323 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, expectedValuesData);
363 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, expectedValuesData);
324 }
364 }
325
365
366 void TestDataSeries::testMergeVectorInScalar_data()
367 {
368 testMergeDifferentTypesStructure<VectorSeries, ScalarSeries>();
369
370 // ////////// //
371 // Test cases //
372 // ////////// //
373
374 QTest::newRow("purgeVectorInScalar")
375 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
376 << createVectorSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.},
377 {610., 710., 810., 910., 1010.}, {620., 720., 820., 920., 1020.})
378 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300., 400., 500.};
379 }
380
381 void TestDataSeries::testMergeVectorInScalar()
382 {
383 testMergeDifferentTypes<VectorSeries, ScalarSeries>();
384 }
385
326 void TestDataSeries::testPurgeScalar_data()
386 void TestDataSeries::testPurgeScalar_data()
327 {
387 {
328 testPurgeStructure<ScalarSeries>();
388 testPurgeStructure<ScalarSeries>();
329
389
330 // ////////// //
390 // ////////// //
331 // Test cases //
391 // Test cases //
332 // ////////// //
392 // ////////// //
333
393
334 QTest::newRow("purgeScalar") << createScalarSeries({1., 2., 3., 4., 5.},
394 QTest::newRow("purgeScalar") << createScalarSeries({1., 2., 3., 4., 5.},
335 {100., 200., 300., 400., 500.})
395 {100., 200., 300., 400., 500.})
336 << 2. << 4. << DataContainer{2., 3., 4.}
396 << 2. << 4. << DataContainer{2., 3., 4.}
337 << std::vector<DataContainer>{{200., 300., 400.}};
397 << std::vector<DataContainer>{{200., 300., 400.}};
338 QTest::newRow("purgeScalar1 (min/max swap)")
398 QTest::newRow("purgeScalar1 (min/max swap)")
339 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 4. << 2.
399 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 4. << 2.
340 << DataContainer{2., 3., 4.} << std::vector<DataContainer>{{200., 300., 400.}};
400 << DataContainer{2., 3., 4.} << std::vector<DataContainer>{{200., 300., 400.}};
341 QTest::newRow("purgeScalar2") << createScalarSeries({1., 2., 3., 4., 5.},
401 QTest::newRow("purgeScalar2") << createScalarSeries({1., 2., 3., 4., 5.},
342 {100., 200., 300., 400., 500.})
402 {100., 200., 300., 400., 500.})
343 << 0. << 2.5 << DataContainer{1., 2.}
403 << 0. << 2.5 << DataContainer{1., 2.}
344 << std::vector<DataContainer>{{100., 200.}};
404 << std::vector<DataContainer>{{100., 200.}};
345 QTest::newRow("purgeScalar3") << createScalarSeries({1., 2., 3., 4., 5.},
405 QTest::newRow("purgeScalar3") << createScalarSeries({1., 2., 3., 4., 5.},
346 {100., 200., 300., 400., 500.})
406 {100., 200., 300., 400., 500.})
347 << 3.5 << 7. << DataContainer{4., 5.}
407 << 3.5 << 7. << DataContainer{4., 5.}
348 << std::vector<DataContainer>{{400., 500.}};
408 << std::vector<DataContainer>{{400., 500.}};
349 QTest::newRow("purgeScalar4") << createScalarSeries({1., 2., 3., 4., 5.},
409 QTest::newRow("purgeScalar4") << createScalarSeries({1., 2., 3., 4., 5.},
350 {100., 200., 300., 400., 500.})
410 {100., 200., 300., 400., 500.})
351 << 0. << 7. << DataContainer{1., 2., 3., 4., 5.}
411 << 0. << 7. << DataContainer{1., 2., 3., 4., 5.}
352 << std::vector<DataContainer>{{100., 200., 300., 400., 500.}};
412 << std::vector<DataContainer>{{100., 200., 300., 400., 500.}};
353 QTest::newRow("purgeScalar5") << createScalarSeries({1., 2., 3., 4., 5.},
413 QTest::newRow("purgeScalar5") << createScalarSeries({1., 2., 3., 4., 5.},
354 {100., 200., 300., 400., 500.})
414 {100., 200., 300., 400., 500.})
355 << 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}};
415 << 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}};
356 }
416 }
357
417
358 void TestDataSeries::testPurgeScalar()
418 void TestDataSeries::testPurgeScalar()
359 {
419 {
360 testPurge<ScalarSeries>();
420 testPurge<ScalarSeries>();
361 }
421 }
362
422
363 void TestDataSeries::testPurgeVector_data()
423 void TestDataSeries::testPurgeVector_data()
364 {
424 {
365 testPurgeStructure<VectorSeries>();
425 testPurgeStructure<VectorSeries>();
366
426
367 // ////////// //
427 // ////////// //
368 // Test cases //
428 // Test cases //
369 // ////////// //
429 // ////////// //
370
430
371 QTest::newRow("purgeVector") << createVectorSeries({1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.},
431 QTest::newRow("purgeVector") << createVectorSeries({1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.},
372 {11., 12., 13., 14., 15.},
432 {11., 12., 13., 14., 15.},
373 {16., 17., 18., 19., 20.})
433 {16., 17., 18., 19., 20.})
374 << 2. << 4. << DataContainer{2., 3., 4.}
434 << 2. << 4. << DataContainer{2., 3., 4.}
375 << std::vector<DataContainer>{
435 << std::vector<DataContainer>{
376 {7., 8., 9.}, {12., 13., 14.}, {17., 18., 19.}};
436 {7., 8., 9.}, {12., 13., 14.}, {17., 18., 19.}};
377 }
437 }
378
438
379 void TestDataSeries::testPurgeVector()
439 void TestDataSeries::testPurgeVector()
380 {
440 {
381 testPurge<VectorSeries>();
441 testPurge<VectorSeries>();
382 }
442 }
383
443
384 void TestDataSeries::testMinXAxisData_data()
444 void TestDataSeries::testMinXAxisData_data()
385 {
445 {
386 // ////////////// //
446 // ////////////// //
387 // Test structure //
447 // Test structure //
388 // ////////////// //
448 // ////////////// //
389
449
390 // Data series to get min data
450 // Data series to get min data
391 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
451 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
392
452
393 // Min data
453 // Min data
394 QTest::addColumn<double>("min");
454 QTest::addColumn<double>("min");
395
455
396 // Expected results
456 // Expected results
397 QTest::addColumn<bool>(
457 QTest::addColumn<bool>(
398 "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
458 "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
399 QTest::addColumn<double>(
459 QTest::addColumn<double>(
400 "expectedMin"); // Expected value when method doesn't return end iterator
460 "expectedMin"); // Expected value when method doesn't return end iterator
401
461
402 // ////////// //
462 // ////////// //
403 // Test cases //
463 // Test cases //
404 // ////////// //
464 // ////////// //
405
465
406 QTest::newRow("minData1") << createScalarSeries({1., 2., 3., 4., 5.},
466 QTest::newRow("minData1") << createScalarSeries({1., 2., 3., 4., 5.},
407 {100., 200., 300., 400., 500.})
467 {100., 200., 300., 400., 500.})
408 << 0. << true << 1.;
468 << 0. << true << 1.;
409 QTest::newRow("minData2") << createScalarSeries({1., 2., 3., 4., 5.},
469 QTest::newRow("minData2") << createScalarSeries({1., 2., 3., 4., 5.},
410 {100., 200., 300., 400., 500.})
470 {100., 200., 300., 400., 500.})
411 << 1. << true << 1.;
471 << 1. << true << 1.;
412 QTest::newRow("minData3") << createScalarSeries({1., 2., 3., 4., 5.},
472 QTest::newRow("minData3") << createScalarSeries({1., 2., 3., 4., 5.},
413 {100., 200., 300., 400., 500.})
473 {100., 200., 300., 400., 500.})
414 << 1.1 << true << 2.;
474 << 1.1 << true << 2.;
415 QTest::newRow("minData4") << createScalarSeries({1., 2., 3., 4., 5.},
475 QTest::newRow("minData4") << createScalarSeries({1., 2., 3., 4., 5.},
416 {100., 200., 300., 400., 500.})
476 {100., 200., 300., 400., 500.})
417 << 5. << true << 5.;
477 << 5. << true << 5.;
418 QTest::newRow("minData5") << createScalarSeries({1., 2., 3., 4., 5.},
478 QTest::newRow("minData5") << createScalarSeries({1., 2., 3., 4., 5.},
419 {100., 200., 300., 400., 500.})
479 {100., 200., 300., 400., 500.})
420 << 5.1 << false << std::numeric_limits<double>::quiet_NaN();
480 << 5.1 << false << std::numeric_limits<double>::quiet_NaN();
421 QTest::newRow("minData6") << createScalarSeries({}, {}) << 1.1 << false
481 QTest::newRow("minData6") << createScalarSeries({}, {}) << 1.1 << false
422 << std::numeric_limits<double>::quiet_NaN();
482 << std::numeric_limits<double>::quiet_NaN();
423 }
483 }
424
484
425 void TestDataSeries::testMinXAxisData()
485 void TestDataSeries::testMinXAxisData()
426 {
486 {
427 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
487 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
428 QFETCH(double, min);
488 QFETCH(double, min);
429
489
430 QFETCH(bool, expectedOK);
490 QFETCH(bool, expectedOK);
431 QFETCH(double, expectedMin);
491 QFETCH(double, expectedMin);
432
492
433 auto it = dataSeries->minXAxisData(min);
493 auto it = dataSeries->minXAxisData(min);
434
494
435 QCOMPARE(expectedOK, it != dataSeries->cend());
495 QCOMPARE(expectedOK, it != dataSeries->cend());
436
496
437 // If the method doesn't return a end iterator, checks with expected value
497 // If the method doesn't return a end iterator, checks with expected value
438 if (expectedOK) {
498 if (expectedOK) {
439 QCOMPARE(expectedMin, it->x());
499 QCOMPARE(expectedMin, it->x());
440 }
500 }
441 }
501 }
442
502
443 void TestDataSeries::testMaxXAxisData_data()
503 void TestDataSeries::testMaxXAxisData_data()
444 {
504 {
445 // ////////////// //
505 // ////////////// //
446 // Test structure //
506 // Test structure //
447 // ////////////// //
507 // ////////////// //
448
508
449 // Data series to get max data
509 // Data series to get max data
450 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
510 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
451
511
452 // Max data
512 // Max data
453 QTest::addColumn<double>("max");
513 QTest::addColumn<double>("max");
454
514
455 // Expected results
515 // Expected results
456 QTest::addColumn<bool>(
516 QTest::addColumn<bool>(
457 "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
517 "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
458 QTest::addColumn<double>(
518 QTest::addColumn<double>(
459 "expectedMax"); // Expected value when method doesn't return end iterator
519 "expectedMax"); // Expected value when method doesn't return end iterator
460
520
461 // ////////// //
521 // ////////// //
462 // Test cases //
522 // Test cases //
463 // ////////// //
523 // ////////// //
464
524
465 QTest::newRow("maxData1") << createScalarSeries({1., 2., 3., 4., 5.},
525 QTest::newRow("maxData1") << createScalarSeries({1., 2., 3., 4., 5.},
466 {100., 200., 300., 400., 500.})
526 {100., 200., 300., 400., 500.})
467 << 6. << true << 5.;
527 << 6. << true << 5.;
468 QTest::newRow("maxData2") << createScalarSeries({1., 2., 3., 4., 5.},
528 QTest::newRow("maxData2") << createScalarSeries({1., 2., 3., 4., 5.},
469 {100., 200., 300., 400., 500.})
529 {100., 200., 300., 400., 500.})
470 << 5. << true << 5.;
530 << 5. << true << 5.;
471 QTest::newRow("maxData3") << createScalarSeries({1., 2., 3., 4., 5.},
531 QTest::newRow("maxData3") << createScalarSeries({1., 2., 3., 4., 5.},
472 {100., 200., 300., 400., 500.})
532 {100., 200., 300., 400., 500.})
473 << 4.9 << true << 4.;
533 << 4.9 << true << 4.;
474 QTest::newRow("maxData4") << createScalarSeries({1., 2., 3., 4., 5.},
534 QTest::newRow("maxData4") << createScalarSeries({1., 2., 3., 4., 5.},
475 {100., 200., 300., 400., 500.})
535 {100., 200., 300., 400., 500.})
476 << 1.1 << true << 1.;
536 << 1.1 << true << 1.;
477 QTest::newRow("maxData5") << createScalarSeries({1., 2., 3., 4., 5.},
537 QTest::newRow("maxData5") << createScalarSeries({1., 2., 3., 4., 5.},
478 {100., 200., 300., 400., 500.})
538 {100., 200., 300., 400., 500.})
479 << 1. << true << 1.;
539 << 1. << true << 1.;
480 QTest::newRow("maxData6") << createScalarSeries({}, {}) << 1.1 << false
540 QTest::newRow("maxData6") << createScalarSeries({}, {}) << 1.1 << false
481 << std::numeric_limits<double>::quiet_NaN();
541 << std::numeric_limits<double>::quiet_NaN();
482 }
542 }
483
543
484 void TestDataSeries::testMaxXAxisData()
544 void TestDataSeries::testMaxXAxisData()
485 {
545 {
486 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
546 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
487 QFETCH(double, max);
547 QFETCH(double, max);
488
548
489 QFETCH(bool, expectedOK);
549 QFETCH(bool, expectedOK);
490 QFETCH(double, expectedMax);
550 QFETCH(double, expectedMax);
491
551
492 auto it = dataSeries->maxXAxisData(max);
552 auto it = dataSeries->maxXAxisData(max);
493
553
494 QCOMPARE(expectedOK, it != dataSeries->cend());
554 QCOMPARE(expectedOK, it != dataSeries->cend());
495
555
496 // If the method doesn't return a end iterator, checks with expected value
556 // If the method doesn't return a end iterator, checks with expected value
497 if (expectedOK) {
557 if (expectedOK) {
498 QCOMPARE(expectedMax, it->x());
558 QCOMPARE(expectedMax, it->x());
499 }
559 }
500 }
560 }
501
561
502 void TestDataSeries::testXAxisRange_data()
562 void TestDataSeries::testXAxisRange_data()
503 {
563 {
504 // ////////////// //
564 // ////////////// //
505 // Test structure //
565 // Test structure //
506 // ////////////// //
566 // ////////////// //
507
567
508 // Data series to get x-axis range
568 // Data series to get x-axis range
509 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
569 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
510
570
511 // Min/max values
571 // Min/max values
512 QTest::addColumn<double>("min");
572 QTest::addColumn<double>("min");
513 QTest::addColumn<double>("max");
573 QTest::addColumn<double>("max");
514
574
515 // Expected values
575 // Expected values
516 QTest::addColumn<DataContainer>("expectedXAxisData");
576 QTest::addColumn<DataContainer>("expectedXAxisData");
517 QTest::addColumn<DataContainer>("expectedValuesData");
577 QTest::addColumn<DataContainer>("expectedValuesData");
518
578
519 // ////////// //
579 // ////////// //
520 // Test cases //
580 // Test cases //
521 // ////////// //
581 // ////////// //
522
582
523 QTest::newRow("xAxisRange") << createScalarSeries({1., 2., 3., 4., 5.},
583 QTest::newRow("xAxisRange") << createScalarSeries({1., 2., 3., 4., 5.},
524 {100., 200., 300., 400., 500.})
584 {100., 200., 300., 400., 500.})
525 << -1. << 3.2 << DataContainer{1., 2., 3.}
585 << -1. << 3.2 << DataContainer{1., 2., 3.}
526 << DataContainer{100., 200., 300.};
586 << DataContainer{100., 200., 300.};
527 QTest::newRow("xAxisRange1 (min/max swap)")
587 QTest::newRow("xAxisRange1 (min/max swap)")
528 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 3.2 << -1.
588 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 3.2 << -1.
529 << DataContainer{1., 2., 3.} << DataContainer{100., 200., 300.};
589 << DataContainer{1., 2., 3.} << DataContainer{100., 200., 300.};
530 QTest::newRow("xAxisRange2") << createScalarSeries({1., 2., 3., 4., 5.},
590 QTest::newRow("xAxisRange2") << createScalarSeries({1., 2., 3., 4., 5.},
531 {100., 200., 300., 400., 500.})
591 {100., 200., 300., 400., 500.})
532 << 1. << 4. << DataContainer{1., 2., 3., 4.}
592 << 1. << 4. << DataContainer{1., 2., 3., 4.}
533 << DataContainer{100., 200., 300., 400.};
593 << DataContainer{100., 200., 300., 400.};
534 QTest::newRow("xAxisRange3") << createScalarSeries({1., 2., 3., 4., 5.},
594 QTest::newRow("xAxisRange3") << createScalarSeries({1., 2., 3., 4., 5.},
535 {100., 200., 300., 400., 500.})
595 {100., 200., 300., 400., 500.})
536 << 1. << 3.9 << DataContainer{1., 2., 3.}
596 << 1. << 3.9 << DataContainer{1., 2., 3.}
537 << DataContainer{100., 200., 300.};
597 << DataContainer{100., 200., 300.};
538 QTest::newRow("xAxisRange4") << createScalarSeries({1., 2., 3., 4., 5.},
598 QTest::newRow("xAxisRange4") << createScalarSeries({1., 2., 3., 4., 5.},
539 {100., 200., 300., 400., 500.})
599 {100., 200., 300., 400., 500.})
540 << 0. << 0.9 << DataContainer{} << DataContainer{};
600 << 0. << 0.9 << DataContainer{} << DataContainer{};
541 QTest::newRow("xAxisRange5") << createScalarSeries({1., 2., 3., 4., 5.},
601 QTest::newRow("xAxisRange5") << createScalarSeries({1., 2., 3., 4., 5.},
542 {100., 200., 300., 400., 500.})
602 {100., 200., 300., 400., 500.})
543 << 0. << 1. << DataContainer{1.} << DataContainer{100.};
603 << 0. << 1. << DataContainer{1.} << DataContainer{100.};
544 QTest::newRow("xAxisRange6") << createScalarSeries({1., 2., 3., 4., 5.},
604 QTest::newRow("xAxisRange6") << createScalarSeries({1., 2., 3., 4., 5.},
545 {100., 200., 300., 400., 500.})
605 {100., 200., 300., 400., 500.})
546 << 2.1 << 6. << DataContainer{3., 4., 5.}
606 << 2.1 << 6. << DataContainer{3., 4., 5.}
547 << DataContainer{300., 400., 500.};
607 << DataContainer{300., 400., 500.};
548 QTest::newRow("xAxisRange7") << createScalarSeries({1., 2., 3., 4., 5.},
608 QTest::newRow("xAxisRange7") << createScalarSeries({1., 2., 3., 4., 5.},
549 {100., 200., 300., 400., 500.})
609 {100., 200., 300., 400., 500.})
550 << 6. << 9. << DataContainer{} << DataContainer{};
610 << 6. << 9. << DataContainer{} << DataContainer{};
551 QTest::newRow("xAxisRange8") << createScalarSeries({1., 2., 3., 4., 5.},
611 QTest::newRow("xAxisRange8") << createScalarSeries({1., 2., 3., 4., 5.},
552 {100., 200., 300., 400., 500.})
612 {100., 200., 300., 400., 500.})
553 << 5. << 9. << DataContainer{5.} << DataContainer{500.};
613 << 5. << 9. << DataContainer{5.} << DataContainer{500.};
554 }
614 }
555
615
556 void TestDataSeries::testXAxisRange()
616 void TestDataSeries::testXAxisRange()
557 {
617 {
558 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
618 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
559 QFETCH(double, min);
619 QFETCH(double, min);
560 QFETCH(double, max);
620 QFETCH(double, max);
561
621
562 QFETCH(DataContainer, expectedXAxisData);
622 QFETCH(DataContainer, expectedXAxisData);
563 QFETCH(DataContainer, expectedValuesData);
623 QFETCH(DataContainer, expectedValuesData);
564
624
565 auto bounds = dataSeries->xAxisRange(min, max);
625 auto bounds = dataSeries->xAxisRange(min, max);
566 validateRange(bounds.first, bounds.second, expectedXAxisData, expectedValuesData);
626 validateRange(bounds.first, bounds.second, expectedXAxisData, expectedValuesData);
567 }
627 }
568
628
569 void TestDataSeries::testValuesBoundsScalar_data()
629 void TestDataSeries::testValuesBoundsScalar_data()
570 {
630 {
571 testValuesBoundsStructure<ScalarSeries>();
631 testValuesBoundsStructure<ScalarSeries>();
572
632
573 // ////////// //
633 // ////////// //
574 // Test cases //
634 // Test cases //
575 // ////////// //
635 // ////////// //
576 auto nan = std::numeric_limits<double>::quiet_NaN();
636 auto nan = std::numeric_limits<double>::quiet_NaN();
577
637
578 QTest::newRow("scalarBounds1")
638 QTest::newRow("scalarBounds1")
579 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 6.
639 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 6.
580 << true << 100. << 500.;
640 << true << 100. << 500.;
581 QTest::newRow("scalarBounds2")
641 QTest::newRow("scalarBounds2")
582 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 2. << 4.
642 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 2. << 4.
583 << true << 200. << 400.;
643 << true << 200. << 400.;
584 QTest::newRow("scalarBounds3")
644 QTest::newRow("scalarBounds3")
585 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 0.5
645 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 0.5
586 << false << nan << nan;
646 << false << nan << nan;
587 QTest::newRow("scalarBounds4")
647 QTest::newRow("scalarBounds4")
588 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 5.1 << 6.
648 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 5.1 << 6.
589 << false << nan << nan;
649 << false << nan << nan;
590 QTest::newRow("scalarBounds5")
650 QTest::newRow("scalarBounds5")
591 << createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100. << 100.;
651 << createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100. << 100.;
592 QTest::newRow("scalarBounds6") << createScalarSeries({}, {}) << 0. << 2. << false << nan << nan;
652 QTest::newRow("scalarBounds6") << createScalarSeries({}, {}) << 0. << 2. << false << nan << nan;
593
653
594 // Tests with NaN values: NaN values are not included in min/max search
654 // Tests with NaN values: NaN values are not included in min/max search
595 QTest::newRow("scalarBounds7")
655 QTest::newRow("scalarBounds7")
596 << createScalarSeries({1., 2., 3., 4., 5.}, {nan, 200., 300., 400., nan}) << 0. << 6.
656 << createScalarSeries({1., 2., 3., 4., 5.}, {nan, 200., 300., 400., nan}) << 0. << 6.
597 << true << 200. << 400.;
657 << true << 200. << 400.;
598 QTest::newRow("scalarBounds8")
658 QTest::newRow("scalarBounds8")
599 << createScalarSeries({1., 2., 3., 4., 5.}, {nan, nan, nan, nan, nan}) << 0. << 6. << true
659 << createScalarSeries({1., 2., 3., 4., 5.}, {nan, nan, nan, nan, nan}) << 0. << 6. << true
600 << std::numeric_limits<double>::quiet_NaN() << std::numeric_limits<double>::quiet_NaN();
660 << std::numeric_limits<double>::quiet_NaN() << std::numeric_limits<double>::quiet_NaN();
601 }
661 }
602
662
603 void TestDataSeries::testValuesBoundsScalar()
663 void TestDataSeries::testValuesBoundsScalar()
604 {
664 {
605 testValuesBounds<ScalarSeries>();
665 testValuesBounds<ScalarSeries>();
606 }
666 }
607
667
608 void TestDataSeries::testValuesBoundsVector_data()
668 void TestDataSeries::testValuesBoundsVector_data()
609 {
669 {
610 testValuesBoundsStructure<VectorSeries>();
670 testValuesBoundsStructure<VectorSeries>();
611
671
612 // ////////// //
672 // ////////// //
613 // Test cases //
673 // Test cases //
614 // ////////// //
674 // ////////// //
615 auto nan = std::numeric_limits<double>::quiet_NaN();
675 auto nan = std::numeric_limits<double>::quiet_NaN();
616
676
617 QTest::newRow("vectorBounds1")
677 QTest::newRow("vectorBounds1")
618 << createVectorSeries({1., 2., 3., 4., 5.}, {10., 15., 20., 13., 12.},
678 << createVectorSeries({1., 2., 3., 4., 5.}, {10., 15., 20., 13., 12.},
619 {35., 24., 10., 9., 0.3}, {13., 14., 12., 9., 24.})
679 {35., 24., 10., 9., 0.3}, {13., 14., 12., 9., 24.})
620 << 0. << 6. << true << 0.3 << 35.; // min/max in same component
680 << 0. << 6. << true << 0.3 << 35.; // min/max in same component
621 QTest::newRow("vectorBounds2")
681 QTest::newRow("vectorBounds2")
622 << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
682 << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
623 {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
683 {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
624 << 0. << 6. << true << 2.3 << 35.; // min/max in same entry
684 << 0. << 6. << true << 2.3 << 35.; // min/max in same entry
625 QTest::newRow("vectorBounds3")
685 QTest::newRow("vectorBounds3")
626 << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
686 << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
627 {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
687 {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
628 << 2. << 3. << true << 10. << 24.;
688 << 2. << 3. << true << 10. << 24.;
629
689
630 // Tests with NaN values: NaN values are not included in min/max search
690 // Tests with NaN values: NaN values are not included in min/max search
631 QTest::newRow("vectorBounds4")
691 QTest::newRow("vectorBounds4")
632 << createVectorSeries({1., 2.}, {nan, nan}, {nan, nan}, {nan, nan}) << 0. << 6. << true
692 << createVectorSeries({1., 2.}, {nan, nan}, {nan, nan}, {nan, nan}) << 0. << 6. << true
633 << nan << nan;
693 << nan << nan;
634 }
694 }
635
695
636 void TestDataSeries::testValuesBoundsVector()
696 void TestDataSeries::testValuesBoundsVector()
637 {
697 {
638 testValuesBounds<VectorSeries>();
698 testValuesBounds<VectorSeries>();
639 }
699 }
640
700
641 QTEST_MAIN(TestDataSeries)
701 QTEST_MAIN(TestDataSeries)
642 #include "TestDataSeries.moc"
702 #include "TestDataSeries.moc"
General Comments 0
You need to be logged in to leave comments. Login now