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

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

Update tst_qchart to match current axis implementation
Michal Klocek -
r1660:525c02d166a8
parent child
Show More
Side by Side Unified
Context file:
r1660:525c02d166a8 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,624 +1,623
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include <QtTest/QtTest>
22 22 #include <qabstractaxis.h>
23 23 #include <qvaluesaxis.h>
24 24 #include <qbarcategoriesaxis.h>
25 25 #include <qlineseries.h>
26 26 #include <qareaseries.h>
27 27 #include <qscatterseries.h>
28 28 #include <qsplineseries.h>
29 29 #include <qpieseries.h>
30 30 #include <qbarseries.h>
31 31 #include <qpercentbarseries.h>
32 32 #include <qstackedbarseries.h>
33 33 #include <private/chartdataset_p.h>
34 34 #include <private/domain_p.h>
35 35 #include <tst_definitions.h>
36 36
37 37 QTCOMMERCIALCHART_USE_NAMESPACE
38 38
39 39 Q_DECLARE_METATYPE(Domain *)
40 40 Q_DECLARE_METATYPE(QAbstractAxis *)
41 41 Q_DECLARE_METATYPE(QAbstractSeries *)
42 42 Q_DECLARE_METATYPE(QList<QAbstractSeries *>)
43 43 Q_DECLARE_METATYPE(QList<QAbstractAxis *>)
44 44 Q_DECLARE_METATYPE(QLineSeries *)
45 45
46 46 class tst_ChartDataSet: public QObject {
47 47
48 48 Q_OBJECT
49 49
50 50 public Q_SLOTS:
51 51 void initTestCase();
52 52 void cleanupTestCase();
53 53 void init();
54 54 void cleanup();
55 55
56 56 private Q_SLOTS:
57 57 void chartdataset_data();
58 58 void chartdataset();
59 59 void addSeries_data();
60 60 void addSeries();
61 61 void setAxisX_data();
62 62 void setAxisX();
63 63 void setAxisY_data();
64 64 void setAxisY();
65 65 void removeSeries_data();
66 66 void removeSeries();
67 67 void removeAllSeries_data();
68 68 void removeAllSeries();
69 69 void seriesCount_data();
70 70 void seriesCount();
71 71 void seriesIndex_data();
72 72 void seriesIndex();
73 73 void domain_data();
74 74 void domain();
75 75 void zoomInDomain_data();
76 76 void zoomInDomain();
77 77 void zoomOutDomain_data();
78 78 void zoomOutDomain();
79 79 void scrollDomain_data();
80 80 void scrollDomain();
81 81
82 82 private:
83 83 ChartDataSet* m_dataset;
84 84 };
85 85
86 86 void tst_ChartDataSet::initTestCase()
87 87 {
88 88 qRegisterMetaType<Domain*>();
89 89 qRegisterMetaType<QAbstractAxis*>();
90 90 qRegisterMetaType<QAbstractSeries*>();
91 91 }
92 92
93 93 void tst_ChartDataSet::cleanupTestCase()
94 94 {
95 95 }
96 96
97 97 void tst_ChartDataSet::init()
98 98 {
99 99 m_dataset = new ChartDataSet();
100 100 }
101 101
102 102
103 103 void tst_ChartDataSet::cleanup()
104 104 {
105 105 QList<QAbstractSeries*> series = m_dataset->series();
106 106 foreach(QAbstractSeries* serie, series)
107 107 {
108 108 m_dataset->removeSeries(serie);
109 109 }
110 110 }
111 111
112 112 void tst_ChartDataSet::chartdataset_data()
113 113 {
114 114 }
115 115
116 116 void tst_ChartDataSet::chartdataset()
117 117 {
118 118 QVERIFY(m_dataset->axisX(0) == 0);
119 119 QVERIFY(m_dataset->axisY(0) == 0);
120 120 QLineSeries* series = new QLineSeries(this);
121 121 QCOMPARE(m_dataset->seriesIndex(series),-1);
122 122 QVERIFY(m_dataset->domain(series) == 0);
123 123 QVERIFY(m_dataset->axisX(series) == 0);
124 124 QVERIFY(m_dataset->axisY(series) == 0);
125 125 m_dataset->createDefaultAxes();
126 126 }
127 127
128 128
129 129 void tst_ChartDataSet::addSeries_data()
130 130 {
131 131 QTest::addColumn<QAbstractSeries*>("series");
132 132
133 133 QAbstractSeries* line = new QLineSeries(this);
134 134 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
135 135 QAbstractSeries* scatter = new QScatterSeries(this);
136 136 QAbstractSeries* spline = new QSplineSeries(this);
137 137 QAbstractSeries* pie = new QPieSeries(this);
138 138 QAbstractSeries* bar = new QBarSeries(this);
139 139 QAbstractSeries* percent = new QPercentBarSeries(this);
140 140 QAbstractSeries* stacked = new QStackedBarSeries(this);
141 141
142 142 QTest::newRow("line") << line;
143 143 QTest::newRow("area") << area;
144 144 QTest::newRow("scatter") << scatter;
145 145 QTest::newRow("spline") << spline;
146 146 QTest::newRow("pie") << pie;
147 147 QTest::newRow("bar") << bar;
148 148 QTest::newRow("percent") << percent;
149 149 QTest::newRow("stacked") << stacked;
150 150 }
151 151
152 152 void tst_ChartDataSet::addSeries()
153 153 {
154 154
155 155 QFETCH(QAbstractSeries*, series);
156 156
157 157 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*, Domain *)));
158 158 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
159 159 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
160 160 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
161 161
162 162 m_dataset->addSeries(series);
163 163 m_dataset->createDefaultAxes();
164 164 if(series->type()==QAbstractSeries::SeriesTypePie){
165 165 TRY_COMPARE(spy0.count(), 0);
166 166 }else{
167 167 TRY_COMPARE(spy0.count(), 2);
168 168 }
169 169 TRY_COMPARE(spy1.count(), 0);
170 170 TRY_COMPARE(spy2.count(), 1);
171 171 TRY_COMPARE(spy3.count(), 0);
172 172 }
173 173
174 174
175 175 void tst_ChartDataSet::setAxisX_data()
176 176 {
177
178 177 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
179 178 QTest::addColumn<QList<QAbstractAxis*> >("axisList");
180 179 QTest::addColumn<int>("axisCount");
181 180
182 181 QAbstractSeries* line = new QLineSeries(this);
183 182 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
184 183 QAbstractSeries* scatter = new QScatterSeries(this);
185 184 QAbstractSeries* spline = new QSplineSeries(this);
186 185 QAbstractSeries* pie = new QPieSeries(this);
187 186 QAbstractSeries* bar = new QBarSeries(this);
188 187 QAbstractSeries* percent = new QPercentBarSeries(this);
189 188 QAbstractSeries* stacked = new QStackedBarSeries(this);
190 189
191 190 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")
192 191 << (QList<QAbstractSeries*>() << line << spline << scatter)
193 192 << (QList<QAbstractAxis*>() << new QValuesAxis(this) << new QValuesAxis(this) << new QValuesAxis(this)) << 3;
194 193
195 194 QTest::newRow("area: axis 0") << (QList<QAbstractSeries*>() << area)
196 195 << (QList<QAbstractAxis*>() << new QValuesAxis(this)) << 1;
197 196
198 197 QList<QAbstractAxis*> axes0;
199 198 axes0 << new QValuesAxis(this) << new QValuesAxis(this);
200 199 axes0 << axes0.last();
201 200 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 1")
202 201 << (QList<QAbstractSeries*>() << line << spline << scatter)
203 202 << axes0 << 2;
204 203 //TODO: add more test cases
205 204 }
206 205
207 206 void tst_ChartDataSet::setAxisX()
208 207 {
209 208 QFETCH(QList<QAbstractSeries*>, seriesList);
210 209 QFETCH(QList<QAbstractAxis*>, axisList);
211 210 QFETCH(int, axisCount);
212 211
213 212 Q_ASSERT(seriesList.count() == axisList.count());
214 213
215 214 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *,Domain*)));
216 215 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
217 216 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
218 217 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
219 218
220 219 foreach(QAbstractSeries* series, seriesList){
221 220 m_dataset->addSeries(series);
222 221 }
223 222
224 223 TRY_COMPARE(spy0.count(), 0);
225 224 TRY_COMPARE(spy1.count(), 0);
226 225 TRY_COMPARE(spy2.count(), seriesList.count());
227 226 TRY_COMPARE(spy3.count(), 0);
228 227
229 228 QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
230 229 QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
231 230 QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
232 231 QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
233 232
234 233 for(int i=0 ; i < seriesList.count(); i++){
235 234 m_dataset->setAxisX(seriesList.at(i),axisList.at(i));
236 235 }
237 236
238 237 TRY_COMPARE(spy4.count(), axisCount);
239 238 TRY_COMPARE(spy5.count(), 0);
240 239 TRY_COMPARE(spy6.count(), 0);
241 240 TRY_COMPARE(spy7.count(), 0);
242 241
243 242 for(int i=0 ; i < seriesList.count(); i++){
244 243 QVERIFY(m_dataset->axisX(seriesList.at(i)) == axisList.at(i));
245 244 }
246 245 }
247 246
248 247 void tst_ChartDataSet::setAxisY_data()
249 248 {
250 249 setAxisX_data();
251 250 }
252 251
253 252 void tst_ChartDataSet::setAxisY()
254 253 {
255 254 QFETCH(QList<QAbstractSeries*>, seriesList);
256 255 QFETCH(QList<QAbstractAxis*>, axisList);
257 256 QFETCH(int, axisCount);
258 257
259 258 Q_ASSERT(seriesList.count() == axisList.count());
260 259
261 260 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
262 261 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
263 262 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
264 263 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
265 264
266 265 foreach(QAbstractSeries* series, seriesList){
267 266 m_dataset->addSeries(series);
268 267 }
269 268
270 269 TRY_COMPARE(spy0.count(), 0);
271 270 TRY_COMPARE(spy1.count(), 0);
272 271 TRY_COMPARE(spy2.count(), seriesList.count());
273 272 TRY_COMPARE(spy3.count(), 0);
274 273
275 274 QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
276 275 QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
277 276 QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
278 277 QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
279 278
280 279 for(int i=0 ; i < seriesList.count(); i++){
281 280 m_dataset->setAxisY(seriesList.at(i),axisList.at(i));
282 281 }
283 282
284 283 TRY_COMPARE(spy4.count(), axisCount);
285 284 TRY_COMPARE(spy5.count(), 0);
286 285 TRY_COMPARE(spy6.count(), 0);
287 286 TRY_COMPARE(spy7.count(), 0);
288 287
289 288 for(int i=0 ; i < seriesList.count(); i++){
290 289 QVERIFY(m_dataset->axisY(seriesList.at(i)) == axisList.at(i));
291 290 }
292 291 }
293 292
294 293 void tst_ChartDataSet::removeSeries_data()
295 294 {
296 295 addSeries_data();
297 296 }
298 297
299 298 void tst_ChartDataSet::removeSeries()
300 299 {
301 300 QFETCH(QAbstractSeries*, series);
302 301
303 302 m_dataset->addSeries(series);
304 303 m_dataset->createDefaultAxes();
305 304
306 305 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*, Domain *)));
307 306 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
308 307 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
309 308 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
310 309
311 310 m_dataset->removeSeries(series);
312 311
313 312 TRY_COMPARE(spy0.count(), 0);
314 313 if (series->type() == QAbstractSeries::SeriesTypePie) {
315 314 TRY_COMPARE(spy1.count(), 0);
316 315 }
317 316 else {
318 317 TRY_COMPARE(spy1.count(), 2);
319 318 }
320 319 TRY_COMPARE(spy2.count(), 0);
321 320 TRY_COMPARE(spy3.count(), 1);
322 321 }
323 322
324 323 void tst_ChartDataSet::removeAllSeries_data()
325 324 {
326 325 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
327 326 QTest::addColumn<QList<QAbstractAxis*> >("axisList");
328 327 QTest::addColumn<int>("axisCount");
329 328
330 329 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")
331 330 << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QSplineSeries(this)
332 331 << new QScatterSeries(this))
333 332 << (QList<QAbstractAxis*>() << new QValuesAxis(this) << new QValuesAxis(this)
334 333 << new QValuesAxis(this)) << 3;
335 334 //TODO:
336 335 }
337 336
338 337 void tst_ChartDataSet::removeAllSeries()
339 338 {
340 339 QFETCH(QList<QAbstractSeries*>, seriesList);
341 340 QFETCH(QList<QAbstractAxis*>, axisList);
342 341 QFETCH(int, axisCount);
343 342
344 343 foreach(QAbstractSeries* series, seriesList) {
345 344 m_dataset->addSeries(series);
346 345 }
347 346
348 347 for (int i = 0; i < seriesList.count(); i++) {
349 348 m_dataset->setAxisX(seriesList.at(i), axisList.at(i));
350 349 }
351 350
352 351 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
353 352 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
354 353 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
355 354 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
356 355
357 356 m_dataset->removeAllSeries();
358 357
359 358 TRY_COMPARE(spy0.count(), 0);
360 359 TRY_COMPARE(spy1.count(), axisCount);
361 360 TRY_COMPARE(spy2.count(), 0);
362 361 TRY_COMPARE(spy3.count(), seriesList.count());
363 362 }
364 363
365 364
366 365 void tst_ChartDataSet::seriesCount_data()
367 366 {
368 367 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
369 368 QTest::addColumn<int>("seriesCount");
370 369
371 370 QTest::newRow("line,line, line, spline 3") << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) ) << 3;
372 371 QTest::newRow("scatter,scatter, line, line 2") << (QList<QAbstractSeries*>() << new QScatterSeries(this) << new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) ) << 2;
373 372 }
374 373
375 374 void tst_ChartDataSet::seriesCount()
376 375 {
377 376 QFETCH(QList<QAbstractSeries*>, seriesList);
378 377 QFETCH(int, seriesCount);
379 378
380 379 foreach(QAbstractSeries* series, seriesList){
381 380 m_dataset->addSeries(series);
382 381 }
383 382
384 383 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
385 384 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
386 385 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
387 386 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
388 387
389 388 QCOMPARE(m_dataset->seriesCount(seriesList.at(0)->type()),seriesCount);
390 389 TRY_COMPARE(spy0.count(), 0);
391 390 TRY_COMPARE(spy1.count(), 0);
392 391 TRY_COMPARE(spy2.count(), 0);
393 392 TRY_COMPARE(spy3.count(), 0);
394 393 }
395 394
396 395 void tst_ChartDataSet::seriesIndex_data()
397 396 {
398 397 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
399 398
400 399 QTest::newRow("line,line, line, spline") << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) );
401 400 QTest::newRow("scatter,scatter, line, line") << (QList<QAbstractSeries*>() << new QScatterSeries(this) << new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) );
402 401 }
403 402
404 403 void tst_ChartDataSet::seriesIndex()
405 404 {
406 405
407 406 QFETCH(QList<QAbstractSeries*>, seriesList);
408 407
409 408 foreach(QAbstractSeries* series, seriesList) {
410 409 m_dataset->addSeries(series);
411 410 }
412 411
413 412 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *,Domain*)));
414 413 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
415 414 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*,Domain*)));
416 415 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
417 416
418 417 for (int i = 0; i < seriesList.count(); i++) {
419 418 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
420 419 }
421 420
422 421 TRY_COMPARE(spy0.count(), 0);
423 422 TRY_COMPARE(spy1.count(), 0);
424 423 TRY_COMPARE(spy2.count(), 0);
425 424 TRY_COMPARE(spy3.count(), 0);
426 425
427 426 foreach(QAbstractSeries* series, seriesList) {
428 427 m_dataset->removeSeries(series);
429 428 }
430 429
431 430 for (int i = 0; i < seriesList.count(); i++) {
432 431 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
433 432 }
434 433
435 434 foreach(QAbstractSeries* series, seriesList) {
436 435 m_dataset->addSeries(series);
437 436 }
438 437
439 438 for (int i = 0; i < seriesList.count(); i++) {
440 439 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
441 440 }
442 441
443 442 m_dataset->removeSeries(seriesList.at(1));
444 443
445 444 for (int i = 0; i < seriesList.count(); i++) {
446 445 if (i != 1)
447 446 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
448 447 else
449 448 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
450 449 }
451 450
452 451 m_dataset->addSeries(seriesList.at(1));
453 452
454 453 for (int i = 0; i < seriesList.count(); i++) {
455 454 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
456 455 }
457 456
458 457 m_dataset->removeSeries(seriesList.at(2));
459 458
460 459 for (int i = 0; i < seriesList.count(); i++) {
461 460 if (i != 2)
462 461 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
463 462 else
464 463 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
465 464 }
466 465
467 466 m_dataset->removeSeries(seriesList.at(0));
468 467
469 468 for (int i = 0; i < seriesList.count(); i++) {
470 469 if (i != 2 && i != 0)
471 470 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
472 471 else
473 472 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
474 473 }
475 474
476 475 m_dataset->addSeries(seriesList.at(2));
477 476 m_dataset->addSeries(seriesList.at(0));
478 477
479 478 for (int i = 0; i < seriesList.count(); i++) {
480 479 if (i == 2)
481 480 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 0);
482 481 else if (i == 0)
483 482 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 2);
484 483 else
485 484 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
486 485 }
487 486
488 487 }
489 488
490 489 void tst_ChartDataSet::domain_data()
491 490 {
492 491 addSeries_data();
493 492 }
494 493
495 494 void tst_ChartDataSet::domain()
496 495 {
497 496 QFETCH(QAbstractSeries*, series);
498 497
499 498 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
500 499 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
501 500 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
502 501 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
503 502
504 503 m_dataset->addSeries(series);
505 504 QVERIFY(m_dataset->domain(series));
506 505
507 506
508 507 TRY_COMPARE(spy0.count(), 0);
509 508 TRY_COMPARE(spy1.count(), 0);
510 509 TRY_COMPARE(spy2.count(), 1);
511 510
512 511 QList<QVariant> arguments = spy2.takeFirst();
513 512 Domain *domain = (Domain *) arguments.at(1).value<Domain *>();
514 513 QVERIFY(m_dataset->domain(series) == domain);
515 514
516 515 TRY_COMPARE(spy3.count(), 0);
517 516
518 517 }
519 518
520 519 void tst_ChartDataSet::zoomInDomain_data()
521 520 {
522 521 QTest::addColumn<bool >("sameAxis");
523 522 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
524 523 QTest::newRow("sameAxis: line,line, line, spline") << true << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) );
525 524 QTest::newRow("separeateAxis: line,line, line, spline") << false << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) );
526 525 }
527 526
528 527 void tst_ChartDataSet::zoomInDomain()
529 528 {
530 529 QFETCH(bool, sameAxis);
531 530 QFETCH(QList<QAbstractSeries*>, seriesList);
532 531
533 532 foreach(QAbstractSeries* series, seriesList) {
534 533 m_dataset->addSeries(series);
535 534 }
536 535
537 536 if(sameAxis) m_dataset->createDefaultAxes();
538 537
539 538 QList<QSignalSpy*> spyList;
540 539
541 540 foreach(QAbstractSeries* series, seriesList) {
542 541 spyList << new QSignalSpy(m_dataset->domain(series),SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
543 542 }
544 543
545 544 m_dataset->zoomInDomain(QRect(0, 0, 100, 100), QSize(1000, 1000));
546 545
547 546 foreach(QSignalSpy* spy, spyList) {
548 547 TRY_COMPARE(spy->count(), 1);
549 548 }
550 549
551 550 qDeleteAll(spyList);
552 551 }
553 552
554 553
555 554
556 555 void tst_ChartDataSet::zoomOutDomain_data()
557 556 {
558 557 zoomInDomain_data();
559 558 }
560 559
561 560 void tst_ChartDataSet::zoomOutDomain()
562 561 {
563 562 QFETCH(bool, sameAxis);
564 563 QFETCH(QList<QAbstractSeries*>, seriesList);
565 564
566 565 foreach(QAbstractSeries* series, seriesList) {
567 566 m_dataset->addSeries(series);
568 567 }
569 568
570 569 if (sameAxis)
571 570 m_dataset->createDefaultAxes();
572 571
573 572 QList<QSignalSpy*> spyList;
574 573
575 574 foreach(QAbstractSeries* series, seriesList) {
576 575 spyList << new QSignalSpy(m_dataset->domain(series), SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
577 576 }
578 577
579 578 m_dataset->zoomOutDomain(QRect(0, 0, 100, 100), QSize(1000, 1000));
580 579
581 580 foreach(QSignalSpy* spy, spyList) {
582 581 TRY_COMPARE(spy->count(), 1);
583 582 }
584 583
585 584 qDeleteAll (spyList);
586 585 }
587 586
588 587 void tst_ChartDataSet::scrollDomain_data()
589 588 {
590 589 zoomInDomain_data();
591 590 }
592 591
593 592 void tst_ChartDataSet::scrollDomain()
594 593 {
595 594 QFETCH(bool, sameAxis);
596 595 QFETCH(QList<QAbstractSeries*>, seriesList);
597 596
598 597 foreach(QAbstractSeries* series, seriesList) {
599 598 m_dataset->addSeries(series);
600 599 }
601 600
602 601 if (sameAxis)
603 602 m_dataset->createDefaultAxes();
604 603
605 604 QList<QSignalSpy*> spyList;
606 605
607 606 foreach(QAbstractSeries* series, seriesList) {
608 607 spyList
609 608 << new QSignalSpy(m_dataset->domain(series),
610 609 SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
611 610 }
612 611
613 612 m_dataset->scrollDomain(10, 10, QSize(1000, 1000));
614 613
615 614 foreach(QSignalSpy* spy, spyList) {
616 615 TRY_COMPARE(spy->count(), 1);
617 616 }
618 617
619 618 qDeleteAll(spyList);
620 619 }
621 620
622 621 QTEST_MAIN(tst_ChartDataSet)
623 622 #include "tst_chartdataset.moc"
624 623
Show file before | Show file after | Hide comments
@@ -1,615 +1,791
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include <QtTest/QtTest>
22 22 #include <qchartview.h>
23 23 #include <qlineseries.h>
24 24 #include <qareaseries.h>
25 25 #include <qscatterseries.h>
26 26 #include <qsplineseries.h>
27 27 #include <qpieseries.h>
28 28 #include <qabstractbarseries.h>
29 29 #include <qbarseries.h>
30 30 #include <qpercentbarseries.h>
31 31 #include <qstackedbarseries.h>
32 32 #include <qvaluesaxis.h>
33 #include <qbarcategoriesaxis.h>
33 34
34 35 QTCOMMERCIALCHART_USE_NAMESPACE
35 36
36 37 Q_DECLARE_METATYPE(QAbstractAxis *)
37 38 Q_DECLARE_METATYPE(QValuesAxis *)
39 Q_DECLARE_METATYPE(QBarCategoriesAxis *)
38 40 Q_DECLARE_METATYPE(QAbstractSeries *)
39 41 Q_DECLARE_METATYPE(QChart::AnimationOption)
40 42 Q_DECLARE_METATYPE(QBrush)
41 43 Q_DECLARE_METATYPE(QPen)
42 44 Q_DECLARE_METATYPE(QChart::ChartTheme)
43 45
44 46 class tst_QChart : public QObject
45 47 {
46 48 Q_OBJECT
47 49
48 50 public slots:
49 51 void initTestCase();
50 52 void cleanupTestCase();
51 53 void init();
52 54 void cleanup();
53 55
54 56 private slots:
55 57 void qchart_data();
56 58 void qchart();
57
58 59 void addSeries_data();
59 60 void addSeries();
60 61 void animationOptions_data();
61 62 void animationOptions();
62 63 void axisX_data();
63 64 void axisX();
64 65 void axisY_data();
65 66 void axisY();
66 67 void backgroundBrush_data();
67 68 void backgroundBrush();
68 69 void backgroundPen_data();
69 70 void backgroundPen();
70 71 void isBackgroundVisible_data();
71 72 void isBackgroundVisible();
72 73 void legend_data();
73 74 void legend();
74 75 void margins_data();
75 76 void margins();
76 77 void removeAllSeries_data();
77 78 void removeAllSeries();
78 79 void removeSeries_data();
79 80 void removeSeries();
80 void scroll_data();
81 void scroll();
81 void scroll_right_data();
82 void scroll_right();
83 void scroll_left_data();
84 void scroll_left();
85 void scroll_up_data();
86 void scroll_up();
87 void scroll_down_data();
88 void scroll_down();
82 89 void theme_data();
83 90 void theme();
84 91 void title_data();
85 92 void title();
86 93 void titleBrush_data();
87 94 void titleBrush();
88 95 void titleFont_data();
89 96 void titleFont();
90 97 void zoomIn_data();
91 98 void zoomIn();
92 99 void zoomOut_data();
93 100 void zoomOut();
94 101
95 102 private:
96 103 void createTestData();
97 104
98 105 private:
99 106 QChartView* m_view;
100 107 QChart* m_chart;
101 108 };
102 109
103 110 void tst_QChart::initTestCase()
104 111 {
105 112
106 113 }
107 114
108 115 void tst_QChart::cleanupTestCase()
109 116 {
110 117
111 118 }
112 119
113 120 void tst_QChart::init()
114 121 {
115 122 m_view = new QChartView(new QChart());
116 123 m_chart = m_view->chart();
117 124 }
118 125
119 void tst_QChart::createTestData()
120 {
121 QLineSeries* series0 = new QLineSeries(this);
122 *series0 << QPointF(0, 0) << QPointF(100, 100);
123 m_chart->addSeries(series0);
124 m_view->show();
125 QTest::qWaitForWindowShown(m_view);
126 }
127
128 126 void tst_QChart::cleanup()
129 127 {
130 128 delete m_view;
131 129 m_view = 0;
132 130 m_chart = 0;
133 131 }
134 132
133
134 void tst_QChart::createTestData()
135 {
136 QLineSeries* series0 = new QLineSeries(this);
137 *series0 << QPointF(0, 0) << QPointF(100, 100);
138 m_chart->addSeries(series0);
139 m_view->show();
140 QTest::qWaitForWindowShown(m_view);
141 }
142
135 143 void tst_QChart::qchart_data()
136 144 {
137 145 }
138 146
139 147 void tst_QChart::qchart()
140 148 {
141 149 QVERIFY(m_chart);
142 150 QVERIFY(m_chart->legend());
143 151 QVERIFY(m_chart->legend()->isVisible());
144 152
145 153 QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation);
146 QVERIFY(m_chart->axisX());
147 QVERIFY(m_chart->axisY());
154 QVERIFY(!m_chart->axisX());
155 QVERIFY(!m_chart->axisY());
148 156 QVERIFY(m_chart->backgroundBrush()!=QBrush());
149 157 QVERIFY(m_chart->backgroundPen()!=QPen());
150 158 QCOMPARE(m_chart->isBackgroundVisible(), true);
151 159
152 160 QVERIFY(m_chart->margins().top()>0);
153 161 QVERIFY(m_chart->margins().left()>0);
154 162 QVERIFY(m_chart->margins().right()>0);
155 163 QVERIFY(m_chart->margins().bottom()>0);
156 164
157 165 QCOMPARE(m_chart->theme(), QChart::ChartThemeLight);
158 166 QCOMPARE(m_chart->title(), QString());
159 167
160 168 //QCOMPARE(m_chart->titleBrush(),QBrush());
161 169 //QCOMPARE(m_chart->titleFont(),QFont());
162 170
163 171 m_chart->removeAllSeries();
164 172 m_chart->scroll(0,0);
165 173
166 174 m_chart->zoomIn();
167 175 m_chart->zoomIn(QRectF());
168 176 m_chart->zoomOut();
169 177 }
170 178
171 179 void tst_QChart::addSeries_data()
172 180 {
173 181 QTest::addColumn<QAbstractSeries *>("series");
174 QTest::addColumn<QAbstractAxis *>("axis");
175
176 QAbstractSeries* series0 = new QLineSeries(this);
177 QAbstractSeries* series1 = new QAreaSeries(static_cast<QLineSeries*>(series0));
178 QAbstractSeries* series2 = new QScatterSeries(this);
179 QAbstractSeries* series3 = new QSplineSeries(this);
180 QAbstractSeries* series4 = new QPieSeries(this);
181 QAbstractSeries* series5 = new QBarSeries(this);
182 QAbstractSeries* series6 = new QPercentBarSeries(this);
183 QAbstractSeries* series7 = new QStackedBarSeries(this);
184
185 QValuesAxis* axis = new QValuesAxis(this);
186
187 QTest::newRow("default axis: lineSeries") << series0 << (QAbstractAxis*) 0;
188 QTest::newRow("axis0: lineSeries") << series0 << axis;
189 QTest::newRow("default axis: areaSeries") << series1 << (QAbstractAxis*) 0;
190 QTest::newRow("axis: areaSeries") << series1 << axis;
191 QTest::newRow("default axis: scatterSeries") << series2 << (QAbstractAxis*) 0;
192 QTest::newRow("axis1: scatterSeries") << series2 << axis;
193 QTest::newRow("default axis: splineSeries") << series3 << (QAbstractAxis*) 0;
194 QTest::newRow("axis: splineSeries") << series3 << axis;
195 QTest::newRow("default axis: pieSeries") << series4 << (QAbstractAxis*) 0;
196 QTest::newRow("axis: pieSeries") << series4 << axis;
197 QTest::newRow("default axis: barSeries") << series5 << (QAbstractAxis*) 0;
198 QTest::newRow("axis: barSeries") << series5 << axis;
199 QTest::newRow("default axis: percentBarSeries") << series6 << (QAbstractAxis*) 0;
200 QTest::newRow("axis: barSeries") << series6 << axis;
201 QTest::newRow("default axis: stackedBarSeries") << series7 << (QAbstractAxis*) 0;
202 QTest::newRow("axis: barSeries") << series7 << axis;
182
183 QAbstractSeries* line = new QLineSeries(this);
184 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
185 QAbstractSeries* scatter = new QScatterSeries(this);
186 QAbstractSeries* spline = new QSplineSeries(this);
187 QAbstractSeries* pie = new QPieSeries(this);
188 QAbstractSeries* bar = new QBarSeries(this);
189 QAbstractSeries* percent = new QPercentBarSeries(this);
190 QAbstractSeries* stacked = new QStackedBarSeries(this);
191
192 QTest::newRow("lineSeries") << line;
193 QTest::newRow("areaSeries") << area;
194 QTest::newRow("scatterSeries") << scatter;
195 QTest::newRow("splineSeries") << spline;
196 QTest::newRow("pieSeries") << pie;
197 QTest::newRow("barSeries") << bar;
198 QTest::newRow("percentBarSeries") << percent;
199 QTest::newRow("stackedBarSeries") << stacked;
203 200
204 201 }
205 202
206 203 void tst_QChart::addSeries()
207 204 {
208 205 QFETCH(QAbstractSeries *, series);
209 QFETCH(QAbstractAxis *, axis);
210 206 m_view->show();
211 207 QTest::qWaitForWindowShown(m_view);
212 if(!axis) axis = m_chart->axisY();
213 208 QVERIFY(!series->chart());
214 209 QCOMPARE(m_chart->series().count(), 0);
215 210 m_chart->addSeries(series);
216 m_chart->setAxisY(axis,series);
217 211 QCOMPARE(m_chart->series().count(), 1);
218 212 QCOMPARE(m_chart->series().first(), series);
219 213 QVERIFY(series->chart() == m_chart);
220 QCOMPARE(m_chart->axisY(series),axis);
214 m_chart->createDefaultAxes();
215 if(series->type()!=QAbstractSeries::SeriesTypePie){
216 QVERIFY(m_chart->axisY(series));
217 QVERIFY(m_chart->axisX(series));
218 }else{
219 QVERIFY(!m_chart->axisY(series));
220 QVERIFY(!m_chart->axisX(series));
221 }
221 222 m_chart->removeSeries(series);
222 223 QVERIFY(!series->chart());
223 224 QCOMPARE(m_chart->series().count(), 0);
224 225 }
225 226
226 227 void tst_QChart::animationOptions_data()
227 228 {
228 229 QTest::addColumn<QChart::AnimationOption>("animationOptions");
229 230 QTest::newRow("AllAnimations") << QChart::AllAnimations;
230 231 QTest::newRow("NoAnimation") << QChart::NoAnimation;
231 232 QTest::newRow("GridAxisAnimations") << QChart::GridAxisAnimations;
232 233 QTest::newRow("SeriesAnimations") << QChart::SeriesAnimations;
233 234 }
234 235
235 236 void tst_QChart::animationOptions()
236 237 {
237 238 createTestData();
238 239 QFETCH(QChart::AnimationOption, animationOptions);
239 240 m_chart->setAnimationOptions(animationOptions);
240 241 QCOMPARE(m_chart->animationOptions(), animationOptions);
241 242 }
242 243
243 244 void tst_QChart::axisX_data()
244 245 {
245 246
247 QTest::addColumn<QAbstractAxis*>("axis");
248 QTest::addColumn<QAbstractSeries *>("series");
249
250 QTest::newRow("categories,lineSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QLineSeries(this);
251 QTest::newRow("categories,areaSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
252 QTest::newRow("categories,scatterSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QScatterSeries(this);
253 QTest::newRow("categories,splineSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QSplineSeries(this);
254 QTest::newRow("categories,pieSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QPieSeries(this);
255 QTest::newRow("categories,barSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QBarSeries(this);
256 QTest::newRow("categories,percentBarSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
257 QTest::newRow("categories,stackedBarSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
258
259 QTest::newRow("value,lineSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QLineSeries(this);
260 QTest::newRow("value,areaSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
261 QTest::newRow("value,scatterSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QScatterSeries(this);
262 QTest::newRow("value,splineSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QSplineSeries(this);
263 QTest::newRow("value,pieSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QPieSeries(this);
264 QTest::newRow("value,barSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QBarSeries(this);
265 QTest::newRow("value,percentBarSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
266 QTest::newRow("value,stackedBarSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
267
246 268 }
247 269
248 270 void tst_QChart::axisX()
249 271 {
250 QVERIFY(m_chart->axisX());
251 QAbstractAxis* axis = m_chart->axisX();
252 createTestData();
253 //it should be the same axis
254 QCOMPARE(axis,m_chart->axisX());
272 QFETCH(QAbstractAxis*, axis);
273 QFETCH(QAbstractSeries*, series);
274 QVERIFY(!m_chart->axisX());
275 m_view->show();
276 QTest::qWaitForWindowShown(m_view);
277 m_chart->addSeries(series);
278 m_chart->setAxisX(axis,series);
279 QVERIFY(m_chart->axisX(series)==axis);
255 280 }
256 281
257 282 void tst_QChart::axisY_data()
258 283 {
259 QTest::addColumn<QAbstractAxis*>("axis0");
260 QTest::addColumn<QAbstractAxis*>("axis1");
261 QTest::addColumn<QAbstractAxis*>("axis2");
262 QTest::newRow("1 defualt, 2 optional") << (QAbstractAxis*)0 << new QValuesAxis() << new QValuesAxis();
263 QTest::newRow("3 optional") << new QValuesAxis() << new QValuesAxis() << new QValuesAxis();
284 axisX_data();
264 285 }
265 286
266 287
267 288 void tst_QChart::axisY()
268 289 {
269 QFETCH(QAbstractAxis*, axis0);
270 QFETCH(QAbstractAxis*, axis1);
271 QFETCH(QAbstractAxis*, axis2);
272
273 QAbstractAxis* defaultAxisY = m_chart->axisY();
274
275 QVERIFY2(defaultAxisY, "Missing axisY.");
276
277 QLineSeries* series0 = new QLineSeries();
278 m_chart->addSeries(series0);
279 m_chart->setAxisY(axis0,series0);
280
281 QLineSeries* series1 = new QLineSeries();
282 m_chart->addSeries(series1);
283 m_chart->setAxisY(axis1,series1);
284
285 QLineSeries* series2 = new QLineSeries();
286 m_chart->addSeries(series2);
287 m_chart->setAxisY(axis2,series2);
288
289 if (!axis0)
290 axis0 = defaultAxisY;
291 if (!axis1)
292 axis1 = defaultAxisY;
293 if (!axis2)
294 axis2 = defaultAxisY;
295
296 QVERIFY(m_chart->axisY(series0) == axis0);
297 QVERIFY(m_chart->axisY(series1) == axis1);
298 QVERIFY(m_chart->axisY(series2) == axis2);
290 QFETCH(QAbstractAxis*, axis);
291 QFETCH(QAbstractSeries*, series);
292 QVERIFY(!m_chart->axisY());
293 m_view->show();
294 QTest::qWaitForWindowShown(m_view);
295 m_chart->addSeries(series);
296 m_chart->setAxisY(axis,series);
297 QVERIFY(m_chart->axisY(series)==axis);
299 298 }
300 299
301 300 void tst_QChart::backgroundBrush_data()
302 301 {
303 302 QTest::addColumn<QBrush>("backgroundBrush");
304 303 QTest::newRow("null") << QBrush();
305 304 QTest::newRow("blue") << QBrush(Qt::blue);
306 305 QTest::newRow("white") << QBrush(Qt::white);
307 306 QTest::newRow("black") << QBrush(Qt::black);
308 307 }
309 308
310 309 void tst_QChart::backgroundBrush()
311 310 {
312 311 QFETCH(QBrush, backgroundBrush);
313 312 m_chart->setBackgroundBrush(backgroundBrush);
314 313 QCOMPARE(m_chart->backgroundBrush(), backgroundBrush);
315 314 }
316 315
317 316 void tst_QChart::backgroundPen_data()
318 317 {
319 318 QTest::addColumn<QPen>("backgroundPen");
320 319 QTest::newRow("null") << QPen();
321 320 QTest::newRow("blue") << QPen(Qt::blue);
322 321 QTest::newRow("white") << QPen(Qt::white);
323 322 QTest::newRow("black") << QPen(Qt::black);
324 323 }
325 324
326 325
327 326 void tst_QChart::backgroundPen()
328 327 {
329 328 QFETCH(QPen, backgroundPen);
330 329 m_chart->setBackgroundPen(backgroundPen);
331 330 QCOMPARE(m_chart->backgroundPen(), backgroundPen);
332 331 }
333 332
334 333 void tst_QChart::isBackgroundVisible_data()
335 334 {
336 335 QTest::addColumn<bool>("isBackgroundVisible");
337 336 QTest::newRow("true") << true;
338 337 QTest::newRow("false") << false;
339 338 }
340 339
341 340 void tst_QChart::isBackgroundVisible()
342 341 {
343 342 QFETCH(bool, isBackgroundVisible);
344 343 m_chart->setBackgroundVisible(isBackgroundVisible);
345 344 QCOMPARE(m_chart->isBackgroundVisible(), isBackgroundVisible);
346 345 }
347 346
348 347 void tst_QChart::legend_data()
349 348 {
350 349
351 350 }
352 351
353 352 void tst_QChart::legend()
354 353 {
355 354 QLegend *legend = m_chart->legend();
356 355 QVERIFY(legend);
357 356
358 357 // Colors related signals
359 358 QSignalSpy colorSpy(legend, SIGNAL(colorChanged(QColor)));
360 359 QSignalSpy borderColorSpy(legend, SIGNAL(borderColorChanged(QColor)));
361 360 QSignalSpy labelColorSpy(legend, SIGNAL(labelColorChanged(QColor)));
362 361
363 362 // colorChanged
364 363 legend->setColor(QColor("aliceblue"));
365 364 QCOMPARE(colorSpy.count(), 1);
366 365 QBrush b = legend->brush();
367 366 b.setColor(QColor("aqua"));
368 367 legend->setBrush(b);
369 368 QCOMPARE(colorSpy.count(), 2);
370 369
371 370 // borderColorChanged
372 371 legend->setBorderColor(QColor("aliceblue"));
373 372 QCOMPARE(borderColorSpy.count(), 1);
374 373 QPen p = legend->pen();
375 374 p.setColor(QColor("aqua"));
376 375 legend->setPen(p);
377 376 QCOMPARE(borderColorSpy.count(), 2);
378 377
379 378 // labelColorChanged
380 379 legend->setLabelColor(QColor("lightsalmon"));
381 380 QCOMPARE(labelColorSpy.count(), 1);
382 381 b = legend->labelBrush();
383 382 b.setColor(QColor("lightseagreen"));
384 383 legend->setLabelBrush(b);
385 384 QCOMPARE(labelColorSpy.count(), 2);
386 385
387 386 // fontChanged
388 387 QSignalSpy fontSpy(legend, SIGNAL(fontChanged(QFont)));
389 388 QFont f = legend->font();
390 389 f.setBold(!f.bold());
391 390 legend->setFont(f);
392 391 QCOMPARE(fontSpy.count(), 1);
393 392 }
394 393
395 394 void tst_QChart::margins_data()
396 395 {
397 396
398 397 }
399 398
400 399 void tst_QChart::margins()
401 400 {
402 401 createTestData();
403 402 QRectF rect = m_chart->geometry();
404
405 403 QVERIFY(m_chart->margins().top()+m_chart->margins().bottom() < rect.height());
406 404 QVERIFY(m_chart->margins().left()+m_chart->margins().right() < rect.width());
407 405 }
408 406
409 407 void tst_QChart::removeAllSeries_data()
410 408 {
411 409
412 410 }
413 411
414 412 void tst_QChart::removeAllSeries()
415 413 {
416 414 QLineSeries* series0 = new QLineSeries(this);
417 415 QLineSeries* series1 = new QLineSeries(this);
418 416 QLineSeries* series2 = new QLineSeries(this);
419 417 QSignalSpy deleteSpy1(series0, SIGNAL(destroyed()));
420 418 QSignalSpy deleteSpy2(series1, SIGNAL(destroyed()));
421 419 QSignalSpy deleteSpy3(series2, SIGNAL(destroyed()));
422 420
423 421 m_chart->addSeries(series0);
424 422 m_chart->addSeries(series1);
425 423 m_chart->addSeries(series2);
426 424 m_view->show();
427 425 QTest::qWaitForWindowShown(m_view);
428
426 m_chart->createDefaultAxes();
429 427 QVERIFY(m_chart->axisY(series0)!=0);
430 428 QVERIFY(m_chart->axisY(series1)!=0);
431 429 QVERIFY(m_chart->axisY(series2)!=0);
432 430
433 431 m_chart->removeAllSeries();
434 432 QVERIFY(m_chart->axisY(series0)==0);
435 433 QVERIFY(m_chart->axisY(series1)==0);
436 434 QVERIFY(m_chart->axisY(series2)==0);
437 435 QCOMPARE(deleteSpy1.count(), 1);
438 436 QCOMPARE(deleteSpy2.count(), 1);
439 437 QCOMPARE(deleteSpy3.count(), 1);
440 438 }
441 439
442 440 void tst_QChart::removeSeries_data()
443 441 {
444 addSeries_data();
442 axisX_data();
445 443 }
446 444
447 445 void tst_QChart::removeSeries()
448 446 {
449 QFETCH(QAbstractSeries *, series);
450 447 QFETCH(QAbstractAxis *, axis);
448 QFETCH(QAbstractSeries *, series);
451 449 QSignalSpy deleteSpy(series, SIGNAL(destroyed()));
452 450 m_view->show();
453 451 QTest::qWaitForWindowShown(m_view);
454 452 if(!axis) axis = m_chart->axisY();
455 453 m_chart->addSeries(series);
456 454 m_chart->setAxisY(axis,series);
457 455 QCOMPARE(m_chart->axisY(series),axis);
458 456 m_chart->removeSeries(series);
459 457 QVERIFY(m_chart->axisY(series)==0);
460 458 QCOMPARE(deleteSpy.count(), 0);
461 459 }
462 460
463 void tst_QChart::scroll_data()
461 void tst_QChart::scroll_right_data()
464 462 {
463 QTest::addColumn<QAbstractSeries *>("series");
464
465 QLineSeries* series0 = new QLineSeries(this);
466 *series0 << QPointF(0, 0) << QPointF(100, 100);
467
468 QLineSeries* series1 = new QLineSeries(this);
469 *series1 << QPointF(0, 0) << QPointF(100, 100);
470
471 QTest::newRow("lineSeries") << (QAbstractSeries*) series0;
472
465 473
466 474 }
467 475
468 void tst_QChart::scroll()
476 void tst_QChart::scroll_right()
469 477 {
470 qFatal("implement me");
471 createTestData();
472 //TODO qreal min = m_chart->axisY()->min();
473 m_chart->scroll(0,0);
474 //TODO QVERIFY(m_chart->axisY()->min()<min);
478 QFETCH(QAbstractSeries *, series);
479 m_chart->addSeries(series);
480 m_chart->createDefaultAxes();
481 m_view->show();
482 QTest::qWaitForWindowShown(m_view);
483 QAbstractAxis * axis = m_chart->axisX();
484 QVERIFY(axis!=0);
485
486 switch(axis->type())
487 {
488 case QAbstractAxis::AxisTypeValues:{
489 QValuesAxis* vaxis = qobject_cast<QValuesAxis*>(axis);
490 QVERIFY(vaxis!=0);
491 qreal min = vaxis->min();
492 qreal max = vaxis->max();
493 QVERIFY(max>min);
494 m_chart->scroll(50, 0);
495 QVERIFY(min<vaxis->min());
496 QVERIFY(max<vaxis->max());
497 break;
498 }
499 case QAbstractAxis::AxisTypeCategories:{
500 QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
501 QVERIFY(caxis!=0);
502 qreal min = caxis->min().toDouble();
503 qreal max = caxis->max().toDouble();
504 m_chart->scroll(50, 0);
505 QVERIFY(min<caxis->min().toDouble());
506 QVERIFY(max<caxis->max().toDouble());
507 break;
508 }
509 default:
510 qFatal("Unsupported type");
511 break;
512 }
513 }
514
515 void tst_QChart::scroll_left_data()
516 {
517 scroll_right_data();
518 }
519
520 void tst_QChart::scroll_left()
521 {
522 QFETCH(QAbstractSeries *, series);
523 m_chart->addSeries(series);
524 m_chart->createDefaultAxes();
525 m_view->show();
526 QTest::qWaitForWindowShown(m_view);
527 QAbstractAxis * axis = m_chart->axisX();
528 QVERIFY(axis!=0);
529
530 switch(axis->type())
531 {
532 case QAbstractAxis::AxisTypeValues:{
533 QValuesAxis* vaxis = qobject_cast<QValuesAxis*>(axis);
534 QVERIFY(vaxis!=0);
535 qreal min = vaxis->min();
536 qreal max = vaxis->max();
537 m_chart->scroll(-50, 0);
538 QVERIFY(min>vaxis->min());
539 QVERIFY(max>vaxis->max());
540 break;
541 }
542 case QAbstractAxis::AxisTypeCategories:{
543 QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
544 QVERIFY(caxis!=0);
545 qreal min = caxis->min().toDouble();
546 qreal max = caxis->max().toDouble();
547 m_chart->scroll(-50, 0);
548 QVERIFY(min>caxis->min().toDouble());
549 QVERIFY(max>caxis->max().toDouble());
550 break;
551 }
552 default:
553 qFatal("Unsupported type");
554 break;
555 }
556 }
557
558 void tst_QChart::scroll_up_data()
559 {
560 scroll_right_data();
561 }
562
563 void tst_QChart::scroll_up()
564 {
565 QFETCH(QAbstractSeries *, series);
566 m_chart->addSeries(series);
567 m_chart->createDefaultAxes();
568 m_view->show();
569 QTest::qWaitForWindowShown(m_view);
570 QAbstractAxis * axis = m_chart->axisY();
571 QVERIFY(axis!=0);
572
573 switch(axis->type())
574 {
575 case QAbstractAxis::AxisTypeValues:{
576 QValuesAxis* vaxis = qobject_cast<QValuesAxis*>(axis);
577 QVERIFY(vaxis!=0);
578 qreal min = vaxis->min();
579 qreal max = vaxis->max();
580 m_chart->scroll(0, 50);
581 QVERIFY(min<vaxis->min());
582 QVERIFY(max<vaxis->max());
583 break;
584 }
585 case QAbstractAxis::AxisTypeCategories:{
586 QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
587 QVERIFY(caxis!=0);
588 qreal min = caxis->min().toDouble();
589 qreal max = caxis->max().toDouble();
590 m_chart->scroll(0, 50);
591 QVERIFY(min<caxis->min().toDouble());
592 QVERIFY(max<caxis->max().toDouble());
593 break;
594 }
595 default:
596 qFatal("Unsupported type");
597 break;
598 }
599 }
600
601 void tst_QChart::scroll_down_data()
602 {
603 scroll_right_data();
604 }
605
606 void tst_QChart::scroll_down()
607 {
608 QFETCH(QAbstractSeries *, series);
609 m_chart->addSeries(series);
610 m_chart->createDefaultAxes();
611 m_view->show();
612 QTest::qWaitForWindowShown(m_view);
613 QAbstractAxis * axis = m_chart->axisY();
614 QVERIFY(axis!=0);
615
616 switch(axis->type())
617 {
618 case QAbstractAxis::AxisTypeValues:{
619 QValuesAxis* vaxis = qobject_cast<QValuesAxis*>(axis);
620 QVERIFY(vaxis!=0);
621 qreal min = vaxis->min();
622 qreal max = vaxis->max();
623 m_chart->scroll(0, -50);
624 QVERIFY(min>vaxis->min());
625 QVERIFY(max>vaxis->max());
626 break;
627 }
628 case QAbstractAxis::AxisTypeCategories:{
629 QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
630 QVERIFY(caxis!=0);
631 qreal min = caxis->min().toDouble();
632 qreal max = caxis->max().toDouble();
633 m_chart->scroll(0, -50);
634 QVERIFY(min>caxis->min().toDouble());
635 QVERIFY(max>caxis->max().toDouble());
636 break;
637 }
638 default:
639 qFatal("Unsupported type");
640 break;
641 }
475 642 }
476 643
477 644 void tst_QChart::theme_data()
478 645 {
479 646 QTest::addColumn<QChart::ChartTheme>("theme");
480 647 QTest::newRow("ChartThemeBlueCerulean") << QChart::ChartThemeBlueCerulean;
481 648 QTest::newRow("ChartThemeBlueIcy") << QChart::ChartThemeBlueIcy;
482 649 QTest::newRow("ChartThemeBlueNcs") << QChart::ChartThemeBlueNcs;
483 650 QTest::newRow("ChartThemeBrownSand") << QChart::ChartThemeBrownSand;
484 651 QTest::newRow("ChartThemeDark") << QChart::ChartThemeDark;
485 652 QTest::newRow("hartThemeHighContrast") << QChart::ChartThemeHighContrast;
486 653 QTest::newRow("ChartThemeLight") << QChart::ChartThemeLight;
487 654 }
488 655
489 656 void tst_QChart::theme()
490 657 {
491 658 QFETCH(QChart::ChartTheme, theme);
492 659 createTestData();
493 660 m_chart->setTheme(theme);
494 661 QVERIFY(m_chart->theme()==theme);
495 662 }
496 663
497 664 void tst_QChart::title_data()
498 665 {
499 666 QTest::addColumn<QString>("title");
500 667 QTest::newRow("null") << QString();
501 668 QTest::newRow("foo") << QString("foo");
502 669 }
503 670
504 671 void tst_QChart::title()
505 672 {
506 673 QFETCH(QString, title);
507 674 m_chart->setTitle(title);
508 675 QCOMPARE(m_chart->title(), title);
509 676 }
510 677
511 678 void tst_QChart::titleBrush_data()
512 679 {
513 680 QTest::addColumn<QBrush>("titleBrush");
514 681 QTest::newRow("null") << QBrush();
515 682 QTest::newRow("blue") << QBrush(Qt::blue);
516 683 QTest::newRow("white") << QBrush(Qt::white);
517 684 QTest::newRow("black") << QBrush(Qt::black);
518 685 }
519 686
520 687 void tst_QChart::titleBrush()
521 688 {
522 689 QFETCH(QBrush, titleBrush);
523 690 m_chart->setTitleBrush(titleBrush);
524 691 QCOMPARE(m_chart->titleBrush(), titleBrush);
525 692 }
526 693
527 694 void tst_QChart::titleFont_data()
528 695 {
529 696 QTest::addColumn<QFont>("titleFont");
530 697 QTest::newRow("null") << QFont();
531 698 QTest::newRow("courier") << QFont("Courier", 8, QFont::Bold, true);
532 699 }
533 700
534 701 void tst_QChart::titleFont()
535 702 {
536 703 QFETCH(QFont, titleFont);
537 704 m_chart->setTitleFont(titleFont);
538 705 QCOMPARE(m_chart->titleFont(), titleFont);
539 706 }
540 707
541 708 void tst_QChart::zoomIn_data()
542 709 {
543 710 QTest::addColumn<QRectF>("rect");
544 711 QTest::newRow("null") << QRectF();
545 712 QTest::newRow("100x100") << QRectF(10,10,100,100);
546 713 QTest::newRow("200x200") << QRectF(10,10,200,200);
547 714 }
548 715
549 716
550 717 void tst_QChart::zoomIn()
551 718 {
552 qFatal("implement me");
553 /*
719
554 720 QFETCH(QRectF, rect);
555 721 createTestData();
722 m_chart->createDefaultAxes();
556 723 QRectF marigns = m_chart->margins();
557 724 rect.adjust(marigns.left(),marigns.top(),-marigns.right(),-marigns.bottom());
558 qreal minX = m_chart->axisX()->min();
559 qreal minY = m_chart->axisY()->min();
560 qreal maxX = m_chart->axisX()->max();
561 qreal maxY = m_chart->axisY()->max();
725 QValuesAxis* axisX = qobject_cast<QValuesAxis*>(m_chart->axisX());
726 QVERIFY(axisX!=0);
727 QValuesAxis* axisY = qobject_cast<QValuesAxis*>(m_chart->axisY());
728 QVERIFY(axisY!=0);
729 qreal minX = axisX->min();
730 qreal minY = axisY->min();
731 qreal maxX = axisX->max();
732 qreal maxY = axisY->max();
562 733 m_chart->zoomIn(rect);
563 734 if(rect.isValid()){
564 QVERIFY(minX<m_chart->axisX()->min());
565 QVERIFY(maxX>m_chart->axisX()->max());
566 QVERIFY(minY<m_chart->axisY()->min());
567 QVERIFY(maxY>m_chart->axisY()->max());
735 QVERIFY(minX<axisX->min());
736 QVERIFY(maxX>axisX->max());
737 QVERIFY(minY<axisY->min());
738 QVERIFY(maxY>axisY->max());
568 739 }
569 */
740
570 741 }
571 742
572 743 void tst_QChart::zoomOut_data()
573 744 {
574 745
575 746 }
576 747
577 748 void tst_QChart::zoomOut()
578 749 {
579 qFatal("implement me");
580 750 createTestData();
581 /*
582 qreal minX = m_chart->axisX()->min();
583 qreal minY = m_chart->axisY()->min();
584 qreal maxX = m_chart->axisX()->max();
585 qreal maxY = m_chart->axisY()->max();
751 m_chart->createDefaultAxes();
752
753 QValuesAxis* axisX = qobject_cast<QValuesAxis*>(m_chart->axisX());
754 QVERIFY(axisX!=0);
755 QValuesAxis* axisY = qobject_cast<QValuesAxis*>(m_chart->axisY());
756 QVERIFY(axisY!=0);
757
758 qreal minX = axisX->min();
759 qreal minY = axisY->min();
760 qreal maxX = axisX->max();
761 qreal maxY = axisY->max();
586 762
587 763 m_chart->zoomIn();
588 764
589 QVERIFY(minX < m_chart->axisX()->min());
590 QVERIFY(maxX > m_chart->axisX()->max());
591 QVERIFY(minY < m_chart->axisY()->min());
592 QVERIFY(maxY > m_chart->axisY()->max());
765 QVERIFY(minX < axisX->min());
766 QVERIFY(maxX > axisX->max());
767 QVERIFY(minY < axisY->min());
768 QVERIFY(maxY > axisY->max());
593 769
594 770 m_chart->zoomOut();
595 771
596 772 // min x may be a zero value
597 773 if (qFuzzyIsNull(minX))
598 QVERIFY(qFuzzyIsNull(m_chart->axisX()->min()));
774 QVERIFY(qFuzzyIsNull(axisX->min()));
599 775 else
600 QCOMPARE(minX, m_chart->axisX()->min());
776 QCOMPARE(minX, axisX->min());
601 777
602 778 // min y may be a zero value
603 779 if (qFuzzyIsNull(minY))
604 QVERIFY(qFuzzyIsNull(m_chart->axisY()->min()));
780 QVERIFY(qFuzzyIsNull(axisY->min()));
605 781 else
606 QCOMPARE(minY, m_chart->axisY()->min());
782 QCOMPARE(minY, axisY->min());
783
784 QVERIFY(maxX == axisX->max());
785 QVERIFY(maxY == axisY->max());
607 786
608 QVERIFY(maxX == m_chart->axisX()->max());
609 QVERIFY(maxY == m_chart->axisY()->max());
610 */
611 787 }
612 788
613 789 QTEST_MAIN(tst_QChart)
614 790 #include "tst_qchart.moc"
615 791
General Comments 0
You need to be logged in to leave comments. Login now