summaryrefslogtreecommitdiffstats
path: root/tests/auto/qgraphicslayoutitem
diff options
context:
space:
mode:
Diffstat (limited to 'tests/auto/qgraphicslayoutitem')
-rw-r--r--tests/auto/qgraphicslayoutitem/.gitignore1
-rw-r--r--tests/auto/qgraphicslayoutitem/qgraphicslayoutitem.pro4
-rw-r--r--tests/auto/qgraphicslayoutitem/tst_qgraphicslayoutitem.cpp368
3 files changed, 373 insertions, 0 deletions
diff --git a/tests/auto/qgraphicslayoutitem/.gitignore b/tests/auto/qgraphicslayoutitem/.gitignore
new file mode 100644
index 0000000..55a8d18
--- /dev/null
+++ b/tests/auto/qgraphicslayoutitem/.gitignore
@@ -0,0 +1 @@
+tst_qgraphicslayoutitem
diff --git a/tests/auto/qgraphicslayoutitem/qgraphicslayoutitem.pro b/tests/auto/qgraphicslayoutitem/qgraphicslayoutitem.pro
new file mode 100644
index 0000000..6c8bf0c
--- /dev/null
+++ b/tests/auto/qgraphicslayoutitem/qgraphicslayoutitem.pro
@@ -0,0 +1,4 @@
+load(qttest_p4)
+SOURCES += tst_qgraphicslayoutitem.cpp
+
+
diff --git a/tests/auto/qgraphicslayoutitem/tst_qgraphicslayoutitem.cpp b/tests/auto/qgraphicslayoutitem/tst_qgraphicslayoutitem.cpp
new file mode 100644
index 0000000..7ab61a1
--- /dev/null
+++ b/tests/auto/qgraphicslayoutitem/tst_qgraphicslayoutitem.cpp
@@ -0,0 +1,368 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, 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.0, 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.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $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 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::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"
+