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