| /**************************************************************************** |
| ** |
| ** 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 <private/xydomain_p.h> |
| #include <private/qabstractaxis_p.h> |
| #include <tst_definitions.h> |
| |
| QT_CHARTS_USE_NAMESPACE |
| |
| Q_DECLARE_METATYPE(XYDomain*) |
| Q_DECLARE_METATYPE(QSizeF) |
| Q_DECLARE_METATYPE(QMargins) |
| |
| |
| class AxisMock: public QAbstractAxisPrivate |
| { |
| Q_OBJECT |
| public: |
| AxisMock(Qt::Alignment alignment):QAbstractAxisPrivate(0){ setAlignment(alignment);}; |
| void initializeGraphics(QGraphicsItem* item) |
| { |
| Q_UNUSED(item); |
| }; |
| |
| void initializeDomain(AbstractDomain* domain) |
| { |
| Q_UNUSED(domain); |
| }; |
| void setMin(const QVariant &min) |
| { |
| Q_UNUSED(min); |
| } |
| qreal min() { return m_min;} |
| void setMax(const QVariant &max) |
| { |
| Q_UNUSED(max); |
| } |
| qreal max() { return m_max; } |
| void setRange(const QVariant &min, const QVariant &max) |
| { |
| Q_UNUSED(min); |
| Q_UNUSED(max); |
| }; |
| |
| void setRange(qreal min, qreal max) |
| { |
| m_min=min; |
| m_max=max; |
| emit rangeChanged(min,max); |
| }; |
| |
| int count () const { return m_count; } |
| |
| void handleDomainUpdated(){}; |
| public: |
| int m_count; |
| qreal m_min; |
| qreal m_max; |
| }; |
| |
| class tst_Domain: public QObject |
| { |
| Q_OBJECT |
| |
| public Q_SLOTS: |
| void initTestCase(); |
| void cleanupTestCase(); |
| void init(); |
| void cleanup(); |
| |
| private Q_SLOTS: |
| void domain(); |
| void handleHorizontalAxisRangeChanged_data(); |
| void handleHorizontalAxisRangeChanged(); |
| void handleVerticalAxisRangeChanged_data(); |
| void handleVerticalAxisRangeChanged(); |
| void isEmpty_data(); |
| void isEmpty(); |
| void maxX_data(); |
| void maxX(); |
| void maxY_data(); |
| void maxY(); |
| void minX_data(); |
| void minX(); |
| void minY_data(); |
| void minY(); |
| void operatorEquals_data(); |
| void operatorEquals(); |
| void setRange_data(); |
| void setRange(); |
| void setRangeX_data(); |
| void setRangeX(); |
| void setRangeY_data(); |
| void setRangeY(); |
| void spanX_data(); |
| void spanX(); |
| void spanY_data(); |
| void spanY(); |
| void zoomIn_data(); |
| void zoomIn(); |
| void zoomOut_data(); |
| void zoomOut(); |
| void move_data(); |
| void move(); |
| }; |
| |
| void tst_Domain::initTestCase() |
| { |
| } |
| |
| void tst_Domain::cleanupTestCase() |
| { |
| QTest::qWait(1); // Allow final deleteLaters to run |
| } |
| |
| void tst_Domain::init() |
| { |
| } |
| |
| void tst_Domain::cleanup() |
| { |
| } |
| |
| void tst_Domain::domain() |
| { |
| XYDomain domain; |
| |
| QCOMPARE(domain.isEmpty(), true); |
| QCOMPARE(domain.maxX(), 0.0); |
| QCOMPARE(domain.maxY(), 0.0); |
| QCOMPARE(domain.minX(), 0.0); |
| QCOMPARE(domain.minY(), 0.0); |
| } |
| |
| void tst_Domain::handleHorizontalAxisRangeChanged_data() |
| { |
| QTest::addColumn<qreal>("min"); |
| QTest::addColumn<qreal>("max"); |
| QTest::newRow("-1 1") << -1.0 << 1.0; |
| QTest::newRow("0 1") << 0.0 << 1.0; |
| QTest::newRow("-1 0") << -1.0 << 0.0; |
| } |
| |
| void tst_Domain::handleHorizontalAxisRangeChanged() |
| { |
| QFETCH(qreal, min); |
| QFETCH(qreal, max); |
| |
| XYDomain domain; |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| AxisMock axis(Qt::AlignBottom); |
| QObject::connect(&axis,SIGNAL(rangeChanged(qreal,qreal)),&domain,SLOT(handleHorizontalAxisRangeChanged(qreal,qreal))); |
| axis.setRange(min,max); |
| |
| QVERIFY(qFuzzyCompare(domain.minX(), min)); |
| QVERIFY(qFuzzyCompare(domain.maxX(), max)); |
| |
| QList<QVariant> arg1 = spy1.first(); |
| QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min)); |
| QVERIFY(qFuzzyCompare(arg1.at(1).toReal(), max)); |
| |
| TRY_COMPARE(spy0.count(), 1); |
| TRY_COMPARE(spy1.count(), 1); |
| TRY_COMPARE(spy2.count(), 0); |
| |
| } |
| |
| void tst_Domain::handleVerticalAxisRangeChanged_data() |
| { |
| QTest::addColumn<qreal>("min"); |
| QTest::addColumn<qreal>("max"); |
| QTest::newRow("-1 1") << -1.0 << 1.0; |
| QTest::newRow("0 1") << 0.0 << 1.0; |
| QTest::newRow("-1 0") << -1.0 << 0.0; |
| } |
| |
| void tst_Domain::handleVerticalAxisRangeChanged() |
| { |
| QFETCH(qreal, min); |
| QFETCH(qreal, max); |
| |
| XYDomain domain; |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| AxisMock axis(Qt::AlignLeft); |
| QObject::connect(&axis, SIGNAL(rangeChanged(qreal,qreal)), &domain, SLOT(handleVerticalAxisRangeChanged(qreal,qreal))); |
| axis.setRange(min,max); |
| |
| QVERIFY(qFuzzyCompare(domain.minY(), min)); |
| QVERIFY(qFuzzyCompare(domain.maxY(), max)); |
| |
| QList<QVariant> arg1 = spy2.first(); |
| QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min)); |
| QVERIFY(qFuzzyCompare(arg1.at(1).toReal(), max)); |
| |
| TRY_COMPARE(spy0.count(), 1); |
| TRY_COMPARE(spy1.count(), 0); |
| TRY_COMPARE(spy2.count(), 1); |
| } |
| |
| void tst_Domain::isEmpty_data() |
| { |
| QTest::addColumn<qreal>("minX"); |
| QTest::addColumn<qreal>("maxX"); |
| QTest::addColumn<qreal>("minY"); |
| QTest::addColumn<qreal>("maxY"); |
| QTest::addColumn<QSizeF>("size"); |
| QTest::addColumn<bool>("isEmpty"); |
| QTest::newRow("0 0 0 0") << 0.0 << 0.0 << 0.0 << 0.0 << QSizeF(1,1) << true; |
| QTest::newRow("0 1 0 0") << 0.0 << 1.0 << 0.0 << 0.0 << QSizeF(1,1) << true; |
| QTest::newRow("0 0 0 1") << 0.0 << 1.0 << 0.0 << 0.0 << QSizeF(1,1) << true; |
| QTest::newRow("0 1 0 1") << 0.0 << 1.0 << 0.0 << 1.0 << QSizeF(1,1) << false; |
| QTest::newRow("0 1 0 1") << 0.0 << 1.0 << 0.0 << 1.0 << QSizeF(-11,1) << true; |
| } |
| |
| void tst_Domain::isEmpty() |
| { |
| QFETCH(qreal, minX); |
| QFETCH(qreal, maxX); |
| QFETCH(qreal, minY); |
| QFETCH(qreal, maxY); |
| QFETCH(QSizeF, size); |
| QFETCH(bool, isEmpty); |
| |
| XYDomain domain; |
| domain.setRange(minX, maxX, minY, maxY); |
| domain.setSize(size); |
| QCOMPARE(domain.isEmpty(), isEmpty); |
| } |
| |
| void tst_Domain::maxX_data() |
| { |
| QTest::addColumn<qreal>("maxX1"); |
| QTest::addColumn<qreal>("maxX2"); |
| QTest::addColumn<int>("count"); |
| QTest::newRow("1") << 0.0 << 1.0 << 1; |
| QTest::newRow("1.0") << 1.0 << 1.0 << 1; |
| QTest::newRow("2.0") << 1.0 << 0.0 << 2; |
| } |
| |
| void tst_Domain::maxX() |
| { |
| QFETCH(qreal, maxX1); |
| QFETCH(qreal, maxX2); |
| QFETCH(int, count); |
| |
| XYDomain domain; |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| domain.setMaxX(maxX1); |
| QCOMPARE(domain.maxX(), maxX1); |
| domain.setMaxX(maxX2); |
| QCOMPARE(domain.maxX(), maxX2); |
| |
| TRY_COMPARE(spy0.count(), count); |
| TRY_COMPARE(spy1.count(), count); |
| TRY_COMPARE(spy2.count(), 0); |
| |
| } |
| |
| void tst_Domain::maxY_data() |
| { |
| QTest::addColumn<qreal>("maxY1"); |
| QTest::addColumn<qreal>("maxY2"); |
| QTest::addColumn<int>("count"); |
| QTest::newRow("1") << 0.0 << 1.0 << 1; |
| QTest::newRow("1.0") << 1.0 << 1.0 << 1; |
| QTest::newRow("2.0") << 1.0 << 0.0 << 2; |
| } |
| |
| void tst_Domain::maxY() |
| { |
| QFETCH(qreal, maxY1); |
| QFETCH(qreal, maxY2); |
| QFETCH(int, count); |
| |
| XYDomain domain; |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| domain.setMaxY(maxY1); |
| QCOMPARE(domain.maxY(), maxY1); |
| domain.setMaxY(maxY2); |
| QCOMPARE(domain.maxY(), maxY2); |
| |
| TRY_COMPARE(spy0.count(), count); |
| TRY_COMPARE(spy1.count(), 0); |
| TRY_COMPARE(spy2.count(), count); |
| } |
| |
| void tst_Domain::minX_data() |
| { |
| QTest::addColumn<qreal>("minX1"); |
| QTest::addColumn<qreal>("minX2"); |
| QTest::addColumn<int>("count"); |
| QTest::newRow("1") << 0.0 << 1.0 << 1; |
| QTest::newRow("1.0") << 1.0 << 1.0 << 1; |
| QTest::newRow("2.0") << 1.0 << 0.0 << 2; |
| } |
| |
| void tst_Domain::minX() |
| { |
| QFETCH(qreal, minX1); |
| QFETCH(qreal, minX2); |
| QFETCH(int, count); |
| |
| XYDomain domain; |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| domain.setMinX(minX1); |
| QCOMPARE(domain.minX(), minX1); |
| domain.setMinX(minX2); |
| QCOMPARE(domain.minX(), minX2); |
| |
| TRY_COMPARE(spy0.count(), count); |
| TRY_COMPARE(spy1.count(), count); |
| TRY_COMPARE(spy2.count(), 0); |
| } |
| |
| void tst_Domain::minY_data() |
| { |
| QTest::addColumn<qreal>("minY1"); |
| QTest::addColumn<qreal>("minY2"); |
| QTest::addColumn<int>("count"); |
| QTest::newRow("1") << 0.0 << 1.0 << 1; |
| QTest::newRow("1.0") << 1.0 << 1.0 << 1; |
| QTest::newRow("2.0") << 1.0 << 0.0 << 2; |
| } |
| |
| void tst_Domain::minY() |
| { |
| QFETCH(qreal, minY1); |
| QFETCH(qreal, minY2); |
| QFETCH(int, count); |
| |
| XYDomain domain; |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| domain.setMinY(minY1); |
| QCOMPARE(domain.minY(), minY1); |
| domain.setMinY(minY2); |
| QCOMPARE(domain.minY(), minY2); |
| |
| TRY_COMPARE(spy0.count(), count); |
| TRY_COMPARE(spy1.count(), 0); |
| TRY_COMPARE(spy2.count(), count); |
| } |
| |
| void tst_Domain::operatorEquals_data() |
| { |
| |
| QTest::addColumn<XYDomain*>("domain1"); |
| QTest::addColumn<XYDomain*>("domain2"); |
| QTest::addColumn<bool>("equals"); |
| QTest::addColumn<bool>("notEquals"); |
| XYDomain* a; |
| XYDomain* b; |
| a = new XYDomain(); |
| a->setRange(0, 100, 0, 100); |
| b = new XYDomain(); |
| b->setRange(0, 100, 0, 100); |
| QTest::newRow("equals") << a << b << true << false; |
| a = new XYDomain(); |
| a->setRange(0, 100, 0, 100); |
| b = new XYDomain(); |
| b->setRange(0, 100, 0, 1); |
| QTest::newRow("equals") << a << b << false << true; |
| a = new XYDomain(); |
| a->setRange(0, 100, 0, 100); |
| b = new XYDomain(); |
| b->setRange(0, 1, 0, 100); |
| QTest::newRow("equals") << a << b << false << true; |
| |
| } |
| |
| void tst_Domain::operatorEquals() |
| { |
| QFETCH(XYDomain*, domain1); |
| QFETCH(XYDomain*, domain2); |
| QFETCH(bool, equals); |
| QFETCH(bool, notEquals); |
| |
| XYDomain domain; |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| QCOMPARE(*domain1==*domain2, equals); |
| QCOMPARE(*domain1!=*domain2, notEquals); |
| |
| TRY_COMPARE(spy0.count(), 0); |
| TRY_COMPARE(spy1.count(), 0); |
| TRY_COMPARE(spy2.count(), 0); |
| |
| delete domain1; |
| delete domain2; |
| } |
| |
| void tst_Domain::setRange_data() |
| { |
| QTest::addColumn<qreal>("minX"); |
| QTest::addColumn<qreal>("maxX"); |
| QTest::addColumn<qreal>("minY"); |
| QTest::addColumn<qreal>("maxY"); |
| QTest::newRow("1,2,1,2") << 1.0 << 2.0 << 1.0 << 2.0; |
| QTest::newRow("1,3,1,3") << 1.0 << 3.0 << 1.0 << 3.0; |
| QTest::newRow("-1,5,-2,-1") << -1.0 << 5.0 << -2.0 << -1.0; |
| } |
| |
| void tst_Domain::setRange() |
| { |
| QFETCH(qreal, minX); |
| QFETCH(qreal, maxX); |
| QFETCH(qreal, minY); |
| QFETCH(qreal, maxY); |
| |
| XYDomain domain; |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| domain.setRange(minX, maxX, minY, maxY); |
| |
| QCOMPARE(domain.minX(), minX); |
| QCOMPARE(domain.maxX(), maxX); |
| QCOMPARE(domain.minY(), minY); |
| QCOMPARE(domain.maxY(), maxY); |
| |
| TRY_COMPARE(spy0.count(), 1); |
| TRY_COMPARE(spy1.count(), 1); |
| TRY_COMPARE(spy2.count(), 1); |
| |
| } |
| |
| void tst_Domain::setRangeX_data() |
| { |
| QTest::addColumn<qreal>("min"); |
| QTest::addColumn<qreal>("max"); |
| QTest::newRow("-1 1") << -1.0 << 1.0; |
| QTest::newRow("0 1") << 0.0 << 1.0; |
| QTest::newRow("-1 0") << -1.0 << 0.0; |
| } |
| |
| void tst_Domain::setRangeX() |
| { |
| QFETCH(qreal, min); |
| QFETCH(qreal, max); |
| |
| XYDomain domain; |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| domain.setRangeX(min, max); |
| |
| QVERIFY(qFuzzyCompare(domain.minX(), min)); |
| QVERIFY(qFuzzyCompare(domain.maxX(), max)); |
| |
| QList<QVariant> arg1 = spy1.first(); |
| QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min)); |
| QVERIFY(qFuzzyCompare(arg1.at(1).toReal(), max)); |
| |
| TRY_COMPARE(spy0.count(), 1); |
| TRY_COMPARE(spy1.count(), 1); |
| TRY_COMPARE(spy2.count(), 0); |
| } |
| |
| void tst_Domain::setRangeY_data() |
| { |
| QTest::addColumn<qreal>("min"); |
| QTest::addColumn<qreal>("max"); |
| QTest::newRow("-1 1") << -1.0 << 1.0; |
| QTest::newRow("0 1") << 0.0 << 1.0; |
| QTest::newRow("-1 0") << -1.0 << 0.0; |
| } |
| |
| void tst_Domain::setRangeY() |
| { |
| QFETCH(qreal, min); |
| QFETCH(qreal, max); |
| |
| XYDomain domain; |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| domain.setRangeY(min, max); |
| |
| QVERIFY(qFuzzyCompare(domain.minY(), min)); |
| QVERIFY(qFuzzyCompare(domain.maxY(), max)); |
| |
| QList<QVariant> arg1 = spy2.first(); |
| QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min)); |
| QVERIFY(qFuzzyCompare(arg1.at(1).toReal(), max)); |
| |
| TRY_COMPARE(spy0.count(), 1); |
| TRY_COMPARE(spy1.count(), 0); |
| TRY_COMPARE(spy2.count(), 1); |
| } |
| |
| void tst_Domain::spanX_data() |
| { |
| QTest::addColumn<qreal>("minX"); |
| QTest::addColumn<qreal>("maxX"); |
| QTest::addColumn<qreal>("spanX"); |
| QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0; |
| QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0; |
| } |
| |
| void tst_Domain::spanX() |
| { |
| QFETCH(qreal, minX); |
| QFETCH(qreal, maxX); |
| QFETCH(qreal, spanX); |
| |
| XYDomain domain; |
| |
| domain.setRangeX(minX, maxX); |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| QCOMPARE(domain.spanX(), spanX); |
| |
| TRY_COMPARE(spy0.count(), 0); |
| TRY_COMPARE(spy1.count(), 0); |
| TRY_COMPARE(spy2.count(), 0); |
| } |
| |
| void tst_Domain::spanY_data() |
| { |
| QTest::addColumn<qreal>("minY"); |
| QTest::addColumn<qreal>("maxY"); |
| QTest::addColumn<qreal>("spanY"); |
| QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0; |
| QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0; |
| } |
| |
| void tst_Domain::spanY() |
| { |
| QFETCH(qreal, minY); |
| QFETCH(qreal, maxY); |
| QFETCH(qreal, spanY); |
| |
| XYDomain domain; |
| |
| domain.setRangeY(minY, maxY); |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| QCOMPARE(domain.spanY(), spanY); |
| |
| TRY_COMPARE(spy0.count(), 0); |
| TRY_COMPARE(spy1.count(), 0); |
| TRY_COMPARE(spy2.count(), 0); |
| } |
| |
| void tst_Domain::zoomIn_data() |
| { |
| QTest::addColumn<QMargins>("range"); |
| QTest::addColumn<QSizeF>("size"); |
| QTest::addColumn<QMargins>("zoom"); |
| QTest::addColumn<QMargins>("result"); |
| |
| QTest::newRow("first") << QMargins(0,0,1000,1000) << QSizeF(1000, 1000) << |
| QMargins(100, 100, 900, 900) << QMargins(100,100,900,900); |
| QTest::newRow("second") << QMargins(0,0,2000,2000) << QSizeF(1000, 1000) << |
| QMargins(100, 100, 900, 900) << QMargins(200,200,1800,1800); |
| } |
| |
| void tst_Domain::zoomIn() |
| { |
| QFETCH(QMargins, range); |
| QFETCH(QSizeF, size); |
| QFETCH(QMargins, zoom); |
| QFETCH(QMargins, result); |
| |
| XYDomain domain; |
| domain.setRange(range.left(), range.right(), range.top(),range.bottom()); |
| domain.setSize(size); |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| domain.zoomIn(QRectF(zoom.left(),zoom.top(),zoom.right()-zoom.left(),zoom.bottom()-zoom.top())); |
| |
| QCOMPARE(domain.minX(),qreal(result.left())); |
| QCOMPARE(domain.maxX(),qreal(result.right())); |
| QCOMPARE(domain.minY(),qreal(result.top())); |
| QCOMPARE(domain.maxY(),qreal(result.bottom())); |
| |
| TRY_COMPARE(spy0.count(), 1); |
| TRY_COMPARE(spy1.count(), 1); |
| TRY_COMPARE(spy2.count(), 1); |
| } |
| |
| void tst_Domain::zoomOut_data() |
| { |
| QTest::addColumn<QMargins>("range"); |
| QTest::addColumn<QSizeF>("size"); |
| QTest::addColumn<QMargins>("zoom"); |
| QTest::addColumn<QMargins>("result"); |
| |
| QTest::newRow("first") << QMargins(100,100,900,900) << QSizeF(1000, 1000) << |
| QMargins(100, 100, 900, 900) << QMargins(0,0,1000,1000); |
| QTest::newRow("second") << QMargins(200,200,1800,1800) << QSizeF(1000, 1000) << |
| QMargins(100, 100, 900, 900) << QMargins(0,0,2000,2000); |
| } |
| |
| void tst_Domain::zoomOut() |
| { |
| QFETCH(QMargins, range); |
| QFETCH(QSizeF, size); |
| QFETCH(QMargins, zoom); |
| QFETCH(QMargins, result); |
| |
| XYDomain domain; |
| domain.setRange(range.left(), range.right(), range.top(),range.bottom()); |
| domain.setSize(size); |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| domain.zoomOut(QRectF(zoom.left(),zoom.top(),zoom.right()-zoom.left(),zoom.bottom()-zoom.top())); |
| |
| QCOMPARE(domain.minX(),qreal(result.left())); |
| QCOMPARE(domain.maxX(),qreal(result.right())); |
| QCOMPARE(domain.minY(),qreal(result.top())); |
| QCOMPARE(domain.maxY(),qreal(result.bottom())); |
| |
| TRY_COMPARE(spy0.count(), 1); |
| TRY_COMPARE(spy1.count(), 1); |
| TRY_COMPARE(spy2.count(), 1); |
| } |
| |
| void tst_Domain::move_data() |
| { |
| QTest::addColumn<QMargins>("range"); |
| QTest::addColumn<QSizeF>("size"); |
| QTest::addColumn<int>("dx"); |
| QTest::addColumn<int>("dy"); |
| QTest::addColumn<QMargins>("result"); |
| |
| QTest::newRow("first") << QMargins(0,0,1000,1000) << QSizeF(1000, 1000) << |
| 10 << 10 << QMargins(10,10,1010,1010); |
| QTest::newRow("second") << QMargins(0,0,1000,1000) << QSizeF(1000, 1000) << |
| -10 << -10 << QMargins(-10,-10,990,990); |
| } |
| |
| void tst_Domain::move() |
| { |
| QFETCH(QMargins, range); |
| QFETCH(QSizeF, size); |
| QFETCH(int, dx); |
| QFETCH(int, dy); |
| QFETCH(QMargins, result); |
| |
| XYDomain domain; |
| domain.setRange(range.left(), range.right(), range.top(),range.bottom()); |
| domain.setSize(size); |
| |
| QSignalSpy spy0(&domain, SIGNAL(updated())); |
| QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal))); |
| QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal))); |
| |
| domain.move(dx, dy); |
| |
| QCOMPARE(domain.minX(),qreal(result.left())); |
| QCOMPARE(domain.maxX(),qreal(result.right())); |
| QCOMPARE(domain.minY(),qreal(result.top())); |
| QCOMPARE(domain.maxY(),qreal(result.bottom())); |
| |
| TRY_COMPARE(spy0.count(), 1); |
| TRY_COMPARE(spy1.count(), (dx != 0 ? 1 : 0)); |
| TRY_COMPARE(spy2.count(), (dy != 0 ? 1 : 0)); |
| } |
| |
| QTEST_MAIN(tst_Domain) |
| #include "tst_domain.moc" |