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