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

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

Put back the tests for tst_qbarseries
Michal Klocek -
r1179:543d38d08025
parent child
Show More
Side by Side Unified
Context file:
r1179:543d38d08025 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,682 +1,677
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 <qbarseries.h>
23 23 #include <qbarset.h>
24 24 #include <qchartview.h>
25 25 #include <qchart.h>
26 26
27 27 QTCOMMERCIALCHART_USE_NAMESPACE
28 28
29 29 Q_DECLARE_METATYPE(QBarSet*)
30 30
31 31 class tst_QBarSeries : public QObject
32 32 {
33 33 Q_OBJECT
34 34
35 35 public slots:
36 36 void initTestCase();
37 37 void cleanupTestCase();
38 38 void init();
39 39 void cleanup();
40 40
41 41 private slots:
42 42 void qbarseries_data();
43 43 void qbarseries();
44 44 void type_data();
45 45 void type();
46 46 void setCategories_data();
47 47 void setCategories();
48 48 void appendBarSet_data();
49 49 void appendBarSet();
50 50 void removeBarSet_data();
51 51 void removeBarSet();
52 52 void appendBarSets_data();
53 53 void appendBarSets();
54 54 void removeBarSets_data();
55 55 void removeBarSets();
56 56 void barsetCount_data();
57 57 void barsetCount();
58 58 void categoryCount_data();
59 59 void categoryCount();
60 60 void barSets_data();
61 61 void barSets();
62 62 void categories_data();
63 63 void categories();
64 64 void setLabelsVisible_data();
65 65 void setLabelsVisible();
66 private:
67 66 void mouseclicked_data();
68 67 void mouseclicked();
69 68 void mousehovered_data();
70 69 void mousehovered();
71 70
72 71 private:
73 72 QBarSeries* m_barseries;
74 73 QBarSeries* m_barseries_with_sets;
75 74
76 75 QList<QBarSet*> m_testSets;
77 76
78 77 QBarCategories m_categories;
79 78 };
80 79
81 80 void tst_QBarSeries::initTestCase()
82 81 {
83 82 qRegisterMetaType<QBarSet*>("QBarSet*");
84 83 }
85 84
86 85 void tst_QBarSeries::cleanupTestCase()
87 86 {
88 87 }
89 88
90 89 void tst_QBarSeries::init()
91 90 {
92 91 m_categories << "category0" << "category1" << "category2";
93 92 m_barseries = new QBarSeries();
94 93 m_barseries->setCategories(m_categories);
95 94 m_barseries_with_sets = new QBarSeries();
96 95 m_barseries_with_sets->setCategories(m_categories);
97 96
98 97 for (int i=0; i<5; i++) {
99 98 m_testSets.append(new QBarSet("testset"));
100 99 m_barseries_with_sets->appendBarSet(m_testSets.at(i));
101 100 }
102 101 }
103 102
104 103 void tst_QBarSeries::cleanup()
105 104 {
106 105 foreach(QBarSet* s, m_testSets) {
107 106 m_barseries_with_sets->removeBarSet(s);
108 107 delete s;
109 108 }
110 109 m_testSets.clear();
111 110
112 111 delete m_barseries;
113 112 m_barseries = 0;
114 113 delete m_barseries_with_sets;
115 114 m_barseries_with_sets = 0;
116 115 m_categories.clear();
117 116 }
118 117
119 118 void tst_QBarSeries::qbarseries_data()
120 119 {
121 120 QTest::addColumn<QBarCategories> ("categories");
122 121 QBarCategories c;
123 122 c << "category0" << "category1" << "category2";
124 123 QTest::newRow("categories") << c;
125 124 }
126 125
127 126 void tst_QBarSeries::qbarseries()
128 127 {
129 128 QFETCH(QBarCategories, categories);
130 129 QBarSeries *barseries = new QBarSeries();
131 130 QVERIFY(barseries != 0);
132 131 barseries->setCategories(categories);
133 132 QBarCategories verifyCategories = barseries->categories();
134 133
135 134 QVERIFY(verifyCategories.count() == categories.count());
136 135 for (int i=0; i<categories.count(); i++) {
137 136 QVERIFY(verifyCategories.at(i).compare(categories.at(i)) == 0);
138 137 }
139 138 }
140 139
141 140 void tst_QBarSeries::type_data()
142 141 {
143 142
144 143 }
145 144
146 145 void tst_QBarSeries::type()
147 146 {
148 147 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeBar);
149 148 }
150 149
151 150 void tst_QBarSeries::setCategories_data()
152 151 {
153 152 QTest::addColumn<QBarCategories> ("categories");
154 153 QBarCategories categories;
155 154 categories << "c1" << "c2" << "c3" << "c4" << "c5" << "c6";
156 155 QTest::newRow("cat") << categories;
157 156 }
158 157
159 158 void tst_QBarSeries::setCategories()
160 159 {
161 160 QVERIFY(m_barseries->categories().count() == m_categories.count());
162 161
163 162 QFETCH(QBarCategories, categories);
164 163 m_barseries->setCategories(categories);
165 164
166 165 QVERIFY(m_barseries->categories().count() == categories.count());
167 166 for (int i=0; i<categories.count(); i++) {
168 167 QVERIFY(m_barseries->categories().at(i).compare(categories.at(i)) == 0);
169 168 }
170 169 }
171 170
172 171 void tst_QBarSeries::appendBarSet_data()
173 172 {
174 173 }
175 174
176 175 void tst_QBarSeries::appendBarSet()
177 176 {
178 177 QVERIFY(m_barseries->barsetCount() == 0);
179 178
180 179 bool ret = false;
181 180
182 181 // Try adding barset
183 182 QBarSet *barset = new QBarSet("testset");
184 183 ret = m_barseries->appendBarSet(barset);
185 184
186 185 QVERIFY(ret == true);
187 186 QVERIFY(m_barseries->barsetCount() == 1);
188 187
189 188 // Try adding another set
190 189 QBarSet *barset2 = new QBarSet("testset2");
191 190 ret = m_barseries->appendBarSet(barset2);
192 191
193 192 QVERIFY(ret == true);
194 193 QVERIFY(m_barseries->barsetCount() == 2);
195 194
196 195 // Try adding same set again
197 196 ret = m_barseries->appendBarSet(barset2);
198 197 QVERIFY(ret == false);
199 198 QVERIFY(m_barseries->barsetCount() == 2);
200 199
201 200 // Try adding null set
202 201 ret = m_barseries->appendBarSet(0);
203 202 QVERIFY(ret == false);
204 203 QVERIFY(m_barseries->barsetCount() == 2);
205 204
206 205 }
207 206
208 207 void tst_QBarSeries::removeBarSet_data()
209 208 {
210 209 }
211 210
212 211 void tst_QBarSeries::removeBarSet()
213 212 {
214 213 int count = m_testSets.count();
215 214 QVERIFY(m_barseries_with_sets->barsetCount() == count);
216 215
217 216 // Try to remove null pointer (should not remove, should not crash)
218 217 bool ret = false;
219 218 ret = m_barseries_with_sets->removeBarSet(0);
220 219 QVERIFY(ret == false);
221 220 QVERIFY(m_barseries_with_sets->barsetCount() == count);
222 221
223 222 // Try to remove invalid pointer (should not remove, should not crash)
224 223 ret = m_barseries_with_sets->removeBarSet((QBarSet*) (m_testSets.at(0) + 1) );
225 224 QVERIFY(ret == false);
226 225 QVERIFY(m_barseries_with_sets->barsetCount() == count);
227 226
228 227 // remove some sets
229 228 ret = m_barseries_with_sets->removeBarSet(m_testSets.at(2));
230 229 QVERIFY(ret == true);
231 230 ret = m_barseries_with_sets->removeBarSet(m_testSets.at(3));
232 231 QVERIFY(ret == true);
233 232 ret = m_barseries_with_sets->removeBarSet(m_testSets.at(4));
234 233 QVERIFY(ret == true);
235 234
236 235 QVERIFY(m_barseries_with_sets->barsetCount() == 2);
237 236
238 237 QList<QBarSet*> verifysets = m_barseries_with_sets->barSets();
239 238
240 239 QVERIFY(verifysets.at(0) == m_testSets.at(0));
241 240 QVERIFY(verifysets.at(1) == m_testSets.at(1));
242 241
243 242 // Try removing all sets again (should be ok, even if some sets have already been removed)
244 243 ret = false;
245 244 for (int i=0; i<count; i++) {
246 245 ret |= m_barseries_with_sets->removeBarSet(m_testSets.at(i));
247 246 }
248 247
249 248 QVERIFY(ret == true);
250 249 QVERIFY(m_barseries_with_sets->barsetCount() == 0);
251 250 }
252 251
253 252 void tst_QBarSeries::appendBarSets_data()
254 253 {
255 254
256 255 }
257 256
258 257 void tst_QBarSeries::appendBarSets()
259 258 {
260 259 int count = 5;
261 260 QVERIFY(m_barseries->barsetCount() == 0);
262 261
263 262 QList<QBarSet*> sets;
264 263 for (int i=0; i<count; i++) {
265 264 sets.append(new QBarSet("testset"));
266 265 }
267 266
268 267 // Append new sets (should succeed, count should match the count of sets)
269 268 bool ret = false;
270 269 ret = m_barseries->appendBarSets(sets);
271 270 QVERIFY(ret == true);
272 271 QVERIFY(m_barseries->barsetCount() == count);
273 272
274 273 // Append same sets again (should fail, count should remain same)
275 274 ret = m_barseries->appendBarSets(sets);
276 275 QVERIFY(ret == false);
277 276 QVERIFY(m_barseries->barsetCount() == count);
278 277
279 278 // Try append empty list (should succeed, but count should remain same)
280 279 QList<QBarSet*> invalidList;
281 280 ret = m_barseries->appendBarSets(invalidList);
282 281 QVERIFY(ret == true);
283 282 QVERIFY(m_barseries->barsetCount() == count);
284 283
285 284 // Try append list with one new and one existing set (should fail, count remains same)
286 285 invalidList.append(new QBarSet("ok set"));
287 286 invalidList.append(sets.at(0));
288 287 ret = m_barseries->appendBarSets(invalidList);
289 288 QVERIFY(ret == false);
290 289 QVERIFY(m_barseries->barsetCount() == count);
291 290
292 291 // Try append list with null pointers (should fail, count remains same)
293 292 QList<QBarSet*> invalidList2;
294 293 invalidList2.append(0);
295 294 invalidList2.append(0);
296 295 invalidList2.append(0);
297 296 ret = m_barseries->appendBarSets(invalidList2);
298 297 QVERIFY(ret == false);
299 298 QVERIFY(m_barseries->barsetCount() == count);
300 299 }
301 300
302 301 void tst_QBarSeries::removeBarSets_data()
303 302 {
304 303
305 304 }
306 305
307 306 void tst_QBarSeries::removeBarSets()
308 307 {
309 308 int count = m_testSets.count();
310 309 QVERIFY(m_barseries_with_sets->barsetCount() == count);
311 310
312 311 // Try removing empty list of sets (should return false, since no barsets were removed)
313 312 bool ret = false;
314 313 QList<QBarSet*> invalidList;
315 314 ret = m_barseries_with_sets->removeBarSets(invalidList);
316 315 QVERIFY(ret == false);
317 316 QVERIFY(m_barseries_with_sets->barsetCount() == count);
318 317
319 318 // Add some null pointers to list
320 319 invalidList.append(0);
321 320 invalidList.append(0);
322 321 invalidList.append(0);
323 322
324 323 // Try removing null pointers from list (should return false, should not crash, should not remove anything)
325 324 ret = m_barseries_with_sets->removeBarSets(invalidList);
326 325 QVERIFY(ret == false);
327 326 QVERIFY(m_barseries_with_sets->barsetCount() == count);
328 327
329 328 // remove all sets (should return true, since sets were removed)
330 329 ret = m_barseries_with_sets->removeBarSets(m_testSets);
331 330 QVERIFY(ret == true);
332 331 QVERIFY(m_barseries_with_sets->barsetCount() == 0);
333 332
334 333 // Try removing invalid list again (should return false, since no barsets were removed)
335 334 ret = m_barseries_with_sets->removeBarSets(invalidList);
336 335 QVERIFY(ret == false);
337 336 QVERIFY(m_barseries_with_sets->barsetCount() == 0);
338 337
339 338 // remove all sets again (should return false, since barsets were already removed)
340 339 ret = m_barseries_with_sets->removeBarSets(m_testSets);
341 340 QVERIFY(ret == false);
342 341 QVERIFY(m_barseries_with_sets->barsetCount() == 0);
343 342 }
344 343
345 344 void tst_QBarSeries::barsetCount_data()
346 345 {
347 346
348 347 }
349 348
350 349 void tst_QBarSeries::barsetCount()
351 350 {
352 351 QVERIFY(m_barseries->barsetCount() == 0);
353 352 QVERIFY(m_barseries_with_sets->barsetCount() == m_testSets.count());
354 353 }
355 354
356 355 void tst_QBarSeries::categoryCount_data()
357 356 {
358 357
359 358 }
360 359
361 360 void tst_QBarSeries::categoryCount()
362 361 {
363 362 QVERIFY(m_barseries->categoryCount() == m_categories.count());
364 363 QVERIFY(m_barseries_with_sets->categoryCount() == m_categories.count());
365 364 }
366 365
367 366 void tst_QBarSeries::barSets_data()
368 367 {
369 368
370 369 }
371 370
372 371 void tst_QBarSeries::barSets()
373 372 {
374 373 QVERIFY(m_barseries->barSets().count() == 0);
375 374
376 375 QList<QBarSet*> sets = m_barseries_with_sets->barSets();
377 376 QVERIFY(sets.count() == m_testSets.count());
378 377
379 378 for (int i=0; i<m_testSets.count(); i++) {
380 379 QVERIFY(sets.at(i) == m_testSets.at(i));
381 380 }
382 381 }
383 382
384 383 void tst_QBarSeries::categories_data()
385 384 {
386 385
387 386 }
388 387
389 388 void tst_QBarSeries::categories()
390 389 {
391 390 QBarCategories categories = m_barseries->categories();
392 391
393 392 QVERIFY(categories.count() == m_categories.count());
394 393 for (int i=0; i<m_categories.count(); i++) {
395 394 QVERIFY(categories.at(i).compare(m_categories.at(i)) == 0);
396 395 }
397 396 }
398 397
399 398 void tst_QBarSeries::setLabelsVisible_data()
400 399 {
401 400
402 401 }
403 402
404 403 void tst_QBarSeries::setLabelsVisible()
405 404 {
406 405 // labels should be invisible by default
407 406 foreach (QBarSet* s, m_testSets) {
408 407 QVERIFY(s->labelsVisible() == false);
409 408 }
410 409
411 410 // turn labels to visible
412 411 m_barseries_with_sets->setLabelsVisible(true);
413 412 foreach (QBarSet* s, m_testSets) {
414 413 QVERIFY(s->labelsVisible() == true);
415 414 }
416 415
417 416 // turn labels to invisible
418 417 m_barseries_with_sets->setLabelsVisible(false);
419 418 foreach (QBarSet* s, m_testSets) {
420 419 QVERIFY(s->labelsVisible() == false);
421 420 }
422 421
423 422 // without parameter, should turn labels to visible
424 423 m_barseries_with_sets->setLabelsVisible();
425 424 foreach (QBarSet* s, m_testSets) {
426 425 QVERIFY(s->labelsVisible() == true);
427 426 }
428 427 }
429 428
430 429 void tst_QBarSeries::mouseclicked_data()
431 430 {
432 431
433 432 }
434 433
435 434 void tst_QBarSeries::mouseclicked()
436 435 {
437
438 436 QBarSeries* series = new QBarSeries();
439 437 QBarCategories categories;
440 438 categories << "test1" << "test2" << "test3";
441 439 series->setCategories(categories);
442 440
443 441 QBarSet* set1 = new QBarSet(QString("set 1"));
444 442 *set1 << QPointF(0,10) << QPointF(1,10) << QPointF(2,10);
445 443 series->appendBarSet(set1);
446 444
447 445 QBarSet* set2 = new QBarSet(QString("set 2"));
448 446 *set2 << QPointF(0.5,10) << QPointF(1.5,10) << QPointF(2.5,10);
449 447 series->appendBarSet(set2);
450 448
451 449 QSignalSpy setSpy1(set1, SIGNAL(clicked(QString)));
452 450 QSignalSpy setSpy2(set2, SIGNAL(clicked(QString)));
453 451 QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,QString)));
454 452
455 453 QChartView view(new QChart());
456 454 view.resize(400,300);
457 455 view.chart()->addSeries(series);
458 456 view.show();
459 457 QTest::qWaitForWindowShown(&view);
460 458
461 459 //====================================================================================
462 460 // barset 1, category test1
463 461 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(75,180));
464 462 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
465 463
466 464 QCOMPARE(setSpy1.count(), 1);
467 465 QCOMPARE(setSpy2.count(), 0);
468 466 QCOMPARE(seriesSpy.count(), 1);
469 467 QList<QVariant> setSpyArg = setSpy1.takeFirst();
470 468 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
471 469 QVERIFY(setSpyArg.at(0).toString().compare(QString("test1")) == 0);
472 470
473 471 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
474 472 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
475 473
476 474 //====================================================================================
477 475 // barset 1, category test2
478 476 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(160,180));
479 477 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
480 478
481 479 QCOMPARE(setSpy1.count(), 1);
482 480 QCOMPARE(setSpy2.count(), 0);
483 481 QCOMPARE(seriesSpy.count(), 1);
484 482 setSpyArg = setSpy1.takeFirst();
485 483 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
486 484 QVERIFY(setSpyArg.at(0).toString().compare(QString("test2")) == 0);
487 485
488 486 seriesSpyArg = seriesSpy.takeFirst();
489 487 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
490 488
491 489 //====================================================================================
492 490 // barset 1, category test3
493 491 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(255,180));
494 492 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
495 493
496 494 QCOMPARE(setSpy1.count(), 1);
497 495 QCOMPARE(setSpy2.count(), 0);
498 496 QCOMPARE(seriesSpy.count(), 1);
499 497 setSpyArg = setSpy1.takeFirst();
500 498 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
501 499 QVERIFY(setSpyArg.at(0).toString().compare(QString("test3")) == 0);
502 500
503 501 seriesSpyArg = seriesSpy.takeFirst();
504 502 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
505 503
506 504 //====================================================================================
507 505 // barset 2, category test1
508 506 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(115,180));
509 507 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
510 508
511 509 QCOMPARE(setSpy1.count(), 0);
512 510 QCOMPARE(setSpy2.count(), 1);
513 511 QCOMPARE(seriesSpy.count(), 1);
514 512 setSpyArg = setSpy2.takeFirst();
515 513 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
516 514 QVERIFY(setSpyArg.at(0).toString().compare(QString("test1")) == 0);
517 515
518 516 seriesSpyArg = seriesSpy.takeFirst();
519 517 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
520 518
521 519 //====================================================================================
522 520 // barset 2, category test2
523 521 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(205,180));
524 522 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
525 523
526 524 QCOMPARE(setSpy1.count(), 0);
527 525 QCOMPARE(setSpy2.count(), 1);
528 526 QCOMPARE(seriesSpy.count(), 1);
529 527 setSpyArg = setSpy2.takeFirst();
530 528 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
531 529 QVERIFY(setSpyArg.at(0).toString().compare(QString("test2")) == 0);
532 530
533 531 seriesSpyArg = seriesSpy.takeFirst();
534 532 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
535 533
536 534 //====================================================================================
537 535 // barset 2, category test3
538 536 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(300,180));
539 537 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
540 538
541 539 QCOMPARE(setSpy1.count(), 0);
542 540 QCOMPARE(setSpy2.count(), 1);
543 541 QCOMPARE(seriesSpy.count(), 1);
544 542 setSpyArg = setSpy2.takeFirst();
545 543 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
546 544 QVERIFY(setSpyArg.at(0).toString().compare(QString("test3")) == 0);
547 545
548 546 seriesSpyArg = seriesSpy.takeFirst();
549 547 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
550 548
551 549 //====================================================================================
552 550 // no event cases
553 551 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(1,1)); // Outside of both sets
554 552 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(1,1)); // Right mouse button outside and inside sets
555 553 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(75,180)); // barset 1, category test1
556 554 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(160,180)); // barset 1, category test2
557 555 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(255,180)); // barset 1, category test3
558 556 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(115,180)); // barset 2, category test1
559 557 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(205,180)); // barset 2, category test2
560 558 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(300,180)); // barset 2, category test3
561 559
562 560 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
563 561 QCOMPARE(setSpy1.count(), 0);
564 562 QCOMPARE(setSpy2.count(), 0);
565 563 QCOMPARE(seriesSpy.count(), 0);
566 564 }
567 565
568 566 void tst_QBarSeries::mousehovered_data()
569 567 {
570 568
571 569 }
572 570
573 571 void tst_QBarSeries::mousehovered()
574 572 {
575 573 QBarSeries* series = new QBarSeries();
576 574 QBarCategories categories;
577 575 categories << "test1" << "test2" << "test3";
578 576 series->setCategories(categories);
579 577
580 578 QBarSet* set1 = new QBarSet(QString("set 1"));
581 579 *set1 << QPointF(0.1,10) << QPointF(1.1,10) << QPointF(2.1,10);
582 580 series->appendBarSet(set1);
583 581
584 582 QBarSet* set2 = new QBarSet(QString("set 2"));
585 583 *set2 << QPointF(0.4,10) << QPointF(1.4,10) << QPointF(2.4,10);
586 584 series->appendBarSet(set2);
587 585
588 586 QSignalSpy setSpy1(set1, SIGNAL(hovered(bool)));
589 587 QSignalSpy setSpy2(set2, SIGNAL(hovered(bool)));
590 588 QSignalSpy seriesSpy(series,SIGNAL(hovered(QBarSet*,bool)));
591 589
592 590 QChartView view(new QChart());
593 591 view.resize(400,300);
594 592 view.chart()->addSeries(series);
595 593 view.show();
596 594 QTest::qWaitForWindowShown(&view);
597 595
598 //this is hack since view does not get events otherwise
599 view.setMouseTracking(true);
600
601 596 //=======================================================================
602 597 // move mouse to left border
603 598 QTest::mouseMove(view.viewport(), QPoint(0, 180));
604 599
605 600 QVERIFY(setSpy1.count() == 0);
606 601 QVERIFY(setSpy2.count() == 0);
607 602 QVERIFY(seriesSpy.count() == 0);
608 603
609 604 //=======================================================================
610 605 // move mouse on top of set1
611 606 QTest::mouseMove(view.viewport(), QPoint(75,180));
612 607
613 608 QVERIFY(setSpy1.count() == 1);
614 609 QVERIFY(setSpy2.count() == 0);
615 610 QVERIFY(seriesSpy.count() == 1);
616 611
617 612 QList<QVariant> setSpyArg = setSpy1.takeFirst();
618 613 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
619 614 QVERIFY(setSpyArg.at(0).toBool() == true);
620 615
621 616 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
622 617 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
623 618
624 619 //=======================================================================
625 620 // move mouse from top of set1 to top of set2
626 621 QTest::mouseMove(view.viewport(), QPoint(105,180));
627 622
628 623 QVERIFY(setSpy1.count() == 1);
629 624 QVERIFY(setSpy2.count() == 1);
630 625 QVERIFY(seriesSpy.count() == 2);
631 626
632 627 // should leave set1
633 628 setSpyArg = setSpy1.takeFirst();
634 629 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
635 630 QVERIFY(setSpyArg.at(0).toBool() == false);
636 631
637 632 // should enter set2
638 633 setSpyArg = setSpy2.takeFirst();
639 634 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
640 635 QVERIFY(setSpyArg.at(0).toBool() == true);
641 636
642 637 // should leave set1
643 638 seriesSpyArg = seriesSpy.takeFirst();
644 639 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
645 640 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
646 641 QVERIFY(seriesSpyArg.at(1).toBool() == false);
647 642
648 643 // should enter set2
649 644 seriesSpyArg = seriesSpy.takeFirst();
650 645 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
651 646 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
652 647 QVERIFY(seriesSpyArg.at(1).toBool() == true);
653 648
654 649 //=======================================================================
655 650 // move mouse from top of set2 to background
656 651 QTest::mouseMove(view.viewport(), QPoint(135,180));
657 652
658 653 QVERIFY(setSpy1.count() == 0);
659 654 QVERIFY(setSpy2.count() == 1);
660 655 QVERIFY(seriesSpy.count() == 1);
661 656
662 657 // should leave set2 (event via set)
663 658 setSpyArg = setSpy2.takeFirst();
664 659 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
665 660 QVERIFY(setSpyArg.at(0).toBool() == false);
666 661
667 662 // should leave set2 (event via series)
668 663 seriesSpyArg = seriesSpy.takeFirst();
669 664 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
670 665 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
671 666 QVERIFY(seriesSpyArg.at(1).toBool() == false);
672 667 }
673 668
674 669 /*
675 670 bool setModel(QAbstractItemModel *model);
676 671 void setModelMapping(int categories, int bottomBoundary, int topBoundary, Qt::Orientation orientation = Qt::Vertical);
677 672 void setModelMappingRange(int first, int count = -1);
678 673 */
679 674 QTEST_MAIN(tst_QBarSeries)
680 675
681 676 #include "tst_qbarseries.moc"
682 677
General Comments 0
You need to be logged in to leave comments. Login now