##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » USERS » JEANDET » qtcharts
RSS

Clone from http://code.qt.io/qt/qtcharts.git

Adds tst_qchartview draft
Michal Klocek -
r774:de60163b4c1f
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,4
1 !include( ../../test.pri ) {
2 error( "Couldn't find the test.pri file!" )
3 }
4 SOURCES += tst_qchartview.cpp No newline at end of file
Show file before | Show file after | Hide comments
@@ -0,0 +1,117
1 /****************************************************************************
2 **
3 ** Copyright (C) 2012 Digia Plc
4 ** All rights reserved.
5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 **
7 ** This file is part of the Qt Commercial Charts Add-on.
8 **
9 ** $QT_BEGIN_LICENSE$
10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 ** accordance with the Qt Commercial License Agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia.
14 **
15 ** If you have questions regarding the use of this file, please use
16 ** contact form at http://qt.digia.com
17 ** $QT_END_LICENSE$
18 **
19 ****************************************************************************/
20
21
22 #include <QtTest/QtTest>
23 #include <qchartview.h>
24
25 QTCOMMERCIALCHART_USE_NAMESPACE
26
27
28 Q_DECLARE_METATYPE(QChart*)
29 Q_DECLARE_METATYPE(QChartView::RubberBands)
30
31 class tst_QChartView : public QObject
32 {
33 Q_OBJECT
34
35 public Q_SLOTS:
36 void initTestCase();
37 void cleanupTestCase();
38 void init();
39 void cleanup();
40
41 private Q_SLOTS:
42 void qchartview_data();
43 void qchartview();
44
45 void chart_data();
46 void chart();
47 void rubberBand_data();
48 void rubberBand();
49
50 private:
51 QChartView* m_view;
52 };
53
54 void tst_QChartView::initTestCase()
55 {
56 }
57
58 void tst_QChartView::cleanupTestCase()
59 {
60 }
61
62 void tst_QChartView::init()
63 {
64 m_view = new QChartView(new QChart());
65 }
66
67 void tst_QChartView::cleanup()
68 {
69 delete m_view;
70 m_view =0;
71 }
72
73 void tst_QChartView::qchartview_data()
74 {
75
76 }
77
78 void tst_QChartView::qchartview()
79 {
80 QVERIFY(m_view->chart());
81 QCOMPARE(m_view->rubberBand(), QChartView::NoRubberBand);
82 QTest::qWaitForWindowShown(m_view);
83 }
84
85 void tst_QChartView::chart_data()
86 {
87
88 QTest::addColumn<QChart*>("chart");
89 QTest::newRow("qchart") << new QChart();
90 }
91
92 void tst_QChartView::chart()
93 {
94 QFETCH(QChart*, chart);
95 QChartView* view = new QChartView(chart);
96 QCOMPARE(view->chart(), chart);
97 delete view;
98 }
99
100 void tst_QChartView::rubberBand_data()
101 {
102 QTest::addColumn<QChartView::RubberBands>("rubberBand");
103 QTest::newRow("HorizonalRubberBand") << QChartView::RubberBands(QChartView::HorizonalRubberBand);
104 QTest::newRow("VerticalRubberBand") << QChartView::RubberBands(QChartView::VerticalRubberBand);
105 QTest::newRow("RectangleRubberBand") << QChartView::RubberBands(QChartView::RectangleRubberBand);
106 }
107
108 void tst_QChartView::rubberBand()
109 {
110 QFETCH(QChartView::RubberBands, rubberBand);
111 m_view->setRubberBand(rubberBand);
112 QCOMPARE(m_view->rubberBand(), rubberBand);
113 }
114
115 QTEST_MAIN(tst_QChartView)
116 #include "tst_qchartview.moc"
117
Show file before | Show file after | Hide comments
@@ -1,2 +1,2
1 1 TEMPLATE = subdirs
2 SUBDIRS += chartdataset domain No newline at end of file
2 SUBDIRS += chartdataset domain qchartview No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,692 +1,712
1 /****************************************************************************
2 **
3 ** Copyright (C) 2012 Digia Plc
4 ** All rights reserved.
5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 **
7 ** This file is part of the Qt Commercial Charts Add-on.
8 **
9 ** $QT_BEGIN_LICENSE$
10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 ** accordance with the Qt Commercial License Agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia.
14 **
15 ** If you have questions regarding the use of this file, please use
16 ** contact form at http://qt.digia.com
17 ** $QT_END_LICENSE$
18 **
19 ****************************************************************************/
20
1 21 #include <QtTest/QtTest>
2 22 #include <private/domain_p.h>
3 23 #include <qchartaxis.h>
4 24
5 25 QTCOMMERCIALCHART_USE_NAMESPACE
6 26
7 27 Q_DECLARE_METATYPE(Domain*)
8 28 Q_DECLARE_METATYPE(QSizeF)
9 29
10 30 class tst_Domain: public QObject
11 31 {
12 32 Q_OBJECT
13 33
14 public slots:
34 public Q_SLOTS:
15 35 void initTestCase();
16 36 void cleanupTestCase();
17 37 void init();
18 38 void cleanup();
19 39
20 private slots:
40 private Q_SLOTS:
21 41 void domain();
22 42 void handleAxisRangeXChanged_data();
23 43 void handleAxisRangeXChanged();
24 44 void handleAxisRangeYChanged_data();
25 45 void handleAxisRangeYChanged();
26 46 void isEmpty_data();
27 47 void isEmpty();
28 48 void maxX_data();
29 49 void maxX();
30 50 void maxY_data();
31 51 void maxY();
32 52 void minX_data();
33 53 void minX();
34 54 void minY_data();
35 55 void minY();
36 56 void operatorEquals_data();
37 57 void operatorEquals();
38 58 void setRange_data();
39 59 void setRange();
40 60 void setRangeX_data();
41 61 void setRangeX();
42 62 void setRangeY_data();
43 63 void setRangeY();
44 64 void spanX_data();
45 65 void spanX();
46 66 void spanY_data();
47 67 void spanY();
48 68 void zoom_data();
49 69 void zoom();
50 70 void move_data();
51 71 void move();
52 72 void handleAxisXChanged_data();
53 73 void handleAxisXChanged();
54 74 void handleAxisYChanged_data();
55 75 void handleAxisYChanged();
56 76 };
57 77
58 78 void tst_Domain::initTestCase()
59 79 {
60 80 }
61 81
62 82 void tst_Domain::cleanupTestCase()
63 83 {
64 84 }
65 85
66 86 void tst_Domain::init()
67 87 {
68 88 }
69 89
70 90 void tst_Domain::cleanup()
71 91 {
72 92 }
73 93
74 94 void tst_Domain::domain()
75 95 {
76 96 Domain domain;
77 97
78 98 QCOMPARE(domain.isEmpty(), true);
79 99 QCOMPARE(domain.maxX(), 0.0);
80 100 QCOMPARE(domain.maxY(), 0.0);
81 101 QCOMPARE(domain.minX(), 0.0);
82 102 QCOMPARE(domain.minY(), 0.0);
83 103 }
84 104
85 105 void tst_Domain::handleAxisRangeXChanged_data()
86 106 {
87 107 QTest::addColumn<qreal>("min");
88 108 QTest::addColumn<qreal>("max");
89 109 QTest::newRow("-1 1") << -1.0 << 1.0;
90 110 QTest::newRow("0 1") << 0.0 << 1.0;
91 111 QTest::newRow("-1 0") << -1.0 << 0.0;
92 112 }
93 113
94 114 void tst_Domain::handleAxisRangeXChanged()
95 115 {
96 116 QFETCH(qreal, min);
97 117 QFETCH(qreal, max);
98 118
99 119 Domain domain;
100 120
101 121 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
102 122 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
103 123 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
104 124
105 125 domain.handleAxisXChanged(min, max);
106 126
107 127 QList<QVariant> arg0 = spy0.first();
108 128 QVERIFY(qFuzzyIsNull(arg0.at(0).toReal() - min));
109 129 QVERIFY(qFuzzyIsNull(arg0.at(1).toReal() - max));
110 130
111 131 QList<QVariant> arg1 = spy1.first();
112 132 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
113 133 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
114 134
115 135 QCOMPARE(spy0.count(), 1);
116 136 QCOMPARE(spy1.count(), 1);
117 137 QCOMPARE(spy2.count(), 0);
118 138
119 139 }
120 140
121 141 void tst_Domain::handleAxisRangeYChanged_data()
122 142 {
123 143 QTest::addColumn<qreal>("min");
124 144 QTest::addColumn<qreal>("max");
125 145 QTest::newRow("-1 1") << -1.0 << 1.0;
126 146 QTest::newRow("0 1") << 0.0 << 1.0;
127 147 QTest::newRow("-1 0") << -1.0 << 0.0;
128 148 }
129 149
130 150 void tst_Domain::handleAxisRangeYChanged()
131 151 {
132 152 QFETCH(qreal, min);
133 153 QFETCH(qreal, max);
134 154
135 155 Domain domain;
136 156
137 157 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
138 158 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
139 159 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
140 160
141 161 domain.handleAxisYChanged(min, max, 5);
142 162
143 163 QList<QVariant> arg0 = spy0.first();
144 164 QVERIFY(qFuzzyIsNull(arg0.at(2).toReal() - min));
145 165 QVERIFY(qFuzzyIsNull(arg0.at(3).toReal() - max));
146 166
147 167 QList<QVariant> arg1 = spy2.first();
148 168 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
149 169 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
150 170
151 171 QCOMPARE(spy0.count(), 1);
152 172 QCOMPARE(spy1.count(), 0);
153 173 QCOMPARE(spy2.count(), 1);
154 174 }
155 175
156 176 void tst_Domain::isEmpty_data()
157 177 {
158 178 QTest::addColumn<qreal>("minX");
159 179 QTest::addColumn<qreal>("maxX");
160 180 QTest::addColumn<qreal>("minY");
161 181 QTest::addColumn<qreal>("maxY");
162 182 QTest::addColumn<bool>("isEmpty");
163 183 QTest::newRow("0 0 0 0") << 0.0 << 0.0 << 0.0 << 0.0 << true;
164 184 QTest::newRow("0 1 0 0") << 0.0 << 1.0 << 0.0 << 0.0 << true;
165 185 QTest::newRow("0 0 0 1") << 0.0 << 1.0 << 0.0 << 0.0 << true;
166 186 QTest::newRow("0 1 0 1") << 0.0 << 1.0 << 0.0 << 1.0 << false;
167 187 }
168 188
169 189 void tst_Domain::isEmpty()
170 190 {
171 191 QFETCH(qreal, minX);
172 192 QFETCH(qreal, maxX);
173 193 QFETCH(qreal, minY);
174 194 QFETCH(qreal, maxY);
175 195 QFETCH(bool, isEmpty);
176 196
177 197 Domain domain;
178 198 domain.setRange(minX, maxX, minY, maxY);
179 199 QCOMPARE(domain.isEmpty(), isEmpty);
180 200 }
181 201
182 202 void tst_Domain::maxX_data()
183 203 {
184 204 QTest::addColumn<qreal>("maxX1");
185 205 QTest::addColumn<qreal>("maxX2");
186 206 QTest::addColumn<int>("count");
187 207 QTest::newRow("1") << 0.0 << 1.0 << 1;
188 208 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
189 209 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
190 210 }
191 211
192 212 void tst_Domain::maxX()
193 213 {
194 214 QFETCH(qreal, maxX1);
195 215 QFETCH(qreal, maxX2);
196 216 QFETCH(int, count);
197 217
198 218 Domain domain;
199 219
200 220 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
201 221 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
202 222 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
203 223
204 224 domain.setMaxX(maxX1);
205 225 QCOMPARE(domain.maxX(), maxX1);
206 226 domain.setMaxX(maxX2);
207 227 QCOMPARE(domain.maxX(), maxX2);
208 228
209 229 QCOMPARE(spy0.count(), count);
210 230 QCOMPARE(spy1.count(), count);
211 231 QCOMPARE(spy2.count(), 0);
212 232
213 233 }
214 234
215 235 void tst_Domain::maxY_data()
216 236 {
217 237 QTest::addColumn<qreal>("maxY1");
218 238 QTest::addColumn<qreal>("maxY2");
219 239 QTest::addColumn<int>("count");
220 240 QTest::newRow("1") << 0.0 << 1.0 << 1;
221 241 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
222 242 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
223 243 }
224 244
225 245 void tst_Domain::maxY()
226 246 {
227 247 QFETCH(qreal, maxY1);
228 248 QFETCH(qreal, maxY2);
229 249 QFETCH(int, count);
230 250
231 251 Domain domain;
232 252
233 253 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
234 254 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
235 255 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
236 256
237 257 domain.setMaxY(maxY1);
238 258 QCOMPARE(domain.maxY(), maxY1);
239 259 domain.setMaxY(maxY2);
240 260 QCOMPARE(domain.maxY(), maxY2);
241 261
242 262 QCOMPARE(spy0.count(), count);
243 263 QCOMPARE(spy1.count(), 0);
244 264 QCOMPARE(spy2.count(), count);
245 265 }
246 266
247 267 void tst_Domain::minX_data()
248 268 {
249 269 QTest::addColumn<qreal>("minX1");
250 270 QTest::addColumn<qreal>("minX2");
251 271 QTest::addColumn<int>("count");
252 272 QTest::newRow("1") << 0.0 << 1.0 << 1;
253 273 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
254 274 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
255 275 }
256 276
257 277 void tst_Domain::minX()
258 278 {
259 279 QFETCH(qreal, minX1);
260 280 QFETCH(qreal, minX2);
261 281 QFETCH(int, count);
262 282
263 283 Domain domain;
264 284
265 285 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
266 286 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
267 287 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
268 288
269 289 domain.setMinX(minX1);
270 290 QCOMPARE(domain.minX(), minX1);
271 291 domain.setMinX(minX2);
272 292 QCOMPARE(domain.minX(), minX2);
273 293
274 294 QCOMPARE(spy0.count(), count);
275 295 QCOMPARE(spy1.count(), count);
276 296 QCOMPARE(spy2.count(), 0);
277 297 }
278 298
279 299 void tst_Domain::minY_data()
280 300 {
281 301 QTest::addColumn<qreal>("minY1");
282 302 QTest::addColumn<qreal>("minY2");
283 303 QTest::addColumn<int>("count");
284 304 QTest::newRow("1") << 0.0 << 1.0 << 1;
285 305 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
286 306 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
287 307 }
288 308
289 309 void tst_Domain::minY()
290 310 {
291 311 QFETCH(qreal, minY1);
292 312 QFETCH(qreal, minY2);
293 313 QFETCH(int, count);
294 314
295 315 Domain domain;
296 316
297 317 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
298 318 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
299 319 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
300 320
301 321 domain.setMinY(minY1);
302 322 QCOMPARE(domain.minY(), minY1);
303 323 domain.setMinY(minY2);
304 324 QCOMPARE(domain.minY(), minY2);
305 325
306 326 QCOMPARE(spy0.count(), count);
307 327 QCOMPARE(spy1.count(), 0);
308 328 QCOMPARE(spy2.count(), count);
309 329 }
310 330
311 331 void tst_Domain::operatorEquals_data()
312 332 {
313 333
314 334 QTest::addColumn<Domain*>("domain1");
315 335 QTest::addColumn<Domain*>("domain2");
316 336 QTest::addColumn<bool>("equals");
317 337 QTest::addColumn<bool>("notEquals");
318 338 Domain* a;
319 339 Domain* b;
320 340 a = new Domain();
321 341 a->setRange(0, 100, 0, 100);
322 342 b = new Domain();
323 343 b->setRange(0, 100, 0, 100);
324 344 QTest::newRow("equals") << a << b << true << false;
325 345 a = new Domain();
326 346 a->setRange(0, 100, 0, 100);
327 347 b = new Domain();
328 348 b->setRange(0, 100, 0, 1);
329 349 QTest::newRow("equals") << a << b << false << true;
330 350 a = new Domain();
331 351 a->setRange(0, 100, 0, 100);
332 352 b = new Domain();
333 353 b->setRange(0, 1, 0, 100);
334 354 QTest::newRow("equals") << a << b << false << true;
335 355
336 356 }
337 357
338 358 void tst_Domain::operatorEquals()
339 359 {
340 360 QFETCH(Domain*, domain1);
341 361 QFETCH(Domain*, domain2);
342 362 QFETCH(bool, equals);
343 363 QFETCH(bool, notEquals);
344 364
345 365 Domain domain;
346 366
347 367 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
348 368 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
349 369 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
350 370
351 371 QCOMPARE(*domain1==*domain2, equals);
352 372 QCOMPARE(*domain1!=*domain2, notEquals);
353 373
354 374 QCOMPARE(spy0.count(), 0);
355 375 QCOMPARE(spy1.count(), 0);
356 376 QCOMPARE(spy2.count(), 0);
357 377 }
358 378
359 379 void tst_Domain::setRange_data()
360 380 {
361 381 QTest::addColumn<qreal>("minX");
362 382 QTest::addColumn<qreal>("maxX");
363 383 QTest::addColumn<qreal>("minY");
364 384 QTest::addColumn<qreal>("maxY");
365 385 QTest::newRow("1,2,1,2") << 1.0 << 2.0 << 1.0 << 2.0;
366 386 QTest::newRow("1,3,1,3") << 1.0 << 3.0 << 1.0 << 3.0;
367 387 QTest::newRow("-1,5,-2,-1") << -1.0 << 5.0 << -2.0 << -1.0;
368 388 }
369 389
370 390 void tst_Domain::setRange()
371 391 {
372 392 QFETCH(qreal, minX);
373 393 QFETCH(qreal, maxX);
374 394 QFETCH(qreal, minY);
375 395 QFETCH(qreal, maxY);
376 396
377 397 Domain domain;
378 398
379 399 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
380 400 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
381 401 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
382 402
383 403 domain.setRange(minX, maxX, minY, maxY);
384 404
385 405 QCOMPARE(domain.minX(), minX);
386 406 QCOMPARE(domain.maxX(), maxX);
387 407 QCOMPARE(domain.minY(), minY);
388 408 QCOMPARE(domain.maxY(), maxY);
389 409
390 410 QCOMPARE(spy0.count(), 1);
391 411 QCOMPARE(spy1.count(), 1);
392 412 QCOMPARE(spy2.count(), 1);
393 413
394 414 }
395 415
396 416 void tst_Domain::setRangeX_data()
397 417 {
398 418 QTest::addColumn<qreal>("min");
399 419 QTest::addColumn<qreal>("max");
400 420 QTest::newRow("-1 1") << -1.0 << 1.0;
401 421 QTest::newRow("0 1") << 0.0 << 1.0;
402 422 QTest::newRow("-1 0") << -1.0 << 0.0;
403 423 }
404 424
405 425 void tst_Domain::setRangeX()
406 426 {
407 427 QFETCH(qreal, min);
408 428 QFETCH(qreal, max);
409 429
410 430 Domain domain;
411 431
412 432 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
413 433 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
414 434 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
415 435
416 436 domain.setRangeX(min, max);
417 437
418 438 QList<QVariant> arg0 = spy0.first();
419 439 QVERIFY(qFuzzyIsNull(arg0.at(0).toReal() - min));
420 440 QVERIFY(qFuzzyIsNull(arg0.at(1).toReal() - max));
421 441
422 442 QList<QVariant> arg1 = spy1.first();
423 443 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
424 444 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
425 445
426 446 QCOMPARE(spy0.count(), 1);
427 447 QCOMPARE(spy1.count(), 1);
428 448 QCOMPARE(spy2.count(), 0);
429 449 }
430 450
431 451 void tst_Domain::setRangeY_data()
432 452 {
433 453 QTest::addColumn<qreal>("min");
434 454 QTest::addColumn<qreal>("max");
435 455 QTest::newRow("-1 1") << -1.0 << 1.0;
436 456 QTest::newRow("0 1") << 0.0 << 1.0;
437 457 QTest::newRow("-1 0") << -1.0 << 0.0;
438 458 }
439 459
440 460 void tst_Domain::setRangeY()
441 461 {
442 462 QFETCH(qreal, min);
443 463 QFETCH(qreal, max);
444 464
445 465 Domain domain;
446 466
447 467 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
448 468 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
449 469 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
450 470
451 471 domain.setRangeY(min, max);
452 472
453 473 QList<QVariant> arg0 = spy0.first();
454 474 QVERIFY(qFuzzyIsNull(arg0.at(2).toReal() - min));
455 475 QVERIFY(qFuzzyIsNull(arg0.at(3).toReal() - max));
456 476
457 477 QList<QVariant> arg1 = spy2.first();
458 478 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
459 479 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
460 480
461 481 QCOMPARE(spy0.count(), 1);
462 482 QCOMPARE(spy1.count(), 0);
463 483 QCOMPARE(spy2.count(), 1);
464 484 }
465 485
466 486 void tst_Domain::spanX_data()
467 487 {
468 488 QTest::addColumn<qreal>("minX");
469 489 QTest::addColumn<qreal>("maxX");
470 490 QTest::addColumn<qreal>("spanX");
471 491 QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0;
472 492 QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0;
473 493 }
474 494
475 495 void tst_Domain::spanX()
476 496 {
477 497 QFETCH(qreal, minX);
478 498 QFETCH(qreal, maxX);
479 499 QFETCH(qreal, spanX);
480 500
481 501 Domain domain;
482 502
483 503 domain.setRangeX(minX, maxX);
484 504
485 505 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
486 506 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
487 507 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
488 508
489 509 QCOMPARE(domain.spanX(), spanX);
490 510
491 511 QCOMPARE(spy0.count(), 0);
492 512 QCOMPARE(spy1.count(), 0);
493 513 QCOMPARE(spy2.count(), 0);
494 514 }
495 515
496 516 void tst_Domain::spanY_data()
497 517 {
498 518 QTest::addColumn<qreal>("minY");
499 519 QTest::addColumn<qreal>("maxY");
500 520 QTest::addColumn<qreal>("spanY");
501 521 QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0;
502 522 QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0;
503 523 }
504 524
505 525 void tst_Domain::spanY()
506 526 {
507 527 QFETCH(qreal, minY);
508 528 QFETCH(qreal, maxY);
509 529 QFETCH(qreal, spanY);
510 530
511 531 Domain domain;
512 532
513 533 domain.setRangeY(minY, maxY);
514 534
515 535 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
516 536 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
517 537 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
518 538
519 539 QCOMPARE(domain.spanY(), spanY);
520 540
521 541 QCOMPARE(spy0.count(), 0);
522 542 QCOMPARE(spy1.count(), 0);
523 543 QCOMPARE(spy2.count(), 0);
524 544 }
525 545
526 546 void tst_Domain::zoom_data()
527 547 {
528 548 QTest::addColumn<QRectF>("rect0");
529 549 QTest::addColumn<QSizeF>("size0");
530 550 QTest::addColumn<QRectF>("rect1");
531 551 QTest::addColumn<QSizeF>("size1");
532 552 QTest::addColumn<QRectF>("rect2");
533 553 QTest::addColumn<QSizeF>("size2");
534 554 QTest::newRow("first") << QRectF(10, 10, 100, 100) << QSizeF(1000, 1000)
535 555 << QRectF(20, 20, 100, 100) << QSizeF(1000, 1000) << QRectF(50, 50, 100, 100)
536 556 << QSizeF(1000, 1000);
537 557 QTest::newRow("scound") << QRectF(10, 10, 50, 50) << QSizeF(1000, 1000)
538 558 << QRectF(20, 20, 100, 100) << QSizeF(1000, 1000) << QRectF(50, 50, 100, 100)
539 559 << QSizeF(1000, 1000);
540 560 QTest::newRow("third") << QRectF(10, 10, 10, 10) << QSizeF(100, 100) << QRectF(20, 20, 20, 20)
541 561 << QSizeF(100, 100) << QRectF(50, 50, 50, 50) << QSizeF(100, 100);
542 562 }
543 563
544 564 void tst_Domain::zoom()
545 565 {
546 566 QFETCH(QRectF, rect0);
547 567 QFETCH(QSizeF, size0);
548 568 QFETCH(QRectF, rect1);
549 569 QFETCH(QSizeF, size1);
550 570 QFETCH(QRectF, rect2);
551 571 QFETCH(QSizeF, size2);
552 572
553 573 Domain domain;
554 574
555 575 domain.setRange(0, 1000, 0, 1000);
556 576
557 577 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
558 578 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
559 579 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
560 580
561 581 Domain domain0;
562 582 domain0.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
563 583 domain.zoomIn(rect0, size0);
564 584 Domain domain1;
565 585 domain1.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
566 586 domain.zoomIn(rect1, size1);
567 587 Domain domain2;
568 588 domain2.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
569 589 domain.zoomIn(rect2, size2);
570 590 domain.zoomOut(rect2, size2);
571 591 QCOMPARE(domain == domain2, true);
572 592 domain.zoomOut(rect1, size1);
573 593 QCOMPARE(domain == domain1, true);
574 594 domain.zoomOut(rect0, size0);
575 595 QCOMPARE(domain == domain0, true);
576 596 QCOMPARE(spy0.count(), 6);
577 597 QCOMPARE(spy1.count(), 6);
578 598 QCOMPARE(spy2.count(), 6);
579 599
580 600 }
581 601
582 602 void tst_Domain::move_data()
583 603 {
584 604 QTest::addColumn<int>("dx");
585 605 QTest::addColumn<int>("dy");
586 606 QTest::addColumn<QSizeF>("size");
587 607 QTest::newRow("dx 100, dy 0, size 1000x1000") << 100 << 0 << QSizeF(1000, 1000);
588 608 QTest::newRow("dx 0, dy 100, size 1000x1000") << 0 << 100 << QSizeF(1000, 1000);
589 609 QTest::newRow("dx -100, dy 0, size 1000x1000") << -100 << 0 << QSizeF(1000, 1000);
590 610 QTest::newRow("dx 0, dy -100, size 1000x1000") << 0 << -100 << QSizeF(1000, 1000);
591 611 QTest::newRow("dx 100, dy 100, size 1000x1000") << 100 << 100 << QSizeF(1000, 1000);
592 612 QTest::newRow("dx 100, dy 50, size 1000x1000") << 100 << 50 << QSizeF(1000, 1000);
593 613 }
594 614
595 615 void tst_Domain::move()
596 616 {
597 617 QFETCH(int, dx);
598 618 QFETCH(int, dy);
599 619 QFETCH(QSizeF, size);
600 620 Domain domain;
601 621
602 622 domain.setRange(0, size.width(), 0, size.height());
603 623
604 624 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
605 625 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
606 626 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
607 627
608 628 domain.move(dx, dy, size);
609 629
610 630 Domain result;
611 631 result.setRange(dx, size.width() + dx, dy, size.height() + dy);
612 632
613 633 QCOMPARE(domain == result, true);
614 634 QCOMPARE(spy0.count(), 1);
615 635 QCOMPARE(spy1.count(), dx!=0?1:0);
616 636 QCOMPARE(spy2.count(), dy!=0?1:0);
617 637 }
618 638
619 639 void tst_Domain::handleAxisXChanged_data()
620 640 {
621 641 QTest::addColumn<qreal>("min");
622 642 QTest::addColumn<qreal>("max");
623 643 QTest::addColumn<int>("tickCount");
624 644 QTest::addColumn<bool>("niceNumbers");
625 645 QTest::addColumn<qreal>("resultMin");
626 646 QTest::addColumn<qreal>("resultMax");
627 647 QTest::addColumn<int>("resultTickCount");
628 648 QTest::newRow("0,100,5,false") << 0.0 << 100.0 << 5 << false << 0.0 << 100.0 << 5;
629 649 QTest::newRow("0,100,5,true") << 0.0 << 100.0 << 5 << true << 0.0 << 100.0 << 6;
630 650 QTest::newRow("0.1,99,5,true") << 0.1 << 99.0 << 5 << true << 0.0 << 100.0 << 6;
631 651 QTest::newRow("5,93.5,true") << 5.0 << 93.5 << 5 << true << 0.0 << 100.0 << 6;
632 652 }
633 653
634 654 void tst_Domain::handleAxisXChanged()
635 655 {
636 656 QFETCH(qreal, min);
637 657 QFETCH(qreal, max);
638 658 QFETCH(int, tickCount);
639 659 QFETCH(bool, niceNumbers);
640 660 QFETCH(qreal, resultMin);
641 661 QFETCH(qreal, resultMax);
642 662 QFETCH(int, resultTickCount);
643 663
644 664 Domain domain;
645 665 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
646 666 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
647 667 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
648 668
649 669 domain.handleAxisXChanged(min, max, tickCount, niceNumbers);
650 670
651 671 QCOMPARE(resultMin, domain.minX());
652 672 QCOMPARE(resultMax, domain.maxX());
653 673 QCOMPARE(resultTickCount, domain.tickXCount());
654 674 QCOMPARE(spy0.count(), 1);
655 675 QCOMPARE(spy1.count(), 1);
656 676 QCOMPARE(spy2.count(), 0);
657 677
658 678 }
659 679
660 680 void tst_Domain::handleAxisYChanged_data()
661 681 {
662 682 handleAxisXChanged_data();
663 683 }
664 684
665 685 void tst_Domain::handleAxisYChanged()
666 686 {
667 687 QFETCH(qreal, min);
668 688 QFETCH(qreal, max);
669 689 QFETCH(int, tickCount);
670 690 QFETCH(bool, niceNumbers);
671 691 QFETCH(qreal, resultMin);
672 692 QFETCH(qreal, resultMax);
673 693 QFETCH(int, resultTickCount);
674 694
675 695 Domain domain;
676 696 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
677 697 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
678 698 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
679 699
680 700 domain.handleAxisYChanged(min, max, tickCount, niceNumbers);
681 701
682 702 QCOMPARE(resultMin, domain.minY());
683 703 QCOMPARE(resultMax, domain.maxY());
684 704 QCOMPARE(resultTickCount, domain.tickYCount());
685 705 QCOMPARE(spy0.count(), 1);
686 706 QCOMPARE(spy1.count(), 0);
687 707 QCOMPARE(spy2.count(), 1);
688 708 }
689 709
690 710 QTEST_MAIN(tst_Domain)
691 711 #include "tst_domain.moc"
692 712
General Comments 0
You need to be logged in to leave comments. Login now