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

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

added SKIP_IF_CANNOT_TEST_MOUSE_EVENTS macro to barseries tests
sauimone -
r2066:a059066f2901
parent child
Show More
Side by Side Unified
Context file:
r2066:a059066f2901 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,619 +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 <qbarseries.h>
23 23 #include <qbarset.h>
24 24 #include <qchartview.h>
25 25 #include <qchart.h>
26 26 #include "tst_definitions.h"
27 27
28 28 QTCOMMERCIALCHART_USE_NAMESPACE
29 29
30 30 Q_DECLARE_METATYPE(QBarSet*)
31 31 Q_DECLARE_METATYPE(QList<QBarSet*>)
32 32
33 33 class tst_QBarSeries : public QObject
34 34 {
35 35 Q_OBJECT
36 36
37 37 public slots:
38 38 void initTestCase();
39 39 void cleanupTestCase();
40 40 void init();
41 41 void cleanup();
42 42
43 43 private slots:
44 44 void qbarseries_data();
45 45 void qbarseries();
46 46 void type_data();
47 47 void type();
48 48 void append_data();
49 49 void append();
50 50 void remove_data();
51 51 void remove();
52 52 void take_data();
53 53 void take();
54 54 void appendList_data();
55 55 void appendList();
56 56 void count_data();
57 57 void count();
58 58 void barSets_data();
59 59 void barSets();
60 60 void setLabelsVisible_data();
61 61 void setLabelsVisible();
62 62 void mouseclicked_data();
63 63 void mouseclicked();
64 64 void mousehovered_data();
65 65 void mousehovered();
66 66 void clearWithAnimations();
67 67 void destruction();
68 68
69 69 private:
70 70 QBarSeries* m_barseries;
71 71 QBarSeries* m_barseries_with_sets;
72 72
73 73 QList<QBarSet*> m_testSets;
74 74
75 75 };
76 76
77 77 void tst_QBarSeries::initTestCase()
78 78 {
79 79 qRegisterMetaType<QBarSet*>("QBarSet*");
80 80 qRegisterMetaType<QList<QBarSet*> >("QList<QBarSet*>");
81 81 }
82 82
83 83 void tst_QBarSeries::cleanupTestCase()
84 84 {
85 85 }
86 86
87 87 void tst_QBarSeries::init()
88 88 {
89 89 m_barseries = new QBarSeries();
90 90 m_barseries_with_sets = new QBarSeries();
91 91
92 92 for (int i=0; i<5; i++) {
93 93 m_testSets.append(new QBarSet("testset"));
94 94 m_barseries_with_sets->append(m_testSets.at(i));
95 95 }
96 96 }
97 97
98 98 void tst_QBarSeries::cleanup()
99 99 {
100 100 foreach(QBarSet* s, m_testSets) {
101 101 m_barseries_with_sets->remove(s);
102 102 }
103 103 m_testSets.clear();
104 104
105 105 delete m_barseries;
106 106 m_barseries = 0;
107 107 delete m_barseries_with_sets;
108 108 m_barseries_with_sets = 0;
109 109 }
110 110
111 111 void tst_QBarSeries::qbarseries_data()
112 112 {
113 113 }
114 114
115 115 void tst_QBarSeries::qbarseries()
116 116 {
117 117 QBarSeries *barseries = new QBarSeries();
118 118 QVERIFY(barseries != 0);
119 119 }
120 120
121 121 void tst_QBarSeries::type_data()
122 122 {
123 123
124 124 }
125 125
126 126 void tst_QBarSeries::type()
127 127 {
128 128 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeBar);
129 129 }
130 130
131 131 void tst_QBarSeries::append_data()
132 132 {
133 133 }
134 134
135 135 void tst_QBarSeries::append()
136 136 {
137 137 QVERIFY(m_barseries->count() == 0);
138 138
139 139 bool ret = false;
140 140
141 141 // Try adding barset
142 142 QBarSet *barset = new QBarSet("testset");
143 143 ret = m_barseries->append(barset);
144 144
145 145 QVERIFY(ret == true);
146 146 QVERIFY(m_barseries->count() == 1);
147 147
148 148 // Try adding another set
149 149 QBarSet *barset2 = new QBarSet("testset2");
150 150 ret = m_barseries->append(barset2);
151 151
152 152 QVERIFY(ret == true);
153 153 QVERIFY(m_barseries->count() == 2);
154 154
155 155 // Try adding same set again
156 156 ret = m_barseries->append(barset2);
157 157 QVERIFY(ret == false);
158 158 QVERIFY(m_barseries->count() == 2);
159 159
160 160 // Try adding null set
161 161 ret = m_barseries->append(0);
162 162 QVERIFY(ret == false);
163 163 QVERIFY(m_barseries->count() == 2);
164 164
165 165 }
166 166
167 167 void tst_QBarSeries::remove_data()
168 168 {
169 169 }
170 170
171 171 void tst_QBarSeries::remove()
172 172 {
173 173 int count = m_testSets.count();
174 174 QVERIFY(m_barseries_with_sets->count() == count);
175 175
176 176 // Try to remove null pointer (should not remove, should not crash)
177 177 bool ret = false;
178 178 ret = m_barseries_with_sets->remove(0);
179 179 QVERIFY(ret == false);
180 180 QVERIFY(m_barseries_with_sets->count() == count);
181 181
182 182 // Try to remove invalid pointer (should not remove, should not crash)
183 183 ret = m_barseries_with_sets->remove((QBarSet*) (m_testSets.at(0) + 1) );
184 184 QVERIFY(ret == false);
185 185 QVERIFY(m_barseries_with_sets->count() == count);
186 186
187 187 // remove some sets
188 188 ret = m_barseries_with_sets->remove(m_testSets.at(2));
189 189 QVERIFY(ret == true);
190 190 ret = m_barseries_with_sets->remove(m_testSets.at(3));
191 191 QVERIFY(ret == true);
192 192 ret = m_barseries_with_sets->remove(m_testSets.at(4));
193 193 QVERIFY(ret == true);
194 194
195 195 QVERIFY(m_barseries_with_sets->count() == 2);
196 196
197 197 QList<QBarSet*> verifysets = m_barseries_with_sets->barSets();
198 198
199 199 QVERIFY(verifysets.at(0) == m_testSets.at(0));
200 200 QVERIFY(verifysets.at(1) == m_testSets.at(1));
201 201
202 202 // Try removing all sets again (should be ok, even if some sets have already been removed)
203 203 ret = false;
204 204 for (int i=0; i<count; i++) {
205 205 ret |= m_barseries_with_sets->remove(m_testSets.at(i));
206 206 }
207 207
208 208 QVERIFY(ret == true);
209 209 QVERIFY(m_barseries_with_sets->count() == 0);
210 210 }
211 211
212 212 void tst_QBarSeries::take_data()
213 213 {
214 214
215 215 }
216 216
217 217 void tst_QBarSeries::take()
218 218 {
219 219 int count = m_testSets.count();
220 220 QVERIFY(m_barseries_with_sets->count() == count);
221 221
222 222 QSignalSpy countSpy(m_barseries_with_sets,SIGNAL(countChanged()));
223 223 QSignalSpy removedSpy(m_barseries_with_sets,SIGNAL(barsetsRemoved(QList<QBarSet *>)));
224 224
225 225 for (int i=0; i<m_testSets.count(); i++) {
226 226 QBarSet* set = m_testSets.at(i);
227 227 bool success = m_barseries_with_sets->take(set);
228 228 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
229 229 QVERIFY(success);
230 230 TRY_COMPARE(countSpy.count(),1);
231 231 TRY_COMPARE(removedSpy.count(),1);
232 232
233 233 QList<QVariant> removedSpyArg = removedSpy.takeFirst();
234 234 QList<QBarSet*> removedSets = qvariant_cast<QList<QBarSet*> > (removedSpyArg.at(0));
235 235 QCOMPARE(removedSets.at(0), m_testSets.at(i));
236 236 countSpy.takeFirst();
237 237 }
238 238 }
239 239
240 240
241 241 void tst_QBarSeries::appendList_data()
242 242 {
243 243
244 244 }
245 245
246 246 void tst_QBarSeries::appendList()
247 247 {
248 248 int count = 5;
249 249 QVERIFY(m_barseries->count() == 0);
250 250
251 251 QList<QBarSet*> sets;
252 252 for (int i=0; i<count; i++) {
253 253 sets.append(new QBarSet("testset"));
254 254 }
255 255
256 256 // Append new sets (should succeed, count should match the count of sets)
257 257 bool ret = false;
258 258 ret = m_barseries->append(sets);
259 259 QVERIFY(ret == true);
260 260 QVERIFY(m_barseries->count() == count);
261 261
262 262 // Append same sets again (should fail, count should remain same)
263 263 ret = m_barseries->append(sets);
264 264 QVERIFY(ret == false);
265 265 QVERIFY(m_barseries->count() == count);
266 266
267 267 // Try append empty list (should succeed, but count should remain same)
268 268 QList<QBarSet*> invalidList;
269 269 ret = m_barseries->append(invalidList);
270 270 QVERIFY(ret == true);
271 271 QVERIFY(m_barseries->count() == count);
272 272
273 273 // Try append list with one new and one existing set (should fail, count remains same)
274 274 invalidList.append(new QBarSet("ok set"));
275 275 invalidList.append(sets.at(0));
276 276 ret = m_barseries->append(invalidList);
277 277 QVERIFY(ret == false);
278 278 QVERIFY(m_barseries->count() == count);
279 279
280 280 // Try append list with null pointers (should fail, count remains same)
281 281 QList<QBarSet*> invalidList2;
282 282 invalidList2.append(0);
283 283 invalidList2.append(0);
284 284 invalidList2.append(0);
285 285 ret = m_barseries->append(invalidList2);
286 286 QVERIFY(ret == false);
287 287 QVERIFY(m_barseries->count() == count);
288 288 }
289 289
290 290 void tst_QBarSeries::count_data()
291 291 {
292 292
293 293 }
294 294
295 295 void tst_QBarSeries::count()
296 296 {
297 297 QVERIFY(m_barseries->count() == 0);
298 298 QVERIFY(m_barseries_with_sets->count() == m_testSets.count());
299 299 }
300 300
301 301 void tst_QBarSeries::barSets_data()
302 302 {
303 303
304 304 }
305 305
306 306 void tst_QBarSeries::barSets()
307 307 {
308 308 QVERIFY(m_barseries->barSets().count() == 0);
309 309
310 310 QList<QBarSet*> sets = m_barseries_with_sets->barSets();
311 311 QVERIFY(sets.count() == m_testSets.count());
312 312
313 313 for (int i=0; i<m_testSets.count(); i++) {
314 314 QVERIFY(sets.at(i) == m_testSets.at(i));
315 315 }
316 316 }
317 317
318 318 void tst_QBarSeries::setLabelsVisible_data()
319 319 {
320 320
321 321 }
322 322
323 323 void tst_QBarSeries::setLabelsVisible()
324 324 {
325 325 // labels should be invisible by default
326 326 QVERIFY(m_barseries->isLabelsVisible() == false);
327 327 QVERIFY(m_barseries_with_sets->isLabelsVisible() == false);
328 328
329 329 // turn labels to visible
330 330 m_barseries_with_sets->setLabelsVisible(true);
331 331 // TODO: test the signal
332 332 QVERIFY(m_barseries_with_sets->isLabelsVisible() == true);
333 333
334 334 // turn labels to invisible
335 335 m_barseries_with_sets->setLabelsVisible(false);
336 336 // TODO: test the signal
337 337 QVERIFY(m_barseries_with_sets->isLabelsVisible() == false);
338 338
339 339 // without parameter, should turn labels to visible
340 340 m_barseries_with_sets->setLabelsVisible();
341 341 // TODO: test the signal
342 342 QVERIFY(m_barseries_with_sets->isLabelsVisible() == true);
343 343 }
344 344
345 345 void tst_QBarSeries::mouseclicked_data()
346 346 {
347 347
348 348 }
349 349
350 350 void tst_QBarSeries::mouseclicked()
351 351 {
352 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
353
352 354 QBarSeries* series = new QBarSeries();
353 355
354 356 QBarSet* set1 = new QBarSet(QString("set 1"));
355 357 *set1 << 10 << 10 << 10;
356 358 series->append(set1);
357 359
358 360 QBarSet* set2 = new QBarSet(QString("set 2"));
359 361 *set2 << 10 << 10 << 10;
360 362 series->append(set2);
361 363
362 364 QSignalSpy seriesSpy(series,SIGNAL(clicked(int,QBarSet*)));
363 365 QSignalSpy setSpy1(set1, SIGNAL(clicked(int)));
364 366 QSignalSpy setSpy2(set2, SIGNAL(clicked(int)));
365 367
366 368 QChartView view(new QChart());
367 369 view.resize(400,300);
368 370 view.chart()->addSeries(series);
369 371 view.show();
370 372 QTest::qWaitForWindowShown(&view);
371 373
372 374 //====================================================================================
373 375 // barset 1, bar 0
374 376 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(72,150));
375 377 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
376 378
377 379 QCOMPARE(seriesSpy.count(), 1);
378 380 QCOMPARE(setSpy1.count(), 1);
379 381 QCOMPARE(setSpy2.count(), 0);
380 382
381 383 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
382 384 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
383 385 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
384 386 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
385 387
386 388 QList<QVariant> setSpyArg = setSpy1.takeFirst();
387 389 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
388 390 QVERIFY(setSpyArg.at(0).toInt() == 0);
389 391
390 392 //====================================================================================
391 393 // barset 1, bar 1
392 394 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(186,150));
393 395 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
394 396
395 397 QCOMPARE(seriesSpy.count(), 1);
396 398 QCOMPARE(setSpy1.count(), 1);
397 399 QCOMPARE(setSpy2.count(), 0);
398 400
399 401 seriesSpyArg = seriesSpy.takeFirst();
400 402 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
401 403 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
402 404 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
403 405
404 406 setSpyArg = setSpy1.takeFirst();
405 407 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
406 408 QVERIFY(setSpyArg.at(0).toInt() == 1);
407 409
408 410 //====================================================================================
409 411 // barset 1, bar 2
410 412 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(300,150));
411 413 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
412 414
413 415 QCOMPARE(seriesSpy.count(), 1);
414 416 QCOMPARE(setSpy1.count(), 1);
415 417 QCOMPARE(setSpy2.count(), 0);
416 418
417 419 seriesSpyArg = seriesSpy.takeFirst();
418 420 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
419 421 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
420 422 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
421 423
422 424 setSpyArg = setSpy1.takeFirst();
423 425 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
424 426 QVERIFY(setSpyArg.at(0).toInt() == 2);
425 427
426 428 //====================================================================================
427 429 // barset 2, bar 0
428 430 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(100,150));
429 431 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
430 432
431 433 QCOMPARE(seriesSpy.count(), 1);
432 434 QCOMPARE(setSpy1.count(), 0);
433 435 QCOMPARE(setSpy2.count(), 1);
434 436
435 437 seriesSpyArg = seriesSpy.takeFirst();
436 438 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
437 439 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
438 440 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
439 441
440 442 setSpyArg = setSpy2.takeFirst();
441 443 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
442 444 QVERIFY(setSpyArg.at(0).toInt() == 0);
443 445
444 446 //====================================================================================
445 447 // barset 2, bar 1
446 448 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(214,150));
447 449 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
448 450
449 451 QCOMPARE(seriesSpy.count(), 1);
450 452 QCOMPARE(setSpy1.count(), 0);
451 453 QCOMPARE(setSpy2.count(), 1);
452 454
453 455 seriesSpyArg = seriesSpy.takeFirst();
454 456 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
455 457 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
456 458 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
457 459
458 460 setSpyArg = setSpy2.takeFirst();
459 461 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
460 462 QVERIFY(setSpyArg.at(0).toInt() == 1);
461 463
462 464 //====================================================================================
463 465 // barset 2, bar 2
464 466 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(328,150));
465 467 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
466 468
467 469 QCOMPARE(seriesSpy.count(), 1);
468 470 QCOMPARE(setSpy1.count(), 0);
469 471 QCOMPARE(setSpy2.count(), 1);
470 472
471 473 seriesSpyArg = seriesSpy.takeFirst();
472 474 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
473 475 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
474 476 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
475 477
476 478 setSpyArg = setSpy2.takeFirst();
477 479 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
478 480 QVERIFY(setSpyArg.at(0).toInt() == 2);
479 481 }
480 482
481 483 void tst_QBarSeries::mousehovered_data()
482 484 {
483 485
484 486 }
485 487
486 488 void tst_QBarSeries::mousehovered()
487 489 {
490 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
491
488 492 QBarSeries* series = new QBarSeries();
489 493
490 494 QBarSet* set1 = new QBarSet(QString("set 1"));
491 495 *set1 << 10 << 10 << 10;
492 496 series->append(set1);
493 497
494 498 QBarSet* set2 = new QBarSet(QString("set 2"));
495 499 *set2 << 10 << 10 << 10;
496 500 series->append(set2);
497 501
498 502 QSignalSpy seriesSpy(series,SIGNAL(hovered(bool,QBarSet*)));
499 503 QSignalSpy setSpy1(set1, SIGNAL(hovered(bool)));
500 504 QSignalSpy setSpy2(set2, SIGNAL(hovered(bool)));
501 505
502 506 QChartView view(new QChart());
503 507 view.resize(400,300);
504 508 view.chart()->addSeries(series);
505 509 view.show();
506 510 QTest::qWaitForWindowShown(&view);
507 511
508 512 //this is hack since view does not get events otherwise
509 513 view.setMouseTracking(true);
510 514
511 515 //=======================================================================
512 516 // move mouse to left border
513 517 QTest::mouseMove(view.viewport(), QPoint(0, 150));
514 518 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
515 519 TRY_COMPARE(seriesSpy.count(), 0);
516 520 TRY_COMPARE(setSpy1.count(), 0);
517 521 TRY_COMPARE(setSpy2.count(), 0);
518 522
519 523 //=======================================================================
520 524 // move mouse on top of set1
521 525 QTest::mouseMove(view.viewport(), QPoint(72,150));
522 526 TRY_COMPARE(seriesSpy.count(), 1);
523 527 TRY_COMPARE(setSpy1.count(), 1);
524 528 TRY_COMPARE(setSpy2.count(), 0);
525 529
526 530 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
527 531 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
528 532 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
529 533 QVERIFY(seriesSpyArg.at(0).toBool() == true);
530 534
531 535 QList<QVariant> setSpyArg = setSpy1.takeFirst();
532 536 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
533 537 QVERIFY(setSpyArg.at(0).toBool() == true);
534 538
535 539 //=======================================================================
536 540 // move mouse from top of set1 to top of set2
537 541 QTest::mouseMove(view.viewport(), QPoint(100,150));
538 542 TRY_COMPARE(seriesSpy.count(), 2);
539 543 TRY_COMPARE(setSpy1.count(), 1);
540 544 TRY_COMPARE(setSpy2.count(), 1);
541 545
542 546 // should leave set1
543 547 seriesSpyArg = seriesSpy.takeFirst();
544 548 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
545 549 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
546 550 QVERIFY(seriesSpyArg.at(0).toBool() == false);
547 551
548 552 setSpyArg = setSpy1.takeFirst();
549 553 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
550 554 QVERIFY(setSpyArg.at(0).toBool() == false);
551 555
552 556 // should enter set2
553 557 seriesSpyArg = seriesSpy.takeFirst();
554 558 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
555 559 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
556 560 QVERIFY(seriesSpyArg.at(0).toBool() == true);
557 561
558 562 setSpyArg = setSpy2.takeFirst();
559 563 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
560 564 QVERIFY(setSpyArg.at(0).toBool() == true);
561 565
562 566 //=======================================================================
563 567 // move mouse from top of set2 to background
564 568 QTest::mouseMove(view.viewport(), QPoint(100,0));
565 569 TRY_COMPARE(seriesSpy.count(), 1);
566 570 TRY_COMPARE(setSpy1.count(), 0);
567 571 TRY_COMPARE(setSpy2.count(), 1);
568 572
569 573 // should leave set2
570 574 seriesSpyArg = seriesSpy.takeFirst();
571 575 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
572 576 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
573 577 QVERIFY(seriesSpyArg.at(0).toBool() == false);
574 578
575 579 setSpyArg = setSpy2.takeFirst();
576 580 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
577 581 QVERIFY(setSpyArg.at(0).toBool() == false);
578 582 }
579 583
580 584 void tst_QBarSeries::clearWithAnimations()
581 585 {
582 586 QBarSeries* series = new QBarSeries();
583 587
584 588 QBarSet* set1 = new QBarSet(QString("set 1"));
585 589 *set1 << 10 << 10 << 10;
586 590 series->append(set1);
587 591
588 592 QBarSet* set2 = new QBarSet(QString("set 2"));
589 593 *set2 << 10 << 10 << 10;
590 594 series->append(set2);
591 595
592 596 QChartView view(new QChart());
593 597 view.resize(400,300);
594 598 view.chart()->setAnimationOptions(QChart::SeriesAnimations);
595 599 view.chart()->addSeries(series);
596 600 view.show();
597 601
598 602 series->clear();
599 603 }
600 604
601 605 void tst_QBarSeries::destruction()
602 606 {
603 607 // add a barset
604 608 QBarSeries *series = new QBarSeries();
605 609 QBarSet *set = new QBarSet("testset");
606 610 QSignalSpy spy1(set, SIGNAL(destroyed()));
607 611 series->append(set);
608 612
609 613 // delete the series
610 614 delete series;
611 615
612 616 // check that series deletes the set
613 617 QCOMPARE(spy1.count(), 1);
614 618 }
615 619
616 620 QTEST_MAIN(tst_QBarSeries)
617 621
618 622 #include "tst_qbarseries.moc"
619 623
Show file before | Show file after | Hide comments
@@ -1,570 +1,574
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 <qhorizontalbarseries.h>
23 23 #include <qbarset.h>
24 24 #include <qchartview.h>
25 25 #include <qchart.h>
26 26 #include "tst_definitions.h"
27 27
28 28 QTCOMMERCIALCHART_USE_NAMESPACE
29 29
30 30 Q_DECLARE_METATYPE(QBarSet*)
31 31
32 32 class tst_QHorizontalBarSeries : public QObject
33 33 {
34 34 Q_OBJECT
35 35
36 36 public slots:
37 37 void initTestCase();
38 38 void cleanupTestCase();
39 39 void init();
40 40 void cleanup();
41 41
42 42 private slots:
43 43 void qhorizontalbarseries_data();
44 44 void qhorizontalbarseries();
45 45 void type_data();
46 46 void type();
47 47 void append_data();
48 48 void append();
49 49 void remove_data();
50 50 void remove();
51 51 void appendList_data();
52 52 void appendList();
53 53 void count_data();
54 54 void count();
55 55 void barSets_data();
56 56 void barSets();
57 57 void setLabelsVisible_data();
58 58 void setLabelsVisible();
59 59 void mouseclicked_data();
60 60 void mouseclicked();
61 61 void mousehovered_data();
62 62 void mousehovered();
63 63 void clearWithAnimations();
64 64
65 65 private:
66 66 QHorizontalBarSeries* m_barseries;
67 67 QHorizontalBarSeries* m_barseries_with_sets;
68 68
69 69 QList<QBarSet*> m_testSets;
70 70
71 71 };
72 72
73 73 void tst_QHorizontalBarSeries::initTestCase()
74 74 {
75 75 qRegisterMetaType<QBarSet*>("QBarSet*");
76 76 }
77 77
78 78 void tst_QHorizontalBarSeries::cleanupTestCase()
79 79 {
80 80 }
81 81
82 82 void tst_QHorizontalBarSeries::init()
83 83 {
84 84 m_barseries = new QHorizontalBarSeries();
85 85 m_barseries_with_sets = new QHorizontalBarSeries();
86 86
87 87 for (int i=0; i<5; i++) {
88 88 m_testSets.append(new QBarSet("testset"));
89 89 m_barseries_with_sets->append(m_testSets.at(i));
90 90 }
91 91 }
92 92
93 93 void tst_QHorizontalBarSeries::cleanup()
94 94 {
95 95 foreach(QBarSet* s, m_testSets) {
96 96 m_barseries_with_sets->remove(s);
97 97 }
98 98 m_testSets.clear();
99 99
100 100 delete m_barseries;
101 101 m_barseries = 0;
102 102 delete m_barseries_with_sets;
103 103 m_barseries_with_sets = 0;
104 104 }
105 105
106 106 void tst_QHorizontalBarSeries::qhorizontalbarseries_data()
107 107 {
108 108 }
109 109
110 110 void tst_QHorizontalBarSeries::qhorizontalbarseries()
111 111 {
112 112 QHorizontalBarSeries *barseries = new QHorizontalBarSeries();
113 113 QVERIFY(barseries != 0);
114 114 }
115 115
116 116 void tst_QHorizontalBarSeries::type_data()
117 117 {
118 118
119 119 }
120 120
121 121 void tst_QHorizontalBarSeries::type()
122 122 {
123 123 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeHorizontalBar);
124 124 }
125 125
126 126 void tst_QHorizontalBarSeries::append_data()
127 127 {
128 128 }
129 129
130 130 void tst_QHorizontalBarSeries::append()
131 131 {
132 132 QVERIFY(m_barseries->count() == 0);
133 133
134 134 bool ret = false;
135 135
136 136 // Try adding barset
137 137 QBarSet *barset = new QBarSet("testset");
138 138 ret = m_barseries->append(barset);
139 139
140 140 QVERIFY(ret == true);
141 141 QVERIFY(m_barseries->count() == 1);
142 142
143 143 // Try adding another set
144 144 QBarSet *barset2 = new QBarSet("testset2");
145 145 ret = m_barseries->append(barset2);
146 146
147 147 QVERIFY(ret == true);
148 148 QVERIFY(m_barseries->count() == 2);
149 149
150 150 // Try adding same set again
151 151 ret = m_barseries->append(barset2);
152 152 QVERIFY(ret == false);
153 153 QVERIFY(m_barseries->count() == 2);
154 154
155 155 // Try adding null set
156 156 ret = m_barseries->append(0);
157 157 QVERIFY(ret == false);
158 158 QVERIFY(m_barseries->count() == 2);
159 159
160 160 }
161 161
162 162 void tst_QHorizontalBarSeries::remove_data()
163 163 {
164 164 }
165 165
166 166 void tst_QHorizontalBarSeries::remove()
167 167 {
168 168 int count = m_testSets.count();
169 169 QVERIFY(m_barseries_with_sets->count() == count);
170 170
171 171 // Try to remove null pointer (should not remove, should not crash)
172 172 bool ret = false;
173 173 ret = m_barseries_with_sets->remove(0);
174 174 QVERIFY(ret == false);
175 175 QVERIFY(m_barseries_with_sets->count() == count);
176 176
177 177 // Try to remove invalid pointer (should not remove, should not crash)
178 178 ret = m_barseries_with_sets->remove((QBarSet*) (m_testSets.at(0) + 1) );
179 179 QVERIFY(ret == false);
180 180 QVERIFY(m_barseries_with_sets->count() == count);
181 181
182 182 // remove some sets
183 183 ret = m_barseries_with_sets->remove(m_testSets.at(2));
184 184 QVERIFY(ret == true);
185 185 ret = m_barseries_with_sets->remove(m_testSets.at(3));
186 186 QVERIFY(ret == true);
187 187 ret = m_barseries_with_sets->remove(m_testSets.at(4));
188 188 QVERIFY(ret == true);
189 189
190 190 QVERIFY(m_barseries_with_sets->count() == 2);
191 191
192 192 QList<QBarSet*> verifysets = m_barseries_with_sets->barSets();
193 193
194 194 QVERIFY(verifysets.at(0) == m_testSets.at(0));
195 195 QVERIFY(verifysets.at(1) == m_testSets.at(1));
196 196
197 197 // Try removing all sets again (should be ok, even if some sets have already been removed)
198 198 ret = false;
199 199 for (int i=0; i<count; i++) {
200 200 ret |= m_barseries_with_sets->remove(m_testSets.at(i));
201 201 }
202 202
203 203 QVERIFY(ret == true);
204 204 QVERIFY(m_barseries_with_sets->count() == 0);
205 205 }
206 206
207 207 void tst_QHorizontalBarSeries::appendList_data()
208 208 {
209 209
210 210 }
211 211
212 212 void tst_QHorizontalBarSeries::appendList()
213 213 {
214 214 int count = 5;
215 215 QVERIFY(m_barseries->count() == 0);
216 216
217 217 QList<QBarSet*> sets;
218 218 for (int i=0; i<count; i++) {
219 219 sets.append(new QBarSet("testset"));
220 220 }
221 221
222 222 // Append new sets (should succeed, count should match the count of sets)
223 223 bool ret = false;
224 224 ret = m_barseries->append(sets);
225 225 QVERIFY(ret == true);
226 226 QVERIFY(m_barseries->count() == count);
227 227
228 228 // Append same sets again (should fail, count should remain same)
229 229 ret = m_barseries->append(sets);
230 230 QVERIFY(ret == false);
231 231 QVERIFY(m_barseries->count() == count);
232 232
233 233 // Try append empty list (should succeed, but count should remain same)
234 234 QList<QBarSet*> invalidList;
235 235 ret = m_barseries->append(invalidList);
236 236 QVERIFY(ret == true);
237 237 QVERIFY(m_barseries->count() == count);
238 238
239 239 // Try append list with one new and one existing set (should fail, count remains same)
240 240 invalidList.append(new QBarSet("ok set"));
241 241 invalidList.append(sets.at(0));
242 242 ret = m_barseries->append(invalidList);
243 243 QVERIFY(ret == false);
244 244 QVERIFY(m_barseries->count() == count);
245 245
246 246 // Try append list with null pointers (should fail, count remains same)
247 247 QList<QBarSet*> invalidList2;
248 248 invalidList2.append(0);
249 249 invalidList2.append(0);
250 250 invalidList2.append(0);
251 251 ret = m_barseries->append(invalidList2);
252 252 QVERIFY(ret == false);
253 253 QVERIFY(m_barseries->count() == count);
254 254 }
255 255
256 256 void tst_QHorizontalBarSeries::count_data()
257 257 {
258 258
259 259 }
260 260
261 261 void tst_QHorizontalBarSeries::count()
262 262 {
263 263 QVERIFY(m_barseries->count() == 0);
264 264 QVERIFY(m_barseries_with_sets->count() == m_testSets.count());
265 265 }
266 266
267 267 void tst_QHorizontalBarSeries::barSets_data()
268 268 {
269 269
270 270 }
271 271
272 272 void tst_QHorizontalBarSeries::barSets()
273 273 {
274 274 QVERIFY(m_barseries->barSets().count() == 0);
275 275
276 276 QList<QBarSet*> sets = m_barseries_with_sets->barSets();
277 277 QVERIFY(sets.count() == m_testSets.count());
278 278
279 279 for (int i=0; i<m_testSets.count(); i++) {
280 280 QVERIFY(sets.at(i) == m_testSets.at(i));
281 281 }
282 282 }
283 283
284 284 void tst_QHorizontalBarSeries::setLabelsVisible_data()
285 285 {
286 286
287 287 }
288 288
289 289 void tst_QHorizontalBarSeries::setLabelsVisible()
290 290 {
291 291 // labels should be invisible by default
292 292 QVERIFY(m_barseries->isLabelsVisible() == false);
293 293 QVERIFY(m_barseries_with_sets->isLabelsVisible() == false);
294 294
295 295 // turn labels to visible
296 296 m_barseries_with_sets->setLabelsVisible(true);
297 297 // TODO: test the signal
298 298 QVERIFY(m_barseries_with_sets->isLabelsVisible() == true);
299 299
300 300 // turn labels to invisible
301 301 m_barseries_with_sets->setLabelsVisible(false);
302 302 // TODO: test the signal
303 303 QVERIFY(m_barseries_with_sets->isLabelsVisible() == false);
304 304
305 305 // without parameter, should turn labels to visible
306 306 m_barseries_with_sets->setLabelsVisible();
307 307 // TODO: test the signal
308 308 QVERIFY(m_barseries_with_sets->isLabelsVisible() == true);
309 309 }
310 310
311 311 void tst_QHorizontalBarSeries::mouseclicked_data()
312 312 {
313 313
314 314 }
315 315
316 316 void tst_QHorizontalBarSeries::mouseclicked()
317 317 {
318 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
319
318 320 QHorizontalBarSeries* series = new QHorizontalBarSeries();
319 321
320 322 QBarSet* set1 = new QBarSet(QString("set 1"));
321 323 *set1 << 10 << 10 << 10;
322 324 series->append(set1);
323 325
324 326 QBarSet* set2 = new QBarSet(QString("set 2"));
325 327 *set2 << 10 << 10 << 10;
326 328 series->append(set2);
327 329
328 330 QSignalSpy seriesSpy(series,SIGNAL(clicked(int,QBarSet*)));
329 331 QSignalSpy setSpy1(set1, SIGNAL(clicked(int)));
330 332 QSignalSpy setSpy2(set2, SIGNAL(clicked(int)));
331 333
332 334 QChartView view(new QChart());
333 335 view.resize(400,300);
334 336 view.chart()->addSeries(series);
335 337 view.show();
336 338 QTest::qWaitForWindowShown(&view);
337 339
338 340 //====================================================================================
339 341 // barset 1, bar 0
340 342 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(200,241));
341 343 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
342 344
343 345 QCOMPARE(seriesSpy.count(), 1);
344 346 QCOMPARE(setSpy1.count(), 1);
345 347 QCOMPARE(setSpy2.count(), 0);
346 348
347 349 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
348 350 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
349 351 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
350 352 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
351 353
352 354 QList<QVariant> setSpyArg = setSpy1.takeFirst();
353 355 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
354 356 QVERIFY(setSpyArg.at(0).toInt() == 0);
355 357
356 358 //====================================================================================
357 359 // barset 1, bar 1
358 360 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(200,160));
359 361 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
360 362
361 363 QCOMPARE(seriesSpy.count(), 1);
362 364 QCOMPARE(setSpy1.count(), 1);
363 365 QCOMPARE(setSpy2.count(), 0);
364 366
365 367 seriesSpyArg = seriesSpy.takeFirst();
366 368 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
367 369 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
368 370 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
369 371
370 372 setSpyArg = setSpy1.takeFirst();
371 373 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
372 374 QVERIFY(setSpyArg.at(0).toInt() == 1);
373 375
374 376 //====================================================================================
375 377 // barset 1, bar 2
376 378 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(200,79));
377 379 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
378 380
379 381 QCOMPARE(seriesSpy.count(), 1);
380 382 QCOMPARE(setSpy1.count(), 1);
381 383 QCOMPARE(setSpy2.count(), 0);
382 384
383 385 seriesSpyArg = seriesSpy.takeFirst();
384 386 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
385 387 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
386 388 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
387 389
388 390 setSpyArg = setSpy1.takeFirst();
389 391 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
390 392 QVERIFY(setSpyArg.at(0).toInt() == 2);
391 393
392 394 //====================================================================================
393 395 // barset 2, bar 0
394 396 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(200,221));
395 397 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
396 398
397 399 QCOMPARE(seriesSpy.count(), 1);
398 400 QCOMPARE(setSpy1.count(), 0);
399 401 QCOMPARE(setSpy2.count(), 1);
400 402
401 403 seriesSpyArg = seriesSpy.takeFirst();
402 404 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
403 405 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
404 406 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
405 407
406 408 setSpyArg = setSpy2.takeFirst();
407 409 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
408 410 QVERIFY(setSpyArg.at(0).toInt() == 0);
409 411
410 412 //====================================================================================
411 413 // barset 2, bar 1
412 414 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(200,140));
413 415 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
414 416
415 417 QCOMPARE(seriesSpy.count(), 1);
416 418 QCOMPARE(setSpy1.count(), 0);
417 419 QCOMPARE(setSpy2.count(), 1);
418 420
419 421 seriesSpyArg = seriesSpy.takeFirst();
420 422 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
421 423 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
422 424 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
423 425
424 426 setSpyArg = setSpy2.takeFirst();
425 427 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
426 428 QVERIFY(setSpyArg.at(0).toInt() == 1);
427 429
428 430 //====================================================================================
429 431 // barset 2, bar 2
430 432 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(200,59));
431 433 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
432 434
433 435 QCOMPARE(seriesSpy.count(), 1);
434 436 QCOMPARE(setSpy1.count(), 0);
435 437 QCOMPARE(setSpy2.count(), 1);
436 438
437 439 seriesSpyArg = seriesSpy.takeFirst();
438 440 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
439 441 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
440 442 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
441 443
442 444 setSpyArg = setSpy2.takeFirst();
443 445 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
444 446 QVERIFY(setSpyArg.at(0).toInt() == 2);
445 447 }
446 448
447 449 void tst_QHorizontalBarSeries::mousehovered_data()
448 450 {
449 451
450 452 }
451 453
452 454 void tst_QHorizontalBarSeries::mousehovered()
453 455 {
456 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
457
454 458 QHorizontalBarSeries* series = new QHorizontalBarSeries();
455 459
456 460 QBarSet* set1 = new QBarSet(QString("set 1"));
457 461 *set1 << 10 << 10 << 10;
458 462 series->append(set1);
459 463
460 464 QBarSet* set2 = new QBarSet(QString("set 2"));
461 465 *set2 << 10 << 10 << 10;
462 466 series->append(set2);
463 467
464 468 QSignalSpy seriesSpy(series,SIGNAL(hovered(bool,QBarSet*)));
465 469 QSignalSpy setSpy1(set1, SIGNAL(hovered(bool)));
466 470 QSignalSpy setSpy2(set2, SIGNAL(hovered(bool)));
467 471
468 472 QChartView view(new QChart());
469 473 view.resize(400,300);
470 474 view.chart()->addSeries(series);
471 475 view.show();
472 476 QTest::qWaitForWindowShown(&view);
473 477
474 478 //this is hack since view does not get events otherwise
475 479 view.setMouseTracking(true);
476 480
477 481 //=======================================================================
478 482 // move mouse to bottom border
479 483 QTest::mouseMove(view.viewport(), QPoint(200, 300));
480 484 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
481 485 TRY_COMPARE(seriesSpy.count(), 0);
482 486 TRY_COMPARE(setSpy1.count(), 0);
483 487 TRY_COMPARE(setSpy2.count(), 0);
484 488
485 489 //=======================================================================
486 490 // move mouse on top of set1
487 491 QTest::mouseMove(view.viewport(), QPoint(200,241));
488 492 TRY_COMPARE(seriesSpy.count(), 1);
489 493 TRY_COMPARE(setSpy1.count(), 1);
490 494 TRY_COMPARE(setSpy2.count(), 0);
491 495
492 496 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
493 497 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
494 498 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
495 499 QVERIFY(seriesSpyArg.at(0).toBool() == true);
496 500
497 501 QList<QVariant> setSpyArg = setSpy1.takeFirst();
498 502 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
499 503 QVERIFY(setSpyArg.at(0).toBool() == true);
500 504
501 505 //=======================================================================
502 506 // move mouse from top of set1 to top of set2
503 507 QTest::mouseMove(view.viewport(), QPoint(200,221));
504 508 TRY_COMPARE(seriesSpy.count(), 2);
505 509 TRY_COMPARE(setSpy1.count(), 1);
506 510 TRY_COMPARE(setSpy2.count(), 1);
507 511
508 512 // should leave set1
509 513 seriesSpyArg = seriesSpy.takeFirst();
510 514 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
511 515 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
512 516 QVERIFY(seriesSpyArg.at(0).toBool() == false);
513 517
514 518 setSpyArg = setSpy1.takeFirst();
515 519 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
516 520 QVERIFY(setSpyArg.at(0).toBool() == false);
517 521
518 522 // should enter set2
519 523 seriesSpyArg = seriesSpy.takeFirst();
520 524 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
521 525 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
522 526 QVERIFY(seriesSpyArg.at(0).toBool() == true);
523 527
524 528 setSpyArg = setSpy2.takeFirst();
525 529 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
526 530 QVERIFY(setSpyArg.at(0).toBool() == true);
527 531
528 532 //=======================================================================
529 533 // move mouse from top of set2 to background
530 534 QTest::mouseMove(view.viewport(), QPoint(0,221));
531 535 TRY_COMPARE(seriesSpy.count(), 1);
532 536 TRY_COMPARE(setSpy1.count(), 0);
533 537 TRY_COMPARE(setSpy2.count(), 1);
534 538
535 539 // should leave set2
536 540 seriesSpyArg = seriesSpy.takeFirst();
537 541 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
538 542 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
539 543 QVERIFY(seriesSpyArg.at(0).toBool() == false);
540 544
541 545 setSpyArg = setSpy2.takeFirst();
542 546 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
543 547 QVERIFY(setSpyArg.at(0).toBool() == false);
544 548 }
545 549
546 550 void tst_QHorizontalBarSeries::clearWithAnimations()
547 551 {
548 552 QHorizontalBarSeries* series = new QHorizontalBarSeries();
549 553
550 554 QBarSet* set1 = new QBarSet(QString("set 1"));
551 555 *set1 << 10 << 10 << 10;
552 556 series->append(set1);
553 557
554 558 QBarSet* set2 = new QBarSet(QString("set 2"));
555 559 *set2 << 10 << 10 << 10;
556 560 series->append(set2);
557 561
558 562 QChartView view(new QChart());
559 563 view.resize(400,300);
560 564 view.chart()->setAnimationOptions(QChart::SeriesAnimations);
561 565 view.chart()->addSeries(series);
562 566 view.show();
563 567
564 568 series->clear();
565 569 }
566 570
567 571 QTEST_MAIN(tst_QHorizontalBarSeries)
568 572
569 573 #include "tst_qhorizontalbarseries.moc"
570 574
Show file before | Show file after | Hide comments
@@ -1,270 +1,274
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 <qhorizontalpercentbarseries.h>
23 23 #include <qbarset.h>
24 24 #include <qchartview.h>
25 25 #include <qchart.h>
26 26 #include "tst_definitions.h"
27 27
28 28 QTCOMMERCIALCHART_USE_NAMESPACE
29 29
30 30 Q_DECLARE_METATYPE(QBarSet*)
31 31
32 32 class tst_QHorizontalPercentBarSeries : public QObject
33 33 {
34 34 Q_OBJECT
35 35
36 36 public slots:
37 37 void initTestCase();
38 38 void cleanupTestCase();
39 39 void init();
40 40 void cleanup();
41 41
42 42 private slots:
43 43 void qhorizontalpercentbarseries_data();
44 44 void qhorizontalpercentbarseries();
45 45 void type_data();
46 46 void type();
47 47 void mouseclicked_data();
48 48 void mouseclicked();
49 49 void mousehovered_data();
50 50 void mousehovered();
51 51
52 52 private:
53 53 QHorizontalPercentBarSeries* m_barseries;
54 54 };
55 55
56 56 void tst_QHorizontalPercentBarSeries::initTestCase()
57 57 {
58 58 qRegisterMetaType<QBarSet*>("QBarSet*");
59 59 }
60 60
61 61 void tst_QHorizontalPercentBarSeries::cleanupTestCase()
62 62 {
63 63 }
64 64
65 65 void tst_QHorizontalPercentBarSeries::init()
66 66 {
67 67 m_barseries = new QHorizontalPercentBarSeries();
68 68 }
69 69
70 70 void tst_QHorizontalPercentBarSeries::cleanup()
71 71 {
72 72 delete m_barseries;
73 73 m_barseries = 0;
74 74 }
75 75
76 76 void tst_QHorizontalPercentBarSeries::qhorizontalpercentbarseries_data()
77 77 {
78 78 }
79 79
80 80 void tst_QHorizontalPercentBarSeries::qhorizontalpercentbarseries()
81 81 {
82 82 QHorizontalPercentBarSeries *barseries = new QHorizontalPercentBarSeries();
83 83 QVERIFY(barseries != 0);
84 84 }
85 85
86 86 void tst_QHorizontalPercentBarSeries::type_data()
87 87 {
88 88
89 89 }
90 90
91 91 void tst_QHorizontalPercentBarSeries::type()
92 92 {
93 93 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeHorizontalPercentBar);
94 94 }
95 95
96 96 void tst_QHorizontalPercentBarSeries::mouseclicked_data()
97 97 {
98 98
99 99 }
100 100
101 101 void tst_QHorizontalPercentBarSeries::mouseclicked()
102 102 {
103 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
104
103 105 QHorizontalPercentBarSeries* series = new QHorizontalPercentBarSeries();
104 106
105 107 QBarSet* set1 = new QBarSet(QString("set 1"));
106 108 *set1 << 10 << 10 << 10;
107 109 series->append(set1);
108 110
109 111 QBarSet* set2 = new QBarSet(QString("set 2"));
110 112 *set2 << 10 << 10 << 10;
111 113 series->append(set2);
112 114
113 115 QSignalSpy seriesSpy(series,SIGNAL(clicked(int, QBarSet*)));
114 116
115 117 QChartView view(new QChart());
116 118 view.resize(400,300);
117 119 view.chart()->addSeries(series);
118 120 view.show();
119 121 QTest::qWaitForWindowShown(&view);
120 122
121 123 //====================================================================================
122 124 // barset 1, category test1
123 125 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(115,231));
124 126 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
125 127
126 128 QCOMPARE(seriesSpy.count(), 1);
127 129
128 130 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
129 131 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
130 132 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
131 133 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
132 134
133 135 //====================================================================================
134 136 // barset 1, category test2
135 137 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(115,150));
136 138 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
137 139
138 140 QCOMPARE(seriesSpy.count(), 1);
139 141
140 142 seriesSpyArg = seriesSpy.takeFirst();
141 143 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
142 144 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
143 145 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
144 146
145 147 //====================================================================================
146 148 // barset 1, category test3
147 149 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(115,69));
148 150 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
149 151
150 152 QCOMPARE(seriesSpy.count(), 1);
151 153
152 154 seriesSpyArg = seriesSpy.takeFirst();
153 155 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
154 156 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
155 157 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
156 158
157 159 //====================================================================================
158 160 // barset 2, category test1
159 161 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(285,230));
160 162 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
161 163
162 164 QCOMPARE(seriesSpy.count(), 1);
163 165
164 166 seriesSpyArg = seriesSpy.takeFirst();
165 167 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
166 168 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
167 169 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
168 170
169 171 //====================================================================================
170 172 // barset 2, category test2
171 173 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(285,150));
172 174 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
173 175
174 176 QCOMPARE(seriesSpy.count(), 1);
175 177
176 178 seriesSpyArg = seriesSpy.takeFirst();
177 179 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
178 180 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
179 181 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
180 182
181 183 //====================================================================================
182 184 // barset 2, category test3
183 185 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(285,69));
184 186 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
185 187
186 188 QCOMPARE(seriesSpy.count(), 1);
187 189
188 190 seriesSpyArg = seriesSpy.takeFirst();
189 191 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
190 192 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
191 193 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
192 194 }
193 195
194 196 void tst_QHorizontalPercentBarSeries::mousehovered_data()
195 197 {
196 198
197 199 }
198 200
199 201 void tst_QHorizontalPercentBarSeries::mousehovered()
200 202 {
203 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
204
201 205 QHorizontalPercentBarSeries* series = new QHorizontalPercentBarSeries();
202 206
203 207 QBarSet* set1 = new QBarSet(QString("set 1"));
204 208 *set1 << 10 << 10 << 10;
205 209 series->append(set1);
206 210
207 211 QBarSet* set2 = new QBarSet(QString("set 2"));
208 212 *set2 << 10 << 10 << 10;
209 213 series->append(set2);
210 214
211 215 QSignalSpy seriesSpy(series,SIGNAL(hovered(bool, QBarSet*)));
212 216
213 217 QChartView view(new QChart());
214 218 view.resize(400,300);
215 219 view.chart()->addSeries(series);
216 220 view.show();
217 221 QTest::qWaitForWindowShown(&view);
218 222
219 223 //this is hack since view does not get events otherwise
220 224 view.setMouseTracking(true);
221 225
222 226 //=======================================================================
223 227 // move mouse to left border
224 228 QTest::mouseMove(view.viewport(), QPoint(0, 231));
225 229 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
226 230 TRY_COMPARE(seriesSpy.count(), 0);
227 231
228 232 //=======================================================================
229 233 // move mouse on top of set1
230 234 QTest::mouseMove(view.viewport(), QPoint(115,231));
231 235 TRY_COMPARE(seriesSpy.count(), 1);
232 236
233 237 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
234 238 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
235 239 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
236 240 QVERIFY(seriesSpyArg.at(0).toBool() == true);
237 241
238 242 //=======================================================================
239 243 // move mouse from top of set1 to top of set2
240 244 QTest::mouseMove(view.viewport(), QPoint(285,231));
241 245 TRY_COMPARE(seriesSpy.count(), 2);
242 246
243 247 // should leave set1
244 248 seriesSpyArg = seriesSpy.takeFirst();
245 249 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
246 250 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
247 251 QVERIFY(seriesSpyArg.at(0).toBool() == false);
248 252
249 253 // should enter set2
250 254 seriesSpyArg = seriesSpy.takeFirst();
251 255 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
252 256 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
253 257 QVERIFY(seriesSpyArg.at(0).toBool() == true);
254 258
255 259 //=======================================================================
256 260 // move mouse from top of set2 to background
257 261 QTest::mouseMove(view.viewport(), QPoint(285,300));
258 262 TRY_COMPARE(seriesSpy.count(), 1);
259 263
260 264 // should leave set2
261 265 seriesSpyArg = seriesSpy.takeFirst();
262 266 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
263 267 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
264 268 QVERIFY(seriesSpyArg.at(0).toBool() == false);
265 269 }
266 270
267 271 QTEST_MAIN(tst_QHorizontalPercentBarSeries)
268 272
269 273 #include "tst_qhorizontalpercentbarseries.moc"
270 274
Show file before | Show file after | Hide comments
@@ -1,270 +1,274
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 <qhorizontalstackedbarseries.h>
23 23 #include <qbarset.h>
24 24 #include <qchartview.h>
25 25 #include <qchart.h>
26 26 #include "tst_definitions.h"
27 27
28 28 QTCOMMERCIALCHART_USE_NAMESPACE
29 29
30 30 Q_DECLARE_METATYPE(QBarSet*)
31 31
32 32 class tst_QHorizontalStackedBarSeries : public QObject
33 33 {
34 34 Q_OBJECT
35 35
36 36 public slots:
37 37 void initTestCase();
38 38 void cleanupTestCase();
39 39 void init();
40 40 void cleanup();
41 41
42 42 private slots:
43 43 void qhorizontalstackedbarseries_data();
44 44 void qhorizontalstackedbarseries();
45 45 void type_data();
46 46 void type();
47 47 void mouseclicked_data();
48 48 void mouseclicked();
49 49 void mousehovered_data();
50 50 void mousehovered();
51 51
52 52 private:
53 53 QHorizontalStackedBarSeries* m_barseries;
54 54 };
55 55
56 56 void tst_QHorizontalStackedBarSeries::initTestCase()
57 57 {
58 58 qRegisterMetaType<QBarSet*>("QBarSet*");
59 59 }
60 60
61 61 void tst_QHorizontalStackedBarSeries::cleanupTestCase()
62 62 {
63 63 }
64 64
65 65 void tst_QHorizontalStackedBarSeries::init()
66 66 {
67 67 m_barseries = new QHorizontalStackedBarSeries();
68 68 }
69 69
70 70 void tst_QHorizontalStackedBarSeries::cleanup()
71 71 {
72 72 delete m_barseries;
73 73 m_barseries = 0;
74 74 }
75 75
76 76 void tst_QHorizontalStackedBarSeries::qhorizontalstackedbarseries_data()
77 77 {
78 78 }
79 79
80 80 void tst_QHorizontalStackedBarSeries::qhorizontalstackedbarseries()
81 81 {
82 82 QHorizontalStackedBarSeries *barseries = new QHorizontalStackedBarSeries();
83 83 QVERIFY(barseries != 0);
84 84 }
85 85
86 86 void tst_QHorizontalStackedBarSeries::type_data()
87 87 {
88 88
89 89 }
90 90
91 91 void tst_QHorizontalStackedBarSeries::type()
92 92 {
93 93 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeHorizontalStackedBar);
94 94 }
95 95
96 96 void tst_QHorizontalStackedBarSeries::mouseclicked_data()
97 97 {
98 98
99 99 }
100 100
101 101 void tst_QHorizontalStackedBarSeries::mouseclicked()
102 102 {
103 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
104
103 105 QHorizontalStackedBarSeries* series = new QHorizontalStackedBarSeries();
104 106
105 107 QBarSet* set1 = new QBarSet(QString("set 1"));
106 108 *set1 << 10 << 10 << 10;
107 109 series->append(set1);
108 110
109 111 QBarSet* set2 = new QBarSet(QString("set 2"));
110 112 *set2 << 10 << 10 << 10;
111 113 series->append(set2);
112 114
113 115 QSignalSpy seriesSpy(series,SIGNAL(clicked(int, QBarSet*)));
114 116
115 117 QChartView view(new QChart());
116 118 view.resize(400,300);
117 119 view.chart()->addSeries(series);
118 120 view.show();
119 121 QTest::qWaitForWindowShown(&view);
120 122
121 123 //====================================================================================
122 124 // barset 1, category test1
123 125 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(115,231));
124 126 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
125 127
126 128 QCOMPARE(seriesSpy.count(), 1);
127 129
128 130 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
129 131 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
130 132 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
131 133 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
132 134
133 135 //====================================================================================
134 136 // barset 1, category test2
135 137 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(115,150));
136 138 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
137 139
138 140 QCOMPARE(seriesSpy.count(), 1);
139 141
140 142 seriesSpyArg = seriesSpy.takeFirst();
141 143 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
142 144 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
143 145 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
144 146
145 147 //====================================================================================
146 148 // barset 1, category test3
147 149 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(115,69));
148 150 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
149 151
150 152 QCOMPARE(seriesSpy.count(), 1);
151 153
152 154 seriesSpyArg = seriesSpy.takeFirst();
153 155 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
154 156 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
155 157 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
156 158
157 159 //====================================================================================
158 160 // barset 2, category test1
159 161 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(285,230));
160 162 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
161 163
162 164 QCOMPARE(seriesSpy.count(), 1);
163 165
164 166 seriesSpyArg = seriesSpy.takeFirst();
165 167 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
166 168 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
167 169 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
168 170
169 171 //====================================================================================
170 172 // barset 2, category test2
171 173 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(285,150));
172 174 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
173 175
174 176 QCOMPARE(seriesSpy.count(), 1);
175 177
176 178 seriesSpyArg = seriesSpy.takeFirst();
177 179 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
178 180 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
179 181 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
180 182
181 183 //====================================================================================
182 184 // barset 2, category test3
183 185 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(285,69));
184 186 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
185 187
186 188 QCOMPARE(seriesSpy.count(), 1);
187 189
188 190 seriesSpyArg = seriesSpy.takeFirst();
189 191 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
190 192 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
191 193 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
192 194 }
193 195
194 196 void tst_QHorizontalStackedBarSeries::mousehovered_data()
195 197 {
196 198
197 199 }
198 200
199 201 void tst_QHorizontalStackedBarSeries::mousehovered()
200 202 {
203 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
204
201 205 QHorizontalStackedBarSeries* series = new QHorizontalStackedBarSeries();
202 206
203 207 QBarSet* set1 = new QBarSet(QString("set 1"));
204 208 *set1 << 10 << 10 << 10;
205 209 series->append(set1);
206 210
207 211 QBarSet* set2 = new QBarSet(QString("set 2"));
208 212 *set2 << 10 << 10 << 10;
209 213 series->append(set2);
210 214
211 215 QSignalSpy seriesSpy(series,SIGNAL(hovered(bool, QBarSet*)));
212 216
213 217 QChartView view(new QChart());
214 218 view.resize(400,300);
215 219 view.chart()->addSeries(series);
216 220 view.show();
217 221 QTest::qWaitForWindowShown(&view);
218 222
219 223 //this is hack since view does not get events otherwise
220 224 view.setMouseTracking(true);
221 225
222 226 //=======================================================================
223 227 // move mouse to left border
224 228 QTest::mouseMove(view.viewport(), QPoint(0, 231));
225 229 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
226 230 TRY_COMPARE(seriesSpy.count(), 0);
227 231
228 232 //=======================================================================
229 233 // move mouse on top of set1
230 234 QTest::mouseMove(view.viewport(), QPoint(115,231));
231 235 TRY_COMPARE(seriesSpy.count(), 1);
232 236
233 237 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
234 238 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
235 239 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
236 240 QVERIFY(seriesSpyArg.at(0).toBool() == true);
237 241
238 242 //=======================================================================
239 243 // move mouse from top of set1 to top of set2
240 244 QTest::mouseMove(view.viewport(), QPoint(285,231));
241 245 TRY_COMPARE(seriesSpy.count(), 2);
242 246
243 247 // should leave set1
244 248 seriesSpyArg = seriesSpy.takeFirst();
245 249 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
246 250 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
247 251 QVERIFY(seriesSpyArg.at(0).toBool() == false);
248 252
249 253 // should enter set2
250 254 seriesSpyArg = seriesSpy.takeFirst();
251 255 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
252 256 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
253 257 QVERIFY(seriesSpyArg.at(0).toBool() == true);
254 258
255 259 //=======================================================================
256 260 // move mouse from top of set2 to background
257 261 QTest::mouseMove(view.viewport(), QPoint(285,300));
258 262 TRY_COMPARE(seriesSpy.count(), 1);
259 263
260 264 // should leave set2
261 265 seriesSpyArg = seriesSpy.takeFirst();
262 266 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
263 267 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
264 268 QVERIFY(seriesSpyArg.at(0).toBool() == false);
265 269 }
266 270
267 271 QTEST_MAIN(tst_QHorizontalStackedBarSeries)
268 272
269 273 #include "tst_qhorizontalstackedbarseries.moc"
270 274
Show file before | Show file after | Hide comments
@@ -1,270 +1,274
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 <qpercentbarseries.h>
23 23 #include <qbarset.h>
24 24 #include <qchartview.h>
25 25 #include <qchart.h>
26 26 #include "tst_definitions.h"
27 27
28 28 QTCOMMERCIALCHART_USE_NAMESPACE
29 29
30 30 Q_DECLARE_METATYPE(QBarSet*)
31 31
32 32 class tst_QPercentBarSeries : public QObject
33 33 {
34 34 Q_OBJECT
35 35
36 36 public slots:
37 37 void initTestCase();
38 38 void cleanupTestCase();
39 39 void init();
40 40 void cleanup();
41 41
42 42 private slots:
43 43 void qpercentbarseries_data();
44 44 void qpercentbarseries();
45 45 void type_data();
46 46 void type();
47 47 void mouseclicked_data();
48 48 void mouseclicked();
49 49 void mousehovered_data();
50 50 void mousehovered();
51 51
52 52 private:
53 53 QPercentBarSeries* m_barseries;
54 54 };
55 55
56 56 void tst_QPercentBarSeries::initTestCase()
57 57 {
58 58 qRegisterMetaType<QBarSet*>("QBarSet*");
59 59 }
60 60
61 61 void tst_QPercentBarSeries::cleanupTestCase()
62 62 {
63 63 }
64 64
65 65 void tst_QPercentBarSeries::init()
66 66 {
67 67 m_barseries = new QPercentBarSeries();
68 68 }
69 69
70 70 void tst_QPercentBarSeries::cleanup()
71 71 {
72 72 delete m_barseries;
73 73 m_barseries = 0;
74 74 }
75 75
76 76 void tst_QPercentBarSeries::qpercentbarseries_data()
77 77 {
78 78 }
79 79
80 80 void tst_QPercentBarSeries::qpercentbarseries()
81 81 {
82 82 QPercentBarSeries *barseries = new QPercentBarSeries();
83 83 QVERIFY(barseries != 0);
84 84 }
85 85
86 86 void tst_QPercentBarSeries::type_data()
87 87 {
88 88
89 89 }
90 90
91 91 void tst_QPercentBarSeries::type()
92 92 {
93 93 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypePercentBar);
94 94 }
95 95
96 96 void tst_QPercentBarSeries::mouseclicked_data()
97 97 {
98 98
99 99 }
100 100
101 101 void tst_QPercentBarSeries::mouseclicked()
102 102 {
103 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
104
103 105 QPercentBarSeries* series = new QPercentBarSeries();
104 106
105 107 QBarSet* set1 = new QBarSet(QString("set 1"));
106 108 *set1 << 10 << 10 << 10;
107 109 series->append(set1);
108 110
109 111 QBarSet* set2 = new QBarSet(QString("set 2"));
110 112 *set2 << 10 << 10 << 10;
111 113 series->append(set2);
112 114
113 115 QSignalSpy seriesSpy(series,SIGNAL(clicked(int, QBarSet*)));
114 116
115 117 QChartView view(new QChart());
116 118 view.resize(400,300);
117 119 view.chart()->addSeries(series);
118 120 view.show();
119 121 QTest::qWaitForWindowShown(&view);
120 122
121 123 //====================================================================================
122 124 // barset 1, category test1
123 125 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(86,211));
124 126 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
125 127
126 128 QCOMPARE(seriesSpy.count(), 1);
127 129
128 130 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
129 131 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
130 132 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
131 133 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
132 134
133 135 //====================================================================================
134 136 // barset 1, category test2
135 137 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(200,211));
136 138 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
137 139
138 140 QCOMPARE(seriesSpy.count(), 1);
139 141
140 142 seriesSpyArg = seriesSpy.takeFirst();
141 143 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
142 144 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
143 145 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
144 146
145 147 //====================================================================================
146 148 // barset 1, category test3
147 149 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(314,211));
148 150 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
149 151
150 152 QCOMPARE(seriesSpy.count(), 1);
151 153
152 154 seriesSpyArg = seriesSpy.takeFirst();
153 155 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
154 156 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
155 157 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
156 158
157 159 //====================================================================================
158 160 // barset 2, category test1
159 161 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(86,90));
160 162 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
161 163
162 164 QCOMPARE(seriesSpy.count(), 1);
163 165
164 166 seriesSpyArg = seriesSpy.takeFirst();
165 167 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
166 168 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
167 169 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
168 170
169 171 //====================================================================================
170 172 // barset 2, category test2
171 173 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(200,90));
172 174 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
173 175
174 176 QCOMPARE(seriesSpy.count(), 1);
175 177
176 178 seriesSpyArg = seriesSpy.takeFirst();
177 179 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
178 180 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
179 181 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
180 182
181 183 //====================================================================================
182 184 // barset 2, category test3
183 185 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(314,90));
184 186 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
185 187
186 188 QCOMPARE(seriesSpy.count(), 1);
187 189
188 190 seriesSpyArg = seriesSpy.takeFirst();
189 191 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
190 192 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
191 193 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
192 194 }
193 195
194 196 void tst_QPercentBarSeries::mousehovered_data()
195 197 {
196 198
197 199 }
198 200
199 201 void tst_QPercentBarSeries::mousehovered()
200 202 {
203 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
204
201 205 QPercentBarSeries* series = new QPercentBarSeries();
202 206
203 207 QBarSet* set1 = new QBarSet(QString("set 1"));
204 208 *set1 << 10 << 10 << 10;
205 209 series->append(set1);
206 210
207 211 QBarSet* set2 = new QBarSet(QString("set 2"));
208 212 *set2 << 10 << 10 << 10;
209 213 series->append(set2);
210 214
211 215 QSignalSpy seriesSpy(series,SIGNAL(hovered(bool, QBarSet*)));
212 216
213 217 QChartView view(new QChart());
214 218 view.resize(400,300);
215 219 view.chart()->addSeries(series);
216 220 view.show();
217 221 QTest::qWaitForWindowShown(&view);
218 222
219 223 //this is hack since view does not get events otherwise
220 224 view.setMouseTracking(true);
221 225
222 226 //=======================================================================
223 227 // move mouse to left border
224 228 QTest::mouseMove(view.viewport(), QPoint(0, 211));
225 229 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
226 230 TRY_COMPARE(seriesSpy.count(), 0);
227 231
228 232 //=======================================================================
229 233 // move mouse on top of set1
230 234 QTest::mouseMove(view.viewport(), QPoint(86,211));
231 235 TRY_COMPARE(seriesSpy.count(), 1);
232 236
233 237 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
234 238 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
235 239 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
236 240 QVERIFY(seriesSpyArg.at(0).toBool() == true);
237 241
238 242 //=======================================================================
239 243 // move mouse from top of set1 to top of set2
240 244 QTest::mouseMove(view.viewport(), QPoint(86,90));
241 245 TRY_COMPARE(seriesSpy.count(), 2);
242 246
243 247 // should leave set1
244 248 seriesSpyArg = seriesSpy.takeFirst();
245 249 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
246 250 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
247 251 QVERIFY(seriesSpyArg.at(0).toBool() == false);
248 252
249 253 // should enter set2
250 254 seriesSpyArg = seriesSpy.takeFirst();
251 255 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
252 256 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
253 257 QVERIFY(seriesSpyArg.at(0).toBool() == true);
254 258
255 259 //=======================================================================
256 260 // move mouse from top of set2 to background
257 261 QTest::mouseMove(view.viewport(), QPoint(86,0));
258 262 TRY_COMPARE(seriesSpy.count(), 1);
259 263
260 264 // should leave set2
261 265 seriesSpyArg = seriesSpy.takeFirst();
262 266 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
263 267 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
264 268 QVERIFY(seriesSpyArg.at(0).toBool() == false);
265 269 }
266 270
267 271 QTEST_MAIN(tst_QPercentBarSeries)
268 272
269 273 #include "tst_qpercentbarseries.moc"
270 274
Show file before | Show file after | Hide comments
@@ -1,270 +1,274
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 <qstackedbarseries.h>
23 23 #include <qbarset.h>
24 24 #include <qchartview.h>
25 25 #include <qchart.h>
26 26 #include "tst_definitions.h"
27 27
28 28 QTCOMMERCIALCHART_USE_NAMESPACE
29 29
30 30 Q_DECLARE_METATYPE(QBarSet*)
31 31
32 32 class tst_QStackedBarSeries : public QObject
33 33 {
34 34 Q_OBJECT
35 35
36 36 public slots:
37 37 void initTestCase();
38 38 void cleanupTestCase();
39 39 void init();
40 40 void cleanup();
41 41
42 42 private slots:
43 43 void qstackedbarseries_data();
44 44 void qstackedbarseries();
45 45 void type_data();
46 46 void type();
47 47 void mouseclicked_data();
48 48 void mouseclicked();
49 49 void mousehovered_data();
50 50 void mousehovered();
51 51
52 52 private:
53 53 QStackedBarSeries* m_barseries;
54 54 };
55 55
56 56 void tst_QStackedBarSeries::initTestCase()
57 57 {
58 58 qRegisterMetaType<QBarSet*>("QBarSet*");
59 59 }
60 60
61 61 void tst_QStackedBarSeries::cleanupTestCase()
62 62 {
63 63 }
64 64
65 65 void tst_QStackedBarSeries::init()
66 66 {
67 67 m_barseries = new QStackedBarSeries();
68 68 }
69 69
70 70 void tst_QStackedBarSeries::cleanup()
71 71 {
72 72 delete m_barseries;
73 73 m_barseries = 0;
74 74 }
75 75
76 76 void tst_QStackedBarSeries::qstackedbarseries_data()
77 77 {
78 78 }
79 79
80 80 void tst_QStackedBarSeries::qstackedbarseries()
81 81 {
82 82 QStackedBarSeries *barseries = new QStackedBarSeries();
83 83 QVERIFY(barseries != 0);
84 84 }
85 85
86 86 void tst_QStackedBarSeries::type_data()
87 87 {
88 88
89 89 }
90 90
91 91 void tst_QStackedBarSeries::type()
92 92 {
93 93 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeStackedBar);
94 94 }
95 95
96 96 void tst_QStackedBarSeries::mouseclicked_data()
97 97 {
98 98
99 99 }
100 100
101 101 void tst_QStackedBarSeries::mouseclicked()
102 102 {
103 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
104
103 105 QStackedBarSeries* series = new QStackedBarSeries();
104 106
105 107 QBarSet* set1 = new QBarSet(QString("set 1"));
106 108 *set1 << 10 << 10 << 10;
107 109 series->append(set1);
108 110
109 111 QBarSet* set2 = new QBarSet(QString("set 2"));
110 112 *set2 << 10 << 10 << 10;
111 113 series->append(set2);
112 114
113 115 QSignalSpy seriesSpy(series,SIGNAL(clicked(int, QBarSet*)));
114 116
115 117 QChartView view(new QChart());
116 118 view.resize(400,300);
117 119 view.chart()->addSeries(series);
118 120 view.show();
119 121 QTest::qWaitForWindowShown(&view);
120 122
121 123 //====================================================================================
122 124 // barset 1, category test1
123 125 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(86,211));
124 126 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
125 127
126 128 QCOMPARE(seriesSpy.count(), 1);
127 129
128 130 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
129 131 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
130 132 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
131 133 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
132 134
133 135 //====================================================================================
134 136 // barset 1, category test2
135 137 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(200,211));
136 138 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
137 139
138 140 QCOMPARE(seriesSpy.count(), 1);
139 141
140 142 seriesSpyArg = seriesSpy.takeFirst();
141 143 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
142 144 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
143 145 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
144 146
145 147 //====================================================================================
146 148 // barset 1, category test3
147 149 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(314,211));
148 150 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
149 151
150 152 QCOMPARE(seriesSpy.count(), 1);
151 153
152 154 seriesSpyArg = seriesSpy.takeFirst();
153 155 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
154 156 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
155 157 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
156 158
157 159 //====================================================================================
158 160 // barset 2, category test1
159 161 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(86,90));
160 162 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
161 163
162 164 QCOMPARE(seriesSpy.count(), 1);
163 165
164 166 seriesSpyArg = seriesSpy.takeFirst();
165 167 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
166 168 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
167 169 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
168 170
169 171 //====================================================================================
170 172 // barset 2, category test2
171 173 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(200,90));
172 174 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
173 175
174 176 QCOMPARE(seriesSpy.count(), 1);
175 177
176 178 seriesSpyArg = seriesSpy.takeFirst();
177 179 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
178 180 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
179 181 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
180 182
181 183 //====================================================================================
182 184 // barset 2, category test3
183 185 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(314,90));
184 186 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
185 187
186 188 QCOMPARE(seriesSpy.count(), 1);
187 189
188 190 seriesSpyArg = seriesSpy.takeFirst();
189 191 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
190 192 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
191 193 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
192 194 }
193 195
194 196 void tst_QStackedBarSeries::mousehovered_data()
195 197 {
196 198
197 199 }
198 200
199 201 void tst_QStackedBarSeries::mousehovered()
200 202 {
203 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
204
201 205 QStackedBarSeries* series = new QStackedBarSeries();
202 206
203 207 QBarSet* set1 = new QBarSet(QString("set 1"));
204 208 *set1 << 10 << 10 << 10;
205 209 series->append(set1);
206 210
207 211 QBarSet* set2 = new QBarSet(QString("set 2"));
208 212 *set2 << 10 << 10 << 10;
209 213 series->append(set2);
210 214
211 215 QSignalSpy seriesSpy(series,SIGNAL(hovered(bool, QBarSet*)));
212 216
213 217 QChartView view(new QChart());
214 218 view.resize(400,300);
215 219 view.chart()->addSeries(series);
216 220 view.show();
217 221 QTest::qWaitForWindowShown(&view);
218 222
219 223 //this is hack since view does not get events otherwise
220 224 view.setMouseTracking(true);
221 225
222 226 //=======================================================================
223 227 // move mouse to left border
224 228 QTest::mouseMove(view.viewport(), QPoint(0, 211));
225 229 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
226 230 TRY_COMPARE(seriesSpy.count(), 0);
227 231
228 232 //=======================================================================
229 233 // move mouse on top of set1
230 234 QTest::mouseMove(view.viewport(), QPoint(86,211));
231 235 TRY_COMPARE(seriesSpy.count(), 1);
232 236
233 237 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
234 238 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
235 239 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
236 240 QVERIFY(seriesSpyArg.at(0).toBool() == true);
237 241
238 242 //=======================================================================
239 243 // move mouse from top of set1 to top of set2
240 244 QTest::mouseMove(view.viewport(), QPoint(86,90));
241 245 TRY_COMPARE(seriesSpy.count(), 2);
242 246
243 247 // should leave set1
244 248 seriesSpyArg = seriesSpy.takeFirst();
245 249 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
246 250 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
247 251 QVERIFY(seriesSpyArg.at(0).toBool() == false);
248 252
249 253 // should enter set2
250 254 seriesSpyArg = seriesSpy.takeFirst();
251 255 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
252 256 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
253 257 QVERIFY(seriesSpyArg.at(0).toBool() == true);
254 258
255 259 //=======================================================================
256 260 // move mouse from top of set2 to background
257 261 QTest::mouseMove(view.viewport(), QPoint(86,0));
258 262 TRY_COMPARE(seriesSpy.count(), 1);
259 263
260 264 // should leave set2
261 265 seriesSpyArg = seriesSpy.takeFirst();
262 266 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
263 267 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
264 268 QVERIFY(seriesSpyArg.at(0).toBool() == false);
265 269 }
266 270
267 271 QTEST_MAIN(tst_QStackedBarSeries)
268 272
269 273 #include "tst_qstackedbarseries.moc"
270 274
General Comments 0
You need to be logged in to leave comments. Login now