|
|
/****************************************************************************
|
|
|
**
|
|
|
** 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"
|
|
|
|
