##// END OF EJS Templates
HG_REPOSITORIES » LPP » SciQLOP_Repos » SciQLop
RSS
Completes DataSeries::purge() and DataSeries::xAxisRange() tests
Alexandre Leroux -
r797:732e5c633f67
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,636 +1,642
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 private slots:
129 129
130 130 /// Input test data
131 131 /// @sa testCtor()
132 132 void testCtor_data();
133 133
134 134 /// Tests construction of a data series
135 135 void testCtor();
136 136
137 137 /// Input test data
138 138 /// @sa testMerge()
139 139 void testMerge_data();
140 140
141 141 /// Tests merge of two data series
142 142 void testMerge();
143 143
144 144 /// Input test data
145 145 /// @sa testPurgeScalar()
146 146 void testPurgeScalar_data();
147 147
148 148 /// Tests purge of a scalar series
149 149 void testPurgeScalar();
150 150
151 151 /// Input test data
152 152 /// @sa testPurgeVector()
153 153 void testPurgeVector_data();
154 154
155 155 /// Tests purge of a vector series
156 156 void testPurgeVector();
157 157
158 158 /// Input test data
159 159 /// @sa testMinXAxisData()
160 160 void testMinXAxisData_data();
161 161
162 162 /// Tests get min x-axis data of a data series
163 163 void testMinXAxisData();
164 164
165 165 /// Input test data
166 166 /// @sa testMaxXAxisData()
167 167 void testMaxXAxisData_data();
168 168
169 169 /// Tests get max x-axis data of a data series
170 170 void testMaxXAxisData();
171 171
172 172 /// Input test data
173 173 /// @sa testXAxisRange()
174 174 void testXAxisRange_data();
175 175
176 176 /// Tests get x-axis range of a data series
177 177 void testXAxisRange();
178 178
179 179 /// Input test data
180 180 /// @sa testValuesBoundsScalar()
181 181 void testValuesBoundsScalar_data();
182 182
183 183 /// Tests get values bounds of a scalar series
184 184 void testValuesBoundsScalar();
185 185
186 186 /// Input test data
187 187 /// @sa testValuesBoundsVector()
188 188 void testValuesBoundsVector_data();
189 189
190 190 /// Tests get values bounds of a vector series
191 191 void testValuesBoundsVector();
192 192 };
193 193
194 194 void TestDataSeries::testCtor_data()
195 195 {
196 196 // ////////////// //
197 197 // Test structure //
198 198 // ////////////// //
199 199
200 200 // x-axis data
201 201 QTest::addColumn<DataContainer>("xAxisData");
202 202 // values data
203 203 QTest::addColumn<DataContainer>("valuesData");
204 204
205 205 // expected x-axis data
206 206 QTest::addColumn<DataContainer>("expectedXAxisData");
207 207 // expected values data
208 208 QTest::addColumn<DataContainer>("expectedValuesData");
209 209
210 210 // ////////// //
211 211 // Test cases //
212 212 // ////////// //
213 213
214 214 QTest::newRow("invalidData (different sizes of vectors)")
215 215 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << DataContainer{}
216 216 << DataContainer{};
217 217
218 218 QTest::newRow("sortedData") << DataContainer{1., 2., 3., 4., 5.}
219 219 << DataContainer{100., 200., 300., 400., 500.}
220 220 << DataContainer{1., 2., 3., 4., 5.}
221 221 << DataContainer{100., 200., 300., 400., 500.};
222 222
223 223 QTest::newRow("unsortedData") << DataContainer{5., 4., 3., 2., 1.}
224 224 << DataContainer{100., 200., 300., 400., 500.}
225 225 << DataContainer{1., 2., 3., 4., 5.}
226 226 << DataContainer{500., 400., 300., 200., 100.};
227 227
228 228 QTest::newRow("unsortedData2")
229 229 << DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.}
230 230 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.};
231 231 }
232 232
233 233 void TestDataSeries::testCtor()
234 234 {
235 235 // Creates series
236 236 QFETCH(DataContainer, xAxisData);
237 237 QFETCH(DataContainer, valuesData);
238 238
239 239 auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
240 240 Unit{}, Unit{});
241 241
242 242 // Validates results : we check that the data series is sorted on its x-axis data
243 243 QFETCH(DataContainer, expectedXAxisData);
244 244 QFETCH(DataContainer, expectedValuesData);
245 245
246 246 validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData);
247 247 }
248 248
249 249 namespace {
250 250
251 251 std::shared_ptr<ScalarSeries> createScalarSeries(DataContainer xAxisData, DataContainer valuesData)
252 252 {
253 253 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
254 254 Unit{});
255 255 }
256 256
257 257 std::shared_ptr<VectorSeries> createVectorSeries(DataContainer xAxisData, DataContainer xValuesData,
258 258 DataContainer yValuesData,
259 259 DataContainer zValuesData)
260 260 {
261 261 return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(xValuesData),
262 262 std::move(yValuesData), std::move(zValuesData), Unit{},
263 263 Unit{});
264 264 }
265 265
266 266 } // namespace
267 267
268 268 void TestDataSeries::testMerge_data()
269 269 {
270 270 // ////////////// //
271 271 // Test structure //
272 272 // ////////////// //
273 273
274 274 // Data series to merge
275 275 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
276 276 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries2");
277 277
278 278 // Expected values in the first data series after merge
279 279 QTest::addColumn<DataContainer>("expectedXAxisData");
280 280 QTest::addColumn<DataContainer>("expectedValuesData");
281 281
282 282 // ////////// //
283 283 // Test cases //
284 284 // ////////// //
285 285
286 286 QTest::newRow("sortedMerge")
287 287 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
288 288 << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
289 289 << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
290 290 << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
291 291
292 292 QTest::newRow("unsortedMerge")
293 293 << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
294 294 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
295 295 << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
296 296 << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
297 297
298 298 QTest::newRow("unsortedMerge2 (merge not made because source is in the bounds of dest)")
299 299 << createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 800., 900., 1000.})
300 300 << createScalarSeries({3., 4., 5., 6., 7.}, {300., 400., 500., 600., 700.})
301 301 << DataContainer{1., 2., 8., 9., 10.} << DataContainer{100., 200., 800., 900., 1000.};
302 302
303 303 QTest::newRow("unsortedMerge3")
304 304 << createScalarSeries({3., 4., 5., 7., 8}, {300., 400., 500., 700., 800.})
305 305 << createScalarSeries({1., 2., 3., 7., 10.}, {100., 200., 333., 777., 1000.})
306 306 << DataContainer{1., 2., 3., 4., 5., 7., 8., 10.}
307 307 << DataContainer{100., 200., 300., 400., 500., 700., 800., 1000.};
308 308 }
309 309
310 310 void TestDataSeries::testMerge()
311 311 {
312 312 // Merges series
313 313 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
314 314 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries2);
315 315
316 316 dataSeries->merge(dataSeries2.get());
317 317
318 318 // Validates results : we check that the merge is valid and the data series is sorted on its
319 319 // x-axis data
320 320 QFETCH(DataContainer, expectedXAxisData);
321 321 QFETCH(DataContainer, expectedValuesData);
322 322
323 323 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, expectedValuesData);
324 324 }
325 325
326 326 void TestDataSeries::testPurgeScalar_data()
327 327 {
328 328 testPurgeStructure<ScalarSeries>();
329 329
330 330 // ////////// //
331 331 // Test cases //
332 332 // ////////// //
333 333
334 334 QTest::newRow("purgeScalar") << createScalarSeries({1., 2., 3., 4., 5.},
335 335 {100., 200., 300., 400., 500.})
336 336 << 2. << 4. << DataContainer{2., 3., 4.}
337 337 << std::vector<DataContainer>{{200., 300., 400.}};
338 QTest::newRow("purgeScalar1 (min/max swap)")
339 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 4. << 2.
340 << DataContainer{2., 3., 4.} << std::vector<DataContainer>{{200., 300., 400.}};
338 341 QTest::newRow("purgeScalar2") << createScalarSeries({1., 2., 3., 4., 5.},
339 342 {100., 200., 300., 400., 500.})
340 343 << 0. << 2.5 << DataContainer{1., 2.}
341 344 << std::vector<DataContainer>{{100., 200.}};
342 345 QTest::newRow("purgeScalar3") << createScalarSeries({1., 2., 3., 4., 5.},
343 346 {100., 200., 300., 400., 500.})
344 347 << 3.5 << 7. << DataContainer{4., 5.}
345 348 << std::vector<DataContainer>{{400., 500.}};
346 349 QTest::newRow("purgeScalar4") << createScalarSeries({1., 2., 3., 4., 5.},
347 350 {100., 200., 300., 400., 500.})
348 351 << 0. << 7. << DataContainer{1., 2., 3., 4., 5.}
349 352 << std::vector<DataContainer>{{100., 200., 300., 400., 500.}};
350 353 QTest::newRow("purgeScalar5") << createScalarSeries({1., 2., 3., 4., 5.},
351 354 {100., 200., 300., 400., 500.})
352 355 << 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}};
353 356 }
354 357
355 358 void TestDataSeries::testPurgeScalar()
356 359 {
357 360 testPurge<ScalarSeries>();
358 361 }
359 362
360 363 void TestDataSeries::testPurgeVector_data()
361 364 {
362 365 testPurgeStructure<VectorSeries>();
363 366
364 367 // ////////// //
365 368 // Test cases //
366 369 // ////////// //
367 370
368 371 QTest::newRow("purgeVector") << createVectorSeries({1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.},
369 372 {11., 12., 13., 14., 15.},
370 373 {16., 17., 18., 19., 20.})
371 374 << 2. << 4. << DataContainer{2., 3., 4.}
372 375 << std::vector<DataContainer>{
373 376 {7., 8., 9.}, {12., 13., 14.}, {17., 18., 19.}};
374 377 }
375 378
376 379 void TestDataSeries::testPurgeVector()
377 380 {
378 381 testPurge<VectorSeries>();
379 382 }
380 383
381 384 void TestDataSeries::testMinXAxisData_data()
382 385 {
383 386 // ////////////// //
384 387 // Test structure //
385 388 // ////////////// //
386 389
387 390 // Data series to get min data
388 391 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
389 392
390 393 // Min data
391 394 QTest::addColumn<double>("min");
392 395
393 396 // Expected results
394 397 QTest::addColumn<bool>(
395 398 "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
396 399 QTest::addColumn<double>(
397 400 "expectedMin"); // Expected value when method doesn't return end iterator
398 401
399 402 // ////////// //
400 403 // Test cases //
401 404 // ////////// //
402 405
403 406 QTest::newRow("minData1") << createScalarSeries({1., 2., 3., 4., 5.},
404 407 {100., 200., 300., 400., 500.})
405 408 << 0. << true << 1.;
406 409 QTest::newRow("minData2") << createScalarSeries({1., 2., 3., 4., 5.},
407 410 {100., 200., 300., 400., 500.})
408 411 << 1. << true << 1.;
409 412 QTest::newRow("minData3") << createScalarSeries({1., 2., 3., 4., 5.},
410 413 {100., 200., 300., 400., 500.})
411 414 << 1.1 << true << 2.;
412 415 QTest::newRow("minData4") << createScalarSeries({1., 2., 3., 4., 5.},
413 416 {100., 200., 300., 400., 500.})
414 417 << 5. << true << 5.;
415 418 QTest::newRow("minData5") << createScalarSeries({1., 2., 3., 4., 5.},
416 419 {100., 200., 300., 400., 500.})
417 420 << 5.1 << false << std::numeric_limits<double>::quiet_NaN();
418 421 QTest::newRow("minData6") << createScalarSeries({}, {}) << 1.1 << false
419 422 << std::numeric_limits<double>::quiet_NaN();
420 423 }
421 424
422 425 void TestDataSeries::testMinXAxisData()
423 426 {
424 427 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
425 428 QFETCH(double, min);
426 429
427 430 QFETCH(bool, expectedOK);
428 431 QFETCH(double, expectedMin);
429 432
430 433 auto it = dataSeries->minXAxisData(min);
431 434
432 435 QCOMPARE(expectedOK, it != dataSeries->cend());
433 436
434 437 // If the method doesn't return a end iterator, checks with expected value
435 438 if (expectedOK) {
436 439 QCOMPARE(expectedMin, it->x());
437 440 }
438 441 }
439 442
440 443 void TestDataSeries::testMaxXAxisData_data()
441 444 {
442 445 // ////////////// //
443 446 // Test structure //
444 447 // ////////////// //
445 448
446 449 // Data series to get max data
447 450 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
448 451
449 452 // Max data
450 453 QTest::addColumn<double>("max");
451 454
452 455 // Expected results
453 456 QTest::addColumn<bool>(
454 457 "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
455 458 QTest::addColumn<double>(
456 459 "expectedMax"); // Expected value when method doesn't return end iterator
457 460
458 461 // ////////// //
459 462 // Test cases //
460 463 // ////////// //
461 464
462 465 QTest::newRow("maxData1") << createScalarSeries({1., 2., 3., 4., 5.},
463 466 {100., 200., 300., 400., 500.})
464 467 << 6. << true << 5.;
465 468 QTest::newRow("maxData2") << createScalarSeries({1., 2., 3., 4., 5.},
466 469 {100., 200., 300., 400., 500.})
467 470 << 5. << true << 5.;
468 471 QTest::newRow("maxData3") << createScalarSeries({1., 2., 3., 4., 5.},
469 472 {100., 200., 300., 400., 500.})
470 473 << 4.9 << true << 4.;
471 474 QTest::newRow("maxData4") << createScalarSeries({1., 2., 3., 4., 5.},
472 475 {100., 200., 300., 400., 500.})
473 476 << 1.1 << true << 1.;
474 477 QTest::newRow("maxData5") << createScalarSeries({1., 2., 3., 4., 5.},
475 478 {100., 200., 300., 400., 500.})
476 479 << 1. << true << 1.;
477 480 QTest::newRow("maxData6") << createScalarSeries({}, {}) << 1.1 << false
478 481 << std::numeric_limits<double>::quiet_NaN();
479 482 }
480 483
481 484 void TestDataSeries::testMaxXAxisData()
482 485 {
483 486 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
484 487 QFETCH(double, max);
485 488
486 489 QFETCH(bool, expectedOK);
487 490 QFETCH(double, expectedMax);
488 491
489 492 auto it = dataSeries->maxXAxisData(max);
490 493
491 494 QCOMPARE(expectedOK, it != dataSeries->cend());
492 495
493 496 // If the method doesn't return a end iterator, checks with expected value
494 497 if (expectedOK) {
495 498 QCOMPARE(expectedMax, it->x());
496 499 }
497 500 }
498 501
499 502 void TestDataSeries::testXAxisRange_data()
500 503 {
501 504 // ////////////// //
502 505 // Test structure //
503 506 // ////////////// //
504 507
505 508 // Data series to get x-axis range
506 509 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
507 510
508 511 // Min/max values
509 512 QTest::addColumn<double>("min");
510 513 QTest::addColumn<double>("max");
511 514
512 515 // Expected values
513 516 QTest::addColumn<DataContainer>("expectedXAxisData");
514 517 QTest::addColumn<DataContainer>("expectedValuesData");
515 518
516 519 // ////////// //
517 520 // Test cases //
518 521 // ////////// //
519 522
520 QTest::newRow("xAxisRange1") << createScalarSeries({1., 2., 3., 4., 5.},
523 QTest::newRow("xAxisRange") << createScalarSeries({1., 2., 3., 4., 5.},
521 524 {100., 200., 300., 400., 500.})
522 525 << -1. << 3.2 << DataContainer{1., 2., 3.}
523 526 << DataContainer{100., 200., 300.};
527 QTest::newRow("xAxisRange1 (min/max swap)")
528 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 3.2 << -1.
529 << DataContainer{1., 2., 3.} << DataContainer{100., 200., 300.};
524 530 QTest::newRow("xAxisRange2") << createScalarSeries({1., 2., 3., 4., 5.},
525 531 {100., 200., 300., 400., 500.})
526 532 << 1. << 4. << DataContainer{1., 2., 3., 4.}
527 533 << DataContainer{100., 200., 300., 400.};
528 534 QTest::newRow("xAxisRange3") << createScalarSeries({1., 2., 3., 4., 5.},
529 535 {100., 200., 300., 400., 500.})
530 536 << 1. << 3.9 << DataContainer{1., 2., 3.}
531 537 << DataContainer{100., 200., 300.};
532 538 QTest::newRow("xAxisRange4") << createScalarSeries({1., 2., 3., 4., 5.},
533 539 {100., 200., 300., 400., 500.})
534 540 << 0. << 0.9 << DataContainer{} << DataContainer{};
535 541 QTest::newRow("xAxisRange5") << createScalarSeries({1., 2., 3., 4., 5.},
536 542 {100., 200., 300., 400., 500.})
537 543 << 0. << 1. << DataContainer{1.} << DataContainer{100.};
538 544 QTest::newRow("xAxisRange6") << createScalarSeries({1., 2., 3., 4., 5.},
539 545 {100., 200., 300., 400., 500.})
540 546 << 2.1 << 6. << DataContainer{3., 4., 5.}
541 547 << DataContainer{300., 400., 500.};
542 548 QTest::newRow("xAxisRange7") << createScalarSeries({1., 2., 3., 4., 5.},
543 549 {100., 200., 300., 400., 500.})
544 550 << 6. << 9. << DataContainer{} << DataContainer{};
545 551 QTest::newRow("xAxisRange8") << createScalarSeries({1., 2., 3., 4., 5.},
546 552 {100., 200., 300., 400., 500.})
547 553 << 5. << 9. << DataContainer{5.} << DataContainer{500.};
548 554 }
549 555
550 556 void TestDataSeries::testXAxisRange()
551 557 {
552 558 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
553 559 QFETCH(double, min);
554 560 QFETCH(double, max);
555 561
556 562 QFETCH(DataContainer, expectedXAxisData);
557 563 QFETCH(DataContainer, expectedValuesData);
558 564
559 565 auto bounds = dataSeries->xAxisRange(min, max);
560 566 validateRange(bounds.first, bounds.second, expectedXAxisData, expectedValuesData);
561 567 }
562 568
563 569 void TestDataSeries::testValuesBoundsScalar_data()
564 570 {
565 571 testValuesBoundsStructure<ScalarSeries>();
566 572
567 573 // ////////// //
568 574 // Test cases //
569 575 // ////////// //
570 576 auto nan = std::numeric_limits<double>::quiet_NaN();
571 577
572 578 QTest::newRow("scalarBounds1")
573 579 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 6.
574 580 << true << 100. << 500.;
575 581 QTest::newRow("scalarBounds2")
576 582 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 2. << 4.
577 583 << true << 200. << 400.;
578 584 QTest::newRow("scalarBounds3")
579 585 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 0.5
580 586 << false << nan << nan;
581 587 QTest::newRow("scalarBounds4")
582 588 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 5.1 << 6.
583 589 << false << nan << nan;
584 QTest::newRow("scalarBounds5") << createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100.
585 << 100.;
590 QTest::newRow("scalarBounds5")
591 << createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100. << 100.;
586 592 QTest::newRow("scalarBounds6") << createScalarSeries({}, {}) << 0. << 2. << false << nan << nan;
587 593
588 594 // Tests with NaN values: NaN values are not included in min/max search
589 595 QTest::newRow("scalarBounds7")
590 596 << createScalarSeries({1., 2., 3., 4., 5.}, {nan, 200., 300., 400., nan}) << 0. << 6.
591 597 << true << 200. << 400.;
592 598 QTest::newRow("scalarBounds8")
593 599 << createScalarSeries({1., 2., 3., 4., 5.}, {nan, nan, nan, nan, nan}) << 0. << 6. << true
594 600 << std::numeric_limits<double>::quiet_NaN() << std::numeric_limits<double>::quiet_NaN();
595 601 }
596 602
597 603 void TestDataSeries::testValuesBoundsScalar()
598 604 {
599 605 testValuesBounds<ScalarSeries>();
600 606 }
601 607
602 608 void TestDataSeries::testValuesBoundsVector_data()
603 609 {
604 610 testValuesBoundsStructure<VectorSeries>();
605 611
606 612 // ////////// //
607 613 // Test cases //
608 614 // ////////// //
609 615 auto nan = std::numeric_limits<double>::quiet_NaN();
610 616
611 617 QTest::newRow("vectorBounds1")
612 618 << createVectorSeries({1., 2., 3., 4., 5.}, {10., 15., 20., 13., 12.},
613 619 {35., 24., 10., 9., 0.3}, {13., 14., 12., 9., 24.})
614 620 << 0. << 6. << true << 0.3 << 35.; // min/max in same component
615 621 QTest::newRow("vectorBounds2")
616 622 << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
617 623 {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
618 624 << 0. << 6. << true << 2.3 << 35.; // min/max in same entry
619 625 QTest::newRow("vectorBounds3")
620 626 << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
621 627 {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
622 628 << 2. << 3. << true << 10. << 24.;
623 629
624 630 // Tests with NaN values: NaN values are not included in min/max search
625 631 QTest::newRow("vectorBounds4")
626 632 << createVectorSeries({1., 2.}, {nan, nan}, {nan, nan}, {nan, nan}) << 0. << 6. << true
627 633 << nan << nan;
628 634 }
629 635
630 636 void TestDataSeries::testValuesBoundsVector()
631 637 {
632 638 testValuesBounds<VectorSeries>();
633 639 }
634 640
635 641 QTEST_MAIN(TestDataSeries)
636 642 #include "TestDataSeries.moc"
General Comments 0
You need to be logged in to leave comments. Login now