diff options
Diffstat (limited to 'tests/auto/widgets/graphicsview/qgraphicslayoutitem/tst_qgraphicslayoutitem.cpp')
| -rw-r--r-- | tests/auto/widgets/graphicsview/qgraphicslayoutitem/tst_qgraphicslayoutitem.cpp | 376 |
1 files changed, 376 insertions, 0 deletions
diff --git a/tests/auto/widgets/graphicsview/qgraphicslayoutitem/tst_qgraphicslayoutitem.cpp b/tests/auto/widgets/graphicsview/qgraphicslayoutitem/tst_qgraphicslayoutitem.cpp new file mode 100644 index 0000000000..a8b6c0854e --- /dev/null +++ b/tests/auto/widgets/graphicsview/qgraphicslayoutitem/tst_qgraphicslayoutitem.cpp @@ -0,0 +1,376 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this +** file. Please review the following information to ensure the GNU Lesser +** General Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#include <QtTest/QtTest> +#include <qgraphicslayoutitem.h> +#include <float.h> +#include <limits.h> + +class tst_QGraphicsLayoutItem : public QObject { +Q_OBJECT + +public slots: + void initTestCase(); + void cleanupTestCase(); + void init(); + void cleanup(); + +private slots: + void qgraphicslayoutitem(); + + void contentsRect(); + void effectiveSizeHint_data(); + void effectiveSizeHint(); + void getContentsMargins(); + void isLayout_data(); + void isLayout(); + void maximumSize(); + void minimumSize(); + void parentLayoutItem_data(); + void parentLayoutItem(); + void preferredSize(); + void setMaximumSize_data(); + void setMaximumSize(); + void setMinimumSize_data(); + void setMinimumSize(); + void setPreferredSize_data(); + void setPreferredSize(); + void setSizePolicy_data(); + void setPreferredSize2(); + void setSizePolicy(); +}; + +// Subclass that exposes the protected functions. +class SubQGraphicsLayoutItem : public QGraphicsLayoutItem { +public: + SubQGraphicsLayoutItem(QGraphicsLayoutItem *par = 0, bool layout = false) + : QGraphicsLayoutItem(par, layout), updateGeometryCalled(0) + {} + + // QGraphicsLayoutItem::geometry is a pure virtual function + QRectF geometry() const + { return QRectF(); } + + // QGraphicsLayoutItem::setGeometry is a pure virtual function + void setGeometry(QRectF const& rect) + { Q_UNUSED(rect); } + + // QGraphicsLayoutItem::sizeHint is a pure virtual function + QSizeF sizeHint(Qt::SizeHint which, QSizeF const& constraint = QSizeF()) const + { Q_UNUSED(which); Q_UNUSED(constraint); return QSizeF(); } + + void updateGeometry() + { updateGeometryCalled++; QGraphicsLayoutItem::updateGeometry(); } + int updateGeometryCalled; + +}; + +// This will be called before the first test function is executed. +// It is only called once. +void tst_QGraphicsLayoutItem::initTestCase() +{ +} + +// This will be called after the last test function is executed. +// It is only called once. +void tst_QGraphicsLayoutItem::cleanupTestCase() +{ +} + +// This will be called before each test function is executed. +void tst_QGraphicsLayoutItem::init() +{ +} + +// This will be called after every test function. +void tst_QGraphicsLayoutItem::cleanup() +{ +} + +void tst_QGraphicsLayoutItem::qgraphicslayoutitem() +{ + SubQGraphicsLayoutItem layoutItem; + layoutItem.contentsRect(); + layoutItem.effectiveSizeHint(Qt::MinimumSize); + layoutItem.geometry(); + QCOMPARE(layoutItem.isLayout(), false); + layoutItem.maximumSize(); + layoutItem.minimumSize(); + QCOMPARE(layoutItem.parentLayoutItem(), (QGraphicsLayoutItem*)0); + layoutItem.preferredSize(); + layoutItem.sizePolicy(); + layoutItem.sizeHint(Qt::MinimumSize); +} + +// QRectF contentsRect() const public +void tst_QGraphicsLayoutItem::contentsRect() +{ + SubQGraphicsLayoutItem layoutItem; + QRectF f = layoutItem.contentsRect(); + QCOMPARE(f, QRectF(QPoint(), QSizeF(0, 0))); +} +Q_DECLARE_METATYPE(Qt::SizeHint) +void tst_QGraphicsLayoutItem::effectiveSizeHint_data() +{ + QTest::addColumn<Qt::SizeHint>("sizeHint"); + QTest::addColumn<QSizeF>("constraint"); + for (int i = 0; i < 15; ++i) { + QTestData &data = QTest::newRow(QString("%1").arg(i).toLatin1()); + switch(i % 5) { + case 0: data << Qt::MinimumSize; break; + case 1: data << Qt::PreferredSize; break; + case 2: data << Qt::MaximumSize; break; + case 3: data << Qt::MinimumDescent; break; + case 4: data << Qt::NSizeHints; break; + } + switch(i % 3) { + case 0: data << QSizeF(-1, -1); break; + case 1: data << QSizeF(0, 0); break; + case 2: data << QSizeF(10, 10); break; + } + } +} + +// QSizeF effectiveSizeHint(Qt::SizeHint which, QSizeF const& constraint = QSize()) const public +void tst_QGraphicsLayoutItem::effectiveSizeHint() +{ + QFETCH(Qt::SizeHint, sizeHint); + QFETCH(QSizeF, constraint); + SubQGraphicsLayoutItem layoutItem; + QSizeF r = layoutItem.effectiveSizeHint(sizeHint, constraint); + if (constraint.width() != -1) + QCOMPARE(r.width(), constraint.width()); + if (constraint.height() != -1) + QCOMPARE(r.height(), constraint.height()); +} + +// void getContentsMargins(qreal* left, qreal* top, qreal* right, qreal* bottom) const public +void tst_QGraphicsLayoutItem::getContentsMargins() +{ + SubQGraphicsLayoutItem layoutItem; + qreal left; + qreal top; + qreal right; + qreal bottom; + layoutItem.getContentsMargins(&left, &top, &right, &bottom); + QCOMPARE(left, (qreal)0); + QCOMPARE(top, (qreal)0); + QCOMPARE(right, (qreal)0); + QCOMPARE(bottom, (qreal)0); +} + +void tst_QGraphicsLayoutItem::isLayout_data() +{ + QTest::addColumn<bool>("isLayout"); + QTest::newRow("no") << false; + QTest::newRow("yes") << true; +} + +// bool isLayout() const public +void tst_QGraphicsLayoutItem::isLayout() +{ + QFETCH(bool, isLayout); + SubQGraphicsLayoutItem layoutItem(0, isLayout); + QCOMPARE(layoutItem.isLayout(), isLayout); +} + +// QSizeF maximumSize() const public +void tst_QGraphicsLayoutItem::maximumSize() +{ + SubQGraphicsLayoutItem layoutItem; + QCOMPARE(layoutItem.maximumSize(), QSizeF(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX)); + // layoutItem.effectiveSizeHint(Qt::MaximumSize); +} + +// QSizeF minimumSize() const public +void tst_QGraphicsLayoutItem::minimumSize() +{ + SubQGraphicsLayoutItem layoutItem; + QCOMPARE(layoutItem.minimumSize(), QSizeF(0, 0)); + // layoutItem.effectiveSizeHint(Qt::MinimumSize); +} + +void tst_QGraphicsLayoutItem::parentLayoutItem_data() +{ + QTest::addColumn<bool>("parent"); + QTest::newRow("no") << false; + QTest::newRow("yes") << true; +} + +// QGraphicsLayoutItem* parentLayoutItem() const public +void tst_QGraphicsLayoutItem::parentLayoutItem() +{ + QFETCH(bool, parent); + SubQGraphicsLayoutItem parentLayout; + SubQGraphicsLayoutItem layoutItem(parent ? &parentLayout : 0); + QCOMPARE(layoutItem.parentLayoutItem(), static_cast<QGraphicsLayoutItem*>( parent ? &parentLayout : 0)); +} + +// QSizeF preferredSize() const public +void tst_QGraphicsLayoutItem::preferredSize() +{ + SubQGraphicsLayoutItem layoutItem; + QCOMPARE(layoutItem.preferredSize(), QSizeF(0, 0)); + // layoutItem.effectiveSizeHint(Qt::PreferredSize)); +} + +void tst_QGraphicsLayoutItem::setMaximumSize_data() +{ + QTest::addColumn<QSizeF>("size"); + QTest::addColumn<QSizeF>("outputSize"); + QTest::newRow("-1") << QSizeF(-1, -1) << QSizeF(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX); + QTest::newRow("0") << QSizeF(0, 0) << QSizeF(0, 0); + QTest::newRow("10") << QSizeF(10, 10) << QSizeF(10, 10); +} + +// void setMaximumSize(QSizeF const& size) public +void tst_QGraphicsLayoutItem::setMaximumSize() +{ + QFETCH(QSizeF, size); + QFETCH(QSizeF, outputSize); + SubQGraphicsLayoutItem layoutItem; + QSizeF oldSize = layoutItem.maximumSize(); + layoutItem.setMaximumSize(size); + if (size.isValid()) + QCOMPARE(layoutItem.updateGeometryCalled, (oldSize == size) ? 0 : 1); + else + QVERIFY(!layoutItem.updateGeometryCalled); + layoutItem.setMinimumSize(1, 1); + + QVERIFY(layoutItem.maximumSize().width() <= outputSize.width()); + QVERIFY(layoutItem.maximumSize().height() <= outputSize.height()); + QVERIFY(layoutItem.minimumSize().width() <= outputSize.width()); + QVERIFY(layoutItem.minimumSize().height() <= outputSize.height()); + QVERIFY(layoutItem.preferredSize().width() <= outputSize.width()); + QVERIFY(layoutItem.preferredSize().height() <= outputSize.height()); +} + +void tst_QGraphicsLayoutItem::setMinimumSize_data() +{ + QTest::addColumn<QSizeF>("size"); + QTest::addColumn<QSizeF>("outputSize"); + QTest::newRow("-1") << QSizeF(-1, -1) << QSizeF(0, 0); + QTest::newRow("0") << QSizeF(0, 0) << QSizeF(0, 0); + QTest::newRow("10") << QSizeF(10, 10) << QSizeF(10, 10); +} + +// void setMinimumSize(QSizeF const& size) public +void tst_QGraphicsLayoutItem::setMinimumSize() +{ + QFETCH(QSizeF, size); + QFETCH(QSizeF, outputSize); + SubQGraphicsLayoutItem layoutItem; + QSizeF oldSize = layoutItem.minimumSize(); + + layoutItem.setMinimumSize(size); + if (size.isValid()) { + QEXPECT_FAIL("0", "updateGeometry() is called when it doesn't have to be.", Continue); + QCOMPARE(layoutItem.updateGeometryCalled, (oldSize == size) ? 0 : 1); + } else { + QVERIFY(!layoutItem.updateGeometryCalled); + } + layoutItem.setMaximumSize(5, 5); + QEXPECT_FAIL("10", "layoutItem.maximumSize().width() < size.width()", Abort); + QVERIFY(layoutItem.maximumSize().width() >= size.width()); + QVERIFY(layoutItem.maximumSize().height() >= size.height()); + QVERIFY(layoutItem.minimumSize().width() >= size.width()); + QVERIFY(layoutItem.minimumSize().height() >= size.height()); + QVERIFY(layoutItem.preferredSize().width() >= size.width()); + QVERIFY(layoutItem.preferredSize().height() >= size.height()); +} + +void tst_QGraphicsLayoutItem::setPreferredSize_data() +{ + QTest::addColumn<QSizeF>("size"); + QTest::newRow("-1") << QSizeF(-1, -1); + QTest::newRow("0") << QSizeF(0, 0); + QTest::newRow("10") << QSizeF(10, 10); +} + +// void setPreferredSize(QSizeF const& size) public +void tst_QGraphicsLayoutItem::setPreferredSize() +{ + QFETCH(QSizeF, size); + SubQGraphicsLayoutItem layoutItem; + QSizeF oldSize = layoutItem.preferredSize(); + layoutItem.setPreferredSize(size); + if (size.isValid()) + QCOMPARE(layoutItem.preferredSize(), size); + + if (size.isValid()) { + QEXPECT_FAIL("0", "updateGeometry() is called when it doesn't have to be.", Continue); + QCOMPARE(layoutItem.updateGeometryCalled, (oldSize == size) ? 0 : 1); + } else { + QVERIFY(!layoutItem.updateGeometryCalled); + } +} + +void tst_QGraphicsLayoutItem::setPreferredSize2() +{ + SubQGraphicsLayoutItem layoutItem; + layoutItem.setPreferredSize(QSizeF(30, -1)); + QCOMPARE(layoutItem.preferredWidth(), qreal(30)); +} + +void tst_QGraphicsLayoutItem::setSizePolicy_data() +{ + QTest::addColumn<QSizePolicy>("policy"); + QTest::newRow("default") << QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed, QSizePolicy::DefaultType); + QTest::newRow("rand") << QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred); +} + +// void setSizePolicy(QSizePolicy const& policy) public +void tst_QGraphicsLayoutItem::setSizePolicy() +{ + QFETCH(QSizePolicy, policy); + SubQGraphicsLayoutItem layoutItem; + QSizePolicy defaultPolicy(QSizePolicy::Preferred, QSizePolicy::Preferred, QSizePolicy::DefaultType); + QCOMPARE(layoutItem.sizePolicy(), defaultPolicy); + + layoutItem.setSizePolicy(policy); + QCOMPARE(layoutItem.sizePolicy(), policy); + QCOMPARE(layoutItem.updateGeometryCalled, (defaultPolicy == policy) ? 0 : 1); +} + +QTEST_MAIN(tst_QGraphicsLayoutItem) +#include "tst_qgraphicslayoutitem.moc" + |