Long live Qt 4.5!

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"
+