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

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

minor. compilation fix in tst_qbarseries
Michal Klocek -
r1803:71ff0d27fedc
parent child
Show More
Side by Side Unified
Context file:
r1803:71ff0d27fedc Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,619 +1,619
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 qRegisterMetaType<QList<QBarSet*>>("QList<QBarSet*>");
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 QList<QBarSet*> removedSets = qvariant_cast<QList<QBarSet*>> (removedSpyArg.at(0));
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 352 QBarSeries* series = new QBarSeries();
353 353
354 354 QBarSet* set1 = new QBarSet(QString("set 1"));
355 355 *set1 << 10 << 10 << 10;
356 356 series->append(set1);
357 357
358 358 QBarSet* set2 = new QBarSet(QString("set 2"));
359 359 *set2 << 10 << 10 << 10;
360 360 series->append(set2);
361 361
362 362 QSignalSpy seriesSpy(series,SIGNAL(clicked(int,QBarSet*)));
363 363 QSignalSpy setSpy1(set1, SIGNAL(clicked(int)));
364 364 QSignalSpy setSpy2(set2, SIGNAL(clicked(int)));
365 365
366 366 QChartView view(new QChart());
367 367 view.resize(400,300);
368 368 view.chart()->addSeries(series);
369 369 view.show();
370 370 QTest::qWaitForWindowShown(&view);
371 371
372 372 //====================================================================================
373 373 // barset 1, bar 0
374 374 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(95,143));
375 375 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
376 376
377 377 QCOMPARE(seriesSpy.count(), 1);
378 378 QCOMPARE(setSpy1.count(), 1);
379 379 QCOMPARE(setSpy2.count(), 0);
380 380
381 381 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
382 382 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
383 383 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
384 384 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
385 385
386 386 QList<QVariant> setSpyArg = setSpy1.takeFirst();
387 387 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
388 388 QVERIFY(setSpyArg.at(0).toInt() == 0);
389 389
390 390 //====================================================================================
391 391 // barset 1, bar 1
392 392 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(187,143));
393 393 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
394 394
395 395 QCOMPARE(seriesSpy.count(), 1);
396 396 QCOMPARE(setSpy1.count(), 1);
397 397 QCOMPARE(setSpy2.count(), 0);
398 398
399 399 seriesSpyArg = seriesSpy.takeFirst();
400 400 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
401 401 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
402 402 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
403 403
404 404 setSpyArg = setSpy1.takeFirst();
405 405 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
406 406 QVERIFY(setSpyArg.at(0).toInt() == 1);
407 407
408 408 //====================================================================================
409 409 // barset 1, bar 2
410 410 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(280,143));
411 411 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
412 412
413 413 QCOMPARE(seriesSpy.count(), 1);
414 414 QCOMPARE(setSpy1.count(), 1);
415 415 QCOMPARE(setSpy2.count(), 0);
416 416
417 417 seriesSpyArg = seriesSpy.takeFirst();
418 418 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
419 419 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
420 420 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
421 421
422 422 setSpyArg = setSpy1.takeFirst();
423 423 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
424 424 QVERIFY(setSpyArg.at(0).toInt() == 2);
425 425
426 426 //====================================================================================
427 427 // barset 2, bar 0
428 428 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(118,143));
429 429 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
430 430
431 431 QCOMPARE(seriesSpy.count(), 1);
432 432 QCOMPARE(setSpy1.count(), 0);
433 433 QCOMPARE(setSpy2.count(), 1);
434 434
435 435 seriesSpyArg = seriesSpy.takeFirst();
436 436 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
437 437 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
438 438 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
439 439
440 440 setSpyArg = setSpy2.takeFirst();
441 441 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
442 442 QVERIFY(setSpyArg.at(0).toInt() == 0);
443 443
444 444 //====================================================================================
445 445 // barset 2, bar 1
446 446 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(210,143));
447 447 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
448 448
449 449 QCOMPARE(seriesSpy.count(), 1);
450 450 QCOMPARE(setSpy1.count(), 0);
451 451 QCOMPARE(setSpy2.count(), 1);
452 452
453 453 seriesSpyArg = seriesSpy.takeFirst();
454 454 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
455 455 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
456 456 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
457 457
458 458 setSpyArg = setSpy2.takeFirst();
459 459 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
460 460 QVERIFY(setSpyArg.at(0).toInt() == 1);
461 461
462 462 //====================================================================================
463 463 // barset 2, bar 2
464 464 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(303,143));
465 465 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
466 466
467 467 QCOMPARE(seriesSpy.count(), 1);
468 468 QCOMPARE(setSpy1.count(), 0);
469 469 QCOMPARE(setSpy2.count(), 1);
470 470
471 471 seriesSpyArg = seriesSpy.takeFirst();
472 472 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
473 473 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
474 474 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
475 475
476 476 setSpyArg = setSpy2.takeFirst();
477 477 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
478 478 QVERIFY(setSpyArg.at(0).toInt() == 2);
479 479 }
480 480
481 481 void tst_QBarSeries::mousehovered_data()
482 482 {
483 483
484 484 }
485 485
486 486 void tst_QBarSeries::mousehovered()
487 487 {
488 488 QBarSeries* series = new QBarSeries();
489 489
490 490 QBarSet* set1 = new QBarSet(QString("set 1"));
491 491 *set1 << 10 << 10 << 10;
492 492 series->append(set1);
493 493
494 494 QBarSet* set2 = new QBarSet(QString("set 2"));
495 495 *set2 << 10 << 10 << 10;
496 496 series->append(set2);
497 497
498 498 QSignalSpy seriesSpy(series,SIGNAL(hovered(bool,QBarSet*)));
499 499 QSignalSpy setSpy1(set1, SIGNAL(hovered(bool)));
500 500 QSignalSpy setSpy2(set2, SIGNAL(hovered(bool)));
501 501
502 502 QChartView view(new QChart());
503 503 view.resize(400,300);
504 504 view.chart()->addSeries(series);
505 505 view.show();
506 506 QTest::qWaitForWindowShown(&view);
507 507
508 508 //this is hack since view does not get events otherwise
509 509 view.setMouseTracking(true);
510 510
511 511 //=======================================================================
512 512 // move mouse to left border
513 513 QTest::mouseMove(view.viewport(), QPoint(0, 143));
514 514 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
515 515 TRY_COMPARE(seriesSpy.count(), 0);
516 516 TRY_COMPARE(setSpy1.count(), 0);
517 517 TRY_COMPARE(setSpy2.count(), 0);
518 518
519 519 //=======================================================================
520 520 // move mouse on top of set1
521 521 QTest::mouseMove(view.viewport(), QPoint(95,143));
522 522 TRY_COMPARE(seriesSpy.count(), 1);
523 523 TRY_COMPARE(setSpy1.count(), 1);
524 524 TRY_COMPARE(setSpy2.count(), 0);
525 525
526 526 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
527 527 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
528 528 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
529 529 QVERIFY(seriesSpyArg.at(0).toBool() == true);
530 530
531 531 QList<QVariant> setSpyArg = setSpy1.takeFirst();
532 532 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
533 533 QVERIFY(setSpyArg.at(0).toBool() == true);
534 534
535 535 //=======================================================================
536 536 // move mouse from top of set1 to top of set2
537 537 QTest::mouseMove(view.viewport(), QPoint(118,143));
538 538 TRY_COMPARE(seriesSpy.count(), 2);
539 539 TRY_COMPARE(setSpy1.count(), 1);
540 540 TRY_COMPARE(setSpy2.count(), 1);
541 541
542 542 // should leave set1
543 543 seriesSpyArg = seriesSpy.takeFirst();
544 544 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
545 545 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
546 546 QVERIFY(seriesSpyArg.at(0).toBool() == false);
547 547
548 548 setSpyArg = setSpy1.takeFirst();
549 549 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
550 550 QVERIFY(setSpyArg.at(0).toBool() == false);
551 551
552 552 // should enter set2
553 553 seriesSpyArg = seriesSpy.takeFirst();
554 554 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
555 555 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
556 556 QVERIFY(seriesSpyArg.at(0).toBool() == true);
557 557
558 558 setSpyArg = setSpy2.takeFirst();
559 559 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
560 560 QVERIFY(setSpyArg.at(0).toBool() == true);
561 561
562 562 //=======================================================================
563 563 // move mouse from top of set2 to background
564 564 QTest::mouseMove(view.viewport(), QPoint(118,0));
565 565 TRY_COMPARE(seriesSpy.count(), 1);
566 566 TRY_COMPARE(setSpy1.count(), 0);
567 567 TRY_COMPARE(setSpy2.count(), 1);
568 568
569 569 // should leave set2
570 570 seriesSpyArg = seriesSpy.takeFirst();
571 571 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
572 572 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
573 573 QVERIFY(seriesSpyArg.at(0).toBool() == false);
574 574
575 575 setSpyArg = setSpy2.takeFirst();
576 576 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
577 577 QVERIFY(setSpyArg.at(0).toBool() == false);
578 578 }
579 579
580 580 void tst_QBarSeries::clearWithAnimations()
581 581 {
582 582 QBarSeries* series = new QBarSeries();
583 583
584 584 QBarSet* set1 = new QBarSet(QString("set 1"));
585 585 *set1 << 10 << 10 << 10;
586 586 series->append(set1);
587 587
588 588 QBarSet* set2 = new QBarSet(QString("set 2"));
589 589 *set2 << 10 << 10 << 10;
590 590 series->append(set2);
591 591
592 592 QChartView view(new QChart());
593 593 view.resize(400,300);
594 594 view.chart()->setAnimationOptions(QChart::SeriesAnimations);
595 595 view.chart()->addSeries(series);
596 596 view.show();
597 597
598 598 series->clear();
599 599 }
600 600
601 601 void tst_QBarSeries::destruction()
602 602 {
603 603 // add a barset
604 604 QBarSeries *series = new QBarSeries();
605 605 QBarSet *set = new QBarSet("testset");
606 606 QSignalSpy spy1(set, SIGNAL(destroyed()));
607 607 series->append(set);
608 608
609 609 // delete the series
610 610 delete series;
611 611
612 612 // check that series deletes the set
613 613 QCOMPARE(spy1.count(), 1);
614 614 }
615 615
616 616 QTEST_MAIN(tst_QBarSeries)
617 617
618 618 #include "tst_qbarseries.moc"
619 619
General Comments 0
You need to be logged in to leave comments. Login now