| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the Qt Charts module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:GPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 3 or (at your option) any later version |
| ** approved by the KDE Free Qt Foundation. The licenses are as published by |
| ** the Free Software Foundation and appearing in the file LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include <QtTest/QtTest> |
| #include <QtCharts/QChartView> |
| #include <QtCharts/QLineSeries> |
| #include <QtCharts/QAreaSeries> |
| #include <QtCharts/QScatterSeries> |
| #include <QtCharts/QSplineSeries> |
| #include <QtCharts/QPieSeries> |
| #include <QtCharts/QAbstractBarSeries> |
| #include <QtCharts/QBarSeries> |
| #include <QtCharts/QPercentBarSeries> |
| #include <QtCharts/QStackedBarSeries> |
| #include <QtCharts/QValueAxis> |
| #include <QtCharts/QBarCategoryAxis> |
| #include <QtCharts/QDateTimeAxis> |
| #include "tst_definitions.h" |
| |
| QT_CHARTS_USE_NAMESPACE |
| |
| Q_DECLARE_METATYPE(QAbstractAxis *) |
| Q_DECLARE_METATYPE(QValueAxis *) |
| Q_DECLARE_METATYPE(QBarCategoryAxis *) |
| Q_DECLARE_METATYPE(QAbstractSeries *) |
| Q_DECLARE_METATYPE(QChart::AnimationOption) |
| Q_DECLARE_METATYPE(QBrush) |
| Q_DECLARE_METATYPE(QPen) |
| Q_DECLARE_METATYPE(QChart::ChartTheme) |
| |
| class tst_QChart : public QObject |
| { |
| Q_OBJECT |
| |
| public slots: |
| void initTestCase(); |
| void cleanupTestCase(); |
| void init(); |
| void cleanup(); |
| |
| private slots: |
| void qchart_data(); |
| void qchart(); |
| void addSeries_data(); |
| void addSeries(); |
| void animationOptions_data(); |
| void animationOptions(); |
| void animationDuration(); |
| void animationCurve_data(); |
| void animationCurve(); |
| void axisX_data(); |
| void axisX(); |
| void axisY_data(); |
| void axisY(); |
| void backgroundBrush_data(); |
| void backgroundBrush(); |
| void backgroundPen_data(); |
| void backgroundPen(); |
| void isBackgroundVisible_data(); |
| void isBackgroundVisible(); |
| void plotAreaBackgroundBrush_data(); |
| void plotAreaBackgroundBrush(); |
| void plotAreaBackgroundPen_data(); |
| void plotAreaBackgroundPen(); |
| void isPlotAreaBackgroundVisible_data(); |
| void isPlotAreaBackgroundVisible(); |
| void legend_data(); |
| void legend(); |
| void plotArea_data(); |
| void plotArea(); |
| void removeAllSeries_data(); |
| void removeAllSeries(); |
| void removeSeries_data(); |
| void removeSeries(); |
| void scroll_right_data(); |
| void scroll_right(); |
| void scroll_left_data(); |
| void scroll_left(); |
| void scroll_up_data(); |
| void scroll_up(); |
| void scroll_down_data(); |
| void scroll_down(); |
| void theme_data(); |
| void theme(); |
| void title_data(); |
| void title(); |
| void titleBrush_data(); |
| void titleBrush(); |
| void titleFont_data(); |
| void titleFont(); |
| void zoomIn_data(); |
| void zoomIn(); |
| void zoomOut_data(); |
| void zoomOut(); |
| void zoomReset(); |
| void createDefaultAxesForLineSeries_data(); |
| void createDefaultAxesForLineSeries(); |
| void axisPolarOrientation(); |
| void backgroundRoundness(); |
| void zoomInAndOut_data(); |
| void zoomInAndOut(); |
| void fixedPlotArea(); |
| private: |
| void createTestData(); |
| |
| private: |
| QChartView* m_view; |
| QChart* m_chart; |
| }; |
| |
| void tst_QChart::initTestCase() |
| { |
| |
| } |
| |
| void tst_QChart::cleanupTestCase() |
| { |
| QTest::qWait(1); // Allow final deleteLaters to run |
| } |
| |
| void tst_QChart::init() |
| { |
| m_view = new QChartView(newQChartOrQPolarChart()); |
| m_view->resize(200, 200); |
| m_chart = m_view->chart(); |
| } |
| |
| void tst_QChart::cleanup() |
| { |
| delete m_view; |
| m_view = 0; |
| m_chart = 0; |
| } |
| |
| |
| void tst_QChart::createTestData() |
| { |
| QLineSeries* series0 = new QLineSeries(this); |
| *series0 << QPointF(0, 0) << QPointF(100, 100); |
| m_chart->addSeries(series0); |
| m_view->show(); |
| QVERIFY(QTest::qWaitForWindowExposed(m_view)); |
| } |
| |
| void tst_QChart::qchart_data() |
| { |
| } |
| |
| void tst_QChart::qchart() |
| { |
| QVERIFY(m_chart); |
| QVERIFY(m_chart->legend()); |
| QVERIFY(m_chart->legend()->isVisible()); |
| |
| QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation); |
| QCOMPARE(m_chart->animationDuration(), 1000); |
| QCOMPARE(m_chart->animationEasingCurve(), QEasingCurve(QEasingCurve::OutQuart)); |
| QVERIFY(m_chart->axes(Qt::Horizontal).isEmpty()); |
| QVERIFY(m_chart->axes(Qt::Vertical).isEmpty()); |
| QVERIFY(m_chart->backgroundBrush()!=QBrush()); |
| QVERIFY(m_chart->backgroundPen()!=QPen()); |
| QCOMPARE(m_chart->isBackgroundVisible(), true); |
| QVERIFY(m_chart->plotArea().top()==0); |
| QVERIFY(m_chart->plotArea().left()==0); |
| QVERIFY(m_chart->plotArea().right()==0); |
| QVERIFY(m_chart->plotArea().bottom()==0); |
| QCOMPARE(m_chart->theme(), QChart::ChartThemeLight); |
| QCOMPARE(m_chart->title(), QString()); |
| |
| //QCOMPARE(m_chart->titleBrush(),QBrush()); |
| //QCOMPARE(m_chart->titleFont(),QFont()); |
| |
| m_chart->removeAllSeries(); |
| m_chart->scroll(0,0); |
| |
| m_chart->zoomIn(); |
| m_chart->zoomIn(QRectF()); |
| m_chart->zoomOut(); |
| |
| m_view->show(); |
| |
| QVERIFY(m_chart->plotArea().top()>0); |
| QVERIFY(m_chart->plotArea().left()>0); |
| QVERIFY(m_chart->plotArea().right()>0); |
| QVERIFY(m_chart->plotArea().bottom()>0); |
| } |
| |
| void tst_QChart::addSeries_data() |
| { |
| QTest::addColumn<QAbstractSeries *>("series"); |
| |
| QAbstractSeries* line = new QLineSeries(this); |
| QAbstractSeries* area = new QAreaSeries(new QLineSeries(this)); |
| QAbstractSeries* scatter = new QScatterSeries(this); |
| QAbstractSeries* spline = new QSplineSeries(this); |
| |
| QTest::newRow("lineSeries") << line; |
| QTest::newRow("areaSeries") << area; |
| QTest::newRow("scatterSeries") << scatter; |
| QTest::newRow("splineSeries") << spline; |
| |
| if (!isPolarTest()) { |
| QAbstractSeries* pie = new QPieSeries(this); |
| QAbstractSeries* bar = new QBarSeries(this); |
| QAbstractSeries* percent = new QPercentBarSeries(this); |
| QAbstractSeries* stacked = new QStackedBarSeries(this); |
| QTest::newRow("pieSeries") << pie; |
| QTest::newRow("barSeries") << bar; |
| QTest::newRow("percentBarSeries") << percent; |
| QTest::newRow("stackedBarSeries") << stacked; |
| } |
| } |
| |
| void tst_QChart::addSeries() |
| { |
| QFETCH(QAbstractSeries *, series); |
| m_view->show(); |
| QVERIFY(QTest::qWaitForWindowExposed(m_view)); |
| QVERIFY(!series->chart()); |
| QCOMPARE(m_chart->series().count(), 0); |
| m_chart->addSeries(series); |
| QCOMPARE(m_chart->series().count(), 1); |
| QCOMPARE(m_chart->series().first(), series); |
| QVERIFY(series->chart() == m_chart); |
| m_chart->createDefaultAxes(); |
| if(series->type()!=QAbstractSeries::SeriesTypePie){ |
| QVERIFY(!m_chart->axes(Qt::Vertical, series).isEmpty()); |
| QVERIFY(!m_chart->axes(Qt::Horizontal, series).isEmpty()); |
| }else{ |
| QVERIFY(m_chart->axes(Qt::Vertical, series).isEmpty()); |
| QVERIFY(m_chart->axes(Qt::Horizontal, series).isEmpty()); |
| } |
| m_chart->removeSeries(series); |
| QVERIFY(!series->chart()); |
| QCOMPARE(m_chart->series().count(), 0); |
| delete series; |
| } |
| |
| void tst_QChart::animationOptions_data() |
| { |
| QTest::addColumn<QChart::AnimationOption>("animationOptions"); |
| QTest::newRow("AllAnimations") << QChart::AllAnimations; |
| QTest::newRow("NoAnimation") << QChart::NoAnimation; |
| QTest::newRow("GridAxisAnimations") << QChart::GridAxisAnimations; |
| QTest::newRow("SeriesAnimations") << QChart::SeriesAnimations; |
| } |
| |
| void tst_QChart::animationOptions() |
| { |
| createTestData(); |
| QFETCH(QChart::AnimationOption, animationOptions); |
| m_chart->setAnimationOptions(animationOptions); |
| QCOMPARE(m_chart->animationOptions(), animationOptions); |
| } |
| |
| void tst_QChart::animationDuration() |
| { |
| createTestData(); |
| m_chart->setAnimationDuration(2000); |
| QVERIFY(m_chart->animationDuration() == 2000); |
| } |
| |
| void tst_QChart::animationCurve_data() |
| { |
| QTest::addColumn<QEasingCurve>("animationCurve"); |
| QTest::newRow("Linear") << QEasingCurve(QEasingCurve::Linear); |
| QTest::newRow("InCubic") << QEasingCurve(QEasingCurve::InCubic); |
| QTest::newRow("OutSine") << QEasingCurve(QEasingCurve::OutSine); |
| QTest::newRow("OutInBack") << QEasingCurve(QEasingCurve::OutInBack); |
| } |
| |
| void tst_QChart::animationCurve() |
| { |
| createTestData(); |
| QFETCH(QEasingCurve, animationCurve); |
| m_chart->setAnimationEasingCurve(animationCurve); |
| QCOMPARE(m_chart->animationEasingCurve(), animationCurve); |
| } |
| |
| void tst_QChart::axisX_data() |
| { |
| |
| QTest::addColumn<QAbstractAxis*>("axis"); |
| QTest::addColumn<QAbstractSeries *>("series"); |
| |
| QTest::newRow("categories,lineSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QLineSeries(this); |
| QTest::newRow("categories,areaSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this)); |
| QTest::newRow("categories,scatterSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QScatterSeries(this); |
| QTest::newRow("categories,splineSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QSplineSeries(this); |
| if (!isPolarTest()) { |
| QTest::newRow("categories,pieSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPieSeries(this); |
| QTest::newRow("categories,barSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QBarSeries(this); |
| QTest::newRow("categories,percentBarSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPercentBarSeries(this); |
| QTest::newRow("categories,stackedBarSeries") << (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QStackedBarSeries(this); |
| } |
| |
| QTest::newRow("value,lineSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QLineSeries(this); |
| QTest::newRow("value,areaSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this)); |
| QTest::newRow("value,scatterSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QScatterSeries(this); |
| QTest::newRow("value,splineSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QSplineSeries(this); |
| if (!isPolarTest()) { |
| QTest::newRow("value,pieSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPieSeries(this); |
| QTest::newRow("value,barSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QBarSeries(this); |
| QTest::newRow("value,percentBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPercentBarSeries(this); |
| QTest::newRow("value,stackedBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QStackedBarSeries(this); |
| } |
| } |
| |
| void tst_QChart::axisX() |
| { |
| QFETCH(QAbstractAxis*, axis); |
| QFETCH(QAbstractSeries*, series); |
| QVERIFY(m_chart->axes(Qt::Horizontal).isEmpty()); |
| m_view->show(); |
| QVERIFY(QTest::qWaitForWindowExposed(m_view)); |
| m_chart->addSeries(series); |
| m_chart->addAxis(axis, Qt::AlignBottom); |
| series->attachAxis(axis); |
| QCOMPARE(m_chart->axes(Qt::Horizontal, series).value(0), axis); |
| } |
| |
| void tst_QChart::axisY_data() |
| { |
| axisX_data(); |
| } |
| |
| |
| void tst_QChart::axisY() |
| { |
| QFETCH(QAbstractAxis*, axis); |
| QFETCH(QAbstractSeries*, series); |
| QVERIFY(m_chart->axes(Qt::Vertical).isEmpty()); |
| m_view->show(); |
| QVERIFY(QTest::qWaitForWindowExposed(m_view)); |
| m_chart->addSeries(series); |
| m_chart->addAxis(axis, Qt::AlignLeft); |
| series->attachAxis(axis); |
| QCOMPARE(m_chart->axes(Qt::Vertical, series).value(0), axis); |
| } |
| |
| void tst_QChart::backgroundBrush_data() |
| { |
| QTest::addColumn<QBrush>("backgroundBrush"); |
| QTest::newRow("null") << QBrush(); |
| QTest::newRow("blue") << QBrush(Qt::blue); |
| QTest::newRow("white") << QBrush(Qt::white); |
| QTest::newRow("black") << QBrush(Qt::black); |
| } |
| |
| void tst_QChart::backgroundBrush() |
| { |
| QFETCH(QBrush, backgroundBrush); |
| m_chart->setBackgroundBrush(backgroundBrush); |
| QCOMPARE(m_chart->backgroundBrush(), backgroundBrush); |
| } |
| |
| void tst_QChart::backgroundPen_data() |
| { |
| QTest::addColumn<QPen>("backgroundPen"); |
| QTest::newRow("null") << QPen(); |
| QTest::newRow("blue") << QPen(Qt::blue); |
| QTest::newRow("white") << QPen(Qt::white); |
| QTest::newRow("black") << QPen(Qt::black); |
| } |
| |
| |
| void tst_QChart::backgroundPen() |
| { |
| QFETCH(QPen, backgroundPen); |
| m_chart->setBackgroundPen(backgroundPen); |
| QCOMPARE(m_chart->backgroundPen(), backgroundPen); |
| } |
| |
| void tst_QChart::isBackgroundVisible_data() |
| { |
| QTest::addColumn<bool>("isBackgroundVisible"); |
| QTest::newRow("true") << true; |
| QTest::newRow("false") << false; |
| } |
| |
| void tst_QChart::isBackgroundVisible() |
| { |
| QFETCH(bool, isBackgroundVisible); |
| m_chart->setBackgroundVisible(isBackgroundVisible); |
| QCOMPARE(m_chart->isBackgroundVisible(), isBackgroundVisible); |
| } |
| |
| void tst_QChart::plotAreaBackgroundBrush_data() |
| { |
| QTest::addColumn<QBrush>("plotAreaBackgroundBrush"); |
| QTest::newRow("null") << QBrush(); |
| QTest::newRow("blue") << QBrush(Qt::blue); |
| QTest::newRow("white") << QBrush(Qt::white); |
| QTest::newRow("black") << QBrush(Qt::black); |
| } |
| |
| void tst_QChart::plotAreaBackgroundBrush() |
| { |
| QFETCH(QBrush, plotAreaBackgroundBrush); |
| m_chart->setPlotAreaBackgroundBrush(plotAreaBackgroundBrush); |
| QCOMPARE(m_chart->plotAreaBackgroundBrush(), plotAreaBackgroundBrush); |
| } |
| |
| void tst_QChart::plotAreaBackgroundPen_data() |
| { |
| QTest::addColumn<QPen>("plotAreaBackgroundPen"); |
| QTest::newRow("null") << QPen(); |
| QTest::newRow("blue") << QPen(Qt::blue); |
| QTest::newRow("white") << QPen(Qt::white); |
| QTest::newRow("black") << QPen(Qt::black); |
| } |
| |
| |
| void tst_QChart::plotAreaBackgroundPen() |
| { |
| QFETCH(QPen, plotAreaBackgroundPen); |
| m_chart->setPlotAreaBackgroundPen(plotAreaBackgroundPen); |
| QCOMPARE(m_chart->plotAreaBackgroundPen(), plotAreaBackgroundPen); |
| } |
| |
| void tst_QChart::isPlotAreaBackgroundVisible_data() |
| { |
| QTest::addColumn<bool>("isPlotAreaBackgroundVisible"); |
| QTest::newRow("true") << true; |
| QTest::newRow("false") << false; |
| } |
| |
| void tst_QChart::isPlotAreaBackgroundVisible() |
| { |
| QFETCH(bool, isPlotAreaBackgroundVisible); |
| m_chart->setPlotAreaBackgroundVisible(isPlotAreaBackgroundVisible); |
| QCOMPARE(m_chart->isPlotAreaBackgroundVisible(), isPlotAreaBackgroundVisible); |
| } |
| void tst_QChart::legend_data() |
| { |
| |
| } |
| |
| void tst_QChart::legend() |
| { |
| QLegend *legend = m_chart->legend(); |
| QVERIFY(legend); |
| QVERIFY(!m_chart->legend()->reverseMarkers()); |
| |
| // Colors related signals |
| QSignalSpy colorSpy(legend, SIGNAL(colorChanged(QColor))); |
| QSignalSpy borderColorSpy(legend, SIGNAL(borderColorChanged(QColor))); |
| QSignalSpy labelColorSpy(legend, SIGNAL(labelColorChanged(QColor))); |
| |
| // colorChanged |
| legend->setColor(QColor("aliceblue")); |
| QCOMPARE(colorSpy.count(), 1); |
| QBrush b = legend->brush(); |
| b.setColor(QColor("aqua")); |
| legend->setBrush(b); |
| QCOMPARE(colorSpy.count(), 2); |
| |
| // borderColorChanged |
| legend->setBorderColor(QColor("aliceblue")); |
| QCOMPARE(borderColorSpy.count(), 1); |
| QPen p = legend->pen(); |
| p.setColor(QColor("aqua")); |
| legend->setPen(p); |
| QCOMPARE(borderColorSpy.count(), 2); |
| |
| // labelColorChanged |
| legend->setLabelColor(QColor("lightsalmon")); |
| QCOMPARE(labelColorSpy.count(), 1); |
| b = legend->labelBrush(); |
| b.setColor(QColor("lightseagreen")); |
| legend->setLabelBrush(b); |
| QCOMPARE(labelColorSpy.count(), 2); |
| |
| // fontChanged |
| QSignalSpy fontSpy(legend, SIGNAL(fontChanged(QFont))); |
| QFont f = legend->font(); |
| f.setBold(!f.bold()); |
| legend->setFont(f); |
| QCOMPARE(fontSpy.count(), 1); |
| |
| // reverseMarkersChanged |
| QSignalSpy reverseMarkersSpy(legend, SIGNAL(reverseMarkersChanged(bool))); |
| QCOMPARE(reverseMarkersSpy.count(), 0); |
| legend->setReverseMarkers(); |
| QCOMPARE(reverseMarkersSpy.count(), 1); |
| QVERIFY(legend->reverseMarkers()); |
| } |
| |
| void tst_QChart::plotArea_data() |
| { |
| |
| } |
| |
| void tst_QChart::plotArea() |
| { |
| createTestData(); |
| QRectF rect = m_chart->geometry(); |
| QVERIFY(m_chart->plotArea().isValid()); |
| QVERIFY(m_chart->plotArea().height() < rect.height()); |
| QVERIFY(m_chart->plotArea().width() < rect.width()); |
| } |
| |
| void tst_QChart::removeAllSeries_data() |
| { |
| |
| } |
| |
| void tst_QChart::removeAllSeries() |
| { |
| QLineSeries* series0 = new QLineSeries(this); |
| QLineSeries* series1 = new QLineSeries(this); |
| QLineSeries* series2 = new QLineSeries(this); |
| QSignalSpy deleteSpy1(series0, SIGNAL(destroyed())); |
| QSignalSpy deleteSpy2(series1, SIGNAL(destroyed())); |
| QSignalSpy deleteSpy3(series2, SIGNAL(destroyed())); |
| |
| m_chart->addSeries(series0); |
| m_chart->addSeries(series1); |
| m_chart->addSeries(series2); |
| m_view->show(); |
| QVERIFY(QTest::qWaitForWindowExposed(m_view)); |
| m_chart->createDefaultAxes(); |
| QCOMPARE(m_chart->axes().count(), 2); |
| QVERIFY(!m_chart->axes(Qt::Vertical, series0).isEmpty()); |
| QVERIFY(!m_chart->axes(Qt::Vertical, series1).isEmpty()); |
| QVERIFY(!m_chart->axes(Qt::Vertical, series2).isEmpty()); |
| |
| m_chart->removeAllSeries(); |
| QCOMPARE(m_chart->axes().count(), 2); |
| QVERIFY(!m_chart->axes(Qt::Horizontal).isEmpty()); |
| QVERIFY(!m_chart->axes(Qt::Vertical).isEmpty()); |
| QCOMPARE(deleteSpy1.count(), 1); |
| QCOMPARE(deleteSpy2.count(), 1); |
| QCOMPARE(deleteSpy3.count(), 1); |
| } |
| |
| void tst_QChart::removeSeries_data() |
| { |
| axisX_data(); |
| } |
| |
| void tst_QChart::removeSeries() |
| { |
| QFETCH(QAbstractAxis *, axis); |
| QFETCH(QAbstractSeries *, series); |
| QSignalSpy deleteSpy(series, SIGNAL(destroyed())); |
| m_view->show(); |
| QVERIFY(QTest::qWaitForWindowExposed(m_view)); |
| if (!axis) |
| axis = m_chart->axes(Qt::Vertical).value(0); |
| QVERIFY(axis); |
| m_chart->addSeries(series); |
| m_chart->addAxis(axis, Qt::AlignLeft); |
| series->attachAxis(axis); |
| QCOMPARE(m_chart->axes(Qt::Vertical, series).value(0), axis); |
| m_chart->removeSeries(series); |
| QCOMPARE(m_chart->axes().count(), 1); |
| QVERIFY(!m_chart->axes(Qt::Vertical).isEmpty()); |
| QVERIFY(m_chart->axes(Qt::Vertical, series).isEmpty()); |
| QCOMPARE(deleteSpy.count(), 0); |
| delete series; |
| } |
| |
| void tst_QChart::scroll_right_data() |
| { |
| QTest::addColumn<QAbstractSeries *>("series"); |
| |
| QLineSeries* series0 = new QLineSeries(this); |
| *series0 << QPointF(0, 0) << QPointF(100, 100); |
| |
| QTest::newRow("lineSeries") << (QAbstractSeries*) series0; |
| |
| |
| } |
| |
| void tst_QChart::scroll_right() |
| { |
| QFETCH(QAbstractSeries *, series); |
| m_chart->addSeries(series); |
| m_chart->createDefaultAxes(); |
| m_view->show(); |
| QVERIFY(QTest::qWaitForWindowExposed(m_view)); |
| QAbstractAxis *axis = m_chart->axes(Qt::Horizontal).value(0); |
| QVERIFY(axis); |
| |
| switch(axis->type()) |
| { |
| case QAbstractAxis::AxisTypeValue:{ |
| QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis); |
| QVERIFY(vaxis!=0); |
| qreal min = vaxis->min(); |
| qreal max = vaxis->max(); |
| QVERIFY(max>min); |
| m_chart->scroll(50, 0); |
| QVERIFY(min<vaxis->min()); |
| QVERIFY(max<vaxis->max()); |
| break; |
| } |
| case QAbstractAxis::AxisTypeBarCategory:{ |
| QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis); |
| QVERIFY(caxis!=0); |
| qreal min = caxis->min().toDouble(); |
| qreal max = caxis->max().toDouble(); |
| m_chart->scroll(50, 0); |
| QVERIFY(min<caxis->min().toDouble()); |
| QVERIFY(max<caxis->max().toDouble()); |
| break; |
| } |
| default: |
| qFatal("Unsupported type"); |
| break; |
| } |
| } |
| |
| void tst_QChart::scroll_left_data() |
| { |
| scroll_right_data(); |
| } |
| |
| void tst_QChart::scroll_left() |
| { |
| QFETCH(QAbstractSeries *, series); |
| m_chart->addSeries(series); |
| m_chart->createDefaultAxes(); |
| m_view->show(); |
| QVERIFY(QTest::qWaitForWindowExposed(m_view)); |
| QAbstractAxis *axis = m_chart->axes(Qt::Horizontal).value(0); |
| QVERIFY(axis); |
| |
| switch(axis->type()) |
| { |
| case QAbstractAxis::AxisTypeValue:{ |
| QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis); |
| QVERIFY(vaxis!=0); |
| qreal min = vaxis->min(); |
| qreal max = vaxis->max(); |
| m_chart->scroll(-50, 0); |
| QVERIFY(min>vaxis->min()); |
| QVERIFY(max>vaxis->max()); |
| break; |
| } |
| case QAbstractAxis::AxisTypeBarCategory:{ |
| QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis); |
| QVERIFY(caxis!=0); |
| qreal min = caxis->min().toDouble(); |
| qreal max = caxis->max().toDouble(); |
| m_chart->scroll(-50, 0); |
| QVERIFY(min>caxis->min().toDouble()); |
| QVERIFY(max>caxis->max().toDouble()); |
| break; |
| } |
| default: |
| qFatal("Unsupported type"); |
| break; |
| } |
| } |
| |
| void tst_QChart::scroll_up_data() |
| { |
| scroll_right_data(); |
| } |
| |
| void tst_QChart::scroll_up() |
| { |
| QFETCH(QAbstractSeries *, series); |
| m_chart->addSeries(series); |
| m_chart->createDefaultAxes(); |
| m_view->show(); |
| QVERIFY(QTest::qWaitForWindowExposed(m_view)); |
| QAbstractAxis *axis = m_chart->axes(Qt::Vertical).value(0); |
| QVERIFY(axis); |
| |
| switch(axis->type()) |
| { |
| case QAbstractAxis::AxisTypeValue:{ |
| QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis); |
| QVERIFY(vaxis!=0); |
| qreal min = vaxis->min(); |
| qreal max = vaxis->max(); |
| m_chart->scroll(0, 50); |
| QVERIFY(min<vaxis->min()); |
| QVERIFY(max<vaxis->max()); |
| break; |
| } |
| case QAbstractAxis::AxisTypeBarCategory:{ |
| QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis); |
| QVERIFY(caxis!=0); |
| qreal min = caxis->min().toDouble(); |
| qreal max = caxis->max().toDouble(); |
| m_chart->scroll(0, 50); |
| QVERIFY(min<caxis->min().toDouble()); |
| QVERIFY(max<caxis->max().toDouble()); |
| break; |
| } |
| default: |
| qFatal("Unsupported type"); |
| break; |
| } |
| } |
| |
| void tst_QChart::scroll_down_data() |
| { |
| scroll_right_data(); |
| } |
| |
| void tst_QChart::scroll_down() |
| { |
| QFETCH(QAbstractSeries *, series); |
| m_chart->addSeries(series); |
| m_chart->createDefaultAxes(); |
| m_view->show(); |
| QVERIFY(QTest::qWaitForWindowExposed(m_view)); |
| QAbstractAxis *axis = m_chart->axes(Qt::Vertical).value(0); |
| QVERIFY(axis); |
| |
| switch(axis->type()) |
| { |
| case QAbstractAxis::AxisTypeValue:{ |
| QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis); |
| QVERIFY(vaxis!=0); |
| qreal min = vaxis->min(); |
| qreal max = vaxis->max(); |
| m_chart->scroll(0, -50); |
| QVERIFY(min>vaxis->min()); |
| QVERIFY(max>vaxis->max()); |
| break; |
| } |
| case QAbstractAxis::AxisTypeBarCategory:{ |
| QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis); |
| QVERIFY(caxis!=0); |
| qreal min = caxis->min().toDouble(); |
| qreal max = caxis->max().toDouble(); |
| m_chart->scroll(0, -50); |
| QVERIFY(min>caxis->min().toDouble()); |
| QVERIFY(max>caxis->max().toDouble()); |
| break; |
| } |
| default: |
| qFatal("Unsupported type"); |
| break; |
| } |
| } |
| |
| void tst_QChart::theme_data() |
| { |
| QTest::addColumn<QChart::ChartTheme>("theme"); |
| QTest::newRow("ChartThemeBlueCerulean") << QChart::ChartThemeBlueCerulean; |
| QTest::newRow("ChartThemeBlueIcy") << QChart::ChartThemeBlueIcy; |
| QTest::newRow("ChartThemeBlueNcs") << QChart::ChartThemeBlueNcs; |
| QTest::newRow("ChartThemeBrownSand") << QChart::ChartThemeBrownSand; |
| QTest::newRow("ChartThemeDark") << QChart::ChartThemeDark; |
| QTest::newRow("hartThemeHighContrast") << QChart::ChartThemeHighContrast; |
| QTest::newRow("ChartThemeLight") << QChart::ChartThemeLight; |
| QTest::newRow("ChartThemeQt") << QChart::ChartThemeQt; |
| } |
| |
| void tst_QChart::theme() |
| { |
| QFETCH(QChart::ChartTheme, theme); |
| createTestData(); |
| m_chart->setTheme(theme); |
| QVERIFY(m_chart->theme()==theme); |
| } |
| |
| void tst_QChart::title_data() |
| { |
| QTest::addColumn<QString>("title"); |
| QTest::newRow("null") << QString(); |
| QTest::newRow("foo") << QString("foo"); |
| } |
| |
| void tst_QChart::title() |
| { |
| QFETCH(QString, title); |
| m_chart->setTitle(title); |
| QCOMPARE(m_chart->title(), title); |
| } |
| |
| void tst_QChart::titleBrush_data() |
| { |
| QTest::addColumn<QBrush>("titleBrush"); |
| QTest::newRow("null") << QBrush(); |
| QTest::newRow("blue") << QBrush(Qt::blue); |
| QTest::newRow("white") << QBrush(Qt::white); |
| QTest::newRow("black") << QBrush(Qt::black); |
| } |
| |
| void tst_QChart::titleBrush() |
| { |
| QFETCH(QBrush, titleBrush); |
| m_chart->setTitleBrush(titleBrush); |
| QCOMPARE(m_chart->titleBrush().color(), titleBrush.color()); |
| } |
| |
| void tst_QChart::titleFont_data() |
| { |
| QTest::addColumn<QFont>("titleFont"); |
| QTest::newRow("null") << QFont(); |
| QTest::newRow("courier") << QFont("Courier", 8, QFont::Bold, true); |
| } |
| |
| void tst_QChart::titleFont() |
| { |
| QFETCH(QFont, titleFont); |
| m_chart->setTitleFont(titleFont); |
| QCOMPARE(m_chart->titleFont(), titleFont); |
| } |
| |
| void tst_QChart::zoomIn_data() |
| { |
| QTest::addColumn<QRectF>("rect"); |
| QTest::newRow("null") << QRectF(); |
| QTest::newRow("100x100") << QRectF(10,10,100,100); |
| QTest::newRow("200x200") << QRectF(10,10,200,200); |
| } |
| |
| |
| void tst_QChart::zoomIn() |
| { |
| |
| QFETCH(QRectF, rect); |
| createTestData(); |
| m_chart->createDefaultAxes(); |
| QRectF marigns = m_chart->plotArea(); |
| rect.adjust(marigns.left(),marigns.top(),-marigns.right(),-marigns.bottom()); |
| auto axisX = qobject_cast<QValueAxis *>(m_chart->axes(Qt::Horizontal).value(0)); |
| QVERIFY(axisX); |
| auto axisY = qobject_cast<QValueAxis *>(m_chart->axes(Qt::Vertical).value(0)); |
| QVERIFY(axisY); |
| qreal minX = axisX->min(); |
| qreal minY = axisY->min(); |
| qreal maxX = axisX->max(); |
| qreal maxY = axisY->max(); |
| m_chart->zoomIn(rect); |
| if(rect.isValid()){ |
| QVERIFY(minX<axisX->min()); |
| QVERIFY(maxX>axisX->max()); |
| QVERIFY(minY<axisY->min()); |
| QVERIFY(maxY>axisY->max()); |
| } |
| |
| } |
| |
| void tst_QChart::zoomOut_data() |
| { |
| |
| } |
| |
| void tst_QChart::zoomOut() |
| { |
| createTestData(); |
| m_chart->createDefaultAxes(); |
| |
| auto axisX = qobject_cast<QValueAxis *>(m_chart->axes(Qt::Horizontal).value(0)); |
| QVERIFY(axisX); |
| auto axisY = qobject_cast<QValueAxis *>(m_chart->axes(Qt::Vertical).value(0)); |
| QVERIFY(axisY); |
| |
| qreal minX = axisX->min(); |
| qreal minY = axisY->min(); |
| qreal maxX = axisX->max(); |
| qreal maxY = axisY->max(); |
| |
| m_chart->zoomIn(); |
| |
| QVERIFY(minX < axisX->min()); |
| QVERIFY(maxX > axisX->max()); |
| QVERIFY(minY < axisY->min()); |
| QVERIFY(maxY > axisY->max()); |
| |
| m_chart->zoomOut(); |
| |
| // min x may be a zero value |
| if (qFuzzyIsNull(minX)) |
| QVERIFY(qFuzzyIsNull(axisX->min())); |
| else |
| QCOMPARE(minX, axisX->min()); |
| |
| // min y may be a zero value |
| if (qFuzzyIsNull(minY)) |
| QVERIFY(qFuzzyIsNull(axisY->min())); |
| else |
| QCOMPARE(minY, axisY->min()); |
| |
| QCOMPARE(maxX, axisX->max()); |
| QCOMPARE(maxY, axisY->max()); |
| |
| } |
| |
| void tst_QChart::zoomReset() |
| { |
| createTestData(); |
| m_chart->createDefaultAxes(); |
| auto axisX = qobject_cast<QValueAxis *>(m_chart->axes(Qt::Horizontal).value(0)); |
| QVERIFY(axisX); |
| auto axisY = qobject_cast<QValueAxis *>(m_chart->axes(Qt::Vertical).value(0)); |
| QVERIFY(axisY); |
| |
| qreal minX = axisX->min(); |
| qreal minY = axisY->min(); |
| qreal maxX = axisX->max(); |
| qreal maxY = axisY->max(); |
| |
| QVERIFY(!m_chart->isZoomed()); |
| |
| m_chart->zoomIn(); |
| |
| QVERIFY(m_chart->isZoomed()); |
| QVERIFY(minX < axisX->min()); |
| QVERIFY(maxX > axisX->max()); |
| QVERIFY(minY < axisY->min()); |
| QVERIFY(maxY > axisY->max()); |
| |
| m_chart->zoomReset(); |
| |
| // Reset after zoomIn should restore originals |
| QVERIFY(!m_chart->isZoomed()); |
| QVERIFY(minX == axisX->min()); |
| QVERIFY(maxX == axisX->max()); |
| QVERIFY(minY == axisY->min()); |
| QVERIFY(maxY == axisY->max()); |
| |
| m_chart->zoomOut(); |
| |
| QVERIFY(m_chart->isZoomed()); |
| QVERIFY(minX > axisX->min()); |
| QVERIFY(maxX < axisX->max()); |
| QVERIFY(minY > axisY->min()); |
| QVERIFY(maxY < axisY->max()); |
| |
| m_chart->zoomReset(); |
| |
| // Reset after zoomOut should restore originals |
| QVERIFY(!m_chart->isZoomed()); |
| QVERIFY(minX == axisX->min()); |
| QVERIFY(maxX == axisX->max()); |
| QVERIFY(minY == axisY->min()); |
| QVERIFY(maxY == axisY->max()); |
| |
| axisX->setRange(234, 345); |
| axisY->setRange(345, 456); |
| |
| minX = axisX->min(); |
| minY = axisY->min(); |
| maxX = axisX->max(); |
| maxY = axisY->max(); |
| |
| QVERIFY(!m_chart->isZoomed()); |
| |
| m_chart->zoomReset(); |
| |
| // Reset without zoom should not change anything |
| QVERIFY(!m_chart->isZoomed()); |
| QVERIFY(minX == axisX->min()); |
| QVERIFY(maxX == axisX->max()); |
| QVERIFY(minY == axisY->min()); |
| QVERIFY(maxY == axisY->max()); |
| |
| } |
| |
| void tst_QChart::createDefaultAxesForLineSeries_data() |
| { |
| QTest::addColumn<qreal>("series1minX"); |
| QTest::addColumn<qreal>("series1midX"); |
| QTest::addColumn<qreal>("series1maxX"); |
| QTest::addColumn<qreal>("series2minX"); |
| QTest::addColumn<qreal>("series2midX"); |
| QTest::addColumn<qreal>("series2maxX"); |
| QTest::addColumn<qreal>("overallminX"); |
| QTest::addColumn<qreal>("overallmaxX"); |
| QTest::addColumn<qreal>("series1minY"); |
| QTest::addColumn<qreal>("series1midY"); |
| QTest::addColumn<qreal>("series1maxY"); |
| QTest::addColumn<qreal>("series2minY"); |
| QTest::addColumn<qreal>("series2midY"); |
| QTest::addColumn<qreal>("series2maxY"); |
| QTest::addColumn<qreal>("overallminY"); |
| QTest::addColumn<qreal>("overallmaxY"); |
| QTest::newRow("series1hasMinAndMax") << (qreal)1.0 << (qreal)2.0 << (qreal)3.0 << (qreal)1.1 << (qreal)1.7 << (qreal)2.9 << (qreal)1.0 << (qreal)3.0 |
| << (qreal)1.0 << (qreal)2.0 << (qreal)3.0 << (qreal)1.1 << (qreal)1.7 << (qreal)2.9 << (qreal)1.0 << (qreal)3.0; |
| QTest::newRow("series2hasMinAndMax") << (qreal)1.1 << (qreal)2.0 << (qreal)2.9 << (qreal)1.0 << (qreal)1.7 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0 |
| << (qreal)1.1 << (qreal)2.0 << (qreal)2.9 << (qreal)1.0 << (qreal)1.7 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0; |
| QTest::newRow("series1hasMinAndMaxX_series2hasMinAndMaxY") << (qreal)1.0 << (qreal)2.0 << (qreal)3.0 << (qreal)1.1 << (qreal)1.7 << (qreal)2.9 << (qreal)1.0 << (qreal)3.0 |
| << (qreal)1.1 << (qreal)2.0 << (qreal)2.9 << (qreal)1.0 << (qreal)2.0 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0; |
| QTest::newRow("series1hasMin_series2hasMax") << (qreal)1.0 << (qreal)2.0 << (qreal)2.9 << (qreal)1.1 << (qreal)1.7 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0 |
| << (qreal)1.0 << (qreal)2.0 << (qreal)2.9 << (qreal)1.1 << (qreal)1.7 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0; |
| QTest::newRow("bothSeriesHaveSameMinAndMax") << (qreal)1.0 << (qreal)2.0 << (qreal)2.9 << (qreal)1.1 << (qreal)1.7 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0 |
| << (qreal)1.1 << (qreal)1.1 << (qreal)1.1 << (qreal)1.1 << (qreal)1.1 << (qreal)1.1 << (qreal)0.6 << (qreal)1.6; |
| } |
| |
| void tst_QChart::createDefaultAxesForLineSeries() |
| { |
| QFETCH(qreal, series1minX); |
| QFETCH(qreal, series1midX); |
| QFETCH(qreal, series1maxX); |
| QFETCH(qreal, series2minX); |
| QFETCH(qreal, series2midX); |
| QFETCH(qreal, series2maxX); |
| QFETCH(qreal, series1minY); |
| QFETCH(qreal, series1midY); |
| QFETCH(qreal, series1maxY); |
| QFETCH(qreal, series2minY); |
| QFETCH(qreal, series2midY); |
| QFETCH(qreal, series2maxY); |
| QFETCH(qreal, overallminX); |
| QFETCH(qreal, overallmaxX); |
| QFETCH(qreal, overallminY); |
| QFETCH(qreal, overallmaxY); |
| QLineSeries* series1 = new QLineSeries(this); |
| series1->append(series1minX, series1minY); |
| series1->append(series1midX, series1midY); |
| series1->append(series1maxX, series1maxY); |
| QLineSeries* series2 = new QLineSeries(this); |
| series2->append(series2minX, series2minY); |
| series2->append(series2midX, series2midY); |
| series2->append(series2maxX, series2maxY); |
| QChart *chart = newQChartOrQPolarChart(); |
| chart->addSeries(series1); |
| chart->addSeries(series2); |
| chart->createDefaultAxes(); |
| auto xAxis = qobject_cast<QValueAxis *>(chart->axes(Qt::Horizontal).value(0)); |
| QVERIFY(xAxis); |
| QCOMPARE(xAxis->min(), overallminX); |
| QCOMPARE(xAxis->max(), overallmaxX); |
| auto yAxis = qobject_cast<QValueAxis *>(chart->axes(Qt::Vertical).value(0)); |
| QVERIFY(yAxis); |
| QCOMPARE(yAxis->min(), overallminY); |
| QCOMPARE(yAxis->max(), overallmaxY); |
| QLineSeries *series3 = new QLineSeries(this); |
| // Numbers clearly out of existing range |
| series3->append(0, 0); |
| series3->append(100, 100); |
| // Adding a new series should not change the axes as they have not been told to update |
| chart->addSeries(series3); |
| QCOMPARE(xAxis->min(), overallminX); |
| QCOMPARE(xAxis->max(), overallmaxX); |
| QCOMPARE(yAxis->min(), overallminY); |
| QCOMPARE(yAxis->max(), overallmaxY); |
| delete chart; |
| } |
| |
| void tst_QChart::axisPolarOrientation() |
| { |
| QLineSeries* series1 = new QLineSeries(this); |
| series1->append(1, 2); |
| series1->append(2, 4); |
| series1->append(3, 8); |
| QPolarChart chart; |
| chart.addSeries(series1); |
| |
| QValueAxis *xAxis = new QValueAxis(); |
| QValueAxis *yAxis = new QValueAxis(); |
| chart.addAxis(xAxis, QPolarChart::PolarOrientationAngular); |
| chart.addAxis(yAxis, QPolarChart::PolarOrientationRadial); |
| |
| QList<QAbstractAxis *> xAxes = chart.axes(QPolarChart::PolarOrientationAngular); |
| QList<QAbstractAxis *> yAxes = chart.axes(QPolarChart::PolarOrientationRadial); |
| |
| QCOMPARE(xAxes.size(), 1); |
| QCOMPARE(yAxes.size(), 1); |
| QCOMPARE(xAxes[0], xAxis); |
| QCOMPARE(yAxes[0], yAxis); |
| |
| QCOMPARE(chart.axisPolarOrientation(xAxes[0]), QPolarChart::PolarOrientationAngular); |
| QCOMPARE(chart.axisPolarOrientation(yAxes[0]), QPolarChart::PolarOrientationRadial); |
| } |
| |
| void tst_QChart::backgroundRoundness() |
| { |
| createTestData(); |
| m_chart->createDefaultAxes(); |
| m_chart->setBackgroundRoundness(100.0); |
| QVERIFY(m_chart->backgroundRoundness() == 100.0); |
| } |
| |
| void tst_QChart::zoomInAndOut_data() |
| { |
| const qreal hourInMSecs = 60.0 * 60.0 * 1000.0; |
| |
| QTest::addColumn<QString>("axisXType"); |
| QTest::addColumn<QString>("axisYType"); |
| QTest::addColumn<qreal>("minX"); |
| QTest::addColumn<qreal>("maxX"); |
| QTest::addColumn<qreal>("minY"); |
| QTest::addColumn<qreal>("maxY"); |
| |
| QTest::newRow("value-value-normal") << "QValueAxis" << "QValueAxis" << 0.0 << 100.0 << 0.0 << 100.0; |
| QTest::newRow("value-value-small") << "QValueAxis" << "QValueAxis" << -1e-12 << 1e-13 << -1e-12 << 1e-13; |
| QTest::newRow("value-value-mixed") << "QValueAxis" << "QValueAxis" << 0.0 << 100.0 << -1e-12 << 1e-13; |
| |
| QTest::newRow("datetime-datetime-normal") << "QDateTimeAxis" << "QDateTimeAxis" |
| << 0.0 << hourInMSecs << 0.0 << hourInMSecs; |
| QTest::newRow("datetime-datetime-small") << "QDateTimeAxis" << "QDateTimeAxis" |
| << 0.0 << 60.0 << 0.0 << 60.0; |
| QTest::newRow("datetime-datetime-mixed") << "QDateTimeAxis" << "QDateTimeAxis" |
| << 0.0 << hourInMSecs << 0.0 << 60.0; |
| } |
| |
| #define CHECK_AXIS_RANGES_MATCH \ |
| if (valueAxisX) { \ |
| QVERIFY(valueAxisX->min() == minX); \ |
| QVERIFY(valueAxisX->max() == maxX); \ |
| } else if (dateTimeAxisX) { \ |
| QVERIFY(dateTimeAxisX->min().toMSecsSinceEpoch() == minX); \ |
| QVERIFY(dateTimeAxisX->max().toMSecsSinceEpoch() == maxX); \ |
| } \ |
| if (valueAxisY) { \ |
| QVERIFY(valueAxisY->min() == minY); \ |
| QVERIFY(valueAxisY->max() == maxY); \ |
| } else if (dateTimeAxisY) { \ |
| QVERIFY(dateTimeAxisY->min().toMSecsSinceEpoch() == minY); \ |
| QVERIFY(dateTimeAxisY->max().toMSecsSinceEpoch() == maxY); \ |
| } |
| |
| void tst_QChart::zoomInAndOut() |
| { |
| QFETCH(QString, axisXType); |
| QFETCH(QString, axisYType); |
| QFETCH(qreal, minX); |
| QFETCH(qreal, maxX); |
| QFETCH(qreal, minY); |
| QFETCH(qreal, maxY); |
| |
| createTestData(); |
| QAbstractAxis *axisX = 0; |
| QAbstractAxis *axisY = 0; |
| QValueAxis *valueAxisX = 0; |
| QValueAxis *valueAxisY = 0; |
| QDateTimeAxis *dateTimeAxisX = 0; |
| QDateTimeAxis *dateTimeAxisY = 0; |
| |
| if (axisXType == "QValueAxis") { |
| axisX = valueAxisX = new QValueAxis(m_chart); |
| valueAxisX->setRange(minX, maxX); |
| } else if (axisXType == "QDateTimeAxis") { |
| axisX = dateTimeAxisX = new QDateTimeAxis(m_chart); |
| dateTimeAxisX->setRange(QDateTime::fromMSecsSinceEpoch(minX), QDateTime::fromMSecsSinceEpoch(maxX)); |
| } |
| if (axisXType == "QValueAxis") { |
| axisY = valueAxisY = new QValueAxis(m_chart); |
| valueAxisY->setRange(minY, maxY); |
| } else if (axisXType == "QDateTimeAxis") { |
| axisY = dateTimeAxisY = new QDateTimeAxis(m_chart); |
| dateTimeAxisY->setRange(QDateTime::fromMSecsSinceEpoch(minY), QDateTime::fromMSecsSinceEpoch(maxY)); |
| } |
| |
| const auto series = m_chart->series().constFirst(); |
| m_chart->addAxis(axisX, Qt::AlignBottom); |
| series->attachAxis(axisX); |
| m_chart->addAxis(axisY, Qt::AlignLeft); |
| series->attachAxis(axisY); |
| CHECK_AXIS_RANGES_MATCH |
| |
| m_chart->zoomIn(); |
| if (valueAxisX) { |
| QVERIFY(valueAxisX->min() != minX); |
| QVERIFY(valueAxisX->max() != maxX); |
| } else if (dateTimeAxisX) { |
| QVERIFY(dateTimeAxisX->min().toMSecsSinceEpoch() != minX); |
| QVERIFY(dateTimeAxisX->max().toMSecsSinceEpoch() != maxX); |
| } |
| if (valueAxisY) { |
| QVERIFY(valueAxisY->min() != minY); |
| QVERIFY(valueAxisY->max() != maxY); |
| } else if (dateTimeAxisY) { |
| QVERIFY(dateTimeAxisY->min().toMSecsSinceEpoch() != minY); |
| QVERIFY(dateTimeAxisY->max().toMSecsSinceEpoch() != maxY); |
| } |
| |
| m_chart->zoomReset(); |
| CHECK_AXIS_RANGES_MATCH |
| |
| m_chart->zoomIn(); |
| m_chart->zoomIn(); |
| m_chart->zoomReset(); |
| CHECK_AXIS_RANGES_MATCH |
| |
| m_chart->zoomOut(); |
| m_chart->zoomReset(); |
| CHECK_AXIS_RANGES_MATCH |
| |
| m_chart->zoomOut(); |
| m_chart->zoomOut(); |
| m_chart->zoomReset(); |
| CHECK_AXIS_RANGES_MATCH |
| } |
| |
| void tst_QChart::fixedPlotArea() |
| { |
| createTestData(); |
| const QRectF originalPlotArea = m_chart->plotArea(); |
| m_chart->setPlotArea(originalPlotArea); |
| QCOMPARE(m_chart->plotArea(), originalPlotArea); |
| m_view->resize(400, 400); |
| // Should still be the same size |
| QCOMPARE(m_chart->plotArea(), originalPlotArea); |
| m_chart->setPlotArea(QRectF()); |
| // Should still be the same size as we have not triggered an update |
| QCOMPARE(m_chart->plotArea(), originalPlotArea); |
| m_view->resize(401, 401); |
| QVERIFY(m_chart->plotArea() != originalPlotArea); |
| m_chart->setPlotArea(originalPlotArea); |
| QCOMPARE(m_chart->plotArea(), originalPlotArea); |
| } |
| |
| QTEST_MAIN(tst_QChart) |
| #include "tst_qchart.moc" |
| |