##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SciQLop-fork
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

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