Moved tests into integrationtests/ and widgets/

Task-number: QTBUG-19013

Change-Id: Ibb776f5967c0645ce6d22ef7afdc40657c575461
Reviewed-by: Holger Ihrig <holger.ihrig@nokia.com>

81 files changed, 42984 insertions, 0 deletions

diff --git a/tests/auto/widgets/graphicsview/graphicsview.pro b/tests/auto/widgets/graphicsview/graphicsview.pro
new file mode 100644
index 0000000000..9955e45b64
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/graphicsview.pro
@@ -0,0 +1,32 @@
+TEMPLATE=subdirs
+SUBDIRS=\
+   qgraphicsanchorlayout \
+   qgraphicsanchorlayout1 \
+   qgraphicseffectsource \
+   qgraphicsgridlayout \
+   qgraphicsitem \
+   qgraphicsitemanimation \
+   qgraphicslayout \
+   qgraphicslayoutitem \
+   qgraphicslinearlayout \
+   qgraphicsobject \
+   qgraphicspixmapitem \
+   qgraphicspolygonitem \
+   qgraphicsproxywidget \
+   qgraphicsscene \
+   qgraphicssceneindex \
+   qgraphicstransform \
+   qgraphicsview \
+   qgraphicswidget \
+
+!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+           qgraphicsanchorlayout \
+           qgraphicsanchorlayout1 \
+           qgraphicsitem \
+           qgraphicsscene \
+           qgraphicssceneindex \
+
+# These tests require the cleanlooks style
+!contains(styles, cleanlooks):SUBDIRS -= \
+    qgraphicsproxywidget \
+    qgraphicswidget \
diff --git a/tests/auto/widgets/graphicsview/qgraphicsanchorlayout/qgraphicsanchorlayout.pro b/tests/auto/widgets/graphicsview/qgraphicsanchorlayout/qgraphicsanchorlayout.pro
new file mode 100644
index 0000000000..5aa2936e3e
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsanchorlayout/qgraphicsanchorlayout.pro
@@ -0,0 +1,5 @@
+load(qttest_p4)
+QT += widgets widgets-private
+QT += core-private gui-private
+SOURCES  += tst_qgraphicsanchorlayout.cpp
+CONFIG += parallel_test
diff --git a/tests/auto/widgets/graphicsview/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp b/tests/auto/widgets/graphicsview/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
new file mode 100644
index 0000000000..5dbe501ea8
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
@@ -0,0 +1,2091 @@
+/****************************************************************************
+**
+** 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 <QtWidgets/qgraphicsanchorlayout.h>
+#include <private/qgraphicsanchorlayout_p.h>
+#include <QtWidgets/qgraphicswidget.h>
+#include <QtWidgets/qgraphicsproxywidget.h>
+#include <QtWidgets/qgraphicsview.h>
+#include <QtWidgets/qwindowsstyle.h>
+
+
+class tst_QGraphicsAnchorLayout : public QObject {
+    Q_OBJECT
+
+public:
+    tst_QGraphicsAnchorLayout() : QObject() {
+        hasSimplification = qgetenv("QT_ANCHORLAYOUT_NO_SIMPLIFICATION").isEmpty();
+    }
+
+private:
+    bool hasSimplification;
+
+private slots:
+    void simple();
+    void simple_center();
+    void simple_semifloat();
+    void layoutDirection();
+    void diagonal();
+    void parallel();
+    void parallel2();
+    void snake();
+    void snakeOppositeDirections();
+    void fairDistribution();
+    void fairDistributionOppositeDirections();
+    void proportionalPreferred();
+    void example();
+    void setSpacing();
+    void styleDefaults();
+    void hardComplexS60();
+    void stability();
+    void delete_anchor();
+    void conflicts();
+    void sizePolicy();
+    void floatConflict();
+    void infiniteMaxSizes();
+    void simplifiableUnfeasible();
+    void simplificationVsOrder();
+    void parallelSimplificationOfCenter();
+    void simplificationVsRedundance();
+    void spacingPersistency();
+    void snakeParallelWithLayout();
+    void parallelToHalfLayout();
+    void globalSpacing();
+    void graphicsAnchorHandling();
+    void invalidHierarchyCheck();
+};
+
+class RectWidget : public QGraphicsWidget
+{
+public:
+    RectWidget(QGraphicsItem *parent = 0) : QGraphicsWidget(parent){}
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        Q_UNUSED(option);
+        Q_UNUSED(widget);
+        painter->drawRoundRect(rect());
+        painter->drawLine(rect().topLeft(), rect().bottomRight());
+        painter->drawLine(rect().bottomLeft(), rect().topRight());
+    }
+};
+
+static QGraphicsWidget *createItem(const QSizeF &minimum = QSizeF(100.0, 100.0),
+                                   const QSizeF &preferred = QSize(150.0, 100.0),
+                                   const QSizeF &maximum = QSizeF(200.0, 100.0),
+                                   const QString &name = QString())
+{
+    QGraphicsWidget *w = new RectWidget;
+    w->setMinimumSize(minimum);
+    w->setPreferredSize(preferred);
+    w->setMaximumSize(maximum);
+    w->setData(0, name);
+    return w;
+}
+
+static void setAnchor(QGraphicsAnchorLayout *l,
+                      QGraphicsLayoutItem *firstItem,
+                      Qt::AnchorPoint firstEdge,
+                      QGraphicsLayoutItem *secondItem,
+                      Qt::AnchorPoint secondEdge,
+                      qreal spacing = 0)
+{
+    QGraphicsAnchor *anchor = l->addAnchor(firstItem, firstEdge, secondItem, secondEdge);
+    anchor->setSpacing(spacing);
+}
+
+static bool checkReverseDirection(QGraphicsWidget *widget)
+{
+    QGraphicsLayout *layout = widget->layout();
+    qreal left, top, right, bottom;
+    layout->getContentsMargins(&left, &top, &right, &bottom);
+    widget->setLayoutDirection(Qt::LeftToRight);
+    QApplication::processEvents();
+    const QRectF layoutGeometry = layout->geometry();
+    QMap<QGraphicsLayoutItem *, QRectF> geometries;
+    for (int i = 0; i < layout->count(); ++i) {
+        QGraphicsLayoutItem *item = layout->itemAt(i);
+        geometries.insert(item, item->geometry());
+    }
+    widget->setLayoutDirection(Qt::RightToLeft);
+    QApplication::processEvents();
+    layoutGeometry.adjusted(+right, +top, -left, -bottom);
+    for (int i = 0; i < layout->count(); ++i) {
+        QGraphicsLayoutItem *item = layout->itemAt(i);
+        const QRectF rightToLeftGeometry = item->geometry();
+        const QRectF leftToRightGeometry = geometries.value(item);
+        QRectF expectedGeometry = leftToRightGeometry;
+        expectedGeometry.moveRight(layoutGeometry.right() - leftToRightGeometry.left());
+        if (expectedGeometry != rightToLeftGeometry) {
+            qDebug() << "layout->geometry():" << layoutGeometry
+                     << "expected:" << expectedGeometry
+                     << "actual:" << rightToLeftGeometry;
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool layoutHasConflict(QGraphicsAnchorLayout *l)
+{
+    return QGraphicsAnchorLayoutPrivate::get(l)->hasConflicts();
+}
+
+static bool usedSimplex(QGraphicsAnchorLayout *l, Qt::Orientation o)
+{
+    QGraphicsAnchorLayoutPrivate::Orientation oo = (o == Qt::Horizontal) ?
+        QGraphicsAnchorLayoutPrivate::Horizontal :
+        QGraphicsAnchorLayoutPrivate::Vertical;
+
+    return QGraphicsAnchorLayoutPrivate::get(l)->lastCalculationUsedSimplex[oo];
+}
+
+void tst_QGraphicsAnchorLayout::simple()
+{
+    QGraphicsWidget *w1 = createItem();
+    QGraphicsWidget *w2 = createItem();
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+
+    // Horizontal
+    l->addAnchor(l, Qt::AnchorLeft, w1, Qt::AnchorLeft);
+    l->addAnchor(w1, Qt::AnchorRight, w2, Qt::AnchorLeft);
+    l->addAnchor(w2, Qt::AnchorRight, l, Qt::AnchorRight);
+
+    // Vertical
+    l->addAnchors(l, w1, Qt::Vertical);
+    l->addAnchors(l, w2, Qt::Vertical);
+
+    QCOMPARE(l->count(), 2);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+    p.adjustSize();
+
+    if (hasSimplification) {
+        QVERIFY(!usedSimplex(l, Qt::Horizontal));
+        QVERIFY(!usedSimplex(l, Qt::Vertical));
+    }
+}
+
+void tst_QGraphicsAnchorLayout::simple_center()
+{
+    QSizeF minSize(10, 10);
+    QSizeF pref(50, 10);
+    QSizeF maxSize(100, 10);
+
+    QGraphicsWidget *a = createItem(minSize, pref, maxSize, "a");
+    QGraphicsWidget *b = createItem(minSize, pref, maxSize, "b");
+    QGraphicsWidget *c = createItem(minSize, pref, maxSize, "c");
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+    // horizontal
+    setAnchor(l, l, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);
+    setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft, 0);
+    setAnchor(l, b, Qt::AnchorRight, l, Qt::AnchorRight, 0);
+    setAnchor(l, a, Qt::AnchorHorizontalCenter, c, Qt::AnchorLeft, 0);
+    setAnchor(l, c, Qt::AnchorRight, b, Qt::AnchorHorizontalCenter, 0);
+
+    // vertical
+    setAnchor(l, l, Qt::AnchorTop, a, Qt::AnchorTop, 0);
+    setAnchor(l, l, Qt::AnchorTop, b, Qt::AnchorTop, 0);
+    setAnchor(l, a, Qt::AnchorBottom, c, Qt::AnchorTop, 0);
+    setAnchor(l, b, Qt::AnchorBottom, c, Qt::AnchorTop, 0);
+    setAnchor(l, c, Qt::AnchorBottom, l, Qt::AnchorBottom, 0);
+
+    QCOMPARE(l->count(), 3);
+
+    QGraphicsWidget *p = new QGraphicsWidget(0, Qt::Window);
+    p->setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QCOMPARE(layoutMinimumSize, QSizeF(20, 20));
+
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QCOMPARE(layoutMaximumSize, QSizeF(200, 20));
+
+    if (hasSimplification) {
+        QVERIFY(usedSimplex(l, Qt::Horizontal));
+        QVERIFY(!usedSimplex(l, Qt::Vertical));
+    }
+
+    delete p;
+}
+
+void tst_QGraphicsAnchorLayout::simple_semifloat()
+{
+    // Useful for testing simplification between A_left and B_left.
+    // Unfortunately the only way to really test that now is to manually inspect the
+    // simplified graph.
+    QSizeF minSize(10, 10);
+    QSizeF pref(50, 10);
+    QSizeF maxSize(100, 10);
+
+    QGraphicsWidget *A = createItem(minSize, pref, maxSize, "A");
+    QGraphicsWidget *B = createItem(minSize, pref, maxSize, "B");
+    QGraphicsWidget *a = createItem(minSize, pref, maxSize, "a");
+    QGraphicsWidget *b = createItem(minSize, pref, maxSize, "b");
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+
+    // horizontal
+    setAnchor(l, l, Qt::AnchorLeft, A, Qt::AnchorLeft, 0);
+    setAnchor(l, A, Qt::AnchorRight, B, Qt::AnchorLeft, 0);
+    setAnchor(l, B, Qt::AnchorRight, l, Qt::AnchorRight, 0);
+
+    setAnchor(l, A, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);
+    setAnchor(l, B, Qt::AnchorLeft, b, Qt::AnchorLeft, 0);
+
+    // vertical
+    setAnchor(l, l, Qt::AnchorTop, A, Qt::AnchorTop, 0);
+    setAnchor(l, l, Qt::AnchorTop, B, Qt::AnchorTop, 0);
+    setAnchor(l, A, Qt::AnchorBottom, a, Qt::AnchorTop, 0);
+    setAnchor(l, B, Qt::AnchorBottom, b, Qt::AnchorTop, 0);
+    setAnchor(l, a, Qt::AnchorBottom, l, Qt::AnchorBottom, 0);
+    setAnchor(l, b, Qt::AnchorBottom, l, Qt::AnchorBottom, 0);
+
+    QCOMPARE(l->count(), 4);
+
+    QGraphicsWidget *p = new QGraphicsWidget(0, Qt::Window);
+    p->setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QCOMPARE(layoutMinimumSize, QSizeF(20, 20));
+
+    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize), QSizeF(100, 20));
+
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QCOMPARE(layoutMaximumSize, QSizeF(200, 20));
+
+    delete p;
+}
+
+void tst_QGraphicsAnchorLayout::layoutDirection()
+{
+    QSizeF minSize(10, 10);
+    QSizeF pref(50, 10);
+    QSizeF maxSize(100, 10);
+
+    QGraphicsWidget *a = createItem(minSize, pref, maxSize, "a");
+    QGraphicsWidget *b = createItem(minSize, pref, maxSize, "b");
+    QGraphicsWidget *c = createItem(minSize, pref, QSizeF(100, 20), "c");
+
+    a->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+    b->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+    c->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 5, 10, 15);
+    // horizontal
+    setAnchor(l, l, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);
+    setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft, 0);
+    setAnchor(l, b, Qt::AnchorRight, l, Qt::AnchorRight, 0);
+    setAnchor(l, a, Qt::AnchorHorizontalCenter, c, Qt::AnchorLeft, 0);
+    setAnchor(l, c, Qt::AnchorRight, b, Qt::AnchorHorizontalCenter, 0);
+
+    // vertical
+    setAnchor(l, l, Qt::AnchorTop, a, Qt::AnchorTop, 0);
+    setAnchor(l, l, Qt::AnchorTop, b, Qt::AnchorTop, 0);
+    setAnchor(l, a, Qt::AnchorBottom, c, Qt::AnchorTop, 0);
+    setAnchor(l, b, Qt::AnchorBottom, c, Qt::AnchorTop, 0);
+    setAnchor(l, c, Qt::AnchorBottom, l, Qt::AnchorBottom, 0);
+
+    QCOMPARE(l->count(), 3);
+
+    QGraphicsWidget *p = new QGraphicsWidget(0, Qt::Window);
+    p->setLayoutDirection(Qt::LeftToRight);
+    p->setLayout(l);
+
+    QGraphicsScene scene;
+    QGraphicsView *view = new QGraphicsView(&scene);
+    scene.addItem(p);
+    p->show();
+    view->show();
+
+    QVERIFY(p->layout());
+    QCOMPARE(checkReverseDirection(p), true);
+
+    if (hasSimplification) {
+        QVERIFY(usedSimplex(l, Qt::Horizontal));
+        QVERIFY(!usedSimplex(l, Qt::Vertical));
+    }
+
+    delete p;
+    delete view;
+}
+
+void tst_QGraphicsAnchorLayout::diagonal()
+{
+    QSizeF minSize(10, 100);
+    QSizeF pref(70, 100);
+    QSizeF maxSize(100, 100);
+
+    QGraphicsWidget *a = createItem(minSize, pref, maxSize, "A");
+    QGraphicsWidget *b = createItem(minSize, pref, maxSize, "B");
+    QGraphicsWidget *c = createItem(minSize, pref, maxSize, "C");
+    QGraphicsWidget *d = createItem(minSize, pref, maxSize, "D");
+    QGraphicsWidget *e = createItem(minSize, pref, maxSize, "E");
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+    l->setSpacing(0);
+
+    // vertical
+    l->addAnchor(a, Qt::AnchorTop, l, Qt::AnchorTop);
+    l->addAnchor(b, Qt::AnchorTop, l, Qt::AnchorTop);
+    l->addAnchor(c, Qt::AnchorTop, a, Qt::AnchorBottom);
+    l->addAnchor(c, Qt::AnchorTop, b, Qt::AnchorBottom);
+    l->addAnchor(c, Qt::AnchorBottom, d, Qt::AnchorTop);
+    l->addAnchor(c, Qt::AnchorBottom, e, Qt::AnchorTop);
+    l->addAnchor(d, Qt::AnchorBottom, l, Qt::AnchorBottom);
+    l->addAnchor(e, Qt::AnchorBottom, l, Qt::AnchorBottom);
+
+    // horizontal
+    l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
+    l->addAnchor(l, Qt::AnchorLeft, d, Qt::AnchorLeft);
+    l->addAnchor(a, Qt::AnchorRight, b, Qt::AnchorLeft);
+
+    l->addAnchor(a, Qt::AnchorRight, c, Qt::AnchorLeft);
+    l->addAnchor(c, Qt::AnchorRight, e, Qt::AnchorLeft);
+
+    l->addAnchor(b, Qt::AnchorRight, l, Qt::AnchorRight);
+    l->addAnchor(e, Qt::AnchorRight, l, Qt::AnchorRight);
+    l->addAnchor(d, Qt::AnchorRight, e, Qt::AnchorLeft);
+
+    QCOMPARE(l->count(), 5);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QSizeF layoutPreferredSize = l->effectiveSizeHint(Qt::PreferredSize);
+
+    QCOMPARE(layoutMinimumSize, QSizeF(30.0, 300.0));
+    QCOMPARE(layoutPreferredSize, QSizeF(170.0, 300.0));
+    QCOMPARE(layoutMaximumSize, QSizeF(190.0, 300.0));
+
+    p.resize(layoutMinimumSize);
+    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 10.0, 100.0));
+    QCOMPARE(b->geometry(), QRectF(10.0, 0.0, 20.0, 100.0));
+    QCOMPARE(c->geometry(), QRectF(10.0, 100.0, 10.0, 100.0));
+    QCOMPARE(d->geometry(), QRectF(0.0, 200.0, 20.0, 100.0));
+    QCOMPARE(e->geometry(), QRectF(20.0, 200.0, 10.0, 100.0));
+    QCOMPARE(p.size(), layoutMinimumSize);
+
+    p.resize(layoutPreferredSize);
+    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 70.0, 100.0));
+    QCOMPARE(b->geometry(), QRectF(70.0, 0.0, 100.0, 100.0));
+    QCOMPARE(c->geometry(), QRectF(70.0, 100.0, 30.0, 100.0));
+    QCOMPARE(d->geometry(), QRectF(0.0, 200.0, 100.0, 100.0));
+    QCOMPARE(e->geometry(), QRectF(100.0, 200.0, 70.0, 100.0));
+    QCOMPARE(p.size(), layoutPreferredSize);
+
+    p.resize(layoutMaximumSize);
+    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 90.0, 100.0));
+    QCOMPARE(b->geometry(), QRectF(90.0, 0.0, 100.0, 100.0));
+    QCOMPARE(c->geometry(), QRectF(90.0, 100.0, 10.0, 100.0));
+    QCOMPARE(d->geometry(), QRectF(0.0, 200.0, 100.0, 100.0));
+    QCOMPARE(e->geometry(), QRectF(100.0, 200.0, 90.0, 100.0));
+    QCOMPARE(p.size(), layoutMaximumSize);
+
+    QSizeF testA(175.0, 300.0);
+    p.resize(testA);
+    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 75.0, 100.0));
+    QCOMPARE(b->geometry(), QRectF(75.0, 0.0, 100.0, 100.0));
+    QCOMPARE(c->geometry(), QRectF(75.0, 100.0, 25.0, 100.0));
+    QCOMPARE(d->geometry(), QRectF(0.0, 200.0, 100.0, 100.0));
+    QCOMPARE(e->geometry(), QRectF(100.0, 200.0, 75.0, 100.0));
+    QCOMPARE(p.size(), testA);
+
+    if (hasSimplification) {
+        QVERIFY(usedSimplex(l, Qt::Horizontal));
+        QVERIFY(!usedSimplex(l, Qt::Vertical));
+    }
+
+    QVERIFY(p.layout());
+    QCOMPARE(checkReverseDirection(&p), true);
+
+    c->setMinimumWidth(300);
+    QVERIFY(layoutHasConflict(l));
+}
+
+void tst_QGraphicsAnchorLayout::parallel()
+{
+    QGraphicsWidget *a = createItem(QSizeF(100, 100),
+                                    QSizeF(150, 100),
+                                    QSizeF(200, 100), "A");
+
+    QGraphicsWidget *b = createItem(QSizeF(100, 100),
+                                    QSizeF(150, 100),
+                                    QSizeF(300, 100), "B");
+
+    QGraphicsWidget *c = createItem(QSizeF(100, 100),
+                                    QSizeF(200, 100),
+                                    QSizeF(350, 100), "C");
+
+    QGraphicsWidget *d = createItem(QSizeF(100, 100),
+                                    QSizeF(170, 100),
+                                    QSizeF(200, 100), "D");
+
+    QGraphicsWidget *e = createItem(QSizeF(150, 100),
+                                    QSizeF(150, 100),
+                                    QSizeF(200, 100), "E");
+
+    QGraphicsWidget *f = createItem(QSizeF(100, 100),
+                                    QSizeF(150, 100),
+                                    QSizeF(200, 100), "F");
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+    l->setSpacing(0);
+
+    l->addAnchor(l, Qt::AnchorTop, a, Qt::AnchorTop);
+    l->addAnchor(a, Qt::AnchorBottom, b, Qt::AnchorTop);
+    l->addAnchor(b, Qt::AnchorBottom, c, Qt::AnchorTop);
+    l->addAnchor(c, Qt::AnchorBottom, d, Qt::AnchorTop);
+    l->addAnchor(d, Qt::AnchorBottom, e, Qt::AnchorTop);
+    l->addAnchor(e, Qt::AnchorBottom, f, Qt::AnchorTop);
+    l->addAnchor(f, Qt::AnchorBottom, l, Qt::AnchorBottom);
+
+    l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
+    l->addAnchor(a, Qt::AnchorRight, b, Qt::AnchorLeft);
+    l->addAnchor(a, Qt::AnchorRight, c, Qt::AnchorLeft);
+    l->addAnchor(b, Qt::AnchorRight, d, Qt::AnchorLeft);
+    l->addAnchor(b, Qt::AnchorRight, e, Qt::AnchorLeft);
+    l->addAnchor(c, Qt::AnchorRight, f, Qt::AnchorLeft);
+    l->addAnchor(d, Qt::AnchorRight, f, Qt::AnchorLeft);
+    l->addAnchor(e, Qt::AnchorRight, f, Qt::AnchorLeft);
+    l->addAnchor(f, Qt::AnchorRight, l, Qt::AnchorRight);
+
+    QCOMPARE(l->count(), 6);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QSizeF layoutPreferredSize = l->effectiveSizeHint(Qt::PreferredSize);
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+
+    QCOMPARE(layoutMinimumSize, QSizeF(450, 600));
+    QCOMPARE(layoutPreferredSize, QSizeF(620, 600));
+    QCOMPARE(layoutMaximumSize, QSizeF(750, 600));
+
+    p.resize(layoutMinimumSize);
+    QCOMPARE(a->geometry(), QRectF(0, 0, 100, 100));
+    QCOMPARE(b->geometry(), QRectF(100, 100, 100, 100));
+    QCOMPARE(c->geometry(), QRectF(100, 200, 250, 100));
+    QCOMPARE(d->geometry(), QRectF(200, 300, 150, 100));
+    QCOMPARE(e->geometry(), QRectF(200, 400, 150, 100));
+    QCOMPARE(f->geometry(), QRectF(350, 500, 100, 100));
+    QCOMPARE(p.size(), layoutMinimumSize);
+
+    if (!hasSimplification)
+        return;
+
+    p.resize(layoutPreferredSize);
+    QCOMPARE(a->geometry(), QRectF(0, 0, 150, 100));
+    QCOMPARE(b->geometry(), QRectF(150, 100, 150, 100));
+    QCOMPARE(c->geometry(), QRectF(150, 200, 320, 100));
+    QCOMPARE(d->geometry(), QRectF(300, 300, 170, 100));
+    QCOMPARE(e->geometry(), QRectF(300, 400, 170, 100));
+    QCOMPARE(f->geometry(), QRectF(470, 500, 150, 100));
+    QCOMPARE(p.size(), layoutPreferredSize);
+
+    // Maximum size depends on simplification / fair distribution
+    // Without that, test may or may not pass, depending on the
+    // solution found by the solver at runtime.
+    p.resize(layoutMaximumSize);
+    QCOMPARE(a->geometry(), QRectF(0, 0, 200, 100));
+    QCOMPARE(b->geometry(), QRectF(200, 100, 175, 100));
+    QCOMPARE(c->geometry(), QRectF(200, 200, 350, 100));
+    QCOMPARE(d->geometry(), QRectF(375, 300, 175, 100));
+    QCOMPARE(e->geometry(), QRectF(375, 400, 175, 100));
+    QCOMPARE(f->geometry(), QRectF(550, 500, 200, 100));
+    QCOMPARE(p.size(), layoutMaximumSize);
+
+    QVERIFY(!usedSimplex(l, Qt::Horizontal));
+    QVERIFY(!usedSimplex(l, Qt::Vertical));
+}
+
+void tst_QGraphicsAnchorLayout::parallel2()
+{
+    QGraphicsWidget *a = createItem(QSizeF(70.0, 100.0),
+                                    QSizeF(100.0, 100.0),
+                                    QSizeF(200.0, 100.0), "A");
+
+    QGraphicsWidget *b = createItem(QSizeF(100.0, 100.0),
+                                    QSizeF(150.0, 100.0),
+                                    QSizeF(190.0, 100.0), "B");
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+    l->setSpacing(0);
+
+    l->addAnchor(l, Qt::AnchorTop, a, Qt::AnchorTop);
+    l->addAnchor(a, Qt::AnchorBottom, b, Qt::AnchorTop);
+    l->addAnchor(b, Qt::AnchorBottom, l, Qt::AnchorBottom);
+
+    l->addAnchors(l, a, Qt::Horizontal);
+    l->addAnchor(l, Qt::AnchorLeft, b, Qt::AnchorLeft);
+    l->addAnchor(b, Qt::AnchorRight, a, Qt::AnchorRight);
+
+    QCOMPARE(l->count(), 2);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QSizeF layoutPreferredSize = l->effectiveSizeHint(Qt::PreferredSize);
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+
+    QCOMPARE(layoutMinimumSize, QSizeF(100.0, 200.0));
+    QCOMPARE(layoutPreferredSize, QSizeF(150.0, 200.0));
+    QCOMPARE(layoutMaximumSize, QSizeF(190.0, 200.0));
+
+    p.resize(layoutMinimumSize);
+    QCOMPARE(p.size(), layoutMinimumSize);
+
+    p.resize(layoutPreferredSize);
+    QCOMPARE(p.size(), layoutPreferredSize);
+
+    p.resize(layoutMaximumSize);
+    QCOMPARE(p.size(), layoutMaximumSize);
+
+    if (hasSimplification) {
+        QVERIFY(!usedSimplex(l, Qt::Horizontal));
+        QVERIFY(!usedSimplex(l, Qt::Vertical));
+    }
+}
+
+void tst_QGraphicsAnchorLayout::snake()
+{
+    QGraphicsWidget *a = createItem(QSizeF(50.0, 100.0),
+                                    QSizeF(70.0, 100.0),
+                                    QSizeF(100.0, 100.0), "A");
+
+    QGraphicsWidget *b = createItem(QSizeF(10.0, 100.0),
+                                    QSizeF(20.0, 100.0),
+                                    QSizeF(40.0, 100.0), "B");
+
+    QGraphicsWidget *c = createItem(QSizeF(50.0, 100.0),
+                                    QSizeF(70.0, 100.0),
+                                    QSizeF(100.0, 100.0), "C");
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+    l->setSpacing(0);
+
+    l->addAnchor(l, Qt::AnchorTop, a, Qt::AnchorTop);
+    l->addAnchor(a, Qt::AnchorBottom, b, Qt::AnchorTop);
+    l->addAnchor(b, Qt::AnchorBottom, c, Qt::AnchorTop);
+    l->addAnchor(c, Qt::AnchorBottom, l, Qt::AnchorBottom);
+
+    l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
+    l->addAnchor(a, Qt::AnchorRight, b, Qt::AnchorRight);
+    l->addAnchor(b, Qt::AnchorLeft, c, Qt::AnchorLeft);
+    l->addAnchor(c, Qt::AnchorRight, l, Qt::AnchorRight);
+
+    QCOMPARE(l->count(), 3);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QSizeF layoutPreferredSize = l->effectiveSizeHint(Qt::PreferredSize);
+
+    QCOMPARE(layoutMinimumSize, QSizeF(60.0, 300.0));
+    QCOMPARE(layoutPreferredSize, QSizeF(120.0, 300.0));
+    QCOMPARE(layoutMaximumSize, QSizeF(190.0, 300.0));
+
+    p.resize(layoutMinimumSize);
+    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 50.0, 100.0));
+    QCOMPARE(b->geometry(), QRectF(10.0, 100.0, 40.0, 100.0));
+    QCOMPARE(c->geometry(), QRectF(10.0, 200.0, 50.0, 100.0));
+    QCOMPARE(p.size(), layoutMinimumSize);
+
+    p.resize(layoutPreferredSize);
+    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 70.0, 100.0));
+    QCOMPARE(b->geometry(), QRectF(50.0, 100.0, 20.0, 100.0));
+    QCOMPARE(c->geometry(), QRectF(50.0, 200.0, 70.0, 100.0));
+    QCOMPARE(p.size(), layoutPreferredSize);
+
+    p.resize(layoutMaximumSize);
+    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 100.0, 100.0));
+    QCOMPARE(b->geometry(), QRectF(90.0, 100.0, 10.0, 100.0));
+    QCOMPARE(c->geometry(), QRectF(90.0, 200.0, 100.0, 100.0));
+    QCOMPARE(p.size(), layoutMaximumSize);
+
+    QVERIFY(layoutHasConflict(l) == false);
+
+    // Test QSizePolicy::ExpandFlag, it shouldn't change the extreme
+    // points of the layout...
+    b->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
+
+    QSizeF newLayoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QSizeF newLayoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QSizeF newLayoutPreferredSize = l->effectiveSizeHint(Qt::PreferredSize);
+
+    QCOMPARE(layoutMinimumSize, newLayoutMinimumSize);
+    QCOMPARE(layoutMaximumSize, newLayoutMaximumSize);
+    QCOMPARE(layoutPreferredSize, newLayoutPreferredSize);
+}
+
+void tst_QGraphicsAnchorLayout::snakeOppositeDirections()
+{
+    QGraphicsWidget *a = createItem(QSizeF(50.0, 100.0),
+                                    QSizeF(70.0, 100.0),
+                                    QSizeF(100.0, 100.0), "A");
+
+    QGraphicsWidget *b = createItem(QSizeF(10.0, 100.0),
+                                    QSizeF(20.0, 100.0),
+                                    QSizeF(40.0, 100.0), "B");
+
+    QGraphicsWidget *c = createItem(QSizeF(50.0, 100.0),
+                                    QSizeF(70.0, 100.0),
+                                    QSizeF(100.0, 100.0), "C");
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+    l->setSpacing(0);
+
+    l->addAnchor(l, Qt::AnchorTop, a, Qt::AnchorTop);
+    l->addAnchor(a, Qt::AnchorBottom, b, Qt::AnchorTop);
+    l->addAnchor(b, Qt::AnchorBottom, c, Qt::AnchorTop);
+    l->addAnchor(c, Qt::AnchorBottom, l, Qt::AnchorBottom);
+
+    l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
+
+    // Both a and c are 'pointing' to b
+    l->addAnchor(a, Qt::AnchorRight, b, Qt::AnchorRight);
+    l->addAnchor(c, Qt::AnchorLeft, b, Qt::AnchorLeft);
+
+    l->addAnchor(c, Qt::AnchorRight, l, Qt::AnchorRight);
+
+    QCOMPARE(l->count(), 3);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QSizeF layoutPreferredSize = l->effectiveSizeHint(Qt::PreferredSize);
+
+    QCOMPARE(layoutMinimumSize, QSizeF(60.0, 300.0));
+    QCOMPARE(layoutPreferredSize, QSizeF(120.0, 300.0));
+    QCOMPARE(layoutMaximumSize, QSizeF(190.0, 300.0));
+
+    p.resize(layoutMinimumSize);
+    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 50.0, 100.0));
+    QCOMPARE(b->geometry(), QRectF(10.0, 100.0, 40.0, 100.0));
+    QCOMPARE(c->geometry(), QRectF(10.0, 200.0, 50.0, 100.0));
+    QCOMPARE(p.size(), layoutMinimumSize);
+
+    p.resize(layoutPreferredSize);
+    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 70.0, 100.0));
+    QCOMPARE(b->geometry(), QRectF(50.0, 100.0, 20.0, 100.0));
+    QCOMPARE(c->geometry(), QRectF(50.0, 200.0, 70.0, 100.0));
+    QCOMPARE(p.size(), layoutPreferredSize);
+
+    p.resize(layoutMaximumSize);
+    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 100.0, 100.0));
+    QCOMPARE(b->geometry(), QRectF(90.0, 100.0, 10.0, 100.0));
+    QCOMPARE(c->geometry(), QRectF(90.0, 200.0, 100.0, 100.0));
+    QCOMPARE(p.size(), layoutMaximumSize);
+
+    QVERIFY(p.layout());
+    QCOMPARE(checkReverseDirection(&p), true);
+}
+
+void tst_QGraphicsAnchorLayout::fairDistribution()
+{
+    QGraphicsWidget *a = createItem(QSizeF(10.0, 100.0),
+                                    QSizeF(50.0, 100.0),
+                                    QSizeF(100.0, 100.0), "A");
+
+    QGraphicsWidget *b = createItem(QSizeF(10.0, 100.0),
+                                    QSizeF(50.0, 100.0),
+                                    QSizeF(100.0, 100.0), "B");
+
+    QGraphicsWidget *c = createItem(QSizeF(10.0, 100.0),
+                                    QSizeF(50.0, 100.0),
+                                    QSizeF(100.0, 100.0), "C");
+
+    QGraphicsWidget *d = createItem(QSizeF(60.0, 100.0),
+                                    QSizeF(165.0, 100.0),
+                                    QSizeF(600.0, 100.0), "D");
+
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+    l->setSpacing(0);
+
+    l->addAnchor(l, Qt::AnchorTop, a, Qt::AnchorTop);
+    l->addAnchor(a, Qt::AnchorBottom, b, Qt::AnchorTop);
+    l->addAnchor(b, Qt::AnchorBottom, c, Qt::AnchorTop);
+    l->addAnchor(c, Qt::AnchorBottom, d, Qt::AnchorTop);
+    l->addAnchor(d, Qt::AnchorBottom, l, Qt::AnchorBottom);
+
+    l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
+    l->addAnchor(a, Qt::AnchorRight, b, Qt::AnchorLeft);
+    l->addAnchor(b, Qt::AnchorRight, c, Qt::AnchorLeft);
+    l->addAnchor(c, Qt::AnchorRight, l, Qt::AnchorRight);
+    l->addAnchor(l, Qt::AnchorLeft, d, Qt::AnchorLeft);
+    l->addAnchor(d, Qt::AnchorRight, l, Qt::AnchorRight);
+
+    QCOMPARE(l->count(), 4);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QSizeF layoutPreferredSize = l->effectiveSizeHint(Qt::PreferredSize);
+
+    QCOMPARE(layoutMinimumSize, QSizeF(60.0, 400.0));
+    QCOMPARE(layoutPreferredSize, QSizeF(165.0, 400.0));
+    QCOMPARE(layoutMaximumSize, QSizeF(300.0, 400.0));
+
+    p.resize(layoutMinimumSize);
+    if (!hasSimplification)
+        QEXPECT_FAIL("", "Without simplification there is no fair distribution.", Abort);
+    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 20.0, 100.0));
+    QCOMPARE(b->geometry(), QRectF(20.0, 100.0, 20.0, 100.0));
+    QCOMPARE(c->geometry(), QRectF(40.0, 200.0, 20.0, 100.0));
+    QCOMPARE(d->geometry(), QRectF(0.0, 300.0, 60.0, 100.0));
+    QCOMPARE(p.size(), layoutMinimumSize);
+
+    p.resize(layoutPreferredSize);
+    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 55.0, 100.0));
+    QCOMPARE(b->geometry(), QRectF(55.0, 100.0, 55.0, 100.0));
+    QCOMPARE(c->geometry(), QRectF(110.0, 200.0, 55.0, 100.0));
+    QCOMPARE(d->geometry(), QRectF(0.0, 300.0, 165.0, 100.0));
+    QCOMPARE(p.size(), layoutPreferredSize);
+
+    p.resize(layoutMaximumSize);
+    QCOMPARE(a->geometry(), QRectF(0.0, 0.0, 100.0, 100.0));
+    QCOMPARE(b->geometry(), QRectF(100.0, 100.0, 100.0, 100.0));
+    QCOMPARE(c->geometry(), QRectF(200.0, 200.0, 100.0, 100.0));
+    QCOMPARE(d->geometry(), QRectF(0.0, 300.0, 300.0, 100.0));
+    QCOMPARE(p.size(), layoutMaximumSize);
+
+    if (hasSimplification) {
+        QVERIFY(!usedSimplex(l, Qt::Horizontal));
+        QVERIFY(!usedSimplex(l, Qt::Vertical));
+    }
+}
+
+void tst_QGraphicsAnchorLayout::fairDistributionOppositeDirections()
+{
+    QGraphicsWidget *a = createItem(QSizeF(10.0, 100.0),
+                                    QSizeF(50.0, 100.0),
+                                    QSizeF(100.0, 100.0), "A");
+
+    QGraphicsWidget *b = createItem(QSizeF(10.0, 100.0),
+                                    QSizeF(50.0, 100.0),
+                                    QSizeF(100.0, 100.0), "B");
+
+    QGraphicsWidget *c = createItem(QSizeF(10.0, 100.0),
+                                    QSizeF(50.0, 100.0),
+                                    QSizeF(100.0, 100.0), "C");
+
+    QGraphicsWidget *d = createItem(QSizeF(10.0, 100.0),
+                                    QSizeF(50.0, 100.0),
+                                    QSizeF(100.0, 100.0), "D");
+
+    QGraphicsWidget *e = createItem(QSizeF(60.0, 100.0),
+                                    QSizeF(220.0, 100.0),
+                                    QSizeF(600.0, 100.0), "E");
+
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+    l->setSpacing(0);
+
+    l->addAnchor(l, Qt::AnchorTop, a, Qt::AnchorTop);
+    l->addAnchor(a, Qt::AnchorBottom, b, Qt::AnchorTop);
+    l->addAnchor(b, Qt::AnchorBottom, c, Qt::AnchorTop);
+    l->addAnchor(c, Qt::AnchorBottom, d, Qt::AnchorTop);
+    l->addAnchor(d, Qt::AnchorBottom, e, Qt::AnchorTop);
+    l->addAnchor(e, Qt::AnchorBottom, l, Qt::AnchorBottom);
+
+    l->addAnchor(a, Qt::AnchorLeft, l, Qt::AnchorLeft);
+    l->addAnchor(b, Qt::AnchorLeft, a, Qt::AnchorRight);
+    l->addAnchor(c, Qt::AnchorLeft, b, Qt::AnchorRight);
+    l->addAnchor(d, Qt::AnchorLeft, c, Qt::AnchorRight);
+    l->addAnchor(d, Qt::AnchorRight, l, Qt::AnchorRight);
+    l->addAnchors(l, e, Qt::Horizontal);
+
+    QCOMPARE(l->count(), 5);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QSizeF layoutPreferredSize = l->effectiveSizeHint(Qt::PreferredSize);
+
+    QCOMPARE(layoutMinimumSize, QSizeF(60.0, 500.0));
+    QCOMPARE(layoutPreferredSize, QSizeF(220.0, 500.0));
+    QCOMPARE(layoutMaximumSize, QSizeF(400.0, 500.0));
+
+    if (!hasSimplification)
+        return;
+
+    p.resize(layoutMinimumSize);
+    QCOMPARE(a->size(), b->size());
+    QCOMPARE(a->size(), c->size());
+    QCOMPARE(a->size(), d->size());
+    QCOMPARE(e->size().width(), 4 * a->size().width());
+    QCOMPARE(p.size(), layoutMinimumSize);
+
+    p.resize(layoutPreferredSize);
+    QCOMPARE(a->size(), b->size());
+    QCOMPARE(a->size(), c->size());
+    QCOMPARE(a->size(), d->size());
+    QCOMPARE(e->size().width(), 4 * a->size().width());
+    QCOMPARE(p.size(), layoutPreferredSize);
+
+    p.resize(layoutMaximumSize);
+    QCOMPARE(a->size(), b->size());
+    QCOMPARE(a->size(), c->size());
+    QCOMPARE(a->size(), d->size());
+    QCOMPARE(e->size().width(), 4 * a->size().width());
+    QCOMPARE(p.size(), layoutMaximumSize);
+
+    QVERIFY(!usedSimplex(l, Qt::Horizontal));
+    QVERIFY(!usedSimplex(l, Qt::Vertical));
+}
+
+void tst_QGraphicsAnchorLayout::proportionalPreferred()
+{
+    QSizeF minSize(0, 100);
+
+    QGraphicsWidget *a = createItem(minSize, QSizeF(10, 100), QSizeF(20, 100), "A");
+    QGraphicsWidget *b = createItem(minSize, QSizeF(20, 100), QSizeF(30, 100), "B");
+    QGraphicsWidget *c = createItem(minSize, QSizeF(14, 100), QSizeF(20, 100), "C");
+    QGraphicsWidget *d = createItem(minSize, QSizeF(10, 100), QSizeF(20, 100), "D");
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+    l->setSpacing(0);
+
+    l->addAnchor(l, Qt::AnchorTop, a, Qt::AnchorTop);
+    l->addAnchor(a, Qt::AnchorBottom, b, Qt::AnchorTop);
+    l->addAnchor(b, Qt::AnchorBottom, c, Qt::AnchorTop);
+    l->addAnchor(c, Qt::AnchorBottom, d, Qt::AnchorTop);
+    l->addAnchor(d, Qt::AnchorBottom, l, Qt::AnchorBottom);
+
+    l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
+    l->addAnchor(l, Qt::AnchorLeft, b, Qt::AnchorLeft);
+    l->addAnchor(a, Qt::AnchorRight, c, Qt::AnchorLeft);
+    l->addAnchor(a, Qt::AnchorRight, d, Qt::AnchorLeft);
+    l->addAnchor(b, Qt::AnchorRight, l, Qt::AnchorRight);
+    l->addAnchor(c, Qt::AnchorRight, l, Qt::AnchorRight);
+    l->addAnchor(d, Qt::AnchorRight, l, Qt::AnchorRight);
+
+    QCOMPARE(l->count(), 4);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QSizeF layoutPreferredSize = l->effectiveSizeHint(Qt::PreferredSize);
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+
+    QCOMPARE(layoutMinimumSize, QSizeF(0, 400));
+    QCOMPARE(layoutPreferredSize, QSizeF(24, 400));
+    QCOMPARE(layoutMaximumSize, QSizeF(30, 400));
+
+    p.resize(layoutMinimumSize);
+    QCOMPARE(p.size(), layoutMinimumSize);
+
+    p.resize(layoutPreferredSize);
+    QCOMPARE(c->size().width(), d->size().width());
+    QCOMPARE(p.size(), layoutPreferredSize);
+
+    p.resize(layoutMaximumSize);
+    QCOMPARE(p.size(), layoutMaximumSize);
+
+    p.resize(QSizeF(12, 400));
+
+    // Proportionality between size given and preferred size, this
+    // should be respected in this graph for (a) and (b)|(c).
+    qreal factor = 12.0 / 24.0;
+
+    QCOMPARE(c->size().width(), d->size().width());
+    QCOMPARE(a->size().width(), 10 * factor);
+    QCOMPARE(c->size().width(), 14 * factor);
+    QCOMPARE(p.size(), QSizeF(12, 400));
+
+    if (hasSimplification) {
+        QVERIFY(!usedSimplex(l, Qt::Horizontal));
+        QVERIFY(!usedSimplex(l, Qt::Vertical));
+    }
+}
+
+void tst_QGraphicsAnchorLayout::example()
+{
+    QSizeF minSize(30, 100);
+    QSizeF pref(210, 100);
+    QSizeF maxSize(300, 100);
+
+    QGraphicsWidget *a = createItem(minSize, pref, maxSize, "A");
+    QGraphicsWidget *b = createItem(minSize, pref, maxSize, "B");
+    QGraphicsWidget *c = createItem(minSize, pref, maxSize, "C");
+    QGraphicsWidget *d = createItem(minSize, pref, maxSize, "D");
+    QGraphicsWidget *e = createItem(minSize, pref, maxSize, "E");
+    QGraphicsWidget *f = createItem(QSizeF(30, 50), QSizeF(150, 50), maxSize, "F");
+    QGraphicsWidget *g = createItem(QSizeF(30, 50), QSizeF(30, 100), maxSize, "G");
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+    l->setSpacing(0);
+
+    // vertical
+    l->addAnchor(a, Qt::AnchorTop, l, Qt::AnchorTop);
+    l->addAnchor(b, Qt::AnchorTop, l, Qt::AnchorTop);
+
+    l->addAnchor(c, Qt::AnchorTop, a, Qt::AnchorBottom);
+    l->addAnchor(c, Qt::AnchorTop, b, Qt::AnchorBottom);
+    l->addAnchor(c, Qt::AnchorBottom, d, Qt::AnchorTop);
+    l->addAnchor(c, Qt::AnchorBottom, e, Qt::AnchorTop);
+
+    l->addAnchor(d, Qt::AnchorBottom, l, Qt::AnchorBottom);
+    l->addAnchor(e, Qt::AnchorBottom, l, Qt::AnchorBottom);
+
+    l->addAnchor(c, Qt::AnchorTop, f, Qt::AnchorTop);
+    l->addAnchor(c, Qt::AnchorVerticalCenter, f, Qt::AnchorBottom);
+    l->addAnchor(f, Qt::AnchorBottom, g, Qt::AnchorTop);
+    l->addAnchor(c, Qt::AnchorBottom, g, Qt::AnchorBottom);
+
+    // horizontal
+    l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
+    l->addAnchor(l, Qt::AnchorLeft, d, Qt::AnchorLeft);
+    l->addAnchor(a, Qt::AnchorRight, b, Qt::AnchorLeft);
+
+    l->addAnchor(a, Qt::AnchorRight, c, Qt::AnchorLeft);
+    l->addAnchor(c, Qt::AnchorRight, e, Qt::AnchorLeft);
+
+    l->addAnchor(b, Qt::AnchorRight, l, Qt::AnchorRight);
+    l->addAnchor(e, Qt::AnchorRight, l, Qt::AnchorRight);
+    l->addAnchor(d, Qt::AnchorRight, e, Qt::AnchorLeft);
+
+    l->addAnchor(l, Qt::AnchorLeft, f, Qt::AnchorLeft);
+    l->addAnchor(l, Qt::AnchorLeft, g, Qt::AnchorLeft);
+    l->addAnchor(f, Qt::AnchorRight, g, Qt::AnchorRight);
+
+    QCOMPARE(l->count(), 7);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QSizeF layoutPreferredSize = l->effectiveSizeHint(Qt::PreferredSize);
+
+    QCOMPARE(layoutMinimumSize, QSizeF(90.0, 300.0));
+    QCOMPARE(layoutPreferredSize, QSizeF(510.0, 300.0));
+    QCOMPARE(layoutMaximumSize, QSizeF(570.0, 300.0));
+
+    p.resize(layoutMinimumSize);
+    QCOMPARE(p.size(), layoutMinimumSize);
+    QCOMPARE(a->size(), e->size());
+    QCOMPARE(b->size(), d->size());
+    QCOMPARE(f->size(), g->size());
+
+    p.resize(layoutPreferredSize);
+    QCOMPARE(p.size(), layoutPreferredSize);
+    QCOMPARE(a->size(), e->size());
+    QCOMPARE(b->size(), d->size());
+    QCOMPARE(f->size(), g->size());
+
+    p.resize(layoutMaximumSize);
+    QCOMPARE(p.size(), layoutMaximumSize);
+    QCOMPARE(a->size(), e->size());
+    QCOMPARE(b->size(), d->size());
+    QCOMPARE(f->size(), g->size());
+
+    if (hasSimplification) {
+        QVERIFY(usedSimplex(l, Qt::Horizontal));
+        QVERIFY(usedSimplex(l, Qt::Vertical));
+    }
+}
+
+void tst_QGraphicsAnchorLayout::setSpacing()
+{
+    QSizeF minSize(10, 10);
+    QSizeF pref(20, 20);
+    QSizeF maxSize(50, 50);
+
+    QGraphicsWidget *a = createItem(minSize, pref, maxSize);
+    QGraphicsWidget *b = createItem(minSize, pref, maxSize);
+    QGraphicsWidget *c = createItem(minSize, pref, maxSize);
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->addCornerAnchors(l, Qt::TopLeftCorner, a, Qt::TopLeftCorner);
+    l->addCornerAnchors(b, Qt::TopRightCorner, l, Qt::TopRightCorner);
+    l->addAnchor(a, Qt::AnchorRight, b, Qt::AnchorLeft);
+
+    l->addAnchors(l, c, Qt::Horizontal);
+
+    l->addAnchor(a, Qt::AnchorBottom, c, Qt::AnchorTop);
+    l->addAnchor(c, Qt::AnchorBottom, l, Qt::AnchorBottom);
+
+    QGraphicsWidget *p = new QGraphicsWidget(0, Qt::Window);
+
+    p->setLayout(l);
+    l->setSpacing(1);
+
+    // don't let the style influence the test.
+    l->setContentsMargins(0, 0, 0, 0);
+
+    QGraphicsScene scene;
+    scene.addItem(p);
+    QGraphicsView *view = new QGraphicsView(&scene);
+    view->show();
+    p->show();
+
+    QApplication::processEvents();
+#ifdef Q_WS_MAC
+    QTest::qWait(200);
+#endif
+
+    // 21x21
+    QCOMPARE(p->size(), QSizeF(41, 41));
+    QCOMPARE(a->geometry(), QRectF(0, 0, 20, 20));
+    QCOMPARE(b->geometry(), QRectF(21, 0, 20, 20));
+    QCOMPARE(c->geometry(), QRectF(0, 21, 41, 20));
+
+    l->setHorizontalSpacing(4);
+    QApplication::processEvents();
+    p->adjustSize();
+    QCOMPARE(a->geometry(), QRectF(0, 0, 20, 20));
+    QCOMPARE(b->geometry(), QRectF(24, 0, 20, 20));
+    QCOMPARE(c->geometry(), QRectF(0, 21, 44, 20));
+
+    l->setVerticalSpacing(0);
+    QApplication::processEvents();
+    p->adjustSize();
+    QCOMPARE(a->geometry(), QRectF(0, 0, 20, 20));
+    QCOMPARE(b->geometry(), QRectF(24, 0, 20, 20));
+    QCOMPARE(c->geometry(), QRectF(0, 20, 44, 20));
+
+    delete p;
+    delete view;
+}
+
+class CustomLayoutStyle : public QWindowsStyle
+{
+    Q_OBJECT
+public:
+    CustomLayoutStyle() : QWindowsStyle()
+    {
+        hspacing = 5;
+        vspacing = 10;
+    }
+
+    virtual int pixelMetric(PixelMetric metric, const QStyleOption * option = 0,
+                            const QWidget * widget = 0 ) const;
+
+    int hspacing;
+    int vspacing;
+
+protected slots:
+    int layoutSpacingImplementation(QSizePolicy::ControlType control1,
+                                    QSizePolicy::ControlType control2,
+                                    Qt::Orientation orientation,
+                                    const QStyleOption *option = 0,
+                                    const QWidget *widget = 0) const;
+
+};
+
+#define CT1(c) CT2(c, c)
+#define CT2(c1, c2) ((uint)c1 << 16) | (uint)c2
+
+int CustomLayoutStyle::layoutSpacingImplementation(QSizePolicy::ControlType control1,
+                                QSizePolicy::ControlType control2,
+                                Qt::Orientation orientation,
+                                const QStyleOption * /*option = 0*/,
+                                const QWidget * /*widget = 0*/) const
+{
+    if (orientation == Qt::Horizontal) {
+        switch (CT2(control1, control2)) {
+            case CT1(QSizePolicy::PushButton):
+                return 2;
+                break;
+        }
+        return 5;
+    } else {
+        switch (CT2(control1, control2)) {
+            case CT1(QSizePolicy::RadioButton):
+                return 2;
+                break;
+
+        }
+        return 10;
+    }
+}
+
+int CustomLayoutStyle::pixelMetric(PixelMetric metric, const QStyleOption * option /*= 0*/,
+                                   const QWidget * widget /*= 0*/ ) const
+{
+    switch (metric) {
+        case PM_LayoutLeftMargin:
+            return 0;
+        break;
+        case PM_LayoutTopMargin:
+            return 3;
+        break;
+        case PM_LayoutRightMargin:
+            return 6;
+        break;
+        case PM_LayoutBottomMargin:
+            return 9;
+        break;
+        case PM_LayoutHorizontalSpacing:
+            return hspacing;
+        case PM_LayoutVerticalSpacing:
+            return vspacing;
+        break;
+        default:
+            break;
+    }
+    return QWindowsStyle::pixelMetric(metric, option, widget);
+}
+
+void tst_QGraphicsAnchorLayout::styleDefaults()
+{
+    QSizeF minSize (10, 10);
+    QSizeF pref(20, 20);
+    QSizeF maxSize (50, 50);
+
+    /*
+    create this layout, where a,b have controlType QSizePolicy::RadioButton
+    c,d have controlType QSizePolicy::PushButton:
+    +-------+
+    |a      |
+    |  b    |
+    |    c  |
+    |      d|
+    +-------+
+    */
+    QGraphicsScene scene;
+    QGraphicsWidget *a = createItem(minSize, pref, maxSize);
+    QSizePolicy spRadioButton = a->sizePolicy();
+    spRadioButton.setControlType(QSizePolicy::RadioButton);
+    a->setSizePolicy(spRadioButton);
+
+    QGraphicsWidget *b = createItem(minSize, pref, maxSize);
+    b->setSizePolicy(spRadioButton);
+
+    QGraphicsWidget *c = createItem(minSize, pref, maxSize);
+    QSizePolicy spPushButton = c->sizePolicy();
+    spPushButton.setControlType(QSizePolicy::PushButton);
+    c->setSizePolicy(spPushButton);
+
+    QGraphicsWidget *d = createItem(minSize, pref, maxSize);
+    d->setSizePolicy(spPushButton);
+
+    QGraphicsWidget *window = new QGraphicsWidget(0, Qt::Window);
+
+    // Test layoutSpacingImplementation
+    CustomLayoutStyle *style = new CustomLayoutStyle;
+    style->hspacing = -1;
+    style->vspacing = -1;
+    window->setStyle(style);
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+
+    l->addCornerAnchors(l, Qt::TopLeftCorner, a, Qt::TopLeftCorner);
+    l->addCornerAnchors(a, Qt::BottomRightCorner, b, Qt::TopLeftCorner);
+    l->addCornerAnchors(b, Qt::BottomRightCorner, c, Qt::TopLeftCorner);
+    l->addCornerAnchors(c, Qt::BottomRightCorner, d, Qt::TopLeftCorner);
+    l->addCornerAnchors(d, Qt::BottomRightCorner, l, Qt::BottomRightCorner);
+
+    window->setLayout(l);
+
+    scene.addItem(window);
+
+    window->show();
+    QGraphicsView view(&scene);
+    view.resize(200, 200);
+    view.show();
+
+    window->adjustSize();
+    QCOMPARE(a->geometry(), QRectF(0,   3, 20, 20));    //radio
+    QCOMPARE(b->geometry(), QRectF(25, 25, 20, 20));    //radio
+    QCOMPARE(c->geometry(), QRectF(50, 55, 20, 20));    //push
+    QCOMPARE(d->geometry(), QRectF(72, 85, 20, 20));    //push
+    QCOMPARE(l->geometry(), QRectF(0,   0, 98, 114));
+
+
+    // Test pixelMetric(PM_Layout{Horizontal|Vertical}Spacing
+    window->setStyle(0);
+
+    style->hspacing = 1;
+    style->vspacing = 2;
+
+    window->setStyle(style);
+    window->adjustSize();
+    QCOMPARE(a->geometry(), QRectF(0,   3, 20, 20));
+    QCOMPARE(b->geometry(), QRectF(21, 25, 20, 20));
+    QCOMPARE(c->geometry(), QRectF(42, 47, 20, 20));
+    QCOMPARE(d->geometry(), QRectF(63, 69, 20, 20));
+    QCOMPARE(l->geometry(), QRectF(0,   0, 89, 98));
+
+    window->setStyle(0);
+    delete style;
+}
+
+
+/*!
+    Taken from "hard" complex case, found at
+    https://cwiki.nokia.com/S60QTUI/AnchorLayoutComplexCases
+
+    This layout has a special property, since it has two possible solutions for its minimum size.
+
+    For instance, when it is in its minimum size - the layout have two possible solutions:
+    1. c.width == 10, e.width == 10 and g.width == 10
+       (all others have width 0)
+    2. d.width == 10 and g.width == 10
+       (all others have width 0)
+
+    It also has several solutions for preferred size.
+*/
+static QGraphicsAnchorLayout *createAmbiguousS60Layout()
+{
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+    l->setSpacing(0);
+
+    QSizeF minSize(0, 10);
+    QSizeF pref(50, 10);
+    QSizeF maxSize(100, 10);
+
+    QGraphicsWidget *a = createItem(minSize, pref, maxSize, "a");
+    QGraphicsWidget *b = createItem(minSize, pref, maxSize, "b");
+    QGraphicsWidget *c = createItem(minSize, pref, maxSize, "c");
+    QGraphicsWidget *d = createItem(minSize, pref, maxSize, "d");
+    QGraphicsWidget *e = createItem(minSize, pref, maxSize, "e");
+    QGraphicsWidget *f = createItem(minSize, pref, maxSize, "f");
+    QGraphicsWidget *g = createItem(minSize, pref, maxSize, "g");
+
+    //<!-- Trunk -->
+    setAnchor(l, l, Qt::AnchorLeft, a, Qt::AnchorLeft, 10);
+    setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft, 10);
+    setAnchor(l, b, Qt::AnchorRight, c, Qt::AnchorLeft, 10);
+    setAnchor(l, c, Qt::AnchorRight, d, Qt::AnchorLeft, 10);
+    setAnchor(l, d, Qt::AnchorRight, l, Qt::AnchorRight, 10);
+
+    //<!-- Above trunk -->
+    setAnchor(l, b, Qt::AnchorLeft, e, Qt::AnchorLeft, 10);
+    setAnchor(l, e, Qt::AnchorRight, d, Qt::AnchorLeft, 10);
+
+    //<!-- Below trunk -->
+    setAnchor(l, a, Qt::AnchorHorizontalCenter, g, Qt::AnchorLeft, 10);
+    setAnchor(l, g, Qt::AnchorRight, f, Qt::AnchorHorizontalCenter, 10);
+    setAnchor(l, c, Qt::AnchorLeft, f, Qt::AnchorLeft, 10);
+    setAnchor(l, f, Qt::AnchorRight, d, Qt::AnchorRight, 10);
+
+    //<!-- vertical is simpler -->
+    setAnchor(l, l, Qt::AnchorTop, e, Qt::AnchorTop, 0);
+    setAnchor(l, e, Qt::AnchorBottom, a, Qt::AnchorTop, 0);
+    setAnchor(l, e, Qt::AnchorBottom, b, Qt::AnchorTop, 0);
+    setAnchor(l, e, Qt::AnchorBottom, c, Qt::AnchorTop, 0);
+    setAnchor(l, e, Qt::AnchorBottom, d, Qt::AnchorTop, 0);
+    setAnchor(l, a, Qt::AnchorBottom, f, Qt::AnchorTop, 0);
+    setAnchor(l, a, Qt::AnchorBottom, b, Qt::AnchorBottom, 0);
+    setAnchor(l, a, Qt::AnchorBottom, c, Qt::AnchorBottom, 0);
+    setAnchor(l, a, Qt::AnchorBottom, d, Qt::AnchorBottom, 0);
+    setAnchor(l, f, Qt::AnchorBottom, g, Qt::AnchorTop, 0);
+    setAnchor(l, g, Qt::AnchorBottom, l, Qt::AnchorBottom, 0);
+    return l;
+}
+
+void tst_QGraphicsAnchorLayout::hardComplexS60()
+{
+    QGraphicsAnchorLayout *l = createAmbiguousS60Layout();
+    QCOMPARE(l->count(), 7);
+
+    QGraphicsWidget *p = new QGraphicsWidget(0, Qt::Window);
+    p->setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QCOMPARE(layoutMinimumSize, QSizeF(60, 40));
+    // expected preferred might be wrong, (haven't manually verified it)
+    QSizeF layoutPreferredSize = l->effectiveSizeHint(Qt::PreferredSize);
+    QCOMPARE(layoutPreferredSize, QSizeF(220, 40));
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QCOMPARE(layoutMaximumSize, QSizeF(240, 40));
+
+    delete p;
+}
+
+void tst_QGraphicsAnchorLayout::stability()
+{
+    QVector<QRectF> geometries;
+    geometries.resize(7);
+    QGraphicsWidget *p = new QGraphicsWidget(0, Qt::Window);
+    bool sameAsPreviousArrangement = true;
+    // it usually fails after 3-4 iterations
+    for (int pass = 0; pass < 20 && sameAsPreviousArrangement; ++pass) {
+        // In case we need to "scramble" the heap allocator to provoke this bug.
+        //static const int primes[] = {2, 3, 5, 13, 89, 233, 1597, 28657, 514229}; // fibo primes
+        //const int primeCount = sizeof(primes)/sizeof(int);
+        //int alloc = primes[pass % primeCount] + pass;
+        //void *mem = qMalloc(alloc);
+        //qFree(mem);
+        QGraphicsAnchorLayout *l = createAmbiguousS60Layout();
+        p->setLayout(l);
+        QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+        l->setGeometry(QRectF(QPointF(0,0), layoutMinimumSize));
+        QApplication::processEvents();
+        for (int i = l->count() - 1; i >=0 && sameAsPreviousArrangement; --i) {
+            QRectF geom = l->itemAt(i)->geometry();
+            if (pass != 0) {
+                sameAsPreviousArrangement = (geometries[i] == geom);
+            }
+            geometries[i] = geom;
+        }
+        p->setLayout(0);    // uninstalls and deletes the layout
+        QApplication::processEvents();
+    }
+    delete p;
+    QEXPECT_FAIL("", "The layout have several solutions, but which solution it picks is not stable", Continue);
+    QCOMPARE(sameAsPreviousArrangement, true);
+}
+
+void tst_QGraphicsAnchorLayout::delete_anchor()
+{
+    QGraphicsScene scene;
+    QSizeF minSize(0, 0);
+    QSizeF prefSize(50, 50);
+    QSizeF maxSize(100, 100);
+    QGraphicsWidget *w1 = createItem(minSize, prefSize, maxSize, "w1");
+    QGraphicsWidget *w2 = createItem(minSize, prefSize, maxSize, "w2");
+    QGraphicsWidget *w3 = createItem(minSize, prefSize, maxSize, "w3");
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setSpacing(0);
+    l->setContentsMargins(0, 0, 0, 0);
+
+    // Horizontal
+    l->addAnchor(l, Qt::AnchorLeft, w1, Qt::AnchorLeft);
+    l->addAnchor(w1, Qt::AnchorRight, w2, Qt::AnchorLeft);
+    l->addAnchor(w2, Qt::AnchorRight, l, Qt::AnchorRight);
+    l->addAnchor(w1, Qt::AnchorRight, w3, Qt::AnchorLeft);
+    l->addAnchor(w3, Qt::AnchorRight, l, Qt::AnchorRight);
+
+    // Vertical
+    l->addAnchors(l, w1, Qt::Vertical);
+    l->addAnchors(l, w2, Qt::Vertical);
+    l->addAnchors(l, w3, Qt::Vertical);
+
+    QGraphicsAnchor *anchor = l->anchor(w3, Qt::AnchorRight, l, Qt::AnchorRight);
+    anchor->setSpacing(10);
+
+    QGraphicsWidget *p = new QGraphicsWidget;
+    p->setLayout(l);
+
+    QCOMPARE(l->count(), 3);
+
+    scene.addItem(p);
+    QGraphicsView *view = new QGraphicsView(&scene);
+    QApplication::processEvents();
+    // Should now be simplified
+    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize).width(), qreal(110));
+    QGraphicsAnchor *anchor1 = l->anchor(w3, Qt::AnchorRight, l, Qt::AnchorRight);
+    QVERIFY(anchor1);
+    QGraphicsAnchor *anchor2 = l->anchor(w3, Qt::AnchorRight, l, Qt::AnchorRight);
+    QVERIFY(anchor2);
+    QGraphicsAnchor *anchor3 = l->anchor(l, Qt::AnchorRight, w3, Qt::AnchorRight);
+    QVERIFY(anchor3);
+    QGraphicsAnchor *anchor4 = l->anchor(l, Qt::AnchorRight, w3, Qt::AnchorRight);
+    QVERIFY(anchor4);
+
+    // should all be the same object
+    QCOMPARE(anchor1, anchor2);
+    QCOMPARE(anchor2, anchor3);
+    QCOMPARE(anchor3, anchor4);
+
+    // check if removal works
+    delete anchor1;
+
+    QApplication::processEvents();
+
+    // it should also change the preferred size of the layout
+    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize).width(), qreal(100));
+
+    delete p;
+    delete view;
+}
+
+void tst_QGraphicsAnchorLayout::sizePolicy()
+{
+    QGraphicsScene scene;
+    QSizeF minSize(0, 0);
+    QSizeF prefSize(50, 50);
+    QSizeF maxSize(100, 100);
+    QGraphicsWidget *w1 = createItem(minSize, prefSize, maxSize, "w1");
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setSpacing(0);
+    l->setContentsMargins(0, 0, 0, 0);
+
+    // horizontal and vertical
+    l->addAnchors(l, w1);
+
+    QGraphicsWidget *p = new QGraphicsWidget;
+    p->setLayout(l);
+
+    scene.addItem(p);
+    QGraphicsView *view = new QGraphicsView(&scene);
+
+    // QSizePolicy::Minimum
+    w1->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
+    QApplication::processEvents();
+    w1->adjustSize();
+
+    QCOMPARE(l->effectiveSizeHint(Qt::MinimumSize), QSizeF(50, 50));
+    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize), QSizeF(50, 50));
+    QCOMPARE(l->effectiveSizeHint(Qt::MaximumSize), QSizeF(100, 100));
+
+    // QSizePolicy::Maximum
+    w1->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
+    QApplication::processEvents();
+    w1->adjustSize();
+
+    QCOMPARE(l->effectiveSizeHint(Qt::MinimumSize), QSizeF(0, 0));
+    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize), QSizeF(50, 50));
+    QCOMPARE(l->effectiveSizeHint(Qt::MaximumSize), QSizeF(50, 50));
+
+    // QSizePolicy::Fixed
+    w1->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+    QApplication::processEvents();
+    w1->adjustSize();
+
+    QCOMPARE(l->effectiveSizeHint(Qt::MinimumSize), QSizeF(50, 50));
+    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize), QSizeF(50, 50));
+    QCOMPARE(l->effectiveSizeHint(Qt::MaximumSize), QSizeF(50, 50));
+
+    // QSizePolicy::Preferred
+    w1->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+    QApplication::processEvents();
+    w1->adjustSize();
+
+    QCOMPARE(l->effectiveSizeHint(Qt::MinimumSize), QSizeF(0, 0));
+    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize), QSizeF(50, 50));
+    QCOMPARE(l->effectiveSizeHint(Qt::MaximumSize), QSizeF(100, 100));
+
+    // QSizePolicy::Ignored
+    w1->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
+    QApplication::processEvents();
+    w1->adjustSize();
+
+    QCOMPARE(l->effectiveSizeHint(Qt::MinimumSize), QSizeF(0, 0));
+    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize), QSizeF(0, 0));
+    QCOMPARE(l->effectiveSizeHint(Qt::MaximumSize), QSizeF(100, 100));
+
+    // Anchor size policies
+    w1->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+    QGraphicsAnchor *anchor = l->anchor(l, Qt::AnchorLeft, w1, Qt::AnchorLeft);
+    anchor->setSpacing(10);
+
+    // QSizePolicy::Minimum
+    anchor->setSizePolicy(QSizePolicy::Minimum);
+    QApplication::processEvents();
+
+    QCOMPARE(l->effectiveSizeHint(Qt::MinimumSize), QSizeF(60, 50));
+    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize), QSizeF(60, 50));
+    // The layout has a maximum size of QWIDGETSIZE_MAX, so the result won't exceed that value.
+    QCOMPARE(l->effectiveSizeHint(Qt::MaximumSize), QSizeF(QWIDGETSIZE_MAX, 50));
+
+    // QSizePolicy::Preferred
+    anchor->setSizePolicy(QSizePolicy::Preferred);
+    QApplication::processEvents();
+
+    QCOMPARE(l->effectiveSizeHint(Qt::MinimumSize), QSizeF(50, 50));
+    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize), QSizeF(60, 50));
+    // The layout has a maximum size of QWIDGETSIZE_MAX, so the result won't exceed that value.
+    QCOMPARE(l->effectiveSizeHint(Qt::MaximumSize), QSizeF(QWIDGETSIZE_MAX, 50));
+
+    // QSizePolicy::Maximum
+    anchor->setSizePolicy(QSizePolicy::Maximum);
+    QApplication::processEvents();
+
+    QCOMPARE(l->effectiveSizeHint(Qt::MinimumSize), QSizeF(50, 50));
+    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize), QSizeF(60, 50));
+    QCOMPARE(l->effectiveSizeHint(Qt::MaximumSize), QSizeF(60, 50));
+
+    // QSizePolicy::Ignored
+    anchor->setSizePolicy(QSizePolicy::Ignored);
+    QApplication::processEvents();
+
+    QCOMPARE(l->effectiveSizeHint(Qt::MinimumSize), QSizeF(50, 50));
+    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize), QSizeF(50, 50));
+    QCOMPARE(l->effectiveSizeHint(Qt::MaximumSize), QSizeF(QWIDGETSIZE_MAX, 50));
+
+    if (hasSimplification) {
+        QVERIFY(!usedSimplex(l, Qt::Horizontal));
+        QVERIFY(!usedSimplex(l, Qt::Vertical));
+    }
+
+    delete p;
+    delete view;
+}
+
+/*!
+    \internal
+
+    Uses private API. (We have decided to pull hasConflicts() out of the API). However, it also
+    tests some tight conditions (almost-in-conflict) that we really want to test.
+*/
+void tst_QGraphicsAnchorLayout::conflicts()
+{
+    QGraphicsWidget *a = createItem(QSizeF(80,10), QSizeF(90,10), QSizeF(100,10), "a");
+    QGraphicsWidget *b = createItem(QSizeF(10,10), QSizeF(20,10), QSizeF(30,10), "b");
+    QGraphicsWidget *c = createItem(QSizeF(10,10), QSizeF(20,10), QSizeF(30,10), "c");
+
+    QGraphicsAnchorLayout *l;
+    QGraphicsWidget *p = new QGraphicsWidget(0, Qt::Window);
+
+    l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+
+    // with the following setup, 'a' cannot be larger than 30 we will first have a Simplex conflict
+
+    // horizontal
+    setAnchor(l, l, Qt::AnchorLeft, b, Qt::AnchorLeft);
+    setAnchor(l, b, Qt::AnchorRight, c, Qt::AnchorLeft);
+    setAnchor(l, c, Qt::AnchorRight, l, Qt::AnchorRight);
+    setAnchor(l, b, Qt::AnchorHorizontalCenter, a, Qt::AnchorLeft);
+    setAnchor(l, a, Qt::AnchorRight, c, Qt::AnchorHorizontalCenter);
+
+    // vertical
+    setAnchor(l, l, Qt::AnchorTop, a, Qt::AnchorTop);
+    setAnchor(l, a, Qt::AnchorBottom, b, Qt::AnchorTop);
+    setAnchor(l, a, Qt::AnchorBottom, c, Qt::AnchorTop);
+    setAnchor(l, b, Qt::AnchorBottom, l, Qt::AnchorBottom);
+    setAnchor(l, c, Qt::AnchorBottom, l, Qt::AnchorBottom);
+
+    p->setLayout(l);
+
+    QCOMPARE(layoutHasConflict(l), true);
+
+    a->setMinimumSize(QSizeF(29,10));
+    QCOMPARE(layoutHasConflict(l), false);
+
+    a->setMinimumSize(QSizeF(30,10));
+    QCOMPARE(layoutHasConflict(l), false);
+
+    delete p;
+}
+
+void tst_QGraphicsAnchorLayout::floatConflict()
+{
+    QGraphicsWidget *a = createItem(QSizeF(80,10), QSizeF(90,10), QSizeF(100,10), "a");
+    QGraphicsWidget *b = createItem(QSizeF(80,10), QSizeF(90,10), QSizeF(100,10), "b");
+
+    QGraphicsAnchorLayout *l;
+    QGraphicsWidget *p = new QGraphicsWidget(0, Qt::Window);
+
+    l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+
+    p->setLayout(l);
+
+    // horizontal
+    // with this anchor we have two floating items
+    setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft);
+
+    // Just checking if the layout is handling well the removal of floating items
+    delete l->anchor(a, Qt::AnchorRight, b, Qt::AnchorLeft);
+    QCOMPARE(l->count(), 0);
+    QCOMPARE(layoutHasConflict(l), false);
+
+    // setting back the same anchor
+    setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft);
+
+    // We don't support floating items but they should be counted as if they are in the layout
+    QCOMPARE(l->count(), 2);
+    // Although, we have an invalid situation
+    QCOMPARE(layoutHasConflict(l), true);
+
+    // Semi-floats are supported
+    setAnchor(l, a, Qt::AnchorLeft, l, Qt::AnchorLeft);
+    QCOMPARE(l->count(), 2);
+
+    // Vertically the layout has floating items. Therefore, we have a conflict
+    QCOMPARE(layoutHasConflict(l), true);
+
+    // No more floating items
+    setAnchor(l, b, Qt::AnchorRight, l, Qt::AnchorRight);
+    setAnchor(l, a, Qt::AnchorTop, l, Qt::AnchorTop);
+    setAnchor(l, a, Qt::AnchorBottom, l, Qt::AnchorBottom);
+    setAnchor(l, b, Qt::AnchorTop, l, Qt::AnchorTop);
+    setAnchor(l, b, Qt::AnchorBottom, l, Qt::AnchorBottom);
+    QCOMPARE(layoutHasConflict(l), false);
+
+    delete p;
+}
+
+void tst_QGraphicsAnchorLayout::infiniteMaxSizes()
+{
+    if (sizeof(qreal) <= 4) {
+        QSKIP("qreal has too little precision, result will be wrong", SkipAll);
+    }
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+    l->setSpacing(0);
+
+    QSizeF minSize(10, 10);
+    QSizeF pref(50, 10);
+    QSizeF maxSize(QWIDGETSIZE_MAX, 10);
+
+    QGraphicsWidget *a = createItem(minSize, pref, maxSize, "a");
+    QGraphicsWidget *b = createItem(minSize, pref, maxSize, "b");
+    QGraphicsWidget *c = createItem(minSize, pref, maxSize, "c");
+    QGraphicsWidget *d = createItem(minSize, pref, maxSize, "d");
+    QGraphicsWidget *e = createItem(minSize, pref, maxSize, "e");
+
+    //<!-- Trunk -->
+    setAnchor(l, l, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);
+    setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft, 0);
+    setAnchor(l, b, Qt::AnchorRight, c, Qt::AnchorLeft, 0);
+    setAnchor(l, c, Qt::AnchorRight, d, Qt::AnchorLeft, 0);
+    setAnchor(l, d, Qt::AnchorRight, l, Qt::AnchorRight, 0);
+    setAnchor(l, b, Qt::AnchorHorizontalCenter, e, Qt::AnchorLeft, 0);
+    setAnchor(l, e, Qt::AnchorRight, c, Qt::AnchorHorizontalCenter, 0);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+
+    QCOMPARE(int(p.effectiveSizeHint(Qt::MaximumSize).width()),
+             QWIDGETSIZE_MAX);
+
+    p.resize(200, 10);
+    QCOMPARE(a->geometry(), QRectF(0, 0, 50, 10));
+    QCOMPARE(b->geometry(), QRectF(50, 0, 50, 10));
+    QCOMPARE(c->geometry(), QRectF(100, 0, 50, 10));
+    QCOMPARE(d->geometry(), QRectF(150, 0, 50, 10));
+
+    p.resize(1000, 10);
+    QCOMPARE(a->geometry(), QRectF(0, 0, 250, 10));
+    QCOMPARE(b->geometry(), QRectF(250, 0, 250, 10));
+    QCOMPARE(c->geometry(), QRectF(500, 0, 250, 10));
+    QCOMPARE(d->geometry(), QRectF(750, 0, 250, 10));
+
+    p.resize(40000, 10);
+    QCOMPARE(a->geometry(), QRectF(0, 0, 10000, 10));
+    QCOMPARE(b->geometry(), QRectF(10000, 0, 10000, 10));
+    QCOMPARE(c->geometry(), QRectF(20000, 0, 10000, 10));
+    QCOMPARE(d->geometry(), QRectF(30000, 0, 10000, 10));
+}
+
+void tst_QGraphicsAnchorLayout::simplifiableUnfeasible()
+{
+    QGraphicsWidget *a = createItem(QSizeF(70.0, 100.0),
+                                    QSizeF(100.0, 100.0),
+                                    QSizeF(100.0, 100.0), "A");
+
+    QGraphicsWidget *b = createItem(QSizeF(110.0, 100.0),
+                                    QSizeF(150.0, 100.0),
+                                    QSizeF(190.0, 100.0), "B");
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+    l->setSpacing(0);
+
+    l->addAnchor(l, Qt::AnchorTop, a, Qt::AnchorTop);
+    l->addAnchor(a, Qt::AnchorBottom, b, Qt::AnchorTop);
+    l->addAnchor(b, Qt::AnchorBottom, l, Qt::AnchorBottom);
+
+    l->addAnchors(l, a, Qt::Horizontal);
+    l->addAnchor(l, Qt::AnchorLeft, b, Qt::AnchorLeft);
+    l->addAnchor(b, Qt::AnchorRight, a, Qt::AnchorRight);
+
+    QCOMPARE(l->count(), 2);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+
+    l->invalidate();
+    QVERIFY(layoutHasConflict(l));
+    if (hasSimplification)
+        QVERIFY(!usedSimplex(l, Qt::Horizontal));
+
+    // Now we make it valid
+    b->setMinimumWidth(100);
+
+    l->invalidate();
+    QVERIFY(!layoutHasConflict(l));
+    if (hasSimplification)
+        QVERIFY(!usedSimplex(l, Qt::Horizontal));
+
+    // And make it invalid again
+    a->setPreferredWidth(70);
+    a->setMaximumWidth(70);
+
+    l->invalidate();
+    QVERIFY(layoutHasConflict(l));
+    if (hasSimplification)
+        QVERIFY(!usedSimplex(l, Qt::Horizontal));
+}
+
+/*
+  Test whether the anchor direction can prevent it from
+  being simplificated
+*/
+void tst_QGraphicsAnchorLayout::simplificationVsOrder()
+{
+    QSizeF minSize(10, 10);
+    QSizeF pref(20, 10);
+    QSizeF maxSize(50, 10);
+
+    QGraphicsWidget *a = createItem(minSize, pref, maxSize, "A");
+    QGraphicsWidget *b = createItem(minSize, pref, maxSize, "B");
+    QGraphicsWidget *c = createItem(minSize, pref, maxSize, "C");
+
+    QGraphicsWidget frame;
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout(&frame);
+
+    // Bulk anchors
+    l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
+    l->addAnchor(a, Qt::AnchorRight, b, Qt::AnchorLeft);
+    l->addAnchor(b, Qt::AnchorLeft, c, Qt::AnchorLeft);
+    l->addAnchor(c, Qt::AnchorRight, l, Qt::AnchorRight);
+
+    // Problematic anchor, direction b->c
+    QGraphicsAnchor *anchor = l->addAnchor(b, Qt::AnchorRight, c, Qt::AnchorRight);
+    anchor->setSpacing(5);
+
+    l->effectiveSizeHint(Qt::MinimumSize);
+    if (hasSimplification) {
+        QCOMPARE(usedSimplex(l, Qt::Horizontal), false);
+        QCOMPARE(usedSimplex(l, Qt::Vertical), false);
+    }
+
+    // Problematic anchor, direction c->b
+    delete anchor;
+    anchor = l->addAnchor(c, Qt::AnchorRight, b, Qt::AnchorRight);
+    anchor->setSpacing(5);
+
+    l->effectiveSizeHint(Qt::MinimumSize);
+    if (hasSimplification) {
+        QCOMPARE(usedSimplex(l, Qt::Horizontal), false);
+        QCOMPARE(usedSimplex(l, Qt::Vertical), false);
+    }
+}
+
+void tst_QGraphicsAnchorLayout::parallelSimplificationOfCenter()
+{
+    QSizeF minSize(10, 10);
+    QSizeF pref(20, 10);
+    QSizeF maxSize(50, 10);
+
+    QGraphicsWidget *a = createItem(minSize, pref, maxSize, "A");
+    QGraphicsWidget *b = createItem(minSize, pref, maxSize, "B");
+
+    QGraphicsWidget parent;
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout(&parent);
+    l->setContentsMargins(0, 0, 0, 0);
+
+    l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
+    l->addAnchor(l, Qt::AnchorRight, a, Qt::AnchorRight);
+
+    l->addAnchor(a, Qt::AnchorHorizontalCenter, b, Qt::AnchorLeft);
+    l->addAnchor(b, Qt::AnchorRight, a, Qt::AnchorRight);
+
+    parent.resize(l->effectiveSizeHint(Qt::PreferredSize));
+
+    QCOMPARE(a->geometry(), QRectF(0, 0, 40, 10));
+    QCOMPARE(b->geometry(), QRectF(20, 0, 20, 10));
+}
+
+/*
+    Test whether redundance of anchors (in this case by using addCornerAnchors), will
+    prevent simplification to take place when it should.
+*/
+void tst_QGraphicsAnchorLayout::simplificationVsRedundance()
+{
+    QSizeF minSize(10, 10);
+    QSizeF pref(20, 10);
+    QSizeF maxSize(50, 30);
+
+    QGraphicsWidget *a = createItem(minSize, pref, maxSize, "A");
+    QGraphicsWidget *b = createItem(minSize, pref, maxSize, "B");
+    QGraphicsWidget *c = createItem(minSize, pref, maxSize, "C");
+
+    QGraphicsWidget frame;
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout(&frame);
+
+    l->addCornerAnchors(a, Qt::TopLeftCorner, l, Qt::TopLeftCorner);
+    l->addCornerAnchors(a, Qt::BottomLeftCorner, l, Qt::BottomLeftCorner);
+
+    l->addCornerAnchors(b, Qt::TopLeftCorner, a, Qt::TopRightCorner);
+    l->addCornerAnchors(b, Qt::TopRightCorner, l, Qt::TopRightCorner);
+
+    l->addCornerAnchors(c, Qt::TopLeftCorner, b, Qt::BottomLeftCorner);
+    l->addCornerAnchors(c, Qt::BottomLeftCorner, a, Qt::BottomRightCorner);
+    l->addCornerAnchors(c, Qt::TopRightCorner, b, Qt::BottomRightCorner);
+    l->addCornerAnchors(c, Qt::BottomRightCorner, l, Qt::BottomRightCorner);
+
+    l->effectiveSizeHint(Qt::MinimumSize);
+
+    QCOMPARE(layoutHasConflict(l), false);
+
+    if (!hasSimplification)
+        QEXPECT_FAIL("", "Test depends on simplification.", Abort);
+
+    QCOMPARE(usedSimplex(l, Qt::Horizontal), false);
+    QCOMPARE(usedSimplex(l, Qt::Vertical), false);
+}
+
+/*
+  Avoid regression where the saved prefSize would be lost. This was
+  solved by saving the original spacing in the QGraphicsAnchorPrivate class
+*/
+void tst_QGraphicsAnchorLayout::spacingPersistency()
+{
+    QGraphicsWidget w;
+    QGraphicsWidget *a = createItem();
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout(&w);
+
+    l->addAnchors(l, a, Qt::Horizontal);
+    QGraphicsAnchor *anchor = l->anchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
+
+    anchor->setSpacing(-30);
+    QCOMPARE(anchor->spacing(), -30.0);
+
+    anchor->setSpacing(30);
+    QCOMPARE(anchor->spacing(), 30.0);
+
+    anchor->setSizePolicy(QSizePolicy::Ignored);
+    w.effectiveSizeHint(Qt::PreferredSize);
+
+    QCOMPARE(anchor->spacing(), 30.0);
+}
+
+/*
+    Test whether a correct preferred size is set when a "snake" sequence is in parallel with the
+    layout or half of the layout. The tricky thing here is that all items on the snake should
+    keep their preferred sizes.
+*/
+void tst_QGraphicsAnchorLayout::snakeParallelWithLayout()
+{
+    QSizeF minSize(10, 20);
+    QSizeF pref(50, 20);
+    QSizeF maxSize(100, 20);
+
+    QGraphicsWidget *a = createItem(maxSize, maxSize, maxSize, "A");
+    QGraphicsWidget *b = createItem(minSize, pref, maxSize, "B");
+    QGraphicsWidget *c = createItem(maxSize, maxSize, maxSize, "C");
+
+    QGraphicsWidget parent;
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout(&parent);
+    l->setContentsMargins(0, 0, 0, 0);
+    l->setSpacing(0);
+
+    // First we'll do the case in parallel with the entire layout...
+    l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
+    l->addAnchor(a, Qt::AnchorRight, b, Qt::AnchorRight);
+    l->addAnchor(b, Qt::AnchorLeft, c, Qt::AnchorLeft);
+    l->addAnchor(c, Qt::AnchorRight, l, Qt::AnchorRight);
+
+    l->addAnchor(l, Qt::AnchorTop, a, Qt::AnchorTop);
+    l->addAnchor(a, Qt::AnchorBottom, b, Qt::AnchorTop);
+    l->addAnchor(b, Qt::AnchorBottom, c, Qt::AnchorTop);
+    l->addAnchor(c, Qt::AnchorBottom, l, Qt::AnchorBottom);
+
+    parent.resize(l->effectiveSizeHint(Qt::PreferredSize));
+
+    // Note that A and C are fixed in the maximum size
+    QCOMPARE(l->geometry(), QRectF(QPointF(0, 0), QSizeF(150, 60)));
+    QCOMPARE(a->geometry(), QRectF(QPointF(0, 0), maxSize));
+    QCOMPARE(b->geometry(), QRectF(QPointF(50, 20), pref));
+    QCOMPARE(c->geometry(), QRectF(QPointF(50, 40), maxSize));
+
+    // Then, we change the "snake" to be in parallel with half of the layout
+    delete l->anchor(c, Qt::AnchorRight, l, Qt::AnchorRight);
+    l->addAnchor(c, Qt::AnchorRight, l, Qt::AnchorHorizontalCenter);
+
+    parent.resize(l->effectiveSizeHint(Qt::PreferredSize));
+
+    QCOMPARE(l->geometry(), QRectF(QPointF(0, 0), QSizeF(300, 60)));
+    QCOMPARE(a->geometry(), QRectF(QPointF(0, 0), maxSize));
+    QCOMPARE(b->geometry(), QRectF(QPointF(50, 20), pref));
+    QCOMPARE(c->geometry(), QRectF(QPointF(50, 40), maxSize));
+}
+
+/*
+  Avoid regression where the sizeHint constraints would not be
+  created for a parallel anchor that included the first layout half
+*/
+void tst_QGraphicsAnchorLayout::parallelToHalfLayout()
+{
+    QGraphicsWidget *a = createItem();
+
+    QGraphicsWidget w;
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout(&w);
+    l->setContentsMargins(10, 10, 10, 10);
+
+    l->addAnchors(l, a, Qt::Vertical);
+
+    QGraphicsAnchor *anchor;
+    anchor = l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
+    anchor->setSpacing(5);
+    anchor = l->addAnchor(l, Qt::AnchorHorizontalCenter, a, Qt::AnchorRight);
+    anchor->setSpacing(-5);
+
+    const QSizeF minimumSizeHint = w.effectiveSizeHint(Qt::MinimumSize);
+    const QSizeF preferredSizeHint = w.effectiveSizeHint(Qt::PreferredSize);
+    const QSizeF maximumSizeHint = w.effectiveSizeHint(Qt::MaximumSize);
+
+    const QSizeF overhead = QSizeF(10 + 5 + 5, 10) * 2;
+
+    QCOMPARE(minimumSizeHint, QSizeF(200, 100) + overhead);
+    QCOMPARE(preferredSizeHint, QSizeF(300, 100) + overhead);
+    QCOMPARE(maximumSizeHint, QSizeF(400, 100) + overhead);
+}
+
+void tst_QGraphicsAnchorLayout::globalSpacing()
+{
+    QGraphicsWidget *a = createItem();
+    QGraphicsWidget *b = createItem();
+
+    QGraphicsWidget w;
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout(&w);
+
+    l->addCornerAnchors(l, Qt::TopLeftCorner, a, Qt::TopLeftCorner);
+    l->addCornerAnchors(a, Qt::BottomRightCorner, b, Qt::TopLeftCorner);
+    l->addCornerAnchors(b, Qt::BottomRightCorner, l, Qt::BottomRightCorner);
+
+    w.resize(w.effectiveSizeHint(Qt::PreferredSize));
+    qreal vSpacing = b->geometry().top() - a->geometry().bottom();
+    qreal hSpacing = b->geometry().left() - a->geometry().right();
+
+    // Set spacings manually
+    l->setVerticalSpacing(vSpacing + 10);
+    l->setHorizontalSpacing(hSpacing + 5);
+
+    w.resize(w.effectiveSizeHint(Qt::PreferredSize));
+    qreal newVSpacing = b->geometry().top() - a->geometry().bottom();
+    qreal newHSpacing = b->geometry().left() - a->geometry().right();
+
+    QCOMPARE(newVSpacing, vSpacing + 10);
+    QCOMPARE(newHSpacing, hSpacing + 5);
+
+    // Set a negative spacing. This will unset the previous spacing and
+    // bring back the widget-defined spacing.
+    l->setSpacing(-1);
+
+    w.resize(w.effectiveSizeHint(Qt::PreferredSize));
+    newVSpacing = b->geometry().top() - a->geometry().bottom();
+    newHSpacing = b->geometry().left() - a->geometry().right();
+
+    QCOMPARE(newVSpacing, vSpacing);
+    QCOMPARE(newHSpacing, hSpacing);
+}
+
+void tst_QGraphicsAnchorLayout::graphicsAnchorHandling()
+{
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout();
+    QGraphicsWidget *a = createItem();
+
+    l->addAnchors(l, a);
+
+    QGraphicsAnchor *layoutAnchor = l->anchor(l, Qt::AnchorTop, l, Qt::AnchorBottom);
+    QGraphicsAnchor *itemAnchor = l->anchor(a, Qt::AnchorTop, a, Qt::AnchorBottom);
+    QGraphicsAnchor *invalidAnchor = l->anchor(a, Qt::AnchorTop, l, Qt::AnchorBottom);
+
+    // Ensure none of these anchors are accessible.
+    QVERIFY(layoutAnchor == 0);
+    QVERIFY(itemAnchor == 0);
+    QVERIFY(invalidAnchor == 0);
+
+    // Hook the anchors to a QObject
+    QObject object;
+    QGraphicsAnchor *userAnchor = l->anchor(l, Qt::AnchorTop, a, Qt::AnchorTop);
+    userAnchor->setParent(&object);
+    userAnchor = l->anchor(l, Qt::AnchorBottom, a, Qt::AnchorBottom);
+    userAnchor->setParent(&object);
+    userAnchor = l->anchor(l, Qt::AnchorRight, a, Qt::AnchorRight);
+    userAnchor->setParent(&object);
+    userAnchor = l->anchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
+    userAnchor->setParent(&object);
+
+    QCOMPARE(object.children().size(), 4);
+
+    // Delete layout, this will cause all anchors to be deleted internally.
+    // We expect the public QGraphicsAnchor instances to be deleted too.
+    delete l;
+    QCOMPARE(object.children().size(), 0);
+
+    delete a;
+}
+
+void tst_QGraphicsAnchorLayout::invalidHierarchyCheck()
+{
+    QGraphicsWidget window(0, Qt::Window);
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    window.setLayout(l);
+
+    QCOMPARE(l->count(), 0);
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): "
+                         "You cannot add the parent of the layout to the layout.");
+    QVERIFY(!l->addAnchor(l, Qt::AnchorLeft, &window, Qt::AnchorLeft));
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): "
+                         "You cannot add the parent of the layout to the layout.");
+    l->addAnchors(l, &window);
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): "
+                         "You cannot add the parent of the layout to the layout.");
+    l->addCornerAnchors(l, Qt::TopLeftCorner, &window, Qt::TopLeftCorner);
+    QCOMPARE(l->count(), 0);
+}
+
+QTEST_MAIN(tst_QGraphicsAnchorLayout)
+#include "tst_qgraphicsanchorlayout.moc"
diff --git a/tests/auto/widgets/graphicsview/qgraphicsanchorlayout1/qgraphicsanchorlayout1.pro b/tests/auto/widgets/graphicsview/qgraphicsanchorlayout1/qgraphicsanchorlayout1.pro
new file mode 100644
index 0000000000..bcad43fc12
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsanchorlayout1/qgraphicsanchorlayout1.pro
@@ -0,0 +1,5 @@
+load(qttest_p4)
+QT += widgets widgets-private
+QT += core-private gui-private
+SOURCES += tst_qgraphicsanchorlayout1.cpp
+CONFIG += parallel_test
diff --git a/tests/auto/widgets/graphicsview/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp b/tests/auto/widgets/graphicsview/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp
new file mode 100644
index 0000000000..05f08e8719
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp
@@ -0,0 +1,3111 @@
+/****************************************************************************
+**
+** 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 <QtGui>
+#include <QtTest/QtTest>
+#include <QTest>
+#include <QMetaType>
+#include <QtWidgets/qgraphicsanchorlayout.h>
+#include <private/qgraphicsanchorlayout_p.h>
+
+#define TEST_COMPLEX_CASES
+
+
+//---------------------- AnchorLayout helper class ----------------------------
+class TheAnchorLayout : public QGraphicsAnchorLayout
+{
+public:
+    TheAnchorLayout() : QGraphicsAnchorLayout()
+    {
+        setContentsMargins( 0,0,0,0 );
+        setSpacing( 0 );
+    }
+
+    bool isValid()
+    {
+        return !QGraphicsAnchorLayoutPrivate::get(this)->hasConflicts();
+    }
+
+    void setAnchor(
+        QGraphicsLayoutItem *startItem,
+        Qt::AnchorPoint startEdge,
+        QGraphicsLayoutItem *endItem,
+        Qt::AnchorPoint endEdge,
+        qreal value)
+        {
+            QGraphicsAnchor *anchor = addAnchor( startItem, startEdge, endItem, endEdge);
+            if (anchor)
+                anchor->setSpacing(value);
+        }
+
+    int indexOf(const QGraphicsLayoutItem* item) const
+    {
+        for ( int i=0; i< count(); i++) {
+            if ( itemAt(i) == item ) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    void removeItem(QGraphicsLayoutItem* item)
+    {
+        removeAt(indexOf(item));
+    }
+
+    void removeAnchor(
+        QGraphicsLayoutItem *startItem,
+        Qt::AnchorPoint startEdge,
+        QGraphicsLayoutItem *endItem,
+        Qt::AnchorPoint endEdge)
+        {
+            delete QGraphicsAnchorLayout::anchor(startItem, startEdge, endItem, endEdge);
+        }
+};
+//-----------------------------------------------------------------------------
+
+
+struct BasicLayoutTestData
+{
+    inline BasicLayoutTestData(
+        int index1, Qt::AnchorPoint edge1,
+        int index2, Qt::AnchorPoint edge2,
+        qreal distance)
+        : firstIndex(index1), firstEdge(edge1),
+          secondIndex(index2), secondEdge(edge2),
+          spacing(distance)
+        {
+        }
+
+    int firstIndex;
+    Qt::AnchorPoint firstEdge;
+    int secondIndex;
+    Qt::AnchorPoint secondEdge;
+    qreal spacing;
+};
+
+struct AnchorItemSizeHint
+{
+    inline AnchorItemSizeHint(
+        qreal hmin, qreal hpref, qreal hmax,
+        qreal vmin, qreal vpref, qreal vmax )
+        : hmin(hmin), hpref(hpref), hmax(hmax), vmin(vmin), vpref(vpref), vmax(vmax)
+        {
+        }
+    qreal hmin, hpref, hmax;
+    qreal vmin, vpref, vmax;
+};
+
+// some test results
+
+struct BasicLayoutTestResult
+{
+    inline BasicLayoutTestResult(
+        int resultIndex, const QRectF& resultRect )
+        : index(resultIndex), rect(resultRect)
+        {
+        }
+
+    int index;
+    QRectF rect;
+};
+
+typedef QList<BasicLayoutTestData> BasicLayoutTestDataList;
+Q_DECLARE_METATYPE(BasicLayoutTestDataList)
+
+typedef QList<BasicLayoutTestResult> BasicLayoutTestResultList;
+Q_DECLARE_METATYPE(BasicLayoutTestResultList)
+
+typedef QList<AnchorItemSizeHint> AnchorItemSizeHintList;
+Q_DECLARE_METATYPE(AnchorItemSizeHintList)
+
+
+//---------------------- Test Widget used on all tests ------------------------
+class TestWidget : public QGraphicsWidget
+{
+public:
+    inline TestWidget(QGraphicsItem *parent = 0, const QString &name = QString())
+        : QGraphicsWidget(parent)
+        {
+            setContentsMargins( 0,0,0,0 );
+            if (name.isEmpty())
+                setData(0, QString::fromAscii("w%1").arg(quintptr(this)));
+            else
+                setData(0, name);
+        }
+    ~TestWidget()
+        {
+        }
+
+protected:
+    QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
+};
+
+QSizeF TestWidget::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
+{
+    Q_UNUSED( constraint );
+    if (which == Qt::MinimumSize) {
+        return QSizeF(5,5);
+    }
+
+    if (which == Qt::PreferredSize) {
+        return QSizeF(50,50);
+    }
+
+    return QSizeF(500,500);
+}
+//-----------------------------------------------------------------------------
+
+
+
+//----------------------------- Test class ------------------------------------
+class tst_QGraphicsAnchorLayout1 : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void testCount();
+
+    void testRemoveAt();
+    void testRemoveItem();
+
+    void testItemAt();
+    void testIndexOf();
+
+    void testAddAndRemoveAnchor();
+    void testIsValid();
+    void testSpecialCases();
+
+    void testBasicLayout_data();
+    void testBasicLayout();
+
+    void testNegativeSpacing_data();
+    void testNegativeSpacing();
+
+    void testMixedSpacing_data();
+    void testMixedSpacing();
+
+    void testMulti_data();
+    void testMulti();
+
+    void testCenterAnchors_data();
+    void testCenterAnchors();
+
+    void testRemoveCenterAnchor_data();
+    void testRemoveCenterAnchor();
+
+    void testSingleSizePolicy_data();
+    void testSingleSizePolicy();
+
+    void testDoubleSizePolicy_data();
+    void testDoubleSizePolicy();
+
+    void testSizeDistribution_data();
+    void testSizeDistribution();
+
+    void testSizeHint();
+
+#ifdef TEST_COMPLEX_CASES
+    void testComplexCases_data();
+    void testComplexCases();
+#endif
+};
+
+
+void tst_QGraphicsAnchorLayout1::testCount()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+
+    TheAnchorLayout *layout = new TheAnchorLayout();
+    QVERIFY( layout->count() == 0 );
+
+    TestWidget *widget1 = new TestWidget();
+    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
+    QCOMPARE( layout->count(), 1 );
+
+    // adding one more anchor for already added widget should not increase the count
+    layout->setAnchor(layout, Qt::AnchorRight, widget1, Qt::AnchorRight, 1);
+    QCOMPARE( layout->count(), 1 );
+
+    // create one more widget and attach with anchor layout
+    TestWidget *widget2 = new TestWidget();
+    layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 1);
+    QCOMPARE( layout->count(), 2 );
+
+    widget->setLayout(layout);
+    delete widget;
+}
+
+void tst_QGraphicsAnchorLayout1::testRemoveAt()
+{
+    TheAnchorLayout *layout = new TheAnchorLayout();
+    QVERIFY( layout->count() == 0 );
+
+    TestWidget *widget1 = new TestWidget();
+    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 2);
+    QVERIFY( layout->count() == 1 );
+
+    TestWidget *widget2 = new TestWidget();
+    layout->setAnchor(widget2, Qt::AnchorLeft, layout, Qt::AnchorLeft, 0.1);
+    QVERIFY( layout->count() == 2 );
+
+    layout->removeAt(0);
+    QVERIFY( layout->count() == 1 );
+
+    layout->removeAt(-55);
+    layout->removeAt(55);
+    QVERIFY( layout->count() == 1 );
+
+    layout->removeAt(0);
+    QVERIFY( layout->count() == 0 );
+
+    delete layout;
+    delete widget1;
+    delete widget2;
+}
+
+void tst_QGraphicsAnchorLayout1::testRemoveItem()
+{
+    TheAnchorLayout *layout = new TheAnchorLayout();
+    QCOMPARE( layout->count(), 0 );
+
+    TestWidget *widget1 = new TestWidget();
+    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 2);
+    QCOMPARE( layout->count(), 1 );
+
+    TestWidget *widget2 = new TestWidget();
+    layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 0.1);
+    QCOMPARE( layout->count(), 2 );
+
+    layout->removeItem(0);
+    QCOMPARE( layout->count(), 2 );
+
+    layout->removeItem(widget1);
+    QCOMPARE( layout->count(), 1 );
+    QCOMPARE( layout->indexOf(widget1), -1 );
+    QCOMPARE( layout->indexOf(widget2), 0 );
+
+    layout->removeItem(widget1);
+    QCOMPARE( layout->count(), 1 );
+
+    layout->removeItem(widget2);
+    QVERIFY( layout->count() == 0 );
+
+    delete layout;
+    delete widget1;
+    delete widget2;
+}
+
+void tst_QGraphicsAnchorLayout1::testItemAt()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+
+    TheAnchorLayout *layout = new TheAnchorLayout();
+
+    TestWidget *widget1 = new TestWidget();
+    TestWidget *widget2 = new TestWidget();
+    TestWidget *widget3 = new TestWidget();
+    TestWidget *widget4 = new TestWidget();
+
+    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);
+    layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 0.1);
+    layout->setAnchor(layout, Qt::AnchorLeft, widget3, Qt::AnchorLeft, 0.1);
+    layout->setAnchor(layout, Qt::AnchorLeft, widget4, Qt::AnchorLeft, 0.1);
+
+    QVERIFY( layout->itemAt(0) == widget1 );
+
+    layout->removeAt(0);
+
+    QVERIFY( layout->itemAt(0) == widget2 );
+
+    delete widget1;
+
+    widget->setLayout(layout);
+    delete widget;
+}
+
+void tst_QGraphicsAnchorLayout1::testIndexOf()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+
+    TheAnchorLayout *layout = new TheAnchorLayout();
+
+    TestWidget *widget1 = new TestWidget();
+    TestWidget *widget2 = new TestWidget();
+    TestWidget *widget3 = new TestWidget();
+    TestWidget *widget4 = new TestWidget();
+
+    QCOMPARE( layout->indexOf(widget1), -1 );
+
+    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);
+    layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 0.1);
+    layout->setAnchor(layout, Qt::AnchorLeft, widget3, Qt::AnchorLeft, 0.1);
+
+    QCOMPARE( layout->indexOf(widget4), -1 );
+    layout->setAnchor(layout, Qt::AnchorLeft, widget4, Qt::AnchorLeft, 0.1);
+
+    QCOMPARE( layout->count(), 4 );
+    for (int i = 0; i < layout->count(); ++i) {
+        QCOMPARE(layout->indexOf(layout->itemAt(i)), i);
+    }
+
+    QCOMPARE( layout->indexOf(0), -1 );
+    widget->setLayout(layout);
+    delete widget;
+}
+
+void tst_QGraphicsAnchorLayout1::testAddAndRemoveAnchor()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+
+    TheAnchorLayout *layout = new TheAnchorLayout();
+
+    TestWidget *widget1 = new TestWidget();
+    TestWidget *widget2 = new TestWidget();
+    TestWidget *widget3 = new TestWidget();
+    TestWidget *widget4 = new TestWidget();
+    TestWidget *widget5 = new TestWidget();
+
+    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);
+    layout->setAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 0.5);
+    layout->setAnchor(layout, Qt::AnchorLeft, widget3, Qt::AnchorLeft, 10);
+    layout->setAnchor(layout, Qt::AnchorLeft, widget4, Qt::AnchorLeft, 0.1);
+    QCOMPARE( layout->count(), 4 );
+
+    // test setting invalid anchors
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor NULL items");
+    layout->setAnchor(0, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor NULL items");
+    layout->setAnchor(layout, Qt::AnchorLeft, 0, Qt::AnchorLeft, 1);
+    QCOMPARE( layout->count(), 4 );
+
+    // test removing invalid anchors
+    layout->removeAnchor(widget4, Qt::AnchorRight, widget1, Qt::AnchorRight);
+
+    // anchor one horizontal edge with vertical edge. it should not add this widget as a child
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor edges of different orientations");
+    layout->setAnchor(layout, Qt::AnchorLeft, widget5, Qt::AnchorTop, 10);
+    QCOMPARE( layout->count(), 4 );
+
+    // anchor two edges of a widget (to define width / height)
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+    layout->setAnchor(widget5, Qt::AnchorLeft, widget5, Qt::AnchorRight, 10);
+    // QCOMPARE( layout->count(), 5 );
+    QCOMPARE( layout->count(), 4 );
+
+    // anchor yet new widget properly
+    layout->setAnchor(layout, Qt::AnchorRight, widget5, Qt::AnchorRight, 20 );
+    QCOMPARE( layout->count(), 5 );
+
+    // remove anchor for widget1. widget1 should be removed from layout since the
+    // last anchor was removed.
+    layout->removeAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft);
+
+    QCOMPARE( layout->count(), 4 );
+    QVERIFY( !widget1->parentLayoutItem() );
+
+    // test that item is not removed from layout if other anchors remain set
+    layout->setAnchor(widget2, Qt::AnchorLeft, widget3, Qt::AnchorRight, 10);
+    layout->removeAnchor(layout, Qt::AnchorLeft, widget2, Qt::AnchorLeft);
+    QCOMPARE( layout->count(), 4 );
+
+    // remove all the anchors
+    layout->removeAnchor(widget2, Qt::AnchorLeft, widget3, Qt::AnchorRight);
+    layout->removeAnchor(layout, Qt::AnchorLeft, widget3, Qt::AnchorLeft);
+    layout->removeAnchor(layout, Qt::AnchorLeft, widget4, Qt::AnchorLeft);
+    layout->removeAnchor(widget5, Qt::AnchorLeft, widget5, Qt::AnchorRight);
+    layout->removeAnchor(layout, Qt::AnchorRight, widget5, Qt::AnchorRight);
+
+    QCOMPARE( layout->count(), 0 );
+
+    // set one anchor "another way round" to get full coverage for "removeAnchor"
+    layout->setAnchor(widget1, Qt::AnchorLeft, layout, Qt::AnchorLeft, 0.1);
+    layout->removeAnchor(widget1, Qt::AnchorLeft, layout, Qt::AnchorLeft);
+
+    QCOMPARE( layout->count(), 0 );
+
+    delete widget1;
+    delete widget2;
+    delete widget3;
+    delete widget4;
+    delete widget5;
+
+    widget->setLayout(layout);
+    delete widget;
+}
+
+void tst_QGraphicsAnchorLayout1::testIsValid()
+{
+    // Empty, valid
+    {
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    TheAnchorLayout *layout = new TheAnchorLayout();
+    widget->setLayout(layout);
+    widget->setGeometry(QRectF(0,0,100,100));
+
+    QCOMPARE(layout->isValid(), true);
+    delete widget;
+    }
+
+    // One widget, valid
+    {
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    TheAnchorLayout *layout = new TheAnchorLayout();
+
+    TestWidget *widget1 = new TestWidget();
+
+    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);
+    layout->setAnchor(layout, Qt::AnchorTop, widget1, Qt::AnchorTop, 0.1);
+    layout->setAnchor(widget1, Qt::AnchorRight, layout, Qt::AnchorRight, 0.1);
+    layout->setAnchor(widget1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 0.1);
+
+    widget->setLayout(layout);
+
+    widget->setGeometry(QRectF(0,0,100,100));
+    QCOMPARE(layout->isValid(), true);
+    delete widget;
+    }
+
+    // Overconstrained one widget, invalid
+    // ### Our understanding is that this case is valid. What happens though,
+    //     is that the layout minimum and maximum vertical size hints become
+    //     the same, 10.1. That means its height is fixed.
+    //     What will "fail" then is the "setGeometry(0, 0, 100, 100)" call,
+    //     after which the layout geometry will be (0, 0, 100, 10.1).
+
+    {
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    TheAnchorLayout *layout = new TheAnchorLayout();
+
+    TestWidget *widget1 = new TestWidget();
+
+    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);
+    layout->setAnchor(layout, Qt::AnchorTop, widget1, Qt::AnchorTop, 0.1);
+    layout->setAnchor(widget1, Qt::AnchorRight, layout, Qt::AnchorRight, 0.1);
+    layout->setAnchor(widget1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 0.1);
+
+    layout->setAnchor(widget1, Qt::AnchorTop, layout, Qt::AnchorBottom, 10);
+
+    widget->setLayout(layout);
+
+    widget->setGeometry(QRectF(0,0,100,100));
+    QCOMPARE(layout->isValid(), true);
+    delete widget;
+    }
+
+    // Underconstrained two widgets, valid
+    {
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    TheAnchorLayout *layout = new TheAnchorLayout();
+
+    TestWidget *widget1 = new TestWidget();
+    TestWidget *widget2 = new TestWidget();
+
+    // Vertically the layout has floating items. Therefore, we have a conflict
+    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);
+    layout->setAnchor(layout, Qt::AnchorRight, widget1, Qt::AnchorRight, -0.1);
+
+    // Horizontally the layout has floating items. Therefore, we have a conflict
+    layout->setAnchor(layout, Qt::AnchorTop, widget2, Qt::AnchorTop, 0.1);
+    layout->setAnchor(layout, Qt::AnchorBottom, widget2, Qt::AnchorBottom, -0.1);
+
+    widget->setLayout(layout);
+
+    widget->setGeometry(QRectF(0,0,100,100));
+    QCOMPARE(layout->isValid(), false);
+    delete widget;
+    }
+}
+
+void tst_QGraphicsAnchorLayout1::testSpecialCases()
+{
+    // One widget, setLayout before defining layouts
+    {
+#ifdef QT_DEBUG
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsLayout::addChildLayoutItem: QGraphicsWidget \"\""
+                                       " in wrong parent; moved to correct parent");
+#endif
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    TheAnchorLayout *layout = new TheAnchorLayout();
+    widget->setLayout(layout);
+
+    TestWidget *widget1 = new TestWidget();
+
+    layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
+    layout->setAnchor(layout, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
+    layout->setAnchor(widget1, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
+    layout->setAnchor(widget1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
+    widget->setGeometry(QRectF(0,0,100,100));
+    QCOMPARE(widget1->geometry(), QRectF(1,1,98,98));
+    delete widget1;
+    delete widget;
+    }
+
+    // One widget, layout inside layout, layout inside layout inside layout
+    {
+#ifdef QT_DEBUG
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsLayout::addChildLayoutItem: QGraphicsWidget \"\""
+                                       " in wrong parent; moved to correct parent");
+#endif
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    TheAnchorLayout *layout = new TheAnchorLayout();
+    widget->setLayout(layout);
+
+    TheAnchorLayout *layout1 = new TheAnchorLayout();
+    TestWidget *widget1 = new TestWidget();
+    layout1->setAnchor(layout1, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
+    layout1->setAnchor(layout1, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
+    layout1->setAnchor(widget1, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
+    layout1->setAnchor(widget1, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
+
+    TheAnchorLayout *layout2 = new TheAnchorLayout();
+    TestWidget *widget2 = new TestWidget();
+    layout2->setAnchor(layout2, Qt::AnchorLeft, widget2, Qt::AnchorLeft, 1);
+    layout2->setAnchor(layout2, Qt::AnchorTop, widget2, Qt::AnchorTop, 1);
+    layout2->setAnchor(widget2, Qt::AnchorRight, layout2, Qt::AnchorRight, 1);
+    layout2->setAnchor(widget2, Qt::AnchorBottom, layout2, Qt::AnchorBottom, 1);
+
+    layout1->setAnchor(layout1, Qt::AnchorLeft, layout2, Qt::AnchorLeft, 1);
+    layout1->setAnchor(layout1, Qt::AnchorTop, layout2, Qt::AnchorTop, 1);
+    layout1->setAnchor(layout2, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
+    layout1->setAnchor(layout2, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
+
+    layout->setAnchor(layout, Qt::AnchorLeft, layout1, Qt::AnchorLeft, 1);
+    layout->setAnchor(layout, Qt::AnchorTop, layout1, Qt::AnchorTop, 1);
+    layout->setAnchor(layout1, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
+    layout->setAnchor(layout1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
+
+    // remove and add again to improve test coverage.
+    layout->removeItem(layout1);
+
+    layout->setAnchor(layout, Qt::AnchorLeft, layout1, Qt::AnchorLeft, 1);
+    layout->setAnchor(layout, Qt::AnchorTop, layout1, Qt::AnchorTop, 1);
+    layout->setAnchor(layout1, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
+    layout->setAnchor(layout1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
+
+    widget->setGeometry(QRectF(0,0,100,100));
+    QCOMPARE(widget1->geometry(), QRectF(2,2,96,96));
+    QCOMPARE(widget2->geometry(), QRectF(3,3,94,94));
+    delete widget;
+    }
+
+    // One widget, layout inside layout, setLayout after layout definition
+    {
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    TheAnchorLayout *layout = new TheAnchorLayout();
+
+    TheAnchorLayout *layout1 = new TheAnchorLayout();
+
+    TestWidget *widget1 = new TestWidget();
+    layout1->setAnchor(layout1, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
+    layout1->setAnchor(layout1, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
+    layout1->setAnchor(widget1, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
+    layout1->setAnchor(widget1, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
+
+    layout->setAnchor(layout, Qt::AnchorLeft, layout1, Qt::AnchorLeft, 1);
+    layout->setAnchor(layout, Qt::AnchorTop, layout1, Qt::AnchorTop, 1);
+    layout->setAnchor(layout1, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
+    layout->setAnchor(layout1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
+
+    widget->setLayout(layout);
+    widget->setGeometry(QRectF(0,0,100,100));
+    QCOMPARE(widget1->geometry(), QRectF(2,2,96,96));
+    delete widget;
+    }
+
+    // One widget, layout inside layout, setLayout after layout definition, widget transferred from
+    // one layout to another
+    {
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    TheAnchorLayout *layout = new TheAnchorLayout();
+    widget->setLayout(layout);
+
+    TheAnchorLayout *layout1 = new TheAnchorLayout();
+    TestWidget *widget1 = new TestWidget();
+
+    // Additional layout + widget to improve coverage.
+    TheAnchorLayout *layout0 = new TheAnchorLayout();
+    TestWidget *widget0 = new TestWidget();
+
+    // widget0 to layout0
+    layout0->setAnchor(layout0, Qt::AnchorLeft, widget0, Qt::AnchorLeft, 1);
+    layout0->setAnchor(layout0, Qt::AnchorTop, widget0, Qt::AnchorTop, 1);
+    layout0->setAnchor(widget0, Qt::AnchorRight, layout0, Qt::AnchorRight, 1);
+    layout0->setAnchor(widget0, Qt::AnchorBottom, layout0, Qt::AnchorBottom, 1);
+
+    // layout0 to layout
+    layout->setAnchor(layout, Qt::AnchorLeft, layout0, Qt::AnchorLeft, 1);
+    layout->setAnchor(layout, Qt::AnchorTop, layout0, Qt::AnchorTop, 1);
+    layout->setAnchor(layout0, Qt::AnchorRight, layout, Qt::AnchorRight, 50);
+    layout->setAnchor(layout0, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
+
+    // widget1 to layout1
+    layout1->setAnchor(layout1, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
+    layout1->setAnchor(layout1, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
+    layout1->setAnchor(widget1, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
+    layout1->setAnchor(widget1, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
+
+    // layout1 to layout
+    layout->setAnchor(layout, Qt::AnchorLeft, layout1, Qt::AnchorLeft, 1);
+    layout->setAnchor(layout, Qt::AnchorTop, layout1, Qt::AnchorTop, 1);
+    layout->setAnchor(layout1, Qt::AnchorRight, layout, Qt::AnchorRight, 50);
+    layout->setAnchor(layout1, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
+
+    TheAnchorLayout *layout2 = new TheAnchorLayout();
+
+    // layout2 to layout
+    layout->setAnchor(layout, Qt::AnchorLeft, layout2, Qt::AnchorLeft, 50);
+    layout->setAnchor(layout, Qt::AnchorTop, layout2, Qt::AnchorTop, 1);
+    layout->setAnchor(layout2, Qt::AnchorRight, layout, Qt::AnchorRight, 1);
+    layout->setAnchor(layout2, Qt::AnchorBottom, layout, Qt::AnchorBottom, 1);
+
+    // transfer widget1 to layout2
+    layout2->setAnchor(layout2, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 1);
+    layout2->setAnchor(layout2, Qt::AnchorTop, widget1, Qt::AnchorTop, 1);
+    layout2->setAnchor(widget1, Qt::AnchorRight, layout2, Qt::AnchorRight, 1);
+    layout2->setAnchor(widget1, Qt::AnchorBottom, layout2, Qt::AnchorBottom, 1);
+
+    widget->setGeometry(QRectF(0,0,100,100));
+    QCOMPARE(widget1->geometry(), QRectF(51,2,47,96));
+    delete widget;
+    }
+
+    // One widget, set first to one layout then to another. Child reparented.
+    // In addition widget as a direct child of another widget. Child reparented.
+    {
+    QGraphicsWidget *widget1 = new QGraphicsWidget;
+    TheAnchorLayout *layout1 = new TheAnchorLayout();
+    widget1->setLayout(layout1);
+
+    TestWidget *childWidget = new TestWidget();
+
+    // childWidget to layout1
+    layout1->setAnchor(layout1, Qt::AnchorLeft, childWidget, Qt::AnchorLeft, 1);
+    layout1->setAnchor(layout1, Qt::AnchorTop, childWidget, Qt::AnchorTop, 1);
+    layout1->setAnchor(childWidget, Qt::AnchorRight, layout1, Qt::AnchorRight, 1);
+    layout1->setAnchor(childWidget, Qt::AnchorBottom, layout1, Qt::AnchorBottom, 1);
+
+    widget1->setGeometry(QRectF(0,0,100,100));
+    QCOMPARE(childWidget->geometry(), QRectF(1,1,98,98));
+    QVERIFY(childWidget->parentLayoutItem() == layout1);
+    QGraphicsWidget *widget2 = new QGraphicsWidget;
+    TheAnchorLayout *layout2 = new TheAnchorLayout();
+    widget2->setLayout(layout2);
+
+    // childWidget to layout2
+    layout2->setAnchor(layout2, Qt::AnchorLeft, childWidget, Qt::AnchorLeft, 1);
+    layout2->setAnchor(layout2, Qt::AnchorTop, childWidget, Qt::AnchorTop, 1);
+    layout2->setAnchor(childWidget, Qt::AnchorRight, layout2, Qt::AnchorRight, 1);
+    layout2->setAnchor(childWidget, Qt::AnchorBottom, layout2, Qt::AnchorBottom, 1);
+
+    QGraphicsWidget *widget3 = new QGraphicsWidget;
+    QGraphicsWidget *widget4 = new QGraphicsWidget;
+    // widget4 is a direct child of widget3 (i.e. not in any layout)
+    widget4->setParentItem(widget3);
+
+    // widget4 to layout2
+    layout2->setAnchor(layout2, Qt::AnchorLeft, widget4, Qt::AnchorLeft, 1);
+    layout2->setAnchor(layout2, Qt::AnchorTop, widget4, Qt::AnchorTop, 1);
+    layout2->setAnchor(widget4, Qt::AnchorRight, layout2, Qt::AnchorRight, 1);
+    layout2->setAnchor(widget4, Qt::AnchorBottom, layout2, Qt::AnchorBottom, 1);
+
+    widget2->setGeometry(QRectF(0,0,100,100));
+    QCOMPARE(childWidget->geometry(), QRectF(1,1,98,98));
+    QVERIFY(childWidget->parentLayoutItem() == layout2);
+    QCOMPARE(widget4->geometry(), QRectF(1,1,98,98));
+    QVERIFY(widget4->parentLayoutItem() == layout2);
+    QVERIFY(widget4->parentItem() == widget2);
+
+    delete widget4;
+    delete widget3;
+    delete widget1;
+    delete childWidget;
+    delete widget2;
+    }
+}
+
+void tst_QGraphicsAnchorLayout1::testBasicLayout_data()
+{
+    QTest::addColumn<QSizeF>("size");
+    QTest::addColumn<BasicLayoutTestDataList>("data");
+    QTest::addColumn<BasicLayoutTestResultList>("result");
+
+    typedef BasicLayoutTestData BasicData;
+    typedef BasicLayoutTestResult BasicResult;
+
+    // One widget, basic
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 20)
+            << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 30)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 40)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(20, 10, 150, 50) )
+            ;
+
+        QTest::newRow("One, simple") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // One widget, duplicates
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 20)
+            << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 30)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 40)
+
+            << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 0)
+            << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, 0)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 0)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(0, 0, 200, 100) )
+            ;
+
+        QTest::newRow("One, duplicates") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // One widget, mixed
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorBottom, 80)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 150)
+            << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorRight, 150)
+            << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorBottom, 80)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(50, 20, 100, 60) )
+            ;
+
+        QTest::newRow("One, mixed") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // Basic case - two widgets (same layout), different ordering
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+
+            << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+            << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 10)
+            << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+            << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(10, 10, 180, 80) )
+            << BasicResult(1, QRectF(10, 10, 180, 80) )
+            ;
+
+        QTest::newRow("Two, orderings") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // Basic case - two widgets, duplicate anchors
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 30)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
+
+            << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+            << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 10)
+            << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+            << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+            << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
+            << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, 0)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(30, 10, 160, 70) )
+            << BasicResult(1, QRectF(10, 0, 190, 90) )
+            ;
+
+        QTest::newRow("Two, duplicates") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // Basic case - two widgets, mixed
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorBottom, 90)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 190)
+            << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorRight, 190)
+            << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorBottom, 90)
+
+            << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorBottom, 20)
+            << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+            << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 10)
+            << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorRight, 20)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(10, 10, 180, 80) )
+            << BasicResult(1, QRectF(10, 80, 10, 10) )
+            ;
+
+        QTest::newRow("Two, mixed") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // Basic case - two widgets, 1 horizontal connection, first completely defined
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
+
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
+            << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+            << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+            << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(10, 10, 10, 80) )
+            << BasicResult(1, QRectF(30, 10, 160, 70) )
+            ;
+
+        QTest::newRow("Two, 1h connected") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // Basic case - two widgets, 2 horizontal connections, first completely defined
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
+
+            // ### QGAL is not sensible to the argument order in this case
+            //     To achieve the desired result we must explicitly set a negative
+            //     spacing.
+            // << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorRight, 100)
+            << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorRight, -100)
+
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 30)
+            << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+            << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(10, 10, 10, 80) )
+            << BasicResult(1, QRectF(50, 10, 60, 70) )
+            ;
+
+        QTest::newRow("Two, 2h connected") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // Basic case - two widgets, 1 vertical connection, first completely defined
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
+
+            << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 30)
+            << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+            << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+            << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(10, 10, 10, 80) )
+            << BasicResult(1, QRectF(30, 20, 160, 60) )
+            ;
+
+        QTest::newRow("Two, 1v connected") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // Basic case - two widgets, 2 vertical connections, first completely defined
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
+
+            << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 30)
+            << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+            << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+            << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 20)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(10, 10, 10, 80) )
+            << BasicResult(1, QRectF(30, 20, 160, 50) )
+            ;
+
+        QTest::newRow("Two, 2v connected") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // Basic case - two widgets, 1 horizontal and 1 vertical connection, first completely defined
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
+
+            << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 80)
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 100)
+            << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+            << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 10)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(10, 10, 10, 80) )
+            << BasicResult(1, QRectF(80, 10, 40, 70) )
+            ;
+
+        QTest::newRow("Two, 1h+1v connected") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // Basic case - two widgets, 2 horizontal and 2 vertical connections, first completely defined
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 180)
+
+            << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, 80)
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 100)
+            << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+            << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 10)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(10, 10, 10, 80) )
+            << BasicResult(1, QRectF(90, 20, 30, 60) )
+            ;
+
+        QTest::newRow("Two, 2h+2v connected") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // Basic case - two widgets, 2 horizontal and 2 vertical connections, dependent on each other.
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 150)
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+            << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorBottom, 10)
+
+            << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, 90)
+            << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+            << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 10)
+            << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 20)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(10, 10, 30, 60) )
+            << BasicResult(1, QRectF(100, 20, 90, 60) )
+            ;
+
+        QTest::newRow("Two, 2h+2v connected2") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // Basic case - two widgets, connected, overlapping
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+            // << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorRight, 30)
+            // ### QGAL has different semantics and assumes right edges are always
+            //     to the left of left edges. Thus we need the minus sign here.
+            << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorRight, -30)
+            << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorBottom, 40)
+
+            << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 40)
+            << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 20)
+            << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+            << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(10, 10, 60, 40) )
+            << BasicResult(1, QRectF(40, 20, 150, 70) )
+            ;
+
+        QTest::newRow("Two, connected overlapping") << QSizeF(200, 100) << theData << theResult;
+    }
+}
+
+void tst_QGraphicsAnchorLayout1::testNegativeSpacing_data()
+{
+    QTest::addColumn<QSizeF>("size");
+    QTest::addColumn<BasicLayoutTestDataList>("data");
+    QTest::addColumn<BasicLayoutTestResultList>("result");
+
+    typedef BasicLayoutTestData BasicData;
+    typedef BasicLayoutTestResult BasicResult;
+
+    // One widget, negative spacing
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        /// ### QGAL assumes items are always inside the layout.
+        //      In this case, the negative spacing would make the item
+        //      grow beyond the layout edges, which is OK, but gives a
+        //      different result.
+        //      Changing the direction of anchors (-1 to 0 or vice-versa)
+        //      has no effect in this case.
+
+        theData
+            // << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
+            // << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -20)
+            // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, -30)
+            // << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -40)
+
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, -10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, -20)
+            << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, -30)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, -40)
+
+            ;
+
+        theResult
+            // << BasicResult(0, QRectF(20, 10, 150, 50) )
+            << BasicResult(0, QRectF(-20, -10, 250, 150) )
+            ;
+
+        QTest::newRow("One, simple (n)") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // One widget, duplicates, negative spacing
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -20)
+            << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -20)
+            << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, -30)
+            << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -40)
+
+            << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
+            << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -10)
+            << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, -10)
+            << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -10)
+            ;
+
+        theResult
+            // ### Same as above...
+            // << BasicResult(0, QRectF(10, 10, 180, 80) )
+            << BasicResult(0, QRectF(-10, -10, 220, 120) )
+            ;
+
+        QTest::newRow("One, duplicates (n)") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // One widget, mixed, negative spacing
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            // ### All anchors of negative spacing between the layout and an
+            //     item are handled as to make sure the item is _outside_ the
+            //     layout.
+            //     To keep it inside, one _must_ use positive spacings.
+            // << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorTop, -80)
+            // << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorLeft, -150)
+            // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorLeft, -150)
+            // << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorTop, -80)
+
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorTop, 80)
+            << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorLeft, 150)
+            << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorLeft, 150)
+            << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorTop, 80)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(50, 20, 100, 60) )
+            ;
+
+        QTest::newRow("One, mixed (n)") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // Basic case - two widgets, 1 horizontal connection, first completely defined, negative spacing
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            // << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
+            // << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -10)
+            // << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -10)
+            // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, -180)
+
+            // << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorRight, -10)
+            // << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, -10)
+            // << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
+            // << BasicData(-1, Qt::AnchorBottom, 1, Qt::AnchorBottom, -20)
+
+            << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
+            << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -10)
+            << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -10)
+            << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, 180)
+
+            << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorRight, -10)
+            << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, -10)
+            << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
+            << BasicData(-1, Qt::AnchorBottom, 1, Qt::AnchorBottom, -20)
+
+            ;
+
+        theResult
+            // << BasicResult(0, QRectF(10, 10, 10, 80) )
+            // << BasicResult(1, QRectF(30, 10, 160, 70) )
+
+            << BasicResult(0, QRectF(-10, -10, 30, 120) )
+            << BasicResult(1, QRectF(10, -10, 200, 130) )
+            ;
+
+        QTest::newRow("Two, 1h connected (n)") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // Basic case - two widgets, 2 horizontal and 2 vertical connections, dependent on each other, negative spacing
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -10)
+            << BasicData(1, Qt::AnchorRight, 0, Qt::AnchorRight, -150)
+            << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, -10)
+            << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, -10)
+
+            << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorLeft, -90)
+            << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, -10)
+            << BasicData(1, Qt::AnchorTop, 0, Qt::AnchorTop, -10)
+            << BasicData(-1, Qt::AnchorBottom, 1, Qt::AnchorBottom, -20)
+            ;
+
+        theResult
+            // << BasicResult(0, QRectF(10, 10, 30, 60) )
+            // << BasicResult(1, QRectF(100, 20, 90, 60) )
+            << BasicResult(0, QRectF(-10, -10, 70, 120) )
+            << BasicResult(1, QRectF(80, 0, 130, 120) )
+            ;
+
+        QTest::newRow("Two, 2h+2v connected2 (n)") << QSizeF(200, 100) << theData << theResult;
+    }
+}
+
+void tst_QGraphicsAnchorLayout1::testMixedSpacing_data()
+{
+    QTest::addColumn<QSizeF>("size");
+    QTest::addColumn<BasicLayoutTestDataList>("data");
+    QTest::addColumn<BasicLayoutTestResultList>("result");
+
+    typedef BasicLayoutTestData BasicData;
+    typedef BasicLayoutTestResult BasicResult;
+
+    // Two widgets, partial overlapping
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+            << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, -50)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 50)
+            << BasicData(1, Qt::AnchorRight, 0, Qt::AnchorRight, 15)
+
+            // << BasicData(1, Qt::AnchorTop, 0, Qt::AnchorBottom, 5)
+            << BasicData(1, Qt::AnchorTop, 0, Qt::AnchorBottom, -5)
+            << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, -10)
+            << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 20)
+            << BasicData(-1, Qt::AnchorBottom, 1, Qt::AnchorBottom, -5)
+            ;
+
+        theResult
+            // << BasicResult(0, QRectF(50, 10, 45, 40) )
+            // << BasicResult(1, QRectF(40, 45, 40, 50) )
+            << BasicResult(0, QRectF(-50, 10, 145, 40) )
+            << BasicResult(1, QRectF(-60, 45, 140, 60) )
+            ;
+
+        QTest::newRow("Two, partial overlap") << QSizeF(100, 100) << theData << theResult;
+    }
+
+    // Two widgets, complete overlapping
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 5)
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 0)
+            << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
+            << BasicData(1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 25)
+
+            << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 0)
+            << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
+            << BasicData(1, Qt::AnchorLeft, -1, Qt::AnchorRight, 50)
+            << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, -10)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(65, 5, 35, 35) )
+            << BasicResult(1, QRectF(40, 5, 60, 35) )
+            ;
+
+        QTest::newRow("Two, complete overlap") << QSizeF(90, 45) << theData << theResult;
+    }
+
+    // Five widgets, v shaped, edges shared
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            // edges shared
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 0)
+            << BasicData(1, Qt::AnchorRight, 2, Qt::AnchorLeft, 0)
+            << BasicData(2, Qt::AnchorRight, 3, Qt::AnchorLeft, 0)
+            << BasicData(3, Qt::AnchorRight, 4, Qt::AnchorLeft, 0)
+            << BasicData(1, Qt::AnchorBottom, 2, Qt::AnchorTop, 0)
+            << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorTop, 0)
+            << BasicData(3, Qt::AnchorBottom, 2, Qt::AnchorTop, 0)
+            << BasicData(4, Qt::AnchorBottom, 3, Qt::AnchorTop, 0)
+            << BasicData(0, Qt::AnchorBottom, 4, Qt::AnchorBottom, 0)
+            << BasicData(1, Qt::AnchorBottom, 3, Qt::AnchorBottom, 0)
+            << BasicData(0, Qt::AnchorTop, 4, Qt::AnchorTop, 0)
+            << BasicData(1, Qt::AnchorTop, 3, Qt::AnchorTop, 0)
+
+            // margins
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 5)
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 5)
+            << BasicData(2, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
+            // << BasicData(-1, Qt::AnchorRight, 4, Qt::AnchorRight, -5)
+            << BasicData(-1, Qt::AnchorRight, 4, Qt::AnchorRight, 5)
+
+            // additional details for exact size determination easily
+            << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 25)
+            << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorRight, 50)
+            // << BasicData(-1, Qt::AnchorRight, 3, Qt::AnchorRight, -25)
+            // << BasicData(-1, Qt::AnchorRight, 2, Qt::AnchorRight, -50)
+            << BasicData(-1, Qt::AnchorRight, 3, Qt::AnchorRight, 25)
+            << BasicData(-1, Qt::AnchorRight, 2, Qt::AnchorRight, 50)
+            << BasicData(-1, Qt::AnchorTop, 3, Qt::AnchorBottom, 50)
+            // << BasicData(-1, Qt::AnchorBottom, 3, Qt::AnchorTop, -50)
+            << BasicData(-1, Qt::AnchorBottom, 3, Qt::AnchorTop, 50)
+
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(5,5,20,20))
+            << BasicResult(1, QRectF(25,25,25,25))
+            << BasicResult(2, QRectF(50,50,25,20))
+            << BasicResult(3, QRectF(75,25,25,25))
+            << BasicResult(4, QRectF(100,5,20,20))
+            ;
+
+        QTest::newRow("Five, V shape") << QSizeF(125, 75) << theData << theResult;
+    }
+
+    // ### The behavior is different in QGraphicsAnchorLayout. What happens here is
+    //     that when the above anchors are set, the layout size hints are changed.
+    //     In the example, the minimum item width is 5, thus the minimum layout width
+    //     becomes 105 (50 + 5 + 50). Once that size hint is set, trying to set
+    //     the widget size to (10, 10) is not possible because
+    //     QGraphicsWidget::setGeometry() will enforce the minimum is respected.
+    if (0)
+    // One widget, unsolvable
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+                << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 50)
+                << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 50)
+                ;
+        theResult
+                << BasicResult(0, QRectF(0,0,0,0))
+                ;
+
+        QTest::newRow("One widget, unsolvable") << QSizeF(10, 10) << theData << theResult;
+    }
+
+    // Two widgets, one has fixed size
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+                << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 50)
+                << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 50)
+            // not supported, use sizePolicy instead
+            // << BasicData(0, Qt::AnchorLeft, 0, Qt::AnchorRight, 50)
+
+                << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorLeft, 50)
+                << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 50)
+                ;
+        theResult
+                << BasicResult(0, QRectF(50,0,50,50))
+                << BasicResult(1, QRectF(50,0,50,50))
+                ;
+
+        QTest::newRow("Two widgets, one has fixed size") << QSizeF(150, 150) << theData << theResult;
+    }
+}
+
+void tst_QGraphicsAnchorLayout1::testMulti_data()
+{
+    QTest::addColumn<QSizeF>("size");
+    QTest::addColumn<BasicLayoutTestDataList>("data");
+    QTest::addColumn<BasicLayoutTestResultList>("result");
+
+    typedef BasicLayoutTestData BasicData;
+    typedef BasicLayoutTestResult BasicResult;
+
+    // Multiple widgets, all overllapping
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        const int n = 30;
+        for ( int i = 0 ; i < n; i++ ) {
+            theData
+                << BasicData(-1, Qt::AnchorTop, i, Qt::AnchorTop, 20)
+                << BasicData(-1, Qt::AnchorLeft, i, Qt::AnchorLeft, 10)
+                // << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -40)
+                // << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, -30);
+                << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, 40)
+                << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, 30);
+
+            theResult
+                << BasicResult(i, QRectF(10, 20, 160, 40) );
+        }
+
+
+        QTest::newRow("Overlapping multi") << QSizeF(200, 100) << theData << theResult;
+    }
+
+    // Multiple widgets, linear order
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        const qreal height = 1000.f;
+        const qreal width = 2000.f;
+
+        const int n = 30;
+
+        const qreal verticalStep = height/qreal(n+2);
+        const qreal horizontalStep = width/qreal(n+2);
+
+        for ( int i = 0 ; i < n; i++ ) {
+
+            if ( i == 0 ) {
+                // First item
+                theData
+                    << BasicData(-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+                    << BasicData(-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+                    << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+                    << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
+
+            } else if ( i == n-1 ) {
+                // Last item
+                theData
+                    << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+                    << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+                    << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, verticalStep)
+                    << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, horizontalStep);
+                    // << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+                    // << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
+
+            } else {
+                // items in the middle
+                theData
+                    << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+                    << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+                    << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+                    << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
+                    // << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+                    // << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
+
+            }
+
+            theResult
+                << BasicResult(i, QRectF((i+1)*horizontalStep, (i+1)*verticalStep, horizontalStep, verticalStep) );
+        }
+
+
+        if (sizeof(qreal) == 4) {
+            qDebug("Linear multi: Skipping! (qreal has too little precision, result will be wrong)");
+        } else {
+            QTest::newRow("Linear multi") << QSizeF(width, height) << theData << theResult;
+        }
+    }
+
+    // Multiple widgets, V shape
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        const qreal height = 100.f;
+        const qreal width = 200.f;
+
+        const int n = 31; // odd number please (3,5,7... )
+
+        const qreal verticalStep = height/(2.f+(n+1)/2.f);
+        const qreal horizontalStep = width/(n+2.f);
+
+        for ( int i = 0 ; i < n; i++ ) {
+
+            if ( i == 0 ) {
+                // First item
+                theData
+                    << BasicData(-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+                    << BasicData(-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+                    << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+                    << BasicData(i, Qt::AnchorRight, i+1, Qt::AnchorRight, horizontalStep);
+
+            } else if ( i == n-1 ) {
+                // Last item
+                theData
+                    << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, -verticalStep)
+                    << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+                    << BasicData(i-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+                    << BasicData(i, Qt::AnchorRight, -1, Qt::AnchorRight, horizontalStep);
+            } else if ( i == ((n-1)/2) ) {
+                // midway
+                theData
+                    << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+                    << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+                    // << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+                    << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, verticalStep)
+                    << BasicData(i, Qt::AnchorRight, i+1, Qt::AnchorRight, horizontalStep);
+            } else if ( i < ((n-1)/2) ) {
+                // before midway - going down
+                theData
+                    << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+                    << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+                    << BasicData(i+1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+                    << BasicData(i, Qt::AnchorRight, i+1, Qt::AnchorRight, horizontalStep);
+
+            } else {
+                // after midway - going up
+                theData
+                    << BasicData(i-1, Qt::AnchorTop, i, Qt::AnchorTop, -verticalStep)
+                    << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+                    << BasicData(i-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+                    << BasicData(i, Qt::AnchorRight, i+1, Qt::AnchorRight, horizontalStep);
+
+            }
+
+            if ( i <= ((n-1)/2) ) {
+                // until midway
+                theResult
+                    << BasicResult(i, QRectF((i+1)*horizontalStep, (i+1)*verticalStep, horizontalStep, verticalStep) );
+            } else {
+                // after midway
+                theResult
+                    << BasicResult(i, QRectF((i+1)*horizontalStep, (n-i)*verticalStep, horizontalStep, verticalStep) );
+            }
+
+        }
+        if (sizeof(qreal) == 4) {
+            qDebug("V multi: Skipping! (qreal has too little precision, result will be wrong)");
+        } else {
+            QTest::newRow("V multi") << QSizeF(width, height) << theData << theResult;
+        }
+    }
+
+    // Multiple widgets, grid
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        const qreal height = 100.f;
+        const qreal width = 200.f;
+
+        const int d = 10; // items per dimension
+        const int n = d*d;
+
+        const qreal verticalStep = height/(d+2.f);
+        const qreal horizontalStep = width/(d+2.f);
+
+        for ( int i = 0 ; i < n; i++ ) {
+            if ( i%d == 0 ) {
+                // left side item
+                theData
+                    << BasicData(-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+                    << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
+            } else if ( (i+1)%d == 0 ) {
+                // rigth side item
+                theData
+                    << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+                    // << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
+                    << BasicData(-1, Qt::AnchorRight, i, Qt::AnchorRight, horizontalStep);
+            } else {
+                // horizontal middle
+                theData
+                    << BasicData(i-1, Qt::AnchorLeft, i, Qt::AnchorLeft, horizontalStep)
+                    << BasicData(i+1, Qt::AnchorRight, i, Qt::AnchorRight, -horizontalStep);
+            }
+
+            if ( i < d ) {
+                // top line
+                theData
+                    << BasicData(-1, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+                    << BasicData(i+d, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep);
+            } else if ( i >= (d-1)*d ){
+                // bottom line
+                theData
+                    << BasicData(i-d, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+                    // << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep)
+                    << BasicData(-1, Qt::AnchorBottom, i, Qt::AnchorBottom, verticalStep);
+            } else {
+                // vertical middle
+                theData
+                    << BasicData(i-d, Qt::AnchorTop, i, Qt::AnchorTop, verticalStep)
+                    << BasicData(i+d, Qt::AnchorBottom, i, Qt::AnchorBottom, -verticalStep);
+            }
+
+            theResult
+                << BasicResult(i, QRectF(((i%d)+1)*horizontalStep, ((i/d)+1)*verticalStep, horizontalStep, verticalStep) );
+        }
+
+        if (sizeof(qreal) == 4) {
+            qDebug("Grid multi: Skipping! (qreal has too little precision, result will be wrong)");
+        } else {
+            QTest::newRow("Grid multi") << QSizeF(200, 100) << theData << theResult;
+        }
+    }
+}
+
+inline QGraphicsLayoutItem *getItem(
+        int index,
+        const QList<QGraphicsWidget *>& widgets,
+        QGraphicsLayoutItem *defaultItem)
+{
+    if (index < 0) {
+        return defaultItem;
+    }
+
+    return widgets[index];
+}
+
+static bool fuzzierCompare(qreal a, qreal b)
+{
+    return qAbs(a - b) <= qreal(0.0001);
+}
+
+static bool fuzzierCompare(const QRectF &r1, const QRectF &r2)
+{
+
+    return fuzzierCompare(r1.x(), r2.x()) && fuzzierCompare(r1.y(), r2.y())
+        && fuzzierCompare(r1.width(), r2.width()) && fuzzierCompare(r1.height(), r2.height());
+}
+
+void tst_QGraphicsAnchorLayout1::testBasicLayout()
+{
+    QFETCH(QSizeF, size);
+    QFETCH(BasicLayoutTestDataList, data);
+    QFETCH(BasicLayoutTestResultList, result);
+
+    QGraphicsWidget *widget = new QGraphicsWidget;
+
+    // Determine amount of widgets to add.
+    int widgetCount = -1;
+    for (int i = 0; i < data.count(); ++i) {
+        const BasicLayoutTestData item = data[i];
+        widgetCount = qMax(widgetCount, item.firstIndex);
+        widgetCount = qMax(widgetCount, item.secondIndex);
+    }
+    ++widgetCount; // widgetCount is max of indices.
+
+    // Create dummy widgets
+    QList<QGraphicsWidget *> widgets;
+    for (int i = 0; i < widgetCount; ++i) {
+        TestWidget *w = new TestWidget(0, QString::fromAscii("W%1").arg(i));
+        widgets << w;
+    }
+
+    // Setup anchor layout
+    TheAnchorLayout *layout = new TheAnchorLayout;
+
+    for (int i = 0; i < data.count(); ++i) {
+        const BasicLayoutTestData item = data[i];
+        layout->setAnchor(
+            getItem(item.firstIndex, widgets, layout),
+            item.firstEdge,
+            getItem(item.secondIndex, widgets, layout),
+            item.secondEdge,
+            item.spacing );
+    }
+
+    widget->setLayout(layout);
+    widget->setContentsMargins(0,0,0,0);
+
+    widget->resize(size);
+    QCOMPARE(widget->size(), size);
+
+    // Validate
+    for (int i = 0; i < result.count(); ++i) {
+        const BasicLayoutTestResult item = result[i];
+        QRectF expected = item.rect;
+        QRectF actual = widgets[item.index]->geometry();
+
+        QVERIFY(fuzzierCompare(actual, expected));
+    }
+
+    // Test mirrored mode
+    widget->setLayoutDirection(Qt::RightToLeft);
+    layout->activate();
+    // Validate
+    for (int j = 0; j < result.count(); ++j) {
+        const BasicLayoutTestResult item = result[j];
+        QRectF mirroredRect(item.rect);
+        // only valid cases are mirrored
+        if (mirroredRect.isValid()){
+            mirroredRect.moveLeft(size.width()-item.rect.width()-item.rect.left());
+        }
+        QRectF expected = mirroredRect;
+        QRectF actual = widgets[item.index]->geometry();
+
+        QVERIFY(fuzzierCompare(actual, expected));
+    }
+
+    qDeleteAll(widgets);
+    delete widget;
+}
+
+void tst_QGraphicsAnchorLayout1::testNegativeSpacing()
+{
+    // use the same frame
+    testBasicLayout();
+}
+
+void tst_QGraphicsAnchorLayout1::testMixedSpacing()
+{
+    // use the same frame
+    testBasicLayout();
+}
+
+void tst_QGraphicsAnchorLayout1::testMulti()
+{
+    // use the same frame
+    testBasicLayout();
+}
+
+void tst_QGraphicsAnchorLayout1::testCenterAnchors_data()
+{
+    QTest::addColumn<QSizeF>("size");
+    QTest::addColumn<BasicLayoutTestDataList>("data");
+    QTest::addColumn<BasicLayoutTestResultList>("result");
+
+    typedef BasicLayoutTestData BasicData;
+    typedef BasicLayoutTestResult BasicResult;
+
+    // Basic center case
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, -10)
+            << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 15)
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorVerticalCenter, 10)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5);
+
+        theResult
+            << BasicResult(0, QRectF(5, 5, 10, 10) );
+
+        QTest::newRow("center, basic") << QSizeF(20, 20) << theData << theResult;
+    }
+
+    // Basic center case, with invalid (shouldn't affect on result)
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, -10)
+            << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 15)
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorVerticalCenter, 10)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
+
+            // bogus definitions
+            << BasicData(0, Qt::AnchorHorizontalCenter, -1, Qt::AnchorBottom, 5)
+            << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorVerticalCenter, 5)
+            << BasicData(0, Qt::AnchorVerticalCenter, -1, Qt::AnchorRight, 5)
+            << BasicData(0, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 666)
+            << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 999)
+            << BasicData(0, Qt::AnchorLeft, 0, Qt::AnchorLeft, 333)
+            << BasicData(-1, Qt::AnchorRight, -1, Qt::AnchorRight, 222)
+            << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorTop, 111)
+            << BasicData(0, Qt::AnchorBottom, 0, Qt::AnchorBottom, 444);
+
+        theResult
+            << BasicResult(0, QRectF(5, 5, 10, 10) );
+
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor edges of different orientations");
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor edges of different orientations");
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor edges of different orientations");
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+        QTest::newRow("center, basic with invalid") << QSizeF(20, 20) << theData << theResult;
+    }
+
+    // Basic center case 2
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 0)
+            // Not supported << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 5)
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 5)
+            << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 0)
+            << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorTop, -5);
+
+        theResult
+            << BasicResult(0, QRectF(5, 5, 10, 10) );
+
+        QTest::newRow("center, basic 2") << QSizeF(20, 20) << theData << theResult;
+    }
+
+    // Basic center case, overrides
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 10)
+            << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 20)
+            << BasicData(0, Qt::AnchorHorizontalCenter, -1, Qt::AnchorHorizontalCenter, 30)
+            << BasicData(0, Qt::AnchorVerticalCenter, -1, Qt::AnchorVerticalCenter, 40)
+            // actual data:
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 0)
+            << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 0)
+            // << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 5)
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 5)
+            << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorTop, -5);
+
+        theResult
+            << BasicResult(0, QRectF(5, 5, 10, 10) );
+
+        QTest::newRow("center, overrides") << QSizeF(20, 20) << theData << theResult;
+    }
+
+    // Two nested
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorLeft, 0)
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
+            << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 0)
+            << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorRight, 0)
+            << BasicData(0, Qt::AnchorVerticalCenter, 1, Qt::AnchorTop, 0)
+            << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, 0)
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 0)
+            << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorBottom, 0);
+
+        theResult
+            << BasicResult(0, QRectF(20, 0, 20, 40))
+            << BasicResult(1, QRectF(20, 20, 20, 20));
+
+        QTest::newRow("center, two nested") << QSizeF(40, 40) << theData << theResult;
+    }
+
+    // Two overlap
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        // theData
+        //     // horizontal
+        //     << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 20)
+        //     << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorLeft, 0)
+        //     << BasicData(1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, -5)
+        //     << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+        //     << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, 10)
+        //     // vertical is pretty much same as horizontal, just roles swapped
+        //     << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 20)
+        //     << BasicData(1, Qt::AnchorVerticalCenter, 0, Qt::AnchorTop, 0)
+        //     << BasicData(0, Qt::AnchorVerticalCenter, 1, Qt::AnchorBottom, -5)
+        //     << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 10)
+        //     << BasicData(1, Qt::AnchorVerticalCenter, 1, Qt::AnchorBottom, 10);
+
+        theData
+            // horizontal
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 20)
+            << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorLeft, 0)
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorHorizontalCenter, 5)
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorRight, 20)
+            // vertical
+            << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 20)
+            << BasicData(1, Qt::AnchorVerticalCenter, 0, Qt::AnchorTop, 0)
+            << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorVerticalCenter, 5)
+            << BasicData(1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 20);
+
+        theResult
+            << BasicResult(0, QRectF(20, 30, 20, 30))
+            << BasicResult(1, QRectF(30, 20, 30, 20));
+
+        QTest::newRow("center, two overlap") << QSizeF(70, 70) << theData << theResult;
+    }
+
+    // Three
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 0)
+            << BasicData(0, Qt::AnchorHorizontalCenter, 2, Qt::AnchorHorizontalCenter, 75)
+            << BasicData(1, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
+            << BasicData(1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, -30)
+            << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 0)
+            << BasicData(1, Qt::AnchorLeft, 1, Qt::AnchorRight, 30)
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
+
+            << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
+            << BasicData(1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 35)
+            << BasicData(1, Qt::AnchorVerticalCenter, 2, Qt::AnchorVerticalCenter, 15)
+            << BasicData(1, Qt::AnchorBottom, 2, Qt::AnchorTop, 5)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 0)
+            << BasicData(2, Qt::AnchorBottom, 0, Qt::AnchorTop, 5)
+            << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorBottom, 20);
+
+        theResult
+            << BasicResult(0, QRectF(0, 30, 10, 20))
+            << BasicResult(1, QRectF(20, 0, 30, 10))
+            << BasicResult(2, QRectF(60, 15, 40, 10));
+
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+
+        QTest::newRow("center, three") << QSizeF(100, 50) << theData << theResult;
+    }
+
+    // Two, parent center
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            // vertical is pretty much same as horizontal, just roles swapped
+            << BasicData(-1, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, -15)
+            << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 10)
+            << BasicData(-1, Qt::AnchorBottom, 0, Qt::AnchorBottom, 0)
+            << BasicData(1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
+            // horizontal
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, -15)
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 10)
+            << BasicData(-1, Qt::AnchorRight, 1, Qt::AnchorRight, 0)
+            << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorLeft, 0);
+
+        theResult
+            << BasicResult(0, QRectF(20, 20, 30, 80))
+            << BasicResult(1, QRectF(20, 20, 80, 30));
+
+        QTest::newRow("center, parent") << QSizeF(100, 100) << theData << theResult;
+    }
+
+    // Two, parent center 2
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            // << BasicData(1, Qt::AnchorLeft, -1, Qt::AnchorHorizontalCenter, 15)
+            << BasicData(1, Qt::AnchorLeft, -1, Qt::AnchorHorizontalCenter, -15)
+            << BasicData(1, Qt::AnchorRight, 0, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, -1, Qt::AnchorRight, 5)
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorRight, -5)
+            // vertical
+            << BasicData(0, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 20)
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 10)
+            << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorBottom, 20)
+            << BasicData(0, Qt::AnchorTop, 1, Qt::AnchorTop, 20)
+            << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorTop, 10);
+
+        theResult
+            << BasicResult(0, QRectF(30, 10, 15, 10))
+            << BasicResult(1, QRectF(10, 30, 10, 10));
+
+        QTest::newRow("center, parent 2") << QSizeF(50, 50) << theData << theResult;
+    }
+
+    // Two, parent center 3
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorRight, -5)
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorLeft, 5)
+            // << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorRight, 100)
+            << BasicData(0, Qt::AnchorLeft, 1, Qt::AnchorRight, -100)
+            << BasicData(0, Qt::AnchorLeft, -1, Qt::AnchorLeft, 0)
+
+            // vertical
+            << BasicData(0, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 55)
+            << BasicData(0, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
+            << BasicData(1, Qt::AnchorBottom, -1, Qt::AnchorBottom, 0)
+            << BasicData(0, Qt::AnchorBottom, 1, Qt::AnchorTop, 10)
+            // << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorBottom, 45)
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorBottom, 45)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(0, 0, 45, 45))
+            << BasicResult(1, QRectF(55, 55, 45, 45));
+
+        QTest::newRow("center, parent 3") << QSizeF(100, 100) << theData << theResult;
+    }
+
+}
+
+void tst_QGraphicsAnchorLayout1::testCenterAnchors()
+{
+    // use the same frame
+    testBasicLayout();
+}
+
+void tst_QGraphicsAnchorLayout1::testRemoveCenterAnchor_data()
+{
+    QTest::addColumn<QSizeF>("size");
+    QTest::addColumn<BasicLayoutTestDataList>("data");
+    QTest::addColumn<BasicLayoutTestDataList>("removeData");
+    QTest::addColumn<BasicLayoutTestResultList>("result");
+
+    typedef BasicLayoutTestData BasicData;
+    typedef BasicLayoutTestResult BasicResult;
+
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestDataList theRemoveData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, -10)
+            << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 15)
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorVerticalCenter, 10)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
+
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 66)
+            << BasicData(1, Qt::AnchorVerticalCenter, -1, Qt::AnchorVerticalCenter, 99)
+            << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 33)
+            ;
+
+        theRemoveData
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 0)
+            << BasicData(1, Qt::AnchorVerticalCenter, -1, Qt::AnchorVerticalCenter, 0)
+            << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 0);
+
+        theResult
+            << BasicResult(0, QRectF(5, 5, 10, 10) );
+
+        QTest::newRow("remove, center, basic") << QSizeF(20, 20) << theData
+            << theRemoveData << theResult;
+    }
+
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestDataList theRemoveData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 0)
+            << BasicData(0, Qt::AnchorHorizontalCenter, 2, Qt::AnchorHorizontalCenter, 75)
+            << BasicData(1, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
+            << BasicData(1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, -30)
+            << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 0)
+            << BasicData(1, Qt::AnchorLeft, 1, Qt::AnchorRight, 30)
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
+
+            // extra:
+            << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 66)
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 33)
+            << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 55)
+            << BasicData(1, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 55)
+
+            << BasicData(1, Qt::AnchorTop, -1, Qt::AnchorTop, 0)
+            << BasicData(1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 35)
+            << BasicData(1, Qt::AnchorVerticalCenter, 2, Qt::AnchorVerticalCenter, 15)
+            << BasicData(1, Qt::AnchorBottom, 2, Qt::AnchorTop, 5)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 0)
+            << BasicData(2, Qt::AnchorBottom, 0, Qt::AnchorTop, 5)
+            << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorBottom, 20);
+
+        theRemoveData
+            << BasicData(-1, Qt::AnchorVerticalCenter, 0, Qt::AnchorVerticalCenter, 66)
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 33)
+            << BasicData(0, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 55)
+            << BasicData(1, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 55);
+
+        theResult
+            << BasicResult(0, QRectF(0, 30, 10, 20))
+            << BasicResult(1, QRectF(20, 0, 30, 10))
+            << BasicResult(2, QRectF(60, 15, 40, 10));
+
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+
+        QTest::newRow("remove, center, three") << QSizeF(100, 50) << theData << theRemoveData << theResult;
+    }
+
+    // add edge (item0,edge0,item1,edge1), remove (item1,edge1,item0,edge0)
+    {
+        BasicLayoutTestDataList theData;
+        BasicLayoutTestDataList theRemoveData;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            // << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, -10)
+            << BasicData(-1, Qt::AnchorRight, 0, Qt::AnchorHorizontalCenter, 10)
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorRight, 15)
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorVerticalCenter, 10)
+            << BasicData(0, Qt::AnchorBottom, -1, Qt::AnchorBottom, 5)
+
+            << BasicData(-1, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 66)
+            << BasicData(1, Qt::AnchorVerticalCenter, -1, Qt::AnchorVerticalCenter, 99)
+            << BasicData(0, Qt::AnchorHorizontalCenter, 1, Qt::AnchorHorizontalCenter, 33)
+            << BasicData(0, Qt::AnchorLeft, 0, Qt::AnchorRight, 22)
+            << BasicData(0, Qt::AnchorTop, 0, Qt::AnchorBottom, 11)
+            ;
+
+        theRemoveData
+            << BasicData(1, Qt::AnchorHorizontalCenter, -1, Qt::AnchorHorizontalCenter, 0)
+            << BasicData(-1, Qt::AnchorVerticalCenter, 1, Qt::AnchorVerticalCenter, 0)
+            << BasicData(1, Qt::AnchorHorizontalCenter, 0, Qt::AnchorHorizontalCenter, 0)
+            << BasicData(0, Qt::AnchorRight, 0, Qt::AnchorLeft, 0)
+            << BasicData(0, Qt::AnchorBottom, 0, Qt::AnchorTop, 0)
+            ;
+
+        theResult
+            << BasicResult(0, QRectF(5, 5, 10, 10) );
+
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
+        QTest::newRow("remove, center, basic 2") << QSizeF(20, 20) << theData
+            << theRemoveData << theResult;
+    }
+
+}
+
+void tst_QGraphicsAnchorLayout1::testRemoveCenterAnchor()
+{
+    QFETCH(QSizeF, size);
+    QFETCH(BasicLayoutTestDataList, data);
+    QFETCH(BasicLayoutTestDataList, removeData);
+    QFETCH(BasicLayoutTestResultList, result);
+
+    QGraphicsWidget *widget = new QGraphicsWidget;
+
+    // Determine amount of widgets to add.
+    int widgetCount = -1;
+    for (int i = 0; i < data.count(); ++i) {
+        const BasicLayoutTestData item = data[i];
+        widgetCount = qMax(widgetCount, item.firstIndex);
+        widgetCount = qMax(widgetCount, item.secondIndex);
+    }
+    ++widgetCount; // widgetCount is max of indices.
+
+    // Create dummy widgets
+    QList<QGraphicsWidget *> widgets;
+    for (int i = 0; i < widgetCount; ++i) {
+        TestWidget *w = new TestWidget;
+        widgets << w;
+    }
+
+    // Setup anchor layout
+    TheAnchorLayout *layout = new TheAnchorLayout;
+
+    for (int i = 0; i < data.count(); ++i) {
+        const BasicLayoutTestData item = data[i];
+        layout->setAnchor(
+            getItem(item.firstIndex, widgets, layout),
+            item.firstEdge,
+            getItem(item.secondIndex, widgets, layout),
+            item.secondEdge,
+            item.spacing );
+    }
+
+    for (int i = 0; i < removeData.count(); ++i) {
+        const BasicLayoutTestData item = removeData[i];
+        layout->removeAnchor(
+            getItem(item.firstIndex, widgets, layout),
+            item.firstEdge,
+            getItem(item.secondIndex, widgets, layout),
+            item.secondEdge);
+    }
+
+    widget->setLayout(layout);
+    widget->setContentsMargins(0,0,0,0);
+
+    widget->resize(size);
+    QCOMPARE(widget->size(), size);
+
+    // Validate
+    for (int i = 0; i < result.count(); ++i) {
+        const BasicLayoutTestResult item = result[i];
+
+        QCOMPARE(widgets[item.index]->geometry(), item.rect);
+    }
+
+    qDeleteAll(widgets);
+    delete widget;
+}
+
+void tst_QGraphicsAnchorLayout1::testSingleSizePolicy_data()
+{
+    QTest::addColumn<QSizeF>("size");
+    QTest::addColumn<QSizePolicy>("policy");
+    QTest::addColumn<bool>("valid");
+
+// FIXED
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed );
+        QTest::newRow("single size policy: fixed ok") << QSizeF(70, 70) << sizePolicy << true;
+    }
+/*
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed );
+        QTest::newRow("single size policy: fixed too big") << QSizeF(100, 100) << sizePolicy << false;
+    }
+
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed );
+        QTest::newRow("single size policy: fixed too small") << QSizeF(50, 50) << sizePolicy << false;
+    }
+*/
+// MINIMUM
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
+        QTest::newRow("single size policy: minimum bigger ok") << QSizeF(100, 100) << sizePolicy << true;
+    }
+
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
+        QTest::newRow("single size policy: minimum limit ok") << QSizeF(70, 70) << sizePolicy << true;
+    }
+/*
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
+        QTest::newRow("single size policy: minimum too small") << QSizeF(50, 50) << sizePolicy << false;
+    }
+*/
+// MAXIMUM
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Maximum, QSizePolicy::Maximum );
+        QTest::newRow("single size policy: maximum small ok") << QSizeF(50, 50) << sizePolicy << true;
+    }
+
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Maximum, QSizePolicy::Maximum );
+        QTest::newRow("single size policy: maximum limit ok") << QSizeF(70, 70) << sizePolicy << true;
+    }
+/*
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Maximum, QSizePolicy::Maximum );
+        QTest::newRow("single size policy: maximum bigger fail") << QSizeF(100, 100) << sizePolicy << false;
+    }
+*/
+// PREFERRED
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred );
+        QTest::newRow("single size policy: preferred bigger ok") << QSizeF(100, 100) << sizePolicy << true;
+    }
+
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred );
+        QTest::newRow("single size policy: preferred smaller ok") << QSizeF(50, 50)  << sizePolicy << true;
+    }
+/*
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred );
+        QTest::newRow("single size policy: preferred too big") << QSizeF(700, 700) << sizePolicy << false;
+    }
+
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred );
+        QTest::newRow("single size policy: preferred too small") << QSizeF(21, 21) << sizePolicy << false;
+    }
+*/
+// MINIMUMEXPANDING
+
+    {
+        QSizePolicy sizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
+        QTest::newRow("single size policy: min.expanding bigger ok") << QSizeF(100, 100) << sizePolicy << true;
+    }
+
+    {
+        QSizePolicy sizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
+        QTest::newRow("single size policy: min.expanding limit ok") << QSizeF(70, 70) << sizePolicy << true;
+    }
+
+    /*{
+        QSizePolicy sizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
+        QTest::newRow("single size policy: min.expanding too small") << QSizeF(50, 50) << sizePolicy << false;
+    }*/
+
+// EXPANDING
+
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
+        QTest::newRow("single size policy: expanding bigger ok") << QSizeF(100, 100) << sizePolicy << true;
+    }
+
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
+        QTest::newRow("single size policy: expanding smaller ok") << QSizeF(50, 50)  << sizePolicy << true;
+    }
+
+ // IGNORED
+
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Ignored, QSizePolicy::Ignored );
+        QTest::newRow("single size policy: ignored bigger ok") << QSizeF(100, 100) << sizePolicy << true;
+    }
+
+    {
+        QSizePolicy sizePolicy( QSizePolicy::Ignored, QSizePolicy::Ignored );
+        QTest::newRow("single size policy: ignored smaller ok") << QSizeF(50, 50)  << sizePolicy << true;
+    }
+}
+
+void tst_QGraphicsAnchorLayout1::testSingleSizePolicy()
+{
+    QFETCH(QSizeF, size);
+    QFETCH(QSizePolicy, policy);
+    QFETCH(bool, valid);
+
+    // create objects
+    QGraphicsWidget widget;
+    TheAnchorLayout *layout = new TheAnchorLayout;
+    TestWidget *childWidget = new TestWidget;
+
+    // set anchors
+    layout->setAnchor( layout, Qt::AnchorLeft, childWidget, Qt::AnchorLeft, 10 );
+    layout->setAnchor( childWidget, Qt::AnchorRight, layout, Qt::AnchorRight, 10 );
+    layout->setAnchor( layout, Qt::AnchorTop, childWidget, Qt::AnchorTop, 10 );
+    layout->setAnchor( childWidget, Qt::AnchorBottom, layout, Qt::AnchorBottom, 10 );
+
+    widget.setLayout( layout );
+
+    // set test case specific: policy and size
+    childWidget->setSizePolicy( policy );
+    widget.setGeometry( QRectF( QPoint(0,0), size ) );
+
+    QCOMPARE( layout->isValid() , valid );
+
+    const QRectF childRect = childWidget->geometry();
+    Q_UNUSED( childRect );
+}
+
+void tst_QGraphicsAnchorLayout1::testDoubleSizePolicy_data()
+{
+    // tests only horizontal direction
+    QTest::addColumn<QSizePolicy>("policy1");
+    QTest::addColumn<QSizePolicy>("policy2");
+    QTest::addColumn<qreal>("width1");
+    QTest::addColumn<qreal>("width2");
+
+    // layout size always 100x100 and size hints for items are 5<50<500
+    // gabs: 10-item1-10-item2-10
+
+    {
+        QSizePolicy sizePolicy1( QSizePolicy::Fixed, QSizePolicy::Fixed );
+        QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
+        const qreal width1 = 50;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("double size policy: fixed-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
+    }
+
+    {
+        QSizePolicy sizePolicy1( QSizePolicy::Minimum, QSizePolicy::Minimum );
+        QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
+        const qreal width1 = 50;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("double size policy: minimum-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
+    }
+
+    {
+        QSizePolicy sizePolicy1( QSizePolicy::Maximum, QSizePolicy::Maximum );
+        QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
+        const qreal width1 = 35;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("double size policy: maximum-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
+    }
+
+    {
+        QSizePolicy sizePolicy1( QSizePolicy::Preferred, QSizePolicy::Preferred );
+        QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
+        const qreal width1 = 35;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("double size policy: preferred-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
+    }
+
+    {
+        QSizePolicy sizePolicy1( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
+        QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
+        const qreal width1 = 50;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("double size policy: min.expanding-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
+    }
+
+    {
+        QSizePolicy sizePolicy1( QSizePolicy::Expanding, QSizePolicy::Expanding );
+        QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
+        const qreal width1 = 35;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("double size policy: expanding-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
+    }
+
+    // QGAL handling of ignored flag is different
+    if (0)
+    {
+        QSizePolicy sizePolicy1( QSizePolicy::Ignored, QSizePolicy::Ignored );
+        QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
+        const qreal width1 = 35;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("double size policy: ignored-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
+    }
+
+    /*{
+        QSizePolicy sizePolicy1( QSizePolicy::Fixed, QSizePolicy::Fixed );
+        QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
+        const qreal width1 = -1;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("double size policy: fixed-fixed invalid") << sizePolicy1 << sizePolicy2 << width1 << width2;
+    }*/
+
+    /*{
+        QSizePolicy sizePolicy1( QSizePolicy::Minimum, QSizePolicy::Minimum );
+        QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
+        const qreal width1 = -1;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("double size policy: minimum-fixed invalid") << sizePolicy1 << sizePolicy2 << width1 << width2;
+    }*/
+
+    {
+        QSizePolicy sizePolicy1( QSizePolicy::Maximum, QSizePolicy::Maximum );
+        QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
+        const qreal width1 = 20;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("double size policy: maximum-fixed") << sizePolicy1 << sizePolicy2 << width1 << width2;
+    }
+
+    {
+        QSizePolicy sizePolicy1( QSizePolicy::Preferred, QSizePolicy::Preferred );
+        QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
+        const qreal width1 = 20;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("double size policy: preferred-fixed") << sizePolicy1 << sizePolicy2 << width1 << width2;
+    }
+
+    /*{
+        QSizePolicy sizePolicy1( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
+        QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
+        const qreal width1 = -1;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("double size policy: min.expanding-fixed invalid") << sizePolicy1 << sizePolicy2 << width1 << width2;
+    }*/
+
+    {
+        QSizePolicy sizePolicy1( QSizePolicy::Expanding, QSizePolicy::Expanding );
+        QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
+        const qreal width1 = 20;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("double size policy: expanding-fixed") << sizePolicy1 << sizePolicy2 << width1 << width2;
+    }
+
+    {
+        QSizePolicy sizePolicy1( QSizePolicy::Ignored, QSizePolicy::Ignored );
+        QSizePolicy sizePolicy2( QSizePolicy::Fixed, QSizePolicy::Fixed );
+        const qreal width1 = 20;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("double size policy: ignored-fixed") << sizePolicy1 << sizePolicy2 << width1 << width2;
+    }
+}
+
+void tst_QGraphicsAnchorLayout1::testDoubleSizePolicy()
+{
+    QFETCH(QSizePolicy, policy1);
+    QFETCH(QSizePolicy, policy2);
+    QFETCH(qreal, width1);
+    QFETCH(qreal, width2);
+
+    // create objects
+    QGraphicsWidget widget;
+    TheAnchorLayout *layout = new TheAnchorLayout;
+    TestWidget *childWidget1 = new TestWidget;
+    TestWidget *childWidget2 = new TestWidget;
+
+    // set anchors
+    layout->setAnchor( layout, Qt::AnchorLeft, childWidget1, Qt::AnchorLeft, 10 );
+    layout->setAnchor( childWidget1, Qt::AnchorRight, childWidget2, Qt::AnchorLeft, 10 );
+    layout->setAnchor( childWidget2, Qt::AnchorRight, layout, Qt::AnchorRight, 10 );
+
+    widget.setLayout( layout );
+
+    // set test case specific: policy
+    childWidget1->setSizePolicy( policy1 );
+    childWidget2->setSizePolicy( policy2 );
+
+    widget.setGeometry( QRectF( QPoint(0,0), QSize( 100,100 ) ) );
+
+    // check results:
+    if ( width1 == -1.0f ) {
+        // invalid
+        QCOMPARE( layout->isValid() , false );
+    } else {
+        // valid
+        QCOMPARE( childWidget1->geometry().width(), width1 );
+        QCOMPARE( childWidget2->geometry().width(), width2 );
+    }
+}
+
+typedef QMap<int,qreal> SizeHintArray;
+Q_DECLARE_METATYPE(SizeHintArray)
+
+void tst_QGraphicsAnchorLayout1::testSizeDistribution_data()
+{
+    // tests only horizontal direction
+    QTest::addColumn<SizeHintArray>("sizeHints1");
+    QTest::addColumn<SizeHintArray>("sizeHints2");
+    QTest::addColumn<qreal>("width1");
+    QTest::addColumn<qreal>("width2");
+
+    // layout size always 100x100 and size policy for items is preferred-preferred
+    // gabs: 10-item1-10-item2-10
+
+    {
+        SizeHintArray sizeHints1;
+        sizeHints1.insert( Qt::MinimumSize, 30 );
+        sizeHints1.insert( Qt::PreferredSize, 35 );
+        sizeHints1.insert( Qt::MaximumSize, 40 );
+
+        SizeHintArray sizeHints2;
+        sizeHints2.insert( Qt::MinimumSize, 5 );
+        sizeHints2.insert( Qt::PreferredSize, 35 );
+        sizeHints2.insert( Qt::MaximumSize, 300 );
+
+        const qreal width1 = 35;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("size distribution: preferred equal") << sizeHints1 << sizeHints2 << width1 << width2;
+    }
+
+    {
+        SizeHintArray sizeHints1;
+        sizeHints1.insert( Qt::MinimumSize, 0 );
+        sizeHints1.insert( Qt::PreferredSize, 20 );
+        sizeHints1.insert( Qt::MaximumSize, 100 );
+
+        SizeHintArray sizeHints2;
+        sizeHints2.insert( Qt::MinimumSize, 0 );
+        sizeHints2.insert( Qt::PreferredSize, 50 );
+        sizeHints2.insert( Qt::MaximumSize, 100 );
+
+        const qreal width1 = 20;
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("size distribution: preferred non-equal") << sizeHints1 << sizeHints2 << width1 << width2;
+    }
+
+    {
+        SizeHintArray sizeHints1;
+        sizeHints1.insert( Qt::MinimumSize, 0 );
+        sizeHints1.insert( Qt::PreferredSize, 40 );
+        sizeHints1.insert( Qt::MaximumSize, 100 );
+
+        SizeHintArray sizeHints2;
+        sizeHints2.insert( Qt::MinimumSize, 0 );
+        sizeHints2.insert( Qt::PreferredSize, 60 );
+        sizeHints2.insert( Qt::MaximumSize, 100 );
+
+        const qreal width1 = 28; // got from manual calculation
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("size distribution: below preferred") << sizeHints1 << sizeHints2 << width1 << width2;
+    }
+
+    {
+        SizeHintArray sizeHints1;
+        sizeHints1.insert( Qt::MinimumSize, 0 );
+        sizeHints1.insert( Qt::PreferredSize, 10 );
+        sizeHints1.insert( Qt::MaximumSize, 100 );
+
+        SizeHintArray sizeHints2;
+        sizeHints2.insert( Qt::MinimumSize, 0 );
+        sizeHints2.insert( Qt::PreferredSize, 40 );
+        sizeHints2.insert( Qt::MaximumSize, 100 );
+
+        const qreal width1 = 22; // got from manual calculation
+        const qreal width2 = 100-10-10-10-width1;
+        QTest::newRow("size distribution: above preferred") << sizeHints1 << sizeHints2 << width1 << width2;
+    }
+
+}
+
+void tst_QGraphicsAnchorLayout1::testSizeDistribution()
+{
+    QFETCH(SizeHintArray, sizeHints1);
+    QFETCH(SizeHintArray, sizeHints2);
+    QFETCH(qreal, width1);
+    QFETCH(qreal, width2);
+
+    // sanity-check the test data - MinimumSize <= PreferredSize <= MaximumSize
+    QVERIFY( sizeHints1.value( Qt::MinimumSize ) <= sizeHints1.value( Qt::PreferredSize ) );
+    QVERIFY( sizeHints1.value( Qt::PreferredSize ) <= sizeHints1.value( Qt::MaximumSize ) );
+    QVERIFY( sizeHints2.value( Qt::MinimumSize ) <= sizeHints2.value( Qt::PreferredSize ) );
+    QVERIFY( sizeHints2.value( Qt::PreferredSize ) <= sizeHints2.value( Qt::MaximumSize ) );
+
+    // create objects
+    QGraphicsWidget widget;
+    TheAnchorLayout *layout = new TheAnchorLayout;
+    TestWidget *childWidget1 = new TestWidget;
+    TestWidget *childWidget2 = new TestWidget;
+
+    // set anchors
+    layout->setAnchor( layout, Qt::AnchorLeft, childWidget1, Qt::AnchorLeft, 10 );
+    layout->setAnchor( childWidget1, Qt::AnchorRight, childWidget2, Qt::AnchorLeft, 10 );
+    layout->setAnchor( childWidget2, Qt::AnchorRight, layout, Qt::AnchorRight, 10 );
+
+    widget.setLayout( layout );
+
+    // set test case specific: size hints
+    childWidget1->setMinimumWidth( sizeHints1.value( Qt::MinimumSize ) );
+    childWidget1->setPreferredWidth( sizeHints1.value( Qt::PreferredSize ) );
+    childWidget1->setMaximumWidth( sizeHints1.value( Qt::MaximumSize ) );
+
+    childWidget2->setMinimumWidth( sizeHints2.value( Qt::MinimumSize ) );
+    childWidget2->setPreferredWidth( sizeHints2.value( Qt::PreferredSize ) );
+    childWidget2->setMaximumWidth( sizeHints2.value( Qt::MaximumSize ) );
+
+    widget.setGeometry( QRectF( QPoint(0,0), QSize( 100,100 ) ) );
+
+    // check results:
+    if ( width1 == -1.0f ) {
+        // invalid
+        QCOMPARE( layout->isValid() , false );
+    } else {
+        // valid
+        QCOMPARE( float(childWidget1->geometry().width()), float(width1) );
+        QCOMPARE( float(childWidget2->geometry().width()), float(width2) );
+    }
+}
+
+void tst_QGraphicsAnchorLayout1::testSizeHint()
+{
+    QGraphicsWidget *widget[5];
+
+    for( int i = 0; i < 5; i++ ) {
+        widget[i] = new QGraphicsWidget;
+        widget[i]->setMinimumSize( 10, 10 );
+        widget[i]->setPreferredSize( 20, 20 );
+        widget[i]->setMaximumSize( 40, 40 );
+    }
+
+    // one, basic
+    {
+        TheAnchorLayout *layout = new TheAnchorLayout();
+
+
+        layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 0 );
+        layout->setAnchor(layout, Qt::AnchorRight, widget[0], Qt::AnchorRight, 0 );
+
+        layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 0 );
+        layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 0 );
+
+        QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() );
+        QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() );
+        QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() );
+
+
+        delete layout;
+    }
+
+    // one, basic again
+    {
+        TheAnchorLayout *layout = new TheAnchorLayout();
+
+
+        layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 10 );
+        // layout->setAnchor(layout, Qt::AnchorRight, widget[0], Qt::AnchorRight, -10 );
+        layout->setAnchor(layout, Qt::AnchorRight, widget[0], Qt::AnchorRight, 10 );
+
+        layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 10 );
+        // layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, -10 );
+        layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 10 );
+
+        QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() + QSizeF( 20, 20 ) );
+        QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() + QSizeF( 20, 20 ) );
+        QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() + QSizeF( 20, 20 ) );
+
+        delete layout;
+    }
+
+    // two, serial
+    {
+        TheAnchorLayout *layout = new TheAnchorLayout();
+
+
+        layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 0 );
+        layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 0 );
+        layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 0 );
+
+        layout->setAnchor(widget[0], Qt::AnchorRight, widget[1], Qt::AnchorLeft, 0 );
+        layout->setAnchor(widget[1], Qt::AnchorRight, layout, Qt::AnchorRight, 0 );
+
+
+        QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() + QSizeF( widget[1]->minimumWidth(), 0 ) );
+        QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() + QSizeF( widget[1]->preferredWidth(), 0 ) );
+        QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() + QSizeF( widget[1]->maximumWidth(), 0 ) );
+
+        delete layout;
+    }
+
+    // two, parallel
+    {
+        TheAnchorLayout *layout = new TheAnchorLayout();
+
+
+        layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 0 );
+        layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 0 );
+        layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 0 );
+        layout->setAnchor(layout, Qt::AnchorRight, widget[0], Qt::AnchorRight, 0 );
+
+        layout->setAnchor(layout, Qt::AnchorLeft, widget[1], Qt::AnchorLeft, 0 );
+        layout->setAnchor(layout, Qt::AnchorTop, widget[1], Qt::AnchorTop, 0 );
+        layout->setAnchor(layout, Qt::AnchorBottom, widget[1], Qt::AnchorBottom, 0 );
+        layout->setAnchor(layout, Qt::AnchorRight, widget[1], Qt::AnchorRight, 0 );
+
+        QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() );
+        QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() );
+        QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() );
+
+        delete layout;
+    }
+
+    // five, serial
+    {
+        TheAnchorLayout *layout = new TheAnchorLayout();
+
+
+        layout->setAnchor(layout, Qt::AnchorLeft, widget[0], Qt::AnchorLeft, 0 );
+        layout->setAnchor(layout, Qt::AnchorTop, widget[0], Qt::AnchorTop, 0 );
+        layout->setAnchor(layout, Qt::AnchorBottom, widget[0], Qt::AnchorBottom, 0 );
+
+        layout->setAnchor(widget[0], Qt::AnchorRight, widget[1], Qt::AnchorLeft, 0 );
+        layout->setAnchor(widget[1], Qt::AnchorRight, widget[2], Qt::AnchorLeft, 0 );
+        layout->setAnchor(widget[2], Qt::AnchorRight, widget[3], Qt::AnchorLeft, 0 );
+        layout->setAnchor(widget[3], Qt::AnchorRight, widget[4], Qt::AnchorLeft, 0 );
+        layout->setAnchor(widget[4], Qt::AnchorRight, layout, Qt::AnchorRight, 0 );
+
+
+        QCOMPARE( layout->minimumSize(), widget[0]->minimumSize() +
+        QSizeF( widget[1]->minimumWidth() +
+        widget[2]->minimumWidth() +
+        widget[3]->minimumWidth() +
+        widget[4]->minimumWidth(), 0 ) );
+
+        QCOMPARE( layout->preferredSize(), widget[0]->preferredSize() +
+        QSizeF( widget[1]->preferredWidth() +
+        widget[2]->preferredWidth() +
+        widget[3]->preferredWidth() +
+        widget[4]->preferredWidth(), 0 ) );
+
+        QCOMPARE( layout->maximumSize(), widget[0]->maximumSize() +
+        QSizeF( widget[1]->maximumWidth() +
+        widget[2]->maximumWidth() +
+        widget[3]->maximumWidth() +
+        widget[4]->maximumWidth(), 0 ) );
+
+        delete layout;
+    }
+
+
+    for( int i = 0; i < 5; i++ ) {
+        delete widget[i];
+    }
+}
+
+#ifdef TEST_COMPLEX_CASES
+
+void tst_QGraphicsAnchorLayout1::testComplexCases_data()
+{
+    QTest::addColumn<QSizeF>("size");
+    QTest::addColumn<BasicLayoutTestDataList>("data");
+    QTest::addColumn<AnchorItemSizeHintList>("sizehint");
+    QTest::addColumn<BasicLayoutTestResultList>("result");
+
+    typedef BasicLayoutTestData BasicData;
+    typedef BasicLayoutTestResult BasicResult;
+
+    // Three widgets, the same sizehint
+    {
+        BasicLayoutTestDataList theData;
+        AnchorItemSizeHintList theSizeHint;
+        BasicLayoutTestResultList theResult1;
+        BasicLayoutTestResultList theResult2;
+
+        theData
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
+
+            << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+            << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
+            << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
+            << BasicData(-1, Qt::AnchorTop, 2, Qt::AnchorTop, 0)
+         ;
+
+        theSizeHint
+            << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+            << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+            << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+         ;
+        theResult1
+            << BasicResult(0, QRectF(10, 0, 30, 50) )
+            << BasicResult(1, QRectF(50, 0, 30, 50) )
+            << BasicResult(2, QRectF(50, 0, 30, 50) )
+            ;
+
+        theResult2
+            << BasicResult(0, QRectF(10, 0, 60, 50) )
+            << BasicResult(1, QRectF(80, 0, 60, 50) )
+            << BasicResult(2, QRectF(80, 0, 60, 50) )
+            ;
+
+        QTest::newRow("Three, the same sizehint(1)") << QSizeF(90, 50) << theData << theSizeHint << theResult1;
+        QTest::newRow("Three, the same sizehint(2)") << QSizeF(150, 50) << theData << theSizeHint << theResult2;
+    }
+
+    // Three widgets, serial is bigger
+    {
+        BasicLayoutTestDataList theData;
+        AnchorItemSizeHintList theSizeHint;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
+
+            << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+            << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
+            << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
+            << BasicData(-1, Qt::AnchorTop, 2, Qt::AnchorTop, 0)
+         ;
+
+        theSizeHint
+            << AnchorItemSizeHint( 0, 100, 200, 0, 50, 100 )
+            << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+            << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+         ;
+
+        theResult
+            << BasicResult(0, QRectF(10, 0, 70, 50) )
+            << BasicResult(1, QRectF(90, 0, 35, 50) )
+            << BasicResult(2, QRectF(90, 0, 35, 50) );
+
+        QTest::newRow("Three, serial is bigger") << QSizeF(135, 50) << theData << theSizeHint << theResult;
+
+        // theResult
+        //     << BasicResult(0, QRectF(10, 0, 80, 50) )
+        //     << BasicResult(1, QRectF(100, 0, 60, 50) )
+        //     << BasicResult(2, QRectF(100, 0, 60, 50) )
+        // ;
+
+        // QTest::newRow("Three, serial is bigger") << QSizeF(170, 50) << theData << theSizeHint << theResult;
+    }
+
+
+    // Three widgets, parallel is bigger
+    {
+        BasicLayoutTestDataList theData;
+        AnchorItemSizeHintList theSizeHint;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, 2, Qt::AnchorLeft, 10)
+
+            << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+            << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
+            << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
+            << BasicData(-1, Qt::AnchorTop, 2, Qt::AnchorTop, 0)
+         ;
+
+        theSizeHint
+            << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+            << AnchorItemSizeHint( 0, 100, 200, 0, 50, 100 )
+            << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+         ;
+
+        // ### QGAL uses a different preferred size calculation algorithm.
+        //     This algorithm was discussed with Jan-Arve and tries to grow
+        //     items instead of shrinking them.
+        //     In this case, the preferred size of each item becomes:
+        //     Item 0: 50
+        //     Item 1: 100 (grows to avoid shrinking item 2)
+        //     Item 2: 100
+        //     Therefore, the preferred size of the parent widget becomes
+        //     180 == (10 + 50 + 10 + 100 + 10)
+        //     As we set its size to 150, each widget is shrinked in the same
+        //     ratio, in order to achieve the width of 150 == (10 + 40 + 10 + 80 + 10)
+
+        theResult
+            << BasicResult(0, QRectF(10, 0, 40, 50) )
+            << BasicResult(1, QRectF(60, 0, 80, 50) )
+            << BasicResult(2, QRectF(60, 0, 80, 50) )
+            ;
+
+        QTest::newRow("Three, parallel is bigger") << QSizeF(150, 50) << theData << theSizeHint << theResult;
+
+        // #ifdef PREFERRED_IS_AVERAGE
+        //         theResult
+        //             << BasicResult(0, QRectF(10, 0, 50, 50) )
+        //             << BasicResult(1, QRectF(70, 0, 75, 50) )
+        //             << BasicResult(2, QRectF(70, 0, 75, 50) )
+        //             ;
+
+        //         QTest::newRow("Three, parallel is bigger") << QSizeF(155, 50) << theData << theSizeHint << theResult;
+        // #else
+        //         theResult
+        //             << BasicResult(0, QRectF(10, 0, 50, 50) )
+        //             << BasicResult(1, QRectF(70, 0, 66.66666666666666, 50) )
+        //             << BasicResult(2, QRectF(70, 0, 60.66666666666666, 50) )
+        //             ;
+
+        //         QTest::newRow("Three, parallel is bigger") << QSizeF(146.66666666666666, 50) << theData << theSizeHint << theResult;
+        // #endif
+    }
+
+    // Three widgets, the same sizehint, one center anchor
+    {
+        BasicLayoutTestDataList theData;
+        AnchorItemSizeHintList theSizeHint;
+        BasicLayoutTestResultList theResult;
+
+        theData
+            << BasicData(-1, Qt::AnchorLeft, 0, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorRight, 1, Qt::AnchorLeft, 10)
+            << BasicData(0, Qt::AnchorHorizontalCenter, 2, Qt::AnchorLeft, 10)
+
+            << BasicData(1, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+            << BasicData(2, Qt::AnchorRight, -1, Qt::AnchorRight, 10)
+
+            << BasicData(-1, Qt::AnchorTop, 0, Qt::AnchorTop, 0)
+            << BasicData(-1, Qt::AnchorTop, 1, Qt::AnchorTop, 0)
+            << BasicData(-1, Qt::AnchorTop, 2, Qt::AnchorTop, 0)
+         ;
+
+        theSizeHint
+            << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+            << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+            << AnchorItemSizeHint( 0, 50, 100, 0, 50, 100 )
+         ;
+        theResult
+            << BasicResult(0, QRectF(10, 0, 40, 50) )
+            << BasicResult(1, QRectF(60, 0, 40, 50) )
+            << BasicResult(2, QRectF(40, 0, 60, 50) )
+            ;
+
+            ;
+
+        QTest::newRow("Three, the same sizehint, one center anchor") << QSizeF(110, 50) << theData << theSizeHint << theResult;
+    }
+}
+
+void tst_QGraphicsAnchorLayout1::testComplexCases()
+{
+    QFETCH(QSizeF, size);
+    QFETCH(BasicLayoutTestDataList, data);
+    QFETCH(AnchorItemSizeHintList, sizehint);
+    QFETCH(BasicLayoutTestResultList, result);
+
+    QGraphicsWidget *widget = new QGraphicsWidget;
+
+    // Determine amount of widgets to add.
+    int widgetCount = -1;
+    for (int i = 0; i < data.count(); ++i) {
+        const BasicLayoutTestData item = data[i];
+        widgetCount = qMax(widgetCount, item.firstIndex);
+        widgetCount = qMax(widgetCount, item.secondIndex);
+    }
+    ++widgetCount; // widgetCount is max of indices.
+
+    // Create dummy widgets
+    QList<QGraphicsWidget *> widgets;
+    for (int i = 0; i < widgetCount; ++i) {
+        TestWidget *w = new TestWidget;
+
+        w->setMinimumWidth( sizehint[i].hmin );
+        w->setPreferredWidth( sizehint[i].hpref );
+        w->setMaximumWidth( sizehint[i].hmax );
+
+        w->setMinimumHeight( sizehint[i].vmin );
+        w->setPreferredHeight( sizehint[i].vpref );
+        w->setMaximumHeight( sizehint[i].vmax );
+
+        widgets << w;
+    }
+
+    // Setup anchor layout
+    TheAnchorLayout *layout = new TheAnchorLayout;
+
+    for (int i = 0; i < data.count(); ++i) {
+        const BasicLayoutTestData item = data[i];
+        layout->setAnchor(
+            getItem(item.firstIndex, widgets, layout),
+            item.firstEdge,
+            getItem(item.secondIndex, widgets, layout),
+            item.secondEdge,
+            item.spacing );
+    }
+
+    widget->setLayout(layout);
+    widget->setContentsMargins(0,0,0,0);
+
+    widget->resize(size);
+    QCOMPARE(widget->size(), size);
+
+//    QTest::qWait(500); // layouting is asynchronous..
+
+    // Validate
+    for (int i = 0; i < result.count(); ++i) {
+        const BasicLayoutTestResult item = result[i];
+        QCOMPARE(widgets[item.index]->geometry(), item.rect);
+    }
+
+    // Test mirrored mode
+    widget->setLayoutDirection(Qt::RightToLeft);
+    layout->activate();
+    // Validate
+    for (int j = 0; j < result.count(); ++j) {
+        const BasicLayoutTestResult item = result[j];
+        QRectF mirroredRect(item.rect);
+        // only valid cases are mirrored
+        if (mirroredRect.isValid()){
+            mirroredRect.moveLeft(size.width()-item.rect.width()-item.rect.left());
+        }
+        QCOMPARE(widgets[item.index]->geometry(), mirroredRect);
+        delete widgets[item.index];
+    }
+
+    delete widget;
+}
+#endif //TEST_COMPLEX_CASES
+
+
+QTEST_MAIN(tst_QGraphicsAnchorLayout1)
+#include "tst_qgraphicsanchorlayout1.moc"
+//-----------------------------------------------------------------------------
+
diff --git a/tests/auto/widgets/graphicsview/qgraphicseffectsource/qgraphicseffectsource.pro b/tests/auto/widgets/graphicsview/qgraphicseffectsource/qgraphicseffectsource.pro
new file mode 100644
index 0000000000..44ec70eef3
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicseffectsource/qgraphicseffectsource.pro
@@ -0,0 +1,7 @@
+load(qttest_p4)
+
+QT += widgets widgets-private
+QT += core-private gui-private
+
+SOURCES  += tst_qgraphicseffectsource.cpp
+CONFIG += parallel_test
diff --git a/tests/auto/widgets/graphicsview/qgraphicseffectsource/tst_qgraphicseffectsource.cpp b/tests/auto/widgets/graphicsview/qgraphicseffectsource/tst_qgraphicseffectsource.cpp
new file mode 100644
index 0000000000..4f39f991c6
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicseffectsource/tst_qgraphicseffectsource.cpp
@@ -0,0 +1,422 @@
+/****************************************************************************
+**
+** 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 <QtWidgets/qgraphicseffect.h>
+#include <QtWidgets/qgraphicsview.h>
+#include <QtWidgets/qgraphicsscene.h>
+#include <QtWidgets/qgraphicsitem.h>
+#include <QtWidgets/qstyleoption.h>
+
+#include <private/qgraphicseffect_p.h>
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class CustomItem : public QGraphicsRectItem
+{
+public:
+    CustomItem(qreal x, qreal y, qreal width, qreal height)
+        : QGraphicsRectItem(x, y, width, height), numRepaints(0),
+          m_painter(0)
+    {}
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        m_painter = painter;
+        ++numRepaints;
+        QGraphicsRectItem::paint(painter, option, widget);
+    }
+
+    void reset()
+    {
+        numRepaints = 0;
+        m_painter = 0;
+    }
+
+    int numRepaints;
+    QPainter *m_painter;
+};
+
+class CustomEffect : public QGraphicsEffect
+{
+public:
+    CustomEffect()
+        : QGraphicsEffect(), numRepaints(0), m_margin(10), m_sourceChanged(false),
+          m_sourceBoundingRectChanged(false), doNothingInDraw(false),
+          storeDeviceDependentStuff(false),
+          m_painter(0), m_source(0)
+    {}
+
+    QRectF boundingRectFor(const QRectF &rect) const
+    { return rect.adjusted(-m_margin, -m_margin, m_margin, m_margin); }
+
+    void reset()
+    {
+        numRepaints = 0;
+        m_sourceChanged = false;
+        m_sourceBoundingRectChanged = false;
+        m_painter = 0;
+        m_source = 0;
+        deviceCoordinatesPixmap = QPixmap();
+        deviceRect = QRect();
+        sourceDeviceBoundingRect = QRectF();
+    }
+
+    void setMargin(int margin)
+    {
+        m_margin = margin;
+        updateBoundingRect();
+    }
+
+    int margin() const
+    { return m_margin; }
+
+    void draw(QPainter *painter)
+    {
+        ++numRepaints;
+        if (storeDeviceDependentStuff) {
+            deviceCoordinatesPixmap = source()->pixmap(Qt::DeviceCoordinates);
+            deviceRect = QRect(0, 0, painter->device()->width(), painter->device()->height());
+            sourceDeviceBoundingRect = source()->boundingRect(Qt::DeviceCoordinates);
+        }
+        if (doNothingInDraw)
+            return;
+        m_source = source();
+        m_painter = painter;
+        source()->draw(painter);
+    }
+
+    void sourceChanged()
+    { m_sourceChanged = true; }
+
+    void sourceBoundingRectChanged()
+    { m_sourceBoundingRectChanged = true; }
+
+    int numRepaints;
+    int m_margin;
+    bool m_sourceChanged;
+    bool m_sourceBoundingRectChanged;
+    bool doNothingInDraw;
+    bool storeDeviceDependentStuff;
+    QPainter *m_painter;
+    QGraphicsEffectSource *m_source;
+    QPixmap deviceCoordinatesPixmap;
+    QRect deviceRect;
+    QRectF sourceDeviceBoundingRect;
+};
+
+class tst_QGraphicsEffectSource : public QObject
+{
+    Q_OBJECT
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+
+private slots:
+    void graphicsItem();
+    void styleOption();
+    void isPixmap();
+    void draw();
+    void update();
+    void boundingRect();
+    void clippedBoundingRect();
+    void deviceRect();
+    void pixmap();
+
+    void pixmapPadding_data();
+    void pixmapPadding();
+
+private:
+    QGraphicsView *view;
+    QGraphicsScene *scene;
+    CustomItem *item;
+    CustomEffect *effect;
+};
+
+void tst_QGraphicsEffectSource::initTestCase()
+{
+    scene = new QGraphicsScene;
+    item = new CustomItem(0, 0, 100, 100);
+    effect = new CustomEffect;
+    item->setGraphicsEffect(effect);
+    scene->addItem(item);
+    view = new QGraphicsView(scene);
+    view->show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(view);
+#endif
+    QTest::qWait(200);
+}
+
+void tst_QGraphicsEffectSource::cleanupTestCase()
+{
+    delete view;
+}
+
+void tst_QGraphicsEffectSource::init()
+{
+    QVERIFY(effect);
+    QVERIFY(item);
+    QVERIFY(effect->source());
+    effect->reset();
+    effect->storeDeviceDependentStuff = false;
+    effect->doNothingInDraw = false;
+    item->reset();
+}
+
+void tst_QGraphicsEffectSource::graphicsItem()
+{
+    QVERIFY(effect->source());
+    QCOMPARE(effect->source()->graphicsItem(), (const QGraphicsItem*)item);
+}
+
+void tst_QGraphicsEffectSource::styleOption()
+{
+    // We don't have style options unless the source is drawing.
+    QVERIFY(effect->source());
+    QVERIFY(!effect->source()->styleOption());
+
+    // Trigger an update and check that the style option in QGraphicsEffect::draw
+    // was the same as the one in QGraphicsItem::paint.
+    QCOMPARE(item->numRepaints, 0);
+    QCOMPARE(effect->numRepaints, 0);
+    item->update();
+    QTRY_COMPARE(item->numRepaints, 1);
+    QTRY_COMPARE(effect->numRepaints, 1);
+}
+
+void tst_QGraphicsEffectSource::isPixmap()
+{
+    // Current source is a CustomItem (which is not a pixmap item).
+    QVERIFY(!effect->source()->isPixmap());
+
+    // Make sure isPixmap() returns true for QGraphicsPixmapItem.
+    QGraphicsPixmapItem *pixmapItem = new QGraphicsPixmapItem;
+    CustomEffect *anotherEffect = new CustomEffect;
+    pixmapItem->setGraphicsEffect(anotherEffect);
+    QVERIFY(anotherEffect->source());
+    QCOMPARE(anotherEffect->source()->graphicsItem(), static_cast<const QGraphicsItem *>(pixmapItem));
+    QVERIFY(anotherEffect->source()->isPixmap());
+    delete pixmapItem;
+}
+
+void tst_QGraphicsEffectSource::draw()
+{
+    // The source can only draw as a result of QGraphicsEffect::draw.
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsEffectSource::draw: Can only begin as a result of QGraphicsEffect::draw");
+    QPixmap dummyPixmap(10, 10);
+    QPainter dummyPainter(&dummyPixmap);
+    effect->source()->draw(&dummyPainter);
+}
+
+void tst_QGraphicsEffectSource::update()
+{
+    QCOMPARE(item->numRepaints, 0);
+    QCOMPARE(effect->numRepaints, 0);
+
+    effect->source()->update();
+
+    QTRY_COMPARE(item->numRepaints, 1);
+    QTRY_COMPARE(effect->numRepaints, 1);
+}
+
+void tst_QGraphicsEffectSource::boundingRect()
+{
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsEffectSource::boundingRect: Not yet implemented, lacking device context");
+    QCOMPARE(effect->source()->boundingRect(Qt::DeviceCoordinates), QRectF());
+
+    QRectF itemBoundingRect = item->boundingRect();
+    if (!item->children().isEmpty())
+        itemBoundingRect |= item->childrenBoundingRect();
+
+    // We can at least check that the device bounding rect was correct in QGraphicsEffect::draw.
+    effect->storeDeviceDependentStuff = true;
+    effect->source()->update();
+    const QTransform deviceTransform = item->deviceTransform(view->viewportTransform());
+    QTRY_COMPARE(effect->sourceDeviceBoundingRect, deviceTransform.mapRect(itemBoundingRect));
+
+    // Bounding rect in logical coordinates is of course fine.
+    QTRY_COMPARE(effect->source()->boundingRect(Qt::LogicalCoordinates), itemBoundingRect);
+    // Make sure default value is Qt::LogicalCoordinates.
+    QTRY_COMPARE(effect->source()->boundingRect(), itemBoundingRect);
+}
+
+void tst_QGraphicsEffectSource::clippedBoundingRect()
+{
+    QRectF itemBoundingRect = item->boundingRect();
+    item->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+
+    QGraphicsRectItem *child = new QGraphicsRectItem(-1000, -1000, 2000, 2000);
+    child->setBrush(Qt::red);
+    child->setParentItem(item);
+
+    effect->storeDeviceDependentStuff = true;
+    effect->source()->update();
+    QTRY_COMPARE(effect->source()->boundingRect(Qt::LogicalCoordinates), itemBoundingRect);
+}
+
+void tst_QGraphicsEffectSource::deviceRect()
+{
+    effect->storeDeviceDependentStuff = true;
+    effect->source()->update();
+    QTRY_COMPARE(effect->deviceRect, view->viewport()->rect());
+}
+
+void tst_QGraphicsEffectSource::pixmap()
+{
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsEffectSource::pixmap: Not yet implemented, lacking device context");
+    QCOMPARE(effect->source()->pixmap(Qt::DeviceCoordinates), QPixmap());
+
+    // We can at least verify a valid pixmap from QGraphicsEffect::draw.
+    effect->storeDeviceDependentStuff = true;
+    effect->source()->update();
+    QTRY_VERIFY(!effect->deviceCoordinatesPixmap.isNull());
+
+    // Pixmaps in logical coordinates we can do fine.
+    QPixmap pixmap1 = effect->source()->pixmap(Qt::LogicalCoordinates);
+    QVERIFY(!pixmap1.isNull());
+
+    // Make sure default value is Qt::LogicalCoordinates.
+    QPixmap pixmap2 = effect->source()->pixmap();
+    QCOMPARE(pixmap1, pixmap2);
+}
+
+class PaddingEffect : public QGraphicsEffect
+{
+public:
+    PaddingEffect(QObject *parent) : QGraphicsEffect(parent)
+    {
+    }
+
+    QRectF boundingRectFor(const QRectF &src) const {
+        return src.adjusted(-10, -10, 10, 10);
+    }
+
+    void draw(QPainter *) {
+        pix = source()->pixmap(coordinateMode, &offset, padMode);
+    }
+
+    QPixmap pix;
+    QPoint offset;
+    QGraphicsEffect::PixmapPadMode padMode;
+    Qt::CoordinateSystem coordinateMode;
+};
+
+void tst_QGraphicsEffectSource::pixmapPadding_data()
+{
+    QTest::addColumn<int>("coordinateMode");
+    QTest::addColumn<int>("padMode");
+    QTest::addColumn<QSize>("size");
+    QTest::addColumn<QPoint>("offset");
+    QTest::addColumn<uint>("ulPixel");
+
+    QTest::newRow("log,nopad") << int(Qt::LogicalCoordinates)
+                               << int(QGraphicsEffect::NoPad)
+                               << QSize(10, 10) << QPoint(0, 0)
+                               << 0xffff0000u;
+
+    QTest::newRow("log,transparent") << int(Qt::LogicalCoordinates)
+                                     << int(QGraphicsEffect::PadToTransparentBorder)
+                                     << QSize(14, 14) << QPoint(-2, -2)
+                                     << 0x00000000u;
+
+    QTest::newRow("log,effectrect") << int(Qt::LogicalCoordinates)
+                                    << int(QGraphicsEffect::PadToEffectiveBoundingRect)
+                                    << QSize(20, 20) << QPoint(-5, -5)
+                                    << 0x00000000u;
+
+    QTest::newRow("dev,nopad") << int(Qt::DeviceCoordinates)
+                               << int(QGraphicsEffect::NoPad)
+                               << QSize(20, 20) << QPoint(40, 40)
+                               << 0xffff0000u;
+
+    QTest::newRow("dev,transparent") << int(Qt::DeviceCoordinates)
+                                     << int(QGraphicsEffect::PadToTransparentBorder)
+                                     << QSize(24, 24) << QPoint(38, 38)
+                                     << 0x00000000u;
+
+    QTest::newRow("dev,effectrect") << int(Qt::DeviceCoordinates)
+                                    << int(QGraphicsEffect::PadToEffectiveBoundingRect)
+                                    << QSize(40, 40) << QPoint(30, 30)
+                                    << 0x00000000u;
+
+}
+
+void tst_QGraphicsEffectSource::pixmapPadding()
+{
+    QPixmap dummyTarget(100, 100);
+    QPainter dummyPainter(&dummyTarget);
+    dummyPainter.translate(40, 40);
+    dummyPainter.scale(2, 2);
+
+    QPixmap pm(10, 10);
+    pm.fill(Qt::red);
+
+    QGraphicsScene *scene = new QGraphicsScene();
+    PaddingEffect *effect = new PaddingEffect(scene);
+    QGraphicsPixmapItem *pmItem = new QGraphicsPixmapItem(pm);
+    scene->addItem(pmItem);
+    pmItem->setGraphicsEffect(effect);
+
+    QFETCH(int, coordinateMode);
+    QFETCH(int, padMode);
+    QFETCH(QPoint, offset);
+    QFETCH(QSize, size);
+    QFETCH(uint, ulPixel);
+
+    effect->padMode = (QGraphicsEffect::PixmapPadMode) padMode;
+    effect->coordinateMode = (Qt::CoordinateSystem) coordinateMode;
+
+    scene->render(&dummyPainter, scene->itemsBoundingRect(), scene->itemsBoundingRect());
+
+    QCOMPARE(effect->pix.size(), size);
+    QCOMPARE(effect->offset, offset);
+    QCOMPARE(effect->pix.toImage().pixel(0, 0), ulPixel);
+
+    // ### Fix corruption in scene destruction, then enable...
+    // delete scene;
+}
+
+QTEST_MAIN(tst_QGraphicsEffectSource)
+#include "tst_qgraphicseffectsource.moc"
+
diff --git a/tests/auto/widgets/graphicsview/qgraphicsgridlayout/.gitignore b/tests/auto/widgets/graphicsview/qgraphicsgridlayout/.gitignore
new file mode 100644
index 0000000000..e3a8cc317c
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsgridlayout/.gitignore
@@ -0,0 +1 @@
+tst_qgraphicsgridlayout
diff --git a/tests/auto/widgets/graphicsview/qgraphicsgridlayout/qgraphicsgridlayout.pro b/tests/auto/widgets/graphicsview/qgraphicsgridlayout/qgraphicsgridlayout.pro
new file mode 100644
index 0000000000..7db7c1ae6f
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsgridlayout/qgraphicsgridlayout.pro
@@ -0,0 +1,6 @@
+load(qttest_p4)
+
+QT += widgets
+SOURCES  += tst_qgraphicsgridlayout.cpp
+CONFIG += parallel_test
+contains(QT_CONFIG,xcb):qpa:CONFIG+=insignificant_test  # QTBUG-20756 crashes on qpa, xcb
diff --git a/tests/auto/widgets/graphicsview/qgraphicsgridlayout/tst_qgraphicsgridlayout.cpp b/tests/auto/widgets/graphicsview/qgraphicsgridlayout/tst_qgraphicsgridlayout.cpp
new file mode 100644
index 0000000000..e9d9cb67bb
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsgridlayout/tst_qgraphicsgridlayout.cpp
@@ -0,0 +1,3465 @@
+/****************************************************************************
+**
+** 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 <qgraphicsgridlayout.h>
+#include <qgraphicswidget.h>
+#include <qgraphicsscene.h>
+#include <qgraphicsview.h>
+
+class tst_QGraphicsGridLayout : public QObject
+{
+    Q_OBJECT
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+private slots:
+    void qgraphicsgridlayout_data();
+    void qgraphicsgridlayout();
+    void addItem_data();
+    void addItem();
+#ifndef Q_WS_MAC
+    void alignment_data();
+    void alignment();
+#endif
+    void alignment2();
+    void alignment2_data();
+#ifndef Q_WS_MAC
+    void columnAlignment_data();
+    void columnAlignment();
+#endif
+    void columnCount_data();
+    void columnCount();
+    void columnMaximumWidth_data();
+    void columnMaximumWidth();
+    void columnMinimumWidth_data();
+    void columnMinimumWidth();
+    void columnPreferredWidth_data();
+    void columnPreferredWidth();
+    void setColumnFixedWidth();
+    void columnSpacing();
+    void columnStretchFactor();
+    void count();
+    void contentsMargins();
+    void horizontalSpacing_data();
+    void horizontalSpacing();
+    void itemAt();
+    void removeAt();
+    void removeItem();
+    void rowAlignment_data();
+    void rowAlignment();
+    void rowCount_data();
+    void rowCount();
+    void rowMaximumHeight_data();
+    void rowMaximumHeight();
+    void rowMinimumHeight_data();
+    void rowMinimumHeight();
+    void rowPreferredHeight_data();
+    void rowPreferredHeight();
+    void rowSpacing();
+    void rowStretchFactor_data();
+    void rowStretchFactor();
+    void setColumnSpacing_data();
+    void setColumnSpacing();
+    void setGeometry_data();
+    void setGeometry();
+    void setRowFixedHeight();
+    void setRowSpacing_data();
+    void setRowSpacing();
+    void setSpacing_data();
+    void setSpacing();
+    void sizeHint_data();
+    void sizeHint();
+    void verticalSpacing_data();
+    void verticalSpacing();
+    void layoutDirection_data();
+    void layoutDirection();
+    void removeLayout();
+    void defaultStretchFactors_data();
+    void defaultStretchFactors();
+    void geometries_data();
+    void geometries();
+    void avoidRecursionInInsertItem();
+    void styleInfoLeak();
+    void task236367_maxSizeHint();
+    void spanningItem2x2_data();
+    void spanningItem2x2();
+    void spanningItem2x3_data();
+    void spanningItem2x3();
+    void spanningItem();
+    void heightForWidth();
+    void widthForHeight();
+    void heightForWidthWithSpanning();
+    void stretchAndHeightForWidth();
+    void testDefaultAlignment();
+};
+
+class RectWidget : public QGraphicsWidget
+{
+public:
+    RectWidget(QGraphicsItem *parent = 0) : QGraphicsWidget(parent), m_fnConstraint(0) {}
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        Q_UNUSED(option);
+        Q_UNUSED(widget);
+        painter->drawRoundRect(rect());
+        painter->drawLine(rect().topLeft(), rect().bottomRight());
+        painter->drawLine(rect().bottomLeft(), rect().topRight());
+    }
+
+    QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const
+    {
+        if (constraint.width() < 0 && constraint.height() < 0 && m_sizeHints[which].isValid()) {
+            return m_sizeHints[which];
+        }
+        if (m_fnConstraint) {
+            return m_fnConstraint(which, constraint);
+        }
+        return QGraphicsWidget::sizeHint(which, constraint);
+    }
+
+    void setSizeHint(Qt::SizeHint which, const QSizeF &size) {
+        m_sizeHints[which] = size;
+        updateGeometry();
+    }
+
+    void setConstraintFunction(QSizeF (*fnConstraint)(Qt::SizeHint, const QSizeF &)) {
+        m_fnConstraint = fnConstraint;
+    }
+
+    QSizeF m_sizeHints[Qt::NSizeHints];
+    QSizeF (*m_fnConstraint)(Qt::SizeHint, const QSizeF &);
+
+};
+
+struct ItemDesc
+{
+    ItemDesc(int row, int col)
+    : m_pos(qMakePair(row, col)),
+      m_rowSpan(1),
+      m_colSpan(1),
+      m_sizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred)),
+      m_align(0),
+      m_fnConstraint(0)
+    {
+    }
+
+    ItemDesc &rowSpan(int span) {
+        m_rowSpan = span;
+        return (*this);
+    }
+
+    ItemDesc &colSpan(int span) {
+        m_colSpan = span;
+        return (*this);
+    }
+
+    ItemDesc &sizePolicy(const QSizePolicy &sp) {
+        m_sizePolicy = sp;
+        return (*this);
+    }
+
+    ItemDesc &sizePolicy(QSizePolicy::Policy horAndVer) {
+        m_sizePolicy = QSizePolicy(horAndVer, horAndVer);
+        return (*this);
+    }
+
+    ItemDesc &sizePolicyH(QSizePolicy::Policy hor) {
+        m_sizePolicy.setHorizontalPolicy(hor);
+        return (*this);
+    }
+
+    ItemDesc &sizePolicyV(QSizePolicy::Policy ver) {
+        m_sizePolicy.setVerticalPolicy(ver);
+        return (*this);
+    }
+
+    ItemDesc &sizePolicy(QSizePolicy::Policy hor, QSizePolicy::Policy ver) {
+        m_sizePolicy = QSizePolicy(hor, ver);
+        return (*this);
+    }
+
+    ItemDesc &sizeHint(Qt::SizeHint which, const QSizeF &sh) {
+        m_sizeHints[which] = sh;
+        return (*this);
+    }
+
+    ItemDesc &preferredSizeHint(const QSizeF &sh) {
+        m_sizeHints[Qt::PreferredSize] = sh;
+        return (*this);
+    }
+
+    ItemDesc &minSize(const QSizeF &sz) {
+        m_sizes[Qt::MinimumSize] = sz;
+        return (*this);
+    }
+    ItemDesc &preferredSize(const QSizeF &sz) {
+        m_sizes[Qt::PreferredSize] = sz;
+        return (*this);
+    }
+    ItemDesc &maxSize(const QSizeF &sz) {
+        m_sizes[Qt::MaximumSize] = sz;
+        return (*this);
+    }
+
+    ItemDesc &alignment(Qt::Alignment alignment) {
+        m_align = alignment;
+        return (*this);
+    }
+
+    ItemDesc &dynamicConstraint(QSizeF (*fnConstraint)(Qt::SizeHint, const QSizeF &),
+                                Qt::Orientation orientation) {
+        m_fnConstraint = fnConstraint;
+        m_constraintOrientation = orientation;
+        return (*this);
+    }
+
+    void apply(QGraphicsGridLayout *layout, QGraphicsWidget *item) {
+        QSizePolicy sp = m_sizePolicy;
+        if (m_fnConstraint) {
+            sp.setHeightForWidth(m_constraintOrientation == Qt::Vertical);
+            sp.setWidthForHeight(m_constraintOrientation == Qt::Horizontal);
+        }
+
+        item->setSizePolicy(sp);
+        for (int i = 0; i < Qt::NSizeHints; ++i) {
+            if (!m_sizes[i].isValid())
+                continue;
+            switch ((Qt::SizeHint)i) {
+            case Qt::MinimumSize:
+                item->setMinimumSize(m_sizes[i]);
+                break;
+            case Qt::PreferredSize:
+                item->setPreferredSize(m_sizes[i]);
+                break;
+            case Qt::MaximumSize:
+                item->setMaximumSize(m_sizes[i]);
+                break;
+            default:
+                qWarning("not implemented");
+                break;
+            }
+        }
+
+        layout->addItem(item, m_pos.first, m_pos.second, m_rowSpan, m_colSpan);
+        layout->setAlignment(item, m_align);
+    }
+
+    void apply(QGraphicsGridLayout *layout, RectWidget *item) {
+        for (int i = 0; i < Qt::NSizeHints; ++i)
+            item->setSizeHint((Qt::SizeHint)i, m_sizeHints[i]);
+        item->setConstraintFunction(m_fnConstraint);
+        apply(layout, static_cast<QGraphicsWidget*>(item));
+    }
+
+//private:
+    QPair<int,int> m_pos; // row,col
+    int m_rowSpan;
+    int m_colSpan;
+    QSizePolicy m_sizePolicy;
+    QSizeF m_sizeHints[Qt::NSizeHints];
+    QSizeF m_sizes[Qt::NSizeHints];
+    Qt::Alignment m_align;
+
+    Qt::Orientation m_constraintOrientation;
+    QSizeF (*m_fnConstraint)(Qt::SizeHint, const QSizeF &);
+};
+
+typedef QList<ItemDesc> ItemList;
+Q_DECLARE_METATYPE(ItemList);
+
+typedef QList<QSizeF> SizeList;
+Q_DECLARE_METATYPE(SizeList);
+
+
+// This will be called before the first test function is executed.
+// It is only called once.
+void tst_QGraphicsGridLayout::initTestCase()
+{
+}
+
+// This will be called after the last test function is executed.
+// It is only called once.
+void tst_QGraphicsGridLayout::cleanupTestCase()
+{
+}
+
+// This will be called before each test function is executed.
+void tst_QGraphicsGridLayout::init()
+{
+#ifdef Q_OS_WINCE //disable magic for WindowsCE
+    qApp->setAutoMaximizeThreshold(-1);
+#endif
+}
+
+// This will be called after every test function.
+void tst_QGraphicsGridLayout::cleanup()
+{
+}
+
+void tst_QGraphicsGridLayout::qgraphicsgridlayout_data()
+{
+}
+
+void tst_QGraphicsGridLayout::qgraphicsgridlayout()
+{
+    QGraphicsGridLayout layout;
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::addItem: invalid row span/column span: 0");
+    layout.addItem(0, 0, 0, 0, 0);
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::addItem: cannot add null item");
+    layout.addItem(0, 0, 0);
+    layout.alignment(0);
+    layout.columnAlignment(0);
+    layout.columnCount();
+    layout.columnMaximumWidth(0);
+    layout.columnMinimumWidth(0);
+    layout.columnPreferredWidth(0);
+    layout.columnSpacing(0);
+    layout.columnStretchFactor(0);
+    layout.count();
+    layout.horizontalSpacing();
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::itemAt: invalid row, column 0, 0");
+    layout.itemAt(0, 0);
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::itemAt: invalid index 0");
+    layout.itemAt(0);
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::removeAt: invalid index 0");
+    layout.removeAt(0);
+    layout.rowAlignment(0);
+    layout.rowCount();
+    layout.rowMaximumHeight(0);
+    layout.rowMinimumHeight(0);
+    layout.rowPreferredHeight(0);
+    layout.rowSpacing(0);
+    layout.rowStretchFactor(0);
+    layout.setAlignment(0, Qt::AlignRight);
+    layout.setColumnAlignment(0, Qt::AlignRight);
+    layout.setColumnFixedWidth(0, 0);
+    layout.setColumnMaximumWidth(0, 0);
+    layout.setColumnMinimumWidth(0, 0);
+    layout.setColumnPreferredWidth(0, 0);
+    layout.setColumnSpacing(0, 0);
+    layout.setColumnStretchFactor(0, 0);
+    layout.setGeometry(QRectF());
+    layout.setHorizontalSpacing(0);
+    layout.setRowAlignment(0, 0);
+    layout.setRowFixedHeight(0, 0);
+    layout.setRowMaximumHeight(0, 0);
+    layout.setRowMinimumHeight(0, 0);
+    layout.setRowPreferredHeight(0, 0);
+    layout.setRowSpacing(0, 0);
+    layout.setRowStretchFactor(0, 0);
+    layout.setSpacing(0);
+    layout.setVerticalSpacing(0);
+    layout.sizeHint(Qt::MinimumSize);
+    layout.verticalSpacing();
+}
+
+static void populateLayout(QGraphicsGridLayout *gridLayout, int width, int height, bool hasHeightForWidth = false)
+{
+    for (int y = 0; y < height; ++y) {
+        for (int x = 0; x < width; ++x) {
+            QGraphicsWidget *item = new RectWidget();
+            item->setMinimumSize(10, 10);
+            item->setPreferredSize(25, 25);
+            item->setMaximumSize(50, 50);
+            gridLayout->addItem(item, y, x);
+            QSizePolicy policy = item->sizePolicy();
+            policy.setHeightForWidth(hasHeightForWidth);
+            item->setSizePolicy(policy);
+        }
+    }
+}
+
+
+/** populates \a gridLayout with a 3x2 layout:
+ * +----+----+----+
+ * |+---|---+|xxxx|
+ * ||span=2 ||hole|
+ * |+---|---+|xxxx|
+ * +----+----+----+
+ * |xxxx|+---|---+|
+ * |hole||span=2 ||
+ * |xxxx|+---|---+|
+ * +----+----+----+
+ */
+static void populateLayoutWithSpansAndHoles(QGraphicsGridLayout *gridLayout, bool hasHeightForWidth = false)
+{
+    QGraphicsWidget *item = new RectWidget();
+    item->setMinimumSize(10, 10);
+    item->setPreferredSize(25, 25);
+    item->setMaximumSize(50, 50);
+    QSizePolicy sizepolicy = item->sizePolicy();
+    sizepolicy.setHeightForWidth(hasHeightForWidth);
+    item->setSizePolicy(sizepolicy);
+    gridLayout->addItem(item, 0, 0, 1, 2);
+
+    item = new RectWidget();
+    item->setMinimumSize(10, 10);
+    item->setPreferredSize(25, 25);
+    item->setMaximumSize(50, 50);
+    item->setSizePolicy(sizepolicy);
+    gridLayout->addItem(item, 1, 1, 1, 2);
+}
+
+Q_DECLARE_METATYPE(Qt::Alignment)
+void tst_QGraphicsGridLayout::addItem_data()
+{
+    QTest::addColumn<int>("row");
+    QTest::addColumn<int>("column");
+    QTest::addColumn<int>("rowSpan");
+    QTest::addColumn<int>("columnSpan");
+    QTest::addColumn<Qt::Alignment>("alignment");
+
+    for (int a = -1; a < 3; ++a) {
+    for (int b = -1; b < 2; ++b) {
+    for (int c = -1; c < 2; ++c) {
+    for (int d = -1; d < 2; ++d) {
+    for (int e = 0; e < 9; ++e) {
+        int row = a;
+        int column = b;
+        int rowSpan = c;
+        int columnSpan = d;
+        QString name = QString::fromAscii("(%1,%2,%3,%4").arg(a).arg(b).arg(c).arg(d);
+        Qt::Alignment alignment = Qt::AlignLeft;
+        QTest::newRow(name.toLatin1()) << row << column << rowSpan << columnSpan << alignment;
+    }}}}}
+}
+
+// public void addItem(QGraphicsLayoutItem* item, int row, int column, int rowSpan, int columnSpan, Qt::Alignment alignment = 0)
+void tst_QGraphicsGridLayout::addItem()
+{
+    QFETCH(int, row);
+    QFETCH(int, column);
+    QFETCH(int, rowSpan);
+    QFETCH(int, columnSpan);
+    QFETCH(Qt::Alignment, alignment);
+
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+
+    QGraphicsWidget *wid = new QGraphicsWidget;
+    if (row < 0 || column < 0) {
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::addItem: invalid row/column: -1");
+    } else if (rowSpan < 1 || columnSpan < 1) {
+        char buf[1024];
+        ::qsnprintf(buf, sizeof(buf), "QGraphicsGridLayout::addItem: invalid row span/column span: %d",
+            rowSpan < 1 ? rowSpan : columnSpan);
+        QTest::ignoreMessage(QtWarningMsg, buf);
+    }
+    layout->addItem(wid, row, column, rowSpan, columnSpan, alignment);
+
+    delete layout;
+}
+
+// Resizing a QGraphicsWidget to effectiveSizeHint(Qt::MaximumSize) is currently not supported on mac.
+#ifndef Q_WS_MAC
+void tst_QGraphicsGridLayout::alignment_data()
+{
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("") << false;
+    QTest::newRow("hasHeightForWidth") << true;
+}
+
+// public Qt::Alignment alignment(QGraphicsLayoutItem* item) const
+void tst_QGraphicsGridLayout::alignment()
+{
+    QFETCH(bool, hasHeightForWidth);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2, hasHeightForWidth);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    view.show();
+    widget->show();
+    widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
+    QApplication::processEvents();
+    // no alignment (the default)
+    QCOMPARE(layout->itemAt(0, 0)->geometry().left(), 0.0);
+    QCOMPARE(layout->itemAt(0, 0)->geometry().right(), layout->itemAt(0, 1)->geometry().left());
+    QCOMPARE(layout->itemAt(0, 1)->geometry().left(), 25.0);
+    QCOMPARE(layout->itemAt(0, 1)->geometry().right(), layout->itemAt(0, 2)->geometry().left());
+    QCOMPARE(layout->itemAt(0, 2)->geometry().left(), 50.0);
+    QCOMPARE(layout->itemAt(0, 2)->geometry().right(), 75.0);
+
+    QCOMPARE(layout->itemAt(1, 0)->geometry().left(), 0.0);
+    QCOMPARE(layout->itemAt(1, 0)->geometry().right(), layout->itemAt(1, 1)->geometry().left());
+    QCOMPARE(layout->itemAt(1, 1)->geometry().left(), 25.0);
+    QCOMPARE(layout->itemAt(1, 1)->geometry().right(), layout->itemAt(1, 2)->geometry().left());
+    QCOMPARE(layout->itemAt(1, 2)->geometry().left(), 50.0);
+    QCOMPARE(layout->itemAt(1, 2)->geometry().right(), 75.0);
+
+    QCOMPARE(layout->itemAt(0, 0)->geometry().top(), 0.0);
+    QCOMPARE(layout->itemAt(0, 0)->geometry().bottom(), layout->itemAt(1, 0)->geometry().top());
+    QCOMPARE(layout->itemAt(1, 0)->geometry().top(), 25.0);
+    QCOMPARE(layout->itemAt(1, 0)->geometry().bottom(), 50.0);
+
+    // align first column left, second hcenter, third right
+    layout->setColumnMinimumWidth(0, 100);
+    layout->setAlignment(layout->itemAt(0,0), Qt::AlignLeft);
+    layout->setAlignment(layout->itemAt(1,0), Qt::AlignLeft);
+    layout->setColumnMinimumWidth(1, 100);
+    layout->setAlignment(layout->itemAt(0,1), Qt::AlignHCenter);
+    layout->setAlignment(layout->itemAt(1,1), Qt::AlignHCenter);
+    layout->setColumnMinimumWidth(2, 100);
+    layout->setAlignment(layout->itemAt(0,2), Qt::AlignRight);
+    layout->setAlignment(layout->itemAt(1,2), Qt::AlignRight);
+
+    widget->resize(widget->effectiveSizeHint(Qt::MaximumSize));
+    QApplication::processEvents();
+
+    QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(0,    0,  50,  50));
+    QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(0,   50,  50,  50));
+    QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(125,  0,  50,  50));
+    QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(125, 50,  50,  50));
+    QCOMPARE(layout->itemAt(0,2)->geometry(), QRectF(250,  0,  50,  50));
+    QCOMPARE(layout->itemAt(1,2)->geometry(), QRectF(250, 50,  50,  50));
+
+    delete widget;
+}
+#endif
+
+// Resizing a QGraphicsWidget to effectiveSizeHint(Qt::MaximumSize) is currently not supported on mac.
+#ifndef Q_WS_MAC
+void tst_QGraphicsGridLayout::columnAlignment_data()
+{
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("") << false;
+    QTest::newRow("hasHeightForWidth") << true;
+}
+
+// public void setColumnAlignment(int column, Qt::Alignment alignment)
+// public Qt::Alignment columnAlignment(int column) const
+void tst_QGraphicsGridLayout::columnAlignment()
+{
+    QFETCH(bool, hasHeightForWidth);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2, hasHeightForWidth);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(1);
+    widget->setContentsMargins(0, 0, 0, 0);
+
+    layout->setColumnMinimumWidth(0, 100);
+    layout->setColumnMinimumWidth(1, 100);
+    layout->setColumnMinimumWidth(2, 100);
+
+    view.resize(450,150);
+    widget->resize(widget->effectiveSizeHint(Qt::MaximumSize));
+    view.show();
+    widget->show();
+    QApplication::sendPostedEvents(0, 0);
+    // Check default
+    QCOMPARE(layout->columnAlignment(0), 0);
+    QCOMPARE(layout->columnAlignment(1), 0);
+    QCOMPARE(layout->columnAlignment(2), 0);
+
+    layout->setColumnAlignment(0, Qt::AlignLeft);
+    layout->setColumnAlignment(1, Qt::AlignHCenter);
+    layout->setColumnAlignment(2, Qt::AlignRight);
+
+    // see if item alignment takes preference over columnAlignment
+    layout->setAlignment(layout->itemAt(1,0), Qt::AlignHCenter);
+    layout->setAlignment(layout->itemAt(1,1), Qt::AlignRight);
+    layout->setAlignment(layout->itemAt(1,2), Qt::AlignLeft);
+
+    QApplication::sendPostedEvents(0, 0);  // process LayoutRequest
+    /*
+      +----------+------------+---------+
+      | Left     |  HCenter   |  Right  |
+      +----------+------------+---------+
+      | HCenter  |   Right    |   Left  |
+      +---------------------------------+
+    */
+    QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(0,   0,   50,  50));
+    QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(25,  51,  50,  50));   // item is king
+    QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(126,  0,  50,  50));
+    QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(151, 51,  50,  50));   // item is king
+    QCOMPARE(layout->itemAt(0,2)->geometry(), QRectF(252,  0,  50,  50));
+    QCOMPARE(layout->itemAt(1,2)->geometry(), QRectF(202, 51,  50,  50));   // item is king
+
+    delete widget;
+}
+#endif
+
+void tst_QGraphicsGridLayout::columnCount_data()
+{
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("") << false;
+    QTest::newRow("hasHeightForWidth") << true;
+}
+// public int columnCount() const
+void tst_QGraphicsGridLayout::columnCount()
+{
+    QFETCH(bool, hasHeightForWidth);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+    widget->setContentsMargins(0, 0, 0, 0);
+
+    view.show();
+    widget->show();
+    QApplication::processEvents();
+
+    QCOMPARE(layout->columnCount(), 0);
+    layout->addItem(new RectWidget(widget), 0, 0);
+    QCOMPARE(layout->columnCount(), 1);
+    layout->addItem(new RectWidget(widget), 1, 1);
+    QCOMPARE(layout->columnCount(), 2);
+    layout->addItem(new RectWidget(widget), 0, 2);
+    QCOMPARE(layout->columnCount(), 3);
+    layout->addItem(new RectWidget(widget), 1, 0);
+    QCOMPARE(layout->columnCount(), 3);
+    layout->addItem(new RectWidget(widget), 0, 1);
+    QCOMPARE(layout->columnCount(), 3);
+    layout->addItem(new RectWidget(widget), 1, 2);
+    QCOMPARE(layout->columnCount(), 3);
+
+    // ### Talk with Jasmin. Not sure if removeAt() should adjust columnCount().
+    widget->setLayout(0);
+    layout = new QGraphicsGridLayout();
+    populateLayout(layout, 3, 2, hasHeightForWidth);
+    QCOMPARE(layout->columnCount(), 3);
+    layout->removeAt(5);
+    layout->removeAt(3);
+    QCOMPARE(layout->columnCount(), 3);
+    layout->removeAt(1);
+    QCOMPARE(layout->columnCount(), 3);
+    layout->removeAt(0);
+    QCOMPARE(layout->columnCount(), 3);
+    layout->removeAt(0);
+    QCOMPARE(layout->columnCount(), 2);
+
+    delete widget;
+}
+
+void tst_QGraphicsGridLayout::columnMaximumWidth_data()
+{
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("") << false;
+    QTest::newRow("hasHeightForWidth") << true;
+}
+// public qreal columnMaximumWidth(int column) const
+void tst_QGraphicsGridLayout::columnMaximumWidth()
+{
+    QFETCH(bool, hasHeightForWidth);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2, hasHeightForWidth);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    QCOMPARE(layout->minimumSize(), QSizeF(10+10+10, 10+10));
+    QCOMPARE(layout->preferredSize(), QSizeF(25+25+25, 25+25));
+    QCOMPARE(layout->maximumSize(), QSizeF(50+50+50, 50+50));
+
+    // should at least be a very large number
+    QVERIFY(layout->columnMaximumWidth(0) >= 10000);
+    QCOMPARE(layout->columnMaximumWidth(0), layout->columnMaximumWidth(1));
+    QCOMPARE(layout->columnMaximumWidth(1), layout->columnMaximumWidth(2));
+    layout->setColumnMaximumWidth(0, 20);
+    layout->setColumnMaximumWidth(2, 60);
+
+    QCOMPARE(layout->minimumSize(), QSizeF(10+10+10, 10+10));
+    QCOMPARE(layout->preferredSize(), QSizeF(20+25+25, 25+25));
+    QCOMPARE(layout->maximumSize(), QSizeF(20+50+60, 50+50));
+    QCOMPARE(layout->maximumSize(), widget->maximumSize());
+
+    widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
+    layout->activate();
+
+    QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(0, 0, 20, 25));
+    QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(0, 25, 20, 25));
+    QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(20, 0, 25, 25));
+    QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(20, 25, 25, 25));
+    QCOMPARE(layout->itemAt(0,2)->geometry(), QRectF(45, 0, 25, 25));
+    QCOMPARE(layout->itemAt(1,2)->geometry(), QRectF(45, 25, 25, 25));
+
+    layout->setColumnAlignment(2, Qt::AlignCenter);
+    widget->resize(widget->effectiveSizeHint(Qt::MaximumSize));
+    layout->activate();
+    QCOMPARE(layout->geometry(), QRectF(0,0,20+50+60, 50+50));
+    QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(0, 0, 20, 50));
+    QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(0, 50, 20, 50));
+    QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(20, 0, 50, 50));
+    QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(20, 50, 50, 50));
+    QCOMPARE(layout->itemAt(0,2)->geometry(), QRectF(75, 0, 50, 50));
+    QCOMPARE(layout->itemAt(1,2)->geometry(), QRectF(75, 50, 50, 50));
+
+    for (int i = 0; i < layout->count(); i++)
+        layout->setAlignment(layout->itemAt(i), Qt::AlignRight | Qt::AlignBottom);
+    layout->activate();
+    QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(0, 0, 20, 50));
+    QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(0, 50, 20, 50));
+    QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(20, 0, 50, 50));
+    QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(20, 50, 50, 50));
+    QCOMPARE(layout->itemAt(0,2)->geometry(), QRectF(80, 0, 50, 50));
+    QCOMPARE(layout->itemAt(1,2)->geometry(), QRectF(80, 50, 50, 50));
+    for (int i = 0; i < layout->count(); i++)
+        layout->setAlignment(layout->itemAt(i), Qt::AlignCenter);
+
+    layout->setMaximumSize(layout->maximumSize() + QSizeF(60,60));
+    widget->resize(widget->effectiveSizeHint(Qt::MaximumSize));
+    layout->activate();
+
+    QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(0, 15, 20, 50));
+    QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(0, 95, 20, 50));
+    QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(20+30, 15, 50, 50));
+    QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(20+30, 95, 50, 50));
+    QCOMPARE(layout->itemAt(0,2)->geometry(), QRectF(20+60+50+5, 15, 50, 50));
+    QCOMPARE(layout->itemAt(1,2)->geometry(), QRectF(20+60+50+5, 95, 50, 50));
+
+    layout->setMaximumSize(layout->preferredSize() + QSizeF(20,20));
+    widget->resize(widget->effectiveSizeHint(Qt::MaximumSize));
+    layout->activate();
+
+    QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(0, 0, 20, 35));
+    QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(0, 35, 20, 35));
+    QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(20, 0, 35, 35));
+    QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(20, 35, 35, 35));
+    QCOMPARE(layout->itemAt(0,2)->geometry(), QRectF(55, 0, 35, 35));
+    QCOMPARE(layout->itemAt(1,2)->geometry(), QRectF(55, 35, 35, 35));
+
+    delete widget;
+}
+
+void tst_QGraphicsGridLayout::columnMinimumWidth_data()
+{
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("") << false;
+    QTest::newRow("hasHeightForWidth") << true;
+}
+// public qreal columnMinimumWidth(int column) const
+void tst_QGraphicsGridLayout::columnMinimumWidth()
+{
+    QFETCH(bool, hasHeightForWidth);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2, hasHeightForWidth);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    // should at least be a very large number
+    QCOMPARE(layout->columnMinimumWidth(0), 0.0);
+    QCOMPARE(layout->columnMinimumWidth(0), layout->columnMinimumWidth(1));
+    QCOMPARE(layout->columnMinimumWidth(1), layout->columnMinimumWidth(2));
+    layout->setColumnMinimumWidth(0, 20);
+    layout->setColumnMinimumWidth(2, 40);
+
+    view.show();
+    widget->show();
+    widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
+    QApplication::processEvents();
+
+    QCOMPARE(layout->itemAt(0,0)->geometry().width(), 25.0);
+    QCOMPARE(layout->itemAt(1,0)->geometry().width(), 25.0);
+    QCOMPARE(layout->itemAt(0,1)->geometry().width(), 25.0);
+    QCOMPARE(layout->itemAt(1,1)->geometry().width(), 25.0);
+    QCOMPARE(layout->itemAt(0,2)->geometry().width(), 40.0);
+    QCOMPARE(layout->itemAt(1,2)->geometry().width(), 40.0);
+
+    delete widget;
+}
+
+void tst_QGraphicsGridLayout::columnPreferredWidth_data()
+{
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("") << false;
+    QTest::newRow("hasHeightForWidth") << true;
+}
+// public qreal columnPreferredWidth(int column) const
+void tst_QGraphicsGridLayout::columnPreferredWidth()
+{
+    QFETCH(bool, hasHeightForWidth);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2, hasHeightForWidth);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    // default preferred width ??
+    QCOMPARE(layout->columnPreferredWidth(0), 0.0);
+    QCOMPARE(layout->columnPreferredWidth(0), layout->columnPreferredWidth(1));
+    QCOMPARE(layout->columnPreferredWidth(1), layout->columnPreferredWidth(2));
+    layout->setColumnPreferredWidth(0, 20);
+    layout->setColumnPreferredWidth(2, 40);
+
+    view.show();
+    widget->show();
+    widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
+    QApplication::processEvents();
+
+    QCOMPARE(layout->itemAt(0,0)->geometry().width(), 25.0);
+    QCOMPARE(layout->itemAt(1,0)->geometry().width(), 25.0);
+    QCOMPARE(layout->itemAt(0,1)->geometry().width(), 25.0);
+    QCOMPARE(layout->itemAt(1,1)->geometry().width(), 25.0);
+    QCOMPARE(layout->itemAt(0,2)->geometry().width(), 40.0);
+    QCOMPARE(layout->itemAt(1,2)->geometry().width(), 40.0);
+
+    delete widget;
+}
+
+// public void setColumnFixedWidth(int row, qreal height)
+void tst_QGraphicsGridLayout::setColumnFixedWidth()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    layout->setColumnFixedWidth(0, 20);
+    layout->setColumnFixedWidth(2, 40);
+
+    view.show();
+    widget->show();
+    widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
+    QApplication::processEvents();
+
+    QCOMPARE(layout->itemAt(0,0)->geometry().width(), 20.0);
+    QCOMPARE(layout->itemAt(1,0)->geometry().width(), 20.0);
+    QCOMPARE(layout->itemAt(0,1)->geometry().width(), 25.0);
+    QCOMPARE(layout->itemAt(1,1)->geometry().width(), 25.0);
+    QCOMPARE(layout->itemAt(0,2)->geometry().width(), 40.0);
+    QCOMPARE(layout->itemAt(1,2)->geometry().width(), 40.0);
+
+    delete widget;
+}
+
+// public qreal columnSpacing(int column) const
+void tst_QGraphicsGridLayout::columnSpacing()
+{
+    {
+        QGraphicsScene scene;
+        QGraphicsView view(&scene);
+        QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+        QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+        scene.addItem(widget);
+        widget->setLayout(layout);
+        populateLayout(layout, 3, 2);
+        layout->setContentsMargins(0, 0, 0, 0);
+        layout->setSpacing(0);
+        QCOMPARE(layout->columnSpacing(0), 0.0);
+
+        layout->setColumnSpacing(0, 20);
+        view.show();
+        widget->show();
+        widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
+        QApplication::processEvents();
+
+        QCOMPARE(layout->itemAt(0,0)->geometry().left(),   0.0);
+        QCOMPARE(layout->itemAt(0,0)->geometry().right(), 25.0);
+        QCOMPARE(layout->itemAt(0,1)->geometry().left(),  45.0);
+        QCOMPARE(layout->itemAt(0,1)->geometry().right(), 70.0);
+        QCOMPARE(layout->itemAt(0,2)->geometry().left(),  70.0);
+        QCOMPARE(layout->itemAt(0,2)->geometry().right(), 95.0);
+
+        delete widget;
+    }
+
+    {
+        // don't include items and spacings that was previously part of the layout
+        // (horizontal)
+        QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+        populateLayout(layout, 3, 1);
+        layout->setContentsMargins(0, 0, 0, 0);
+        layout->setSpacing(0);
+        layout->setColumnSpacing(0, 10);
+        layout->setColumnSpacing(1, 10);
+        layout->setColumnSpacing(2, 10);
+        layout->setColumnSpacing(3, 10);
+        QCOMPARE(layout->preferredSize(), QSizeF(95, 25));
+        layout->removeAt(2);
+        QCOMPARE(layout->preferredSize(), QSizeF(60, 25));
+        layout->removeAt(1);
+        QCOMPARE(layout->preferredSize(), QSizeF(25, 25));
+        delete layout;
+    }
+    {
+        // don't include items and spacings that was previously part of the layout
+        // (vertical)
+        QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+        populateLayout(layout, 2, 2);
+        layout->setContentsMargins(0, 0, 0, 0);
+        layout->setSpacing(0);
+        layout->setColumnSpacing(0, 10);
+        layout->setColumnSpacing(1, 10);
+        layout->setRowSpacing(0, 10);
+        layout->setRowSpacing(1, 10);
+        QCOMPARE(layout->preferredSize(), QSizeF(60, 60));
+        layout->removeAt(3);
+        QCOMPARE(layout->preferredSize(), QSizeF(60, 60));
+        layout->removeAt(2);
+        QCOMPARE(layout->preferredSize(), QSizeF(60, 25));
+        layout->removeAt(1);
+        QCOMPARE(layout->preferredSize(), QSizeF(25, 25));
+        delete layout;
+    }
+
+}
+
+// public int columnStretchFactor(int column) const
+void tst_QGraphicsGridLayout::columnStretchFactor()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    layout->setColumnStretchFactor(0, 1);
+    layout->setColumnStretchFactor(1, 2);
+    layout->setColumnStretchFactor(2, 3);
+    view.show();
+    widget->show();
+    widget->resize(130, 50);
+    QApplication::processEvents();
+
+    QVERIFY(layout->itemAt(0,0)->geometry().width() <  layout->itemAt(0,1)->geometry().width());
+    QVERIFY(layout->itemAt(0,1)->geometry().width() <  layout->itemAt(0,2)->geometry().width());
+    QVERIFY(layout->itemAt(1,0)->geometry().width() <  layout->itemAt(1,1)->geometry().width());
+    QVERIFY(layout->itemAt(1,1)->geometry().width() <  layout->itemAt(1,2)->geometry().width());
+
+    delete widget;
+}
+
+
+// public int count() const
+void tst_QGraphicsGridLayout::count()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2);
+    QCOMPARE(layout->count(), 6);
+    layout->removeAt(5);
+    layout->removeAt(3);
+    QCOMPARE(layout->count(), 4);
+    layout->removeAt(1);
+    QCOMPARE(layout->count(), 3);
+    layout->removeAt(0);
+    QCOMPARE(layout->count(), 2);
+    layout->removeAt(0);
+    QCOMPARE(layout->count(), 1);
+    layout->removeAt(0);
+    QCOMPARE(layout->count(), 0);
+
+    delete widget;
+}
+
+void tst_QGraphicsGridLayout::horizontalSpacing_data()
+{
+    QTest::addColumn<qreal>("horizontalSpacing");
+    QTest::newRow("zero") << qreal(0.0);
+    QTest::newRow("10") << qreal(10.0);
+}
+
+// public qreal horizontalSpacing() const
+void tst_QGraphicsGridLayout::horizontalSpacing()
+{
+    QFETCH(qreal, horizontalSpacing);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2);
+    layout->setContentsMargins(0, 0, 0, 0);
+    qreal w = layout->sizeHint(Qt::PreferredSize, QSizeF()).width();
+    qreal oldSpacing = layout->horizontalSpacing();
+    if (oldSpacing != -1) {
+        layout->setHorizontalSpacing(horizontalSpacing);
+        QApplication::processEvents();
+        qreal new_w = layout->sizeHint(Qt::PreferredSize, QSizeF()).width();
+        QCOMPARE(new_w, w - (3-1)*(oldSpacing - horizontalSpacing));
+    } else {
+        QSKIP("The current style uses non-uniform layout spacing", SkipAll);
+    }
+    delete widget;
+}
+
+void tst_QGraphicsGridLayout::contentsMargins()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    QGraphicsGridLayout *sublayout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    layout->addItem(sublayout,0, 1);
+
+    qreal left, top, right, bottom;
+    // sublayouts have 0 margin
+    sublayout->getContentsMargins(&left, &top, &right, &bottom);
+    QCOMPARE(left, 0.0);
+    QCOMPARE(top, 0.0);
+    QCOMPARE(right, 0.0);
+    QCOMPARE(bottom, 0.0);
+
+    // top level layouts have style dependent margins.
+    // we'll just check if its different from 0. (applies to all our styles)
+    layout->getContentsMargins(&left, &top, &right, &bottom);
+    QVERIFY(left >= 0.0);
+    QVERIFY(top >= 0.0);
+    QVERIFY(right >= 0.0);
+    QVERIFY(bottom >= 0.0);
+
+    delete widget;
+}
+
+// public QGraphicsLayoutItem* itemAt(int index) const
+void tst_QGraphicsGridLayout::itemAt()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayoutWithSpansAndHoles(layout);
+
+    //itemAt(int row, int column)
+    QVERIFY( layout->itemAt(0,0));
+    QVERIFY( layout->itemAt(0,1));
+    QCOMPARE(layout->itemAt(0,2), static_cast<QGraphicsLayoutItem*>(0));
+    QCOMPARE(layout->itemAt(1,0), static_cast<QGraphicsLayoutItem*>(0));
+    QVERIFY( layout->itemAt(1,1));
+    QVERIFY( layout->itemAt(1,2));
+
+
+    //itemAt(int index)
+    for (int i = -2; i < layout->count() + 2; ++i) {
+        if (i >= 0 && i < layout->count()) {
+            QVERIFY(layout->itemAt(i));
+        } else {
+            QTest::ignoreMessage(QtWarningMsg, QString::fromAscii("QGraphicsGridLayout::itemAt: invalid index %1").arg(i).toLatin1().constData());
+            QCOMPARE(layout->itemAt(i), static_cast<QGraphicsLayoutItem*>(0));
+        }
+    }
+    delete widget;
+}
+
+// public void removeAt(int index)
+void tst_QGraphicsGridLayout::removeAt()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2);
+    QCOMPARE(layout->count(), 6);
+    layout->removeAt(5);
+    layout->removeAt(3);
+    QCOMPARE(layout->count(), 4);
+    layout->removeAt(1);
+    QCOMPARE(layout->count(), 3);
+    layout->removeAt(0);
+    QCOMPARE(layout->count(), 2);
+    layout->removeAt(0);
+    QCOMPARE(layout->count(), 1);
+    QGraphicsLayoutItem *item0 = layout->itemAt(0);
+    QCOMPARE(item0->parentLayoutItem(), static_cast<QGraphicsLayoutItem *>(layout));
+    layout->removeAt(0);
+    QCOMPARE(item0->parentLayoutItem(), static_cast<QGraphicsLayoutItem *>(0));
+    QCOMPARE(layout->count(), 0);
+    QTest::ignoreMessage(QtWarningMsg, QString::fromAscii("QGraphicsGridLayout::removeAt: invalid index 0").toLatin1().constData());
+    layout->removeAt(0);
+    QCOMPARE(layout->count(), 0);
+    delete widget;
+}
+
+void tst_QGraphicsGridLayout::removeItem()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    scene.addItem(widget);
+    QGraphicsGridLayout *l = new QGraphicsGridLayout();
+    widget->setLayout(l);
+
+    populateLayout(l, 3, 2);
+    QCOMPARE(l->count(), 6);
+    l->removeItem(l->itemAt(5));
+    l->removeItem(l->itemAt(4));
+    QCOMPARE(l->count(), 4);
+
+    // Avoid crashing. Note that the warning message might change in the future.
+    QTest::ignoreMessage(QtWarningMsg, QString::fromAscii("QGraphicsGridLayout::removeAt: invalid index -1").toLatin1().constData());
+    l->removeItem(0);
+    QCOMPARE(l->count(), 4);
+
+    QTest::ignoreMessage(QtWarningMsg, QString::fromAscii("QGraphicsGridLayout::removeAt: invalid index -1").toLatin1().constData());
+    l->removeItem(new QGraphicsWidget);
+    QCOMPARE(l->count(), 4);
+}
+
+void tst_QGraphicsGridLayout::rowAlignment_data()
+{
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("") << false;
+    QTest::newRow("hasHeightForWidth") << true;
+}
+
+// public Qt::Alignment rowAlignment(int row) const
+void tst_QGraphicsGridLayout::rowAlignment()
+{
+    QFETCH(bool, hasHeightForWidth);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 2, 3, hasHeightForWidth);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(1);
+    widget->setContentsMargins(0, 0, 0, 0);
+
+    view.resize(330,450);
+    widget->resize(300, 400);
+    view.show();
+    widget->show();
+    QApplication::sendPostedEvents(0, 0);
+    // Check default
+    QCOMPARE(layout->rowAlignment(0), 0);
+    QCOMPARE(layout->rowAlignment(1), 0);
+    QCOMPARE(layout->rowAlignment(2), 0);
+
+    // make the grids larger than the items, so that alignment kicks in
+    layout->setRowMinimumHeight(0, 100.0);
+    layout->setRowMinimumHeight(1, 100.0);
+    layout->setRowMinimumHeight(2, 100.0);
+    // expand columns also, so we can test combination of horiz and vertical alignment
+    layout->setColumnMinimumWidth(0, 100.0);
+    layout->setColumnMinimumWidth(1, 100.0);
+
+    layout->setRowAlignment(0, Qt::AlignBottom);
+    layout->setRowAlignment(1, Qt::AlignVCenter);
+    layout->setRowAlignment(2, Qt::AlignTop);
+
+    // see if item alignment takes preference over rowAlignment
+    layout->setAlignment(layout->itemAt(0,0), Qt::AlignRight);
+    layout->setAlignment(layout->itemAt(1,0), Qt::AlignTop);
+    layout->setAlignment(layout->itemAt(2,0), Qt::AlignHCenter);
+
+    QApplication::sendPostedEvents(0, 0);   // process LayoutRequest
+
+    QCOMPARE(layout->alignment(layout->itemAt(0,0)), Qt::AlignRight);  //Qt::AlignRight | Qt::AlignBottom
+    QCOMPARE(layout->itemAt(0,0)->geometry(), QRectF(50,  50,  50,  50));
+    QCOMPARE(layout->rowAlignment(0), Qt::AlignBottom);
+    QCOMPARE(layout->itemAt(0,1)->geometry(), QRectF(101, 50,  50,  50));
+    QCOMPARE(layout->alignment(layout->itemAt(1,0)), Qt::AlignTop);
+    QCOMPARE(layout->itemAt(1,0)->geometry(), QRectF(0,  101,  50,  50));
+    QCOMPARE(layout->rowAlignment(1), Qt::AlignVCenter);
+    QCOMPARE(layout->itemAt(1,1)->geometry(), QRectF(101, 126, 50,  50));
+    QCOMPARE(layout->alignment(layout->itemAt(2,0)), Qt::AlignHCenter);
+    QCOMPARE(layout->itemAt(2,0)->geometry(), QRectF(25, 202,  50,  50));
+    QCOMPARE(layout->rowAlignment(2), Qt::AlignTop);
+    QCOMPARE(layout->itemAt(2,1)->geometry(), QRectF(101,202,  50,  50));
+
+    delete widget;
+}
+
+void tst_QGraphicsGridLayout::rowCount_data()
+{
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("") << false;
+    QTest::newRow("hasHeightForWidth") << true;
+}
+
+// public int rowCount() const
+// public int columnCount() const
+void tst_QGraphicsGridLayout::rowCount()
+{
+    QFETCH(bool, hasHeightForWidth);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 2, 3, hasHeightForWidth);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+    widget->setContentsMargins(0, 0, 0, 0);
+    QCOMPARE(layout->rowCount(), 3);
+    QCOMPARE(layout->columnCount(), 2);
+
+    // with spans and holes...
+    widget->setLayout(0);
+    layout = new QGraphicsGridLayout();
+    populateLayoutWithSpansAndHoles(layout, hasHeightForWidth);
+    QCOMPARE(layout->rowCount(), 2);
+    QCOMPARE(layout->columnCount(), 3);
+
+    delete widget;
+}
+
+void tst_QGraphicsGridLayout::rowMaximumHeight_data()
+{
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("") << false;
+    QTest::newRow("hasHeightForWidth") << true;
+}
+
+// public qreal rowMaximumHeight(int row) const
+void tst_QGraphicsGridLayout::rowMaximumHeight()
+{
+    QFETCH(bool, hasHeightForWidth);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 2, 3, hasHeightForWidth);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    // should at least be a very large number
+    QVERIFY(layout->rowMaximumHeight(0) >= 10000);
+    QCOMPARE(layout->rowMaximumHeight(0), layout->rowMaximumHeight(1));
+    QCOMPARE(layout->rowMaximumHeight(1), layout->rowMaximumHeight(2));
+    layout->setRowMaximumHeight(0, 20);
+    layout->setRowMaximumHeight(2, 60);
+
+    view.show();
+    widget->show();
+    widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
+    QApplication::processEvents();
+
+    QCOMPARE(layout->itemAt(0,0)->geometry().height(), 20.0);
+    QCOMPARE(layout->itemAt(0,1)->geometry().height(), 20.0);
+    QCOMPARE(layout->itemAt(1,0)->geometry().height(), 25.0);
+    QCOMPARE(layout->itemAt(1,1)->geometry().height(), 25.0);
+    QCOMPARE(layout->itemAt(2,0)->geometry().height(), 25.0);
+    QCOMPARE(layout->itemAt(2,1)->geometry().height(), 25.0);
+
+    delete widget;
+}
+
+void tst_QGraphicsGridLayout::rowMinimumHeight_data()
+{
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("") << false;
+    QTest::newRow("hasHeightForWidth") << true;
+}
+// public qreal rowMinimumHeight(int row) const
+void tst_QGraphicsGridLayout::rowMinimumHeight()
+{
+    QFETCH(bool, hasHeightForWidth);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 2, 3, hasHeightForWidth);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    // should at least be a very large number
+    QCOMPARE(layout->rowMinimumHeight(0), 0.0);
+    QCOMPARE(layout->rowMinimumHeight(0), layout->rowMinimumHeight(1));
+    QCOMPARE(layout->rowMinimumHeight(1), layout->rowMinimumHeight(2));
+    layout->setRowMinimumHeight(0, 20);
+    layout->setRowMinimumHeight(2, 40);
+
+    view.show();
+    widget->show();
+    widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
+    QApplication::processEvents();
+
+    QCOMPARE(layout->itemAt(0,0)->geometry().height(), 25.0);
+    QCOMPARE(layout->itemAt(0,1)->geometry().height(), 25.0);
+    QCOMPARE(layout->itemAt(1,0)->geometry().height(), 25.0);
+    QCOMPARE(layout->itemAt(1,1)->geometry().height(), 25.0);
+    QCOMPARE(layout->itemAt(2,0)->geometry().height(), 40.0);
+    QCOMPARE(layout->itemAt(2,1)->geometry().height(), 40.0);
+
+    delete widget;
+}
+
+void tst_QGraphicsGridLayout::rowPreferredHeight_data()
+{
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("") << false;
+    QTest::newRow("hasHeightForWidth") << true;
+}
+// public qreal rowPreferredHeight(int row) const
+void tst_QGraphicsGridLayout::rowPreferredHeight()
+{
+    QFETCH(bool, hasHeightForWidth);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 2, 3, hasHeightForWidth);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    // default preferred height ??
+    QCOMPARE(layout->rowPreferredHeight(0), 0.0);
+    QCOMPARE(layout->rowPreferredHeight(0), layout->rowPreferredHeight(1));
+    QCOMPARE(layout->rowPreferredHeight(1), layout->rowPreferredHeight(2));
+    layout->setRowPreferredHeight(0, 20);
+    layout->setRowPreferredHeight(2, 40);
+
+    view.show();
+    widget->show();
+    widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
+    QApplication::processEvents();
+
+    // ### Jasmin: Should rowPreferredHeight have precedence over sizeHint(Qt::PreferredSize) ?
+    QCOMPARE(layout->itemAt(0,0)->geometry().height(), 25.0);
+    QCOMPARE(layout->itemAt(0,1)->geometry().height(), 25.0);
+    QCOMPARE(layout->itemAt(1,0)->geometry().height(), 25.0);
+    QCOMPARE(layout->itemAt(1,1)->geometry().height(), 25.0);
+    QCOMPARE(layout->itemAt(2,0)->geometry().height(), 40.0);
+    QCOMPARE(layout->itemAt(2,1)->geometry().height(), 40.0);
+
+    delete widget;
+}
+
+// public void setRowFixedHeight(int row, qreal height)
+void tst_QGraphicsGridLayout::setRowFixedHeight()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 2, 3);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    layout->setRowFixedHeight(0, 20.);
+    layout->setRowFixedHeight(2, 40.);
+
+    view.show();
+    widget->show();
+    widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
+    QApplication::processEvents();
+
+    QCOMPARE(layout->itemAt(0,0)->geometry().height(), 20.0);
+    QCOMPARE(layout->itemAt(0,1)->geometry().height(), 20.0);
+    QCOMPARE(layout->itemAt(1,0)->geometry().height(), 25.0);
+    QCOMPARE(layout->itemAt(1,1)->geometry().height(), 25.0);
+    QCOMPARE(layout->itemAt(2,0)->geometry().height(), 40.0);
+    QCOMPARE(layout->itemAt(2,1)->geometry().height(), 40.0);
+
+    delete widget;
+}
+
+// public qreal rowSpacing(int row) const
+void tst_QGraphicsGridLayout::rowSpacing()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+    QCOMPARE(layout->columnSpacing(0), 0.0);
+
+    layout->setColumnSpacing(0, 20);
+    view.show();
+    widget->show();
+    widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
+    QApplication::processEvents();
+
+    QCOMPARE(layout->itemAt(0,0)->geometry().left(),   0.0);
+    QCOMPARE(layout->itemAt(0,0)->geometry().right(), 25.0);
+    QCOMPARE(layout->itemAt(0,1)->geometry().left(),  45.0);
+    QCOMPARE(layout->itemAt(0,1)->geometry().right(), 70.0);
+    QCOMPARE(layout->itemAt(0,2)->geometry().left(),  70.0);
+    QCOMPARE(layout->itemAt(0,2)->geometry().right(), 95.0);
+
+    delete widget;
+
+}
+
+void tst_QGraphicsGridLayout::rowStretchFactor_data()
+{
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("") << false;
+    QTest::newRow("hasHeightForWidth") << true;
+}
+
+// public int rowStretchFactor(int row) const
+void tst_QGraphicsGridLayout::rowStretchFactor()
+{
+    QFETCH(bool, hasHeightForWidth);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 2, 3, hasHeightForWidth);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    layout->setRowStretchFactor(0, 1);
+    layout->setRowStretchFactor(1, 2);
+    layout->setRowStretchFactor(2, 3);
+    view.show();
+    widget->show();
+    widget->resize(50, 130);
+    QApplication::processEvents();
+
+    QVERIFY(layout->itemAt(0,0)->geometry().height() <  layout->itemAt(1,0)->geometry().height());
+    QVERIFY(layout->itemAt(1,0)->geometry().height() <  layout->itemAt(2,0)->geometry().height());
+    QVERIFY(layout->itemAt(0,1)->geometry().height() <  layout->itemAt(1,1)->geometry().height());
+    QVERIFY(layout->itemAt(1,1)->geometry().height() <  layout->itemAt(2,1)->geometry().height());
+
+    delete widget;
+}
+
+void tst_QGraphicsGridLayout::setColumnSpacing_data()
+{
+    QTest::addColumn<int>("column");
+    QTest::addColumn<qreal>("spacing");
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("null") << 0 << qreal(0.0) << false;
+    QTest::newRow("10") << 0 << qreal(10.0) << false;
+    QTest::newRow("null, hasHeightForWidth") << 0 << qreal(0.0) << true;
+    QTest::newRow("10, hasHeightForWidth") << 0 << qreal(10.0) << true;
+}
+
+// public void setColumnSpacing(int column, qreal spacing)
+void tst_QGraphicsGridLayout::setColumnSpacing()
+{
+    QFETCH(int, column);
+    QFETCH(qreal, spacing);
+    QFETCH(bool, hasHeightForWidth);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2, hasHeightForWidth);
+    layout->setSpacing(0);
+    layout->setContentsMargins(0, 0, 0, 0);
+    qreal oldSpacing = layout->columnSpacing(column);
+    QCOMPARE(oldSpacing, 0.0);
+    qreal w = layout->sizeHint(Qt::PreferredSize, QSizeF()).width();
+    layout->setColumnSpacing(column, spacing);
+    QApplication::processEvents();
+    QCOMPARE(layout->sizeHint(Qt::PreferredSize, QSizeF()).width(), w + spacing);
+}
+
+void tst_QGraphicsGridLayout::setGeometry_data()
+{    
+    QTest::addColumn<QRectF>("rect");
+    QTest::newRow("null") << QRectF();
+    QTest::newRow("normal") << QRectF(0,0, 50, 50);
+}
+
+// public void setGeometry(QRectF const& rect)
+void tst_QGraphicsGridLayout::setGeometry()
+{
+    QFETCH(QRectF, rect);
+
+    QGraphicsWidget *window = new QGraphicsWidget;
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    window->setLayout(layout);
+    QGraphicsGridLayout *layout2 = new QGraphicsGridLayout();
+    layout2->setMaximumSize(100, 100);
+    layout->addItem(layout2, 0, 0);
+    layout2->setGeometry(rect);
+    QCOMPARE(layout2->geometry(), rect);
+}
+
+void tst_QGraphicsGridLayout::setRowSpacing_data()
+{
+    QTest::addColumn<int>("row");
+    QTest::addColumn<qreal>("spacing");
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("null") << 0 << qreal(0.0) << false;
+    QTest::newRow("10") << 0 << qreal(10.0) << false;
+    QTest::newRow("null, hasHeightForWidth") << 0 << qreal(0.0) << true;
+    QTest::newRow("10, hasHeightForWidth") << 0 << qreal(10.0) << true;
+}
+
+// public void setRowSpacing(int row, qreal spacing)
+void tst_QGraphicsGridLayout::setRowSpacing()
+{
+    QFETCH(int, row);
+    QFETCH(qreal, spacing);
+    QFETCH(bool, hasHeightForWidth);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2, hasHeightForWidth);
+    layout->setSpacing(0);
+    layout->setContentsMargins(0, 0, 0, 0);
+    qreal oldSpacing = layout->rowSpacing(row);
+    QCOMPARE(oldSpacing, 0.0);
+    qreal h = layout->sizeHint(Qt::PreferredSize, QSizeF()).height();
+    layout->setRowSpacing(row, spacing);
+    QApplication::processEvents();
+    QCOMPARE(layout->sizeHint(Qt::PreferredSize, QSizeF()).height(), h + spacing);
+}
+
+void tst_QGraphicsGridLayout::setSpacing_data()
+{
+    QTest::addColumn<qreal>("spacing");
+    QTest::addColumn<bool>("hasHeightForWidth");
+    QTest::newRow("zero") << qreal(0.0) << false;
+    QTest::newRow("17") << qreal(17.0) << false;
+    QTest::newRow("zero, hasHeightForWidth") << qreal(0.0) << true;
+    QTest::newRow("17, hasHeightForWidth") << qreal(17.0) << true;
+}
+
+// public void setSpacing(qreal spacing)
+void tst_QGraphicsGridLayout::setSpacing()
+{
+    QFETCH(qreal, spacing);
+    QFETCH(bool, hasHeightForWidth);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2, hasHeightForWidth);
+    layout->setContentsMargins(0, 0, 0, 0);
+    QSizeF sh = layout->sizeHint(Qt::PreferredSize, QSizeF());
+    qreal oldVSpacing = layout->verticalSpacing();
+    qreal oldHSpacing = layout->horizontalSpacing();
+    if (oldVSpacing != -1) {
+        layout->setSpacing(spacing);
+        QApplication::processEvents();
+        QSizeF newSH = layout->sizeHint(Qt::PreferredSize, QSizeF());
+        QCOMPARE(newSH.height(), sh.height() - (2-1)*(oldVSpacing - spacing));
+        QCOMPARE(newSH.width(), sh.width() - (3-1)*(oldHSpacing - spacing));
+    } else {
+        QSKIP("The current style uses non-uniform layout spacing", SkipAll);
+    }
+    delete widget;
+}
+
+void tst_QGraphicsGridLayout::sizeHint_data()
+{
+    QTest::addColumn<ItemList>("itemDescriptions");
+    QTest::addColumn<QSizeF>("expectedMinimumSizeHint");
+    QTest::addColumn<QSizeF>("expectedPreferredSizeHint");
+    QTest::addColumn<QSizeF>("expectedMaximumSizeHint");
+
+    QTest::newRow("rowSpan_larger_than_rows") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(50,300))
+                                        .maxSize(QSizeF(50,300))
+                                        .rowSpan(2)
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(50,0))
+                                        .preferredSize(QSizeF(50,50))
+                                        .maxSize(QSize(50, 1000))
+                                    << ItemDesc(1,1)
+                                        .minSize(QSizeF(50,0))
+                                        .preferredSize(QSizeF(50,50))
+                                        .maxSize(QSize(50, 1000))
+                                )
+                            << QSizeF(100, 300)
+                            << QSizeF(100, 300)
+                            << QSizeF(100, 2000);
+
+    QTest::newRow("rowSpan_smaller_than_rows") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(50, 0))
+                                        .preferredSize(QSizeF(50, 50))
+                                        .maxSize(QSizeF(50, 300))
+                                        .rowSpan(2)
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(50, 50))
+                                        .preferredSize(QSizeF(50, 50))
+                                        .maxSize(QSize(50, 50))
+                                    << ItemDesc(1,1)
+                                        .minSize(QSizeF(50, 50))
+                                        .preferredSize(QSizeF(50, 50))
+                                        .maxSize(QSize(50, 50))
+                                )
+                            << QSizeF(100, 100)
+                            << QSizeF(100, 100)
+                            << QSizeF(100, 100);
+
+}
+
+// public QSizeF sizeHint(Qt::SizeHint which, QSizeF const& constraint = QSizeF()) const
+void tst_QGraphicsGridLayout::sizeHint()
+{
+    QFETCH(ItemList, itemDescriptions);
+    QFETCH(QSizeF, expectedMinimumSizeHint);
+    QFETCH(QSizeF, expectedPreferredSizeHint);
+    QFETCH(QSizeF, expectedMaximumSizeHint);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0.0);
+    widget->setContentsMargins(0, 0, 0, 0);
+
+    int i;
+    for (i = 0; i < itemDescriptions.count(); ++i) {
+        ItemDesc desc = itemDescriptions.at(i);
+        RectWidget *item = new RectWidget(widget);
+        desc.apply(layout, item);
+    }
+
+    QApplication::sendPostedEvents(0, 0);
+
+    widget->show();
+    view.show();
+    view.resize(400,300);
+    QCOMPARE(layout->sizeHint(Qt::MinimumSize), expectedMinimumSizeHint);
+    QCOMPARE(layout->sizeHint(Qt::PreferredSize), expectedPreferredSizeHint);
+    QCOMPARE(layout->sizeHint(Qt::MaximumSize), expectedMaximumSizeHint);
+
+}
+
+void tst_QGraphicsGridLayout::verticalSpacing_data()
+{
+    QTest::addColumn<qreal>("verticalSpacing");
+    QTest::newRow("zero") << qreal(0.0);
+    QTest::newRow("17") << qreal(10.0);
+}
+
+// public qreal verticalSpacing() const
+void tst_QGraphicsGridLayout::verticalSpacing()
+{
+    QFETCH(qreal, verticalSpacing);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout();
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    populateLayout(layout, 3, 2);
+    layout->setContentsMargins(0, 0, 0, 0);
+    qreal h = layout->sizeHint(Qt::PreferredSize, QSizeF()).height();
+    qreal oldSpacing = layout->verticalSpacing();
+    if (oldSpacing != -1) {
+        layout->setVerticalSpacing(verticalSpacing);
+        QApplication::processEvents();
+        qreal new_h = layout->sizeHint(Qt::PreferredSize, QSizeF()).height();
+        QCOMPARE(new_h, h - (2-1)*(oldSpacing - verticalSpacing));
+    } else {
+        QSKIP("The current style uses non-uniform layout spacing", SkipAll);
+    }
+    delete widget;
+}
+
+void tst_QGraphicsGridLayout::layoutDirection_data()
+{
+    QTest::addColumn<bool>("hasHeightForWidth");
+
+    QTest::newRow("") << false;
+    QTest::newRow("hasHeightForWidth") << true;
+}
+
+void tst_QGraphicsGridLayout::layoutDirection()
+{
+    QFETCH(bool, hasHeightForWidth);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    QGraphicsWidget *window = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+    layout->setContentsMargins(1, 2, 3, 4);
+    layout->setSpacing(6);
+    RectWidget *w1 = new RectWidget;
+    w1->setMinimumSize(30, 20);
+    layout->addItem(w1, 0, 0);
+    RectWidget *w2 = new RectWidget;
+    w2->setMinimumSize(20, 20);
+    w2->setMaximumSize(20, 20);
+    layout->addItem(w2, 0, 1);
+    RectWidget *w3 = new RectWidget;
+    w3->setMinimumSize(20, 20);
+    w3->setMaximumSize(20, 20);
+    layout->addItem(w3, 1, 0);
+    RectWidget *w4 = new RectWidget;
+    w4->setMinimumSize(30, 20);
+    layout->addItem(w4, 1, 1);
+
+    QSizePolicy policy = w1->sizePolicy();
+    policy.setHeightForWidth(hasHeightForWidth);
+    w1->setSizePolicy(policy);
+    w2->setSizePolicy(policy);
+    w4->setSizePolicy(policy);
+
+    layout->setAlignment(w2, Qt::AlignRight);
+    layout->setAlignment(w3, Qt::AlignLeft);
+
+    scene.addItem(window);
+    window->setLayout(layout);
+    view.show();
+    window->resize(70, 52);
+    QApplication::processEvents();
+    QCOMPARE(w1->geometry().left(), 1.0);
+    QCOMPARE(w1->geometry().right(), 31.0);
+    QCOMPARE(w2->geometry().left(), 47.0);
+    QCOMPARE(w2->geometry().right(), 67.0);
+    QCOMPARE(w3->geometry().left(), 1.0);
+    QCOMPARE(w3->geometry().right(), 21.0);
+    QCOMPARE(w4->geometry().left(), 37.0);
+    QCOMPARE(w4->geometry().right(), 67.0);
+
+    window->setLayoutDirection(Qt::RightToLeft);
+    QApplication::processEvents();
+    QCOMPARE(w1->geometry().left(),  39.0);
+    QCOMPARE(w1->geometry().right(), 69.0);
+    QCOMPARE(w2->geometry().left(),   3.0);
+    QCOMPARE(w2->geometry().right(), 23.0);
+    QCOMPARE(w3->geometry().left(),  49.0);
+    QCOMPARE(w3->geometry().right(), 69.0);
+    QCOMPARE(w4->geometry().left(),   3.0);
+    QCOMPARE(w4->geometry().right(), 33.0);
+
+    delete window;
+}
+
+void tst_QGraphicsGridLayout::removeLayout()
+{
+    QGraphicsScene scene;
+    RectWidget *textEdit = new RectWidget;
+    RectWidget *pushButton = new RectWidget;
+    scene.addItem(textEdit);
+    scene.addItem(pushButton);
+
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+    layout->addItem(textEdit, 0, 0);
+    layout->addItem(pushButton, 1, 0);
+
+    QGraphicsWidget *form = new QGraphicsWidget;
+    form->setLayout(layout);
+    scene.addItem(form);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWait(20);
+
+    QRectF r1 = textEdit->geometry();
+    QRectF r2 = pushButton->geometry();
+    form->setLayout(0);
+    //documentation of QGraphicsWidget::setLayout:
+    //If layout is 0, the widget is left without a layout. Existing subwidgets' geometries will remain unaffected.
+    QCOMPARE(textEdit->geometry(), r1);
+    QCOMPARE(pushButton->geometry(), r2);
+}
+
+void tst_QGraphicsGridLayout::defaultStretchFactors_data()
+{
+    QTest::addColumn<ItemList>("itemDescriptions");
+    QTest::addColumn<QSizeF>("newSize");
+    QTest::addColumn<SizeList>("expectedSizes");
+
+    QTest::newRow("usepreferredsize") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,2)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,2)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                )
+                            << QSizeF()
+                            << (SizeList()
+                                << QSizeF(10,10) << QSizeF(10,10) << QSizeF(10,10)
+                                << QSizeF(10,10) << QSizeF(10,10) << QSizeF(10,10)
+                            );
+
+    QTest::newRow("ignoreitem01") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,1)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,2)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,2)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                )
+                            << QSizeF()
+                            << (SizeList()
+                                << QSizeF(10,10) << QSizeF(10,10) << QSizeF(10,10)
+                                << QSizeF(10,10) << QSizeF(10,10) << QSizeF(10,10)
+                            );
+
+    QTest::newRow("ignoreitem01_resize120x40") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,1)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(20,10))
+                                    << ItemDesc(0,2)
+                                        .preferredSizeHint(QSizeF(30,10))
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,1)
+                                        .preferredSizeHint(QSizeF(20,10))
+                                    << ItemDesc(1,2)
+                                        .preferredSizeHint(QSizeF(30,10))
+                                )
+                            << QSizeF(120, 40)
+                            << (SizeList()
+                                << QSizeF(20,20) << QSizeF(40,20) << QSizeF(60,20)
+                                << QSizeF(20,20) << QSizeF(40,20) << QSizeF(60,20)
+                            );
+
+    QTest::newRow("ignoreitem11_resize120x40") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,1)
+                                        .preferredSizeHint(QSizeF(20,10))
+                                    << ItemDesc(0,2)
+                                        .preferredSizeHint(QSizeF(30,10))
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,20))
+                                    << ItemDesc(1,1)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(20,20))
+                                    << ItemDesc(1,2)
+                                        .preferredSizeHint(QSizeF(30,20))
+                                )
+                            << QSizeF(120, 60)
+                            << (SizeList()
+                                << QSizeF(20,20) << QSizeF(40,20) << QSizeF(60,20)
+                                << QSizeF(20,40) << QSizeF(40,40) << QSizeF(60,40)
+                            );
+
+    QTest::newRow("ignoreitem01_span01_resize70x60") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,1)
+                                        .preferredSizeHint(QSizeF(20,10))
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .rowSpan(2)
+                                    << ItemDesc(0,2)
+                                        .preferredSizeHint(QSizeF(30,10))
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,20))
+                                    << ItemDesc(1,2)
+                                        .preferredSizeHint(QSizeF(30,20))
+                                )
+                            << QSizeF(70, 60)
+                            << (SizeList()
+                                << QSizeF(20,20) << QSizeF(10,60) << QSizeF(40,20)
+                                << QSizeF(20,40) << QSizeF(40,40)
+                            );
+
+    QTest::newRow("ignoreitem10_resize40x120") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,0)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(10,20))
+                                    << ItemDesc(1,1)
+                                        .preferredSizeHint(QSizeF(10,20))
+                                    << ItemDesc(2,0)
+                                        .preferredSizeHint(QSizeF(10,30))
+                                    << ItemDesc(2,1)
+                                        .preferredSizeHint(QSizeF(10,30))
+                                )
+                            << QSizeF(40, 120)
+                            << (SizeList()
+                                << QSizeF(20,20) << QSizeF(20,20)
+                                << QSizeF(20,40) << QSizeF(20,40)
+                                << QSizeF(20,60) << QSizeF(20,60)
+                            );
+
+    QTest::newRow("ignoreitem01_span02") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,1)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(10,20))
+                                        .rowSpan(2)
+                                    << ItemDesc(0,2)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,2)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                )
+                            << QSizeF()
+                            << (SizeList()
+                                << QSizeF(10,10) << QSizeF(0,20) << QSizeF(10,10)
+                                << QSizeF(10,10) << QSizeF(10,10)
+                            );
+
+    QTest::newRow("ignoreitem02_span02") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,2)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(10,20))
+                                        .rowSpan(2)
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                )
+                            << QSizeF()
+                            << (SizeList()
+                                << QSizeF(10,10) << QSizeF(10,10) << QSizeF(0,20)
+                                << QSizeF(10,10) << QSizeF(10,10)
+                            );
+
+    QTest::newRow("ignoreitem02_span00_span02") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                        .rowSpan(2)
+                                    << ItemDesc(0,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,2)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(10,20))
+                                        .rowSpan(2)
+                                    << ItemDesc(1,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                )
+                            << QSizeF()
+                            << (SizeList()
+                                << QSizeF(10,20) << QSizeF(10,10) << QSizeF(0,20)
+                                << QSizeF(10,10)
+                            );
+
+    QTest::newRow("ignoreitem00_colspan00") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(10,20))
+                                        .colSpan(2)
+                                    << ItemDesc(0,2)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,2)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                )
+                            << QSizeF()
+                            << (SizeList()
+                                << QSizeF(20,10) << QSizeF(10,10) << QSizeF(10,10)
+                                << QSizeF(10,10) << QSizeF(10,10)
+                            );
+
+    QTest::newRow("ignoreitem01_colspan01") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,1)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(10,20))
+                                        .colSpan(2)
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,2)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                )
+                            << QSizeF()
+                            << (SizeList()
+                                << QSizeF(10,10) << QSizeF(20,10) << QSizeF(10,10)
+                                << QSizeF(10,10) << QSizeF(10,10)
+                            );
+
+    QTest::newRow("ignorecolumn1_resize70x60") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,1)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(20,10))
+                                    << ItemDesc(0,2)
+                                        .preferredSizeHint(QSizeF(30,10))
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,20))
+                                    << ItemDesc(1,1)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(20,20))
+                                    << ItemDesc(1,2)
+                                        .preferredSizeHint(QSizeF(30,20))
+                                )
+                            << QSizeF(70, 60)
+                            << (SizeList()
+                                << QSizeF(20,20) << QSizeF(10,20) << QSizeF(40,20)
+                                << QSizeF(20,40) << QSizeF(10,40) << QSizeF(40,40)
+                            );
+
+    QTest::newRow("ignorerow0") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,1)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,2)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,2)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                )
+                            << QSizeF()
+                            << (SizeList()
+                                << QSizeF(10,0) << QSizeF(10,0) << QSizeF(10,0)
+                                << QSizeF(10,10) << QSizeF(10,10) << QSizeF(10,10)
+                            );
+
+    QTest::newRow("ignorerow1") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,2)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,0)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,1)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(1,2)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                )
+                            << QSizeF()
+                            << (SizeList()
+                                << QSizeF(10,10) << QSizeF(10,10) << QSizeF(10,10)
+                                << QSizeF(10,0) << QSizeF(10,0) << QSizeF(10,0)
+                            );
+
+    QTest::newRow("ignorerow0_resize60x50") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                    << ItemDesc(0,1)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(20,10))
+                                    << ItemDesc(0,2)
+                                        .sizePolicy(QSizePolicy::Ignored)
+                                        .preferredSizeHint(QSizeF(30,10))
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,30))
+                                    << ItemDesc(1,1)
+                                        .preferredSizeHint(QSizeF(20,30))
+                                    << ItemDesc(1,2)
+                                        .preferredSizeHint(QSizeF(30,30))
+                                )
+                            << QSizeF(60, 50)
+                            << (SizeList()
+                                << QSizeF(10,10) << QSizeF(20,10) << QSizeF(30,10)
+                                << QSizeF(10,40) << QSizeF(20,40) << QSizeF(30,40)
+                            );
+
+}
+
+void tst_QGraphicsGridLayout::defaultStretchFactors()
+{
+    QFETCH(ItemList, itemDescriptions);
+    QFETCH(QSizeF, newSize);
+    QFETCH(SizeList, expectedSizes);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0.0);
+    widget->setContentsMargins(0, 0, 0, 0);
+
+    int i;
+    for (i = 0; i < itemDescriptions.count(); ++i) {
+        ItemDesc desc = itemDescriptions.at(i);
+        RectWidget *item = new RectWidget(widget);
+        desc.apply(layout, item);
+    }
+
+    QApplication::sendPostedEvents(0, 0);
+
+    widget->show();
+    view.show();
+    view.resize(400,300);
+    if (newSize.isValid())
+        widget->resize(newSize);
+
+    QApplication::sendPostedEvents(0, 0);
+    for (i = 0; i < expectedSizes.count(); ++i) {
+        QSizeF itemSize = layout->itemAt(i)->geometry().size();
+        QCOMPARE(itemSize, expectedSizes.at(i));
+    }
+
+    delete widget;
+}
+
+typedef QList<QRectF> RectList;
+Q_DECLARE_METATYPE(RectList);
+
+void tst_QGraphicsGridLayout::alignment2_data()
+{
+    QTest::addColumn<ItemList>("itemDescriptions");
+    QTest::addColumn<QSizeF>("newSize");
+    QTest::addColumn<RectList>("expectedGeometries");
+
+    QTest::newRow("hor_sizepolicy_fixed") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,20))
+                                        .sizePolicyV(QSizePolicy::Fixed)
+                                    << ItemDesc(0,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                        .sizePolicyV(QSizePolicy::Fixed)
+                                )
+                            << QSizeF()
+                            << (RectList()
+                                << QRectF(0, 0, 10,20) << QRectF(10, 0, 10,10)
+                            );
+
+    QTest::newRow("hor_sizepolicy_fixed_alignvcenter") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,20))
+                                        .sizePolicyV(QSizePolicy::Fixed)
+                                    << ItemDesc(0,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                        .sizePolicyV(QSizePolicy::Fixed)
+                                        .alignment(Qt::AlignVCenter)
+                                )
+                            << QSizeF()
+                            << (RectList()
+                                << QRectF(0, 0, 10,20) << QRectF(10, 5, 10,10)
+                            );
+
+    QTest::newRow("hor_sizepolicy_fixed_aligntop") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,20))
+                                        .sizePolicyV(QSizePolicy::Fixed)
+                                    << ItemDesc(0,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                        .sizePolicyV(QSizePolicy::Fixed)
+                                        .alignment(Qt::AlignTop)
+                                )
+                            << QSizeF()
+                            << (RectList()
+                                << QRectF(0, 0, 10,20) << QRectF(10, 0, 10,10)
+                            );
+
+    QTest::newRow("hor_sizepolicy_fixed_alignbottom") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(10,20))
+                                        .sizePolicyV(QSizePolicy::Fixed)
+                                    << ItemDesc(0,1)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                        .sizePolicyV(QSizePolicy::Fixed)
+                                        .alignment(Qt::AlignBottom)
+                                )
+                            << QSizeF()
+                            << (RectList()
+                                << QRectF(0, 0, 10,20) << QRectF(10, 10, 10,10)
+                            );
+
+    QTest::newRow("ver_sizepolicy_fixed") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(20,10))
+                                        .sizePolicyH(QSizePolicy::Fixed)
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                        .sizePolicyH(QSizePolicy::Fixed)
+                                )
+                            << QSizeF()
+                            << (RectList()
+                                << QRectF(0, 0, 20,10) << QRectF(0, 10, 10,10)
+                            );
+
+    QTest::newRow("ver_sizepolicy_fixed_alignhcenter") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(20,10))
+                                        .sizePolicyH(QSizePolicy::Fixed)
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                        .sizePolicyH(QSizePolicy::Fixed)
+                                        .alignment(Qt::AlignHCenter)
+                                )
+                            << QSizeF()
+                            << (RectList()
+                                << QRectF(0, 0, 20,10) << QRectF(5, 10, 10,10)
+                            );
+
+    QTest::newRow("ver_sizepolicy_fixed_alignleft") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(20,10))
+                                        .sizePolicyH(QSizePolicy::Fixed)
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                        .sizePolicyH(QSizePolicy::Fixed)
+                                        .alignment(Qt::AlignLeft)
+                                )
+                            << QSizeF()
+                            << (RectList()
+                                << QRectF(0, 0, 20,10) << QRectF(0, 10, 10,10)
+                            );
+
+    QTest::newRow("ver_sizepolicy_fixed_alignright") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .preferredSizeHint(QSizeF(20,10))
+                                        .sizePolicyH(QSizePolicy::Fixed)
+                                    << ItemDesc(1,0)
+                                        .preferredSizeHint(QSizeF(10,10))
+                                        .sizePolicyH(QSizePolicy::Fixed)
+                                        .alignment(Qt::AlignRight)
+                                )
+                            << QSizeF()
+                            << (RectList()
+                                << QRectF(0, 0, 20,10) << QRectF(10, 10, 10,10)
+                            );
+}
+
+void tst_QGraphicsGridLayout::alignment2()
+{
+    QFETCH(ItemList, itemDescriptions);
+    QFETCH(QSizeF, newSize);
+    QFETCH(RectList, expectedGeometries);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0.0);
+    widget->setContentsMargins(0, 0, 0, 0);
+
+    int i;
+    for (i = 0; i < itemDescriptions.count(); ++i) {
+        ItemDesc desc = itemDescriptions.at(i);
+        RectWidget *item = new RectWidget(widget);
+        desc.apply(layout, item);
+    }
+
+    QApplication::sendPostedEvents(0, 0);
+
+    widget->show();
+    view.resize(400,300);
+    view.show();
+    if (newSize.isValid())
+        widget->resize(newSize);
+
+    QApplication::sendPostedEvents(0, 0);
+    for (i = 0; i < expectedGeometries.count(); ++i) {
+        QRectF itemRect = layout->itemAt(i)->geometry();
+        QCOMPARE(itemRect, expectedGeometries.at(i));
+    }
+
+    delete widget;
+}
+
+static QSizeF hfw1(Qt::SizeHint, const QSizeF &constraint)
+{
+    QSizeF result(constraint);
+    const qreal ch = constraint.height();
+    const qreal cw = constraint.width();
+    if (cw < 0 && ch < 0) {
+        return QSizeF(50, 400);
+    } else if (cw > 0) {
+        result.setHeight(20000./cw);
+    }
+    return result;
+}
+
+static QSizeF wfh1(Qt::SizeHint, const QSizeF &constraint)
+{
+    QSizeF result(constraint);
+    const qreal ch = constraint.height();
+    const qreal cw = constraint.width();
+    if (cw < 0 && ch < 0) {
+        return QSizeF(400, 50);
+    } else if (ch > 0) {
+        result.setWidth(20000./ch);
+    }
+    return result;
+}
+
+static QSizeF wfh2(Qt::SizeHint, const QSizeF &constraint)
+{
+    QSizeF result(constraint);
+    const qreal ch = constraint.height();
+    const qreal cw = constraint.width();
+    if (ch < 0 && cw < 0)
+        return QSizeF(50, 50);
+    if (ch >= 0)
+        result.setWidth(ch);
+    return result;
+}
+
+static QSizeF hfw3(Qt::SizeHint, const QSizeF &constraint)
+{
+    QSizeF result(constraint);
+    const qreal ch = constraint.height();
+    const qreal cw = constraint.width();
+    if (cw < 0 && ch < 0) {
+        return QSizeF(10, 10);
+    } else if (cw > 0) {
+        result.setHeight(100./cw);
+    }
+    return result;
+}
+
+static QSizeF hfw2(Qt::SizeHint /*which*/, const QSizeF &constraint)
+{
+    return QSizeF(constraint.width(), constraint.width());
+}
+
+void tst_QGraphicsGridLayout::geometries_data()
+{
+
+    QTest::addColumn<ItemList>("itemDescriptions");
+    QTest::addColumn<QSizeF>("newSize");
+    QTest::addColumn<RectList>("expectedGeometries");
+
+    QTest::newRow("combine_max_sizes") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .maxSize(QSizeF(50,10))
+                                    << ItemDesc(1,0)
+                                        .maxSize(QSizeF(10,10))
+                                )
+                            << QSizeF(50, 20)
+                            << (RectList()
+                                << QRectF(0, 0, 50,10) << QRectF(0, 10, 10,10)
+                            );
+
+    QTest::newRow("combine_min_sizes") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(50,10))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(10,10))
+                                )
+                            << QSizeF(60, 20)
+                            << (RectList()
+                                << QRectF(0, 0, 60,10) << QRectF(0, 10, 60,10)
+                            );
+
+    // change layout height and verify
+    QTest::newRow("hfw-100x401") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .minSize(QSizeF(40,-1))
+                                        .preferredSize(QSizeF(50,-1))
+                                        .maxSize(QSizeF(500, -1))
+                                        .dynamicConstraint(hfw1, Qt::Vertical)
+                                )
+                            << QSizeF(100, 401)
+                            << (RectList()
+                                << QRectF(0, 0, 50,  1) << QRectF(50, 0, 50,  1)
+                                << QRectF(0, 1, 50,100) << QRectF(50, 1, 50,400)
+                            );
+    QTest::newRow("hfw-h408") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .sizeHint(Qt::MinimumSize, QSizeF(40,40))
+                                        .sizeHint(Qt::PreferredSize, QSizeF(50,400))
+                                        .sizeHint(Qt::MaximumSize, QSizeF(500, 500))
+                                        .dynamicConstraint(hfw1, Qt::Vertical)
+                                )
+                            << QSizeF(100, 408)
+                            << (RectList()
+                                << QRectF(0, 0, 50,  8) << QRectF(50,  0, 50,  8)
+                                << QRectF(0, 8, 50,100) << QRectF(50,  8, 50,400)
+                            );
+    QTest::newRow("hfw-h410") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .minSize(QSizeF(40,40))
+                                        .preferredSize(QSizeF(50,400))
+                                        .maxSize(QSizeF(500, 500))
+                                        .dynamicConstraint(hfw1, Qt::Vertical)
+                                )
+                            << QSizeF(100, 410)
+                            << (RectList()
+                                << QRectF(0, 0, 50,10) << QRectF(50, 0, 50,10)
+                                << QRectF(0, 10, 50,100) << QRectF(50, 10, 50,400)
+                            );
+
+    QTest::newRow("hfw-100x470") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .sizeHint(Qt::MinimumSize, QSizeF(40,40))
+                                        .sizeHint(Qt::PreferredSize, QSizeF(50,400))
+                                        .sizeHint(Qt::MaximumSize, QSizeF(500,500))
+                                        .dynamicConstraint(hfw1, Qt::Vertical)
+                                )
+                            << QSizeF(100, 470)
+                            << (RectList()
+                                << QRectF(0, 0, 50,70) << QRectF(50, 0, 50,70)
+                                << QRectF(0, 70, 50,100) << QRectF(50, 70, 50,400)
+                            );
+
+    // change layout width and verify
+    QTest::newRow("hfw-100x401") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .minSize(QSizeF(-1,-1))
+                                        .preferredSize(QSizeF(-1,-1))
+                                        .maxSize(QSizeF(-1, -1))
+                                        .dynamicConstraint(hfw1, Qt::Vertical)
+                                )
+                            << QSizeF(100, 401)
+                            << (RectList()
+                                << QRectF( 0, 0,  50,   1) << QRectF( 50,  0,  50,   1)
+                                << QRectF( 0, 1,  50, 100) << QRectF( 50,  1,  50, 400)
+                            );
+
+    QTest::newRow("hfw-160x350") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .sizeHint(Qt::MinimumSize, QSizeF(40,40))
+                                        .sizeHint(Qt::PreferredSize, QSizeF(50,400))
+                                        .sizeHint(Qt::MaximumSize, QSizeF(5000,5000))
+                                       .dynamicConstraint(hfw1, Qt::Vertical)
+                                )
+                            << QSizeF(160, 350)
+                            << (RectList()
+                                << QRectF( 0,   0,  80, 100) << QRectF( 80,   0,  80, 100)
+                                << QRectF( 0, 100,  80, 100) << QRectF( 80, 100,  80, 250)
+                            );
+
+    QTest::newRow("hfw-160x300") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .sizeHint(Qt::MinimumSize, QSizeF(40,40))
+                                        .sizeHint(Qt::PreferredSize, QSizeF(50,400))
+                                        .sizeHint(Qt::MaximumSize, QSizeF(5000, 5000))
+                                        .dynamicConstraint(hfw1, Qt::Vertical)
+                                )
+                            << QSizeF(160, 300)
+                            << (RectList()
+                                << QRectF( 0,   0,  80,  50) << QRectF( 80,   0,  80,  50)
+                                << QRectF( 0,  50,  80, 100) << QRectF( 80,  50,  80, 250)
+                            );
+
+    QTest::newRow("hfw-20x40") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,10))
+                                        .preferredSize(QSizeF(50,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .sizeHint(Qt::MinimumSize, QSizeF(1, 1))
+                                        .sizeHint(Qt::PreferredSize, QSizeF(50, 50))
+                                        .sizeHint(Qt::MaximumSize, QSizeF(100, 100))
+                                        .dynamicConstraint(hfw3, Qt::Vertical)
+                                )
+                            << QSizeF(20, 40)
+                            << (RectList()
+                                << QRectF(0,  0, 10, 20) << QRectF(10,  0, 10, 20)
+                                << QRectF(0, 20, 10, 20) << QRectF(10, 20, 10, 10)
+                            );
+
+    QTest::newRow("wfh-300x160") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(10,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(10,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(10,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .sizeHint(Qt::MinimumSize, QSizeF(10,10))
+                                        .sizeHint(Qt::PreferredSize, QSizeF(400,50))
+                                        .sizeHint(Qt::MaximumSize, QSizeF(5000, 5000))
+                                        .dynamicConstraint(wfh1, Qt::Horizontal)
+                                )
+                            << QSizeF(300, 160)
+                            << (RectList()
+                                << QRectF( 0,   0,  50,  80) << QRectF( 50,   0, 100,  80)
+                                << QRectF( 0,  80,  50,  80) << QRectF( 50,  80, 250,  80)
+                            );
+
+    QTest::newRow("wfh-40x20") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                    // Note, must be 10 in order to match stretching  of wfh item
+                                    // below (the same stretch makes it easier to test)
+                                        .minSize(QSizeF(10,1))
+                                        .preferredSize(QSizeF(50,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .sizeHint(Qt::MinimumSize, QSizeF(1,1))
+                                        .sizeHint(Qt::PreferredSize, QSizeF(50,50))
+                                        .sizeHint(Qt::MaximumSize, QSizeF(100, 100))
+                                        .dynamicConstraint(wfh2, Qt::Horizontal)
+                                )
+                            << QSizeF(40, 20)
+                            << (RectList()
+                                << QRectF(0,  0, 20, 10) << QRectF(20,  0, 20, 10)
+                                << QRectF(0, 10, 20, 10) << QRectF(20, 10, 10, 10)
+                            );
+
+    QTest::newRow("wfh-400x160") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .sizeHint(Qt::MinimumSize, QSizeF(1,1))
+                                        .sizeHint(Qt::PreferredSize, QSizeF(50,50))
+                                        .sizeHint(Qt::MaximumSize, QSizeF(100, 100))
+                                        .dynamicConstraint(wfh2, Qt::Horizontal)
+                                )
+
+                            << QSizeF(400, 160)
+                            << (RectList()
+                                << QRectF(0,  0, 100, 80) << QRectF(100,  0, 100, 80)
+                                << QRectF(0, 80, 100, 80) << QRectF(100, 80,  80, 80)
+                            );
+
+    QTest::newRow("wfh-160x100") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,1))
+                                        // Note, preferred width must be 50 in order to match
+                                        // preferred width of wfh item below.
+                                        // (The same preferred size makes the stretch the same, and
+                                        // makes it easier to test) (The stretch algorithm is a
+                                        // blackbox)
+                                        .preferredSize(QSizeF(50,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(10,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(10,50))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .sizeHint(Qt::MinimumSize, QSizeF(1,1))
+                                        .sizeHint(Qt::PreferredSize, QSizeF(10,50))
+                                        .sizeHint(Qt::MaximumSize, QSizeF(500, 500))
+                                        .dynamicConstraint(wfh2, Qt::Horizontal)
+                                )
+                            << QSizeF(160, 100)
+                            << (RectList()
+                                << QRectF(0,  0,  80,  50) << QRectF( 80,  0,  80,  50)
+                                << QRectF(0, 50,  80,  50) << QRectF( 80, 50,  50,  50)
+                            );
+
+    QTest::newRow("hfw-h470") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .sizeHint(Qt::MinimumSize, QSizeF(40,40))
+                                        .sizeHint(Qt::PreferredSize, QSizeF(50,400))
+                                        .sizeHint(Qt::MaximumSize, QSizeF(500,500))
+                                        .dynamicConstraint(hfw1, Qt::Vertical)
+                                )
+                            << QSizeF(100, 470)
+                            << (RectList()
+                                << QRectF(0, 0, 50,70) << QRectF(50, 0, 50,70)
+                                << QRectF(0, 70, 50,100) << QRectF(50, 70, 50,400)
+                            );
+
+    // change layout width and verify
+    QTest::newRow("hfw-w100") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .sizeHint(Qt::MinimumSize, QSizeF(40,40))
+                                        .sizeHint(Qt::PreferredSize, QSizeF(50,400))
+                                        .sizeHint(Qt::MaximumSize, QSizeF(5000,5000))
+                                        .dynamicConstraint(hfw1, Qt::Vertical)
+                                )
+                            << QSizeF(100, 401)
+                            << (RectList()
+                                << QRectF( 0, 0,  50,   1) << QRectF( 50,  0,  50,   1)
+                                << QRectF( 0, 1,  50, 100) << QRectF( 50,  1,  50, 400)
+                            );
+
+    QTest::newRow("hfw-w160") << (ItemList()
+                                     << ItemDesc(0,0)
+                                         .minSize(QSizeF(1,1))
+                                         .preferredSize(QSizeF(50,10))
+                                         .maxSize(QSizeF(100, 100))
+                                     << ItemDesc(0,1)
+                                         .minSize(QSizeF(1,1))
+                                         .preferredSize(QSizeF(50,10))
+                                         .maxSize(QSizeF(100, 100))
+                                     << ItemDesc(1,0)
+                                         .minSize(QSizeF(1,1))
+                                         .preferredSize(QSizeF(50,10))
+                                         .maxSize(QSizeF(100, 100))
+                                     << ItemDesc(1,1)
+                                         .sizeHint(Qt::MinimumSize, QSizeF(40,40))
+                                         .sizeHint(Qt::PreferredSize, QSizeF(50,400))
+                                         .sizeHint(Qt::MaximumSize, QSizeF(5000,5000))
+                                         .dynamicConstraint(hfw1, Qt::Vertical)
+                                 )
+                             << QSizeF(160, 350)
+                             << (RectList()
+                                 << QRectF( 0,   0,  80, 100) << QRectF( 80,   0,  80, 100)
+                                 << QRectF( 0, 100,  80, 100) << QRectF( 80, 100,  80, 250)
+                             );
+
+    QTest::newRow("hfw-w500") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(0,1)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(1,1))
+                                        .preferredSize(QSizeF(50,10))
+                                        .maxSize(QSizeF(100, 100))
+                                    << ItemDesc(1,1)
+                                        .sizeHint(Qt::MinimumSize, QSizeF(40,40))
+                                        .sizeHint(Qt::PreferredSize, QSizeF(50,400))
+                                        .sizeHint(Qt::MaximumSize, QSizeF(5000,5000))
+                                        .dynamicConstraint(hfw1, Qt::Vertical)
+                                )
+                            << QSizeF(500, 200)
+                            << (RectList()
+                                << QRectF( 0,   0, 100, 100) << QRectF(100,   0, 100, 100)
+                                << QRectF( 0, 100, 100, 100) << QRectF(100, 100, 400,  50)
+                            );
+
+    QTest::newRow("hfw-alignment-defaults") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(100, 100))
+                                        .maxSize(QSizeF(100, 100))
+                                        .dynamicConstraint(hfw2, Qt::Vertical)
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(200, 200))
+                                        .maxSize(QSizeF(200, 200))
+                                        .dynamicConstraint(hfw2, Qt::Vertical)
+                                    << ItemDesc(2,0)
+                                        .minSize(QSizeF(300, 300))
+                                        .maxSize(QSizeF(300, 300))
+                                )
+                            << QSizeF(300, 600)
+                            << (RectList()
+                                << QRectF(0, 0,   100, 100)
+                                << QRectF(0, 100, 200, 200)
+                                << QRectF(0, 300, 300, 300)
+                            );
+
+    QTest::newRow("hfw-alignment2") << (ItemList()
+                                    << ItemDesc(0,0)
+                                        .minSize(QSizeF(100, 100))
+                                        .maxSize(QSizeF(100, 100))
+                                        .dynamicConstraint(hfw2, Qt::Vertical)
+                                        .alignment(Qt::AlignRight)
+                                    << ItemDesc(1,0)
+                                        .minSize(QSizeF(200, 200))
+                                        .maxSize(QSizeF(200, 200))
+                                        .dynamicConstraint(hfw2, Qt::Vertical)
+                                        .alignment(Qt::AlignHCenter)
+                                    << ItemDesc(2,0)
+                                        .minSize(QSizeF(300, 300))
+                                        .maxSize(QSizeF(300, 300))
+                                )
+                            << QSizeF(300, 600)
+                            << (RectList()
+                                << QRectF(200, 0,   100, 100)
+                                << QRectF( 50, 100, 200, 200)
+                                << QRectF(  0, 300, 300, 300)
+                            );
+
+}
+
+void tst_QGraphicsGridLayout::geometries()
+{
+    QFETCH(ItemList, itemDescriptions);
+    QFETCH(QSizeF, newSize);
+    QFETCH(RectList, expectedGeometries);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0.0);
+    widget->setContentsMargins(0, 0, 0, 0);
+
+    int i;
+    for (i = 0; i < itemDescriptions.count(); ++i) {
+        ItemDesc desc = itemDescriptions.at(i);
+        RectWidget *item = new RectWidget(widget);
+        desc.apply(layout, item);
+    }
+
+    QApplication::processEvents();
+
+    widget->show();
+    view.resize(400,300);
+    view.show();
+    if (newSize.isValid())
+        widget->resize(newSize);
+
+    QApplication::processEvents();
+    for (i = 0; i < expectedGeometries.count(); ++i) {
+        QRectF itemRect = layout->itemAt(i)->geometry();
+        QCOMPARE(itemRect, expectedGeometries.at(i));
+    }
+
+    delete widget;
+}
+
+void tst_QGraphicsGridLayout::avoidRecursionInInsertItem()
+{
+    QGraphicsWidget window(0, Qt::Window);
+	QGraphicsGridLayout *layout = new QGraphicsGridLayout(&window);
+    QCOMPARE(layout->count(), 0);
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsGridLayout::addItem: cannot insert itself");
+    layout->addItem(layout, 0, 0);
+    QCOMPARE(layout->count(), 0);
+}
+
+void tst_QGraphicsGridLayout::styleInfoLeak()
+{
+    QGraphicsGridLayout grid;
+    grid.horizontalSpacing();
+}
+
+void tst_QGraphicsGridLayout::task236367_maxSizeHint()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+    widget->setLayout(layout);
+    layout->setContentsMargins(0, 0, 0, 0);
+    int w = 203;
+    int h = 204;
+    widget->resize(w, h);
+    QCOMPARE(widget->size(), QSizeF(w, h));
+}
+
+static QSizeF hfw(Qt::SizeHint /*which*/, const QSizeF &constraint)
+{
+    QSizeF result(constraint);
+    const qreal cw = constraint.width();
+    const qreal ch = constraint.height();
+    if (cw < 0 && ch < 0) {
+        return QSizeF(200, 100);
+    } else if (cw >= 0) {
+        result.setHeight(20000./cw);
+    } else if (cw == 0) {
+        result.setHeight(20000);
+    } else if (ch >= 0) {
+        result.setWidth(20000./ch);
+    } else if (ch == 0) {
+        result.setWidth(20000);
+    }
+    return result;
+}
+
+static QSizeF wfh(Qt::SizeHint /*which*/, const QSizeF &constraint)
+{
+    QSizeF result(constraint);
+    const qreal ch = constraint.height();
+    if (ch >= 0) {
+        result.setWidth(ch);
+    }
+    return result;
+}
+
+bool qFuzzyCompare(const QSizeF &a, const QSizeF &b)
+{
+    return qFuzzyCompare(a.width(), b.width()) && qFuzzyCompare(a.height(), b.height());
+}
+
+void tst_QGraphicsGridLayout::heightForWidth()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+    widget->setLayout(layout);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+    RectWidget *w00 = new RectWidget;
+    w00->setSizeHint(Qt::MinimumSize, QSizeF(1,1));
+    w00->setSizeHint(Qt::PreferredSize, QSizeF(10,10));
+    w00->setSizeHint(Qt::MaximumSize, QSizeF(100,100));
+    layout->addItem(w00, 0, 0);
+
+    RectWidget *w01 = new RectWidget;
+    w01->setSizeHint(Qt::MinimumSize, QSizeF(1,1));
+    w01->setSizeHint(Qt::PreferredSize, QSizeF(10,10));
+    w01->setSizeHint(Qt::MaximumSize, QSizeF(100,100));
+    layout->addItem(w01, 0, 1);
+
+    RectWidget *w10 = new RectWidget;
+    w10->setSizeHint(Qt::MinimumSize, QSizeF(1,1));
+    w10->setSizeHint(Qt::PreferredSize, QSizeF(10,10));
+    w10->setSizeHint(Qt::MaximumSize, QSizeF(100,100));
+    layout->addItem(w10, 1, 0);
+
+    RectWidget *w11 = new RectWidget;
+    w11->setSizeHint(Qt::MinimumSize, QSizeF(1,1));
+    w11->setSizeHint(Qt::MaximumSize, QSizeF(30000,30000));
+    w11->setConstraintFunction(hfw);
+    QSizePolicy sp(QSizePolicy::Preferred, QSizePolicy::Preferred);
+    sp.setHeightForWidth(true);
+    w11->setSizePolicy(sp);
+    layout->addItem(w11, 1, 1);
+
+    QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1)), QSizeF(2, 2));
+    QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1)), QSizeF(210, 110));
+    QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(-1, -1)), QSizeF(30100, 30100));
+
+    QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(2, -1)), QSizeF(2, 20001));
+    QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(2, -1)), QSizeF(2, 20010));
+    QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(2, -1)), QSizeF(2, 20100));
+
+    // Since 20 is somewhere between "minimum width hint" (2) and
+    // "preferred width hint" (210), it will try to do distribution by
+    // stretching them with different factors.
+    // Since column 1 has a "preferred width" of 200 it means that
+    // column 1 will be a bit wider than column 0. Thus it will also be a bit
+    // shorter than 2001, (the expected height if all columns had width=10)
+    QSizeF sh = layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(20, -1));
+    // column 1 cannot be wider than 19, which means that it must be taller than 20000/19~=1052
+    QVERIFY(sh.height() < 2000 + 1 && sh.height() > 1052 + 1);
+
+    sh = layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(20, -1));
+    QVERIFY(sh.height() < 2000 + 10 && sh.height() > 1052 + 10);
+
+    sh = layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(20, -1));
+    QVERIFY(sh.height() < 2000 + 100 && sh.height() > 1052 + 100);
+
+    // the height of the hfw widget is shorter than the one to the left, which is 100, so
+    // the total height of the last row is 100 (which leaves the layout height to be 200)
+    QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(500, -1)), QSizeF(500, 100 + 100));
+
+}
+
+void tst_QGraphicsGridLayout::widthForHeight()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+    widget->setLayout(layout);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    RectWidget *w00 = new RectWidget;
+    w00->setMinimumSize(1, 1);
+    w00->setPreferredSize(50, 50);
+    w00->setMaximumSize(100, 100);
+
+    layout->addItem(w00, 0, 0);
+
+    RectWidget *w01 = new RectWidget;
+    w01->setMinimumSize(1,1);
+    w01->setPreferredSize(50,50);
+    w01->setMaximumSize(100,100);
+    layout->addItem(w01, 0, 1);
+
+    RectWidget *w10 = new RectWidget;
+    w10->setMinimumSize(1,1);
+    w10->setPreferredSize(50,50);
+    w10->setMaximumSize(100,100);
+    layout->addItem(w10, 1, 0);
+
+    RectWidget *w11 = new RectWidget;
+    w11->setSizeHint(Qt::MinimumSize, QSizeF(1,1));
+    w11->setSizeHint(Qt::PreferredSize, QSizeF(50,50));
+    w11->setSizeHint(Qt::MaximumSize, QSizeF(30000,30000));
+
+    // This will make sure its always square.
+    w11->setConstraintFunction(wfh);
+    QSizePolicy sp(QSizePolicy::Preferred, QSizePolicy::Preferred);
+    sp.setWidthForHeight(true);
+    w11->setSizePolicy(sp);
+    layout->addItem(w11, 1, 1);
+
+    /*
+         | 1, 50, 100   | 1, 50, 100   |
+    -----+--------------+--------------+
+        1|              |              |
+       50|              |              |
+      100|              |              |
+    -----|--------------+--------------+
+        1|              |              |
+       50|              |  WFH         |
+      100|              |              |
+    -----------------------------------+
+    */
+
+
+    QSizeF prefSize = layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1));
+    QCOMPARE(prefSize, QSizeF(50+50, 50+50));
+
+    // wfh(1):  = 1
+    QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, 2)), QSizeF(1 + 1, 2));
+    QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, 2)), QSizeF(50 + 50, 2));
+    QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(-1, 2)), QSizeF(100 + 100, 2));
+
+    // wfh(40) = 40
+    QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, 80)), QSizeF(1 + 40, 80));
+    QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, 80)), QSizeF(50 + 50, 80));
+    QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(-1, 80)), QSizeF(100 + 100, 80));
+
+    // wfh(80) = 80
+    QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, 160)), QSizeF(1 + 80, 160));
+    QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, 160)), QSizeF(50 + 80, 160));
+    QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(-1, 160)), QSizeF(100 + 100, 160));
+
+    // wfh(200) = 200
+    QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, 300)), QSizeF(1 + 200, 300));
+    QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, 300)), QSizeF(50 + 200, 300));
+    QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(-1, 300)), QSizeF(100 + 200, 300));
+}
+
+void tst_QGraphicsGridLayout::heightForWidthWithSpanning()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+    widget->setLayout(layout);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    RectWidget *w = new RectWidget;
+    w->setSizeHint(Qt::MinimumSize, QSizeF(1,1));
+    w->setSizeHint(Qt::MaximumSize, QSizeF(30000,30000));
+    w->setConstraintFunction(hfw);
+    QSizePolicy sp(QSizePolicy::Preferred, QSizePolicy::Preferred);
+    sp.setHeightForWidth(true);
+    w->setSizePolicy(sp);
+    layout->addItem(w, 0,0,2,2);
+
+    QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1)), QSizeF(1, 1));
+    QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1)), QSizeF(200, 100));
+    QEXPECT_FAIL("", "Due to an old bug this wrongly returns QWIDGETSIZE_MAX", Continue);
+    QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(-1, -1)), QSizeF(30000, 30000));
+
+    QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(200, -1)), QSizeF(200, 100));
+    QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(200, -1)), QSizeF(200, 100));
+    QEXPECT_FAIL("", "Due to an old bug this wrongly returns QWIDGETSIZE_MAX", Continue);
+    QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(200, -1)), QSizeF(200, 100));
+
+    QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(2, -1)), QSizeF(2, 10000));
+    QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(2, -1)), QSizeF(2, 10000));
+    QEXPECT_FAIL("", "Due to an old bug this wrongly returns QWIDGETSIZE_MAX", Continue);
+    QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(2, -1)), QSizeF(2, 10000));
+
+    QCOMPARE(layout->effectiveSizeHint(Qt::MinimumSize, QSizeF(200, -1)), QSizeF(200, 100));
+    QCOMPARE(layout->effectiveSizeHint(Qt::PreferredSize, QSizeF(200, -1)), QSizeF(200, 100));
+    QEXPECT_FAIL("", "Due to an old bug this wrongly returns QWIDGETSIZE_MAX", Continue);
+    QCOMPARE(layout->effectiveSizeHint(Qt::MaximumSize, QSizeF(200, -1)), QSizeF(200, 10000));
+}
+
+Q_DECLARE_METATYPE(QSizePolicy::Policy)
+void tst_QGraphicsGridLayout::spanningItem2x2_data()
+{
+    QTest::addColumn<QSizePolicy::Policy>("sizePolicy");
+    QTest::addColumn<int>("itemHeight");
+    QTest::addColumn<int>("expectedHeight");
+
+    QTest::newRow("A larger spanning item with 2 widgets with fixed policy") << QSizePolicy::Fixed << 39 << 80;
+    QTest::newRow("A larger spanning item with 2 widgets with preferred policy") << QSizePolicy::Preferred << 39 << 80;
+    QTest::newRow("An equally-sized spanning item with 2 widgets with fixed policy") << QSizePolicy::Fixed << 40 << 80;
+    QTest::newRow("An equally-sized spanning item with 2 widgets with preferred policy") << QSizePolicy::Preferred << 40 << 80;
+    QTest::newRow("A smaller spanning item with 2 widgets with fixed policy") << QSizePolicy::Fixed << 41 << 82;
+    QTest::newRow("A smaller spanning item with 2 widgets with preferred policy") << QSizePolicy::Preferred << 41 << 82;
+}
+
+void tst_QGraphicsGridLayout::spanningItem2x2()
+{
+    QFETCH(QSizePolicy::Policy, sizePolicy);
+    QFETCH(int, itemHeight);
+    QFETCH(int, expectedHeight);
+    QGraphicsWidget *form = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout(form);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    QGraphicsWidget *w1 = new QGraphicsWidget;
+    w1->setMinimumSize(80,80);
+    w1->setMaximumSize(80,80);
+
+    QGraphicsWidget *w2 = new QGraphicsWidget;
+    w2->setMinimumSize(80,itemHeight);
+    w2->setPreferredSize(80,itemHeight);
+    w2->setSizePolicy(QSizePolicy::Fixed, sizePolicy);
+
+    QGraphicsWidget *w3 = new QGraphicsWidget;
+    w3->setMinimumSize(80,itemHeight);
+    w3->setPreferredSize(80,itemHeight);
+    w3->setSizePolicy(QSizePolicy::Fixed, sizePolicy);
+
+    layout->addItem(w1, 0, 0, 2, 1);
+    layout->addItem(w2, 0, 1);
+    layout->addItem(w3, 1, 1);
+
+    QCOMPARE(layout->minimumSize(), QSizeF(160,expectedHeight));
+    if(sizePolicy == QSizePolicy::Fixed)
+        QCOMPARE(layout->maximumSize(), QSizeF(160,expectedHeight));
+    else
+        QCOMPARE(layout->maximumSize(), QSizeF(160,QWIDGETSIZE_MAX));
+}
+
+void tst_QGraphicsGridLayout::spanningItem2x3_data()
+{
+    QTest::addColumn<bool>("w1_fixed");
+    QTest::addColumn<bool>("w2_fixed");
+    QTest::addColumn<bool>("w3_fixed");
+    QTest::addColumn<bool>("w4_fixed");
+    QTest::addColumn<bool>("w5_fixed");
+
+    for(int w1 = 0; w1 < 2; w1++)
+        for(int w2 = 0; w2 < 2; w2++)
+            for(int w3 = 0; w3 < 2; w3++)
+                for(int w4 = 0; w4 < 2; w4++)
+                    for(int w5 = 0; w5 < 2; w5++) {
+                        QString description = QString("Fixed sizes:") + (w1?" w1":"") + (w2?" w2":"") + (w3?" w3":"") + (w4?" w4":"") + (w5?" w5":"");
+                        QTest::newRow(description.toLatin1()) << (bool)w1 << (bool)w2 << (bool)w3 << (bool)w4 << (bool)w5;
+                    }
+}
+
+void tst_QGraphicsGridLayout::spanningItem2x3()
+{
+    QFETCH(bool, w1_fixed);
+    QFETCH(bool, w2_fixed);
+    QFETCH(bool, w3_fixed);
+    QFETCH(bool, w4_fixed);
+    QFETCH(bool, w5_fixed);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    QGraphicsWidget *w1 = new QGraphicsWidget;
+    w1->setMinimumSize(80,80);
+    w1->setMaximumSize(80,80);
+    if (w1_fixed)
+        w1->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
+
+    QGraphicsWidget *w2 = new QGraphicsWidget;
+    w2->setMinimumSize(80,48);
+    w2->setPreferredSize(80,48);
+    if (w2_fixed)
+        w2->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
+
+    QGraphicsWidget *w3 = new QGraphicsWidget;
+    w3->setMinimumSize(80,30);
+    w3->setPreferredSize(80,30);
+    if (w3_fixed)
+        w3->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
+
+    QGraphicsWidget *w4 = new QGraphicsWidget;
+    w4->setMinimumSize(80,30);
+    w4->setMaximumSize(80,30);
+    if (w4_fixed)
+        w4->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
+
+    QGraphicsWidget *w5 = new QGraphicsWidget;
+    w5->setMinimumSize(40,24);
+    w5->setMaximumSize(40,24);
+    if (w5_fixed)
+        w5->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
+
+    layout->addItem(w1, 0, 0, 2, 1);
+    layout->addItem(w2, 0, 1);
+    layout->addItem(w3, 1, 1);
+    layout->addItem(w4, 0, 2);
+    layout->addItem(w5, 1, 2);
+
+    QCOMPARE(layout->minimumSize(), QSizeF(240,80));
+    // Only w2 and w3 grow vertically, so when they have a fixed vertical size policy,
+    // the whole layout cannot grow vertically.
+    if (w2_fixed && w3_fixed)
+        QCOMPARE(layout->maximumSize(), QSizeF(QWIDGETSIZE_MAX,80));
+    else
+        QCOMPARE(layout->maximumSize(), QSizeF(QWIDGETSIZE_MAX,QWIDGETSIZE_MAX));
+}
+
+void tst_QGraphicsGridLayout::spanningItem()
+{
+    QGraphicsWidget *form = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout(form);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    QGraphicsWidget *w1 = new QGraphicsWidget;
+    w1->setMinimumSize(80,80);
+    w1->setMaximumSize(80,80);
+
+    QGraphicsWidget *w2 = new QGraphicsWidget;
+    w2->setMinimumSize(80,38);
+    w2->setPreferredSize(80,38);
+    w2->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+
+    QGraphicsWidget *w3 = new QGraphicsWidget;
+    w3->setMinimumSize(80,38);
+    w3->setPreferredSize(80,38);
+    w3->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+
+    layout->addItem(w1, 0, 0, 2, 1);
+    layout->addItem(w2, 0, 1);
+    layout->addItem(w3, 1, 1);
+
+    QCOMPARE(layout->minimumSize(), QSizeF(160,80));
+    QCOMPARE(layout->maximumSize(), QSizeF(160,80));
+}
+
+void tst_QGraphicsGridLayout::stretchAndHeightForWidth()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout;
+    widget->setLayout(layout);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    RectWidget *w1 = new RectWidget;
+    w1->setSizeHint(Qt::MinimumSize, QSizeF(10, 10));
+    w1->setSizeHint(Qt::PreferredSize, QSizeF(100, 100));
+    w1->setSizeHint(Qt::MaximumSize, QSizeF(500, 500));
+    layout->addItem(w1, 0,0,1,1);
+
+    RectWidget *w2 = new RectWidget;
+    w2->setSizeHint(Qt::MinimumSize, QSizeF(10, 10));
+    w2->setSizeHint(Qt::PreferredSize, QSizeF(100, 100));
+    w2->setSizeHint(Qt::MaximumSize, QSizeF(500, 500));
+    layout->addItem(w2, 0,1,1,1);
+    layout->setColumnStretchFactor(1, 2);
+
+    QApplication::sendPostedEvents();
+    QGraphicsScene scene;
+    QGraphicsView *view = new QGraphicsView(&scene);
+
+    scene.addItem(widget);
+
+    view->show();
+
+    widget->resize(500, 100);
+    // w1 should stay at its preferred size
+    QCOMPARE(w1->geometry(), QRectF(0, 0, 100, 100));
+    QCOMPARE(w2->geometry(), QRectF(100, 0, 400, 100));
+
+
+    // only w1 has hfw
+    w1->setConstraintFunction(hfw);
+    QSizePolicy sp(QSizePolicy::Preferred, QSizePolicy::Preferred);
+    sp.setHeightForWidth(true);
+    w1->setSizePolicy(sp);
+    QApplication::sendPostedEvents();
+
+    QCOMPARE(w1->geometry(), QRectF(0, 0, 100, 200));
+    QCOMPARE(w2->geometry(), QRectF(100, 0, 400, 200));
+
+    // only w2 has hfw
+    w2->setConstraintFunction(hfw);
+    w2->setSizePolicy(sp);
+
+    w1->setConstraintFunction(0);
+    sp.setHeightForWidth(false);
+    w1->setSizePolicy(sp);
+    QApplication::sendPostedEvents();
+
+    QCOMPARE(w1->geometry(), QRectF(0, 0, 100, 100));
+    QCOMPARE(w2->geometry(), QRectF(100, 0, 400, 50));
+
+}
+
+void tst_QGraphicsGridLayout::testDefaultAlignment()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout(widget);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    QGraphicsWidget *w = new QGraphicsWidget;
+    w->setMinimumSize(50,50);
+    w->setMaximumSize(50,50);
+    layout->addItem(w,0,0);
+
+    //Default alignment should be to the top-left
+
+    //First, check by forcing the layout to be bigger
+    layout->setMinimumSize(100,100);
+    layout->activate();
+    QCOMPARE(layout->geometry(), QRectF(0,0,100,100));
+    QCOMPARE(w->geometry(), QRectF(0,0,50,50));
+    layout->setMinimumSize(-1,-1);
+
+    //Second, check by forcing the column and row to be bigger instead
+    layout->setColumnMinimumWidth(0, 100);
+    layout->setRowMinimumHeight(0, 100);
+    layout->activate();
+    QCOMPARE(layout->geometry(), QRectF(0,0,100,100));
+    QCOMPARE(w->geometry(), QRectF(0,0,50,50));
+    layout->setMinimumSize(-1,-1);
+    layout->setColumnMinimumWidth(0, 0);
+    layout->setRowMinimumHeight(0, 0);
+
+
+    //Third, check by adding a larger item in the column
+    QGraphicsWidget *w2 = new QGraphicsWidget;
+    w2->setMinimumSize(100,100);
+    w2->setMaximumSize(100,100);
+    layout->addItem(w2,1,0);
+    layout->activate();
+    QCOMPARE(layout->geometry(), QRectF(0,0,100,150));
+    QCOMPARE(w->geometry(), QRectF(0,0,50,50));
+    QCOMPARE(w2->geometry(), QRectF(0,50,100,100));
+}
+QTEST_MAIN(tst_QGraphicsGridLayout)
+#include "tst_qgraphicsgridlayout.moc"
+
diff --git a/tests/auto/widgets/graphicsview/qgraphicsitem/.gitignore b/tests/auto/widgets/graphicsview/qgraphicsitem/.gitignore
new file mode 100644
index 0000000000..b766388e3e
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsitem/.gitignore
@@ -0,0 +1 @@
+tst_qgraphicsitem
diff --git a/tests/auto/widgets/graphicsview/qgraphicsitem/qgraphicsitem.pro b/tests/auto/widgets/graphicsview/qgraphicsitem/qgraphicsitem.pro
new file mode 100644
index 0000000000..51a4426680
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsitem/qgraphicsitem.pro
@@ -0,0 +1,9 @@
+load(qttest_p4)
+QT += widgets widgets-private
+QT += core-private gui-private
+SOURCES  += tst_qgraphicsitem.cpp
+DEFINES += QT_NO_CAST_TO_ASCII
+
+win32:!wince*: LIBS += -lUser32
+
+contains(QT_CONFIG,xcb):qpa:CONFIG+=insignificant_test  # QTBUG-20756 crashes on qpa, xcb
diff --git a/tests/auto/widgets/graphicsview/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/auto/widgets/graphicsview/qgraphicsitem/tst_qgraphicsitem.cpp
new file mode 100644
index 0000000000..8ac1f6b5c5
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsitem/tst_qgraphicsitem.cpp
@@ -0,0 +1,11402 @@
+/****************************************************************************
+**
+** 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 <private/qgraphicsitem_p.h>
+#include <private/qgraphicsview_p.h>
+#include <private/qgraphicsscene_p.h>
+#include <QStyleOptionGraphicsItem>
+#include <QAbstractTextDocumentLayout>
+#include <QBitmap>
+#include <QCursor>
+#include <QLabel>
+#include <QDial>
+#include <QGraphicsItem>
+#include <QGraphicsScene>
+#include <QGraphicsSceneEvent>
+#include <QGraphicsView>
+#include <QGraphicsWidget>
+#include <QGraphicsProxyWidget>
+#include <QPainter>
+#include <QScrollBar>
+#include <QVBoxLayout>
+#include <QGraphicsEffect>
+#include <QInputContext>
+#include <QPushButton>
+#include <QLineEdit>
+#include <QGraphicsLinearLayout>
+#include <float.h>
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+Q_DECLARE_METATYPE(QList<int>)
+Q_DECLARE_METATYPE(QList<QRectF>)
+Q_DECLARE_METATYPE(QPainterPath)
+Q_DECLARE_METATYPE(QPointF)
+Q_DECLARE_METATYPE(QRectF)
+
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+#include <windows.h>
+#define Q_CHECK_PAINTEVENTS \
+    if (::SwitchDesktop(::GetThreadDesktop(::GetCurrentThreadId())) == 0) \
+        QSKIP("The Graphics View doesn't get the paint events", SkipSingle);
+#else
+#define Q_CHECK_PAINTEVENTS
+#endif
+
+#if defined(Q_WS_MAC)
+// On mac (cocoa) we always get full update.
+// So check that the expected region is contained inside the actual
+#define COMPARE_REGIONS(ACTUAL, EXPECTED) QVERIFY((EXPECTED).subtracted(ACTUAL).isEmpty())
+#else
+#define COMPARE_REGIONS QTRY_COMPARE
+#endif
+
+#include "../../../platformquirks.h"
+
+static QGraphicsRectItem staticItem; //QTBUG-7629, we should not crash at exit.
+
+static void sendMousePress(QGraphicsScene *scene, const QPointF &point, Qt::MouseButton button = Qt::LeftButton)
+{
+    QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+    event.setScenePos(point);
+    event.setButton(button);
+    event.setButtons(button);
+    QApplication::sendEvent(scene, &event);
+}
+
+static void sendMouseMove(QGraphicsScene *scene, const QPointF &point,
+                          Qt::MouseButton button = Qt::NoButton, Qt::MouseButtons /* buttons */ = 0)
+{
+    QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseMove);
+    event.setScenePos(point);
+    event.setButton(button);
+    event.setButtons(button);
+    QApplication::sendEvent(scene, &event);
+}
+
+static void sendMouseRelease(QGraphicsScene *scene, const QPointF &point, Qt::MouseButton button = Qt::LeftButton)
+{
+    QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseRelease);
+    event.setScenePos(point);
+    event.setButton(button);
+    QApplication::sendEvent(scene, &event);
+}
+
+static void sendMouseClick(QGraphicsScene *scene, const QPointF &point, Qt::MouseButton button = Qt::LeftButton)
+{
+    sendMousePress(scene, point, button);
+    sendMouseRelease(scene, point, button);
+}
+
+static void sendKeyPress(QGraphicsScene *scene, Qt::Key key)
+{
+    QKeyEvent keyEvent(QEvent::KeyPress, key, Qt::NoModifier);
+    QApplication::sendEvent(scene, &keyEvent);
+}
+
+static void sendKeyRelease(QGraphicsScene *scene, Qt::Key key)
+{
+    QKeyEvent keyEvent(QEvent::KeyRelease, key, Qt::NoModifier);
+    QApplication::sendEvent(scene, &keyEvent);
+}
+
+static void sendKeyClick(QGraphicsScene *scene, Qt::Key key)
+{
+    sendKeyPress(scene, key);
+    sendKeyRelease(scene, key);
+}
+
+class EventSpy : public QGraphicsWidget
+{
+    Q_OBJECT
+public:
+    EventSpy(QObject *watched, QEvent::Type type)
+        : _count(0), spied(type)
+    {
+        watched->installEventFilter(this);
+    }
+
+    EventSpy(QGraphicsScene *scene, QGraphicsItem *watched, QEvent::Type type)
+        : _count(0), spied(type)
+    {
+        scene->addItem(this);
+        watched->installSceneEventFilter(this);
+    }
+
+    int count() const { return _count; }
+
+protected:
+    bool eventFilter(QObject *watched, QEvent *event)
+    {
+        Q_UNUSED(watched);
+        if (event->type() == spied)
+            ++_count;
+        return false;
+    }
+
+    bool sceneEventFilter(QGraphicsItem *watched, QEvent *event)
+    {
+        Q_UNUSED(watched);
+        if (event->type() == spied)
+            ++_count;
+        return false;
+    }
+
+    int _count;
+    QEvent::Type spied;
+};
+
+class EventSpy2 : public QGraphicsWidget
+{
+    Q_OBJECT
+public:
+    EventSpy2(QObject *watched)
+    {
+        watched->installEventFilter(this);
+    }
+
+    EventSpy2(QGraphicsScene *scene, QGraphicsItem *watched)
+    {
+        scene->addItem(this);
+        watched->installSceneEventFilter(this);
+    }
+
+    QMap<QEvent::Type, int> counts;
+
+protected:
+    bool eventFilter(QObject *watched, QEvent *event)
+    {
+        Q_UNUSED(watched);
+        ++counts[event->type()];
+        return false;
+    }
+
+    bool sceneEventFilter(QGraphicsItem *watched, QEvent *event)
+    {
+        Q_UNUSED(watched);
+        ++counts[event->type()];
+        return false;
+    }
+};
+
+class EventTester : public QGraphicsItem
+{
+public:
+    EventTester(QGraphicsItem *parent = 0) : QGraphicsItem(parent), repaints(0)
+    { br = QRectF(-10, -10, 20, 20); }
+
+    void setGeometry(const QRectF &rect)
+    {
+        prepareGeometryChange();
+        br = rect;
+        update();
+    }
+
+    QRectF boundingRect() const
+    { return br; }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *o, QWidget *)
+    {
+        hints = painter->renderHints();
+        painter->setBrush(brush);
+        painter->drawRect(boundingRect());
+        lastExposedRect = o->exposedRect;
+        ++repaints;
+    }
+
+    bool sceneEvent(QEvent *event)
+    {
+        events << event->type();
+        return QGraphicsItem::sceneEvent(event);
+    }
+
+    void reset()
+    {
+        events.clear();
+        hints = QPainter::RenderHints(0);
+        repaints = 0;
+        lastExposedRect = QRectF();
+    }
+
+    QList<QEvent::Type> events;
+    QPainter::RenderHints hints;
+    int repaints;
+    QRectF br;
+    QRectF lastExposedRect;
+    QBrush brush;
+};
+
+class MyGraphicsView : public QGraphicsView
+{
+public:
+    int repaints;
+    QRegion paintedRegion;
+    MyGraphicsView(QGraphicsScene *scene, QWidget *parent=0) : QGraphicsView(scene,parent), repaints(0) {}
+    void paintEvent(QPaintEvent *e)
+    {
+        paintedRegion += e->region();
+        ++repaints;
+        QGraphicsView::paintEvent(e);
+    }
+    void reset() { repaints = 0; paintedRegion = QRegion(); }
+};
+
+class tst_QGraphicsItem : public QObject
+{
+    Q_OBJECT
+
+public slots:
+    void init();
+
+private slots:
+    void construction();
+    void constructionWithParent();
+    void destruction();
+    void deleteChildItem();
+    void scene();
+    void parentItem();
+    void setParentItem();
+    void children();
+    void flags();
+    void inputMethodHints();
+    void toolTip();
+    void visible();
+    void isVisibleTo();
+    void explicitlyVisible();
+    void enabled();
+    void explicitlyEnabled();
+    void selected();
+    void selected2();
+    void selected_group();
+    void selected_textItem();
+    void selected_multi();
+    void acceptedMouseButtons();
+    void acceptsHoverEvents();
+    void childAcceptsHoverEvents();
+    void hasFocus();
+    void pos();
+    void scenePos();
+    void matrix();
+    void sceneMatrix();
+    void setMatrix();
+    void zValue();
+    void shape();
+    void contains();
+    void collidesWith_item();
+    void collidesWith_path_data();
+    void collidesWith_path();
+    void collidesWithItemWithClip();
+    void isObscuredBy();
+    void isObscured();
+    void mapFromToParent();
+    void mapFromToScene();
+    void mapFromToItem();
+    void mapRectFromToParent_data();
+    void mapRectFromToParent();
+    void isAncestorOf();
+    void commonAncestorItem();
+    void data();
+    void type();
+    void graphicsitem_cast();
+    void hoverEventsGenerateRepaints();
+    void boundingRects_data();
+    void boundingRects();
+    void boundingRects2();
+    void sceneBoundingRect();
+    void childrenBoundingRect();
+    void childrenBoundingRectTransformed();
+    void childrenBoundingRect2();
+    void childrenBoundingRect3();
+    void childrenBoundingRect4();
+    void childrenBoundingRect5();
+    void group();
+    void setGroup();
+    void setGroup2();
+    void nestedGroups();
+    void warpChildrenIntoGroup();
+    void removeFromGroup();
+    void handlesChildEvents();
+    void handlesChildEvents2();
+    void handlesChildEvents3();
+    void filtersChildEvents();
+    void filtersChildEvents2();
+    void ensureVisible();
+    void cursor();
+    //void textControlGetterSetter();
+    void defaultItemTest_QGraphicsLineItem();
+    void defaultItemTest_QGraphicsPixmapItem();
+    void defaultItemTest_QGraphicsTextItem();
+    void defaultItemTest_QGraphicsEllipseItem();
+    void itemChange();
+    void sceneEventFilter();
+    void prepareGeometryChange();
+    void paint();
+    void deleteItemInEventHandlers();
+    void itemClipsToShape();
+    void itemClipsChildrenToShape();
+    void itemClipsChildrenToShape2();
+    void itemClipsChildrenToShape3();
+    void itemClipsChildrenToShape4();
+    void itemClipsChildrenToShape5();
+    void itemClipsTextChildToShape();
+    void itemClippingDiscovery();
+    void ancestorFlags();
+    void untransformable();
+    void contextMenuEventPropagation();
+    void itemIsMovable();
+    void boundingRegion_data();
+    void boundingRegion();
+    void itemTransform_parentChild();
+    void itemTransform_siblings();
+    void itemTransform_unrelated();
+    void opacity_data();
+    void opacity();
+    void opacity2();
+    void opacityZeroUpdates();
+    void itemStacksBehindParent();
+    void nestedClipping();
+    void nestedClippingTransforms();
+    void sceneTransformCache();
+    void tabChangesFocus();
+    void tabChangesFocus_data();
+    void cacheMode();
+    void cacheMode2();
+    void updateCachedItemAfterMove();
+    void deviceTransform_data();
+    void deviceTransform();
+    void update();
+    void setTransformProperties_data();
+    void setTransformProperties();
+    void itemUsesExtendedStyleOption();
+    void itemSendsGeometryChanges();
+    void moveItem();
+    void moveLineItem();
+    void sorting_data();
+    void sorting();
+    void itemHasNoContents();
+    void hitTestUntransformableItem();
+    void hitTestGraphicsEffectItem();
+    void focusProxy();
+    void subFocus();
+    void focusProxyDeletion();
+    void negativeZStacksBehindParent();
+    void setGraphicsEffect();
+    void panel();
+    void addPanelToActiveScene();
+    void panelWithFocusItem();
+    void activate();
+    void setActivePanelOnInactiveScene();
+    void activationOnShowHide();
+    void moveWhileDeleting();
+    void ensureDirtySceneTransform();
+    void focusScope();
+    void focusScope2();
+    void stackBefore();
+    void sceneModality();
+    void panelModality();
+    void mixedModality();
+    void modality_hover();
+    void modality_mouseGrabber();
+    void modality_clickFocus();
+    void modality_keyEvents();
+    void itemIsInFront();
+    void scenePosChange();
+    void updateMicroFocus();
+    void textItem_shortcuts();
+    void scroll();
+    void focusHandling_data();
+    void focusHandling();
+    void touchEventPropagation_data();
+    void touchEventPropagation();
+    void deviceCoordinateCache_simpleRotations();
+
+    // task specific tests below me
+    void task141694_textItemEnsureVisible();
+    void task128696_textItemEnsureMovable();
+    void ensureUpdateOnTextItem();
+    void task177918_lineItemUndetected();
+    void task240400_clickOnTextItem_data();
+    void task240400_clickOnTextItem();
+    void task243707_addChildBeforeParent();
+    void task197802_childrenVisibility();
+    void QTBUG_4233_updateCachedWithSceneRect();
+    void QTBUG_5418_textItemSetDefaultColor();
+    void QTBUG_6738_missingUpdateWithSetParent();
+    void QTBUG_7714_fullUpdateDiscardingOpacityUpdate2();
+    void QT_2653_fullUpdateDiscardingOpacityUpdate();
+    void QT_2649_focusScope();
+    void sortItemsWhileAdding();
+    void doNotMarkFullUpdateIfNotInScene();
+    void itemDiesDuringDraggingOperation();
+    void QTBUG_12112_focusItem();
+    void QTBUG_13473_sceneposchange();
+    void QTBUG_16374_crashInDestructor();
+    void QTBUG_20699_focusScopeCrash();
+
+private:
+    QList<QGraphicsItem *> paintedItems;
+};
+
+void tst_QGraphicsItem::init()
+{
+#ifdef Q_OS_WINCE //disable magic for WindowsCE
+    qApp->setAutoMaximizeThreshold(-1);
+#endif
+}
+
+void tst_QGraphicsItem::construction()
+{
+    for (int i = 0; i < 7; ++i) {
+        QGraphicsItem *item;
+        switch (i) {
+        case 0:
+            item = new QGraphicsEllipseItem;
+            QCOMPARE(int(item->type()), int(QGraphicsEllipseItem::Type));
+            QCOMPARE(qgraphicsitem_cast<QGraphicsEllipseItem *>(item), (QGraphicsEllipseItem *)item);
+            QCOMPARE(qgraphicsitem_cast<QGraphicsRectItem *>(item), (QGraphicsRectItem *)0);
+            QCOMPARE(item->flags(), 0);
+            break;
+        case 1:
+            item = new QGraphicsLineItem;
+            QCOMPARE(int(item->type()), int(QGraphicsLineItem::Type));
+            QCOMPARE(qgraphicsitem_cast<QGraphicsLineItem *>(item), (QGraphicsLineItem *)item);
+            QCOMPARE(qgraphicsitem_cast<QGraphicsRectItem *>(item), (QGraphicsRectItem *)0);
+            QCOMPARE(item->flags(), 0);
+            break;
+        case 2:
+            item = new QGraphicsPathItem;
+            QCOMPARE(int(item->type()), int(QGraphicsPathItem::Type));
+            QCOMPARE(qgraphicsitem_cast<QGraphicsPathItem *>(item), (QGraphicsPathItem *)item);
+            QCOMPARE(qgraphicsitem_cast<QGraphicsRectItem *>(item), (QGraphicsRectItem *)0);
+            QCOMPARE(item->flags(), 0);
+            break;
+        case 3:
+            item = new QGraphicsPixmapItem;
+            QCOMPARE(int(item->type()), int(QGraphicsPixmapItem::Type));
+            QCOMPARE(qgraphicsitem_cast<QGraphicsPixmapItem *>(item), (QGraphicsPixmapItem *)item);
+            QCOMPARE(qgraphicsitem_cast<QGraphicsRectItem *>(item), (QGraphicsRectItem *)0);
+            QCOMPARE(item->flags(), 0);
+            break;
+        case 4:
+            item = new QGraphicsPolygonItem;
+            QCOMPARE(int(item->type()), int(QGraphicsPolygonItem::Type));
+            QCOMPARE(qgraphicsitem_cast<QGraphicsPolygonItem *>(item), (QGraphicsPolygonItem *)item);
+            QCOMPARE(qgraphicsitem_cast<QGraphicsRectItem *>(item), (QGraphicsRectItem *)0);
+            QCOMPARE(item->flags(), 0);
+            break;
+        case 5:
+            item = new QGraphicsRectItem;
+            QCOMPARE(int(item->type()), int(QGraphicsRectItem::Type));
+            QCOMPARE(qgraphicsitem_cast<QGraphicsRectItem *>(item), (QGraphicsRectItem *)item);
+            QCOMPARE(qgraphicsitem_cast<QGraphicsLineItem *>(item), (QGraphicsLineItem *)0);
+            QCOMPARE(item->flags(), 0);
+            break;
+        case 6:
+            item = new QGraphicsTextItem;
+            QCOMPARE(int(item->type()), int(QGraphicsTextItem::Type));
+            QCOMPARE(qgraphicsitem_cast<QGraphicsTextItem *>(item), (QGraphicsTextItem *)item);
+            QCOMPARE(qgraphicsitem_cast<QGraphicsRectItem *>(item), (QGraphicsRectItem *)0);
+            // This is the only item that uses an extended style option.
+            QCOMPARE(item->flags(), QGraphicsItem::GraphicsItemFlags(QGraphicsItem::ItemUsesExtendedStyleOption));
+            break;
+        default:
+            qFatal("You broke the logic, please fix!");
+            break;
+        }
+
+        QCOMPARE(item->scene(), (QGraphicsScene *)0);
+        QCOMPARE(item->parentItem(), (QGraphicsItem *)0);
+        QVERIFY(item->children().isEmpty());
+        QVERIFY(item->isVisible());
+        QVERIFY(item->isEnabled());
+        QVERIFY(!item->isSelected());
+        QCOMPARE(item->acceptedMouseButtons(), Qt::MouseButtons(0x1f));
+        if (item->type() == QGraphicsTextItem::Type)
+            QVERIFY(item->acceptsHoverEvents());
+        else
+            QVERIFY(!item->acceptsHoverEvents());
+        QVERIFY(!item->hasFocus());
+        QCOMPARE(item->pos(), QPointF());
+        QCOMPARE(item->matrix(), QMatrix());
+        QCOMPARE(item->sceneMatrix(), QMatrix());
+        QCOMPARE(item->zValue(), qreal(0));
+        QCOMPARE(item->sceneBoundingRect(), QRectF());
+        QCOMPARE(item->shape(), QPainterPath());
+        QVERIFY(!item->contains(QPointF(0, 0)));
+        QVERIFY(!item->collidesWithItem(0));
+        QVERIFY(item->collidesWithItem(item));
+        QVERIFY(!item->collidesWithPath(QPainterPath()));
+        QVERIFY(!item->isAncestorOf(0));
+        QVERIFY(!item->isAncestorOf(item));
+        QCOMPARE(item->data(0), QVariant());
+        delete item;
+    }
+}
+
+class BoundingRectItem : public QGraphicsRectItem
+{
+public:
+    BoundingRectItem(QGraphicsItem *parent = 0)
+        : QGraphicsRectItem(0, 0, parent ? 200 : 100, parent ? 200 : 100,
+                            parent)
+    {}
+
+    QRectF boundingRect() const
+    {
+        QRectF tmp = QGraphicsRectItem::boundingRect();
+        foreach (QGraphicsItem *child, children())
+            tmp |= child->boundingRect(); // <- might be pure virtual
+        return tmp;
+    }
+};
+
+void tst_QGraphicsItem::constructionWithParent()
+{
+    // This test causes a crash if item1 calls item2's pure virtuals before the
+    // object has been constructed.
+    QGraphicsItem *item0 = new BoundingRectItem;
+    QGraphicsItem *item1 = new BoundingRectItem;
+    QGraphicsScene scene;
+    scene.addItem(item0);
+    scene.addItem(item1);
+    QGraphicsItem *item2 = new BoundingRectItem(item1);
+    QCOMPARE(item1->children(), QList<QGraphicsItem *>() << item2);
+    QCOMPARE(item1->boundingRect(), QRectF(0, 0, 200, 200));
+
+    item2->setParentItem(item0);
+    QCOMPARE(item0->children(), QList<QGraphicsItem *>() << item2);
+    QCOMPARE(item0->boundingRect(), QRectF(0, 0, 200, 200));
+}
+
+static int itemDeleted = 0;
+class Item : public QGraphicsRectItem
+{
+public:
+    ~Item()
+    { ++itemDeleted; }
+};
+
+void tst_QGraphicsItem::destruction()
+{
+    QCOMPARE(itemDeleted, 0);
+    {
+        QGraphicsItem *parent = new QGraphicsRectItem;
+        Item *child = new Item;
+        child->setParentItem(parent);
+        QCOMPARE(child->parentItem(), parent);
+        delete parent;
+        QCOMPARE(itemDeleted, 1);
+    }
+    {
+        QGraphicsItem *parent = new QGraphicsRectItem;
+        Item *child = new Item;
+        child->setParentItem(parent);
+        QCOMPARE(parent->children().size(), 1);
+        delete child;
+        QCOMPARE(parent->children().size(), 0);
+        delete parent;
+        QCOMPARE(itemDeleted, 2);
+    }
+    {
+        QGraphicsScene scene;
+        QGraphicsItem *parent = new QGraphicsRectItem;
+        Item *child = new Item;
+        QCOMPARE(child->parentItem(), (QGraphicsItem *)0);
+        child->setParentItem(parent);
+        QCOMPARE(child->parentItem(), parent);
+        scene.addItem(parent);
+        QCOMPARE(child->parentItem(), parent);
+        delete parent;
+        QCOMPARE(itemDeleted, 3);
+    }
+    {
+        QGraphicsScene scene;
+        QGraphicsItem *parent = new QGraphicsRectItem;
+        Item *child = new Item;
+        child->setParentItem(parent);
+        scene.addItem(parent);
+        QCOMPARE(child->scene(), &scene);
+        QCOMPARE(parent->children().size(), 1);
+        delete child;
+        QCOMPARE(parent->children().size(), 0);
+        delete parent;
+        QCOMPARE(itemDeleted, 4);
+    }
+    {
+        QGraphicsScene scene;
+        QGraphicsItem *parent = new QGraphicsRectItem;
+        Item *child = new Item;
+        child->setParentItem(parent);
+        scene.addItem(parent);
+        QCOMPARE(child->scene(), &scene);
+        scene.removeItem(parent);
+        QCOMPARE(child->scene(), (QGraphicsScene *)0);
+        delete parent;
+        QCOMPARE(itemDeleted, 5);
+    }
+    {
+        QGraphicsScene scene;
+        QGraphicsItem *parent = new QGraphicsRectItem;
+        Item *child = new Item;
+        child->setParentItem(parent);
+        QCOMPARE(child->scene(), (QGraphicsScene *)0);
+        QCOMPARE(parent->scene(), (QGraphicsScene *)0);
+        scene.addItem(parent);
+        QCOMPARE(child->scene(), &scene);
+        scene.removeItem(child);
+        QCOMPARE(child->scene(), (QGraphicsScene *)0);
+        QCOMPARE(parent->scene(), &scene);
+        QCOMPARE(child->parentItem(), (QGraphicsItem *)0);
+        QVERIFY(parent->children().isEmpty());
+        delete parent;
+        QCOMPARE(itemDeleted, 5);
+        delete child;
+        QCOMPARE(itemDeleted, 6);
+    }
+    {
+        QGraphicsScene scene;
+        QGraphicsItem *parent = new QGraphicsRectItem;
+        Item *child = new Item;
+        child->setParentItem(parent);
+        scene.addItem(parent);
+        scene.removeItem(child);
+        scene.removeItem(parent);
+        delete child;
+        delete parent;
+        QCOMPARE(itemDeleted, 7);
+    }
+    {
+        QGraphicsScene scene;
+        QGraphicsItem *parent = new QGraphicsRectItem;
+        Item *child = new Item;
+        child->setParentItem(parent);
+        scene.addItem(parent);
+        QGraphicsScene scene2;
+        scene2.addItem(parent);
+        delete parent;
+        QCOMPARE(itemDeleted, 8);
+    }
+    {
+        QGraphicsScene scene;
+        QGraphicsItem *parent = new QGraphicsRectItem;
+        Item *child = new Item;
+        child->setParentItem(parent);
+        scene.addItem(parent);
+        QCOMPARE(child->scene(), &scene);
+        QGraphicsScene scene2;
+        scene2.addItem(parent);
+        QCOMPARE(child->scene(), &scene2);
+        scene.addItem(parent);
+        QCOMPARE(child->scene(), &scene);
+        scene2.addItem(parent);
+        QCOMPARE(child->scene(), &scene2);
+        delete parent;
+        QCOMPARE(itemDeleted, 9);
+    }
+    {
+        QGraphicsScene scene;
+        QGraphicsItem *parent = new QGraphicsRectItem;
+        Item *child = new Item;
+        child->setParentItem(parent);
+        scene.addItem(parent);
+        QCOMPARE(child->scene(), &scene);
+        QGraphicsScene scene2;
+        scene2.addItem(child);
+        QCOMPARE(child->scene(), &scene2);
+        delete parent;
+        QCOMPARE(itemDeleted, 9);
+        delete child;
+        QCOMPARE(itemDeleted, 10);
+    }
+    {
+        QGraphicsScene scene;
+        QGraphicsItem *root = new QGraphicsRectItem;
+        QGraphicsItem *parent = root;
+        QGraphicsItem *middleItem = 0;
+        for (int i = 0; i < 99; ++i) {
+            Item *child = new Item;
+            child->setParentItem(parent);
+            parent = child;
+            if (i == 50)
+                middleItem = parent;
+        }
+        scene.addItem(root);
+
+        QCOMPARE(scene.items().size(), 100);
+
+        QGraphicsScene scene2;
+        scene2.addItem(middleItem);
+
+        delete middleItem;
+        QCOMPARE(itemDeleted, 59);
+    }
+    QCOMPARE(itemDeleted, 109);
+    {
+        QGraphicsScene *scene = new QGraphicsScene;
+        QGraphicsRectItem *parent = new QGraphicsRectItem;
+        Item *child = new Item;
+        child->setParentItem(parent);
+        parent->setVisible(false);
+        scene->addItem(parent);
+        QCOMPARE(child->parentItem(), static_cast<QGraphicsItem*>(parent));
+        delete scene;
+        QCOMPARE(itemDeleted, 110);
+    }
+}
+
+void tst_QGraphicsItem::deleteChildItem()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *rect = scene.addRect(QRectF());
+    QGraphicsItem *child1 = new QGraphicsRectItem(rect);
+    QGraphicsItem *child2 = new QGraphicsRectItem(rect);
+    QGraphicsItem *child3 = new QGraphicsRectItem(rect);
+    Q_UNUSED(child3);
+    delete child1;
+    child2->setParentItem(0);
+    delete child2;
+}
+
+void tst_QGraphicsItem::scene()
+{
+    QGraphicsRectItem *item = new QGraphicsRectItem;
+    QCOMPARE(item->scene(), (QGraphicsScene *)0);
+
+    QGraphicsScene scene;
+    scene.addItem(item);
+    QCOMPARE(item->scene(), (QGraphicsScene *)&scene);
+
+    QGraphicsScene scene2;
+    scene2.addItem(item);
+    QCOMPARE(item->scene(), (QGraphicsScene *)&scene2);
+
+    scene2.removeItem(item);
+    QCOMPARE(item->scene(), (QGraphicsScene *)0);
+
+    delete item;
+}
+
+void tst_QGraphicsItem::parentItem()
+{
+    QGraphicsRectItem item;
+    QCOMPARE(item.parentItem(), (QGraphicsItem *)0);
+
+    QGraphicsRectItem *item2 = new QGraphicsRectItem(QRectF(), &item);
+    QCOMPARE(item2->parentItem(), (QGraphicsItem *)&item);
+    item2->setParentItem(&item);
+    QCOMPARE(item2->parentItem(), (QGraphicsItem *)&item);
+    item2->setParentItem(0);
+    QCOMPARE(item2->parentItem(), (QGraphicsItem *)0);
+
+    delete item2;
+}
+
+void tst_QGraphicsItem::setParentItem()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item = scene.addRect(QRectF(0, 0, 10, 10));
+    QCOMPARE(item->scene(), &scene);
+
+    QGraphicsRectItem *child = new QGraphicsRectItem;
+    QCOMPARE(child->scene(), (QGraphicsScene *)0);
+
+    // This implicitly adds the item to the parent's scene
+    child->setParentItem(item);
+    QCOMPARE(child->scene(), &scene);
+
+    // This just makes it a toplevel
+    child->setParentItem(0);
+    QCOMPARE(child->scene(), &scene);
+
+    // Add the child back to the parent, then remove the parent from the scene
+    child->setParentItem(item);
+    scene.removeItem(item);
+    QCOMPARE(child->scene(), (QGraphicsScene *)0);
+}
+
+void tst_QGraphicsItem::children()
+{
+    QGraphicsRectItem item;
+    QVERIFY(item.children().isEmpty());
+
+    QGraphicsRectItem *item2 = new QGraphicsRectItem(QRectF(), &item);
+    QCOMPARE(item.children().size(), 1);
+    QCOMPARE(item.children().first(), (QGraphicsItem *)item2);
+    QVERIFY(item2->children().isEmpty());
+
+    delete item2;
+    QVERIFY(item.children().isEmpty());
+}
+
+void tst_QGraphicsItem::flags()
+{
+    QGraphicsRectItem *item = new QGraphicsRectItem(QRectF(-10, -10, 20, 20));
+    QCOMPARE(item->flags(), 0);
+
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    scene.addItem(item);
+
+    {
+        // Focus
+        item->setFlag(QGraphicsItem::ItemIsFocusable, false);
+        QVERIFY(!item->hasFocus());
+        item->setFocus();
+        QVERIFY(!item->hasFocus());
+
+        item->setFlag(QGraphicsItem::ItemIsFocusable, true);
+        QVERIFY(!item->hasFocus());
+        item->setFocus();
+        QVERIFY(item->hasFocus());
+        QVERIFY(scene.hasFocus());
+
+        item->setFlag(QGraphicsItem::ItemIsFocusable, false);
+        QVERIFY(!item->hasFocus());
+        QVERIFY(scene.hasFocus());
+    }
+    {
+        // Selectable
+        item->setFlag(QGraphicsItem::ItemIsSelectable, false);
+        QVERIFY(!item->isSelected());
+        item->setSelected(true);
+        QVERIFY(!item->isSelected());
+
+        item->setFlag(QGraphicsItem::ItemIsSelectable, true);
+        QVERIFY(!item->isSelected());
+        item->setSelected(true);
+        QVERIFY(item->isSelected());
+        item->setFlag(QGraphicsItem::ItemIsSelectable, false);
+        QVERIFY(!item->isSelected());
+    }
+    {
+        // Movable
+        item->setFlag(QGraphicsItem::ItemIsMovable, false);
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+        event.setScenePos(QPointF(0, 0));
+        event.setButton(Qt::LeftButton);
+        event.setButtons(Qt::LeftButton);
+        QApplication::sendEvent(&scene, &event);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0); // mouse grabber is reset
+
+        QGraphicsSceneMouseEvent event2(QEvent::GraphicsSceneMouseMove);
+        event2.setScenePos(QPointF(10, 10));
+        event2.setButton(Qt::LeftButton);
+        event2.setButtons(Qt::LeftButton);
+        QApplication::sendEvent(&scene, &event2);
+        QCOMPARE(item->pos(), QPointF());
+
+        QGraphicsSceneMouseEvent event3(QEvent::GraphicsSceneMouseRelease);
+        event3.setScenePos(QPointF(10, 10));
+        event3.setButtons(0);
+        QApplication::sendEvent(&scene, &event3);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+
+        item->setFlag(QGraphicsItem::ItemIsMovable, true);
+        QGraphicsSceneMouseEvent event4(QEvent::GraphicsSceneMousePress);
+        event4.setScenePos(QPointF(0, 0));
+        event4.setButton(Qt::LeftButton);
+        event4.setButtons(Qt::LeftButton);
+        QApplication::sendEvent(&scene, &event4);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)item);
+        QGraphicsSceneMouseEvent event5(QEvent::GraphicsSceneMouseMove);
+        event5.setScenePos(QPointF(10, 10));
+        event5.setButton(Qt::LeftButton);
+        event5.setButtons(Qt::LeftButton);
+        QApplication::sendEvent(&scene, &event5);
+        QCOMPARE(item->pos(), QPointF(10, 10));
+    }
+    {
+        QGraphicsItem* clippingParent = new QGraphicsRectItem;
+        clippingParent->setFlag(QGraphicsItem::ItemClipsChildrenToShape, true);
+
+        QGraphicsItem* nonClippingParent = new QGraphicsRectItem;
+        nonClippingParent->setFlag(QGraphicsItem::ItemClipsChildrenToShape, false);
+
+        QGraphicsItem* child = new QGraphicsRectItem(nonClippingParent);
+        QVERIFY(!child->isClipped());
+
+        child->setParentItem(clippingParent);
+        QVERIFY(child->isClipped());
+
+        child->setParentItem(nonClippingParent);
+        QVERIFY(!child->isClipped());
+    }
+}
+
+class ImhTester : public QGraphicsItem
+{
+    QRectF boundingRect() const { return QRectF(); }
+    void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) {}
+};
+
+void tst_QGraphicsItem::inputMethodHints()
+{
+    ImhTester *item = new ImhTester;
+    item->setFlag(QGraphicsItem::ItemAcceptsInputMethod, true);
+    item->setFlag(QGraphicsItem::ItemIsFocusable, true);
+    QCOMPARE(item->inputMethodHints(), Qt::ImhNone);
+    ImhTester *item2 = new ImhTester;
+    item2->setFlag(QGraphicsItem::ItemAcceptsInputMethod, true);
+    item2->setFlag(QGraphicsItem::ItemIsFocusable, true);
+    Qt::InputMethodHints imHints = item2->inputMethodHints();
+    imHints |= Qt::ImhHiddenText;
+    item2->setInputMethodHints(imHints);
+    QGraphicsScene scene;
+    scene.addItem(item);
+    scene.addItem(item2);
+    QGraphicsView view(&scene);
+    QApplication::setActiveWindow(&view);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    item->setFocus();
+    QTRY_VERIFY(item->hasFocus());
+    QCOMPARE(view.inputMethodHints(), item->inputMethodHints());
+    item2->setFocus();
+    QTRY_VERIFY(item2->hasFocus());
+    QCOMPARE(view.inputMethodHints(), item2->inputMethodHints());
+    item->setFlag(QGraphicsItem::ItemAcceptsInputMethod, false);
+    item->setFocus();
+    QTRY_VERIFY(item->hasFocus());
+    //Focus has changed but the new item doesn't accept input method, no hints.
+    QCOMPARE(view.inputMethodHints(), 0);
+    item2->setFocus();
+    QTRY_VERIFY(item2->hasFocus());
+    QCOMPARE(view.inputMethodHints(), item2->inputMethodHints());
+    imHints = item2->inputMethodHints();
+    imHints |= (Qt::ImhNoAutoUppercase | Qt::ImhNoPredictiveText);
+    item2->setInputMethodHints(imHints);
+    QCOMPARE(view.inputMethodHints(), item2->inputMethodHints());
+    QGraphicsProxyWidget *widget = new QGraphicsProxyWidget;
+    QLineEdit *edit = new QLineEdit;
+    edit->setEchoMode(QLineEdit::Password);
+    scene.addItem(widget);
+    widget->setFocus();
+    QTRY_VERIFY(widget->hasFocus());
+    //No widget on the proxy, so no hints
+    QCOMPARE(view.inputMethodHints(), 0);
+    widget->setWidget(edit);
+    //View should match with the line edit
+    QCOMPARE(view.inputMethodHints(), edit->inputMethodHints());
+}
+
+void tst_QGraphicsItem::toolTip()
+{
+    QString toolTip = "Qt rocks!";
+
+    QGraphicsRectItem *item = new QGraphicsRectItem(QRectF(0, 0, 100, 100));
+    item->setPen(QPen(Qt::red, 1));
+    item->setBrush(QBrush(Qt::blue));
+    QVERIFY(item->toolTip().isEmpty());
+    item->setToolTip(toolTip);
+    QCOMPARE(item->toolTip(), toolTip);
+
+    QGraphicsScene scene;
+    scene.addItem(item);
+
+    QGraphicsView view(&scene);
+    view.setFixedSize(200, 200);
+    view.show();
+    QTest::qWait(250);
+    {
+        QHelpEvent helpEvent(QEvent::ToolTip, view.viewport()->rect().topLeft(),
+                             view.viewport()->mapToGlobal(view.viewport()->rect().topLeft()));
+        QApplication::sendEvent(view.viewport(), &helpEvent);
+        QTest::qWait(250);
+
+        bool foundView = false;
+        bool foundTipLabel = false;
+        foreach (QWidget *widget, QApplication::topLevelWidgets()) {
+            if (widget == &view)
+                foundView = true;
+            if (widget->inherits("QTipLabel"))
+                foundTipLabel = true;
+        }
+        QVERIFY(foundView);
+        QVERIFY(!foundTipLabel);
+    }
+
+    {
+        QHelpEvent helpEvent(QEvent::ToolTip, view.viewport()->rect().center(),
+                             view.viewport()->mapToGlobal(view.viewport()->rect().center()));
+        QApplication::sendEvent(view.viewport(), &helpEvent);
+        QTest::qWait(250);
+
+        bool foundView = false;
+        bool foundTipLabel = false;
+        foreach (QWidget *widget, QApplication::topLevelWidgets()) {
+            if (widget == &view)
+                foundView = true;
+            if (widget->inherits("QTipLabel"))
+                foundTipLabel = true;
+        }
+        QVERIFY(foundView);
+        QVERIFY(foundTipLabel);
+    }
+
+    {
+        QHelpEvent helpEvent(QEvent::ToolTip, view.viewport()->rect().topLeft(),
+                             view.viewport()->mapToGlobal(view.viewport()->rect().topLeft()));
+        QApplication::sendEvent(view.viewport(), &helpEvent);
+        QTest::qWait(1000);
+
+        bool foundView = false;
+        bool foundTipLabel = false;
+        foreach (QWidget *widget, QApplication::topLevelWidgets()) {
+            if (widget == &view)
+                foundView = true;
+            if (widget->inherits("QTipLabel") && widget->isVisible())
+                foundTipLabel = true;
+        }
+        QVERIFY(foundView);
+        QVERIFY(!foundTipLabel);
+    }
+}
+
+void tst_QGraphicsItem::visible()
+{
+    QGraphicsItem *item = new QGraphicsRectItem(QRectF(-10, -10, 20, 20));
+    item->setFlag(QGraphicsItem::ItemIsMovable);
+    QVERIFY(item->isVisible());
+    item->setVisible(false);
+    QVERIFY(!item->isVisible());
+    item->setVisible(true);
+    QVERIFY(item->isVisible());
+
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    scene.addItem(item);
+    QVERIFY(item->isVisible());
+    QCOMPARE(scene.itemAt(0, 0), item);
+    item->setVisible(false);
+    QCOMPARE(scene.itemAt(0, 0), (QGraphicsItem *)0);
+    item->setVisible(true);
+    QCOMPARE(scene.itemAt(0, 0), item);
+
+    QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+    event.setButton(Qt::LeftButton);
+    event.setScenePos(QPointF(0, 0));
+    QApplication::sendEvent(&scene, &event);
+    QCOMPARE(scene.mouseGrabberItem(), item);
+    item->setVisible(false);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+    item->setVisible(true);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+
+    item->setFlag(QGraphicsItem::ItemIsFocusable);
+    item->setFocus();
+    QVERIFY(item->hasFocus());
+    item->setVisible(false);
+    QVERIFY(!item->hasFocus());
+    item->setVisible(true);
+    QVERIFY(!item->hasFocus());
+}
+
+void tst_QGraphicsItem::isVisibleTo()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *parent = scene.addRect(QRectF(0, 0, 100, 100));
+    QGraphicsItem *child = scene.addRect(QRectF(25, 25, 50, 50));
+    QGraphicsItem *grandChild = scene.addRect(QRectF(50, 50, 50, 50));
+    QGraphicsItem *stranger = scene.addRect(100, 100, 100, 100);
+
+    child->setParentItem(parent);
+    grandChild->setParentItem(child);
+
+    QVERIFY(grandChild->isVisible());
+    QVERIFY(grandChild->isVisibleTo(grandChild));
+    QVERIFY(grandChild->isVisibleTo(child));
+    QVERIFY(grandChild->isVisibleTo(parent));
+    QVERIFY(grandChild->isVisibleTo(0));
+    QVERIFY(child->isVisible());
+    QVERIFY(child->isVisibleTo(child));
+    QVERIFY(child->isVisibleTo(parent));
+    QVERIFY(child->isVisibleTo(0));
+    QVERIFY(parent->isVisible());
+    QVERIFY(parent->isVisibleTo(parent));
+    QVERIFY(parent->isVisibleTo(0));
+    QVERIFY(!parent->isVisibleTo(child));
+    QVERIFY(!child->isVisibleTo(grandChild));
+    QVERIFY(!grandChild->isVisibleTo(stranger));
+    QVERIFY(!child->isVisibleTo(stranger));
+    QVERIFY(!parent->isVisibleTo(stranger));
+    QVERIFY(!stranger->isVisibleTo(grandChild));
+    QVERIFY(!stranger->isVisibleTo(child));
+    QVERIFY(!stranger->isVisibleTo(parent));
+
+    // Case 1: only parent is explicitly hidden
+    parent->hide();
+
+    QVERIFY(!grandChild->isVisible());
+    QVERIFY(grandChild->isVisibleTo(grandChild));
+    QVERIFY(grandChild->isVisibleTo(child));
+    QVERIFY(grandChild->isVisibleTo(parent));
+    QVERIFY(!grandChild->isVisibleTo(0));
+    QVERIFY(!child->isVisible());
+    QVERIFY(child->isVisibleTo(child));
+    QVERIFY(child->isVisibleTo(parent));
+    QVERIFY(!child->isVisibleTo(0));
+    QVERIFY(!parent->isVisible());
+    QVERIFY(!parent->isVisibleTo(parent));
+    QVERIFY(!parent->isVisibleTo(0));
+    QVERIFY(!parent->isVisibleTo(child));
+    QVERIFY(!child->isVisibleTo(grandChild));
+    QVERIFY(!grandChild->isVisibleTo(stranger));
+    QVERIFY(!child->isVisibleTo(stranger));
+    QVERIFY(!parent->isVisibleTo(stranger));
+    QVERIFY(!stranger->isVisibleTo(grandChild));
+    QVERIFY(!stranger->isVisibleTo(child));
+    QVERIFY(!stranger->isVisibleTo(parent));
+
+    // Case 2: only child is hidden
+    parent->show();
+    child->hide();
+
+    QVERIFY(!grandChild->isVisible());
+    QVERIFY(grandChild->isVisibleTo(grandChild));
+    QVERIFY(grandChild->isVisibleTo(child));
+    QVERIFY(!grandChild->isVisibleTo(parent));
+    QVERIFY(!grandChild->isVisibleTo(0));
+    QVERIFY(!child->isVisible());
+    QVERIFY(!child->isVisibleTo(child));
+    QVERIFY(!child->isVisibleTo(parent));
+    QVERIFY(!child->isVisibleTo(0));
+    QVERIFY(parent->isVisible());
+    QVERIFY(parent->isVisibleTo(parent));
+    QVERIFY(parent->isVisibleTo(0));
+    QVERIFY(!parent->isVisibleTo(child));
+    QVERIFY(!child->isVisibleTo(grandChild));
+    QVERIFY(!grandChild->isVisibleTo(stranger));
+    QVERIFY(!child->isVisibleTo(stranger));
+    QVERIFY(!parent->isVisibleTo(stranger));
+    QVERIFY(!stranger->isVisibleTo(grandChild));
+    QVERIFY(!stranger->isVisibleTo(child));
+    QVERIFY(!stranger->isVisibleTo(parent));
+
+    // Case 3: only grand child is hidden
+    child->show();
+    grandChild->hide();
+
+    QVERIFY(!grandChild->isVisible());
+    QVERIFY(!grandChild->isVisibleTo(grandChild));
+    QVERIFY(!grandChild->isVisibleTo(child));
+    QVERIFY(!grandChild->isVisibleTo(parent));
+    QVERIFY(!grandChild->isVisibleTo(0));
+    QVERIFY(child->isVisible());
+    QVERIFY(child->isVisibleTo(child));
+    QVERIFY(child->isVisibleTo(parent));
+    QVERIFY(child->isVisibleTo(0));
+    QVERIFY(parent->isVisible());
+    QVERIFY(parent->isVisibleTo(parent));
+    QVERIFY(parent->isVisibleTo(0));
+    QVERIFY(!parent->isVisibleTo(child));
+    QVERIFY(!child->isVisibleTo(grandChild));
+    QVERIFY(!grandChild->isVisibleTo(stranger));
+    QVERIFY(!child->isVisibleTo(stranger));
+    QVERIFY(!parent->isVisibleTo(stranger));
+    QVERIFY(!stranger->isVisibleTo(grandChild));
+    QVERIFY(!stranger->isVisibleTo(child));
+    QVERIFY(!stranger->isVisibleTo(parent));
+}
+
+void tst_QGraphicsItem::explicitlyVisible()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *parent = scene.addRect(QRectF(0, 0, 100, 100));
+    QGraphicsItem *child = scene.addRect(QRectF(25, 25, 50, 50));
+    child->setParentItem(parent);
+
+    QVERIFY(parent->isVisible());
+    QVERIFY(child->isVisible());
+
+    parent->hide();
+
+    QVERIFY(!parent->isVisible());
+    QVERIFY(!child->isVisible());
+
+    parent->show();
+    child->hide();
+
+    QVERIFY(parent->isVisible());
+    QVERIFY(!child->isVisible());
+
+    parent->hide();
+
+    QVERIFY(!parent->isVisible());
+    QVERIFY(!child->isVisible());
+
+    parent->show();
+
+    QVERIFY(parent->isVisible());
+    QVERIFY(!child->isVisible()); // <- explicitly hidden
+
+    child->show();
+
+    QVERIFY(child->isVisible());
+
+    parent->hide();
+
+    QVERIFY(!parent->isVisible());
+    QVERIFY(!child->isVisible()); // <- explicit show doesn't work
+
+    parent->show();
+
+    QVERIFY(parent->isVisible());
+    QVERIFY(child->isVisible()); // <- no longer explicitly hidden
+
+    // ------------------- Reparenting ------------------------------
+
+    QGraphicsItem *parent2 = scene.addRect(-50, -50, 200, 200);
+    QVERIFY(parent2->isVisible());
+
+    // Reparent implicitly hidden item to a visible parent.
+    parent->hide();
+    QVERIFY(!parent->isVisible());
+    QVERIFY(!child->isVisible());
+    child->setParentItem(parent2);
+    QVERIFY(parent2->isVisible());
+    QVERIFY(child->isVisible());
+
+    // Reparent implicitly hidden item to a hidden parent.
+    child->setParentItem(parent);
+    parent2->hide();
+    child->setParentItem(parent2);
+    QVERIFY(!parent2->isVisible());
+    QVERIFY(!child->isVisible());
+
+    // Reparent explicitly hidden item to a visible parent.
+    child->hide();
+    parent->show();
+    child->setParentItem(parent);
+    QVERIFY(parent->isVisible());
+    QVERIFY(!child->isVisible());
+
+    // Reparent explicitly hidden item to a hidden parent.
+    child->setParentItem(parent2);
+    QVERIFY(!parent2->isVisible());
+    QVERIFY(!child->isVisible());
+
+    // Reparent explicitly hidden item to a visible parent.
+    parent->show();
+    child->setParentItem(parent);
+    QVERIFY(parent->isVisible());
+    QVERIFY(!child->isVisible());
+
+    // Reparent visible item to a hidden parent.
+    child->show();
+    parent2->hide();
+    child->setParentItem(parent2);
+    QVERIFY(!parent2->isVisible());
+    QVERIFY(!child->isVisible());
+    parent2->show();
+    QVERIFY(parent2->isVisible());
+    QVERIFY(child->isVisible());
+
+    // Reparent implicitly hidden child to root.
+    parent2->hide();
+    QVERIFY(!child->isVisible());
+    child->setParentItem(0);
+    QVERIFY(child->isVisible());
+
+    // Reparent an explicitly hidden child to root.
+    child->hide();
+    child->setParentItem(parent2);
+    parent2->show();
+    QVERIFY(!child->isVisible());
+    child->setParentItem(0);
+    QVERIFY(!child->isVisible());
+}
+
+void tst_QGraphicsItem::enabled()
+{
+    QGraphicsRectItem *item = new QGraphicsRectItem(QRectF(-10, -10, 20, 20));
+    item->setFlag(QGraphicsItem::ItemIsMovable);
+    QVERIFY(item->isEnabled());
+    item->setEnabled(false);
+    QVERIFY(!item->isEnabled());
+    item->setEnabled(true);
+    QVERIFY(item->isEnabled());
+    item->setEnabled(false);
+    item->setFlag(QGraphicsItem::ItemIsFocusable);
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    scene.addItem(item);
+    item->setFocus();
+    QVERIFY(!item->hasFocus());
+    item->setEnabled(true);
+    item->setFocus();
+    QVERIFY(item->hasFocus());
+    item->setEnabled(false);
+    QVERIFY(!item->hasFocus());
+
+    QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+    event.setButton(Qt::LeftButton);
+    event.setScenePos(QPointF(0, 0));
+    QApplication::sendEvent(&scene, &event);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+    item->setEnabled(true);
+    QApplication::sendEvent(&scene, &event);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)item);
+    item->setEnabled(false);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+}
+
+void tst_QGraphicsItem::explicitlyEnabled()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *parent = scene.addRect(QRectF(0, 0, 100, 100));
+    QGraphicsItem *child = scene.addRect(QRectF(25, 25, 50, 50));
+    child->setParentItem(parent);
+
+    QVERIFY(parent->isEnabled());
+    QVERIFY(child->isEnabled());
+
+    parent->setEnabled(false);
+
+    QVERIFY(!parent->isEnabled());
+    QVERIFY(!child->isEnabled());
+
+    parent->setEnabled(true);
+    child->setEnabled(false);
+
+    QVERIFY(parent->isEnabled());
+    QVERIFY(!child->isEnabled());
+
+    parent->setEnabled(false);
+
+    QVERIFY(!parent->isEnabled());
+    QVERIFY(!child->isEnabled());
+
+    parent->setEnabled(true);
+
+    QVERIFY(parent->isEnabled());
+    QVERIFY(!child->isEnabled()); // <- explicitly disabled
+
+    child->setEnabled(true);
+
+    QVERIFY(child->isEnabled());
+
+    parent->setEnabled(false);
+
+    QVERIFY(!parent->isEnabled());
+    QVERIFY(!child->isEnabled()); // <- explicit enabled doesn't work
+
+    parent->setEnabled(true);
+
+    QVERIFY(parent->isEnabled());
+    QVERIFY(child->isEnabled()); // <- no longer explicitly disabled
+
+    // ------------------- Reparenting ------------------------------
+
+    QGraphicsItem *parent2 = scene.addRect(-50, -50, 200, 200);
+    QVERIFY(parent2->isEnabled());
+
+    // Reparent implicitly hidden item to a enabled parent.
+    parent->setEnabled(false);
+    QVERIFY(!parent->isEnabled());
+    QVERIFY(!child->isEnabled());
+    child->setParentItem(parent2);
+    QVERIFY(parent2->isEnabled());
+    QVERIFY(child->isEnabled());
+
+    // Reparent implicitly hidden item to a hidden parent.
+    child->setParentItem(parent);
+    parent2->setEnabled(false);
+    child->setParentItem(parent2);
+    QVERIFY(!parent2->isEnabled());
+    QVERIFY(!child->isEnabled());
+
+    // Reparent explicitly hidden item to a enabled parent.
+    child->setEnabled(false);
+    parent->setEnabled(true);
+    child->setParentItem(parent);
+    QVERIFY(parent->isEnabled());
+    QVERIFY(!child->isEnabled());
+
+    // Reparent explicitly hidden item to a hidden parent.
+    child->setParentItem(parent2);
+    QVERIFY(!parent2->isEnabled());
+    QVERIFY(!child->isEnabled());
+
+    // Reparent explicitly hidden item to a enabled parent.
+    parent->setEnabled(true);
+    child->setParentItem(parent);
+    QVERIFY(parent->isEnabled());
+    QVERIFY(!child->isEnabled());
+
+    // Reparent enabled item to a hidden parent.
+    child->setEnabled(true);
+    parent2->setEnabled(false);
+    child->setParentItem(parent2);
+    QVERIFY(!parent2->isEnabled());
+    QVERIFY(!child->isEnabled());
+    parent2->setEnabled(true);
+    QVERIFY(parent2->isEnabled());
+    QVERIFY(child->isEnabled());
+
+    // Reparent implicitly hidden child to root.
+    parent2->setEnabled(false);
+    QVERIFY(!child->isEnabled());
+    child->setParentItem(0);
+    QVERIFY(child->isEnabled());
+
+    // Reparent an explicitly hidden child to root.
+    child->setEnabled(false);
+    child->setParentItem(parent2);
+    parent2->setEnabled(true);
+    QVERIFY(!child->isEnabled());
+    child->setParentItem(0);
+    QVERIFY(!child->isEnabled());
+}
+
+class SelectChangeItem : public QGraphicsRectItem
+{
+public:
+    SelectChangeItem() : QGraphicsRectItem(-50, -50, 100, 100) { setBrush(Qt::blue); }
+    QList<bool> values;
+
+protected:
+    QVariant itemChange(GraphicsItemChange change, const QVariant &value)
+    {
+        if (change == ItemSelectedChange)
+            values << value.toBool();
+        return QGraphicsRectItem::itemChange(change, value);
+    }
+};
+
+void tst_QGraphicsItem::selected()
+{
+    SelectChangeItem *item = new SelectChangeItem;
+    item->setFlag(QGraphicsItem::ItemIsSelectable);
+    QVERIFY(!item->isSelected());
+    QVERIFY(item->values.isEmpty());
+    item->setSelected(true);
+    QCOMPARE(item->values.size(), 1);
+    QCOMPARE(item->values.last(), true);
+    QVERIFY(item->isSelected());
+    item->setSelected(false);
+    QCOMPARE(item->values.size(), 2);
+    QCOMPARE(item->values.last(), false);
+    QVERIFY(!item->isSelected());
+    item->setSelected(true);
+    QCOMPARE(item->values.size(), 3);
+    item->setEnabled(false);
+    QCOMPARE(item->values.size(), 4);
+    QCOMPARE(item->values.last(), false);
+    QVERIFY(!item->isSelected());
+    item->setEnabled(true);
+    QCOMPARE(item->values.size(), 4);
+    item->setSelected(true);
+    QCOMPARE(item->values.size(), 5);
+    QCOMPARE(item->values.last(), true);
+    QVERIFY(item->isSelected());
+    item->setVisible(false);
+    QCOMPARE(item->values.size(), 6);
+    QCOMPARE(item->values.last(), false);
+    QVERIFY(!item->isSelected());
+    item->setVisible(true);
+    QCOMPARE(item->values.size(), 6);
+    item->setSelected(true);
+    QCOMPARE(item->values.size(), 7);
+    QCOMPARE(item->values.last(), true);
+    QVERIFY(item->isSelected());
+
+    QGraphicsScene scene(-100, -100, 200, 200);
+    scene.addItem(item);
+    QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>() << item);
+    item->setSelected(false);
+    QVERIFY(scene.selectedItems().isEmpty());
+    item->setSelected(true);
+    QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>() << item);
+    item->setSelected(false);
+    QVERIFY(scene.selectedItems().isEmpty());
+
+    // Interactive selection
+    QGraphicsView view(&scene);
+    view.setFixedSize(250, 250);
+    view.show();
+
+    QTest::qWaitForWindowShown(&view);
+    qApp->processEvents();
+    qApp->processEvents();
+
+    scene.clearSelection();
+    QCOMPARE(item->values.size(), 10);
+    QCOMPARE(item->values.last(), false);
+    QVERIFY(!item->isSelected());
+
+    // Click inside and check that it's selected
+    QTest::mouseMove(view.viewport());
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(item->scenePos()));
+    QCOMPARE(item->values.size(), 11);
+    QCOMPARE(item->values.last(), true);
+    QVERIFY(item->isSelected());
+
+    // Click outside and check that it's not selected
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(item->scenePos() + QPointF(item->boundingRect().width(), item->boundingRect().height())));
+    QCOMPARE(item->values.size(), 12);
+    QCOMPARE(item->values.last(), false);
+    QVERIFY(!item->isSelected());
+
+    SelectChangeItem *item2 = new SelectChangeItem;
+    item2->setFlag(QGraphicsItem::ItemIsSelectable);
+    item2->setPos(100, 0);
+    scene.addItem(item2);
+
+    // Click inside and check that it's selected
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(item->scenePos()));
+    QCOMPARE(item->values.size(), 13);
+    QCOMPARE(item->values.last(), true);
+    QVERIFY(item->isSelected());
+
+    // Click inside item2 and check that it's selected, and item is not
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(item2->scenePos()));
+    QCOMPARE(item->values.size(), 14);
+    QCOMPARE(item->values.last(), false);
+    QVERIFY(!item->isSelected());
+    QCOMPARE(item2->values.size(), 1);
+    QCOMPARE(item2->values.last(), true);
+    QVERIFY(item2->isSelected());
+}
+
+void tst_QGraphicsItem::selected2()
+{
+    // Selecting an item, then moving another previously caused a crash.
+    QGraphicsScene scene;
+    QGraphicsItem *line1 = scene.addRect(QRectF(0, 0, 100, 100));
+    line1->setPos(-105, 0);
+    line1->setFlag(QGraphicsItem::ItemIsSelectable);
+
+    QGraphicsItem *line2 = scene.addRect(QRectF(0, 0, 100, 100));
+    line2->setFlag(QGraphicsItem::ItemIsMovable);
+
+    line1->setSelected(true);
+
+    {
+        QGraphicsSceneMouseEvent mousePress(QEvent::GraphicsSceneMousePress);
+        mousePress.setScenePos(QPointF(50, 50));
+        mousePress.setButton(Qt::LeftButton);
+        QApplication::sendEvent(&scene, &mousePress);
+        QVERIFY(mousePress.isAccepted());
+    }
+    {
+        QGraphicsSceneMouseEvent mouseMove(QEvent::GraphicsSceneMouseMove);
+        mouseMove.setScenePos(QPointF(60, 60));
+        mouseMove.setButton(Qt::LeftButton);
+        mouseMove.setButtons(Qt::LeftButton);
+        QApplication::sendEvent(&scene, &mouseMove);
+        QVERIFY(mouseMove.isAccepted());
+    }
+}
+
+void tst_QGraphicsItem::selected_group()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item1 = scene.addRect(QRectF());
+    QGraphicsItem *item2 = scene.addRect(QRectF());
+    item1->setFlag(QGraphicsItem::ItemIsSelectable);
+    item2->setFlag(QGraphicsItem::ItemIsSelectable);
+    scene.addRect(QRectF())->setParentItem(item1);
+    QGraphicsItem *leaf = scene.addRect(QRectF());
+    leaf->setFlag(QGraphicsItem::ItemIsSelectable);
+    leaf->setParentItem(item2);
+
+    QGraphicsItemGroup *group = scene.createItemGroup(QList<QGraphicsItem *>() << item1 << item2);
+    QCOMPARE(group->scene(), &scene);
+    group->setFlag(QGraphicsItem::ItemIsSelectable);
+    foreach (QGraphicsItem *item, scene.items()) {
+        if (item == group)
+            QVERIFY(!item->group());
+        else
+            QCOMPARE(item->group(), group);
+    }
+
+    QVERIFY(group->handlesChildEvents());
+    QVERIFY(!group->isSelected());
+    group->setSelected(false);
+    QVERIFY(!group->isSelected());
+    group->setSelected(true);
+    QVERIFY(group->isSelected());
+    foreach (QGraphicsItem *item, scene.items())
+        QVERIFY(item->isSelected());
+    group->setSelected(false);
+    QVERIFY(!group->isSelected());
+    foreach (QGraphicsItem *item, scene.items())
+        QVERIFY(!item->isSelected());
+    leaf->setSelected(true);
+    foreach (QGraphicsItem *item, scene.items())
+        QVERIFY(item->isSelected());
+    leaf->setSelected(false);
+    foreach (QGraphicsItem *item, scene.items())
+        QVERIFY(!item->isSelected());
+
+    leaf->setSelected(true);
+    QGraphicsScene scene2;
+    scene2.addItem(item1);
+    QVERIFY(!item1->isSelected());
+    QVERIFY(item2->isSelected());
+}
+
+void tst_QGraphicsItem::selected_textItem()
+{
+    QGraphicsScene scene;
+    QGraphicsTextItem *text = scene.addText(QLatin1String("Text"));
+    text->setFlag(QGraphicsItem::ItemIsSelectable);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTest::qWait(20);
+
+    QTRY_VERIFY(!text->isSelected());
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,
+                      view.mapFromScene(text->mapToScene(0, 0)));
+    QTRY_VERIFY(text->isSelected());
+
+    text->setSelected(false);
+    text->setTextInteractionFlags(Qt::TextEditorInteraction);
+
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,
+                      view.mapFromScene(text->mapToScene(0, 0)));
+    QTRY_VERIFY(text->isSelected());
+}
+
+void tst_QGraphicsItem::selected_multi()
+{
+    // Test multiselection behavior
+    QGraphicsScene scene;
+
+    // Create two disjoint items
+    QGraphicsItem *item1 = scene.addRect(QRectF(-10, -10, 20, 20));
+    QGraphicsItem *item2 = scene.addRect(QRectF(-10, -10, 20, 20));
+    item1->setPos(-15, 0);
+    item2->setPos(15, 20);
+
+    // Make both items selectable
+    item1->setFlag(QGraphicsItem::ItemIsSelectable);
+    item2->setFlag(QGraphicsItem::ItemIsSelectable);
+
+    // Create and show a view
+    QGraphicsView view(&scene);
+    view.show();
+    view.fitInView(scene.sceneRect());
+    qApp->processEvents();
+
+    QVERIFY(!item1->isSelected());
+    QVERIFY(!item2->isSelected());
+
+    // Start clicking
+    QTest::qWait(200);
+
+    // Click on item1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(item1->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(item1->isSelected());
+    QVERIFY(!item2->isSelected());
+
+    // Click on item2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(item2->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(item2->isSelected());
+    QVERIFY(!item1->isSelected());
+
+    // Ctrl-click on item1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, Qt::ControlModifier, view.mapFromScene(item1->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(item2->isSelected());
+    QVERIFY(item1->isSelected());
+
+    // Ctrl-click on item1 again
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, Qt::ControlModifier, view.mapFromScene(item1->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(item2->isSelected());
+    QVERIFY(!item1->isSelected());
+
+    // Ctrl-click on item2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, Qt::ControlModifier, view.mapFromScene(item2->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(!item2->isSelected());
+    QVERIFY(!item1->isSelected());
+
+    // Click on item1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(item1->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(item1->isSelected());
+    QVERIFY(!item2->isSelected());
+
+    // Click on scene
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(0, 0));
+    QTest::qWait(20);
+    QVERIFY(!item1->isSelected());
+    QVERIFY(!item2->isSelected());
+
+    // Click on item1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(item1->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(item1->isSelected());
+    QVERIFY(!item2->isSelected());
+
+    // Ctrl-click on scene
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, Qt::ControlModifier, view.mapFromScene(0, 0));
+    QTest::qWait(20);
+    QVERIFY(!item1->isSelected());
+    QVERIFY(!item2->isSelected());
+
+    // Click on item1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(item1->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(item1->isSelected());
+    QVERIFY(!item2->isSelected());
+
+    // Press on item2
+    QTest::mousePress(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(item2->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(!item1->isSelected());
+    QVERIFY(item2->isSelected());
+
+    // Release on item2
+    QTest::mouseRelease(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(item2->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(!item1->isSelected());
+    QVERIFY(item2->isSelected());
+
+    // Click on item1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(item1->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(item1->isSelected());
+    QVERIFY(!item2->isSelected());
+
+    // Ctrl-click on item1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, Qt::ControlModifier, view.mapFromScene(item1->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(!item1->isSelected());
+    QVERIFY(!item2->isSelected());
+
+    // Ctrl-press on item1
+    QTest::mousePress(view.viewport(), Qt::LeftButton, Qt::ControlModifier, view.mapFromScene(item1->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(!item1->isSelected());
+    QVERIFY(!item2->isSelected());
+
+    {
+        // Ctrl-move on item1
+        QMouseEvent event(QEvent::MouseMove, view.mapFromScene(item1->scenePos()) + QPoint(1, 0), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier);
+        QApplication::sendEvent(view.viewport(), &event);
+        QTest::qWait(20);
+        QVERIFY(!item1->isSelected());
+        QVERIFY(!item2->isSelected());
+    }
+
+    // Release on item1
+    QTest::mouseRelease(view.viewport(), Qt::LeftButton, Qt::ControlModifier, view.mapFromScene(item1->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(item1->isSelected());
+    QVERIFY(!item2->isSelected());
+
+    item1->setFlag(QGraphicsItem::ItemIsMovable);
+    item1->setSelected(false);
+
+    // Ctrl-press on item1
+    QTest::mousePress(view.viewport(), Qt::LeftButton, Qt::ControlModifier, view.mapFromScene(item1->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(!item1->isSelected());
+    QVERIFY(!item2->isSelected());
+
+    {
+        // Ctrl-move on item1
+        QMouseEvent event(QEvent::MouseMove, view.mapFromScene(item1->scenePos()) + QPoint(1, 0), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier);
+        QApplication::sendEvent(view.viewport(), &event);
+        QTest::qWait(20);
+        QVERIFY(item1->isSelected());
+        QVERIFY(!item2->isSelected());
+    }
+
+    // Release on item1
+    QTest::mouseRelease(view.viewport(), Qt::LeftButton, Qt::ControlModifier, view.mapFromScene(item1->scenePos()));
+    QTest::qWait(20);
+    QVERIFY(item1->isSelected());
+    QVERIFY(!item2->isSelected());
+}
+
+void tst_QGraphicsItem::acceptedMouseButtons()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *item1 = scene.addRect(QRectF(-10, -10, 20, 20));
+    QGraphicsRectItem *item2 = scene.addRect(QRectF(-10, -10, 20, 20));
+    item2->setZValue(1);
+
+    item1->setFlag(QGraphicsItem::ItemIsMovable);
+    item2->setFlag(QGraphicsItem::ItemIsMovable);
+
+    QCOMPARE(item1->acceptedMouseButtons(), Qt::MouseButtons(0x1f));
+    QCOMPARE(item2->acceptedMouseButtons(), Qt::MouseButtons(0x1f));
+
+    QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+    event.setButton(Qt::LeftButton);
+    event.setScenePos(QPointF(0, 0));
+    QApplication::sendEvent(&scene, &event);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)item2);
+    item2->setAcceptedMouseButtons(0);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+    QApplication::sendEvent(&scene, &event);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)item1);
+}
+
+class HoverItem : public QGraphicsRectItem
+{
+public:
+    HoverItem(const QRectF &rect)
+        : QGraphicsRectItem(rect), hoverInCount(0),
+          hoverMoveCount(0), hoverOutCount(0)
+    { }
+
+    int hoverInCount;
+    int hoverMoveCount;
+    int hoverOutCount;
+protected:
+    void hoverEnterEvent(QGraphicsSceneHoverEvent *)
+    { ++hoverInCount; }
+
+    void hoverMoveEvent(QGraphicsSceneHoverEvent *)
+    { ++hoverMoveCount; }
+
+    void hoverLeaveEvent(QGraphicsSceneHoverEvent *)
+    { ++hoverOutCount; }
+};
+
+void tst_QGraphicsItem::acceptsHoverEvents()
+{
+    QGraphicsScene scene;
+    HoverItem *item1 = new HoverItem(QRectF(-10, -10, 20, 20));
+    HoverItem *item2 = new HoverItem(QRectF(-5, -5, 10, 10));
+    scene.addItem(item1);
+    scene.addItem(item2);
+    item2->setZValue(1);
+
+    QVERIFY(!item1->acceptsHoverEvents());
+    QVERIFY(!item2->acceptsHoverEvents());
+    item1->setAcceptsHoverEvents(true);
+    item2->setAcceptsHoverEvents(true);
+
+    QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseMove);
+    event.setScenePos(QPointF(-100, -100));
+    QApplication::sendEvent(&scene, &event);
+    event.setScenePos(QPointF(-2.5, -2.5));
+    QApplication::sendEvent(&scene, &event);
+
+    QCOMPARE(item1->hoverInCount, 0);
+    QCOMPARE(item2->hoverInCount, 1);
+
+    item1->setAcceptsHoverEvents(false);
+    item2->setAcceptsHoverEvents(false);
+
+    event.setScenePos(QPointF(-100, -100));
+    QApplication::sendEvent(&scene, &event);
+    event.setScenePos(QPointF(-2.5, -2.5));
+    QApplication::sendEvent(&scene, &event);
+
+    QCOMPARE(item1->hoverInCount, 0);
+    QCOMPARE(item2->hoverInCount, 1);
+
+    item1->setAcceptsHoverEvents(true);
+    item2->setAcceptsHoverEvents(false);
+
+    event.setScenePos(QPointF(-100, -100));
+    QApplication::sendEvent(&scene, &event);
+    event.setScenePos(QPointF(-2.5, -2.5));
+    QApplication::sendEvent(&scene, &event);
+
+    QCOMPARE(item1->hoverInCount, 1);
+    QCOMPARE(item2->hoverInCount, 1);
+}
+
+void tst_QGraphicsItem::childAcceptsHoverEvents()
+{
+    QGraphicsScene scene;
+    HoverItem *item1 = new HoverItem(QRectF(-10, -10, 20, 20));
+    HoverItem *item2 = new HoverItem(QRectF(-5, -5, 10, 10));
+
+    scene.addItem(item1);
+    scene.addItem(item2);
+    item2->setParentItem(item1);
+    item2->setAcceptHoverEvents(true);
+
+    QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseMove);
+    event.setScenePos(QPointF(-100, -100));
+    QApplication::sendEvent(&scene, &event);
+    QCOMPARE(item2->hoverInCount, 0);
+    QCOMPARE(item2->hoverMoveCount, 0);
+    QCOMPARE(item2->hoverOutCount, 0);
+    QCOMPARE(item1->hoverInCount, 0);
+    QCOMPARE(item1->hoverMoveCount, 0);
+    QCOMPARE(item1->hoverOutCount, 0);
+
+    event.setScenePos(QPointF(-2.5, -2.5));
+    QApplication::sendEvent(&scene, &event);
+
+    QCOMPARE(item2->hoverInCount, 1);
+    QCOMPARE(item2->hoverMoveCount, 1);
+    QCOMPARE(item2->hoverOutCount, 0);
+    QCOMPARE(item1->hoverInCount, 0);
+    QCOMPARE(item1->hoverMoveCount, 0);
+    QCOMPARE(item1->hoverOutCount, 0);
+
+    event.setScenePos(QPointF(0, 0));
+    QApplication::sendEvent(&scene, &event);
+
+    QCOMPARE(item2->hoverInCount, 1);
+    QCOMPARE(item2->hoverMoveCount, 2);
+    QCOMPARE(item2->hoverOutCount, 0);
+    QCOMPARE(item1->hoverInCount, 0);
+    QCOMPARE(item1->hoverMoveCount, 0);
+    QCOMPARE(item1->hoverOutCount, 0);
+
+    event.setScenePos(QPointF(-7, -7));
+    QApplication::sendEvent(&scene, &event);
+
+    QCOMPARE(item2->hoverInCount, 1);
+    QCOMPARE(item2->hoverMoveCount, 2);
+    QCOMPARE(item2->hoverOutCount, 1);
+    QCOMPARE(item1->hoverInCount, 0);
+    QCOMPARE(item1->hoverMoveCount, 0);
+    QCOMPARE(item1->hoverOutCount, 0);
+
+    event.setScenePos(QPointF(0, 0));
+    QApplication::sendEvent(&scene, &event);
+
+    QCOMPARE(item2->hoverInCount, 2);
+    QCOMPARE(item2->hoverMoveCount, 3);
+    QCOMPARE(item2->hoverOutCount, 1);
+    QCOMPARE(item1->hoverInCount, 0);
+    QCOMPARE(item1->hoverMoveCount, 0);
+    QCOMPARE(item1->hoverOutCount, 0);
+
+    HoverItem *item0 = new HoverItem(QRectF(-20, -20, 20, 20));
+    scene.addItem(item0);
+    item1->setParentItem(item0);
+    item0->setAcceptHoverEvents(true);
+
+    event.setScenePos(QPointF(-100, -100));
+    QApplication::sendEvent(&scene, &event);
+
+    event.setScenePos(QPointF(-15, -15));
+    QApplication::sendEvent(&scene, &event);
+
+    QCOMPARE(item2->hoverInCount, 2);
+    QCOMPARE(item2->hoverMoveCount, 3);
+    QCOMPARE(item2->hoverOutCount, 2);
+    QCOMPARE(item1->hoverInCount, 0);
+    QCOMPARE(item1->hoverMoveCount, 0);
+    QCOMPARE(item1->hoverOutCount, 0);
+    QCOMPARE(item0->hoverInCount, 1);
+    QCOMPARE(item0->hoverMoveCount, 1);
+    QCOMPARE(item0->hoverOutCount, 0);
+}
+
+void tst_QGraphicsItem::hasFocus()
+{
+    QGraphicsLineItem *line = new QGraphicsLineItem;
+    QVERIFY(!line->hasFocus());
+    line->setFocus();
+    QVERIFY(!line->hasFocus());
+
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    scene.addItem(line);
+
+    line->setFocus();
+    QVERIFY(!line->hasFocus());
+    line->setFlag(QGraphicsItem::ItemIsFocusable);
+    line->setFocus();
+    QVERIFY(line->hasFocus());
+
+    QGraphicsScene scene2;
+    QApplication::sendEvent(&scene2, &activate);
+
+    scene2.addItem(line);
+    QVERIFY(!line->hasFocus());
+
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *)0);
+    QCOMPARE(scene2.focusItem(), (QGraphicsItem *)0);
+
+    line->setFocus();
+    QVERIFY(line->hasFocus());
+    line->clearFocus();
+    QVERIFY(!line->hasFocus());
+
+    QGraphicsLineItem *line2 = new QGraphicsLineItem;
+    line2->setFlag(QGraphicsItem::ItemIsFocusable);
+    scene2.addItem(line2);
+
+    line2->setFocus();
+    QVERIFY(!line->hasFocus());
+    QVERIFY(line2->hasFocus());
+    line->setFocus();
+    QVERIFY(line->hasFocus());
+    QVERIFY(!line2->hasFocus());
+}
+
+void tst_QGraphicsItem::pos()
+{
+    QGraphicsItem *child = new QGraphicsLineItem;
+    QGraphicsItem *parent = new QGraphicsLineItem;
+
+    QCOMPARE(child->pos(), QPointF());
+    QCOMPARE(parent->pos(), QPointF());
+
+    child->setParentItem(parent);
+    child->setPos(10, 10);
+
+    QCOMPARE(child->pos(), QPointF(10, 10));
+
+    parent->setPos(10, 10);
+
+    QCOMPARE(parent->pos(), QPointF(10, 10));
+    QCOMPARE(child->pos(), QPointF(10, 10));
+
+    delete child;
+    delete parent;
+}
+
+void tst_QGraphicsItem::scenePos()
+{
+    QGraphicsItem *child = new QGraphicsLineItem;
+    QGraphicsItem *parent = new QGraphicsLineItem;
+
+    QCOMPARE(child->scenePos(), QPointF());
+    QCOMPARE(parent->scenePos(), QPointF());
+
+    child->setParentItem(parent);
+    child->setPos(10, 10);
+
+    QCOMPARE(child->scenePos(), QPointF(10, 10));
+
+    parent->setPos(10, 10);
+
+    QCOMPARE(parent->scenePos(), QPointF(10, 10));
+    QCOMPARE(child->scenePos(), QPointF(20, 20));
+
+    parent->setPos(20, 20);
+
+    QCOMPARE(parent->scenePos(), QPointF(20, 20));
+    QCOMPARE(child->scenePos(), QPointF(30, 30));
+
+    delete child;
+    delete parent;
+}
+
+void tst_QGraphicsItem::matrix()
+{
+    QGraphicsLineItem line;
+    QCOMPARE(line.matrix(), QMatrix());
+    line.setMatrix(QMatrix().rotate(90));
+    QCOMPARE(line.matrix(), QMatrix().rotate(90));
+    line.setMatrix(QMatrix().rotate(90));
+    QCOMPARE(line.matrix(), QMatrix().rotate(90));
+    line.setMatrix(QMatrix().rotate(90), true);
+    QCOMPARE(line.matrix(), QMatrix().rotate(180));
+    line.setMatrix(QMatrix().rotate(-90), true);
+    QCOMPARE(line.matrix(), QMatrix().rotate(90));
+    line.resetMatrix();
+    QCOMPARE(line.matrix(), QMatrix());
+
+    line.rotate(90);
+    QCOMPARE(line.matrix(), QMatrix().rotate(90));
+    line.rotate(90);
+    QCOMPARE(line.matrix(), QMatrix().rotate(90).rotate(90));
+    line.resetMatrix();
+
+    line.scale(2, 4);
+    QCOMPARE(line.matrix(), QMatrix().scale(2, 4));
+    line.scale(2, 4);
+    QCOMPARE(line.matrix(), QMatrix().scale(2, 4).scale(2, 4));
+    line.resetMatrix();
+
+    line.shear(2, 4);
+    QCOMPARE(line.matrix(), QMatrix().shear(2, 4));
+    line.shear(2, 4);
+    QCOMPARE(line.matrix(), QMatrix().shear(2, 4).shear(2, 4));
+    line.resetMatrix();
+
+    line.translate(10, 10);
+    QCOMPARE(line.matrix(), QMatrix().translate(10, 10));
+    line.translate(10, 10);
+    QCOMPARE(line.matrix(), QMatrix().translate(10, 10).translate(10, 10));
+    line.resetMatrix();
+}
+
+void tst_QGraphicsItem::sceneMatrix()
+{
+    QGraphicsLineItem *parent = new QGraphicsLineItem;
+    QGraphicsLineItem *child = new QGraphicsLineItem(QLineF(), parent);
+
+    QCOMPARE(parent->sceneMatrix(), QMatrix());
+    QCOMPARE(child->sceneMatrix(), QMatrix());
+
+    parent->translate(10, 10);
+    QCOMPARE(parent->sceneMatrix(), QMatrix().translate(10, 10));
+    QCOMPARE(child->sceneMatrix(), QMatrix().translate(10, 10));
+
+    child->translate(10, 10);
+    QCOMPARE(parent->sceneMatrix(), QMatrix().translate(10, 10));
+    QCOMPARE(child->sceneMatrix(), QMatrix().translate(20, 20));
+
+    parent->rotate(90);
+    QCOMPARE(parent->sceneMatrix(), QMatrix().translate(10, 10).rotate(90));
+    QCOMPARE(child->sceneMatrix(), QMatrix().translate(10, 10).rotate(90).translate(10, 10));
+
+    delete child;
+    delete parent;
+}
+
+void tst_QGraphicsItem::setMatrix()
+{
+    QGraphicsScene scene;
+    qRegisterMetaType<QList<QRectF> >("QList<QRectF>");
+    QSignalSpy spy(&scene, SIGNAL(changed(QList<QRectF>)));
+    QRectF unrotatedRect(-12, -34, 56, 78);
+    QGraphicsRectItem item(unrotatedRect, 0, &scene);
+    scene.update(scene.sceneRect());
+    QApplication::instance()->processEvents();
+
+    QCOMPARE(spy.count(), 1);
+
+    item.setMatrix(QMatrix().rotate(qreal(12.34)));
+    QRectF rotatedRect = scene.sceneRect();
+    QVERIFY(unrotatedRect != rotatedRect);
+    scene.update(scene.sceneRect());
+    QApplication::instance()->processEvents();
+
+    QCOMPARE(spy.count(), 2);
+
+    item.setMatrix(QMatrix());
+
+    scene.update(scene.sceneRect());
+    QApplication::instance()->processEvents();
+
+    QCOMPARE(spy.count(), 3);
+    QList<QRectF> rlist = qVariantValue<QList<QRectF> >(spy.last().at(0));
+
+    QCOMPARE(rlist.size(), 3);
+    QCOMPARE(rlist.at(0), rotatedRect);   // From item.setMatrix() (clearing rotated rect)
+    QCOMPARE(rlist.at(1), rotatedRect);   // From scene.update()   (updating scene rect)
+    QCOMPARE(rlist.at(2), unrotatedRect); // From post-update      (update current state)
+}
+
+static QList<QGraphicsItem *> _paintedItems;
+class PainterItem : public QGraphicsItem
+{
+protected:
+    QRectF boundingRect() const
+    { return QRectF(-10, -10, 20, 20); }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+    { _paintedItems << this; painter->fillRect(boundingRect(), Qt::red); }
+};
+
+void tst_QGraphicsItem::zValue()
+{
+    Q_CHECK_PAINTEVENTS
+
+    QGraphicsScene scene;
+
+    QGraphicsItem *item1 = new PainterItem;
+    QGraphicsItem *item2 = new PainterItem;
+    QGraphicsItem *item3 = new PainterItem;
+    QGraphicsItem *item4 = new PainterItem;
+    scene.addItem(item1);
+    scene.addItem(item2);
+    scene.addItem(item3);
+    scene.addItem(item4);
+    item2->setZValue(-3);
+    item4->setZValue(-2);
+    item1->setZValue(-1);
+    item3->setZValue(0);
+
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QApplication::processEvents();
+#ifdef Q_WS_QWS
+    QApplication::sendPostedEvents(); //glib workaround
+#endif
+
+    QTRY_VERIFY(!_paintedItems.isEmpty());
+    QVERIFY((_paintedItems.size() % 4) == 0);
+    for (int i = 0; i < 3; ++i)
+        QVERIFY(_paintedItems.at(i)->zValue() < _paintedItems.at(i + 1)->zValue());
+}
+
+void tst_QGraphicsItem::shape()
+{
+    QGraphicsLineItem line(QLineF(-10, -10, 20, 20));
+
+    // We unfortunately need this hack as QPainterPathStroker will set a width of 1.0
+    // if we pass a value of 0.0 to QPainterPathStroker::setWidth()
+    const qreal penWidthZero = qreal(0.00000001);
+
+    QPainterPathStroker ps;
+    ps.setWidth(penWidthZero);
+
+    QPainterPath path(line.line().p1());
+    path.lineTo(line.line().p2());
+    QPainterPath p = ps.createStroke(path);
+    p.addPath(path);
+    QCOMPARE(line.shape(), p);
+
+    QPen linePen;
+    linePen.setWidthF(5.0);
+    linePen.setCapStyle(Qt::RoundCap);
+    line.setPen(linePen);
+
+    ps.setCapStyle(line.pen().capStyle());
+    ps.setWidth(line.pen().widthF());
+    p = ps.createStroke(path);
+    p.addPath(path);
+    QCOMPARE(line.shape(), p);
+
+    linePen.setCapStyle(Qt::FlatCap);
+    line.setPen(linePen);
+    ps.setCapStyle(line.pen().capStyle());
+    p = ps.createStroke(path);
+    p.addPath(path);
+    QCOMPARE(line.shape(), p);
+
+    linePen.setCapStyle(Qt::SquareCap);
+    line.setPen(linePen);
+    ps.setCapStyle(line.pen().capStyle());
+    p = ps.createStroke(path);
+    p.addPath(path);
+    QCOMPARE(line.shape(), p);
+
+    QGraphicsRectItem rect(QRectF(-10, -10, 20, 20));
+    QPainterPathStroker ps1;
+    ps1.setWidth(penWidthZero);
+    path = QPainterPath();
+    path.addRect(rect.rect());
+    p = ps1.createStroke(path);
+    p.addPath(path);
+    QCOMPARE(rect.shape(), p);
+
+    QGraphicsEllipseItem ellipse(QRectF(-10, -10, 20, 20));
+    QPainterPathStroker ps2;
+    ps2.setWidth(ellipse.pen().widthF() <= 0.0 ? penWidthZero : ellipse.pen().widthF());
+    path = QPainterPath();
+    path.addEllipse(ellipse.rect());
+    p = ps2.createStroke(path);
+    p.addPath(path);
+    QCOMPARE(ellipse.shape(), p);
+
+    QPainterPathStroker ps3;
+    ps3.setWidth(penWidthZero);
+    p = ps3.createStroke(path);
+    p.addPath(path);
+    QGraphicsPathItem pathItem(path);
+    QCOMPARE(pathItem.shape(), p);
+
+    QRegion region(QRect(0, 0, 300, 200));
+    region = region.subtracted(QRect(50, 50, 200, 100));
+
+    QImage image(300, 200, QImage::Format_ARGB32_Premultiplied);
+    image.fill(0);
+    QPainter painter(&image);
+    painter.setClipRegion(region);
+    painter.fillRect(0, 0, 300, 200, Qt::green);
+    painter.end();
+    QPixmap pixmap = QPixmap::fromImage(image);
+
+    QGraphicsPixmapItem pixmapItem(pixmap);
+    path = QPainterPath();
+    path.addRegion(region);
+
+    {
+        QBitmap bitmap(300, 200);
+        bitmap.clear();
+        QPainter painter(&bitmap);
+        painter.setClipRegion(region);
+        painter.fillRect(0, 0, 300, 200, Qt::color1);
+        painter.end();
+
+        QBitmap bitmap2(300, 200);
+        bitmap2.clear();
+        painter.begin(&bitmap2);
+        painter.setClipPath(pixmapItem.shape());
+        painter.fillRect(0, 0, 300, 200, Qt::color1);
+        painter.end();
+
+        QCOMPARE(bitmap.toImage(), bitmap2.toImage());
+    }
+
+    QPolygonF poly;
+    poly << QPointF(0, 0) << QPointF(10, 0) << QPointF(0, 10);
+    QGraphicsPolygonItem polygon(poly);
+    path = QPainterPath();
+    path.addPolygon(poly);
+
+    QPainterPathStroker ps4;
+    ps4.setWidth(penWidthZero);
+    p = ps4.createStroke(path);
+    p.addPath(path);
+    QCOMPARE(polygon.shape(), p);
+}
+
+void tst_QGraphicsItem::contains()
+{
+    if (sizeof(qreal) != sizeof(double)) {
+        QSKIP("Skipped due to rounding errors", SkipAll);
+    }
+
+    // Rect
+    QGraphicsRectItem rect(QRectF(-10, -10, 20, 20));
+    QVERIFY(!rect.contains(QPointF(-11, -10)));
+    QVERIFY(rect.contains(QPointF(-10, -10)));
+    QVERIFY(!rect.contains(QPointF(-11, 0)));
+    QVERIFY(rect.contains(QPointF(-10, 0)));
+    QVERIFY(rect.contains(QPointF(0, -10)));
+    QVERIFY(rect.contains(QPointF(0, 0)));
+    QVERIFY(rect.contains(QPointF(9, 9)));
+
+    // Ellipse
+    QGraphicsEllipseItem ellipse(QRectF(-10, -10, 20, 20));
+    QVERIFY(!ellipse.contains(QPointF(-10, -10)));
+    QVERIFY(ellipse.contains(QPointF(-9, 0)));
+    QVERIFY(ellipse.contains(QPointF(0, -9)));
+    QVERIFY(ellipse.contains(QPointF(0, 0)));
+    QVERIFY(!ellipse.contains(QPointF(9, 9)));
+
+    // Line
+    QGraphicsLineItem line(QLineF(-10, -10, 20, 20));
+    QVERIFY(!line.contains(QPointF(-10, 0)));
+    QVERIFY(!line.contains(QPointF(0, -10)));
+    QVERIFY(!line.contains(QPointF(10, 0)));
+    QVERIFY(!line.contains(QPointF(0, 10)));
+    QVERIFY(line.contains(QPointF(0, 0)));
+    QVERIFY(line.contains(QPointF(-9, -9)));
+    QVERIFY(line.contains(QPointF(9, 9)));
+
+    // Polygon
+    QGraphicsPolygonItem polygon(QPolygonF()
+                                 << QPointF(0, 0)
+                                 << QPointF(10, 0)
+                                 << QPointF(0, 10));
+    QVERIFY(polygon.contains(QPointF(1, 1)));
+    QVERIFY(polygon.contains(QPointF(4, 4)));
+    QVERIFY(polygon.contains(QPointF(1, 4)));
+    QVERIFY(polygon.contains(QPointF(4, 1)));
+    QVERIFY(!polygon.contains(QPointF(8, 8)));
+    QVERIFY(polygon.contains(QPointF(1, 8)));
+    QVERIFY(polygon.contains(QPointF(8, 1)));
+}
+
+void tst_QGraphicsItem::collidesWith_item()
+{
+    // Rectangle
+    QGraphicsRectItem rect(QRectF(-10, -10, 20, 20));
+    QGraphicsRectItem rect2(QRectF(-10, -10, 20, 20));
+    QVERIFY(rect.collidesWithItem(&rect2));
+    QVERIFY(rect2.collidesWithItem(&rect));
+    rect2.setPos(21, 21);
+    QVERIFY(!rect.collidesWithItem(&rect2));
+    QVERIFY(!rect2.collidesWithItem(&rect));
+    rect2.setPos(-21, -21);
+    QVERIFY(!rect.collidesWithItem(&rect2));
+    QVERIFY(!rect2.collidesWithItem(&rect));
+    rect2.setPos(-17, -17);
+    QVERIFY(rect.collidesWithItem(&rect2));
+    QVERIFY(rect2.collidesWithItem(&rect));
+
+    QGraphicsEllipseItem ellipse(QRectF(-10, -10, 20, 20));
+    QGraphicsEllipseItem ellipse2(QRectF(-10, -10, 20, 20));
+    QVERIFY(ellipse.collidesWithItem(&ellipse2));
+    QVERIFY(ellipse2.collidesWithItem(&ellipse));
+    ellipse2.setPos(21, 21);
+    QVERIFY(!ellipse.collidesWithItem(&ellipse2));
+    QVERIFY(!ellipse2.collidesWithItem(&ellipse));
+    ellipse2.setPos(-21, -21);
+    QVERIFY(!ellipse.collidesWithItem(&ellipse2));
+    QVERIFY(!ellipse2.collidesWithItem(&ellipse));
+
+    ellipse2.setPos(-17, -17);
+    QVERIFY(!ellipse.collidesWithItem(&ellipse2));
+    QVERIFY(!ellipse2.collidesWithItem(&ellipse));
+
+    {
+        QGraphicsScene scene;
+        QGraphicsRectItem rect(20, 20, 100, 100, 0, &scene);
+        QGraphicsRectItem rect2(40, 40, 50, 50, 0, &scene);
+        rect2.setZValue(1);
+        QGraphicsLineItem line(0, 0, 200, 200, 0, &scene);
+        line.setZValue(2);
+
+        QCOMPARE(scene.items().size(), 3);
+
+        QList<QGraphicsItem *> col1 = rect.collidingItems();
+        QCOMPARE(col1.size(), 2);
+        QCOMPARE(col1.first(), static_cast<QGraphicsItem *>(&line));
+        QCOMPARE(col1.last(), static_cast<QGraphicsItem *>(&rect2));
+
+        QList<QGraphicsItem *> col2 = rect2.collidingItems();
+        QCOMPARE(col2.size(), 2);
+        QCOMPARE(col2.first(), static_cast<QGraphicsItem *>(&line));
+        QCOMPARE(col2.last(), static_cast<QGraphicsItem *>(&rect));
+
+        QList<QGraphicsItem *> col3 = line.collidingItems();
+        QCOMPARE(col3.size(), 2);
+        QCOMPARE(col3.first(), static_cast<QGraphicsItem *>(&rect2));
+        QCOMPARE(col3.last(), static_cast<QGraphicsItem *>(&rect));
+    }
+}
+
+void tst_QGraphicsItem::collidesWith_path_data()
+{
+    QTest::addColumn<QPointF>("pos");
+    QTest::addColumn<QMatrix>("matrix");
+    QTest::addColumn<QPainterPath>("shape");
+    QTest::addColumn<bool>("rectCollides");
+    QTest::addColumn<bool>("ellipseCollides");
+
+    QTest::newRow("nothing") << QPointF(0, 0) << QMatrix() << QPainterPath() << false << false;
+
+    QPainterPath rect;
+    rect.addRect(0, 0, 20, 20);
+
+    QTest::newRow("rect1") << QPointF(0, 0) << QMatrix() << rect << true << true;
+    QTest::newRow("rect2") << QPointF(0, 0) << QMatrix().translate(21, 21) << rect << false << false;
+    QTest::newRow("rect3") << QPointF(21, 21) << QMatrix() << rect << false << false;
+}
+
+void tst_QGraphicsItem::collidesWith_path()
+{
+    QFETCH(QPointF, pos);
+    QFETCH(QMatrix, matrix);
+    QFETCH(QPainterPath, shape);
+    QFETCH(bool, rectCollides);
+    QFETCH(bool, ellipseCollides);
+
+    QGraphicsRectItem rect(QRectF(0, 0, 20, 20));
+    QGraphicsEllipseItem ellipse(QRectF(0, 0, 20, 20));
+
+    rect.setPos(pos);
+    rect.setMatrix(matrix);
+
+    ellipse.setPos(pos);
+    ellipse.setMatrix(matrix);
+
+    QPainterPath mappedShape = rect.sceneMatrix().inverted().map(shape);
+
+    if (rectCollides)
+        QVERIFY(rect.collidesWithPath(mappedShape));
+    else
+        QVERIFY(!rect.collidesWithPath(mappedShape));
+
+    if (ellipseCollides)
+        QVERIFY(ellipse.collidesWithPath(mappedShape));
+    else
+        QVERIFY(!ellipse.collidesWithPath(mappedShape));
+}
+
+void tst_QGraphicsItem::collidesWithItemWithClip()
+{
+    QGraphicsScene scene;
+
+    QGraphicsEllipseItem *ellipse = scene.addEllipse(0, 0, 100, 100);
+    ellipse->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    QGraphicsEllipseItem *ellipse2 = scene.addEllipse(0, 0, 10, 10);
+    ellipse2->setParentItem(ellipse);
+    QGraphicsEllipseItem *ellipse3 = scene.addEllipse(0, 0, 10, 10);
+    ellipse3->setParentItem(ellipse);
+    QGraphicsEllipseItem *ellipse5 = scene.addEllipse(50, 50, 10, 10);
+    ellipse5->setParentItem(ellipse);
+    QGraphicsEllipseItem *ellipse4 = scene.addEllipse(0, 0, 10, 10);
+
+    QVERIFY(ellipse2->collidesWithItem(ellipse3));
+    QVERIFY(ellipse3->collidesWithItem(ellipse2));
+    QVERIFY(!ellipse2->collidesWithItem(ellipse));
+    QVERIFY(!ellipse->collidesWithItem(ellipse2));
+    QVERIFY(!ellipse4->collidesWithItem(ellipse));
+    QVERIFY(!ellipse4->collidesWithItem(ellipse2));
+    QVERIFY(!ellipse4->collidesWithItem(ellipse3));
+    QVERIFY(!ellipse->collidesWithItem(ellipse4));
+    QVERIFY(!ellipse2->collidesWithItem(ellipse4));
+    QVERIFY(!ellipse3->collidesWithItem(ellipse4));
+    QVERIFY(ellipse->collidesWithItem(ellipse5));
+    QVERIFY(ellipse5->collidesWithItem(ellipse));
+}
+
+class MyItem : public QGraphicsEllipseItem
+{
+public:
+    bool isObscuredBy(const QGraphicsItem *item) const
+    {
+        const MyItem *myItem = qgraphicsitem_cast<const MyItem *>(item);
+        if (myItem) {
+            if (item->zValue() > zValue()) {
+                QRectF r = rect();
+                QPointF topMid = (r.topRight()+r.topLeft())/2;
+                QPointF botMid = (r.bottomRight()+r.bottomLeft())/2;
+                QPointF leftMid = (r.topLeft()+r.bottomLeft())/2;
+                QPointF rightMid = (r.topRight()+r.bottomRight())/2;
+
+                QPainterPath mappedShape = item->mapToItem(this, item->opaqueArea());
+
+                if (mappedShape.contains(topMid) &&
+                    mappedShape.contains(botMid) &&
+                    mappedShape.contains(leftMid) &&
+                    mappedShape.contains(rightMid))
+                    return true;
+                else
+                    return false;
+            }
+            else return false;
+        }
+        else
+            return QGraphicsItem::isObscuredBy(item);
+    }
+
+    QPainterPath opaqueArea() const
+    {
+        return shape();
+    }
+
+    enum {
+        Type = UserType+1
+    };
+    int type() const { return Type; }
+};
+
+void tst_QGraphicsItem::isObscuredBy()
+{
+    QGraphicsScene scene;
+
+    MyItem myitem1, myitem2;
+
+    myitem1.setRect(QRectF(50, 50, 40, 200));
+    myitem1.rotate(67);
+
+    myitem2.setRect(QRectF(25, 25, 20, 20));
+    myitem2.setZValue(-1.0);
+    scene.addItem(&myitem1);
+    scene.addItem(&myitem2);
+
+    QVERIFY(!myitem2.isObscuredBy(&myitem1));
+    QVERIFY(!myitem1.isObscuredBy(&myitem2));
+
+    myitem2.setRect(QRectF(-50, 85, 20, 20));
+    QVERIFY(myitem2.isObscuredBy(&myitem1));
+    QVERIFY(!myitem1.isObscuredBy(&myitem2));
+
+    myitem2.setRect(QRectF(-30, 70, 20, 20));
+    QVERIFY(!myitem2.isObscuredBy(&myitem1));
+    QVERIFY(!myitem1.isObscuredBy(&myitem2));
+
+    QGraphicsRectItem rect1, rect2;
+
+    rect1.setRect(QRectF(-40, -40, 50, 50));
+    rect1.setBrush(QBrush(Qt::red));
+    rect2.setRect(QRectF(-30, -20, 20, 20));
+    rect2.setZValue(-1.0);
+    rect2.setBrush(QBrush(Qt::blue));
+
+    QVERIFY(rect2.isObscuredBy(&rect1));
+    QVERIFY(!rect1.isObscuredBy(&rect2));
+
+    rect2.setPos(QPointF(-20, -25));
+
+    QVERIFY(!rect2.isObscuredBy(&rect1));
+    QVERIFY(!rect1.isObscuredBy(&rect2));
+
+    rect2.setPos(QPointF(-100, -100));
+
+    QVERIFY(!rect2.isObscuredBy(&rect1));
+    QVERIFY(!rect1.isObscuredBy(&rect2));
+}
+
+class OpaqueItem : public QGraphicsRectItem
+{
+protected:
+    QPainterPath opaqueArea() const
+    {
+        return shape();
+    }
+};
+
+void tst_QGraphicsItem::isObscured()
+{
+    if (sizeof(qreal) != sizeof(double)) {
+        QSKIP("Skipped due to rounding errors", SkipAll);
+    }
+
+    OpaqueItem *item1 = new OpaqueItem;
+    item1->setRect(0, 0, 100, 100);
+    item1->setZValue(0);
+
+    OpaqueItem *item2 = new OpaqueItem;
+    item2->setZValue(1);
+    item2->setRect(0, 0, 100, 100);
+
+    QGraphicsScene scene;
+    scene.addItem(item1);
+    scene.addItem(item2);
+
+    QVERIFY(item1->isObscured());
+    QVERIFY(item1->isObscuredBy(item2));
+    QVERIFY(item1->isObscured(QRectF(0, 0, 50, 50)));
+    QVERIFY(item1->isObscured(QRectF(50, 0, 50, 50)));
+    QVERIFY(item1->isObscured(QRectF(50, 50, 50, 50)));
+    QVERIFY(item1->isObscured(QRectF(0, 50, 50, 50)));
+    QVERIFY(item1->isObscured(0, 0, 50, 50));
+    QVERIFY(item1->isObscured(50, 0, 50, 50));
+    QVERIFY(item1->isObscured(50, 50, 50, 50));
+    QVERIFY(item1->isObscured(0, 50, 50, 50));
+    QVERIFY(!item2->isObscured());
+    QVERIFY(!item2->isObscuredBy(item1));
+    QVERIFY(!item2->isObscured(QRectF(0, 0, 50, 50)));
+    QVERIFY(!item2->isObscured(QRectF(50, 0, 50, 50)));
+    QVERIFY(!item2->isObscured(QRectF(50, 50, 50, 50)));
+    QVERIFY(!item2->isObscured(QRectF(0, 50, 50, 50)));
+    QVERIFY(!item2->isObscured(0, 0, 50, 50));
+    QVERIFY(!item2->isObscured(50, 0, 50, 50));
+    QVERIFY(!item2->isObscured(50, 50, 50, 50));
+    QVERIFY(!item2->isObscured(0, 50, 50, 50));
+
+    item2->moveBy(50, 0);
+
+    QVERIFY(!item1->isObscured());
+    QVERIFY(!item1->isObscuredBy(item2));
+    QVERIFY(!item1->isObscured(QRectF(0, 0, 50, 50)));
+    QVERIFY(item1->isObscured(QRectF(50, 0, 50, 50)));
+    QVERIFY(item1->isObscured(QRectF(50, 50, 50, 50)));
+    QVERIFY(!item1->isObscured(QRectF(0, 50, 50, 50)));
+    QVERIFY(!item1->isObscured(0, 0, 50, 50));
+    QVERIFY(item1->isObscured(50, 0, 50, 50));
+    QVERIFY(item1->isObscured(50, 50, 50, 50));
+    QVERIFY(!item1->isObscured(0, 50, 50, 50));
+    QVERIFY(!item2->isObscured());
+    QVERIFY(!item2->isObscuredBy(item1));
+    QVERIFY(!item2->isObscured(QRectF(0, 0, 50, 50)));
+    QVERIFY(!item2->isObscured(QRectF(50, 0, 50, 50)));
+    QVERIFY(!item2->isObscured(QRectF(50, 50, 50, 50)));
+    QVERIFY(!item2->isObscured(QRectF(0, 50, 50, 50)));
+    QVERIFY(!item2->isObscured(0, 0, 50, 50));
+    QVERIFY(!item2->isObscured(50, 0, 50, 50));
+    QVERIFY(!item2->isObscured(50, 50, 50, 50));
+    QVERIFY(!item2->isObscured(0, 50, 50, 50));
+}
+
+void tst_QGraphicsItem::mapFromToParent()
+{
+    QPainterPath path1;
+    path1.addRect(0, 0, 200, 200);
+
+    QPainterPath path2;
+    path2.addRect(0, 0, 100, 100);
+
+    QPainterPath path3;
+    path3.addRect(0, 0, 50, 50);
+
+    QPainterPath path4;
+    path4.addRect(0, 0, 25, 25);
+
+    QGraphicsItem *item1 = new QGraphicsPathItem(path1);
+    QGraphicsItem *item2 = new QGraphicsPathItem(path2, item1);
+    QGraphicsItem *item3 = new QGraphicsPathItem(path3, item2);
+    QGraphicsItem *item4 = new QGraphicsPathItem(path4, item3);
+
+    item1->setPos(10, 10);
+    item2->setPos(10, 10);
+    item3->setPos(10, 10);
+    item4->setPos(10, 10);
+
+    for (int i = 0; i < 4; ++i) {
+        QMatrix matrix;
+        matrix.rotate(i * 90);
+        matrix.translate(i * 100, -i * 100);
+        matrix.scale(2, 4);
+        item1->setMatrix(matrix);
+
+        QCOMPARE(item1->mapToParent(QPointF(0, 0)), item1->pos() + matrix.map(QPointF(0, 0)));
+        QCOMPARE(item2->mapToParent(QPointF(0, 0)), item2->pos());
+        QCOMPARE(item3->mapToParent(QPointF(0, 0)), item3->pos());
+        QCOMPARE(item4->mapToParent(QPointF(0, 0)), item4->pos());
+        QCOMPARE(item1->mapToParent(QPointF(10, -10)), item1->pos() + matrix.map(QPointF(10, -10)));
+        QCOMPARE(item2->mapToParent(QPointF(10, -10)), item2->pos() + QPointF(10, -10));
+        QCOMPARE(item3->mapToParent(QPointF(10, -10)), item3->pos() + QPointF(10, -10));
+        QCOMPARE(item4->mapToParent(QPointF(10, -10)), item4->pos() + QPointF(10, -10));
+        QCOMPARE(item1->mapToParent(QPointF(-10, 10)), item1->pos() + matrix.map(QPointF(-10, 10)));
+        QCOMPARE(item2->mapToParent(QPointF(-10, 10)), item2->pos() + QPointF(-10, 10));
+        QCOMPARE(item3->mapToParent(QPointF(-10, 10)), item3->pos() + QPointF(-10, 10));
+        QCOMPARE(item4->mapToParent(QPointF(-10, 10)), item4->pos() + QPointF(-10, 10));
+        QCOMPARE(item1->mapFromParent(item1->pos()), matrix.inverted().map(QPointF(0, 0)));
+        QCOMPARE(item2->mapFromParent(item2->pos()), QPointF(0, 0));
+        QCOMPARE(item3->mapFromParent(item3->pos()), QPointF(0, 0));
+        QCOMPARE(item4->mapFromParent(item4->pos()), QPointF(0, 0));
+        QCOMPARE(item1->mapFromParent(item1->pos() + QPointF(10, -10)),
+                 matrix.inverted().map(QPointF(10, -10)));
+        QCOMPARE(item2->mapFromParent(item2->pos() + QPointF(10, -10)), QPointF(10, -10));
+        QCOMPARE(item3->mapFromParent(item3->pos() + QPointF(10, -10)), QPointF(10, -10));
+        QCOMPARE(item4->mapFromParent(item4->pos() + QPointF(10, -10)), QPointF(10, -10));
+        QCOMPARE(item1->mapFromParent(item1->pos() + QPointF(-10, 10)),
+                 matrix.inverted().map(QPointF(-10, 10)));
+        QCOMPARE(item2->mapFromParent(item2->pos() + QPointF(-10, 10)), QPointF(-10, 10));
+        QCOMPARE(item3->mapFromParent(item3->pos() + QPointF(-10, 10)), QPointF(-10, 10));
+        QCOMPARE(item4->mapFromParent(item4->pos() + QPointF(-10, 10)), QPointF(-10, 10));
+    }
+
+    delete item1;
+}
+
+void tst_QGraphicsItem::mapFromToScene()
+{
+    QGraphicsItem *item1 = new QGraphicsPathItem(QPainterPath());
+    QGraphicsItem *item2 = new QGraphicsPathItem(QPainterPath(), item1);
+    QGraphicsItem *item3 = new QGraphicsPathItem(QPainterPath(), item2);
+    QGraphicsItem *item4 = new QGraphicsPathItem(QPainterPath(), item3);
+
+    item1->setPos(100, 100);
+    item2->setPos(100, 100);
+    item3->setPos(100, 100);
+    item4->setPos(100, 100);
+    QCOMPARE(item1->pos(), QPointF(100, 100));
+    QCOMPARE(item2->pos(), QPointF(100, 100));
+    QCOMPARE(item3->pos(), QPointF(100, 100));
+    QCOMPARE(item4->pos(), QPointF(100, 100));
+    QCOMPARE(item1->pos(), item1->mapToParent(0, 0));
+    QCOMPARE(item2->pos(), item2->mapToParent(0, 0));
+    QCOMPARE(item3->pos(), item3->mapToParent(0, 0));
+    QCOMPARE(item4->pos(), item4->mapToParent(0, 0));
+    QCOMPARE(item1->mapToParent(10, 10), QPointF(110, 110));
+    QCOMPARE(item2->mapToParent(10, 10), QPointF(110, 110));
+    QCOMPARE(item3->mapToParent(10, 10), QPointF(110, 110));
+    QCOMPARE(item4->mapToParent(10, 10), QPointF(110, 110));
+    QCOMPARE(item1->mapToScene(0, 0), QPointF(100, 100));
+    QCOMPARE(item2->mapToScene(0, 0), QPointF(200, 200));
+    QCOMPARE(item3->mapToScene(0, 0), QPointF(300, 300));
+    QCOMPARE(item4->mapToScene(0, 0), QPointF(400, 400));
+    QCOMPARE(item1->mapToScene(10, 0), QPointF(110, 100));
+    QCOMPARE(item2->mapToScene(10, 0), QPointF(210, 200));
+    QCOMPARE(item3->mapToScene(10, 0), QPointF(310, 300));
+    QCOMPARE(item4->mapToScene(10, 0), QPointF(410, 400));
+    QCOMPARE(item1->mapFromScene(100, 100), QPointF(0, 0));
+    QCOMPARE(item2->mapFromScene(200, 200), QPointF(0, 0));
+    QCOMPARE(item3->mapFromScene(300, 300), QPointF(0, 0));
+    QCOMPARE(item4->mapFromScene(400, 400), QPointF(0, 0));
+    QCOMPARE(item1->mapFromScene(110, 100), QPointF(10, 0));
+    QCOMPARE(item2->mapFromScene(210, 200), QPointF(10, 0));
+    QCOMPARE(item3->mapFromScene(310, 300), QPointF(10, 0));
+    QCOMPARE(item4->mapFromScene(410, 400), QPointF(10, 0));
+
+    // Rotate item1 90 degrees clockwise
+    QMatrix matrix; matrix.rotate(90);
+    item1->setMatrix(matrix);
+    QCOMPARE(item1->pos(), item1->mapToParent(0, 0));
+    QCOMPARE(item2->pos(), item2->mapToParent(0, 0));
+    QCOMPARE(item3->pos(), item3->mapToParent(0, 0));
+    QCOMPARE(item4->pos(), item4->mapToParent(0, 0));
+    QCOMPARE(item1->mapToParent(10, 0), QPointF(100, 110));
+    QCOMPARE(item2->mapToParent(10, 0), QPointF(110, 100));
+    QCOMPARE(item3->mapToParent(10, 0), QPointF(110, 100));
+    QCOMPARE(item4->mapToParent(10, 0), QPointF(110, 100));
+    QCOMPARE(item1->mapToScene(0, 0), QPointF(100, 100));
+    QCOMPARE(item2->mapToScene(0, 0), QPointF(0, 200));
+    QCOMPARE(item3->mapToScene(0, 0), QPointF(-100, 300));
+    QCOMPARE(item4->mapToScene(0, 0), QPointF(-200, 400));
+    QCOMPARE(item1->mapToScene(10, 0), QPointF(100, 110));
+    QCOMPARE(item2->mapToScene(10, 0), QPointF(0, 210));
+    QCOMPARE(item3->mapToScene(10, 0), QPointF(-100, 310));
+    QCOMPARE(item4->mapToScene(10, 0), QPointF(-200, 410));
+    QCOMPARE(item1->mapFromScene(100, 100), QPointF(0, 0));
+    QCOMPARE(item2->mapFromScene(0, 200), QPointF(0, 0));
+    QCOMPARE(item3->mapFromScene(-100, 300), QPointF(0, 0));
+    QCOMPARE(item4->mapFromScene(-200, 400), QPointF(0, 0));
+    QCOMPARE(item1->mapFromScene(100, 110), QPointF(10, 0));
+    QCOMPARE(item2->mapFromScene(0, 210), QPointF(10, 0));
+    QCOMPARE(item3->mapFromScene(-100, 310), QPointF(10, 0));
+    QCOMPARE(item4->mapFromScene(-200, 410), QPointF(10, 0));
+
+    // Rotate item2 90 degrees clockwise
+    item2->setMatrix(matrix);
+    QCOMPARE(item1->pos(), item1->mapToParent(0, 0));
+    QCOMPARE(item2->pos(), item2->mapToParent(0, 0));
+    QCOMPARE(item3->pos(), item3->mapToParent(0, 0));
+    QCOMPARE(item4->pos(), item4->mapToParent(0, 0));
+    QCOMPARE(item1->mapToParent(10, 0), QPointF(100, 110));
+    QCOMPARE(item2->mapToParent(10, 0), QPointF(100, 110));
+    QCOMPARE(item3->mapToParent(10, 0), QPointF(110, 100));
+    QCOMPARE(item4->mapToParent(10, 0), QPointF(110, 100));
+    QCOMPARE(item1->mapToScene(0, 0), QPointF(100, 100));
+    QCOMPARE(item2->mapToScene(0, 0), QPointF(0, 200));
+    QCOMPARE(item3->mapToScene(0, 0), QPointF(-100, 100));
+    QCOMPARE(item4->mapToScene(0, 0), QPointF(-200, 0));
+    QCOMPARE(item1->mapToScene(10, 0), QPointF(100, 110));
+    QCOMPARE(item2->mapToScene(10, 0), QPointF(-10, 200));
+    QCOMPARE(item3->mapToScene(10, 0), QPointF(-110, 100));
+    QCOMPARE(item4->mapToScene(10, 0), QPointF(-210, 0));
+    QCOMPARE(item1->mapFromScene(100, 100), QPointF(0, 0));
+    QCOMPARE(item2->mapFromScene(0, 200), QPointF(0, 0));
+    QCOMPARE(item3->mapFromScene(-100, 100), QPointF(0, 0));
+    QCOMPARE(item4->mapFromScene(-200, 0), QPointF(0, 0));
+    QCOMPARE(item1->mapFromScene(100, 110), QPointF(10, 0));
+    QCOMPARE(item2->mapFromScene(-10, 200), QPointF(10, 0));
+    QCOMPARE(item3->mapFromScene(-110, 100), QPointF(10, 0));
+    QCOMPARE(item4->mapFromScene(-210, 0), QPointF(10, 0));
+
+    // Translate item3 50 points, then rotate 90 degrees counterclockwise
+    QMatrix matrix2;
+    matrix2.translate(50, 0);
+    matrix2.rotate(-90);
+    item3->setMatrix(matrix2);
+    QCOMPARE(item1->pos(), item1->mapToParent(0, 0));
+    QCOMPARE(item2->pos(), item2->mapToParent(0, 0));
+    QCOMPARE(item3->pos(), item3->mapToParent(0, 0) - QPointF(50, 0));
+    QCOMPARE(item4->pos(), item4->mapToParent(0, 0));
+    QCOMPARE(item1->mapToParent(10, 0), QPointF(100, 110));
+    QCOMPARE(item2->mapToParent(10, 0), QPointF(100, 110));
+    QCOMPARE(item3->mapToParent(10, 0), QPointF(150, 90));
+    QCOMPARE(item4->mapToParent(10, 0), QPointF(110, 100));
+    QCOMPARE(item1->mapToScene(0, 0), QPointF(100, 100));
+    QCOMPARE(item2->mapToScene(0, 0), QPointF(0, 200));
+    QCOMPARE(item3->mapToScene(0, 0), QPointF(-150, 100));
+    QCOMPARE(item4->mapToScene(0, 0), QPointF(-250, 200));
+    QCOMPARE(item1->mapToScene(10, 0), QPointF(100, 110));
+    QCOMPARE(item2->mapToScene(10, 0), QPointF(-10, 200));
+    QCOMPARE(item3->mapToScene(10, 0), QPointF(-150, 110));
+    QCOMPARE(item4->mapToScene(10, 0), QPointF(-250, 210));
+    QCOMPARE(item1->mapFromScene(100, 100), QPointF(0, 0));
+    QCOMPARE(item2->mapFromScene(0, 200), QPointF(0, 0));
+    QCOMPARE(item3->mapFromScene(-150, 100), QPointF(0, 0));
+    QCOMPARE(item4->mapFromScene(-250, 200), QPointF(0, 0));
+    QCOMPARE(item1->mapFromScene(100, 110), QPointF(10, 0));
+    QCOMPARE(item2->mapFromScene(-10, 200), QPointF(10, 0));
+    QCOMPARE(item3->mapFromScene(-150, 110), QPointF(10, 0));
+    QCOMPARE(item4->mapFromScene(-250, 210), QPointF(10, 0));
+
+    delete item1;
+}
+
+void tst_QGraphicsItem::mapFromToItem()
+{
+    QGraphicsItem *item1 = new QGraphicsPathItem;
+    QGraphicsItem *item2 = new QGraphicsPathItem;
+    QGraphicsItem *item3 = new QGraphicsPathItem;
+    QGraphicsItem *item4 = new QGraphicsPathItem;
+
+    item1->setPos(-100, -100);
+    item2->setPos(100, -100);
+    item3->setPos(100, 100);
+    item4->setPos(-100, 100);
+
+    QCOMPARE(item1->mapFromItem(item2, 0, 0), QPointF(200, 0));
+    QCOMPARE(item2->mapFromItem(item3, 0, 0), QPointF(0, 200));
+    QCOMPARE(item3->mapFromItem(item4, 0, 0), QPointF(-200, 0));
+    QCOMPARE(item4->mapFromItem(item1, 0, 0), QPointF(0, -200));
+    QCOMPARE(item1->mapFromItem(item4, 0, 0), QPointF(0, 200));
+    QCOMPARE(item2->mapFromItem(item1, 0, 0), QPointF(-200, 0));
+    QCOMPARE(item3->mapFromItem(item2, 0, 0), QPointF(0, -200));
+    QCOMPARE(item4->mapFromItem(item3, 0, 0), QPointF(200, 0));
+
+    QMatrix matrix;
+    matrix.translate(100, 100);
+    item1->setMatrix(matrix);
+
+    QCOMPARE(item1->mapFromItem(item2, 0, 0), QPointF(100, -100));
+    QCOMPARE(item2->mapFromItem(item3, 0, 0), QPointF(0, 200));
+    QCOMPARE(item3->mapFromItem(item4, 0, 0), QPointF(-200, 0));
+    QCOMPARE(item4->mapFromItem(item1, 0, 0), QPointF(100, -100));
+    QCOMPARE(item1->mapFromItem(item4, 0, 0), QPointF(-100, 100));
+    QCOMPARE(item2->mapFromItem(item1, 0, 0), QPointF(-100, 100));
+    QCOMPARE(item3->mapFromItem(item2, 0, 0), QPointF(0, -200));
+    QCOMPARE(item4->mapFromItem(item3, 0, 0), QPointF(200, 0));
+
+    matrix.rotate(90);
+    item1->setMatrix(matrix);
+    item2->setMatrix(matrix);
+    item3->setMatrix(matrix);
+    item4->setMatrix(matrix);
+
+    QCOMPARE(item1->mapFromItem(item2, 0, 0), QPointF(0, -200));
+    QCOMPARE(item2->mapFromItem(item3, 0, 0), QPointF(200, 0));
+    QCOMPARE(item3->mapFromItem(item4, 0, 0), QPointF(0, 200));
+    QCOMPARE(item4->mapFromItem(item1, 0, 0), QPointF(-200, 0));
+    QCOMPARE(item1->mapFromItem(item4, 0, 0), QPointF(200, 0));
+    QCOMPARE(item2->mapFromItem(item1, 0, 0), QPointF(0, 200));
+    QCOMPARE(item3->mapFromItem(item2, 0, 0), QPointF(-200, 0));
+    QCOMPARE(item4->mapFromItem(item3, 0, 0), QPointF(0, -200));
+    QCOMPARE(item1->mapFromItem(item2, 10, -5), QPointF(10, -205));
+    QCOMPARE(item2->mapFromItem(item3, 10, -5), QPointF(210, -5));
+    QCOMPARE(item3->mapFromItem(item4, 10, -5), QPointF(10, 195));
+    QCOMPARE(item4->mapFromItem(item1, 10, -5), QPointF(-190, -5));
+    QCOMPARE(item1->mapFromItem(item4, 10, -5), QPointF(210, -5));
+    QCOMPARE(item2->mapFromItem(item1, 10, -5), QPointF(10, 195));
+    QCOMPARE(item3->mapFromItem(item2, 10, -5), QPointF(-190, -5));
+    QCOMPARE(item4->mapFromItem(item3, 10, -5), QPointF(10, -205));
+
+    QCOMPARE(item1->mapFromItem(0, 10, -5), item1->mapFromScene(10, -5));
+    QCOMPARE(item2->mapFromItem(0, 10, -5), item2->mapFromScene(10, -5));
+    QCOMPARE(item3->mapFromItem(0, 10, -5), item3->mapFromScene(10, -5));
+    QCOMPARE(item4->mapFromItem(0, 10, -5), item4->mapFromScene(10, -5));
+    QCOMPARE(item1->mapToItem(0, 10, -5), item1->mapToScene(10, -5));
+    QCOMPARE(item2->mapToItem(0, 10, -5), item2->mapToScene(10, -5));
+    QCOMPARE(item3->mapToItem(0, 10, -5), item3->mapToScene(10, -5));
+    QCOMPARE(item4->mapToItem(0, 10, -5), item4->mapToScene(10, -5));
+
+    delete item1;
+    delete item2;
+    delete item3;
+    delete item4;
+}
+
+void tst_QGraphicsItem::mapRectFromToParent_data()
+{
+    QTest::addColumn<bool>("parent");
+    QTest::addColumn<QPointF>("parentPos");
+    QTest::addColumn<QTransform>("parentTransform");
+    QTest::addColumn<QPointF>("pos");
+    QTest::addColumn<QTransform>("transform");
+    QTest::addColumn<QRectF>("inputRect");
+    QTest::addColumn<QRectF>("outputRect");
+
+    QTest::newRow("nil") << false << QPointF() << QTransform() << QPointF() << QTransform() << QRectF() << QRectF();
+    QTest::newRow("simple") << false << QPointF() << QTransform() << QPointF() << QTransform()
+                            << QRectF(0, 0, 10, 10) << QRectF(0, 0, 10, 10);
+    QTest::newRow("simple w/parent") << true
+                                     << QPointF() << QTransform()
+                                     << QPointF() << QTransform()
+                                     << QRectF(0, 0, 10, 10) << QRectF(0, 0, 10, 10);
+    QTest::newRow("simple w/parent parentPos") << true
+                                               << QPointF(50, 50) << QTransform()
+                                               << QPointF() << QTransform()
+                                               << QRectF(0, 0, 10, 10) << QRectF(0, 0, 10, 10);
+    QTest::newRow("simple w/parent parentPos parentRotation") << true
+                                                              << QPointF(50, 50) << QTransform().rotate(45)
+                                                              << QPointF() << QTransform()
+                                                              << QRectF(0, 0, 10, 10) << QRectF(0, 0, 10, 10);
+    QTest::newRow("pos w/parent") << true
+                                  << QPointF() << QTransform()
+                                  << QPointF(50, 50) << QTransform()
+                                  << QRectF(0, 0, 10, 10) << QRectF(50, 50, 10, 10);
+    QTest::newRow("rotation w/parent") << true
+                                       << QPointF() << QTransform()
+                                       << QPointF() << QTransform().rotate(90)
+                                       << QRectF(0, 0, 10, 10) << QRectF(-10, 0, 10, 10);
+    QTest::newRow("pos rotation w/parent") << true
+                                           << QPointF() << QTransform()
+                                           << QPointF(50, 50) << QTransform().rotate(90)
+                                           << QRectF(0, 0, 10, 10) << QRectF(40, 50, 10, 10);
+    QTest::newRow("pos rotation w/parent parentPos parentRotation") << true
+                                                                    << QPointF(-170, -190) << QTransform().rotate(90)
+                                                                    << QPointF(50, 50) << QTransform().rotate(90)
+                                                                    << QRectF(0, 0, 10, 10) << QRectF(40, 50, 10, 10);
+}
+
+void tst_QGraphicsItem::mapRectFromToParent()
+{
+    QFETCH(bool, parent);
+    QFETCH(QPointF, parentPos);
+    QFETCH(QTransform, parentTransform);
+    QFETCH(QPointF, pos);
+    QFETCH(QTransform, transform);
+    QFETCH(QRectF, inputRect);
+    QFETCH(QRectF, outputRect);
+
+    QGraphicsRectItem *rect = new QGraphicsRectItem;
+    rect->setPos(pos);
+    rect->setTransform(transform);
+
+    if (parent) {
+        QGraphicsRectItem *rectParent = new QGraphicsRectItem;
+        rect->setParentItem(rectParent);
+        rectParent->setPos(parentPos);
+        rectParent->setTransform(parentTransform);
+    }
+
+    // Make sure we use non-destructive transform operations (e.g., 90 degree
+    // rotations).
+    QCOMPARE(rect->mapRectToParent(inputRect), outputRect);
+    QCOMPARE(rect->mapRectFromParent(outputRect), inputRect);
+    QCOMPARE(rect->itemTransform(rect->parentItem()).mapRect(inputRect), outputRect);
+    QCOMPARE(rect->mapToParent(inputRect).boundingRect(), outputRect);
+    QCOMPARE(rect->mapToParent(QPolygonF(inputRect)).boundingRect(), outputRect);
+    QCOMPARE(rect->mapFromParent(outputRect).boundingRect(), inputRect);
+    QCOMPARE(rect->mapFromParent(QPolygonF(outputRect)).boundingRect(), inputRect);
+    QPainterPath inputPath;
+    inputPath.addRect(inputRect);
+    QPainterPath outputPath;
+    outputPath.addRect(outputRect);
+    QCOMPARE(rect->mapToParent(inputPath).boundingRect(), outputPath.boundingRect());
+    QCOMPARE(rect->mapFromParent(outputPath).boundingRect(), inputPath.boundingRect());
+}
+
+void tst_QGraphicsItem::isAncestorOf()
+{
+    QGraphicsItem *grandPa = new QGraphicsRectItem;
+    QGraphicsItem *parent = new QGraphicsRectItem;
+    QGraphicsItem *child = new QGraphicsRectItem;
+
+    QVERIFY(!parent->isAncestorOf(0));
+    QVERIFY(!child->isAncestorOf(0));
+    QVERIFY(!parent->isAncestorOf(child));
+    QVERIFY(!child->isAncestorOf(parent));
+    QVERIFY(!parent->isAncestorOf(parent));
+
+    child->setParentItem(parent);
+    parent->setParentItem(grandPa);
+
+    QVERIFY(parent->isAncestorOf(child));
+    QVERIFY(grandPa->isAncestorOf(parent));
+    QVERIFY(grandPa->isAncestorOf(child));
+    QVERIFY(!child->isAncestorOf(parent));
+    QVERIFY(!parent->isAncestorOf(grandPa));
+    QVERIFY(!child->isAncestorOf(grandPa));
+    QVERIFY(!child->isAncestorOf(child));
+    QVERIFY(!parent->isAncestorOf(parent));
+    QVERIFY(!grandPa->isAncestorOf(grandPa));
+
+    parent->setParentItem(0);
+
+    delete child;
+    delete parent;
+    delete grandPa;
+}
+
+void tst_QGraphicsItem::commonAncestorItem()
+{
+    QGraphicsItem *ancestor = new QGraphicsRectItem;
+    QGraphicsItem *grandMa = new QGraphicsRectItem;
+    QGraphicsItem *grandPa = new QGraphicsRectItem;
+    QGraphicsItem *brotherInLaw = new QGraphicsRectItem;
+    QGraphicsItem *cousin = new QGraphicsRectItem;
+    QGraphicsItem *husband = new QGraphicsRectItem;
+    QGraphicsItem *child = new QGraphicsRectItem;
+    QGraphicsItem *wife = new QGraphicsRectItem;
+
+    child->setParentItem(husband);
+    husband->setParentItem(grandPa);
+    brotherInLaw->setParentItem(grandPa);
+    cousin->setParentItem(brotherInLaw);
+    wife->setParentItem(grandMa);
+    grandMa->setParentItem(ancestor);
+    grandPa->setParentItem(ancestor);
+
+    QCOMPARE(grandMa->commonAncestorItem(grandMa), grandMa);
+    QCOMPARE(grandMa->commonAncestorItem(0), (QGraphicsItem *)0);
+    QCOMPARE(grandMa->commonAncestorItem(grandPa), ancestor);
+    QCOMPARE(grandPa->commonAncestorItem(grandMa), ancestor);
+    QCOMPARE(grandPa->commonAncestorItem(husband), grandPa);
+    QCOMPARE(grandPa->commonAncestorItem(wife), ancestor);
+    QCOMPARE(grandMa->commonAncestorItem(husband), ancestor);
+    QCOMPARE(grandMa->commonAncestorItem(wife), grandMa);
+    QCOMPARE(wife->commonAncestorItem(grandMa), grandMa);
+    QCOMPARE(child->commonAncestorItem(cousin), grandPa);
+    QCOMPARE(cousin->commonAncestorItem(child), grandPa);
+    QCOMPARE(wife->commonAncestorItem(child), ancestor);
+    QCOMPARE(child->commonAncestorItem(wife), ancestor);
+}
+
+void tst_QGraphicsItem::data()
+{
+    QGraphicsTextItem text;
+
+    QCOMPARE(text.data(0), QVariant());
+    text.setData(0, "TextItem");
+    QCOMPARE(text.data(0), QVariant(QString("TextItem")));
+    text.setData(0, QVariant());
+    QCOMPARE(text.data(0), QVariant());
+}
+
+void tst_QGraphicsItem::type()
+{
+    QCOMPARE(int(QGraphicsItem::Type), 1);
+    QCOMPARE(int(QGraphicsPathItem::Type), 2);
+    QCOMPARE(int(QGraphicsRectItem::Type), 3);
+    QCOMPARE(int(QGraphicsEllipseItem::Type), 4);
+    QCOMPARE(int(QGraphicsPolygonItem::Type), 5);
+    QCOMPARE(int(QGraphicsLineItem::Type), 6);
+    QCOMPARE(int(QGraphicsPixmapItem::Type), 7);
+    QCOMPARE(int(QGraphicsTextItem::Type), 8);
+
+    QCOMPARE(QGraphicsPathItem().type(), 2);
+    QCOMPARE(QGraphicsRectItem().type(), 3);
+    QCOMPARE(QGraphicsEllipseItem().type(), 4);
+    QCOMPARE(QGraphicsPolygonItem().type(), 5);
+    QCOMPARE(QGraphicsLineItem().type(), 6);
+    QCOMPARE(QGraphicsPixmapItem().type(), 7);
+    QCOMPARE(QGraphicsTextItem().type(), 8);
+}
+
+void tst_QGraphicsItem::graphicsitem_cast()
+{
+    QGraphicsPathItem pathItem;
+    const QGraphicsPathItem *pPathItem = &pathItem;
+    QGraphicsRectItem rectItem;
+    const QGraphicsRectItem *pRectItem = &rectItem;
+    QGraphicsEllipseItem ellipseItem;
+    const QGraphicsEllipseItem *pEllipseItem = &ellipseItem;
+    QGraphicsPolygonItem polygonItem;
+    const QGraphicsPolygonItem *pPolygonItem = &polygonItem;
+    QGraphicsLineItem lineItem;
+    const QGraphicsLineItem *pLineItem = &lineItem;
+    QGraphicsPixmapItem pixmapItem;
+    const QGraphicsPixmapItem *pPixmapItem = &pixmapItem;
+    QGraphicsTextItem textItem;
+    const QGraphicsTextItem *pTextItem = &textItem;
+
+    QVERIFY(qgraphicsitem_cast<QGraphicsPathItem *>(&pathItem));
+    //QVERIFY(qgraphicsitem_cast<QAbstractGraphicsPathItem *>(&pathItem));
+    QVERIFY(qgraphicsitem_cast<QGraphicsItem *>(&pathItem));
+    QVERIFY(qgraphicsitem_cast<const QGraphicsItem *>(pPathItem));
+    QVERIFY(qgraphicsitem_cast<const QGraphicsPathItem *>(pPathItem));
+
+    QVERIFY(qgraphicsitem_cast<QGraphicsRectItem *>(&rectItem));
+    QVERIFY(qgraphicsitem_cast<QGraphicsItem *>(&rectItem));
+    QVERIFY(qgraphicsitem_cast<const QGraphicsItem *>(pRectItem));
+    QVERIFY(qgraphicsitem_cast<const QGraphicsRectItem *>(pRectItem));
+
+    QVERIFY(qgraphicsitem_cast<QGraphicsEllipseItem *>(&ellipseItem));
+    QVERIFY(qgraphicsitem_cast<QGraphicsItem *>(&ellipseItem));
+    QVERIFY(qgraphicsitem_cast<const QGraphicsItem *>(pEllipseItem));
+    QVERIFY(qgraphicsitem_cast<const QGraphicsEllipseItem *>(pEllipseItem));
+
+    QVERIFY(qgraphicsitem_cast<QGraphicsPolygonItem *>(&polygonItem));
+    //QVERIFY(qgraphicsitem_cast<QAbstractGraphicsPathItem *>(&polygonItem));
+    QVERIFY(qgraphicsitem_cast<QGraphicsItem *>(&polygonItem));
+    QVERIFY(qgraphicsitem_cast<const QGraphicsItem *>(pPolygonItem));
+    QVERIFY(qgraphicsitem_cast<const QGraphicsPolygonItem *>(pPolygonItem));
+
+    QVERIFY(qgraphicsitem_cast<QGraphicsLineItem *>(&lineItem));
+    QVERIFY(qgraphicsitem_cast<QGraphicsItem *>(&lineItem));
+    QVERIFY(qgraphicsitem_cast<const QGraphicsItem *>(pLineItem));
+    QVERIFY(qgraphicsitem_cast<const QGraphicsLineItem *>(pLineItem));
+
+    QVERIFY(qgraphicsitem_cast<QGraphicsPixmapItem *>(&pixmapItem));
+    QVERIFY(qgraphicsitem_cast<QGraphicsItem *>(&pixmapItem));
+    QVERIFY(qgraphicsitem_cast<const QGraphicsItem *>(pPixmapItem));
+    QVERIFY(qgraphicsitem_cast<const QGraphicsPixmapItem *>(pPixmapItem));
+
+    QVERIFY(qgraphicsitem_cast<QGraphicsTextItem *>(&textItem));
+    QVERIFY(qgraphicsitem_cast<QGraphicsItem *>(&textItem));
+    QVERIFY(qgraphicsitem_cast<const QGraphicsItem *>(pTextItem));
+    QVERIFY(qgraphicsitem_cast<const QGraphicsTextItem *>(pTextItem));
+
+    // and some casts that _should_ fail:
+    QVERIFY(!qgraphicsitem_cast<QGraphicsEllipseItem *>(&pathItem));
+    QVERIFY(!qgraphicsitem_cast<const QGraphicsTextItem *>(pPolygonItem));
+
+    // and this shouldn't crash
+    QGraphicsItem *ptr = 0;
+    QVERIFY(!qgraphicsitem_cast<QGraphicsTextItem *>(ptr));
+    QVERIFY(!qgraphicsitem_cast<QGraphicsItem *>(ptr));
+}
+
+void tst_QGraphicsItem::hoverEventsGenerateRepaints()
+{
+    Q_CHECK_PAINTEVENTS
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTest::qWait(150);
+
+    EventTester *tester = new EventTester;
+    scene.addItem(tester);
+    tester->setAcceptsHoverEvents(true);
+
+    QTRY_COMPARE(tester->repaints, 1);
+
+    // Send a hover enter event
+    QGraphicsSceneHoverEvent hoverEnterEvent(QEvent::GraphicsSceneHoverEnter);
+    hoverEnterEvent.setScenePos(QPointF(0, 0));
+    hoverEnterEvent.setPos(QPointF(0, 0));
+    QApplication::sendEvent(&scene, &hoverEnterEvent);
+
+    // Check that we get a repaint
+    int npaints = tester->repaints;
+    qApp->processEvents();
+    qApp->processEvents();
+    QCOMPARE(tester->events.size(), 2); //  enter + move
+    QCOMPARE(tester->repaints, npaints + 1);
+    QCOMPARE(tester->events.last(), QEvent::GraphicsSceneHoverMove);
+
+    // Send a hover move event
+    QGraphicsSceneHoverEvent hoverMoveEvent(QEvent::GraphicsSceneHoverMove);
+    hoverMoveEvent.setScenePos(QPointF(0, 0));
+    hoverMoveEvent.setPos(QPointF(0, 0));
+    QApplication::sendEvent(&scene, &hoverMoveEvent);
+
+    // Check that we don't get a repaint
+    qApp->processEvents();
+    qApp->processEvents();
+
+    QCOMPARE(tester->events.size(), 3);
+    QCOMPARE(tester->repaints, npaints + 1);
+    QCOMPARE(tester->events.last(), QEvent::GraphicsSceneHoverMove);
+
+    // Send a hover leave event
+    QGraphicsSceneHoverEvent hoverLeaveEvent(QEvent::GraphicsSceneHoverLeave);
+    hoverLeaveEvent.setScenePos(QPointF(-100, -100));
+    hoverLeaveEvent.setPos(QPointF(0, 0));
+    QApplication::sendEvent(&scene, &hoverLeaveEvent);
+
+    // Check that we get a repaint
+    qApp->processEvents();
+    qApp->processEvents();
+
+    QCOMPARE(tester->events.size(), 4);
+    QCOMPARE(tester->repaints, npaints + 2);
+    QCOMPARE(tester->events.last(), QEvent::GraphicsSceneHoverLeave);
+}
+
+void tst_QGraphicsItem::boundingRects_data()
+{
+    QTest::addColumn<QGraphicsItem *>("item");
+    QTest::addColumn<QRectF>("boundingRect");
+
+    QRectF rect(0, 0, 100, 100);
+    QPainterPath path;
+    path.addRect(rect);
+
+    QRectF adjustedRect(-0.5, -0.5, 101, 101);
+
+    QTest::newRow("path") << (QGraphicsItem *)new QGraphicsPathItem(path) << adjustedRect;
+    QTest::newRow("rect") << (QGraphicsItem *)new QGraphicsRectItem(rect) << adjustedRect;
+    QTest::newRow("ellipse") << (QGraphicsItem *)new QGraphicsEllipseItem(rect) << adjustedRect;
+    QTest::newRow("polygon") << (QGraphicsItem *)new QGraphicsPolygonItem(rect) << adjustedRect;
+}
+
+void tst_QGraphicsItem::boundingRects()
+{
+    QFETCH(QGraphicsItem *, item);
+    QFETCH(QRectF, boundingRect);
+
+    ((QAbstractGraphicsShapeItem *)item)->setPen(QPen(Qt::black, 1));
+    QCOMPARE(item->boundingRect(), boundingRect);
+}
+
+void tst_QGraphicsItem::boundingRects2()
+{
+    QGraphicsPixmapItem pixmap(QPixmap::fromImage(QImage(100, 100, QImage::Format_ARGB32_Premultiplied)));
+    QCOMPARE(pixmap.boundingRect(), QRectF(0, 0, 100, 100));
+
+    QGraphicsLineItem line(0, 0, 100, 0);
+    line.setPen(QPen(Qt::black, 1));
+    QCOMPARE(line.boundingRect(), QRectF(-0.5, -0.5, 101, 1));
+}
+
+void tst_QGraphicsItem::sceneBoundingRect()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *item = scene.addRect(QRectF(0, 0, 100, 100), QPen(Qt::black, 0));
+    item->setPos(100, 100);
+
+    QCOMPARE(item->boundingRect(), QRectF(0, 0, 100, 100));
+    QCOMPARE(item->sceneBoundingRect(), QRectF(100, 100, 100, 100));
+
+    item->rotate(90);
+
+    QCOMPARE(item->boundingRect(), QRectF(0, 0, 100, 100));
+    QCOMPARE(item->sceneBoundingRect(), QRectF(0, 100, 100, 100));
+}
+
+void tst_QGraphicsItem::childrenBoundingRect()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *parent = scene.addRect(QRectF(0, 0, 100, 100), QPen(Qt::black, 0));
+    QGraphicsRectItem *child = scene.addRect(QRectF(0, 0, 100, 100), QPen(Qt::black, 0));
+    child->setParentItem(parent);
+    parent->setPos(100, 100);
+    child->setPos(100, 100);
+
+    QCOMPARE(parent->boundingRect(), QRectF(0, 0, 100, 100));
+    QCOMPARE(child->boundingRect(), QRectF(0, 0, 100, 100));
+    QCOMPARE(child->childrenBoundingRect(), QRectF());
+    QCOMPARE(parent->childrenBoundingRect(), QRectF(100, 100, 100, 100));
+
+    QGraphicsRectItem *child2 = scene.addRect(QRectF(0, 0, 100, 100), QPen(Qt::black, 0));
+    child2->setParentItem(parent);
+    child2->setPos(-100, -100);
+    QCOMPARE(parent->childrenBoundingRect(), QRectF(-100, -100, 300, 300));
+
+    QGraphicsRectItem *childChild = scene.addRect(QRectF(0, 0, 100, 100), QPen(Qt::black, 0));
+    childChild->setParentItem(child);
+    childChild->setPos(500, 500);
+    child->rotate(90);
+
+    scene.addPolygon(parent->mapToScene(parent->boundingRect() | parent->childrenBoundingRect()))->setPen(QPen(Qt::red));;
+
+    QGraphicsView view(&scene);
+    view.show();
+
+    QTest::qWaitForWindowShown(&view);
+    QTest::qWait(30);
+
+    QCOMPARE(parent->childrenBoundingRect(), QRectF(-500, -100, 600, 800));
+}
+
+void tst_QGraphicsItem::childrenBoundingRectTransformed()
+{
+    QGraphicsScene scene;
+
+    QGraphicsRectItem *rect = scene.addRect(QRectF(0, 0, 100, 100));
+    QGraphicsRectItem *rect2 = scene.addRect(QRectF(0, 0, 100, 100));
+    QGraphicsRectItem *rect3 = scene.addRect(QRectF(0, 0, 100, 100));
+    QGraphicsRectItem *rect4 = scene.addRect(QRectF(0, 0, 100, 100));
+    QGraphicsRectItem *rect5 = scene.addRect(QRectF(0, 0, 100, 100));
+    rect2->setParentItem(rect);
+    rect3->setParentItem(rect2);
+    rect4->setParentItem(rect3);
+    rect5->setParentItem(rect4);
+
+    rect2->setTransform(QTransform().translate(50, 50).rotate(45));
+    rect2->setPos(25, 25);
+    rect3->setTransform(QTransform().translate(50, 50).rotate(45));
+    rect3->setPos(25, 25);
+    rect4->setTransform(QTransform().translate(50, 50).rotate(45));
+    rect4->setPos(25, 25);
+    rect5->setTransform(QTransform().translate(50, 50).rotate(45));
+    rect5->setPos(25, 25);
+
+    QRectF subTreeRect = rect->childrenBoundingRect();
+    QCOMPARE(subTreeRect.left(), qreal(-206.0660171779821));
+    QCOMPARE(subTreeRect.top(), qreal(75.0));
+    QCOMPARE(subTreeRect.width(), qreal(351.7766952966369));
+    QCOMPARE(subTreeRect.height(), qreal(251.7766952966369));
+
+    rect->rotate(45);
+    rect2->rotate(-45);
+    rect3->rotate(45);
+    rect4->rotate(-45);
+    rect5->rotate(45);
+
+    subTreeRect = rect->childrenBoundingRect();
+    QCOMPARE(rect->childrenBoundingRect(), QRectF(-100, 75, 275, 250));
+}
+
+void tst_QGraphicsItem::childrenBoundingRect2()
+{
+    QGraphicsItemGroup box;
+    QGraphicsLineItem l1(0, 0, 100, 0, &box);
+    QGraphicsLineItem l2(100, 0, 100, 100, &box);
+    QGraphicsLineItem l3(0, 0, 0, 100, &box);
+    // Make sure lines (zero with/height) are included in the childrenBoundingRect.
+    QCOMPARE(box.childrenBoundingRect(), QRectF(0, 0, 100, 100));
+}
+
+void tst_QGraphicsItem::childrenBoundingRect3()
+{
+    QGraphicsScene scene;
+
+    QGraphicsRectItem *rect = scene.addRect(QRectF(0, 0, 100, 100));
+    QGraphicsRectItem *rect2 = scene.addRect(QRectF(0, 0, 100, 100));
+    QGraphicsRectItem *rect3 = scene.addRect(QRectF(0, 0, 100, 100));
+    QGraphicsRectItem *rect4 = scene.addRect(QRectF(0, 0, 100, 100));
+    QGraphicsRectItem *rect5 = scene.addRect(QRectF(0, 0, 100, 100));
+    rect2->setParentItem(rect);
+    rect3->setParentItem(rect2);
+    rect4->setParentItem(rect3);
+    rect5->setParentItem(rect4);
+
+    rect2->setTransform(QTransform().translate(50, 50).rotate(45));
+    rect2->setPos(25, 25);
+    rect3->setTransform(QTransform().translate(50, 50).rotate(45));
+    rect3->setPos(25, 25);
+    rect4->setTransform(QTransform().translate(50, 50).rotate(45));
+    rect4->setPos(25, 25);
+    rect5->setTransform(QTransform().translate(50, 50).rotate(45));
+    rect5->setPos(25, 25);
+
+    // Try to mess up the cached bounding rect.
+    (void)rect2->childrenBoundingRect();
+
+    QRectF subTreeRect = rect->childrenBoundingRect();
+    QCOMPARE(subTreeRect.left(), qreal(-206.0660171779821));
+    QCOMPARE(subTreeRect.top(), qreal(75.0));
+    QCOMPARE(subTreeRect.width(), qreal(351.7766952966369));
+    QCOMPARE(subTreeRect.height(), qreal(251.7766952966369));
+}
+
+void tst_QGraphicsItem::childrenBoundingRect4()
+{
+    QGraphicsScene scene;
+
+    QGraphicsRectItem *rect = scene.addRect(QRectF(0, 0, 10, 10));
+    QGraphicsRectItem *rect2 = scene.addRect(QRectF(0, 0, 20, 20));
+    QGraphicsRectItem *rect3 = scene.addRect(QRectF(0, 0, 30, 30));
+    rect2->setParentItem(rect);
+    rect3->setParentItem(rect);
+
+    QGraphicsView view(&scene);
+    view.show();
+
+    QTest::qWaitForWindowShown(&view);
+
+    // Try to mess up the cached bounding rect.
+    rect->childrenBoundingRect();
+    rect2->childrenBoundingRect();
+
+    rect3->setOpacity(0.0);
+    rect3->setParentItem(rect2);
+
+    QCOMPARE(rect->childrenBoundingRect(), rect3->boundingRect());
+    QCOMPARE(rect2->childrenBoundingRect(), rect3->boundingRect());
+}
+
+void tst_QGraphicsItem::childrenBoundingRect5()
+{
+    QGraphicsScene scene;
+
+    QGraphicsRectItem *parent = scene.addRect(QRectF(0, 0, 100, 100));
+    QGraphicsRectItem *child = scene.addRect(QRectF(0, 0, 100, 100));
+    child->setParentItem(parent);
+
+    QGraphicsView view(&scene);
+    view.show();
+
+    QTest::qWaitForWindowShown(&view);
+
+    // Try to mess up the cached bounding rect.
+    QRectF expectedChildrenBoundingRect = parent->boundingRect();
+    QCOMPARE(parent->childrenBoundingRect(), expectedChildrenBoundingRect);
+
+    // Apply some effects.
+    QGraphicsDropShadowEffect *dropShadow = new QGraphicsDropShadowEffect;
+    dropShadow->setOffset(25, 25);
+    child->setGraphicsEffect(dropShadow);
+    parent->setGraphicsEffect(new QGraphicsOpacityEffect);
+
+    QVERIFY(parent->childrenBoundingRect() != expectedChildrenBoundingRect);
+    expectedChildrenBoundingRect |= dropShadow->boundingRect();
+    QCOMPARE(parent->childrenBoundingRect(), expectedChildrenBoundingRect);
+}
+
+void tst_QGraphicsItem::group()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *parent = scene.addRect(QRectF(0, 0, 50, 50), QPen(Qt::black, 0), QBrush(Qt::green));
+    QGraphicsRectItem *child = scene.addRect(QRectF(0, 0, 50, 50), QPen(Qt::black, 0), QBrush(Qt::blue));
+    QGraphicsRectItem *parent2 = scene.addRect(QRectF(0, 0, 50, 50), QPen(Qt::black, 0), QBrush(Qt::red));
+    parent2->setPos(-50, 50);
+    child->rotate(45);
+    child->setParentItem(parent);
+    parent->setPos(25, 25);
+    child->setPos(25, 25);
+
+    QCOMPARE(parent->group(), (QGraphicsItemGroup *)0);
+    QCOMPARE(parent2->group(), (QGraphicsItemGroup *)0);
+    QCOMPARE(child->group(), (QGraphicsItemGroup *)0);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QApplication::processEvents();
+
+    QGraphicsItemGroup *group = new QGraphicsItemGroup;
+    group->setSelected(true);
+    scene.addItem(group);
+
+    QRectF parentSceneBoundingRect = parent->sceneBoundingRect();
+    group->addToGroup(parent);
+    QCOMPARE(parent->group(), group);
+    QCOMPARE(parent->sceneBoundingRect(), parentSceneBoundingRect);
+
+    QCOMPARE(parent->parentItem(), (QGraphicsItem *)group);
+    QCOMPARE(group->children().size(), 1);
+    QCOMPARE(scene.items().size(), 4);
+    QCOMPARE(scene.items(group->sceneBoundingRect()).size(), 3);
+
+    QTest::qWait(25);
+
+    QRectF parent2SceneBoundingRect = parent2->sceneBoundingRect();
+    group->addToGroup(parent2);
+    QCOMPARE(parent2->group(), group);
+    QCOMPARE(parent2->sceneBoundingRect(), parent2SceneBoundingRect);
+
+    QCOMPARE(parent2->parentItem(), (QGraphicsItem *)group);
+    QCOMPARE(group->children().size(), 2);
+    QCOMPARE(scene.items().size(), 4);
+    QCOMPARE(scene.items(group->sceneBoundingRect()).size(), 4);
+
+    QTest::qWait(25);
+
+    QList<QGraphicsItem *> newItems;
+    for (int i = 0; i < 100; ++i) {
+        QGraphicsItem *item = scene.addRect(QRectF(-25, -25, 50, 50), QPen(Qt::black, 0),
+                                            QBrush(QColor(rand() % 255, rand() % 255,
+                                                          rand() % 255, rand() % 255)));
+        newItems << item;
+        item->setPos(-1000 + rand() % 2000,
+                     -1000 + rand() % 2000);
+        item->rotate(rand() % 90);
+    }
+
+    view.fitInView(scene.itemsBoundingRect());
+
+    int n = 0;
+    foreach (QGraphicsItem *item, newItems) {
+        group->addToGroup(item);
+        QCOMPARE(item->group(), group);
+        if ((n++ % 100) == 0)
+            QTest::qWait(10);
+    }
+}
+
+void tst_QGraphicsItem::setGroup()
+{
+    QGraphicsItemGroup group1;
+    QGraphicsItemGroup group2;
+
+    QGraphicsRectItem *rect = new QGraphicsRectItem;
+    QCOMPARE(rect->group(), (QGraphicsItemGroup *)0);
+    QCOMPARE(rect->parentItem(), (QGraphicsItem *)0);
+    rect->setGroup(&group1);
+    QCOMPARE(rect->group(), &group1);
+    QCOMPARE(rect->parentItem(), (QGraphicsItem *)&group1);
+    rect->setGroup(&group2);
+    QCOMPARE(rect->group(), &group2);
+    QCOMPARE(rect->parentItem(), (QGraphicsItem *)&group2);
+    rect->setGroup(0);
+    QCOMPARE(rect->group(), (QGraphicsItemGroup *)0);
+    QCOMPARE(rect->parentItem(), (QGraphicsItem *)0);
+}
+
+void tst_QGraphicsItem::setGroup2()
+{
+    QGraphicsScene scene;
+    QGraphicsItemGroup group;
+    scene.addItem(&group);
+
+    QGraphicsRectItem *rect = scene.addRect(50,50,50,50,Qt::NoPen,Qt::black);
+    rect->setTransformOriginPoint(50,50);
+    rect->setRotation(45);
+    rect->setScale(1.5);
+    rect->translate(20,20);
+    group.translate(-30,-40);
+    group.setRotation(180);
+    group.setScale(0.5);
+
+    QTransform oldSceneTransform = rect->sceneTransform();
+    rect->setGroup(&group);
+    QCOMPARE(rect->sceneTransform(), oldSceneTransform);
+
+    group.setRotation(20);
+    group.setScale(2);
+    rect->setRotation(90);
+    rect->setScale(0.8);
+
+    oldSceneTransform = rect->sceneTransform();
+    rect->setGroup(0);
+    QCOMPARE(rect->sceneTransform(), oldSceneTransform);
+}
+
+void tst_QGraphicsItem::nestedGroups()
+{
+    QGraphicsItemGroup *group1 = new QGraphicsItemGroup;
+    QGraphicsItemGroup *group2 = new QGraphicsItemGroup;
+
+    QGraphicsRectItem *rect = new QGraphicsRectItem;
+    QGraphicsRectItem *rect2 = new QGraphicsRectItem;
+    rect2->setParentItem(rect);
+
+    group1->addToGroup(rect);
+    QCOMPARE(rect->group(), group1);
+    QCOMPARE(rect2->group(), group1);
+
+    group2->addToGroup(group1);
+    QCOMPARE(rect->group(), group1);
+    QCOMPARE(rect2->group(), group1);
+    QCOMPARE(group1->group(), group2);
+    QCOMPARE(group2->group(), (QGraphicsItemGroup *)0);
+
+    QGraphicsScene scene;
+    scene.addItem(group1);
+
+    QCOMPARE(rect->group(), group1);
+    QCOMPARE(rect2->group(), group1);
+    QCOMPARE(group1->group(), (QGraphicsItemGroup *)0);
+    QVERIFY(group2->children().isEmpty());
+
+    delete group2;
+}
+
+void tst_QGraphicsItem::warpChildrenIntoGroup()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *parentRectItem = scene.addRect(QRectF(0, 0, 100, 100));
+    QGraphicsRectItem *childRectItem = scene.addRect(QRectF(0, 0, 100, 100));
+    parentRectItem->rotate(90);
+    childRectItem->setPos(-50, -25);
+    childRectItem->setParentItem(parentRectItem);
+
+    QCOMPARE(childRectItem->mapToScene(50, 0), QPointF(25, 0));
+    QCOMPARE(childRectItem->scenePos(), QPointF(25, -50));
+
+    QGraphicsRectItem *parentOfGroup = scene.addRect(QRectF(0, 0, 100, 100));
+    parentOfGroup->setPos(-200, -200);
+    parentOfGroup->scale(2, 2);
+
+    QGraphicsItemGroup *group = new QGraphicsItemGroup;
+    group->setPos(50, 50);
+    group->setParentItem(parentOfGroup);
+
+    QCOMPARE(group->scenePos(), QPointF(-100, -100));
+
+    group->addToGroup(childRectItem);
+
+    QCOMPARE(childRectItem->mapToScene(50, 0), QPointF(25, 0));
+    QCOMPARE(childRectItem->scenePos(), QPointF(25, -50));
+}
+
+void tst_QGraphicsItem::removeFromGroup()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *rect1 = scene.addRect(QRectF(-100, -100, 200, 200));
+    QGraphicsRectItem *rect2 = scene.addRect(QRectF(100, 100, 200, 200));
+    rect1->setFlag(QGraphicsItem::ItemIsSelectable);
+    rect2->setFlag(QGraphicsItem::ItemIsSelectable);
+    rect1->setSelected(true);
+    rect2->setSelected(true);
+
+    QGraphicsView view(&scene);
+    view.show();
+
+    qApp->processEvents(); // index items
+    qApp->processEvents(); // emit changed
+
+    QGraphicsItemGroup *group = scene.createItemGroup(scene.selectedItems());
+    QVERIFY(group);
+    QCOMPARE(group->children().size(), 2);
+    qApp->processEvents(); // index items
+    qApp->processEvents(); // emit changed
+
+    scene.destroyItemGroup(group); // calls removeFromGroup.
+
+    qApp->processEvents(); // index items
+    qApp->processEvents(); // emit changed
+
+    QCOMPARE(scene.items().size(), 2);
+    QVERIFY(!rect1->group());
+    QVERIFY(!rect2->group());
+}
+
+class ChildEventTester : public QGraphicsRectItem
+{
+public:
+    ChildEventTester(const QRectF &rect, QGraphicsItem *parent = 0)
+        : QGraphicsRectItem(rect, parent), counter(0)
+    { }
+
+    int counter;
+
+protected:
+    void focusInEvent(QFocusEvent *event)
+    { ++counter; QGraphicsRectItem::focusInEvent(event); }
+    void mousePressEvent(QGraphicsSceneMouseEvent *)
+    { ++counter; }
+    void mouseMoveEvent(QGraphicsSceneMouseEvent *)
+    { ++counter; }
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent *)
+    { ++counter; }
+};
+
+void tst_QGraphicsItem::handlesChildEvents()
+{
+    ChildEventTester *blue = new ChildEventTester(QRectF(0, 0, 100, 100));
+    ChildEventTester *red = new ChildEventTester(QRectF(0, 0, 50, 50));
+    ChildEventTester *green = new ChildEventTester(QRectF(0, 0, 25, 25));
+    ChildEventTester *gray = new ChildEventTester(QRectF(0, 0, 25, 25));
+    ChildEventTester *yellow = new ChildEventTester(QRectF(0, 0, 50, 50));
+
+    blue->setBrush(QBrush(Qt::blue));
+    red->setBrush(QBrush(Qt::red));
+    yellow->setBrush(QBrush(Qt::yellow));
+    green->setBrush(QBrush(Qt::green));
+    gray->setBrush(QBrush(Qt::gray));
+    red->setPos(50, 0);
+    yellow->setPos(50, 50);
+    green->setPos(25, 0);
+    gray->setPos(25, 25);
+    red->setParentItem(blue);
+    yellow->setParentItem(blue);
+    green->setParentItem(red);
+    gray->setParentItem(red);
+
+    QGraphicsScene scene;
+    scene.addItem(blue);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTest::qWait(20);
+
+    // Pull out the items, closest item first
+    QList<QGraphicsItem *> items = scene.items(scene.itemsBoundingRect());
+    QCOMPARE(items.at(0), (QGraphicsItem *)yellow);
+    QCOMPARE(items.at(1), (QGraphicsItem *)gray);
+    QCOMPARE(items.at(2), (QGraphicsItem *)green);
+    QCOMPARE(items.at(3), (QGraphicsItem *)red);
+    QCOMPARE(items.at(4), (QGraphicsItem *)blue);
+
+    QCOMPARE(blue->counter, 0);
+
+    // Send events to the toplevel item
+    QGraphicsSceneMouseEvent pressEvent(QEvent::GraphicsSceneMousePress);
+    QGraphicsSceneMouseEvent releaseEvent(QEvent::GraphicsSceneMouseRelease);
+
+    pressEvent.setButton(Qt::LeftButton);
+    pressEvent.setScenePos(blue->mapToScene(5, 5));
+    pressEvent.setScreenPos(view.mapFromScene(pressEvent.scenePos()));
+    releaseEvent.setButton(Qt::LeftButton);
+    releaseEvent.setScenePos(blue->mapToScene(5, 5));
+    releaseEvent.setScreenPos(view.mapFromScene(pressEvent.scenePos()));
+    QApplication::sendEvent(&scene, &pressEvent);
+    QApplication::sendEvent(&scene, &releaseEvent);
+
+    QCOMPARE(blue->counter, 2);
+
+    // Send events to a level1 item
+    pressEvent.setScenePos(red->mapToScene(5, 5));
+    pressEvent.setScreenPos(view.mapFromScene(pressEvent.scenePos()));
+    releaseEvent.setScenePos(red->mapToScene(5, 5));
+    releaseEvent.setScreenPos(view.mapFromScene(releaseEvent.scenePos()));
+    QApplication::sendEvent(&scene, &pressEvent);
+    QApplication::sendEvent(&scene, &releaseEvent);
+
+    QCOMPARE(blue->counter, 2);
+    QCOMPARE(red->counter, 2);
+
+    // Send events to a level2 item
+    pressEvent.setScenePos(green->mapToScene(5, 5));
+    pressEvent.setScreenPos(view.mapFromScene(pressEvent.scenePos()));
+    releaseEvent.setScenePos(green->mapToScene(5, 5));
+    releaseEvent.setScreenPos(view.mapFromScene(releaseEvent.scenePos()));
+    QApplication::sendEvent(&scene, &pressEvent);
+    QApplication::sendEvent(&scene, &releaseEvent);
+
+    QCOMPARE(blue->counter, 2);
+    QCOMPARE(red->counter, 2);
+    QCOMPARE(green->counter, 2);
+
+    blue->setHandlesChildEvents(true);
+
+    // Send events to a level1 item
+    pressEvent.setScenePos(red->mapToScene(5, 5));
+    pressEvent.setScreenPos(view.mapFromScene(pressEvent.scenePos()));
+    releaseEvent.setScenePos(red->mapToScene(5, 5));
+    releaseEvent.setScreenPos(view.mapFromScene(releaseEvent.scenePos()));
+    QApplication::sendEvent(&scene, &pressEvent);
+    QApplication::sendEvent(&scene, &releaseEvent);
+
+    QCOMPARE(blue->counter, 4);
+    QCOMPARE(red->counter, 2);
+
+    // Send events to a level2 item
+    pressEvent.setScenePos(green->mapToScene(5, 5));
+    pressEvent.setScreenPos(view.mapFromScene(pressEvent.scenePos()));
+    releaseEvent.setScenePos(green->mapToScene(5, 5));
+    releaseEvent.setScreenPos(view.mapFromScene(releaseEvent.scenePos()));
+    QApplication::sendEvent(&scene, &pressEvent);
+    QApplication::sendEvent(&scene, &releaseEvent);
+
+    QCOMPARE(blue->counter, 6);
+    QCOMPARE(red->counter, 2);
+    QCOMPARE(green->counter, 2);
+
+    blue->setHandlesChildEvents(false);
+
+    // Send events to a level1 item
+    pressEvent.setScenePos(red->mapToScene(5, 5));
+    pressEvent.setScreenPos(view.mapFromScene(pressEvent.scenePos()));
+    releaseEvent.setScenePos(red->mapToScene(5, 5));
+    releaseEvent.setScreenPos(view.mapFromScene(releaseEvent.scenePos()));
+    QApplication::sendEvent(&scene, &pressEvent);
+    QApplication::sendEvent(&scene, &releaseEvent);
+
+    QCOMPARE(blue->counter, 6);
+    QCOMPARE(red->counter, 4);
+
+    // Send events to a level2 item
+    pressEvent.setScenePos(green->mapToScene(5, 5));
+    pressEvent.setScreenPos(view.mapFromScene(pressEvent.scenePos()));
+    releaseEvent.setScenePos(green->mapToScene(5, 5));
+    releaseEvent.setScreenPos(view.mapFromScene(releaseEvent.scenePos()));
+    QApplication::sendEvent(&scene, &pressEvent);
+    QApplication::sendEvent(&scene, &releaseEvent);
+
+    QCOMPARE(blue->counter, 6);
+    QCOMPARE(red->counter, 4);
+    QCOMPARE(green->counter, 4);
+}
+
+void tst_QGraphicsItem::handlesChildEvents2()
+{
+    ChildEventTester *root = new ChildEventTester(QRectF(0, 0, 10, 10));
+    root->setHandlesChildEvents(true);
+    QVERIFY(root->handlesChildEvents());
+
+    ChildEventTester *child = new ChildEventTester(QRectF(0, 0, 10, 10), root);
+    QVERIFY(!child->handlesChildEvents());
+
+    ChildEventTester *child2 = new ChildEventTester(QRectF(0, 0, 10, 10));
+    ChildEventTester *child3 = new ChildEventTester(QRectF(0, 0, 10, 10), child2);
+    ChildEventTester *child4 = new ChildEventTester(QRectF(0, 0, 10, 10), child3);
+    child2->setParentItem(root);
+    QVERIFY(!child2->handlesChildEvents());
+    QVERIFY(!child3->handlesChildEvents());
+    QVERIFY(!child4->handlesChildEvents());
+
+    QGraphicsScene scene;
+    scene.addItem(root);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QApplication::processEvents();
+
+    QMouseEvent event(QEvent::MouseButtonPress, view.mapFromScene(5, 5),
+                      view.viewport()->mapToGlobal(view.mapFromScene(5, 5)), Qt::LeftButton, 0, 0);
+    QApplication::sendEvent(view.viewport(), &event);
+
+    QTRY_COMPARE(root->counter, 1);
+}
+
+void tst_QGraphicsItem::handlesChildEvents3()
+{
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    ChildEventTester *group2 = new ChildEventTester(QRectF(), 0);
+    ChildEventTester *group1 = new ChildEventTester(QRectF(), group2);
+    ChildEventTester *leaf = new ChildEventTester(QRectF(), group1);
+    scene.addItem(group2);
+
+    leaf->setFlag(QGraphicsItem::ItemIsFocusable);
+    group1->setFlag(QGraphicsItem::ItemIsFocusable);
+    group1->setHandlesChildEvents(true);
+    group2->setFlag(QGraphicsItem::ItemIsFocusable);
+    group2->setHandlesChildEvents(true);
+
+    leaf->setFocus();
+    QVERIFY(leaf->hasFocus()); // group2 stole the event, but leaf still got focus
+    QVERIFY(!group1->hasFocus());
+    QVERIFY(!group2->hasFocus());
+    QCOMPARE(leaf->counter, 0);
+    QCOMPARE(group1->counter, 0);
+    QCOMPARE(group2->counter, 1);
+
+    group1->setFocus();
+    QVERIFY(group1->hasFocus()); // group2 stole the event, but group1 still got focus
+    QVERIFY(!leaf->hasFocus());
+    QVERIFY(!group2->hasFocus());
+    QCOMPARE(leaf->counter, 0);
+    QCOMPARE(group1->counter, 0);
+    QCOMPARE(group2->counter, 2);
+
+    group2->setFocus();
+    QVERIFY(group2->hasFocus()); // group2 stole the event, and now group2 also has focus
+    QVERIFY(!leaf->hasFocus());
+    QVERIFY(!group1->hasFocus());
+    QCOMPARE(leaf->counter, 0);
+    QCOMPARE(group1->counter, 0);
+    QCOMPARE(group2->counter, 3);
+}
+
+
+class ChildEventFilterTester : public ChildEventTester
+{
+public:
+    ChildEventFilterTester(const QRectF &rect, QGraphicsItem *parent = 0)
+        : ChildEventTester(rect, parent), filter(QEvent::None)
+    { }
+
+    QEvent::Type filter;
+
+protected:
+    bool sceneEventFilter(QGraphicsItem *item, QEvent *event)
+    {
+        Q_UNUSED(item);
+        if (event->type() == filter) {
+            ++counter;
+            return true;
+        }
+        return false;
+    }
+};
+
+void tst_QGraphicsItem::filtersChildEvents()
+{
+    QGraphicsScene scene;
+    ChildEventFilterTester *root = new ChildEventFilterTester(QRectF(0, 0, 10, 10));
+    ChildEventFilterTester *filter = new ChildEventFilterTester(QRectF(10, 10, 10, 10), root);
+    ChildEventTester *child = new ChildEventTester(QRectF(20, 20, 10, 10), filter);
+
+    // setup filter
+    filter->setFiltersChildEvents(true);
+    filter->filter = QEvent::GraphicsSceneMousePress;
+
+    scene.addItem(root);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTest::qWait(20);
+
+    QGraphicsSceneMouseEvent pressEvent(QEvent::GraphicsSceneMousePress);
+    QGraphicsSceneMouseEvent releaseEvent(QEvent::GraphicsSceneMouseRelease);
+
+    // send event to child
+    pressEvent.setButton(Qt::LeftButton);
+    pressEvent.setScenePos(QPointF(25, 25));//child->mapToScene(5, 5));
+    pressEvent.setScreenPos(view.mapFromScene(pressEvent.scenePos()));
+    releaseEvent.setButton(Qt::LeftButton);
+    releaseEvent.setScenePos(QPointF(25, 25));//child->mapToScene(5, 5));
+    releaseEvent.setScreenPos(view.mapFromScene(pressEvent.scenePos()));
+    QApplication::sendEvent(&scene, &pressEvent);
+    QApplication::sendEvent(&scene, &releaseEvent);
+
+    QTRY_COMPARE(child->counter, 1);  // mouse release is not filtered
+    QCOMPARE(filter->counter, 1); // mouse press is filtered
+    QCOMPARE(root->counter, 0);
+
+    // add another filter
+    root->setFiltersChildEvents(true);
+    root->filter = QEvent::GraphicsSceneMouseRelease;
+
+    // send event to child
+    QApplication::sendEvent(&scene, &pressEvent);
+    QApplication::sendEvent(&scene, &releaseEvent);
+
+    QCOMPARE(child->counter, 1);
+    QCOMPARE(filter->counter, 2); // mouse press is filtered
+    QCOMPARE(root->counter, 1); // mouse release is filtered
+
+    // reparent to another sub-graph
+    ChildEventTester *parent = new ChildEventTester(QRectF(10, 10, 10, 10), root);
+    child->setParentItem(parent);
+
+    // send event to child
+    QApplication::sendEvent(&scene, &pressEvent);
+    QApplication::sendEvent(&scene, &releaseEvent);
+
+    QCOMPARE(child->counter, 2); // mouse press is _not_ filtered
+    QCOMPARE(parent->counter, 0);
+    QCOMPARE(filter->counter, 2);
+    QCOMPARE(root->counter, 2); // mouse release is filtered
+}
+
+void tst_QGraphicsItem::filtersChildEvents2()
+{
+    ChildEventFilterTester *root = new ChildEventFilterTester(QRectF(0, 0, 10, 10));
+    root->setFiltersChildEvents(true);
+    root->filter = QEvent::GraphicsSceneMousePress;
+    QVERIFY(root->filtersChildEvents());
+
+    ChildEventTester *child = new ChildEventTester(QRectF(0, 0, 10, 10), root);
+    QVERIFY(!child->filtersChildEvents());
+
+    ChildEventTester *child2 = new ChildEventTester(QRectF(0, 0, 10, 10));
+    ChildEventTester *child3 = new ChildEventTester(QRectF(0, 0, 10, 10), child2);
+    ChildEventTester *child4 = new ChildEventTester(QRectF(0, 0, 10, 10), child3);
+
+    child2->setParentItem(root);
+    QVERIFY(!child2->filtersChildEvents());
+    QVERIFY(!child3->filtersChildEvents());
+    QVERIFY(!child4->filtersChildEvents());
+
+    QGraphicsScene scene;
+    scene.addItem(root);
+
+    QGraphicsView view(&scene);
+    view.show();
+
+    QTest::qWaitForWindowShown(&view);
+    QApplication::processEvents();
+
+    QMouseEvent event(QEvent::MouseButtonPress, view.mapFromScene(5, 5),
+                      view.viewport()->mapToGlobal(view.mapFromScene(5, 5)), Qt::LeftButton, 0, 0);
+    QApplication::sendEvent(view.viewport(), &event);
+
+    QTRY_COMPARE(root->counter, 1);
+    QCOMPARE(child->counter, 0);
+    QCOMPARE(child2->counter, 0);
+    QCOMPARE(child3->counter, 0);
+    QCOMPARE(child4->counter, 0);
+}
+
+class CustomItem : public QGraphicsItem
+{
+public:
+    QRectF boundingRect() const
+    { return QRectF(-110, -110, 220, 220); }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+    {
+        for (int x = -100; x <= 100; x += 25)
+            painter->drawLine(x, -100, x, 100);
+        for (int y = -100; y <= 100; y += 25)
+            painter->drawLine(-100, y, 100, y);
+
+        QFont font = painter->font();
+        font.setPointSize(4);
+        painter->setFont(font);
+        for (int x = -100; x < 100; x += 25) {
+            for (int y = -100; y < 100; y += 25) {
+                painter->drawText(QRectF(x, y, 25, 25), Qt::AlignCenter, QString("%1x%2").arg(x).arg(y));
+            }
+        }
+    }
+};
+
+void tst_QGraphicsItem::ensureVisible()
+{
+    QGraphicsScene scene;
+    scene.setSceneRect(-200, -200, 400, 400);
+    QGraphicsItem *item = new CustomItem;
+    scene.addItem(item);
+
+    QGraphicsView view(&scene);
+    view.setFixedSize(300, 300);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    for (int i = 0; i < 25; ++i) {
+        view.scale(qreal(1.06), qreal(1.06));
+        QApplication::processEvents();
+    }
+
+    item->ensureVisible(-100, -100, 25, 25);
+    QTest::qWait(25);
+
+    for (int x = -100; x < 100; x += 25) {
+        for (int y = -100; y < 100; y += 25) {
+            int xmargin = rand() % 75;
+            int ymargin = rand() % 75;
+            item->ensureVisible(x, y, 25, 25, xmargin, ymargin);
+            QApplication::processEvents();
+
+            QPolygonF viewScenePoly;
+            viewScenePoly << view.mapToScene(view.rect().topLeft())
+                          << view.mapToScene(view.rect().topRight())
+                          << view.mapToScene(view.rect().bottomRight())
+                          << view.mapToScene(view.rect().bottomLeft());
+
+            QVERIFY(scene.items(viewScenePoly).contains(item));
+
+            QPainterPath path;
+            path.addPolygon(viewScenePoly);
+            QVERIFY(path.contains(item->mapToScene(x + 12, y + 12)));
+
+            QPolygonF viewScenePolyMinusMargins;
+            viewScenePolyMinusMargins << view.mapToScene(view.rect().topLeft() + QPoint(xmargin, ymargin))
+                          << view.mapToScene(view.rect().topRight() + QPoint(-xmargin, ymargin))
+                          << view.mapToScene(view.rect().bottomRight() + QPoint(-xmargin, -ymargin))
+                          << view.mapToScene(view.rect().bottomLeft() + QPoint(xmargin, -ymargin));
+
+            QPainterPath path2;
+            path2.addPolygon(viewScenePolyMinusMargins);
+            QVERIFY(path2.contains(item->mapToScene(x + 12, y + 12)));
+        }
+    }
+
+    item->ensureVisible(100, 100, 25, 25);
+    QTest::qWait(25);
+}
+
+void tst_QGraphicsItem::cursor()
+{
+#ifndef QT_NO_CURSOR
+    QGraphicsScene scene;
+    QGraphicsRectItem *item1 = scene.addRect(QRectF(0, 0, 50, 50));
+    QGraphicsRectItem *item2 = scene.addRect(QRectF(0, 0, 50, 50));
+    item1->setPos(-100, 0);
+    item2->setPos(50, 0);
+
+    QVERIFY(!item1->hasCursor());
+    QVERIFY(!item2->hasCursor());
+
+    item1->setCursor(Qt::IBeamCursor);
+    item2->setCursor(Qt::PointingHandCursor);
+
+    QVERIFY(item1->hasCursor());
+    QVERIFY(item2->hasCursor());
+
+    item1->setCursor(QCursor());
+    item2->setCursor(QCursor());
+
+    QVERIFY(item1->hasCursor());
+    QVERIFY(item2->hasCursor());
+
+    item1->unsetCursor();
+    item2->unsetCursor();
+
+    QVERIFY(!item1->hasCursor());
+    QVERIFY(!item2->hasCursor());
+
+    item1->setCursor(Qt::IBeamCursor);
+    item2->setCursor(Qt::PointingHandCursor);
+
+    QWidget topLevel;
+    QGraphicsView view(&scene,&topLevel);
+    view.setFixedSize(200, 100);
+    topLevel.show();
+    QTest::mouseMove(&view, view.rect().center());
+
+    QTest::qWait(25);
+
+    QCursor cursor = view.viewport()->cursor();
+
+    {
+        QMouseEvent event(QEvent::MouseMove, QPoint(100, 50), Qt::NoButton, 0, 0);
+        QApplication::sendEvent(view.viewport(), &event);
+    }
+
+    QTest::qWait(25);
+
+    QCOMPARE(view.viewport()->cursor().shape(), cursor.shape());
+
+    {
+        QTest::mouseMove(view.viewport(), view.mapFromScene(item1->sceneBoundingRect().center()));
+        QMouseEvent event(QEvent::MouseMove, view.mapFromScene(item1->sceneBoundingRect().center()), Qt::NoButton, 0, 0);
+        QApplication::sendEvent(view.viewport(), &event);
+    }
+
+    if (!PlatformQuirks::haveMouseCursor())
+        return;
+#if !defined(Q_OS_WINCE)
+    QTest::qWait(250);
+#else
+    // Test environment does not have any cursor, therefore no shape
+    return;
+#endif
+
+    QCOMPARE(view.viewport()->cursor().shape(), item1->cursor().shape());
+
+    {
+        QTest::mouseMove(view.viewport(), view.mapFromScene(item2->sceneBoundingRect().center()));
+        QMouseEvent event(QEvent::MouseMove, view.mapFromScene(item2->sceneBoundingRect().center()), Qt::NoButton, 0, 0);
+        QApplication::sendEvent(view.viewport(), &event);
+    }
+
+    QTest::qWait(25);
+
+    QCOMPARE(view.viewport()->cursor().shape(), item2->cursor().shape());
+
+    {
+        QTest::mouseMove(view.viewport(), view.rect().center());
+        QMouseEvent event(QEvent::MouseMove, QPoint(100, 25), Qt::NoButton, 0, 0);
+        QApplication::sendEvent(view.viewport(), &event);
+    }
+
+    QTest::qWait(25);
+
+    QCOMPARE(view.viewport()->cursor().shape(), cursor.shape());
+#endif
+}
+/*
+void tst_QGraphicsItem::textControlGetterSetter()
+{
+    QGraphicsTextItem *item = new QGraphicsTextItem;
+    QVERIFY(item->textControl()->parent() == item);
+    QPointer<QTextControl> control = item->textControl();
+    delete item;
+    QVERIFY(!control);
+
+    item = new QGraphicsTextItem;
+
+    QPointer<QTextControl> oldControl = control;
+    control = new QTextControl;
+
+    item->setTextControl(control);
+    QVERIFY(item->textControl() == control);
+    QVERIFY(!control->parent());
+    QVERIFY(!oldControl);
+
+    // set some text to give it a size, to test that
+    // setTextControl (re)connects signals
+    const QRectF oldBoundingRect = item->boundingRect();
+    QVERIFY(oldBoundingRect.isValid());
+    item->setPlainText("Some text");
+    item->adjustSize();
+    QVERIFY(item->boundingRect().isValid());
+    QVERIFY(item->boundingRect() != oldBoundingRect);
+
+    // test that on setting a control the item size
+    // is adjusted
+    oldControl = control;
+    control = new QTextControl;
+    control->setPlainText("foo!");
+    item->setTextControl(control);
+    QCOMPARE(item->boundingRect().size(), control->document()->documentLayout()->documentSize());
+
+    QVERIFY(oldControl);
+    delete oldControl;
+
+    delete item;
+    QVERIFY(control);
+    delete control;
+}
+*/
+
+void tst_QGraphicsItem::defaultItemTest_QGraphicsLineItem()
+{
+    QGraphicsLineItem item;
+    QCOMPARE(item.line(), QLineF());
+    QCOMPARE(item.pen(), QPen());
+    QCOMPARE(item.shape(), QPainterPath());
+
+    item.setPen(QPen(Qt::black, 1));
+    QCOMPARE(item.pen(), QPen(Qt::black, 1));
+    item.setLine(QLineF(0, 0, 10, 0));
+    QCOMPARE(item.line(), QLineF(0, 0, 10, 0));
+    QCOMPARE(item.boundingRect(), QRectF(-0.5, -0.5, 11, 1));
+    QCOMPARE(item.shape().elementCount(), 11);
+
+    QPainterPath path;
+    path.moveTo(0, -0.5);
+    path.lineTo(10, -0.5);
+    path.lineTo(10.5, -0.5);
+    path.lineTo(10.5, 0.5);
+    path.lineTo(10, 0.5);
+    path.lineTo(0, 0.5);
+    path.lineTo(-0.5, 0.5);
+    path.lineTo(-0.5, -0.5);
+    path.lineTo(0, -0.5);
+    path.lineTo(0, 0);
+    path.lineTo(10, 0);
+    path.closeSubpath();
+
+    for (int i = 0; i < 11; ++i)
+        QCOMPARE(QPointF(item.shape().elementAt(i)), QPointF(path.elementAt(i)));
+}
+
+void tst_QGraphicsItem::defaultItemTest_QGraphicsPixmapItem()
+{
+    QGraphicsPixmapItem item;
+    QVERIFY(item.pixmap().isNull());
+    QCOMPARE(item.offset(), QPointF());
+    QCOMPARE(item.transformationMode(), Qt::FastTransformation);
+
+    QPixmap pixmap(300, 200);
+    pixmap.fill(Qt::red);
+    item.setPixmap(pixmap);
+    QCOMPARE(item.pixmap(), pixmap);
+
+    item.setTransformationMode(Qt::FastTransformation);
+    QCOMPARE(item.transformationMode(), Qt::FastTransformation);
+    item.setTransformationMode(Qt::SmoothTransformation);
+    QCOMPARE(item.transformationMode(), Qt::SmoothTransformation);
+
+    item.setOffset(-15, -15);
+    QCOMPARE(item.offset(), QPointF(-15, -15));
+    item.setOffset(QPointF(-10, -10));
+    QCOMPARE(item.offset(), QPointF(-10, -10));
+
+    QCOMPARE(item.boundingRect(), QRectF(-10, -10, 300, 200));
+}
+
+void tst_QGraphicsItem::defaultItemTest_QGraphicsTextItem()
+{
+    QGraphicsTextItem *text = new QGraphicsTextItem;
+    QVERIFY(!text->openExternalLinks());
+    QVERIFY(text->textCursor().isNull());
+    QCOMPARE(text->defaultTextColor(), QPalette().color(QPalette::Text));
+    QVERIFY(text->document() != 0);
+    QCOMPARE(text->font(), QApplication::font());
+    QCOMPARE(text->textInteractionFlags(), Qt::TextInteractionFlags(Qt::NoTextInteraction));
+    QCOMPARE(text->textWidth(), -1.0);
+    QCOMPARE(text->toPlainText(), QString(""));
+
+    QGraphicsScene scene;
+    scene.addItem(text);
+    text->setPlainText("Hello world");
+    text->setFlag(QGraphicsItem::ItemIsMovable);
+
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+        event.setScenePos(QPointF(1, 1));
+        event.setButton(Qt::LeftButton);
+        event.setButtons(Qt::LeftButton);
+        QApplication::sendEvent(&scene, &event);
+        QGraphicsSceneMouseEvent event2(QEvent::GraphicsSceneMouseMove);
+        event2.setScenePos(QPointF(11, 11));
+        event2.setButton(Qt::LeftButton);
+        event2.setButtons(Qt::LeftButton);
+        QApplication::sendEvent(&scene, &event2);
+    }
+
+    QCOMPARE(text->pos(), QPointF(10, 10));
+
+    text->setTextInteractionFlags(Qt::NoTextInteraction);
+    QVERIFY(!(text->flags() & QGraphicsItem::ItemAcceptsInputMethod));
+    text->setTextInteractionFlags(Qt::TextEditorInteraction);
+    QCOMPARE(text->textInteractionFlags(), Qt::TextInteractionFlags(Qt::TextEditorInteraction));
+    QVERIFY(text->flags() & QGraphicsItem::ItemAcceptsInputMethod);
+
+    {
+        QGraphicsSceneMouseEvent event2(QEvent::GraphicsSceneMouseMove);
+        event2.setScenePos(QPointF(21, 21));
+        event2.setButton(Qt::LeftButton);
+        event2.setButtons(Qt::LeftButton);
+        QApplication::sendEvent(&scene, &event2);
+    }
+
+    QCOMPARE(text->pos(), QPointF(20, 20)); // clicked on edge, item moved
+}
+
+void tst_QGraphicsItem::defaultItemTest_QGraphicsEllipseItem()
+{
+    QGraphicsEllipseItem item;
+    QVERIFY(item.rect().isNull());
+    QVERIFY(item.boundingRect().isNull());
+    QVERIFY(item.shape().isEmpty());
+    QCOMPARE(item.spanAngle(), 360 * 16);
+    QCOMPARE(item.startAngle(), 0);
+
+    item.setRect(0, 0, 100, 100);
+    QCOMPARE(item.boundingRect(), QRectF(0, 0, 100, 100));
+
+    item.setSpanAngle(90 * 16);
+    qFuzzyCompare(item.boundingRect().left(), qreal(50.0));
+    qFuzzyCompare(item.boundingRect().top(), qreal(0.0));
+    qFuzzyCompare(item.boundingRect().width(), qreal(50.0));
+    qFuzzyCompare(item.boundingRect().height(), qreal(50.0));
+
+    item.setPen(QPen(Qt::black, 1));
+    QCOMPARE(item.boundingRect(), QRectF(49.5, -0.5, 51, 51));
+
+    item.setSpanAngle(180 * 16);
+    QCOMPARE(item.boundingRect(), QRectF(-0.5, -0.5, 101, 51));
+
+    item.setSpanAngle(360 * 16);
+    QCOMPARE(item.boundingRect(), QRectF(-0.5, -0.5, 101, 101));
+}
+
+class ItemChangeTester : public QGraphicsRectItem
+{
+public:
+    ItemChangeTester()
+    { setFlag(ItemSendsGeometryChanges); clear(); }
+    ItemChangeTester(QGraphicsItem *parent) : QGraphicsRectItem(parent)
+    { setFlag(ItemSendsGeometryChanges); clear(); }
+
+    void clear()
+    {
+        itemChangeReturnValue = QVariant();
+        itemSceneChangeTargetScene = 0;
+        changes.clear();
+        values.clear();
+        oldValues.clear();
+    }
+
+    QVariant itemChangeReturnValue;
+    QGraphicsScene *itemSceneChangeTargetScene;
+
+    QList<GraphicsItemChange> changes;
+    QList<QVariant> values;
+    QList<QVariant> oldValues;
+protected:
+    QVariant itemChange(GraphicsItemChange change, const QVariant &value)
+    {
+        changes << change;
+        values << value;
+        switch (change) {
+        case QGraphicsItem::ItemPositionChange:
+            oldValues << pos();
+            break;
+        case QGraphicsItem::ItemPositionHasChanged:
+            break;
+        case QGraphicsItem::ItemMatrixChange: {
+            QVariant variant;
+            qVariantSetValue<QMatrix>(variant, matrix());
+            oldValues << variant;
+        }
+            break;
+        case QGraphicsItem::ItemTransformChange: {
+            QVariant variant;
+            qVariantSetValue<QTransform>(variant, transform());
+            oldValues << variant;
+        }
+            break;
+        case QGraphicsItem::ItemTransformHasChanged:
+            break;
+        case QGraphicsItem::ItemVisibleChange:
+            oldValues << isVisible();
+            break;
+        case QGraphicsItem::ItemVisibleHasChanged:
+            break;
+        case QGraphicsItem::ItemEnabledChange:
+            oldValues << isEnabled();
+            break;
+        case QGraphicsItem::ItemEnabledHasChanged:
+            break;
+        case QGraphicsItem::ItemSelectedChange:
+            oldValues << isSelected();
+            break;
+        case QGraphicsItem::ItemSelectedHasChanged:
+            break;
+        case QGraphicsItem::ItemParentChange:
+            oldValues << qVariantFromValue<void *>(parentItem());
+            break;
+        case QGraphicsItem::ItemParentHasChanged:
+            break;
+        case QGraphicsItem::ItemChildAddedChange:
+            oldValues << children().size();
+            break;
+        case QGraphicsItem::ItemChildRemovedChange:
+            oldValues << children().size();
+            break;
+        case QGraphicsItem::ItemSceneChange:
+            oldValues << qVariantFromValue<QGraphicsScene *>(scene());
+            if (itemSceneChangeTargetScene
+                && qVariantValue<QGraphicsScene *>(value)
+                && itemSceneChangeTargetScene != qVariantValue<QGraphicsScene *>(value)) {
+                return qVariantFromValue<QGraphicsScene *>(itemSceneChangeTargetScene);
+            }
+            return value;
+        case QGraphicsItem::ItemSceneHasChanged:
+            break;
+        case QGraphicsItem::ItemCursorChange:
+#ifndef QT_NO_CURSOR
+            oldValues << cursor();
+#endif
+            break;
+        case QGraphicsItem::ItemCursorHasChanged:
+            break;
+        case QGraphicsItem::ItemToolTipChange:
+            oldValues << toolTip();
+            break;
+        case QGraphicsItem::ItemToolTipHasChanged:
+            break;
+        case QGraphicsItem::ItemFlagsChange:
+            oldValues << quint32(flags());
+            break;
+        case QGraphicsItem::ItemFlagsHaveChanged:
+            break;
+        case QGraphicsItem::ItemZValueChange:
+            oldValues << zValue();
+            break;
+        case QGraphicsItem::ItemZValueHasChanged:
+            break;
+        case QGraphicsItem::ItemOpacityChange:
+            oldValues << opacity();
+            break;
+        case QGraphicsItem::ItemOpacityHasChanged:
+            break;
+        case QGraphicsItem::ItemScenePositionHasChanged:
+            break;
+        case QGraphicsItem::ItemRotationChange:
+            oldValues << rotation();
+            break;
+        case QGraphicsItem::ItemRotationHasChanged:
+            break;
+        case QGraphicsItem::ItemScaleChange:
+            oldValues << scale();
+            break;
+        case QGraphicsItem::ItemScaleHasChanged:
+            break;
+        case QGraphicsItem::ItemTransformOriginPointChange:
+            oldValues << transformOriginPoint();
+            break;
+        case QGraphicsItem::ItemTransformOriginPointHasChanged:
+            break;
+        }
+        return itemChangeReturnValue.isValid() ? itemChangeReturnValue : value;
+    }
+};
+
+void tst_QGraphicsItem::itemChange()
+{
+    ItemChangeTester tester;
+    tester.itemSceneChangeTargetScene = 0;
+
+    ItemChangeTester testerHelper;
+    QVERIFY(tester.changes.isEmpty());
+    QVERIFY(tester.values.isEmpty());
+
+    int changeCount = 0;
+    {
+        // ItemEnabledChange
+        tester.itemChangeReturnValue = true;
+        tester.setEnabled(false);
+        ++changeCount;
+        ++changeCount; // HasChanged
+        QCOMPARE(tester.changes.size(), changeCount);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemEnabledChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemEnabledHasChanged);
+        QCOMPARE(tester.values.at(tester.values.size() - 2), QVariant(false));
+        QCOMPARE(tester.values.at(tester.values.size() - 1), QVariant(true));
+        QCOMPARE(tester.oldValues.last(), QVariant(true));
+        QCOMPARE(tester.isEnabled(), true);
+    }
+    {
+        // ItemMatrixChange / ItemTransformHasChanged
+        qVariantSetValue<QMatrix>(tester.itemChangeReturnValue, QMatrix().rotate(90));
+        tester.setMatrix(QMatrix().translate(50, 0), true);
+        ++changeCount; // notification sent too
+        QCOMPARE(tester.changes.size(), ++changeCount);
+        QCOMPARE(int(tester.changes.at(tester.changes.size() - 2)), int(QGraphicsItem::ItemMatrixChange));
+        QCOMPARE(int(tester.changes.last()), int(QGraphicsItem::ItemTransformHasChanged));
+        QCOMPARE(qVariantValue<QMatrix>(tester.values.at(tester.values.size() - 2)),
+                 QMatrix().translate(50, 0));
+        QCOMPARE(tester.values.last(), QVariant(QTransform(QMatrix().rotate(90))));
+        QVariant variant;
+        qVariantSetValue<QMatrix>(variant, QMatrix());
+        QCOMPARE(tester.oldValues.last(), variant);
+        QCOMPARE(tester.matrix(), QMatrix().rotate(90));
+    }
+    {
+        tester.resetTransform();
+        ++changeCount;
+        ++changeCount; // notification sent too
+
+        // ItemTransformChange / ItemTransformHasChanged
+        qVariantSetValue<QTransform>(tester.itemChangeReturnValue, QTransform().rotate(90));
+        tester.translate(50, 0);
+        ++changeCount; // notification sent too
+        ++changeCount;
+        QCOMPARE(tester.changes.size(), changeCount);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemTransformChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemTransformHasChanged);
+        QCOMPARE(qVariantValue<QTransform>(tester.values.at(tester.values.size() - 2)),
+                 QTransform().translate(50, 0));
+        QCOMPARE(qVariantValue<QTransform>(tester.values.at(tester.values.size() - 1)),
+                 QTransform().rotate(90));
+        QVariant variant;
+        qVariantSetValue<QTransform>(variant, QTransform());
+        QCOMPARE(tester.oldValues.last(), variant);
+        QCOMPARE(tester.transform(), QTransform().rotate(90));
+    }
+    {
+        // ItemPositionChange / ItemPositionHasChanged
+        tester.itemChangeReturnValue = QPointF(42, 0);
+        tester.setPos(0, 42);
+        ++changeCount; // notification sent too
+        ++changeCount;
+        QCOMPARE(tester.changes.size(), changeCount);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemPositionChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemPositionHasChanged);
+        QCOMPARE(tester.values.at(tester.changes.size() - 2), QVariant(QPointF(0, 42)));
+        QCOMPARE(tester.values.at(tester.changes.size() - 1), QVariant(QPointF(42, 0)));
+        QCOMPARE(tester.oldValues.last(), QVariant(QPointF()));
+        QCOMPARE(tester.pos(), QPointF(42, 0));
+    }
+    {
+        // ItemZValueChange / ItemZValueHasChanged
+        tester.itemChangeReturnValue = qreal(2.0);
+        tester.setZValue(1.0);
+        ++changeCount; // notification sent too
+        ++changeCount;
+        QCOMPARE(tester.changes.size(), changeCount);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemZValueChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemZValueHasChanged);
+        QCOMPARE(tester.values.at(tester.changes.size() - 2), QVariant(qreal(1.0)));
+        QCOMPARE(tester.values.at(tester.changes.size() - 1), QVariant(qreal(2.0)));
+        QCOMPARE(tester.oldValues.last(), QVariant(qreal(0.0)));
+        QCOMPARE(tester.zValue(), qreal(2.0));
+    }
+    {
+        // ItemRotationChange / ItemRotationHasChanged
+        tester.itemChangeReturnValue = qreal(15.0);
+        tester.setRotation(10.0);
+        ++changeCount; // notification sent too
+        ++changeCount;
+        QCOMPARE(tester.changes.size(), changeCount);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemRotationChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemRotationHasChanged);
+        QCOMPARE(tester.values.at(tester.changes.size() - 2), QVariant(qreal(10.0)));
+        QCOMPARE(tester.values.at(tester.changes.size() - 1), QVariant(qreal(15.0)));
+        QCOMPARE(tester.oldValues.last(), QVariant(qreal(0.0)));
+        QCOMPARE(tester.rotation(), qreal(15.0));
+    }
+    {
+        // ItemScaleChange / ItemScaleHasChanged
+        tester.itemChangeReturnValue = qreal(2.0);
+        tester.setScale(1.5);
+        ++changeCount; // notification sent too
+        ++changeCount;
+        QCOMPARE(tester.changes.size(), changeCount);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemScaleChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemScaleHasChanged);
+        QCOMPARE(tester.values.at(tester.changes.size() - 2), QVariant(qreal(1.5)));
+        QCOMPARE(tester.values.at(tester.changes.size() - 1), QVariant(qreal(2.0)));
+        QCOMPARE(tester.oldValues.last(), QVariant(qreal(1.0)));
+        QCOMPARE(tester.scale(), qreal(2.0));
+    }
+    {
+        // ItemTransformOriginPointChange / ItemTransformOriginPointHasChanged
+        tester.itemChangeReturnValue = QPointF(2.0, 2.0);
+        tester.setTransformOriginPoint(1.0, 1.0);
+        ++changeCount; // notification sent too
+        ++changeCount;
+        QCOMPARE(tester.changes.size(), changeCount);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemTransformOriginPointChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemTransformOriginPointHasChanged);
+        QCOMPARE(tester.values.at(tester.changes.size() - 2), QVariant(QPointF(1.0, 1.0)));
+        QCOMPARE(tester.values.at(tester.changes.size() - 1), QVariant(QPointF(2.0, 2.0)));
+        QCOMPARE(tester.oldValues.last(), QVariant(QPointF(0.0, 0.0)));
+        QCOMPARE(tester.transformOriginPoint(), QPointF(2.0, 2.0));
+    }
+    {
+        // ItemFlagsChange
+        tester.itemChangeReturnValue = QGraphicsItem::ItemIsSelectable;
+        tester.setFlag(QGraphicsItem::ItemIsSelectable, false);
+        QCOMPARE(tester.changes.size(), changeCount);  // No change
+        tester.setFlag(QGraphicsItem::ItemIsSelectable, true);
+        ++changeCount;
+        ++changeCount; // ItemFlagsHasChanged
+        QCOMPARE(tester.changes.size(), changeCount);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemFlagsChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemFlagsHaveChanged);
+        QVariant expectedFlags = qVariantFromValue<quint32>(QGraphicsItem::GraphicsItemFlags(QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemSendsGeometryChanges));
+        QCOMPARE(tester.values.at(tester.values.size() - 2), expectedFlags);
+        QCOMPARE(tester.values.at(tester.values.size() - 1), qVariantFromValue<quint32>((quint32)QGraphicsItem::ItemIsSelectable));
+    }
+    {
+        // ItemSelectedChange
+        tester.setSelected(false);
+        QCOMPARE(tester.changes.size(), changeCount); // No change :-)
+        tester.itemChangeReturnValue = true;
+        tester.setSelected(true);
+        ++changeCount;
+        ++changeCount; // ItemSelectedHasChanged
+        QCOMPARE(tester.changes.size(), changeCount);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemSelectedChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemSelectedHasChanged);
+        QCOMPARE(tester.values.at(tester.values.size() - 2), QVariant(true));
+        QCOMPARE(tester.values.at(tester.values.size() - 1), QVariant(true));
+        QCOMPARE(tester.oldValues.last(), QVariant(false));
+        QCOMPARE(tester.isSelected(), true);
+
+        tester.itemChangeReturnValue = false;
+        tester.setSelected(true);
+
+        // the value hasn't changed to the itemChange return value
+        // bacause itemChange is never called (true -> true is a noop).
+        QCOMPARE(tester.isSelected(), true);
+    }
+    {
+        // ItemVisibleChange
+        tester.itemChangeReturnValue = false;
+        QVERIFY(tester.isVisible());
+        tester.setVisible(false);
+        ++changeCount; // ItemVisibleChange
+        ++changeCount; // ItemSelectedChange
+        ++changeCount; // ItemSelectedHasChanged
+        ++changeCount; // ItemVisibleHasChanged
+        QCOMPARE(tester.changes.size(), changeCount);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 4), QGraphicsItem::ItemVisibleChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 3), QGraphicsItem::ItemSelectedChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemSelectedHasChanged);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemVisibleHasChanged);
+        QCOMPARE(tester.values.at(tester.values.size() - 4), QVariant(false));
+        QCOMPARE(tester.values.at(tester.values.size() - 3), QVariant(false));
+        QCOMPARE(tester.values.at(tester.values.size() - 2), QVariant(false));
+        QCOMPARE(tester.values.at(tester.values.size() - 1), QVariant(false));
+        QCOMPARE(tester.isVisible(), false);
+    }
+    {
+        // ItemParentChange
+        qVariantSetValue<QGraphicsItem *>(tester.itemChangeReturnValue, 0);
+        tester.setParentItem(&testerHelper);
+        QCOMPARE(tester.changes.size(), ++changeCount);
+        QCOMPARE(tester.changes.last(), QGraphicsItem::ItemParentChange);
+        QCOMPARE(qVariantValue<QGraphicsItem *>(tester.values.last()), (QGraphicsItem *)&testerHelper);
+        QCOMPARE(qVariantValue<QGraphicsItem *>(tester.oldValues.last()), (QGraphicsItem *)0);
+        QCOMPARE(tester.parentItem(), (QGraphicsItem *)0);
+    }
+    {
+        // ItemOpacityChange
+        tester.itemChangeReturnValue = 1.0;
+        tester.setOpacity(0.7);
+        QCOMPARE(tester.changes.size(), ++changeCount);
+        QCOMPARE(tester.changes.last(), QGraphicsItem::ItemOpacityChange);
+        QVERIFY(qFuzzyCompare(qreal(tester.values.last().toDouble()), qreal(0.7)));
+        QCOMPARE(tester.oldValues.last().toDouble(), double(1.0));
+        QCOMPARE(tester.opacity(), qreal(1.0));
+        tester.itemChangeReturnValue = 0.7;
+        tester.setOpacity(0.7);
+        ++changeCount; // ItemOpacityChange
+        ++changeCount; // ItemOpacityHasChanged
+        QCOMPARE(tester.changes.size(), changeCount);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemOpacityChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemOpacityHasChanged);
+        QCOMPARE(tester.opacity(), qreal(0.7));
+    }
+    {
+        // ItemChildAddedChange
+        tester.itemChangeReturnValue.clear();
+        testerHelper.setParentItem(&tester);
+        QCOMPARE(tester.changes.size(), ++changeCount);
+        QCOMPARE(tester.changes.last(), QGraphicsItem::ItemChildAddedChange);
+        QCOMPARE(qVariantValue<QGraphicsItem *>(tester.values.last()), (QGraphicsItem *)&testerHelper);
+    }
+    {
+        // ItemChildRemovedChange 1
+        testerHelper.setParentItem(0);
+        QCOMPARE(tester.changes.size(), ++changeCount);
+        QCOMPARE(tester.changes.last(), QGraphicsItem::ItemChildRemovedChange);
+        QCOMPARE(qVariantValue<QGraphicsItem *>(tester.values.last()), (QGraphicsItem *)&testerHelper);
+
+        // ItemChildRemovedChange 1
+        ItemChangeTester *test = new ItemChangeTester;
+        test->itemSceneChangeTargetScene = 0;
+        int count = 0;
+        QGraphicsScene *scene = new QGraphicsScene;
+        scene->addItem(test);
+        count = test->changes.size();
+        //We test here the fact that when a child is deleted the parent receive only one ItemChildRemovedChange
+        QGraphicsRectItem *child = new QGraphicsRectItem(test);
+        //We received ItemChildAddedChange
+        QCOMPARE(test->changes.size(), ++count);
+        QCOMPARE(test->changes.last(), QGraphicsItem::ItemChildAddedChange);
+        delete child;
+        child = 0;
+        QCOMPARE(test->changes.size(), ++count);
+        QCOMPARE(test->changes.last(), QGraphicsItem::ItemChildRemovedChange);
+
+        ItemChangeTester *childTester = new ItemChangeTester(test);
+        //Changes contains all sceneHasChanged and so on, we don't want to test that
+        int childCount = childTester->changes.size();
+        //We received ItemChildAddedChange
+        QCOMPARE(test->changes.size(), ++count);
+        child = new QGraphicsRectItem(childTester);
+        //We received ItemChildAddedChange
+        QCOMPARE(childTester->changes.size(), ++childCount);
+        QCOMPARE(childTester->changes.last(), QGraphicsItem::ItemChildAddedChange);
+        //Delete the child of the top level with all its children
+        delete childTester;
+        //Only one removal
+        QCOMPARE(test->changes.size(), ++count);
+        QCOMPARE(test->changes.last(), QGraphicsItem::ItemChildRemovedChange);
+        delete scene;
+    }
+    {
+        // ItemChildRemovedChange 2
+        ItemChangeTester parent;
+        ItemChangeTester *child = new ItemChangeTester;
+        child->setParentItem(&parent);
+        QCOMPARE(parent.changes.last(), QGraphicsItem::ItemChildAddedChange);
+        QCOMPARE(qVariantValue<QGraphicsItem *>(parent.values.last()), (QGraphicsItem *)child);
+        delete child;
+        QCOMPARE(parent.changes.last(), QGraphicsItem::ItemChildRemovedChange);
+        QCOMPARE(qVariantValue<QGraphicsItem *>(parent.values.last()), (QGraphicsItem *)child);
+    }
+    {
+        // !!! Note: If this test crashes because of double-deletion, there's
+        // a bug somewhere in QGraphicsScene or QGraphicsItem.
+
+        // ItemSceneChange
+        QGraphicsScene scene;
+        QGraphicsScene scene2;
+        scene.addItem(&tester);
+        ++changeCount; // ItemSceneChange (scene)
+        ++changeCount; // ItemSceneHasChanged (scene)
+        QCOMPARE(tester.changes.size(), changeCount);
+
+        QCOMPARE(tester.scene(), &scene);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemSceneChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemSceneHasChanged);
+        // Item's old value was 0
+        // Item's current value is scene
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)0);
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.last()), (QGraphicsScene *)&scene);
+        scene2.addItem(&tester);
+        ++changeCount; // ItemSceneChange (0) was: (scene)
+        ++changeCount; // ItemSceneHasChanged (0)
+        ++changeCount; // ItemSceneChange (scene2) was: (0)
+        ++changeCount; // ItemSceneHasChanged (scene2)
+        QCOMPARE(tester.changes.size(), changeCount);
+
+        QCOMPARE(tester.scene(), &scene2);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 4), QGraphicsItem::ItemSceneChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 3), QGraphicsItem::ItemSceneHasChanged);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemSceneChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemSceneHasChanged);
+        // Item's last old value was scene
+        // Item's last current value is 0
+
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.at(tester.oldValues.size() - 2)), (QGraphicsScene *)&scene);
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.at(tester.oldValues.size() - 1)), (QGraphicsScene *)0);
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 4)), (QGraphicsScene *)0);
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 3)), (QGraphicsScene *)0);
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 2)), (QGraphicsScene *)&scene2);
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 1)), (QGraphicsScene *)&scene2);
+        // Item's last old value was 0
+        // Item's last current value is scene2
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)0);
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.last()), (QGraphicsScene *)&scene2);
+
+        scene2.removeItem(&tester);
+        ++changeCount; // ItemSceneChange (0) was: (scene2)
+        ++changeCount; // ItemSceneHasChanged (0)
+        QCOMPARE(tester.changes.size(), changeCount);
+
+        QCOMPARE(tester.scene(), (QGraphicsScene *)0);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemSceneChange);
+        QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemSceneHasChanged);
+        // Item's last old value was scene2
+        // Item's last current value is 0
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.oldValues.last()), (QGraphicsScene *)&scene2);
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 2)), (QGraphicsScene *)0);
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 1)), (QGraphicsScene *)0);
+
+        tester.itemSceneChangeTargetScene = &scene;
+        scene2.addItem(&tester);
+        ++changeCount; // ItemSceneChange (scene2) was: (0)
+        ++changeCount; // ItemSceneChange (scene) was: (0)
+        ++changeCount; // ItemSceneHasChanged (scene)
+        QCOMPARE(tester.values.size(), changeCount);
+
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 3)), (QGraphicsScene *)&scene2);
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 2)), (QGraphicsScene *)&scene);
+        QCOMPARE(qVariantValue<QGraphicsScene *>(tester.values.at(tester.values.size() - 1)), (QGraphicsScene *)&scene);
+
+        QCOMPARE(tester.scene(), &scene);
+        tester.itemSceneChangeTargetScene = 0;
+        tester.itemChangeReturnValue = QVariant();
+        scene.removeItem(&tester);
+        ++changeCount; // ItemSceneChange
+        ++changeCount; // ItemSceneHasChanged
+        QCOMPARE(tester.scene(), (QGraphicsScene *)0);
+    }
+    {
+        // ItemToolTipChange/ItemToolTipHasChanged
+        const QString toolTip(QLatin1String("I'm soo cool"));
+        const QString overridenToolTip(QLatin1String("No, you are not soo cool"));
+        tester.itemChangeReturnValue = overridenToolTip;
+        tester.setToolTip(toolTip);
+        ++changeCount; // ItemToolTipChange
+        ++changeCount; // ItemToolTipHasChanged
+        QCOMPARE(tester.changes.size(), changeCount);
+        QCOMPARE(tester.changes.at(changeCount - 2), QGraphicsItem::ItemToolTipChange);
+        QCOMPARE(tester.values.at(changeCount - 2).toString(), toolTip);
+        QCOMPARE(tester.changes.at(changeCount - 1), QGraphicsItem::ItemToolTipHasChanged);
+        QCOMPARE(tester.values.at(changeCount - 1).toString(), overridenToolTip);
+        QCOMPARE(tester.toolTip(), overridenToolTip);
+        tester.itemChangeReturnValue = QVariant();
+    }
+}
+
+class EventFilterTesterItem : public QGraphicsLineItem
+{
+public:
+    QList<QEvent::Type> filteredEvents;
+    QList<QGraphicsItem *> filteredEventReceivers;
+    bool handlesSceneEvents;
+
+    QList<QEvent::Type> receivedEvents;
+
+    EventFilterTesterItem() : handlesSceneEvents(false) {}
+
+protected:
+    bool sceneEventFilter(QGraphicsItem *watched, QEvent *event)
+    {
+        filteredEvents << event->type();
+        filteredEventReceivers << watched;
+        return handlesSceneEvents;
+    }
+
+    bool sceneEvent(QEvent *event)
+    {
+        return QGraphicsLineItem::sceneEvent(event);
+    }
+};
+
+void tst_QGraphicsItem::sceneEventFilter()
+{
+    QGraphicsScene scene;
+
+    QGraphicsView view(&scene);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+    QTest::qWait(25);
+
+    QGraphicsTextItem *text1 = scene.addText(QLatin1String("Text1"));
+    QGraphicsTextItem *text2 = scene.addText(QLatin1String("Text2"));
+    QGraphicsTextItem *text3 = scene.addText(QLatin1String("Text3"));
+    text1->setFlag(QGraphicsItem::ItemIsFocusable);
+    text2->setFlag(QGraphicsItem::ItemIsFocusable);
+    text3->setFlag(QGraphicsItem::ItemIsFocusable);
+
+    EventFilterTesterItem *tester = new EventFilterTesterItem;
+    scene.addItem(tester);
+
+    QTRY_VERIFY(!text1->hasFocus());
+    text1->installSceneEventFilter(tester);
+    text1->setFocus();
+    QTRY_VERIFY(text1->hasFocus());
+
+    QCOMPARE(tester->filteredEvents.size(), 1);
+    QCOMPARE(tester->filteredEvents.at(0), QEvent::FocusIn);
+    QCOMPARE(tester->filteredEventReceivers.at(0), static_cast<QGraphicsItem *>(text1));
+
+    text2->installSceneEventFilter(tester);
+    text3->installSceneEventFilter(tester);
+
+    text2->setFocus();
+    text3->setFocus();
+
+    QCOMPARE(tester->filteredEvents.size(), 5);
+    QCOMPARE(tester->filteredEvents.at(1), QEvent::FocusOut);
+    QCOMPARE(tester->filteredEventReceivers.at(1), static_cast<QGraphicsItem *>(text1));
+    QCOMPARE(tester->filteredEvents.at(2), QEvent::FocusIn);
+    QCOMPARE(tester->filteredEventReceivers.at(2), static_cast<QGraphicsItem *>(text2));
+    QCOMPARE(tester->filteredEvents.at(3), QEvent::FocusOut);
+    QCOMPARE(tester->filteredEventReceivers.at(3), static_cast<QGraphicsItem *>(text2));
+    QCOMPARE(tester->filteredEvents.at(4), QEvent::FocusIn);
+    QCOMPARE(tester->filteredEventReceivers.at(4), static_cast<QGraphicsItem *>(text3));
+
+    text1->removeSceneEventFilter(tester);
+    text1->setFocus();
+
+    QCOMPARE(tester->filteredEvents.size(), 6);
+    QCOMPARE(tester->filteredEvents.at(5), QEvent::FocusOut);
+    QCOMPARE(tester->filteredEventReceivers.at(5), static_cast<QGraphicsItem *>(text3));
+
+    tester->handlesSceneEvents = true;
+    text2->setFocus();
+
+    QCOMPARE(tester->filteredEvents.size(), 7);
+    QCOMPARE(tester->filteredEvents.at(6), QEvent::FocusIn);
+    QCOMPARE(tester->filteredEventReceivers.at(6), static_cast<QGraphicsItem *>(text2));
+
+    QVERIFY(text2->hasFocus());
+
+    //Let check if the items are correctly removed from the sceneEventFilters array
+    //to avoid stale pointers.
+    QGraphicsView gv;
+    QGraphicsScene *anotherScene = new QGraphicsScene;
+    QGraphicsTextItem *ti = anotherScene->addText("This is a test #1");
+    ti->moveBy(50, 50);
+    QGraphicsTextItem *ti2 = anotherScene->addText("This is a test #2");
+    QGraphicsTextItem *ti3 = anotherScene->addText("This is a test #3");
+    gv.setScene(anotherScene);
+    gv.show();
+    QTest::qWaitForWindowShown(&gv);
+    QTest::qWait(25);
+    ti->installSceneEventFilter(ti2);
+    ti3->installSceneEventFilter(ti);
+    delete ti2;
+    //we souldn't crash
+    QTest::mouseMove(gv.viewport(), gv.mapFromScene(ti->scenePos()));
+    QTest::qWait(30);
+    delete ti;
+}
+
+class GeometryChanger : public QGraphicsItem
+{
+public:
+    void changeGeometry()
+    { prepareGeometryChange(); }
+};
+
+void tst_QGraphicsItem::prepareGeometryChange()
+{
+    {
+        QGraphicsScene scene;
+        QGraphicsItem *item = scene.addRect(QRectF(0, 0, 100, 100));
+        QVERIFY(scene.items(QRectF(0, 0, 100, 100)).contains(item));
+        ((GeometryChanger *)item)->changeGeometry();
+        QVERIFY(scene.items(QRectF(0, 0, 100, 100)).contains(item));
+    }
+}
+
+
+class PaintTester : public QGraphicsRectItem
+{
+public:
+    PaintTester() : widget(NULL), painted(0) { setRect(QRectF(10, 10, 20, 20));}
+
+    void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *w)
+    {
+        widget = w;
+        painted++;
+    }
+
+    QWidget*  widget;
+    int painted;
+};
+
+void tst_QGraphicsItem::paint()
+{
+    QGraphicsScene scene;
+
+    PaintTester paintTester;
+    scene.addItem(&paintTester);
+
+    QGraphicsView view(&scene);
+
+    if(PlatformQuirks::isAutoMaximizing())
+        view.showFullScreen();
+    else
+        view.show();
+    QTest::qWaitForWindowShown(&view);
+    QApplication::processEvents();
+#ifdef Q_OS_WIN32
+    //we try to switch the desktop: if it fails, we skip the test
+    if (::SwitchDesktop( ::GetThreadDesktop( ::GetCurrentThreadId() ) ) == 0) {
+        QSKIP("The Graphics View doesn't get the paint events", SkipSingle);
+    }
+#endif
+
+    QTRY_COMPARE(paintTester.widget, view.viewport());
+
+    view.hide();
+
+    QGraphicsScene scene2;
+    QGraphicsView view2(&scene2);
+    view2.show();
+    QTest::qWaitForWindowShown(&view2);
+    QTest::qWait(25);
+
+    PaintTester tester2;
+    scene2.addItem(&tester2);
+    qApp->processEvents();
+
+    //First show one paint
+    QTRY_COMPARE(tester2.painted, 1);
+
+    //nominal case, update call paint
+    tester2.update();
+    qApp->processEvents();
+    QTRY_VERIFY(tester2.painted == 2);
+
+    //we remove the item from the scene, number of updates is still the same
+    tester2.update();
+    scene2.removeItem(&tester2);
+    qApp->processEvents();
+    QTRY_VERIFY(tester2.painted == 2);
+
+    //We re-add the item, the number of paint should increase
+    scene2.addItem(&tester2);
+    tester2.update();
+    qApp->processEvents();
+    QTRY_VERIFY(tester2.painted == 3);
+}
+
+class HarakiriItem : public QGraphicsRectItem
+{
+public:
+    HarakiriItem(int harakiriPoint)
+        : QGraphicsRectItem(QRectF(0, 0, 100, 100)), harakiri(harakiriPoint)
+    { dead = 0; }
+
+    static int dead;
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        QGraphicsRectItem::paint(painter, option, widget);
+        if (harakiri == 0) {
+            // delete unsupported since 4.5
+            /*
+            dead = 1;
+            delete this;
+            */
+        }
+    }
+
+    void advance(int n)
+    {
+        if (harakiri == 1 && n == 0) {
+            // delete unsupported
+            /*
+            dead = 1;
+            delete this;
+            */
+        }
+        if (harakiri == 2 && n == 1) {
+            dead = 1;
+            delete this;
+        }
+    }
+
+protected:
+    void contextMenuEvent(QGraphicsSceneContextMenuEvent *)
+    {
+        if (harakiri == 3) {
+            dead = 1;
+            delete this;
+        }
+    }
+
+    void dragEnterEvent(QGraphicsSceneDragDropEvent *event)
+    {
+        // ??
+        QGraphicsRectItem::dragEnterEvent(event);
+    }
+
+    void dragLeaveEvent(QGraphicsSceneDragDropEvent *event)
+    {
+        // ??
+        QGraphicsRectItem::dragLeaveEvent(event);
+    }
+
+    void dragMoveEvent(QGraphicsSceneDragDropEvent *event)
+    {
+        // ??
+        QGraphicsRectItem::dragMoveEvent(event);
+    }
+
+    void dropEvent(QGraphicsSceneDragDropEvent *event)
+    {
+        // ??
+        QGraphicsRectItem::dropEvent(event);
+    }
+
+    void focusInEvent(QFocusEvent *)
+    {
+        if (harakiri == 4) {
+            dead = 1;
+            delete this;
+        }
+    }
+
+    void focusOutEvent(QFocusEvent *)
+    {
+        if (harakiri == 5) {
+            dead = 1;
+            delete this;
+        }
+    }
+
+    void hoverEnterEvent(QGraphicsSceneHoverEvent *)
+    {
+        if (harakiri == 6) {
+            dead = 1;
+            delete this;
+        }
+    }
+
+    void hoverLeaveEvent(QGraphicsSceneHoverEvent *)
+    {
+        if (harakiri == 7) {
+            dead = 1;
+            delete this;
+        }
+    }
+
+    void hoverMoveEvent(QGraphicsSceneHoverEvent *)
+    {
+        if (harakiri == 8) {
+            dead = 1;
+            delete this;
+        }
+    }
+
+    void inputMethodEvent(QInputMethodEvent *event)
+    {
+        // ??
+        QGraphicsRectItem::inputMethodEvent(event);
+    }
+
+    QVariant inputMethodQuery(Qt::InputMethodQuery query) const
+    {
+        // ??
+        return QGraphicsRectItem::inputMethodQuery(query);
+    }
+
+    QVariant itemChange(GraphicsItemChange change, const QVariant &value)
+    {
+        // deletion not supported
+        return QGraphicsRectItem::itemChange(change, value);
+    }
+
+    void keyPressEvent(QKeyEvent *)
+    {
+        if (harakiri == 9) {
+            dead = 1;
+            delete this;
+        }
+    }
+
+    void keyReleaseEvent(QKeyEvent *)
+    {
+        if (harakiri == 10) {
+            dead = 1;
+            delete this;
+        }
+    }
+
+    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *)
+    {
+        if (harakiri == 11) {
+            dead = 1;
+            delete this;
+        }
+    }
+
+    void mouseMoveEvent(QGraphicsSceneMouseEvent *)
+    {
+        if (harakiri == 12) {
+            dead = 1;
+            delete this;
+        }
+    }
+
+    void mousePressEvent(QGraphicsSceneMouseEvent *)
+    {
+        if (harakiri == 13) {
+            dead = 1;
+            delete this;
+        }
+    }
+
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent *)
+    {
+        if (harakiri == 14) {
+            dead = 1;
+            delete this;
+        }
+    }
+
+    bool sceneEvent(QEvent *event)
+    {
+        // deletion not supported
+        return QGraphicsRectItem::sceneEvent(event);
+    }
+
+    bool sceneEventFilter(QGraphicsItem *watched, QEvent *event)
+    {
+        // deletion not supported
+        return QGraphicsRectItem::sceneEventFilter(watched, event);
+    }
+
+    void wheelEvent(QGraphicsSceneWheelEvent *)
+    {
+        if (harakiri == 16) {
+            dead = 1;
+            delete this;
+        }
+    }
+
+private:
+    int harakiri;
+};
+
+int HarakiriItem::dead;
+
+void tst_QGraphicsItem::deleteItemInEventHandlers()
+{
+    for (int i = 0; i < 17; ++i) {
+        QGraphicsScene scene;
+        HarakiriItem *item = new HarakiriItem(i);
+        item->setAcceptsHoverEvents(true);
+        item->setFlag(QGraphicsItem::ItemIsFocusable);
+
+        scene.addItem(item);
+
+        item->installSceneEventFilter(item); // <- ehey!
+
+        QGraphicsView view(&scene);
+        view.show();
+
+        qApp->processEvents();
+        qApp->processEvents();
+
+        if (!item->dead)
+            scene.advance();
+
+        if (!item->dead) {
+            QContextMenuEvent event(QContextMenuEvent::Other,
+                                    view.mapFromScene(item->scenePos()));
+            QCoreApplication::sendEvent(view.viewport(), &event);
+        }
+        if (!item->dead)
+            QTest::mouseMove(view.viewport(), view.mapFromScene(item->scenePos()));
+        if (!item->dead)
+            QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(item->scenePos()));
+        if (!item->dead)
+            QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(item->scenePos()));
+        if (!item->dead)
+            QTest::mouseClick(view.viewport(), Qt::RightButton, 0, view.mapFromScene(item->scenePos()));
+        if (!item->dead)
+            QTest::mouseMove(view.viewport(), view.mapFromScene(item->scenePos() + QPointF(20, -20)));
+        if (!item->dead)
+            item->setFocus();
+        if (!item->dead)
+            item->clearFocus();
+        if (!item->dead)
+            item->setFocus();
+        if (!item->dead)
+            QTest::keyPress(view.viewport(), Qt::Key_A);
+        if (!item->dead)
+            QTest::keyRelease(view.viewport(), Qt::Key_A);
+        if (!item->dead)
+            QTest::keyPress(view.viewport(), Qt::Key_A);
+        if (!item->dead)
+            QTest::keyRelease(view.viewport(), Qt::Key_A);
+    }
+}
+
+class ItemPaintsOutsideShape : public QGraphicsItem
+{
+public:
+    QRectF boundingRect() const
+    {
+        return QRectF(0, 0, 100, 100);
+    }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+    {
+        painter->fillRect(-50, -50, 200, 200, Qt::red);
+        painter->fillRect(0, 0, 100, 100, Qt::blue);
+    }
+};
+
+void tst_QGraphicsItem::itemClipsToShape()
+{
+    QGraphicsItem *clippedItem = new ItemPaintsOutsideShape;
+    clippedItem->setFlag(QGraphicsItem::ItemClipsToShape);
+
+    QGraphicsItem *unclippedItem = new ItemPaintsOutsideShape;
+    unclippedItem->setPos(200, 0);
+
+    QGraphicsScene scene(-50, -50, 400, 200);
+    scene.addItem(clippedItem);
+    scene.addItem(unclippedItem);
+
+    QImage image(400, 200, QImage::Format_ARGB32_Premultiplied);
+    image.fill(0);
+    QPainter painter(&image);
+    painter.setRenderHint(QPainter::Antialiasing);
+    scene.render(&painter);
+    painter.end();
+
+    QCOMPARE(image.pixel(45, 100), QRgb(0));
+    QCOMPARE(image.pixel(100, 45), QRgb(0));
+    QCOMPARE(image.pixel(155, 100), QRgb(0));
+    QCOMPARE(image.pixel(45, 155), QRgb(0));
+    QCOMPARE(image.pixel(55, 100), QColor(Qt::blue).rgba());
+    QCOMPARE(image.pixel(100, 55), QColor(Qt::blue).rgba());
+    QCOMPARE(image.pixel(145, 100), QColor(Qt::blue).rgba());
+    QCOMPARE(image.pixel(55, 145), QColor(Qt::blue).rgba());
+    QCOMPARE(image.pixel(245, 100), QColor(Qt::red).rgba());
+    QCOMPARE(image.pixel(300, 45), QColor(Qt::red).rgba());
+    QCOMPARE(image.pixel(355, 100), QColor(Qt::red).rgba());
+    QCOMPARE(image.pixel(245, 155), QColor(Qt::red).rgba());
+    QCOMPARE(image.pixel(255, 100), QColor(Qt::blue).rgba());
+    QCOMPARE(image.pixel(300, 55), QColor(Qt::blue).rgba());
+    QCOMPARE(image.pixel(345, 100), QColor(Qt::blue).rgba());
+    QCOMPARE(image.pixel(255, 145), QColor(Qt::blue).rgba());
+}
+
+void tst_QGraphicsItem::itemClipsChildrenToShape()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *rect = scene.addRect(0, 0, 50, 50, QPen(Qt::NoPen), QBrush(Qt::yellow));
+
+    QGraphicsItem *ellipse = scene.addEllipse(0, 0, 100, 100, QPen(Qt::NoPen), QBrush(Qt::green));
+    ellipse->setParentItem(rect);
+
+    QGraphicsItem *clippedEllipse = scene.addEllipse(0, 0, 50, 50, QPen(Qt::NoPen), QBrush(Qt::blue));
+    clippedEllipse->setParentItem(ellipse);
+
+    QGraphicsItem *clippedEllipse2 = scene.addEllipse(0, 0, 25, 25, QPen(Qt::NoPen), QBrush(Qt::red));
+    clippedEllipse2->setParentItem(clippedEllipse);
+
+    QGraphicsItem *clippedEllipse3 = scene.addEllipse(50, 50, 25, 25, QPen(Qt::NoPen), QBrush(Qt::red));
+    clippedEllipse3->setParentItem(clippedEllipse);
+
+    QVERIFY(!(ellipse->flags() & QGraphicsItem::ItemClipsChildrenToShape));
+    ellipse->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    QVERIFY((ellipse->flags() & QGraphicsItem::ItemClipsChildrenToShape));
+
+    QImage image(100, 100, QImage::Format_ARGB32_Premultiplied);
+    image.fill(0);
+    QPainter painter(&image);
+    painter.setRenderHint(QPainter::Antialiasing);
+    scene.render(&painter);
+    painter.end();
+
+    QCOMPARE(image.pixel(16, 16), QColor(255, 0, 0).rgba());
+    QCOMPARE(image.pixel(32, 32), QColor(0, 0, 255).rgba());
+    QCOMPARE(image.pixel(50, 50), QColor(0, 255, 0).rgba());
+    QCOMPARE(image.pixel(12, 12), QColor(255, 255, 0).rgba());
+    QCOMPARE(image.pixel(60, 60), QColor(255, 0, 0).rgba());
+}
+
+void tst_QGraphicsItem::itemClipsChildrenToShape2()
+{
+    QGraphicsRectItem *parent = new QGraphicsRectItem(QRectF(0, 0, 10, 10));
+    QGraphicsEllipseItem *child1 = new QGraphicsEllipseItem(QRectF(50, 50, 100, 100));
+    QGraphicsRectItem *child2 = new QGraphicsRectItem(QRectF(15, 15, 80, 80));
+
+    child1->setParentItem(parent);
+    child1->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    child2->setParentItem(child1);
+
+    parent->setBrush(Qt::blue);
+    child1->setBrush(Qt::green);
+    child2->setBrush(Qt::red);
+
+    QGraphicsScene scene;
+    scene.addItem(parent);
+
+    QCOMPARE(scene.itemAt(5, 5), (QGraphicsItem *)parent);
+    QCOMPARE(scene.itemAt(15, 5), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(5, 15), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(60, 60), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(140, 60), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(60, 140), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(140, 140), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(75, 75), (QGraphicsItem *)child2);
+    QCOMPARE(scene.itemAt(75, 100), (QGraphicsItem *)child1);
+    QCOMPARE(scene.itemAt(100, 75), (QGraphicsItem *)child1);
+
+#if 1
+    QImage image(100, 100, QImage::Format_ARGB32_Premultiplied);
+    image.fill(0);
+    QPainter painter(&image);
+    scene.render(&painter);
+    painter.end();
+
+    QCOMPARE(image.pixel(5, 5), QColor(0, 0, 255).rgba());
+    QCOMPARE(image.pixel(5, 10), QRgb(0));
+    QCOMPARE(image.pixel(10, 5), QRgb(0));
+    QCOMPARE(image.pixel(40, 40), QRgb(0));
+    QCOMPARE(image.pixel(90, 40), QRgb(0));
+    QCOMPARE(image.pixel(40, 90), QRgb(0));
+    QCOMPARE(image.pixel(95, 95), QRgb(0));
+    QCOMPARE(image.pixel(50, 70), QColor(0, 255, 0).rgba());
+    QCOMPARE(image.pixel(70, 50), QColor(0, 255, 0).rgba());
+    QCOMPARE(image.pixel(50, 60), QColor(255, 0, 0).rgba());
+    QCOMPARE(image.pixel(60, 50), QColor(255, 0, 0).rgba());
+#else
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWait(5000);
+#endif
+}
+
+void tst_QGraphicsItem::itemClipsChildrenToShape3()
+{
+    // Construct a scene with nested children, each 50 pixels offset from the elder.
+    // Set a top-level clipping flag
+    QGraphicsScene scene;
+    QGraphicsRectItem *parent = scene.addRect( 0, 0, 150, 150 );
+    QGraphicsRectItem *child = scene.addRect( 0, 0, 150, 150 );
+    QGraphicsRectItem *grandchild = scene.addRect( 0, 0, 150, 150 );
+    child->setParentItem(parent);
+    grandchild->setParentItem(child);
+    child->setPos( 50, 50 );
+    grandchild->setPos( 50, 50 );
+    parent->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+
+    QCOMPARE(scene.itemAt(25,25), (QGraphicsItem *)parent);
+    QCOMPARE(scene.itemAt(75,75), (QGraphicsItem *)child);
+    QCOMPARE(scene.itemAt(125,125), (QGraphicsItem *)grandchild);
+    QCOMPARE(scene.itemAt(175,175), (QGraphicsItem *)0);
+
+    // Move child to fully overlap the parent.  The grandchild should
+    // now occupy two-thirds of the scene
+    child->prepareGeometryChange();
+    child->setPos( 0, 0 );
+
+    QCOMPARE(scene.itemAt(25,25), (QGraphicsItem *)child);
+    QCOMPARE(scene.itemAt(75,75), (QGraphicsItem *)grandchild);
+    QCOMPARE(scene.itemAt(125,125), (QGraphicsItem *)grandchild);
+    QCOMPARE(scene.itemAt(175,175), (QGraphicsItem *)0);
+}
+
+class MyProxyWidget : public QGraphicsProxyWidget
+{
+public:
+    MyProxyWidget(QGraphicsItem *parent) : QGraphicsProxyWidget(parent)
+    {
+        painted = false;
+    }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        QGraphicsProxyWidget::paint(painter, option, widget);
+        painted = true;
+    }
+    bool painted;
+};
+
+void tst_QGraphicsItem::itemClipsChildrenToShape4()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    QGraphicsWidget * outerWidget = new QGraphicsWidget();
+    outerWidget->setFlag(QGraphicsItem::ItemClipsChildrenToShape, true);
+    MyProxyWidget * innerWidget = new MyProxyWidget(outerWidget);
+    QLabel * label = new QLabel();
+    label->setText("Welcome back my friends to the show that never ends...");
+    innerWidget->setWidget(label);
+    view.resize(300, 300);
+    scene.addItem(outerWidget);
+    outerWidget->resize( 200, 100 );
+    scene.addEllipse( 100, 100, 100, 50 );   // <-- this is important to trigger the right codepath*
+    //now the label is shown
+    outerWidget->setFlag(QGraphicsItem::ItemClipsChildrenToShape, false );
+    QApplication::setActiveWindow(&view);
+    view.show();
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget *)&view);
+    QTRY_COMPARE(innerWidget->painted, true);
+}
+
+//#define DEBUG_ITEM_CLIPS_CHILDREN_TO_SHAPE_5
+static inline void renderSceneToImage(QGraphicsScene *scene, QImage *image, const QString &filename)
+{
+    image->fill(0);
+    QPainter painter(image);
+    scene->render(&painter);
+    painter.end();
+#ifdef DEBUG_ITEM_CLIPS_CHILDREN_TO_SHAPE_5
+    image->save(filename);
+#else
+    Q_UNUSED(filename);
+#endif
+}
+
+void tst_QGraphicsItem::itemClipsChildrenToShape5()
+{
+    class ParentItem : public QGraphicsRectItem
+    {
+    public:
+        ParentItem(qreal x, qreal y, qreal width, qreal height)
+            : QGraphicsRectItem(x, y, width, height) {}
+
+        QPainterPath shape() const
+        {
+            QPainterPath path;
+            path.addRect(50, 50, 200, 200);
+            return path;
+        }
+    };
+
+    ParentItem *parent = new ParentItem(0, 0, 300, 300);
+    parent->setBrush(Qt::blue);
+    parent->setOpacity(0.5);
+
+    const QRegion parentRegion(0, 0, 300, 300);
+    const QRegion clippedParentRegion = parentRegion & QRect(50, 50, 200, 200);
+    QRegion childRegion;
+    QRegion grandChildRegion;
+
+    QGraphicsRectItem *topLeftChild = new QGraphicsRectItem(0, 0, 100, 100);
+    topLeftChild->setBrush(Qt::red);
+    topLeftChild->setParentItem(parent);
+    childRegion += QRect(0, 0, 100, 100);
+
+    QGraphicsRectItem *topRightChild = new QGraphicsRectItem(0, 0, 100, 100);
+    topRightChild->setBrush(Qt::red);
+    topRightChild->setParentItem(parent);
+    topRightChild->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    topRightChild->setPos(200, 0);
+    childRegion += QRect(200, 0, 100, 100);
+
+    QGraphicsRectItem *topRightGrandChild = new QGraphicsRectItem(0, 0, 100, 100);
+    topRightGrandChild->setBrush(Qt::green);
+    topRightGrandChild->setParentItem(topRightChild);
+    topRightGrandChild->setPos(-40, 40);
+    grandChildRegion += QRect(200 - 40, 0 + 40, 100, 100) & QRect(200, 0, 100, 100);
+
+    QGraphicsRectItem *bottomLeftChild = new QGraphicsRectItem(0, 0, 100, 100);
+    bottomLeftChild->setBrush(Qt::red);
+    bottomLeftChild->setParentItem(parent);
+    bottomLeftChild->setFlag(QGraphicsItem::ItemClipsToShape);
+    bottomLeftChild->setPos(0, 200);
+    childRegion += QRect(0, 200, 100, 100);
+
+    QGraphicsRectItem *bottomLeftGrandChild = new QGraphicsRectItem(0, 0, 160, 160);
+    bottomLeftGrandChild->setBrush(Qt::green);
+    bottomLeftGrandChild->setParentItem(bottomLeftChild);
+    bottomLeftGrandChild->setFlag(QGraphicsItem::ItemClipsToShape);
+    bottomLeftGrandChild->setPos(0, -60);
+    grandChildRegion += QRect(0, 200 - 60, 160, 160);
+
+    QGraphicsRectItem *bottomRightChild = new QGraphicsRectItem(0, 0, 100, 100);
+    bottomRightChild->setBrush(Qt::red);
+    bottomRightChild->setParentItem(parent);
+    bottomRightChild->setPos(200, 200);
+    childRegion += QRect(200, 200, 100, 100);
+
+    QPoint controlPoints[17] = {
+        QPoint(5, 5)  , QPoint(95, 5)  , QPoint(205, 5)  , QPoint(295, 5)  ,
+        QPoint(5, 95) , QPoint(95, 95) , QPoint(205, 95) , QPoint(295, 95) ,
+                             QPoint(150, 150),
+        QPoint(5, 205), QPoint(95, 205), QPoint(205, 205), QPoint(295, 205),
+        QPoint(5, 295), QPoint(95, 295), QPoint(205, 295), QPoint(295, 295),
+    };
+
+    const QRegion clippedChildRegion = childRegion & QRect(50, 50, 200, 200);
+    const QRegion clippedGrandChildRegion = grandChildRegion & QRect(50, 50, 200, 200);
+
+    QGraphicsScene scene;
+    scene.addItem(parent);
+    QImage sceneImage(300, 300, QImage::Format_ARGB32);
+
+#define VERIFY_CONTROL_POINTS(pRegion, cRegion, gRegion) \
+    for (int i = 0; i < 17; ++i) { \
+        QPoint controlPoint = controlPoints[i]; \
+        QRgb pixel = sceneImage.pixel(controlPoint.x(), controlPoint.y()); \
+        if (pRegion.contains(controlPoint)) \
+            QVERIFY(qBlue(pixel) != 0); \
+        else \
+            QVERIFY(qBlue(pixel) == 0); \
+        if (cRegion.contains(controlPoint)) \
+            QVERIFY(qRed(pixel) != 0); \
+        else \
+            QVERIFY(qRed(pixel) == 0); \
+        if (gRegion.contains(controlPoint)) \
+            QVERIFY(qGreen(pixel) != 0); \
+        else \
+            QVERIFY(qGreen(pixel) == 0); \
+    }
+
+    const QList<QGraphicsItem *> children = parent->childItems();
+    const int childrenCount = children.count();
+
+    for (int i = 0; i < 5; ++i) {
+        QString clipString;
+        QString childString;
+        switch (i) {
+        case 0:
+            // All children stacked in front.
+            childString = QLatin1String("ChildrenInFront.png");
+            foreach (QGraphicsItem *child, children)
+                child->setFlag(QGraphicsItem::ItemStacksBehindParent, false);
+            break;
+        case 1:
+            // All children stacked behind.
+            childString = QLatin1String("ChildrenBehind.png");
+            foreach (QGraphicsItem *child, children)
+                child->setFlag(QGraphicsItem::ItemStacksBehindParent, true);
+            break;
+        case 2:
+            // First half of the children behind, second half in front.
+            childString = QLatin1String("FirstHalfBehind_SecondHalfInFront.png");
+            for (int j = 0; j < childrenCount; ++j) {
+                QGraphicsItem *child = children.at(j);
+                child->setFlag(QGraphicsItem::ItemStacksBehindParent, (j < childrenCount / 2));
+            }
+            break;
+        case 3:
+            // First half of the children in front, second half behind.
+            childString = QLatin1String("FirstHalfInFront_SecondHalfBehind.png");
+            for (int j = 0; j < childrenCount; ++j) {
+                QGraphicsItem *child = children.at(j);
+                child->setFlag(QGraphicsItem::ItemStacksBehindParent, (j >= childrenCount / 2));
+            }
+            break;
+        case 4:
+            // Child2 and child4 behind, rest in front.
+            childString = QLatin1String("Child2And4Behind_RestInFront.png");
+            for (int j = 0; j < childrenCount; ++j) {
+                QGraphicsItem *child = children.at(j);
+                if (j == 1 || j == 3)
+                    child->setFlag(QGraphicsItem::ItemStacksBehindParent, true);
+                else
+                    child->setFlag(QGraphicsItem::ItemStacksBehindParent, false);
+            }
+            break;
+        default:
+            qFatal("internal error");
+        }
+
+        // Nothing is clipped.
+        parent->setFlag(QGraphicsItem::ItemClipsChildrenToShape, false);
+        parent->setFlag(QGraphicsItem::ItemClipsToShape, false);
+        clipString = QLatin1String("nothingClipped_");
+        renderSceneToImage(&scene, &sceneImage, clipString + childString);
+        VERIFY_CONTROL_POINTS(parentRegion, childRegion, grandChildRegion);
+
+        // Parent clips children to shape.
+        parent->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+        clipString = QLatin1String("parentClipsChildrenToShape_");
+        renderSceneToImage(&scene, &sceneImage, clipString + childString);
+        VERIFY_CONTROL_POINTS(parentRegion, clippedChildRegion, clippedGrandChildRegion);
+
+        // Parent clips itself and children to shape.
+        parent->setFlag(QGraphicsItem::ItemClipsToShape);
+        clipString = QLatin1String("parentClipsItselfAndChildrenToShape_");
+        renderSceneToImage(&scene, &sceneImage, clipString + childString);
+        VERIFY_CONTROL_POINTS(clippedParentRegion, clippedChildRegion, clippedGrandChildRegion);
+
+        // Parent clips itself to shape.
+        parent->setFlag(QGraphicsItem::ItemClipsChildrenToShape, false);
+        clipString = QLatin1String("parentClipsItselfToShape_");
+        renderSceneToImage(&scene, &sceneImage, clipString + childString);
+        VERIFY_CONTROL_POINTS(clippedParentRegion, childRegion, grandChildRegion);
+    }
+}
+
+void tst_QGraphicsItem::itemClipsTextChildToShape()
+{
+    // Construct a scene with a rect that clips its children, with one text
+    // child that has text that exceeds the size of the rect.
+    QGraphicsScene scene;
+    QGraphicsItem *rect = scene.addRect(0, 0, 50, 50, QPen(Qt::black), Qt::black);
+    rect->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    QGraphicsTextItem *text = new QGraphicsTextItem("This is a long sentence that's wider than 50 pixels.");
+    text->setParentItem(rect);
+
+    // Render this scene to a transparent image.
+    QRectF sr = scene.itemsBoundingRect();
+    QImage image(sr.size().toSize(), QImage::Format_ARGB32_Premultiplied);
+    image.fill(0);
+    QPainter painter(&image);
+    scene.render(&painter);
+
+    // Erase the area immediately underneath the rect.
+    painter.setCompositionMode(QPainter::CompositionMode_Source);
+    painter.fillRect(rect->sceneBoundingRect().translated(-sr.topLeft()).adjusted(-0.5, -0.5, 0.5, 0.5),
+                     Qt::transparent);
+    painter.end();
+
+    // Check that you get a truly transparent image back (i.e., the text was
+    // clipped away, so there should be no trails left after erasing only the
+    // rect's area).
+    QImage emptyImage(scene.itemsBoundingRect().size().toSize(), QImage::Format_ARGB32_Premultiplied);
+    emptyImage.fill(0);
+    QCOMPARE(image, emptyImage);
+}
+
+void tst_QGraphicsItem::itemClippingDiscovery()
+{
+    // A simple scene with an ellipse parent and two rect children, one a
+    // child of the other.
+    QGraphicsScene scene;
+    QGraphicsEllipseItem *clipItem = scene.addEllipse(0, 0, 100, 100);
+    QGraphicsRectItem *leftRectItem = scene.addRect(0, 0, 50, 100);
+    QGraphicsRectItem *rightRectItem = scene.addRect(50, 0, 50, 100);
+    leftRectItem->setParentItem(clipItem);
+    rightRectItem->setParentItem(clipItem);
+
+    // The rects item are both visible at these points.
+    QCOMPARE(scene.itemAt(10, 10), (QGraphicsItem *)leftRectItem);
+    QCOMPARE(scene.itemAt(90, 90), (QGraphicsItem *)rightRectItem);
+
+    // The ellipse clips the rects now.
+    clipItem->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+
+    // The rect items are no longer visible at these points.
+    QCOMPARE(scene.itemAt(10, 10), (QGraphicsItem *)0);
+    if (sizeof(qreal) != sizeof(double))
+        QSKIP("This fails due to internal rounding errors", SkipSingle);
+    QCOMPARE(scene.itemAt(90, 90), (QGraphicsItem *)0);
+}
+
+void tst_QGraphicsItem::ancestorFlags()
+{
+    QGraphicsItem *level1 = new QGraphicsRectItem;
+    QGraphicsItem *level21 = new QGraphicsRectItem;
+    level21->setParentItem(level1);
+    QGraphicsItem *level22 = new QGraphicsRectItem;
+    level22->setParentItem(level1);
+    QGraphicsItem *level31 = new QGraphicsRectItem;
+    level31->setParentItem(level21);
+    QGraphicsItem *level32 = new QGraphicsRectItem;
+    level32->setParentItem(level21);
+
+    QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level21->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level22->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level31->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level32->d_ptr->ancestorFlags), 0);
+
+    // HandlesChildEvents: 1) Root level sets a flag
+    level1->setHandlesChildEvents(true);
+    QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level21->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level22->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level31->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level32->d_ptr->ancestorFlags), 1);
+
+    // HandlesChildEvents: 2) Root level set it again
+    level1->setHandlesChildEvents(true);
+    QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level21->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level22->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level31->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level32->d_ptr->ancestorFlags), 1);
+
+    // HandlesChildEvents: 3) Root level unsets a flag
+    level1->setHandlesChildEvents(false);
+    QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level21->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level22->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level31->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level32->d_ptr->ancestorFlags), 0);
+
+    // HandlesChildEvents: 4) Child item sets a flag
+    level21->setHandlesChildEvents(true);
+    QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level21->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level22->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level31->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level32->d_ptr->ancestorFlags), 1);
+
+    // HandlesChildEvents: 5) Parent item sets a flag
+    level1->setHandlesChildEvents(true);
+    QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level21->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level22->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level31->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level32->d_ptr->ancestorFlags), 1);
+
+    // HandlesChildEvents: 6) Child item unsets a flag
+    level21->setHandlesChildEvents(false);
+    QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level21->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level22->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level31->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level32->d_ptr->ancestorFlags), 1);
+
+    // HandlesChildEvents: 7) Parent item unsets a flag
+    level21->setHandlesChildEvents(true);
+    level1->setHandlesChildEvents(false);
+    QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level21->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level22->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level31->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level32->d_ptr->ancestorFlags), 1);
+
+    // Reparent the child to root
+    level21->setParentItem(0);
+    QCOMPARE(int(level21->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level22->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level31->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level32->d_ptr->ancestorFlags), 1);
+
+    // Reparent the child to level1 again.
+    level1->setHandlesChildEvents(true);
+    level21->setParentItem(level1);
+    QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level21->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level22->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level31->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level32->d_ptr->ancestorFlags), 1);
+
+    // Reparenting level31 back to level1.
+    level31->setParentItem(level1);
+    QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level21->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level22->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level31->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level32->d_ptr->ancestorFlags), 1);
+
+    // Reparenting level31 back to level21.
+    level31->setParentItem(0);
+    QCOMPARE(int(level31->d_ptr->ancestorFlags), 0);
+    level31->setParentItem(level21);
+    QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level21->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level22->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level31->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level32->d_ptr->ancestorFlags), 1);
+
+    // Level1 doesn't handle child events
+    level1->setHandlesChildEvents(false);
+    QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level21->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level22->d_ptr->ancestorFlags), 0);
+    QCOMPARE(int(level31->d_ptr->ancestorFlags), 1);
+    QCOMPARE(int(level32->d_ptr->ancestorFlags), 1);
+
+    // Nobody handles child events
+    level21->setHandlesChildEvents(false);
+
+    for (int i = 0; i < 2; ++i) {
+        QGraphicsItem::GraphicsItemFlag flag = !i ? QGraphicsItem::ItemClipsChildrenToShape
+                                               : QGraphicsItem::ItemIgnoresTransformations;
+        int ancestorFlag = !i ? QGraphicsItemPrivate::AncestorClipsChildren
+                           : QGraphicsItemPrivate::AncestorIgnoresTransformations;
+
+        QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level21->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level22->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level32->d_ptr->ancestorFlags), 0);
+
+        // HandlesChildEvents: 1) Root level sets a flag
+        level1->setFlag(flag, true);
+        QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level21->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level22->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level32->d_ptr->ancestorFlags), ancestorFlag);
+
+        // HandlesChildEvents: 2) Root level set it again
+        level1->setFlag(flag, true);
+        QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level21->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level22->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level32->d_ptr->ancestorFlags), ancestorFlag);
+
+        // HandlesChildEvents: 3) Root level unsets a flag
+        level1->setFlag(flag, false);
+        QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level21->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level22->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level32->d_ptr->ancestorFlags), 0);
+
+        // HandlesChildEvents: 4) Child item sets a flag
+        level21->setFlag(flag, true);
+        QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level21->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level22->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level32->d_ptr->ancestorFlags), ancestorFlag);
+
+        // HandlesChildEvents: 5) Parent item sets a flag
+        level1->setFlag(flag, true);
+        QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level21->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level22->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level32->d_ptr->ancestorFlags), ancestorFlag);
+
+        // HandlesChildEvents: 6) Child item unsets a flag
+        level21->setFlag(flag, false);
+        QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level21->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level22->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level32->d_ptr->ancestorFlags), ancestorFlag);
+
+        // HandlesChildEvents: 7) Parent item unsets a flag
+        level21->setFlag(flag, true);
+        level1->setFlag(flag, false);
+        QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level21->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level22->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level32->d_ptr->ancestorFlags), ancestorFlag);
+
+        // Reparent the child to root
+        level21->setParentItem(0);
+        QCOMPARE(int(level21->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level22->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level32->d_ptr->ancestorFlags), ancestorFlag);
+
+        // Reparent the child to level1 again.
+        level1->setFlag(flag, true);
+        level21->setParentItem(level1);
+        QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level21->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level22->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level32->d_ptr->ancestorFlags), ancestorFlag);
+
+        // Reparenting level31 back to level1.
+        level31->setParentItem(level1);
+        QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level21->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level22->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level32->d_ptr->ancestorFlags), ancestorFlag);
+
+        // Reparenting level31 back to level21.
+        level31->setParentItem(0);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), 0);
+        level31->setParentItem(level21);
+        QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level21->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level22->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level32->d_ptr->ancestorFlags), ancestorFlag);
+
+        // Level1 doesn't handle child events
+        level1->setFlag(flag, false);
+        QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level21->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level22->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), ancestorFlag);
+        QCOMPARE(int(level32->d_ptr->ancestorFlags), ancestorFlag);
+
+        // Nobody handles child events
+        level21->setFlag(flag, false);
+        QCOMPARE(int(level1->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level21->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level22->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level31->d_ptr->ancestorFlags), 0);
+        QCOMPARE(int(level32->d_ptr->ancestorFlags), 0);
+    }
+
+    delete level1;
+}
+
+void tst_QGraphicsItem::untransformable()
+{
+    QGraphicsItem *item1 = new QGraphicsEllipseItem(QRectF(-50, -50, 100, 100));
+    item1->setZValue(1);
+    item1->setFlag(QGraphicsItem::ItemIgnoresTransformations);
+    item1->rotate(45);
+    ((QGraphicsEllipseItem *)item1)->setBrush(Qt::red);
+
+    QGraphicsItem *item2 = new QGraphicsEllipseItem(QRectF(-50, -50, 100, 100));
+    item2->setParentItem(item1);
+    item2->rotate(45);
+    item2->setPos(100, 0);
+    ((QGraphicsEllipseItem *)item2)->setBrush(Qt::green);
+
+    QGraphicsItem *item3 = new QGraphicsEllipseItem(QRectF(-50, -50, 100, 100));
+    item3->setParentItem(item2);
+    item3->setPos(100, 0);
+    ((QGraphicsEllipseItem *)item3)->setBrush(Qt::blue);
+
+    QGraphicsScene scene(-500, -500, 1000, 1000);
+    scene.addItem(item1);
+
+    QWidget topLevel;
+    QGraphicsView view(&scene,&topLevel);
+    view.resize(300, 300);
+    topLevel.show();
+    view.scale(8, 8);
+    view.centerOn(0, 0);
+
+// Painting with the DiagCrossPattern is really slow on Mac
+// when zoomed out. (The test times out). Task to fix is 155567.
+#if !defined(Q_WS_MAC) || 1
+    view.setBackgroundBrush(QBrush(Qt::black, Qt::DiagCrossPattern));
+#endif
+
+    QTest::qWaitForWindowShown(&view);
+
+    for (int i = 0; i < 10; ++i) {
+        QPoint center = view.viewport()->rect().center();
+        QCOMPARE(view.itemAt(center), item1);
+        QCOMPARE(view.itemAt(center - QPoint(40, 0)), item1);
+        QCOMPARE(view.itemAt(center - QPoint(-40, 0)), item1);
+        QCOMPARE(view.itemAt(center - QPoint(0, 40)), item1);
+        QCOMPARE(view.itemAt(center - QPoint(0, -40)), item1);
+
+        center += QPoint(70, 70);
+        QCOMPARE(view.itemAt(center - QPoint(40, 0)), item2);
+        QCOMPARE(view.itemAt(center - QPoint(-40, 0)), item2);
+        QCOMPARE(view.itemAt(center - QPoint(0, 40)), item2);
+        QCOMPARE(view.itemAt(center - QPoint(0, -40)), item2);
+
+        center += QPoint(0, 100);
+        QCOMPARE(view.itemAt(center - QPoint(40, 0)), item3);
+        QCOMPARE(view.itemAt(center - QPoint(-40, 0)), item3);
+        QCOMPARE(view.itemAt(center - QPoint(0, 40)), item3);
+        QCOMPARE(view.itemAt(center - QPoint(0, -40)), item3);
+
+        view.scale(0.5, 0.5);
+        view.rotate(13);
+        view.shear(qreal(0.01), qreal(0.01));
+        view.translate(10, 10);
+        QTest::qWait(25);
+    }
+}
+
+class ContextMenuItem : public QGraphicsRectItem
+{
+public:
+    ContextMenuItem()
+        : ignoreEvent(true), gotEvent(false), eventWasAccepted(false)
+    { }
+    bool ignoreEvent;
+    bool gotEvent;
+    bool eventWasAccepted;
+protected:
+    void contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+    {
+        gotEvent = true;
+        eventWasAccepted = event->isAccepted();
+        if (ignoreEvent)
+            event->ignore();
+    }
+};
+
+void tst_QGraphicsItem::contextMenuEventPropagation()
+{
+    ContextMenuItem *bottomItem = new ContextMenuItem;
+    bottomItem->setRect(0, 0, 100, 100);
+    ContextMenuItem *topItem = new ContextMenuItem;
+    topItem->setParentItem(bottomItem);
+    topItem->setRect(0, 0, 100, 100);
+
+    QGraphicsScene scene;
+
+    QGraphicsView view(&scene);
+    view.setAlignment(Qt::AlignLeft | Qt::AlignTop);
+    view.show();
+    view.resize(200, 200);
+    QTest::qWaitForWindowShown(&view);
+    QTest::qWait(20);
+
+    QContextMenuEvent event(QContextMenuEvent::Mouse, QPoint(10, 10),
+                            view.viewport()->mapToGlobal(QPoint(10, 10)));
+    event.ignore();
+    QApplication::sendEvent(view.viewport(), &event);
+    QVERIFY(!event.isAccepted());
+
+    scene.addItem(bottomItem);
+    topItem->ignoreEvent = true;
+    bottomItem->ignoreEvent = true;
+
+    QApplication::sendEvent(view.viewport(), &event);
+    QVERIFY(!event.isAccepted());
+    QCOMPARE(topItem->gotEvent, true);
+    QCOMPARE(topItem->eventWasAccepted, true);
+    QCOMPARE(bottomItem->gotEvent, true);
+    QCOMPARE(bottomItem->eventWasAccepted, true);
+
+    topItem->ignoreEvent = false;
+    topItem->gotEvent = false;
+    bottomItem->gotEvent = false;
+
+    QApplication::sendEvent(view.viewport(), &event);
+    QVERIFY(event.isAccepted());
+    QCOMPARE(topItem->gotEvent, true);
+    QCOMPARE(bottomItem->gotEvent, false);
+    QCOMPARE(topItem->eventWasAccepted, true);
+}
+
+void tst_QGraphicsItem::itemIsMovable()
+{
+    QGraphicsRectItem *rect = new QGraphicsRectItem(-50, -50, 100, 100);
+    rect->setFlag(QGraphicsItem::ItemIsMovable);
+
+    QGraphicsScene scene;
+    scene.addItem(rect);
+
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+        event.setButton(Qt::LeftButton);
+        event.setButtons(Qt::LeftButton);
+        qApp->sendEvent(&scene, &event);
+    }
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseMove);
+        event.setButton(Qt::LeftButton);
+        event.setButtons(Qt::LeftButton);
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(rect->pos(), QPointF(0, 0));
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseMove);
+        event.setButtons(Qt::LeftButton);
+        event.setScenePos(QPointF(10, 10));
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(rect->pos(), QPointF(10, 10));
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseMove);
+        event.setButtons(Qt::RightButton);
+        event.setScenePos(QPointF(20, 20));
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(rect->pos(), QPointF(10, 10));
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseMove);
+        event.setButtons(Qt::LeftButton);
+        event.setScenePos(QPointF(30, 30));
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(rect->pos(), QPointF(30, 30));
+}
+
+class ItemAddScene : public QGraphicsScene
+{
+    Q_OBJECT
+public:
+    ItemAddScene()
+    {
+        QTimer::singleShot(500, this, SLOT(newTextItem()));
+    }
+
+public slots:
+    void newTextItem()
+    {
+        // Add a text item
+        QGraphicsItem *item = new QGraphicsTextItem("This item will not ensure that it's visible", 0, this);
+        item->setPos(.0, .0);
+        item->show();
+    }
+};
+
+void tst_QGraphicsItem::task141694_textItemEnsureVisible()
+{
+    ItemAddScene scene;
+    scene.setSceneRect(-1000, -1000, 2000, 2000);
+
+    QGraphicsView view(&scene);
+    view.setFixedSize(200, 200);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    view.ensureVisible(-1000, -1000, 5, 5);
+    int hscroll = view.horizontalScrollBar()->value();
+    int vscroll = view.verticalScrollBar()->value();
+
+    QTest::qWait(10);
+
+    // This should not cause the view to scroll
+    QTRY_COMPARE(view.horizontalScrollBar()->value(), hscroll);
+    QCOMPARE(view.verticalScrollBar()->value(), vscroll);
+}
+
+void tst_QGraphicsItem::task128696_textItemEnsureMovable()
+{
+    QGraphicsTextItem *item = new QGraphicsTextItem;
+    item->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
+    item->setTextInteractionFlags(Qt::TextEditorInteraction);
+    item->setPlainText("abc de\nf ghi\n   j k l");
+
+    QGraphicsScene scene;
+    scene.setSceneRect(-100, -100, 200, 200);
+    scene.addItem(item);
+
+    QGraphicsView view(&scene);
+    view.setFixedSize(200, 200);
+    view.show();
+
+    QGraphicsSceneMouseEvent event1(QEvent::GraphicsSceneMousePress);
+    event1.setScenePos(QPointF(0, 0));
+    event1.setButton(Qt::LeftButton);
+    event1.setButtons(Qt::LeftButton);
+    QApplication::sendEvent(&scene, &event1);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)item);
+
+    QGraphicsSceneMouseEvent event2(QEvent::GraphicsSceneMouseMove);
+    event2.setScenePos(QPointF(10, 10));
+    event2.setButton(Qt::LeftButton);
+    event2.setButtons(Qt::LeftButton);
+    QApplication::sendEvent(&scene, &event2);
+    QCOMPARE(item->pos(), QPointF(10, 10));
+}
+
+void tst_QGraphicsItem::task177918_lineItemUndetected()
+{
+    QGraphicsScene scene;
+    QGraphicsLineItem *line = scene.addLine(10, 10, 10, 10);
+    QCOMPARE(line->boundingRect(), QRectF(10, 10, 0, 0));
+
+    QVERIFY(!scene.items(9, 9, 2, 2, Qt::IntersectsItemShape).isEmpty());
+    QVERIFY(!scene.items(9, 9, 2, 2, Qt::ContainsItemShape).isEmpty());
+    QVERIFY(!scene.items(9, 9, 2, 2, Qt::IntersectsItemBoundingRect).isEmpty());
+    QVERIFY(!scene.items(9, 9, 2, 2, Qt::ContainsItemBoundingRect).isEmpty());
+}
+
+void tst_QGraphicsItem::task240400_clickOnTextItem_data()
+{
+    QTest::addColumn<int>("flags");
+    QTest::addColumn<int>("textFlags");
+    QTest::newRow("editor, noflags") << 0 << int(Qt::TextEditorInteraction);
+    QTest::newRow("editor, movable") << int(QGraphicsItem::ItemIsMovable) << int(Qt::TextEditorInteraction);
+    QTest::newRow("editor, selectable") << int(QGraphicsItem::ItemIsSelectable) << int(Qt::TextEditorInteraction);
+    QTest::newRow("editor, movable | selectable") << int(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable)
+                                                  << int(Qt::TextEditorInteraction);
+    QTest::newRow("noninteractive, noflags") << 0 << int(Qt::NoTextInteraction);
+    QTest::newRow("noninteractive, movable") << int(QGraphicsItem::ItemIsMovable) << int(Qt::NoTextInteraction);
+    QTest::newRow("noninteractive, selectable") << int(QGraphicsItem::ItemIsSelectable) << int(Qt::NoTextInteraction);
+    QTest::newRow("noninteractive, movable | selectable") << int(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable)
+                                                          << int(Qt::NoTextInteraction);
+}
+
+void tst_QGraphicsItem::task240400_clickOnTextItem()
+{
+    QFETCH(int, flags);
+    QFETCH(int, textFlags);
+
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    QGraphicsTextItem *item = scene.addText("Hello");
+    item->setFlags(QGraphicsItem::GraphicsItemFlags(flags));
+    item->setTextInteractionFlags(Qt::TextInteractionFlags(textFlags));
+    bool focusable = (item->flags() & QGraphicsItem::ItemIsFocusable);
+    QVERIFY(textFlags ? focusable : !focusable);
+
+    int column = item->textCursor().columnNumber();
+    QCOMPARE(column, 0);
+
+    QVERIFY(!item->hasFocus());
+
+    // Click in the top-left corner of the item
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+        event.setScenePos(item->sceneBoundingRect().topLeft() + QPointF(0.1, 0.1));
+        event.setButton(Qt::LeftButton);
+        event.setButtons(Qt::LeftButton);
+        QApplication::sendEvent(&scene, &event);
+    }
+    if (flags || textFlags)
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)item);
+    else
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseRelease);
+        event.setScenePos(item->sceneBoundingRect().topLeft() + QPointF(0.1, 0.1));
+        event.setButton(Qt::LeftButton);
+        event.setButtons(0);
+        QApplication::sendEvent(&scene, &event);
+    }
+    if (textFlags)
+        QVERIFY(item->hasFocus());
+    else
+        QVERIFY(!item->hasFocus());
+    QVERIFY(!scene.mouseGrabberItem());
+    bool selectable = (flags & QGraphicsItem::ItemIsSelectable);
+    QVERIFY(selectable ? item->isSelected() : !item->isSelected());
+
+    // Now click in the middle and check that the cursor moved.
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+        event.setScenePos(item->sceneBoundingRect().center());
+        event.setButton(Qt::LeftButton);
+        event.setButtons(Qt::LeftButton);
+        QApplication::sendEvent(&scene, &event);
+    }
+    if (flags || textFlags)
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)item);
+    else
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseRelease);
+        event.setScenePos(item->sceneBoundingRect().center());
+        event.setButton(Qt::LeftButton);
+        event.setButtons(0);
+        QApplication::sendEvent(&scene, &event);
+    }
+    if (textFlags)
+        QVERIFY(item->hasFocus());
+    else
+        QVERIFY(!item->hasFocus());
+    QVERIFY(!scene.mouseGrabberItem());
+
+    QVERIFY(selectable ? item->isSelected() : !item->isSelected());
+
+    //
+    if (textFlags & Qt::TextEditorInteraction)
+        QVERIFY(item->textCursor().columnNumber() > column);
+    else
+        QCOMPARE(item->textCursor().columnNumber(), 0);
+}
+
+class TextItem : public QGraphicsSimpleTextItem
+{
+public:
+    TextItem(const QString& text) : QGraphicsSimpleTextItem(text)
+    {
+        updates = 0;
+    }
+
+    void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget)
+    {
+        updates++;
+        QGraphicsSimpleTextItem::paint(painter, option, widget);
+    }
+
+    int updates;
+};
+
+void tst_QGraphicsItem::ensureUpdateOnTextItem()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTest::qWait(25);
+    TextItem *text1 = new TextItem(QLatin1String("123"));
+    scene.addItem(text1);
+    qApp->processEvents();
+    QTRY_COMPARE(text1->updates,1);
+
+    //same bouding rect but we have to update
+    text1->setText(QLatin1String("321"));
+    qApp->processEvents();
+    QTRY_COMPARE(text1->updates,2);
+}
+
+void tst_QGraphicsItem::task243707_addChildBeforeParent()
+{
+    // Task reports that adding the child before the parent leads to an
+    // inconsistent internal state that can cause a crash.  This test shows
+    // one such crash.
+    QGraphicsScene scene;
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsWidget *widget2 = new QGraphicsWidget(widget);
+    scene.addItem(widget2);
+    QVERIFY(!widget2->parentItem());
+    scene.addItem(widget);
+    QVERIFY(!widget->commonAncestorItem(widget2));
+    QVERIFY(!widget2->commonAncestorItem(widget));
+}
+
+void tst_QGraphicsItem::task197802_childrenVisibility()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem item(QRectF(0,0,20,20));
+
+    QGraphicsRectItem *item2 = new QGraphicsRectItem(QRectF(0,0,10,10), &item);
+    scene.addItem(&item);
+
+    //freshly created: both visible
+    QVERIFY(item.isVisible());
+    QVERIFY(item2->isVisible());
+
+    //hide child: parent visible, child not
+    item2->hide();
+    QVERIFY(item.isVisible());
+    QVERIFY(!item2->isVisible());
+
+    //hide parent: parent and child invisible
+    item.hide();
+    QVERIFY(!item.isVisible());
+    QVERIFY(!item2->isVisible());
+
+    //ask to show the child: parent and child invisible anyways
+    item2->show();
+    QVERIFY(!item.isVisible());
+    QVERIFY(!item2->isVisible());
+
+    //show the parent: both parent and child visible
+    item.show();
+    QVERIFY(item.isVisible());
+    QVERIFY(item2->isVisible());
+
+    delete item2;
+}
+
+void tst_QGraphicsItem::boundingRegion_data()
+{
+    QTest::addColumn<QLineF>("line");
+    QTest::addColumn<qreal>("granularity");
+    QTest::addColumn<QTransform>("transform");
+    QTest::addColumn<QRegion>("expectedRegion");
+
+    QTest::newRow("(0, 0, 10, 10) | 0.0 | identity | {(0, 0, 10, 10)}") << QLineF(0, 0, 10, 10) << qreal(0.0) << QTransform()
+                                                                        << QRegion(QRect(0, 0, 10, 10));
+#if 0
+    {
+        QRegion r;
+        r += QRect(0, 0, 6, 2);
+        r += QRect(0, 2, 8, 2);
+        r += QRect(0, 4, 10, 2);
+        r += QRect(2, 6, 8, 2);
+        r += QRect(4, 8, 6, 2);
+        QTest::newRow("(0, 0, 10, 10) | 0.5 | identity | {(0, 0, 10, 10)}") << QLineF(0, 0, 10, 10) << qreal(0.5) << QTransform() << r;
+    }
+    {
+        QRegion r;
+        r += QRect(0, 0, 4, 1); r += QRect(0, 1, 5, 1); r += QRect(0, 2, 6, 1);
+        r += QRect(0, 3, 7, 1); r += QRect(1, 4, 7, 1); r += QRect(2, 5, 7, 1);
+        r += QRect(3, 6, 7, 1); r += QRect(4, 7, 6, 1); r += QRect(5, 8, 5, 1);
+        r += QRect(6, 9, 4, 1);
+        QTest::newRow("(0, 0, 10, 10) | 1.0 | identity | {(0, 0, 10, 10)}") << QLineF(0, 0, 10, 10) << qreal(1.0) << QTransform() << r;
+    }
+#endif
+    QTest::newRow("(0, 0, 10, 0) | 0.0 | identity | {(0, 0, 10, 10)}") << QLineF(0, 0, 10, 0) << qreal(0.0) << QTransform()
+                                                                       << QRegion(QRect(0, 0, 10, 1));
+    QTest::newRow("(0, 0, 10, 0) | 0.5 | identity | {(0, 0, 10, 1)}") << QLineF(0, 0, 10, 0) << qreal(0.5) << QTransform()
+                                                                      << QRegion(QRect(0, 0, 10, 1));
+    QTest::newRow("(0, 0, 10, 0) | 1.0 | identity | {(0, 0, 10, 1)}") << QLineF(0, 0, 10, 0) << qreal(1.0) << QTransform()
+                                                                      << QRegion(QRect(0, 0, 10, 1));
+    QTest::newRow("(0, 0, 0, 10) | 0.0 | identity | {(0, 0, 10, 10)}") << QLineF(0, 0, 0, 10) << qreal(0.0) << QTransform()
+                                                                       << QRegion(QRect(0, 0, 1, 10));
+    QTest::newRow("(0, 0, 0, 10) | 0.5 | identity | {(0, 0, 1, 10)}") << QLineF(0, 0, 0, 10) << qreal(0.5) << QTransform()
+                                                                      << QRegion(QRect(0, 0, 1, 10));
+    QTest::newRow("(0, 0, 0, 10) | 1.0 | identity | {(0, 0, 1, 10)}") << QLineF(0, 0, 0, 10) << qreal(1.0) << QTransform()
+                                                                      << QRegion(QRect(0, 0, 1, 10));
+}
+
+void tst_QGraphicsItem::boundingRegion()
+{
+    QFETCH(QLineF, line);
+    QFETCH(qreal, granularity);
+    QFETCH(QTransform, transform);
+    QFETCH(QRegion, expectedRegion);
+
+    QGraphicsLineItem item(line);
+    QCOMPARE(item.boundingRegionGranularity(), qreal(0.0));
+    item.setBoundingRegionGranularity(granularity);
+    QCOMPARE(item.boundingRegionGranularity(), granularity);
+    QCOMPARE(item.boundingRegion(transform), expectedRegion);
+}
+
+void tst_QGraphicsItem::itemTransform_parentChild()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *parent = scene.addRect(0, 0, 100, 100);
+    QGraphicsItem *child = scene.addRect(0, 0, 100, 100);
+    child->setParentItem(parent);
+    child->setPos(10, 10);
+    child->scale(2, 2);
+    child->rotate(90);
+
+    QCOMPARE(child->itemTransform(parent).map(QPointF(10, 10)), QPointF(-10, 30));
+    QCOMPARE(parent->itemTransform(child).map(QPointF(-10, 30)), QPointF(10, 10));
+}
+
+void tst_QGraphicsItem::itemTransform_siblings()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *parent = scene.addRect(0, 0, 100, 100);
+    QGraphicsItem *brother = scene.addRect(0, 0, 100, 100);
+    QGraphicsItem *sister = scene.addRect(0, 0, 100, 100);
+    parent->scale(10, 5);
+    parent->rotate(-180);
+    parent->shear(2, 3);
+
+    brother->setParentItem(parent);
+    sister->setParentItem(parent);
+
+    brother->setPos(10, 10);
+    brother->scale(2, 2);
+    brother->rotate(90);
+    sister->setPos(10, 10);
+    sister->scale(2, 2);
+    sister->rotate(90);
+
+    QCOMPARE(brother->itemTransform(sister).map(QPointF(10, 10)), QPointF(10, 10));
+    QCOMPARE(sister->itemTransform(brother).map(QPointF(10, 10)), QPointF(10, 10));
+}
+
+void tst_QGraphicsItem::itemTransform_unrelated()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *stranger1 = scene.addRect(0, 0, 100, 100);
+    QGraphicsItem *stranger2 = scene.addRect(0, 0, 100, 100);
+    stranger1->setPos(10, 10);
+    stranger1->scale(2, 2);
+    stranger1->rotate(90);
+    stranger2->setPos(10, 10);
+    stranger2->scale(2, 2);
+    stranger2->rotate(90);
+
+    QCOMPARE(stranger1->itemTransform(stranger2).map(QPointF(10, 10)), QPointF(10, 10));
+    QCOMPARE(stranger2->itemTransform(stranger1).map(QPointF(10, 10)), QPointF(10, 10));
+}
+
+void tst_QGraphicsItem::opacity_data()
+{
+    QTest::addColumn<qreal>("p_opacity");
+    QTest::addColumn<int>("p_opacityFlags");
+    QTest::addColumn<qreal>("c1_opacity");
+    QTest::addColumn<int>("c1_opacityFlags");
+    QTest::addColumn<qreal>("c2_opacity");
+    QTest::addColumn<int>("c2_opacityFlags");
+    QTest::addColumn<qreal>("p_effectiveOpacity");
+    QTest::addColumn<qreal>("c1_effectiveOpacity");
+    QTest::addColumn<qreal>("c2_effectiveOpacity");
+    QTest::addColumn<qreal>("c3_effectiveOpacity");
+
+    // Modify the opacity and see how it propagates
+    QTest::newRow("A: 1.0 0 1.0 0 1.0 1.0 1.0 1.0 1.0") << qreal(1.0) << 0 << qreal(1.0) << 0 << qreal(1.0) << 0
+                                                        << qreal(1.0) << qreal(1.0) << qreal(1.0) << qreal(1.0);
+    QTest::newRow("B: 0.5 0 1.0 0 1.0 1.0 1.0 1.0 1.0") << qreal(0.5) << 0 << qreal(1.0) << 0 << qreal(1.0) << 0
+                                                        << qreal(0.5) << qreal(0.5) << qreal(0.5) << qreal(0.5);
+    QTest::newRow("C: 0.5 0 0.1 0 1.0 1.0 1.0 1.0 1.0") << qreal(0.5) << 0 << qreal(0.1) << 0 << qreal(1.0) << 0
+                                                        << qreal(0.5) << qreal(0.05) << qreal(0.05) << qreal(0.05);
+    QTest::newRow("D: 0.0 0 1.0 0 1.0 1.0 1.0 1.0 1.0") << qreal(0.0) << 0 << qreal(1.0) << 0 << qreal(1.0) << 0
+                                                        << qreal(0.0) << qreal(0.0) << qreal(0.0) << qreal(0.0);
+
+    // Parent doesn't propagate to children - now modify the opacity and see how it propagates
+    int flags = QGraphicsItem::ItemDoesntPropagateOpacityToChildren;
+    QTest::newRow("E: 1.0 2 1.0 0 1.0 1.0 1.0 1.0 1.0") << qreal(1.0) << flags << qreal(1.0) << 0 << qreal(1.0) << 0
+                                                        << qreal(1.0) << qreal(1.0) << qreal(1.0) << qreal(1.0);
+    QTest::newRow("F: 0.5 2 1.0 0 1.0 1.0 1.0 1.0 1.0") << qreal(0.5) << flags << qreal(1.0) << 0 << qreal(1.0) << 0
+                                                        << qreal(0.5) << qreal(1.0) << qreal(1.0) << qreal(1.0);
+    QTest::newRow("G: 0.5 2 0.1 0 1.0 1.0 1.0 1.0 1.0") << qreal(0.5) << flags << qreal(0.1) << 0 << qreal(1.0) << 0
+                                                        << qreal(0.5) << qreal(0.1) << qreal(0.1) << qreal(0.1);
+    QTest::newRow("H: 0.0 2 1.0 0 1.0 1.0 1.0 1.0 1.0") << qreal(0.0) << flags << qreal(1.0) << 0 << qreal(1.0) << 0
+                                                        << qreal(0.0) << qreal(1.0) << qreal(1.0) << qreal(1.0);
+
+    // Child ignores parent - now modify the opacity and see how it propagates
+    flags = QGraphicsItem::ItemIgnoresParentOpacity;
+    QTest::newRow("I: 1.0 0 1.0 1 1.0 1.0 1.0 1.0 1.0") << qreal(1.0) << 0 << qreal(1.0) << flags << qreal(1.0) << 0
+                                                        << qreal(1.0) << qreal(1.0) << qreal(1.0) << qreal(1.0);
+    QTest::newRow("J: 1.0 0 1.0 1 1.0 1.0 1.0 1.0 1.0") << qreal(0.5) << 0 << qreal(0.5) << flags << qreal(0.5) << 0
+                                                        << qreal(0.5) << qreal(0.5) << qreal(0.25) << qreal(0.25);
+    QTest::newRow("K: 1.0 0 1.0 1 1.0 1.0 1.0 1.0 1.0") << qreal(0.2) << 0 << qreal(0.2) << flags << qreal(0.2) << 0
+                                                        << qreal(0.2) << qreal(0.2) << qreal(0.04) << qreal(0.04);
+    QTest::newRow("L: 1.0 0 1.0 1 1.0 1.0 1.0 1.0 1.0") << qreal(0.0) << 0 << qreal(0.0) << flags << qreal(0.0) << 0
+                                                        << qreal(0.0) << qreal(0.0) << qreal(0.0) << qreal(0.0);
+
+    // Child ignores parent and doesn't propagate - now modify the opacity and see how it propagates
+    flags = QGraphicsItem::ItemIgnoresParentOpacity | QGraphicsItem::ItemDoesntPropagateOpacityToChildren;
+    QTest::newRow("M: 1.0 0 1.0 1 1.0 1.0 1.0 1.0 1.0") << qreal(1.0) << 0 // p
+                                                        << qreal(1.0) << flags // c1 (no prop)
+                                                        << qreal(1.0) << 0 // c2
+                                                        << qreal(1.0) << qreal(1.0) << qreal(1.0) << qreal(1.0);
+    QTest::newRow("M: 0.5 0 1.0 1 1.0 1.0 1.0 1.0 1.0") << qreal(0.5) << 0 // p
+                                                        << qreal(1.0) << flags // c1 (no prop)
+                                                        << qreal(1.0) << 0 // c2
+                                                        << qreal(0.5) << qreal(1.0) << qreal(1.0) << qreal(1.0);
+    QTest::newRow("M: 0.5 0 0.5 1 1.0 1.0 1.0 1.0 1.0") << qreal(0.5) << 0 // p
+                                                        << qreal(0.5) << flags // c1 (no prop)
+                                                        << qreal(1.0) << 0 // c2
+                                                        << qreal(0.5) << qreal(0.5) << qreal(1.0) << qreal(1.0);
+    QTest::newRow("M: 0.5 0 0.5 1 0.5 1.0 1.0 1.0 1.0") << qreal(0.5) << 0 // p
+                                                        << qreal(0.5) << flags // c1 (no prop)
+                                                        << qreal(0.5) << 0 // c2
+                                                        << qreal(0.5) << qreal(0.5) << qreal(0.5) << qreal(0.5);
+    QTest::newRow("M: 1.0 0 0.5 1 0.5 1.0 1.0 1.0 1.0") << qreal(1.0) << 0 // p
+                                                        << qreal(0.5) << flags // c1 (no prop)
+                                                        << qreal(0.5) << 0 // c2
+                                                        << qreal(1.0) << qreal(0.5) << qreal(0.5) << qreal(0.5);
+}
+
+void tst_QGraphicsItem::opacity()
+{
+    QFETCH(qreal, p_opacity);
+    QFETCH(int, p_opacityFlags);
+    QFETCH(qreal, p_effectiveOpacity);
+    QFETCH(qreal, c1_opacity);
+    QFETCH(int, c1_opacityFlags);
+    QFETCH(qreal, c1_effectiveOpacity);
+    QFETCH(qreal, c2_opacity);
+    QFETCH(int, c2_opacityFlags);
+    QFETCH(qreal, c2_effectiveOpacity);
+    QFETCH(qreal, c3_effectiveOpacity);
+
+    QGraphicsRectItem *p = new QGraphicsRectItem;
+    QGraphicsRectItem *c1 = new QGraphicsRectItem(p);
+    QGraphicsRectItem *c2 = new QGraphicsRectItem(c1);
+    QGraphicsRectItem *c3 = new QGraphicsRectItem(c2);
+
+    QCOMPARE(p->opacity(), qreal(1.0));
+    QCOMPARE(p->effectiveOpacity(), qreal(1.0));
+    int opacityMask = QGraphicsItem::ItemIgnoresParentOpacity | QGraphicsItem::ItemDoesntPropagateOpacityToChildren;
+    QVERIFY(!(p->flags() & opacityMask));
+
+    p->setOpacity(p_opacity);
+    c1->setOpacity(c1_opacity);
+    c2->setOpacity(c2_opacity);
+    p->setFlags(QGraphicsItem::GraphicsItemFlags(p->flags() | p_opacityFlags));
+    c1->setFlags(QGraphicsItem::GraphicsItemFlags(c1->flags() | c1_opacityFlags));
+    c2->setFlags(QGraphicsItem::GraphicsItemFlags(c2->flags() | c2_opacityFlags));
+
+    QCOMPARE(int(p->flags() & opacityMask), p_opacityFlags);
+    QCOMPARE(int(c1->flags() & opacityMask), c1_opacityFlags);
+    QCOMPARE(int(c2->flags() & opacityMask), c2_opacityFlags);
+    QCOMPARE(p->opacity(), p_opacity);
+    QCOMPARE(p->effectiveOpacity(), p_effectiveOpacity);
+    QCOMPARE(c1->effectiveOpacity(), c1_effectiveOpacity);
+    QCOMPARE(c2->effectiveOpacity(), c2_effectiveOpacity);
+    QCOMPARE(c3->effectiveOpacity(), c3_effectiveOpacity);
+}
+
+void tst_QGraphicsItem::opacity2()
+{
+    EventTester *parent = new EventTester;
+    EventTester *child = new EventTester(parent);
+    EventTester *grandChild = new EventTester(child);
+
+    QGraphicsScene scene;
+    scene.addItem(parent);
+
+    MyGraphicsView view(&scene);
+    if(PlatformQuirks::isAutoMaximizing())
+        view.showFullScreen();
+    else
+        view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(view.repaints >= 1);
+
+#define RESET_REPAINT_COUNTERS \
+    parent->repaints = 0; \
+    child->repaints = 0; \
+    grandChild->repaints = 0; \
+    view.repaints = 0;
+
+    RESET_REPAINT_COUNTERS
+
+    child->setOpacity(0.0);
+    QTest::qWait(10);
+    QTRY_COMPARE(view.repaints, 1);
+    QCOMPARE(parent->repaints, 1);
+    QCOMPARE(child->repaints, 0);
+    QCOMPARE(grandChild->repaints, 0);
+
+    RESET_REPAINT_COUNTERS
+
+    child->setOpacity(1.0);
+    QTest::qWait(10);
+    QTRY_COMPARE(view.repaints, 1);
+    QCOMPARE(parent->repaints, 1);
+    QCOMPARE(child->repaints, 1);
+    QCOMPARE(grandChild->repaints, 1);
+
+    RESET_REPAINT_COUNTERS
+
+    parent->setOpacity(0.0);
+    QTest::qWait(10);
+    QTRY_COMPARE(view.repaints, 1);
+    QCOMPARE(parent->repaints, 0);
+    QCOMPARE(child->repaints, 0);
+    QCOMPARE(grandChild->repaints, 0);
+
+    RESET_REPAINT_COUNTERS
+
+    parent->setOpacity(1.0);
+    QTest::qWait(10);
+    QTRY_COMPARE(view.repaints, 1);
+    QCOMPARE(parent->repaints, 1);
+    QCOMPARE(child->repaints, 1);
+    QCOMPARE(grandChild->repaints, 1);
+
+    grandChild->setFlag(QGraphicsItem::ItemIgnoresParentOpacity);
+    RESET_REPAINT_COUNTERS
+
+    child->setOpacity(0.0);
+    QTest::qWait(10);
+    QTRY_COMPARE(view.repaints, 1);
+    QCOMPARE(parent->repaints, 1);
+    QCOMPARE(child->repaints, 0);
+    QCOMPARE(grandChild->repaints, 1);
+
+    RESET_REPAINT_COUNTERS
+
+    child->setOpacity(0.0); // Already 0.0; no change.
+    QTest::qWait(10);
+    QTRY_COMPARE(view.repaints, 0);
+    QCOMPARE(parent->repaints, 0);
+    QCOMPARE(child->repaints, 0);
+    QCOMPARE(grandChild->repaints, 0);
+}
+
+void tst_QGraphicsItem::opacityZeroUpdates()
+{
+    EventTester *parent = new EventTester;
+    EventTester *child = new EventTester(parent);
+
+    child->setPos(10, 10);
+
+    QGraphicsScene scene;
+    scene.addItem(parent);
+
+    MyGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(view.repaints > 0);
+
+    view.reset();
+    parent->setOpacity(0.0);
+
+    QTest::qWait(20);
+
+    // transforming items bounding rect to view coordinates
+    const QRect childDeviceBoundingRect = child->deviceTransform(view.viewportTransform())
+                                           .mapRect(child->boundingRect()).toRect();
+    const QRect parentDeviceBoundingRect = parent->deviceTransform(view.viewportTransform())
+                                           .mapRect(parent->boundingRect()).toRect();
+
+    QRegion expectedRegion = parentDeviceBoundingRect.adjusted(-2, -2, 2, 2);
+    expectedRegion += childDeviceBoundingRect.adjusted(-2, -2, 2, 2);
+
+    COMPARE_REGIONS(view.paintedRegion, expectedRegion);
+}
+
+class StacksBehindParentHelper : public QGraphicsRectItem
+{
+public:
+    StacksBehindParentHelper(QList<QGraphicsItem *> *paintedItems, const QRectF &rect, QGraphicsItem *parent = 0)
+        : QGraphicsRectItem(rect, parent), paintedItems(paintedItems)
+    { }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        QGraphicsRectItem::paint(painter, option, widget);
+        paintedItems->append(this);
+    }
+
+private:
+    QList<QGraphicsItem *> *paintedItems;
+};
+
+void tst_QGraphicsItem::itemStacksBehindParent()
+{
+    StacksBehindParentHelper *parent1 = new StacksBehindParentHelper(&paintedItems, QRectF(0, 0, 100, 50));
+    StacksBehindParentHelper *child11 = new StacksBehindParentHelper(&paintedItems, QRectF(-10, 10, 50, 50), parent1);
+    StacksBehindParentHelper *grandChild111 = new StacksBehindParentHelper(&paintedItems, QRectF(-20, 20, 50, 50), child11);
+    StacksBehindParentHelper *child12 = new StacksBehindParentHelper(&paintedItems, QRectF(60, 10, 50, 50), parent1);
+    StacksBehindParentHelper *grandChild121 = new StacksBehindParentHelper(&paintedItems, QRectF(70, 20, 50, 50), child12);
+
+    StacksBehindParentHelper *parent2 = new StacksBehindParentHelper(&paintedItems, QRectF(0, 0, 100, 50));
+    StacksBehindParentHelper *child21 = new StacksBehindParentHelper(&paintedItems, QRectF(-10, 10, 50, 50), parent2);
+    StacksBehindParentHelper *grandChild211 = new StacksBehindParentHelper(&paintedItems, QRectF(-20, 20, 50, 50), child21);
+    StacksBehindParentHelper *child22 = new StacksBehindParentHelper(&paintedItems, QRectF(60, 10, 50, 50), parent2);
+    StacksBehindParentHelper *grandChild221 = new StacksBehindParentHelper(&paintedItems, QRectF(70, 20, 50, 50), child22);
+
+    parent1->setData(0, "parent1");
+    child11->setData(0, "child11");
+    grandChild111->setData(0, "grandChild111");
+    child12->setData(0, "child12");
+    grandChild121->setData(0, "grandChild121");
+    parent2->setData(0, "parent2");
+    child21->setData(0, "child21");
+    grandChild211->setData(0, "grandChild211");
+    child22->setData(0, "child22");
+    grandChild221->setData(0, "grandChild221");
+
+    // Disambiguate siblings
+    parent1->setZValue(1);
+    child11->setZValue(1);
+    child21->setZValue(1);
+
+    QGraphicsScene scene;
+    scene.addItem(parent1);
+    scene.addItem(parent2);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(!paintedItems.isEmpty());
+    QTest::qWait(100);
+    paintedItems.clear();
+    view.viewport()->update();
+    QApplication::processEvents();
+    QTRY_COMPARE(scene.items(0, 0, 100, 100), (QList<QGraphicsItem *>()
+                                           << grandChild111 << child11
+                                           << grandChild121 << child12 << parent1
+                                           << grandChild211 << child21
+                                           << grandChild221 << child22 << parent2));
+    QTRY_COMPARE(paintedItems, QList<QGraphicsItem *>()
+             << parent2 << child22 << grandChild221
+             << child21 << grandChild211
+             << parent1 << child12 << grandChild121
+             << child11 << grandChild111);
+
+    child11->setFlag(QGraphicsItem::ItemStacksBehindParent);
+    scene.update();
+    paintedItems.clear();
+    QApplication::processEvents();
+
+    QTRY_COMPARE(scene.items(0, 0, 100, 100), (QList<QGraphicsItem *>()
+                                           << grandChild121 << child12 << parent1
+                                           << grandChild111 << child11
+                                           << grandChild211 << child21
+                                           << grandChild221 << child22 << parent2));
+    QCOMPARE(paintedItems, QList<QGraphicsItem *>()
+             << parent2 << child22 << grandChild221
+             << child21 << grandChild211
+             << child11 << grandChild111
+             << parent1 << child12 << grandChild121);
+
+    child12->setFlag(QGraphicsItem::ItemStacksBehindParent);
+    paintedItems.clear();
+    scene.update();
+    QApplication::processEvents();
+
+    QTRY_COMPARE(scene.items(0, 0, 100, 100), (QList<QGraphicsItem *>()
+                                           << parent1 << grandChild111 << child11
+                                           << grandChild121 << child12
+                                           << grandChild211 << child21
+                                           << grandChild221 << child22 << parent2));
+    QCOMPARE(paintedItems, QList<QGraphicsItem *>()
+             << parent2 << child22 << grandChild221
+             << child21 << grandChild211
+             << child12 << grandChild121
+             << child11 << grandChild111 << parent1);
+}
+
+class ClippingAndTransformsScene : public QGraphicsScene
+{
+public:
+    QList<QGraphicsItem *> drawnItems;
+protected:
+    void drawItems(QPainter *painter, int numItems, QGraphicsItem *items[],
+                   const QStyleOptionGraphicsItem options[], QWidget *widget = 0)
+    {
+        drawnItems.clear();
+        for (int i = 0; i < numItems; ++i)
+            drawnItems << items[i];
+        QGraphicsScene::drawItems(painter, numItems, items, options, widget);
+    }
+};
+
+void tst_QGraphicsItem::nestedClipping()
+{
+    ClippingAndTransformsScene scene;
+    scene.setSceneRect(-50, -50, 200, 200);
+
+    QGraphicsRectItem *root = new QGraphicsRectItem(QRectF(0, 0, 100, 100));
+    root->setBrush(QColor(0, 0, 255));
+    root->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    QGraphicsRectItem *l1 = new QGraphicsRectItem(QRectF(0, 0, 100, 100));
+    l1->setParentItem(root);
+    l1->setPos(-50, 0);
+    l1->setBrush(QColor(255, 0, 0));
+    l1->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    QGraphicsEllipseItem *l2 = new QGraphicsEllipseItem(QRectF(0, 0, 100, 100));
+    l2->setParentItem(l1);
+    l2->setPos(50, 50);
+    l2->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    l2->setBrush(QColor(255, 255, 0));
+    QGraphicsRectItem *l3 = new QGraphicsRectItem(QRectF(0, 0, 25, 25));
+    l3->setParentItem(l2);
+    l3->setBrush(QColor(0, 255, 0));
+    l3->setPos(50 - 12, -12);
+
+    scene.addItem(root);
+
+    root->setData(0, "root");
+    l1->setData(0, "l1");
+    l2->setData(0, "l2");
+    l3->setData(0, "l3");
+
+    QGraphicsView view(&scene);
+    view.setOptimizationFlag(QGraphicsView::IndirectPainting);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTest::qWait(25);
+
+    QList<QGraphicsItem *> expected;
+    expected << root << l1 << l2 << l3;
+    QTRY_COMPARE(scene.drawnItems, expected);
+
+    QImage image(200, 200, QImage::Format_ARGB32_Premultiplied);
+    image.fill(0);
+
+    QPainter painter(&image);
+    scene.render(&painter);
+    painter.end();
+
+    // Check transparent areas
+    QCOMPARE(image.pixel(100, 25), qRgba(0, 0, 0, 0));
+    QCOMPARE(image.pixel(100, 175), qRgba(0, 0, 0, 0));
+    QCOMPARE(image.pixel(25, 100), qRgba(0, 0, 0, 0));
+    QCOMPARE(image.pixel(175, 100), qRgba(0, 0, 0, 0));
+    QCOMPARE(image.pixel(70, 80), qRgba(255, 0, 0, 255));
+    QCOMPARE(image.pixel(80, 130), qRgba(255, 255, 0, 255));
+    QCOMPARE(image.pixel(92, 105), qRgba(0, 255, 0, 255));
+    QCOMPARE(image.pixel(105, 105), qRgba(0, 0, 255, 255));
+#if 0
+    // Enable this to compare if the test starts failing.
+    image.save("nestedClipping_reference.png");
+#endif
+}
+
+class TransformDebugItem : public QGraphicsRectItem
+{
+public:
+    TransformDebugItem()
+        : QGraphicsRectItem(QRectF(-10, -10, 20, 20))
+    {
+        setBrush(QColor(qrand() % 256, qrand() % 256, qrand() % 256));
+    }
+
+    QTransform x;
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
+               QWidget *widget = 0)
+    {
+        x = painter->worldTransform();
+        QGraphicsRectItem::paint(painter, option, widget);
+    }
+};
+
+void tst_QGraphicsItem::nestedClippingTransforms()
+{
+    TransformDebugItem *rootClipper = new TransformDebugItem;
+    rootClipper->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    TransformDebugItem *child = new TransformDebugItem;
+    child->setParentItem(rootClipper);
+    child->setPos(2, 2);
+    TransformDebugItem *grandChildClipper = new TransformDebugItem;
+    grandChildClipper->setParentItem(child);
+    grandChildClipper->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    grandChildClipper->setPos(4, 4);
+    TransformDebugItem *greatGrandChild = new TransformDebugItem;
+    greatGrandChild->setPos(2, 2);
+    greatGrandChild->setParentItem(grandChildClipper);
+    TransformDebugItem *grandChildClipper2 = new TransformDebugItem;
+    grandChildClipper2->setParentItem(child);
+    grandChildClipper2->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    grandChildClipper2->setPos(8, 8);
+    TransformDebugItem *greatGrandChild2 = new TransformDebugItem;
+    greatGrandChild2->setPos(2, 2);
+    greatGrandChild2->setParentItem(grandChildClipper2);
+    TransformDebugItem *grandChildClipper3 = new TransformDebugItem;
+    grandChildClipper3->setParentItem(child);
+    grandChildClipper3->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    grandChildClipper3->setPos(12, 12);
+    TransformDebugItem *greatGrandChild3 = new TransformDebugItem;
+    greatGrandChild3->setPos(2, 2);
+    greatGrandChild3->setParentItem(grandChildClipper3);
+
+    QGraphicsScene scene;
+    scene.addItem(rootClipper);
+
+    QImage image(scene.itemsBoundingRect().size().toSize(), QImage::Format_ARGB32_Premultiplied);
+    image.fill(0);
+    QPainter p(&image);
+    scene.render(&p);
+    p.end();
+
+    QCOMPARE(rootClipper->x, QTransform(1, 0, 0, 0, 1, 0, 10, 10, 1));
+    QCOMPARE(child->x, QTransform(1, 0, 0, 0, 1, 0, 12, 12, 1));
+    QCOMPARE(grandChildClipper->x, QTransform(1, 0, 0, 0, 1, 0, 16, 16, 1));
+    QCOMPARE(greatGrandChild->x, QTransform(1, 0, 0, 0, 1, 0, 18, 18, 1));
+    QCOMPARE(grandChildClipper2->x, QTransform(1, 0, 0, 0, 1, 0, 20, 20, 1));
+    QCOMPARE(greatGrandChild2->x, QTransform(1, 0, 0, 0, 1, 0, 22, 22, 1));
+    QCOMPARE(grandChildClipper3->x, QTransform(1, 0, 0, 0, 1, 0, 24, 24, 1));
+    QCOMPARE(greatGrandChild3->x, QTransform(1, 0, 0, 0, 1, 0, 26, 26, 1));
+}
+
+void tst_QGraphicsItem::sceneTransformCache()
+{
+    // Test that an item's scene transform is updated correctly when the
+    // parent is transformed.
+    QGraphicsScene scene;
+    QGraphicsRectItem *rect = scene.addRect(0, 0, 100, 100);
+    QGraphicsRectItem *rect2 = scene.addRect(0, 0, 100, 100);
+    rect2->setParentItem(rect);
+    rect2->rotate(90);
+    rect->translate(0, 50);
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+
+    rect->translate(0, 100);
+    QTransform x;
+    x.translate(0, 150);
+    x.rotate(90);
+    QCOMPARE(rect2->sceneTransform(), x);
+
+    scene.removeItem(rect);
+
+    //Crazy use case : rect4 child of rect3 so the transformation of rect4 will be cached.Good!
+    //We remove rect4 from the scene, then the validTransform bit flag is set to 0 and the index of the cache
+    //add to the freeTransformSlots. The problem was that sceneTransformIndex was not set to -1 so if a new item arrive
+    //with a child (rect6) that will be cached then it will take the freeSlot (ex rect4) and put it his transform. But if rect4 is
+    //added back to the scene then it will set the transform to his old sceneTransformIndex value that will erase the new
+    //value of rect6 so rect6 transform will be wrong.
+    QGraphicsRectItem *rect3 = scene.addRect(0, 0, 100, 100);
+    QGraphicsRectItem *rect4 = scene.addRect(0, 0, 100, 100);
+    rect3->setPos(QPointF(10,10));
+
+    rect4->setParentItem(rect3);
+    rect4->setPos(QPointF(10,10));
+
+    QCOMPARE(rect4->mapToScene(rect4->boundingRect().topLeft()), QPointF(20,20));
+
+    scene.removeItem(rect4);
+    //rect4 transform is local only
+    QCOMPARE(rect4->mapToScene(rect4->boundingRect().topLeft()), QPointF(10,10));
+
+    QGraphicsRectItem *rect5 = scene.addRect(0, 0, 100, 100);
+    QGraphicsRectItem *rect6 = scene.addRect(0, 0, 100, 100);
+    rect5->setPos(QPointF(20,20));
+
+    rect6->setParentItem(rect5);
+    rect6->setPos(QPointF(10,10));
+    //test if rect6 transform is ok
+    QCOMPARE(rect6->mapToScene(rect6->boundingRect().topLeft()), QPointF(30,30));
+
+    scene.addItem(rect4);
+
+    QCOMPARE(rect4->mapToScene(rect4->boundingRect().topLeft()), QPointF(10,10));
+    //test if rect6 transform is still correct
+    QCOMPARE(rect6->mapToScene(rect6->boundingRect().topLeft()), QPointF(30,30));
+}
+
+void tst_QGraphicsItem::tabChangesFocus_data()
+{
+    QTest::addColumn<bool>("tabChangesFocus");
+    QTest::newRow("tab changes focus") << true;
+    QTest::newRow("tab doesn't change focus") << false;
+}
+
+void tst_QGraphicsItem::tabChangesFocus()
+{
+    QFETCH(bool, tabChangesFocus);
+
+    QGraphicsScene scene;
+    QGraphicsTextItem *item = scene.addText("Hello");
+    item->setTabChangesFocus(tabChangesFocus);
+    item->setTextInteractionFlags(Qt::TextEditorInteraction);
+    item->setFocus();
+
+    QDial *dial1 = new QDial;
+    QGraphicsView *view = new QGraphicsView(&scene);
+
+    QDial *dial2 = new QDial;
+    QVBoxLayout *layout = new QVBoxLayout;
+    layout->addWidget(dial1);
+    layout->addWidget(view);
+    layout->addWidget(dial2);
+
+    QWidget widget;
+    widget.setLayout(layout);
+    widget.show();
+    QTest::qWaitForWindowShown(&widget);
+    QTest::qWait(2000);
+
+    QTRY_VERIFY(scene.isActive());
+
+    dial1->setFocus();
+    QTest::qWait(15);
+    QTRY_VERIFY(dial1->hasFocus());
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QTest::qWait(15);
+    QTRY_VERIFY(view->hasFocus());
+    QTRY_VERIFY(item->hasFocus());
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QTest::qWait(15);
+
+    if (tabChangesFocus) {
+        QTRY_VERIFY(!view->hasFocus());
+        QTRY_VERIFY(!item->hasFocus());
+        QTRY_VERIFY(dial2->hasFocus());
+    } else {
+        QTRY_VERIFY(view->hasFocus());
+        QTRY_VERIFY(item->hasFocus());
+        QCOMPARE(item->toPlainText(), QString("\tHello"));
+    }
+}
+
+void tst_QGraphicsItem::cacheMode()
+{
+    QGraphicsScene scene(0, 0, 100, 100);
+    QGraphicsView view(&scene);
+    view.resize(150, 150);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+
+    // Increase the probability of window activation
+    // not causing another repaint of test items.
+    QTest::qWait(50);
+
+    EventTester *tester = new EventTester;
+    EventTester *testerChild = new EventTester;
+    testerChild->setParentItem(tester);
+    EventTester *testerChild2 = new EventTester;
+    testerChild2->setParentItem(testerChild);
+    testerChild2->setFlag(QGraphicsItem::ItemIgnoresTransformations);
+
+    scene.addItem(tester);
+    QTest::qWait(10);
+
+    for (int i = 0; i < 2; ++i) {
+        // No visual change.
+        QTRY_COMPARE(tester->repaints, 1);
+        QCOMPARE(testerChild->repaints, 1);
+        QCOMPARE(testerChild2->repaints, 1);
+        tester->setCacheMode(QGraphicsItem::NoCache);
+        testerChild->setCacheMode(QGraphicsItem::NoCache);
+        testerChild2->setCacheMode(QGraphicsItem::NoCache);
+        QTest::qWait(25);
+        QTRY_COMPARE(tester->repaints, 1);
+        QCOMPARE(testerChild->repaints, 1);
+        QCOMPARE(testerChild2->repaints, 1);
+        tester->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+        testerChild->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+        testerChild2->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+        QTest::qWait(25);
+    }
+
+    // The first move causes a repaint as the item is painted into its pixmap.
+    // (Only occurs if the item has previously been painted without cache).
+    tester->setPos(10, 10);
+    testerChild->setPos(10, 10);
+    testerChild2->setPos(10, 10);
+    QTest::qWait(25);
+    QTRY_COMPARE(tester->repaints, 2);
+    QCOMPARE(testerChild->repaints, 2);
+    QCOMPARE(testerChild2->repaints, 2);
+
+    // Consecutive moves should not repaint.
+    tester->setPos(20, 20);
+    testerChild->setPos(20, 20);
+    testerChild2->setPos(20, 20);
+    QTest::qWait(250);
+    QCOMPARE(tester->repaints, 2);
+    QCOMPARE(testerChild->repaints, 2);
+    QCOMPARE(testerChild2->repaints, 2);
+
+    // Translating does not result in a repaint.
+    tester->translate(10, 10);
+    QTest::qWait(25);
+    QTRY_COMPARE(tester->repaints, 2);
+    QCOMPARE(testerChild->repaints, 2);
+    QCOMPARE(testerChild2->repaints, 2);
+
+    // Rotating results in a repaint.
+    tester->rotate(45);
+    QTest::qWait(25);
+    QTRY_COMPARE(tester->repaints, 3);
+    QCOMPARE(testerChild->repaints, 3);
+    QCOMPARE(testerChild2->repaints, 2);
+
+    // Change to ItemCoordinateCache (triggers repaint).
+    tester->setCacheMode(QGraphicsItem::ItemCoordinateCache); // autosize
+    testerChild->setCacheMode(QGraphicsItem::ItemCoordinateCache); // autosize
+    testerChild2->setCacheMode(QGraphicsItem::ItemCoordinateCache); // autosize
+    QTest::qWait(25);
+    QTRY_COMPARE(tester->repaints, 4);
+    QCOMPARE(testerChild->repaints, 4);
+    QCOMPARE(testerChild2->repaints, 3);
+
+    // Rotating items with ItemCoordinateCache doesn't cause a repaint.
+    tester->rotate(22);
+    testerChild->rotate(22);
+    testerChild2->rotate(22);
+    QTest::qWait(25);
+    QTRY_COMPARE(tester->repaints, 4);
+    QTRY_COMPARE(testerChild->repaints, 4);
+    QTRY_COMPARE(testerChild2->repaints, 3);
+    tester->resetTransform();
+    testerChild->resetTransform();
+    testerChild2->resetTransform();
+
+    // Explicit update causes a repaint.
+    tester->update(0, 0, 5, 5);
+    QTest::qWait(25);
+    QTRY_COMPARE(tester->repaints, 5);
+    QCOMPARE(testerChild->repaints, 4);
+    QCOMPARE(testerChild2->repaints, 3);
+
+    // Updating outside the item's bounds does not cause a repaint.
+    tester->update(10, 10, 5, 5);
+    QTest::qWait(25);
+    QTRY_COMPARE(tester->repaints, 5);
+    QCOMPARE(testerChild->repaints, 4);
+    QCOMPARE(testerChild2->repaints, 3);
+
+    // Resizing an item should cause a repaint of that item. (because of
+    // autosize).
+    tester->setGeometry(QRectF(-15, -15, 30, 30));
+    QTest::qWait(25);
+    QTRY_COMPARE(tester->repaints, 6);
+    QCOMPARE(testerChild->repaints, 4);
+    QCOMPARE(testerChild2->repaints, 3);
+
+    // Set fixed size.
+    tester->setCacheMode(QGraphicsItem::ItemCoordinateCache, QSize(30, 30));
+    testerChild->setCacheMode(QGraphicsItem::ItemCoordinateCache, QSize(30, 30));
+    testerChild2->setCacheMode(QGraphicsItem::ItemCoordinateCache, QSize(30, 30));
+    QTest::qWait(20);
+    QTRY_COMPARE(tester->repaints, 7);
+    QCOMPARE(testerChild->repaints, 5);
+    QCOMPARE(testerChild2->repaints, 4);
+
+    // Resizing the item should cause a repaint.
+    testerChild->setGeometry(QRectF(-15, -15, 30, 30));
+    QTest::qWait(25);
+    QTRY_COMPARE(tester->repaints, 7);
+    QCOMPARE(testerChild->repaints, 6);
+    QCOMPARE(testerChild2->repaints, 4);
+
+    // Scaling the view does not cause a repaint.
+    view.scale(0.7, 0.7);
+    QTest::qWait(25);
+    QTRY_COMPARE(tester->repaints, 7);
+    QCOMPARE(testerChild->repaints, 6);
+    QCOMPARE(testerChild2->repaints, 4);
+
+    // Switch to device coordinate cache.
+    tester->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+    testerChild->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+    testerChild2->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+    QTest::qWait(25);
+    QTRY_COMPARE(tester->repaints, 8);
+    QCOMPARE(testerChild->repaints, 7);
+    QCOMPARE(testerChild2->repaints, 5);
+
+    // Scaling the view back should cause repaints for two of the items.
+    view.setTransform(QTransform());
+    QTest::qWait(25);
+    QTRY_COMPARE(tester->repaints, 9);
+    QCOMPARE(testerChild->repaints, 8);
+    QCOMPARE(testerChild2->repaints, 5);
+
+    // Rotating the base item (perspective) should repaint two items.
+    tester->setTransform(QTransform().rotate(10, Qt::XAxis));
+    QTest::qWait(25);
+    QTRY_COMPARE(tester->repaints, 10);
+    QCOMPARE(testerChild->repaints, 9);
+    QCOMPARE(testerChild2->repaints, 5);
+
+    // Moving the middle item should case a repaint even if it's a move,
+    // because the parent is rotated with a perspective.
+    testerChild->setPos(1, 1);
+    QTest::qWait(25);
+    QTRY_COMPARE(tester->repaints, 11);
+    QTRY_COMPARE(testerChild->repaints, 10);
+    QTRY_COMPARE(testerChild2->repaints, 5);
+    tester->resetTransform();
+
+    // Make a huge item
+    tester->setGeometry(QRectF(-4000, -4000, 8000, 8000));
+    QTRY_COMPARE(tester->repaints, 12);
+    QTRY_COMPARE(testerChild->repaints, 11);
+    QTRY_COMPARE(testerChild2->repaints, 5);
+
+    // Move the large item - will cause a repaint as the
+    // cache is clipped.
+    tester->setPos(5, 0);
+    QTRY_COMPARE(tester->repaints, 13);
+    QTRY_COMPARE(testerChild->repaints, 11);
+    QTRY_COMPARE(testerChild2->repaints, 5);
+
+    // Hiding and showing should invalidate the cache
+    tester->hide();
+    QTest::qWait(25);
+    tester->show();
+    QTRY_COMPARE(tester->repaints, 14);
+    QTRY_COMPARE(testerChild->repaints, 12);
+    QTRY_COMPARE(testerChild2->repaints, 6);
+}
+
+void tst_QGraphicsItem::cacheMode2()
+{
+    QGraphicsScene scene(0, 0, 100, 100);
+    QGraphicsView view(&scene);
+    view.resize(150, 150);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+
+    // Increase the probability of window activation
+    // not causing another repaint of test items.
+    QTest::qWait(50);
+
+    EventTester *tester = new EventTester;
+    scene.addItem(tester);
+    QTest::qWait(10);
+    QTRY_COMPARE(tester->repaints, 1);
+
+    // Switching from NoCache to NoCache (no repaint)
+    tester->setCacheMode(QGraphicsItem::NoCache);
+    QTest::qWait(50);
+    QTRY_COMPARE(tester->repaints, 1);
+
+    // Switching from NoCache to DeviceCoordinateCache (no repaint)
+    tester->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+    QTest::qWait(50);
+    QTRY_COMPARE(tester->repaints, 1);
+
+    // Switching from DeviceCoordinateCache to DeviceCoordinateCache (no repaint)
+    tester->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+    QTest::qWait(50);
+    QTRY_COMPARE(tester->repaints, 1);
+
+    // Switching from DeviceCoordinateCache to NoCache (no repaint)
+    tester->setCacheMode(QGraphicsItem::NoCache);
+    QTest::qWait(50);
+    QTRY_COMPARE(tester->repaints, 1);
+
+    // Switching from NoCache to ItemCoordinateCache (repaint)
+    tester->setCacheMode(QGraphicsItem::ItemCoordinateCache);
+    QTest::qWait(50);
+    QTRY_COMPARE(tester->repaints, 2);
+
+    // Switching from ItemCoordinateCache to ItemCoordinateCache (no repaint)
+    tester->setCacheMode(QGraphicsItem::ItemCoordinateCache);
+    QTest::qWait(50);
+    QTRY_COMPARE(tester->repaints, 2);
+
+    // Switching from ItemCoordinateCache to ItemCoordinateCache with different size (repaint)
+    tester->setCacheMode(QGraphicsItem::ItemCoordinateCache, QSize(100, 100));
+    QTest::qWait(50);
+    QTRY_COMPARE(tester->repaints, 3);
+
+    // Switching from ItemCoordinateCache to NoCache (repaint)
+    tester->setCacheMode(QGraphicsItem::NoCache);
+    QTest::qWait(50);
+    QTRY_COMPARE(tester->repaints, 4);
+
+    // Switching from DeviceCoordinateCache to ItemCoordinateCache (repaint)
+    tester->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+    QTest::qWait(50);
+    QTRY_COMPARE(tester->repaints, 4);
+    tester->setCacheMode(QGraphicsItem::ItemCoordinateCache);
+    QTest::qWait(50);
+    QTRY_COMPARE(tester->repaints, 5);
+
+    // Switching from ItemCoordinateCache to DeviceCoordinateCache (repaint)
+    tester->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+    QTest::qWait(50);
+    QTRY_COMPARE(tester->repaints, 6);
+}
+
+void tst_QGraphicsItem::updateCachedItemAfterMove()
+{
+    // A simple item that uses ItemCoordinateCache
+    EventTester *tester = new EventTester;
+    tester->setCacheMode(QGraphicsItem::ItemCoordinateCache);
+
+    // Add to a scene, show in a view, ensure it's painted and reset its
+    // repaint counter.
+    QGraphicsScene scene;
+    scene.addItem(tester);
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QTest::qWait(12);
+    QTRY_VERIFY(tester->repaints > 0);
+    tester->repaints = 0;
+
+    // Move the item, should not cause repaints
+    tester->setPos(10, 0);
+    QTest::qWait(12);
+    QCOMPARE(tester->repaints, 0);
+
+    // Move then update, should cause one repaint
+    tester->setPos(20, 0);
+    tester->update();
+    QTest::qWait(12);
+    QCOMPARE(tester->repaints, 1);
+
+    // Hiding the item doesn't cause a repaint
+    tester->hide();
+    QTest::qWait(12);
+    QCOMPARE(tester->repaints, 1);
+
+    // Moving a hidden item doesn't cause a repaint
+    tester->setPos(30, 0);
+    tester->update();
+    QTest::qWait(12);
+    QCOMPARE(tester->repaints, 1);
+}
+
+class Track : public QGraphicsRectItem
+{
+public:
+    Track(const QRectF &rect)
+        : QGraphicsRectItem(rect)
+    {
+        setAcceptHoverEvents(true);
+    }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0)
+    {
+        QGraphicsRectItem::paint(painter, option, widget);
+        painter->drawText(boundingRect(), Qt::AlignCenter, QString("%1x%2\n%3x%4").arg(p.x()).arg(p.y()).arg(sp.x()).arg(sp.y()));
+    }
+
+protected:
+    void hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+    {
+        p = event->pos();
+        sp = event->widget()->mapFromGlobal(event->screenPos());
+        update();
+    }
+private:
+    QPointF p;
+    QPoint sp;
+};
+
+void tst_QGraphicsItem::deviceTransform_data()
+{
+    QTest::addColumn<bool>("untransformable1");
+    QTest::addColumn<bool>("untransformable2");
+    QTest::addColumn<bool>("untransformable3");
+    QTest::addColumn<qreal>("rotation1");
+    QTest::addColumn<qreal>("rotation2");
+    QTest::addColumn<qreal>("rotation3");
+    QTest::addColumn<QTransform>("deviceX");
+    QTest::addColumn<QPointF>("mapResult1");
+    QTest::addColumn<QPointF>("mapResult2");
+    QTest::addColumn<QPointF>("mapResult3");
+
+    QTest::newRow("nil") << false << false << false
+                         << qreal(0.0) << qreal(0.0) << qreal(0.0)
+                         << QTransform()
+                         << QPointF(150, 150) << QPointF(250, 250) << QPointF(350, 350);
+    QTest::newRow("deviceX rot 90") << false << false << false
+                         << qreal(0.0) << qreal(0.0) << qreal(0.0)
+                         << QTransform().rotate(90)
+                         << QPointF(-150, 150) << QPointF(-250, 250) << QPointF(-350, 350);
+    QTest::newRow("deviceX rot 90 100") << true << false << false
+                         << qreal(0.0) << qreal(0.0) << qreal(0.0)
+                         << QTransform().rotate(90)
+                         << QPointF(-50, 150) << QPointF(50, 250) << QPointF(150, 350);
+    QTest::newRow("deviceX rot 90 010") << false << true << false
+                         << qreal(0.0) << qreal(0.0) << qreal(0.0)
+                         << QTransform().rotate(90)
+                         << QPointF(-150, 150) << QPointF(-150, 250) << QPointF(-50, 350);
+    QTest::newRow("deviceX rot 90 001") << false << false << true
+                         << qreal(0.0) << qreal(0.0) << qreal(0.0)
+                         << QTransform().rotate(90)
+                         << QPointF(-150, 150) << QPointF(-250, 250) << QPointF(-250, 350);
+    QTest::newRow("deviceX rot 90 111") << true << true << true
+                         << qreal(0.0) << qreal(0.0) << qreal(0.0)
+                         << QTransform().rotate(90)
+                         << QPointF(-50, 150) << QPointF(50, 250) << QPointF(150, 350);
+    QTest::newRow("deviceX rot 90 101") << true << false << true
+                         << qreal(0.0) << qreal(0.0) << qreal(0.0)
+                         << QTransform().rotate(90)
+                         << QPointF(-50, 150) << QPointF(50, 250) << QPointF(150, 350);
+}
+
+void tst_QGraphicsItem::deviceTransform()
+{
+    QFETCH(bool, untransformable1);
+    QFETCH(bool, untransformable2);
+    QFETCH(bool, untransformable3);
+    QFETCH(qreal, rotation1);
+    QFETCH(qreal, rotation2);
+    QFETCH(qreal, rotation3);
+    QFETCH(QTransform, deviceX);
+    QFETCH(QPointF, mapResult1);
+    QFETCH(QPointF, mapResult2);
+    QFETCH(QPointF, mapResult3);
+
+    QGraphicsScene scene;
+    Track *rect1 = new Track(QRectF(0, 0, 100, 100));
+    Track *rect2 = new Track(QRectF(0, 0, 100, 100));
+    Track *rect3 = new Track(QRectF(0, 0, 100, 100));
+    rect2->setParentItem(rect1);
+    rect3->setParentItem(rect2);
+    rect1->setPos(100, 100);
+    rect2->setPos(100, 100);
+    rect3->setPos(100, 100);
+    rect1->rotate(rotation1);
+    rect2->rotate(rotation2);
+    rect3->rotate(rotation3);
+    rect1->setFlag(QGraphicsItem::ItemIgnoresTransformations, untransformable1);
+    rect2->setFlag(QGraphicsItem::ItemIgnoresTransformations, untransformable2);
+    rect3->setFlag(QGraphicsItem::ItemIgnoresTransformations, untransformable3);
+    rect1->setBrush(Qt::red);
+    rect2->setBrush(Qt::green);
+    rect3->setBrush(Qt::blue);
+    scene.addItem(rect1);
+
+    QCOMPARE(rect1->deviceTransform(deviceX).map(QPointF(50, 50)), mapResult1);
+    QCOMPARE(rect2->deviceTransform(deviceX).map(QPointF(50, 50)), mapResult2);
+    QCOMPARE(rect3->deviceTransform(deviceX).map(QPointF(50, 50)), mapResult3);
+}
+
+void tst_QGraphicsItem::update()
+{
+    QGraphicsScene scene;
+    scene.setSceneRect(-100, -100, 200, 200);
+    QWidget topLevel;
+    MyGraphicsView view(&scene,&topLevel);
+
+    topLevel.resize(300, 300);
+    topLevel.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(100);
+
+    EventTester *item = new EventTester;
+    scene.addItem(item);
+    QTest::qWait(100); // Make sure all pending updates are processed.
+    item->repaints = 0;
+
+    item->update(); // Item marked as dirty
+    scene.update(); // Entire scene marked as dirty
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 1);
+
+    // Make sure the dirty state from the previous update is reset so that
+    // the item don't think it is already dirty and discards this update.
+    item->update();
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 2);
+
+    // Make sure a partial update doesn't cause a full update to be discarded.
+    view.reset();
+    item->repaints = 0;
+    item->update(QRectF(0, 0, 5, 5));
+    item->update();
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 1);
+    QCOMPARE(view.repaints, 1);
+    QRect itemDeviceBoundingRect = item->deviceTransform(view.viewportTransform())
+                                                         .mapRect(item->boundingRect()).toAlignedRect();
+    QRegion expectedRegion = itemDeviceBoundingRect.adjusted(-2, -2, 2, 2);
+    // The entire item's bounding rect (adjusted for antialiasing) should have been painted.
+    QCOMPARE(view.paintedRegion, expectedRegion);
+
+    // Make sure update requests outside the bounding rect are discarded.
+    view.reset();
+    item->repaints = 0;
+    item->update(-15, -15, 5, 5); // Item's brect: (-10, -10, 20, 20)
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 0);
+    QCOMPARE(view.repaints, 0);
+
+    // Make sure the area occupied by an item is repainted when hiding it.
+    view.reset();
+    item->repaints = 0;
+    item->update(); // Full update; all sub-sequent update requests are discarded.
+    item->hide(); // visible set to 0. ignoreVisible must be set to 1; the item won't be processed otherwise.
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 0);
+    QCOMPARE(view.repaints, 1);
+    // The entire item's bounding rect (adjusted for antialiasing) should have been painted.
+    QCOMPARE(view.paintedRegion, expectedRegion);
+
+    // Make sure item is repainted when shown (after being hidden).
+    view.reset();
+    item->repaints = 0;
+    item->show();
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 1);
+    QCOMPARE(view.repaints, 1);
+    // The entire item's bounding rect (adjusted for antialiasing) should have been painted.
+    QCOMPARE(view.paintedRegion, expectedRegion);
+
+    item->repaints = 0;
+    item->hide();
+    qApp->processEvents();
+    view.reset();
+    const QPointF originalPos = item->pos();
+    item->setPos(5000, 5000);
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 0);
+    QCOMPARE(view.repaints, 0);
+    qApp->processEvents();
+
+    item->setPos(originalPos);
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 0);
+    QCOMPARE(view.repaints, 0);
+    item->show();
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 1);
+    QCOMPARE(view.repaints, 1);
+    // The entire item's bounding rect (adjusted for antialiasing) should have been painted.
+    QCOMPARE(view.paintedRegion, expectedRegion);
+
+    QGraphicsViewPrivate *viewPrivate = static_cast<QGraphicsViewPrivate *>(qt_widget_private(&view));
+    item->setPos(originalPos + QPoint(50, 50));
+    viewPrivate->updateAll();
+    QVERIFY(viewPrivate->fullUpdatePending);
+    QTest::qWait(50);
+    item->repaints = 0;
+    view.reset();
+    item->setPos(originalPos);
+    QTest::qWait(50);
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 1);
+    QCOMPARE(view.repaints, 1);
+    COMPARE_REGIONS(view.paintedRegion, expectedRegion + expectedRegion.translated(50, 50));
+
+    // Make sure moving a parent item triggers an update on the children
+    // (even though the parent itself is outside the viewport).
+    QGraphicsRectItem *parent = new QGraphicsRectItem(0, 0, 10, 10);
+    parent->setPos(-400, 0);
+    item->setParentItem(parent);
+    item->setPos(400, 0);
+    scene.addItem(parent);
+    QTest::qWait(50);
+    itemDeviceBoundingRect = item->deviceTransform(view.viewportTransform())
+                                                   .mapRect(item->boundingRect()).toAlignedRect();
+    expectedRegion = itemDeviceBoundingRect.adjusted(-2, -2, 2, 2);
+    view.reset();
+    item->repaints = 0;
+    parent->translate(-400, 0);
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 0);
+    QCOMPARE(view.repaints, 1);
+    QCOMPARE(view.paintedRegion, expectedRegion);
+    view.reset();
+    item->repaints = 0;
+    parent->translate(400, 0);
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 1);
+    QCOMPARE(view.repaints, 1);
+    QCOMPARE(view.paintedRegion, expectedRegion);
+    QCOMPARE(view.paintedRegion, expectedRegion);
+}
+
+void tst_QGraphicsItem::setTransformProperties_data()
+{
+    QTest::addColumn<QPointF>("origin");
+    QTest::addColumn<qreal>("rotation");
+    QTest::addColumn<qreal>("scale");
+
+    QTest::newRow("nothing") << QPointF() << qreal(0.0) << qreal(1.0);
+
+    QTest::newRow("rotation") << QPointF() << qreal(42.2) << qreal(1.0);
+
+    QTest::newRow("rotation dicentred") << QPointF(qreal(22.3), qreal(-56.2))
+                                << qreal(-2578.2)
+                                << qreal(1.0);
+
+    QTest::newRow("Scale")    << QPointF() << qreal(0.0)
+                                          << qreal(6);
+
+    QTest::newRow("Everything dicentred")  << QPointF(qreal(22.3), qreal(-56.2)) << qreal(-175) << qreal(196);
+}
+
+/**
+ * the normal QCOMPARE doesn't work because it doesn't use qFuzzyCompare
+ */
+#define QCOMPARE_TRANSFORM(X1, X2)   QVERIFY(((X1)*(X2).inverted()).isIdentity())
+
+void tst_QGraphicsItem::setTransformProperties()
+{
+    QFETCH(QPointF,origin);
+    QFETCH(qreal,rotation);
+    QFETCH(qreal,scale);
+
+    QTransform result;
+    result.translate(origin.x(), origin.y());
+    result.rotate(rotation, Qt::ZAxis);
+    result.scale(scale, scale);
+    result.translate(-origin.x(), -origin.y());
+
+    QGraphicsScene scene;
+    QGraphicsRectItem *item = new QGraphicsRectItem(QRectF(0, 0, 100, 100));
+    scene.addItem(item);
+
+    item->setRotation(rotation);
+    item->setScale(scale);
+    item->setTransformOriginPoint(origin);
+
+    QCOMPARE(item->rotation(), rotation);
+    QCOMPARE(item->scale(), scale);
+    QCOMPARE(item->transformOriginPoint(), origin);
+
+    QCOMPARE(QTransform(), item->transform());
+    QCOMPARE(result, item->sceneTransform());
+
+    //-----------------------------------------------------------------
+    //Change the rotation Z
+    item->setRotation(45);
+    QTransform result2;
+    result2.translate(origin.x(), origin.y());
+    result2.rotate(45);
+    result2.scale(scale, scale);
+    result2.translate(-origin.x(), -origin.y());
+
+    QCOMPARE(item->rotation(), 45.);
+    QCOMPARE(item->scale(), scale);
+    QCOMPARE(item->transformOriginPoint(), origin);
+
+    QCOMPARE(QTransform(), item->transform());
+    QCOMPARE(result2, item->sceneTransform());
+
+    //-----------------------------------------------------------------
+    // calling setTransform() and setPos should change the sceneTransform
+    item->setTransform(result);
+    item->setPos(100, -150.5);
+
+    QCOMPARE(item->rotation(), 45.);
+    QCOMPARE(item->scale(), scale);
+    QCOMPARE(item->transformOriginPoint(), origin);
+    QCOMPARE(result, item->transform());
+
+    QTransform result3(result);
+
+    result3.translate(origin.x(), origin.y());
+    result3.rotate(45);
+    result3.scale(scale, scale);
+    result3.translate(-origin.x(), -origin.y());
+
+    result3 *= QTransform::fromTranslate(100, -150.5); //the pos;
+
+    QCOMPARE(result3, item->sceneTransform());
+
+    //-----------------------------------------------------
+    // setting the propertiees should be the same as setting a transform
+    {//with center origin on the matrix
+        QGraphicsRectItem *item1 = new QGraphicsRectItem(QRectF(50.2, -150, 230.5, 119));
+        scene.addItem(item1);
+        QGraphicsRectItem *item2 = new QGraphicsRectItem(QRectF(50.2, -150, 230.5, 119));
+        scene.addItem(item2);
+
+        item1->setPos(12.3, -5);
+        item2->setPos(12.3, -5);
+        item1->setRotation(rotation);
+        item1->setScale(scale);
+        item1->setTransformOriginPoint(origin);
+
+        item2->setTransform(result);
+
+        QCOMPARE_TRANSFORM(item1->sceneTransform(), item2->sceneTransform());
+
+        QCOMPARE_TRANSFORM(item1->itemTransform(item2), QTransform());
+        QCOMPARE_TRANSFORM(item2->itemTransform(item1), QTransform());
+    }
+}
+
+class MyStyleOptionTester : public QGraphicsRectItem
+{
+public:
+    MyStyleOptionTester(const QRectF &rect)
+        : QGraphicsRectItem(rect), startTrack(false)
+    {}
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0)
+    {
+        if (startTrack) {
+            //Doesn't use the extended style option so the exposed rect is the boundingRect
+            if (!(flags() & QGraphicsItem::ItemUsesExtendedStyleOption)) {
+                QCOMPARE(option->exposedRect, boundingRect());
+                QCOMPARE(option->matrix, QMatrix());
+            } else {
+                QVERIFY(option->exposedRect != QRect());
+                QVERIFY(option->exposedRect != boundingRect());
+                QCOMPARE(option->matrix, sceneTransform().toAffine());
+            }
+        }
+        QGraphicsRectItem::paint(painter, option, widget);
+    }
+    bool startTrack;
+};
+
+void tst_QGraphicsItem::itemUsesExtendedStyleOption()
+{
+    QGraphicsScene scene(0, 0, 300, 300);
+    QGraphicsPixmapItem item;
+    item.setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, true);
+    QCOMPARE(item.flags(), QGraphicsItem::GraphicsItemFlags(QGraphicsItem::ItemUsesExtendedStyleOption));
+    item.setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, false);
+    QCOMPARE(item.flags(), 0);
+
+    //We now test the content of the style option
+    MyStyleOptionTester *rect = new MyStyleOptionTester(QRect(0, 0, 100, 100));
+    scene.addItem(rect);
+    rect->setPos(200, 200);
+    QWidget topLevel;
+    QGraphicsView view(&scene, &topLevel);
+    topLevel.setWindowFlags(Qt::X11BypassWindowManagerHint);
+    rect->startTrack = false;
+    topLevel.show();
+    QTest::qWaitForWindowShown(&view);
+    QTest::qWait(60);
+    rect->startTrack = true;
+    rect->update(10, 10, 10, 10);
+    QTest::qWait(60);
+    rect->startTrack = false;
+    rect->setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, true);
+    QVERIFY((rect->flags() & QGraphicsItem::ItemUsesExtendedStyleOption));
+    QTest::qWait(60);
+    rect->startTrack = true;
+    rect->update(10, 10, 10, 10);
+    QTest::qWait(60);
+}
+
+void tst_QGraphicsItem::itemSendsGeometryChanges()
+{
+    ItemChangeTester item;
+    item.setFlags(0);
+    item.clear();
+
+    QTransform x = QTransform().rotate(45);
+    QPointF pos(10, 10);
+    qreal o(0.5);
+    qreal r(10.0);
+    qreal s(1.5);
+    QPointF origin(1.0, 1.0);
+    item.setTransform(x);
+    item.setPos(pos);
+    item.setRotation(r);
+    item.setScale(s);
+    item.setTransformOriginPoint(origin);
+    QCOMPARE(item.transform(), x);
+    QCOMPARE(item.pos(), pos);
+    QCOMPARE(item.rotation(), r);
+    QCOMPARE(item.scale(), s);
+    QCOMPARE(item.transformOriginPoint(), origin);
+    QCOMPARE(item.changes.size(), 0);
+
+    item.setOpacity(o);
+    QCOMPARE(item.changes.size(), 2); // opacity
+
+    item.setFlag(QGraphicsItem::ItemSendsGeometryChanges);
+    QCOMPARE(item.changes.size(), 4); // flags
+    item.setTransform(QTransform());
+    item.setPos(QPointF());
+    QCOMPARE(item.changes.size(), 8); // transform + pos
+    QCOMPARE(item.transform(), QTransform());
+    QCOMPARE(item.pos(), QPointF());
+    QCOMPARE(item.opacity(), o);
+    item.setRotation(0.0);
+    item.setScale(1.0);
+    item.setTransformOriginPoint(0.0, 0.0);
+    QCOMPARE(item.changes.size(), 14); // rotation + scale + origin
+    QCOMPARE(item.rotation(), qreal(0.0));
+    QCOMPARE(item.scale(), qreal(1.0));
+    QCOMPARE(item.transformOriginPoint(), QPointF(0.0, 0.0));
+
+    QCOMPARE(item.changes, QList<QGraphicsItem::GraphicsItemChange>()
+             << QGraphicsItem::ItemOpacityChange
+             << QGraphicsItem::ItemOpacityHasChanged
+             << QGraphicsItem::ItemFlagsChange
+             << QGraphicsItem::ItemFlagsHaveChanged
+             << QGraphicsItem::ItemTransformChange
+             << QGraphicsItem::ItemTransformHasChanged
+             << QGraphicsItem::ItemPositionChange
+             << QGraphicsItem::ItemPositionHasChanged
+             << QGraphicsItem::ItemRotationChange
+             << QGraphicsItem::ItemRotationHasChanged
+             << QGraphicsItem::ItemScaleChange
+             << QGraphicsItem::ItemScaleHasChanged
+             << QGraphicsItem::ItemTransformOriginPointChange
+             << QGraphicsItem::ItemTransformOriginPointHasChanged);
+}
+
+// Make sure we update moved items correctly.
+void tst_QGraphicsItem::moveItem()
+{
+    QGraphicsScene scene;
+    scene.setSceneRect(-50, -50, 200, 200);
+
+    MyGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(100);
+
+    EventTester *parent = new EventTester;
+    EventTester *child = new EventTester(parent);
+    EventTester *grandChild = new EventTester(child);
+
+#define RESET_COUNTERS \
+    parent->repaints = 0; \
+    child->repaints = 0; \
+    grandChild->repaints = 0; \
+    view.reset();
+
+    scene.addItem(parent);
+    QTest::qWait(100);
+
+    RESET_COUNTERS
+
+    // Item's boundingRect:  (-10, -10, 20, 20).
+    QRect parentDeviceBoundingRect = parent->deviceTransform(view.viewportTransform())
+                                     .mapRect(parent->boundingRect()).toAlignedRect()
+                                     .adjusted(-2, -2, 2, 2); // Adjusted for antialiasing.
+
+    parent->setPos(20, 20);
+    qApp->processEvents();
+    QCOMPARE(parent->repaints, 1);
+    QCOMPARE(view.repaints, 1);
+    QRegion expectedParentRegion = parentDeviceBoundingRect; // old position
+    parentDeviceBoundingRect.translate(20, 20);
+    expectedParentRegion += parentDeviceBoundingRect; // new position
+    COMPARE_REGIONS(view.paintedRegion, expectedParentRegion);
+
+    RESET_COUNTERS
+
+    child->setPos(20, 20);
+    qApp->processEvents();
+    QCOMPARE(parent->repaints, 1);
+    QCOMPARE(child->repaints, 1);
+    QCOMPARE(view.repaints, 1);
+    const QRegion expectedChildRegion = expectedParentRegion.translated(20, 20);
+    COMPARE_REGIONS(view.paintedRegion, expectedChildRegion);
+
+    RESET_COUNTERS
+
+    grandChild->setPos(20, 20);
+    qApp->processEvents();
+    QCOMPARE(parent->repaints, 1);
+    QCOMPARE(child->repaints, 1);
+    QCOMPARE(grandChild->repaints, 1);
+    QCOMPARE(view.repaints, 1);
+    const QRegion expectedGrandChildRegion = expectedParentRegion.translated(40, 40);
+    COMPARE_REGIONS(view.paintedRegion, expectedGrandChildRegion);
+
+    RESET_COUNTERS
+
+    parent->translate(20, 20);
+    qApp->processEvents();
+    QCOMPARE(parent->repaints, 1);
+    QCOMPARE(child->repaints, 1);
+    QCOMPARE(grandChild->repaints, 1);
+    QCOMPARE(view.repaints, 1);
+    expectedParentRegion.translate(20, 20);
+    expectedParentRegion += expectedChildRegion.translated(20, 20);
+    expectedParentRegion += expectedGrandChildRegion.translated(20, 20);
+    COMPARE_REGIONS(view.paintedRegion, expectedParentRegion);
+}
+
+void tst_QGraphicsItem::moveLineItem()
+{
+    QGraphicsScene scene;
+    scene.setSceneRect(0, 0, 200, 200);
+    QGraphicsLineItem *item = new QGraphicsLineItem(0, 0, 100, 0);
+    item->setPos(50, 50);
+    scene.addItem(item);
+
+    MyGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(200);
+    view.reset();
+
+    QRectF brect = item->boundingRect();
+    // Do same adjustments as in qgraphicsscene.cpp
+    if (!brect.width())
+        brect.adjust(qreal(-0.00001), 0, qreal(0.00001), 0);
+    if (!brect.height())
+        brect.adjust(0, qreal(-0.00001), 0, qreal(0.00001));
+    const QRect itemDeviceBoundingRect = item->deviceTransform(view.viewportTransform())
+                                         .mapRect(brect).toAlignedRect();
+    QRegion expectedRegion = itemDeviceBoundingRect.adjusted(-2, -2, 2, 2); // antialiasing
+
+    // Make sure the calculated region is correct.
+    item->update();
+    QTest::qWait(10);
+    QTRY_COMPARE(view.paintedRegion, expectedRegion);
+    view.reset();
+
+    // Old position: (50, 50)
+    item->setPos(50, 100);
+    expectedRegion += expectedRegion.translated(0, 50);
+    QTest::qWait(10);
+    QCOMPARE(view.paintedRegion, expectedRegion);
+}
+
+void tst_QGraphicsItem::sorting_data()
+{
+    QTest::addColumn<int>("index");
+
+    QTest::newRow("NoIndex") << int(QGraphicsScene::NoIndex);
+    QTest::newRow("BspTreeIndex") << int(QGraphicsScene::BspTreeIndex);
+}
+
+void tst_QGraphicsItem::sorting()
+{
+    if (PlatformQuirks::isAutoMaximizing())
+        QSKIP("Skipped because Platform is auto maximizing", SkipAll);
+
+    _paintedItems.clear();
+
+    QGraphicsScene scene;
+    QGraphicsItem *grid[100][100];
+    for (int x = 0; x < 100; ++x) {
+        for (int y = 0; y < 100; ++y) {
+            PainterItem *item = new PainterItem;
+            item->setPos(x * 25, y * 25);
+            item->setData(0, QString("%1x%2").arg(x).arg(y));
+            grid[x][y] = item;
+            scene.addItem(item);
+        }
+    }
+
+    PainterItem *item1 = new PainterItem;
+    PainterItem *item2 = new PainterItem;
+    item1->setData(0, "item1");
+    item2->setData(0, "item2");
+    scene.addItem(item1);
+    scene.addItem(item2);
+
+    QGraphicsView view(&scene);
+    view.setResizeAnchor(QGraphicsView::NoAnchor);
+    view.setTransformationAnchor(QGraphicsView::NoAnchor);
+    view.resize(120, 100);
+    view.setFrameStyle(0);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(100);
+
+    _paintedItems.clear();
+
+    view.viewport()->repaint();
+#if defined(Q_WS_MAC)
+    // There's no difference between repaint and update on the Mac,
+    // so we have to process events here to make sure we get the event.
+    QTest::qWait(100);
+#endif
+
+    QCOMPARE(_paintedItems, QList<QGraphicsItem *>()
+                 << grid[0][0] << grid[0][1] << grid[0][2] << grid[0][3]
+                 << grid[1][0] << grid[1][1] << grid[1][2] << grid[1][3]
+                 << grid[2][0] << grid[2][1] << grid[2][2] << grid[2][3]
+                 << grid[3][0] << grid[3][1] << grid[3][2] << grid[3][3]
+                 << grid[4][0] << grid[4][1] << grid[4][2] << grid[4][3]
+                 << item1 << item2);
+}
+
+void tst_QGraphicsItem::itemHasNoContents()
+{
+    PainterItem *item1 = new PainterItem;
+    PainterItem *item2 = new PainterItem;
+    item2->setParentItem(item1);
+    item2->setPos(50, 50);
+    item1->setFlag(QGraphicsItem::ItemHasNoContents);
+    item1->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+
+    QGraphicsScene scene;
+    scene.addItem(item1);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(!_paintedItems.isEmpty());
+
+    _paintedItems.clear();
+
+    view.viewport()->repaint();
+#ifdef Q_WS_MAC
+    // There's no difference between update() and repaint() on the Mac,
+    // so we have to process events here to make sure we get the event.
+    QTest::qWait(10);
+#endif
+
+    QTRY_COMPARE(_paintedItems, QList<QGraphicsItem *>() << item2);
+}
+
+void tst_QGraphicsItem::hitTestUntransformableItem()
+{
+    QGraphicsScene scene;
+    scene.setSceneRect(-100, -100, 200, 200);
+
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(100);
+
+    // Confuse the BSP with dummy items.
+    QGraphicsRectItem *dummy = new QGraphicsRectItem(0, 0, 20, 20);
+    dummy->setPos(-100, -100);
+    scene.addItem(dummy);
+    for (int i = 0; i < 100; ++i) {
+        QGraphicsItem *parent = dummy;
+        dummy = new QGraphicsRectItem(0, 0, 20, 20);
+        dummy->setPos(-100 + i, -100 + i);
+        dummy->setParentItem(parent);
+    }
+
+    QGraphicsRectItem *item1 = new QGraphicsRectItem(0, 0, 20, 20);
+    item1->setPos(-200, -200);
+
+    QGraphicsRectItem *item2 = new QGraphicsRectItem(0, 0, 20, 20);
+    item2->setFlag(QGraphicsItem::ItemIgnoresTransformations);
+    item2->setParentItem(item1);
+    item2->setPos(200, 200);
+
+    QGraphicsRectItem *item3 = new QGraphicsRectItem(0, 0, 20, 20);
+    item3->setParentItem(item2);
+    item3->setPos(80, 80);
+
+    scene.addItem(item1);
+    QTest::qWait(100);
+
+    QList<QGraphicsItem *> items = scene.items(QPointF(80, 80));
+    QCOMPARE(items.size(), 1);
+    QCOMPARE(items.at(0), static_cast<QGraphicsItem*>(item3));
+
+    scene.setItemIndexMethod(QGraphicsScene::NoIndex);
+    QTest::qWait(100);
+
+    items = scene.items(QPointF(80, 80));
+    QCOMPARE(items.size(), 1);
+    QCOMPARE(items.at(0), static_cast<QGraphicsItem*>(item3));
+}
+
+void tst_QGraphicsItem::hitTestGraphicsEffectItem()
+{
+    QGraphicsScene scene;
+    scene.setSceneRect(-100, -100, 200, 200);
+
+    QWidget toplevel;
+
+    QGraphicsView view(&scene, &toplevel);
+    toplevel.resize(300, 300);
+    toplevel.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&toplevel);
+#endif
+    QTest::qWait(100);
+
+    // Confuse the BSP with dummy items.
+    QGraphicsRectItem *dummy = new QGraphicsRectItem(0, 0, 20, 20);
+    dummy->setPos(-100, -100);
+    scene.addItem(dummy);
+    for (int i = 0; i < 100; ++i) {
+        QGraphicsItem *parent = dummy;
+        dummy = new QGraphicsRectItem(0, 0, 20, 20);
+        dummy->setPos(-100 + i, -100 + i);
+        dummy->setParentItem(parent);
+    }
+
+    const QRectF itemBoundingRect(0, 0, 20, 20);
+    EventTester *item1 = new EventTester;
+    item1->br = itemBoundingRect;
+    item1->setPos(-200, -200);
+    item1->brush = Qt::red;
+
+    EventTester *item2 = new EventTester;
+    item2->br = itemBoundingRect;
+    item2->setFlag(QGraphicsItem::ItemIgnoresTransformations);
+    item2->setParentItem(item1);
+    item2->setPos(200, 200);
+    item2->brush = Qt::green;
+
+    EventTester *item3 = new EventTester;
+    item3->br = itemBoundingRect;
+    item3->setParentItem(item2);
+    item3->setPos(80, 80);
+    item3->brush = Qt::blue;
+
+    scene.addItem(item1);
+    QTest::qWait(100);
+
+    item1->repaints = 0;
+    item2->repaints = 0;
+    item3->repaints = 0;
+
+    // Apply shadow effect to the entire sub-tree.
+    QGraphicsDropShadowEffect *shadow = new QGraphicsDropShadowEffect;
+    shadow->setOffset(-20, -20);
+    item1->setGraphicsEffect(shadow);
+    QTest::qWait(50);
+
+    // Make sure all visible items are repainted.
+    QCOMPARE(item1->repaints, 1);
+    QCOMPARE(item2->repaints, 1);
+    QCOMPARE(item3->repaints, 1);
+
+    // Make sure an item doesn't respond to a click on its shadow.
+    QList<QGraphicsItem *> items = scene.items(QPointF(75, 75));
+    QVERIFY(items.isEmpty());
+    items = scene.items(QPointF(80, 80));
+    QCOMPARE(items.size(), 1);
+    QCOMPARE(items.at(0), static_cast<QGraphicsItem *>(item3));
+
+    scene.setItemIndexMethod(QGraphicsScene::NoIndex);
+    QTest::qWait(100);
+
+    items = scene.items(QPointF(75, 75));
+    QVERIFY(items.isEmpty());
+    items = scene.items(QPointF(80, 80));
+    QCOMPARE(items.size(), 1);
+    QCOMPARE(items.at(0), static_cast<QGraphicsItem *>(item3));
+}
+
+void tst_QGraphicsItem::focusProxy()
+{
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    QGraphicsItem *item = scene.addRect(0, 0, 10, 10);
+    item->setFlag(QGraphicsItem::ItemIsFocusable);
+    QVERIFY(!item->focusProxy());
+
+    QGraphicsItem *item2 = scene.addRect(0, 0, 10, 10);
+    item2->setFlag(QGraphicsItem::ItemIsFocusable);
+    item->setFocusProxy(item2);
+    QCOMPARE(item->focusProxy(), item2);
+
+    item->setFocus();
+    QVERIFY(item->hasFocus());
+    QVERIFY(item2->hasFocus());
+
+    // Try to make a focus chain loop
+    QString err;
+    QTextStream stream(&err);
+    stream << "QGraphicsItem::setFocusProxy: "
+           << (void*)item << " is already in the focus proxy chain" << flush;
+    QTest::ignoreMessage(QtWarningMsg, err.toLatin1().constData());
+    item2->setFocusProxy(item); // fails
+    QCOMPARE(item->focusProxy(), (QGraphicsItem *)item2);
+    QCOMPARE(item2->focusProxy(), (QGraphicsItem *)0);
+
+    // Try to assign self as focus proxy
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsItem::setFocusProxy: cannot assign self as focus proxy");
+    item->setFocusProxy(item); // fails
+    QCOMPARE(item->focusProxy(), (QGraphicsItem *)item2);
+    QCOMPARE(item2->focusProxy(), (QGraphicsItem *)0);
+
+    // Reset the focus proxy
+    item->setFocusProxy(0);
+    QCOMPARE(item->focusProxy(), (QGraphicsItem *)0);
+    QVERIFY(!item->hasFocus());
+    QVERIFY(item2->hasFocus());
+
+    // Test deletion
+    item->setFocusProxy(item2);
+    QCOMPARE(item->focusProxy(), (QGraphicsItem *)item2);
+    delete item2;
+    QCOMPARE(item->focusProxy(), (QGraphicsItem *)0);
+
+    // Test event delivery
+    item2 = scene.addRect(0, 0, 10, 10);
+    item2->setFlag(QGraphicsItem::ItemIsFocusable);
+    item->setFocusProxy(item2);
+    item->clearFocus();
+
+    EventSpy focusInSpy(&scene, item, QEvent::FocusIn);
+    EventSpy focusOutSpy(&scene, item, QEvent::FocusOut);
+    EventSpy focusInSpy2(&scene, item2, QEvent::FocusIn);
+    EventSpy focusOutSpy2(&scene, item2, QEvent::FocusOut);
+    QCOMPARE(focusInSpy.count(), 0);
+    QCOMPARE(focusOutSpy.count(), 0);
+    QCOMPARE(focusInSpy2.count(), 0);
+    QCOMPARE(focusOutSpy2.count(), 0);
+
+    item->setFocus();
+    QCOMPARE(focusInSpy.count(), 0);
+    QCOMPARE(focusInSpy2.count(), 1);
+    item->clearFocus();
+    QCOMPARE(focusOutSpy.count(), 0);
+    QCOMPARE(focusOutSpy2.count(), 1);
+
+    // Test two items proxying one item.
+    QGraphicsItem *item3 = scene.addRect(0, 0, 10, 10);
+    item3->setFlag(QGraphicsItem::ItemIsFocusable);
+    item3->setFocusProxy(item2); // item and item3 use item2 as proxy
+
+    QCOMPARE(item->focusProxy(), item2);
+    QCOMPARE(item2->focusProxy(), (QGraphicsItem *)0);
+    QCOMPARE(item3->focusProxy(), item2);
+    delete item2;
+    QCOMPARE(item->focusProxy(), (QGraphicsItem *)0);
+    QCOMPARE(item3->focusProxy(), (QGraphicsItem *)0);
+}
+
+void tst_QGraphicsItem::subFocus()
+{
+    // Construct a text item that's not part of a scene (yet)
+    // and has no parent. Setting focus on it will not make
+    // the item gain input focus; that requires a scene. But
+    // it does set subfocus, indicating that the item wishes
+    // to gain focus later.
+    QGraphicsTextItem *text = new QGraphicsTextItem("Hello");
+    text->setTextInteractionFlags(Qt::TextEditorInteraction);
+    QVERIFY(!text->hasFocus());
+    text->setFocus();
+    QVERIFY(!text->hasFocus());
+    QCOMPARE(text->focusItem(), (QGraphicsItem *)text);
+
+    // Add a sibling.
+    QGraphicsTextItem *text2 = new QGraphicsTextItem("Hi");
+    text2->setTextInteractionFlags(Qt::TextEditorInteraction);
+    text2->setPos(30, 30);
+
+    // Add both items to a scene and check that it's text that
+    // got input focus.
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    scene.addItem(text);
+    scene.addItem(text2);
+    QVERIFY(text->hasFocus());
+
+    text->setData(0, "text");
+    text2->setData(0, "text2");
+
+    // Remove text2 and set subfocus on it. Then readd. Reparent it onto the
+    // other item and see that it gains input focus.
+    scene.removeItem(text2);
+    text2->setFocus();
+    scene.addItem(text2);
+    QCOMPARE(text2->focusItem(), (QGraphicsItem *)text2);
+    text2->setParentItem(text);
+    QCOMPARE(text->focusItem(), (QGraphicsItem *)text2);
+    QCOMPARE(text2->focusItem(), (QGraphicsItem *)text2);
+    QVERIFY(!text->hasFocus());
+    QVERIFY(text2->hasFocus());
+
+    // Remove both items from the scene, restore subfocus and
+    // readd them. Now the subfocus should kick in and give
+    // text2 focus.
+    scene.removeItem(text);
+    QCOMPARE(text->focusItem(), (QGraphicsItem *)0);
+    QCOMPARE(text2->focusItem(), (QGraphicsItem *)0);
+    text2->setFocus();
+    QCOMPARE(text->focusItem(), (QGraphicsItem *)text2);
+    QCOMPARE(text2->focusItem(), (QGraphicsItem *)text2);
+    scene.addItem(text);
+
+    // Hiding and showing text should pass focus to text2.
+    QCOMPARE(text->focusItem(), (QGraphicsItem *)text2);
+    QVERIFY(text2->hasFocus());
+
+    // Subfocus should repropagate to root when reparenting.
+    QGraphicsRectItem *rect = new QGraphicsRectItem;
+    QGraphicsRectItem *rect2 = new QGraphicsRectItem(rect);
+    QGraphicsRectItem *rect3 = new QGraphicsRectItem(rect2);
+    rect3->setFlag(QGraphicsItem::ItemIsFocusable);
+
+    text->setData(0, "text");
+    text2->setData(0, "text2");
+    rect->setData(0, "rect");
+    rect2->setData(0, "rect2");
+    rect3->setData(0, "rect3");
+
+    rect3->setFocus();
+    QVERIFY(!rect3->hasFocus());
+    QCOMPARE(rect->focusItem(), (QGraphicsItem *)rect3);
+    QCOMPARE(rect2->focusItem(), (QGraphicsItem *)rect3);
+    QCOMPARE(rect3->focusItem(), (QGraphicsItem *)rect3);
+    rect->setParentItem(text2);
+    QCOMPARE(text->focusItem(), (QGraphicsItem *)rect3);
+    QCOMPARE(text2->focusItem(), (QGraphicsItem *)rect3);
+    QCOMPARE(rect->focusItem(), (QGraphicsItem *)rect3);
+    QCOMPARE(rect2->focusItem(), (QGraphicsItem *)rect3);
+    QCOMPARE(rect3->focusItem(), (QGraphicsItem *)rect3);
+    QVERIFY(!rect->hasFocus());
+    QVERIFY(!rect2->hasFocus());
+    QVERIFY(rect3->hasFocus());
+
+    delete rect2;
+    QCOMPARE(text->focusItem(), (QGraphicsItem *)0);
+    QCOMPARE(text2->focusItem(), (QGraphicsItem *)0);
+    QCOMPARE(rect->focusItem(), (QGraphicsItem *)0);
+}
+
+void tst_QGraphicsItem::focusProxyDeletion()
+{
+    QGraphicsRectItem *rect = new QGraphicsRectItem;
+    QGraphicsRectItem *rect2 = new QGraphicsRectItem;
+    rect->setFocusProxy(rect2);
+    QCOMPARE(rect->focusProxy(), (QGraphicsItem *)rect2);
+
+    delete rect2;
+    QCOMPARE(rect->focusProxy(), (QGraphicsItem *)0);
+
+    rect2 = new QGraphicsRectItem;
+    rect->setFocusProxy(rect2);
+    delete rect; // don't crash
+
+    rect = new QGraphicsRectItem;
+    rect->setFocusProxy(rect2);
+    QGraphicsScene *scene = new QGraphicsScene;
+    scene->addItem(rect);
+    scene->addItem(rect2);
+    delete rect2;
+    QCOMPARE(rect->focusProxy(), (QGraphicsItem *)0);
+
+    rect2 = new QGraphicsRectItem;
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsItem::setFocusProxy: focus proxy must be in same scene");
+    rect->setFocusProxy(rect2);
+    QCOMPARE(rect->focusProxy(), (QGraphicsItem *)0);
+    scene->addItem(rect2);
+    rect->setFocusProxy(rect2);
+    QCOMPARE(rect->focusProxy(), (QGraphicsItem *)rect2);
+    delete rect; // don't crash
+
+    rect = new QGraphicsRectItem;
+    rect2 = new QGraphicsRectItem;
+    rect->setFocusProxy(rect2);
+    QCOMPARE(rect->focusProxy(), (QGraphicsItem *)rect2);
+    scene->addItem(rect);
+    scene->addItem(rect2);
+    rect->setFocusProxy(rect2);
+    delete scene; // don't crash
+}
+
+void tst_QGraphicsItem::negativeZStacksBehindParent()
+{
+    QGraphicsRectItem rect;
+    QCOMPARE(rect.zValue(), qreal(0.0));
+    QVERIFY(!(rect.flags() & QGraphicsItem::ItemNegativeZStacksBehindParent));
+    QVERIFY(!(rect.flags() & QGraphicsItem::ItemStacksBehindParent));
+    rect.setZValue(-1);
+    QCOMPARE(rect.zValue(), qreal(-1.0));
+    QVERIFY(!(rect.flags() & QGraphicsItem::ItemStacksBehindParent));
+    rect.setZValue(0);
+    rect.setFlag(QGraphicsItem::ItemNegativeZStacksBehindParent);
+    QVERIFY(rect.flags() & QGraphicsItem::ItemNegativeZStacksBehindParent);
+    QVERIFY(!(rect.flags() & QGraphicsItem::ItemStacksBehindParent));
+    rect.setZValue(-1);
+    QVERIFY(rect.flags() & QGraphicsItem::ItemStacksBehindParent);
+    rect.setZValue(0);
+    QVERIFY(!(rect.flags() & QGraphicsItem::ItemStacksBehindParent));
+    rect.setFlag(QGraphicsItem::ItemNegativeZStacksBehindParent, false);
+    rect.setZValue(-1);
+    rect.setFlag(QGraphicsItem::ItemNegativeZStacksBehindParent, true);
+    QVERIFY(rect.flags() & QGraphicsItem::ItemStacksBehindParent);
+    rect.setFlag(QGraphicsItem::ItemNegativeZStacksBehindParent, false);
+    QVERIFY(rect.flags() & QGraphicsItem::ItemStacksBehindParent);
+}
+
+void tst_QGraphicsItem::setGraphicsEffect()
+{
+    // Check that we don't have any effect by default.
+    QGraphicsItem *item = new QGraphicsRectItem(0, 0, 10, 10);
+    QVERIFY(!item->graphicsEffect());
+
+    // SetGet check.
+    QPointer<QGraphicsEffect> blurEffect = new QGraphicsBlurEffect;
+    item->setGraphicsEffect(blurEffect);
+    QCOMPARE(item->graphicsEffect(), static_cast<QGraphicsEffect *>(blurEffect));
+
+    // Ensure the existing effect is deleted when setting a new one.
+    QPointer<QGraphicsEffect> shadowEffect = new QGraphicsDropShadowEffect;
+    item->setGraphicsEffect(shadowEffect);
+    QVERIFY(!blurEffect);
+    QCOMPARE(item->graphicsEffect(), static_cast<QGraphicsEffect *>(shadowEffect));
+    blurEffect = new QGraphicsBlurEffect;
+
+    // Ensure the effect is uninstalled when setting it on a new target.
+    QGraphicsItem *anotherItem = new QGraphicsRectItem(0, 0, 10, 10);
+    anotherItem->setGraphicsEffect(blurEffect);
+    item->setGraphicsEffect(blurEffect);
+    QVERIFY(!anotherItem->graphicsEffect());
+    QVERIFY(!shadowEffect);
+
+    // Ensure the existing effect is deleted when deleting the item.
+    delete item;
+    QVERIFY(!blurEffect);
+    delete anotherItem;
+
+    // Ensure the effect is uninstalled when deleting it
+    item = new QGraphicsRectItem(0, 0, 10, 10);
+    blurEffect = new QGraphicsBlurEffect;
+    item->setGraphicsEffect(blurEffect);
+    delete blurEffect;
+    QVERIFY(!item->graphicsEffect());
+
+    // Ensure the existing effect is uninstalled and deleted when setting a null effect
+    blurEffect = new QGraphicsBlurEffect;
+    item->setGraphicsEffect(blurEffect);
+    item->setGraphicsEffect(0);
+    QVERIFY(!item->graphicsEffect());
+    QVERIFY(!blurEffect);
+
+    delete item;
+}
+
+void tst_QGraphicsItem::panel()
+{
+    QGraphicsScene scene;
+
+    QGraphicsRectItem *panel1 = new QGraphicsRectItem;
+    QGraphicsRectItem *panel2 = new QGraphicsRectItem;
+    QGraphicsRectItem *panel3 = new QGraphicsRectItem;
+    QGraphicsRectItem *panel4 = new QGraphicsRectItem;
+    QGraphicsRectItem *notPanel1 = new QGraphicsRectItem;
+    QGraphicsRectItem *notPanel2 = new QGraphicsRectItem;
+    panel1->setFlag(QGraphicsItem::ItemIsPanel);
+    panel2->setFlag(QGraphicsItem::ItemIsPanel);
+    panel3->setFlag(QGraphicsItem::ItemIsPanel);
+    panel4->setFlag(QGraphicsItem::ItemIsPanel);
+    scene.addItem(panel1);
+    scene.addItem(panel2);
+    scene.addItem(panel3);
+    scene.addItem(panel4);
+    scene.addItem(notPanel1);
+    scene.addItem(notPanel2);
+
+    EventSpy spy_activate_panel1(&scene, panel1, QEvent::WindowActivate);
+    EventSpy spy_deactivate_panel1(&scene, panel1, QEvent::WindowDeactivate);
+    EventSpy spy_activate_panel2(&scene, panel2, QEvent::WindowActivate);
+    EventSpy spy_deactivate_panel2(&scene, panel2, QEvent::WindowDeactivate);
+    EventSpy spy_activate_panel3(&scene, panel3, QEvent::WindowActivate);
+    EventSpy spy_deactivate_panel3(&scene, panel3, QEvent::WindowDeactivate);
+    EventSpy spy_activate_panel4(&scene, panel4, QEvent::WindowActivate);
+    EventSpy spy_deactivate_panel4(&scene, panel4, QEvent::WindowDeactivate);
+    EventSpy spy_activate_notPanel1(&scene, notPanel1, QEvent::WindowActivate);
+    EventSpy spy_deactivate_notPanel1(&scene, notPanel1, QEvent::WindowDeactivate);
+    EventSpy spy_activate_notPanel2(&scene, notPanel1, QEvent::WindowActivate);
+    EventSpy spy_deactivate_notPanel2(&scene, notPanel1, QEvent::WindowDeactivate);
+
+    QCOMPARE(spy_activate_panel1.count(), 0);
+    QCOMPARE(spy_deactivate_panel1.count(), 0);
+    QCOMPARE(spy_activate_panel2.count(), 0);
+    QCOMPARE(spy_deactivate_panel2.count(), 0);
+    QCOMPARE(spy_activate_panel3.count(), 0);
+    QCOMPARE(spy_deactivate_panel3.count(), 0);
+    QCOMPARE(spy_activate_panel4.count(), 0);
+    QCOMPARE(spy_deactivate_panel4.count(), 0);
+    QCOMPARE(spy_activate_notPanel1.count(), 0);
+    QCOMPARE(spy_deactivate_notPanel1.count(), 0);
+    QCOMPARE(spy_activate_notPanel2.count(), 0);
+    QCOMPARE(spy_deactivate_notPanel2.count(), 0);
+
+    QVERIFY(!scene.activePanel());
+    QVERIFY(!scene.isActive());
+
+    QEvent activate(QEvent::WindowActivate);
+    QEvent deactivate(QEvent::WindowDeactivate);
+
+    QApplication::sendEvent(&scene, &activate);
+
+    // No previous activation, so the scene is active.
+    QVERIFY(scene.isActive());
+    QCOMPARE(scene.activePanel(), (QGraphicsItem *)panel1);
+    QVERIFY(panel1->isActive());
+    QVERIFY(!panel2->isActive());
+    QVERIFY(!panel3->isActive());
+    QVERIFY(!panel4->isActive());
+    QVERIFY(!notPanel1->isActive());
+    QVERIFY(!notPanel2->isActive());
+    QCOMPARE(spy_deactivate_notPanel1.count(), 0);
+    QCOMPARE(spy_deactivate_notPanel2.count(), 0);
+    QCOMPARE(spy_activate_panel1.count(), 1);
+    QCOMPARE(spy_activate_panel2.count(), 0);
+    QCOMPARE(spy_activate_panel3.count(), 0);
+    QCOMPARE(spy_activate_panel4.count(), 0);
+
+    // Switch back to scene.
+    scene.setActivePanel(0);
+    QVERIFY(!scene.activePanel());
+    QVERIFY(!panel1->isActive());
+    QVERIFY(!panel2->isActive());
+    QVERIFY(!panel3->isActive());
+    QVERIFY(!panel4->isActive());
+    QVERIFY(notPanel1->isActive());
+    QVERIFY(notPanel2->isActive());
+    QCOMPARE(spy_activate_notPanel1.count(), 1);
+    QCOMPARE(spy_activate_notPanel2.count(), 1);
+
+    // Deactivate the scene
+    QApplication::sendEvent(&scene, &deactivate);
+    QVERIFY(!scene.activePanel());
+    QVERIFY(!panel1->isActive());
+    QVERIFY(!panel2->isActive());
+    QVERIFY(!panel3->isActive());
+    QVERIFY(!panel4->isActive());
+    QVERIFY(!notPanel1->isActive());
+    QVERIFY(!notPanel2->isActive());
+    QCOMPARE(spy_deactivate_notPanel1.count(), 1);
+    QCOMPARE(spy_deactivate_notPanel2.count(), 1);
+
+    // Reactivate the scene
+    QApplication::sendEvent(&scene, &activate);
+    QVERIFY(!scene.activePanel());
+    QVERIFY(!panel1->isActive());
+    QVERIFY(!panel2->isActive());
+    QVERIFY(!panel3->isActive());
+    QVERIFY(!panel4->isActive());
+    QVERIFY(notPanel1->isActive());
+    QVERIFY(notPanel2->isActive());
+    QCOMPARE(spy_activate_notPanel1.count(), 2);
+    QCOMPARE(spy_activate_notPanel2.count(), 2);
+
+    // Switch to panel1
+    scene.setActivePanel(panel1);
+    QVERIFY(panel1->isActive());
+    QCOMPARE(spy_deactivate_notPanel1.count(), 2);
+    QCOMPARE(spy_deactivate_notPanel2.count(), 2);
+    QCOMPARE(spy_activate_panel1.count(), 2);
+
+    // Deactivate the scene
+    QApplication::sendEvent(&scene, &deactivate);
+    QVERIFY(!panel1->isActive());
+    QCOMPARE(spy_deactivate_panel1.count(), 2);
+
+    // Reactivate the scene
+    QApplication::sendEvent(&scene, &activate);
+    QVERIFY(panel1->isActive());
+    QCOMPARE(spy_activate_panel1.count(), 3);
+
+    // Deactivate the scene
+    QApplication::sendEvent(&scene, &deactivate);
+    QVERIFY(!panel1->isActive());
+    QVERIFY(!scene.activePanel());
+    scene.setActivePanel(0);
+
+    // Reactivate the scene
+    QApplication::sendEvent(&scene, &activate);
+    QVERIFY(!panel1->isActive());
+}
+
+void tst_QGraphicsItem::panelWithFocusItem()
+{
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    QGraphicsRectItem *parentPanel = new QGraphicsRectItem;
+    QGraphicsRectItem *parentPanelFocusItem = new QGraphicsRectItem(parentPanel);
+    parentPanel->setFlag(QGraphicsItem::ItemIsPanel);
+    parentPanelFocusItem->setFlag(QGraphicsItem::ItemIsFocusable);
+    parentPanelFocusItem->setFocus();
+    scene.addItem(parentPanel);
+
+    QVERIFY(parentPanel->isActive());
+    QVERIFY(parentPanelFocusItem->hasFocus());
+    QCOMPARE(parentPanel->focusItem(), (QGraphicsItem *)parentPanelFocusItem);
+    QCOMPARE(parentPanelFocusItem->focusItem(), (QGraphicsItem *)parentPanelFocusItem);
+
+    QGraphicsRectItem *childPanel = new QGraphicsRectItem;
+    QGraphicsRectItem *childPanelFocusItem = new QGraphicsRectItem(childPanel);
+    childPanel->setFlag(QGraphicsItem::ItemIsPanel);
+    childPanelFocusItem->setFlag(QGraphicsItem::ItemIsFocusable);
+    childPanelFocusItem->setFocus();
+
+    QVERIFY(!childPanelFocusItem->hasFocus());
+    QCOMPARE(childPanel->focusItem(), (QGraphicsItem *)childPanelFocusItem);
+    QCOMPARE(childPanelFocusItem->focusItem(), (QGraphicsItem *)childPanelFocusItem);
+
+    childPanel->setParentItem(parentPanel);
+
+    QVERIFY(!parentPanel->isActive());
+    QVERIFY(!parentPanelFocusItem->hasFocus());
+    QCOMPARE(parentPanel->focusItem(), (QGraphicsItem *)parentPanelFocusItem);
+    QCOMPARE(parentPanelFocusItem->focusItem(), (QGraphicsItem *)parentPanelFocusItem);
+
+    QVERIFY(childPanel->isActive());
+    QVERIFY(childPanelFocusItem->hasFocus());
+    QCOMPARE(childPanel->focusItem(), (QGraphicsItem *)childPanelFocusItem);
+    QCOMPARE(childPanelFocusItem->focusItem(), (QGraphicsItem *)childPanelFocusItem);
+
+    childPanel->hide();
+
+    QVERIFY(parentPanel->isActive());
+    QVERIFY(parentPanelFocusItem->hasFocus());
+    QCOMPARE(parentPanel->focusItem(), (QGraphicsItem *)parentPanelFocusItem);
+    QCOMPARE(parentPanelFocusItem->focusItem(), (QGraphicsItem *)parentPanelFocusItem);
+}
+
+void tst_QGraphicsItem::addPanelToActiveScene()
+{
+    QGraphicsScene scene;
+    QVERIFY(!scene.isActive());
+
+    QGraphicsRectItem *rect = new QGraphicsRectItem;
+    scene.addItem(rect);
+    QVERIFY(!rect->isActive());
+    scene.removeItem(rect);
+
+    QEvent activate(QEvent::WindowActivate);
+    QEvent deactivate(QEvent::WindowDeactivate);
+
+    QApplication::sendEvent(&scene, &activate);
+    QVERIFY(scene.isActive());
+    scene.addItem(rect);
+    QVERIFY(rect->isActive());
+    scene.removeItem(rect);
+
+    rect->setFlag(QGraphicsItem::ItemIsPanel);
+    scene.addItem(rect);
+    QVERIFY(rect->isActive());
+    QCOMPARE(scene.activePanel(), (QGraphicsItem *)rect);
+
+    QGraphicsRectItem *rect2 = new QGraphicsRectItem;
+    scene.addItem(rect2);
+    QVERIFY(rect->isActive());
+    QCOMPARE(scene.activePanel(), (QGraphicsItem *)rect);
+}
+
+void tst_QGraphicsItem::activate()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *rect = scene.addRect(-10, -10, 20, 20);
+    QVERIFY(!rect->isActive());
+
+    QEvent activate(QEvent::WindowActivate);
+    QEvent deactivate(QEvent::WindowDeactivate);
+
+    QApplication::sendEvent(&scene, &activate);
+
+    // Non-panel item (active when scene is active).
+    QVERIFY(rect->isActive());
+
+    QGraphicsRectItem *rect2 = new QGraphicsRectItem;
+    rect2->setFlag(QGraphicsItem::ItemIsPanel);
+    QGraphicsRectItem *rect3 = new QGraphicsRectItem;
+    rect3->setFlag(QGraphicsItem::ItemIsPanel);
+
+    // Test normal activation.
+    QVERIFY(!rect2->isActive());
+    scene.addItem(rect2);
+    QVERIFY(rect2->isActive()); // first panel item is activated
+    scene.addItem(rect3);
+    QVERIFY(!rect3->isActive()); // second panel item is _not_ activated
+    rect3->setActive(true);
+    QVERIFY(rect3->isActive());
+    scene.removeItem(rect3);
+    QVERIFY(!rect3->isActive()); // no panel is active anymore
+    QCOMPARE(scene.activePanel(), (QGraphicsItem *)0);
+    scene.addItem(rect3);
+    QVERIFY(rect3->isActive()); // second panel item is activated
+
+    // Test pending activation.
+    scene.removeItem(rect3);
+    rect2->setActive(true);
+    QVERIFY(rect2->isActive()); // first panel item is activated
+    rect3->setActive(true);
+    QVERIFY(!rect3->isActive()); // not active (yet)
+    scene.addItem(rect3);
+    QVERIFY(rect3->isActive()); // now becomes active
+
+    // Test pending deactivation.
+    scene.removeItem(rect3);
+    rect3->setActive(false);
+    scene.addItem(rect3);
+    QVERIFY(!rect3->isActive()); // doesn't become active
+
+    // Child of panel activation.
+    rect3->setActive(true);
+    QGraphicsRectItem *rect4 = new QGraphicsRectItem;
+    rect4->setFlag(QGraphicsItem::ItemIsPanel);
+    QGraphicsRectItem *rect5 = new QGraphicsRectItem(rect4);
+    QGraphicsRectItem *rect6 = new QGraphicsRectItem(rect5);
+    scene.addItem(rect4);
+    QCOMPARE(scene.activePanel(), (QGraphicsItem *)rect3);
+    scene.removeItem(rect4);
+    rect6->setActive(true);
+    scene.addItem(rect4);
+    QVERIFY(rect4->isActive());
+    QVERIFY(rect5->isActive());
+    QVERIFY(rect6->isActive());
+    QCOMPARE(scene.activePanel(), (QGraphicsItem *)rect4);
+    scene.removeItem(rect4); // no active panel
+    rect6->setActive(false);
+    scene.addItem(rect4);
+    QVERIFY(!rect4->isActive());
+    QVERIFY(!rect5->isActive());
+    QVERIFY(!rect6->isActive());
+    QCOMPARE(scene.activePanel(), (QGraphicsItem *)0);
+
+    // Controlling auto-activation when the scene changes activation.
+    rect4->setActive(true);
+    QApplication::sendEvent(&scene, &deactivate);
+    QVERIFY(!scene.isActive());
+    QVERIFY(!rect4->isActive());
+    rect4->setActive(false);
+    QApplication::sendEvent(&scene, &activate);
+    QVERIFY(scene.isActive());
+    QVERIFY(!scene.activePanel());
+    QVERIFY(!rect4->isActive());
+}
+
+void tst_QGraphicsItem::setActivePanelOnInactiveScene()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *item = scene.addRect(QRectF());
+    QGraphicsRectItem *panel = scene.addRect(QRectF());
+    panel->setFlag(QGraphicsItem::ItemIsPanel);
+
+    EventSpy itemActivateSpy(&scene, item, QEvent::WindowActivate);
+    EventSpy itemDeactivateSpy(&scene, item, QEvent::WindowDeactivate);
+    EventSpy panelActivateSpy(&scene, panel, QEvent::WindowActivate);
+    EventSpy panelDeactivateSpy(&scene, panel, QEvent::WindowDeactivate);
+    EventSpy sceneActivationChangeSpy(&scene, QEvent::ActivationChange);
+
+    scene.setActivePanel(panel);
+    QCOMPARE(scene.activePanel(), (QGraphicsItem *)0);
+    QCOMPARE(itemActivateSpy.count(), 0);
+    QCOMPARE(itemDeactivateSpy.count(), 0);
+    QCOMPARE(panelActivateSpy.count(), 0);
+    QCOMPARE(panelDeactivateSpy.count(), 0);
+    QCOMPARE(sceneActivationChangeSpy.count(), 0);
+}
+
+void tst_QGraphicsItem::activationOnShowHide()
+{
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    QGraphicsRectItem *rootPanel = scene.addRect(QRectF());
+    rootPanel->setFlag(QGraphicsItem::ItemIsPanel);
+    rootPanel->setActive(true);
+
+    QGraphicsRectItem *subPanel = new QGraphicsRectItem;
+    subPanel->setFlag(QGraphicsItem::ItemIsPanel);
+
+    // Reparenting onto an active panel auto-activates the child panel.
+    subPanel->setParentItem(rootPanel);
+    QVERIFY(subPanel->isActive());
+    QVERIFY(!rootPanel->isActive());
+
+    // Hiding an active child panel will reactivate the parent panel.
+    subPanel->hide();
+    QVERIFY(rootPanel->isActive());
+
+    // Showing a child panel will auto-activate it.
+    subPanel->show();
+    QVERIFY(subPanel->isActive());
+    QVERIFY(!rootPanel->isActive());
+
+    // Adding an unrelated panel doesn't affect activation.
+    QGraphicsRectItem *otherPanel = new QGraphicsRectItem;
+    otherPanel->setFlag(QGraphicsItem::ItemIsPanel);
+    scene.addItem(otherPanel);
+    QVERIFY(subPanel->isActive());
+
+    // Showing an unrelated panel doesn't affect activation.
+    otherPanel->hide();
+    otherPanel->show();
+    QVERIFY(subPanel->isActive());
+
+    // Add a non-panel item.
+    QGraphicsRectItem *otherItem = new QGraphicsRectItem;
+    scene.addItem(otherItem);
+    otherItem->setActive(true);
+    QVERIFY(otherItem->isActive());
+
+    // Reparent a panel onto an active non-panel item.
+    subPanel->setParentItem(otherItem);
+    QVERIFY(subPanel->isActive());
+
+    // Showing a child panel of a non-panel item will activate it.
+    subPanel->hide();
+    QVERIFY(!subPanel->isActive());
+    QVERIFY(otherItem->isActive());
+    subPanel->show();
+    QVERIFY(subPanel->isActive());
+
+    // Hiding a toplevel active panel will pass activation back
+    // to the non-panel items.
+    rootPanel->setActive(true);
+    rootPanel->hide();
+    QVERIFY(!rootPanel->isActive());
+    QVERIFY(otherItem->isActive());
+}
+
+class MoveWhileDying : public QGraphicsRectItem
+{
+public:
+    MoveWhileDying(QGraphicsItem *parent = 0)
+        : QGraphicsRectItem(parent)
+    { }
+    ~MoveWhileDying()
+    {
+        foreach (QGraphicsItem *c, childItems()) {
+            foreach (QGraphicsItem *cc, c->childItems()) {
+                cc->moveBy(10, 10);
+            }
+            c->moveBy(10, 10);
+        }
+        if (QGraphicsItem *p = parentItem()) { p->moveBy(10, 10); }
+    }
+};
+
+void tst_QGraphicsItem::moveWhileDeleting()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *rect = new QGraphicsRectItem;
+    MoveWhileDying *silly = new MoveWhileDying(rect);
+    QGraphicsRectItem *child = new QGraphicsRectItem(silly);
+    scene.addItem(rect);
+    delete rect; // don't crash!
+
+    rect = new QGraphicsRectItem;
+    silly = new MoveWhileDying(rect);
+    child = new QGraphicsRectItem(silly);
+
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(125);
+
+    delete rect;
+
+    rect = new QGraphicsRectItem;
+    rect->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    silly = new MoveWhileDying(rect);
+    child = new QGraphicsRectItem(silly);
+
+    QTest::qWait(125);
+
+    delete rect;
+
+    rect = new MoveWhileDying;
+    rect->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    child = new QGraphicsRectItem(rect);
+    silly = new MoveWhileDying(child);
+
+    QTest::qWait(125);
+
+    delete rect;
+}
+
+class MyRectItem : public QGraphicsWidget
+{
+    Q_OBJECT
+public:
+    MyRectItem(QGraphicsItem *parent = 0) : QGraphicsWidget(parent)
+    {
+
+    }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+    {
+        painter->setBrush(brush);
+        painter->drawRect(boundingRect());
+    }
+    void move()
+    {
+        setPos(-100,-100);
+        topLevel->collidingItems(Qt::IntersectsItemBoundingRect);
+    }
+public:
+    QGraphicsItem *topLevel;
+    QBrush brush;
+};
+
+
+void tst_QGraphicsItem::ensureDirtySceneTransform()
+{
+    QGraphicsScene scene;
+
+    MyRectItem *topLevel = new MyRectItem;
+    topLevel->setGeometry(0, 0, 100, 100);
+    topLevel->setPos(-50, -50);
+    topLevel->brush = QBrush(QColor(Qt::black));
+    scene.addItem(topLevel);
+
+    MyRectItem *parent = new MyRectItem;
+    parent->topLevel = topLevel;
+    parent->setGeometry(0, 0, 100, 100);
+    parent->setPos(0, 0);
+    parent->brush = QBrush(QColor(Qt::magenta));
+    parent->setObjectName("parent");
+    scene.addItem(parent);
+
+    MyRectItem *child = new MyRectItem(parent);
+    child->setGeometry(0, 0, 80, 80);
+    child->setPos(10, 10);
+    child->setObjectName("child");
+    child->brush = QBrush(QColor(Qt::blue));
+
+    MyRectItem *child2 = new MyRectItem(parent);
+    child2->setGeometry(0, 0, 80, 80);
+    child2->setPos(15, 15);
+    child2->setObjectName("child2");
+    child2->brush = QBrush(QColor(Qt::green));
+
+    MyRectItem *child3 = new MyRectItem(parent);
+    child3->setGeometry(0, 0, 80, 80);
+    child3->setPos(20, 20);
+    child3->setObjectName("child3");
+    child3->brush = QBrush(QColor(Qt::gray));
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&view));
+
+    //We move the parent
+    parent->move();
+    QApplication::processEvents();
+
+    //We check if all items moved
+    QCOMPARE(child->pos(), QPointF(10, 10));
+    QCOMPARE(child2->pos(), QPointF(15, 15));
+    QCOMPARE(child3->pos(), QPointF(20, 20));
+
+    QCOMPARE(child->sceneBoundingRect(), QRectF(-90, -90, 80, 80));
+    QCOMPARE(child2->sceneBoundingRect(), QRectF(-85, -85, 80, 80));
+    QCOMPARE(child3->sceneBoundingRect(), QRectF(-80, -80, 80, 80));
+
+    QCOMPARE(child->sceneTransform(), QTransform::fromTranslate(-90, -90));
+    QCOMPARE(child2->sceneTransform(), QTransform::fromTranslate(-85, -85));
+    QCOMPARE(child3->sceneTransform(), QTransform::fromTranslate(-80, -80));
+}
+
+void tst_QGraphicsItem::focusScope()
+{
+    // ItemIsFocusScope is an internal feature (for now).
+    QGraphicsScene scene;
+
+    QGraphicsRectItem *scope3 = new QGraphicsRectItem;
+    scope3->setData(0, "scope3");
+    scope3->setFlags(QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemIsFocusScope);
+    scope3->setFocus();
+    QVERIFY(!scope3->focusScopeItem());
+    QCOMPARE(scope3->focusItem(), (QGraphicsItem *)scope3);
+
+    QGraphicsRectItem *scope2 = new QGraphicsRectItem;
+    scope2->setData(0, "scope2");
+    scope2->setFlags(QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemIsFocusScope);
+    scope2->setFocus();
+    QVERIFY(!scope2->focusScopeItem());
+    scope3->setParentItem(scope2);
+    QCOMPARE(scope2->focusScopeItem(), (QGraphicsItem *)scope3);
+    QCOMPARE(scope2->focusItem(), (QGraphicsItem *)scope3);
+
+    QGraphicsRectItem *scope1 = new QGraphicsRectItem;
+    scope1->setData(0, "scope1");
+    scope1->setFlags(QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemIsFocusScope);
+    scope1->setFocus();
+    QVERIFY(!scope1->focusScopeItem());
+    scope2->setParentItem(scope1);
+
+    QCOMPARE(scope1->focusItem(), (QGraphicsItem *)scope3);
+    QCOMPARE(scope2->focusItem(), (QGraphicsItem *)scope3);
+    QCOMPARE(scope3->focusItem(), (QGraphicsItem *)scope3);
+    QCOMPARE(scope1->focusScopeItem(), (QGraphicsItem *)scope2);
+    QCOMPARE(scope2->focusScopeItem(), (QGraphicsItem *)scope3);
+    QCOMPARE(scope3->focusScopeItem(), (QGraphicsItem *)0);
+
+    scene.addItem(scope1);
+
+    QEvent windowActivate(QEvent::WindowActivate);
+    qApp->sendEvent(&scene, &windowActivate);
+    scene.setFocus();
+
+    QCOMPARE(scope1->focusItem(), (QGraphicsItem *)scope3);
+    QCOMPARE(scope2->focusItem(), (QGraphicsItem *)scope3);
+    QCOMPARE(scope3->focusItem(), (QGraphicsItem *)scope3);
+    QCOMPARE(scope1->focusScopeItem(), (QGraphicsItem *)scope2);
+    QCOMPARE(scope2->focusScopeItem(), (QGraphicsItem *)scope3);
+    QCOMPARE(scope3->focusScopeItem(), (QGraphicsItem *)0);
+
+    QVERIFY(scope3->hasFocus());
+
+    scope3->hide();
+    QVERIFY(scope2->hasFocus());
+    scope2->hide();
+    QVERIFY(scope1->hasFocus());
+    scope2->show();
+    QVERIFY(scope2->hasFocus());
+    scope3->show();
+    QVERIFY(scope3->hasFocus());
+    scope1->hide();
+    QVERIFY(!scope3->hasFocus());
+    scope1->show();
+    QVERIFY(scope3->hasFocus());
+    scope3->clearFocus();
+    QVERIFY(scope2->hasFocus());
+    scope2->clearFocus();
+    QVERIFY(scope1->hasFocus());
+    scope2->hide();
+    scope2->show();
+    QVERIFY(!scope2->hasFocus());
+    QVERIFY(scope1->hasFocus());
+    scope2->setFocus();
+    QVERIFY(scope2->hasFocus());
+    scope3->setFocus();
+    QVERIFY(scope3->hasFocus());
+
+    QGraphicsRectItem *rect4 = new QGraphicsRectItem;
+    rect4->setData(0, "rect4");
+    rect4->setParentItem(scope3);
+
+    QGraphicsRectItem *rect5 = new QGraphicsRectItem;
+    rect5->setData(0, "rect5");
+    rect5->setFlags(QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemIsFocusScope);
+    rect5->setFocus();
+    rect5->setParentItem(rect4);
+    QCOMPARE(scope3->focusScopeItem(), (QGraphicsItem *)rect5);
+    QVERIFY(rect5->hasFocus());
+
+    rect4->setParentItem(0);
+    QVERIFY(rect5->hasFocus());
+    QCOMPARE(scope3->focusScopeItem(), (QGraphicsItem *)0);
+    QCOMPARE(scope3->focusItem(), (QGraphicsItem *)0);
+    QVERIFY(!scope3->hasFocus());
+
+    QGraphicsRectItem *rectA = new QGraphicsRectItem;
+    QGraphicsRectItem *scopeA = new QGraphicsRectItem(rectA);
+    scopeA->setFlags(QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemIsFocusScope);
+    scopeA->setFocus();
+    QGraphicsRectItem *scopeB = new QGraphicsRectItem(scopeA);
+    scopeB->setFlags(QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemIsFocusScope);
+    scopeB->setFocus();
+
+    scene.addItem(rectA);
+    QVERIFY(rect5->hasFocus());
+    QVERIFY(!scopeB->hasFocus());
+
+    scopeA->setFocus();
+    QVERIFY(scopeB->hasFocus());
+    QCOMPARE(scopeB->focusItem(), (QGraphicsItem *)scopeB);
+}
+
+void tst_QGraphicsItem::focusScope2()
+{
+    QGraphicsRectItem *child1 = new QGraphicsRectItem;
+    child1->setFlags(QGraphicsItem::ItemIsFocusable);
+    child1->setFocus();
+    QCOMPARE(child1->focusItem(), (QGraphicsItem *)child1);
+
+    QGraphicsRectItem *child2 = new QGraphicsRectItem;
+    child2->setFlags(QGraphicsItem::ItemIsFocusable);
+
+    QGraphicsRectItem *rootFocusScope = new QGraphicsRectItem;
+    rootFocusScope->setFlags(QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemIsFocusScope);
+    rootFocusScope->setFocus();
+    QCOMPARE(rootFocusScope->focusItem(), (QGraphicsItem *)rootFocusScope);
+
+    child1->setParentItem(rootFocusScope);
+    child2->setParentItem(rootFocusScope);
+
+    QCOMPARE(rootFocusScope->focusScopeItem(), (QGraphicsItem *)child1);
+    QCOMPARE(rootFocusScope->focusItem(), (QGraphicsItem *)child1);
+
+    QGraphicsRectItem *siblingChild1 = new QGraphicsRectItem;
+    siblingChild1->setFlags(QGraphicsItem::ItemIsFocusable);
+    siblingChild1->setFocus();
+
+    QGraphicsRectItem *siblingChild2 = new QGraphicsRectItem;
+    siblingChild2->setFlags(QGraphicsItem::ItemIsFocusable);
+
+    QGraphicsRectItem *siblingFocusScope = new QGraphicsRectItem;
+    siblingFocusScope->setFlags(QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemIsFocusScope);
+
+    siblingChild1->setParentItem(siblingFocusScope);
+    siblingChild2->setParentItem(siblingFocusScope);
+
+    QCOMPARE(siblingFocusScope->focusScopeItem(), (QGraphicsItem *)siblingChild1);
+    QCOMPARE(siblingFocusScope->focusItem(), (QGraphicsItem *)0);
+
+    QGraphicsItem *root = new QGraphicsRectItem;
+    rootFocusScope->setParentItem(root);
+    siblingFocusScope->setParentItem(root);
+
+    QCOMPARE(root->focusItem(), (QGraphicsItem *)child1);
+
+    QGraphicsScene scene;
+    scene.addItem(root);
+
+    QEvent activate(QEvent::WindowActivate);
+    qApp->sendEvent(&scene, &activate);
+    scene.setFocus();
+
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *)child1);
+
+    // You cannot set focus on a descendant of a focus scope directly;
+    // this will only change the scope's focus scope item pointer. If
+    // you want to give true input focus, you must set it directly on
+    // the scope itself
+    siblingChild2->setFocus();
+    QVERIFY(!siblingChild2->hasFocus());
+    QVERIFY(!siblingChild2->focusItem());
+    QCOMPARE(siblingFocusScope->focusScopeItem(), (QGraphicsItem *)siblingChild2);
+    QCOMPARE(siblingFocusScope->focusItem(), (QGraphicsItem *)0);
+
+    // Set focus on the scope; focus is forwarded to the focus scope item.
+    siblingFocusScope->setFocus();
+    QVERIFY(siblingChild2->hasFocus());
+    QVERIFY(siblingChild2->focusItem());
+    QCOMPARE(siblingFocusScope->focusScopeItem(), (QGraphicsItem *)siblingChild2);
+    QCOMPARE(siblingFocusScope->focusItem(), (QGraphicsItem *)siblingChild2);
+}
+
+void tst_QGraphicsItem::stackBefore()
+{
+    QGraphicsRectItem parent;
+    QGraphicsRectItem *child1 = new QGraphicsRectItem(QRectF(0, 0, 5, 5), &parent);
+    QGraphicsRectItem *child2 = new QGraphicsRectItem(QRectF(0, 0, 5, 5), &parent);
+    QGraphicsRectItem *child3 = new QGraphicsRectItem(QRectF(0, 0, 5, 5), &parent);
+    QGraphicsRectItem *child4 = new QGraphicsRectItem(QRectF(0, 0, 5, 5), &parent);
+    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child1 << child2 << child3 << child4));
+    child1->setData(0, "child1");
+    child2->setData(0, "child2");
+    child3->setData(0, "child3");
+    child4->setData(0, "child4");
+
+    // Remove and append
+    child2->setParentItem(0);
+    child2->setParentItem(&parent);
+    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child1 << child3 << child4 << child2));
+
+    // Move child2 before child1
+    child2->stackBefore(child1); // 2134
+    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child2 << child1 << child3 << child4));
+    child2->stackBefore(child2); // 2134
+    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child2 << child1 << child3 << child4));
+    child1->setZValue(1); // 2341
+    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child2 << child3 << child4 << child1));
+    child1->stackBefore(child2); // 2341
+    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child2 << child3 << child4 << child1));
+    child1->setZValue(0); // 1234
+    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child1 << child2 << child3 << child4));
+    child4->stackBefore(child1); // 4123
+    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child4 << child1 << child2 << child3));
+    child4->setZValue(1); // 1234 (4123)
+    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child1 << child2 << child3 << child4));
+    child3->stackBefore(child1); // 3124 (4312)
+    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child3 << child1 << child2 << child4));
+    child4->setZValue(0); // 4312
+    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child4 << child3 << child1 << child2));
+
+    // Make them all toplevels
+    child1->setParentItem(0);
+    child2->setParentItem(0);
+    child3->setParentItem(0);
+    child4->setParentItem(0);
+
+    QGraphicsScene scene;
+    scene.addItem(child1);
+    scene.addItem(child2);
+    scene.addItem(child3);
+    scene.addItem(child4);
+    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder),
+             (QList<QGraphicsItem *>() << child1 << child2 << child3 << child4));
+
+    // Remove and append
+    scene.removeItem(child2);
+    scene.addItem(child2);
+    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child1 << child3 << child4 << child2));
+
+    // Move child2 before child1
+    child2->stackBefore(child1); // 2134
+    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child2 << child1 << child3 << child4));
+    child2->stackBefore(child2); // 2134
+    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child2 << child1 << child3 << child4));
+    child1->setZValue(1); // 2341
+    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child2 << child3 << child4 << child1));
+    child1->stackBefore(child2); // 2341
+    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child2 << child3 << child4 << child1));
+    child1->setZValue(0); // 1234
+    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child1 << child2 << child3 << child4));
+    child4->stackBefore(child1); // 4123
+    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child4 << child1 << child2 << child3));
+    child4->setZValue(1); // 1234 (4123)
+    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child1 << child2 << child3 << child4));
+    child3->stackBefore(child1); // 3124 (4312)
+    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child3 << child1 << child2 << child4));
+    child4->setZValue(0); // 4312
+    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child4 << child3 << child1 << child2));
+}
+
+void tst_QGraphicsItem::QTBUG_4233_updateCachedWithSceneRect()
+{
+    EventTester *tester = new EventTester;
+    tester->setCacheMode(QGraphicsItem::ItemCoordinateCache);
+
+    QGraphicsScene scene;
+    scene.addItem(tester);
+    scene.setSceneRect(-100, -100, 200, 200); // contains the tester item
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget *)&view);
+
+    QTRY_COMPARE(tester->repaints, 1);
+
+    scene.update(); // triggers "updateAll" optimization
+    qApp->processEvents();
+    qApp->processEvents(); // in 4.6 only one processEvents is necessary
+
+    QCOMPARE(tester->repaints, 1);
+
+    scene.update(); // triggers "updateAll" optimization
+    tester->update();
+    qApp->processEvents();
+    qApp->processEvents(); // in 4.6 only one processEvents is necessary
+
+    QCOMPARE(tester->repaints, 2);
+}
+
+void tst_QGraphicsItem::sceneModality()
+{
+    // 1) Test mouse events (delivery/propagation/redirection)
+    // 2) Test hover events (incl. leave on block, enter on unblock)
+    // 3) Test cursor stuff (incl. unset on block, set on unblock)
+    // 4) Test clickfocus
+    // 5) Test grab/ungrab events (possibly ungrab on block, regrab on unblock)
+    // 6) ### modality for non-panels is unsupported for now
+    QGraphicsScene scene;
+
+    QGraphicsRectItem *bottomItem = scene.addRect(-150, -100, 300, 200);
+    bottomItem->setFlag(QGraphicsItem::ItemIsFocusable);
+    bottomItem->setBrush(Qt::yellow);
+
+    QGraphicsRectItem *leftParent = scene.addRect(-50, -50, 100, 100);
+    leftParent->setFlag(QGraphicsItem::ItemIsPanel);
+    leftParent->setBrush(Qt::blue);
+
+    QGraphicsRectItem *leftChild = scene.addRect(-25, -25, 50, 50);
+    leftChild->setFlag(QGraphicsItem::ItemIsPanel);
+    leftChild->setBrush(Qt::green);
+    leftChild->setParentItem(leftParent);
+
+    QGraphicsRectItem *rightParent = scene.addRect(-50, -50, 100, 100);
+    rightParent->setFlag(QGraphicsItem::ItemIsPanel);
+    rightParent->setBrush(Qt::red);
+    QGraphicsRectItem *rightChild = scene.addRect(-25, -25, 50, 50);
+    rightChild->setFlag(QGraphicsItem::ItemIsPanel);
+    rightChild->setBrush(Qt::gray);
+    rightChild->setParentItem(rightParent);
+
+    leftParent->setPos(-75, 0);
+    rightParent->setPos(75, 0);
+
+    bottomItem->setData(0, "bottomItem");
+    leftParent->setData(0, "leftParent");
+    leftChild->setData(0, "leftChild");
+    rightParent->setData(0, "rightParent");
+    rightChild->setData(0, "rightChild");
+
+    scene.setSceneRect(scene.itemsBoundingRect().adjusted(-50, -50, 50, 50));
+
+    EventSpy2 leftParentSpy(&scene, leftParent);
+    EventSpy2 leftChildSpy(&scene, leftChild);
+    EventSpy2 rightParentSpy(&scene, rightParent);
+    EventSpy2 rightChildSpy(&scene, rightChild);
+    EventSpy2 bottomItemSpy(&scene, bottomItem);
+
+    // Scene modality, also test multiple scene modal items
+    leftChild->setPanelModality(QGraphicsItem::SceneModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(bottomItemSpy.counts[QEvent::WindowBlocked], 0); // not a panel
+
+    // Click inside left child
+    sendMouseClick(&scene, leftChild->scenePos(), Qt::LeftButton);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 1);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMouseRelease], 0); // no grab
+    QCOMPARE(leftParentSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(rightParentSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(rightChildSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(bottomItemSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+
+    // Click on left parent, event goes to modal child
+    sendMouseClick(&scene, leftParent->sceneBoundingRect().topLeft() + QPointF(5, 5), Qt::LeftButton);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 2);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMouseRelease], 0); // no grab
+    QCOMPARE(leftParentSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(rightParentSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(rightChildSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(bottomItemSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+
+    // Click on all other items and outside the items
+    sendMouseClick(&scene, rightParent->sceneBoundingRect().topLeft() + QPointF(5, 5), Qt::LeftButton);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 3);
+    sendMouseClick(&scene, rightChild->scenePos(), Qt::LeftButton);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 4);
+    sendMouseClick(&scene, bottomItem->scenePos(), Qt::LeftButton);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 5);
+    sendMouseClick(&scene, QPointF(10000, 10000), Qt::LeftButton);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 6);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMouseRelease], 0); // no grab
+    QCOMPARE(leftParentSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(rightParentSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(rightChildSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(bottomItemSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+
+    leftChildSpy.counts.clear();
+    rightChildSpy.counts.clear();
+    leftParentSpy.counts.clear();
+    rightParentSpy.counts.clear();
+    bottomItemSpy.counts.clear();
+
+    leftChild->setPanelModality(QGraphicsItem::NonModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowUnblocked], 1);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowUnblocked], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowUnblocked], 1);
+    QCOMPARE(bottomItemSpy.counts[QEvent::WindowUnblocked], 0);
+
+    // Left parent enters scene modality.
+    leftParent->setPanelModality(QGraphicsItem::SceneModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(bottomItemSpy.counts[QEvent::WindowBlocked], 0);
+
+    // Click inside left child.
+    sendMouseClick(&scene, leftChild->scenePos(), Qt::LeftButton);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 1);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMouseRelease], 0);
+    QCOMPARE(leftParentSpy.counts[QEvent::GraphicsSceneMousePress], 0); // panel stops propagation
+    QCOMPARE(rightParentSpy.counts[QEvent::GraphicsSceneMousePress], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(bottomItemSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+
+   // Click on left parent.
+    sendMouseClick(&scene, leftParent->sceneBoundingRect().topLeft() + QPointF(5, 5), Qt::LeftButton);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 1);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMouseRelease], 0);
+    QCOMPARE(leftParentSpy.counts[QEvent::GraphicsSceneMousePress], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::GraphicsSceneMousePress], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::GraphicsSceneMousePress], 0);
+    QCOMPARE(bottomItemSpy.counts[QEvent::GraphicsSceneMousePress], 0);
+
+    // Click on all other items and outside the items
+    sendMouseClick(&scene, rightParent->sceneBoundingRect().topLeft() + QPointF(5, 5), Qt::LeftButton);
+    QCOMPARE(leftParentSpy.counts[QEvent::GraphicsSceneMousePress], 2);
+    sendMouseClick(&scene, rightChild->scenePos(), Qt::LeftButton);
+    QCOMPARE(leftParentSpy.counts[QEvent::GraphicsSceneMousePress], 3);
+    sendMouseClick(&scene, bottomItem->scenePos(), Qt::LeftButton);
+    QCOMPARE(leftParentSpy.counts[QEvent::GraphicsSceneMousePress], 4);
+    sendMouseClick(&scene, QPointF(10000, 10000), Qt::LeftButton);
+    QCOMPARE(leftParentSpy.counts[QEvent::GraphicsSceneMousePress], 5);
+    QCOMPARE(leftParentSpy.counts[QEvent::GraphicsSceneMouseRelease], 0);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::GraphicsSceneMousePress], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::GraphicsSceneMousePress], 0);
+    QCOMPARE(bottomItemSpy.counts[QEvent::GraphicsSceneMousePress], 0);
+
+    leftChildSpy.counts.clear();
+    rightChildSpy.counts.clear();
+    leftParentSpy.counts.clear();
+    rightParentSpy.counts.clear();
+    bottomItemSpy.counts.clear();
+
+    // Now both left parent and child are scene modal. Left parent is blocked.
+    leftChild->setPanelModality(QGraphicsItem::SceneModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(bottomItemSpy.counts[QEvent::WindowBlocked], 0);
+
+    // Click inside left child
+    sendMouseClick(&scene, leftChild->scenePos(), Qt::LeftButton);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 1);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMouseRelease], 0); // no grab
+    QCOMPARE(leftParentSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(rightParentSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(rightChildSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(bottomItemSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+
+    // Click on left parent, event goes to modal child
+    sendMouseClick(&scene, leftParent->sceneBoundingRect().topLeft() + QPointF(5, 5), Qt::LeftButton);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 2);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMouseRelease], 0); // no grab
+    QCOMPARE(leftParentSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(rightParentSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(rightChildSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(bottomItemSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+
+    // Click on all other items and outside the items
+    sendMouseClick(&scene, rightParent->sceneBoundingRect().topLeft() + QPointF(5, 5), Qt::LeftButton);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 3);
+    sendMouseClick(&scene, rightChild->scenePos(), Qt::LeftButton);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 4);
+    sendMouseClick(&scene, bottomItem->scenePos(), Qt::LeftButton);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 5);
+    sendMouseClick(&scene, QPointF(10000, 10000), Qt::LeftButton);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMousePress], 6);
+    QCOMPARE(leftChildSpy.counts[QEvent::GraphicsSceneMouseRelease], 0); // no grab
+    QCOMPARE(leftParentSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(rightParentSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(rightChildSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+    QCOMPARE(bottomItemSpy.counts[QEvent::GraphicsSceneMousePress], 0); // blocked
+
+    leftChildSpy.counts.clear();
+    rightChildSpy.counts.clear();
+    leftParentSpy.counts.clear();
+    rightParentSpy.counts.clear();
+    bottomItemSpy.counts.clear();
+
+    // Right child enters scene modality, only left child is blocked.
+    rightChild->setPanelModality(QGraphicsItem::SceneModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(bottomItemSpy.counts[QEvent::WindowBlocked], 0);
+}
+
+void tst_QGraphicsItem::panelModality()
+{
+    // 1) Test mouse events (delivery/propagation/redirection)
+    // 2) Test hover events (incl. leave on block, enter on unblock)
+    // 3) Test cursor stuff (incl. unset on block, set on unblock)
+    // 4) Test clickfocus
+    // 5) Test grab/ungrab events (possibly ungrab on block, regrab on unblock)
+    // 6) ### modality for non-panels is unsupported for now
+    QGraphicsScene scene;
+
+    QGraphicsRectItem *bottomItem = scene.addRect(-150, -100, 300, 200);
+    bottomItem->setFlag(QGraphicsItem::ItemIsFocusable);
+    bottomItem->setBrush(Qt::yellow);
+
+    QGraphicsRectItem *leftParent = scene.addRect(-50, -50, 100, 100);
+    leftParent->setFlag(QGraphicsItem::ItemIsPanel);
+    leftParent->setBrush(Qt::blue);
+
+    QGraphicsRectItem *leftChild = scene.addRect(-25, -25, 50, 50);
+    leftChild->setFlag(QGraphicsItem::ItemIsPanel);
+    leftChild->setBrush(Qt::green);
+    leftChild->setParentItem(leftParent);
+
+    QGraphicsRectItem *rightParent = scene.addRect(-50, -50, 100, 100);
+    rightParent->setFlag(QGraphicsItem::ItemIsPanel);
+    rightParent->setBrush(Qt::red);
+    QGraphicsRectItem *rightChild = scene.addRect(-25, -25, 50, 50);
+    rightChild->setFlag(QGraphicsItem::ItemIsPanel);
+    rightChild->setBrush(Qt::gray);
+    rightChild->setParentItem(rightParent);
+
+    leftParent->setPos(-75, 0);
+    rightParent->setPos(75, 0);
+
+    bottomItem->setData(0, "bottomItem");
+    leftParent->setData(0, "leftParent");
+    leftChild->setData(0, "leftChild");
+    rightParent->setData(0, "rightParent");
+    rightChild->setData(0, "rightChild");
+
+    scene.setSceneRect(scene.itemsBoundingRect().adjusted(-50, -50, 50, 50));
+
+    EventSpy2 leftParentSpy(&scene, leftParent);
+    EventSpy2 leftChildSpy(&scene, leftChild);
+    EventSpy2 rightParentSpy(&scene, rightParent);
+    EventSpy2 rightChildSpy(&scene, rightChild);
+    EventSpy2 bottomItemSpy(&scene, bottomItem);
+
+    // Left Child enters panel modality, only left parent is blocked.
+    leftChild->setPanelModality(QGraphicsItem::PanelModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(bottomItemSpy.counts[QEvent::WindowBlocked], 0);
+
+    leftChild->setPanelModality(QGraphicsItem::NonModal);
+    leftChildSpy.counts.clear();
+    rightChildSpy.counts.clear();
+    leftParentSpy.counts.clear();
+    rightParentSpy.counts.clear();
+    bottomItemSpy.counts.clear();
+
+    // Left parent enter panel modality, nothing is blocked.
+    leftParent->setPanelModality(QGraphicsItem::PanelModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(bottomItemSpy.counts[QEvent::WindowBlocked], 0);
+
+    // Left child enters panel modality, left parent is blocked again.
+    leftChild->setPanelModality(QGraphicsItem::PanelModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(bottomItemSpy.counts[QEvent::WindowBlocked], 0);
+
+    leftChildSpy.counts.clear();
+    rightChildSpy.counts.clear();
+    leftParentSpy.counts.clear();
+    rightParentSpy.counts.clear();
+    bottomItemSpy.counts.clear();
+
+    leftChild->setPanelModality(QGraphicsItem::NonModal);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowUnblocked], 1);
+    leftParent->setPanelModality(QGraphicsItem::NonModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowUnblocked], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(bottomItemSpy.counts[QEvent::WindowUnblocked], 0);
+
+    leftChildSpy.counts.clear();
+    rightChildSpy.counts.clear();
+    leftParentSpy.counts.clear();
+    rightParentSpy.counts.clear();
+    bottomItemSpy.counts.clear();
+
+    // Left and right child enter panel modality, both parents are blocked.
+    rightChild->setPanelModality(QGraphicsItem::PanelModal);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 1);
+    leftChild->setPanelModality(QGraphicsItem::PanelModal);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 1);
+}
+
+void tst_QGraphicsItem::mixedModality()
+{
+    // 1) Test mouse events (delivery/propagation/redirection)
+    // 2) Test hover events (incl. leave on block, enter on unblock)
+    // 3) Test cursor stuff (incl. unset on block, set on unblock)
+    // 4) Test clickfocus
+    // 5) Test grab/ungrab events (possibly ungrab on block, regrab on unblock)
+    // 6) ### modality for non-panels is unsupported for now
+    QGraphicsScene scene;
+
+    QGraphicsRectItem *bottomItem = scene.addRect(-150, -100, 300, 200);
+    bottomItem->setFlag(QGraphicsItem::ItemIsFocusable);
+    bottomItem->setBrush(Qt::yellow);
+
+    QGraphicsRectItem *leftParent = scene.addRect(-50, -50, 100, 100);
+    leftParent->setFlag(QGraphicsItem::ItemIsPanel);
+    leftParent->setBrush(Qt::blue);
+
+    QGraphicsRectItem *leftChild = scene.addRect(-25, -25, 50, 50);
+    leftChild->setFlag(QGraphicsItem::ItemIsPanel);
+    leftChild->setBrush(Qt::green);
+    leftChild->setParentItem(leftParent);
+
+    QGraphicsRectItem *rightParent = scene.addRect(-50, -50, 100, 100);
+    rightParent->setFlag(QGraphicsItem::ItemIsPanel);
+    rightParent->setBrush(Qt::red);
+    QGraphicsRectItem *rightChild = scene.addRect(-25, -25, 50, 50);
+    rightChild->setFlag(QGraphicsItem::ItemIsPanel);
+    rightChild->setBrush(Qt::gray);
+    rightChild->setParentItem(rightParent);
+
+    leftParent->setPos(-75, 0);
+    rightParent->setPos(75, 0);
+
+    bottomItem->setData(0, "bottomItem");
+    leftParent->setData(0, "leftParent");
+    leftChild->setData(0, "leftChild");
+    rightParent->setData(0, "rightParent");
+    rightChild->setData(0, "rightChild");
+
+    scene.setSceneRect(scene.itemsBoundingRect().adjusted(-50, -50, 50, 50));
+
+    EventSpy2 leftParentSpy(&scene, leftParent);
+    EventSpy2 leftChildSpy(&scene, leftChild);
+    EventSpy2 rightParentSpy(&scene, rightParent);
+    EventSpy2 rightChildSpy(&scene, rightChild);
+    EventSpy2 bottomItemSpy(&scene, bottomItem);
+
+    // Left Child enters panel modality, only left parent is blocked.
+    leftChild->setPanelModality(QGraphicsItem::PanelModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 0);
+
+    // Left parent enters scene modality, which blocks everything except the child.
+    leftParent->setPanelModality(QGraphicsItem::SceneModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowUnblocked], 0);
+
+    // Right child enters panel modality (changes nothing).
+    rightChild->setPanelModality(QGraphicsItem::PanelModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowUnblocked], 0);
+
+    // Left parent leaves modality. Right child is unblocked.
+    leftParent->setPanelModality(QGraphicsItem::NonModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowBlocked], 0);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowUnblocked], 1);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowUnblocked], 0);
+
+    // Right child "upgrades" its modality to scene modal. Left child is blocked.
+    // Right parent is unaffected.
+    rightChild->setPanelModality(QGraphicsItem::SceneModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowUnblocked], 1);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowUnblocked], 0);
+
+    // "downgrade" right child back to panel modal, left child is unblocked
+    rightChild->setPanelModality(QGraphicsItem::PanelModal);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(leftChildSpy.counts[QEvent::WindowUnblocked], 1);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightChildSpy.counts[QEvent::WindowUnblocked], 1);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(leftParentSpy.counts[QEvent::WindowUnblocked], 0);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowBlocked], 1);
+    QCOMPARE(rightParentSpy.counts[QEvent::WindowUnblocked], 0);
+}
+
+void tst_QGraphicsItem::modality_hover()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *rect1 = scene.addRect(-50, -50, 100, 100);
+    rect1->setFlag(QGraphicsItem::ItemIsPanel);
+    rect1->setAcceptHoverEvents(true);
+    rect1->setData(0, "rect1");
+
+    QGraphicsRectItem *rect2 = scene.addRect(-50, -50, 100, 100);
+    rect2->setParentItem(rect1);
+    rect2->setFlag(QGraphicsItem::ItemIsPanel);
+    rect2->setAcceptHoverEvents(true);
+    rect2->setPos(50, 50);
+    rect2->setPanelModality(QGraphicsItem::SceneModal);
+    rect2->setData(0, "rect2");
+
+    EventSpy2 rect1Spy(&scene, rect1);
+    EventSpy2 rect2Spy(&scene, rect2);
+
+    sendMouseMove(&scene, QPointF(-25, -25));
+
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverEnter], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverMove], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverLeave], 0);
+
+    sendMouseMove(&scene, QPointF(75, 75));
+
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverEnter], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverMove], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverLeave], 0);
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverEnter], 1);
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverMove], 1);
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverLeave], 0);
+
+    sendMouseMove(&scene, QPointF(-25, -25));
+
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverLeave], 1);
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverEnter], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverMove], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverLeave], 0);
+
+    rect2->setPanelModality(QGraphicsItem::NonModal);
+
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverEnter], 1);
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverMove], 1);
+
+    sendMouseMove(&scene, QPointF(75, 75));
+
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverEnter], 2);
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverMove], 2);
+
+    rect2->setPanelModality(QGraphicsItem::SceneModal);
+
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverLeave], 1);
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverEnter], 2);
+    // changing modality causes a spurious GraphicsSceneHoveMove, even though the mouse didn't
+    // actually move
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverMove], 3);
+
+    sendMouseMove(&scene, QPointF(-25, -25));
+
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverLeave], 2);
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverEnter], 1);
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverMove], 1);
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverLeave], 1);
+
+    rect2->setPanelModality(QGraphicsItem::PanelModal);
+
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverEnter], 1);
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverMove], 1);
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverLeave], 1);
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverEnter], 2);
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverMove], 3);
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverLeave], 2);
+
+    rect2->setPanelModality(QGraphicsItem::NonModal);
+
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverEnter], 2);
+    QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneHoverMove], 2);
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverEnter], 2);
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverMove], 3);
+    QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneHoverLeave], 2);
+}
+
+void tst_QGraphicsItem::modality_mouseGrabber()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *rect1 = scene.addRect(-50, -50, 100, 100);
+    rect1->setFlag(QGraphicsItem::ItemIsPanel);
+    rect1->setFlag(QGraphicsItem::ItemIsMovable);
+    rect1->setData(0, "rect1");
+
+    QGraphicsRectItem *rect2 = scene.addRect(-50, -50, 100, 100);
+    rect2->setParentItem(rect1);
+    rect2->setFlag(QGraphicsItem::ItemIsPanel);
+    rect2->setFlag(QGraphicsItem::ItemIsMovable);
+    rect2->setPos(50, 50);
+    rect2->setData(0, "rect2");
+
+    EventSpy2 rect1Spy(&scene, rect1);
+    EventSpy2 rect2Spy(&scene, rect2);
+
+    {
+        // pressing mouse on rect1 starts implicit grab
+        sendMousePress(&scene, QPoint(-25, -25));
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneMousePress], 1);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) rect1);
+
+        // grab lost when rect1 is modally shadowed
+        rect2->setPanelModality(QGraphicsItem::SceneModal);
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) 0);
+
+        // releasing goes nowhere
+        sendMouseRelease(&scene, QPoint(-25, -25));
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneMouseRelease], 0);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneMouseRelease], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) 0);
+
+        // pressing mouse on rect1 starts implicit grab on rect2 (since it is modal)
+        sendMouseClick(&scene, QPoint(-25, -25));
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneMousePress], 1);
+        QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneMouseRelease], 0);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneMousePress], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneMouseRelease], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 1);
+
+        rect2->setPanelModality(QGraphicsItem::NonModal);
+
+        // pressing mouse on rect1 starts implicit grab
+        sendMousePress(&scene, QPoint(-25, -25));
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 2);
+        QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneMousePress], 2);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) rect1);
+
+        // grab lost to rect2 when rect1 is modally shadowed
+        rect2->setPanelModality(QGraphicsItem::SceneModal);
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 2);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 2);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) 0);
+
+        // rect1 does *not* re-grab when rect2 is no longer modal
+        rect2->setPanelModality(QGraphicsItem::NonModal);
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 2);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 2);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) 0);
+
+        // release goes nowhere
+        sendMouseRelease(&scene, QPoint(-25, -25));
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 2);
+        QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneMouseRelease], 0);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 2);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) 0);
+    }
+    {
+        // repeat the test using PanelModal
+        rect2->setPanelModality(QGraphicsItem::NonModal);
+        rect1Spy.counts.clear();
+        rect2Spy.counts.clear();
+
+        // pressing mouse on rect1 starts implicit grab
+        sendMousePress(&scene, QPoint(-25, -25));
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneMousePress], 1);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) rect1);
+
+        // grab lost when rect1 is modally shadowed
+        rect2->setPanelModality(QGraphicsItem::PanelModal);
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) 0);
+
+        // releasing goes nowhere
+        sendMouseRelease(&scene, QPoint(-25, -25));
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneMouseRelease], 0);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneMouseRelease], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) 0);
+
+        // pressing mouse on rect1 starts implicit grab on rect2 (since it is modal)
+        sendMouseClick(&scene, QPoint(-25, -25));
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneMousePress], 1);
+        QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneMouseRelease], 0);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneMousePress], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::GraphicsSceneMouseRelease], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 1);
+
+        rect2->setPanelModality(QGraphicsItem::NonModal);
+
+        // pressing mouse on rect1 starts implicit grab
+        sendMousePress(&scene, QPoint(-25, -25));
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 2);
+        QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneMousePress], 2);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) rect1);
+
+        // grab lost to rect2 when rect1 is modally shadowed
+        rect2->setPanelModality(QGraphicsItem::PanelModal);
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 2);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 2);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) 0);
+
+        // rect1 does *not* re-grab when rect2 is no longer modal
+        rect2->setPanelModality(QGraphicsItem::NonModal);
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 2);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 2);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) 0);
+
+        // release goes nowhere
+        sendMouseRelease(&scene, QPoint(-25, -25));
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 2);
+        QCOMPARE(rect1Spy.counts[QEvent::GraphicsSceneMouseRelease], 0);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 2);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) 0);
+    }
+
+    {
+        // repeat the PanelModal tests, but this time the mouse events will be on a non-modal item,
+        // meaning normal grabbing should work
+        rect2->setPanelModality(QGraphicsItem::NonModal);
+        rect1Spy.counts.clear();
+        rect2Spy.counts.clear();
+
+        QGraphicsRectItem *rect3 = scene.addRect(-50, -50, 100, 100);
+        rect3->setFlag(QGraphicsItem::ItemIsPanel);
+        rect3->setFlag(QGraphicsItem::ItemIsMovable);
+        rect3->setPos(150, 50);
+        rect3->setData(0, "rect3");
+
+        EventSpy2 rect3Spy(&scene, rect3);
+
+        // pressing mouse on rect3 starts implicit grab
+        sendMousePress(&scene, QPoint(150, 50));
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect3Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect3Spy.counts[QEvent::GraphicsSceneMousePress], 1);
+        QCOMPARE(rect3Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) rect3);
+
+        // grab is *not* lost when rect1 is modally shadowed by rect2
+        rect2->setPanelModality(QGraphicsItem::PanelModal);
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect3Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect3Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) rect3);
+
+        // releasing goes to rect3
+        sendMouseRelease(&scene, QPoint(150, 50));
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect3Spy.counts[QEvent::GrabMouse], 1);
+        QCOMPARE(rect3Spy.counts[QEvent::GraphicsSceneMouseRelease], 1);
+        QCOMPARE(rect3Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) 0);
+
+        rect2->setPanelModality(QGraphicsItem::NonModal);
+
+        // pressing mouse on rect3 starts implicit grab
+        sendMousePress(&scene, QPoint(150, 50));
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect3Spy.counts[QEvent::GrabMouse], 2);
+        QCOMPARE(rect3Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) rect3);
+
+        // grab is not lost
+        rect2->setPanelModality(QGraphicsItem::PanelModal);
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect3Spy.counts[QEvent::GrabMouse], 2);
+        QCOMPARE(rect3Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) rect3);
+
+        // grab stays on rect3
+        rect2->setPanelModality(QGraphicsItem::NonModal);
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect3Spy.counts[QEvent::GrabMouse], 2);
+        QCOMPARE(rect3Spy.counts[QEvent::UngrabMouse], 1);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) rect3);
+
+        // release goes to rect3
+        sendMouseRelease(&scene, QPoint(150, 50));
+        QCOMPARE(rect1Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect1Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::GrabMouse], 0);
+        QCOMPARE(rect2Spy.counts[QEvent::UngrabMouse], 0);
+        QCOMPARE(rect3Spy.counts[QEvent::GrabMouse], 2);
+        QCOMPARE(rect3Spy.counts[QEvent::UngrabMouse], 2);
+        QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *) 0);
+    }
+}
+
+void tst_QGraphicsItem::modality_clickFocus()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *rect1 = scene.addRect(-50, -50, 100, 100);
+    rect1->setFlag(QGraphicsItem::ItemIsPanel);
+    rect1->setFlag(QGraphicsItem::ItemIsFocusable);
+    rect1->setData(0, "rect1");
+
+    QGraphicsRectItem *rect2 = scene.addRect(-50, -50, 100, 100);
+    rect2->setParentItem(rect1);
+    rect2->setFlag(QGraphicsItem::ItemIsPanel);
+    rect2->setFlag(QGraphicsItem::ItemIsFocusable);
+    rect2->setPos(50, 50);
+    rect2->setData(0, "rect2");
+
+    QEvent windowActivateEvent(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &windowActivateEvent);
+
+    EventSpy2 rect1Spy(&scene, rect1);
+    EventSpy2 rect2Spy(&scene, rect2);
+
+    // activate rect1, it should not get focus
+    rect1->setActive(true);
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *) 0);
+
+    // focus stays unset when rect2 becomes modal
+    rect2->setPanelModality(QGraphicsItem::SceneModal);
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *) 0);
+    QCOMPARE(rect1Spy.counts[QEvent::FocusIn], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::FocusOut], 0);
+    QCOMPARE(rect2Spy.counts[QEvent::FocusIn], 0);
+    QCOMPARE(rect2Spy.counts[QEvent::FocusOut], 0);
+
+    // clicking on rect1 should not set it's focus item
+    sendMouseClick(&scene, QPointF(-25, -25));
+    QCOMPARE(rect1->focusItem(), (QGraphicsItem *) 0);
+    QCOMPARE(rect1Spy.counts[QEvent::FocusIn], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::FocusOut], 0);
+    QCOMPARE(rect2Spy.counts[QEvent::FocusIn], 0);
+    QCOMPARE(rect2Spy.counts[QEvent::FocusOut], 0);
+
+    // clicking on rect2 gives it focus
+    rect2->setActive(true);
+    sendMouseClick(&scene, QPointF(75, 75));
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *) rect2);
+    QCOMPARE(rect1Spy.counts[QEvent::FocusIn], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::FocusOut], 0);
+    QCOMPARE(rect2Spy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(rect2Spy.counts[QEvent::FocusOut], 0);
+
+    // clicking on rect1 does *not* give it focus
+    rect1->setActive(true);
+    sendMouseClick(&scene, QPointF(-25, -25));
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *) 0);
+    QCOMPARE(rect1Spy.counts[QEvent::FocusIn], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::FocusOut], 0);
+    QCOMPARE(rect2Spy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(rect2Spy.counts[QEvent::FocusOut], 1);
+
+    // focus doesn't change when leaving modality either
+    rect2->setPanelModality(QGraphicsItem::NonModal);
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *) 0);
+    QCOMPARE(rect1Spy.counts[QEvent::FocusIn], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::FocusOut], 0);
+    QCOMPARE(rect2Spy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(rect2Spy.counts[QEvent::FocusOut], 1);
+
+    // click on rect1, it should get focus now
+    sendMouseClick(&scene, QPointF(-25, -25));
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *) rect1);
+    QCOMPARE(rect1Spy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(rect1Spy.counts[QEvent::FocusOut], 0);
+    QCOMPARE(rect2Spy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(rect2Spy.counts[QEvent::FocusOut], 1);
+}
+
+void tst_QGraphicsItem::modality_keyEvents()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *rect1 = scene.addRect(-50, -50, 100, 100);
+    rect1->setFlag(QGraphicsItem::ItemIsPanel);
+    rect1->setFlag(QGraphicsItem::ItemIsFocusable);
+    rect1->setData(0, "rect1");
+
+    QGraphicsRectItem *rect1child = scene.addRect(-10, -10, 20, 20);
+    rect1child->setParentItem(rect1);
+    rect1child->setFlag(QGraphicsItem::ItemIsFocusable);
+    rect1child->setData(0, "rect1child1");
+
+    QGraphicsRectItem *rect2 = scene.addRect(-50, -50, 100, 100);
+    rect2->setParentItem(rect1);
+    rect2->setFlag(QGraphicsItem::ItemIsPanel);
+    rect2->setFlag(QGraphicsItem::ItemIsFocusable);
+    rect2->setPos(50, 50);
+    rect2->setData(0, "rect2");
+
+    QGraphicsRectItem *rect2child = scene.addRect(-10, -10, 20, 20);
+    rect2child->setParentItem(rect2);
+    rect2child->setFlag(QGraphicsItem::ItemIsFocusable);
+    rect2child->setData(0, "rect2child1");
+
+    QEvent windowActivateEvent(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &windowActivateEvent);
+
+    EventSpy2 rect1Spy(&scene, rect1);
+    EventSpy2 rect1childSpy(&scene, rect1child);
+    EventSpy2 rect2Spy(&scene, rect2);
+    EventSpy2 rect2childSpy(&scene, rect2child);
+
+    // activate rect1 and give it rect1child focus
+    rect1->setActive(true);
+    rect1child->setFocus();
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *) rect1child);
+
+    // focus stays on rect1child when rect2 becomes modal
+    rect2->setPanelModality(QGraphicsItem::SceneModal);
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *) rect1child);
+
+    // but key events to rect1child should be neither delivered nor propagated
+    sendKeyClick(&scene, Qt::Key_A);
+    sendKeyClick(&scene, Qt::Key_S);
+    sendKeyClick(&scene, Qt::Key_D);
+    sendKeyClick(&scene, Qt::Key_F);
+    QCOMPARE(rect1childSpy.counts[QEvent::KeyPress], 0);
+    QCOMPARE(rect1childSpy.counts[QEvent::KeyRelease], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::KeyPress], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::KeyRelease], 0);
+
+    // change to panel modality, rect1child1 keeps focus
+    rect2->setPanelModality(QGraphicsItem::PanelModal);
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *) rect1child);
+
+    // still no key events
+    sendKeyClick(&scene, Qt::Key_J);
+    sendKeyClick(&scene, Qt::Key_K);
+    sendKeyClick(&scene, Qt::Key_L);
+    sendKeyClick(&scene, Qt::Key_Semicolon);
+    QCOMPARE(rect1childSpy.counts[QEvent::KeyPress], 0);
+    QCOMPARE(rect1childSpy.counts[QEvent::KeyRelease], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::KeyPress], 0);
+    QCOMPARE(rect1Spy.counts[QEvent::KeyRelease], 0);
+}
+
+void tst_QGraphicsItem::itemIsInFront()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *rect1 = new QGraphicsRectItem;
+    rect1->setData(0, "rect1");
+    scene.addItem(rect1);
+
+    QGraphicsRectItem *rect1child1 = new QGraphicsRectItem(rect1);
+    rect1child1->setZValue(1);
+    rect1child1->setData(0, "rect1child1");
+
+    QGraphicsRectItem *rect1child2 = new QGraphicsRectItem(rect1);
+    rect1child2->setParentItem(rect1);
+    rect1child2->setData(0, "rect1child2");
+
+    QGraphicsRectItem *rect1child1_1 = new QGraphicsRectItem(rect1child1);
+    rect1child1_1->setData(0, "rect1child1_1");
+
+    QGraphicsRectItem *rect1child1_2 = new QGraphicsRectItem(rect1child1);
+    rect1child1_2->setFlag(QGraphicsItem::ItemStacksBehindParent);
+    rect1child1_2->setData(0, "rect1child1_2");
+
+    QGraphicsRectItem *rect2 = new QGraphicsRectItem;
+    rect2->setData(0, "rect2");
+    scene.addItem(rect2);
+
+    QGraphicsRectItem *rect2child1 = new QGraphicsRectItem(rect2);
+    rect2child1->setData(0, "rect2child1");
+
+    QCOMPARE(qt_closestItemFirst(rect1, rect1), false);
+    QCOMPARE(qt_closestItemFirst(rect1, rect2), false);
+    QCOMPARE(qt_closestItemFirst(rect1child1, rect2child1), false);
+    QCOMPARE(qt_closestItemFirst(rect1child1, rect1child2), true);
+    QCOMPARE(qt_closestItemFirst(rect1child1_1, rect1child2), true);
+    QCOMPARE(qt_closestItemFirst(rect1child1_1, rect1child1), true);
+    QCOMPARE(qt_closestItemFirst(rect1child1_2, rect1child2), true);
+    QCOMPARE(qt_closestItemFirst(rect1child1_2, rect1child1), false);
+    QCOMPARE(qt_closestItemFirst(rect1child1_2, rect1), true);
+    QCOMPARE(qt_closestItemFirst(rect1child1_2, rect2), false);
+    QCOMPARE(qt_closestItemFirst(rect1child1_2, rect2child1), false);
+}
+
+class ScenePosChangeTester : public ItemChangeTester
+{
+public:
+    ScenePosChangeTester()
+    { }
+    ScenePosChangeTester(QGraphicsItem *parent) : ItemChangeTester(parent)
+    { }
+};
+
+void tst_QGraphicsItem::scenePosChange()
+{
+    ScenePosChangeTester* root = new ScenePosChangeTester;
+    ScenePosChangeTester* child1 = new ScenePosChangeTester(root);
+    ScenePosChangeTester* grandChild1 = new ScenePosChangeTester(child1);
+    ScenePosChangeTester* child2 = new ScenePosChangeTester(root);
+    ScenePosChangeTester* grandChild2 = new ScenePosChangeTester(child2);
+
+    child1->setFlag(QGraphicsItem::ItemSendsScenePositionChanges, true);
+    grandChild2->setFlag(QGraphicsItem::ItemSendsScenePositionChanges, true);
+
+    QVERIFY(child1->flags() & QGraphicsItem::ItemSendsScenePositionChanges);
+    QVERIFY(grandChild2->flags() & QGraphicsItem::ItemSendsScenePositionChanges);
+
+    QGraphicsScene scene;
+    scene.addItem(root);
+
+    // ignore uninteresting changes
+    child1->clear();
+    child2->clear();
+    grandChild1->clear();
+    grandChild2->clear();
+
+    // move whole tree
+    root->moveBy(1.0, 1.0);
+    QCOMPARE(child1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 1);
+    QCOMPARE(grandChild1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+    QCOMPARE(child2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+    QCOMPARE(grandChild2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 1);
+
+    // move subtree
+    child2->moveBy(1.0, 1.0);
+    QCOMPARE(child1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 1);
+    QCOMPARE(grandChild1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+    QCOMPARE(child2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+    QCOMPARE(grandChild2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 2);
+
+    // reparent
+    grandChild2->setParentItem(child1);
+    child1->moveBy(1.0, 1.0);
+    QCOMPARE(child1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 2);
+    QCOMPARE(grandChild1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+    QCOMPARE(child2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+    QCOMPARE(grandChild2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 3);
+
+    // change flags
+    grandChild1->setFlag(QGraphicsItem::ItemSendsScenePositionChanges, true);
+    grandChild2->setFlag(QGraphicsItem::ItemSendsScenePositionChanges, false);
+    QCoreApplication::processEvents(); // QGraphicsScenePrivate::_q_updateScenePosDescendants()
+    child1->moveBy(1.0, 1.0);
+    QCOMPARE(child1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 3);
+    QCOMPARE(grandChild1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 1);
+    QCOMPARE(child2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+    QCOMPARE(grandChild2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 3);
+
+    // remove
+    scene.removeItem(grandChild1);
+    delete grandChild2; grandChild2 = 0;
+    QCoreApplication::processEvents(); // QGraphicsScenePrivate::_q_updateScenePosDescendants()
+    root->moveBy(1.0, 1.0);
+    QCOMPARE(child1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 4);
+    QCOMPARE(grandChild1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 1);
+    QCOMPARE(child2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+
+    root->setX(1);
+    QCOMPARE(child1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 5);
+    QCOMPARE(grandChild1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 1);
+    QCOMPARE(child2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+
+    root->setY(1);
+    QCOMPARE(child1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 6);
+    QCOMPARE(grandChild1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 1);
+    QCOMPARE(child2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+}
+
+class MyInputContext : public QInputContext
+{
+public:
+    MyInputContext() : nbUpdates(0) {}
+    ~MyInputContext() {}
+
+    QString identifierName() { return QString(); }
+    QString language() { return QString(); }
+
+    void reset() {}
+
+    bool isComposing() const { return false; }
+
+    void update() { nbUpdates++; }
+
+    bool nbUpdates;
+};
+
+class MyInputWidget : public QGraphicsWidget
+{
+public:
+    MyInputWidget()
+    {
+        setFlag(QGraphicsItem::ItemIsFocusable, true);
+        setFlag(QGraphicsItem::ItemAcceptsInputMethod, true);
+    }
+    void mousePressEvent(QGraphicsSceneMouseEvent *event)
+    {
+        event->accept();
+    }
+
+    void doUpdateMicroFocus()
+    {
+        if (QWidget *fw = QApplication::focusWidget()) {
+            if (scene()) {
+                for (int i = 0 ; i < scene()->views().count() ; ++i) {
+                    if (scene()->views().at(i) == fw) {
+                        if (QInputContext *inputContext = fw->inputContext()) {
+                            inputContext->update();
+                        }
+                    }
+                }
+            }
+        }
+    }
+};
+
+void tst_QGraphicsItem::updateMicroFocus()
+{
+#if defined Q_OS_WIN || defined Q_OS_MAC
+    QSKIP("QTBUG-9578", SkipAll);
+#endif
+    QGraphicsScene scene;
+    QWidget parent;
+    QGridLayout layout;
+    parent.setLayout(&layout);
+    QGraphicsView view(&scene);
+    QGraphicsView view2(&scene);
+    layout.addWidget(&view, 0, 0);
+    layout.addWidget(&view2, 0, 1);
+    MyInputContext *ic = new MyInputContext;
+    qApp->setInputContext(ic);
+    MyInputWidget input;
+    input.setPos(0, 0);
+    input.resize(150, 150);
+    scene.addItem(&input);
+    input.setFocus();
+    parent.show();
+    view.setFocus();
+    qApp->setAutoSipEnabled(true);
+    QApplication::setActiveWindow(&parent);
+    QTest::qWaitForWindowShown(&parent);
+    QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&parent));
+    //We reset the number of updates that happened previously (initialisation)
+    ic->nbUpdates = 0;
+    input.doUpdateMicroFocus();
+    QApplication::processEvents();
+    QTRY_COMPARE(ic->nbUpdates, 1);
+}
+
+void tst_QGraphicsItem::textItem_shortcuts()
+{
+    QWidget w;
+    QVBoxLayout l;
+    w.setLayout(&l);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    l.addWidget(&view);
+    QPushButton b("Push Me");
+    l.addWidget(&b);
+
+    QGraphicsTextItem *item = scene.addText("Troll Text");
+    item->setFlag(QGraphicsItem::ItemIsFocusable);
+    item->setTextInteractionFlags(Qt::TextEditorInteraction);
+    w.show();
+    QTest::qWaitForWindowShown(&w);
+
+    item->setFocus();
+    QTRY_VERIFY(item->hasFocus());
+    QVERIFY(item->textCursor().selectedText().isEmpty());
+
+    // Shortcut should work (select all)
+    QTest::keyClick(&view, Qt::Key_A, Qt::ControlModifier);
+    QTRY_COMPARE(item->textCursor().selectedText(), item->toPlainText());
+    QTextCursor tc = item->textCursor();
+    tc.clearSelection();
+    item->setTextCursor(tc);
+    QVERIFY(item->textCursor().selectedText().isEmpty());
+
+    // Shortcut should also work if the text item has the focus and another widget
+    // has the same shortcut.
+    b.setShortcut(QKeySequence("CTRL+A"));
+    QTest::keyClick(&view, Qt::Key_A, Qt::ControlModifier);
+    QTRY_COMPARE(item->textCursor().selectedText(), item->toPlainText());
+}
+
+void tst_QGraphicsItem::scroll()
+{
+    // Create two overlapping rectangles in the scene:
+    // +-------+
+    // |       | <- item1
+    // |   +-------+
+    // |   |       |
+    // +---|       | <- item2
+    //     |       |
+    //     +-------+
+
+    EventTester *item1 = new EventTester;
+    item1->br = QRectF(0, 0, 200, 200);
+    item1->brush = Qt::red;
+    item1->setFlag(QGraphicsItem::ItemUsesExtendedStyleOption);
+
+    EventTester *item2 = new EventTester;
+    item2->br = QRectF(0, 0, 200, 200);
+    item2->brush = Qt::blue;
+    item2->setFlag(QGraphicsItem::ItemUsesExtendedStyleOption);
+    item2->setPos(100, 100);
+
+    QGraphicsScene scene(0, 0, 300, 300);
+    scene.addItem(item1);
+    scene.addItem(item2);
+
+    MyGraphicsView view(&scene);
+    view.setFrameStyle(0);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(view.repaints > 0);
+
+    view.reset();
+    item1->reset();
+    item2->reset();
+
+    const QRectF item1BoundingRect = item1->boundingRect();
+    const QRectF item2BoundingRect = item2->boundingRect();
+
+    // Scroll item1:
+    // Item1 should get full exposure
+    // Item2 should get exposure for the part that overlaps item1.
+    item1->scroll(0, -10);
+    QTRY_VERIFY(view.repaints > 0);
+    QCOMPARE(item1->lastExposedRect, item1BoundingRect);
+
+    QRectF expectedItem2Expose = item2BoundingRect;
+    // NB! Adjusted by 2 pixels for antialiasing
+    expectedItem2Expose &= item1->mapRectToItem(item2, item1BoundingRect.adjusted(-2, -2, 2, 2));
+    QCOMPARE(item2->lastExposedRect, expectedItem2Expose);
+
+    // Enable ItemCoordinateCache on item1.
+    view.reset();
+    item1->setCacheMode(QGraphicsItem::ItemCoordinateCache);
+    QTRY_VERIFY(view.repaints > 0);
+    view.reset();
+    item1->reset();
+    item2->reset();
+
+    // Scroll item1:
+    // Item1 should only get expose for the newly exposed area (accelerated scroll).
+    // Item2 should get exposure for the part that overlaps item1.
+    item1->scroll(0, -10, QRectF(50, 50, 100, 100));
+    QTRY_VERIFY(view.repaints > 0);
+    QCOMPARE(item1->lastExposedRect, QRectF(50, 140, 100, 10));
+
+    expectedItem2Expose = item2BoundingRect;
+    // NB! Adjusted by 2 pixels for antialiasing
+    expectedItem2Expose &= item1->mapRectToItem(item2, QRectF(50, 50, 100, 100).adjusted(-2, -2, 2, 2));
+    QCOMPARE(item2->lastExposedRect, expectedItem2Expose);
+}
+
+Q_DECLARE_METATYPE(QGraphicsItem::GraphicsItemFlag);
+
+void tst_QGraphicsItem::focusHandling_data()
+{
+    QTest::addColumn<QGraphicsItem::GraphicsItemFlag>("focusFlag");
+    QTest::addColumn<bool>("useStickyFocus");
+    QTest::addColumn<int>("expectedFocusItem"); // 0: none, 1: focusableUnder, 2: itemWithFocus
+
+    QTest::newRow("Focus goes through.")
+        << static_cast<QGraphicsItem::GraphicsItemFlag>(0x0) << false << 1;
+
+    QTest::newRow("Focus goes through, even with sticky scene.")
+        << static_cast<QGraphicsItem::GraphicsItemFlag>(0x0) << true  << 1;
+
+    QTest::newRow("With ItemStopsClickFocusPropagation, we cannot focus the item beneath the flagged one (but can still focus-out).")
+        << QGraphicsItem::ItemStopsClickFocusPropagation << false << 0;
+
+    QTest::newRow("With ItemStopsClickFocusPropagation, we cannot focus the item beneath the flagged one (and cannot focus-out if scene is sticky).")
+        << QGraphicsItem::ItemStopsClickFocusPropagation << true << 2;
+
+    QTest::newRow("With ItemStopsFocusHandling, focus cannot be changed by presses.")
+        << QGraphicsItem::ItemStopsFocusHandling << false << 2;
+
+    QTest::newRow("With ItemStopsFocusHandling, focus cannot be changed by presses (even if scene is sticky).")
+        << QGraphicsItem::ItemStopsFocusHandling << true << 2;
+}
+
+void tst_QGraphicsItem::focusHandling()
+{
+    QFETCH(QGraphicsItem::GraphicsItemFlag, focusFlag);
+    QFETCH(bool, useStickyFocus);
+    QFETCH(int, expectedFocusItem);
+
+    class MyItem : public QGraphicsRectItem
+    {
+    public:
+        MyItem() : QGraphicsRectItem(0, 0, 100, 100) {}
+        void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+        {
+            painter->fillRect(boundingRect(), hasFocus() ? QBrush(Qt::red) : brush());
+        }
+    };
+
+    QGraphicsRectItem *noFocusOnTop = new MyItem;
+    noFocusOnTop->setFlag(QGraphicsItem::ItemIsFocusable, false);
+    noFocusOnTop->setBrush(Qt::yellow);
+
+    QGraphicsRectItem *focusableUnder = new MyItem;
+    focusableUnder->setBrush(Qt::blue);
+    focusableUnder->setFlag(QGraphicsItem::ItemIsFocusable);
+    focusableUnder->setPos(50, 50);
+
+    QGraphicsRectItem *itemWithFocus = new MyItem;
+    itemWithFocus->setBrush(Qt::black);
+    itemWithFocus->setFlag(QGraphicsItem::ItemIsFocusable);
+    itemWithFocus->setPos(250, 10);
+
+    QGraphicsScene scene(-50, -50, 400, 400);
+    scene.addItem(noFocusOnTop);
+    scene.addItem(focusableUnder);
+    scene.addItem(itemWithFocus);
+    scene.setStickyFocus(useStickyFocus);
+
+    noFocusOnTop->setFlag(focusFlag);
+    focusableUnder->stackBefore(noFocusOnTop);
+    itemWithFocus->setFocus();
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QApplication::setActiveWindow(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&view));
+    QVERIFY(itemWithFocus->hasFocus());
+
+    const QPointF mousePressPoint = noFocusOnTop->mapToScene(noFocusOnTop->boundingRect().center());
+    const QList<QGraphicsItem *> itemsAtMousePressPosition = scene.items(mousePressPoint);
+    QVERIFY(itemsAtMousePressPosition.contains(noFocusOnTop));
+
+    sendMousePress(&scene, mousePressPoint);
+
+    switch (expectedFocusItem) {
+    case 0:
+        QCOMPARE(scene.focusItem(), static_cast<QGraphicsRectItem *>(0));
+        break;
+    case 1:
+        QCOMPARE(scene.focusItem(), focusableUnder);
+        break;
+    case 2:
+        QCOMPARE(scene.focusItem(), itemWithFocus);
+        break;
+    }
+
+    // Sanity check - manually setting the focus must work regardless of our
+    // focus handling flags:
+    focusableUnder->setFocus();
+    QCOMPARE(scene.focusItem(), focusableUnder);
+}
+
+void tst_QGraphicsItem::touchEventPropagation_data()
+{
+    QTest::addColumn<QGraphicsItem::GraphicsItemFlag>("flag");
+    QTest::addColumn<int>("expectedCount");
+
+    QTest::newRow("ItemIsPanel")
+        << QGraphicsItem::ItemIsPanel << 0;
+    QTest::newRow("ItemStopsClickFocusPropagation")
+        << QGraphicsItem::ItemStopsClickFocusPropagation << 1;
+    QTest::newRow("ItemStopsFocusHandling")
+        << QGraphicsItem::ItemStopsFocusHandling << 1;
+}
+
+void tst_QGraphicsItem::touchEventPropagation()
+{
+    QFETCH(QGraphicsItem::GraphicsItemFlag, flag);
+    QFETCH(int, expectedCount);
+
+    class Testee : public QGraphicsRectItem
+    {
+    public:
+        int touchBeginEventCount;
+
+        Testee()
+            : QGraphicsRectItem(0, 0, 100, 100)
+            , touchBeginEventCount(0)
+        {
+            setAcceptTouchEvents(true);
+            setFlag(QGraphicsItem::ItemIsFocusable, false);
+        }
+
+        bool sceneEvent(QEvent *ev)
+        {
+            if (ev->type() == QEvent::TouchBegin)
+                ++touchBeginEventCount;
+
+            return QGraphicsRectItem::sceneEvent(ev);
+        }
+    };
+
+    Testee *touchEventReceiver = new Testee;
+    QGraphicsItem *topMost = new QGraphicsRectItem(touchEventReceiver->boundingRect());
+
+    QGraphicsScene scene;
+    scene.addItem(topMost);
+    scene.addItem(touchEventReceiver);
+
+    topMost->setAcceptTouchEvents(true);
+    topMost->setZValue(FLT_MAX);
+    topMost->setFlag(QGraphicsItem::ItemIsFocusable, false);
+    topMost->setFlag(flag, true);
+
+    QGraphicsView view(&scene);
+    view.setSceneRect(touchEventReceiver->boundingRect());
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QCOMPARE(touchEventReceiver->touchBeginEventCount, 0);
+
+    QTouchEvent::TouchPoint tp(0);
+    tp.setState(Qt::TouchPointPressed);
+    tp.setScenePos(view.sceneRect().center());
+    tp.setLastScenePos(view.sceneRect().center());
+
+    QList<QTouchEvent::TouchPoint> touchPoints;
+    touchPoints << tp;
+
+    sendMousePress(&scene, tp.scenePos());
+    QTouchEvent touchBegin(QEvent::TouchBegin, QTouchEvent::TouchScreen, Qt::NoModifier, Qt::TouchPointPressed, touchPoints);
+
+    qApp->sendEvent(&scene, &touchBegin);
+    QCOMPARE(touchEventReceiver->touchBeginEventCount, expectedCount);
+}
+
+void tst_QGraphicsItem::deviceCoordinateCache_simpleRotations()
+{
+    // Make sure we don't invalidate the cache when applying simple
+    // (90, 180, 270, 360) rotation transforms to the item.
+    QGraphicsRectItem *item = new QGraphicsRectItem(0, 0, 300, 200);
+    item->setBrush(Qt::red);
+    item->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+
+    QGraphicsScene scene;
+    scene.setSceneRect(0, 0, 300, 200);
+    scene.addItem(item);
+
+    MyGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(view.repaints > 0);
+
+    QGraphicsItemCache *itemCache = QGraphicsItemPrivate::get(item)->extraItemCache();
+    QVERIFY(itemCache);
+    QPixmapCache::Key currentKey = itemCache->deviceData.value(view.viewport()).key;
+
+    // Trigger an update and verify that the cache is unchanged.
+    QPixmapCache::Key oldKey = currentKey;
+    view.reset();
+    view.viewport()->update();
+    QTRY_VERIFY(view.repaints > 0);
+    currentKey = itemCache->deviceData.value(view.viewport()).key;
+    QCOMPARE(currentKey, oldKey);
+
+    // Check 90, 180, 270 and 360 degree rotations.
+    for (int angle = 90; angle <= 360; angle += 90) {
+        // Rotate item and verify that the cache was invalidated.
+        oldKey = currentKey;
+        view.reset();
+        QTransform transform;
+        transform.translate(150, 100);
+        transform.rotate(angle);
+        transform.translate(-150, -100);
+        item->setTransform(transform);
+        QTRY_VERIFY(view.repaints > 0);
+        currentKey = itemCache->deviceData.value(view.viewport()).key;
+        QVERIFY(currentKey != oldKey);
+
+        // IMPORTANT PART:
+        // Trigger an update and verify that the cache is unchanged.
+        oldKey = currentKey;
+        view.reset();
+        view.viewport()->update();
+        QTRY_VERIFY(view.repaints > 0);
+        currentKey = itemCache->deviceData.value(view.viewport()).key;
+        QCOMPARE(currentKey, oldKey);
+    }
+
+    // 45 degree rotation.
+    oldKey = currentKey;
+    view.reset();
+    QTransform transform;
+    transform.translate(150, 100);
+    transform.rotate(45);
+    transform.translate(-150, -100);
+    item->setTransform(transform);
+    QTRY_VERIFY(view.repaints > 0);
+    currentKey = itemCache->deviceData.value(view.viewport()).key;
+    QVERIFY(currentKey != oldKey);
+
+    // Trigger an update and verify that the cache was invalidated.
+    // We should always invalidate the cache for non-trivial transforms.
+    oldKey = currentKey;
+    view.reset();
+    view.viewport()->update();
+    QTRY_VERIFY(view.repaints > 0);
+    currentKey = itemCache->deviceData.value(view.viewport()).key;
+    QVERIFY(currentKey != oldKey);
+}
+
+void tst_QGraphicsItem::QTBUG_5418_textItemSetDefaultColor()
+{
+    struct Item : public QGraphicsTextItem
+    {
+        int painted;
+        void paint(QPainter *painter, const QStyleOptionGraphicsItem *opt, QWidget *wid)
+        {
+            painted++;
+            QGraphicsTextItem::paint(painter, opt, wid);
+        }
+    };
+
+    Item *i = new Item;
+    i->painted = 0;
+    i->setPlainText("I AM A TROLL");
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    scene.addItem(i);
+    QApplication::processEvents();
+    QTRY_VERIFY(i->painted);
+    QApplication::processEvents();
+
+    i->painted = 0;
+    QColor col(Qt::red);
+    i->setDefaultTextColor(col);
+    QApplication::processEvents();
+    QTRY_COMPARE(i->painted, 1); //check that changing the color force an update
+
+    i->painted = false;
+    QImage image(400, 200, QImage::Format_RGB32);
+    image.fill(0);
+    QPainter painter(&image);
+    scene.render(&painter);
+    painter.end();
+    QCOMPARE(i->painted, 1);
+
+    int numRedPixel = 0;
+    QRgb rgb = col.rgb();
+    for (int y = 0; y < image.height(); ++y) {
+        for (int x = 0; x < image.width(); ++x) {
+            // Because of antialiasing we allow a certain range of errors here.
+            QRgb pixel = image.pixel(x, y);
+            if (qAbs((int)(pixel & 0xff) - (int)(rgb & 0xff)) +
+                qAbs((int)((pixel & 0xff00) >> 8) - (int)((rgb & 0xff00) >> 8)) +
+                qAbs((int)((pixel & 0xff0000) >> 16) - (int)((rgb & 0xff0000) >> 16)) <= 50) {
+                if (++numRedPixel >= 10) {
+                    return;
+                }
+            }
+        }
+    }
+    QCOMPARE(numRedPixel, -1); //color not found, FAIL!
+
+    i->painted = 0;
+    i->setDefaultTextColor(col);
+    QApplication::processEvents();
+    QCOMPARE(i->painted, 0); //same color as before should not trigger an update (QTBUG-6242)
+}
+
+void tst_QGraphicsItem::QTBUG_6738_missingUpdateWithSetParent()
+{
+    // In all 3 test cases below the reparented item should disappear
+    EventTester *parent = new EventTester;
+    EventTester *child = new EventTester(parent);
+    EventTester *child2 = new EventTester(parent);
+    EventTester *child3 = new EventTester(parent);
+    EventTester *child4 = new EventTester(parent);
+
+    child->setPos(10, 10);
+    child2->setPos(20, 20);
+    child3->setPos(30, 30);
+    child4->setPos(40, 40);
+
+    QGraphicsScene scene;
+    scene.addItem(parent);
+
+    MyGraphicsView view(&scene);
+    if(PlatformQuirks::isAutoMaximizing())
+        view.showFullScreen();
+    else
+        view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(view.repaints > 0);
+
+    // test case #1
+    view.reset();
+    child2->setVisible(false);
+    child2->setParentItem(child);
+
+    QTRY_VERIFY(view.repaints == 1);
+
+    // test case #2
+    view.reset();
+    child3->setOpacity(0.0);
+    child3->setParentItem(child);
+
+    QTRY_VERIFY(view.repaints == 1);
+
+    // test case #3
+    view.reset();
+    child4->setParentItem(child);
+    child4->setVisible(false);
+
+    QTRY_VERIFY(view.repaints == 1);
+}
+
+void tst_QGraphicsItem::QT_2653_fullUpdateDiscardingOpacityUpdate()
+{
+    QGraphicsScene scene(0, 0, 200, 200);
+    MyGraphicsView view(&scene);
+
+    EventTester *parentGreen = new EventTester();
+    parentGreen->setGeometry(QRectF(20, 20, 100, 100));
+    parentGreen->brush = Qt::green;
+
+    EventTester *childYellow = new EventTester(parentGreen);
+    childYellow->setGeometry(QRectF(10, 10, 50, 50));
+    childYellow->brush = Qt::yellow;
+
+    scene.addItem(parentGreen);
+
+    childYellow->setOpacity(0.0);
+    parentGreen->setOpacity(0.0);
+
+    // set any of the flags below to trigger a fullUpdate to reproduce the bug:
+    // ItemIgnoresTransformations, ItemClipsChildrenToShape, ItemIsSelectable
+    parentGreen->setFlag(QGraphicsItem::ItemIgnoresTransformations);
+
+    if (PlatformQuirks::isAutoMaximizing())
+        view.showFullScreen();
+    else
+        view.show();
+    QTest::qWaitForWindowShown(&view);
+    view.reset();
+
+    parentGreen->setOpacity(1.0);
+
+    QTRY_COMPARE(view.repaints, 1);
+
+    view.reset();
+    childYellow->repaints = 0;
+
+    childYellow->setOpacity(1.0);
+
+    QTRY_COMPARE(view.repaints, 1);
+    QTRY_COMPARE(childYellow->repaints, 1);
+}
+
+void tst_QGraphicsItem::QTBUG_7714_fullUpdateDiscardingOpacityUpdate2()
+{
+    QGraphicsScene scene(0, 0, 200, 200);
+    MyGraphicsView view(&scene);
+    MyGraphicsView origView(&scene);
+
+    EventTester *parentGreen = new EventTester();
+    parentGreen->setGeometry(QRectF(20, 20, 100, 100));
+    parentGreen->brush = Qt::green;
+
+    EventTester *childYellow = new EventTester(parentGreen);
+    childYellow->setGeometry(QRectF(10, 10, 50, 50));
+    childYellow->brush = Qt::yellow;
+
+    scene.addItem(parentGreen);
+
+    origView.show();
+    QTest::qWaitForWindowShown(&origView);
+    origView.setGeometry(origView.width() + 20, 20,
+                         origView.width(), origView.height());
+
+    parentGreen->setFlag(QGraphicsItem::ItemIgnoresTransformations);
+
+    origView.reset();
+    childYellow->setOpacity(0.0);
+
+    QTRY_COMPARE(origView.repaints, 1);
+
+    view.show();
+
+    QTest::qWaitForWindowShown(&view);
+    view.reset();
+    origView.reset();
+
+    childYellow->setOpacity(1.0);
+
+    QTRY_COMPARE(origView.repaints, 1);
+    QTRY_COMPARE(view.repaints, 1);
+}
+
+void tst_QGraphicsItem::QT_2649_focusScope()
+{
+    QGraphicsScene *scene = new QGraphicsScene;
+
+    QGraphicsRectItem *subFocusItem = new QGraphicsRectItem;
+    subFocusItem->setFlags(QGraphicsItem::ItemIsFocusable);
+    subFocusItem->setFocus();
+    QCOMPARE(subFocusItem->focusItem(), (QGraphicsItem *)subFocusItem);
+
+    QGraphicsRectItem *scope = new QGraphicsRectItem;
+    scope->setFlags(QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemIsFocusScope);
+    scope->setFocus();
+    subFocusItem->setParentItem(scope);
+    QCOMPARE(subFocusItem->focusItem(), (QGraphicsItem *)subFocusItem);
+    QCOMPARE(subFocusItem->focusScopeItem(), (QGraphicsItem *)0);
+    QCOMPARE(scope->focusItem(), (QGraphicsItem *)subFocusItem);
+    QCOMPARE(scope->focusScopeItem(), (QGraphicsItem *)subFocusItem);
+
+    QGraphicsRectItem *rootItem = new QGraphicsRectItem;
+    rootItem->setFlags(QGraphicsItem::ItemIsFocusable);
+    scope->setParentItem(rootItem);
+    QCOMPARE(rootItem->focusItem(), (QGraphicsItem *)subFocusItem);
+    QCOMPARE(rootItem->focusScopeItem(), (QGraphicsItem *)0);
+    QCOMPARE(subFocusItem->focusItem(), (QGraphicsItem *)subFocusItem);
+    QCOMPARE(subFocusItem->focusScopeItem(), (QGraphicsItem *)0);
+    QCOMPARE(scope->focusItem(), (QGraphicsItem *)subFocusItem);
+    QCOMPARE(scope->focusScopeItem(), (QGraphicsItem *)subFocusItem);
+
+    scene->addItem(rootItem);
+
+    QEvent windowActivate(QEvent::WindowActivate);
+    qApp->sendEvent(scene, &windowActivate);
+    scene->setFocus();
+
+    QCOMPARE(rootItem->focusItem(), (QGraphicsItem *)subFocusItem);
+    QCOMPARE(scope->focusItem(), (QGraphicsItem *)subFocusItem);
+    QCOMPARE(subFocusItem->focusItem(), (QGraphicsItem *)subFocusItem);
+    QCOMPARE(rootItem->focusScopeItem(), (QGraphicsItem *)0);
+    QCOMPARE(scope->focusScopeItem(), (QGraphicsItem *)subFocusItem);
+    QCOMPARE(subFocusItem->focusScopeItem(), (QGraphicsItem *)0);
+    QVERIFY(subFocusItem->hasFocus());
+
+    scope->hide();
+
+    QCOMPARE(rootItem->focusItem(), (QGraphicsItem *)0);
+    QCOMPARE(scope->focusItem(), (QGraphicsItem *)0);
+    QCOMPARE(subFocusItem->focusItem(), (QGraphicsItem *)0);
+    QCOMPARE(rootItem->focusScopeItem(), (QGraphicsItem *)0);
+    QCOMPARE(scope->focusScopeItem(), (QGraphicsItem *)subFocusItem);
+    QCOMPARE(subFocusItem->focusScopeItem(), (QGraphicsItem *)0);
+    QVERIFY(!subFocusItem->hasFocus());
+
+    scope->show();
+
+    QCOMPARE(rootItem->focusItem(), (QGraphicsItem *)subFocusItem);
+    QCOMPARE(scope->focusItem(), (QGraphicsItem *)subFocusItem);
+    QCOMPARE(subFocusItem->focusItem(), (QGraphicsItem *)subFocusItem);
+    QCOMPARE(rootItem->focusScopeItem(), (QGraphicsItem *)0);
+    QCOMPARE(scope->focusScopeItem(), (QGraphicsItem *)subFocusItem);
+    QCOMPARE(subFocusItem->focusScopeItem(), (QGraphicsItem *)0);
+    QVERIFY(subFocusItem->hasFocus());
+
+    // This should not crash
+    scope->hide();
+    delete scene;
+}
+
+class MyGraphicsItemWithItemChange : public QGraphicsWidget
+{
+public:
+    MyGraphicsItemWithItemChange(QGraphicsItem *parent = 0) : QGraphicsWidget(parent)
+    {}
+
+    QVariant itemChange(GraphicsItemChange change, const QVariant &value)
+    {
+        if (change == QGraphicsItem::ItemSceneHasChanged) {
+            foreach (QGraphicsView *view, scene()->views()) {
+                //We trigger a sort of unindexed items in the BSP
+                view->sceneRect();
+            }
+        }
+        return QGraphicsWidget::itemChange(change, value);
+    }
+};
+
+void tst_QGraphicsItem::sortItemsWhileAdding()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget grandGrandParent;
+    grandGrandParent.resize(200, 200);
+    scene.addItem(&grandGrandParent);
+    QGraphicsWidget grandParent;
+    grandParent.resize(200, 200);
+    QGraphicsWidget parent(&grandParent);
+    parent.resize(200, 200);
+    MyGraphicsItemWithItemChange item(&parent);
+    grandParent.setParentItem(&grandGrandParent);
+}
+
+void tst_QGraphicsItem::doNotMarkFullUpdateIfNotInScene()
+{
+    struct Item : public QGraphicsTextItem
+    {
+        int painted;
+        void paint(QPainter *painter, const QStyleOptionGraphicsItem *opt, QWidget *wid)
+        {
+            painted++;
+            QGraphicsTextItem::paint(painter, opt, wid);
+        }
+    };
+    QGraphicsScene scene;
+    MyGraphicsView view(&scene);
+    Item *item = new Item;
+    item->painted = 0;
+    item->setPlainText("Grandparent");
+    Item *item2 = new Item;
+    item2->setPlainText("parent");
+    item2->painted = 0;
+    Item *item3 = new Item;
+    item3->setPlainText("child");
+    item3->painted = 0;
+    QGraphicsOpacityEffect *effect = new QGraphicsOpacityEffect;
+    effect->setOpacity(0.5);
+    item2->setGraphicsEffect(effect);
+    item3->setParentItem(item2);
+    item2->setParentItem(item);
+    scene.addItem(item);
+    if(PlatformQuirks::isAutoMaximizing())
+        view.showFullScreen();
+    else
+        view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_COMPARE(view.repaints, 1);
+    QTRY_COMPARE(item->painted, 1);
+    QTRY_COMPARE(item2->painted, 1);
+    QTRY_COMPARE(item3->painted, 1);
+    item2->update();
+    QApplication::processEvents();
+    QTRY_COMPARE(item->painted, 2);
+    QTRY_COMPARE(item2->painted, 2);
+    QTRY_COMPARE(item3->painted, 2);
+    item2->update();
+    QApplication::processEvents();
+    QTRY_COMPARE(item->painted, 3);
+    QTRY_COMPARE(item2->painted, 3);
+    QTRY_COMPARE(item3->painted, 3);
+}
+
+void tst_QGraphicsItem::itemDiesDuringDraggingOperation()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsRectItem *item = new QGraphicsRectItem(QRectF(0, 0, 100, 100));
+    item->setFlag(QGraphicsItem::ItemIsMovable);
+    item->setAcceptDrops(true);
+    scene.addItem(item);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget *)&view);
+    QGraphicsSceneDragDropEvent dragEnter(QEvent::GraphicsSceneDragEnter);
+    dragEnter.setScenePos(item->boundingRect().center());
+    QApplication::sendEvent(&scene, &dragEnter);
+    QGraphicsSceneDragDropEvent event(QEvent::GraphicsSceneDragMove);
+    event.setScenePos(item->boundingRect().center());
+    QApplication::sendEvent(&scene, &event);
+    QVERIFY(QGraphicsScenePrivate::get(&scene)->dragDropItem == item);
+    delete item;
+    QVERIFY(QGraphicsScenePrivate::get(&scene)->dragDropItem == 0);
+}
+
+void tst_QGraphicsItem::QTBUG_12112_focusItem()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsRectItem *item1 = new QGraphicsRectItem(0, 0, 20, 20);
+    item1->setFlag(QGraphicsItem::ItemIsFocusable);
+    QGraphicsRectItem *item2 = new QGraphicsRectItem(20, 20, 20, 20);
+    item2->setFlag(QGraphicsItem::ItemIsFocusable);
+    item1->setFocus();
+    scene.addItem(item2);
+    scene.addItem(item1);
+
+    view.show();
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget *)&view);
+
+    QVERIFY(item1->focusItem());
+    QVERIFY(!item2->focusItem());
+
+    item2->setFocus();
+    QVERIFY(!item1->focusItem());
+    QVERIFY(item2->focusItem());
+}
+
+void tst_QGraphicsItem::QTBUG_13473_sceneposchange()
+{
+    ScenePosChangeTester* parent = new ScenePosChangeTester;
+    ScenePosChangeTester* child = new ScenePosChangeTester(parent);
+
+    // parent's disabled ItemSendsGeometryChanges flag must not affect
+    // child's scene pos change notifications
+    parent->setFlag(QGraphicsItem::ItemSendsGeometryChanges, false);
+    child->setFlag(QGraphicsItem::ItemSendsScenePositionChanges, true);
+
+    QGraphicsScene scene;
+    scene.addItem(parent);
+
+    // ignore uninteresting changes
+    parent->clear();
+    child->clear();
+
+    // move
+    parent->moveBy(1.0, 1.0);
+    QCOMPARE(child->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 1);
+
+    // transform
+    parent->setTransform(QTransform::fromScale(0.5, 0.5));
+    QCOMPARE(child->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 2);
+}
+
+class MyGraphicsWidget : public QGraphicsWidget {
+Q_OBJECT
+public:
+    MyGraphicsWidget()
+        : QGraphicsWidget(0)
+    {
+        QGraphicsLinearLayout *lay = new QGraphicsLinearLayout(Qt::Vertical);
+        QLatin1String wiseWords("AZ BUKI VEDI");
+        QString sentence(wiseWords);
+        QStringList words = sentence.split(QLatin1Char(' '), QString::SkipEmptyParts);
+        for (int i = 0; i < words.count(); ++i) {
+            QGraphicsProxyWidget *proxy = new QGraphicsProxyWidget(this);
+            QLabel *label = new QLabel(words.at(i));
+            proxy->setWidget(label);
+            proxy->setFocusPolicy(Qt::StrongFocus);
+            proxy->setFlag(QGraphicsItem::ItemAcceptsInputMethod, true);
+            if (i%2 == 0)
+                proxy->setVisible(false);
+            proxy->setFocus();
+            lay->addItem(proxy);
+        }
+        setLayout(lay);
+    }
+
+};
+
+class MyWidgetWindow : public QGraphicsWidget
+{
+public:
+    MyWidgetWindow()
+        : QGraphicsWidget(0, Qt::Window)
+    {
+        QGraphicsLinearLayout *lay = new QGraphicsLinearLayout(Qt::Vertical);
+        MyGraphicsWidget *widget = new MyGraphicsWidget();
+        lay->addItem(widget);
+        setLayout(lay);
+    }
+};
+
+void tst_QGraphicsItem::QTBUG_16374_crashInDestructor()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    MyWidgetWindow win;
+    scene.addItem(&win);
+
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+}
+
+void tst_QGraphicsItem::QTBUG_20699_focusScopeCrash()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsPixmapItem fs;
+    fs.setFlags(QGraphicsItem::ItemIsFocusScope | QGraphicsItem::ItemIsFocusable);
+    scene.addItem(&fs);
+    QGraphicsPixmapItem* fs2 = new QGraphicsPixmapItem(&fs);
+    fs2->setFlags(QGraphicsItem::ItemIsFocusScope | QGraphicsItem::ItemIsFocusable);
+    QGraphicsPixmapItem* fi2 = new QGraphicsPixmapItem(&fs);
+    fi2->setFlags(QGraphicsItem::ItemIsFocusable);
+    QGraphicsPixmapItem* fi = new QGraphicsPixmapItem(fs2);
+    fi->setFlags(QGraphicsItem::ItemIsFocusable);
+    fs.setFocus();
+    fi->setFocus();
+
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    fi->setParentItem(fi2);
+    fi->setFocus();
+    fs.setFocus();
+    fi->setParentItem(fs2);
+    fi->setFocus();
+    fs2->setFocus();
+    fs.setFocus();
+    fi->setParentItem(fi2);
+    fi->setFocus();
+    fs.setFocus();
+}
+
+QTEST_MAIN(tst_QGraphicsItem)
+#include "tst_qgraphicsitem.moc"
diff --git a/tests/auto/widgets/graphicsview/qgraphicsitemanimation/.gitignore b/tests/auto/widgets/graphicsview/qgraphicsitemanimation/.gitignore
new file mode 100644
index 0000000000..fe9fe0b8ec
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsitemanimation/.gitignore
@@ -0,0 +1 @@
+tst_qgraphicsitemanimation
diff --git a/tests/auto/widgets/graphicsview/qgraphicsitemanimation/qgraphicsitemanimation.pro b/tests/auto/widgets/graphicsview/qgraphicsitemanimation/qgraphicsitemanimation.pro
new file mode 100644
index 0000000000..5d723da32e
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsitemanimation/qgraphicsitemanimation.pro
@@ -0,0 +1,6 @@
+load(qttest_p4)
+QT += widgets
+SOURCES  += tst_qgraphicsitemanimation.cpp
+DEFINES += QT_NO_CAST_TO_ASCII
+CONFIG += parallel_test
+
diff --git a/tests/auto/widgets/graphicsview/qgraphicsitemanimation/tst_qgraphicsitemanimation.cpp b/tests/auto/widgets/graphicsview/qgraphicsitemanimation/tst_qgraphicsitemanimation.cpp
new file mode 100644
index 0000000000..f7cf393253
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsitemanimation/tst_qgraphicsitemanimation.cpp
@@ -0,0 +1,192 @@
+/****************************************************************************
+**
+** 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 <qgraphicsitemanimation.h>
+#include <QtCore/qtimeline.h>
+#include <QtGui/qmatrix.h>
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QGraphicsItemAnimation : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void construction();
+    void linearMove();
+    void linearRotation();
+    void checkReturnedLists();
+    void overwriteValueForStep();
+    void setTimeLine();
+};
+
+void tst_QGraphicsItemAnimation::construction()
+{
+    QGraphicsItemAnimation animation;
+    QVERIFY(!animation.item());
+    QVERIFY(!animation.timeLine());
+    QCOMPARE(animation.posAt(0), QPointF());
+    QCOMPARE(animation.posAt(0.5), QPointF());
+    QCOMPARE(animation.posAt(1), QPointF());
+    QCOMPARE(animation.matrixAt(0), QMatrix());
+    QCOMPARE(animation.matrixAt(0.5), QMatrix());
+    QCOMPARE(animation.matrixAt(1), QMatrix());
+    QCOMPARE(animation.rotationAt(0), qreal(0.0));
+    QCOMPARE(animation.rotationAt(0.5), qreal(0.0));
+    QCOMPARE(animation.rotationAt(1), qreal(0.0));
+    QCOMPARE(animation.xTranslationAt(0), qreal(0.0));
+    QCOMPARE(animation.xTranslationAt(0.5), qreal(0.0));
+    QCOMPARE(animation.xTranslationAt(1), qreal(0.0));
+    QCOMPARE(animation.yTranslationAt(0), qreal(0.0));
+    QCOMPARE(animation.yTranslationAt(0.5), qreal(0.0));
+    QCOMPARE(animation.yTranslationAt(1), qreal(0.0));
+    QCOMPARE(animation.verticalScaleAt(0), qreal(1.0));
+    QCOMPARE(animation.horizontalScaleAt(0), qreal(1.0));
+    QCOMPARE(animation.verticalShearAt(0), qreal(0.0));
+    QCOMPARE(animation.horizontalShearAt(0), qreal(0.0));
+    animation.clear(); // don't crash
+}
+
+void tst_QGraphicsItemAnimation::linearMove()
+{
+    QGraphicsItemAnimation animation;
+
+    for (int i = 0; i <= 10; ++i) {
+        QCOMPARE(animation.posAt(i / 10.0).x(), qreal(0));
+        QCOMPARE(animation.posAt(i / 10.0).y(), qreal(0));
+    }
+
+    animation.setPosAt(1, QPointF(10, -10));
+
+    for (int i = 0; i <= 10; ++i) {
+        QCOMPARE(animation.posAt(i / 10.0).x(), qreal(i));
+        QCOMPARE(animation.posAt(i / 10.0).y(), qreal(-i));
+    }
+
+    animation.setPosAt(2, QPointF(10, -10));
+
+    QCOMPARE(animation.posAt(11).x(), qreal(10));
+}
+
+void tst_QGraphicsItemAnimation::linearRotation()
+{
+    QGraphicsItemAnimation animation;
+    animation.setRotationAt(1, 1);
+
+    for (int i = 0; i <= 10; ++i)
+        QCOMPARE(animation.rotationAt(i / 10.0), qreal(i / 10.0));
+}
+
+void tst_QGraphicsItemAnimation::checkReturnedLists()
+{
+    QGraphicsItemAnimation animation;
+
+    animation.setPosAt(1.0, QPointF(10, -10));
+    animation.setPosAt(0.5, QPointF(5, -5));
+
+    animation.setRotationAt(0.3, 2.3);
+    animation.setTranslationAt(0.3, 15, 15);
+    animation.setScaleAt(0.3, 2.5, 1.8);
+    animation.setShearAt(0.3, 5, 5);
+
+    QCOMPARE(animation.posList().at(0), (QPair<qreal, QPointF>(0.5, QPointF(5, -5))));
+    QCOMPARE(animation.posList().at(1), (QPair<qreal, QPointF>(1.0, QPointF(10, -10))));
+    QCOMPARE(animation.rotationList().at(0), (QPair<qreal, qreal>(0.3, 2.3)));
+    QCOMPARE(animation.translationList().at(0), (QPair<qreal, QPointF>(0.3, QPointF(15, 15))));
+    QCOMPARE(animation.scaleList().at(0), (QPair<qreal, QPointF>(0.3, QPointF(2.5, 1.8))));
+    QCOMPARE(animation.shearList().at(0), (QPair<qreal, QPointF>(0.3, QPointF(5, 5))));
+
+    QCOMPARE(animation.posList().size(), 2);
+    QCOMPARE(animation.rotationList().size(), 1);
+    QCOMPARE(animation.translationList().size(), 1);
+    QCOMPARE(animation.scaleList().size(), 1);
+    QCOMPARE(animation.shearList().size(), 1);
+}
+
+void tst_QGraphicsItemAnimation::overwriteValueForStep()
+{
+    QGraphicsItemAnimation animation;
+
+    for (int i=0; i<3; i++){
+        animation.setPosAt(0.3, QPointF(3, -3.1));
+        animation.setRotationAt(0.3, 2.3);
+        animation.setTranslationAt(0.3, 15, 15);
+        animation.setScaleAt(0.3, 2.5, 1.8);
+        animation.setShearAt(0.3, 5, 5);
+
+        QCOMPARE(animation.posList().size(), 1);
+        QCOMPARE(animation.rotationList().size(), 1);
+        QCOMPARE(animation.translationList().size(), 1);
+        QCOMPARE(animation.scaleList().size(), 1);
+        QCOMPARE(animation.shearList().size(), 1);
+    }
+}
+
+void tst_QGraphicsItemAnimation::setTimeLine()
+{
+    QGraphicsItemAnimation animation;
+    QCOMPARE(animation.timeLine(), (QTimeLine *)0);
+
+    QPointer<QTimeLine> line1 = new QTimeLine;
+    animation.setTimeLine(line1);
+    QCOMPARE(animation.timeLine(), (QTimeLine *)line1);
+    animation.setTimeLine(line1);
+    QVERIFY(line1);
+    QCOMPARE(animation.timeLine(), (QTimeLine *)line1);
+
+    animation.setTimeLine(0);
+    QCOMPARE(animation.timeLine(), (QTimeLine *)0);
+    QVERIFY(!line1);
+
+    QTimeLine *line2 = new QTimeLine;
+    animation.setTimeLine(line2);
+    QCOMPARE(animation.timeLine(), (QTimeLine *)line2);
+
+    delete line2;
+    QCOMPARE(animation.timeLine(), (QTimeLine *)0);
+}
+
+QTEST_MAIN(tst_QGraphicsItemAnimation)
+#include "tst_qgraphicsitemanimation.moc"
diff --git a/tests/auto/widgets/graphicsview/qgraphicslayout/.gitignore b/tests/auto/widgets/graphicsview/qgraphicslayout/.gitignore
new file mode 100644
index 0000000000..b3b27f68a1
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicslayout/.gitignore
@@ -0,0 +1 @@
+tst_qgraphicslayout
diff --git a/tests/auto/widgets/graphicsview/qgraphicslayout/qgraphicslayout.pro b/tests/auto/widgets/graphicsview/qgraphicslayout/qgraphicslayout.pro
new file mode 100644
index 0000000000..ea176c98fe
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicslayout/qgraphicslayout.pro
@@ -0,0 +1,9 @@
+############################################################
+# Project file for autotest for file qlayout.h
+############################################################
+
+load(qttest_p4)
+QT += widgets
+SOURCES += tst_qgraphicslayout.cpp
+DEFINES += QT_USE_USING_NAMESPACE
+CONFIG += parallel_test
diff --git a/tests/auto/widgets/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp b/tests/auto/widgets/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp
new file mode 100644
index 0000000000..3eac04e4e5
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp
@@ -0,0 +1,992 @@
+/****************************************************************************
+**
+** 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 <QtGui>
+#include <QtWidgets>
+#include <math.h>
+
+//TESTED_CLASS=QGraphicsLayout
+//TESTED_FILES=
+
+class tst_QGraphicsLayout : public QObject
+{
+Q_OBJECT
+
+public:
+    tst_QGraphicsLayout();
+    virtual ~tst_QGraphicsLayout();
+
+private slots:
+    void sizeHints();
+    void compressLayoutRequest();
+    void automaticReparenting();
+    void verifyActivate();
+    void invalidate();
+    void constructors();
+    void alternativeLayoutItems();
+    void ownership();
+};
+
+tst_QGraphicsLayout::tst_QGraphicsLayout()
+{
+}
+
+tst_QGraphicsLayout::~tst_QGraphicsLayout()
+{
+}
+
+void tst_QGraphicsLayout::sizeHints()
+{
+
+    QGraphicsView view;
+    QGraphicsScene scene;
+    QGraphicsWidget *window = new QGraphicsWidget();
+    scene.addItem(window);
+    QGraphicsLinearLayout *lout = new QGraphicsLinearLayout(window);
+    lout->setContentsMargins(0,0,0,0);
+    QGraphicsWidget *gw = new QGraphicsWidget(window);
+    gw->setMinimumSize(QSizeF(10,10));
+    gw->setPreferredSize(QSizeF(100,100));
+    gw->setMaximumSize(QSizeF(500,500));
+    lout->addItem(gw);
+    QCOMPARE(lout->effectiveSizeHint(Qt::MinimumSize), gw->effectiveSizeHint(Qt::MinimumSize));
+    QCOMPARE(lout->effectiveSizeHint(Qt::PreferredSize), gw->effectiveSizeHint(Qt::PreferredSize));
+    QCOMPARE(lout->effectiveSizeHint(Qt::MaximumSize), gw->effectiveSizeHint(Qt::MaximumSize));
+
+}
+
+enum FunctionType {
+    SetGeometry = 0,
+    Invalidate,
+    NumFunctionTypes
+};
+
+
+
+class TestGraphicsWidget : public QGraphicsWidget {
+public:
+    TestGraphicsWidget(QGraphicsWidget *parent = 0) : QGraphicsWidget(parent)
+    { }
+
+    bool event(QEvent *e) {
+        ++(m_eventCount[int(e->type())]);
+        return QGraphicsWidget::event(e);
+    }
+
+    int eventCount(QEvent::Type type) {
+        return m_eventCount.value(int(type));
+    }
+
+    void clearEventCount() {
+        m_eventCount.clear();
+    }
+
+    void clearCounters() {
+        m_eventCount.clear();
+        functionCount.clear();
+    }
+
+    void setGeometry(const QRectF &rect)
+    {
+        QGraphicsWidget::setGeometry(rect);
+        ++(functionCount[SetGeometry]);
+    }
+
+    void callUpdateGeometry()
+    {
+        // updateGeometry() is protected
+        QGraphicsWidget::updateGeometry();
+    }
+    QMap<FunctionType, int> functionCount;
+private:
+    QMap<int, int> m_eventCount;
+};
+
+void tst_QGraphicsLayout::compressLayoutRequest()
+{
+    QGraphicsView view;
+    QGraphicsScene scene;
+    TestGraphicsWidget *tw = new TestGraphicsWidget();
+    scene.addItem(tw);
+    view.show();
+
+    QTest::qWaitForWindowShown(&view);
+    QGraphicsLinearLayout *lout = new QGraphicsLinearLayout(tw);
+    for (int i = 0; i < 4; ++i) {
+        QGraphicsWidget *gw = new QGraphicsWidget(tw);
+        gw->setPreferredSize(QSizeF(50, 50));
+        lout->addItem(gw);
+    }
+    QApplication::processEvents();
+    QCOMPARE(tw->eventCount(QEvent::LayoutRequest), 1);
+}
+
+void tst_QGraphicsLayout::automaticReparenting()
+{
+    QGraphicsView view;
+    QGraphicsScene scene;
+    {
+        QGraphicsWidget *w = new QGraphicsWidget();
+        QGraphicsLinearLayout *l = new QGraphicsLinearLayout(w);
+        QGraphicsWidget *w1 = new QGraphicsWidget;
+        l->addItem(w1);
+        scene.addItem(w);
+        QCOMPARE(w1->parentWidget(), w);
+        delete w;
+    }
+    {
+        QGraphicsWidget *w = new QGraphicsWidget();
+        QGraphicsLinearLayout *l = new QGraphicsLinearLayout(w);
+        QGraphicsWidget *w1 = new QGraphicsWidget;
+        l->addItem(w1);
+        scene.addItem(w);
+        QCOMPARE(w1->parentWidget(), w);
+
+        QGraphicsWidget *ww = new QGraphicsWidget();
+        QGraphicsLinearLayout *l1 = new QGraphicsLinearLayout(ww);
+#if !defined(Q_OS_MAC) && defined(QT_DEBUG)
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsLayout::addChildLayoutItem: QGraphicsWidget \"\""
+                             " in wrong parent; moved to correct parent");
+#endif
+        l1->addItem(w1);
+        QCOMPARE(w1->parentWidget(), ww);
+        delete w;
+    }
+
+    QGraphicsWidget *window = new QGraphicsWidget();
+    scene.addItem(window);
+    view.show();
+    QGraphicsLinearLayout *l1 = new QGraphicsLinearLayout();
+    QGraphicsWidget *w1 = new QGraphicsWidget();
+    l1->addItem(w1);
+    QGraphicsWidget *w2 = new QGraphicsWidget();
+    l1->addItem(w2);
+    QCOMPARE(w1->parentItem(), static_cast<QGraphicsItem*>(0));
+    QCOMPARE(w2->parentItem(), static_cast<QGraphicsItem*>(0));
+    scene.addItem(w1);
+    QCOMPARE(w1->parentItem(), static_cast<QGraphicsItem*>(0));
+    window->setLayout(l1);
+    QCOMPARE(w1->parentItem(), static_cast<QGraphicsItem*>(window));
+    QCOMPARE(w2->parentItem(), static_cast<QGraphicsItem*>(window));
+
+    // Sublayouts
+    QGraphicsLinearLayout *l2 = new QGraphicsLinearLayout();
+    QGraphicsWidget *w3 = new QGraphicsWidget();
+    l2->addItem(w3);
+    QGraphicsWidget *w4 = new QGraphicsWidget();
+    l2->addItem(w4);
+    QGraphicsLinearLayout *l3 = new QGraphicsLinearLayout();
+    l2->addItem(l3);
+    QGraphicsWidget *window2 = new QGraphicsWidget();
+    scene.addItem(window2);
+    window2->setLayout(l2);
+
+    QCOMPARE(w3->parentItem(), static_cast<QGraphicsItem*>(window2));
+    QCOMPARE(w4->parentItem(), static_cast<QGraphicsItem*>(window2));
+
+    // graphics item with another parent
+    QGraphicsLinearLayout *l5 = new QGraphicsLinearLayout();
+    l5->addItem(w1);
+    l5->addItem(w2);
+    QCOMPARE(w1->parentItem(), static_cast<QGraphicsItem*>(window));
+    QCOMPARE(w2->parentItem(), static_cast<QGraphicsItem*>(window));
+    QGraphicsLinearLayout *l4 = new QGraphicsLinearLayout();
+    l4->addItem(l5);
+    QGraphicsWidget *window3 = new QGraphicsWidget();
+    scene.addItem(window3);
+    window3->setLayout(l4);
+
+    QCOMPARE(w1->parentItem(), static_cast<QGraphicsItem*>(window3));
+    QCOMPARE(w2->parentItem(), static_cast<QGraphicsItem*>(window3));
+}
+
+class TestLayout : public QGraphicsLinearLayout
+{
+    public:
+    TestLayout(QGraphicsLayoutItem *parent = 0)
+        : QGraphicsLinearLayout(parent)
+    {
+        setContentsMargins(0,0,0,0);
+        setSpacing(0);
+    }
+
+    void setGeometry(const QRectF &rect)
+    {
+        ++(functionCount[SetGeometry]);
+        QGraphicsLinearLayout::setGeometry(rect);
+    }
+
+    void invalidate()
+    {
+        ++(functionCount[Invalidate]);
+        QGraphicsLinearLayout::invalidate();
+    }
+
+    void clearCounters() {
+        functionCount.clear();
+    }
+
+    QMap<FunctionType, int> functionCount;
+};
+
+void tst_QGraphicsLayout::verifyActivate()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    QGraphicsWidget *window = new QGraphicsWidget();
+    scene.addItem(window);
+    TestLayout *lout = new TestLayout(window);
+    QGraphicsWidget *w = new QGraphicsWidget();
+    lout->addItem(w);
+    window->setLayout(lout);
+
+    QCOMPARE(lout->functionCount[SetGeometry], 0);
+    window->setVisible(false);
+    QCOMPARE(lout->functionCount[SetGeometry], 0);
+    window->setVisible(true);
+    // on polish or the first time a widget is shown, the widget is resized.
+    QCOMPARE(lout->functionCount[SetGeometry], 1);
+
+}
+
+static void clearAllCounters(TestGraphicsWidget *widget)
+{
+    if (!widget)
+        return;
+    widget->clearCounters();
+    TestLayout *layout = static_cast<TestLayout *>(widget->layout());
+    if (layout) {
+        layout->clearCounters();
+        for (int i = layout->count() - 1; i >=0; --i) {
+            QGraphicsLayoutItem *item = layout->itemAt(i);
+            if (item->isLayout()) {
+                // ### Not used ATM
+                //TestLayout *lay = static_cast<TestLayout*>(static_cast<QGraphicsLayout*>(item));
+                //clearAllCounters(lay);
+            } else {
+                TestGraphicsWidget *wid = static_cast<TestGraphicsWidget *>(item);
+                clearAllCounters(wid);
+            }
+        }
+    }
+}
+
+static void activateAndReset(TestGraphicsWidget *widget)
+{
+    QApplication::sendPostedEvents();
+    QApplication::processEvents();
+    if (widget->layout())
+        widget->layout()->activate();
+    clearAllCounters(widget);
+}
+
+
+void tst_QGraphicsLayout::invalidate()
+{
+    QGraphicsLayout::setInstantInvalidatePropagation(true);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    TestGraphicsWidget *a = new TestGraphicsWidget;
+    a->setData(0, QString("a"));
+    scene.addItem(a);
+    TestLayout *alay = new TestLayout(a);
+    TestGraphicsWidget *b = new TestGraphicsWidget;
+    b->setData(0, QString("b"));
+    alay->addItem(b);
+    TestLayout *blay = new TestLayout(b);
+    TestGraphicsWidget *e = new TestGraphicsWidget;
+    e->setData(0, QString("e"));
+    blay->addItem(e);
+
+
+    TestGraphicsWidget *c = new TestGraphicsWidget;
+    c->setData(0, QString("c"));
+    alay->addItem(c);
+    TestLayout *clay = new TestLayout(c);
+    TestGraphicsWidget *f = new TestGraphicsWidget;
+    f->setData(0, QString("f"));
+    clay->addItem(f);
+
+    TestGraphicsWidget *d = new TestGraphicsWidget;
+    d->setData(0, QString("d"));
+    alay->addItem(d);
+    TestLayout *dlay = new TestLayout(d);
+    TestGraphicsWidget *g = new TestGraphicsWidget;
+    g->setData(0, QString("g"));
+    dlay->addItem(g);
+
+    view.show();
+
+    {
+        clearAllCounters(a);
+
+        QCoreApplication::sendPostedEvents();
+        QCoreApplication::processEvents();
+
+        alay->activate();
+        QCOMPARE(alay->isActivated(), true);
+        QCOMPARE(blay->isActivated(), true);
+        QCOMPARE(clay->isActivated(), true);
+        QCOMPARE(dlay->isActivated(), true);
+    }
+
+    {
+        clearAllCounters(a);
+        e->callUpdateGeometry();
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), false);
+        QCOMPARE(clay->isActivated(), true);
+        QCOMPARE(dlay->isActivated(), true);
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+
+        // should only invalidate ascendants of e
+        QCOMPARE(blay->functionCount[Invalidate], 1);
+        QCOMPARE(alay->functionCount[Invalidate], 1);
+        // not siblings
+        QCOMPARE(clay->functionCount[Invalidate], 0);
+        QCOMPARE(dlay->functionCount[Invalidate], 0);
+
+        QApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+    }
+
+
+    {
+        activateAndReset(a);
+        f->callUpdateGeometry();
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), true);
+        QCOMPARE(clay->isActivated(), false);
+        QCOMPARE(dlay->isActivated(), true);
+
+        QCoreApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+
+        QCOMPARE(a->functionCount[SetGeometry], 1);
+        QCOMPARE(alay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(b->functionCount[SetGeometry], 1);
+        QCOMPARE(c->functionCount[SetGeometry], 1);
+        QCOMPARE(d->functionCount[SetGeometry], 1);
+        // Since nothing really changed, blay and dlay don't need
+        // to be resized.
+        QCOMPARE(blay->functionCount[SetGeometry], 0);
+        QCOMPARE(clay->functionCount[SetGeometry], 1);
+        QCOMPARE(dlay->functionCount[SetGeometry], 0);
+
+        QCOMPARE(f->functionCount[SetGeometry], 1);
+
+        QCOMPARE(a->size(), QSizeF(150, 50));
+    }
+
+    {
+        activateAndReset(a);
+        f->setPreferredSize(QSizeF(60,50));
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), true);
+        QCOMPARE(clay->isActivated(), false);
+        QCOMPARE(dlay->isActivated(), true);
+
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCoreApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+
+        QCOMPARE(a->functionCount[SetGeometry], 1);
+        QCOMPARE(alay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(b->functionCount[SetGeometry], 1);
+        QCOMPARE(c->functionCount[SetGeometry], 1);
+        QCOMPARE(d->functionCount[SetGeometry], 1);
+        // f actually got wider, need to rearrange its siblings
+        QCOMPARE(blay->functionCount[SetGeometry], 1);
+        QCOMPARE(clay->functionCount[SetGeometry], 1);
+        QCOMPARE(dlay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(e->functionCount[SetGeometry], 1);
+        QCOMPARE(f->functionCount[SetGeometry], 1);
+        QCOMPARE(g->functionCount[SetGeometry], 1);
+
+        QVERIFY(e->size().width() < f->size().width());
+        QVERIFY(g->size().width() < f->size().width());
+    }
+
+    {
+        // resize f so much that it'll force a resize of the top widget
+        // this will currently generate two setGeometry() calls on the child layout
+        // of the top widget.
+        activateAndReset(a);
+        f->setPreferredSize(QSizeF());
+        f->setMinimumSize(QSizeF(200,50));
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), true);
+        QCOMPARE(clay->isActivated(), false);
+        QCOMPARE(dlay->isActivated(), true);
+
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCoreApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+
+        QCOMPARE(a->functionCount[SetGeometry], 1);
+
+        /* well, ideally one call to setGeometry(), but it will currently
+         * get two calls to setGeometry():
+         *   1. The first LayoutRequest will call activate() - that will call
+         *      setGeometry() on the layout. This geometry will be based on
+         *      the widget geometry which is not correct at this moment.
+         *      (it is still 150 wide)
+         *   2. Next, we check if the widget is top level, and then we call
+         *      parentWidget->resize(parentWidget->size());
+         *      This will be adjusted to be minimum 200 pixels wide.
+         *      The new size will then be propagated down to the layout
+         *
+         */
+        QCOMPARE(alay->functionCount[SetGeometry], 2);
+
+        QCOMPARE(b->functionCount[SetGeometry], 2);
+        QCOMPARE(c->functionCount[SetGeometry], 2);
+        QCOMPARE(d->functionCount[SetGeometry], 2);
+        // f actually got wider, need to rearrange its siblings
+        QCOMPARE(blay->functionCount[SetGeometry], 1);
+        QCOMPARE(clay->functionCount[SetGeometry], 1);
+        QCOMPARE(dlay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(e->functionCount[SetGeometry], 1);
+        QCOMPARE(f->functionCount[SetGeometry], 1);
+        QCOMPARE(g->functionCount[SetGeometry], 1);
+
+        QVERIFY(e->size().width() < f->size().width());
+        QVERIFY(g->size().width() < f->size().width());
+    }
+
+    {
+        f->setPreferredSize(QSizeF());
+        f->setMinimumSize(QSizeF());
+        a->adjustSize();
+        activateAndReset(a);
+        // update two different leaf widgets,
+        // eventCount and functionCount should never be >= 2
+        e->callUpdateGeometry();
+        g->callUpdateGeometry();
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), false);
+        QCOMPARE(clay->isActivated(), true);
+        QCOMPARE(dlay->isActivated(), false);
+
+        QCoreApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 1);
+
+        QCOMPARE(a->functionCount[SetGeometry], 1);
+        QCOMPARE(alay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(b->functionCount[SetGeometry], 1);
+        QCOMPARE(c->functionCount[SetGeometry], 1);
+        QCOMPARE(d->functionCount[SetGeometry], 1);
+        // f actually got wider, need to rearrange its siblings
+        QCOMPARE(blay->functionCount[SetGeometry], 1);
+        QCOMPARE(clay->functionCount[SetGeometry], 0);
+        QCOMPARE(dlay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(e->functionCount[SetGeometry], 1);
+        QCOMPARE(f->functionCount[SetGeometry], 0);
+        QCOMPARE(g->functionCount[SetGeometry], 1);
+
+    }
+
+    QGraphicsLayout::setInstantInvalidatePropagation(false);
+}
+
+class Layout : public QGraphicsLayout
+{
+public:
+    Layout(QGraphicsLayoutItem *parentItem = 0) : QGraphicsLayout(parentItem) {}
+
+    void setGeometry(const QRectF &rect)
+    {
+        QGraphicsLayout::setGeometry(rect);
+    }
+
+    int count() const {
+        return 0;
+    }
+
+    QGraphicsLayoutItem *itemAt(int index) const {
+        Q_UNUSED(index);
+        return 0;
+    }
+
+    void removeAt(int index)
+    {
+        Q_UNUSED(index);
+    }
+
+protected:
+    QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const
+    {
+        Q_UNUSED(constraint);
+        Q_UNUSED(which);
+        return QSizeF(100,100);
+    }
+
+};
+
+void tst_QGraphicsLayout::constructors()
+{
+    // Strange test, but see the fix that was with this submit
+    QVector<Layout*> layouts;
+    for (int pass = 0; pass < 5; ++pass) {
+        Layout *lay = new Layout();
+        layouts << lay;
+        qreal left, top, right, bottom;
+        lay->getContentsMargins(&left, &top, &right, &bottom);
+        // Test if the style defaults are sane (should always be ints)
+        double intpart;
+        QVERIFY(modf(left, &intpart) == 0.0);
+        QVERIFY(modf(top, &intpart) == 0.0);
+        QVERIFY(modf(right, &intpart) == 0.0);
+        QVERIFY(modf(bottom, &intpart) == 0.0);
+
+        lay->setContentsMargins(1, 2, 4, 8);
+        lay->getContentsMargins(&left, &top, &right, &bottom);
+
+        QCOMPARE(int(left), 1);
+        QCOMPARE(int(top), 2);
+        QCOMPARE(int(right), 4);
+        QCOMPARE(int(bottom), 8);
+    }
+
+    qDeleteAll(layouts);
+}
+
+class AnimatedLayoutItem : public QGraphicsLayoutItem {
+public:
+    AnimatedLayoutItem(QGraphicsRectItem *item)
+    : QGraphicsLayoutItem()
+    {
+        setGraphicsItem(item);
+    }
+
+    void setGeometry(const QRectF &geom);
+
+    QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const;
+
+    inline QGraphicsRectItem *rectItem() {
+        return static_cast<QGraphicsRectItem *>(graphicsItem());
+    }
+
+    QRectF m_geom;
+private:
+    AnimatedLayoutItem() {}
+};
+
+void AnimatedLayoutItem::setGeometry(const QRectF &geom)
+{
+    QGraphicsLayoutItem::setGeometry(geom);
+}
+
+QSizeF AnimatedLayoutItem::sizeHint(Qt::SizeHint which, const QSizeF & /* constraint */) const
+{
+    switch (which) {
+    case Qt::MinimumSize:
+        return QSizeF(32,32);
+    case Qt::PreferredSize:
+        return QSizeF(160,90);
+    case Qt::MaximumSize:
+        return QSizeF(1000,1000);
+    default:
+        return QSizeF(300, 300);
+    }
+}
+
+class AnimatedLayout : public QObject, public QGraphicsLinearLayout {
+    Q_OBJECT
+public:
+    AnimatedLayout(QGraphicsWidget *widget) : QGraphicsLinearLayout(widget), m_timeline(500, this)
+    {
+        connect(&m_timeline, SIGNAL(valueChanged(qreal)), this, SLOT(valueChanged(qreal)));
+    }
+
+    void setGeometry(const QRectF &geom) {
+        fromGeoms.clear();
+        toGeoms.clear();
+        for (int i = 0; i < count(); ++i) {
+            fromGeoms << itemAt(i)->geometry();
+        }
+
+        QGraphicsLinearLayout::setGeometry(geom);
+
+        for (int i = 0; i < count(); ++i) {
+            toGeoms << itemAt(i)->geometry();
+        }
+        m_timeline.start();
+    }
+
+private slots:
+    void valueChanged(qreal value) {
+        for (int i = 0; i < fromGeoms.count(); ++i) {
+            QGraphicsLayoutItem *li = itemAt(i);
+            QRectF from = fromGeoms.at(i);
+            QRectF to = toGeoms.at(i);
+
+            QRectF geom(from.topLeft() + (to.topLeft() - from.topLeft()) * value,
+                        from.size() + (to.size() - from.size()) * value);
+            static_cast<QGraphicsRectItem*>(li->graphicsItem())->setRect(geom);
+        }
+    }
+private:
+    QTimeLine m_timeline;
+    QVector<QRectF> fromGeoms;
+    QVector<QRectF> toGeoms;
+};
+
+
+void tst_QGraphicsLayout::alternativeLayoutItems()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    QGraphicsWidget *window = new QGraphicsWidget;
+    scene.addItem(window);
+    AnimatedLayout *lout = new AnimatedLayout(window);
+    lout->setContentsMargins(0, 0, 0, 0);
+    lout->setSpacing(0);
+
+    QGraphicsRectItem *item1 = new QGraphicsRectItem;
+    AnimatedLayoutItem *li1 = new AnimatedLayoutItem(item1);
+    lout->addItem(li1);
+
+    QGraphicsRectItem *item2 = new QGraphicsRectItem;
+    AnimatedLayoutItem *li2 = new AnimatedLayoutItem(item2);
+    lout->addItem(li2);
+
+    QGraphicsRectItem *item3 = new QGraphicsRectItem;
+    AnimatedLayoutItem *li3 = new AnimatedLayoutItem(item3);
+    lout->addItem(li3);
+
+    window->setLayout(lout);
+
+    window->setGeometry(0, 0, 99, 99);
+    view.setSceneRect(QRectF(-10, -10, 110, 110));
+    view.resize(150, 150);
+    view.show();
+
+    QTRY_COMPARE(static_cast<QGraphicsRectItem*>(li1->graphicsItem())->rect(), QRectF( 0, 0, 33, 99));
+    QTRY_COMPARE(static_cast<QGraphicsRectItem*>(li2->graphicsItem())->rect(), QRectF(33, 0, 33, 99));
+    QTRY_COMPARE(static_cast<QGraphicsRectItem*>(li3->graphicsItem())->rect(), QRectF(66, 0, 33, 99));
+
+    lout->setOrientation(Qt::Vertical);
+
+    QTRY_COMPARE(static_cast<QGraphicsRectItem*>(li1->graphicsItem())->rect(), QRectF(0, 0,  99, 33));
+    QTRY_COMPARE(static_cast<QGraphicsRectItem*>(li2->graphicsItem())->rect(), QRectF(0, 33, 99, 33));
+    QTRY_COMPARE(static_cast<QGraphicsRectItem*>(li3->graphicsItem())->rect(), QRectF(0, 66, 99, 33));
+
+}
+
+class CustomLayoutItem : public QGraphicsLayoutItem {
+public:
+    CustomLayoutItem(QSet<QGraphicsLayoutItem*> *destructedSet)
+    : QGraphicsLayoutItem()
+    {
+        m_destructedSet = destructedSet;
+        setOwnedByLayout(true);
+    }
+
+    QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const;
+
+    ~CustomLayoutItem() {
+        m_destructedSet->insert(this);
+    }
+private:
+    QSet<QGraphicsLayoutItem*> *m_destructedSet;
+};
+
+QSizeF CustomLayoutItem::sizeHint(Qt::SizeHint which, const QSizeF & /* constraint */) const
+{
+    switch (which) {
+    case Qt::MinimumSize:
+        return QSizeF(32,32);
+    case Qt::PreferredSize:
+        return QSizeF(160,90);
+    case Qt::MaximumSize:
+        return QSizeF(1000,1000);
+    default:
+        return QSizeF(300, 300);
+    }
+}
+
+class CustomGraphicsWidget : public QGraphicsWidget {
+public:
+    CustomGraphicsWidget(QSet<QGraphicsLayoutItem*> *destructedSet = 0)
+    : QGraphicsWidget()
+    {
+        m_destructedSet = destructedSet;
+    }
+
+    QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const;
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget * = 0)
+    {
+        const QRect r = option->rect.adjusted(0, 0, -1, -1);
+        painter->drawLine(r.topLeft(), r.bottomRight());
+        painter->drawLine(r.bottomLeft(), r.topRight());
+        painter->drawRect(r);
+    }
+
+    ~CustomGraphicsWidget() {
+        if (m_destructedSet)
+            m_destructedSet->insert(this);
+    }
+private:
+    QSet<QGraphicsLayoutItem*> *m_destructedSet;
+};
+
+QSizeF CustomGraphicsWidget::sizeHint(Qt::SizeHint which, const QSizeF & /* constraint */) const
+{
+    switch (which) {
+    case Qt::MinimumSize:
+        return QSizeF(32,32);
+    case Qt::PreferredSize:
+        return QSizeF(160,90);
+    case Qt::MaximumSize:
+        return QSizeF(1000,1000);
+    default:
+        return QSizeF(300, 300);
+    }
+}
+
+static bool compareSets(const QSet<QGraphicsLayoutItem*> &actual, const QSet<QGraphicsLayoutItem*> &expected)
+{
+    if (actual != expected) {
+        qDebug() << "actual:" << actual << "expected:" << expected;
+        return false;
+    }
+    return true;
+}
+
+class CustomLayout : public QGraphicsLayout
+{
+public :
+CustomLayout(QGraphicsLayoutItem *parent)
+    : QGraphicsLayout(parent)
+{
+}
+
+
+~CustomLayout()
+{
+}
+
+int count() const
+{
+    return items.count();
+}
+
+QGraphicsLayoutItem* itemAt(int index) const
+{
+    return items.at(index);
+}
+
+
+void removeAt(int index)
+{
+    items.removeAt(index);
+}
+
+void addItem(QGraphicsLayoutItem *item)
+{
+    insertItem(items.count(), item);
+}
+
+void insertItem(int index, QGraphicsLayoutItem *item)
+{
+    index = qBound(0, index, items.count());
+
+    item->setParentLayoutItem(this);
+
+    QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);
+    updateParentWidget(widget);
+
+
+    if (index == items.count()) {
+        items.append(item);
+    } else {
+        items.insert(index, item);
+    }
+
+    updateGeometry();
+    activate();
+}
+
+void updateParentWidget(QGraphicsWidget *item)
+{
+    QGraphicsLayoutItem *parentItem = parentLayoutItem();
+    while (parentItem && parentItem->isLayout()) {
+        parentItem = parentItem->parentLayoutItem();
+    }
+
+    if (parentItem) {
+        item->setParentItem(static_cast<QGraphicsWidget*>(parentItem));
+    }
+}
+
+QSizeF sizeHint(Qt::SizeHint /* which */, const QSizeF & /* constraint */) const
+{
+    return QSizeF(50,50);
+}
+
+QList<QGraphicsLayoutItem*> items;
+
+};
+
+void tst_QGraphicsLayout::ownership()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    {
+        QGraphicsLinearLayout *lay = new QGraphicsLinearLayout;
+        QSet<QGraphicsLayoutItem*> destructedSet;
+        CustomLayoutItem *li1 = new CustomLayoutItem(&destructedSet);
+        lay->addItem(li1);
+        CustomLayoutItem *li2 = new CustomLayoutItem(&destructedSet);
+        lay->addItem(li2);
+        CustomLayoutItem *li3 = new CustomLayoutItem(&destructedSet);
+        lay->addItem(li3);
+        destructedSet.clear();
+
+        delete lay;
+        QSet<QGraphicsLayoutItem*> expected;
+        expected << li1 << li2 << li3;
+        QVERIFY(compareSets(destructedSet, expected));
+    }
+
+    {
+        QGraphicsWidget *window = new QGraphicsWidget;
+        QGraphicsLinearLayout *lay = new QGraphicsLinearLayout;
+        QSet<QGraphicsLayoutItem*> destructedSet;
+        CustomGraphicsWidget *li1 = new CustomGraphicsWidget(&destructedSet);
+        lay->addItem(li1);
+        CustomGraphicsWidget *li2 = new CustomGraphicsWidget(&destructedSet);
+        lay->addItem(li2);
+        CustomGraphicsWidget *li3 = new CustomGraphicsWidget(&destructedSet);
+        lay->addItem(li3);
+        window->setLayout(lay);
+        scene.addItem(window);
+
+        destructedSet.clear();
+        window->setLayout(0);
+        QVERIFY(destructedSet.count() == 0);
+        delete window;
+    }
+
+    {
+        QGraphicsWidget *window = new QGraphicsWidget(0, Qt::Window);
+        QGraphicsLinearLayout *lay = new QGraphicsLinearLayout;
+
+        CustomGraphicsWidget *li1 = new CustomGraphicsWidget;
+        lay->addItem(li1);
+
+        QGraphicsLinearLayout *li2 = new QGraphicsLinearLayout;
+        CustomGraphicsWidget *li2_1 = new CustomGraphicsWidget;
+        li2->addItem(li2_1);
+        CustomGraphicsWidget *li2_2 = new CustomGraphicsWidget;
+        li2->addItem(li2_2);
+        CustomGraphicsWidget *li2_3 = new CustomGraphicsWidget;
+        li2->addItem(li2_3);
+        lay->addItem(li2);
+
+        CustomGraphicsWidget *li3 = new CustomGraphicsWidget;
+        lay->addItem(li3);
+
+        window->setLayout(lay);
+        scene.addItem(window);
+        view.resize(500, 200);
+        view.show();
+
+        for (int i = li2->count(); i > 0; --i) {
+            QCOMPARE(li2->count(), i);
+            delete li2->itemAt(0);
+        }
+
+        for (int i = lay->count(); i > 0; --i) {
+            QCOMPARE(lay->count(), i);
+            delete lay->itemAt(0);
+        }
+
+        delete window;
+    }
+
+    {
+        QGraphicsWidget *top = new QGraphicsWidget;
+        QGraphicsWidget *w = new QGraphicsWidget;
+        QGraphicsWidget *w2 = new QGraphicsWidget;
+        CustomLayout *layout = new CustomLayout(top);
+        layout->addItem(w);
+        layout->addItem(w2);
+        top->setLayout(layout);
+        delete top;
+        //don't crash after that.
+    }
+}
+
+QTEST_MAIN(tst_QGraphicsLayout)
+#include "tst_qgraphicslayout.moc"
diff --git a/tests/auto/widgets/graphicsview/qgraphicslayoutitem/.gitignore b/tests/auto/widgets/graphicsview/qgraphicslayoutitem/.gitignore
new file mode 100644
index 0000000000..55a8d18acb
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicslayoutitem/.gitignore
@@ -0,0 +1 @@
+tst_qgraphicslayoutitem
diff --git a/tests/auto/widgets/graphicsview/qgraphicslayoutitem/qgraphicslayoutitem.pro b/tests/auto/widgets/graphicsview/qgraphicslayoutitem/qgraphicslayoutitem.pro
new file mode 100644
index 0000000000..ed9adf87fd
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicslayoutitem/qgraphicslayoutitem.pro
@@ -0,0 +1,5 @@
+load(qttest_p4)
+QT += widgets
+SOURCES  += tst_qgraphicslayoutitem.cpp
+CONFIG += parallel_test
+
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"
+
diff --git a/tests/auto/widgets/graphicsview/qgraphicslinearlayout/.gitignore b/tests/auto/widgets/graphicsview/qgraphicslinearlayout/.gitignore
new file mode 100644
index 0000000000..95c7dac979
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicslinearlayout/.gitignore
@@ -0,0 +1 @@
+tst_qgraphicslinearlayout
diff --git a/tests/auto/widgets/graphicsview/qgraphicslinearlayout/qgraphicslinearlayout.pro b/tests/auto/widgets/graphicsview/qgraphicslinearlayout/qgraphicslinearlayout.pro
new file mode 100644
index 0000000000..1f7ff0cc6e
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicslinearlayout/qgraphicslinearlayout.pro
@@ -0,0 +1,5 @@
+load(qttest_p4)
+QT += widgets
+SOURCES  += tst_qgraphicslinearlayout.cpp
+CONFIG += parallel_test
+
diff --git a/tests/auto/widgets/graphicsview/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp b/tests/auto/widgets/graphicsview/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp
new file mode 100644
index 0000000000..873a711127
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp
@@ -0,0 +1,1650 @@
+/****************************************************************************
+**
+** 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 <qgraphicslinearlayout.h>
+#include <qgraphicsproxywidget.h>
+#include <qgraphicswidget.h>
+#include <qgraphicsscene.h>
+#include <qgraphicsview.h>
+#include <qapplication.h>
+#include <qplastiquestyle.h>
+
+class tst_QGraphicsLinearLayout : public QObject {
+Q_OBJECT
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+private slots:
+    void qgraphicslinearlayout_data();
+    void qgraphicslinearlayout();
+
+    void alignment_data();
+    void alignment();
+    void count_data();
+    void count();
+    void dump_data();
+    void dump();
+    void geometry_data();
+    void geometry();
+    void insertItem_data();
+    void insertItem();
+    void insertStretch_data();
+    void insertStretch();
+    void invalidate_data();
+    void invalidate();
+    void itemAt_data();
+    void itemAt();
+    void itemAt_visualOrder();
+    void orientation_data();
+    void orientation();
+    void removeAt_data();
+    void removeAt();
+    void removeItem_data();
+    void removeItem();
+    void setGeometry_data();
+    void setGeometry();
+    void setSpacing_data();
+    void setSpacing();
+    void setItemSpacing_data();
+    void setItemSpacing();
+    void itemSpacing();
+    void setStretchFactor_data();
+    void setStretchFactor();
+    void testStretch();
+    void defaultStretchFactors_data();
+    void defaultStretchFactors();
+    void sizeHint_data();
+    void sizeHint();
+    void updateGeometry();
+    void layoutDirection();
+    void removeLayout();
+    void avoidRecursionInInsertItem();
+    void styleInfoLeak();
+    void testAlignmentInLargerLayout();
+    void testOffByOneInLargerLayout();
+    void testDefaultAlignment();
+    void combineSizePolicies();
+
+    // Task specific tests
+    void task218400_insertStretchCrash();
+};
+
+// Subclass that exposes the protected functions.
+class SubQGraphicsLinearLayout : public QGraphicsLinearLayout {
+public:
+    SubQGraphicsLinearLayout(Qt::Orientation orientation = Qt::Horizontal) : QGraphicsLinearLayout(orientation),
+        graphicsSceneResize(0),
+        layoutRequest(0),
+        layoutDirectionChange(0)
+        { }
+
+    void widgetEvent(QEvent *e)
+    {
+        switch (e->type()) {
+        case QEvent::GraphicsSceneResize:
+            graphicsSceneResize++;
+            break;
+        case QEvent::LayoutRequest:
+            layoutRequest++;
+            break;
+        case QEvent::LayoutDirectionChange:
+            layoutDirectionChange++;
+            break;
+        default:
+            break;
+        }
+
+        QGraphicsLinearLayout::widgetEvent(e);
+    }
+
+    int graphicsSceneResize;
+    int layoutRequest;
+    int layoutDirectionChange;
+};
+
+// This will be called before the first test function is executed.
+// It is only called once.
+void tst_QGraphicsLinearLayout::initTestCase()
+{
+    // since the style will influence the results, we have to ensure
+    // that the tests are run using the same style on all platforms
+#if defined (Q_WS_WINCE)
+    QApplication::setStyle(new QWindowsStyle);
+#else
+    QApplication::setStyle(new QPlastiqueStyle);
+#endif
+}
+
+// This will be called after the last test function is executed.
+// It is only called once.
+void tst_QGraphicsLinearLayout::cleanupTestCase()
+{
+}
+
+// This will be called before each test function is executed.
+void tst_QGraphicsLinearLayout::init()
+{
+}
+
+// This will be called after every test function.
+void tst_QGraphicsLinearLayout::cleanup()
+{
+}
+
+class RectWidget : public QGraphicsWidget
+{
+public:
+    RectWidget(QGraphicsItem *parent = 0, const QBrush &brush = QBrush()) : QGraphicsWidget(parent){ m_brush = brush;}
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        Q_UNUSED(option);
+        Q_UNUSED(widget);
+        painter->setBrush(m_brush);
+        painter->drawRoundRect(rect());
+    }
+
+    void setSizeHint(Qt::SizeHint which, const QSizeF &size) {
+        m_sizeHints[which] = size;
+        updateGeometry();
+    }
+
+    virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const {
+        if (m_sizeHints[which].isValid()) {
+            return m_sizeHints[which];
+        }
+        return QGraphicsWidget::sizeHint(which, constraint);
+    }
+
+    QSizeF m_sizeHints[Qt::NSizeHints];
+    QBrush m_brush;
+};
+
+
+Q_DECLARE_METATYPE(Qt::Orientation)
+void tst_QGraphicsLinearLayout::qgraphicslinearlayout_data()
+{
+    QTest::addColumn<Qt::Orientation>("orientation");
+    QTest::newRow("vertical") << Qt::Vertical;
+    QTest::newRow("horizontal") << Qt::Horizontal;
+}
+
+void tst_QGraphicsLinearLayout::qgraphicslinearlayout()
+{
+    QFETCH(Qt::Orientation, orientation);
+    SubQGraphicsLinearLayout layout(orientation);
+    QVERIFY(layout.isLayout());
+
+    qApp->processEvents();
+    QCOMPARE(layout.graphicsSceneResize, 0);
+    QCOMPARE(layout.layoutRequest, 0);
+    QCOMPARE(layout.layoutDirectionChange, 0);
+
+    layout.setOrientation(Qt::Vertical);
+    layout.orientation();
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsLinearLayout::insertItem: cannot insert null item");
+    QCOMPARE(layout.count(), 0);
+    layout.addItem(0);
+    QCOMPARE(layout.count(), 0);
+    layout.addStretch(0);
+    QCOMPARE(layout.count(), 0);
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsLinearLayout::insertItem: cannot insert null item");
+    layout.insertItem(0, 0);
+    layout.insertStretch(0, 0);
+    layout.removeItem(0);
+    QCOMPARE(layout.count(), 0);
+    layout.setSpacing(0);
+    layout.spacing();
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsLinearLayout::setStretchFactor: cannot assign a stretch factor to a null item");
+    layout.setStretchFactor(0, 0);
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsLinearLayout::setStretchFactor: cannot return a stretch factor for a null item");
+    layout.stretchFactor(0);
+    layout.setAlignment(0, Qt::AlignHCenter);
+    QCOMPARE(layout.alignment(0), 0);
+    layout.setGeometry(QRectF());
+    layout.geometry();
+    QCOMPARE(layout.count(), 0);
+    layout.invalidate();
+    layout.sizeHint(Qt::MinimumSize, QSizeF());
+}
+
+Q_DECLARE_METATYPE(Qt::AlignmentFlag)
+void tst_QGraphicsLinearLayout::alignment_data()
+{
+    QTest::addColumn<Qt::Orientation>("orientation");
+    QTest::addColumn<QSize>("newSize");
+    QTest::newRow("h-defaultsize") << Qt::Horizontal << QSize();
+    QTest::newRow("v-defaultsize") << Qt::Vertical << QSize();
+    QTest::newRow("h-300") << Qt::Horizontal << QSize(300,100);
+    QTest::newRow("v-300") << Qt::Vertical << QSize(100, 300);
+}
+
+void tst_QGraphicsLinearLayout::alignment()
+{
+    QFETCH(Qt::Orientation, orientation);
+    QFETCH(QSize, newSize);
+
+    //if (alignment == Qt::AlignAbsolute)
+    //    QApplication::setLayoutDirection(Qt::RightToLeft);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.setSceneRect(0, 0, 320, 240);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    SubQGraphicsLinearLayout &layout = *(new SubQGraphicsLinearLayout(orientation));
+    scene.addItem(widget);
+    widget->setLayout(&layout);
+
+    static const Qt::Alignment alignmentsToTest[] = {
+        (Qt::Alignment)0,
+        Qt::AlignLeft,
+        Qt::AlignRight,
+        Qt::AlignHCenter,
+        Qt::AlignTop,
+        Qt::AlignBottom,
+        Qt::AlignVCenter,
+        Qt::AlignCenter,
+        (Qt::Alignment)0,
+        Qt::AlignLeft,
+        Qt::AlignRight,
+        Qt::AlignHCenter,
+        Qt::AlignTop,
+        Qt::AlignBottom,
+        Qt::AlignVCenter,
+        Qt::AlignCenter
+    };
+
+    int i;
+    bool addWidget = true;
+    for (size_t i = 0; i < sizeof(alignmentsToTest)/sizeof(Qt::Alignment); ++i) {
+        QGraphicsLayoutItem *loutItem;
+        Qt::Alignment align = alignmentsToTest[i];
+        if (!align && i > 0)
+            addWidget = false;
+        if (addWidget)
+            loutItem = new RectWidget(widget, QBrush(Qt::blue));
+        else {
+            SubQGraphicsLinearLayout *lay = new SubQGraphicsLinearLayout(Qt::Vertical);
+            lay->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred, QSizePolicy::DefaultType);
+            lay->setContentsMargins(0,0,0,0);
+            QGraphicsWidget *w = new RectWidget(widget, QBrush(Qt::red));
+            if (align) {
+                w->setMinimumSize(QSizeF(10,10));
+                w->setMaximumSize(QSizeF(10,10));
+            } else {
+                w->setMinimumSize(QSizeF(50,50));
+                w->setMaximumSize(QSizeF(50,50));
+            }
+            lay->addItem(w);
+            loutItem = lay;
+        }
+        if (align) {
+            loutItem->setMinimumSize(QSizeF(10,10));
+            loutItem->setMaximumSize(QSizeF(10,10));
+        } else {
+            loutItem->setMinimumSize(QSizeF(50,50));
+            loutItem->setMaximumSize(QSizeF(50,50));
+        }
+        layout.addItem(loutItem);
+        layout.setAlignment(loutItem, align);
+
+    }
+    layout.setContentsMargins(0,0,0,0);
+    int spacing = 1;
+    layout.setSpacing(spacing);
+    if (newSize.isValid())
+        widget->resize(newSize);
+    view.show();
+    widget->show();
+    QTest::qWaitForWindowShown(&view);
+    QApplication::processEvents();
+
+    int x = 0;
+    int y = 0;
+    for (i = 0; i < layout.count(); ++i) {
+        QGraphicsLayoutItem *item = layout.itemAt(i);
+        Qt::Alignment align = layout.alignment(item);
+
+        int w = 10;
+        int h = 10;
+        switch(align) {
+            case Qt::AlignLeft:
+                break;
+            case Qt::AlignRight:
+                if (orientation == Qt::Vertical)
+                    x += 40;
+                break;
+            case Qt::AlignHCenter:
+                if (orientation == Qt::Vertical)
+                    x += 20;
+                break;
+            case Qt::AlignTop:
+                break;
+            case Qt::AlignBottom:
+                if (orientation == Qt::Horizontal)
+                    y += 40;
+                break;
+            case Qt::AlignVCenter:
+                if (orientation == Qt::Horizontal)
+                    y += 20;
+                break;
+            case Qt::AlignCenter:
+                if (orientation == Qt::Horizontal)
+                    y += 20;
+                else
+                    x += 20;
+                break;
+            case 0:
+                w = 50;
+                h = 50;
+                break;
+            default:
+                break;
+        }
+        QRectF expectedGeometry(x, y, w, h);
+        QCOMPARE(item->geometry(), expectedGeometry);
+        if (orientation == Qt::Horizontal) {
+            x += w;
+            y = 0;
+            x += spacing;
+        } else {
+            x = 0;
+            y += h;
+            y += spacing;
+        }
+    }
+}
+
+void tst_QGraphicsLinearLayout::count_data()
+{
+    QTest::addColumn<int>("itemCount");
+    QTest::addColumn<int>("layoutCount");
+    QTest::newRow("0, 0") << 0 << 0;
+    QTest::newRow("0, 5") << 0 << 5;
+    QTest::newRow("5, 0") << 5 << 0;
+    QTest::newRow("5, 5") << 5 << 5;
+}
+
+// int count() const public
+void tst_QGraphicsLinearLayout::count()
+{
+    QFETCH(int, itemCount);
+    QFETCH(int, layoutCount);
+
+    SubQGraphicsLinearLayout layout;
+    QCOMPARE(layout.count(), 0);
+
+    for (int i = 0; i < itemCount; ++i)
+        layout.addItem(new QGraphicsWidget);
+    QCOMPARE(layout.count(), itemCount);
+
+    for (int i = 0; i < layoutCount; ++i)
+        layout.addItem(new SubQGraphicsLinearLayout);
+    QCOMPARE(layout.count(), itemCount + layoutCount);
+
+    // see also removeAt()
+}
+
+void tst_QGraphicsLinearLayout::dump_data()
+{
+    QTest::addColumn<int>("itemCount");
+    QTest::addColumn<int>("layoutCount");
+    for (int i = -1; i < 3; ++i) {
+        QTest::newRow(QString("%1, 0, 0").arg(i).toLatin1()) << 0 << 0;
+        QTest::newRow(QString("%1, 0, 5").arg(i).toLatin1()) << 5 << 5;
+        QTest::newRow(QString("%1, 5, 0").arg(i).toLatin1()) << 5 << 5;
+        QTest::newRow(QString("%1, 5, 5").arg(i).toLatin1()) << 5 << 5;
+    }
+}
+
+// void dump(int indent = 0) const public
+void tst_QGraphicsLinearLayout::dump()
+{
+    QFETCH(int, itemCount);
+    QFETCH(int, layoutCount);
+    SubQGraphicsLinearLayout layout;
+    for (int i = 0; i < itemCount; ++i)
+        layout.addItem(new QGraphicsWidget);
+    for (int i = 0; i < layoutCount; ++i)
+        layout.addItem(new SubQGraphicsLinearLayout);
+}
+
+void tst_QGraphicsLinearLayout::geometry_data()
+{
+    QTest::addColumn<int>("itemCount");
+    QTest::addColumn<int>("layoutCount");
+    QTest::addColumn<int>("itemSpacing");
+    QTest::addColumn<int>("spacing");
+    QTest::addColumn<Qt::Orientation>("orientation");
+    QTest::addColumn<QRectF>("rect");
+
+    QTest::newRow("null") << 0 << 0 << 0 << 0 << Qt::Horizontal << QRectF();
+
+    QTest::newRow("one item") << 1 << 0 << 0 << 0 << Qt::Horizontal << QRectF(0, 0, 10, 10);
+    QTest::newRow("one layout") << 0 << 1 << 0 << 0 << Qt::Horizontal << QRectF(0, 0, 10, 10);
+    QTest::newRow("two h") << 1 << 1 << 0 << 0 << Qt::Horizontal << QRectF(0, 0, 20, 10);
+    QTest::newRow("two v") << 1 << 1 << 0 << 0 << Qt::Vertical << QRectF(0, 0, 10, 20);
+
+    QTest::newRow("two w/itemspacing") << 1 << 1 << 5 << 0 << Qt::Horizontal << QRectF(0, 0, 25, 10);
+    QTest::newRow("two w/spacing") << 1 << 1 << 8 << 0 << Qt::Horizontal << QRectF(0, 0, 28, 10);
+
+    QTest::newRow("two w/itemspacing v") << 1 << 1 << 5 << 0 << Qt::Vertical << QRectF(0, 0, 10, 25);
+    QTest::newRow("two w/spacing v") << 1 << 1 << 8 << 0 << Qt::Vertical << QRectF(0, 0, 10, 28);
+}
+
+// QRectF geometry() const public
+void tst_QGraphicsLinearLayout::geometry()
+{
+    QFETCH(int, itemCount);
+    QFETCH(int, layoutCount);
+    QFETCH(int, itemSpacing);
+    QFETCH(int, spacing);
+    QFETCH(Qt::Orientation, orientation);
+    QFETCH(QRectF, rect);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    SubQGraphicsLinearLayout &layout = *(new SubQGraphicsLinearLayout(orientation));
+    scene.addItem(widget);
+    widget->setLayout(&layout);
+    widget->setContentsMargins(0, 0, 0, 0);
+    for (int i = 0; i < itemCount; ++i)
+        layout.addItem(new QGraphicsWidget);
+    for (int i = 0; i < layoutCount; ++i)
+        layout.addItem(new SubQGraphicsLinearLayout);
+
+    for (int i = 0; i < layout.count(); ++i) {
+        QGraphicsLayoutItem *item = layout.itemAt(i);
+        item->setMaximumSize(10, 10);
+        item->setMinimumSize(10, 10);
+    }
+    layout.setItemSpacing(0, itemSpacing);
+    layout.setSpacing(spacing);
+    layout.setContentsMargins(0, 0, 0, 0);
+
+    widget->show();
+    view.show();
+    QApplication::processEvents();
+    QCOMPARE(layout.geometry(), rect);
+    delete widget;
+}
+
+void tst_QGraphicsLinearLayout::insertItem_data()
+{
+    QTest::addColumn<int>("itemCount");
+    QTest::addColumn<int>("layoutCount");
+    QTest::addColumn<int>("insertItemAt");
+    QTest::addColumn<bool>("isWidget");
+    for (int i = -1; i < 4; ++i) {
+        for (int j = 0; j < 2; ++j) {
+            QTest::newRow(QString("0, 0, %1 %2").arg(i).arg(j).toLatin1()) << 0 << 0 << i << (bool)j;
+            QTest::newRow(QString("1, 0, %1 %2").arg(i).arg(j).toLatin1()) << 1 << 0 << i << (bool)j;
+            QTest::newRow(QString("0, 1, %1 %2").arg(i).arg(j).toLatin1()) << 0 << 1 << i << (bool)j;
+            QTest::newRow(QString("2, 2, %1 %2").arg(i).arg(j).toLatin1()) << 2 << 2 << i << (bool)j;
+        }
+    }
+}
+
+// void insertItem(int index, QGraphicsLayoutItem* item) public
+void tst_QGraphicsLinearLayout::insertItem()
+{
+    QFETCH(int, itemCount);
+    QFETCH(int, layoutCount);
+    QFETCH(int, insertItemAt);
+    QFETCH(bool, isWidget);
+    if (insertItemAt > layoutCount + itemCount)
+        return;
+
+    SubQGraphicsLinearLayout layout;
+    for (int i = 0; i < itemCount; ++i)
+        layout.addItem(new QGraphicsWidget);
+    for (int i = 0; i < layoutCount; ++i)
+        layout.addItem(new SubQGraphicsLinearLayout);
+
+    QGraphicsLayoutItem *item = 0;
+    if (isWidget)
+        item = new QGraphicsWidget;
+    else
+        item = new SubQGraphicsLinearLayout;
+
+    QSizeF oldSizeHint = layout.sizeHint(Qt::PreferredSize, QSizeF());
+    layout.insertItem(insertItemAt, item);
+    QCOMPARE(layout.count(), itemCount + layoutCount + 1);
+
+    if (insertItemAt >= 0 && (itemCount + layoutCount >= 0)) {
+        QCOMPARE(layout.itemAt(insertItemAt), item);
+    }
+
+    layout.activate();
+    QSizeF newSizeHint = layout.sizeHint(Qt::PreferredSize, QSizeF());
+    if (!isWidget && layout.count() == 1)
+        QCOMPARE(oldSizeHint.width(), newSizeHint.width());
+    else if (itemCount + layoutCount > 0)
+        QVERIFY(oldSizeHint.width() < newSizeHint.width());
+}
+
+void tst_QGraphicsLinearLayout::insertStretch_data()
+{
+    QTest::addColumn<int>("itemCount");
+    QTest::addColumn<int>("layoutCount");
+    QTest::addColumn<int>("insertItemAt");
+    QTest::addColumn<int>("stretch");
+    for (int i = -1; i < 4; ++i) {
+        for (int j = 0; j < 2; ++j) {
+            QTest::newRow(QString("0, 0, %1 %2").arg(i).arg(j).toLatin1()) << 0 << 0 << i << j;
+            QTest::newRow(QString("1, 0, %1 %2").arg(i).arg(j).toLatin1()) << 1 << 0 << i << j;
+            QTest::newRow(QString("0, 1, %1 %2").arg(i).arg(j).toLatin1()) << 0 << 1 << i << j;
+            QTest::newRow(QString("2, 2, %1 %2").arg(i).arg(j).toLatin1()) << 2 << 2 << i << j;
+        }
+    }
+}
+
+// void insertStretch(int index, int stretch = 1) public
+void tst_QGraphicsLinearLayout::insertStretch()
+{
+    QFETCH(int, itemCount);
+    QFETCH(int, layoutCount);
+    QFETCH(int, insertItemAt);
+    QFETCH(int, stretch);
+    if (insertItemAt > layoutCount + itemCount)
+        return;
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    SubQGraphicsLinearLayout *layout = new SubQGraphicsLinearLayout;
+    scene.addItem(widget);
+
+    QList<QGraphicsWidget *>items;
+    QGraphicsWidget *item = 0;
+    for (int i = 0; i < itemCount; ++i) {
+        item = new RectWidget;
+        item->setMinimumSize(10, 10);
+        item->setPreferredSize(25, 25);
+        item->setMaximumSize(50, 50);
+        layout->addItem(item);
+    }
+    for (int i = 0; i < layoutCount; ++i) {
+        item = new RectWidget;
+        item->setMinimumSize(10, 10);
+        item->setPreferredSize(25, 25);
+        item->setMaximumSize(50, 50);
+        SubQGraphicsLinearLayout *sublayout = new SubQGraphicsLinearLayout;
+        sublayout->addItem(item);
+        layout->addItem(sublayout);
+    }
+    widget->setLayout(layout);
+    layout->insertStretch(insertItemAt, stretch);
+    QCOMPARE(layout->count(), itemCount + layoutCount);
+
+    layout->activate();
+    view.show();
+    widget->show();
+
+    int prevStretch = -2;
+    int prevWidth = -2;
+    widget->resize((layoutCount + itemCount) * 25 + 25, 25);
+    for (int i = 0; i < layout->count(); ++i) {
+        if (QGraphicsLayoutItem *item = layout->itemAt(i)) {
+            if (prevStretch != -2) {
+                if (layout->stretchFactor(item) >= prevStretch) {
+                    QVERIFY(item->geometry().width() >= prevWidth);
+                } else {
+                    QVERIFY(item->geometry().width() < prevWidth);
+                }
+            }
+            prevStretch = layout->stretchFactor(item);
+            prevWidth = (int)(item->geometry().width());
+        }
+    }
+
+    //QTest::qWait(1000);
+    delete widget;
+}
+
+void tst_QGraphicsLinearLayout::invalidate_data()
+{
+    QTest::addColumn<int>("count");
+    QTest::newRow("0") << 0;
+    QTest::newRow("1") << 1;
+    QTest::newRow("2") << 2;
+    QTest::newRow("3") << 3;
+}
+
+// void invalidate() public
+void tst_QGraphicsLinearLayout::invalidate()
+{
+    QFETCH(int, count);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    SubQGraphicsLinearLayout &layout = *(new SubQGraphicsLinearLayout);
+    scene.addItem(widget);
+    widget->setLayout(&layout);
+    widget->setContentsMargins(0, 0, 0, 0);
+    layout.setContentsMargins(0, 0, 0, 0);
+    view.show();
+    widget->show();
+    //QTest::qWait(1000);
+    QTest::qWaitForWindowShown(&view);
+    qApp->processEvents();
+    layout.layoutRequest = 0;
+
+    layout.setContentsMargins(1, 2, 3, 4);
+    QApplication::sendPostedEvents(0, 0);
+    QCOMPARE(layout.layoutRequest, 1);
+
+    layout.setOrientation(Qt::Vertical);
+    QApplication::sendPostedEvents(0, 0);
+    QCOMPARE(layout.layoutRequest, 2);
+
+    for (int i = 0; i < count; ++i)
+        layout.invalidate();        // Event is compressed, should only get one layoutrequest
+    QApplication::sendPostedEvents(0, 0);
+    QCOMPARE(layout.layoutRequest, count ? 3 : 2);
+    delete widget;
+}
+
+void tst_QGraphicsLinearLayout::itemAt_data()
+{
+    QTest::addColumn<int>("index");
+    QTest::newRow("0") << 0;
+    QTest::newRow("1") << 1;
+    QTest::newRow("2") << 2;
+}
+
+// QGraphicsLayoutItem* itemAt(int index) const public
+void tst_QGraphicsLinearLayout::itemAt()
+{
+    // see also the insertItem() etc tests
+    QFETCH(int, index);
+    SubQGraphicsLinearLayout layout;
+    for (int i = 0; i < 3; ++i)
+        layout.addItem(new QGraphicsWidget);
+
+    QVERIFY(layout.itemAt(index) != 0);
+}
+
+void tst_QGraphicsLinearLayout::itemAt_visualOrder()
+{
+    QGraphicsLinearLayout *l = new QGraphicsLinearLayout;
+
+    QGraphicsWidget *w1 = new QGraphicsWidget;
+    l->addItem(w1);
+
+    QGraphicsWidget *w3 = new QGraphicsWidget;
+    l->addItem(w3);
+
+    QGraphicsWidget *w0 = new QGraphicsWidget;
+    l->insertItem(0, w0);
+
+    QGraphicsWidget *w2 = new QGraphicsWidget;
+    l->insertItem(2, w2);
+
+    QCOMPARE(l->itemAt(0), static_cast<QGraphicsLayoutItem*>(w0));
+    QCOMPARE(l->itemAt(1), static_cast<QGraphicsLayoutItem*>(w1));
+    QCOMPARE(l->itemAt(2), static_cast<QGraphicsLayoutItem*>(w2));
+    QCOMPARE(l->itemAt(3), static_cast<QGraphicsLayoutItem*>(w3));
+}
+
+void tst_QGraphicsLinearLayout::orientation_data()
+{
+    QTest::addColumn<Qt::Orientation>("orientation");
+    QTest::newRow("vertical") << Qt::Vertical;
+    QTest::newRow("horizontal") << Qt::Horizontal;
+}
+
+// Qt::Orientation orientation() const public
+void tst_QGraphicsLinearLayout::orientation()
+{
+    QFETCH(Qt::Orientation, orientation);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    Qt::Orientation initialOrientation = (orientation == Qt::Vertical ? Qt::Horizontal : Qt::Vertical);
+    SubQGraphicsLinearLayout &layout = *(new SubQGraphicsLinearLayout(initialOrientation));
+    scene.addItem(widget);
+    widget->setLayout(&layout);
+    widget->setContentsMargins(0, 0, 0, 0);
+    layout.setContentsMargins(0, 0, 0, 0);
+    int i;
+    int itemCount = 3;
+    for (i = 0; i < itemCount; ++i)
+        layout.addItem(new RectWidget);
+    QCOMPARE(layout.orientation(), initialOrientation);
+    QList<qreal> positions;
+
+    view.show();
+    widget->show();
+    qApp->processEvents();
+
+    for (i = 0; i < itemCount; ++i) {
+        QGraphicsWidget *item = static_cast<QGraphicsWidget*>(layout.itemAt(i));
+        qreal pos;
+        if (initialOrientation == Qt::Horizontal)
+            pos = item->pos().x();
+        else
+            pos = item->pos().y();
+        positions.append(pos);
+
+    }
+
+    layout.setOrientation(orientation);
+    QCOMPARE(layout.orientation(), orientation);
+	// important to resize to preferredsize when orientation is switched
+    widget->resize(widget->effectiveSizeHint(Qt::PreferredSize));
+    qApp->processEvents();
+    for (i = 0; i < positions.count(); ++i) {
+        QGraphicsWidget *item = static_cast<QGraphicsWidget*>(layout.itemAt(i));
+        if (initialOrientation == Qt::Horizontal)
+            QCOMPARE(item->pos().y(), positions.at(i));
+        else
+            QCOMPARE(item->pos().x(), positions.at(i));
+    }
+}
+
+void tst_QGraphicsLinearLayout::removeAt_data()
+{
+    QTest::addColumn<int>("itemCount");
+    QTest::addColumn<int>("layoutCount");
+    QTest::addColumn<int>("removeItemAt");
+    QTest::addColumn<Qt::Orientation>("orientation");
+    for (int i = -1; i < 4; ++i) {
+        for (int k = 0; k < 2; ++k) {
+            Qt::Orientation orientation = (k == 0) ? Qt::Vertical : Qt::Horizontal;
+            QTest::newRow(QString("0, 0, %1").arg(i).toLatin1()) << 0 << 0 << i << orientation;
+            QTest::newRow(QString("1, 0, %1").arg(i).toLatin1()) << 1 << 0 << i << orientation;
+            QTest::newRow(QString("0, 1, %1").arg(i).toLatin1()) << 0 << 1 << i << orientation;
+            QTest::newRow(QString("2, 2, %1").arg(i).toLatin1()) << 2 << 2 << i << orientation;
+        }
+    }
+}
+
+// void removeAt(int index) public
+void tst_QGraphicsLinearLayout::removeAt()
+{
+    QFETCH(int, itemCount);
+    QFETCH(int, layoutCount);
+    QFETCH(int, removeItemAt);
+    QFETCH(Qt::Orientation, orientation);
+    if (removeItemAt >= layoutCount + itemCount)
+        return;
+
+    SubQGraphicsLinearLayout layout(orientation);
+    for (int i = 0; i < itemCount; ++i)
+        layout.addItem(new QGraphicsWidget);
+    for (int i = 0; i < layoutCount; ++i)
+        layout.addItem(new SubQGraphicsLinearLayout);
+    QSizeF oldSizeHint = layout.sizeHint(Qt::PreferredSize, QSizeF());
+
+    QGraphicsLayoutItem *w = 0;
+    if (removeItemAt >= 0 && removeItemAt < layout.count())
+        w = layout.itemAt(removeItemAt);
+    if (w) {
+        QGraphicsLayoutItem *wParent = w->parentLayoutItem();
+        QCOMPARE(wParent, static_cast<QGraphicsLayoutItem *>(&layout));
+        layout.removeAt(removeItemAt);
+        wParent = w->parentLayoutItem();
+        QCOMPARE(wParent, static_cast<QGraphicsLayoutItem *>(0));
+        delete w;
+    }
+    QCOMPARE(layout.count(), itemCount + layoutCount - (w ? 1 : 0));
+
+    layout.activate();
+    QSizeF newSizeHint = layout.sizeHint(Qt::PreferredSize, QSizeF());
+    if (orientation == Qt::Horizontal)
+        QVERIFY(oldSizeHint.width() >= newSizeHint.width());
+    else
+        QVERIFY(oldSizeHint.height() >= newSizeHint.height());
+}
+
+void tst_QGraphicsLinearLayout::removeItem_data()
+{
+    QTest::addColumn<int>("itemCount");
+    QTest::addColumn<int>("layoutCount");
+    QTest::addColumn<int>("removeItemAt");
+    for (int i = -1; i < 4; ++i) {
+        QTest::newRow(QString("0, 0, %1").arg(i).toLatin1()) << 0 << 0 << i;
+        QTest::newRow(QString("1, 0, %1").arg(i).toLatin1()) << 1 << 0 << i;
+        QTest::newRow(QString("0, 1, %1").arg(i).toLatin1()) << 0 << 1 << i;
+        QTest::newRow(QString("2, 2, %1").arg(i).toLatin1()) << 2 << 2 << i;
+    }
+}
+
+// void removeItem(QGraphicsLayoutItem* item) public
+void tst_QGraphicsLinearLayout::removeItem()
+{
+    QFETCH(int, itemCount);
+    QFETCH(int, layoutCount);
+    QFETCH(int, removeItemAt);
+    if (removeItemAt >= layoutCount + itemCount)
+        return;
+
+    SubQGraphicsLinearLayout layout;
+    for (int i = 0; i < itemCount; ++i)
+        layout.addItem(new QGraphicsWidget);
+    for (int i = 0; i < layoutCount; ++i)
+        layout.addItem(new SubQGraphicsLinearLayout);
+
+    QGraphicsLayoutItem *w = 0;
+    if (removeItemAt >= 0 && removeItemAt < layout.count())
+        w = layout.itemAt(removeItemAt);
+    QSizeF oldSizeHint = layout.sizeHint(Qt::PreferredSize, QSizeF());
+    if (w) {
+        layout.removeItem(w);
+        delete w;
+    }
+    QCOMPARE(layout.count(), itemCount + layoutCount - (w ? 1 : 0));
+
+    layout.activate();
+    QSizeF newSizeHint = layout.sizeHint(Qt::PreferredSize, QSizeF());
+    QVERIFY(oldSizeHint.width() >= newSizeHint.width());
+}
+
+void tst_QGraphicsLinearLayout::setGeometry_data()
+{
+    QTest::addColumn<QRectF>("rect");
+    QTest::newRow("null") << QRectF();
+    QTest::newRow("small") << QRectF(0, 0, 10, 10);
+}
+
+// void setGeometry(QRectF const& rect) public
+void tst_QGraphicsLinearLayout::setGeometry()
+{
+    QFETCH(QRectF, rect);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    SubQGraphicsLinearLayout &layout = *(new SubQGraphicsLinearLayout);
+    scene.addItem(widget);
+    widget->setLayout(&layout);
+    widget->setContentsMargins(0, 0, 0, 0);
+    layout.setContentsMargins(0, 0, 0, 0);
+    layout.setMaximumSize(100, 100);
+    view.show();
+    widget->show();
+    QApplication::processEvents();
+    widget->setGeometry(rect);
+    QCOMPARE(layout.geometry(), rect);
+    // see also geometry()
+    delete widget;
+}
+
+void tst_QGraphicsLinearLayout::setSpacing_data()
+{
+    QTest::addColumn<qreal>("spacing");
+    QTest::newRow("0") << (qreal)0;
+    QTest::newRow("5") << (qreal)5;
+    QTest::newRow("3.3") << (qreal)3.3;
+    QTest::newRow("-4.3") << (qreal)4.3;
+}
+
+// void setSpacing(qreal spacing) public
+void tst_QGraphicsLinearLayout::setSpacing()
+{
+    QFETCH(qreal, spacing);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    SubQGraphicsLinearLayout &layout = *(new SubQGraphicsLinearLayout);
+    scene.addItem(widget);
+    widget->setLayout(&layout);
+    layout.setContentsMargins(0, 0, 0, 0);
+
+    qreal oldSpacing = layout.spacing();
+    if (oldSpacing != -1) {
+        for (int i = 0; i < 3; ++i)
+            layout.addItem(new QGraphicsWidget);
+        QSizeF oldSizeHint = layout.sizeHint(Qt::PreferredSize);
+
+        layout.setSpacing(spacing);
+        QCOMPARE(layout.spacing(), spacing);
+
+        view.show();
+        widget->show();
+        QApplication::processEvents();
+        QSizeF newSizeHint = layout.sizeHint(Qt::PreferredSize);
+
+        QCOMPARE(oldSizeHint.width() - oldSpacing * 2, newSizeHint.width() - spacing * 2);
+    } else {
+        QSKIP("This style uses non-uniform spacings (layoutSpacingImplementation() is reimplemented)", SkipAll);
+    }
+    delete widget;
+}
+
+void tst_QGraphicsLinearLayout::setItemSpacing_data()
+{
+    QTest::addColumn<int>("index");
+    QTest::addColumn<int>("spacing");
+
+    QTest::newRow("0 at 0") << 0 << 0;
+    QTest::newRow("10 at 0") << 0 << 10;
+    QTest::newRow("10 at 1") << 1 << 10;
+    QTest::newRow("10 at the end") << 4 << 10;
+}
+
+void tst_QGraphicsLinearLayout::setItemSpacing()
+{
+    QFETCH(int, index);
+    QFETCH(int, spacing);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    SubQGraphicsLinearLayout *layout = new SubQGraphicsLinearLayout;
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    layout->setContentsMargins(0, 0, 0, 0);
+    for (int i = 0; i < 5; ++i) {
+        QGraphicsWidget *w = new QGraphicsWidget;
+        layout->addItem(w);
+    }
+    QSizeF oldSizeHint = layout->sizeHint(Qt::PreferredSize);
+    qreal oldSpacing = 0;
+    if (index < layout->count() - 1)
+        oldSpacing = layout->spacing();
+    else
+        spacing = 0;
+
+    layout->setItemSpacing(index, spacing);
+    view.show();
+    QApplication::processEvents();
+    QSizeF newSizeHint = layout->sizeHint(Qt::PreferredSize);
+    if (oldSpacing >= 0) {
+        QCOMPARE(newSizeHint.width() - spacing, oldSizeHint.width() - oldSpacing);
+    } else {
+        QSKIP("This style uses non-uniform spacings (layoutSpacingImplementation() is reimplemented)", SkipAll);
+    }
+    delete widget;
+}
+
+void tst_QGraphicsLinearLayout::itemSpacing()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    SubQGraphicsLinearLayout *layout = new SubQGraphicsLinearLayout;
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    layout->setContentsMargins(0, 0, 0, 0);
+    for (int i = 0; i < 5; ++i) {
+        QGraphicsWidget *w = new QGraphicsWidget;
+        layout->addItem(w);
+    }
+
+    // Check defaults
+    qreal defaultSpacing = layout->spacing();
+    if (defaultSpacing >= 0) {
+        QCOMPARE(layout->itemSpacing(0), defaultSpacing);
+    } else {
+        // all widgets are the same, so the spacing should be uniform
+        QCOMPARE(layout->itemSpacing(0), layout->itemSpacing(1));
+    }
+
+    layout->setItemSpacing(1, 42);
+    QCOMPARE(layout->itemSpacing(1), qreal(42));
+
+    // try to unset
+    layout->setItemSpacing(1, -1);
+    QCOMPARE(layout->itemSpacing(1), defaultSpacing);
+
+    delete widget;
+}
+
+/**
+ * The stretch factors are not applied linearly, but they are used together with both the preferred size, maximum size to form the
+ * internal effective stretch factor.
+ * There is only need to apply stretch factors if the size of the layout is different than the layouts preferred size.
+ * (If the size of the layout is the preferred size, then all items should get their preferred sizes.
+ * However, imagine this use case:
+ * Layout
+ *          +----------+----------+----------+
+ * name     |    A     |    B     |    C     |
+ * stretch  |    1     |    2     |    3     |
+ * sizehints|[5,10,50] |[5,10,50] |[5,10,50] |
+ *          +----------+----------+----------+
+ *
+ * layout->resize(120, h)
+ *
+ * In QLayout, C would become 50, B would become 50 and A would get 20. When scaling a layout this would give a jerky feeling, since
+ * the item with the highest stretch factor will first resize. When that has reached its maximum the next candidate for stretch will
+ * resize, and finally, item with the lowest stretch factor will resize.
+ * In QGraphicsLinearLayout we try to scale all items so that they all reach their maximum at the same time. This means that
+ * their relative sizes are not proportional to their stretch factors.
+ */
+
+typedef QList<int> IntList;
+Q_DECLARE_METATYPE(IntList)
+Q_DECLARE_METATYPE(qreal)
+
+void tst_QGraphicsLinearLayout::setStretchFactor_data()
+{
+    QTest::addColumn<qreal>("totalSize");
+    QTest::addColumn<IntList>("stretches");
+
+    QTest::newRow(QString("60 [1,2]").toLatin1()) << qreal(60.0) << (IntList() << 1 << 2);
+    QTest::newRow(QString("60 [1,2,3]").toLatin1()) << qreal(60.0) << (IntList() << 1 << 2 << 3);
+    QTest::newRow(QString("120 [1,2,3,6]").toLatin1()) << qreal(120.0) << (IntList() << 1 << 2 << 3 << 6);
+}
+
+// void setStretchFactor(QGraphicsLayoutItem* item, int stretch) public
+void tst_QGraphicsLinearLayout::setStretchFactor()
+{
+    QFETCH(qreal, totalSize);
+    QFETCH(IntList, stretches);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    SubQGraphicsLinearLayout &layout = *(new SubQGraphicsLinearLayout);
+    scene.addItem(widget);
+    widget->setLayout(&layout);
+    layout.setContentsMargins(0, 0, 0, 0);
+    layout.setSpacing(0.0);
+    widget->setContentsMargins(0, 0, 0, 0);
+
+
+    int i;
+    for (i = 0; i < stretches.count(); ++i) {
+        QGraphicsWidget *item = new RectWidget(widget);
+        item->setMinimumSize(5,5);
+        item->setPreferredSize(10,5);
+        item->setMaximumSize(50,5);
+        layout.addItem(item);
+        layout.setStretchFactor(item, stretches.at(i));
+    }
+
+    widget->resize(totalSize, 10);
+    QApplication::processEvents();
+
+    view.show();
+    widget->show();
+
+    qreal firstStretch = -1;
+    qreal firstExtent = -1.;
+    qreal sumExtent = 0;
+    for (i = 0; i < stretches.count(); ++i) {
+        QGraphicsWidget *item = static_cast<QGraphicsWidget*>(layout.itemAt(i));
+        qreal extent = item->size().width();
+        qreal stretch = (qreal)stretches.at(i);
+        if (firstStretch != -1 && firstExtent != -1) {
+            // The resulting widths does not correspond linearly to the stretch factors.
+            if (stretch == firstStretch)
+                QCOMPARE(extent, firstExtent);
+            else if (stretch > firstStretch)
+                QVERIFY(extent > firstExtent);
+            else
+                QVERIFY(extent < firstExtent);
+        } else {
+            firstStretch = (qreal)stretch;
+            firstExtent = extent;
+        }
+        sumExtent+= extent;
+    }
+    QCOMPARE(sumExtent, totalSize);
+
+    delete widget;
+}
+
+void tst_QGraphicsLinearLayout::testStretch()
+{
+    QGraphicsScene scene;
+    QGraphicsView *view = new QGraphicsView(&scene);
+    Q_UNUSED(view);
+    QGraphicsWidget *form = new QGraphicsWidget(0, Qt::Window);
+
+    scene.addItem(form);
+    form->setMinimumSize(600, 600);
+    form->setMaximumSize(600, 600);
+    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Horizontal, form);
+    QGraphicsWidget *w1 = new RectWidget;
+    w1->setPreferredSize(100,100);
+    w1->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+    QGraphicsWidget *w2 = new RectWidget;
+    w2->setPreferredSize(200,200);
+    w2->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+    layout->setSpacing(0);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->addItem(w1);
+    layout->addStretch(2);
+    layout->addItem(w2);
+    QCOMPARE(layout->count(), 2);
+    QVERIFY(layout->itemAt(0) == w1);
+    QVERIFY(layout->itemAt(1) == w2);
+    layout->activate();
+
+    //view->setSceneRect(-50, -50, 800, 800);
+    //view->show();
+    //QTest::qWaitForWindowShown(view);
+    //QTest::qWait(5000);
+    QCOMPARE(form->geometry().size(), QSizeF(600,600));
+    QCOMPARE(w1->geometry(), QRectF(0, 0, 100, 100));
+    QCOMPARE(w2->geometry(), QRectF(400, 0, 200, 200));
+}
+
+void tst_QGraphicsLinearLayout::defaultStretchFactors_data()
+{
+    QTest::addColumn<Qt::Orientation>("orientation");
+    QTest::addColumn<int>("count");
+    QTest::addColumn<IntList>("preferredSizeHints");
+    QTest::addColumn<IntList>("stretches");
+    QTest::addColumn<IntList>("ignoreFlag");
+    QTest::addColumn<QSizeF>("newSize");
+    QTest::addColumn<IntList>("expectedSizes");
+
+    QTest::newRow("hor") << Qt::Horizontal << 3
+                            << (IntList() << 20 << 40 << 60)
+                            << (IntList())
+                            << (IntList())
+                            << QSizeF()
+                            << (IntList() << 20 << 40 << 60);
+
+    QTest::newRow("ver") << Qt::Vertical << 3
+                            << (IntList() << 20 << 40 << 60)
+                            << (IntList())
+                            << (IntList())
+                            << QSizeF()
+                            << (IntList() << 20 << 40 << 60);
+
+    QTest::newRow("hor,ignore123") << Qt::Horizontal << 3
+                            << (IntList() << 20 << 40 << 60)
+                            << (IntList())
+                            << (IntList() << 1 << 1 << 1)
+                            << QSizeF()
+                            << (IntList() << 0 << 0 << 0);
+
+    QTest::newRow("hor,ignore23") << Qt::Horizontal << 3
+                            << (IntList() << 10 << 10 << 10)
+                            << (IntList())
+                            << (IntList() << 0 << 1 << 1)
+                            << QSizeF(200, 50)
+                            << (IntList());     //### stretches are not linear.
+
+    QTest::newRow("hor,ignore2") << Qt::Horizontal << 3
+                            << (IntList() << 10 << 10 << 10)
+                            << (IntList())
+                            << (IntList() << 0 << 1 << 0)
+                            << QSizeF()
+                            << (IntList() << 10 << 0 << 10);
+
+}
+
+void tst_QGraphicsLinearLayout::defaultStretchFactors()
+{
+    QFETCH(Qt::Orientation, orientation);
+    QFETCH(int, count);
+    QFETCH(IntList, preferredSizeHints);
+    QFETCH(IntList, stretches);
+    QFETCH(IntList, ignoreFlag);
+    QFETCH(QSizeF, newSize);
+    QFETCH(IntList, expectedSizes);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    SubQGraphicsLinearLayout *layout = new SubQGraphicsLinearLayout(orientation);
+    scene.addItem(widget);
+    widget->setLayout(layout);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0.0);
+    widget->setContentsMargins(0, 0, 0, 0);
+
+    int i;
+    for (i = 0; i < count; ++i) {
+        RectWidget *item = new RectWidget(widget);
+        layout->addItem(item);
+        if (preferredSizeHints.value(i, -1) >= 0) {
+            item->setSizeHint(Qt::PreferredSize, QSizeF(preferredSizeHints.at(i), preferredSizeHints.at(i)));
+        }
+        if (stretches.value(i, -1) >= 0) {
+            layout->setStretchFactor(item, stretches.at(i));
+        }
+        if (ignoreFlag.value(i, 0) != 0) {
+            QSizePolicy sp = item->sizePolicy();
+            if (orientation == Qt::Horizontal)
+                sp.setHorizontalPolicy(QSizePolicy::Policy(sp.horizontalPolicy() | QSizePolicy::IgnoreFlag));
+            else
+                sp.setVerticalPolicy(QSizePolicy::Policy(sp.verticalPolicy() | QSizePolicy::IgnoreFlag));
+            item->setSizePolicy(sp);
+        }
+    }
+
+    QApplication::processEvents();
+
+    widget->show();
+    view.show();
+    view.resize(400,300);
+    if (newSize.isValid())
+        widget->resize(newSize);
+
+    QApplication::processEvents();
+    for (i = 0; i < count; ++i) {
+        QSizeF itemSize = layout->itemAt(i)->geometry().size();
+        if (orientation == Qt::Vertical)
+            itemSize.transpose();
+        if (i < expectedSizes.count())
+            QCOMPARE(itemSize.width(), qreal(expectedSizes.at(i)));
+    }
+
+    delete widget;
+}
+
+Q_DECLARE_METATYPE(Qt::SizeHint)
+void tst_QGraphicsLinearLayout::sizeHint_data()
+{
+    QTest::addColumn<Qt::SizeHint>("which");
+    QTest::addColumn<QSizeF>("constraint");
+    QTest::addColumn<qreal>("spacing");
+    QTest::addColumn<qreal>("layoutMargin");
+    QTest::addColumn<QSizeF>("sizeHint");
+
+    QTest::newRow("minimumSize") << Qt::MinimumSize << QSizeF() << qreal(0.0) << qreal(0.0) << QSizeF(30, 10);
+    QTest::newRow("preferredSize") << Qt::PreferredSize << QSizeF() << qreal(0.0) << qreal(0.0) << QSizeF(75, 25);
+    QTest::newRow("maximumSize") << Qt::MaximumSize << QSizeF() << qreal(0.0) << qreal(0.0) << QSizeF(150, 50);
+    QTest::newRow("minimumSize, spacing=3") << Qt::MinimumSize << QSizeF() << qreal(3.0) << qreal(0.0) << QSizeF(30 + 2*3, 10);
+    QTest::newRow("minimumSize, spacing=3, layoutMargin=10") << Qt::MinimumSize << QSizeF() << qreal(3.0) << qreal(10.0) << QSizeF(30 + 2*3 + 2*10, 10 + 2*10);
+    QTest::newRow("minimumSize, spacing=0, layoutMargin=7") << Qt::MinimumSize << QSizeF() << qreal(0.0) << qreal(7.0) << QSizeF(30 + 0 + 2*7, 10 + 2*7);
+}
+
+// QSizeF sizeHint(Qt::SizeHint which, QSizeF const& constraint) const public
+void tst_QGraphicsLinearLayout::sizeHint()
+{
+    QFETCH(Qt::SizeHint, which);
+    QFETCH(QSizeF, constraint);
+    QFETCH(qreal, spacing);
+    QFETCH(qreal, layoutMargin);
+    QFETCH(QSizeF, sizeHint);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Window);
+    SubQGraphicsLinearLayout &layout = *(new SubQGraphicsLinearLayout);
+    scene.addItem(widget);
+    widget->setLayout(&layout);
+    layout.setContentsMargins(layoutMargin, layoutMargin, layoutMargin, layoutMargin);
+    layout.setSpacing(spacing);
+    for (int i = 0; i < 3; ++i) {
+        QGraphicsWidget *item = new QGraphicsWidget(widget);
+        item->setMinimumSize(10, 10);
+        item->setPreferredSize(25, 25);
+        item->setMaximumSize(50, 50);
+        layout.addItem(item);
+    }
+    QApplication::processEvents();
+    QCOMPARE(layout.sizeHint(which, constraint), sizeHint);
+    delete widget;
+}
+
+void tst_QGraphicsLinearLayout::updateGeometry()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    QGraphicsWidget *window = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsWidget *w1 = new QGraphicsWidget(window);
+    w1->setMinimumSize(100, 40);
+    SubQGraphicsLinearLayout *layout = new SubQGraphicsLinearLayout;
+    layout->addItem(w1);
+    scene.addItem(window);
+    window->setLayout(layout);
+    layout->setContentsMargins(0, 0, 0, 0);
+    QCOMPARE(w1->parentLayoutItem(), static_cast<QGraphicsLayoutItem*>(layout));
+    QCOMPARE(layout->parentLayoutItem(), static_cast<QGraphicsLayoutItem*>(window));
+
+    view.show();
+    QApplication::processEvents();
+    QCOMPARE(window->size().toSize(), QSize(100, 50));
+    w1->setMinimumSize(110, 60);
+    QApplication::processEvents();
+    QCOMPARE(window->size().toSize(), QSize(110, 60));
+    QApplication::processEvents();
+
+    {
+        delete window;
+        window = new QGraphicsWidget(0, Qt::Window);
+        SubQGraphicsLinearLayout *layout2a = new SubQGraphicsLinearLayout;
+        QGraphicsWidget *w1 = new QGraphicsWidget(window);
+        w1->setMinimumSize(110, 50);
+        layout2a->addItem(w1);
+        SubQGraphicsLinearLayout *layout2 = new SubQGraphicsLinearLayout;
+        layout2->addItem(layout2a);
+        layout2->setContentsMargins(1, 1, 1, 1);
+        layout2a->setContentsMargins(1, 1, 1, 1);
+        window->setLayout(layout2);
+        QApplication::processEvents();
+        QCOMPARE(w1->parentLayoutItem(), static_cast<QGraphicsLayoutItem*>(layout2a));
+        QCOMPARE(layout2a->parentLayoutItem(), static_cast<QGraphicsLayoutItem*>(layout2));
+        QCOMPARE(layout2->parentLayoutItem(), static_cast<QGraphicsLayoutItem*>(window));
+        QCOMPARE(window->size().toSize(), QSize(114, 54));
+        QApplication::processEvents();
+        w1->setMinimumSize(120, 60);
+        QApplication::processEvents();
+        QCOMPARE(window->size().toSize(), QSize(124, 64));
+    }
+
+    {
+        delete window;
+        window = new QGraphicsWidget(0, Qt::Window);
+        scene.addItem(window);
+        window->show();
+        QGraphicsWidget *w1 = new QGraphicsWidget(window);
+        w1->setMinimumSize(100, 50);
+        SubQGraphicsLinearLayout *layout2a = new SubQGraphicsLinearLayout;
+        layout2a->addItem(w1);
+        SubQGraphicsLinearLayout *layout2 = new SubQGraphicsLinearLayout;
+        layout2->addItem(layout2a);
+        layout2a->setContentsMargins(1, 1, 1, 1);
+        window->setLayout(layout2);
+        QApplication::processEvents();
+        qreal left, top, right, bottom;
+        layout2->getContentsMargins(&left, &top, &right, &bottom);
+        QCOMPARE(window->size().toSize(), QSize(102 +left + right, 52 + top + bottom));
+    }
+
+    {
+        delete window;
+        window = new QGraphicsWidget(0, Qt::Window);
+        scene.addItem(window);
+        QGraphicsWidget *w1 = new QGraphicsWidget(window);
+        w1->setMinimumSize(100, 50);
+        window->setLayout(0);
+        SubQGraphicsLinearLayout *layout2a = new SubQGraphicsLinearLayout;
+        layout2a->addItem(w1);
+        SubQGraphicsLinearLayout *layout2 = new SubQGraphicsLinearLayout;
+        layout2->addItem(layout2a);
+        window->resize(200, 80);
+        window->setLayout(layout2);
+        window->show();
+        QApplication::processEvents();
+        QCOMPARE(window->size().toSize(), QSize(200, 80));
+    }
+
+}
+
+void tst_QGraphicsLinearLayout::layoutDirection()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    QGraphicsWidget *window = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout;
+    layout->setContentsMargins(1, 2, 3, 4);
+    layout->setSpacing(6);
+
+    RectWidget *w1 = new RectWidget;
+    w1->setPreferredSize(20, 20);
+    w1->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+    layout->addItem(w1);
+    RectWidget *w2 = new RectWidget;
+    w2->setPreferredSize(20, 20);
+    w2->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+    layout->addItem(w2);
+
+    scene.addItem(window);
+    window->setLayout(layout);
+    view.show();
+    window->resize(50, 20);
+    window->setLayoutDirection(Qt::LeftToRight);
+    QApplication::processEvents();
+    QCOMPARE(w1->geometry().left(), 1.0);
+    QCOMPARE(w1->geometry().right(), 21.0);
+    QCOMPARE(w2->geometry().left(), 27.0);
+    QCOMPARE(w2->geometry().right(), 47.0);
+
+    window->setLayoutDirection(Qt::RightToLeft);
+    QApplication::processEvents();
+    QCOMPARE(w1->geometry().right(), 49.0);
+    QCOMPARE(w1->geometry().left(), 29.0);
+    QCOMPARE(w2->geometry().right(), 23.0);
+    QCOMPARE(w2->geometry().left(),  3.0);
+
+    delete window;
+}
+
+void tst_QGraphicsLinearLayout::removeLayout()
+{
+    QGraphicsScene scene;
+    RectWidget *textEdit = new RectWidget;
+    RectWidget *pushButton = new RectWidget;
+    scene.addItem(textEdit);
+    scene.addItem(pushButton);
+
+    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout;
+    layout->addItem(textEdit);
+    layout->addItem(pushButton);
+
+    QGraphicsWidget *form = new QGraphicsWidget;
+    form->setLayout(layout);
+    scene.addItem(form);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWait(20);
+
+    QRectF r1 = textEdit->geometry();
+    QRectF r2 = pushButton->geometry();
+    form->setLayout(0);
+    //documentation of QGraphicsWidget::setLayout:
+    //If layout is 0, the widget is left without a layout. Existing subwidgets' geometries will remain unaffected.
+    QCOMPARE(textEdit->geometry(), r1);
+    QCOMPARE(pushButton->geometry(), r2);
+}
+
+void tst_QGraphicsLinearLayout::avoidRecursionInInsertItem()
+{
+    QGraphicsWidget window(0, Qt::Window);
+	QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(&window);
+    QCOMPARE(layout->count(), 0);
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsLinearLayout::insertItem: cannot insert itself");
+    layout->insertItem(0, layout);
+    QCOMPARE(layout->count(), 0);
+}
+
+void tst_QGraphicsLinearLayout::styleInfoLeak()
+{
+    QGraphicsLinearLayout layout;
+    layout.spacing();
+}
+
+void tst_QGraphicsLinearLayout::task218400_insertStretchCrash()
+{
+    QGraphicsScene *scene = new QGraphicsScene;
+    QGraphicsWidget *a = scene->addWidget(new QWidget);
+    QGraphicsWidget *b = scene->addWidget(new QWidget);
+
+    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout;
+    layout->addItem(a);
+    layout->addItem(b);
+    layout->insertStretch(0); // inserts gap in item grid in the layout engine
+
+    QGraphicsWidget *form  = new QGraphicsWidget;
+    form->setLayout(layout); // crash
+}
+
+void tst_QGraphicsLinearLayout::testAlignmentInLargerLayout()
+{
+    QGraphicsScene *scene = new QGraphicsScene;
+    QGraphicsWidget *form = new QGraphicsWidget;
+    scene->addItem(form);
+    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Vertical, form);
+    layout->setSpacing(0);
+    layout->setContentsMargins(0,0,0,0);
+
+    QGraphicsWidget *a = new QGraphicsWidget;
+    a->setMaximumSize(100,100);
+    layout->addItem(a);
+
+    QCOMPARE(form->maximumSize(), QSizeF(100,100));
+    QCOMPARE(layout->maximumSize(), QSizeF(100,100));
+    layout->setMinimumSize(QSizeF(200,200));
+    layout->setMaximumSize(QSizeF(200,200));
+
+    layout->setAlignment(a, Qt::AlignCenter);
+    layout->activate();
+    QCOMPARE(a->geometry(), QRectF(50,50,100,100));
+
+    layout->setAlignment(a, Qt::AlignRight | Qt::AlignBottom);
+    layout->activate();
+    QCOMPARE(a->geometry(), QRectF(100,100,100,100));
+
+    layout->setAlignment(a, Qt::AlignHCenter | Qt::AlignTop);
+    layout->activate();
+    QCOMPARE(a->geometry(), QRectF(50,0,100,100));
+
+    QGraphicsWidget *b = new QGraphicsWidget;
+    b->setMaximumSize(100,100);
+    layout->addItem(b);
+
+    layout->setAlignment(a, Qt::AlignCenter);
+    layout->setAlignment(b, Qt::AlignCenter);
+    layout->activate();
+    QCOMPARE(a->geometry(), QRectF(50,0,100,100));
+    QCOMPARE(b->geometry(), QRectF(50,100,100,100));
+
+    layout->setAlignment(a, Qt::AlignRight | Qt::AlignBottom);
+    layout->setAlignment(b, Qt::AlignLeft | Qt::AlignTop);
+    layout->activate();
+    QCOMPARE(a->geometry(), QRectF(100,0,100,100));
+    QCOMPARE(b->geometry(), QRectF(0,100,100,100));
+}
+
+void tst_QGraphicsLinearLayout::testOffByOneInLargerLayout() {
+    QGraphicsScene *scene = new QGraphicsScene;
+    QGraphicsWidget *form = new QGraphicsWidget;
+    scene->addItem(form);
+    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Vertical, form);
+    layout->setSpacing(0);
+    layout->setContentsMargins(0,0,0,0);
+
+    QGraphicsWidget *a = new QGraphicsWidget;
+    QGraphicsWidget *b = new QGraphicsWidget;
+    a->setMaximumSize(100,100);
+    b->setMaximumSize(100,100);
+    layout->addItem(a);
+    layout->addItem(b);
+
+    layout->setAlignment(a, Qt::AlignRight | Qt::AlignBottom);
+    layout->setAlignment(b, Qt::AlignLeft | Qt::AlignTop);
+    layout->setMinimumSize(QSizeF(101,201));
+    layout->setMaximumSize(QSizeF(101,201));
+    layout->activate();
+    QCOMPARE(a->geometry(), QRectF(1,0.5,100,100));
+    QCOMPARE(b->geometry(), QRectF(0,100.5,100,100));
+
+    layout->setMinimumSize(QSizeF(100,200));
+    layout->setMaximumSize(QSizeF(100,200));
+    layout->activate();
+    QCOMPARE(a->geometry(), QRectF(0,0,100,100));
+    QCOMPARE(b->geometry(), QRectF(0,100,100,100));
+
+    layout->setMinimumSize(QSizeF(99,199));
+    layout->setMaximumSize(QSizeF(99,199));
+    layout->activate();
+    QCOMPARE(a->geometry(), QRectF(0,0,99,99.5));
+    QCOMPARE(b->geometry(), QRectF(0,99.5,99,99.5));
+}
+void tst_QGraphicsLinearLayout::testDefaultAlignment()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Vertical, widget);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    QGraphicsWidget *w = new QGraphicsWidget;
+    w->setMinimumSize(50,50);
+    w->setMaximumSize(50,50);
+    layout->addItem(w);
+
+    //Default alignment should be to the top-left
+    QCOMPARE(layout->alignment(w), 0);
+
+    //First, check by forcing the layout to be bigger
+    layout->setMinimumSize(100,100);
+    layout->activate();
+    QCOMPARE(layout->geometry(), QRectF(0,0,100,100));
+    QCOMPARE(w->geometry(), QRectF(0,0,50,50));
+    layout->setMinimumSize(-1,-1);
+
+    //Second, check by adding a larger item in the column
+    QGraphicsWidget *w2 = new QGraphicsWidget;
+    w2->setMinimumSize(100,100);
+    w2->setMaximumSize(100,100);
+    layout->addItem(w2);
+    layout->activate();
+    QCOMPARE(layout->geometry(), QRectF(0,0,100,150));
+    QCOMPARE(w->geometry(), QRectF(0,0,50,50));
+    QCOMPARE(w2->geometry(), QRectF(0,50,100,100));
+}
+
+void tst_QGraphicsLinearLayout::combineSizePolicies()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Horizontal, widget);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    QGraphicsWidget *w1 = new QGraphicsWidget;
+    w1->setMaximumSize(200,200);
+    w1->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+    layout->addItem(w1);
+
+    QGraphicsWidget *w2 = new QGraphicsWidget;
+    w2->setPreferredSize(50,50);
+    w2->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+    layout->addItem(w2);
+    QCOMPARE(layout->maximumHeight(), qreal(200));
+
+    // now remove the fixed vertical size policy, and set instead the maximum height to 50
+    // this should in effect give the same maximumHeight
+    w2->setMaximumHeight(50);
+    w2->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
+    QCOMPARE(layout->maximumHeight(), qreal(200));
+}
+
+QTEST_MAIN(tst_QGraphicsLinearLayout)
+#include "tst_qgraphicslinearlayout.moc"
+
diff --git a/tests/auto/widgets/graphicsview/qgraphicsobject/qgraphicsobject.pro b/tests/auto/widgets/graphicsview/qgraphicsobject/qgraphicsobject.pro
new file mode 100644
index 0000000000..5232ec8372
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsobject/qgraphicsobject.pro
@@ -0,0 +1,7 @@
+load(qttest_p4)
+
+QT += widgets
+QT += core-private
+
+SOURCES  += tst_qgraphicsobject.cpp
+CONFIG += parallel_test
diff --git a/tests/auto/widgets/graphicsview/qgraphicsobject/tst_qgraphicsobject.cpp b/tests/auto/widgets/graphicsview/qgraphicsobject/tst_qgraphicsobject.cpp
new file mode 100644
index 0000000000..85e36b74b2
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsobject/tst_qgraphicsobject.cpp
@@ -0,0 +1,297 @@
+/****************************************************************************
+**
+** 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 <qgraphicsitem.h>
+#include <qgraphicsscene.h>
+#include <qgraphicssceneevent.h>
+#include <qgraphicsview.h>
+#include <qstyleoption.h>
+#include <private/qobject_p.h>
+
+class tst_QGraphicsObject : public QObject {
+    Q_OBJECT
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+private slots:
+    void pos();
+    void x();
+    void y();
+    void z();
+    void opacity();
+    void enabled();
+    void visible();
+    void deleted();
+};
+
+
+// This will be called before the first test function is executed.
+// It is only called once.
+void tst_QGraphicsObject::initTestCase()
+{
+}
+
+// This will be called after the last test function is executed.
+// It is only called once.
+void tst_QGraphicsObject::cleanupTestCase()
+{
+}
+
+// This will be called before each test function is executed.
+void tst_QGraphicsObject::init()
+{
+}
+
+// This will be called after every test function.
+void tst_QGraphicsObject::cleanup()
+{
+}
+
+
+class MyGraphicsObject : public QGraphicsObject
+{
+public:
+    MyGraphicsObject() : QGraphicsObject() {}
+    virtual QRectF boundingRect() const { return QRectF(); }
+    virtual void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) {}
+};
+
+void tst_QGraphicsObject::pos()
+{
+    MyGraphicsObject object;
+    QSignalSpy xSpy(&object, SIGNAL(xChanged()));
+    QSignalSpy ySpy(&object, SIGNAL(yChanged()));
+    QVERIFY(object.pos() == QPointF(0, 0));
+    object.setPos(10, 10);
+    QCOMPARE(xSpy.count(), 1);
+    QCOMPARE(ySpy.count(), 1);
+
+    QVERIFY(object.pos() == QPointF(10,10));
+
+    object.setPos(10, 10);
+    QCOMPARE(xSpy.count(), 1);
+    QCOMPARE(ySpy.count(), 1);
+
+    object.setProperty("pos", QPointF(0, 0));
+    QCOMPARE(xSpy.count(), 2);
+    QCOMPARE(ySpy.count(), 2);
+    QVERIFY(object.property("pos") == QPointF(0,0));
+
+    object.setProperty("pos", QPointF(10, 0));
+    QCOMPARE(xSpy.count(), 3);
+    QCOMPARE(ySpy.count(), 2);
+    QVERIFY(object.property("pos") == QPointF(10,0));
+
+    object.setProperty("pos", QPointF(10, 10));
+    QCOMPARE(xSpy.count(), 3);
+    QCOMPARE(ySpy.count(), 3);
+    QVERIFY(object.property("pos") == QPointF(10, 10));
+}
+
+void tst_QGraphicsObject::x()
+{
+    MyGraphicsObject object;
+    QSignalSpy xSpy(&object, SIGNAL(xChanged()));
+    QSignalSpy ySpy(&object, SIGNAL(yChanged()));
+    QVERIFY(object.pos() == QPointF(0, 0));
+    object.setX(10);
+    QCOMPARE(xSpy.count(), 1);
+    QCOMPARE(ySpy.count(), 0);
+
+    QVERIFY(object.pos() == QPointF(10, 0));
+    QVERIFY(object.x() == 10);
+
+    object.setX(10);
+    QCOMPARE(xSpy.count(), 1);
+    QCOMPARE(ySpy.count(), 0);
+
+    object.setProperty("x", 0);
+    QCOMPARE(xSpy.count(), 2);
+    QCOMPARE(ySpy.count(), 0);
+    QVERIFY(object.property("x") == 0);
+}
+
+void tst_QGraphicsObject::y()
+{
+    MyGraphicsObject object;
+    QSignalSpy xSpy(&object, SIGNAL(xChanged()));
+    QSignalSpy ySpy(&object, SIGNAL(yChanged()));
+    QVERIFY(object.pos() == QPointF(0, 0));
+    object.setY(10);
+    QCOMPARE(xSpy.count(), 0);
+    QCOMPARE(ySpy.count(), 1);
+
+    QVERIFY(object.pos() == QPointF(0, 10));
+    QVERIFY(object.y() == 10);
+
+    object.setY(10);
+    QCOMPARE(xSpy.count(), 0);
+    QCOMPARE(ySpy.count(), 1);
+
+    object.setProperty("y", 0);
+    QCOMPARE(xSpy.count(), 0);
+    QCOMPARE(ySpy.count(), 2);
+    QVERIFY(object.property("y") == 0);
+}
+
+void tst_QGraphicsObject::z()
+{
+    MyGraphicsObject object;
+    QSignalSpy zSpy(&object, SIGNAL(zChanged()));
+    QVERIFY(object.zValue() == 0);
+    object.setZValue(10);
+    QCOMPARE(zSpy.count(), 1);
+
+    QVERIFY(object.zValue() == 10);
+
+    object.setZValue(10);
+    QCOMPARE(zSpy.count(), 1);
+
+    object.setProperty("z", 0);
+    QCOMPARE(zSpy.count(), 2);
+    QVERIFY(object.property("z") == 0);
+}
+
+void tst_QGraphicsObject::opacity()
+{
+    MyGraphicsObject object;
+    QSignalSpy spy(&object, SIGNAL(opacityChanged()));
+    QVERIFY(object.opacity() == 1.);
+    object.setOpacity(0);
+    QCOMPARE(spy.count(), 1);
+
+    QVERIFY(object.opacity() == 0.);
+
+    object.setOpacity(0);
+    QCOMPARE(spy.count(), 1);
+
+    object.setProperty("opacity", .5);
+    QCOMPARE(spy.count(), 2);
+    QVERIFY(object.property("opacity") == .5);
+}
+
+void tst_QGraphicsObject::enabled()
+{
+    MyGraphicsObject object;
+    QSignalSpy spy(&object, SIGNAL(enabledChanged()));
+    QVERIFY(object.isEnabled() == true);
+    object.setEnabled(false);
+    QCOMPARE(spy.count(), 1);
+
+    QVERIFY(object.isEnabled() == false);
+
+    object.setEnabled(false);
+    QCOMPARE(spy.count(), 1);
+
+    object.setProperty("enabled", true);
+    QCOMPARE(spy.count(), 2);
+    QVERIFY(object.property("enabled") == true);
+}
+
+void tst_QGraphicsObject::visible()
+{
+    MyGraphicsObject object;
+    QSignalSpy spy(&object, SIGNAL(visibleChanged()));
+    QVERIFY(object.isVisible() == true);
+    object.setVisible(false);
+    QCOMPARE(spy.count(), 1);
+
+    QVERIFY(object.isVisible() == false);
+
+    object.setVisible(false);
+    QCOMPARE(spy.count(), 1);
+
+    object.setProperty("visible", true);
+    QCOMPARE(spy.count(), 2);
+    QVERIFY(object.property("visible") == true);
+}
+
+class DeleteTester : public QGraphicsObject
+{
+public:
+    DeleteTester(bool *w, bool *pw, QGraphicsItem *parent = 0)
+        : QGraphicsObject(parent), wasDeleted(w), parentWasDeleted(pw)
+    { }
+
+    ~DeleteTester()
+    {
+        *wasDeleted = QObjectPrivate::get(this)->wasDeleted;
+        if (QGraphicsItem *p = parentItem()) {
+            if (QGraphicsObject *o = p->toGraphicsObject())
+                *parentWasDeleted = QObjectPrivate::get(o)->wasDeleted;
+        }
+    }
+
+    void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget * = 0)
+    { }
+    QRectF boundingRect() const
+    { return QRectF(); }
+
+    bool *wasDeleted;
+    bool *parentWasDeleted;
+};
+
+void tst_QGraphicsObject::deleted()
+{
+    bool item1_parentWasDeleted = false;
+    bool item1_wasDeleted = false;
+    bool item2_parentWasDeleted = false;
+    bool item2_wasDeleted = false;
+    DeleteTester *item1 = new DeleteTester(&item1_wasDeleted, &item1_parentWasDeleted);
+    DeleteTester *item2 = new DeleteTester(&item2_wasDeleted, &item2_parentWasDeleted, item1);
+    Q_UNUSED(item2);
+    delete item1;
+
+    QVERIFY(!item1_wasDeleted); // destructor not called yet
+    QVERIFY(!item1_parentWasDeleted); // no parent
+    QVERIFY(!item2_wasDeleted); // destructor not called yet
+    QVERIFY(item2_parentWasDeleted);
+}
+
+QTEST_MAIN(tst_QGraphicsObject)
+#include "tst_qgraphicsobject.moc"
+
diff --git a/tests/auto/widgets/graphicsview/qgraphicspixmapitem/.gitignore b/tests/auto/widgets/graphicsview/qgraphicspixmapitem/.gitignore
new file mode 100644
index 0000000000..1e92419fd0
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicspixmapitem/.gitignore
@@ -0,0 +1 @@
+tst_qgraphicspixmapitem
diff --git a/tests/auto/widgets/graphicsview/qgraphicspixmapitem/qgraphicspixmapitem.pro b/tests/auto/widgets/graphicsview/qgraphicspixmapitem/qgraphicspixmapitem.pro
new file mode 100644
index 0000000000..6b1ad34057
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicspixmapitem/qgraphicspixmapitem.pro
@@ -0,0 +1,5 @@
+load(qttest_p4)
+QT += widgets
+SOURCES  += tst_qgraphicspixmapitem.cpp
+CONFIG += parallel_test
+
diff --git a/tests/auto/widgets/graphicsview/qgraphicspixmapitem/tst_qgraphicspixmapitem.cpp b/tests/auto/widgets/graphicsview/qgraphicspixmapitem/tst_qgraphicspixmapitem.cpp
new file mode 100644
index 0000000000..b2dccb0b09
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicspixmapitem/tst_qgraphicspixmapitem.cpp
@@ -0,0 +1,427 @@
+/****************************************************************************
+**
+** 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 <qgraphicsscene.h>
+#include <qgraphicsitem.h>
+
+class tst_QGraphicsPixmapItem : public QObject
+{
+    Q_OBJECT
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+private slots:
+    void qgraphicspixmapitem_data();
+    void qgraphicspixmapitem();
+    void boundingRect_data();
+    void boundingRect();
+    void contains_data();
+    void contains();
+    void isObscuredBy_data();
+    void isObscuredBy();
+    void offset_data();
+    void offset();
+    void opaqueArea_data();
+    void opaqueArea();
+    void pixmap_data();
+    void pixmap();
+    void setPixmap_data();
+    void setPixmap();
+    void setShapeMode_data();
+    void setShapeMode();
+    void setTransformationMode_data();
+    void setTransformationMode();
+    void shape_data();
+    void shape();
+    void extension_data();
+    void extension();
+    void setExtension_data();
+    void setExtension();
+    void supportsExtension_data();
+    void supportsExtension();
+};
+
+// Subclass that exposes the protected functions.
+class SubQGraphicsPixmapItem : public QGraphicsPixmapItem
+{
+public:
+    enum Extension {
+        UserExtension = QGraphicsItem::UserExtension
+    };
+    SubQGraphicsPixmapItem(QGraphicsItem *parent = 0) : QGraphicsPixmapItem(parent)
+    {
+    }
+
+    SubQGraphicsPixmapItem(const QPixmap &pixmap, QGraphicsItem *parent = 0) : QGraphicsPixmapItem(pixmap, parent)
+    {
+    }
+
+    QVariant call_extension(QVariant const& variant) const
+        { return SubQGraphicsPixmapItem::extension(variant); }
+
+    void call_setExtension(Extension extension, QVariant const& variant)
+        { return SubQGraphicsPixmapItem::setExtension((QGraphicsItem::Extension)extension, variant); }
+
+    bool call_supportsExtension(Extension extension) const
+        { return SubQGraphicsPixmapItem::supportsExtension((QGraphicsItem::Extension)extension); }
+};
+
+// This will be called before the first test function is executed.
+// It is only called once.
+void tst_QGraphicsPixmapItem::initTestCase()
+{
+}
+
+// This will be called after the last test function is executed.
+// It is only called once.
+void tst_QGraphicsPixmapItem::cleanupTestCase()
+{
+}
+
+// This will be called before each test function is executed.
+void tst_QGraphicsPixmapItem::init()
+{
+}
+
+// This will be called after every test function.
+void tst_QGraphicsPixmapItem::cleanup()
+{
+}
+
+void tst_QGraphicsPixmapItem::qgraphicspixmapitem_data()
+{
+}
+
+void tst_QGraphicsPixmapItem::qgraphicspixmapitem()
+{
+    SubQGraphicsPixmapItem item;
+    item.boundingRect();
+    item.contains(QPoint());
+    item.isObscuredBy(0);
+    item.opaqueArea();
+    //item.paint();
+    QCOMPARE(item.offset(), QPointF());
+    QCOMPARE(item.pixmap(), QPixmap());
+    QCOMPARE(item.shapeMode(), QGraphicsPixmapItem::MaskShape);
+    QCOMPARE(item.transformationMode(), Qt::FastTransformation);
+    item.setOffset(0, 0);
+    item.setOffset(QPointF(0, 0));
+    item.setPixmap(QPixmap());
+    item.setShapeMode(QGraphicsPixmapItem::MaskShape);
+    item.setTransformationMode(Qt::FastTransformation);
+    item.shape();
+    item.type();
+    item.call_extension(QVariant());
+    item.call_setExtension(SubQGraphicsPixmapItem::UserExtension, QVariant());
+    item.call_supportsExtension(SubQGraphicsPixmapItem::UserExtension);
+}
+
+void tst_QGraphicsPixmapItem::boundingRect_data()
+{
+    QTest::addColumn<QPixmap>("pixmap");
+    QTest::addColumn<QRectF>("boundingRect");
+    QTest::newRow("null") << QPixmap() << QRectF();
+    QTest::newRow("10x10") << QPixmap(10, 10) << QRectF(0, 0, 10, 10);
+}
+
+// public QRectF boundingRect() const
+void tst_QGraphicsPixmapItem::boundingRect()
+{
+    QFETCH(QPixmap, pixmap);
+    QFETCH(QRectF, boundingRect);
+
+    SubQGraphicsPixmapItem item(pixmap);
+    QCOMPARE(item.boundingRect(), boundingRect);
+}
+
+void tst_QGraphicsPixmapItem::contains_data()
+{
+    QTest::addColumn<QPixmap>("pixmap");
+    QTest::addColumn<QPointF>("point");
+    QTest::addColumn<bool>("contains");
+    QTest::newRow("null") << QPixmap() << QPointF() << false;
+    QTest::newRow("10x10, 100x100") << QPixmap(10, 10) << QPointF(100, 100) << false;
+    QTest::newRow("10x10, 5x5") << QPixmap(10, 10) << QPointF(5, 5) << true;
+    QTest::newRow("border-1") << QPixmap(10, 10) << QPointF(10.5, 10.5) << false;
+    QTest::newRow("border-2") << QPixmap(10, 10) << QPointF(-0.5, -0.5) << false;
+}
+
+// public bool contains(QPointF const& point) const
+void tst_QGraphicsPixmapItem::contains()
+{
+    QFETCH(QPixmap, pixmap);
+    QFETCH(QPointF, point);
+    QFETCH(bool, contains);
+
+    SubQGraphicsPixmapItem item(pixmap);
+    QCOMPARE(item.contains(point), contains);
+}
+
+void tst_QGraphicsPixmapItem::isObscuredBy_data()
+{
+    QTest::addColumn<QPixmap>("pixmap");
+    QTest::addColumn<QPixmap>("otherPixmap");
+    QTest::addColumn<bool>("isObscuredBy");
+    QTest::newRow("null") << QPixmap() << QPixmap() << false;
+    QTest::newRow("(10, 10) vs. (5, 5)") << QPixmap(10, 10) << QPixmap(5, 5) << false;
+    QTest::newRow("(5, 5) vs. (10, 10)") << QPixmap(5, 5) << QPixmap(10, 10) << true;
+    QTest::newRow("(10, 10) vs. (10, 10)") << QPixmap(10, 10) << QPixmap(10, 10) << false;
+    QTest::newRow("(9, 9) vs. (10, 10)") << QPixmap(8, 8) << QPixmap(10, 10) << true;
+    QTest::newRow("(10, 10) vs. (9, 9)") << QPixmap(10, 10) << QPixmap(8, 8) << false;
+}
+
+// public bool isObscuredBy(QGraphicsItem const* item) const
+void tst_QGraphicsPixmapItem::isObscuredBy()
+{
+    QFETCH(QPixmap, pixmap);
+    QFETCH(QPixmap, otherPixmap);
+    QFETCH(bool, isObscuredBy);
+    pixmap.fill();
+    otherPixmap.fill();
+
+    SubQGraphicsPixmapItem *item = new SubQGraphicsPixmapItem(pixmap);
+    SubQGraphicsPixmapItem *otherItem = new SubQGraphicsPixmapItem(otherPixmap);
+
+    item->setOffset(-pixmap.width() / 2.0, -pixmap.height() / 2.0);
+    otherItem->setOffset(-otherPixmap.width() / 2.0, -otherPixmap.height() / 2.0);
+
+    QGraphicsScene scene;
+    scene.addItem(item);
+    scene.addItem(otherItem);
+    otherItem->setZValue(1);
+
+    QCOMPARE(item->isObscuredBy(otherItem), isObscuredBy);
+}
+
+void tst_QGraphicsPixmapItem::offset_data()
+{
+    QTest::addColumn<QPixmap>("pixmap");
+    QTest::addColumn<QPointF>("offset");
+    QTest::newRow("null") << QPixmap() << QPointF();
+    QTest::newRow("10x10, 1x1") << QPixmap(10, 10) << QPointF(1, 1);
+}
+
+// public QPointF offset() const
+void tst_QGraphicsPixmapItem::offset()
+{
+    QFETCH(QPixmap, pixmap);
+    QFETCH(QPointF, offset);
+
+    SubQGraphicsPixmapItem item(pixmap);
+    item.setOffset(offset);
+    QCOMPARE(item.offset(), offset);
+
+    // ### test actual painting and compare pixmap with offseted one?
+}
+
+Q_DECLARE_METATYPE(QPainterPath)
+void tst_QGraphicsPixmapItem::opaqueArea_data()
+{
+    QTest::addColumn<QPixmap>("pixmap");
+    QTest::addColumn<QPainterPath>("opaqueArea");
+    QTest::newRow("null") << QPixmap() << QPainterPath();
+    // Currently QGraphicsPixmapItem just calls QGraphicsItem test there
+}
+
+// public QPainterPath opaqueArea() const
+void tst_QGraphicsPixmapItem::opaqueArea()
+{
+    QFETCH(QPixmap, pixmap);
+    QFETCH(QPainterPath, opaqueArea);
+
+    SubQGraphicsPixmapItem item;
+    QCOMPARE(item.opaqueArea(), opaqueArea);
+}
+
+void tst_QGraphicsPixmapItem::pixmap_data()
+{
+    QTest::addColumn<QPixmap>("pixmap");
+    QTest::newRow("null") << QPixmap();
+    QTest::newRow("10x10") << QPixmap(10, 10);
+}
+
+// public QPixmap pixmap() const
+void tst_QGraphicsPixmapItem::pixmap()
+{
+    QFETCH(QPixmap, pixmap);
+
+    SubQGraphicsPixmapItem item(pixmap);
+    QCOMPARE(item.pixmap(), pixmap);
+}
+
+void tst_QGraphicsPixmapItem::setPixmap_data()
+{
+    QTest::addColumn<QPixmap>("pixmap");
+    QTest::newRow("null") << QPixmap();
+    QTest::newRow("10x10") << QPixmap(10, 10);
+}
+
+// public void setPixmap(QPixmap const& pixmap)
+void tst_QGraphicsPixmapItem::setPixmap()
+{
+    QFETCH(QPixmap, pixmap);
+
+    SubQGraphicsPixmapItem item;
+    item.setPixmap(pixmap);
+    QCOMPARE(item.pixmap(), pixmap);
+}
+
+Q_DECLARE_METATYPE(QGraphicsPixmapItem::ShapeMode)
+void tst_QGraphicsPixmapItem::setShapeMode_data()
+{
+    QTest::addColumn<QPixmap>("pixmap");
+    QTest::addColumn<QGraphicsPixmapItem::ShapeMode>("mode");
+    QTest::newRow("MaskShape") << QPixmap() << QGraphicsPixmapItem::MaskShape;
+    QTest::newRow("BoundingRectShape") << QPixmap() << QGraphicsPixmapItem::BoundingRectShape;
+    QTest::newRow("HeuristicMaskShape") << QPixmap() << QGraphicsPixmapItem::HeuristicMaskShape;
+}
+
+// public void setShapeMode(QGraphicsPixmapItem::ShapeMode mode)
+void tst_QGraphicsPixmapItem::setShapeMode()
+{
+    QFETCH(QPixmap, pixmap);
+    QFETCH(QGraphicsPixmapItem::ShapeMode, mode);
+
+    SubQGraphicsPixmapItem item(pixmap);
+    item.setShapeMode(mode);
+    QCOMPARE(item.shapeMode(), mode);
+}
+
+Q_DECLARE_METATYPE(Qt::TransformationMode)
+void tst_QGraphicsPixmapItem::setTransformationMode_data()
+{
+    QTest::addColumn<QPixmap>("pixmap");
+    QTest::addColumn<Qt::TransformationMode>("mode");
+    QTest::newRow("FastTransformation") << QPixmap() << Qt::FastTransformation;
+    QTest::newRow("SmoothTransformation") << QPixmap() << Qt::SmoothTransformation;
+}
+
+// public void setTransformationMode(Qt::TransformationMode mode)
+void tst_QGraphicsPixmapItem::setTransformationMode()
+{
+    QFETCH(QPixmap, pixmap);
+    QFETCH(Qt::TransformationMode, mode);
+
+    SubQGraphicsPixmapItem item(pixmap);
+    item.setTransformationMode(mode);
+    QCOMPARE(item.transformationMode(), mode);
+}
+
+void tst_QGraphicsPixmapItem::shape_data()
+{
+    QTest::addColumn<QPixmap>("pixmap");
+    QTest::addColumn<QPainterPath>("shape");
+    QTest::newRow("null") << QPixmap() << QPainterPath();
+    // ### what does a normal shape look like?
+}
+
+// public QPainterPath shape() const
+void tst_QGraphicsPixmapItem::shape()
+{
+    QFETCH(QPixmap, pixmap);
+    QFETCH(QPainterPath, shape);
+
+    SubQGraphicsPixmapItem item(pixmap);
+    QCOMPARE(item.shape(), shape);
+}
+
+Q_DECLARE_METATYPE(SubQGraphicsPixmapItem::Extension)
+Q_DECLARE_METATYPE(QVariant)
+void tst_QGraphicsPixmapItem::extension_data()
+{
+    QTest::addColumn<QVariant>("variant");
+    QTest::addColumn<QVariant>("extension");
+    QTest::newRow("null") << QVariant() << QVariant();
+}
+
+// protected QVariant extension(QVariant const& variant) const
+void tst_QGraphicsPixmapItem::extension()
+{
+    QFETCH(QVariant, variant);
+    QFETCH(QVariant, extension);
+
+    SubQGraphicsPixmapItem item;
+    QCOMPARE(item.call_extension(variant), extension);
+}
+
+void tst_QGraphicsPixmapItem::setExtension_data()
+{
+    QTest::addColumn<SubQGraphicsPixmapItem::Extension>("extension");
+    QTest::addColumn<QVariant>("variant");
+    QTest::newRow("null") << SubQGraphicsPixmapItem::UserExtension << QVariant();
+}
+
+// protected void setExtension(QGraphicsItem::Extension extension, QVariant const& variant)
+void tst_QGraphicsPixmapItem::setExtension()
+{
+    QFETCH(SubQGraphicsPixmapItem::Extension, extension);
+    QFETCH(QVariant, variant);
+
+    SubQGraphicsPixmapItem item;
+    item.call_setExtension(extension, variant);
+}
+
+void tst_QGraphicsPixmapItem::supportsExtension_data()
+{
+    QTest::addColumn<SubQGraphicsPixmapItem::Extension>("extension");
+    QTest::addColumn<bool>("supportsExtension");
+    QTest::newRow("null") << SubQGraphicsPixmapItem::UserExtension << false;
+}
+
+// protected bool supportsExtension(QGraphicsItem::Extension extension) const
+void tst_QGraphicsPixmapItem::supportsExtension()
+{
+    QFETCH(SubQGraphicsPixmapItem::Extension, extension);
+    QFETCH(bool, supportsExtension);
+
+    SubQGraphicsPixmapItem item;
+    QCOMPARE(item.call_supportsExtension(extension), supportsExtension);
+}
+
+QTEST_MAIN(tst_QGraphicsPixmapItem)
+#include "tst_qgraphicspixmapitem.moc"
+
diff --git a/tests/auto/widgets/graphicsview/qgraphicspolygonitem/.gitignore b/tests/auto/widgets/graphicsview/qgraphicspolygonitem/.gitignore
new file mode 100644
index 0000000000..595076024b
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicspolygonitem/.gitignore
@@ -0,0 +1 @@
+tst_qgraphicspolygonitem
diff --git a/tests/auto/widgets/graphicsview/qgraphicspolygonitem/qgraphicspolygonitem.pro b/tests/auto/widgets/graphicsview/qgraphicspolygonitem/qgraphicspolygonitem.pro
new file mode 100644
index 0000000000..2aa16751e6
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicspolygonitem/qgraphicspolygonitem.pro
@@ -0,0 +1,5 @@
+load(qttest_p4)
+QT += widgets
+SOURCES  += tst_qgraphicspolygonitem.cpp
+CONFIG += parallel_test
+
diff --git a/tests/auto/widgets/graphicsview/qgraphicspolygonitem/tst_qgraphicspolygonitem.cpp b/tests/auto/widgets/graphicsview/qgraphicspolygonitem/tst_qgraphicspolygonitem.cpp
new file mode 100644
index 0000000000..061b3eda81
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicspolygonitem/tst_qgraphicspolygonitem.cpp
@@ -0,0 +1,349 @@
+/****************************************************************************
+**
+** 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 <qgraphicsitem.h>
+
+Q_DECLARE_METATYPE(QPolygonF)
+
+class tst_QGraphicsPolygonItem : public QObject
+{
+    Q_OBJECT
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+private slots:
+    void qgraphicspolygonitem_data();
+    void qgraphicspolygonitem();
+    void boundingRect_data();
+    void boundingRect();
+    void contains_data();
+    void contains();
+    void fillRule_data();
+    void fillRule();
+    void isObscuredBy_data();
+    void isObscuredBy();
+    void opaqueArea_data();
+    void opaqueArea();
+    void polygon_data();
+    void polygon();
+    void shape_data();
+    void shape();
+    void extension_data();
+    void extension();
+    void setExtension_data();
+    void setExtension();
+    void supportsExtension_data();
+    void supportsExtension();
+};
+
+// Subclass that exposes the protected functions.
+class SubQGraphicsPolygonItem : public QGraphicsPolygonItem
+{
+public:
+    enum Extension {
+        UserExtension = QGraphicsItem::UserExtension
+    };
+
+    SubQGraphicsPolygonItem(QGraphicsItem *parent = 0) : QGraphicsPolygonItem(parent)
+    {
+    }
+
+    SubQGraphicsPolygonItem(const QPolygonF &polygon, QGraphicsItem *parent = 0) : QGraphicsPolygonItem(polygon, parent)
+    {
+    }
+
+    QVariant call_extension(QVariant const& variant) const
+        { return SubQGraphicsPolygonItem::extension(variant); }
+
+    void call_setExtension(SubQGraphicsPolygonItem::Extension extension, QVariant const& variant)
+        { return SubQGraphicsPolygonItem::setExtension((QGraphicsItem::Extension)extension, variant); }
+
+    bool call_supportsExtension(SubQGraphicsPolygonItem::Extension extension) const
+        { return SubQGraphicsPolygonItem::supportsExtension((QGraphicsItem::Extension)extension); }
+};
+
+// This will be called before the first test function is executed.
+// It is only called once.
+void tst_QGraphicsPolygonItem::initTestCase()
+{
+}
+
+// This will be called after the last test function is executed.
+// It is only called once.
+void tst_QGraphicsPolygonItem::cleanupTestCase()
+{
+}
+
+// This will be called before each test function is executed.
+void tst_QGraphicsPolygonItem::init()
+{
+}
+
+// This will be called after every test function.
+void tst_QGraphicsPolygonItem::cleanup()
+{
+}
+
+void tst_QGraphicsPolygonItem::qgraphicspolygonitem_data()
+{
+}
+
+void tst_QGraphicsPolygonItem::qgraphicspolygonitem()
+{
+    SubQGraphicsPolygonItem item;
+
+    item.boundingRect();
+    item.contains(QPoint());
+    item.isObscuredBy(0);
+    item.opaqueArea();
+    //item.paint();
+    item.shape();
+    item.type();
+    item.call_extension(QVariant());
+    item.call_setExtension(SubQGraphicsPolygonItem::UserExtension, QVariant());
+    item.call_supportsExtension(SubQGraphicsPolygonItem::UserExtension);
+    item.fillRule();
+    item.polygon();
+    item.setFillRule(Qt::OddEvenFill);
+    item.setPolygon(QPolygonF());
+}
+
+void tst_QGraphicsPolygonItem::boundingRect_data()
+{
+    QTest::addColumn<QPolygonF>("polygon");
+    QTest::addColumn<QRectF>("boundingRect");
+    QTest::newRow("null") << QPolygonF() << QRectF();
+    QPolygonF example;
+    example << QPointF(10.4, 20.5) << QPointF(20.2, 30.2);
+    QTest::newRow("example") << example << example.boundingRect();
+    // ### set pen width?
+}
+
+// public QRectF boundingRect() const
+void tst_QGraphicsPolygonItem::boundingRect()
+{
+    QFETCH(QPolygonF, polygon);
+    QFETCH(QRectF, boundingRect);
+
+    SubQGraphicsPolygonItem item(polygon);
+    QCOMPARE(item.boundingRect(), boundingRect);
+}
+
+void tst_QGraphicsPolygonItem::contains_data()
+{
+    QTest::addColumn<QPolygonF>("polygon");
+    QTest::addColumn<QPointF>("point");
+    QTest::addColumn<bool>("contains");
+    QTest::newRow("null") << QPolygonF() << QPointF() << false;
+}
+
+// public bool contains(QPointF const& point) const
+void tst_QGraphicsPolygonItem::contains()
+{
+    QFETCH(QPolygonF, polygon);
+    QFETCH(QPointF, point);
+    QFETCH(bool, contains);
+
+    SubQGraphicsPolygonItem item(polygon);
+
+    QCOMPARE(item.contains(point), contains);
+}
+
+Q_DECLARE_METATYPE(Qt::FillRule)
+void tst_QGraphicsPolygonItem::fillRule_data()
+{
+    QTest::addColumn<QPolygonF>("polygon");
+    QTest::addColumn<Qt::FillRule>("fillRule");
+    QTest::newRow("OddEvenFill") << QPolygonF() << Qt::OddEvenFill;
+    QTest::newRow("WindingFill") << QPolygonF() << Qt::WindingFill;
+}
+
+// public Qt::FillRule fillRule() const
+void tst_QGraphicsPolygonItem::fillRule()
+{
+    QFETCH(QPolygonF, polygon);
+    QFETCH(Qt::FillRule, fillRule);
+
+    SubQGraphicsPolygonItem item(polygon);
+
+    item.setFillRule(fillRule);
+    QCOMPARE(item.fillRule(), fillRule);
+    // ### Check that the painting is different?
+}
+
+void tst_QGraphicsPolygonItem::isObscuredBy_data()
+{
+    QTest::addColumn<QPolygonF>("polygon");
+    QTest::addColumn<QPolygonF>("otherPolygon");
+    QTest::addColumn<bool>("isObscuredBy");
+    QTest::newRow("null") << QPolygonF() << QPolygonF() << false;
+    //QTest::newRow("ontop-inside") << QPixmap(10, 10) << QPixmap(5, 5) << false;
+    //QTest::newRow("ontop-larger") << QPixmap(10, 10) << QPixmap(11, 11) << true;
+}
+
+// public bool isObscuredBy(QGraphicsItem const* item) const
+void tst_QGraphicsPolygonItem::isObscuredBy()
+{
+    QFETCH(QPolygonF, polygon);
+    QFETCH(QPolygonF, otherPolygon);
+    QFETCH(bool, isObscuredBy);
+    SubQGraphicsPolygonItem item(polygon);
+    SubQGraphicsPolygonItem otherItem(otherPolygon);
+    QCOMPARE(item.isObscuredBy(&otherItem), isObscuredBy);
+}
+
+Q_DECLARE_METATYPE(QPainterPath)
+void tst_QGraphicsPolygonItem::opaqueArea_data()
+{
+    QTest::addColumn<QPolygonF>("polygon");
+    QTest::addColumn<QPainterPath>("opaqueArea");
+    QTest::newRow("null") << QPolygonF() << QPainterPath();
+    // Currently QGraphicsPolygonItem just calls QGraphicsItem test there
+}
+
+// public QPainterPath opaqueArea() const
+void tst_QGraphicsPolygonItem::opaqueArea()
+{
+    QFETCH(QPolygonF, polygon);
+    QFETCH(QPainterPath, opaqueArea);
+
+    SubQGraphicsPolygonItem item(polygon);
+    QCOMPARE(item.opaqueArea(), opaqueArea);
+}
+
+void tst_QGraphicsPolygonItem::polygon_data()
+{
+    QTest::addColumn<QPolygonF>("polygon");
+    QTest::newRow("null") << QPolygonF();
+    QPolygonF example;
+    example << QPointF(10.4, 20.5) << QPointF(20.2, 30.2);
+    QTest::newRow("example") << example;
+}
+
+// public QPolygonF polygon() const
+void tst_QGraphicsPolygonItem::polygon()
+{
+    QFETCH(QPolygonF, polygon);
+
+    SubQGraphicsPolygonItem item;
+    item.setPolygon(polygon);
+    QCOMPARE(item.polygon(), polygon);
+}
+
+void tst_QGraphicsPolygonItem::shape_data()
+{
+    QTest::addColumn<QPainterPath>("shape");
+    QTest::newRow("null") << QPainterPath();
+    // ### what should a normal shape look like?
+}
+
+// public QPainterPath shape() const
+void tst_QGraphicsPolygonItem::shape()
+{
+    QFETCH(QPainterPath, shape);
+
+    SubQGraphicsPolygonItem item;
+    QCOMPARE(item.shape(), shape);
+}
+
+Q_DECLARE_METATYPE(QVariant)
+void tst_QGraphicsPolygonItem::extension_data()
+{
+    QTest::addColumn<QVariant>("variant");
+    QTest::addColumn<QVariant>("extension");
+    QTest::newRow("null") << QVariant() << QVariant();
+}
+
+// protected QVariant extension(QVariant const& variant) const
+void tst_QGraphicsPolygonItem::extension()
+{
+    QFETCH(QVariant, variant);
+    QFETCH(QVariant, extension);
+
+    SubQGraphicsPolygonItem item;
+
+    QCOMPARE(item.call_extension(variant), extension);
+}
+
+Q_DECLARE_METATYPE(SubQGraphicsPolygonItem::Extension)
+void tst_QGraphicsPolygonItem::setExtension_data()
+{
+    QTest::addColumn<SubQGraphicsPolygonItem::Extension>("extension");
+    QTest::addColumn<QVariant>("variant");
+    QTest::newRow("null") << SubQGraphicsPolygonItem::Extension() << QVariant();
+}
+
+// protected void setExtension(SubQGraphicsPolygonItem::Extension extension, QVariant const& variant)
+void tst_QGraphicsPolygonItem::setExtension()
+{
+    QFETCH(SubQGraphicsPolygonItem::Extension, extension);
+    QFETCH(QVariant, variant);
+
+    SubQGraphicsPolygonItem item;
+    item.call_setExtension(extension, variant);
+}
+
+void tst_QGraphicsPolygonItem::supportsExtension_data()
+{
+    QTest::addColumn<SubQGraphicsPolygonItem::Extension>("extension");
+    QTest::addColumn<bool>("supportsExtension");
+    QTest::newRow("null") << SubQGraphicsPolygonItem::Extension() << false;
+}
+
+// protected bool supportsExtension(SubQGraphicsPolygonItem::Extension extension) const
+void tst_QGraphicsPolygonItem::supportsExtension()
+{
+    QFETCH(SubQGraphicsPolygonItem::Extension, extension);
+    QFETCH(bool, supportsExtension);
+
+    SubQGraphicsPolygonItem item;
+    QCOMPARE(item.call_supportsExtension(extension), supportsExtension);
+}
+
+QTEST_MAIN(tst_QGraphicsPolygonItem)
+#include "tst_qgraphicspolygonitem.moc"
+
diff --git a/tests/auto/widgets/graphicsview/qgraphicsproxywidget/.gitignore b/tests/auto/widgets/graphicsview/qgraphicsproxywidget/.gitignore
new file mode 100644
index 0000000000..530452478b
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsproxywidget/.gitignore
@@ -0,0 +1 @@
+tst_qgraphicsproxywidget
diff --git a/tests/auto/widgets/graphicsview/qgraphicsproxywidget/qgraphicsproxywidget.pro b/tests/auto/widgets/graphicsview/qgraphicsproxywidget/qgraphicsproxywidget.pro
new file mode 100644
index 0000000000..a649ae1a3c
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsproxywidget/qgraphicsproxywidget.pro
@@ -0,0 +1,8 @@
+load(qttest_p4)
+
+QT += widgets widgets-private
+QT += core-private gui-private
+
+SOURCES  += tst_qgraphicsproxywidget.cpp
+
+contains(QT_CONFIG,xcb):qpa:CONFIG+=insignificant_test  # QTBUG-20756 crashes on qpa, xcb
diff --git a/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp b/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
new file mode 100644
index 0000000000..78c545e25a
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
@@ -0,0 +1,3649 @@
+/****************************************************************************
+**
+** 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 <QtGui>
+#include <QtWidgets>
+#include <private/qgraphicsproxywidget_p.h>
+#include <private/qlayoutengine_p.h>    // qSmartMin functions...
+#if defined(Q_WS_MAC) && !defined(QT_NO_STYLE_MAC)
+#include <QMacStyle>
+#endif
+#ifdef Q_WS_X11
+#include <private/qt_x11_p.h>
+#endif
+
+static void sendMouseMove(QWidget *widget, const QPoint &point, Qt::MouseButton button = Qt::NoButton)
+{
+    QMouseEvent event(QEvent::MouseMove, point, widget->mapToGlobal(point), button, button, 0);
+    QApplication::sendEvent(widget, &event);
+}
+
+/*
+    Notes:
+
+    1) The proxy and the widget geometries are linked.
+       proxy resize => widget resize => stop (no livelock)
+       widget resize => proxy resize => stop (no livelock)
+
+    2) As far as possible, the properties are linked.
+       proxy enable => widget enable => stop
+       widget disabled => proxy disabled => stop
+
+    3) Windowed state is linked
+       Windowed proxy state => windowed widget state => stop
+       Windowed widget state => windowed proxy state => stop
+*/
+
+class EventSpy : public QObject
+{
+public:
+    EventSpy(QObject *receiver)
+    {
+        receiver->installEventFilter(this);
+    }
+
+    QMap<QEvent::Type, int> counts;
+
+protected:
+    bool eventFilter(QObject *, QEvent *event)
+    {
+        ++counts[event->type()];
+        return false;
+    }
+};
+
+class tst_QGraphicsProxyWidget : public QObject
+{
+    Q_OBJECT
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+private slots:
+    void qgraphicsproxywidget_data();
+    void qgraphicsproxywidget();
+    void paint();
+    void paint_2();
+    void setWidget_data();
+    void setWidget();
+    void eventFilter_data();
+    void eventFilter();
+    void focusInEvent_data();
+    void focusInEvent();
+    void focusInEventNoWidget();
+    void focusNextPrevChild_data();
+    void focusNextPrevChild();
+    void focusOutEvent_data();
+    void focusOutEvent();
+#if !defined(Q_OS_WINCE) || (defined(GWES_ICONCURS) && !defined(QT_NO_CURSOR))
+    void hoverEnterLeaveEvent_data();
+    void hoverEnterLeaveEvent();
+#endif
+    void hoverMoveEvent_data();
+    void hoverMoveEvent();
+    void keyPressEvent_data();
+    void keyPressEvent();
+    void keyReleaseEvent_data();
+    void keyReleaseEvent();
+    void mouseDoubleClickEvent_data();
+    void mouseDoubleClickEvent();
+    void mousePressReleaseEvent_data();
+    void mousePressReleaseEvent();
+    void resizeEvent_data();
+    void resizeEvent();
+    void paintEvent();
+    void wheelEvent();
+    void sizeHint_data();
+    void sizeHint();
+    void sizePolicy();
+    void minimumSize();
+    void maximumSize();
+    void scrollUpdate();
+    void setWidget_simple();
+    void setWidget_ownership();
+    void resize_simple_data();
+    void resize_simple();
+    void symmetricMove();
+    void symmetricResize();
+    void symmetricEnabled();
+    void symmetricVisible();
+    void tabFocus_simpleWidget();
+    void tabFocus_simpleTwoWidgets();
+    void tabFocus_complexWidget();
+    void tabFocus_complexTwoWidgets();
+    void setFocus_simpleWidget();
+    void setFocus_simpleTwoWidgets();
+    void setFocus_complexTwoWidgets();
+    void popup_basic();
+    void popup_subwidget();
+#if !defined(QT_NO_CURSOR) && (!defined(Q_OS_WINCE) || defined(GWES_ICONCURS))
+    void changingCursor_basic();
+#endif
+    void tooltip_basic();
+    void childPos_data();
+    void childPos();
+    void autoShow();
+    void windowOpacity();
+    void stylePropagation();
+    void palettePropagation();
+    void fontPropagation();
+    void dontCrashWhenDie();
+    void createProxyForChildWidget();
+    void actionsContextMenu();
+    void actionsContextMenu_data();
+    void deleteProxyForChildWidget();
+    void bypassGraphicsProxyWidget_data();
+    void bypassGraphicsProxyWidget();
+    void dragDrop();
+    void windowFlags_data();
+    void windowFlags();
+    void comboboxWindowFlags();
+    void updateAndDelete();
+    void inputMethod();
+    void clickFocus();
+    void windowFrameMargins();
+    void QTBUG_6986_sendMouseEventToAlienWidget();
+};
+
+// Subclass that exposes the protected functions.
+class SubQGraphicsProxyWidget : public QGraphicsProxyWidget
+{
+
+public:
+    SubQGraphicsProxyWidget(QGraphicsItem *parent = 0) : QGraphicsProxyWidget(parent),
+    paintCount(0), keyPress(0), focusOut(0)
+        {}
+
+    bool call_eventFilter(QObject* object, QEvent* event)
+        { return SubQGraphicsProxyWidget::eventFilter(object, event); }
+
+    void call_focusInEvent(QFocusEvent* event)
+        { return SubQGraphicsProxyWidget::focusInEvent(event); }
+
+    bool call_focusNextPrevChild(bool next)
+        { return SubQGraphicsProxyWidget::focusNextPrevChild(next); }
+
+    void call_focusOutEvent(QFocusEvent* event)
+        { return SubQGraphicsProxyWidget::focusOutEvent(event); }
+
+    void call_hideEvent(QHideEvent* event)
+        { return SubQGraphicsProxyWidget::hideEvent(event); }
+
+    void call_hoverEnterEvent(QGraphicsSceneHoverEvent* event)
+        { return SubQGraphicsProxyWidget::hoverEnterEvent(event); }
+
+    void call_hoverLeaveEvent(QGraphicsSceneHoverEvent* event)
+        { return SubQGraphicsProxyWidget::hoverLeaveEvent(event); }
+
+    void call_hoverMoveEvent(QGraphicsSceneHoverEvent* event)
+        { return SubQGraphicsProxyWidget::hoverMoveEvent(event); }
+
+    void call_keyPressEvent(QKeyEvent* event)
+        { return SubQGraphicsProxyWidget::keyPressEvent(event); }
+
+    void call_keyReleaseEvent(QKeyEvent* event)
+        { return SubQGraphicsProxyWidget::keyReleaseEvent(event); }
+
+    void call_mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event)
+        { return SubQGraphicsProxyWidget::mouseDoubleClickEvent(event); }
+
+    void call_mouseMoveEvent(QGraphicsSceneMouseEvent* event)
+        { return SubQGraphicsProxyWidget::mouseMoveEvent(event); }
+
+    void call_mousePressEvent(QGraphicsSceneMouseEvent* event)
+        { return SubQGraphicsProxyWidget::mousePressEvent(event); }
+
+    void call_mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
+        { return SubQGraphicsProxyWidget::mouseReleaseEvent(event); }
+
+    void call_resizeEvent(QGraphicsSceneResizeEvent* event)
+        { return SubQGraphicsProxyWidget::resizeEvent(event); }
+
+    QSizeF call_sizeHint(Qt::SizeHint which, QSizeF const& constraint = QSizeF()) const
+        { return SubQGraphicsProxyWidget::sizeHint(which, constraint); }
+
+    void call_showEvent(QShowEvent* event)
+        { return SubQGraphicsProxyWidget::showEvent(event); }
+
+    void paint (QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0)    {
+        paintCount++;
+        QGraphicsProxyWidget::paint(painter, option, widget);
+    }
+
+    void focusOutEvent(QFocusEvent *event)
+    {
+        focusOut++;
+        QGraphicsProxyWidget::focusOutEvent(event);
+    }
+
+    bool eventFilter(QObject *object, QEvent *event) {
+        if (event->type() == QEvent::KeyPress && object == widget())
+            keyPress++;
+        return QGraphicsProxyWidget::eventFilter(object, event);
+    }
+    int paintCount;
+    int keyPress;
+    int focusOut;
+};
+
+class WheelWidget : public QWidget
+{
+public:
+    WheelWidget() : wheelEventCalled(false) { setFocusPolicy(Qt::WheelFocus); }
+
+    virtual void wheelEvent(QWheelEvent *event) { event->accept(); wheelEventCalled = true; }
+
+    bool wheelEventCalled;
+};
+
+// This will be called before the first test function is executed.
+// It is only called once.
+void tst_QGraphicsProxyWidget::initTestCase()
+{
+#ifdef Q_OS_WINCE //disable magic for WindowsCE
+    qApp->setAutoMaximizeThreshold(-1);
+#endif
+}
+
+// This will be called after the last test function is executed.
+// It is only called once.
+void tst_QGraphicsProxyWidget::cleanupTestCase()
+{
+}
+
+// This will be called before each test function is executed.
+void tst_QGraphicsProxyWidget::init()
+{
+}
+
+// This will be called after every test function.
+void tst_QGraphicsProxyWidget::cleanup()
+{
+}
+
+void tst_QGraphicsProxyWidget::qgraphicsproxywidget_data()
+{
+}
+
+void tst_QGraphicsProxyWidget::qgraphicsproxywidget()
+{
+    SubQGraphicsProxyWidget proxy;
+    proxy.paint(0, 0, 0);
+    proxy.setWidget(0);
+    QVERIFY(proxy.type() == QGraphicsProxyWidget::Type);
+    QVERIFY(!proxy.widget());
+    QEvent event(QEvent::None);
+    proxy.call_eventFilter(0, &event);
+    QFocusEvent focusEvent(QEvent::FocusIn);
+    focusEvent.ignore();
+    proxy.call_focusInEvent(&focusEvent);
+    QCOMPARE(focusEvent.isAccepted(), false);
+    QCOMPARE(proxy.call_focusNextPrevChild(false), false);
+    QCOMPARE(proxy.call_focusNextPrevChild(true), false);
+    proxy.call_focusOutEvent(&focusEvent);
+    QHideEvent hideEvent;
+    proxy.call_hideEvent(&hideEvent);
+    QGraphicsSceneHoverEvent hoverEvent;
+    proxy.call_hoverEnterEvent(&hoverEvent);
+    proxy.call_hoverLeaveEvent(&hoverEvent);
+    proxy.call_hoverMoveEvent(&hoverEvent);
+    QKeyEvent keyEvent(QEvent::KeyPress, 0, Qt::NoModifier);
+    proxy.call_keyPressEvent(&keyEvent);
+    proxy.call_keyReleaseEvent(&keyEvent);
+    QGraphicsSceneMouseEvent mouseEvent;
+    proxy.call_mouseDoubleClickEvent(&mouseEvent);
+    proxy.call_mouseMoveEvent(&mouseEvent);
+    proxy.call_mousePressEvent(&mouseEvent);
+    proxy.call_mouseReleaseEvent(&mouseEvent);
+    QGraphicsSceneResizeEvent resizeEvent;
+    proxy.call_resizeEvent(&resizeEvent);
+    QShowEvent showEvent;
+    proxy.call_showEvent(&showEvent);
+    proxy.call_sizeHint(Qt::PreferredSize, QSizeF());
+}
+
+// public void paint(QPainter* painter, QStyleOptionGraphicsItem const* option, QWidget* widget)
+void tst_QGraphicsProxyWidget::paint()
+{
+    SubQGraphicsProxyWidget proxy;
+    proxy.paint(0, 0, 0);
+}
+
+class MyProxyWidget : public QGraphicsProxyWidget
+{
+public:
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        // Make sure QGraphicsProxyWidget::paint does not modify the render hints set on the painter.
+        painter->setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform
+                                | QPainter::NonCosmeticDefaultPen | QPainter::TextAntialiasing);
+        const QPainter::RenderHints oldRenderHints = painter->renderHints();
+        QGraphicsProxyWidget::paint(painter, option, widget);
+        QCOMPARE(painter->renderHints(), oldRenderHints);
+    }
+};
+
+void tst_QGraphicsProxyWidget::paint_2()
+{
+    MyProxyWidget *proxyWidget = new MyProxyWidget;
+    proxyWidget->setWidget(new QLineEdit);
+
+    QGraphicsScene scene;
+    scene.addItem(proxyWidget);
+    scene.setSceneRect(scene.itemsBoundingRect());
+
+    // Trigger repaint.
+    QPixmap pixmap(scene.sceneRect().toRect().size());
+    QPainter painter(&pixmap);
+    scene.render(&painter);
+}
+
+void tst_QGraphicsProxyWidget::setWidget_data()
+{
+    QTest::addColumn<bool>("widgetExists");
+    QTest::addColumn<bool>("insertWidget");
+    QTest::addColumn<bool>("hasParent");
+    QTest::addColumn<bool>("proxyHasParent");
+
+    QTest::newRow("setWidget(0)") << false << false << false << false;
+    QTest::newRow("setWidget(widget)") << false << true << false << false;
+    QTest::newRow("setWidget(widgetWParent)") << false << true << true << false;
+    QTest::newRow("setWidget(1), setWidget(0)") << true << false << false << false;
+    QTest::newRow("setWidget(1), setWidget(widget)") << true << true << false << false;
+    QTest::newRow("setWidget(1), setWidget(widgetWParent)") << true << true << true << false;
+    QTest::newRow("p setWidget(0)") << false << false << false << true;
+    QTest::newRow("p setWidget(widget)") << false << true << false << true;
+    QTest::newRow("p setWidget(widgetWParent)") << false << true << true << true;
+    QTest::newRow("p setWidget(1), setWidget(0)") << true << false << false << true;
+    QTest::newRow("p setWidget(1), setWidget(widget)") << true << true << false << true;
+    QTest::newRow("p setWidget(1), setWidget(widgetWParent)") << true << true << true << true;
+}
+
+// public void setWidget(QWidget* widget)
+void tst_QGraphicsProxyWidget::setWidget()
+{
+    QFETCH(bool, widgetExists);
+    QFETCH(bool, insertWidget);
+    QFETCH(bool, hasParent);
+    QFETCH(bool, proxyHasParent);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QPointer<SubQGraphicsProxyWidget> proxy = new SubQGraphicsProxyWidget;
+    SubQGraphicsProxyWidget parentProxy;
+    scene.addItem(proxy);
+    scene.addItem(&parentProxy);
+    if (proxyHasParent)
+        proxy->setParent(&parentProxy);
+    QPointer<QWidget> existingSubWidget = new QWidget;
+    proxy->setVisible(false);
+    proxy->setEnabled(false);
+
+    if (widgetExists) {
+        existingSubWidget->setAttribute(Qt::WA_QuitOnClose, true);
+        proxy->setWidget(existingSubWidget);
+    }
+
+    QWidget *widget = new QWidget;
+#ifndef QT_NO_CURSOR
+    widget->setCursor(Qt::IBeamCursor);
+#endif
+    widget->setPalette(QPalette(Qt::magenta));
+    widget->setLayoutDirection(Qt::RightToLeft);
+    QCleanlooksStyle cleanlooksStyle;
+    widget->setStyle(&cleanlooksStyle);
+    widget->setFont(QFont("Times"));
+    widget->setVisible(true);
+    QApplication::setActiveWindow(widget);
+    widget->activateWindow();
+    widget->setEnabled(true);
+    widget->resize(325, 241);
+    widget->setMinimumSize(100, 200);
+    widget->setMaximumSize(1000, 2000);
+    widget->setFocusPolicy(Qt::TabFocus);
+    widget->setContentsMargins(10, 29, 19, 81);
+    widget->setFocus(Qt::TabFocusReason);
+    widget->setAcceptDrops(true);
+    QTRY_VERIFY(widget->hasFocus());
+    QVERIFY(widget->isActiveWindow());
+
+    QWidget parentWidget;
+    if (hasParent)
+        widget->setParent(&parentWidget);
+
+    QWidget *subWidget = insertWidget ? widget : 0;
+    bool shouldBeInsertable = !hasParent && subWidget;
+    if (shouldBeInsertable)
+        subWidget->setAttribute(Qt::WA_QuitOnClose, true);
+
+    proxy->setWidget(subWidget);
+
+    if (shouldBeInsertable) {
+        QCOMPARE(proxy->widget(), subWidget);
+        QVERIFY(subWidget->testAttribute(Qt::WA_DontShowOnScreen));
+        QVERIFY(!subWidget->testAttribute(Qt::WA_QuitOnClose));
+        QCOMPARE(proxy->acceptHoverEvents(), true);
+#ifndef QT_NO_CURSOR
+        QVERIFY(proxy->hasCursor());
+
+        // These should match
+        QCOMPARE(proxy->cursor().shape(), widget->cursor().shape());
+#endif
+        //###QCOMPARE(proxy->palette(), widget->palette());
+        QCOMPARE(proxy->layoutDirection(), widget->layoutDirection());
+        QCOMPARE(proxy->style(), widget->style());
+        QCOMPARE(proxy->isVisible(), widget->isVisible());
+        QCOMPARE(proxy->isEnabled(), widget->isEnabled());
+        QVERIFY(proxy->flags() & QGraphicsItem::ItemIsFocusable);
+        QCOMPARE(proxy->effectiveSizeHint(Qt::MinimumSize).toSize(),
+            qSmartMinSize(widget));
+        QCOMPARE(proxy->minimumSize().toSize(),
+                 qSmartMinSize(widget) );
+        QCOMPARE(proxy->maximumSize().toSize(), QSize(1000, 2000));
+        QCOMPARE(proxy->effectiveSizeHint(Qt::PreferredSize).toSize(),
+                qSmartMinSize(widget));
+        QCOMPARE(proxy->size().toSize(), widget->size());
+        QCOMPARE(proxy->rect().toRect(), widget->rect());
+        QCOMPARE(proxy->focusPolicy(), Qt::WheelFocus);
+        QVERIFY(proxy->acceptDrops());
+        QCOMPARE(proxy->acceptsHoverEvents(), true); // to get widget enter events
+        int left, top, right, bottom;
+        widget->getContentsMargins(&left, &top, &right, &bottom);
+        qreal rleft, rtop, rright, rbottom;
+        proxy->getContentsMargins(&rleft, &rtop, &rright, &rbottom);
+        QCOMPARE((qreal)left, rleft);
+        QCOMPARE((qreal)top, rtop);
+        QCOMPARE((qreal)right, rright);
+        QCOMPARE((qreal)bottom, rbottom);
+    } else {
+        // proxy shouldn't mess with the widget if it can't insert it.
+        QCOMPARE(proxy->widget(), (QWidget*)0);
+        QCOMPARE(proxy->acceptHoverEvents(), false);
+        if (subWidget) {
+            QVERIFY(!subWidget->testAttribute(Qt::WA_DontShowOnScreen));
+            QVERIFY(subWidget->testAttribute(Qt::WA_QuitOnClose));
+            // reset
+            subWidget->setAttribute(Qt::WA_QuitOnClose, false);
+        }
+    }
+
+    if (widgetExists) {
+        QCOMPARE(existingSubWidget->parent(), static_cast<QObject*>(0));
+        QVERIFY(!existingSubWidget->testAttribute(Qt::WA_DontShowOnScreen));
+        QVERIFY(!existingSubWidget->testAttribute(Qt::WA_QuitOnClose));
+    }
+
+    if (hasParent)
+        widget->setParent(0);
+
+    delete widget;
+    if (shouldBeInsertable)
+        QVERIFY(!proxy);
+    delete existingSubWidget;
+    if (!shouldBeInsertable) {
+        QVERIFY(proxy);
+        delete proxy;
+    }
+    QVERIFY(!proxy);
+}
+
+Q_DECLARE_METATYPE(QEvent::Type)
+void tst_QGraphicsProxyWidget::eventFilter_data()
+{
+    QTest::addColumn<QEvent::Type>("eventType");
+    QTest::addColumn<bool>("fromObject"); // big grin evil
+    QTest::newRow("none") << QEvent::None << false;
+    for (int i = 0; i < 2; ++i) {
+        bool fromObject = (i == 0);
+        QTest::newRow(QString("resize %1").arg(fromObject).toLatin1()) << QEvent::Resize << fromObject;
+        QTest::newRow(QString("move %1").arg(fromObject).toLatin1()) << QEvent::Move << fromObject;
+        QTest::newRow(QString("hide %1").arg(fromObject).toLatin1()) << QEvent::Hide << fromObject;
+        QTest::newRow(QString("show %1").arg(fromObject).toLatin1()) << QEvent::Show << fromObject;
+        QTest::newRow(QString("enabled %1").arg(fromObject).toLatin1()) << QEvent::EnabledChange << fromObject;
+        QTest::newRow(QString("focusIn %1").arg(fromObject).toLatin1()) << QEvent::FocusIn << fromObject;
+        QTest::newRow(QString("focusOut %1").arg(fromObject).toLatin1()) << QEvent::FocusOut << fromObject;
+        QTest::newRow(QString("keyPress %1").arg(fromObject).toLatin1()) << QEvent::KeyPress << fromObject;
+    }
+}
+
+// protected bool eventFilter(QObject* object, QEvent* event)
+void tst_QGraphicsProxyWidget::eventFilter()
+{
+    QFETCH(QEvent::Type, eventType);
+    QFETCH(bool, fromObject);
+
+    QGraphicsScene scene;
+    QEvent windowActivate(QEvent::WindowActivate);
+    qApp->sendEvent(&scene, &windowActivate);
+
+    SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;
+    scene.addItem(proxy);
+
+    QWidget *widget = new QWidget(0, Qt::FramelessWindowHint);
+    widget->setFocusPolicy(Qt::TabFocus);
+    widget->resize(10, 10);
+    widget->show();
+    proxy->setWidget(widget);
+    proxy->show();
+
+    // mirror whatever is happening to the widget
+    // don't get in a loop
+    switch (eventType) {
+    case QEvent::None: {
+        QEvent event(QEvent::None);
+        proxy->call_eventFilter(widget, &event);
+        break;
+                       }
+    case QEvent::Resize: {
+        QSize oldSize = widget->size();
+        QSize newSize = QSize(100, 100);
+        if (fromObject) {
+            widget->resize(newSize);
+        } else {
+            proxy->resize(newSize);
+        }
+        QCOMPARE(proxy->size().toSize(), newSize);
+        QCOMPARE(widget->size(), newSize);
+        break;
+                         }
+    case QEvent::Move: {
+        QPoint oldPoint = widget->pos();
+        QPoint newPoint = QPoint(100, 100);
+        if (fromObject) {
+            widget->move(newPoint);
+        } else {
+            proxy->setPos(newPoint);
+        }
+        QCOMPARE(proxy->pos().toPoint(), newPoint);
+        QCOMPARE(widget->pos(), newPoint);
+        break;
+                         }
+    case QEvent::Hide: {
+        // A hide event can only come from a widget
+        if (fromObject) {
+            widget->setFocus(Qt::TabFocusReason);
+            widget->hide();
+        } else {
+            QHideEvent event;
+            proxy->call_eventFilter(widget, &event);
+        }
+        QCOMPARE(proxy->isVisible(), false);
+        break;
+                         }
+    case QEvent::Show: {
+        // A show event can either come from a widget or somewhere else
+        widget->hide();
+        if (fromObject) {
+            widget->show();
+        } else {
+            QShowEvent event;
+            proxy->call_eventFilter(widget, &event);
+        }
+        QCOMPARE(proxy->isVisible(), true);
+        break;
+                         }
+    case QEvent::EnabledChange: {
+        widget->setEnabled(false);
+        proxy->setEnabled(false);
+        if (fromObject) {
+            widget->setEnabled(true);
+            QCOMPARE(proxy->isEnabled(), true);
+            widget->setEnabled(false);
+            QCOMPARE(proxy->isEnabled(), false);
+        } else {
+            QEvent event(QEvent::EnabledChange);
+            proxy->call_eventFilter(widget, &event);
+            // match the widget not the event
+            QCOMPARE(proxy->isEnabled(), false);
+        }
+        break;
+                         }
+    case QEvent::FocusIn: {
+        if (fromObject) {
+            widget->setFocus(Qt::TabFocusReason);
+            QVERIFY(proxy->hasFocus());
+        }
+        break;
+                         }
+    case QEvent::FocusOut: {
+        widget->setFocus(Qt::TabFocusReason);
+        QVERIFY(proxy->hasFocus());
+        QVERIFY(widget->hasFocus());
+        if (fromObject) {
+            widget->clearFocus();
+            QVERIFY(!proxy->hasFocus());
+        }
+        break;
+                         }
+    case QEvent::KeyPress: {
+        if (fromObject) {
+            QTest::keyPress(widget, Qt::Key_A, Qt::NoModifier);
+        } else {
+            QKeyEvent event(QEvent::KeyPress, Qt::Key_A, Qt::NoModifier);
+            proxy->call_eventFilter(widget, &event);
+        }
+        QCOMPARE(proxy->keyPress, 1);
+        break;
+                         }
+    default:
+        break;
+    }
+}
+
+void tst_QGraphicsProxyWidget::focusInEvent_data()
+{
+    QTest::addColumn<bool>("widgetHasFocus");
+    QTest::addColumn<bool>("widgetCanHaveFocus");
+    QTest::newRow("no focus, can't get") << false << false;
+    QTest::newRow("no focus, can get") << false << true;
+    QTest::newRow("has focus, can't get") << true << false;
+    QTest::newRow("has focus, can get") << true << true;
+    // ### add test for widget having a focusNextPrevChild
+}
+
+// protected void focusInEvent(QFocusEvent* event)
+void tst_QGraphicsProxyWidget::focusInEvent()
+{
+    // ### This test is just plain old broken
+    QFETCH(bool, widgetHasFocus);
+    QFETCH(bool, widgetCanHaveFocus);
+
+    QGraphicsScene scene;
+    QEvent windowActivate(QEvent::WindowActivate);
+    qApp->sendEvent(&scene, &windowActivate);
+
+    SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;
+    proxy->setEnabled(true);
+    scene.addItem(proxy);
+    proxy->setVisible(true);
+
+    QWidget *widget = new QWidget;
+    widget->resize(100, 100);
+    if (widgetCanHaveFocus)
+        widget->setFocusPolicy(Qt::WheelFocus);
+    widget->show();
+
+    if (widgetHasFocus)
+        widget->setFocus(Qt::TabFocusReason);
+
+    proxy->setWidget(widget);
+    proxy->setFlag(QGraphicsItem::ItemIsFocusable, true); // <- shouldn't need to do this
+
+    // ### This test is just plain old broken - sending a focus in event
+    // does not cause items to gain input focus. The widget has focus
+    // because the proxy has focus, not because it got this event.
+
+    QFocusEvent event(QEvent::FocusIn, Qt::TabFocusReason);
+    event.ignore();
+    proxy->call_focusInEvent(&event);
+    QTRY_COMPARE(widget->hasFocus(), widgetCanHaveFocus);
+}
+
+void tst_QGraphicsProxyWidget::focusInEventNoWidget()
+{
+    QGraphicsView view;
+    QGraphicsScene scene(&view);
+    SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;
+    proxy->setEnabled(true);
+    scene.addItem(proxy);
+    proxy->setVisible(true);
+    view.show();
+
+    proxy->setFlag(QGraphicsItem::ItemIsFocusable, true); // <- shouldn't need to do this
+    QFocusEvent event(QEvent::FocusIn, Qt::TabFocusReason);
+    event.ignore();
+    //should not crash
+    proxy->call_focusInEvent(&event);
+}
+
+void tst_QGraphicsProxyWidget::focusNextPrevChild_data()
+{
+    QTest::addColumn<bool>("hasWidget");
+    QTest::addColumn<bool>("hasScene");
+    QTest::addColumn<bool>("next");
+    QTest::addColumn<bool>("focusNextPrevChild");
+
+    for (int i = 0; i < 2; ++i) {
+        for (int j = 0; j < 2; ++j) {
+            for (int k = 0; k < 2; ++k) {
+                bool next = (i == 0);
+                bool hasWidget = (j == 0);
+                bool hasScene = (k == 0);
+                bool result = hasScene && hasWidget;
+                QString name = QString("Forward: %1, hasWidget: %2, hasScene: %3, result: %4").arg(next).arg(hasWidget).arg(hasScene).arg(result);
+                QTest::newRow(name.toLatin1()) << hasWidget << hasScene << next << result;
+            }
+        }
+    }
+}
+
+// protected bool focusNextPrevChild(bool next)
+void tst_QGraphicsProxyWidget::focusNextPrevChild()
+{
+    QFETCH(bool, next);
+    QFETCH(bool, focusNextPrevChild);
+    QFETCH(bool, hasWidget);
+    QFETCH(bool, hasScene);
+
+    // If a widget has its own focusNextPrevChild we need to respect it
+    // otherwise respect the scene
+    // Respect the widget over the scene!
+
+    SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;
+
+    QLabel *widget = new QLabel;
+    // I can't believe designer adds this much junk!
+    widget->setText("<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\"> p, li { white-space: pre-wrap; } </style></head><body style=\" font-family:'Sans Serif'; font-size:9pt; font-weight:400; font-style:normal;\"> <p style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><a href=\"http://www.slashdot.org\"><span style=\" text-decoration: underline; color:#0000ff;\">old</span></a> foo <a href=\"http://www.reddit.org\"><span style=\" text-decoration: underline; color:#0000ff;\">new</span></a></p></body></html>");
+    widget->setTextInteractionFlags(Qt::TextBrowserInteraction);
+
+    if (hasWidget)
+        proxy->setWidget(widget);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+    if (hasScene) {
+        scene.addItem(proxy);
+        proxy->show();
+
+        // widget should take precedence over scene so make scene.focusNextPrevChild return false
+        // so we know that a true can only come from the widget
+        if (!(hasWidget && hasScene)) {
+            QGraphicsTextItem *item = new QGraphicsTextItem("Foo");
+            item->setTextInteractionFlags(Qt::TextBrowserInteraction);
+            scene.addItem(item);
+            item->setPos(50, 40);
+        }
+        scene.setFocusItem(proxy);
+        QVERIFY(proxy->hasFocus());
+    }
+
+    QCOMPARE(proxy->call_focusNextPrevChild(next), focusNextPrevChild);
+
+    if (!hasScene)
+        delete proxy;
+}
+
+void tst_QGraphicsProxyWidget::focusOutEvent_data()
+{
+    QTest::addColumn<bool>("hasWidget");
+    QTest::addColumn<bool>("call");
+    QTest::newRow("no widget, focus to other widget") << false << false;
+    QTest::newRow("no widget, focusOutCalled") << false << true;
+    QTest::newRow("widget, focus to other widget") << true << false;
+    QTest::newRow("widget, focusOutCalled") << true << true;
+}
+
+// protected void focusOutEvent(QFocusEvent* event)
+void tst_QGraphicsProxyWidget::focusOutEvent()
+{
+    QFETCH(bool, hasWidget);
+    QFETCH(bool, call);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;
+    scene.addItem(proxy);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    view.activateWindow();
+    view.setFocus();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(view.isVisible());
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+
+    QWidget *widget = new QWidget;
+    widget->setFocusPolicy(Qt::WheelFocus);
+    if (hasWidget)
+        proxy->setWidget(widget);
+    proxy->show();
+    proxy->setFocus();
+    QVERIFY(proxy->hasFocus());
+    QEXPECT_FAIL("widget, focus to other widget", "Widget should have focus but doesn't", Continue);
+    QEXPECT_FAIL("widget, focusOutCalled", "Widget should have focus but doesn't", Continue);
+    QCOMPARE(widget->hasFocus(), hasWidget);
+
+    if (!call) {
+        QWidget *other = new QLineEdit(&view);
+        other->show();
+        QApplication::processEvents();
+        QTRY_VERIFY(other->isVisible());
+        other->setFocus();
+        QTRY_VERIFY(other->hasFocus());
+        qApp->processEvents();
+        QTRY_COMPARE(proxy->hasFocus(), false);
+        QVERIFY(proxy->focusOut);
+        QCOMPARE(widget->hasFocus(), false);
+    } else {
+        {
+            /*
+            ### Test doesn't make sense
+            QFocusEvent focusEvent(QEvent::FocusOut);
+            proxy->call_focusOutEvent(&focusEvent);
+            QCOMPARE(focusEvent.isAccepted(), hasWidget);
+            qApp->processEvents();
+            QCOMPARE(proxy->paintCount, hasWidget ? 1 : 0);
+            */
+        }
+        {
+            /*
+            ### Test doesn't make sense
+            proxy->setFlag(QGraphicsItem::ItemIsFocusable, false);
+            QFocusEvent focusEvent(QEvent::FocusOut);
+            proxy->call_focusOutEvent(&focusEvent);
+            QCOMPARE(focusEvent.isAccepted(), hasWidget);
+            qApp->processEvents();
+            QCOMPARE(proxy->paintCount, 0);
+            */
+        }
+    }
+}
+
+class EventLogger : public QWidget
+{
+public:
+    EventLogger() : QWidget(), enterCount(0), leaveCount(0), moveCount(0),
+        hoverEnter(0), hoverLeave(0), hoverMove(0)
+    {
+        installEventFilter(this);
+    }
+
+    void enterEvent(QEvent *event)
+    {
+        enterCount++;
+        QWidget::enterEvent(event);
+    }
+
+    void leaveEvent(QEvent *event )
+    {
+        leaveCount++;
+        QWidget::leaveEvent(event);
+    }
+
+    void mouseMoveEvent(QMouseEvent *event)
+    {
+        event->setAccepted(true);
+        moveCount++;
+        QWidget::mouseMoveEvent(event);
+    }
+
+    int enterCount;
+    int leaveCount;
+    int moveCount;
+
+    int hoverEnter;
+    int hoverLeave;
+    int hoverMove;
+protected:
+    bool eventFilter(QObject *object, QEvent *event)
+    {
+        switch (event->type()) {
+        case QEvent::HoverEnter:
+             hoverEnter++;
+             break;
+        case QEvent::HoverLeave:
+             hoverLeave++;
+             break;
+        case QEvent::HoverMove:
+             hoverMove++;
+             break;
+        default:
+             break;
+        }
+        return QWidget::eventFilter(object, event);
+    }
+};
+
+// protected void hoverEnterEvent(QGraphicsSceneHoverEvent* event)
+#if !defined(Q_OS_WINCE) || (defined(GWES_ICONCURS) && !defined(QT_NO_CURSOR))
+void tst_QGraphicsProxyWidget::hoverEnterLeaveEvent_data()
+{
+    QTest::addColumn<bool>("hasWidget");
+    QTest::addColumn<bool>("hoverEnabled");
+    QTest::newRow("widget, no hover") << true << false;
+    QTest::newRow("no widget, no hover") << false << false;
+    QTest::newRow("widget, hover") << true << true;
+    QTest::newRow("no widget, hover") << false << true;
+}
+
+void tst_QGraphicsProxyWidget::hoverEnterLeaveEvent()
+{
+    QFETCH(bool, hasWidget);
+    QFETCH(bool, hoverEnabled);
+
+    // proxy should translate this into events that the widget would expect
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    //do not let the window manager move the window while we are moving the mouse on it
+    view.setWindowFlags(Qt::X11BypassWindowManagerHint);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+
+    SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;
+    EventLogger *widget = new EventLogger;
+    widget->resize(50, 50);
+    widget->setAttribute(Qt::WA_Hover, hoverEnabled);
+    widget->setMouseTracking(true);
+    view.resize(100, 100);
+    if (hasWidget)
+        proxy->setWidget(widget);
+    proxy->setPos(50, 0);
+    scene.addItem(proxy);
+    QTest::qWait(30);
+    QTest::mouseMove(&view, QPoint(10, 10));
+    QTest::qWait(30);
+
+    // in
+    QTest::mouseMove(&view, QPoint(50, 50));
+    QTRY_COMPARE(widget->testAttribute(Qt::WA_UnderMouse), hasWidget ? true : false);
+    // ### this attribute isn't supported
+    QCOMPARE(widget->enterCount, hasWidget ? 1 : 0);
+    QCOMPARE(widget->hoverEnter, (hasWidget && hoverEnabled) ? 1 : 0);
+    // does not work on all platforms
+    //QCOMPARE(widget->moveCount, 0);
+
+    // out
+    QTest::mouseMove(&view, QPoint(10, 10));
+    // QTRY_COMPARE(widget->testAttribute(Qt::WA_UnderMouse), false);
+    // ### this attribute isn't supported
+    QTRY_COMPARE(widget->leaveCount, hasWidget ? 1 : 0);
+    QTRY_COMPARE(widget->hoverLeave, (hasWidget && hoverEnabled) ? 1 : 0);
+    // does not work on all platforms
+    //QCOMPARE(widget->moveCount, 0);
+
+    if (!hasWidget)
+        delete widget;
+}
+#endif
+
+void tst_QGraphicsProxyWidget::hoverMoveEvent_data()
+{
+    QTest::addColumn<bool>("hasWidget");
+    QTest::addColumn<bool>("hoverEnabled");
+    QTest::addColumn<bool>("mouseTracking");
+    QTest::addColumn<bool>("mouseDown");
+    for (int i = 0; i < 2; ++i) {
+        for (int j = 0; j < 2; ++j) {
+            for (int k = 0; k < 2; ++k) {
+                for (int l = 0; l < 2; ++l) {
+                    bool hasWidget = (i == 0);
+                    bool hoverEnabled = (j == 0);
+                    bool mouseTracking = (k == 0);
+                    bool mouseDown = (l == 0);
+                    QString name = QString("hasWidget:%1, hover:%2, mouseTracking:%3, mouseDown: %4").arg(hasWidget).arg(hoverEnabled).arg(mouseTracking).arg(mouseDown);
+                    QTest::newRow(name.toLatin1()) << hasWidget << hoverEnabled << mouseTracking << mouseDown;
+                }
+            }
+        }
+    }
+}
+
+// protected void hoverMoveEvent(QGraphicsSceneHoverEvent* event)
+void tst_QGraphicsProxyWidget::hoverMoveEvent()
+{
+    QFETCH(bool, hasWidget);
+    QFETCH(bool, hoverEnabled);
+    QFETCH(bool, mouseTracking);
+    QFETCH(bool, mouseDown);
+
+    QSKIP("Ambiguous test...", SkipAll);
+
+    // proxy should translate the move events to what the widget would expect
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+
+    SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;
+    proxy->setFlag(QGraphicsItem::ItemIsFocusable, true); // ### remove me!!!
+    EventLogger *widget = new EventLogger;
+    widget->resize(50, 50);
+    widget->setAttribute(Qt::WA_Hover, hoverEnabled);
+    if (mouseTracking)
+        widget->setMouseTracking(true);
+    view.resize(100, 100);
+    if (hasWidget)
+        proxy->setWidget(widget);
+    proxy->setPos(50, 0);
+    scene.addItem(proxy);
+
+    // in
+    QTest::mouseMove(&view, QPoint(50, 50));
+    QTest::qWait(12);
+
+    if (mouseDown)
+        QTest::mousePress(view.viewport(), Qt::LeftButton);
+
+    // move a little bit
+    QTest::mouseMove(&view, QPoint(60, 60));
+    QTRY_COMPARE(widget->hoverEnter, (hasWidget && hoverEnabled) ? 1 : 0);
+    QCOMPARE(widget->moveCount, (hasWidget && mouseTracking) || (hasWidget && mouseDown) ? 1 : 0);
+
+    if (!hasWidget)
+        delete widget;
+}
+
+void tst_QGraphicsProxyWidget::keyPressEvent_data()
+{
+    QTest::addColumn<bool>("hasWidget");
+    QTest::newRow("widget") << true;
+    QTest::newRow("no widget") << false;
+}
+
+// protected void keyPressEvent(QKeyEvent* event)
+void tst_QGraphicsProxyWidget::keyPressEvent()
+{
+    QFETCH(bool, hasWidget);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+    view.viewport()->setFocus();
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+
+    SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;
+    proxy->setFlag(QGraphicsItem::ItemIsFocusable, true); // ### remove me!!!
+
+    QLineEdit *widget = new QLineEdit;
+    widget->resize(50, 50);
+    view.resize(100, 100);
+    if (hasWidget) {
+        proxy->setWidget(widget);
+        proxy->show();
+    }
+    proxy->setPos(50, 0);
+    scene.addItem(proxy);
+    proxy->setFocus();
+
+    QTest::keyPress(view.viewport(), 'x');
+
+    QTRY_COMPARE(widget->text(), hasWidget ? QString("x") : QString());
+
+    if (!hasWidget)
+        delete widget;
+}
+
+void tst_QGraphicsProxyWidget::keyReleaseEvent_data()
+{
+    QTest::addColumn<bool>("hasWidget");
+    QTest::newRow("widget") << true;
+    QTest::newRow("no widget") << false;
+}
+
+// protected void keyReleaseEvent(QKeyEvent* event)
+void tst_QGraphicsProxyWidget::keyReleaseEvent()
+{
+    QFETCH(bool, hasWidget);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+
+
+    SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;
+    proxy->setFlag(QGraphicsItem::ItemIsFocusable, true); // ### remove me!!!
+    QPushButton *widget = new QPushButton;
+    QSignalSpy spy(widget, SIGNAL(clicked()));
+    widget->resize(50, 50);
+    view.resize(100, 100);
+    if (hasWidget) {
+        proxy->setWidget(widget);
+        proxy->show();
+    }
+    proxy->setPos(50, 0);
+    scene.addItem(proxy);
+    proxy->setFocus();
+
+    QTest::keyPress(view.viewport(), Qt::Key_Space);
+    QTRY_COMPARE(spy.count(), 0);
+    QTest::keyRelease(view.viewport(), Qt::Key_Space);
+    QTRY_COMPARE(spy.count(), (hasWidget) ? 1 : 0);
+
+    if (!hasWidget)
+        delete widget;
+}
+
+void tst_QGraphicsProxyWidget::mouseDoubleClickEvent_data()
+{
+    QTest::addColumn<bool>("hasWidget");
+    QTest::newRow("widget") << true;
+    QTest::newRow("no widget") << false;
+}
+
+// protected void mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event)
+void tst_QGraphicsProxyWidget::mouseDoubleClickEvent()
+{
+    QFETCH(bool, hasWidget);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+
+    SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;
+    proxy->setFlag(QGraphicsItem::ItemIsFocusable, true); // ### remove me!!!
+    QLineEdit *widget = new QLineEdit;
+    widget->setText("foo");
+    widget->resize(50, 50);
+    view.resize(100, 100);
+    if (hasWidget) {
+        proxy->setWidget(widget);
+        proxy->show();
+    }
+    proxy->setPos(50, 0);
+    scene.addItem(proxy);
+    proxy->setFocus();
+
+    QTest::mouseMove(view.viewport(), view.mapFromScene(proxy->mapToScene(15, proxy->boundingRect().center().y())));
+    QTest::mousePress(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(proxy->mapToScene(15, proxy->boundingRect().center().y())));
+    QTest::mouseRelease(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(proxy->mapToScene(15, proxy->boundingRect().center().y())));
+    QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(proxy->mapToScene(15, proxy->boundingRect().center().y())));
+    QTest::mouseRelease(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(proxy->mapToScene(15, proxy->boundingRect().center().y())));
+
+    QTRY_COMPARE(widget->selectedText(), hasWidget ? QString("foo") : QString());
+
+    if (!hasWidget)
+        delete widget;
+}
+
+void tst_QGraphicsProxyWidget::mousePressReleaseEvent_data()
+{
+    QTest::addColumn<bool>("hasWidget");
+    QTest::newRow("widget") << true;
+    QTest::newRow("no widget") << false;
+}
+
+// protected void mousePressEvent(QGraphicsSceneMouseEvent* event)
+void tst_QGraphicsProxyWidget::mousePressReleaseEvent()
+{
+    QFETCH(bool, hasWidget);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;
+    proxy->setFlag(QGraphicsItem::ItemIsFocusable, true); // ### remove me!!!
+    QPushButton *widget = new QPushButton;
+    QSignalSpy spy(widget, SIGNAL(clicked()));
+    widget->resize(50, 50);
+    view.resize(100, 100);
+    if (hasWidget) {
+        proxy->setWidget(widget);
+	proxy->show();
+    }
+    proxy->setPos(50, 0);
+    scene.addItem(proxy);
+    proxy->setFocus();
+
+    QTest::mousePress(view.viewport(), Qt::LeftButton, 0,
+		      view.mapFromScene(proxy->mapToScene(proxy->boundingRect().center())));
+    QTRY_COMPARE(spy.count(), 0);
+    QTest::mouseRelease(view.viewport(), Qt::LeftButton, 0,
+		      view.mapFromScene(proxy->mapToScene(proxy->boundingRect().center())));
+    QTRY_COMPARE(spy.count(), (hasWidget) ? 1 : 0);
+
+    if (!hasWidget)
+        delete widget;
+}
+
+void tst_QGraphicsProxyWidget::resizeEvent_data()
+{
+    QTest::addColumn<bool>("hasWidget");
+    QTest::newRow("widget") << true;
+    QTest::newRow("no widget") << false;
+}
+
+// protected void resizeEvent(QGraphicsSceneResizeEvent* event)
+void tst_QGraphicsProxyWidget::resizeEvent()
+{
+    QFETCH(bool, hasWidget);
+
+    SubQGraphicsProxyWidget proxy;
+    QWidget *widget = new QWidget;
+    if (hasWidget)
+        proxy.setWidget(widget);
+
+    QSize newSize(100, 100);
+    QGraphicsSceneResizeEvent event;
+    event.setOldSize(QSize(10, 10));
+    event.setNewSize(newSize);
+    proxy.call_resizeEvent(&event);
+    if (hasWidget)
+        QCOMPARE(widget->size(), newSize);
+    if (!hasWidget)
+        delete widget;
+}
+
+void tst_QGraphicsProxyWidget::paintEvent()
+{
+    //we test that calling update on a widget inside a QGraphicsView is triggering a repaint
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(view.isActiveWindow());
+
+    SubQGraphicsProxyWidget proxy;
+
+    QWidget *w = new QWidget;
+    //showing the widget here seems to create a bug in Graphics View
+    //this bug prevents the widget from being updated
+
+    w->show();
+    QTest::qWaitForWindowShown(w);
+    QApplication::processEvents();
+    QTest::qWait(30);
+    proxy.setWidget(w);
+    scene.addItem(&proxy);
+
+    //make sure we flush all the paint events
+    QTRY_VERIFY(proxy.paintCount > 1);
+    QTest::qWait(30);
+    proxy.paintCount = 0;
+
+    w->update();
+    QTRY_COMPARE(proxy.paintCount, 1); //the widget should have been painted now
+}
+
+
+void tst_QGraphicsProxyWidget::wheelEvent()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+
+    WheelWidget *wheelWidget = new WheelWidget();
+    wheelWidget->setFixedSize(400, 400);
+
+    QGraphicsProxyWidget *proxy = scene.addWidget(wheelWidget);
+    proxy->setVisible(true);
+
+    QGraphicsSceneWheelEvent event(QEvent::GraphicsSceneWheel);
+    event.setScenePos(QPoint(50, 50));
+    event.setAccepted(false);
+    wheelWidget->wheelEventCalled = false;
+
+    QApplication::sendEvent(&scene, &event);
+
+    QVERIFY(event.isAccepted());
+    QVERIFY(wheelWidget->wheelEventCalled);
+}
+
+Q_DECLARE_METATYPE(Qt::SizeHint)
+void tst_QGraphicsProxyWidget::sizeHint_data()
+{
+    QTest::addColumn<Qt::SizeHint>("which");
+    QTest::addColumn<QSizeF>("constraint");
+    QTest::addColumn<QSizeF>("sizeHint");
+    QTest::addColumn<bool>("hasWidget");
+
+    for (int i = 0; i < 2; ++i) {
+        bool hasWidget = (i == 0);
+        // ### What should these do?
+        QTest::newRow("min") << Qt::MinimumSize << QSizeF() << QSizeF() << hasWidget;
+        QTest::newRow("pre") << Qt::PreferredSize << QSizeF() << QSizeF() << hasWidget;
+        QTest::newRow("max") << Qt::MaximumSize << QSizeF() << QSizeF() << hasWidget;
+        QTest::newRow("mindes") << Qt::MinimumDescent << QSizeF() << QSizeF() << hasWidget;
+        QTest::newRow("nsize") << Qt::NSizeHints << QSizeF() << QSizeF() << hasWidget;
+    }
+}
+
+// protected QSizeF sizeHint(Qt::SizeHint which, QSizeF const& constraint = QSizeF()) const
+void tst_QGraphicsProxyWidget::sizeHint()
+{
+    QFETCH(Qt::SizeHint, which);
+    QFETCH(QSizeF, constraint);
+    QFETCH(QSizeF, sizeHint);
+    QFETCH(bool, hasWidget);
+    QSKIP("Broken test", SkipAll);
+    SubQGraphicsProxyWidget proxy;
+    QWidget *widget = new QWidget;
+    if (hasWidget)
+        proxy.setWidget(widget);
+    QCOMPARE(proxy.call_sizeHint(which, constraint), sizeHint);
+    if (!hasWidget)
+        delete widget;
+}
+
+void tst_QGraphicsProxyWidget::sizePolicy()
+{
+    for (int p = 0; p < 2; ++p) {
+        bool hasWidget = (p == 0 ? true : false);
+        SubQGraphicsProxyWidget proxy;
+        QWidget *widget = new QWidget;
+        QSizePolicy proxyPol(QSizePolicy::Maximum, QSizePolicy::Expanding);
+        proxy.setSizePolicy(proxyPol);
+        QSizePolicy widgetPol(QSizePolicy::Fixed, QSizePolicy::Minimum);
+        widget->setSizePolicy(widgetPol);
+
+        QCOMPARE(proxy.sizePolicy(), proxyPol);
+        QCOMPARE(widget->sizePolicy(), widgetPol);
+        if (hasWidget) {
+            proxy.setWidget(widget);
+            QCOMPARE(proxy.sizePolicy(), widgetPol);
+        } else {
+            QCOMPARE(proxy.sizePolicy(), proxyPol);
+        }
+        QCOMPARE(widget->sizePolicy(), widgetPol);
+
+        proxy.setSizePolicy(widgetPol);
+        widget->setSizePolicy(proxyPol);
+        if (hasWidget)
+            QCOMPARE(proxy.sizePolicy(), proxyPol);
+        else
+            QCOMPARE(proxy.sizePolicy(), widgetPol);
+    }
+}
+
+void tst_QGraphicsProxyWidget::minimumSize()
+{
+    SubQGraphicsProxyWidget proxy;
+    QWidget *widget = new QWidget;
+    QSize minSize(50, 50);
+    widget->setMinimumSize(minSize);
+    proxy.resize(30, 30);
+    widget->resize(30,30);
+    QCOMPARE(proxy.size(), QSizeF(30, 30));
+    proxy.setWidget(widget);
+    QCOMPARE(proxy.size().toSize(), minSize);
+    QCOMPARE(proxy.minimumSize().toSize(), minSize);
+    widget->setMinimumSize(70, 70);
+    QCOMPARE(proxy.minimumSize(), QSizeF(70, 70));
+    QCOMPARE(proxy.size(), QSizeF(70, 70));
+}
+
+void tst_QGraphicsProxyWidget::maximumSize()
+{
+    SubQGraphicsProxyWidget proxy;
+    QWidget *widget = new QWidget;
+    QSize maxSize(150, 150);
+    widget->setMaximumSize(maxSize);
+    proxy.resize(200, 200);
+    widget->resize(200,200);
+    QCOMPARE(proxy.size(), QSizeF(200, 200));
+    proxy.setWidget(widget);
+    QCOMPARE(proxy.size().toSize(), maxSize);
+    QCOMPARE(proxy.maximumSize().toSize(), maxSize);
+    widget->setMaximumSize(70, 70);
+    QCOMPARE(proxy.maximumSize(), QSizeF(70, 70));
+    QCOMPARE(proxy.size(), QSizeF(70, 70));
+}
+
+class View : public QGraphicsView
+{
+public:
+    View(QGraphicsScene *scene, QWidget *parent = 0)
+	: QGraphicsView(scene, parent), npaints(0)
+    { }
+    QRegion paintEventRegion;
+    int npaints;
+protected:
+    void paintEvent(QPaintEvent *event)
+    {
+	++npaints;
+	paintEventRegion += event->region();
+	QGraphicsView::paintEvent(event);
+    }
+};
+
+class ScrollWidget : public QWidget
+{
+    Q_OBJECT
+public:
+    ScrollWidget() : npaints(0)
+    {
+	resize(200, 200);
+    }
+    QRegion paintEventRegion;
+    int npaints;
+
+public slots:
+    void updateScroll()
+    {
+	update(0, 0, 200, 10);
+	scroll(0, 10, QRect(0, 0, 100, 20));
+    }
+
+protected:
+    void paintEvent(QPaintEvent *event)
+    {
+	++npaints;
+	paintEventRegion += event->region();
+	QPainter painter(this);
+	painter.fillRect(event->rect(), Qt::blue);
+    }
+};
+
+void tst_QGraphicsProxyWidget::scrollUpdate()
+{
+    ScrollWidget *widget = new ScrollWidget;
+
+    QGraphicsScene scene;
+    scene.addWidget(widget);
+
+    View view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(view.npaints >= 1);
+    QTest::qWait(20);
+    widget->paintEventRegion = QRegion();
+    widget->npaints = 0;
+    view.paintEventRegion = QRegion();
+    view.npaints = 0;
+    QTimer::singleShot(0, widget, SLOT(updateScroll()));
+    QTRY_COMPARE(view.npaints, 2);
+    // QRect(0, 0, 200, 12) is the first update, expanded (-2, -2, 2, 2)
+    // QRect(0, 12, 102, 10) is the scroll update, expanded (-2, -2, 2, 2),
+    // intersected with the above update.
+    QCOMPARE(view.paintEventRegion.rects(),
+	     QVector<QRect>() << QRect(0, 0, 200, 12) << QRect(0, 12, 102, 10));
+    QCOMPARE(widget->npaints, 2);
+    QCOMPARE(widget->paintEventRegion.rects(),
+             QVector<QRect>() << QRect(0, 0, 200, 12) << QRect(0, 12, 102, 10));
+}
+
+void tst_QGraphicsProxyWidget::setWidget_simple()
+{
+    QGraphicsProxyWidget proxy;
+    QLineEdit *lineEdit = new QLineEdit;
+    proxy.setWidget(lineEdit);
+
+    QVERIFY(lineEdit->testAttribute(Qt::WA_DontShowOnScreen));
+    // Size hints
+    // ### size hints are tested in a different test
+    // QCOMPARE(proxy.effectiveSizeHint(Qt::MinimumSize).toSize(), lineEdit->minimumSizeHint());
+    // QCOMPARE(proxy.effectiveSizeHint(Qt::MaximumSize).toSize(), lineEdit->maximumSize());
+    // QCOMPARE(proxy.effectiveSizeHint(Qt::PreferredSize).toSize(), lineEdit->sizeHint());
+    QCOMPARE(proxy.size().toSize(), lineEdit->minimumSizeHint().expandedTo(lineEdit->size()));
+    QRect rect = lineEdit->rect();
+    rect.setSize(rect.size().expandedTo(lineEdit->minimumSizeHint()));
+    QCOMPARE(proxy.rect().toRect(), rect);
+
+    // Properties
+    // QCOMPARE(proxy.focusPolicy(), lineEdit->focusPolicy());
+    // QCOMPARE(proxy.palette(), lineEdit->palette());
+#ifndef QT_NO_CURSOR
+    QCOMPARE(proxy.cursor().shape(), lineEdit->cursor().shape());
+#endif
+    QCOMPARE(proxy.layoutDirection(), lineEdit->layoutDirection());
+    QCOMPARE(proxy.style(), lineEdit->style());
+    QCOMPARE(proxy.font(), lineEdit->font());
+    QCOMPARE(proxy.isEnabled(), lineEdit->isEnabled());
+    QCOMPARE(proxy.isVisible(), lineEdit->isVisible());
+}
+
+void tst_QGraphicsProxyWidget::setWidget_ownership()
+{
+    QPointer<QLineEdit> lineEdit = new QLineEdit;
+    QPointer<QLineEdit> lineEdit2 = new QLineEdit;
+    QVERIFY(lineEdit);
+    {
+        // Create a proxy and transfer ownership to it
+        QGraphicsProxyWidget proxy;
+        proxy.setWidget(lineEdit);
+        QCOMPARE(proxy.widget(), (QWidget *)lineEdit);
+
+        // Remove the widget without destroying it.
+        proxy.setWidget(0);
+        QVERIFY(!proxy.widget());
+        QVERIFY(lineEdit);
+
+        // Assign the widget again and switch to another widget.
+        proxy.setWidget(lineEdit);
+        proxy.setWidget(lineEdit2);
+        QCOMPARE(proxy.widget(), (QWidget *)lineEdit2);
+
+        // Assign the first widget, and destroy the proxy.
+        proxy.setWidget(lineEdit);
+    }
+    QVERIFY(!lineEdit);
+    QVERIFY(lineEdit2);
+
+    QGraphicsScene scene;
+    QPointer<QGraphicsProxyWidget> proxy = scene.addWidget(lineEdit2);
+
+    delete lineEdit2;
+    QVERIFY(!proxy);
+}
+
+void tst_QGraphicsProxyWidget::resize_simple_data()
+{
+    QTest::addColumn<QSizeF>("size");
+
+    QTest::newRow("200, 200") << QSizeF(200, 200);
+#if !defined(QT_ARCH_ARM) && !defined(Q_OS_WINCE)
+    QTest::newRow("1000, 1000") << QSizeF(1000, 1000);
+    // Since 4.5, 10000x10000 runs out of memory.
+    // QTest::newRow("10000, 10000") << QSizeF(10000, 10000);
+#endif
+}
+
+void tst_QGraphicsProxyWidget::resize_simple()
+{
+    QFETCH(QSizeF, size);
+
+    QGraphicsProxyWidget proxy;
+    QWidget *widget = new QWidget;
+    widget->setGeometry(0, 0, (int)size.width(), (int)size.height());
+    proxy.setWidget(widget);
+    widget->show();
+    QCOMPARE(widget->pos(), QPoint());
+
+    // The proxy resizes itself, the line edit follows
+    proxy.resize(size);
+    QCOMPARE(proxy.size(), size);
+    QCOMPARE(proxy.size().toSize(), widget->size());
+
+    // The line edit resizes itself, the proxy follows (no loopback/live lock)
+    QSize doubleSize = size.toSize() * 2;
+    widget->resize(doubleSize);
+    QCOMPARE(widget->size(), doubleSize);
+    QCOMPARE(widget->size(), proxy.size().toSize());
+}
+
+void tst_QGraphicsProxyWidget::symmetricMove()
+{
+    QGraphicsProxyWidget proxy;
+    QLineEdit *lineEdit = new QLineEdit;
+    proxy.setWidget(lineEdit);
+    lineEdit->show();
+
+    proxy.setPos(10, 10);
+    QCOMPARE(proxy.pos(), QPointF(10, 10));
+    QCOMPARE(lineEdit->pos(), QPoint(10, 10));
+
+    lineEdit->move(5, 5);
+    QCOMPARE(proxy.pos(), QPointF(5, 5));
+    QCOMPARE(lineEdit->pos(), QPoint(5, 5));
+}
+
+void tst_QGraphicsProxyWidget::symmetricResize()
+{
+    QGraphicsProxyWidget proxy;
+    QLineEdit *lineEdit = new QLineEdit;
+    proxy.setWidget(lineEdit);
+    lineEdit->show();
+
+    proxy.resize(256, 256);
+    QCOMPARE(proxy.size(), QSizeF(256, 256));
+    QCOMPARE(lineEdit->size(), QSize(256, 256));
+
+    lineEdit->resize(512, 512);
+    QCOMPARE(proxy.size(), QSizeF(512, 512));
+    QCOMPARE(lineEdit->size(), QSize(512, 512));
+}
+
+void tst_QGraphicsProxyWidget::symmetricVisible()
+{
+    QGraphicsProxyWidget proxy;
+    QLineEdit *lineEdit = new QLineEdit;
+    proxy.setWidget(lineEdit);
+    lineEdit->show();
+
+    QCOMPARE(proxy.isVisible(), lineEdit->isVisible());
+
+    proxy.hide();
+    QCOMPARE(proxy.isVisible(), lineEdit->isVisible());
+    proxy.show();
+    QCOMPARE(proxy.isVisible(), lineEdit->isVisible());
+    lineEdit->hide();
+    QCOMPARE(proxy.isVisible(), lineEdit->isVisible());
+    lineEdit->show();
+    QCOMPARE(proxy.isVisible(), lineEdit->isVisible());
+ }
+
+void tst_QGraphicsProxyWidget::symmetricEnabled()
+{
+    QGraphicsProxyWidget proxy;
+    QLineEdit *lineEdit = new QLineEdit;
+    proxy.setWidget(lineEdit);
+    lineEdit->show();
+
+    QCOMPARE(proxy.isEnabled(), lineEdit->isEnabled());
+    proxy.setEnabled(false);
+    QCOMPARE(proxy.isEnabled(), lineEdit->isEnabled());
+    proxy.setEnabled(true);
+    QCOMPARE(proxy.isEnabled(), lineEdit->isEnabled());
+    lineEdit->setEnabled(false);
+    QCOMPARE(proxy.isEnabled(), lineEdit->isEnabled());
+    lineEdit->setEnabled(true);
+    QCOMPARE(proxy.isEnabled(), lineEdit->isEnabled());
+}
+
+void tst_QGraphicsProxyWidget::tabFocus_simpleWidget()
+{
+    QGraphicsScene scene;
+    QLineEdit *edit = new QLineEdit;
+    QGraphicsProxyWidget *editProxy = scene.addWidget(edit);
+    editProxy->show();
+
+    QDial *leftDial = new QDial;
+    QDial *rightDial = new QDial;
+    QGraphicsView *view = new QGraphicsView(&scene);
+
+    QWidget window;
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(leftDial);
+    layout->addWidget(view);
+    layout->addWidget(rightDial);
+    window.setLayout(layout);
+
+    window.show();
+    QApplication::setActiveWindow(&window);
+    window.activateWindow();
+    QTest::qWaitForWindowShown(&window);
+
+    leftDial->setFocus();
+    QApplication::processEvents();
+    QTRY_VERIFY(leftDial->hasFocus());
+
+    EventSpy eventSpy(edit);
+
+    // Tab into line edit
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QTRY_VERIFY(!leftDial->hasFocus());
+    QTRY_VERIFY(view->hasFocus());
+    QVERIFY(view->viewport()->hasFocus());
+    QVERIFY(scene.hasFocus());
+    QVERIFY(editProxy->hasFocus());
+    QVERIFY(edit->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 0);
+
+    // Tab into right dial
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QTRY_VERIFY(!view->hasFocus());
+    QVERIFY(!view->viewport()->hasFocus());
+    QVERIFY(!scene.hasFocus());
+    QVERIFY(!editProxy->hasFocus());
+    QVERIFY(!edit->hasFocus());
+    QTRY_VERIFY(rightDial->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 1);
+
+    // Backtab into line edit
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QTRY_VERIFY(view->hasFocus());
+    QVERIFY(view->viewport()->hasFocus());
+    QTRY_VERIFY(scene.hasFocus());
+    QVERIFY(editProxy->hasFocus());
+    QVERIFY(edit->hasFocus());
+    QVERIFY(!rightDial->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 2);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 1);
+
+    // Backtab into left dial
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QTRY_VERIFY(!view->hasFocus());
+    QVERIFY(!view->viewport()->hasFocus());
+    QVERIFY(!scene.hasFocus());
+    QVERIFY(!editProxy->hasFocus());
+    QVERIFY(!edit->hasFocus());
+    QTRY_VERIFY(leftDial->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 2);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 2);
+
+    delete view;
+}
+
+void tst_QGraphicsProxyWidget::tabFocus_simpleTwoWidgets()
+{
+    QGraphicsScene scene;
+    QLineEdit *edit = new QLineEdit;
+    QLineEdit *edit2 = new QLineEdit;
+    QGraphicsProxyWidget *editProxy = scene.addWidget(edit);
+    editProxy->show();
+    QGraphicsProxyWidget *editProxy2 = scene.addWidget(edit2);
+    editProxy2->show();
+    editProxy2->setPos(0, editProxy->rect().height() * 1.1);
+
+    QDial *leftDial = new QDial;
+    QDial *rightDial = new QDial;
+    QGraphicsView *view = new QGraphicsView(&scene);
+
+    QWidget window;
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(leftDial);
+    layout->addWidget(view);
+    layout->addWidget(rightDial);
+    window.setLayout(layout);
+
+    window.show();
+    QApplication::setActiveWindow(&window);
+    window.activateWindow();
+    QTest::qWaitForWindowShown(&window);
+
+    leftDial->setFocus();
+    QApplication::processEvents();
+    QTRY_VERIFY(leftDial->hasFocus());
+
+    EventSpy eventSpy(edit);
+    EventSpy eventSpy2(edit2);
+
+    // Tab into line edit
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QVERIFY(!leftDial->hasFocus());
+    QVERIFY(view->hasFocus());
+    QVERIFY(view->viewport()->hasFocus());
+    QVERIFY(scene.hasFocus());
+    QVERIFY(editProxy->hasFocus());
+    QVERIFY(edit->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 0);
+
+    // Tab into second line edit
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QVERIFY(view->hasFocus());
+    QVERIFY(view->viewport()->hasFocus());
+    QVERIFY(scene.hasFocus());
+    QVERIFY(!editProxy->hasFocus());
+    QVERIFY(!edit->hasFocus());
+    QVERIFY(editProxy2->hasFocus());
+    QVERIFY(edit2->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpy2.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy2.counts[QEvent::FocusOut], 0);
+
+    // Tab into right dial
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QVERIFY(!view->hasFocus());
+    QVERIFY(!view->viewport()->hasFocus());
+    QVERIFY(!scene.hasFocus());
+    QVERIFY(!editProxy->hasFocus());
+    QVERIFY(!edit->hasFocus());
+    QVERIFY(!editProxy2->hasFocus());
+    QVERIFY(!edit2->hasFocus());
+    QVERIFY(rightDial->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpy2.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy2.counts[QEvent::FocusOut], 1);
+
+    // Backtab into line edit 2
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(view->hasFocus());
+    QVERIFY(view->viewport()->hasFocus());
+    QVERIFY(scene.hasFocus());
+    QVERIFY(!editProxy->hasFocus());
+    QVERIFY(!edit->hasFocus());
+    QVERIFY(editProxy2->hasFocus());
+    QVERIFY(edit2->hasFocus());
+    QVERIFY(!rightDial->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpy2.counts[QEvent::FocusIn], 2);
+    QCOMPARE(eventSpy2.counts[QEvent::FocusOut], 1);
+
+    // Backtab into line edit 1
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(view->hasFocus());
+    QVERIFY(view->viewport()->hasFocus());
+    QVERIFY(scene.hasFocus());
+    QVERIFY(editProxy->hasFocus());
+    QVERIFY(edit->hasFocus());
+    QVERIFY(!editProxy2->hasFocus());
+    QVERIFY(!edit2->hasFocus());
+    QVERIFY(!rightDial->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 2);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpy2.counts[QEvent::FocusIn], 2);
+    QCOMPARE(eventSpy2.counts[QEvent::FocusOut], 2);
+
+    // Backtab into left dial
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!view->hasFocus());
+    QVERIFY(!view->viewport()->hasFocus());
+    QVERIFY(!scene.hasFocus());
+    QVERIFY(!editProxy->hasFocus());
+    QVERIFY(!edit->hasFocus());
+    QVERIFY(leftDial->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 2);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 2);
+
+    delete view;
+}
+
+void tst_QGraphicsProxyWidget::tabFocus_complexWidget()
+{
+    QGraphicsScene scene;
+
+    QLineEdit *edit1 = new QLineEdit;
+    edit1->setText("QLineEdit 1");
+    QLineEdit *edit2 = new QLineEdit;
+    edit2->setText("QLineEdit 2");
+    QVBoxLayout *vlayout = new QVBoxLayout;
+    vlayout->addWidget(edit1);
+    vlayout->addWidget(edit2);
+
+    QGroupBox *box = new QGroupBox("QGroupBox");
+    box->setCheckable(true);
+    box->setChecked(true);
+    box->setLayout(vlayout);
+
+    QGraphicsProxyWidget *proxy = scene.addWidget(box);
+    proxy->show();
+
+    QDial *leftDial = new QDial;
+    QDial *rightDial = new QDial;
+    QGraphicsView *view = new QGraphicsView(&scene);
+
+    QWidget window;
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(leftDial);
+    layout->addWidget(view);
+    layout->addWidget(rightDial);
+    window.setLayout(layout);
+
+    window.show();
+    QApplication::setActiveWindow(&window);
+    window.activateWindow();
+    QTest::qWaitForWindowShown(&window);
+
+    leftDial->setFocus();
+    QApplication::processEvents();
+    QTRY_VERIFY(leftDial->hasFocus());
+
+    EventSpy eventSpy(edit1);
+    EventSpy eventSpy2(edit2);
+    EventSpy eventSpyBox(box);
+
+    // Tab into group box
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QVERIFY(!leftDial->hasFocus());
+    QVERIFY(view->hasFocus());
+    QVERIFY(view->viewport()->hasFocus());
+    QVERIFY(scene.hasFocus());
+    QVERIFY(proxy->hasFocus());
+    QVERIFY(box->hasFocus());
+
+    // Tab into line edit
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    edit1->hasFocus();
+    QVERIFY(!box->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 0);
+
+    // Tab into line edit 2
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    edit2->hasFocus();
+    QVERIFY(!edit1->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpy2.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy2.counts[QEvent::FocusOut], 0);
+
+    // Tab into right dial
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QVERIFY(!edit2->hasFocus());
+    rightDial->hasFocus();
+    QCOMPARE(eventSpy2.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy2.counts[QEvent::FocusOut], 1);
+
+    // Backtab into line edit 2
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!rightDial->hasFocus());
+    edit2->hasFocus();
+    QCOMPARE(eventSpy2.counts[QEvent::FocusIn], 2);
+    QCOMPARE(eventSpy2.counts[QEvent::FocusOut], 1);
+
+    // Backtab into line edit 1
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!edit2->hasFocus());
+    edit1->hasFocus();
+    QCOMPARE(eventSpy2.counts[QEvent::FocusOut], 2);
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 2);
+
+    // Backtab into line box
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!edit1->hasFocus());
+    box->hasFocus();
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 2);
+
+    // Backtab into left dial
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!box->hasFocus());
+    leftDial->hasFocus();
+
+    delete view;
+}
+
+void tst_QGraphicsProxyWidget::tabFocus_complexTwoWidgets()
+{
+    // ### add event spies to this test.
+    QGraphicsScene scene;
+
+    QLineEdit *edit1 = new QLineEdit;
+    edit1->setText("QLineEdit 1");
+    QLineEdit *edit2 = new QLineEdit;
+    edit2->setText("QLineEdit 2");
+    QFontComboBox *fontComboBox = new QFontComboBox;
+    QVBoxLayout *vlayout = new QVBoxLayout;
+    vlayout->addWidget(edit1);
+    vlayout->addWidget(fontComboBox);
+    vlayout->addWidget(edit2);
+
+    QGroupBox *box = new QGroupBox("QGroupBox");
+    box->setCheckable(true);
+    box->setChecked(true);
+    box->setLayout(vlayout);
+
+    QLineEdit *edit1_2 = new QLineEdit;
+    edit1_2->setText("QLineEdit 1_2");
+    QLineEdit *edit2_2 = new QLineEdit;
+    edit2_2->setText("QLineEdit 2_2");
+    QFontComboBox *fontComboBox2 = new QFontComboBox;
+    vlayout = new QVBoxLayout;
+    vlayout->addWidget(edit1_2);
+    vlayout->addWidget(fontComboBox2);
+    vlayout->addWidget(edit2_2);
+
+    QGroupBox *box_2 = new QGroupBox("QGroupBox 2");
+    box_2->setCheckable(true);
+    box_2->setChecked(true);
+    box_2->setLayout(vlayout);
+
+    QGraphicsProxyWidget *proxy = scene.addWidget(box);
+    proxy->show();
+
+    QGraphicsProxyWidget *proxy_2 = scene.addWidget(box_2);
+    proxy_2->setPos(proxy->boundingRect().width() * 1.2, 0);
+    proxy_2->show();
+
+    QDial *leftDial = new QDial;
+    QDial *rightDial = new QDial;
+    QGraphicsView *view = new QGraphicsView(&scene);
+    view->setRenderHint(QPainter::Antialiasing);
+    view->rotate(45);
+    view->scale(0.5, 0.5);
+
+    QWidget window;
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(leftDial);
+    layout->addWidget(view);
+    layout->addWidget(rightDial);
+    window.setLayout(layout);
+
+    window.show();
+    QApplication::setActiveWindow(&window);
+    window.activateWindow();
+    QTest::qWaitForWindowShown(&window);
+    QTRY_COMPARE(QApplication::activeWindow(), &window);
+
+    leftDial->setFocus();
+    QApplication::processEvents();
+    QTRY_VERIFY(leftDial->hasFocus());
+
+    EventSpy eventSpy(edit1);
+    EventSpy eventSpy2(edit2);
+    EventSpy eventSpy3(fontComboBox);
+    EventSpy eventSpy1_2(edit1_2);
+    EventSpy eventSpy2_2(edit2_2);
+    EventSpy eventSpy2_3(fontComboBox2);
+    EventSpy eventSpyBox(box);
+
+    // Tab into group box
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QVERIFY(!leftDial->hasFocus());
+    QVERIFY(view->hasFocus());
+    QVERIFY(view->viewport()->hasFocus());
+    QVERIFY(scene.hasFocus());
+    QVERIFY(proxy->hasFocus());
+    QVERIFY(box->hasFocus());
+
+    // Tab into line edit
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    edit1->hasFocus();
+    QVERIFY(!box->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 0);
+
+    // Tab to the font combobox
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    fontComboBox->hasFocus();
+    QVERIFY(!edit2->hasFocus());
+    QCOMPARE(eventSpy3.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy3.counts[QEvent::FocusOut], 0);
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 1);
+
+    // Tab into line edit 2
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    edit2->hasFocus();
+    QVERIFY(!edit1->hasFocus());
+    QCOMPARE(eventSpy2.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy2.counts[QEvent::FocusOut], 0);
+    QCOMPARE(eventSpy3.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 1);
+
+    // Tab into right box
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QVERIFY(!edit2->hasFocus());
+    box_2->hasFocus();
+
+    // Tab into right top line edit
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QVERIFY(!box_2->hasFocus());
+    edit1_2->hasFocus();
+    QCOMPARE(eventSpy1_2.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy1_2.counts[QEvent::FocusOut], 0);
+
+    // Tab into right font combobox
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QVERIFY(!edit1_2->hasFocus());
+    fontComboBox2->hasFocus();
+    QCOMPARE(eventSpy1_2.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy1_2.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpy2_3.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy2_3.counts[QEvent::FocusOut], 0);
+
+    // Tab into right bottom line edit
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QVERIFY(!edit1_2->hasFocus());
+    edit2_2->hasFocus();
+    QCOMPARE(eventSpy1_2.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy1_2.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpy2_3.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy2_3.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpy2_2.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy2_2.counts[QEvent::FocusOut], 0);
+
+    // Tab into right dial
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QVERIFY(!edit2->hasFocus());
+    rightDial->hasFocus();
+    QCOMPARE(eventSpy2_2.counts[QEvent::FocusOut], 1);
+
+    // Backtab into line edit 2
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!rightDial->hasFocus());
+    edit2_2->hasFocus();
+
+    // Backtab into the right font combobox
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!edit2_2->hasFocus());
+    fontComboBox2->hasFocus();
+
+    // Backtab into line edit 1
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!edit2_2->hasFocus());
+    edit1_2->hasFocus();
+
+    // Backtab into line box
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!edit1_2->hasFocus());
+    box_2->hasFocus();
+
+    // Backtab into line edit 2
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!rightDial->hasFocus());
+    edit2->hasFocus();
+
+    // Backtab into the font combobox
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!edit2->hasFocus());
+    fontComboBox->hasFocus();
+
+    // Backtab into line edit 1
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!fontComboBox->hasFocus());
+    edit1->hasFocus();
+
+    // Backtab into line box
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!edit1->hasFocus());
+    box->hasFocus();
+
+    // Backtab into left dial
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!box->hasFocus());
+    leftDial->hasFocus();
+
+    delete view;
+}
+
+void tst_QGraphicsProxyWidget::setFocus_simpleWidget()
+{
+    QGraphicsScene scene;
+    QLineEdit *edit = new QLineEdit;
+    QGraphicsProxyWidget *editProxy = scene.addWidget(edit);
+    editProxy->show();
+
+    QDial *leftDial = new QDial;
+    QDial *rightDial = new QDial;
+    QGraphicsView *view = new QGraphicsView(&scene);
+
+    QWidget window;
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(leftDial);
+    layout->addWidget(view);
+    layout->addWidget(rightDial);
+    window.setLayout(layout);
+
+    window.show();
+    QApplication::setActiveWindow(&window);
+    window.activateWindow();
+    QTest::qWaitForWindowShown(&window);
+    QTRY_COMPARE(QApplication::activeWindow(), &window);
+
+    leftDial->setFocus();
+    QApplication::processEvents();
+    QTRY_VERIFY(leftDial->hasFocus());
+
+    EventSpy eventSpy(edit);
+
+    // Calling setFocus for the line edit when the view doesn't have input
+    // focus does not steal focus from the dial. The edit, proxy and scene
+    // have focus but only in their own little space.
+    edit->setFocus();
+    QVERIFY(scene.hasFocus());
+    QVERIFY(edit->hasFocus());
+    QVERIFY(!view->hasFocus());
+    QVERIFY(!view->viewport()->hasFocus());
+    QVERIFY(leftDial->hasFocus());
+
+    // Clearing focus is a local operation.
+    edit->clearFocus();
+    QVERIFY(scene.hasFocus());
+    QVERIFY(!edit->hasFocus());
+    QVERIFY(!view->hasFocus());
+    QVERIFY(leftDial->hasFocus());
+
+    view->setFocus();
+    QVERIFY(scene.hasFocus());
+    QVERIFY(view->hasFocus());
+    QVERIFY(!leftDial->hasFocus());
+    QVERIFY(!edit->hasFocus());
+
+    scene.clearFocus();
+    QVERIFY(!scene.hasFocus());
+
+    edit->setFocus();
+    QVERIFY(scene.hasFocus());
+    QVERIFY(edit->hasFocus());
+    QVERIFY(editProxy->hasFocus());
+
+    // Symmetry
+    editProxy->clearFocus();
+    QVERIFY(!edit->hasFocus());
+
+    delete view;
+}
+
+void tst_QGraphicsProxyWidget::setFocus_simpleTwoWidgets()
+{
+    QGraphicsScene scene;
+    QLineEdit *edit = new QLineEdit;
+    QGraphicsProxyWidget *editProxy = scene.addWidget(edit);
+    editProxy->show();
+    QLineEdit *edit2 = new QLineEdit;
+    QGraphicsProxyWidget *edit2Proxy = scene.addWidget(edit2);
+    edit2Proxy->show();
+    edit2Proxy->setPos(editProxy->boundingRect().width() * 1.01, 0);
+
+    QDial *leftDial = new QDial;
+    QDial *rightDial = new QDial;
+    QGraphicsView *view = new QGraphicsView(&scene);
+
+    QWidget window;
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(leftDial);
+    layout->addWidget(view);
+    layout->addWidget(rightDial);
+    window.setLayout(layout);
+
+    window.show();
+    QApplication::setActiveWindow(&window);
+    window.activateWindow();
+    QTest::qWaitForWindowShown(&window);
+    QTRY_COMPARE(QApplication::activeWindow(), &window);
+
+    leftDial->setFocus();
+    QApplication::processEvents();
+    QTRY_VERIFY(leftDial->hasFocus());
+
+    EventSpy eventSpy(edit);
+
+    view->setFocus();
+    QVERIFY(!edit->hasFocus());
+
+    edit->setFocus();
+    QVERIFY(scene.hasFocus());
+    QVERIFY(edit->hasFocus());
+    QVERIFY(editProxy->hasFocus());
+
+    edit2->setFocus();
+    QVERIFY(scene.hasFocus());
+    QVERIFY(!edit->hasFocus());
+    QVERIFY(!editProxy->hasFocus());
+    QVERIFY(edit2->hasFocus());
+    QVERIFY(edit2Proxy->hasFocus());
+
+    delete view;
+}
+
+void tst_QGraphicsProxyWidget::setFocus_complexTwoWidgets()
+{
+    // ### add event spies to this test.
+    QGraphicsScene scene;
+
+    QLineEdit *edit1 = new QLineEdit;
+    edit1->setText("QLineEdit 1");
+    QLineEdit *edit2 = new QLineEdit;
+    edit2->setText("QLineEdit 2");
+    QVBoxLayout *vlayout = new QVBoxLayout;
+    vlayout->addWidget(edit1);
+    vlayout->addWidget(edit2);
+
+    QGroupBox *box = new QGroupBox("QGroupBox");
+    box->setCheckable(true);
+    box->setChecked(true);
+    box->setLayout(vlayout);
+
+    QLineEdit *edit1_2 = new QLineEdit;
+    edit1_2->setText("QLineEdit 1_2");
+    QLineEdit *edit2_2 = new QLineEdit;
+    edit2_2->setText("QLineEdit 2_2");
+    vlayout = new QVBoxLayout;
+    vlayout->addWidget(edit1_2);
+    vlayout->addWidget(edit2_2);
+
+    QGroupBox *box_2 = new QGroupBox("QGroupBox 2");
+    box_2->setCheckable(true);
+    box_2->setChecked(true);
+    box_2->setLayout(vlayout);
+
+    QGraphicsProxyWidget *proxy = scene.addWidget(box);
+    proxy->show();
+
+    QGraphicsProxyWidget *proxy_2 = scene.addWidget(box_2);
+    proxy_2->setPos(proxy->boundingRect().width() * 1.2, 0);
+    proxy_2->show();
+
+    QDial *leftDial = new QDial;
+    QDial *rightDial = new QDial;
+    QGraphicsView *view = new QGraphicsView(&scene);
+
+    QWidget window;
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(leftDial);
+    layout->addWidget(view);
+    layout->addWidget(rightDial);
+    window.setLayout(layout);
+
+    window.show();
+    QApplication::setActiveWindow(&window);
+    window.activateWindow();
+    QTest::qWaitForWindowShown(&window);
+    QTRY_COMPARE(QApplication::activeWindow(), &window);
+
+    leftDial->setFocus();
+    QApplication::processEvents();
+    QTRY_VERIFY(leftDial->hasFocus());
+
+    EventSpy eventSpy(edit1);
+    EventSpy eventSpy2(edit2);
+    EventSpy eventSpyBox(box);
+    EventSpy eventSpy_2(edit1_2);
+    EventSpy eventSpy2_2(edit2_2);
+    EventSpy eventSpyBox_2(box_2);
+
+    view->setFocus();
+
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 0);
+
+    edit1->setFocus();
+    QApplication::processEvents();
+    QVERIFY(scene.hasFocus());
+    QVERIFY(edit1->hasFocus());
+    QVERIFY(!box->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpyBox.counts[QEvent::FocusIn], 0);
+
+    edit2_2->setFocus();
+    QApplication::processEvents();
+    QVERIFY(!edit1->hasFocus());
+    QVERIFY(!box_2->hasFocus());
+    QVERIFY(edit2_2->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpy2_2.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpyBox.counts[QEvent::FocusIn], 0);
+    QCOMPARE(eventSpyBox_2.counts[QEvent::FocusIn], 0);
+
+    box->setFocus();
+    QApplication::processEvents();
+    QVERIFY(!edit2_2->hasFocus());
+    QVERIFY(!edit1->hasFocus());
+    QVERIFY(box->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpy2_2.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy2_2.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpyBox.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpyBox.counts[QEvent::FocusOut], 0);
+    QCOMPARE(eventSpyBox_2.counts[QEvent::FocusIn], 0);
+    QCOMPARE(eventSpyBox_2.counts[QEvent::FocusOut], 0);
+
+    edit2_2->setFocus();
+    QApplication::processEvents();
+    QVERIFY(edit2_2->hasFocus());
+    QVERIFY(!edit1->hasFocus());
+    QVERIFY(!box->hasFocus());
+    QVERIFY(!box_2->hasFocus());
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpy2_2.counts[QEvent::FocusIn], 2);
+    QCOMPARE(eventSpy2_2.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpyBox.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpyBox.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpyBox_2.counts[QEvent::FocusIn], 0);
+    QCOMPARE(eventSpyBox_2.counts[QEvent::FocusOut], 0);
+
+    delete view;
+}
+
+void tst_QGraphicsProxyWidget::popup_basic()
+{
+    // ProxyWidget should automatically create proxy's when the widget creates a child
+    QGraphicsScene *scene = new QGraphicsScene;
+    QGraphicsView view(scene);
+    view.setAlignment(Qt::AlignLeft | Qt::AlignTop);
+    view.setGeometry(0, 100, 480, 500);
+    view.show();
+
+    SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;
+    QComboBox *box = new QComboBox;
+    box->setGeometry(0, 0, 320, 40);
+    box->addItems(QStringList() << "monday" << "tuesday" << "wednesday"
+		  << "thursday" << "saturday" << "sunday");
+    QCOMPARE(proxy->childItems().count(), 0);
+    proxy->setWidget(box);
+    proxy->show();
+    scene->addItem(proxy);
+
+    QCOMPARE(box->pos(), QPoint());
+    QCOMPARE(proxy->pos(), QPointF());
+
+    QTest::qWaitForWindowShown(&view);
+    QTest::qWait(125);
+    QApplication::processEvents();
+
+    QTest::mousePress(view.viewport(), Qt::LeftButton, 0,
+		      view.mapFromScene(proxy->mapToScene(proxy->boundingRect().center())));
+
+    QTRY_COMPARE(box->pos(), QPoint());
+
+    QCOMPARE(proxy->childItems().count(), 1);
+    QGraphicsProxyWidget *child = (QGraphicsProxyWidget*)(proxy->childItems())[0];
+    QVERIFY(child->isWidget());
+    QVERIFY(child->widget());
+    QStyleOptionComboBox opt;
+    opt.initFrom(box);
+    opt.editable = box->isEditable();
+    if (box->style()->styleHint(QStyle::SH_ComboBox_Popup, &opt))
+        QSKIP("Does not work due to SH_Combobox_Popup", SkipAll);
+    QCOMPARE(child->widget()->parent(), static_cast<QObject*>(box));
+
+    QTRY_COMPARE(proxy->pos(), QPointF(box->pos()));
+    QCOMPARE(child->x(), qreal(box->x()));
+    QCOMPARE(child->y(), qreal(box->rect().bottom()));
+#ifndef Q_OS_WIN
+    // The popup's coordinates on Windows are in global space,
+    // regardless.
+    QCOMPARE(child->widget()->x(), box->x());
+    QCOMPARE(child->widget()->y(), box->rect().bottom());
+    QCOMPARE(child->geometry().toRect(), child->widget()->geometry());
+#endif
+    QTest::qWait(12);
+}
+
+void tst_QGraphicsProxyWidget::popup_subwidget()
+{
+    QGroupBox *groupBox = new QGroupBox;
+    groupBox->setTitle("GroupBox");
+    groupBox->setCheckable(true);
+
+    QComboBox *box = new QComboBox;
+    box->addItems(QStringList() << "monday" << "tuesday" << "wednesday"
+		  << "thursday" << "saturday" << "sunday");
+
+    QVBoxLayout *layout = new QVBoxLayout;
+    layout->addWidget(new QLineEdit("QLineEdit"));
+    layout->addWidget(box);
+    layout->addWidget(new QLineEdit("QLineEdit"));
+    groupBox->setLayout(layout);
+
+    QGraphicsScene scene;
+    QGraphicsProxyWidget *groupBoxProxy = scene.addWidget(groupBox);
+    groupBox->show();
+    groupBox->move(10000, 10000);
+    QCOMPARE(groupBox->pos(), QPoint(10000, 10000));
+    QCOMPARE(groupBoxProxy->pos(), QPointF(10000, 10000));
+
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+
+    box->showPopup();
+
+    QVERIFY(!groupBoxProxy->childItems().isEmpty());
+
+    QStyleOptionComboBox opt;
+    opt.initFrom(box);
+    opt.editable = box->isEditable();
+    if (box->style()->styleHint(QStyle::SH_ComboBox_Popup, &opt))
+        QSKIP("Does not work due to SH_Combobox_Popup", SkipAll);
+    QGraphicsProxyWidget *child = (QGraphicsProxyWidget*)(groupBoxProxy->childItems())[0];
+    QWidget *popup = child->widget();
+    QCOMPARE(popup->parent(), static_cast<QObject*>(box));
+    QCOMPARE(popup->x(), box->mapToGlobal(QPoint()).x());
+    QCOMPARE(popup->y(), QRect(box->mapToGlobal(QPoint()), box->size()).bottom());
+    QCOMPARE(popup->size(), child->size().toSize());
+}
+
+#if !defined(QT_NO_CURSOR) && (!defined(Q_OS_WINCE) || defined(GWES_ICONCURS))
+void tst_QGraphicsProxyWidget::changingCursor_basic()
+{
+    // Confirm that mouse events are working properly by checking that
+    // when moving the mouse over a line edit it will change the cursor into the I
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+
+    SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;
+    QLineEdit *widget = new QLineEdit;
+    proxy->setWidget(widget);
+    proxy->show();
+    scene.addItem(proxy);
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+    QApplication::processEvents();
+    QTRY_VERIFY(view.isActiveWindow());
+
+    // in
+    QTest::mouseMove(view.viewport(), view.mapFromScene(proxy->mapToScene(proxy->boundingRect().center())));
+    sendMouseMove(view.viewport(), view.mapFromScene(proxy->mapToScene(proxy->boundingRect().center())));
+    QTRY_COMPARE(view.viewport()->cursor().shape(), Qt::IBeamCursor);
+
+    // out
+    QTest::mouseMove(view.viewport(), QPoint(1, 1));
+    sendMouseMove(view.viewport(), QPoint(1, 1));
+    QTRY_COMPARE(view.viewport()->cursor().shape(), Qt::ArrowCursor);
+}
+#endif
+
+void tst_QGraphicsProxyWidget::tooltip_basic()
+{
+    QString toolTip = "Qt rocks!";
+    QString toolTip2 = "Qt rocks even more!";
+
+    QPushButton *button = new QPushButton("button");
+    QGraphicsProxyWidget *proxy = new QGraphicsProxyWidget;
+    QGraphicsProxyWidgetPrivate *proxyd = static_cast<QGraphicsProxyWidgetPrivate *>(QGraphicsItemPrivate::get(proxy));
+    proxy->setWidget(button);
+    proxyd->lastWidgetUnderMouse = button; // force widget under mouse
+
+    QVERIFY(button->toolTip().isEmpty());
+    QVERIFY(proxy->toolTip().isEmpty());
+    // Check that setting the tooltip on the proxy also set it on the widget
+    proxy->setToolTip(toolTip);
+    QCOMPARE(proxy->toolTip(), toolTip);
+    QCOMPARE(button->toolTip(), toolTip);
+    // Check that setting the tooltip on the widget also set it on the proxy
+    button->setToolTip(toolTip2);
+    QCOMPARE(proxy->toolTip(), toolTip2);
+    QCOMPARE(button->toolTip(), toolTip2);
+
+    QGraphicsScene scene;
+    scene.addItem(proxy);
+
+    QGraphicsView view(&scene);
+    view.setFixedSize(200, 200);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    {
+        QHelpEvent helpEvent(QEvent::ToolTip, view.viewport()->rect().topLeft(),
+                             view.viewport()->mapToGlobal(view.viewport()->rect().topLeft()));
+        QApplication::sendEvent(view.viewport(), &helpEvent);
+        QTest::qWait(350);
+
+        bool foundView = false;
+        bool foundTipLabel = false;
+        foreach (QWidget *widget, QApplication::topLevelWidgets()) {
+            if (widget == &view)
+                foundView = true;
+            if (widget->inherits("QTipLabel"))
+                foundTipLabel = true;
+        }
+        QVERIFY(foundView);
+        QVERIFY(!foundTipLabel);
+    }
+
+    {
+        QHelpEvent helpEvent(QEvent::ToolTip, view.mapFromScene(proxy->boundingRect().center()),
+                             view.viewport()->mapToGlobal(view.mapFromScene(proxy->boundingRect().center())));
+        QApplication::sendEvent(view.viewport(), &helpEvent);
+        QTest::qWait(350);
+
+        bool foundView = false;
+        bool foundTipLabel = false;
+        foreach (QWidget *widget, QApplication::topLevelWidgets()) {
+            if (widget == &view)
+                foundView = true;
+            if (widget->inherits("QTipLabel"))
+                foundTipLabel = true;
+        }
+        QVERIFY(foundView);
+        QVERIFY(foundTipLabel);
+    }
+}
+
+void tst_QGraphicsProxyWidget::childPos_data()
+{
+    QTest::addColumn<bool>("moveCombo");
+    QTest::addColumn<QPoint>("comboPos");
+    QTest::addColumn<QPointF>("proxyPos");
+    QTest::addColumn<QPointF>("menuPos");
+
+    QTest::newRow("0") << true << QPoint() << QPointF() << QPointF();
+    QTest::newRow("1") << true << QPoint(10, 0) << QPointF(10, 0) << QPointF();
+    QTest::newRow("2") << true << QPoint(100, 0) << QPointF(100, 0) << QPointF();
+    QTest::newRow("3") << true << QPoint(1000, 0) << QPointF(1000, 0) << QPointF();
+    QTest::newRow("4") << true << QPoint(10000, 0) << QPointF(10000, 0) << QPointF();
+    QTest::newRow("5") << true << QPoint(-10000, 0) << QPointF(-10000, 0) << QPointF();
+    QTest::newRow("6") << true << QPoint(-1000, 0) << QPointF(-1000, 0) << QPointF();
+    QTest::newRow("7") << true << QPoint(-100, 0) << QPointF(-100, 0) << QPointF();
+    QTest::newRow("8") << true << QPoint(-10, 0) << QPointF(-10, 0) << QPointF();
+    QTest::newRow("0-") << false << QPoint() << QPointF() << QPointF();
+    QTest::newRow("1-") << false << QPoint(10, 0) << QPointF(10, 0) << QPointF();
+    QTest::newRow("2-") << false << QPoint(100, 0) << QPointF(100, 0) << QPointF();
+    QTest::newRow("3-") << false << QPoint(1000, 0) << QPointF(1000, 0) << QPointF();
+    QTest::newRow("4-") << false << QPoint(10000, 0) << QPointF(10000, 0) << QPointF();
+    QTest::newRow("5-") << false << QPoint(-10000, 0) << QPointF(-10000, 0) << QPointF();
+    QTest::newRow("6-") << false << QPoint(-1000, 0) << QPointF(-1000, 0) << QPointF();
+    QTest::newRow("7-") << false << QPoint(-100, 0) << QPointF(-100, 0) << QPointF();
+    QTest::newRow("8-") << false << QPoint(-10, 0) << QPointF(-10, 0) << QPointF();
+}
+
+void tst_QGraphicsProxyWidget::childPos()
+{
+#ifdef Q_OS_IRIX
+    QSKIP("This test is not reliable on IRIX.", SkipAll);
+#endif
+    QFETCH(bool, moveCombo);
+    QFETCH(QPoint, comboPos);
+    QFETCH(QPointF, proxyPos);
+    QFETCH(QPointF, menuPos);
+
+    QGraphicsScene scene;
+
+    QComboBox *box = new QComboBox;
+    box->addItem("Item 1");
+    box->addItem("Item 2");
+    box->addItem("Item 3");
+    box->addItem("Item 4");
+
+    if (moveCombo)
+        box->move(comboPos);
+
+    QGraphicsProxyWidget *proxy = scene.addWidget(box);
+    proxy->show();
+    QVERIFY(proxy->isVisible());
+    QVERIFY(box->isVisible());
+
+    if (!moveCombo)
+        proxy->setPos(proxyPos);
+
+    QCOMPARE(proxy->pos(), proxyPos);
+    QCOMPARE(box->pos(), comboPos);
+
+    for (int i = 0; i < 2; ++i) {
+        box->showPopup();
+        QApplication::processEvents();
+        QApplication::processEvents();
+
+        QWidget *menu = 0;
+        foreach (QObject *child, box->children()) {
+            if ((menu = qobject_cast<QWidget *>(child)))
+                break;
+        }
+        QVERIFY(menu);
+        QVERIFY(menu->isVisible());
+        QVERIFY(menu->testAttribute(Qt::WA_DontShowOnScreen));
+
+        QCOMPARE(proxy->childItems().size(), 1);
+        QGraphicsProxyWidget *proxyChild = 0;
+        foreach (QGraphicsItem *child, proxy->childItems()) {
+            if (child->isWidget() && (proxyChild = qobject_cast<QGraphicsProxyWidget *>(static_cast<QGraphicsWidget *>(child))))
+                break;
+        }
+        QVERIFY(proxyChild);
+        QVERIFY(proxyChild->isVisible());
+        qreal expectedXPosition = 0.0;
+#if defined(Q_WS_MAC) && !defined(QT_NO_STYLE_MAC)
+        // The Mac style wants the popup to show up at QPoint(4 - 11, 1).
+        // See QMacStyle::subControlRect SC_ComboBoxListBoxPopup.
+        if (qobject_cast<QMacStyle *>(QApplication::style()))
+            expectedXPosition = qreal(4 - 11);
+#endif
+        QCOMPARE(proxyChild->pos().x(), expectedXPosition);
+        menu->hide();
+    }
+}
+
+void tst_QGraphicsProxyWidget::autoShow()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    QGraphicsProxyWidget *proxy1 = scene.addWidget(new QPushButton("Button1"));
+
+    QPushButton *button2 = new QPushButton("Button2");
+    button2->hide();
+    QGraphicsProxyWidget *proxy2 = new QGraphicsProxyWidget();
+    proxy2->setWidget(button2);
+    scene.addItem(proxy2);
+
+    view.show();
+    QApplication::processEvents();
+
+    QCOMPARE(proxy1->isVisible(), true);
+    QCOMPARE(proxy2->isVisible(), false);
+
+}
+
+Q_DECLARE_METATYPE(QList<QRectF>)
+void tst_QGraphicsProxyWidget::windowOpacity()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    QWidget *widget = new QWidget;
+    widget->resize(100, 100);
+    QGraphicsProxyWidget *proxy = scene.addWidget(widget);
+    proxy->setCacheMode(QGraphicsItem::ItemCoordinateCache);
+
+    QApplication::setActiveWindow(&view);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QApplication::sendPostedEvents();
+    QTRY_VERIFY(view.isActiveWindow());
+
+    qRegisterMetaType<QList<QRectF> >("QList<QRectF>");
+    QSignalSpy signalSpy(&scene, SIGNAL(changed(const QList<QRectF> &)));
+
+    EventSpy eventSpy(widget);
+    QVERIFY(widget->isVisible());
+
+    widget->setWindowOpacity(0.5);
+    QApplication::processEvents();
+
+    // Make sure setWindowOpacity triggers an update on the scene,
+    // and not on the widget or the proxy itself. The entire proxy needs an update
+    // in case it has a window decoration. Update: QGraphicsItem::CacheMode is
+    // disabled on platforms without alpha channel support in QPixmap (e.g.,
+    // X11 without XRender).
+    int paints = 0;
+#ifdef Q_WS_X11
+    paints = !X11->use_xrender;
+#endif
+    QTRY_COMPARE(eventSpy.counts[QEvent::UpdateRequest], 0);
+    QTRY_COMPARE(eventSpy.counts[QEvent::Paint], paints);
+
+    QCOMPARE(signalSpy.count(), 1);
+    const QList<QVariant> arguments = signalSpy.takeFirst();
+    const QList<QRectF> updateRects = qvariant_cast<QList<QRectF> >(arguments.at(0));
+    QCOMPARE(updateRects.size(), 1);
+    QCOMPARE(updateRects.at(0), proxy->sceneBoundingRect());
+}
+
+void tst_QGraphicsProxyWidget::stylePropagation()
+{
+    QPointer<QWindowsStyle> windowsStyle = new QWindowsStyle;
+
+    QLineEdit *edit = new QLineEdit;
+    QGraphicsProxyWidget proxy;
+    proxy.setWidget(edit);
+
+    EventSpy editSpy(edit);
+    EventSpy proxySpy(&proxy);
+
+    // Widget to proxy
+    QCOMPARE(proxy.style(), QApplication::style());
+    edit->setStyle(windowsStyle);
+    QCOMPARE(editSpy.counts[QEvent::StyleChange], 1);
+    QCOMPARE(proxySpy.counts[QEvent::StyleChange], 1);
+    QCOMPARE(proxy.style(), (QStyle *)windowsStyle);
+    edit->setStyle(0);
+    QCOMPARE(editSpy.counts[QEvent::StyleChange], 2);
+    QCOMPARE(proxySpy.counts[QEvent::StyleChange], 2);
+    QCOMPARE(proxy.style(), QApplication::style());
+    QCOMPARE(edit->style(), QApplication::style());
+    QVERIFY(windowsStyle); // not deleted
+
+    // Proxy to widget
+    proxy.setStyle(windowsStyle);
+    QCOMPARE(editSpy.counts[QEvent::StyleChange], 3);
+    QCOMPARE(proxySpy.counts[QEvent::StyleChange], 3);
+    QCOMPARE(edit->style(), (QStyle *)windowsStyle);
+    proxy.setStyle(0);
+    QCOMPARE(editSpy.counts[QEvent::StyleChange], 4);
+    QCOMPARE(proxySpy.counts[QEvent::StyleChange], 4);
+    QCOMPARE(proxy.style(), QApplication::style());
+    QCOMPARE(edit->style(), QApplication::style());
+    QVERIFY(windowsStyle); // not deleted
+
+    delete windowsStyle;
+}
+
+void tst_QGraphicsProxyWidget::palettePropagation()
+{
+    // Construct a palette with an unlikely setup
+    QPalette lineEditPalette = QApplication::palette("QLineEdit");
+    QPalette palette = lineEditPalette;
+    palette.setBrush(QPalette::Text, Qt::red);
+
+    QLineEdit *edit = new QLineEdit;
+    QGraphicsProxyWidget proxy;
+    proxy.setWidget(edit);
+
+    EventSpy editSpy(edit);
+    EventSpy proxySpy(&proxy);
+
+    // Widget to proxy (no change)
+    QVERIFY(!edit->testAttribute(Qt::WA_SetPalette));
+    edit->setPalette(palette);
+    QCOMPARE(editSpy.counts[QEvent::PaletteChange], 1);
+    QCOMPARE(proxySpy.counts[QEvent::PaletteChange], 0);
+    QVERIFY(edit->testAttribute(Qt::WA_SetPalette));
+    QVERIFY(!proxy.testAttribute(Qt::WA_SetPalette));
+    QCOMPARE(proxy.palette(), QPalette());
+    edit->setPalette(QPalette());
+    QCOMPARE(editSpy.counts[QEvent::PaletteChange], 2);
+    QCOMPARE(proxySpy.counts[QEvent::PaletteChange], 0);
+    QVERIFY(!edit->testAttribute(Qt::WA_SetPalette));
+    QVERIFY(!proxy.testAttribute(Qt::WA_SetPalette));
+    QCOMPARE(proxy.palette(), QPalette());
+
+    // Proxy to widget
+    proxy.setPalette(palette);
+    QVERIFY(proxy.testAttribute(Qt::WA_SetPalette));
+    QCOMPARE(editSpy.counts[QEvent::PaletteChange], 3);
+    QCOMPARE(proxySpy.counts[QEvent::PaletteChange], 1);
+    QVERIFY(!edit->testAttribute(Qt::WA_SetPalette));
+    QCOMPARE(edit->palette(), palette);
+    QCOMPARE(edit->palette(), proxy.palette());
+    QCOMPARE(edit->palette().color(QPalette::Text), QColor(Qt::red));
+    proxy.setPalette(QPalette());
+    QVERIFY(!proxy.testAttribute(Qt::WA_SetPalette));
+    QVERIFY(!edit->testAttribute(Qt::WA_SetPalette));
+    QCOMPARE(editSpy.counts[QEvent::PaletteChange], 4);
+    QCOMPARE(proxySpy.counts[QEvent::PaletteChange], 2);
+    QCOMPARE(edit->palette(), lineEditPalette);
+}
+
+void tst_QGraphicsProxyWidget::fontPropagation()
+{
+    // Construct a font with an unlikely setup
+    QGraphicsScene scene;
+    QFont lineEditFont = QApplication::font("QLineEdit");
+    QFont font = lineEditFont;
+    font.setPointSize(43);
+
+    QLineEdit *edit = new QLineEdit;
+    QGraphicsProxyWidget proxy;
+    proxy.setWidget(edit);
+
+    scene.addItem(&proxy);
+    EventSpy editSpy(edit);
+    EventSpy proxySpy(&proxy);
+
+    // Widget to proxy (no change)
+    QVERIFY(!edit->testAttribute(Qt::WA_SetFont));
+    edit->setFont(font);
+    QCOMPARE(editSpy.counts[QEvent::FontChange], 1);
+    QCOMPARE(proxySpy.counts[QEvent::FontChange], 0);
+    QVERIFY(edit->testAttribute(Qt::WA_SetFont));
+    QVERIFY(!proxy.testAttribute(Qt::WA_SetFont));
+    QCOMPARE(proxy.font(), lineEditFont);
+    edit->setFont(QFont());
+    QCOMPARE(editSpy.counts[QEvent::FontChange], 2);
+    QCOMPARE(proxySpy.counts[QEvent::FontChange], 0);
+    QVERIFY(!edit->testAttribute(Qt::WA_SetFont));
+    QVERIFY(!proxy.testAttribute(Qt::WA_SetFont));
+    QCOMPARE(proxy.font(), lineEditFont);
+
+    // Proxy to widget
+    proxy.setFont(font);
+    QApplication::processEvents();  // wait for QEvent::Polish
+    QVERIFY(proxy.testAttribute(Qt::WA_SetFont));
+    QCOMPARE(editSpy.counts[QEvent::FontChange], 3);
+    QCOMPARE(proxySpy.counts[QEvent::FontChange], 1);
+    QVERIFY(!edit->testAttribute(Qt::WA_SetFont));
+    QCOMPARE(edit->font(), font);
+    QCOMPARE(edit->font(), proxy.font());
+    QCOMPARE(edit->font().pointSize(), 43);
+    proxy.setFont(QFont());
+    QVERIFY(!proxy.testAttribute(Qt::WA_SetFont));
+    QVERIFY(!edit->testAttribute(Qt::WA_SetFont));
+    QCOMPARE(editSpy.counts[QEvent::FontChange], 4);
+    QCOMPARE(proxySpy.counts[QEvent::FontChange], 2);
+    QCOMPARE(edit->font(), lineEditFont);
+
+    proxy.setFont(font);
+    QLineEdit *edit2 = new QLineEdit;
+    proxy.setWidget(edit2);
+    delete edit;
+    QCOMPARE(edit2->font().pointSize(), 43);
+}
+
+class MainWidget : public QMainWindow
+{
+Q_OBJECT
+public:
+    MainWidget() : QMainWindow() {
+      view = new QGraphicsView(this);
+      scene = new QGraphicsScene(this);
+      item = new QGraphicsWidget();
+      widget = new QGraphicsProxyWidget(item);
+      layout = new QGraphicsLinearLayout(item);
+      layout->addItem(widget);
+      item->setLayout(layout);
+      button = new QPushButton("Push me");
+      widget->setWidget(button);
+      setCentralWidget(view);
+      scene->addItem(item);
+      view->setScene(scene);
+      scene->setFocusItem(item);
+      layout->activate();
+    }
+    QGraphicsView* view;
+    QGraphicsScene* scene;
+    QGraphicsWidget * item;
+    QGraphicsLinearLayout * layout;
+    QGraphicsProxyWidget * widget;
+    QPushButton * button;
+};
+
+void tst_QGraphicsProxyWidget::dontCrashWhenDie()
+{
+    MainWidget *w = new MainWidget();
+    w->show();
+    QTest::qWaitForWindowShown(w);
+    QTest::qWait(100);
+    QTest::mouseMove(w->view->viewport(), w->view->mapFromScene(w->widget->mapToScene(w->widget->boundingRect().center())));
+    delete w->item;
+
+    QApplication::processEvents();
+    delete w;
+}
+
+void tst_QGraphicsProxyWidget::createProxyForChildWidget()
+{
+    QGraphicsScene scene;
+
+    QLineEdit *edit1 = new QLineEdit;
+    edit1->setText("QLineEdit 1");
+    QLineEdit *edit2 = new QLineEdit;
+    edit2->setText("QLineEdit 2");
+    QCheckBox *checkbox = new QCheckBox("QCheckBox");
+    QVBoxLayout *vlayout = new QVBoxLayout;
+
+    vlayout->addWidget(edit1);
+    vlayout->addWidget(edit2);
+    vlayout->addWidget(checkbox);
+    vlayout->insertStretch(-1);
+
+    QGroupBox *box = new QGroupBox("QGroupBox");
+    box->setCheckable(true);
+    box->setChecked(true);
+    box->setLayout(vlayout);
+
+    QDial *leftDial = new QDial;
+    QDial *rightDial = new QDial;
+
+    QWidget window;
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(leftDial);
+    layout->addWidget(box);
+    layout->addWidget(rightDial);
+    window.setLayout(layout);
+
+    QVERIFY(window.graphicsProxyWidget() == 0);
+    QVERIFY(checkbox->graphicsProxyWidget() == 0);
+
+    QGraphicsProxyWidget *windowProxy = scene.addWidget(&window);
+    QGraphicsView view(&scene);
+    view.show();
+    view.resize(500,500);
+
+    QVERIFY(window.graphicsProxyWidget() == windowProxy);
+    QVERIFY(box->graphicsProxyWidget() == 0);
+    QVERIFY(checkbox->graphicsProxyWidget() == 0);
+
+    QPointer<QGraphicsProxyWidget> checkboxProxy = windowProxy->createProxyForChildWidget(checkbox);
+
+    QGraphicsProxyWidget *boxProxy = box->graphicsProxyWidget();
+
+    QVERIFY(boxProxy);
+    QVERIFY(checkbox->graphicsProxyWidget() == checkboxProxy);
+    QVERIFY(checkboxProxy->parentItem() == boxProxy);
+    QVERIFY(boxProxy->parentItem() == windowProxy);
+
+    QVERIFY(checkboxProxy->mapToScene(QPointF()) == checkbox->mapTo(&window, QPoint()));
+    QVERIFY(checkboxProxy->size() == checkbox->size());
+    QVERIFY(boxProxy->size() == box->size());
+
+    window.resize(500,500);
+    QVERIFY(windowProxy->size() == QSize(500,500));
+    QVERIFY(checkboxProxy->mapToScene(QPointF()) == checkbox->mapTo(&window, QPoint()));
+    QVERIFY(checkboxProxy->size() == checkbox->size());
+    QVERIFY(boxProxy->size() == box->size());
+
+    QTest::qWait(10);
+
+
+    QSignalSpy spy(checkbox, SIGNAL(clicked()));
+
+    QTest::mousePress(view.viewport(), Qt::LeftButton, 0,
+                      view.mapFromScene(checkboxProxy->mapToScene(QPointF(8,8))));
+    QTRY_COMPARE(spy.count(), 0);
+    QTest::mouseRelease(view.viewport(), Qt::LeftButton, 0,
+                        view.mapFromScene(checkboxProxy->mapToScene(QPointF(8,8))));
+    QTRY_COMPARE(spy.count(), 1);
+
+
+
+    boxProxy->setWidget(0);
+
+    QVERIFY(checkbox->graphicsProxyWidget() == 0);
+    QVERIFY(box->graphicsProxyWidget() == 0);
+    QVERIFY(checkboxProxy == 0);
+
+    delete boxProxy;
+}
+
+class ContextMenuWidget : public QWidget
+{
+    Q_OBJECT
+public:
+    ContextMenuWidget()
+        : embeddedPopup(false),
+          gotContextMenuEvent(false)
+    { }
+    bool embeddedPopup;
+    bool gotContextMenuEvent;
+protected:
+    bool event(QEvent *event)
+    {
+        if (event->type() == QEvent::ContextMenu)
+            QTimer::singleShot(0, this, SLOT(checkMenu()));
+        return QWidget::event(event);
+    }
+    void contextMenuEvent(QContextMenuEvent *)
+    {
+        gotContextMenuEvent = true;
+    }
+
+private slots:
+    void checkMenu()
+    {
+        if (qFindChild<QMenu *>(this))
+            embeddedPopup = true;
+        hide();
+    }
+};
+
+void tst_QGraphicsProxyWidget::actionsContextMenu_data()
+{
+    QTest::addColumn<bool>("actionsContextMenu");
+    QTest::addColumn<bool>("hasFocus");
+
+    QTest::newRow("without actionsContextMenu and with focus") << false << true;
+    QTest::newRow("without actionsContextMenu and without focus") << false << false;
+    QTest::newRow("with actionsContextMenu and focus") << true << true;
+    QTest::newRow("with actionsContextMenu without focus") << true << false;
+}
+
+void tst_QGraphicsProxyWidget::actionsContextMenu()
+{
+    QFETCH(bool, hasFocus);
+    QFETCH(bool, actionsContextMenu);
+
+    ContextMenuWidget *widget = new ContextMenuWidget;
+    if (actionsContextMenu) {
+        widget->addAction(new QAction("item 1", widget));
+        widget->addAction(new QAction("item 2", widget));
+        widget->addAction(new QAction("item 3", widget));
+        widget->setContextMenuPolicy(Qt::ActionsContextMenu);
+    }
+    QGraphicsScene scene;
+
+    QGraphicsView view(&scene);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+    view.setFocus();
+    QTRY_VERIFY(view.hasFocus());
+
+    if (hasFocus)
+        scene.addWidget(widget)->setFocus();
+    else
+        scene.addWidget(widget)->clearFocus();
+
+    QApplication::processEvents();
+
+    QContextMenuEvent contextMenuEvent(QContextMenuEvent::Mouse,
+                                       view.viewport()->rect().center(),
+                                       view.viewport()->mapToGlobal(view.viewport()->rect().center()));
+    contextMenuEvent.accept();
+    qApp->sendEvent(view.viewport(), &contextMenuEvent);
+
+    if (hasFocus) {
+        if (actionsContextMenu) {
+            //actionsContextMenu embedded popup but no contextMenuEvent (widget has focus)
+            QVERIFY(widget->embeddedPopup);
+            QVERIFY(!widget->gotContextMenuEvent);
+        } else {
+            //no embedded popup but contextMenuEvent (widget has focus)
+            QVERIFY(!widget->embeddedPopup);
+            QVERIFY(widget->gotContextMenuEvent);
+        }
+    } else {
+        //qgraphicsproxywidget doesn't have the focus, the widget must not receive any contextMenuEvent and must not create any QMenu
+        QVERIFY(!widget->embeddedPopup);
+        QVERIFY(!widget->gotContextMenuEvent);
+    }
+
+}
+
+
+void tst_QGraphicsProxyWidget::deleteProxyForChildWidget()
+{
+    QDialog dialog;
+    dialog.resize(320, 120);
+    dialog.move(80, 40);
+
+    QGraphicsScene scene;
+    scene.setSceneRect(QRectF(0, 0, 640, 480));
+    QGraphicsView view(&scene);
+    QComboBox *combo = new QComboBox;
+    combo->addItems(QStringList() << "red" << "green" << "blue" << "white" << "black" << "yellow" << "cyan" << "magenta");
+    dialog.setLayout(new QVBoxLayout);
+    dialog.layout()->addWidget(combo);
+
+    QGraphicsProxyWidget *proxy = scene.addWidget(&dialog);
+    view.show();
+
+    proxy->setWidget(0);
+    //just don't crash
+    QApplication::processEvents();
+    delete combo;
+}
+
+void tst_QGraphicsProxyWidget::bypassGraphicsProxyWidget_data()
+{
+    QTest::addColumn<bool>("bypass");
+
+    QTest::newRow("autoembed") << false;
+    QTest::newRow("bypass") << true;
+}
+
+void tst_QGraphicsProxyWidget::bypassGraphicsProxyWidget()
+{
+    QFETCH(bool, bypass);
+
+    QWidget *widget = new QWidget;
+    widget->resize(100, 100);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+
+    QGraphicsProxyWidget *proxy = scene.addWidget(widget);
+
+    QCOMPARE(proxy->widget(), widget);
+    QVERIFY(proxy->childItems().isEmpty());
+
+    Qt::WindowFlags flags;
+    flags |= Qt::Dialog;
+    if (bypass)
+        flags |= Qt::BypassGraphicsProxyWidget;
+    QFileDialog *dialog = new QFileDialog(widget, flags);
+    dialog->setOption(QFileDialog::DontUseNativeDialog, true);
+    dialog->show();
+
+    QCOMPARE(proxy->childItems().size(), bypass ? 0 : 1);
+    if (!bypass)
+        QCOMPARE(((QGraphicsProxyWidget *)proxy->childItems().first())->widget(), (QWidget *)dialog);
+
+    dialog->hide();
+    QApplication::processEvents();
+    delete dialog;
+    delete widget;
+}
+
+static void makeDndEvent(QGraphicsSceneDragDropEvent *event, QGraphicsView *view, const QPointF &pos)
+{
+    event->setScenePos(pos);
+    event->setScreenPos(view->mapToGlobal(view->mapFromScene(pos)));
+    event->setButtons(Qt::LeftButton);
+    event->setModifiers(0);
+    event->setPossibleActions(Qt::CopyAction);
+    event->setProposedAction(Qt::CopyAction);
+    event->setDropAction(Qt::CopyAction);
+    event->setWidget(view->viewport());
+    event->setSource(view->viewport());
+    event->ignore();
+}
+
+void tst_QGraphicsProxyWidget::dragDrop()
+{
+    QPushButton *button = new QPushButton; // acceptDrops(false)
+    QLineEdit *edit = new QLineEdit; // acceptDrops(true)
+
+    QGraphicsScene scene;
+    QGraphicsProxyWidget *buttonProxy = scene.addWidget(button);
+    QGraphicsProxyWidget *editProxy = scene.addWidget(edit);
+    QVERIFY(buttonProxy->acceptDrops());
+    QVERIFY(editProxy->acceptDrops());
+
+    button->setGeometry(0, 0, 100, 50);
+    edit->setGeometry(0, 60, 100, 50);
+
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+
+    QMimeData data;
+    data.setText("hei");
+    {
+        QGraphicsSceneDragDropEvent event(QEvent::GraphicsSceneDragEnter);
+        makeDndEvent(&event, &view, QPointF(50, 25));
+        event.setMimeData(&data);
+        qApp->sendEvent(&scene, &event);
+        QVERIFY(event.isAccepted());
+    }
+    {
+        QGraphicsSceneDragDropEvent event(QEvent::GraphicsSceneDragMove);
+        makeDndEvent(&event, &view, QPointF(50, 25));
+        event.setMimeData(&data);
+        qApp->sendEvent(&scene, &event);
+        QVERIFY(!event.isAccepted());
+    }
+    {
+        QGraphicsSceneDragDropEvent event(QEvent::GraphicsSceneDragMove);
+        makeDndEvent(&event, &view, QPointF(50, 75));
+        event.setMimeData(&data);
+        qApp->sendEvent(&scene, &event);
+        QVERIFY(event.isAccepted());
+    }
+    {
+        QGraphicsSceneDragDropEvent event(QEvent::GraphicsSceneDrop);
+        makeDndEvent(&event, &view, QPointF(50, 75));
+        event.setMimeData(&data);
+        qApp->sendEvent(&scene, &event);
+        QVERIFY(event.isAccepted());
+    }
+    QCOMPARE(edit->text(), QString("hei"));
+}
+
+void tst_QGraphicsProxyWidget::windowFlags_data()
+{
+    QTest::addColumn<int>("proxyFlags");
+    QTest::addColumn<int>("widgetFlags");
+    QTest::addColumn<int>("resultingProxyFlags");
+    QTest::addColumn<int>("resultingWidgetFlags");
+
+    QTest::newRow("proxy(0) widget(0)") << 0 << 0 << 0 << int(Qt::Window);
+    QTest::newRow("proxy(window)") << int(Qt::Window) << 0 << int(Qt::Window) << int(Qt::Window);
+    QTest::newRow("proxy(window) widget(window)") << int(Qt::Window) << int(Qt::Window) << int(Qt::Window) << int(Qt::Window);
+    QTest::newRow("proxy(0) widget(window)") << int(0) << int(Qt::Window) << int(0) << int(Qt::Window);
+}
+
+void tst_QGraphicsProxyWidget::windowFlags()
+{
+    QFETCH(int, proxyFlags);
+    QFETCH(int, widgetFlags);
+    QFETCH(int, resultingProxyFlags);
+    QFETCH(int, resultingWidgetFlags);
+    Qt::WindowFlags proxyWFlags = Qt::WindowFlags(proxyFlags);
+    Qt::WindowFlags widgetWFlags = Qt::WindowFlags(widgetFlags);
+    Qt::WindowFlags resultingProxyWFlags = Qt::WindowFlags(resultingProxyFlags);
+    Qt::WindowFlags resultingWidgetWFlags = Qt::WindowFlags(resultingWidgetFlags);
+
+    QGraphicsProxyWidget proxy(0, proxyWFlags);
+    QVERIFY((proxy.windowFlags() & proxyWFlags) == proxyWFlags);
+
+    QWidget *widget = new QWidget(0, widgetWFlags);
+    QVERIFY((widget->windowFlags() & widgetWFlags) == widgetWFlags);
+
+    proxy.setWidget(widget);
+
+    if (resultingProxyFlags == 0)
+        QVERIFY(!proxy.windowFlags());
+    else
+        QVERIFY((proxy.windowFlags() & resultingProxyWFlags) == resultingProxyWFlags);
+    QVERIFY((widget->windowFlags() & resultingWidgetWFlags) == resultingWidgetWFlags);
+}
+
+void tst_QGraphicsProxyWidget::comboboxWindowFlags()
+{
+    QComboBox *comboBox = new QComboBox;
+    comboBox->addItem("Item 1");
+    comboBox->addItem("Item 2");
+    comboBox->addItem("Item 3");
+    QWidget *embedWidget = comboBox;
+
+    QGraphicsScene scene;
+    QGraphicsProxyWidget *proxy = scene.addWidget(embedWidget);
+    proxy->setWindowFlags(Qt::Window);
+    QVERIFY(embedWidget->isWindow());
+    QVERIFY(proxy->isWindow());
+
+    comboBox->showPopup();
+
+    QCOMPARE(proxy->childItems().size(), 1);
+    QGraphicsItem *popupProxy = proxy->childItems().first();
+    QVERIFY(popupProxy->isWindow());
+    QVERIFY((static_cast<QGraphicsWidget *>(popupProxy)->windowFlags() & Qt::Popup) == Qt::Popup);
+}
+
+void tst_QGraphicsProxyWidget::updateAndDelete()
+{
+    QGraphicsScene scene;
+    QGraphicsProxyWidget *proxy = scene.addWidget(new QPushButton("Hello World"));
+    View view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTRY_VERIFY(view.npaints > 0);
+
+    const QRect itemDeviceBoundingRect = proxy->deviceTransform(view.viewportTransform())
+                                         .mapRect(proxy->boundingRect()).toRect();
+    const QRegion expectedRegion = itemDeviceBoundingRect.adjusted(-2, -2, 2, 2);
+
+    view.npaints = 0;
+    view.paintEventRegion = QRegion();
+
+    // Update and hide.
+    proxy->update();
+    proxy->hide();
+    QTRY_COMPARE(view.npaints, 1);
+    QCOMPARE(view.paintEventRegion, expectedRegion);
+
+    proxy->show();
+    QTest::qWait(50);
+    view.npaints = 0;
+    view.paintEventRegion = QRegion();
+
+    // Update and delete.
+    proxy->update();
+    delete proxy;
+    QTRY_COMPARE(view.npaints, 1);
+    QCOMPARE(view.paintEventRegion, expectedRegion);
+}
+
+class InputMethod_LineEdit : public QLineEdit
+{
+    bool event(QEvent *e)
+    {
+        if (e->type() == QEvent::InputMethod)
+            ++inputMethodEvents;
+        return QLineEdit::event(e);
+    }
+public:
+    int inputMethodEvents;
+};
+
+void tst_QGraphicsProxyWidget::inputMethod()
+{
+    QGraphicsScene scene;
+
+    // check that the proxy is initialized with the correct input method sensitivity
+    for (int i = 0; i < 2; ++i)
+    {
+        QLineEdit *lineEdit = new QLineEdit;
+        lineEdit->setAttribute(Qt::WA_InputMethodEnabled, !!i);
+        QGraphicsProxyWidget *proxy = scene.addWidget(lineEdit);
+        QCOMPARE(!!(proxy->flags() & QGraphicsItem::ItemAcceptsInputMethod), !!i);
+    }
+
+    // check that input method events are only forwarded to widgets with focus
+    for (int i = 0; i < 2; ++i)
+    {
+        InputMethod_LineEdit *lineEdit = new InputMethod_LineEdit;
+        lineEdit->setAttribute(Qt::WA_InputMethodEnabled, true);
+        QGraphicsProxyWidget *proxy = scene.addWidget(lineEdit);
+
+        if (i)
+            lineEdit->setFocus();
+
+        lineEdit->inputMethodEvents = 0;
+        QInputMethodEvent event;
+        qApp->sendEvent(proxy, &event);
+        QCOMPARE(lineEdit->inputMethodEvents, i);
+    }
+
+    scene.clear();
+    QGraphicsView view(&scene);
+    QWidget *w = new QWidget;
+    w->setLayout(new QVBoxLayout(w));
+    QLineEdit *lineEdit = new QLineEdit;
+    lineEdit->setEchoMode(QLineEdit::Password);
+    w->layout()->addWidget(lineEdit);
+    lineEdit->setAttribute(Qt::WA_InputMethodEnabled, true);
+    QGraphicsProxyWidget *proxy = scene.addWidget(w);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(!(proxy->flags() & QGraphicsItem::ItemAcceptsInputMethod));
+    lineEdit->setFocus();
+    QVERIFY((proxy->flags() & QGraphicsItem::ItemAcceptsInputMethod));
+}
+
+void tst_QGraphicsProxyWidget::clickFocus()
+{
+    QGraphicsScene scene;
+    scene.setItemIndexMethod(QGraphicsScene::NoIndex);
+    QGraphicsProxyWidget *proxy = scene.addWidget(new QLineEdit);
+
+    QGraphicsView view(&scene);
+
+    {
+        EventSpy proxySpy(proxy);
+        EventSpy widgetSpy(proxy->widget());
+
+        view.setFrameStyle(0);
+        view.resize(300, 300);
+        view.show();
+#ifdef Q_WS_X11
+        qt_x11_wait_for_window_manager(&view);
+#endif
+        QApplication::setActiveWindow(&view);
+        QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+
+        QVERIFY(!proxy->hasFocus());
+        QVERIFY(!proxy->widget()->hasFocus());
+
+        QCOMPARE(proxySpy.counts[QEvent::FocusIn], 0);
+        QCOMPARE(proxySpy.counts[QEvent::FocusOut], 0);
+        QCOMPARE(widgetSpy.counts[QEvent::FocusIn], 0);
+        QCOMPARE(widgetSpy.counts[QEvent::FocusOut], 0);
+
+        QPointF lineEditCenter = proxy->mapToScene(proxy->boundingRect().center());
+        // Spontaneous mouse click sets focus on a clickable widget.
+        for (int retry = 0; retry < 50 && !proxy->hasFocus(); retry++)
+            QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(lineEditCenter));
+        QVERIFY(proxy->hasFocus());
+        QVERIFY(proxy->widget()->hasFocus());
+        QCOMPARE(proxySpy.counts[QEvent::FocusIn], 1);
+        QCOMPARE(widgetSpy.counts[QEvent::FocusIn], 1);
+
+        scene.setFocusItem(0);
+        QVERIFY(!proxy->hasFocus());
+        QVERIFY(!proxy->widget()->hasFocus());
+        QCOMPARE(proxySpy.counts[QEvent::FocusOut], 1);
+        QCOMPARE(widgetSpy.counts[QEvent::FocusOut], 1);
+
+        // Non-spontaneous mouse click sets focus if the widget has been clicked before
+        {
+            QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+            event.setScenePos(lineEditCenter);
+            event.setButton(Qt::LeftButton);
+            qApp->sendEvent(&scene, &event);
+            QVERIFY(proxy->hasFocus());
+            QVERIFY(proxy->widget()->hasFocus());
+            QCOMPARE(proxySpy.counts[QEvent::FocusIn], 2);
+            QCOMPARE(widgetSpy.counts[QEvent::FocusIn], 2);
+        }
+    }
+
+    scene.setFocusItem(0);
+    proxy->setWidget(new QLineEdit); // resets focusWidget
+
+    {
+        QPointF lineEditCenter = proxy->mapToScene(proxy->boundingRect().center());
+        EventSpy proxySpy(proxy);
+        EventSpy widgetSpy(proxy->widget());
+        QVERIFY(!proxy->hasFocus());
+        QVERIFY(!proxy->widget()->hasFocus());
+        QCOMPARE(proxySpy.counts[QEvent::FocusOut], 0);
+        QCOMPARE(widgetSpy.counts[QEvent::FocusOut], 0);
+
+        // Non-spontaneous mouse click does not set focus on the embedded widget.
+        {
+            QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+            event.setScenePos(lineEditCenter);
+            event.setButton(Qt::LeftButton);
+            qApp->sendEvent(&scene, &event);
+            QVERIFY(!proxy->hasFocus());
+            QVERIFY(!proxy->widget()->hasFocus());
+            QCOMPARE(proxySpy.counts[QEvent::FocusIn], 0);
+            QCOMPARE(widgetSpy.counts[QEvent::FocusIn], 0);
+        }
+
+        scene.setFocusItem(0);
+        QVERIFY(!proxy->hasFocus());
+        QVERIFY(!proxy->widget()->hasFocus());
+        QCOMPARE(proxySpy.counts[QEvent::FocusOut], 0);
+        QCOMPARE(widgetSpy.counts[QEvent::FocusOut], 0);
+
+        // Spontaneous click on non-clickable widget does not give focus.
+        proxy->widget()->setFocusPolicy(Qt::NoFocus);
+        QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(lineEditCenter));
+        QVERIFY(!proxy->hasFocus());
+        QVERIFY(!proxy->widget()->hasFocus());
+
+        // Multiple clicks should only result in one FocusIn.
+        proxy->widget()->setFocusPolicy(Qt::StrongFocus);
+        scene.setFocusItem(0);
+        QVERIFY(!proxy->hasFocus());
+        QVERIFY(!proxy->widget()->hasFocus());
+        QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(lineEditCenter));
+        QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(lineEditCenter));
+        QVERIFY(proxy->hasFocus());
+        QVERIFY(proxy->widget()->hasFocus());
+        QCOMPARE(widgetSpy.counts[QEvent::FocusIn], 1);
+        QCOMPARE(proxySpy.counts[QEvent::FocusIn], 1);
+    }
+}
+
+void tst_QGraphicsProxyWidget::windowFrameMargins()
+{
+    // Make sure the top margin is non-zero when passing Qt::Window.
+    QGraphicsProxyWidget *proxy = new QGraphicsProxyWidget(0, Qt::Window);
+
+    qreal left, top, right, bottom;
+    proxy->getWindowFrameMargins(&left, &top, &right, &bottom);
+    QVERIFY(top > 0);
+
+    proxy->setWidget(new QPushButton("testtest"));
+    proxy->getWindowFrameMargins(&left, &top, &right, &bottom);
+    QVERIFY(top > 0);
+
+    QGraphicsScene scene;
+    scene.addItem(proxy);
+    proxy->getWindowFrameMargins(&left, &top, &right, &bottom);
+    QVERIFY(top > 0);
+
+    proxy->unsetWindowFrameMargins();
+    proxy->getWindowFrameMargins(&left, &top, &right, &bottom);
+    QVERIFY(top > 0);
+}
+
+class HoverButton : public QPushButton
+{
+public:
+    HoverButton(QWidget *parent = 0) : QPushButton(parent), hoverLeaveReceived(false)
+    {}
+
+    bool hoverLeaveReceived;
+
+    bool event(QEvent* e)
+    {
+        if(QEvent::HoverLeave == e->type())
+            hoverLeaveReceived = true;
+        return QPushButton::event(e);
+    }
+};
+
+class Scene : public QGraphicsScene
+{
+Q_OBJECT
+public:
+    Scene() {
+        QWidget *background = new QWidget;
+        background->setGeometry(0, 0, 500, 500);
+        hoverButton = new HoverButton;
+        hoverButton->setParent(background);
+        hoverButton->setText("Second button");
+        hoverButton->setGeometry(10, 10, 200, 50);
+        addWidget(background);
+
+        QPushButton *hideButton = new QPushButton("I'm a button with a very very long text");
+        hideButton->setGeometry(10, 10, 400, 50);
+        topButton = addWidget(hideButton);
+        connect(hideButton, SIGNAL(clicked()), this, SLOT(hideButton()));
+        topButton->setFocus();
+    }
+
+    QGraphicsProxyWidget *topButton;
+    HoverButton *hoverButton;
+
+public slots:
+    void hideButton() {
+       QCursor::setPos(600,600);
+       topButton->hide();
+    }
+};
+
+void tst_QGraphicsProxyWidget::QTBUG_6986_sendMouseEventToAlienWidget()
+{
+#if defined(Q_OS_MAC) || defined(Q_OS_WIN) || defined(QT_NO_CURSOR)
+    QSKIP("Test case unstable on this platform", SkipAll);
+#endif
+    QGraphicsView view;
+    Scene scene;
+    view.setScene(&scene);
+    view.resize(600, 600);
+    QApplication::setActiveWindow(&view);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), &view);
+    QCursor::setPos(view.mapToGlobal(view.mapFromScene(scene.topButton->boundingRect().center())));
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, view.mapFromScene(scene.topButton->scenePos()));
+    QTRY_COMPARE(scene.hoverButton->hoverLeaveReceived, true);
+}
+
+QTEST_MAIN(tst_QGraphicsProxyWidget)
+#include "tst_qgraphicsproxywidget.moc"
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/.gitignore b/tests/auto/widgets/graphicsview/qgraphicsscene/.gitignore
new file mode 100644
index 0000000000..df1097ad74
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/.gitignore
@@ -0,0 +1 @@
+tst_qgraphicsscene
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/Ash_European.jpg b/tests/auto/widgets/graphicsview/qgraphicsscene/Ash_European.jpg
new file mode 100644
index 0000000000..8581d322ba
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/Ash_European.jpg
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/graphicsScene_selection.data b/tests/auto/widgets/graphicsview/qgraphicsscene/graphicsScene_selection.data
new file mode 100644
index 0000000000..8ff3feebb1
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/graphicsScene_selection.data
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/images.qrc b/tests/auto/widgets/graphicsview/qgraphicsscene/images.qrc
new file mode 100644
index 0000000000..cac10bef82
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/images.qrc
@@ -0,0 +1,5 @@
+<!DOCTYPE RCC><RCC version="1.0">
+<qresource>
+   <file>Ash_European.jpg</file>
+</qresource>
+</RCC>
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/qgraphicsscene.pro b/tests/auto/widgets/graphicsview/qgraphicsscene/qgraphicsscene.pro
new file mode 100644
index 0000000000..75b4d84fb4
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/qgraphicsscene.pro
@@ -0,0 +1,20 @@
+load(qttest_p4)
+QT += widgets widgets-private
+QT += core-private gui-private
+SOURCES  += tst_qgraphicsscene.cpp
+RESOURCES += images.qrc
+win32:!wince*: LIBS += -lUser32
+
+!wince*:DEFINES += SRCDIR=\\\"$$PWD\\\"
+DEFINES += QT_NO_CAST_TO_ASCII
+
+wince* {
+   rootFiles.files = Ash_European.jpg graphicsScene_selection.data
+   rootFiles.path = .
+   renderFiles.files = testData\\render\\*
+   renderFiles.path = testData\\render
+   DEPLOYMENT += rootFiles renderFiles
+   DEFINES += SRCDIR=\\\".\\\"
+}
+
+contains(QT_CONFIG,xcb):qpa:CONFIG+=insignificant_test  # QTBUG-20756 crashes on qpa, xcb
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-45-deg-left.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-45-deg-left.png
new file mode 100644
index 0000000000..526b897c1c
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-45-deg-left.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-45-deg-right.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-45-deg-right.png
new file mode 100644
index 0000000000..83563872c1
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-45-deg-right.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-scale-2x.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-scale-2x.png
new file mode 100644
index 0000000000..a929621bca
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-scale-2x.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-translate-0-50.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-translate-0-50.png
new file mode 100644
index 0000000000..aeaf20ae41
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-translate-0-50.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-translate-50-0.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-translate-50-0.png
new file mode 100644
index 0000000000..ed80dba118
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-translate-50-0.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-untransformed-clip-ellipse.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-untransformed-clip-ellipse.png
new file mode 100644
index 0000000000..9b401b41c7
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-untransformed-clip-ellipse.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-untransformed-clip-rect.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-untransformed-clip-rect.png
new file mode 100644
index 0000000000..1c5969870d
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-untransformed-clip-rect.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-untransformed.png
new file mode 100644
index 0000000000..3592744bda
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-all-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-bottomleft-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-bottomleft-untransformed.png
new file mode 100644
index 0000000000..ab15e7228b
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-bottomleft-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-bottomright-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-bottomright-untransformed.png
new file mode 100644
index 0000000000..82e25762fa
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-bottomright-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-topleft-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-topleft-untransformed.png
new file mode 100644
index 0000000000..934ee4679b
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-topleft-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-topright-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-topright-untransformed.png
new file mode 100644
index 0000000000..aced485c75
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/all-topright-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottom-bottomright-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottom-bottomright-untransformed.png
new file mode 100644
index 0000000000..5df8ab0612
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottom-bottomright-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottom-topleft-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottom-topleft-untransformed.png
new file mode 100644
index 0000000000..bb04881763
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottom-topleft-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottomleft-all-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottomleft-all-untransformed.png
new file mode 100644
index 0000000000..907dec647d
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottomleft-all-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottomleft-topleft-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottomleft-topleft-untransformed.png
new file mode 100644
index 0000000000..d37313c06d
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottomleft-topleft-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottomright-all-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottomright-all-untransformed.png
new file mode 100644
index 0000000000..9fbafe48d5
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottomright-all-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottomright-topleft-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottomright-topleft-untransformed.png
new file mode 100644
index 0000000000..1d0253796e
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/bottomright-topleft-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/left-bottomright-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/left-bottomright-untransformed.png
new file mode 100644
index 0000000000..bcfda9968b
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/left-bottomright-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/left-topleft-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/left-topleft-untransformed.png
new file mode 100644
index 0000000000..b443a4f991
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/left-topleft-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/right-bottomright-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/right-bottomright-untransformed.png
new file mode 100644
index 0000000000..e6922e0920
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/right-bottomright-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/right-topleft-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/right-topleft-untransformed.png
new file mode 100644
index 0000000000..a74f218876
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/right-topleft-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/top-bottomright-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/top-bottomright-untransformed.png
new file mode 100644
index 0000000000..6c51907a6d
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/top-bottomright-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/top-topleft-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/top-topleft-untransformed.png
new file mode 100644
index 0000000000..0a37133e31
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/top-topleft-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/topleft-all-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/topleft-all-untransformed.png
new file mode 100644
index 0000000000..edc7dc9ce6
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/topleft-all-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/topleft-topleft-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/topleft-topleft-untransformed.png
new file mode 100644
index 0000000000..e37051f7d2
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/topleft-topleft-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/topright-all-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/topright-all-untransformed.png
new file mode 100644
index 0000000000..a185d14ebd
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/topright-all-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/topright-topleft-untransformed.png b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/topright-topleft-untransformed.png
new file mode 100644
index 0000000000..42e07f11ea
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/testData/render/topright-topleft-untransformed.png
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/tst_qgraphicsscene.cpp b/tests/auto/widgets/graphicsview/qgraphicsscene/tst_qgraphicsscene.cpp
new file mode 100644
index 0000000000..9ac1573b2a
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/tst_qgraphicsscene.cpp
@@ -0,0 +1,4710 @@
+/****************************************************************************
+**
+** 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>
+#if defined(Q_OS_WINCE)
+#include <ceconfig.h>
+#endif
+
+#include <QtGui>
+#include <QtWidgets>
+#include <private/qgraphicsscene_p.h>
+#include <private/qgraphicssceneindex_p.h>
+#include <math.h>
+#include "../../../gui/painting/qpathclipper/pathcompare.h"
+
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+#include <windows.h>
+#define Q_CHECK_PAINTEVENTS \
+    if (::SwitchDesktop(::GetThreadDesktop(::GetCurrentThreadId())) == 0) \
+        QSKIP("The Graphics View doesn't get the paint events", SkipSingle);
+#else
+#define Q_CHECK_PAINTEVENTS
+#endif
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+Q_DECLARE_METATYPE(QList<int>)
+Q_DECLARE_METATYPE(QList<QRectF>)
+Q_DECLARE_METATYPE(QMatrix)
+Q_DECLARE_METATYPE(QPainterPath)
+Q_DECLARE_METATYPE(QPointF)
+Q_DECLARE_METATYPE(QRectF)
+Q_DECLARE_METATYPE(Qt::AspectRatioMode)
+Q_DECLARE_METATYPE(Qt::ItemSelectionMode)
+
+static const int randomX[] = {276, 40, 250, 864, -56, 426, 855, 825, 184, 955, -798, -804, 773,
+                              282, 489, 686, 780, -220, 50, 749, -856, -205, 81, 492, -819, 518,
+                              895, 57, -559, 788, -965, 68, -442, -247, -339, -648, 292, 891,
+                              -865, 462, 864, 673, 640, 523, 194, 500, -727, 307, -243, 320,
+                              -545, 415, 448, 341, -619, 652, 892, -16, -14, -659, -101, -934,
+                              532, 356, 824, 132, 160, 130, 104, 886, -179, -174, 543, -644, 60,
+                              -470, -354, -728, 689, 682, -587, -694, -221, -741, 37, 372, -289,
+                              741, -300, 858, -320, 729, -602, -956, -544, -403, 203, 398, 284,
+                              -972, -572, -946, 81, 51, -403, -580, 867, 546, 565, -580, -484,
+                              659, 982, -518, -976, 423, -800, 659, -297, 712, 938, -19, -16,
+                              824, -252, 197, 321, -837, 824, 136, 226, -980, -909, -826, -479,
+                              -835, -503, -828, -901, -810, -641, -548, -179, 194, 749, -296, 539,
+                              -37, -599, -235, 121, 35, -230, -915, 789, 764, -622, -382, -90, -701,
+                              676, -407, 998, 267, 913, 817, -748, -370, -162, -797, 19, -556, 933,
+                              -670, -101, -765, -941, -17, 360, 31, 960, 509, 933, -35, 974, -924,
+                              -734, 589, 963, 724, 794, 843, 16, -272, -811, 721, 99, -122, 216,
+                              -404, 158, 787, -443, -437, -337, 383, -342, 538, -641, 791, 637,
+                              -848, 397, 820, 109, 11, 45, 809, 591, 933, 961, 625, -140, -592,
+                              -694, -969, 317, 293, 777, -18, -282, 835, -455, -708, -407, -204,
+                              748, 347, -501, -545, 292, -362, 176, 546, -573, -38, -854, -395,
+                              560, -624, -940, -971, 66, -910, 782, 985};
+
+static const int randomY[] = {603, 70, -318, 843, 450, -637, 199, -527, 407, 964, -54, 620, -207,
+                              -736, -700, -476, -706, -142, 837, 621, 522, -98, 232, 292, -267, 900,
+                              615, -356, -415, 783, 290, 462, -857, -314, 677, 36, 772, 424, -72,
+                              -121, 547, -533, 537, -656, 289, 508, 914, 601, 434, 588, -779, -714,
+                              -368, 628, -276, 432, -1, -929, 638, -36, 253, -922, -943, 979, -34,
+                              -268, -193, 601, 686, -330, 165, 98, 75, -691, -605, 617, 773, 617,
+                              619, 238, -42, -405, 17, 384, -472, -846, 520, 110, 591, -217, 936,
+                              -373, 731, 734, 810, 961, 881, 939, 379, -905, -137, 437, 298, 688,
+                              -71, -204, 573, -120, -821, 489, -722, -926, 529, -113, -243, 543,
+                              868, -301, -781, -549, -842, -489, -80, -910, -928, 51, -91, 324,
+                              204, -92, 867, 723, 248, 709, -357, 591, -365, -379, 266, -649, -95,
+                              205, 551, 355, -631, 79, -186, 795, -7, -225, 46, -410, 665, -874,
+                              -618, 845, -548, 443, 471, -644, 606, -607, 59, -619, 288, -244, 529,
+                              690, 349, -738, -611, -879, -642, 801, -178, 823, -748, -552, -247,
+                              -223, -408, 651, -62, 949, -795, 171, -107, -210, -207, -842, -86,
+                              436, 528, 366, -178, 245, -695, 665, 613, -948, 667, -620, -979, -949,
+                              905, 181, -412, -467, -437, -774, 750, -10, 54, 205, -674, -290, -924,
+                              -361, -463, 912, -702, 622, -542, 220, 115, 832, 451, -38, -952, -230,
+                              -588, 864, 234, 225, -303, 493, 246, 153, 338, -378, 377, -819, 140, 136,
+                              467, -849, -326, -533, 166, 252, -994, -699, 904, -566, 621, -752};
+
+class HoverItem : public QGraphicsRectItem
+{
+public:
+    HoverItem()
+        : QGraphicsRectItem(QRectF(-10, -10, 20, 20)), isHovered(false)
+    { setAcceptsHoverEvents(true); }
+
+    bool isHovered;
+
+protected:
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *)
+    {
+        isHovered = (option->state & QStyle::State_MouseOver);
+
+        painter->setOpacity(0.75);
+        painter->setPen(Qt::NoPen);
+        painter->setBrush(Qt::darkGray);
+        painter->drawRoundRect(boundingRect().adjusted(3, 3, -3, -3), Qt::darkGray);
+        painter->setPen(Qt::black);
+        if (isHovered) {
+            painter->setBrush(QColor(Qt::blue).light(120));
+        } else {
+            painter->setBrush(Qt::gray);
+        }
+        painter->drawRoundRect(boundingRect().adjusted(0, 0, -5, -5));
+    }
+};
+
+class EventSpy : public QGraphicsWidget
+{
+    Q_OBJECT
+public:
+    EventSpy(QObject *watched, QEvent::Type type)
+        : _count(0), spied(type)
+    {
+        watched->installEventFilter(this);
+    }
+
+    EventSpy(QGraphicsScene *scene, QGraphicsItem *watched, QEvent::Type type)
+        : _count(0), spied(type)
+    {
+        scene->addItem(this);
+        watched->installSceneEventFilter(this);
+    }
+
+    int count() const { return _count; }
+
+protected:
+    bool eventFilter(QObject *watched, QEvent *event)
+    {
+        Q_UNUSED(watched);
+        if (event->type() == spied)
+            ++_count;
+        return false;
+    }
+
+    bool sceneEventFilter(QGraphicsItem *watched, QEvent *event)
+    {
+        Q_UNUSED(watched);
+        if (event->type() == spied)
+            ++_count;
+        return false;
+    }
+
+    int _count;
+    QEvent::Type spied;
+};
+
+class tst_QGraphicsScene : public QObject
+{
+    Q_OBJECT
+public slots:
+    void initTestCase();
+
+private slots:
+    void construction();
+    void sceneRect();
+    void itemIndexMethod();
+    void bspTreeDepth();
+    void itemsBoundingRect_data();
+    void itemsBoundingRect();
+    void items();
+    void items_QPointF_data();
+    void items_QPointF();
+    void items_QRectF();
+    void items_QRectF_2_data();
+    void items_QRectF_2();
+    void items_QPolygonF();
+    void items_QPolygonF_2();
+    void items_QPainterPath();
+    void items_QPainterPath_2();
+    void selection();
+    void selectionChanged();
+    void selectionChanged2();
+    void addItem();
+    void addEllipse();
+    void addLine();
+    void addPath();
+    void addPixmap();
+    void addRect();
+    void addText();
+#if !defined(Q_OS_WINCE) || defined(GWES_ICONCURS)
+    void removeItem();
+#endif
+    void clear();
+    void focusItem();
+    void focusItemLostFocus();
+    void setFocusItem();
+    void setFocusItem_inactive();
+    void mouseGrabberItem();
+    void hoverEvents_siblings();
+    void hoverEvents_parentChild();
+    void createItemGroup();
+    void mouseEventPropagation();
+    void mouseEventPropagation_ignore();
+    void mouseEventPropagation_focus();
+    void mouseEventPropagation_doubleclick();
+    void mouseEventPropagation_mouseMove();
+#ifndef QT_NO_DRAGANDDROP
+    void dragAndDrop_simple();
+    void dragAndDrop_disabledOrInvisible();
+    void dragAndDrop_propagate();
+#endif
+    void render_data();
+    void render();
+    void renderItemsWithNegativeWidthOrHeight();
+    void contextMenuEvent();
+    void contextMenuEvent_ItemIgnoresTransformations();
+    void update();
+    void update2();
+    void views();
+    void event();
+    void eventsToDisabledItems();
+    void exposedRect();
+    void tabFocus_emptyScene();
+    void tabFocus_sceneWithFocusableItems();
+    void tabFocus_sceneWithFocusWidgets();
+    void tabFocus_sceneWithNestedFocusWidgets();
+    void style();
+    void sorting_data();
+    void sorting();
+    void changedSignal_data();
+    void changedSignal();
+    void stickyFocus_data();
+    void stickyFocus();
+    void sendEvent();
+    void inputMethod_data();
+    void inputMethod();
+    void dispatchHoverOnPress();
+    void initialFocus_data();
+    void initialFocus();
+    void polishItems();
+    void polishItems2();
+    void isActive();
+    void siblingIndexAlwaysValid();
+    void removeFullyTransparentItem();
+    void zeroScale();
+
+    // task specific tests below me
+    void task139710_bspTreeCrash();
+    void task139782_containsItemBoundingRect();
+    void task176178_itemIndexMethodBreaksSceneRect();
+    void task160653_selectionChanged();
+    void task250680_childClip();
+    void taskQTBUG_5904_crashWithDeviceCoordinateCache();
+    void taskQT657_paintIntoCacheWithTransparentParts();
+    void taskQTBUG_7863_paintIntoCacheWithTransparentParts();
+    void taskQT_3674_doNotCrash();
+    void taskQTBUG_15977_renderWithDeviceCoordinateCache();
+    void taskQTBUG_16401_focusItem();
+};
+
+void tst_QGraphicsScene::initTestCase()
+{
+#ifdef Q_OS_WINCE //disable magic for WindowsCE
+    qApp->setAutoMaximizeThreshold(-1);
+#endif
+}
+
+void tst_QGraphicsScene::construction()
+{
+    QGraphicsScene scene;
+    QCOMPARE(scene.itemsBoundingRect(), QRectF());
+    QVERIFY(scene.items().isEmpty());
+    QVERIFY(scene.items(QPointF()).isEmpty());
+    QVERIFY(scene.items(QRectF()).isEmpty());
+    QVERIFY(scene.items(QPolygonF()).isEmpty());
+    QVERIFY(scene.items(QPainterPath()).isEmpty());
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsScene::collidingItems: cannot find collisions for null item");
+    QVERIFY(scene.collidingItems(0).isEmpty());
+    QVERIFY(!scene.itemAt(QPointF()));
+    QVERIFY(scene.selectedItems().isEmpty());
+    QVERIFY(!scene.focusItem());
+}
+
+void tst_QGraphicsScene::sceneRect()
+{
+    QGraphicsScene scene;
+    QSignalSpy sceneRectChanged(&scene, SIGNAL(sceneRectChanged(QRectF)));
+    QCOMPARE(scene.sceneRect(), QRectF());
+    QCOMPARE(sceneRectChanged.count(), 0);
+
+    QGraphicsItem *item = scene.addRect(QRectF(0, 0, 10, 10));
+    item->setPos(-5, -5);
+    QCOMPARE(sceneRectChanged.count(), 0);
+
+    QCOMPARE(scene.itemAt(0, 0), item);
+    QCOMPARE(scene.itemAt(10, 10), (QGraphicsItem *)0);
+    QCOMPARE(sceneRectChanged.count(), 0);
+    QCOMPARE(scene.sceneRect(), QRectF(-5, -5, 10, 10));
+    QCOMPARE(sceneRectChanged.count(), 1);
+    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());
+
+    item->setPos(0, 0);
+    QCOMPARE(scene.sceneRect(), QRectF(-5, -5, 15, 15));
+    QCOMPARE(sceneRectChanged.count(), 2);
+    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());
+
+    scene.setSceneRect(-100, -100, 10, 10);
+    QCOMPARE(sceneRectChanged.count(), 3);
+    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());
+
+    QCOMPARE(scene.itemAt(0, 0), item);
+    QCOMPARE(scene.itemAt(10, 10), (QGraphicsItem *)0);
+    QCOMPARE(scene.sceneRect(), QRectF(-100, -100, 10, 10));
+    item->setPos(10, 10);
+    QCOMPARE(scene.sceneRect(), QRectF(-100, -100, 10, 10));
+    QCOMPARE(sceneRectChanged.count(), 3);
+    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());
+
+    scene.setSceneRect(QRectF());
+
+    QCOMPARE(scene.itemAt(10, 10), item);
+    QCOMPARE(scene.itemAt(20, 20), (QGraphicsItem *)0);
+    QCOMPARE(sceneRectChanged.count(), 4);
+    QCOMPARE(scene.sceneRect(), QRectF(-5, -5, 25, 25));
+    QCOMPARE(sceneRectChanged.count(), 5);
+    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());
+}
+
+void tst_QGraphicsScene::itemIndexMethod()
+{
+    QGraphicsScene scene;
+    QCOMPARE(scene.itemIndexMethod(), QGraphicsScene::BspTreeIndex);
+
+#ifdef QT_ARCH_ARM
+    const int minY = -500;
+    const int maxY = 500;
+    const int minX = -500;
+    const int maxX = 500;
+#else
+    const int minY = -1000;
+    const int maxY = 2000;
+    const int minX = -1000;
+    const int maxX = 2000;
+#endif
+
+    QList<QGraphicsItem *> items;
+    for (int y = minY; y < maxY; y += 100) {
+        for (int x = minX; x < maxX; x += 100) {
+            QGraphicsItem *item = scene.addRect(QRectF(0, 0, 10, 10));
+            item->setPos(x, y);
+            QCOMPARE(scene.itemAt(x, y), item);
+            items << item;
+        }
+    }
+
+    int n = 0;
+    for (int y = minY; y < maxY; y += 100) {
+        for (int x = minX; x < maxX; x += 100)
+            QCOMPARE(scene.itemAt(x, y), items.at(n++));
+    }
+
+    scene.setItemIndexMethod(QGraphicsScene::NoIndex);
+    QCOMPARE(scene.itemIndexMethod(), QGraphicsScene::NoIndex);
+
+    n = 0;
+    for (int y = minY; y < maxY; y += 100) {
+        for (int x = minX; x < maxX; x += 100)
+            QCOMPARE(scene.itemAt(x, y), items.at(n++));
+    }
+
+    scene.setItemIndexMethod(QGraphicsScene::BspTreeIndex);
+    QCOMPARE(scene.itemIndexMethod(), QGraphicsScene::BspTreeIndex);
+
+    n = 0;
+    for (int y = minY; y < maxY; y += 100) {
+        for (int x = minX; x < maxX; x += 100)
+            QCOMPARE(scene.itemAt(x, y), items.at(n++));
+    }
+}
+
+void tst_QGraphicsScene::bspTreeDepth()
+{
+    QGraphicsScene scene;
+    QCOMPARE(scene.itemIndexMethod(), QGraphicsScene::BspTreeIndex);
+    QCOMPARE(scene.bspTreeDepth(), 0);
+    scene.setBspTreeDepth(1);
+    QCOMPARE(scene.bspTreeDepth(), 1);
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsScene::setBspTreeDepth: invalid depth -1 ignored; must be >= 0");
+    scene.setBspTreeDepth(-1);
+    QCOMPARE(scene.bspTreeDepth(), 1);
+}
+
+void tst_QGraphicsScene::items()
+{
+#ifdef QT_ARCH_ARM
+    const int minY = -500;
+    const int maxY = 500;
+    const int minX = -500;
+    const int maxX = 500;
+#else
+    const int minY = -1000;
+    const int maxY = 2000;
+    const int minX = -1000;
+    const int maxX = 2000;
+#endif
+
+    {
+        QGraphicsScene scene;
+
+        QList<QGraphicsItem *> items;
+        for (int y = minY; y < maxY; y += 100) {
+            for (int x = minX; x < maxX; x += 100)
+                items << scene.addRect(QRectF(0, 0, 10, 10));
+        }
+        QCOMPARE(scene.items().size(), items.size());
+        scene.itemAt(0, 0); // trigger indexing
+
+        scene.removeItem(items.at(5));
+        delete items.at(5);
+        QVERIFY(!scene.items().contains(0));
+        delete items.at(7);
+        QVERIFY(!scene.items().contains(0));
+    }
+    {
+        QGraphicsScene scene;
+        QGraphicsLineItem *l1 = scene.addLine(-5, 0, 5, 0);
+        QGraphicsLineItem *l2 = scene.addLine(0, -5, 0, 5);
+        QVERIFY(!l1->sceneBoundingRect().intersects(l2->sceneBoundingRect()));
+        QVERIFY(!l2->sceneBoundingRect().intersects(l1->sceneBoundingRect()));
+        QList<QGraphicsItem *> items;
+        items<<l1<<l2;
+        QCOMPARE(scene.items().size(), items.size());
+        QVERIFY(scene.items(-1, -1, 2, 2).contains(l1));
+        QVERIFY(scene.items(-1, -1, 2, 2).contains(l2));
+    }
+}
+
+void tst_QGraphicsScene::itemsBoundingRect_data()
+{
+    QTest::addColumn<QList<QRectF> >("rects");
+    QTest::addColumn<QMatrix>("matrix");
+    QTest::addColumn<QRectF>("boundingRect");
+
+    QMatrix transformationMatrix;
+    transformationMatrix.translate(50, -50);
+    transformationMatrix.scale(2, 2);
+    transformationMatrix.rotate(90);
+
+    QTest::newRow("none")
+        << QList<QRectF>()
+        << QMatrix()
+        << QRectF();
+    QTest::newRow("{{0, 0, 10, 10}}")
+        << (QList<QRectF>() << QRectF(0, 0, 10, 10))
+        << QMatrix()
+        << QRectF(0, 0, 10, 10);
+    QTest::newRow("{{-10, -10, 10, 10}}")
+        << (QList<QRectF>() << QRectF(-10, -10, 10, 10))
+        << QMatrix()
+        << QRectF(-10, -10, 10, 10);
+    QTest::newRow("{{-1000, -1000, 1, 1}, {-10, -10, 10, 10}}")
+        << (QList<QRectF>() << QRectF(-1000, -1000, 1, 1) << QRectF(-10, -10, 10, 10))
+        << QMatrix()
+        << QRectF(-1000, -1000, 1000, 1000);
+    QTest::newRow("transformed {{0, 0, 10, 10}}")
+        << (QList<QRectF>() << QRectF(0, 0, 10, 10))
+        << transformationMatrix
+        << QRectF(30, -50, 20, 20);
+    QTest::newRow("transformed {{-10, -10, 10, 10}}")
+        << (QList<QRectF>() << QRectF(-10, -10, 10, 10))
+        << transformationMatrix
+        << QRectF(50, -70, 20, 20);
+    QTest::newRow("transformed {{-1000, -1000, 1, 1}, {-10, -10, 10, 10}}")
+        << (QList<QRectF>() << QRectF(-1000, -1000, 1, 1) << QRectF(-10, -10, 10, 10))
+        << transformationMatrix
+        << QRectF(50, -2050, 2000, 2000);
+
+    QList<QRectF> all;
+    for (int i = 0; i < 256; ++i)
+        all << QRectF(randomX[i], randomY[i], 10, 10);
+    QTest::newRow("all")
+        << all
+        << QMatrix()
+        << QRectF(-980, -994, 1988, 1983);
+    QTest::newRow("transformed all")
+        << all
+        << transformationMatrix
+        << QRectF(-1928, -2010, 3966, 3976);
+}
+
+void tst_QGraphicsScene::itemsBoundingRect()
+{
+    QFETCH(QList<QRectF>, rects);
+    QFETCH(QMatrix, matrix);
+    QFETCH(QRectF, boundingRect);
+
+    QGraphicsScene scene;
+
+    foreach (QRectF rect, rects) {
+        QPainterPath path;
+        path.addRect(rect);
+        scene.addPath(path)->setMatrix(matrix);
+    }
+
+    QCOMPARE(scene.itemsBoundingRect(), boundingRect);
+}
+
+void tst_QGraphicsScene::items_QPointF_data()
+{
+    QTest::addColumn<QList<QRectF> >("items");
+    QTest::addColumn<QPointF>("point");
+    QTest::addColumn<QList<int> >("itemsAtPoint");
+
+    QTest::newRow("empty")
+        << QList<QRectF>()
+        << QPointF()
+        << QList<int>();
+    QTest::newRow("1")
+        << (QList<QRectF>() << QRectF(0, 0, 10, 10))
+        << QPointF(0, 0)
+        << (QList<int>() << 0);
+    QTest::newRow("2")
+        << (QList<QRectF>() << QRectF(0, 0, 10, 10))
+        << QPointF(5, 5)
+        << (QList<int>() << 0);
+    QTest::newRow("3")
+        << (QList<QRectF>() << QRectF(0, 0, 10, 10))
+        << QPointF(9.9, 9.9)
+        << (QList<int>() << 0);
+    QTest::newRow("3.5")
+        << (QList<QRectF>() << QRectF(0, 0, 10, 10))
+        << QPointF(10, 10)
+        << QList<int>();
+    QTest::newRow("4")
+        << (QList<QRectF>() << QRectF(0, 0, 10, 10) << QRectF(9.9, 9.9, 10, 10))
+        << QPointF(9.9, 9.9)
+        << (QList<int>() << 1 << 0);
+    QTest::newRow("4.5")
+        << (QList<QRectF>() << QRectF(0, 0, 10, 10) << QRectF(10, 10, 10, 10))
+        << QPointF(10, 10)
+        << (QList<int>() << 1);
+    QTest::newRow("5")
+        << (QList<QRectF>() << QRectF(5, 5, 10, 10) << QRectF(10, 10, 10, 10))
+        << QPointF(10, 10)
+        << (QList<int>() << 1 << 0);
+    QTest::newRow("6")
+        << (QList<QRectF>() << QRectF(5, 5, 10, 10) << QRectF(10, 10, 10, 10) << QRectF(0, 0, 20, 30))
+        << QPointF(10, 10)
+        << (QList<int>() << 2 << 1 << 0);
+}
+
+void tst_QGraphicsScene::items_QPointF()
+{
+    QFETCH(QList<QRectF>, items);
+    QFETCH(QPointF, point);
+    QFETCH(QList<int>, itemsAtPoint);
+
+    QGraphicsScene scene;
+
+    int n = 0;
+    QList<QGraphicsItem *> addedItems;
+    foreach(QRectF rect, items) {
+        QPainterPath path;
+        path.addRect(0, 0, rect.width(), rect.height());
+
+        QGraphicsItem *item = scene.addPath(path);
+        item->setZValue(n++);
+        item->setPos(rect.topLeft());
+        addedItems << item;
+    }
+
+    QList<int> itemIndexes;
+    foreach (QGraphicsItem *item, scene.items(point))
+        itemIndexes << addedItems.indexOf(item);
+
+    QCOMPARE(itemIndexes, itemsAtPoint);
+}
+
+void tst_QGraphicsScene::items_QRectF()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item1 = scene.addRect(QRectF(-10, -10, 10, 10));
+    QGraphicsItem *item2 = scene.addRect(QRectF(10, -10, 10, 10));
+    QGraphicsItem *item3 = scene.addRect(QRectF(10, 10, 10, 10));
+    QGraphicsItem *item4 = scene.addRect(QRectF(-10, 10, 10, 10));
+
+    item1->setZValue(0);
+    item2->setZValue(1);
+    item3->setZValue(2);
+    item4->setZValue(3);
+
+    QCOMPARE(scene.items(QRectF(-10, -10, 10, 10)), QList<QGraphicsItem *>() << item1);
+    QCOMPARE(scene.items(QRectF(10, -10, 10, 10)), QList<QGraphicsItem *>() << item2);
+    QCOMPARE(scene.items(QRectF(10, 10, 10, 10)), QList<QGraphicsItem *>() << item3);
+    QCOMPARE(scene.items(QRectF(-10, 10, 10, 10)), QList<QGraphicsItem *>() << item4);
+    QCOMPARE(scene.items(QRectF(-10, -10, 1, 1)), QList<QGraphicsItem *>() << item1);
+    QCOMPARE(scene.items(QRectF(10, -10, 1, 1)), QList<QGraphicsItem *>() << item2);
+    QCOMPARE(scene.items(QRectF(10, 10, 1, 1)), QList<QGraphicsItem *>() << item3);
+    QCOMPARE(scene.items(QRectF(-10, 10, 1, 1)), QList<QGraphicsItem *>() << item4);
+
+    QCOMPARE(scene.items(QRectF(-10, -10, 40, 10)), QList<QGraphicsItem *>() << item2 << item1);
+    QCOMPARE(scene.items(QRectF(-10, 10, 40, 10)), QList<QGraphicsItem *>() << item4 << item3);
+
+    item1->setZValue(3);
+    item2->setZValue(2);
+    item3->setZValue(1);
+    item4->setZValue(0);
+
+    QCOMPARE(scene.items(QRectF(-10, -10, 40, 10)), QList<QGraphicsItem *>() << item1 << item2);
+    QCOMPARE(scene.items(QRectF(-10, 10, 40, 10)), QList<QGraphicsItem *>() << item3 << item4);
+}
+
+void tst_QGraphicsScene::items_QRectF_2_data()
+{
+    QTest::addColumn<QRectF>("ellipseRect");
+    QTest::addColumn<QRectF>("sceneRect");
+    QTest::addColumn<Qt::ItemSelectionMode>("selectionMode");
+    QTest::addColumn<bool>("contained");
+    QTest::addColumn<bool>("containedRotated");
+
+    // None of the rects contain the ellipse's shape nor bounding rect
+    QTest::newRow("1") << QRectF(0, 0, 100, 100) << QRectF(1, 1, 10, 10) << Qt::ContainsItemShape << false << false;
+    QTest::newRow("2") << QRectF(0, 0, 100, 100) << QRectF(1, 89, 10, 10) << Qt::ContainsItemShape << false << false;
+    QTest::newRow("3") << QRectF(0, 0, 100, 100) << QRectF(89, 1, 10, 10) << Qt::ContainsItemShape << false << false;
+    QTest::newRow("4") << QRectF(0, 0, 100, 100) << QRectF(89, 89, 10, 10) << Qt::ContainsItemShape << false << false;
+    QTest::newRow("5") << QRectF(0, 0, 100, 100) << QRectF(1, 1, 10, 10) << Qt::ContainsItemBoundingRect << false << false;
+    QTest::newRow("6") << QRectF(0, 0, 100, 100) << QRectF(1, 89, 10, 10) << Qt::ContainsItemBoundingRect << false << false;
+    QTest::newRow("7") << QRectF(0, 0, 100, 100) << QRectF(89, 1, 10, 10) << Qt::ContainsItemBoundingRect << false << false;
+    QTest::newRow("8") << QRectF(0, 0, 100, 100) << QRectF(89, 89, 10, 10) << Qt::ContainsItemBoundingRect << false << false;
+    QTest::newRow("9") << QRectF(0, 0, 100, 100) << QRectF(0, 0, 50, 50) << Qt::ContainsItemShape << false << false;
+    QTest::newRow("10") << QRectF(0, 0, 100, 100) << QRectF(0, 50, 50, 50) << Qt::ContainsItemShape << false << false;
+    QTest::newRow("11") << QRectF(0, 0, 100, 100) << QRectF(50, 0, 50, 50) << Qt::ContainsItemShape << false << false;
+    QTest::newRow("12") << QRectF(0, 0, 100, 100) << QRectF(50, 50, 50, 50) << Qt::ContainsItemShape << false << false;
+    QTest::newRow("13") << QRectF(0, 0, 100, 100) << QRectF(0, 0, 50, 50) << Qt::ContainsItemBoundingRect << false << false;
+    QTest::newRow("14") << QRectF(0, 0, 100, 100) << QRectF(0, 50, 50, 50) << Qt::ContainsItemBoundingRect << false << false;
+    QTest::newRow("15") << QRectF(0, 0, 100, 100) << QRectF(50, 0, 50, 50) << Qt::ContainsItemBoundingRect << false << false;
+    QTest::newRow("16") << QRectF(0, 0, 100, 100) << QRectF(50, 50, 50, 50) << Qt::ContainsItemBoundingRect << false << false;
+    QTest::newRow("17") << QRectF(0, 0, 100, 100) << QRectF(-50, -50, 100, 100) << Qt::ContainsItemShape << false << false;
+    QTest::newRow("18") << QRectF(0, 0, 100, 100) << QRectF(0, -50, 100, 100) << Qt::ContainsItemShape << false << false;
+    QTest::newRow("19") << QRectF(0, 0, 100, 100) << QRectF(-50, 0, 100, 100) << Qt::ContainsItemShape << false << false;
+    QTest::newRow("20") << QRectF(0, 0, 100, 100) << QRectF(0, 0, 100, 100) << Qt::ContainsItemShape << false << false;
+    QTest::newRow("21") << QRectF(0, 0, 100, 100) << QRectF(-50, -50, 100, 100) << Qt::ContainsItemBoundingRect << false << false;
+    QTest::newRow("22") << QRectF(0, 0, 100, 100) << QRectF(0, -50, 100, 100) << Qt::ContainsItemBoundingRect << false << false;
+    QTest::newRow("23") << QRectF(0, 0, 100, 100) << QRectF(-50, 0, 100, 100) << Qt::ContainsItemBoundingRect << false << false;
+
+    // The rect is the same as the ellipse's bounding rect
+    QTest::newRow("24") << QRectF(0, 0, 100, 100) << QRectF(0, 0, 100, 100) << Qt::ContainsItemBoundingRect << false << false;
+
+    // None intersects with the item's shape, but they all intersects with the
+    // item's bounding rect.
+    QTest::newRow("25") << QRectF(0, 0, 100, 100) << QRectF(1, 1, 10, 10) << Qt::IntersectsItemShape << false << false;
+    QTest::newRow("26") << QRectF(0, 0, 100, 100) << QRectF(1, 89, 10, 10) << Qt::IntersectsItemShape << false << true;
+    QTest::newRow("27") << QRectF(0, 0, 100, 100) << QRectF(89, 1, 10, 10) << Qt::IntersectsItemShape << false << false;
+    QTest::newRow("28") << QRectF(0, 0, 100, 100) << QRectF(89, 89, 10, 10) << Qt::IntersectsItemShape << false << false;
+    QTest::newRow("29") << QRectF(0, 0, 100, 100) << QRectF(1, 1, 10, 10) << Qt::IntersectsItemBoundingRect << true << true;
+    QTest::newRow("30") << QRectF(0, 0, 100, 100) << QRectF(1, 89, 10, 10) << Qt::IntersectsItemBoundingRect << true << true;
+    QTest::newRow("31") << QRectF(0, 0, 100, 100) << QRectF(89, 1, 10, 10) << Qt::IntersectsItemBoundingRect << true << false;
+    QTest::newRow("32") << QRectF(0, 0, 100, 100) << QRectF(89, 89, 10, 10) << Qt::IntersectsItemBoundingRect << true << false;
+
+    // This rect does not contain the shape nor the bounding rect
+    QTest::newRow("33") << QRectF(0, 0, 100, 100) << QRectF(5, 5, 90, 90) << Qt::ContainsItemShape << false << false;
+    QTest::newRow("34") << QRectF(0, 0, 100, 100) << QRectF(5, 5, 90, 90) << Qt::ContainsItemBoundingRect << false << false;
+
+    // It will, however, intersect with both
+    QTest::newRow("35") << QRectF(0, 0, 100, 100) << QRectF(5, 5, 90, 90) << Qt::IntersectsItemShape << true << true;
+    QTest::newRow("36") << QRectF(0, 0, 100, 100) << QRectF(5, 5, 90, 90) << Qt::IntersectsItemBoundingRect << true << true;
+
+    // A rect that contains the whole ellipse will both contain and intersect
+    // with both the ellipse's shape and bounding rect.
+    QTest::newRow("37") << QRectF(0, 0, 100, 100) << QRectF(-5, -5, 110, 110) << Qt::IntersectsItemBoundingRect << true << true;
+    QTest::newRow("38") << QRectF(0, 0, 100, 100) << QRectF(-5, -5, 110, 110) << Qt::IntersectsItemShape << true << true;
+    QTest::newRow("39") << QRectF(0, 0, 100, 100) << QRectF(-5, -5, 110, 110) << Qt::ContainsItemBoundingRect << true << false;
+    QTest::newRow("40") << QRectF(0, 0, 100, 100) << QRectF(-5, -5, 110, 110) << Qt::ContainsItemShape << true << false;
+
+    // A rect that is fully contained within the ellipse will intersect only
+    QTest::newRow("41") << QRectF(0, 0, 100, 100) << QRectF(40, 40, 20, 20) << Qt::ContainsItemShape << false << false;
+    QTest::newRow("42") << QRectF(0, 0, 100, 100) << QRectF(40, 40, 20, 20) << Qt::ContainsItemBoundingRect << false << false;
+    QTest::newRow("43") << QRectF(0, 0, 100, 100) << QRectF(40, 40, 20, 20) << Qt::IntersectsItemShape << true << true;
+    QTest::newRow("44") << QRectF(0, 0, 100, 100) << QRectF(40, 40, 20, 20) << Qt::IntersectsItemBoundingRect << true << true;
+}
+
+void tst_QGraphicsScene::items_QRectF_2()
+{
+    QFETCH(QRectF, ellipseRect);
+    QFETCH(QRectF, sceneRect);
+    QFETCH(Qt::ItemSelectionMode, selectionMode);
+    QFETCH(bool, contained);
+    QFETCH(bool, containedRotated);
+
+    QGraphicsScene scene;
+    QGraphicsItem *item = scene.addEllipse(ellipseRect);
+
+    QCOMPARE(!scene.items(sceneRect, selectionMode).isEmpty(), contained);
+    item->rotate(45);
+    QCOMPARE(!scene.items(sceneRect, selectionMode).isEmpty(), containedRotated);
+}
+
+void tst_QGraphicsScene::items_QPolygonF()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item1 = scene.addRect(QRectF(-10, -10, 10, 10));
+    QGraphicsItem *item2 = scene.addRect(QRectF(10, -10, 10, 10));
+    QGraphicsItem *item3 = scene.addRect(QRectF(10, 10, 10, 10));
+    QGraphicsItem *item4 = scene.addRect(QRectF(-10, 10, 10, 10));
+
+    item1->setZValue(0);
+    item2->setZValue(1);
+    item3->setZValue(2);
+    item4->setZValue(3);
+
+    QPolygonF poly1(item1->boundingRect());
+    QPolygonF poly2(item2->boundingRect());
+    QPolygonF poly3(item3->boundingRect());
+    QPolygonF poly4(item4->boundingRect());
+
+    QCOMPARE(scene.items(poly1), QList<QGraphicsItem *>() << item1);
+    QCOMPARE(scene.items(poly2), QList<QGraphicsItem *>() << item2);
+    QCOMPARE(scene.items(poly3), QList<QGraphicsItem *>() << item3);
+    QCOMPARE(scene.items(poly4), QList<QGraphicsItem *>() << item4);
+
+    poly1 = QPolygonF(QRectF(-10, -10, 1, 1));
+    poly2 = QPolygonF(QRectF(10, -10, 1, 1));
+    poly3 = QPolygonF(QRectF(10, 10, 1, 1));
+    poly4 = QPolygonF(QRectF(-10, 10, 1, 1));
+
+    QCOMPARE(scene.items(poly1), QList<QGraphicsItem *>() << item1);
+    QCOMPARE(scene.items(poly2), QList<QGraphicsItem *>() << item2);
+    QCOMPARE(scene.items(poly3), QList<QGraphicsItem *>() << item3);
+    QCOMPARE(scene.items(poly4), QList<QGraphicsItem *>() << item4);
+
+    poly1 = QPolygonF(QRectF(-10, -10, 40, 10));
+    poly2 = QPolygonF(QRectF(-10, 10, 40, 10));
+
+    QCOMPARE(scene.items(poly1), QList<QGraphicsItem *>() << item2 << item1);
+    QCOMPARE(scene.items(poly2), QList<QGraphicsItem *>() << item4 << item3);
+
+    item1->setZValue(3);
+    item2->setZValue(2);
+    item3->setZValue(1);
+    item4->setZValue(0);
+
+    QCOMPARE(scene.items(poly1), QList<QGraphicsItem *>() << item1 << item2);
+    QCOMPARE(scene.items(poly2), QList<QGraphicsItem *>() << item3 << item4);
+}
+
+void tst_QGraphicsScene::items_QPolygonF_2()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *ellipse = scene.addEllipse(QRectF(0, 0, 100, 100));
+
+    // None of the rects contain the ellipse's shape nor bounding rect
+    QVERIFY(scene.items(QPolygonF(QRectF(1, 1, 10, 10)), Qt::ContainsItemShape).isEmpty());
+    QVERIFY(scene.items(QPolygonF(QRectF(1, 89, 10, 10)), Qt::ContainsItemShape).isEmpty());
+    QVERIFY(scene.items(QPolygonF(QRectF(89, 1, 10, 10)), Qt::ContainsItemShape).isEmpty());
+    QVERIFY(scene.items(QPolygonF(QRectF(89, 89, 10, 10)), Qt::ContainsItemShape).isEmpty());
+    QVERIFY(scene.items(QPolygonF(QRectF(1, 1, 10, 10)), Qt::ContainsItemBoundingRect).isEmpty());
+    QVERIFY(scene.items(QPolygonF(QRectF(1, 89, 10, 10)), Qt::ContainsItemBoundingRect).isEmpty());
+    QVERIFY(scene.items(QPolygonF(QRectF(89, 1, 10, 10)), Qt::ContainsItemBoundingRect).isEmpty());
+    QVERIFY(scene.items(QPolygonF(QRectF(89, 89, 10, 10)), Qt::ContainsItemBoundingRect).isEmpty());
+
+    // None intersects with the item's shape, but they all intersects with the
+    // item's bounding rect.
+    QVERIFY(scene.items(QPolygonF(QRectF(1, 1, 10, 10)), Qt::IntersectsItemShape).isEmpty());
+    QVERIFY(scene.items(QPolygonF(QRectF(1, 89, 10, 10)), Qt::IntersectsItemShape).isEmpty());
+    QVERIFY(scene.items(QPolygonF(QRectF(89, 1, 10, 10)), Qt::IntersectsItemShape).isEmpty());
+    QVERIFY(scene.items(QPolygonF(QRectF(89, 89, 10, 10)), Qt::IntersectsItemShape).isEmpty());
+    QCOMPARE(scene.items(QPolygonF(QRectF(1, 1, 10, 10)), Qt::IntersectsItemBoundingRect).first(), ellipse);
+    QCOMPARE(scene.items(QPolygonF(QRectF(1, 89, 10, 10)), Qt::IntersectsItemBoundingRect).first(), ellipse);
+    QCOMPARE(scene.items(QPolygonF(QRectF(89, 1, 10, 10)), Qt::IntersectsItemBoundingRect).first(), ellipse);
+    QCOMPARE(scene.items(QPolygonF(QRectF(89, 89, 10, 10)), Qt::IntersectsItemBoundingRect).first(), ellipse);
+
+    // This rect does not contain the shape nor the bounding rect
+    QVERIFY(scene.items(QPolygonF(QRectF(5, 5, 90, 90)), Qt::ContainsItemShape).isEmpty());
+    QVERIFY(scene.items(QPolygonF(QRectF(5, 5, 90, 90)), Qt::ContainsItemBoundingRect).isEmpty());
+
+    // It will, however, intersect with both
+    QCOMPARE(scene.items(QPolygonF(QRectF(5, 5, 90, 90)), Qt::IntersectsItemShape).first(), ellipse);
+    QCOMPARE(scene.items(QPolygonF(QRectF(5, 5, 90, 90)), Qt::IntersectsItemBoundingRect).first(), ellipse);
+
+    // A rect that contains the whole ellipse will both contain and intersect
+    // with both the ellipse's shape and bounding rect.
+    QCOMPARE(scene.items(QPolygonF(QRectF(-5, -5, 110, 110)), Qt::IntersectsItemShape).first(), ellipse);
+    QCOMPARE(scene.items(QPolygonF(QRectF(-5, -5, 110, 110)), Qt::ContainsItemShape).first(), ellipse);
+    QCOMPARE(scene.items(QPolygonF(QRectF(-5, -5, 110, 110)), Qt::IntersectsItemBoundingRect).first(), ellipse);
+    QCOMPARE(scene.items(QPolygonF(QRectF(-5, -5, 110, 110)), Qt::ContainsItemBoundingRect).first(), ellipse);
+}
+
+void tst_QGraphicsScene::items_QPainterPath()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item1 = scene.addRect(QRectF(-10, -10, 10, 10));
+    QGraphicsItem *item2 = scene.addRect(QRectF(10, -10, 10, 10));
+    QGraphicsItem *item3 = scene.addRect(QRectF(10, 10, 10, 10));
+    QGraphicsItem *item4 = scene.addRect(QRectF(-10, 10, 10, 10));
+
+    item1->setZValue(0);
+    item2->setZValue(1);
+    item3->setZValue(2);
+    item4->setZValue(3);
+
+    QPainterPath path1; path1.addEllipse(item1->boundingRect());
+    QPainterPath path2; path2.addEllipse(item2->boundingRect());
+    QPainterPath path3; path3.addEllipse(item3->boundingRect());
+    QPainterPath path4; path4.addEllipse(item4->boundingRect());
+
+    QCOMPARE(scene.items(path1), QList<QGraphicsItem *>() << item1);
+    QCOMPARE(scene.items(path2), QList<QGraphicsItem *>() << item2);
+    QCOMPARE(scene.items(path3), QList<QGraphicsItem *>() << item3);
+    QCOMPARE(scene.items(path4), QList<QGraphicsItem *>() << item4);
+
+    path1 = QPainterPath(); path1.addEllipse(QRectF(-10, -10, 1, 1));
+    path2 = QPainterPath(); path2.addEllipse(QRectF(10, -10, 1, 1));
+    path3 = QPainterPath(); path3.addEllipse(QRectF(10, 10, 1, 1));
+    path4 = QPainterPath(); path4.addEllipse(QRectF(-10, 10, 1, 1));
+
+    QCOMPARE(scene.items(path1), QList<QGraphicsItem *>() << item1);
+    QCOMPARE(scene.items(path2), QList<QGraphicsItem *>() << item2);
+    QCOMPARE(scene.items(path3), QList<QGraphicsItem *>() << item3);
+    QCOMPARE(scene.items(path4), QList<QGraphicsItem *>() << item4);
+
+    path1 = QPainterPath(); path1.addRect(QRectF(-10, -10, 40, 10));
+    path2 = QPainterPath(); path2.addRect(QRectF(-10, 10, 40, 10));
+
+    QCOMPARE(scene.items(path1), QList<QGraphicsItem *>() << item2 << item1);
+    QCOMPARE(scene.items(path2), QList<QGraphicsItem *>() << item4 << item3);
+
+    item1->setZValue(3);
+    item2->setZValue(2);
+    item3->setZValue(1);
+    item4->setZValue(0);
+
+    QCOMPARE(scene.items(path1), QList<QGraphicsItem *>() << item1 << item2);
+    QCOMPARE(scene.items(path2), QList<QGraphicsItem *>() << item3 << item4);
+}
+
+void tst_QGraphicsScene::items_QPainterPath_2()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *ellipse = scene.addEllipse(QRectF(0, 0, 100, 100));
+
+    QPainterPath p1; p1.addRect(QRectF(1, 1, 10, 10));
+    QPainterPath p2; p2.addRect(QRectF(1, 89, 10, 10));
+    QPainterPath p3; p3.addRect(QRectF(89, 1, 10, 10));
+    QPainterPath p4; p4.addRect(QRectF(89, 89, 10, 10));
+
+    // None of the rects contain the ellipse's shape nor bounding rect
+    QVERIFY(scene.items(p1, Qt::ContainsItemShape).isEmpty());
+    QVERIFY(scene.items(p2, Qt::ContainsItemShape).isEmpty());
+    QVERIFY(scene.items(p3, Qt::ContainsItemShape).isEmpty());
+    QVERIFY(scene.items(p4, Qt::ContainsItemShape).isEmpty());
+    QVERIFY(scene.items(p1, Qt::ContainsItemBoundingRect).isEmpty());
+    QVERIFY(scene.items(p2, Qt::ContainsItemBoundingRect).isEmpty());
+    QVERIFY(scene.items(p3, Qt::ContainsItemBoundingRect).isEmpty());
+    QVERIFY(scene.items(p4, Qt::ContainsItemBoundingRect).isEmpty());
+
+    // None intersects with the item's shape, but they all intersects with the
+    // item's bounding rect.
+    QVERIFY(scene.items(p1, Qt::IntersectsItemShape).isEmpty());
+    QVERIFY(scene.items(p2, Qt::IntersectsItemShape).isEmpty());
+    QVERIFY(scene.items(p3, Qt::IntersectsItemShape).isEmpty());
+    QVERIFY(scene.items(p4, Qt::IntersectsItemShape).isEmpty());
+    QCOMPARE(scene.items(p1, Qt::IntersectsItemBoundingRect).first(), ellipse);
+    QCOMPARE(scene.items(p2, Qt::IntersectsItemBoundingRect).first(), ellipse);
+    QCOMPARE(scene.items(p3, Qt::IntersectsItemBoundingRect).first(), ellipse);
+    QCOMPARE(scene.items(p4, Qt::IntersectsItemBoundingRect).first(), ellipse);
+
+    QPainterPath p5;
+    p5.addRect(QRectF(5, 5, 90, 90));
+
+    // This rect does not contain the shape nor the bounding rect
+    QVERIFY(scene.items(p5, Qt::ContainsItemShape).isEmpty());
+    QVERIFY(scene.items(p5, Qt::ContainsItemBoundingRect).isEmpty());
+
+    // It will, however, intersect with both
+    QCOMPARE(scene.items(p5, Qt::IntersectsItemShape).first(), ellipse);
+    QCOMPARE(scene.items(p5, Qt::IntersectsItemBoundingRect).first(), ellipse);
+
+    QPainterPath p6;
+    p6.addRect(QRectF(-5, -5, 110, 110));
+
+    // A rect that contains the whole ellipse will both contain and intersect
+    // with both the ellipse's shape and bounding rect.
+    QCOMPARE(scene.items(p6, Qt::IntersectsItemShape).first(), ellipse);
+    QCOMPARE(scene.items(p6, Qt::ContainsItemShape).first(), ellipse);
+    QCOMPARE(scene.items(p6, Qt::IntersectsItemBoundingRect).first(), ellipse);
+    QCOMPARE(scene.items(p6, Qt::ContainsItemBoundingRect).first(), ellipse);
+}
+
+void tst_QGraphicsScene::selection()
+{
+    // ### This test is difficult to make work for all platforms; instead, a
+    // hand crafted data set would make it stable. Its behavior is thoroughly
+    // covered by other tests. Todo: Fix this test.
+
+    /*
+    QGraphicsScene scene;
+    QMap<QGraphicsItem *, int> itemIndexes;
+    for (int i = 0; i < 256; ++i) {
+        QPainterPath path;
+        path.addRect(randomX[i], randomY[i], 25, 25);
+
+        QGraphicsPathItem *pathItem = scene.addPath(path);
+        pathItem->setFlag(QGraphicsItem::ItemIsSelectable);
+        itemIndexes.insert(pathItem, i);
+    }
+
+#if 0
+    // Write data
+    QFile::remove("graphicsScene_selection.data");
+    QFile file("graphicsScene_selection.data");
+    if (!file.open(QFile::WriteOnly))
+        QFAIL("Unable to generate data file graphicsScene_selection.data");
+    QDataStream stream(&file);
+    for (qreal y = -1000; y < 1000; y += 33) {
+        for (qreal x = -1000; x < 1000; x += 33) {
+            for (qreal size = 1; size < 200; size += 33) {
+                QPainterPath path;
+                path.addRect(QRectF(x, y, size, size));
+                scene.setSelectionArea(path);
+                QCOMPARE(scene.selectionArea(), path);
+
+                QList<int> indexes;
+                foreach (QGraphicsItem *item, scene.selectedItems())
+                    indexes << itemIndexes.value(item);
+
+                stream << x << y << size << indexes;
+            }
+        }
+    }
+#else
+    // Read data
+    QFile file("graphicsScene_selection.data");
+    if (!file.open(QFile::ReadOnly))
+        QFAIL("Unable to load data file graphicsScene_selection.data");
+
+    QDataStream stream(&file);
+
+    while (!stream.atEnd()) {
+        QList<int> expectedIndexes;
+
+        qreal x, y, size;
+        stream >> x >> y >> size >> expectedIndexes;
+
+        QPainterPath path;
+        path.addRect(QRectF(x, y, size, size));
+        scene.setSelectionArea(path);
+        QCOMPARE(scene.selectionArea(), path);
+
+        QList<int> indexes;
+        foreach (QGraphicsItem *item, scene.selectedItems())
+            indexes << itemIndexes.value(item);
+
+        qSort(indexes);
+        qSort(expectedIndexes);
+
+        QCOMPARE(indexes, expectedIndexes);
+
+        scene.clearSelection();
+        QVERIFY(scene.selectedItems().isEmpty());
+    }
+#endif
+    */
+}
+
+class CustomView : public QGraphicsView
+{
+public:
+    CustomView() : repaints(0)
+    { }
+
+    int repaints;
+protected:
+    void paintEvent(QPaintEvent *event)
+    {
+        ++repaints;
+        QGraphicsView::paintEvent(event);
+    }
+};
+
+void tst_QGraphicsScene::selectionChanged()
+{
+    QGraphicsScene scene(0, 0, 1000, 1000);
+    QSignalSpy spy(&scene, SIGNAL(selectionChanged()));
+    QCOMPARE(spy.count(), 0);
+
+    QPainterPath path;
+    path.addRect(scene.sceneRect());
+    QCOMPARE(scene.selectionArea(), QPainterPath());
+    scene.setSelectionArea(path);
+    QCOMPARE(scene.selectionArea(), path);
+    QCOMPARE(spy.count(), 0); // selection didn't change
+    QVERIFY(scene.selectedItems().isEmpty());
+
+    QGraphicsItem *rect = scene.addRect(QRectF(0, 0, 100, 100));
+    QCOMPARE(spy.count(), 0); // selection didn't change
+
+    rect->setSelected(true);
+    QVERIFY(!rect->isSelected());
+    QCOMPARE(spy.count(), 0); // selection didn't change, item isn't selectable
+
+    rect->setFlag(QGraphicsItem::ItemIsSelectable);
+    rect->setSelected(true);
+    QVERIFY(rect->isSelected());
+    QCOMPARE(spy.count(), 1); // selection changed
+    QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>() << rect);
+
+    rect->setSelected(false);
+    QVERIFY(!rect->isSelected());
+    QCOMPARE(spy.count(), 2); // selection changed
+    QVERIFY(scene.selectedItems().isEmpty());
+
+    QGraphicsEllipseItem *parentItem = new QGraphicsEllipseItem(QRectF(0, 0, 100, 100));
+    QGraphicsEllipseItem *childItem = new QGraphicsEllipseItem(QRectF(0, 0, 100, 100), parentItem);
+    QGraphicsEllipseItem *grandChildItem = new QGraphicsEllipseItem(QRectF(0, 0, 100, 100), childItem);
+    grandChildItem->setFlag(QGraphicsItem::ItemIsSelectable);
+    grandChildItem->setSelected(true);
+    grandChildItem->setSelected(false);
+    grandChildItem->setSelected(true);
+    scene.addItem(parentItem);
+
+    QCOMPARE(spy.count(), 3); // the grandchild was added, so the selection changed once
+
+    scene.removeItem(parentItem);
+    QCOMPARE(spy.count(), 4); // the grandchild was removed, so the selection changed
+
+    rect->setSelected(true);
+    QCOMPARE(spy.count(), 5); // the rect was reselected, so the selection changed
+
+    scene.clearSelection();
+    QCOMPARE(spy.count(), 6); // the scene selection was cleared
+
+    rect->setSelected(true);
+    QCOMPARE(spy.count(), 7); // the rect was reselected, so the selection changed
+
+    rect->setFlag(QGraphicsItem::ItemIsSelectable, false);
+    QCOMPARE(spy.count(), 8); // the rect was unselected, so the selection changed
+
+    rect->setSelected(true);
+    QCOMPARE(spy.count(), 8); // the rect is not longer selectable, so the selection does not change
+
+
+    rect->setFlag(QGraphicsItem::ItemIsSelectable, true);
+    rect->setSelected(true);
+    QCOMPARE(spy.count(), 9); // the rect is again selectable, so the selection changed
+
+    delete rect;
+    QCOMPARE(spy.count(), 10); // a selected item was deleted; selection changed
+}
+
+void tst_QGraphicsScene::selectionChanged2()
+{
+    QGraphicsScene scene;
+    QSignalSpy spy(&scene, SIGNAL(selectionChanged()));
+
+    QGraphicsItem *item1 = scene.addRect(0, 0, 100, 100);
+    QGraphicsItem *item2 = scene.addRect(100, 100, 100, 100);
+    item1->setFlag(QGraphicsItem::ItemIsSelectable);
+    item2->setFlag(QGraphicsItem::ItemIsSelectable);
+
+    QCOMPARE(spy.count(), 0);
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+        event.setScenePos(QPointF(50, 50));
+        event.setButton(Qt::LeftButton);
+        qApp->sendEvent(&scene, &event);
+    }
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseRelease);
+        event.setScenePos(QPointF(50, 50));
+        event.setButton(Qt::LeftButton);
+        qApp->sendEvent(&scene, &event);
+    }
+    QVERIFY(item1->isSelected());
+    QVERIFY(!item2->isSelected());
+    QCOMPARE(spy.count(), 1);
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+        event.setScenePos(QPointF(150, 150));
+        event.setButton(Qt::LeftButton);
+        qApp->sendEvent(&scene, &event);
+    }
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseRelease);
+        event.setScenePos(QPointF(150, 150));
+        event.setButton(Qt::LeftButton);
+        qApp->sendEvent(&scene, &event);
+    }
+    QVERIFY(!item1->isSelected());
+    QVERIFY(item2->isSelected());
+    QCOMPARE(spy.count(), 2);
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+        event.setScenePos(QPointF(50, 50));
+        event.setButton(Qt::LeftButton);
+        event.setModifiers(Qt::ControlModifier);
+        qApp->sendEvent(&scene, &event);
+    }
+    QVERIFY(!item1->isSelected());
+    QVERIFY(item2->isSelected());
+    QCOMPARE(spy.count(), 2);
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseRelease);
+        event.setScenePos(QPointF(50, 50));
+        event.setButton(Qt::LeftButton);
+        qApp->sendEvent(&scene, &event);
+    }
+    QVERIFY(item1->isSelected());
+    QVERIFY(!item2->isSelected());
+    QCOMPARE(spy.count(), 3);
+}
+
+void tst_QGraphicsScene::addItem()
+{
+    Q_CHECK_PAINTEVENTS
+    {
+        // 1) Create item, then scene, then add item
+        QGraphicsItem *path = new QGraphicsEllipseItem(QRectF(-10, -10, 20, 20));
+        QGraphicsScene scene;
+
+        CustomView view;
+        view.setScene(&scene);
+        view.show();
+#ifdef Q_WS_X11
+        qt_x11_wait_for_window_manager(&view);
+#endif
+        qApp->processEvents();
+        view.repaints = 0;
+
+        scene.addItem(path);
+
+        // Adding an item should always issue a repaint.
+        qApp->processEvents(); // <- delayed update is called
+        qApp->processEvents(); // <- scene schedules pending update
+        qApp->processEvents(); // <- pending update is sent to view
+        QVERIFY(view.repaints > 0);
+        view.repaints = 0;
+
+        QCOMPARE(scene.itemAt(0, 0), path);
+
+        QGraphicsItem *path2 = new QGraphicsEllipseItem(QRectF(-10, -10, 20, 20));
+        path2->setPos(100, 100);
+
+        QCOMPARE(scene.itemAt(0, 0), path);
+        QCOMPARE(scene.itemAt(100, 100), (QGraphicsItem *)0);
+        scene.addItem(path2);
+
+        // Adding an item should always issue a repaint.
+        qApp->processEvents(); // <- delayed update is called
+        qApp->processEvents(); // <- scene schedules pending update
+        qApp->processEvents(); // <- pending update is sent to view
+        QVERIFY(view.repaints > 0);
+
+        QCOMPARE(scene.itemAt(100, 100), path2);
+    }
+    {
+        // 2) Create scene, then item, then add item
+        QGraphicsScene scene;
+        QGraphicsItem *path = new QGraphicsEllipseItem(QRectF(-10, -10, 20, 20));
+        scene.addItem(path);
+
+        QGraphicsItem *path2 = new QGraphicsEllipseItem(QRectF(-10, -10, 20, 20));
+        path2->setPos(100, 100);
+        scene.addItem(path2);
+
+        QCOMPARE(scene.itemAt(0, 0), path);
+        QCOMPARE(scene.itemAt(100, 100), path2);
+    }
+}
+
+void tst_QGraphicsScene::addEllipse()
+{
+    QGraphicsScene scene;
+    QGraphicsEllipseItem *ellipse = scene.addEllipse(QRectF(-10, -10, 20, 20),
+                                                     QPen(Qt::red), QBrush(Qt::blue));
+    QCOMPARE(ellipse->pos(), QPointF());
+    QCOMPARE(ellipse->pen(), QPen(Qt::red));
+    QCOMPARE(ellipse->brush(), QBrush(Qt::blue));
+    QCOMPARE(ellipse->rect(), QRectF(-10, -10, 20, 20));
+    QCOMPARE(scene.itemAt(0, 0), (QGraphicsItem *)ellipse);
+    QCOMPARE(scene.itemAt(-10, -10), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(-9.9, 0), (QGraphicsItem *)ellipse);
+    QCOMPARE(scene.itemAt(-10, 10), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(0, -9.9), (QGraphicsItem *)ellipse);
+    QCOMPARE(scene.itemAt(0, 9.9), (QGraphicsItem *)ellipse);
+    QCOMPARE(scene.itemAt(10, -10), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(9.9, 0), (QGraphicsItem *)ellipse);
+    QCOMPARE(scene.itemAt(10, 10), (QGraphicsItem *)0);
+}
+
+void tst_QGraphicsScene::addLine()
+{
+    QGraphicsScene scene;
+    QPen pen(Qt::red);
+    pen.setWidthF(1.0);
+    QGraphicsLineItem *line = scene.addLine(QLineF(-10, -10, 20, 20),
+                                            pen);
+    QCOMPARE(line->pos(), QPointF());
+    QCOMPARE(line->pen(), pen);
+    QCOMPARE(line->line(), QLineF(-10, -10, 20, 20));
+    QCOMPARE(scene.itemAt(0, 0), (QGraphicsItem *)line);
+    QCOMPARE(scene.itemAt(-10, -10), (QGraphicsItem *)line);
+    QCOMPARE(scene.itemAt(-9.9, 0), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(-10, 10), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(0, -9.9), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(0, 9.9), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(10, -10), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(9.9, 0), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(10, 10), (QGraphicsItem *)line);
+}
+
+void tst_QGraphicsScene::addPath()
+{
+    QGraphicsScene scene;
+    QPainterPath p;
+    p.addEllipse(QRectF(-10, -10, 20, 20));
+    p.addEllipse(QRectF(-10, 20, 20, 20));
+
+    QGraphicsPathItem *path = scene.addPath(p, QPen(Qt::red), QBrush(Qt::blue));
+    QCOMPARE(path->pos(), QPointF());
+    QCOMPARE(path->pen(), QPen(Qt::red));
+    QCOMPARE(path->path(), p);
+    QCOMPARE(path->brush(), QBrush(Qt::blue));
+    QCOMPARE(scene.itemAt(0, 0), (QGraphicsItem *)path);
+    QCOMPARE(scene.itemAt(-9.9, 0), (QGraphicsItem *)path);
+    QCOMPARE(scene.itemAt(9.9, 0), (QGraphicsItem *)path);
+    QCOMPARE(scene.itemAt(0, -9.9), (QGraphicsItem *)path);
+    QCOMPARE(scene.itemAt(0, 9.9), (QGraphicsItem *)path);
+    QCOMPARE(scene.itemAt(0, 30), (QGraphicsItem *)path);
+    QCOMPARE(scene.itemAt(-9.9, 30), (QGraphicsItem *)path);
+    QCOMPARE(scene.itemAt(9.9, 30), (QGraphicsItem *)path);
+    QCOMPARE(scene.itemAt(0, 20.1), (QGraphicsItem *)path);
+    QCOMPARE(scene.itemAt(0, 39.9), (QGraphicsItem *)path);
+    QCOMPARE(scene.itemAt(-10, -10), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(10, -10), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(-10, 10), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(10, 10), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(-10, 20), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(10, 20), (QGraphicsItem *)0);
+if (sizeof(qreal) != sizeof(double))
+    QWARN("Skipping test because of rounding errors when qreal != double");
+else
+    QCOMPARE(scene.itemAt(-10, 30), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(10.1, 30), (QGraphicsItem *)0);
+}
+
+void tst_QGraphicsScene::addPixmap()
+{
+    QGraphicsScene scene;
+    QPixmap pix(":/Ash_European.jpg");
+    QGraphicsPixmapItem *pixmap = scene.addPixmap(pix);
+
+    QCOMPARE(pixmap->pos(), QPointF());
+    QCOMPARE(pixmap->pixmap(), pix);
+    QCOMPARE(scene.itemAt(0, 0), (QGraphicsItem *)pixmap);
+    QCOMPARE(scene.itemAt(pix.width() - 1, 0), (QGraphicsItem *)pixmap);
+    QCOMPARE(scene.itemAt(0, pix.height() - 1), (QGraphicsItem *)pixmap);
+    QCOMPARE(scene.itemAt(pix.width() - 1, pix.height() - 1), (QGraphicsItem *)pixmap);
+    QCOMPARE(scene.itemAt(-1, -1), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(pix.width() - 1, -1), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(-1, pix.height() - 1), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(pix.width(), pix.height()), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(0, pix.height()), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(pix.width(), 0), (QGraphicsItem *)0);
+}
+
+void tst_QGraphicsScene::addRect()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *rect = scene.addRect(QRectF(-10, -10, 20, 20),
+                                            QPen(Qt::red), QBrush(Qt::blue));
+    QCOMPARE(rect->pos(), QPointF());
+    QCOMPARE(rect->pen(), QPen(Qt::red));
+    QCOMPARE(rect->brush(), QBrush(Qt::blue));
+    QCOMPARE(rect->rect(), QRectF(-10, -10, 20, 20));
+    QCOMPARE(scene.itemAt(0, 0), (QGraphicsItem *)rect);
+    QCOMPARE(scene.itemAt(-10, -10), (QGraphicsItem *)rect);
+    QCOMPARE(scene.itemAt(-9.9, 0), (QGraphicsItem *)rect);
+    QCOMPARE(scene.itemAt(-10, 10), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(0, -9.9), (QGraphicsItem *)rect);
+    QCOMPARE(scene.itemAt(0, 9.9), (QGraphicsItem *)rect);
+    QCOMPARE(scene.itemAt(10, -10), (QGraphicsItem *)0);
+    QCOMPARE(scene.itemAt(9.9, 0), (QGraphicsItem *)rect);
+    QCOMPARE(scene.itemAt(10, 10), (QGraphicsItem *)0);
+}
+
+void tst_QGraphicsScene::addText()
+{
+    QGraphicsScene scene;
+    QGraphicsTextItem *text = scene.addText("Qt", QFont());
+    QCOMPARE(text->pos(), QPointF());
+    QCOMPARE(text->toPlainText(), QString("Qt"));
+    QCOMPARE(text->font(), QFont());
+}
+
+#if !defined(Q_OS_WINCE) || defined(GWES_ICONCURS)
+void tst_QGraphicsScene::removeItem()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item = scene.addRect(QRectF(0, 0, 10, 10));
+    QCOMPARE(scene.itemAt(0, 0), item); // forces indexing
+    scene.removeItem(item);
+    QCOMPARE(scene.itemAt(0, 0), (QGraphicsItem *)0);
+    delete item;
+
+    QGraphicsItem *item2 = scene.addRect(QRectF(0, 0, 10, 10));
+    item2->setFlag(QGraphicsItem::ItemIsSelectable);
+    QCOMPARE(scene.itemAt(0, 0), item2);
+
+    // Removing a selected item
+    QVERIFY(scene.selectedItems().isEmpty());
+    item2->setSelected(true);
+    QVERIFY(scene.selectedItems().contains(item2));
+    scene.removeItem(item2);
+    QVERIFY(scene.selectedItems().isEmpty());
+
+    // Check that we are in a state that can receive paint events
+    // (i.e., not logged out on Windows).
+    Q_CHECK_PAINTEVENTS
+
+    // Removing a hovered item
+    HoverItem *hoverItem = new HoverItem;
+    scene.addItem(hoverItem);
+    scene.setSceneRect(-50, -50, 100, 100);
+
+    QGraphicsView view(&scene);
+    view.setFixedSize(150, 150);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::mouseMove(view.viewport(), QPoint(-1, -1));
+    {
+        QMouseEvent moveEvent(QEvent::MouseMove, view.mapFromScene(hoverItem->scenePos() + QPointF(20, 20)), Qt::NoButton, 0, 0);
+        QApplication::sendEvent(view.viewport(), &moveEvent);
+    }
+    qApp->processEvents(); // update
+    qApp->processEvents(); // draw
+    QVERIFY(!hoverItem->isHovered);
+
+    {
+        QTest::qWait(250);
+        QTest::mouseMove(view.viewport(), view.mapFromScene(hoverItem->scenePos()), Qt::NoButton);
+        QTest::qWait(10);
+        QMouseEvent moveEvent(QEvent::MouseMove, view.mapFromScene(hoverItem->scenePos()), Qt::NoButton, 0, 0);
+        QApplication::sendEvent(view.viewport(), &moveEvent);
+    }
+    qApp->processEvents(); // update
+    qApp->processEvents(); // draw
+    QVERIFY(hoverItem->isHovered);
+
+    scene.removeItem(hoverItem);
+    hoverItem->setAcceptsHoverEvents(false);
+    scene.addItem(hoverItem);
+    qApp->processEvents(); // <- delayed update is called
+    qApp->processEvents(); // <- scene schedules pending update
+    qApp->processEvents(); // <- pending update is sent to view
+    QVERIFY(!hoverItem->isHovered);
+}
+#endif
+
+void tst_QGraphicsScene::focusItem()
+{
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    QVERIFY(!scene.focusItem());
+    QGraphicsItem *item = scene.addText("Qt");
+    QVERIFY(!scene.focusItem());
+    item->setFocus();
+    QVERIFY(!scene.focusItem());
+    item->setFlag(QGraphicsItem::ItemIsFocusable);
+    QVERIFY(!scene.focusItem());
+    item->setFocus();
+    QCOMPARE(scene.focusItem(), item);
+
+    QFocusEvent focusOut(QEvent::FocusOut);
+    QApplication::sendEvent(&scene, &focusOut);
+
+    QVERIFY(!scene.focusItem());
+
+    QFocusEvent focusIn(QEvent::FocusIn);
+    QApplication::sendEvent(&scene, &focusIn);
+    QCOMPARE(scene.focusItem(), item);
+
+    QGraphicsItem *item2 = scene.addText("Qt");
+    item2->setFlag(QGraphicsItem::ItemIsFocusable);
+    QCOMPARE(scene.focusItem(), item);
+
+    item2->setFocus();
+    QCOMPARE(scene.focusItem(), item2);
+    item->setFocus();
+    QCOMPARE(scene.focusItem(), item);
+
+    item2->setFocus();
+    QCOMPARE(scene.focusItem(), item2);
+    QApplication::sendEvent(&scene, &focusOut);
+    QVERIFY(!scene.hasFocus());
+    QVERIFY(!scene.focusItem());
+    QApplication::sendEvent(&scene, &focusIn);
+    QCOMPARE(scene.focusItem(), item2);
+
+    QApplication::sendEvent(&scene, &focusOut);
+
+    QVERIFY(!scene.focusItem());
+    scene.removeItem(item2);
+    delete item2;
+
+    QApplication::sendEvent(&scene, &focusIn);
+    QVERIFY(!scene.focusItem());
+}
+
+class FocusItem : public QGraphicsTextItem
+{
+protected:
+    void focusOutEvent(QFocusEvent *)
+    {
+        QVERIFY(!scene()->focusItem());
+    }
+};
+
+void tst_QGraphicsScene::focusItemLostFocus()
+{
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    FocusItem *item = new FocusItem;
+    item->setTextInteractionFlags(Qt::TextEditorInteraction);
+    scene.addItem(item);
+
+    item->setFocus();
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *)item);
+    item->clearFocus();
+}
+
+class ClearTestItem : public QGraphicsRectItem
+{
+public:
+    ClearTestItem(QGraphicsItem *parent = 0) : QGraphicsRectItem(parent) {}
+    ~ClearTestItem() { qDeleteAll(items); }
+    QList<QGraphicsItem *> items;
+};
+
+void tst_QGraphicsScene::clear()
+{
+    QGraphicsScene scene;
+    scene.clear();
+    QVERIFY(scene.items().isEmpty());
+    scene.addRect(0, 0, 100, 100);
+    QCOMPARE(scene.sceneRect(), QRectF(0, 0, 100, 100));
+    scene.clear();
+    QVERIFY(scene.items().isEmpty());
+    QCOMPARE(scene.sceneRect(), QRectF(0, 0, 100, 100));
+
+    ClearTestItem *firstItem = new ClearTestItem;
+    QGraphicsItem *secondItem = new QGraphicsRectItem;
+    firstItem->items += secondItem;
+
+    scene.setItemIndexMethod(QGraphicsScene::NoIndex);
+    scene.addItem(firstItem);
+    scene.addItem(secondItem);
+    QCOMPARE(scene.items().at(0), (QGraphicsItem*)firstItem);
+    QCOMPARE(scene.items().at(1), secondItem);
+
+    ClearTestItem *thirdItem = new ClearTestItem(firstItem);
+    QGraphicsItem *forthItem = new QGraphicsRectItem(firstItem);
+    thirdItem->items += forthItem;
+
+    // must not crash even if firstItem deletes secondItem
+    scene.clear();
+    QVERIFY(scene.items().isEmpty());
+}
+
+void tst_QGraphicsScene::setFocusItem()
+{
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    QGraphicsItem *item = scene.addText("Qt");
+    QVERIFY(!scene.focusItem());
+    QVERIFY(!scene.hasFocus());
+    scene.setFocusItem(item);
+    QVERIFY(!scene.hasFocus());
+    QVERIFY(!scene.focusItem());
+    item->setFlag(QGraphicsItem::ItemIsFocusable);
+
+    for (int i = 0; i < 3; ++i) {
+        scene.setFocusItem(item);
+        QVERIFY(scene.hasFocus());
+        QCOMPARE(scene.focusItem(), item);
+        QVERIFY(item->hasFocus());
+    }
+
+    QGraphicsItem *item2 = scene.addText("Qt");
+    item2->setFlag(QGraphicsItem::ItemIsFocusable);
+
+    scene.setFocusItem(item2);
+    QVERIFY(!item->hasFocus());
+    QVERIFY(item2->hasFocus());
+
+    scene.setFocusItem(item);
+    QVERIFY(item->hasFocus());
+    QVERIFY(!item2->hasFocus());
+
+    scene.clearFocus();
+    QVERIFY(!item->hasFocus());
+    QVERIFY(!item2->hasFocus());
+
+    scene.setFocus();
+    QVERIFY(item->hasFocus());
+    QVERIFY(!item2->hasFocus());
+
+    scene.setFocusItem(0);
+    QVERIFY(!item->hasFocus());
+    QVERIFY(!item2->hasFocus());
+
+    scene.setFocus();
+    QVERIFY(!item->hasFocus());
+    QVERIFY(!item2->hasFocus());
+}
+
+void tst_QGraphicsScene::setFocusItem_inactive()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item = scene.addText("Qt");
+    QVERIFY(!scene.focusItem());
+    QVERIFY(!scene.hasFocus());
+    scene.setFocusItem(item);
+    QVERIFY(!scene.hasFocus());
+    QVERIFY(!scene.focusItem());
+    item->setFlag(QGraphicsItem::ItemIsFocusable);
+
+    for (int i = 0; i < 3; ++i) {
+        scene.setFocusItem(item);
+        QCOMPARE(scene.focusItem(), item);
+        QVERIFY(!item->hasFocus());
+    }
+
+}
+
+
+void tst_QGraphicsScene::mouseGrabberItem()
+{
+    QGraphicsScene scene;
+    QVERIFY(!scene.mouseGrabberItem());
+
+    QGraphicsItem *item = scene.addRect(QRectF(-10, -10, 20, 20));
+    item->setFlag(QGraphicsItem::ItemIsMovable);
+    item->setZValue(1);
+
+    QGraphicsItem *item2 = scene.addRect(QRectF(-10, -10, 20, 20));
+    item2->setFlag(QGraphicsItem::ItemIsMovable);
+    item2->setZValue(0);
+
+    for (int i = 0; i < 3; ++i) {
+        item->setPos(0, 0);
+        item2->setPos(0, 0);
+        item->setZValue((i & 1) ? 0 : 1);
+        item2->setZValue((i & 1) ? 1 : 0);
+        QGraphicsItem *topMostItem = (i & 1) ? item2 : item;
+
+        QGraphicsSceneMouseEvent pressEvent(QEvent::GraphicsSceneMousePress);
+        pressEvent.setButton(Qt::LeftButton);
+        pressEvent.setScenePos(QPointF(0, 0));
+        pressEvent.setScreenPos(QPoint(100, 100));
+
+        QApplication::sendEvent(&scene, &pressEvent);
+        QCOMPARE(scene.mouseGrabberItem(), topMostItem);
+
+        for (int i = 0; i < 1000; ++i) {
+            QGraphicsSceneMouseEvent moveEvent(QEvent::GraphicsSceneMouseMove);
+            moveEvent.setButtons(Qt::LeftButton);
+            moveEvent.setScenePos(QPointF(i * 10, i * 10));
+            moveEvent.setScreenPos(QPoint(100 + i * 10, 100 + i * 10));
+            QApplication::sendEvent(&scene, &moveEvent);
+            QCOMPARE(scene.mouseGrabberItem(), topMostItem);
+
+            // Geometrical changes should not affect the mouse grabber.
+            item->setZValue(rand() % 500);
+            item2->setZValue(rand() % 500);
+            item->setPos(rand() % 50000, rand() % 50000);
+            item2->setPos(rand() % 50000, rand() % 50000);
+        }
+
+        QGraphicsSceneMouseEvent releaseEvent(QEvent::GraphicsSceneMouseRelease);
+        releaseEvent.setScenePos(QPointF(10000, 10000));
+        releaseEvent.setScreenPos(QPoint(1000000, 1000000));
+        QApplication::sendEvent(&scene, &releaseEvent);
+        QVERIFY(!scene.mouseGrabberItem());
+    }
+
+    // Structural change: deleting the mouse grabber
+    item->setPos(0, 0);
+    item->setZValue(1);
+    item2->setPos(0, 0);
+    item2->setZValue(0);
+    QGraphicsSceneMouseEvent pressEvent(QEvent::GraphicsSceneMousePress);
+    pressEvent.setButton(Qt::LeftButton);
+    pressEvent.setScenePos(QPointF(0, 0));
+    pressEvent.setScreenPos(QPoint(100, 100));
+
+    QGraphicsSceneMouseEvent moveEvent(QEvent::GraphicsSceneMouseMove);
+    moveEvent.setButtons(Qt::LeftButton);
+    moveEvent.setScenePos(QPointF(0, 0));
+    moveEvent.setScreenPos(QPoint(100, 100));
+
+    QApplication::sendEvent(&scene, &pressEvent);
+    QApplication::sendEvent(&scene, &moveEvent);
+    QCOMPARE(scene.mouseGrabberItem(), item);
+    item->setVisible(false);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+    QApplication::sendEvent(&scene, &pressEvent);
+    QCOMPARE(scene.mouseGrabberItem(), item2);
+    item2->setVisible(false);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+    QApplication::sendEvent(&scene, &moveEvent);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+    item2->setVisible(true);
+    QApplication::sendEvent(&scene, &moveEvent);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+    QApplication::sendEvent(&scene, &pressEvent);
+    QApplication::sendEvent(&scene, &moveEvent);
+    QCOMPARE(scene.mouseGrabberItem(), item2);
+    scene.removeItem(item2);
+    delete item2;
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+}
+
+void tst_QGraphicsScene::hoverEvents_siblings()
+{
+    Q_CHECK_PAINTEVENTS
+
+    QGraphicsScene scene;
+    QGraphicsItem *lastItem = 0;
+    QList<HoverItem *> items;
+    for (int i = 0; i < 15; ++i) {
+        QGraphicsItem *item = new HoverItem;
+        scene.addItem(item);
+        items << (HoverItem *)item;
+        if (lastItem) {
+            item->setPos(lastItem->pos() + QPointF(sin(i / 3.0) * 17, cos(i / 3.0) * 17));
+        }
+        item->setZValue(i);
+        lastItem = item;
+    }
+
+    QGraphicsView view(&scene);
+    view.setRenderHint(QPainter::Antialiasing, true);
+#if defined(Q_OS_WINCE)
+    view.setMinimumSize(230, 200);
+#else
+    view.setMinimumSize(400, 300);
+#endif
+    view.rotate(10);
+    view.scale(1.7, 1.7);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    qApp->setActiveWindow(&view);
+    view.activateWindow();
+    QTest::qWait(70);
+
+    QCursor::setPos(view.mapToGlobal(QPoint(-5, -5)));
+
+    QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove);
+    mouseEvent.setScenePos(QPointF(-1000, -1000));
+    QApplication::sendEvent(&scene, &mouseEvent);
+
+    QTest::qWait(50);
+
+    for (int j = 1; j >= 0; --j) {
+        int i = j ? 0 : 14;
+        forever {
+            if (j)
+                QVERIFY(!items.at(i)->isHovered);
+            else
+                QVERIFY(!items.at(i)->isHovered);
+            QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove);
+            mouseEvent.setScenePos(items.at(i)->mapToScene(0, 0));
+            QApplication::sendEvent(&scene, &mouseEvent);
+
+            qApp->processEvents(); // this posts updates from the scene to the view
+            qApp->processEvents(); // which trigger a repaint here
+
+            QTRY_VERIFY(items.at(i)->isHovered);
+            if (j && i > 0)
+                QVERIFY(!items.at(i - 1)->isHovered);
+            if (!j && i < 14)
+                QVERIFY(!items.at(i + 1)->isHovered);
+            i += j ? 1 : -1;
+            if ((j && i == 15) || (!j && i == -1))
+                break;
+        }
+
+        QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove);
+        mouseEvent.setScenePos(QPointF(-1000, -1000));
+        QApplication::sendEvent(&scene, &mouseEvent);
+
+        qApp->processEvents(); // this posts updates from the scene to the view
+        qApp->processEvents(); // which trigger a repaint here
+    }
+}
+
+void tst_QGraphicsScene::hoverEvents_parentChild()
+{
+    Q_CHECK_PAINTEVENTS
+
+    QGraphicsScene scene;
+    QGraphicsItem *lastItem = 0;
+    QList<HoverItem *> items;
+    for (int i = 0; i < 15; ++i) {
+        QGraphicsItem *item = new HoverItem;
+        scene.addItem(item);
+        items << (HoverItem *)item;
+        if (lastItem) {
+            item->setParentItem(lastItem);
+            item->setPos(sin(i / 3.0) * 17, cos(i / 3.0) * 17);
+        }
+        lastItem = item;
+    }
+
+    QGraphicsView view(&scene);
+    view.setRenderHint(QPainter::Antialiasing, true);
+#if defined(Q_OS_WINCE)
+    view.setMinimumSize(230, 200);
+#else
+    view.setMinimumSize(400, 300);
+#endif
+    view.rotate(10);
+    view.scale(1.7, 1.7);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTest::qWait(70);
+
+    QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove);
+    mouseEvent.setScenePos(QPointF(-1000, -1000));
+    QApplication::sendEvent(&scene, &mouseEvent);
+
+    for (int j = 1; j >= 0; --j) {
+        int i = j ? 0 : 14;
+        forever {
+            if (j) {
+                QVERIFY(!items.at(i)->isHovered);
+            } else {
+                if (i == 14)
+                    QVERIFY(!items.at(13)->isHovered);
+            }
+            mouseEvent.setScenePos(items.at(i)->mapToScene(0, 0));
+            QApplication::sendEvent(&scene, &mouseEvent);
+
+            qApp->processEvents(); // this posts updates from the scene to the view
+            qApp->processEvents(); // which trigger a repaint here
+
+            QTRY_VERIFY(items.at(i)->isHovered);
+            if (i < 14)
+                QVERIFY(!items.at(i + 1)->isHovered);
+            i += j ? 1 : -1;
+            if ((j && i == 15) || (!j && i == -1))
+                break;
+        }
+
+        mouseEvent.setScenePos(QPointF(-1000, -1000));
+        QApplication::sendEvent(&scene, &mouseEvent);
+
+        qApp->processEvents(); // this posts updates from the scene to the view
+        qApp->processEvents(); // which trigger a repaint here
+    }
+}
+
+void tst_QGraphicsScene::createItemGroup()
+{
+    QGraphicsScene scene;
+
+    QList<QGraphicsItem *> children1;
+    children1 << scene.addRect(QRectF(-10, -10, 20, 20));
+    children1 << scene.addRect(QRectF(-10, -10, 20, 20));
+    children1 << scene.addRect(QRectF(-10, -10, 20, 20));
+    children1 << scene.addRect(QRectF(-10, -10, 20, 20));
+
+    QList<QGraphicsItem *> children2;
+    children2 << scene.addRect(QRectF(-10, -10, 20, 20));
+    children2 << scene.addRect(QRectF(-10, -10, 20, 20));
+    children2 << scene.addRect(QRectF(-10, -10, 20, 20));
+    children2 << scene.addRect(QRectF(-10, -10, 20, 20));
+
+    QList<QGraphicsItem *> children3;
+    children3 << scene.addRect(QRectF(-10, -10, 20, 20));
+    children3 << scene.addRect(QRectF(-10, -10, 20, 20));
+    children3 << scene.addRect(QRectF(-10, -10, 20, 20));
+    children3 << scene.addRect(QRectF(-10, -10, 20, 20));
+
+    // All items in children1 are children of parent1
+    QGraphicsItem *parent1 = scene.addRect(QRectF(-10, -10, 20, 20));
+    foreach (QGraphicsItem *item, children1)
+        item->setParentItem(parent1);
+
+    QGraphicsItemGroup *group = scene.createItemGroup(children1);
+    QCOMPARE(group->parentItem(), parent1);
+    QCOMPARE(children1.first()->parentItem(), (QGraphicsItem *)group);
+    scene.destroyItemGroup(group);
+    QCOMPARE(children1.first()->parentItem(), parent1);
+    group = scene.createItemGroup(children1);
+    QCOMPARE(group->parentItem(), parent1);
+    QCOMPARE(children1.first()->parentItem(), (QGraphicsItem *)group);
+    scene.destroyItemGroup(group);
+    QCOMPARE(children1.first()->parentItem(), parent1);
+
+    // All items in children2 are children of parent2
+    QGraphicsItem *parent2 = scene.addRect(QRectF(-10, -10, 20, 20));
+    foreach (QGraphicsItem *item, children2)
+        item->setParentItem(parent2);
+
+    // Now make parent2 a child of parent1, so all children2 are also children
+    // of parent1.
+    parent2->setParentItem(parent1);
+
+    // The children2 group should still have parent2 as their common ancestor.
+    group = scene.createItemGroup(children2);
+    QCOMPARE(group->parentItem(), parent2);
+    QCOMPARE(children2.first()->parentItem(), (QGraphicsItem *)group);
+    scene.destroyItemGroup(group);
+    QCOMPARE(children2.first()->parentItem(), parent2);
+
+    // But the set of both children2 and children1 share only parent1.
+    group = scene.createItemGroup(children2 + children1);
+    QCOMPARE(group->parentItem(), parent1);
+    QCOMPARE(children1.first()->parentItem(), (QGraphicsItem *)group);
+    QCOMPARE(children2.first()->parentItem(), (QGraphicsItem *)group);
+    scene.destroyItemGroup(group);
+    QCOMPARE(children1.first()->parentItem(), parent1);
+    QCOMPARE(children2.first()->parentItem(), parent1);
+
+    // Fixup the parent-child chain
+    foreach (QGraphicsItem *item, children2)
+        item->setParentItem(parent2);
+
+    // These share no common parent
+    group = scene.createItemGroup(children3);
+    QCOMPARE(group->parentItem(), (QGraphicsItem *)0);
+    scene.destroyItemGroup(group);
+
+    // Make children3 children of parent3
+    QGraphicsItem *parent3 = scene.addRect(QRectF(-10, -10, 20, 20));
+    foreach (QGraphicsItem *item, children3)
+        item->setParentItem(parent3);
+
+    // These should have parent3 as a parent
+    group = scene.createItemGroup(children3);
+    QCOMPARE(group->parentItem(), parent3);
+    scene.destroyItemGroup(group);
+
+    // Now make them all children of parent1
+    parent3->setParentItem(parent1);
+
+    group = scene.createItemGroup(children3);
+    QCOMPARE(group->parentItem(), parent3);
+    scene.destroyItemGroup(group);
+
+    group = scene.createItemGroup(children2);
+    QCOMPARE(group->parentItem(), parent2);
+    scene.destroyItemGroup(group);
+
+    group = scene.createItemGroup(children1);
+    QCOMPARE(group->parentItem(), parent1);
+    scene.destroyItemGroup(group);
+
+    QGraphicsItemGroup *emptyGroup = scene.createItemGroup(QList<QGraphicsItem *>());
+    QCOMPARE(emptyGroup->children(), QList<QGraphicsItem *>());
+    QVERIFY(!emptyGroup->parentItem());
+    QCOMPARE(emptyGroup->scene(), &scene);
+}
+
+class EventTester : public QGraphicsEllipseItem
+{
+public:
+    EventTester()
+        : QGraphicsEllipseItem(QRectF(-10, -10, 20, 20)), ignoreMouse(false)
+    { }
+
+    bool ignoreMouse;
+    QList<QEvent::Type> eventTypes;
+
+protected:
+    bool sceneEvent(QEvent *event)
+    {
+        eventTypes << QEvent::Type(event->type());
+        switch (event->type()) {
+        case QEvent::GraphicsSceneMousePress:
+        case QEvent::GraphicsSceneMouseMove:
+        case QEvent::GraphicsSceneMouseRelease:
+            if (ignoreMouse) {
+                event->ignore();
+                return true;
+            }
+        default:
+            break;
+        }
+
+        return QGraphicsEllipseItem::sceneEvent(event);
+    }
+};
+
+void tst_QGraphicsScene::mouseEventPropagation()
+{
+    EventTester *a = new EventTester;
+    EventTester *b = new EventTester;
+    EventTester *c = new EventTester;
+    EventTester *d = new EventTester;
+    b->setParentItem(a);
+    c->setParentItem(b);
+    d->setParentItem(c);
+
+    a->setFlag(QGraphicsItem::ItemIsMovable);
+    b->setFlag(QGraphicsItem::ItemIsMovable);
+    c->setFlag(QGraphicsItem::ItemIsMovable);
+    d->setFlag(QGraphicsItem::ItemIsMovable);
+
+    a->setData(0, "A");
+    b->setData(0, "B");
+    c->setData(0, "C");
+    d->setData(0, "D");
+
+    // scene -> a -> b -> c -> d
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    scene.addItem(a);
+
+    // Prepare some events
+    QGraphicsSceneMouseEvent pressEvent(QEvent::GraphicsSceneMousePress);
+    pressEvent.setButton(Qt::LeftButton);
+    pressEvent.setScenePos(QPointF(0, 0));
+    QGraphicsSceneMouseEvent moveEvent(QEvent::GraphicsSceneMouseMove);
+    moveEvent.setButton(Qt::LeftButton);
+    moveEvent.setScenePos(QPointF(0, 0));
+    QGraphicsSceneMouseEvent releaseEvent(QEvent::GraphicsSceneMouseRelease);
+    releaseEvent.setButton(Qt::LeftButton);
+    releaseEvent.setScenePos(QPointF(0, 0));
+
+    // Send a press
+    QApplication::sendEvent(&scene, &pressEvent);
+    QCOMPARE(d->eventTypes.size(), 2);
+    QCOMPARE(d->eventTypes.at(0), QEvent::GrabMouse);
+    QCOMPARE(d->eventTypes.at(1), QEvent::GraphicsSceneMousePress);
+    QCOMPARE(c->eventTypes.size(), 0);
+    QCOMPARE(b->eventTypes.size(), 0);
+    QCOMPARE(a->eventTypes.size(), 0);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)d);
+
+    // Send a move
+    QApplication::sendEvent(&scene, &moveEvent);
+    QCOMPARE(d->eventTypes.size(), 3);
+    QCOMPARE(d->eventTypes.at(2), QEvent::GraphicsSceneMouseMove);
+    QCOMPARE(c->eventTypes.size(), 0);
+    QCOMPARE(b->eventTypes.size(), 0);
+    QCOMPARE(a->eventTypes.size(), 0);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)d);
+
+    // Send a release
+    QApplication::sendEvent(&scene, &releaseEvent);
+    QCOMPARE(d->eventTypes.size(), 5);
+    QCOMPARE(d->eventTypes.at(3), QEvent::GraphicsSceneMouseRelease);
+    QCOMPARE(d->eventTypes.at(4), QEvent::UngrabMouse);
+    QCOMPARE(c->eventTypes.size(), 0);
+    QCOMPARE(b->eventTypes.size(), 0);
+    QCOMPARE(a->eventTypes.size(), 0);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+
+    d->setAcceptedMouseButtons(Qt::RightButton);
+
+    // Send a press
+    QApplication::sendEvent(&scene, &pressEvent);
+    QCOMPARE(d->eventTypes.size(), 5);
+    QCOMPARE(c->eventTypes.size(), 2);
+    QCOMPARE(c->eventTypes.at(0), QEvent::GrabMouse);
+    QCOMPARE(c->eventTypes.at(1), QEvent::GraphicsSceneMousePress);
+    QCOMPARE(b->eventTypes.size(), 0);
+    QCOMPARE(a->eventTypes.size(), 0);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)c);
+
+    // Send another press, with a button that isn't actually accepted
+    QApplication::sendEvent(&scene, &pressEvent);
+    pressEvent.setButton(Qt::RightButton);
+    QCOMPARE(d->eventTypes.size(), 5);
+    QCOMPARE(c->eventTypes.size(), 3);
+    QCOMPARE(c->eventTypes.at(2), QEvent::GraphicsSceneMousePress);
+    QCOMPARE(b->eventTypes.size(), 0);
+    QCOMPARE(a->eventTypes.size(), 0);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)c);
+
+    // Send a move
+    QApplication::sendEvent(&scene, &moveEvent);
+    QCOMPARE(d->eventTypes.size(), 5);
+    QCOMPARE(c->eventTypes.size(), 4);
+    QCOMPARE(c->eventTypes.at(3), QEvent::GraphicsSceneMouseMove);
+    QCOMPARE(b->eventTypes.size(), 0);
+    QCOMPARE(a->eventTypes.size(), 0);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)c);
+
+    // Send a release
+    QApplication::sendEvent(&scene, &releaseEvent);
+    QCOMPARE(d->eventTypes.size(), 5);
+    QCOMPARE(c->eventTypes.size(), 6);
+    QCOMPARE(c->eventTypes.at(4), QEvent::GraphicsSceneMouseRelease);
+    QCOMPARE(c->eventTypes.at(5), QEvent::UngrabMouse);
+    QCOMPARE(b->eventTypes.size(), 0);
+    QCOMPARE(a->eventTypes.size(), 0);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+
+    // Disabled items eat events. c should not get this.
+    d->setEnabled(false);
+    d->setAcceptedMouseButtons(Qt::RightButton);
+
+    // Send a right press. This disappears in d.
+    QApplication::sendEvent(&scene, &pressEvent);
+    QCOMPARE(d->eventTypes.size(), 5);
+    QCOMPARE(c->eventTypes.size(), 6);
+    QCOMPARE(b->eventTypes.size(), 0);
+    QCOMPARE(a->eventTypes.size(), 0);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+
+    // Send a left press. This goes to c.
+    pressEvent.setButton(Qt::LeftButton);
+    QApplication::sendEvent(&scene, &pressEvent);
+    QCOMPARE(d->eventTypes.size(), 5);
+    QCOMPARE(c->eventTypes.size(), 8);
+    QCOMPARE(c->eventTypes.at(6), QEvent::GrabMouse);
+    QCOMPARE(c->eventTypes.at(7), QEvent::GraphicsSceneMousePress);
+    QCOMPARE(b->eventTypes.size(), 0);
+    QCOMPARE(a->eventTypes.size(), 0);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)c);
+
+    // Clicking outside the items removes the mouse grabber
+}
+
+void tst_QGraphicsScene::mouseEventPropagation_ignore()
+{
+    EventTester *a = new EventTester;
+    EventTester *b = new EventTester;
+    EventTester *c = new EventTester;
+    EventTester *d = new EventTester;
+    b->setParentItem(a);
+    c->setParentItem(b);
+    d->setParentItem(c);
+
+    a->setFlags(QGraphicsItem::ItemIsMovable);
+    b->setFlags(QGraphicsItem::ItemIsMovable);
+    c->setFlags(QGraphicsItem::ItemIsMovable);
+    d->setFlags(QGraphicsItem::ItemIsMovable);
+
+    // scene -> a -> b -> c -> d
+    QGraphicsScene scene;
+    scene.addItem(a);
+
+    // Prepare some events
+    QGraphicsSceneMouseEvent pressEvent(QEvent::GraphicsSceneMousePress);
+    pressEvent.setButton(Qt::LeftButton);
+    pressEvent.setScenePos(QPointF(0, 0));
+
+    b->ignoreMouse = true;
+    c->ignoreMouse = true;
+    d->ignoreMouse = true;
+
+    QApplication::sendEvent(&scene, &pressEvent);
+    QCOMPARE(a->eventTypes.size(), 2);
+    QCOMPARE(a->eventTypes.at(0), QEvent::GrabMouse);
+    QCOMPARE(a->eventTypes.at(1), QEvent::GraphicsSceneMousePress);
+    QCOMPARE(b->eventTypes.size(), 3);
+    QCOMPARE(b->eventTypes.at(0), QEvent::GrabMouse);
+    QCOMPARE(b->eventTypes.at(1), QEvent::GraphicsSceneMousePress);
+    QCOMPARE(b->eventTypes.at(2), QEvent::UngrabMouse);
+    QCOMPARE(c->eventTypes.size(), 3);
+    QCOMPARE(c->eventTypes.at(0), QEvent::GrabMouse);
+    QCOMPARE(c->eventTypes.at(1), QEvent::GraphicsSceneMousePress);
+    QCOMPARE(c->eventTypes.at(2), QEvent::UngrabMouse);
+    QCOMPARE(d->eventTypes.size(), 3);
+    QCOMPARE(d->eventTypes.at(0), QEvent::GrabMouse);
+    QCOMPARE(d->eventTypes.at(1), QEvent::GraphicsSceneMousePress);
+    QCOMPARE(d->eventTypes.at(2), QEvent::UngrabMouse);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)a);
+
+    a->ignoreMouse = true;
+
+    QApplication::sendEvent(&scene, &pressEvent);
+    QCOMPARE(a->eventTypes.size(), 3);
+    QCOMPARE(a->eventTypes.at(2), QEvent::GraphicsSceneMousePress);
+    QCOMPARE(b->eventTypes.size(), 3);
+    QCOMPARE(c->eventTypes.size(), 3);
+    QCOMPARE(d->eventTypes.size(), 3);
+
+    QVERIFY(!pressEvent.isAccepted());
+}
+
+void tst_QGraphicsScene::mouseEventPropagation_focus()
+{
+    EventTester *a = new EventTester;
+    EventTester *b = new EventTester;
+    EventTester *c = new EventTester;
+    EventTester *d = new EventTester;
+    b->setParentItem(a);
+    c->setParentItem(b);
+    d->setParentItem(c);
+
+    a->setFlag(QGraphicsItem::ItemIsMovable);
+    b->setFlag(QGraphicsItem::ItemIsMovable);
+    c->setFlag(QGraphicsItem::ItemIsMovable);
+    d->setFlag(QGraphicsItem::ItemIsMovable);
+
+    // scene -> a -> b -> c -> d
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    scene.addItem(a);
+
+    // Prepare some events
+    QGraphicsSceneMouseEvent pressEvent(QEvent::GraphicsSceneMousePress);
+    pressEvent.setButton(Qt::LeftButton);
+    pressEvent.setScenePos(QPointF(0, 0));
+
+    a->setFlag(QGraphicsItem::ItemIsFocusable);
+    QVERIFY(!a->hasFocus());
+
+    QApplication::sendEvent(&scene, &pressEvent);
+
+    QVERIFY(a->hasFocus());
+    QCOMPARE(a->eventTypes.size(), 1);
+    QCOMPARE(a->eventTypes.first(), QEvent::FocusIn);
+    QCOMPARE(d->eventTypes.size(), 2);
+    QCOMPARE(d->eventTypes.at(0), QEvent::GrabMouse);
+    QCOMPARE(d->eventTypes.at(1), QEvent::GraphicsSceneMousePress);
+}
+
+void tst_QGraphicsScene::mouseEventPropagation_doubleclick()
+{
+    EventTester *a = new EventTester;
+    EventTester *b = new EventTester;
+    a->setFlags(QGraphicsItem::ItemIsMovable);
+    b->setFlags(QGraphicsItem::ItemIsMovable);
+
+    a->setPos(-50, 0);
+    b->setPos(50, 0);
+
+    QGraphicsScene scene;
+    scene.addItem(a);
+    scene.addItem(b);
+
+    // Prepare some events
+    QGraphicsSceneMouseEvent pressEvent(QEvent::GraphicsSceneMousePress);
+    pressEvent.setButton(Qt::LeftButton);
+    pressEvent.setScenePos(QPointF(0, 0));
+    QGraphicsSceneMouseEvent doubleClickEvent(QEvent::GraphicsSceneMouseDoubleClick);
+    doubleClickEvent.setButton(Qt::LeftButton);
+    doubleClickEvent.setScenePos(QPointF(0, 0));
+    QGraphicsSceneMouseEvent releaseEvent(QEvent::GraphicsSceneMouseRelease);
+    releaseEvent.setButton(Qt::LeftButton);
+    releaseEvent.setScenePos(QPointF(0, 0));
+
+    // Send press to A
+    pressEvent.setScenePos(a->mapToScene(0, 0));
+    QApplication::sendEvent(&scene, &pressEvent);
+    QCOMPARE(a->eventTypes.size(), 2);
+    QCOMPARE(a->eventTypes.at(0), QEvent::GrabMouse);
+    QCOMPARE(a->eventTypes.at(1), QEvent::GraphicsSceneMousePress);
+
+    // Send release to A
+    releaseEvent.setScenePos(a->mapToScene(0, 0));
+    QApplication::sendEvent(&scene, &releaseEvent);
+    QCOMPARE(a->eventTypes.size(), 4);
+    QCOMPARE(a->eventTypes.at(2), QEvent::GraphicsSceneMouseRelease);
+    QCOMPARE(a->eventTypes.at(3), QEvent::UngrabMouse);
+
+    // Send doubleclick to B
+    doubleClickEvent.setScenePos(b->mapToScene(0, 0));
+    QApplication::sendEvent(&scene, &doubleClickEvent);
+    QCOMPARE(a->eventTypes.size(), 4);
+    QCOMPARE(b->eventTypes.size(), 2);
+    QCOMPARE(b->eventTypes.at(0), QEvent::GrabMouse);
+    QCOMPARE(b->eventTypes.at(1), QEvent::GraphicsSceneMousePress);
+
+    // Send release to B
+    releaseEvent.setScenePos(b->mapToScene(0, 0));
+    QApplication::sendEvent(&scene, &releaseEvent);
+    QCOMPARE(a->eventTypes.size(), 4);
+    QCOMPARE(b->eventTypes.size(), 4);
+    QCOMPARE(b->eventTypes.at(2), QEvent::GraphicsSceneMouseRelease);
+    QCOMPARE(b->eventTypes.at(3), QEvent::UngrabMouse);
+}
+
+class Scene : public QGraphicsScene
+{
+public:
+    QList<QPointF> mouseMovePoints;
+
+protected:
+    void mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+    {
+        mouseMovePoints << event->scenePos();
+    }
+};
+
+void tst_QGraphicsScene::mouseEventPropagation_mouseMove()
+{
+    Scene scene;
+    scene.addRect(QRectF(5, 0, 12, 12));
+    scene.addRect(QRectF(15, 0, 12, 12))->setAcceptsHoverEvents(true);
+    for (int i = 0; i < 30; ++i) {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseMove);
+        event.setScenePos(QPointF(i, 5));
+        QApplication::sendEvent(&scene, &event);
+    }
+
+    QCOMPARE(scene.mouseMovePoints.size(), 30);
+    for (int i = 0; i < 30; ++i)
+        QCOMPARE(scene.mouseMovePoints.at(i), QPointF(i, 5));
+}
+
+class DndTester : public QGraphicsEllipseItem
+{
+public:
+    DndTester(const QRectF &rect)
+        : QGraphicsEllipseItem(rect), lastEvent(0),
+          ignoresDragEnter(false), ignoresDragMove(false)
+
+    {
+    }
+
+    ~DndTester()
+    {
+        delete lastEvent;
+    }
+
+    QGraphicsSceneDragDropEvent *lastEvent;
+    QList<QEvent::Type> eventList;
+    bool ignoresDragEnter;
+    bool ignoresDragMove;
+
+protected:
+    void dragEnterEvent(QGraphicsSceneDragDropEvent *event)
+    {
+        storeLastEvent(event);
+        event->setAccepted(!ignoresDragEnter);
+        if (!ignoresDragEnter)
+            event->setDropAction(Qt::IgnoreAction);
+        eventList << event->type();
+    }
+
+    void dragMoveEvent(QGraphicsSceneDragDropEvent *event)
+    {
+        storeLastEvent(event);
+        event->setAccepted(!ignoresDragMove);
+        eventList << event->type();
+    }
+
+    void dragLeaveEvent(QGraphicsSceneDragDropEvent *event)
+    {
+        storeLastEvent(event);
+        eventList << event->type();
+    }
+
+    void dropEvent(QGraphicsSceneDragDropEvent *event)
+    {
+        storeLastEvent(event);
+        eventList << event->type();
+    }
+
+private:
+    void storeLastEvent(QGraphicsSceneDragDropEvent *event)
+    {
+        delete lastEvent;
+        lastEvent = new QGraphicsSceneDragDropEvent(event->type());
+        lastEvent->setScenePos(event->scenePos());
+        lastEvent->setScreenPos(event->screenPos());
+        lastEvent->setButtons(event->buttons());
+        lastEvent->setModifiers(event->modifiers());
+        lastEvent->setPossibleActions(event->possibleActions());
+        lastEvent->setProposedAction(event->proposedAction());
+        lastEvent->setDropAction(event->dropAction());
+        lastEvent->setMimeData(event->mimeData());
+        lastEvent->setWidget(event->widget());
+        lastEvent->setSource(event->source());
+    }
+};
+
+#ifndef QT_NO_DRAGANDDROP
+void tst_QGraphicsScene::dragAndDrop_simple()
+{
+    DndTester *item = new DndTester(QRectF(-10, -10, 20, 20));
+
+    QGraphicsScene scene;
+    scene.addItem(item);
+
+    QGraphicsView view(&scene);
+    view.setFixedSize(100, 100);
+
+    QMimeData mimeData;
+
+    // Initial drag enter for the scene
+    QDragEnterEvent dragEnter(QPoint(0, 0), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+    QApplication::sendEvent(view.viewport(), &dragEnter);
+    QVERIFY(dragEnter.isAccepted());
+    QCOMPARE(dragEnter.dropAction(), Qt::CopyAction);
+
+    {
+        // Move outside the item
+        QDragMoveEvent dragMove(QPoint(0, 0), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(!dragMove.isAccepted());
+        QCOMPARE(dragMove.dropAction(), Qt::CopyAction);
+    }
+    {
+        // Move inside the item without setAcceptDrops
+        QDragMoveEvent dragMove(view.mapFromScene(item->scenePos()), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(!dragMove.isAccepted());
+        QCOMPARE(dragMove.dropAction(), Qt::CopyAction);
+        QCOMPARE(item->eventList.size(), 0);
+    }
+    item->setAcceptDrops(true);
+    {
+        // Move inside the item with setAcceptDrops
+        QDragMoveEvent dragMove(view.mapFromScene(item->scenePos()), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(dragMove.isAccepted());
+        QCOMPARE(dragMove.dropAction(), Qt::IgnoreAction);
+        QCOMPARE(item->eventList.size(), 2);
+        QCOMPARE(item->eventList.at(0), QEvent::GraphicsSceneDragEnter);
+        QCOMPARE(item->eventList.at(1), QEvent::GraphicsSceneDragMove);
+        QCOMPARE(item->lastEvent->screenPos(), view.mapToGlobal(dragMove.pos()));
+        QCOMPARE(item->lastEvent->scenePos(), view.mapToScene(dragMove.pos()));
+        QVERIFY(item->lastEvent->isAccepted());
+        QCOMPARE(item->lastEvent->dropAction(), Qt::IgnoreAction);
+    }
+    {
+        // Another move inside the item
+        QDragMoveEvent dragMove(view.mapFromScene(item->mapToScene(5, 5)), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(dragMove.isAccepted());
+        QCOMPARE(dragMove.dropAction(), Qt::IgnoreAction);
+        QCOMPARE(item->eventList.size(), 3);
+        QCOMPARE(item->eventList.at(2), QEvent::GraphicsSceneDragMove);
+        QCOMPARE(item->lastEvent->screenPos(), view.mapToGlobal(dragMove.pos()));
+        QCOMPARE(item->lastEvent->scenePos(), view.mapToScene(dragMove.pos()));
+        QVERIFY(item->lastEvent->isAccepted());
+        QCOMPARE(item->lastEvent->dropAction(), Qt::IgnoreAction);
+    }
+    {
+        // Move outside the item
+        QDragMoveEvent dragMove(QPoint(0, 0), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(!dragMove.isAccepted());
+        QCOMPARE(dragMove.dropAction(), Qt::CopyAction);
+        QCOMPARE(item->eventList.size(), 4);
+        QCOMPARE(item->eventList.at(3), QEvent::GraphicsSceneDragLeave);
+        QCOMPARE(item->lastEvent->screenPos(), view.mapToGlobal(dragMove.pos()));
+        QCOMPARE(item->lastEvent->scenePos(), view.mapToScene(dragMove.pos()));
+        QVERIFY(item->lastEvent->isAccepted());
+        QCOMPARE(item->lastEvent->dropAction(), Qt::CopyAction);
+    }
+    {
+        // Move inside the item again
+        QDragMoveEvent dragMove(view.mapFromScene(item->scenePos()), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(dragMove.isAccepted());
+        QCOMPARE(dragMove.dropAction(), Qt::IgnoreAction);
+        QCOMPARE(item->eventList.size(), 6);
+        QCOMPARE(item->eventList.at(4), QEvent::GraphicsSceneDragEnter);
+        QCOMPARE(item->eventList.at(5), QEvent::GraphicsSceneDragMove);
+        QCOMPARE(item->lastEvent->screenPos(), view.mapToGlobal(dragMove.pos()));
+        QCOMPARE(item->lastEvent->scenePos(), view.mapToScene(dragMove.pos()));
+        QVERIFY(item->lastEvent->isAccepted());
+        QCOMPARE(item->lastEvent->dropAction(), Qt::IgnoreAction);
+    }
+    {
+        // Drop inside the item
+        QDropEvent drop(view.mapFromScene(item->scenePos()), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &drop);
+        QVERIFY(drop.isAccepted());
+        QCOMPARE(drop.dropAction(), Qt::CopyAction);
+        QCOMPARE(item->eventList.size(), 7);
+        QCOMPARE(item->eventList.at(6), QEvent::GraphicsSceneDrop);
+        QCOMPARE(item->lastEvent->screenPos(), view.mapToGlobal(drop.pos()));
+        QCOMPARE(item->lastEvent->scenePos(), view.mapToScene(drop.pos()));
+        QVERIFY(item->lastEvent->isAccepted());
+        QCOMPARE(item->lastEvent->dropAction(), Qt::CopyAction);
+    }
+}
+
+void tst_QGraphicsScene::dragAndDrop_disabledOrInvisible()
+{
+    DndTester *item = new DndTester(QRectF(-10, -10, 20, 20));
+    item->setAcceptDrops(true);
+
+    QGraphicsScene scene;
+    scene.addItem(item);
+
+    QGraphicsView view(&scene);
+    view.setFixedSize(100, 100);
+
+    QMimeData mimeData;
+
+    // Initial drag enter for the scene
+    QDragEnterEvent dragEnter(QPoint(0, 0), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+    QApplication::sendEvent(view.viewport(), &dragEnter);
+    QVERIFY(dragEnter.isAccepted());
+    QCOMPARE(dragEnter.dropAction(), Qt::CopyAction);
+    {
+        // Move inside the item
+        QDragMoveEvent dragMove(view.mapFromScene(item->scenePos()), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(dragMove.isAccepted());
+        QCOMPARE(dragMove.dropAction(), Qt::IgnoreAction);
+        QCOMPARE(item->eventList.size(), 2);
+        QCOMPARE(item->eventList.at(0), QEvent::GraphicsSceneDragEnter);
+        QCOMPARE(item->eventList.at(1), QEvent::GraphicsSceneDragMove);
+    }
+    {
+        // Move outside the item
+        QDragMoveEvent dragMove(QPoint(0, 0), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(!dragMove.isAccepted());
+        QCOMPARE(dragMove.dropAction(), Qt::CopyAction);
+        QCOMPARE(item->eventList.size(), 3);
+        QCOMPARE(item->eventList.at(2), QEvent::GraphicsSceneDragLeave);
+    }
+
+    // Now disable the item
+    item->setEnabled(false);
+    QVERIFY(!item->isEnabled());
+    QVERIFY(item->isVisible());
+
+    {
+        // Move inside the item
+        QDragMoveEvent dragMove(view.mapFromScene(item->scenePos()), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(!dragMove.isAccepted());
+        QCOMPARE(dragMove.dropAction(), Qt::CopyAction);
+        QCOMPARE(item->eventList.size(), 3);
+        QCOMPARE(item->eventList.at(2), QEvent::GraphicsSceneDragLeave);
+    }
+
+    // Reenable it, and make it invisible
+    item->setEnabled(true);
+    item->setVisible(false);
+    QVERIFY(item->isEnabled());
+    QVERIFY(!item->isVisible());
+
+    {
+        // Move inside the item
+        QDragMoveEvent dragMove(view.mapFromScene(item->scenePos()), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(!dragMove.isAccepted());
+        QCOMPARE(dragMove.dropAction(), Qt::CopyAction);
+        QCOMPARE(item->eventList.size(), 3);
+        QCOMPARE(item->eventList.at(2), QEvent::GraphicsSceneDragLeave);
+    }
+
+    // Dummy drop event to keep the Mac from crashing.
+    QDropEvent dropEvent(QPoint(0, 0), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+    QApplication::sendEvent(view.viewport(), &dropEvent);
+}
+
+void tst_QGraphicsScene::dragAndDrop_propagate()
+{
+    DndTester *item1 = new DndTester(QRectF(-10, -10, 20, 20));
+    DndTester *item2 = new DndTester(QRectF(0, 0, 20, 20));
+    item1->setAcceptDrops(true);
+    item2->setAcceptDrops(true);
+    item2->ignoresDragMove = true;
+    item2->ignoresDragEnter = false;
+    item2->setZValue(1);
+
+    item1->setData(0, "item1");
+    item2->setData(0, "item2");
+
+    QGraphicsScene scene;
+    scene.addItem(item1);
+    scene.addItem(item2);
+
+    QGraphicsView view(&scene);
+    view.setFixedSize(100, 100);
+
+    QMimeData mimeData;
+
+    // Initial drag enter for the scene
+    QDragEnterEvent dragEnter(QPoint(0, 0), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+    QApplication::sendEvent(view.viewport(), &dragEnter);
+    QVERIFY(dragEnter.isAccepted());
+    QCOMPARE(dragEnter.dropAction(), Qt::CopyAction);
+
+    {
+        // Move outside the items
+        QDragMoveEvent dragMove(QPoint(0, 0), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(!dragMove.isAccepted());
+        QCOMPARE(dragMove.dropAction(), Qt::CopyAction);
+        QVERIFY(item1->eventList.isEmpty());
+        QVERIFY(item2->eventList.isEmpty());
+    }
+    {
+        // Move inside item1
+        QDragMoveEvent dragMove(view.mapFromScene(-5, -5), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(dragMove.isAccepted());
+        QCOMPARE(dragMove.dropAction(), Qt::IgnoreAction);
+        QCOMPARE(item1->eventList.size(), 2);
+        QCOMPARE(item1->eventList.at(0), QEvent::GraphicsSceneDragEnter);
+        QCOMPARE(item1->eventList.at(1), QEvent::GraphicsSceneDragMove);
+    }
+
+    {
+        // Move into the intersection item1-item2
+        QDragMoveEvent dragMove(view.mapFromScene(5, 5), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(!dragMove.isAccepted());    // move does not propagate, (ignoresDragMove = true)
+        QCOMPARE(item1->eventList.size(), 3);
+        QCOMPARE(item1->eventList.at(2), QEvent::GraphicsSceneDragLeave);
+        QCOMPARE(item2->eventList.size(), 2);
+        QCOMPARE(item2->eventList.at(0), QEvent::GraphicsSceneDragEnter);
+        QCOMPARE(item2->eventList.at(1), QEvent::GraphicsSceneDragMove);
+    }
+    {
+        // Move into the item2
+        QDragMoveEvent dragMove(view.mapFromScene(15, 15), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(!dragMove.isAccepted());
+        QCOMPARE(dragMove.dropAction(), Qt::CopyAction);
+        QCOMPARE(item1->eventList.size(), 3);
+        QCOMPARE(item2->eventList.size(), 3);
+        QCOMPARE(item2->eventList.at(2), QEvent::GraphicsSceneDragMove);
+    }
+    {
+        // Move inside item1
+        QDragMoveEvent dragMove(view.mapFromScene(-5, -5), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(dragMove.isAccepted());
+        QCOMPARE(dragMove.dropAction(), Qt::IgnoreAction);
+        QCOMPARE(item1->eventList.size(), 5);
+        QCOMPARE(item1->eventList.at(3), QEvent::GraphicsSceneDragEnter);
+        QCOMPARE(item1->eventList.at(4), QEvent::GraphicsSceneDragMove);
+        QCOMPARE(item2->eventList.size(), 4);
+        QCOMPARE(item2->eventList.at(3), QEvent::GraphicsSceneDragLeave);
+    }
+
+    {
+        item2->ignoresDragEnter = true;
+        // Move into the intersection item1-item2
+        QDragMoveEvent dragMove(view.mapFromScene(5, 5), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &dragMove);
+        QVERIFY(dragMove.isAccepted());    // dragEnter propagates down to item1, which then accepts the move event.
+        QCOMPARE(dragMove.dropAction(), Qt::IgnoreAction);
+        QCOMPARE(item1->eventList.size(), 6);
+        QCOMPARE(item1->eventList.at(5), QEvent::GraphicsSceneDragMove);
+        QCOMPARE(item2->eventList.size(), 5);
+        QCOMPARE(item2->eventList.at(4), QEvent::GraphicsSceneDragEnter);
+    }
+
+    {
+        item2->ignoresDragEnter = false;
+        // Drop on the intersection item1-item2
+        QDropEvent drop(view.mapFromScene(5, 5), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+        QApplication::sendEvent(view.viewport(), &drop);
+        QVERIFY(drop.isAccepted());
+        QCOMPARE(drop.dropAction(), Qt::CopyAction);
+
+        QCOMPARE(item1->eventList.size(), 7);
+        QCOMPARE(item1->eventList.at(6), QEvent::GraphicsSceneDrop);
+        QCOMPARE(item2->eventList.size(), 5);
+    }
+
+    // Dummy drop event to keep the Mac from crashing.
+    QDropEvent dropEvent(QPoint(0, 0), Qt::CopyAction, &mimeData, Qt::LeftButton, 0);
+    QApplication::sendEvent(view.viewport(), &dropEvent);
+}
+#endif
+
+void tst_QGraphicsScene::render_data()
+{
+    QTest::addColumn<QRectF>("targetRect");
+    QTest::addColumn<QRectF>("sourceRect");
+    QTest::addColumn<Qt::AspectRatioMode>("aspectRatioMode");
+    QTest::addColumn<QMatrix>("matrix");
+    QTest::addColumn<QPainterPath>("clip");
+
+    QPainterPath clip_rect;
+    clip_rect.addRect(50, 100, 200, 150);
+
+    QPainterPath clip_ellipse;
+    clip_ellipse.addEllipse(100,50,150,200);
+
+    QTest::newRow("all-all-untransformed") << QRectF() << QRectF()
+                                           << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("all-topleft-untransformed") << QRectF(0, 0, 150, 150)
+                                               << QRectF() << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("all-topright-untransformed") << QRectF(150, 0, 150, 150)
+                                                << QRectF() << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("all-bottomleft-untransformed") << QRectF(0, 150, 150, 150)
+                                                  << QRectF() << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("all-bottomright-untransformed") << QRectF(150, 150, 150, 150)
+                                                   << QRectF() << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("topleft-all-untransformed") << QRectF() << QRectF(-10, -10, 10, 10)
+                                               << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("topright-all-untransformed") << QRectF() << QRectF(0, -10, 10, 10)
+                                                << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("bottomleft-all-untransformed") << QRectF() << QRectF(-10, 0, 10, 10)
+                                                  << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("bottomright-all-untransformed") << QRectF() << QRectF(0, 0, 10, 10)
+                                                   << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("topleft-topleft-untransformed") << QRectF(0, 0, 150, 150) << QRectF(-10, -10, 10, 10)
+                                                   << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("topright-topleft-untransformed") << QRectF(150, 0, 150, 150) << QRectF(-10, -10, 10, 10)
+                                                    << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("bottomleft-topleft-untransformed") << QRectF(0, 150, 150, 150) << QRectF(-10, -10, 10, 10)
+                                                      << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("bottomright-topleft-untransformed") << QRectF(150, 150, 150, 150) << QRectF(-10, -10, 10, 10)
+                                                       << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("top-topleft-untransformed") << QRectF(0, 0, 300, 150) << QRectF(-10, -10, 10, 10)
+                                               << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("bottom-topleft-untransformed") << QRectF(0, 150, 300, 150) << QRectF(-10, -10, 10, 10)
+                                                  << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("left-topleft-untransformed") << QRectF(0, 0, 150, 300) << QRectF(-10, -10, 10, 10)
+                                                << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("right-topleft-untransformed") << QRectF(150, 0, 150, 300) << QRectF(-10, -10, 10, 10)
+                                                 << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("top-bottomright-untransformed") << QRectF(0, 0, 300, 150) << QRectF(0, 0, 10, 10)
+                                                   << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("bottom-bottomright-untransformed") << QRectF(0, 150, 300, 150) << QRectF(0, 0, 10, 10)
+                                                      << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("left-bottomright-untransformed") << QRectF(0, 0, 150, 300) << QRectF(0, 0, 10, 10)
+                                                    << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("right-bottomright-untransformed") << QRectF(150, 0, 150, 300) << QRectF(0, 0, 10, 10)
+                                                     << Qt::IgnoreAspectRatio << QMatrix() << QPainterPath();
+    QTest::newRow("all-all-45-deg-right") << QRectF() << QRectF()
+                                          << Qt::IgnoreAspectRatio << QMatrix().rotate(-45) << QPainterPath();
+    QTest::newRow("all-all-45-deg-left") << QRectF() << QRectF()
+                                         << Qt::IgnoreAspectRatio << QMatrix().rotate(45) << QPainterPath();
+    QTest::newRow("all-all-scale-2x") << QRectF() << QRectF()
+                                      << Qt::IgnoreAspectRatio << QMatrix().scale(2, 2) << QPainterPath();
+    QTest::newRow("all-all-translate-50-0") << QRectF() << QRectF()
+                                            << Qt::IgnoreAspectRatio << QMatrix().translate(50, 0) << QPainterPath();
+    QTest::newRow("all-all-translate-0-50") << QRectF() << QRectF()
+                                            << Qt::IgnoreAspectRatio << QMatrix().translate(0, 50) << QPainterPath();
+    QTest::newRow("all-all-untransformed-clip-rect") << QRectF() << QRectF()
+                                           << Qt::IgnoreAspectRatio << QMatrix() << clip_rect;
+    QTest::newRow("all-all-untransformed-clip-ellipse") << QRectF() << QRectF()
+                                           << Qt::IgnoreAspectRatio << QMatrix() << clip_ellipse;
+}
+
+void tst_QGraphicsScene::render()
+{
+    QFETCH(QRectF, targetRect);
+    QFETCH(QRectF, sourceRect);
+    QFETCH(Qt::AspectRatioMode, aspectRatioMode);
+    QFETCH(QMatrix, matrix);
+    QFETCH(QPainterPath, clip);
+
+    QPixmap pix(30, 30);
+    pix.fill(Qt::blue);
+
+    QGraphicsView view;
+    QGraphicsScene scene(&view);
+    scene.addEllipse(QRectF(-10, -10, 20, 20), QPen(Qt::black), QBrush(Qt::white));
+    scene.addEllipse(QRectF(-2, -7, 4, 4), QPen(Qt::black), QBrush(Qt::yellow))->setZValue(1);
+    QGraphicsPixmapItem *item = scene.addPixmap(pix);
+    item->setZValue(2);
+    item->setOffset(QPointF(3, 3));
+    view.show();
+
+    scene.setSceneRect(scene.itemsBoundingRect());
+
+    QImage bigImage(300, 300, QImage::Format_RGB32);
+    bigImage.fill(0);
+    QPainter painter(&bigImage);
+    painter.setPen(Qt::lightGray);
+    for (int i = 0; i <= 300; i += 25) {
+        painter.drawLine(0, i, 300, i);
+        painter.drawLine(i, 0, i, 300);
+    }
+    painter.setPen(QPen(Qt::darkGray, 2));
+    painter.drawLine(0, 150, 300, 150);
+    painter.drawLine(150, 0, 150, 300);
+    painter.setMatrix(matrix);
+    if (!clip.isEmpty()) painter.setClipPath(clip);
+    scene.render(&painter, targetRect, sourceRect, aspectRatioMode);
+    painter.end();
+
+    const QString renderPath = QLatin1String(SRCDIR) + "/testData/render";
+    QString fileName = renderPath + QString("/%1.png").arg(QTest::currentDataTag());
+    QImage original(fileName);
+    QVERIFY(!original.isNull());
+
+    // Compare
+    int wrongPixels = 0;
+    for (int y = 0; y < original.height(); ++y) {
+        for (int x = 0; x < original.width(); ++x) {
+            if (bigImage.pixel(x, y) != original.pixel(x, y))
+                ++wrongPixels;
+        }
+    }
+
+    // This is a pixmap compare test - because of rounding errors on diverse
+    // platforms, and especially because tests are compiled in release mode,
+    // we set a 95% acceptance threshold for comparing images. This number may
+    // have to be adjusted if this test fails.
+    qreal threshold = 0.95;
+    qreal similarity = (1 - (wrongPixels / qreal(original.width() * original.height())));
+    if (similarity < threshold) {
+#if 1
+        // fail
+        QLabel *expectedLabel = new QLabel;
+        expectedLabel->setPixmap(QPixmap::fromImage(original));
+
+        QLabel *newLabel = new QLabel;
+        newLabel->setPixmap(QPixmap::fromImage(bigImage));
+
+        QGridLayout *gridLayout = new QGridLayout;
+        gridLayout->addWidget(new QLabel(tr("MISMATCH: %1").arg(QTest::currentDataTag())), 0, 0, 1, 2);
+        gridLayout->addWidget(new QLabel(tr("Current")), 1, 0);
+        gridLayout->addWidget(new QLabel(tr("Expected")), 1, 1);
+        gridLayout->addWidget(expectedLabel, 2, 1);
+        gridLayout->addWidget(newLabel, 2, 0);
+
+        QWidget widget;
+        widget.setLayout(gridLayout);
+        widget.show();
+
+        QTestEventLoop::instance().enterLoop(1);
+
+        QFAIL("Images are not identical.");
+#else
+        // generate
+        qDebug() << "Updating" << QTest::currentDataTag() << ":" << bigImage.save(fileName, "png");
+#endif
+    }
+}
+
+void tst_QGraphicsScene::renderItemsWithNegativeWidthOrHeight()
+{
+    QGraphicsScene scene(0, 0, 150, 150);
+
+    // Add item with negative width.
+    QGraphicsRectItem *item1 = new QGraphicsRectItem(0, 0, -150, 50);
+    item1->setBrush(Qt::red);
+    item1->setPos(150, 50);
+    scene.addItem(item1);
+
+    // Add item with negative height.
+    QGraphicsRectItem *item2 = new QGraphicsRectItem(0, 0, 50, -150);
+    item2->setBrush(Qt::blue);
+    item2->setPos(50, 150);
+    scene.addItem(item2);
+
+    QGraphicsView view(&scene);
+    view.setFrameStyle(QFrame::NoFrame);
+    view.resize(150, 150);
+    view.show();
+    QCOMPARE(view.viewport()->size(), QSize(150, 150));
+
+    QImage expected(view.viewport()->size(), QImage::Format_RGB32);
+    view.viewport()->render(&expected);
+
+    // Make sure the scene background is the same as the viewport background.
+    scene.setBackgroundBrush(view.viewport()->palette().brush(view.viewport()->backgroundRole()));
+    QImage actual(150, 150, QImage::Format_RGB32);
+    QPainter painter(&actual);
+    scene.render(&painter);
+    painter.end();
+
+    QCOMPARE(actual, expected);
+}
+
+void tst_QGraphicsScene::contextMenuEvent()
+{
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    EventTester *item = new EventTester;
+    scene.addItem(item);
+    item->setFlag(QGraphicsItem::ItemIsFocusable);
+    item->setFocus();
+
+    QVERIFY(item->hasFocus());
+    QVERIFY(scene.hasFocus());
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    view.activateWindow();
+#ifdef Q_WS_X11
+        qt_x11_wait_for_window_manager(&view);
+#endif
+    view.centerOn(item);
+
+    {
+        QContextMenuEvent event(QContextMenuEvent::Keyboard, view.viewport()->rect().center(),
+                                view.mapToGlobal(view.viewport()->rect().center()));
+        QApplication::sendEvent(view.viewport(), &event);
+        QCOMPARE(item->eventTypes.last(), QEvent::GraphicsSceneContextMenu);
+    }
+}
+
+class ContextMenuItem : public QGraphicsRectItem
+{
+public:
+    ContextMenuItem() : QGraphicsRectItem(0, 0, 100, 100)
+    { setBrush(Qt::red); }
+
+protected:
+    void contextMenuEvent(QGraphicsSceneContextMenuEvent *)
+    { /* just accept */ }
+};
+
+void tst_QGraphicsScene::contextMenuEvent_ItemIgnoresTransformations()
+{
+    QGraphicsScene scene(0, 0, 200, 200);
+    ContextMenuItem *item = new ContextMenuItem;
+    item->setFlag(QGraphicsItem::ItemIgnoresTransformations);
+    scene.addItem(item);
+
+    QWidget topLevel;
+    QGraphicsView view(&scene, &topLevel);
+    view.resize(200, 200);
+    topLevel.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWaitForWindowShown(&topLevel);
+
+    {
+        QPoint pos(50, 50);
+        QContextMenuEvent event(QContextMenuEvent::Keyboard, pos, view.viewport()->mapToGlobal(pos));
+        event.ignore();
+        QApplication::sendEvent(view.viewport(), &event);
+        QVERIFY(event.isAccepted());
+    }
+    {
+        QPoint pos(150, 150);
+        QContextMenuEvent event(QContextMenuEvent::Keyboard, pos, view.viewport()->mapToGlobal(pos));
+        event.ignore();
+        QApplication::sendEvent(view.viewport(), &event);
+        QVERIFY(!event.isAccepted());
+    }
+    view.scale(1.5, 1.5);
+    {
+        QPoint pos(25, 25);
+        QContextMenuEvent event(QContextMenuEvent::Keyboard, pos, view.viewport()->mapToGlobal(pos));
+        event.ignore();
+        QApplication::sendEvent(view.viewport(), &event);
+        QVERIFY(event.isAccepted());
+    }
+    {
+        QPoint pos(55, 55);
+        QContextMenuEvent event(QContextMenuEvent::Keyboard, pos, view.viewport()->mapToGlobal(pos));
+        event.ignore();
+        QApplication::sendEvent(view.viewport(), &event);
+        QVERIFY(!event.isAccepted());
+    }
+}
+
+void tst_QGraphicsScene::update()
+{
+    QGraphicsScene scene;
+
+    QGraphicsRectItem *rect = new QGraphicsRectItem(0, 0, 100, 100);
+    scene.addItem(rect);
+    qApp->processEvents();
+    rect->setPos(-100, -100);
+
+    // This function forces indexing
+    scene.itemAt(0, 0);
+
+    qRegisterMetaType<QList<QRectF> >("QList<QRectF>");
+    QSignalSpy spy(&scene, SIGNAL(changed(QList<QRectF>)));
+
+    // We update the scene.
+    scene.update();
+
+    // This function forces a purge, which will post an update signal
+    scene.itemAt(0, 0);
+
+    // This will process the pending update
+    QApplication::instance()->processEvents();
+
+    // Check that the update region is correct
+    QCOMPARE(spy.count(), 1);
+    QRectF region;
+    foreach (QRectF rectF, qVariantValue<QList<QRectF> >(spy.at(0).at(0)))
+        region |= rectF;
+    QCOMPARE(region, QRectF(-100, -100, 200, 200));
+}
+
+void tst_QGraphicsScene::update2()
+{
+    QGraphicsScene scene;
+    scene.setSceneRect(-200, -200, 200, 200);
+    CustomView view;
+    view.setScene(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(view.repaints >= 1);
+    view.repaints = 0;
+
+    // Make sure QGraphicsScene::update only requires one event-loop iteration
+    // before the view is updated.
+    scene.update();
+    qApp->processEvents();
+    QTRY_COMPARE(view.repaints, 1);
+    view.repaints = 0;
+
+    // The same for partial scene updates.
+    scene.update(QRectF(-100, -100, 100, 100));
+    qApp->processEvents();
+    QCOMPARE(view.repaints, 1);
+}
+
+void tst_QGraphicsScene::views()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    QCOMPARE(scene.views().size(), 1);
+    QCOMPARE(scene.views().at(0), &view);
+
+    QGraphicsView view1(&scene);
+    QCOMPARE(scene.views().size(), 2);
+    QVERIFY(scene.views().contains(&view1));
+
+    view.setScene(0);
+    QCOMPARE(scene.views().size(), 1);
+    QCOMPARE(scene.views().at(0), &view1);
+
+    QGraphicsView *view2 = new QGraphicsView(&scene);
+    QCOMPARE(scene.views().size(), 2);
+    QCOMPARE(scene.views().at(0), &view1);
+    QCOMPARE(scene.views().at(1), view2);
+
+    delete view2;
+
+    QCOMPARE(scene.views().size(), 1);
+    QCOMPARE(scene.views().at(0), &view1);
+}
+
+class CustomScene : public QGraphicsScene
+{
+public:
+    CustomScene() : gotTimerEvent(false)
+    { startTimer(10); }
+
+    bool gotTimerEvent;
+protected:
+    void timerEvent(QTimerEvent *)
+    {
+        gotTimerEvent = true;
+    }
+};
+
+void tst_QGraphicsScene::event()
+{
+    // Test that QGraphicsScene properly propagates events to QObject.
+    CustomScene scene;
+    QTestEventLoop::instance().enterLoop(1);
+    QVERIFY(scene.gotTimerEvent);
+}
+
+class DisabledItemTester : public QGraphicsRectItem
+{
+public:
+    DisabledItemTester(const QRectF &rect, QGraphicsItem *parent = 0)
+        : QGraphicsRectItem(rect, parent)
+    { }
+
+    QList<QEvent::Type> receivedSceneEvents;
+    QList<QEvent::Type> receivedSceneEventFilters;
+
+protected:
+    bool sceneEventFilter(QGraphicsItem *watched, QEvent *event)
+    {
+        receivedSceneEventFilters << event->type();
+        return QGraphicsRectItem::sceneEventFilter(watched, event);
+    }
+
+    bool sceneEvent(QEvent *event)
+    {
+        receivedSceneEvents << event->type();
+        return QGraphicsRectItem::sceneEvent(event);
+    }
+};
+
+void tst_QGraphicsScene::eventsToDisabledItems()
+{
+    QGraphicsScene scene;
+
+    DisabledItemTester *item1 = new DisabledItemTester(QRectF(-50, -50, 100, 100));
+    DisabledItemTester *item2 = new DisabledItemTester(QRectF(-50, -50, 100, 100));
+    item1->setZValue(1); // on top
+
+    scene.addItem(item1);
+    scene.addItem(item2);
+
+    item1->installSceneEventFilter(item2);
+
+    QVERIFY(item1->receivedSceneEvents.isEmpty());
+    QVERIFY(item2->receivedSceneEvents.isEmpty());
+    QVERIFY(item1->receivedSceneEventFilters.isEmpty());
+    QVERIFY(item2->receivedSceneEventFilters.isEmpty());
+
+    QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+    event.setButton(Qt::LeftButton);
+    QApplication::sendEvent(&scene, &event);
+
+    // First item2 receives a scene event filter. Then item1 receives the
+    // actual event. Finally the event propagates to item2. So both items
+    // should have received the event, and item1 also got the filter.
+    QCOMPARE(item1->receivedSceneEvents.size(), 3);
+    QCOMPARE(item2->receivedSceneEvents.size(), 3);
+    QCOMPARE(item1->receivedSceneEventFilters.size(), 0);
+    QCOMPARE(item2->receivedSceneEventFilters.size(), 3);
+
+    item1->receivedSceneEvents.clear();
+    item1->receivedSceneEventFilters.clear();
+    item2->receivedSceneEvents.clear();
+    item2->receivedSceneEventFilters.clear();
+
+    item1->setEnabled(false); // disable the topmost item, eat mouse events
+
+    event.setButton(Qt::LeftButton);
+    event.setAccepted(false);
+    QApplication::sendEvent(&scene, &event);
+
+    // Check that only item1 received anything - it only got the filter.
+    QCOMPARE(item1->receivedSceneEvents.size(), 0);
+    QCOMPARE(item2->receivedSceneEvents.size(), 0);
+    QCOMPARE(item1->receivedSceneEventFilters.size(), 0);
+    QCOMPARE(item2->receivedSceneEventFilters.size(), 3);
+}
+
+class ExposedPixmapItem : public QGraphicsPixmapItem
+{
+public:
+    ExposedPixmapItem(QGraphicsItem *item = 0)
+        : QGraphicsPixmapItem(item)
+    { }
+
+    void paint(QPainter *, const QStyleOptionGraphicsItem *option, QWidget *)
+    {
+        exposed = option->exposedRect;
+    }
+
+    QRectF exposed;
+};
+
+void tst_QGraphicsScene::exposedRect()
+{
+    ExposedPixmapItem *item = new ExposedPixmapItem;
+    item->setPixmap(QPixmap(":/Ash_European.jpg"));
+    QGraphicsScene scene;
+    scene.addItem(item);
+
+    QCOMPARE(item->exposed, QRectF());
+
+    QImage image(100, 100, QImage::Format_ARGB32_Premultiplied);
+    QPainter painter(&image);
+
+    scene.render(&painter);
+    QCOMPARE(item->exposed, item->boundingRect());
+
+    painter.rotate(180);
+    painter.translate(100, 100);
+
+    scene.render(&painter);
+    QCOMPARE(item->exposed, item->boundingRect());
+}
+
+void tst_QGraphicsScene::tabFocus_emptyScene()
+{
+    QGraphicsScene scene;
+    QDial *dial1 = new QDial;
+    QGraphicsView *view = new QGraphicsView(&scene);
+    QDial *dial2 = new QDial;
+
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(dial1);
+    layout->addWidget(view);
+    layout->addWidget(dial2);
+
+    QWidget widget;
+    widget.setLayout(layout);
+    widget.show();
+    qApp->setActiveWindow(&widget);
+    widget.activateWindow();
+    QTest::qWait(125);
+
+    dial1->setFocus();
+    QVERIFY(dial1->hasFocus());
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QVERIFY(!dial1->hasFocus());
+    QVERIFY(view->hasFocus());
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QVERIFY(!view->hasFocus());
+    QVERIFY(dial2->hasFocus());
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QVERIFY(!dial2->hasFocus());
+    QVERIFY(view->hasFocus());
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QVERIFY(dial1->hasFocus());
+    QVERIFY(!dial2->hasFocus());
+}
+
+void tst_QGraphicsScene::tabFocus_sceneWithFocusableItems()
+{
+    QGraphicsScene scene;
+    QGraphicsTextItem *item = scene.addText("Qt rocks!");
+    item->setTabChangesFocus(true);
+    item->setTextInteractionFlags(Qt::TextEditorInteraction);
+    QVERIFY(item->flags() & QGraphicsItem::ItemIsFocusable);
+    item->setFocus();
+    item->clearFocus();
+
+    QGraphicsTextItem *item2 = scene.addText("Trolltech rocks!");
+    item2->setTabChangesFocus(true);
+    item2->setTextInteractionFlags(Qt::TextEditorInteraction);
+    item2->setPos(0, item->boundingRect().bottom());
+    QVERIFY(item2->flags() & QGraphicsItem::ItemIsFocusable);
+
+    QDial *dial1 = new QDial;
+    QGraphicsView *view = new QGraphicsView(&scene);
+    QDial *dial2 = new QDial;
+
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(dial1);
+    layout->addWidget(view);
+    layout->addWidget(dial2);
+
+    QWidget widget;
+    widget.setLayout(layout);
+    widget.show();
+    qApp->setActiveWindow(&widget);
+    widget.activateWindow();
+    QTest::qWaitForWindowShown(&widget);
+    QApplication::processEvents();
+
+    dial1->setFocus();
+    QTRY_VERIFY(dial1->hasFocus());
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QTRY_VERIFY(view->hasFocus());
+    QVERIFY(view->viewport()->hasFocus());
+    QVERIFY(scene.hasFocus());
+    QVERIFY(item->hasFocus());
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QTRY_VERIFY(dial2->hasFocus());
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QTRY_VERIFY(view->hasFocus());
+    QTRY_VERIFY(view->viewport()->hasFocus());
+    QTRY_VERIFY(scene.hasFocus());
+    QTRY_VERIFY(item->hasFocus());
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QTRY_VERIFY(dial1->hasFocus());
+
+    // If the item requests input focus, it can only ensure that the scene
+    // sets focus on itself, but the scene cannot request focus from any view.
+    item->setFocus();
+    QApplication::processEvents();
+    QTRY_VERIFY(!view->hasFocus());
+    QVERIFY(!view->viewport()->hasFocus());
+    QTRY_VERIFY(scene.hasFocus());
+    QVERIFY(item->hasFocus());
+
+    view->setFocus();
+    QApplication::processEvents();
+    QTRY_VERIFY(view->hasFocus());
+    QTRY_VERIFY(view->viewport()->hasFocus());
+    QTRY_VERIFY(scene.hasFocus());
+    QTRY_VERIFY(item->hasFocus());
+
+    // Check that everyone loses focus when the widget is hidden.
+    widget.hide();
+    QTest::qWait(15);
+    QTRY_VERIFY(!view->hasFocus());
+    QVERIFY(!view->viewport()->hasFocus());
+    QVERIFY(!scene.hasFocus());
+    QVERIFY(!item->hasFocus());
+    QCOMPARE(scene.focusItem(), static_cast<QGraphicsItem *>(item));
+
+    // Check that the correct item regains focus.
+    widget.show();
+    qApp->setActiveWindow(&widget);
+    widget.activateWindow();
+    QTest::qWaitForWindowShown(&widget);
+    QTRY_VERIFY(view->hasFocus());
+    QTRY_VERIFY(scene.isActive());
+    QVERIFY(view->viewport()->hasFocus());
+    QVERIFY(scene.hasFocus());
+    QCOMPARE(scene.focusItem(), static_cast<QGraphicsItem *>(item));
+    QVERIFY(item->hasFocus());
+}
+
+class FocusWidget : public QGraphicsWidget
+{
+    Q_OBJECT
+public:
+    FocusWidget(QGraphicsItem *parent = 0)
+        : QGraphicsWidget(parent), tabs(0), backTabs(0)
+    {
+        setFocusPolicy(Qt::StrongFocus);
+        resize(100, 100);
+    }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *)
+    {
+        if (option->state & QStyle::State_HasFocus) {
+            painter->fillRect(rect(), Qt::blue);
+        }
+        painter->setBrush(Qt::green);
+        painter->drawEllipse(rect());
+        if (option->state & QStyle::State_HasFocus) {
+            painter->setPen(QPen(Qt::black, 1, Qt::DashLine));
+            painter->setBrush(Qt::NoBrush);
+            painter->drawEllipse(rect().adjusted(5, 5, -5, -5));
+        }
+    }
+
+    int tabs;
+    int backTabs;
+
+protected:
+    bool sceneEvent(QEvent *event)
+    {
+        if (event->type() == QEvent::KeyPress) {
+            QKeyEvent *k = static_cast<QKeyEvent *>(event);
+            if (k->key() == Qt::Key_Tab)
+                ++tabs;
+            if (k->key() == Qt::Key_Backtab)
+                ++backTabs;
+        }
+        return QGraphicsWidget::sceneEvent(event);
+    }
+
+    void focusInEvent(QFocusEvent *)
+    { update(); }
+    void focusOutEvent(QFocusEvent *)
+    { update(); }
+};
+
+void tst_QGraphicsScene::tabFocus_sceneWithFocusWidgets()
+{
+    QGraphicsScene scene;
+
+    FocusWidget *widget1 = new FocusWidget;
+    FocusWidget *widget2 = new FocusWidget;
+    widget2->setPos(widget1->boundingRect().right(), 0);
+    scene.addItem(widget1);
+    scene.addItem(widget2);
+
+    QDial *dial1 = new QDial;
+    QGraphicsView *view = new QGraphicsView(&scene);
+    view->setRenderHint(QPainter::Antialiasing);
+    QDial *dial2 = new QDial;
+
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(dial1);
+    layout->addWidget(view);
+    layout->addWidget(dial2);
+
+    QWidget widget;
+    widget.setLayout(layout);
+    widget.show();
+    qApp->setActiveWindow(&widget);
+    widget.activateWindow();
+    QTest::qWaitForWindowShown(&widget);
+    QApplication::processEvents();
+
+    dial1->setFocus();
+    QTRY_VERIFY(dial1->hasFocus());
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QTRY_VERIFY(view->hasFocus());
+    QTRY_VERIFY(view->viewport()->hasFocus());
+    QTRY_VERIFY(scene.hasFocus());
+    QCOMPARE(widget1->tabs, 0);
+    QVERIFY(widget1->hasFocus());
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QTRY_COMPARE(widget1->tabs, 1);
+    QTRY_VERIFY(widget2->hasFocus());
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QTRY_COMPARE(widget2->tabs, 1);
+    QTRY_VERIFY(dial2->hasFocus());
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QTRY_VERIFY(widget2->hasFocus());
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QTRY_COMPARE(widget2->backTabs, 1);
+    QTRY_VERIFY(widget1->hasFocus());
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QTRY_COMPARE(widget1->backTabs, 1);
+    QTRY_VERIFY(dial1->hasFocus());
+
+    widget1->setFocus();
+    view->viewport()->setFocus();
+    widget.hide();
+    QTest::qWait(15);
+    widget.show();
+    qApp->setActiveWindow(&widget);
+    widget.activateWindow();
+    QTest::qWaitForWindowShown(&widget);
+    QTRY_VERIFY(widget1->hasFocus());
+}
+
+void tst_QGraphicsScene::tabFocus_sceneWithNestedFocusWidgets()
+{
+    QGraphicsScene scene;
+
+    FocusWidget *widget1 = new FocusWidget;
+    FocusWidget *widget1_1 = new FocusWidget;
+    FocusWidget *widget1_2 = new FocusWidget;
+    widget1_1->setParentItem(widget1);
+    widget1_1->scale(0.5, 0.5);
+    widget1_1->setPos(0, widget1->boundingRect().height() / 2);
+    widget1_2->setParentItem(widget1);
+    widget1_2->scale(0.5, 0.5);
+    widget1_2->setPos(widget1->boundingRect().width() / 2, widget1->boundingRect().height() / 2);
+
+    FocusWidget *widget2 = new FocusWidget;
+    widget2->setPos(widget1->boundingRect().right(), 0);
+
+    widget1->setData(0, "widget1");
+    widget1_1->setData(0, "widget1_1");
+    widget1_2->setData(0, "widget1_2");
+    widget2->setData(0, "widget2");
+
+    scene.addItem(widget1);
+    scene.addItem(widget2);
+
+    QDial *dial1 = new QDial;
+    QGraphicsView *view = new QGraphicsView(&scene);
+    view->setRenderHint(QPainter::Antialiasing);
+    QDial *dial2 = new QDial;
+
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(dial1);
+    layout->addWidget(view);
+    layout->addWidget(dial2);
+
+    QWidget widget;
+    widget.setLayout(layout);
+    widget.show();
+    qApp->setActiveWindow(&widget);
+    widget.activateWindow();
+    QTest::qWaitForWindowShown(&widget);
+
+    dial1->setFocus();
+    QTRY_VERIFY(dial1->hasFocus());
+
+    EventSpy focusInSpy_1(widget1, QEvent::FocusIn);
+    EventSpy focusOutSpy_1(widget1, QEvent::FocusOut);
+    EventSpy focusInSpy_1_1(widget1_1, QEvent::FocusIn);
+    EventSpy focusOutSpy_1_1(widget1_1, QEvent::FocusOut);
+    EventSpy focusInSpy_1_2(widget1_2, QEvent::FocusIn);
+    EventSpy focusOutSpy_1_2(widget1_2, QEvent::FocusOut);
+    EventSpy focusInSpy_2(widget2, QEvent::FocusIn);
+    EventSpy focusOutSpy_2(widget2, QEvent::FocusOut);
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QTRY_VERIFY(widget1->hasFocus());
+    QCOMPARE(focusInSpy_1.count(), 1);
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QTRY_VERIFY(!widget1->hasFocus());
+    QVERIFY(widget1_1->hasFocus());
+    QCOMPARE(focusOutSpy_1.count(), 1);
+    QCOMPARE(focusInSpy_1_1.count(), 1);
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QTRY_VERIFY(!widget1_1->hasFocus());
+    QVERIFY(widget1_2->hasFocus());
+    QCOMPARE(focusOutSpy_1_1.count(), 1);
+    QCOMPARE(focusInSpy_1_2.count(), 1);
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QTRY_VERIFY(!widget1_2->hasFocus());
+    QVERIFY(widget2->hasFocus());
+    QCOMPARE(focusOutSpy_1_2.count(), 1);
+    QCOMPARE(focusInSpy_2.count(), 1);
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QTRY_VERIFY(!widget2->hasFocus());
+    QVERIFY(dial2->hasFocus());
+    QCOMPARE(focusOutSpy_2.count(), 1);
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QTRY_VERIFY(widget2->hasFocus());
+    QCOMPARE(focusInSpy_2.count(), 2);
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QTRY_VERIFY(!widget2->hasFocus());
+    QTRY_VERIFY(widget1_2->hasFocus());
+    QCOMPARE(focusOutSpy_2.count(), 2);
+    QCOMPARE(focusInSpy_1_2.count(), 2);
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QTRY_VERIFY(!widget1_2->hasFocus());
+    QTRY_VERIFY(widget1_1->hasFocus());
+    QCOMPARE(focusOutSpy_1_2.count(), 2);
+    QCOMPARE(focusInSpy_1_1.count(), 2);
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QTRY_VERIFY(!widget1_1->hasFocus());
+    QTRY_VERIFY(widget1->hasFocus());
+    QCOMPARE(focusOutSpy_1_1.count(), 2);
+    QCOMPARE(focusInSpy_1.count(), 2);
+
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QTRY_VERIFY(!widget1->hasFocus());
+    QTRY_VERIFY(dial1->hasFocus());
+    QCOMPARE(focusOutSpy_1.count(), 2);
+
+    widget1->setFocus();
+    view->viewport()->setFocus();
+    widget.hide();
+    QTest::qWait(12);
+    widget.show();
+    qApp->setActiveWindow(&widget);
+    widget.activateWindow();
+    QTest::qWaitForWindowShown(&widget);
+    QApplication::processEvents();
+    QTRY_VERIFY(widget1->hasFocus());
+}
+
+void tst_QGraphicsScene::style()
+{
+    QPointer<QWindowsStyle> windowsStyle = new QWindowsStyle;
+
+    QGraphicsScene scene;
+    QLineEdit *edit = new QLineEdit;
+    QGraphicsProxyWidget *proxy = scene.addWidget(edit);
+
+    EventSpy sceneSpy(&scene, QEvent::StyleChange);
+    EventSpy proxySpy(proxy, QEvent::StyleChange);
+    EventSpy editSpy(edit, QEvent::StyleChange);
+
+    QCOMPARE(scene.style(), QApplication::style());
+
+    scene.setStyle(windowsStyle);
+    QCOMPARE(sceneSpy.count(), 1);
+    QCOMPARE(proxySpy.count(), 1);
+    QCOMPARE(editSpy.count(), 1);
+    QCOMPARE(scene.style(), (QStyle *)windowsStyle);
+    QCOMPARE(proxy->style(), (QStyle *)windowsStyle);
+    QCOMPARE(edit->style(), (QStyle *)windowsStyle);
+
+    scene.setStyle(0);
+    QCOMPARE(sceneSpy.count(), 2);
+    QCOMPARE(proxySpy.count(), 2);
+    QCOMPARE(editSpy.count(), 2);
+    QCOMPARE(scene.style(), QApplication::style());
+    QCOMPARE(proxy->style(), QApplication::style());
+    QCOMPARE(edit->style(), QApplication::style());
+    QVERIFY(!windowsStyle); // deleted
+}
+
+void tst_QGraphicsScene::task139710_bspTreeCrash()
+{
+    // create a scene with 2000 items
+    QGraphicsScene scene(0, 0, 1000, 1000);
+
+    for (int i = 0; i < 2; ++i) {
+        // trigger delayed item indexing
+        qApp->processEvents();
+        scene.setSceneRect(0, 0, 10000, 10000);
+
+        // delete all items in the scene - pointers are now likely to be recycled
+        foreach (QGraphicsItem *item, scene.items()) {
+            scene.removeItem(item);
+            delete item;
+        }
+
+        // add 1000 more items - the BSP tree is now resized
+        for (int i = 0; i < 1000; ++i) {
+            QGraphicsRectItem *item = scene.addRect(QRectF(0, 0, 200, 200));
+            item->setPos(qrand() % 10000, qrand() % 10000);
+        }
+
+        // trigger delayed item indexing for the first 1000 items
+        qApp->processEvents();
+
+        // add 1000 more items - the BSP tree is now resized
+        for (int i = 0; i < 1000; ++i) {
+            QGraphicsRectItem *item = scene.addRect(QRectF(0, 0, 200, 200));
+            item->setPos(qrand() % 10000, qrand() % 10000);
+        }
+
+        // get items from the BSP tree and use them. there was junk in the tree
+        // the second time this happened.
+        foreach (QGraphicsItem *item, scene.items(QRectF(0, 0, 1000, 1000)))
+            item->moveBy(0, 0);
+    }
+}
+
+void tst_QGraphicsScene::task139782_containsItemBoundingRect()
+{
+    // The item in question has a scene bounding rect of (10, 10, 50, 50)
+    QGraphicsScene scene(0.0, 0.0, 200.0, 200.0);
+    QGraphicsRectItem *item = new QGraphicsRectItem(0.0, 0.0, 50.0, 50.0, 0, &scene);
+    item->setPos(10.0, 10.0);
+
+    // The (0, 0, 50, 50) scene rect should not include the item's bounding rect
+    QVERIFY(!scene.items(QRectF(0.0, 0.0, 50.0, 50.0), Qt::ContainsItemBoundingRect).contains(item));
+
+    // The (9, 9, 500, 500) scene rect _should_ include the item's bounding rect
+    QVERIFY(scene.items(QRectF(9.0, 9.0, 500.0, 500.0), Qt::ContainsItemBoundingRect).contains(item));
+
+    // The (25, 25, 5, 5) scene rect should not include the item's bounding rect
+    QVERIFY(!scene.items(QRectF(25.0, 25.0, 5.0, 5.0), Qt::ContainsItemBoundingRect).contains(item));
+}
+
+void tst_QGraphicsScene::task176178_itemIndexMethodBreaksSceneRect()
+{
+    QGraphicsScene scene;
+    scene.setItemIndexMethod(QGraphicsScene::NoIndex);
+    QGraphicsRectItem *rect = new QGraphicsRectItem;
+    rect->setRect(0,0,100,100);
+    scene.addItem(rect);
+    QCOMPARE(scene.sceneRect(), rect->rect());
+}
+
+void tst_QGraphicsScene::task160653_selectionChanged()
+{
+    QGraphicsScene scene(0, 0, 100, 100);
+    scene.addItem(new QGraphicsRectItem(0, 0, 20, 20));
+    scene.addItem(new QGraphicsRectItem(30, 30, 20, 20));
+    foreach (QGraphicsItem *item, scene.items()) {
+        item->setFlags(
+            item->flags() | QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemIsMovable);
+        item->setSelected(true);
+    }
+    QVERIFY(scene.items().size() > 1);
+    QCOMPARE(scene.items().size(), scene.selectedItems().size());
+
+    QSignalSpy spy(&scene, SIGNAL(selectionChanged()));
+    QGraphicsView view(&scene);
+    QTest::mouseClick(
+        view.viewport(), Qt::LeftButton, 0, view.mapFromScene(scene.items().first()->scenePos()));
+    QCOMPARE(spy.count(), 1);
+}
+
+void tst_QGraphicsScene::task250680_childClip()
+{
+    QGraphicsRectItem *clipper = new QGraphicsRectItem;
+    clipper->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    clipper->setPen(QPen(Qt::green));
+    clipper->setRect(200, 200, 640, 480);
+
+    QGraphicsRectItem *rect = new QGraphicsRectItem(clipper);
+    rect->setPen(QPen(Qt::red));
+    rect->setBrush(QBrush(QColor(255, 0, 0, 75)));
+    rect->setPos(320, 240);
+    rect->setRect(-25, -25, 50, 50);
+
+    QGraphicsScene scene;
+    scene.addItem(clipper);
+
+    QPainterPath path;
+    path.addRect(-25, -25, 50, 50);
+    QVERIFY(QPathCompare::comparePaths(rect->clipPath().simplified(), path));
+
+    QCOMPARE(scene.items(QRectF(320, 240, 5, 5)).size(), 2);
+    rect->rotate(45);
+    QCOMPARE(scene.items(QRectF(320, 240, 5, 5)).size(), 2);
+}
+
+void tst_QGraphicsScene::sorting_data()
+{
+    QTest::addColumn<bool>("cache");
+
+    QTest::newRow("Normal sorting") << false;
+    QTest::newRow("Cached sorting") << true;
+}
+
+void tst_QGraphicsScene::sorting()
+{
+    QFETCH(bool, cache);
+
+    QGraphicsScene scene;
+    scene.setSortCacheEnabled(cache);
+
+    QGraphicsRectItem *t_1 = new QGraphicsRectItem(0, 0, 50, 50);
+    QGraphicsRectItem *c_1 = new QGraphicsRectItem(0, 0, 40, 40, t_1);
+    QGraphicsRectItem *c_1_1 = new QGraphicsRectItem(0, 0, 30, 30, c_1);
+    QGraphicsRectItem *c_1_1_1 = new QGraphicsRectItem(0, 0, 20, 20, c_1_1);
+    QGraphicsRectItem *c_1_2 = new QGraphicsRectItem(0, 0, 30, 30, c_1);
+    QGraphicsRectItem *c_2 = new QGraphicsRectItem(0, 0, 40, 40, t_1);
+    QGraphicsRectItem *c_2_1 = new QGraphicsRectItem(0, 0, 30, 30, c_2);
+    QGraphicsRectItem *c_2_1_1 = new QGraphicsRectItem(0, 0, 20, 20, c_2_1);
+    QGraphicsRectItem *c_2_2 = new QGraphicsRectItem(0, 0, 30, 30, c_2);
+    t_1->setBrush(QColor(qrand() % 256, qrand() % 256, qrand() % 256));
+    c_1->setBrush(QColor(qrand() % 256, qrand() % 256, qrand() % 256));
+    c_1_1->setBrush(QColor(qrand() % 256, qrand() % 256, qrand() % 256));
+    c_1_1_1->setBrush(QColor(qrand() % 256, qrand() % 256, qrand() % 256));
+    c_1_2->setBrush(QColor(qrand() % 256, qrand() % 256, qrand() % 256));
+    c_2->setBrush(QColor(qrand() % 256, qrand() % 256, qrand() % 256));
+    c_2_1->setBrush(QColor(qrand() % 256, qrand() % 256, qrand() % 256));
+    c_2_1_1->setBrush(QColor(qrand() % 256, qrand() % 256, qrand() % 256));
+    c_2_2->setBrush(QColor(qrand() % 256, qrand() % 256, qrand() % 256));
+
+    c_1->setPos(23, 18);
+    c_1_1->setPos(24, 28);
+    c_1_1_1->setPos(-16, 16);
+    c_1_2->setPos(-16, 28);
+    c_1_2->setZValue(1);
+    c_2->setPos(-23, 18);
+    c_2->setZValue(1);
+    c_2_1->setPos(24, 28);
+    c_2_1_1->setPos(-16, 16);
+    c_2_2->setPos(-16, 28);
+    c_2_2->setZValue(1);
+
+    c_1->setFlag(QGraphicsItem::ItemIsMovable);
+    c_1_1->setFlag(QGraphicsItem::ItemIsMovable);
+    c_1_1_1->setFlag(QGraphicsItem::ItemIsMovable);
+    c_1_2->setFlag(QGraphicsItem::ItemIsMovable);
+    c_2->setFlag(QGraphicsItem::ItemIsMovable);
+    c_2_1->setFlag(QGraphicsItem::ItemIsMovable);
+    c_2_1_1->setFlag(QGraphicsItem::ItemIsMovable);
+    c_2_2->setFlag(QGraphicsItem::ItemIsMovable);
+
+    t_1->setData(0, "t_1");
+    c_1->setData(0, "c_1");
+    c_1_1->setData(0, "c_1_1");
+    c_1_1_1->setData(0, "c_1_1_1");
+    c_1_2->setData(0, "c_1_2");
+    c_2->setData(0, "c_2");
+    c_2_1->setData(0, "c_2_1");
+    c_2_1_1->setData(0, "c_2_1_1");
+    c_2_2->setData(0, "c_2_2");
+
+    scene.addItem(t_1);
+
+    foreach (QGraphicsItem *item, scene.items())
+        item->setFlag(QGraphicsItem::ItemIsSelectable);
+
+    // QGraphicsView view(&scene);
+    // view.setDragMode(QGraphicsView::RubberBandDrag);
+    // view.show();
+
+    qDebug() << "items: {";
+    foreach (QGraphicsItem *item, scene.items(32, 31, 4, 55))
+        qDebug() << "\t" << item->data(0).toString();
+    qDebug() << "}";
+
+    QCOMPARE(scene.items(32, 31, 4, 55),
+             QList<QGraphicsItem *>()
+             << c_1_2 << c_1_1_1 << c_1 << t_1);
+    QCOMPARE(scene.items(-53, 47, 136, 3),
+             QList<QGraphicsItem *>()
+             << c_2_2 << c_2_1 << c_2 << c_1_2 << c_1_1 << c_1 << t_1);
+    QCOMPARE(scene.items(-23, 79, 104, 3),
+             QList<QGraphicsItem *>()
+             << c_2_1_1 << c_1_1_1);
+    QCOMPARE(scene.items(-26, -3, 92, 79),
+             QList<QGraphicsItem *>()
+             << c_2_2 << c_2_1_1 << c_2_1 << c_2
+             << c_1_2 << c_1_1_1 << c_1_1 << c_1
+             << t_1);
+}
+
+class ChangedListener : public QObject
+{
+    Q_OBJECT
+public:
+    QList<QList<QRectF> > changes;
+
+public slots:
+    void changed(const QList<QRectF> &dirty)
+    {
+        changes << dirty;
+    }
+};
+
+void tst_QGraphicsScene::changedSignal_data()
+{
+    QTest::addColumn<bool>("withView");
+
+    QTest::newRow("without view") << false;
+    QTest::newRow("with view") << true;
+}
+
+void tst_QGraphicsScene::changedSignal()
+{
+    QFETCH(bool, withView);
+    QGraphicsScene scene;
+    ChangedListener cl;
+    connect(&scene, SIGNAL(changed(const QList<QRectF> &)), &cl, SLOT(changed(const QList<QRectF> &)));
+
+    QGraphicsView *view = 0;
+    if (withView)
+        view = new QGraphicsView(&scene);
+
+    QGraphicsRectItem *rect = new QGraphicsRectItem(0, 0, 10, 10);
+    scene.addItem(rect);
+
+    QCOMPARE(cl.changes.size(), 0);
+    QTRY_COMPARE(cl.changes.size(), 1);
+    QCOMPARE(cl.changes.at(0).size(), 1);
+    QCOMPARE(cl.changes.at(0).first(), QRectF(0, 0, 10, 10));
+
+    rect->setPos(20, 0);
+
+    QCOMPARE(cl.changes.size(), 1);
+    qApp->processEvents();
+    QCOMPARE(cl.changes.size(), 2);
+    QCOMPARE(cl.changes.at(1).size(), 2);
+    QCOMPARE(cl.changes.at(1).first(), QRectF(0, 0, 10, 10));
+    QCOMPARE(cl.changes.at(1).last(), QRectF(20, 0, 10, 10));
+
+    QCOMPARE(scene.sceneRect(), QRectF(0, 0, 30, 10));
+
+    if (withView)
+        delete view;
+}
+
+void tst_QGraphicsScene::stickyFocus_data()
+{
+    QTest::addColumn<bool>("sticky");
+    QTest::newRow("sticky") << true;
+    QTest::newRow("not sticky") << false;
+}
+
+void tst_QGraphicsScene::stickyFocus()
+{
+    QFETCH(bool, sticky);
+
+    QGraphicsScene scene;
+    QEvent activate(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activate);
+
+    QGraphicsTextItem *text = scene.addText("Hei");
+    text->setTextInteractionFlags(Qt::TextEditorInteraction);
+    text->setFocus();
+
+    scene.setStickyFocus(sticky);
+
+    QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+    event.setScenePos(QPointF(-10, -10)); // outside item
+    event.setButton(Qt::LeftButton);
+    qApp->sendEvent(&scene, &event);
+
+    QCOMPARE(text->hasFocus(), sticky);
+}
+
+void tst_QGraphicsScene::sendEvent()
+{
+    QGraphicsScene scene;
+    QGraphicsTextItem *item = scene.addText(QString());
+    EventSpy *spy = new EventSpy(&scene, item, QEvent::User);
+    QCOMPARE(spy->count(), 0);
+    QEvent event(QEvent::User);
+    scene.sendEvent(item, &event);
+    QCOMPARE(spy->count(), 1);
+}
+
+void tst_QGraphicsScene::inputMethod_data()
+{
+    QTest::addColumn<int>("flags");
+    QTest::addColumn<bool>("callFocusItem");
+    QTest::newRow("0") << 0 << false;
+    QTest::newRow("1") << (int)QGraphicsItem::ItemAcceptsInputMethod << false;
+    QTest::newRow("2") << (int)QGraphicsItem::ItemIsFocusable << false;
+    QTest::newRow("3") <<
+        (int)(QGraphicsItem::ItemAcceptsInputMethod|QGraphicsItem::ItemIsFocusable) << true;
+}
+
+class InputMethodTester : public QGraphicsRectItem
+{
+    void inputMethodEvent(QInputMethodEvent *) { ++eventCalls; }
+    QVariant inputMethodQuery(Qt::InputMethodQuery) const { ++queryCalls; return QVariant(); }
+public:
+    int eventCalls;
+    mutable int queryCalls;
+};
+
+class TestInputContext : public QInputContext
+{
+public:
+    TestInputContext() {}
+
+    QString identifierName() { return QString(); }
+    QString language() { return QString(); }
+
+    void reset() {
+        ++resetCalls;
+        sendEvent(QInputMethodEvent()); }
+
+    bool isComposing() const { return false; }
+
+    int resetCalls;
+};
+
+void tst_QGraphicsScene::inputMethod()
+{
+    QFETCH(int, flags);
+    QFETCH(bool, callFocusItem);
+
+    InputMethodTester *item = new InputMethodTester;
+    item->setFlags((QGraphicsItem::GraphicsItemFlags)flags);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    TestInputContext *inputContext = new TestInputContext;
+    qApp->setInputContext(inputContext);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    view.setFocus();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&view));
+
+    inputContext->resetCalls = 0;
+    scene.addItem(item);
+    QInputMethodEvent event;
+
+    scene.setFocusItem(item);
+    QCOMPARE(!!(item->flags() & QGraphicsItem::ItemIsFocusable), scene.focusItem() == item);
+    QCOMPARE(inputContext->resetCalls, 0);
+
+    item->eventCalls = 0;
+    qApp->sendEvent(&scene, &event);
+    QCOMPARE(item->eventCalls, callFocusItem ? 1 : 0);
+
+    item->queryCalls = 0;
+    scene.inputMethodQuery((Qt::InputMethodQuery)0);
+    QCOMPARE(item->queryCalls, callFocusItem ? 1 : 0);
+
+    scene.setFocusItem(0);
+    // the input context is reset twice, once because an item has lost focus and again because
+    // the Qt::WA_InputMethodEnabled flag is cleared because no item has focus.
+    QCOMPARE(inputContext->resetCalls, callFocusItem ? 2 : 0);
+    QCOMPARE(item->eventCalls, callFocusItem ? 2 : 0); // verify correct delivery of "reset" event
+    QCOMPARE(item->queryCalls, callFocusItem ? 1 : 0); // verify that value is unaffected
+
+    item->eventCalls = 0;
+    qApp->sendEvent(&scene, &event);
+    QCOMPARE(item->eventCalls, 0);
+
+    item->queryCalls = 0;
+    scene.inputMethodQuery((Qt::InputMethodQuery)0);
+    QCOMPARE(item->queryCalls, 0);
+}
+
+void tst_QGraphicsScene::dispatchHoverOnPress()
+{
+    QGraphicsScene scene;
+    EventTester *tester1 = new EventTester;
+    tester1->setAcceptHoverEvents(true);
+    EventTester *tester2 = new EventTester;
+    tester2->setAcceptHoverEvents(true);
+    tester2->setPos(30, 30);
+    scene.addItem(tester1);
+    scene.addItem(tester2);
+
+    tester1->eventTypes.clear();
+    tester2->eventTypes.clear();
+
+    {
+        QGraphicsSceneMouseEvent me(QEvent::GraphicsSceneMousePress);
+        me.setButton(Qt::LeftButton);
+        me.setButtons(Qt::LeftButton);
+        QGraphicsSceneMouseEvent me2(QEvent::GraphicsSceneMouseRelease);
+        me2.setButton(Qt::LeftButton);
+        qApp->sendEvent(&scene, &me);
+        qApp->sendEvent(&scene, &me2);
+        QCOMPARE(tester1->eventTypes, QList<QEvent::Type>()
+                 << QEvent::GraphicsSceneHoverEnter
+                 << QEvent::GraphicsSceneHoverMove
+                 << QEvent::GrabMouse
+                 << QEvent::GraphicsSceneMousePress
+                 << QEvent::UngrabMouse);
+        tester1->eventTypes.clear();
+        qApp->sendEvent(&scene, &me);
+        qApp->sendEvent(&scene, &me2);
+        QCOMPARE(tester1->eventTypes, QList<QEvent::Type>()
+                 << QEvent::GraphicsSceneHoverMove
+                 << QEvent::GrabMouse
+                 << QEvent::GraphicsSceneMousePress
+                 << QEvent::UngrabMouse);
+    }
+    {
+        QGraphicsSceneMouseEvent me(QEvent::GraphicsSceneMousePress);
+        me.setScenePos(QPointF(30, 30));
+        me.setButton(Qt::LeftButton);
+        me.setButtons(Qt::LeftButton);
+        QGraphicsSceneMouseEvent me2(QEvent::GraphicsSceneMouseRelease);
+        me2.setScenePos(QPointF(30, 30));
+        me2.setButton(Qt::LeftButton);
+        tester1->eventTypes.clear();
+        qApp->sendEvent(&scene, &me);
+        qApp->sendEvent(&scene, &me2);
+        qDebug() << tester1->eventTypes;
+        QCOMPARE(tester1->eventTypes, QList<QEvent::Type>()
+                 << QEvent::GraphicsSceneHoverLeave);
+        QCOMPARE(tester2->eventTypes, QList<QEvent::Type>()
+                 << QEvent::GraphicsSceneHoverEnter
+                 << QEvent::GraphicsSceneHoverMove
+                 << QEvent::GrabMouse
+                 << QEvent::GraphicsSceneMousePress
+                 << QEvent::UngrabMouse);
+        tester2->eventTypes.clear();
+        qApp->sendEvent(&scene, &me);
+        qApp->sendEvent(&scene, &me2);
+        QCOMPARE(tester2->eventTypes, QList<QEvent::Type>()
+                 << QEvent::GraphicsSceneHoverMove
+                 << QEvent::GrabMouse
+                 << QEvent::GraphicsSceneMousePress
+                 << QEvent::UngrabMouse);
+    }
+}
+
+void tst_QGraphicsScene::initialFocus_data()
+{
+    QTest::addColumn<bool>("activeScene");
+    QTest::addColumn<bool>("explicitSetFocus");
+    QTest::addColumn<bool>("isPanel");
+    QTest::addColumn<bool>("shouldHaveFocus");
+
+    QTest::newRow("inactive scene, normal item") << false << false << false << false;
+    QTest::newRow("inactive scene, panel item") << false << false << true << false;
+    QTest::newRow("inactive scene, normal item, explicit focus") << false << true << false << true;
+    QTest::newRow("inactive scene, panel, explicit focus") << false << true << true << true;
+    QTest::newRow("active scene, normal item") << true << false << false << false;
+    QTest::newRow("active scene, panel item") << true << false << true << false;
+    QTest::newRow("active scene, normal item, explicit focus") << true << true << false << true;
+    QTest::newRow("active scene, panel, explicit focus") << true << true << true << true;
+}
+
+void tst_QGraphicsScene::initialFocus()
+{
+    QFETCH(bool, activeScene);
+    QFETCH(bool, explicitSetFocus);
+    QFETCH(bool, isPanel);
+    QFETCH(bool, shouldHaveFocus);
+
+    QGraphicsRectItem *rect = new QGraphicsRectItem;
+    rect->setFlag(QGraphicsItem::ItemIsFocusable);
+    QVERIFY(!rect->hasFocus());
+
+    if (isPanel)
+        rect->setFlag(QGraphicsItem::ItemIsPanel);
+
+    // Setting focus on an item before adding to the scene will ensure
+    // it gets focus when the scene is activated.
+    if (explicitSetFocus)
+        rect->setFocus();
+
+    QGraphicsScene scene;
+    QVERIFY(!scene.isActive());
+
+    if (activeScene) {
+        QEvent windowActivate(QEvent::WindowActivate);
+        qApp->sendEvent(&scene, &windowActivate);
+        scene.setFocus();
+    }
+
+    scene.addItem(rect);
+
+    if (!activeScene) {
+        QEvent windowActivate(QEvent::WindowActivate);
+        qApp->sendEvent(&scene, &windowActivate);
+        scene.setFocus();
+    }
+
+    QCOMPARE(rect->hasFocus(), shouldHaveFocus);
+}
+
+class PolishItem : public QGraphicsTextItem
+{
+public:
+    PolishItem(QGraphicsItem *parent = 0)
+        : QGraphicsTextItem(parent), polished(false), deleteChildrenInPolish(true), addChildrenInPolish(false) { }
+
+    bool polished;
+    bool deleteChildrenInPolish;
+    bool addChildrenInPolish;
+protected:
+    QVariant itemChange(GraphicsItemChange change, const QVariant& value)
+    {
+        if (change == ItemVisibleChange) {
+            polished = true;
+            if (deleteChildrenInPolish)
+                qDeleteAll(childItems());
+            if (addChildrenInPolish) {
+                for (int i = 0; i < 10; ++i)
+                    new PolishItem(this);
+            }
+        }
+        return QGraphicsItem::itemChange(change, value);
+    }
+};
+
+void tst_QGraphicsScene::polishItems()
+{
+    QGraphicsScene scene;
+    PolishItem *parent = new PolishItem;
+    scene.addItem(parent);
+    PolishItem *child = new PolishItem(parent);
+    Q_UNUSED(child)
+    // test that QGraphicsScenePrivate::_q_polishItems() doesn't crash
+    QMetaObject::invokeMethod(&scene,"_q_polishItems");
+}
+
+void tst_QGraphicsScene::polishItems2()
+{
+    QGraphicsScene scene;
+    PolishItem *item = new PolishItem;
+    item->addChildrenInPolish = true;
+    item->deleteChildrenInPolish = true;
+    // These children should be deleted in the polish.
+    for (int i = 0; i < 20; ++i)
+        new PolishItem(item);
+    scene.addItem(item);
+
+    // Wait for the polish event to be delivered.
+    QVERIFY(!item->polished);
+    QApplication::sendPostedEvents(&scene, QEvent::MetaCall);
+    QVERIFY(item->polished);
+
+    // We deleted the children we added above, but we also
+    // added 10 new children. These should be polished in the next
+    // event loop iteration.
+    QList<QGraphicsItem *> children = item->childItems();
+    QCOMPARE(children.count(), 10);
+    foreach (QGraphicsItem *child, children)
+        QVERIFY(!static_cast<PolishItem *>(child)->polished);
+
+    QApplication::sendPostedEvents(&scene, QEvent::MetaCall);
+    foreach (QGraphicsItem *child, children)
+        QVERIFY(static_cast<PolishItem *>(child)->polished);
+}
+
+void tst_QGraphicsScene::isActive()
+{
+    QGraphicsScene scene1;
+    QVERIFY(!scene1.isActive());
+    QGraphicsScene scene2;
+    QVERIFY(!scene2.isActive());
+
+    {
+        QWidget toplevel1;
+        QHBoxLayout *layout = new QHBoxLayout;
+        toplevel1.setLayout(layout);
+        QGraphicsView *view1 = new QGraphicsView(&scene1);
+        QGraphicsView *view2 = new QGraphicsView(&scene2);
+        layout->addWidget(view1);
+        layout->addWidget(view2);
+
+        QVERIFY(!scene1.isActive());
+        QVERIFY(!scene2.isActive());
+
+        view1->setVisible(false);
+
+        toplevel1.show();
+        QApplication::setActiveWindow(&toplevel1);
+        QTest::qWaitForWindowShown(&toplevel1);
+        QTRY_COMPARE(QApplication::activeWindow(), &toplevel1);
+
+        QVERIFY(!scene1.isActive()); //it is hidden;
+        QVERIFY(scene2.isActive());
+        QVERIFY(!scene1.hasFocus());
+        QVERIFY(scene2.hasFocus());
+
+        view1->show();
+        QVERIFY(scene1.isActive());
+        QVERIFY(scene2.isActive());
+        QVERIFY(!scene1.hasFocus());
+        QVERIFY(scene2.hasFocus());
+
+        view2->hide();
+
+        QVERIFY(scene1.isActive());
+        QVERIFY(!scene2.isActive());
+        QVERIFY(scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+
+        toplevel1.hide();
+        QTest::qWait(50);
+        QTRY_VERIFY(!scene1.isActive());
+        QTRY_VERIFY(!scene2.isActive());
+        QVERIFY(!scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+
+        toplevel1.show();
+        QApplication::setActiveWindow(&toplevel1);
+        QApplication::processEvents();
+        QTRY_COMPARE(QApplication::activeWindow(), &toplevel1);
+
+        QTRY_VERIFY(scene1.isActive());
+        QTRY_VERIFY(!scene2.isActive());
+        QVERIFY(scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+
+        view2->show();
+        QVERIFY(scene1.isActive());
+        QVERIFY(scene2.isActive());
+        QVERIFY(scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+    }
+
+    QVERIFY(!scene1.isActive());
+    QVERIFY(!scene2.isActive());
+    QVERIFY(!scene1.hasFocus());
+    QVERIFY(!scene2.hasFocus());
+
+
+    {
+        QWidget toplevel2;
+        QHBoxLayout *layout = new QHBoxLayout;
+        toplevel2.setLayout(layout);
+        QGraphicsView *view1 = new QGraphicsView(&scene1);
+        QGraphicsView *view2 = new QGraphicsView();
+        layout->addWidget(view1);
+        layout->addWidget(view2);
+
+        QVERIFY(!scene1.isActive());
+        QVERIFY(!scene2.isActive());
+        QVERIFY(!scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+
+        toplevel2.show();
+        QApplication::setActiveWindow(&toplevel2);
+        QTest::qWaitForWindowShown(&toplevel2);
+        QTRY_COMPARE(QApplication::activeWindow(), &toplevel2);
+
+        QVERIFY(scene1.isActive());
+        QVERIFY(!scene2.isActive());
+        QVERIFY(scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+
+        view2->setScene(&scene2);
+
+        QVERIFY(scene1.isActive());
+        QVERIFY(scene2.isActive());
+        QVERIFY(scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+
+        view1->setScene(&scene2);
+        QVERIFY(!scene1.isActive());
+        QVERIFY(scene2.isActive());
+        QVERIFY(!scene1.hasFocus());
+        QVERIFY(scene2.hasFocus());
+
+        view1->hide();
+        QVERIFY(!scene1.isActive());
+        QVERIFY(scene2.isActive());
+        QVERIFY(!scene1.hasFocus());
+        QVERIFY(scene2.hasFocus());
+
+        view1->setScene(&scene1);
+        QVERIFY(!scene1.isActive());
+        QVERIFY(scene2.isActive());
+        QVERIFY(!scene1.hasFocus());
+        QVERIFY(scene2.hasFocus());
+
+        view1->show();
+        QVERIFY(scene1.isActive());
+        QVERIFY(scene2.isActive());
+        QVERIFY(!scene1.hasFocus());
+        QVERIFY(scene2.hasFocus());
+
+        view2->hide();
+        QVERIFY(scene1.isActive());
+        QVERIFY(!scene2.isActive());
+        QVERIFY(scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+
+        QGraphicsView topLevelView;
+        topLevelView.show();
+        QApplication::setActiveWindow(&topLevelView);
+        topLevelView.setFocus();
+        QTest::qWaitForWindowShown(&topLevelView);
+        QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&topLevelView));
+
+        QVERIFY(!scene1.isActive());
+        QVERIFY(!scene2.isActive());
+        QVERIFY(!scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+
+        topLevelView.setScene(&scene1);
+        QVERIFY(scene1.isActive());
+        QVERIFY(!scene2.isActive());
+        QVERIFY(scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+
+        view2->show();
+        QVERIFY(scene1.isActive());
+        QVERIFY(!scene2.isActive());
+        QVERIFY(scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+
+        view1->hide();
+        QVERIFY(scene1.isActive());
+        QVERIFY(!scene2.isActive());
+        QVERIFY(scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+
+        QApplication::setActiveWindow(&toplevel2);
+        QTRY_COMPARE(QApplication::activeWindow(), &toplevel2);
+
+        QVERIFY(!scene1.isActive());
+        QVERIFY(scene2.isActive());
+        QVERIFY(!scene1.hasFocus());
+        QVERIFY(scene2.hasFocus());
+    }
+
+    QVERIFY(!scene1.isActive());
+    QVERIFY(!scene2.isActive());
+    QVERIFY(!scene1.hasFocus());
+    QVERIFY(!scene2.hasFocus());
+
+    {
+        QWidget toplevel3;
+        QHBoxLayout *layout = new QHBoxLayout;
+        toplevel3.setLayout(layout);
+        QGraphicsView *view1 = new QGraphicsView(&scene1);
+        QGraphicsView *view2 = new QGraphicsView(&scene2);
+        layout->addWidget(view1);
+
+        QVERIFY(!scene1.isActive());
+        QVERIFY(!scene2.isActive());
+        QVERIFY(!scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+
+
+        toplevel3.show();
+        QApplication::setActiveWindow(&toplevel3);
+        QTest::qWaitForWindowShown(&toplevel3);
+        QTRY_COMPARE(QApplication::activeWindow(), &toplevel3);
+
+        QVERIFY(scene1.isActive());
+        QVERIFY(!scene2.isActive());
+        QVERIFY(scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+
+        layout->addWidget(view2);
+        QApplication::processEvents();
+        QVERIFY(scene1.isActive());
+        QVERIFY(scene2.isActive());
+        QVERIFY(scene1.hasFocus());
+        QVERIFY(!scene2.hasFocus());
+
+        view1->setParent(0);
+        QVERIFY(!scene1.isActive());
+        QVERIFY(scene2.isActive());
+        QVERIFY(!scene1.hasFocus());
+        QVERIFY(scene2.hasFocus());
+        delete view1;
+    }
+
+    QVERIFY(!scene1.isActive());
+    QVERIFY(!scene2.isActive());
+    QVERIFY(!scene1.hasFocus());
+    QVERIFY(!scene2.hasFocus());
+
+}
+
+void tst_QGraphicsScene::siblingIndexAlwaysValid()
+{
+    QGraphicsScene scene;
+
+    QGraphicsWidget *parent = new QGraphicsWidget;
+    parent->setZValue(350);
+    parent->setGeometry(0, 0, 100, 100);
+    QGraphicsWidget *parent2 = new QGraphicsWidget;
+    parent2->setGeometry(10, 10, 50, 50);
+    QGraphicsWidget *child = new QGraphicsWidget(parent2);
+    child->setGeometry(15, 15, 25, 25);
+    child->setZValue(150);
+    //Both are top level
+    scene.addItem(parent);
+    scene.addItem(parent2);
+
+    //Then we make the child a top level
+    child->setParentItem(0);
+
+    //This is trigerred by a repaint...
+    QGraphicsScenePrivate::get(&scene)->index->estimateTopLevelItems(QRectF(), Qt::AscendingOrder);
+
+    delete child;
+
+    //If there are in the list that's bad, we crash...
+    QVERIFY(!QGraphicsScenePrivate::get(&scene)->topLevelItems.contains(static_cast<QGraphicsItem *>(child)));
+
+    //Other case
+    QGraphicsScene scene2;
+    // works with bsp tree index
+    scene2.setItemIndexMethod(QGraphicsScene::NoIndex);
+
+    QGraphicsView view2(&scene2);
+
+    // first add the blue rect
+    QGraphicsRectItem* const item1 = new QGraphicsRectItem(QRect( 10, 10, 10, 10 ));
+    item1->setPen(QColor(Qt::blue));
+    item1->setBrush(Qt::blue);
+    scene2.addItem(item1);
+
+    // then add the red rect
+    QGraphicsRectItem* const item2 = new QGraphicsRectItem(5, 5, 10, 10);
+    item2->setPen(QColor(Qt::red));
+    item2->setBrush(Qt::red);
+    scene2.addItem(item2);
+
+    // now the blue one is visible on top of the red one -> swap them (important for the bug)
+    item1->setZValue(1.0);
+    item2->setZValue(0.0);
+
+    view2.show();
+
+    // handle events as a real life app would do
+    QApplication::processEvents();
+
+    // now delete the red rect
+    delete item2;
+
+    // handle events as a real life app would do
+     QApplication::processEvents();
+
+     //We should not crash
+
+}
+
+void tst_QGraphicsScene::removeFullyTransparentItem()
+{
+    QGraphicsScene scene;
+
+    QGraphicsItem *parent = scene.addRect(0, 0, 100, 100);
+    parent->setFlag(QGraphicsItem::ItemHasNoContents);
+
+    QGraphicsItem *child = scene.addRect(0, 0, 100, 100);
+    child->setParentItem(parent);
+
+    CustomView view;
+    view.setScene(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // NB! The parent has the ItemHasNoContents flag set, which means
+    // the parent itself doesn't generate any update requests, only the
+    // child can possibly trigger an update. Also note that the child
+    // is removed before processing events.
+    view.repaints = 0;
+    parent->setOpacity(0);
+    QVERIFY(qFuzzyIsNull(child->effectiveOpacity()));
+    scene.removeItem(child);
+    QVERIFY(!scene.items().contains(child));
+    QTRY_VERIFY(view.repaints > 0);
+
+    // Re-add child. There's nothing new to display (child is still
+    // effectively hidden), so it shouldn't trigger an update.
+    view.repaints = 0;
+    child->setParentItem(parent);
+    QVERIFY(scene.items().contains(child));
+    QVERIFY(qFuzzyIsNull(child->effectiveOpacity()));
+    QApplication::processEvents();
+    QCOMPARE(view.repaints, 0);
+
+    // Nothing is visible on the screen, removing child item shouldn't trigger an update.
+    scene.removeItem(child);
+    QApplication::processEvents();
+    QCOMPARE(view.repaints, 0);
+    delete child;
+}
+
+void tst_QGraphicsScene::taskQTBUG_5904_crashWithDeviceCoordinateCache()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *rectItem = scene.addRect(QRectF(0, 0, 100, 200), QPen(Qt::black), QBrush(Qt::green));
+
+    rectItem->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+
+    QPixmap pixmap(100,200);
+    QPainter painter(&pixmap);
+    painter.setRenderHint(QPainter::Antialiasing);
+    scene.render(&painter);
+    painter.end();
+    // No crash, then it passed!
+}
+
+void tst_QGraphicsScene::taskQT657_paintIntoCacheWithTransparentParts()
+{
+    // Test using DeviceCoordinateCache and opaque item
+    QWidget *w = new QWidget();
+    w->setPalette(QColor(0, 0, 255));
+    w->setGeometry(0, 0, 50, 50);
+
+    QGraphicsScene *scene = new QGraphicsScene();
+    CustomView *view = new CustomView;
+    view->setScene(scene);
+
+    QGraphicsProxyWidget *proxy = scene->addWidget(w);
+    proxy->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+    proxy->rotate(15);
+
+    view->show();
+    QTest::qWaitForWindowShown(view);
+    view->repaints = 0;
+    proxy->update(10, 10, 10, 10);
+    QTest::qWait(50);
+    QTRY_VERIFY(view->repaints > 0);
+
+    QPixmap pix;
+    QGraphicsItemPrivate* itemp = QGraphicsItemPrivate::get(proxy);
+    QTRY_VERIFY(QPixmapCache::find(itemp->extraItemCache()->deviceData.value(view->viewport()).key, &pix));
+
+    QTransform t = proxy->sceneTransform();
+    // Map from scene coordinates to pixmap coordinates.
+    // X origin in the pixmap is the most-left point
+    // of the item's boundingRect in the scene.
+    qreal adjust = t.mapRect(proxy->boundingRect().toRect()).left();
+    QRect rect = t.mapRect(QRect(10, 10, 10, 10)).adjusted(-adjust, 0, -adjust + 1, 1);
+    QPixmap subpix = pix.copy(rect);
+
+    QImage im = subpix.toImage();
+    for(int i = 0; i < im.width(); i++) {
+        for(int j = 0; j < im.height(); j++)
+            QCOMPARE(qAlpha(im.pixel(i, j)), 255);
+    }
+
+    delete w;
+}
+
+void tst_QGraphicsScene::taskQTBUG_7863_paintIntoCacheWithTransparentParts()
+{
+    // Test using DeviceCoordinateCache and semi-transparent item
+    {
+        QGraphicsRectItem *backItem = new QGraphicsRectItem(0, 0, 100, 100);
+        backItem->setBrush(QColor(255, 255, 0));
+        QGraphicsRectItem *rectItem = new QGraphicsRectItem(0, 0, 50, 50);
+        rectItem->setBrush(QColor(0, 0, 255, 125));
+        rectItem->setParentItem(backItem);
+
+        QGraphicsScene *scene = new QGraphicsScene();
+        CustomView *view = new CustomView;
+        view->setScene(scene);
+
+        scene->addItem(backItem);
+        rectItem->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+        backItem->rotate(15);
+
+        view->show();
+        QTest::qWaitForWindowShown(view);
+        view->repaints = 0;
+        rectItem->update(10, 10, 10, 10);
+        QTest::qWait(50);
+        QTRY_VERIFY(view->repaints > 0);
+
+        QPixmap pix;
+        QGraphicsItemPrivate* itemp = QGraphicsItemPrivate::get(rectItem);
+        QTRY_VERIFY(QPixmapCache::find(itemp->extraItemCache()->deviceData.value(view->viewport()).key, &pix));
+
+        QTransform t = rectItem->sceneTransform();
+        // Map from scene coordinates to pixmap coordinates.
+        // X origin in the pixmap is the most-left point
+        // of the item's boundingRect in the scene.
+        qreal adjust = t.mapRect(rectItem->boundingRect().toRect()).left();
+        QRect rect = t.mapRect(QRect(10, 10, 10, 10)).adjusted(-adjust, 0, -adjust + 1, 1);
+        QPixmap subpix = pix.copy(rect);
+
+        QImage im = subpix.toImage();
+        for(int i = 0; i < im.width(); i++) {
+            for(int j = 0; j < im.height(); j++) {
+                QCOMPARE(qAlpha(im.pixel(i, j)), 125);
+            }
+        }
+
+        delete view;
+    }
+
+    // Test using ItemCoordinateCache and opaque item
+    {
+        QGraphicsRectItem *rectItem = new QGraphicsRectItem(0, 0, 50, 50);
+        rectItem->setBrush(QColor(0, 0, 255));
+
+        QGraphicsScene *scene = new QGraphicsScene();
+        CustomView *view = new CustomView;
+        view->setScene(scene);
+
+        scene->addItem(rectItem);
+        rectItem->setCacheMode(QGraphicsItem::ItemCoordinateCache);
+        rectItem->rotate(15);
+
+        view->show();
+        QTest::qWaitForWindowShown(view);
+        view->repaints = 0;
+        rectItem->update(10, 10, 10, 10);
+        QTest::qWait(50);
+        QTRY_VERIFY(view->repaints > 0);
+
+        QPixmap pix;
+        QGraphicsItemPrivate* itemp = QGraphicsItemPrivate::get(rectItem);
+        QTRY_VERIFY(QPixmapCache::find(itemp->extraItemCache()->key, &pix));
+
+        QTransform t = rectItem->sceneTransform();
+        // Map from scene coordinates to pixmap coordinates.
+        // X origin in the pixmap is the most-left point
+        // of the item's boundingRect in the scene.
+        qreal adjust = t.mapRect(rectItem->boundingRect().toRect()).left();
+        QRect rect = t.mapRect(QRect(10, 10, 10, 10)).adjusted(-adjust, 0, -adjust + 1, 1);
+        QPixmap subpix = pix.copy(rect);
+
+        QImage im = subpix.toImage();
+        for(int i = 0; i < im.width(); i++) {
+            for(int j = 0; j < im.height(); j++)
+                QCOMPARE(qAlpha(im.pixel(i, j)), 255);
+        }
+
+        delete view;
+    }
+
+    // Test using ItemCoordinateCache and semi-transparent item
+    {
+        QGraphicsRectItem *rectItem = new QGraphicsRectItem(0, 0, 50, 50);
+        rectItem->setBrush(QColor(0, 0, 255, 125));
+
+        QGraphicsScene *scene = new QGraphicsScene();
+        CustomView *view = new CustomView;
+        view->setScene(scene);
+
+        scene->addItem(rectItem);
+        rectItem->setCacheMode(QGraphicsItem::ItemCoordinateCache);
+        rectItem->rotate(15);
+
+        view->show();
+        QTest::qWaitForWindowShown(view);
+        view->repaints = 0;
+        rectItem->update(10, 10, 10, 10);
+        QTest::qWait(50);
+        QTRY_VERIFY(view->repaints > 0);
+
+        QPixmap pix;
+        QGraphicsItemPrivate* itemp = QGraphicsItemPrivate::get(rectItem);
+        QTRY_VERIFY(QPixmapCache::find(itemp->extraItemCache()->key, &pix));
+
+        QTransform t = rectItem->sceneTransform();
+        // Map from scene coordinates to pixmap coordinates.
+        // X origin in the pixmap is the most-left point
+        // of the item's boundingRect in the scene.
+        qreal adjust = t.mapRect(rectItem->boundingRect().toRect()).left();
+        QRect rect = t.mapRect(QRect(10, 10, 10, 10)).adjusted(-adjust, 0, -adjust + 1, 1);
+        QPixmap subpix = pix.copy(rect);
+
+        QImage im = subpix.toImage();
+        for(int i = 0; i < im.width(); i++) {
+            for(int j = 0; j < im.height(); j++)
+                QCOMPARE(qAlpha(im.pixel(i, j)), 125);
+        }
+
+        delete view;
+    }
+}
+
+void tst_QGraphicsScene::taskQT_3674_doNotCrash()
+{
+    QGraphicsScene scene;
+
+    QGraphicsView view(&scene);
+    view.resize(200, 200);
+
+    QPixmap pixmap(view.size());
+    QPainter painter(&pixmap);
+    view.render(&painter);
+    painter.end();
+
+    scene.addItem(new QGraphicsWidget);
+    scene.setBackgroundBrush(Qt::green);
+
+    QApplication::processEvents();
+    QApplication::processEvents();
+}
+
+void tst_QGraphicsScene::zeroScale()
+{
+    //should not crash
+    QGraphicsScene scene;
+    scene.setSceneRect(-100, -100, 100, 100);
+    QGraphicsView view(&scene);
+
+    ChangedListener cl;
+    connect(&scene, SIGNAL(changed(const QList<QRectF> &)), &cl, SLOT(changed(const QList<QRectF> &)));
+
+    QGraphicsRectItem *rect1 = new QGraphicsRectItem(0, 0, 0.0000001, 0.00000001);
+    scene.addItem(rect1);
+    rect1->setRotation(82);
+    rect1->setScale(0.00000001);
+
+    QApplication::processEvents();
+    QTRY_COMPARE(cl.changes.count(), 1);
+    QGraphicsRectItem *rect2 = new QGraphicsRectItem(-0.0000001, -0.0000001, 0.0000001, 0.0000001);
+    rect2->setScale(0.00000001);
+    scene.addItem(rect2);
+    rect1->setPos(20,20);
+    QApplication::processEvents();
+    QTRY_COMPARE(cl.changes.count(), 2);
+}
+
+void tst_QGraphicsScene::taskQTBUG_15977_renderWithDeviceCoordinateCache()
+{
+    QGraphicsScene scene;
+    scene.setSceneRect(0, 0, 100, 100);
+    QGraphicsRectItem *rect = scene.addRect(0, 0, 100, 100);
+    rect->setPen(Qt::NoPen);
+    rect->setBrush(Qt::red);
+    rect->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+
+    QImage image(100, 100, QImage::Format_RGB32);
+    QPainter p(&image);
+    scene.render(&p);
+    p.end();
+
+    QImage expected(100, 100, QImage::Format_RGB32);
+    p.begin(&expected);
+    p.fillRect(expected.rect(), Qt::red);
+    p.end();
+
+    QCOMPARE(image, expected);
+}
+
+void tst_QGraphicsScene::taskQTBUG_16401_focusItem()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsRectItem *rect = scene.addRect(0, 0, 100, 100);
+    rect->setFlag(QGraphicsItem::ItemIsFocusable);
+
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QApplication::setActiveWindow(&view);
+
+    QVERIFY(!scene.focusItem());
+
+    rect->setFocus();
+    QCOMPARE(scene.focusItem(), rect);
+    QFocusEvent focusOut(QEvent::FocusOut);
+    QApplication::sendEvent(&view, &focusOut);
+    QVERIFY(!scene.focusItem());
+    QFocusEvent focusIn(QEvent::FocusIn);
+    QApplication::sendEvent(&view, &focusIn);
+    QCOMPARE(scene.focusItem(), rect);
+
+    rect->clearFocus();
+    QVERIFY(!scene.focusItem());
+    QApplication::sendEvent(&view, &focusOut);
+    QVERIFY(!scene.focusItem());
+    QApplication::sendEvent(&view, &focusIn);
+    QVERIFY(!scene.focusItem());
+}
+
+QTEST_MAIN(tst_QGraphicsScene)
+#include "tst_qgraphicsscene.moc"
diff --git a/tests/auto/widgets/graphicsview/qgraphicssceneindex/qgraphicssceneindex.pro b/tests/auto/widgets/graphicsview/qgraphicssceneindex/qgraphicssceneindex.pro
new file mode 100644
index 0000000000..5e61034d7c
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicssceneindex/qgraphicssceneindex.pro
@@ -0,0 +1,6 @@
+load(qttest_p4)
+requires(contains(QT_CONFIG,private_tests))
+QT += widgets widgets-private
+QT += core-private gui-private
+SOURCES  += tst_qgraphicssceneindex.cpp
+CONFIG += parallel_test
diff --git a/tests/auto/widgets/graphicsview/qgraphicssceneindex/tst_qgraphicssceneindex.cpp b/tests/auto/widgets/graphicsview/qgraphicssceneindex/tst_qgraphicssceneindex.cpp
new file mode 100644
index 0000000000..7507701267
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicssceneindex/tst_qgraphicssceneindex.cpp
@@ -0,0 +1,366 @@
+/****************************************************************************
+**
+** 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 <QtWidgets/qgraphicsscene.h>
+#include <private/qgraphicsscenebsptreeindex_p.h>
+#include <private/qgraphicssceneindex_p.h>
+#include <private/qgraphicsscenelinearindex_p.h>
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QGraphicsSceneIndex : public QObject
+{
+    Q_OBJECT
+public slots:
+    void initTestCase();
+
+private slots:
+    void customIndex_data();
+    void customIndex();
+    void scatteredItems_data();
+    void scatteredItems();
+    void overlappedItems_data();
+    void overlappedItems();
+    void movingItems_data();
+    void movingItems();
+    void connectedToSceneRectChanged();
+    void items();
+    void removeItems();
+    void clear();
+
+private:
+    void common_data();
+    QGraphicsSceneIndex *createIndex(const QString &name);
+};
+
+void tst_QGraphicsSceneIndex::initTestCase()
+{
+}
+
+void tst_QGraphicsSceneIndex::common_data()
+{
+    QTest::addColumn<QString>("indexMethod");
+
+    QTest::newRow("BSP") << QString("bsp");
+    QTest::newRow("Linear") << QString("linear");
+}
+
+QGraphicsSceneIndex *tst_QGraphicsSceneIndex::createIndex(const QString &indexMethod)
+{
+    QGraphicsSceneIndex *index = 0;
+    QGraphicsScene *scene = new QGraphicsScene();
+    if (indexMethod == "bsp")
+        index = new QGraphicsSceneBspTreeIndex(scene);
+
+    if (indexMethod == "linear")
+        index = new QGraphicsSceneLinearIndex(scene);
+
+    return index;
+}
+
+void tst_QGraphicsSceneIndex::customIndex_data()
+{
+    common_data();
+}
+
+void tst_QGraphicsSceneIndex::customIndex()
+{
+#if 0
+    QFETCH(QString, indexMethod);
+    QGraphicsSceneIndex *index = createIndex(indexMethod);
+
+    QGraphicsScene scene;
+    scene.setSceneIndex(index);
+
+    scene.addRect(0, 0, 30, 40);
+    QCOMPARE(scene.items(QRectF(0, 0, 10, 10)).count(), 1);
+#endif
+}
+
+void tst_QGraphicsSceneIndex::scatteredItems_data()
+{
+    common_data();
+}
+
+void tst_QGraphicsSceneIndex::scatteredItems()
+{
+    QFETCH(QString, indexMethod);
+
+    QGraphicsScene scene;
+#if 1
+    scene.setItemIndexMethod(indexMethod == "linear" ? QGraphicsScene::NoIndex : QGraphicsScene::BspTreeIndex);
+#else
+    QGraphicsSceneIndex *index = createIndex(indexMethod);
+    scene.setSceneIndex(index);
+#endif
+
+    for (int i = 0; i < 10; ++i)
+        scene.addRect(i*50, i*50, 40, 35);
+
+    QCOMPARE(scene.items(QPointF(5, 5)).count(), 1);
+    QCOMPARE(scene.items(QPointF(55, 55)).count(), 1);
+    QCOMPARE(scene.items(QPointF(-100, -100)).count(), 0);
+
+    QCOMPARE(scene.items(QRectF(0, 0, 10, 10)).count(), 1);
+    QCOMPARE(scene.items(QRectF(0, 0, 1000, 1000)).count(), 10);
+    QCOMPARE(scene.items(QRectF(-100, -1000, 0, 0)).count(), 0);
+}
+
+void tst_QGraphicsSceneIndex::overlappedItems_data()
+{
+    common_data();
+}
+
+void tst_QGraphicsSceneIndex::overlappedItems()
+{
+    QFETCH(QString, indexMethod);
+
+    QGraphicsScene scene;
+#if 1
+    scene.setItemIndexMethod(indexMethod == "linear" ? QGraphicsScene::NoIndex : QGraphicsScene::BspTreeIndex);
+#else
+    QGraphicsSceneIndex *index = createIndex(indexMethod);
+    scene.setSceneIndex(index);
+#endif
+
+    for (int i = 0; i < 10; ++i)
+        for (int j = 0; j < 10; ++j)
+            scene.addRect(i*50, j*50, 200, 200);
+
+    QCOMPARE(scene.items(QPointF(5, 5)).count(), 1);
+    QCOMPARE(scene.items(QPointF(55, 55)).count(), 4);
+    QCOMPARE(scene.items(QPointF(105, 105)).count(), 9);
+    QCOMPARE(scene.items(QPointF(-100, -100)).count(), 0);
+
+    QCOMPARE(scene.items(QRectF(0, 0, 1000, 1000)).count(), 100);
+    QCOMPARE(scene.items(QRectF(-100, -1000, 0, 0)).count(), 0);
+    QCOMPARE(scene.items(QRectF(0, 0, 200, 200)).count(), 16);
+    QCOMPARE(scene.items(QRectF(0, 0, 100, 100)).count(), 4);
+    QCOMPARE(scene.items(QRectF(0, 0, 1, 100)).count(), 2);
+    QCOMPARE(scene.items(QRectF(0, 0, 1, 1000)).count(), 10);
+}
+
+void tst_QGraphicsSceneIndex::movingItems_data()
+{
+    common_data();
+}
+
+void tst_QGraphicsSceneIndex::movingItems()
+{
+    QFETCH(QString, indexMethod);
+
+    QGraphicsScene scene;
+#if 1
+    scene.setItemIndexMethod(indexMethod == "linear" ? QGraphicsScene::NoIndex : QGraphicsScene::BspTreeIndex);
+#else
+    QGraphicsSceneIndex *index = createIndex(indexMethod);
+    scene.setSceneIndex(index);
+#endif
+
+    for (int i = 0; i < 10; ++i)
+        scene.addRect(i*50, i*50, 40, 35);
+
+    QGraphicsRectItem *box = scene.addRect(0, 0, 10, 10);
+    QCOMPARE(scene.items(QPointF(5, 5)).count(), 2);
+    QCOMPARE(scene.items(QPointF(-1, -1)).count(), 0);
+    QCOMPARE(scene.items(QRectF(0, 0, 5, 5)).count(), 2);
+
+    box->setPos(10, 10);
+    QCOMPARE(scene.items(QPointF(9, 9)).count(), 1);
+    QCOMPARE(scene.items(QPointF(15, 15)).count(), 2);
+    QCOMPARE(scene.items(QRectF(0, 0, 1, 1)).count(), 1);
+
+    box->setPos(-5, -5);
+    QCOMPARE(scene.items(QPointF(-1, -1)).count(), 1);
+    QCOMPARE(scene.items(QRectF(0, 0, 1, 1)).count(), 2);
+
+    QCOMPARE(scene.items(QRectF(0, 0, 1000, 1000)).count(), 11);
+}
+
+void tst_QGraphicsSceneIndex::connectedToSceneRectChanged()
+{
+
+    class MyScene : public QGraphicsScene
+    {
+    public:
+        using QGraphicsScene::receivers;
+    };
+
+    MyScene scene; // Uses QGraphicsSceneBspTreeIndex by default.
+    QCOMPARE(scene.receivers(SIGNAL(sceneRectChanged(const QRectF&))), 1);
+
+    scene.setItemIndexMethod(QGraphicsScene::NoIndex); // QGraphicsSceneLinearIndex
+    QCOMPARE(scene.receivers(SIGNAL(sceneRectChanged(const QRectF&))), 1);
+}
+
+void tst_QGraphicsSceneIndex::items()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item1 = scene.addRect(0, 0, 10, 10);
+    QGraphicsItem *item2 = scene.addRect(10, 10, 10, 10);
+    QCOMPARE(scene.items().size(), 2);
+
+    // Move from unindexed items into bsp tree.
+    QTest::qWait(50);
+    QCOMPARE(scene.items().size(), 2);
+
+    // Add untransformable item.
+    QGraphicsItem *item3 = new QGraphicsRectItem(QRectF(20, 20, 10, 10));
+    item3->setFlag(QGraphicsItem::ItemIgnoresTransformations);
+    scene.addItem(item3);
+    QCOMPARE(scene.items().size(), 3);
+
+    // Move from unindexed items into untransformable items.
+    QTest::qWait(50);
+    QCOMPARE(scene.items().size(), 3);
+
+    // Move from untransformable items into unindexed items.
+    item3->setFlag(QGraphicsItem::ItemIgnoresTransformations, false);
+    QCOMPARE(scene.items().size(), 3);
+    QTest::qWait(50);
+    QCOMPARE(scene.items().size(), 3);
+
+    // Make all items untransformable.
+    item1->setFlag(QGraphicsItem::ItemIgnoresTransformations);
+    item2->setParentItem(item1);
+    item3->setParentItem(item2);
+    QCOMPARE(scene.items().size(), 3);
+
+    // Move from unindexed items into untransformable items.
+    QTest::qWait(50);
+    QCOMPARE(scene.items().size(), 3);
+}
+
+class RectWidget : public QGraphicsWidget
+{
+    Q_OBJECT
+public:
+    RectWidget(QGraphicsItem *parent = 0) : QGraphicsWidget(parent)
+    {
+    }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem * /* option */, QWidget * /* widget */)
+    {
+        painter->setBrush(brush);
+        painter->drawRect(boundingRect());
+    }
+public:
+    QBrush brush;
+};
+
+void tst_QGraphicsSceneIndex::removeItems()
+{
+     QGraphicsScene scene;
+
+    RectWidget *parent = new RectWidget;
+    parent->brush = QBrush(QColor(Qt::magenta));
+    parent->setGeometry(250, 250, 400, 400);
+
+    RectWidget *widget = new RectWidget(parent);
+    widget->brush = QBrush(QColor(Qt::blue));
+    widget->setGeometry(10, 10, 200, 200);
+
+    RectWidget *widgetChild1 = new RectWidget(widget);
+    widgetChild1->brush = QBrush(QColor(Qt::green));
+    widgetChild1->setGeometry(20, 20, 100, 100);
+
+    RectWidget *widgetChild2 = new RectWidget(widgetChild1);
+    widgetChild2->brush = QBrush(QColor(Qt::yellow));
+    widgetChild2->setGeometry(25, 25, 50, 50);
+
+    scene.addItem(parent);
+
+    QGraphicsView view(&scene);
+    view.resize(600, 600);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+
+    QApplication::processEvents();
+
+    scene.removeItem(widgetChild1);
+
+    delete widgetChild1;
+
+    //We move the parent
+    scene.items(295, 295, 50, 50);
+
+    //This should not crash
+}
+
+void tst_QGraphicsSceneIndex::clear()
+{
+    class MyItem : public QGraphicsItem
+    {
+    public:
+        MyItem(QGraphicsItem *parent = 0) : QGraphicsItem(parent), numPaints(0) {}
+        int numPaints;
+    protected:
+        QRectF boundingRect() const { return QRectF(0, 0, 10, 10); }
+        void paint(QPainter * /* painter */, const QStyleOptionGraphicsItem *, QWidget *)
+        { ++numPaints; }
+    };
+
+    QGraphicsScene scene;
+    scene.setSceneRect(0, 0, 100, 100);
+    scene.addItem(new MyItem);
+
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(250);
+    scene.clear();
+
+    // Make sure the index is re-generated after QGraphicsScene::clear();
+    // otherwise no items will be painted.
+    MyItem *item = new MyItem;
+    scene.addItem(item);
+    qApp->processEvents();
+    QTRY_COMPARE(item->numPaints, 1);
+}
+
+QTEST_MAIN(tst_QGraphicsSceneIndex)
+#include "tst_qgraphicssceneindex.moc"
diff --git a/tests/auto/widgets/graphicsview/qgraphicstransform/qgraphicstransform.pro b/tests/auto/widgets/graphicsview/qgraphicstransform/qgraphicstransform.pro
new file mode 100644
index 0000000000..de7f01f36f
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicstransform/qgraphicstransform.pro
@@ -0,0 +1,6 @@
+load(qttest_p4)
+QT += widgets
+SOURCES  += tst_qgraphicstransform.cpp
+CONFIG += parallel_test
+
+linux-*:contains(QT_CONFIG,release):DEFINES+=MAY_HIT_QTBUG_20661
diff --git a/tests/auto/widgets/graphicsview/qgraphicstransform/tst_qgraphicstransform.cpp b/tests/auto/widgets/graphicsview/qgraphicstransform/tst_qgraphicstransform.cpp
new file mode 100644
index 0000000000..7d5a9578ad
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicstransform/tst_qgraphicstransform.cpp
@@ -0,0 +1,408 @@
+/****************************************************************************
+**
+** 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 <qgraphicsitem.h>
+#include <qgraphicstransform.h>
+
+class tst_QGraphicsTransform : public QObject {
+    Q_OBJECT
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+private slots:
+    void scale();
+    void rotation();
+    void rotation3d_data();
+    void rotation3d();
+    void rotation3dArbitraryAxis_data();
+    void rotation3dArbitraryAxis();
+
+private:
+    QString toString(QTransform const&);
+};
+
+
+// This will be called before the first test function is executed.
+// It is only called once.
+void tst_QGraphicsTransform::initTestCase()
+{
+}
+
+// This will be called after the last test function is executed.
+// It is only called once.
+void tst_QGraphicsTransform::cleanupTestCase()
+{
+}
+
+// This will be called before each test function is executed.
+void tst_QGraphicsTransform::init()
+{
+}
+
+// This will be called after every test function.
+void tst_QGraphicsTransform::cleanup()
+{
+}
+
+static QTransform transform2D(const QGraphicsTransform& t)
+{
+    QMatrix4x4 m;
+    t.applyTo(&m);
+    return m.toTransform();
+}
+
+void tst_QGraphicsTransform::scale()
+{
+    QGraphicsScale scale;
+
+    // check initial conditions
+    QCOMPARE(scale.xScale(), qreal(1));
+    QCOMPARE(scale.yScale(), qreal(1));
+    QCOMPARE(scale.zScale(), qreal(1));
+    QCOMPARE(scale.origin(), QVector3D(0, 0, 0));
+
+    scale.setOrigin(QVector3D(10, 10, 0));
+
+    QCOMPARE(scale.xScale(), qreal(1));
+    QCOMPARE(scale.yScale(), qreal(1));
+    QCOMPARE(scale.zScale(), qreal(1));
+    QCOMPARE(scale.origin(), QVector3D(10, 10, 0));
+
+    QMatrix4x4 t;
+    scale.applyTo(&t);
+
+    QCOMPARE(t, QMatrix4x4());
+    QCOMPARE(transform2D(scale), QTransform());
+
+    scale.setXScale(10);
+    scale.setOrigin(QVector3D(0, 0, 0));
+
+    QCOMPARE(scale.xScale(), qreal(10));
+    QCOMPARE(scale.yScale(), qreal(1));
+    QCOMPARE(scale.zScale(), qreal(1));
+    QCOMPARE(scale.origin(), QVector3D(0, 0, 0));
+
+    QTransform res;
+    res.scale(10, 1);
+
+    QCOMPARE(transform2D(scale), res);
+    QCOMPARE(transform2D(scale).map(QPointF(10, 10)), QPointF(100, 10));
+
+    scale.setOrigin(QVector3D(10, 10, 0));
+    QCOMPARE(transform2D(scale).map(QPointF(10, 10)), QPointF(10, 10));
+    QCOMPARE(transform2D(scale).map(QPointF(11, 10)), QPointF(20, 10));
+
+    scale.setYScale(2);
+    scale.setZScale(4.5);
+    scale.setOrigin(QVector3D(1, 2, 3));
+
+    QCOMPARE(scale.xScale(), qreal(10));
+    QCOMPARE(scale.yScale(), qreal(2));
+    QCOMPARE(scale.zScale(), qreal(4.5));
+    QCOMPARE(scale.origin(), QVector3D(1, 2, 3));
+
+    QMatrix4x4 t2;
+    scale.applyTo(&t2);
+
+    QCOMPARE(t2.map(QVector3D(4, 5, 6)), QVector3D(31, 8, 16.5));
+
+    // Because the origin has a non-zero z, mapping (4, 5) in 2D
+    // will introduce a projective component into the result.
+    QTransform t3 = t2.toTransform();
+    QCOMPARE(t3.map(QPointF(4, 5)), QPointF(31 / t3.m33(), 8 / t3.m33()));
+}
+
+// QMatrix4x4 uses float internally, whereas QTransform uses qreal.
+// This can lead to issues with qFuzzyCompare() where it uses double
+// precision to compare values that have no more than float precision
+// after conversion from QMatrix4x4 to QTransform.  The following
+// definitions correct for the difference.
+static inline bool fuzzyCompare(qreal p1, qreal p2)
+{
+    // increase delta on small machines using float instead of double
+    if (sizeof(qreal) == sizeof(float))
+        return (qAbs(p1 - p2) <= 0.00003f * qMin(qAbs(p1), qAbs(p2)));
+    else
+        return (qAbs(p1 - p2) <= 0.00001f * qMin(qAbs(p1), qAbs(p2)));
+}
+
+static bool fuzzyCompare(const QTransform& t1, const QTransform& t2)
+{
+    return fuzzyCompare(t1.m11(), t2.m11()) &&
+           fuzzyCompare(t1.m12(), t2.m12()) &&
+           fuzzyCompare(t1.m13(), t2.m13()) &&
+           fuzzyCompare(t1.m21(), t2.m21()) &&
+           fuzzyCompare(t1.m22(), t2.m22()) &&
+           fuzzyCompare(t1.m23(), t2.m23()) &&
+           fuzzyCompare(t1.m31(), t2.m31()) &&
+           fuzzyCompare(t1.m32(), t2.m32()) &&
+           fuzzyCompare(t1.m33(), t2.m33());
+}
+
+static inline bool fuzzyCompare(const QMatrix4x4& m1, const QMatrix4x4& m2)
+{
+    bool ok = true;
+    for (int y = 0; y < 4; ++y)
+        for (int x = 0; x < 4; ++x)
+            ok &= fuzzyCompare(m1(y, x), m2(y, x));
+    return ok;
+}
+
+void tst_QGraphicsTransform::rotation()
+{
+    QGraphicsRotation rotation;
+    QCOMPARE(rotation.axis(), QVector3D(0, 0, 1));
+    QCOMPARE(rotation.origin(), QVector3D(0, 0, 0));
+    QCOMPARE(rotation.angle(), (qreal)0);
+
+    rotation.setOrigin(QVector3D(10, 10, 0));
+
+    QCOMPARE(rotation.axis(), QVector3D(0, 0, 1));
+    QCOMPARE(rotation.origin(), QVector3D(10, 10, 0));
+    QCOMPARE(rotation.angle(), (qreal)0);
+
+    QMatrix4x4 t;
+    rotation.applyTo(&t);
+
+    QCOMPARE(t, QMatrix4x4());
+    QCOMPARE(transform2D(rotation), QTransform());
+
+    rotation.setAngle(40);
+    rotation.setOrigin(QVector3D(0, 0, 0));
+
+    QCOMPARE(rotation.axis(), QVector3D(0, 0, 1));
+    QCOMPARE(rotation.origin(), QVector3D(0, 0, 0));
+    QCOMPARE(rotation.angle(), (qreal)40);
+
+    QTransform res;
+    res.rotate(40);
+
+    QVERIFY(fuzzyCompare(transform2D(rotation), res));
+
+    rotation.setOrigin(QVector3D(10, 10, 0));
+    rotation.setAngle(90);
+    QCOMPARE(transform2D(rotation).map(QPointF(10, 10)), QPointF(10, 10));
+    QCOMPARE(transform2D(rotation).map(QPointF(20, 10)), QPointF(10, 20));
+
+    rotation.setOrigin(QVector3D(0, 0, 0));
+    rotation.setAngle(qQNaN());
+    QCOMPARE(transform2D(rotation).map(QPointF(20, 10)), QPointF(20, 10));
+}
+
+Q_DECLARE_METATYPE(Qt::Axis);
+void tst_QGraphicsTransform::rotation3d_data()
+{
+    QTest::addColumn<Qt::Axis>("axis");
+    QTest::addColumn<qreal>("angle");
+
+    for (int angle = 0; angle <= 360; angle++) {
+        QTest::newRow("test rotation on X") << Qt::XAxis << qreal(angle);
+        QTest::newRow("test rotation on Y") << Qt::YAxis << qreal(angle);
+        QTest::newRow("test rotation on Z") << Qt::ZAxis << qreal(angle);
+    }
+}
+
+void tst_QGraphicsTransform::rotation3d()
+{
+    QFETCH(Qt::Axis, axis);
+    QFETCH(qreal, angle);
+
+    QGraphicsRotation rotation;
+    rotation.setAxis(axis);
+
+    QMatrix4x4 t;
+    rotation.applyTo(&t);
+
+    QVERIFY(t.isIdentity());
+    QVERIFY(transform2D(rotation).isIdentity());
+
+    rotation.setAngle(angle);
+
+    // QGraphicsRotation uses a correct mathematical rotation in 3D.
+    // QTransform's Qt::YAxis rotation is inverted from the mathematical
+    // version of rotation.  We correct for that here.
+    QTransform expected;
+    if (axis == Qt::YAxis && angle != 180.)
+        expected.rotate(-angle, axis);
+    else
+        expected.rotate(angle, axis);
+
+    QVERIFY(fuzzyCompare(transform2D(rotation), expected));
+
+    // Check that "rotation" produces the 4x4 form of the 3x3 matrix.
+    // i.e. third row and column are 0 0 1 0.
+    t.setToIdentity();
+    rotation.applyTo(&t);
+    QMatrix4x4 r(expected);
+    if (sizeof(qreal) == sizeof(float) && angle == 268) {
+        // This test fails, on only this angle, when qreal == float
+        // because the deg2rad value in QTransform is not accurate
+        // enough to match what QMatrix4x4 is doing.
+    } else {
+        QVERIFY(fuzzyCompare(t, r));
+    }
+
+    //now let's check that a null vector will not change the transform
+    rotation.setAxis(QVector3D(0, 0, 0));
+    rotation.setOrigin(QVector3D(10, 10, 0));
+
+    t.setToIdentity();
+    rotation.applyTo(&t);
+
+    QVERIFY(t.isIdentity());
+    QVERIFY(transform2D(rotation).isIdentity());
+
+    rotation.setAngle(angle);
+
+    QVERIFY(t.isIdentity());
+    QVERIFY(transform2D(rotation).isIdentity());
+
+    rotation.setOrigin(QVector3D(0, 0, 0));
+
+    QVERIFY(t.isIdentity());
+    QVERIFY(transform2D(rotation).isIdentity());
+}
+
+QByteArray labelForTest(QVector3D const& axis, int angle) {
+    return QString("rotation of %1 on (%2, %3, %4)")
+        .arg(angle)
+        .arg(axis.x())
+        .arg(axis.y())
+        .arg(axis.z())
+        .toLatin1();
+}
+
+void tst_QGraphicsTransform::rotation3dArbitraryAxis_data()
+{
+    QTest::addColumn<QVector3D>("axis");
+    QTest::addColumn<qreal>("angle");
+
+    QVector3D axis1 = QVector3D(1.0f, 1.0f, 1.0f);
+    QVector3D axis2 = QVector3D(2.0f, -3.0f, 0.5f);
+    QVector3D axis3 = QVector3D(-2.0f, 0.0f, -0.5f);
+    QVector3D axis4 = QVector3D(0.0001f, 0.0001f, 0.0001f);
+    QVector3D axis5 = QVector3D(0.01f, 0.01f, 0.01f);
+
+    for (int angle = 0; angle <= 360; angle++) {
+        QTest::newRow(labelForTest(axis1, angle).constData()) << axis1 << qreal(angle);
+        QTest::newRow(labelForTest(axis2, angle).constData()) << axis2 << qreal(angle);
+        QTest::newRow(labelForTest(axis3, angle).constData()) << axis3 << qreal(angle);
+        QTest::newRow(labelForTest(axis4, angle).constData()) << axis4 << qreal(angle);
+        QTest::newRow(labelForTest(axis5, angle).constData()) << axis5 << qreal(angle);
+    }
+}
+
+void tst_QGraphicsTransform::rotation3dArbitraryAxis()
+{
+    QFETCH(QVector3D, axis);
+    QFETCH(qreal, angle);
+
+    QGraphicsRotation rotation;
+    rotation.setAxis(axis);
+
+    QMatrix4x4 t;
+    rotation.applyTo(&t);
+
+    QVERIFY(t.isIdentity());
+    QVERIFY(transform2D(rotation).isIdentity());
+
+    rotation.setAngle(angle);
+
+    // Compute the expected answer using QMatrix4x4 and a projection.
+    // These two steps are performed in one hit by QGraphicsRotation.
+    QMatrix4x4 exp;
+    exp.rotate(angle, axis);
+    QTransform expected = exp.toTransform(1024.0f);
+
+#if defined(MAY_HIT_QTBUG_20661)
+    // These failures possibly relate to the float vs qreal issue mentioned
+    // in the comment above fuzzyCompare().
+    if (sizeof(qreal) == sizeof(double)) {
+        QEXPECT_FAIL("rotation of 120 on (1, 1, 1)",                "QTBUG-20661", Abort);
+        QEXPECT_FAIL("rotation of 240 on (1, 1, 1)",                "QTBUG-20661", Abort);
+        QEXPECT_FAIL("rotation of 120 on (0.01, 0.01, 0.01)",       "QTBUG-20661", Abort);
+        QEXPECT_FAIL("rotation of 240 on (0.01, 0.01, 0.01)",       "QTBUG-20661", Abort);
+        QEXPECT_FAIL("rotation of 120 on (0.0001, 0.0001, 0.0001)", "QTBUG-20661", Abort);
+        QEXPECT_FAIL("rotation of 240 on (0.0001, 0.0001, 0.0001)", "QTBUG-20661", Abort);
+    }
+#endif
+
+    QTransform actual = transform2D(rotation);
+    QVERIFY2(fuzzyCompare(actual, expected), qPrintable(
+        QString("\nactual:   %1\n"
+                  "expected: %2")
+        .arg(toString(actual))
+        .arg(toString(expected))
+    ));
+
+    // Check that "rotation" produces the 4x4 form of the 3x3 matrix.
+    // i.e. third row and column are 0 0 1 0.
+    t.setToIdentity();
+    rotation.applyTo(&t);
+    QMatrix4x4 r(expected);
+    QVERIFY(qFuzzyCompare(t, r));
+}
+
+QString tst_QGraphicsTransform::toString(QTransform const& t)
+{
+    return QString("[ [ %1  %2   %3 ]; [ %4  %5  %6 ]; [ %7  %8  %9 ] ]")
+        .arg(t.m11())
+        .arg(t.m12())
+        .arg(t.m13())
+        .arg(t.m21())
+        .arg(t.m22())
+        .arg(t.m23())
+        .arg(t.m31())
+        .arg(t.m32())
+        .arg(t.m33())
+    ;
+}
+
+
+QTEST_MAIN(tst_QGraphicsTransform)
+#include "tst_qgraphicstransform.moc"
+
diff --git a/tests/auto/widgets/graphicsview/qgraphicsview/.gitignore b/tests/auto/widgets/graphicsview/qgraphicsview/.gitignore
new file mode 100644
index 0000000000..c8182c9e0d
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsview/.gitignore
@@ -0,0 +1 @@
+tst_qgraphicsview
diff --git a/tests/auto/widgets/graphicsview/qgraphicsview/qgraphicsview.pro b/tests/auto/widgets/graphicsview/qgraphicsview/qgraphicsview.pro
new file mode 100644
index 0000000000..9f32522546
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsview/qgraphicsview.pro
@@ -0,0 +1,9 @@
+load(qttest_p4)
+
+QT += widgets widgets-private
+QT += core-private gui-private
+
+SOURCES  += tst_qgraphicsview.cpp tst_qgraphicsview_2.cpp
+DEFINES += QT_NO_CAST_TO_ASCII
+
+contains(QT_CONFIG,xcb):qpa:CONFIG+=insignificant_test  # QTBUG-20756 crashes on qpa, xcb
diff --git a/tests/auto/widgets/graphicsview/qgraphicsview/tst_qgraphicsview.cpp b/tests/auto/widgets/graphicsview/qgraphicsview/tst_qgraphicsview.cpp
new file mode 100644
index 0000000000..0a404cab46
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsview/tst_qgraphicsview.cpp
@@ -0,0 +1,4558 @@
+/****************************************************************************
+**
+** 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 <qgraphicsitem.h>
+#include <qgraphicsscene.h>
+#include <qgraphicssceneevent.h>
+#include <qgraphicsview.h>
+#include <qgraphicswidget.h>
+#include <qgraphicsproxywidget.h>
+
+#include <math.h>
+
+#include <QtWidgets/QLabel>
+#if !defined(QT_NO_STYLE_MOTIF)
+#include <QtWidgets/QMotifStyle>
+#endif
+#if !defined(QT_NO_STYLE_WINDOWS)
+#include <QtWidgets/QWindowsStyle>
+#endif
+#if !defined(QT_NO_STYLE_PLASTIQUE)
+#include <QtWidgets/QPlastiqueStyle>
+#endif
+#include <QtGui/QPainterPath>
+#include <QtWidgets/QRubberBand>
+#include <QtWidgets/QScrollBar>
+#include <QtWidgets/QStyleOption>
+#include <QtWidgets/QBoxLayout>
+#include <QtWidgets/QStyle>
+#include <QtWidgets/QPushButton>
+#include <QtWidgets/QInputContext>
+#include <QtWidgets/QDesktopWidget>
+#include <private/qgraphicsview_p.h>
+#include "../../../platformquirks.h"
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+Q_DECLARE_METATYPE(QList<int>)
+Q_DECLARE_METATYPE(QList<QRectF>)
+Q_DECLARE_METATYPE(QMatrix)
+Q_DECLARE_METATYPE(QPainterPath)
+Q_DECLARE_METATYPE(QPointF)
+Q_DECLARE_METATYPE(QPolygonF)
+Q_DECLARE_METATYPE(QRectF)
+Q_DECLARE_METATYPE(Qt::ScrollBarPolicy)
+
+#ifdef Q_WS_MAC
+//On mac we get full update. So check that the expected region is contained inside the actual
+#define COMPARE_REGIONS(ACTUAL, EXPECTED) QVERIFY((EXPECTED).subtracted(ACTUAL).isEmpty())
+#else
+#define COMPARE_REGIONS QCOMPARE
+#endif
+
+static void sendMousePress(QWidget *widget, const QPoint &point, Qt::MouseButton button = Qt::LeftButton)
+{
+    QMouseEvent event(QEvent::MouseButtonPress, point, widget->mapToGlobal(point), button, 0, 0);
+    QApplication::sendEvent(widget, &event);
+}
+
+static void sendMouseMove(QWidget *widget, const QPoint &point, Qt::MouseButton button = Qt::NoButton, Qt::MouseButtons buttons = 0)
+{
+    QTest::mouseMove(widget, point);
+    QMouseEvent event(QEvent::MouseMove, point, button, buttons, 0);
+    QApplication::sendEvent(widget, &event);
+    QApplication::processEvents();
+}
+
+static void sendMouseRelease(QWidget *widget, const QPoint &point, Qt::MouseButton button = Qt::LeftButton)
+{
+    QMouseEvent event(QEvent::MouseButtonRelease, point, widget->mapToGlobal(point), button, 0, 0);
+    QApplication::sendEvent(widget, &event);
+}
+
+class EventSpy : public QObject
+{
+    Q_OBJECT
+public:
+    EventSpy(QObject *watched, QEvent::Type type)
+        : _count(0), spied(type)
+    {
+        watched->installEventFilter(this);
+    }
+
+    int count() const { return _count; }
+    void reset() { _count = 0; }
+
+protected:
+    bool eventFilter(QObject *watched, QEvent *event)
+    {
+        Q_UNUSED(watched);
+        if (event->type() == spied)
+            ++_count;
+        return false;
+    }
+
+    int _count;
+    QEvent::Type spied;
+};
+
+class tst_QGraphicsView : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void initTestCase();
+    void construction();
+    void renderHints();
+    void alignment();
+    void interactive();
+    void scene();
+    void setScene();
+    void deleteScene();
+    void sceneRect();
+    void sceneRect_growing();
+    void setSceneRect();
+    void viewport();
+    void dragMode_scrollHand();
+    void dragMode_rubberBand();
+    void rubberBandSelectionMode();
+    void backgroundBrush();
+    void foregroundBrush();
+    void matrix();
+    void matrix_convenience();
+    void matrix_combine();
+    void centerOnPoint();
+    void centerOnItem();
+    void ensureVisibleRect();
+    void fitInView();
+    void itemsAtPoint();
+    void itemsInRect();
+    void itemsInRect_cosmeticAdjust_data();
+    void itemsInRect_cosmeticAdjust();
+    void itemsInPoly();
+    void itemsInPath();
+    void itemAt();
+    void itemAt2();
+    void mapToScene();
+    void mapToScenePoint();
+    void mapToSceneRect_data();
+    void mapToSceneRect();
+    void mapToScenePoly();
+    void mapToScenePath();
+    void mapFromScenePoint();
+    void mapFromSceneRect();
+    void mapFromScenePoly();
+    void mapFromScenePath();
+    void sendEvent();
+    void wheelEvent();
+#if !defined(QT_NO_CURSOR) && !defined(Q_OS_WINCE)
+    void cursor();
+    void cursor2();
+#endif
+    void transformationAnchor();
+    void resizeAnchor();
+    void viewportUpdateMode();
+    void viewportUpdateMode2();
+#ifndef QT_NO_DRAGANDDROP
+    void acceptDrops();
+#endif
+    void optimizationFlags();
+    void optimizationFlags_dontSavePainterState();
+    void optimizationFlags_dontSavePainterState2_data();
+    void optimizationFlags_dontSavePainterState2();
+    void levelOfDetail_data();
+    void levelOfDetail();
+    void scrollBarRanges_data();
+    void scrollBarRanges();
+    void acceptMousePressEvent();
+    void replayMouseMove();
+    void itemsUnderMouse();
+    void embeddedViews();
+    void scrollAfterResize_data();
+    void scrollAfterResize();
+    void moveItemWhileScrolling_data();
+    void moveItemWhileScrolling();
+    void centerOnDirtyItem();
+    void mouseTracking();
+    void mouseTracking2();
+    void mouseTracking3();
+    void render();
+    void exposeRegion();
+    void update_data();
+    void update();
+    void update2_data();
+    void update2();
+    void update_ancestorClipsChildrenToShape();
+    void update_ancestorClipsChildrenToShape2();
+    void inputMethodSensitivity();
+    void inputContextReset();
+    void indirectPainting();
+    void compositionModeInDrawBackground();
+
+    // task specific tests below me
+    void task172231_untransformableItems();
+    void task180429_mouseReleaseDragMode();
+    void task187791_setSceneCausesUpdate();
+    void task186827_deleteReplayedItem();
+    void task207546_focusCrash();
+    void task210599_unsetDragWhileDragging();
+    void task236394_sendShortcutOverrideEvent();
+    void task239729_noViewUpdate_data();
+    void task239729_noViewUpdate();
+    void task239047_fitInViewSmallViewport();
+    void task245469_itemsAtPointWithClip();
+    void task253415_reconnectUpdateSceneOnSceneChanged();
+#ifndef Q_OS_WINCE
+    void task255529_transformationAnchorMouseAndViewportMargins();
+#endif
+    void task259503_scrollingArtifacts();
+    void QTBUG_4151_clipAndIgnore_data();
+    void QTBUG_4151_clipAndIgnore();
+    void QTBUG_5859_exposedRect();
+#if !defined(QT_NO_CURSOR) && !defined(Q_OS_WINCE)
+    void QTBUG_7438_cursor();
+#endif
+    void hoverLeave();
+    void QTBUG_16063_microFocusRect();
+
+public slots:
+    void dummySlot() {}
+};
+
+void tst_QGraphicsView::initTestCase()
+{
+#ifdef Q_OS_WINCE_WM
+    qApp->setAutoMaximizeThreshold(-1);
+#endif
+}
+
+void tst_QGraphicsView::construction()
+{
+    QGraphicsView view;
+    QCOMPARE(view.renderHints(), QPainter::TextAntialiasing);
+    QCOMPARE(view.dragMode(), QGraphicsView::NoDrag);
+    QVERIFY(view.isInteractive());
+    QVERIFY(!view.scene());
+    QCOMPARE(view.sceneRect(), QRectF());
+    QVERIFY(view.viewport());
+    QCOMPARE(view.viewport()->metaObject()->className(), "QWidget");
+    QCOMPARE(view.matrix(), QMatrix());
+    QVERIFY(view.items().isEmpty());
+    QVERIFY(view.items(QPoint()).isEmpty());
+    QVERIFY(view.items(QRect()).isEmpty());
+    QVERIFY(view.items(QPolygon()).isEmpty());
+    QVERIFY(view.items(QPainterPath()).isEmpty());
+    QVERIFY(!view.itemAt(QPoint()));
+    QCOMPARE(view.mapToScene(QPoint()), QPointF());
+    QCOMPARE(view.mapToScene(QRect()), QPolygonF());
+    QCOMPARE(view.mapToScene(QPolygon()), QPolygonF());
+    QCOMPARE(view.mapFromScene(QPointF()), QPoint());
+    QPolygon poly;
+    poly << QPoint() << QPoint() << QPoint() << QPoint();
+    QCOMPARE(view.mapFromScene(QRectF()), poly);
+    QCOMPARE(view.mapFromScene(QPolygonF()), QPolygon());
+    QCOMPARE(view.transformationAnchor(), QGraphicsView::AnchorViewCenter);
+    QCOMPARE(view.resizeAnchor(), QGraphicsView::NoAnchor);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+}
+
+class TestItem : public QGraphicsItem
+{
+public:
+    QRectF boundingRect() const
+    { return QRectF(-10, -10, 20, 20); }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+    { hints = painter->renderHints(); painter->drawRect(boundingRect()); }
+
+    bool sceneEvent(QEvent *event)
+    {
+        events << event->type();
+        return QGraphicsItem::sceneEvent(event);
+    }
+
+    QList<QEvent::Type> events;
+    QPainter::RenderHints hints;
+};
+
+void tst_QGraphicsView::renderHints()
+{
+    QGraphicsView view;
+    QCOMPARE(view.renderHints(), QPainter::TextAntialiasing);
+    view.setRenderHint(QPainter::TextAntialiasing, false);
+    QCOMPARE(view.renderHints(), 0);
+    view.setRenderHint(QPainter::Antialiasing, false);
+    QCOMPARE(view.renderHints(), 0);
+    view.setRenderHint(QPainter::TextAntialiasing, true);
+    QCOMPARE(view.renderHints(), QPainter::TextAntialiasing);
+    view.setRenderHint(QPainter::Antialiasing);
+    QCOMPARE(view.renderHints(), QPainter::TextAntialiasing | QPainter::Antialiasing);
+    view.setRenderHints(0);
+    QCOMPARE(view.renderHints(), 0);
+
+    TestItem *item = new TestItem;
+    QGraphicsScene scene;
+    scene.addItem(item);
+
+    view.setScene(&scene);
+
+    view.setRenderHints(QPainter::TextAntialiasing | QPainter::Antialiasing | QPainter::NonCosmeticDefaultPen);
+    QCOMPARE(view.renderHints(), QPainter::TextAntialiasing | QPainter::Antialiasing | QPainter::NonCosmeticDefaultPen);
+
+    QCOMPARE(item->hints, 0);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    view.repaint();
+    QTRY_COMPARE(item->hints, view.renderHints());
+
+    view.setRenderHints(QPainter::Antialiasing | QPainter::NonCosmeticDefaultPen);
+    QCOMPARE(view.renderHints(), QPainter::Antialiasing | QPainter::NonCosmeticDefaultPen);
+
+    view.repaint();
+    QTRY_COMPARE(item->hints, view.renderHints());
+}
+
+void tst_QGraphicsView::alignment()
+{
+    QGraphicsScene scene;
+    scene.addRect(QRectF(-10, -10, 20, 20));
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    for (int i = 0; i < 3; ++i) {
+        for (int j = 0; j < 3; ++j) {
+            Qt::Alignment alignment = 0;
+            switch (i) {
+            case 0:
+                alignment |= Qt::AlignLeft;
+                break;
+            case 1:
+                alignment |= Qt::AlignHCenter;
+                break;
+            case 2:
+            default:
+                alignment |= Qt::AlignRight;
+                break;
+            }
+            switch (j) {
+            case 0:
+                alignment |= Qt::AlignTop;
+                break;
+            case 1:
+                alignment |= Qt::AlignVCenter;
+                break;
+            case 2:
+            default:
+                alignment |= Qt::AlignBottom;
+                break;
+            }
+            view.setAlignment(alignment);
+            QCOMPARE(view.alignment(), alignment);
+
+            for (int k = 0; k < 3; ++k) {
+                view.resize(100 + k * 25, 100 + k * 25);
+                QApplication::processEvents();
+            }
+        }
+    }
+}
+
+void tst_QGraphicsView::interactive()
+{
+    TestItem *item = new TestItem;
+    item->setFlags(QGraphicsItem::ItemIsMovable);
+    QCOMPARE(item->events.size(), 0);
+
+    QGraphicsScene scene(-200, -200, 400, 400);
+    scene.addItem(item);
+
+    QGraphicsView view(&scene);
+    if (PlatformQuirks::isAutoMaximizing())
+        view.setWindowFlags(view.windowFlags()|Qt::X11BypassWindowManagerHint);
+    view.setFixedSize(300, 300);
+    QCOMPARE(item->events.size(), 0);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    view.activateWindow();
+
+    QApplication::processEvents();
+    QTRY_COMPARE(item->events.size(), 1); // activate
+
+    QPoint itemPoint = view.mapFromScene(item->scenePos());
+
+    QVERIFY(view.itemAt(itemPoint));
+
+    for (int i = 0; i < 100; ++i) {
+        sendMousePress(view.viewport(), itemPoint);
+        QCOMPARE(item->events.size(), i * 5 + 3);
+        QCOMPARE(item->events.at(item->events.size() - 2), QEvent::GrabMouse);
+        QCOMPARE(item->events.at(item->events.size() - 1), QEvent::GraphicsSceneMousePress);
+        sendMouseRelease(view.viewport(), itemPoint);
+        QCOMPARE(item->events.size(), i * 5 + 5);
+        QCOMPARE(item->events.at(item->events.size() - 2), QEvent::GraphicsSceneMouseRelease);
+        QCOMPARE(item->events.at(item->events.size() - 1), QEvent::UngrabMouse);
+        QContextMenuEvent contextEvent(QContextMenuEvent::Mouse, itemPoint, view.mapToGlobal(itemPoint));
+        QApplication::sendEvent(view.viewport(), &contextEvent);
+        QCOMPARE(item->events.size(), i * 5 + 6);
+        QCOMPARE(item->events.last(), QEvent::GraphicsSceneContextMenu);
+    }
+
+    view.setInteractive(false);
+
+    for (int i = 0; i < 100; ++i) {
+        sendMousePress(view.viewport(), itemPoint);
+        QCOMPARE(item->events.size(), 501);
+        QCOMPARE(item->events.last(), QEvent::GraphicsSceneContextMenu);
+        sendMouseRelease(view.viewport(), itemPoint);
+        QCOMPARE(item->events.size(), 501);
+        QCOMPARE(item->events.last(), QEvent::GraphicsSceneContextMenu);
+        QContextMenuEvent contextEvent(QContextMenuEvent::Mouse, itemPoint, view.mapToGlobal(itemPoint));
+        QApplication::sendEvent(view.viewport(), &contextEvent);
+        QCOMPARE(item->events.size(), 501);
+        QCOMPARE(item->events.last(), QEvent::GraphicsSceneContextMenu);
+    }
+}
+
+void tst_QGraphicsView::scene()
+{
+    QGraphicsView view;
+    QVERIFY(!view.scene());
+    view.setScene(0);
+    QVERIFY(!view.scene());
+
+    {
+        QGraphicsScene scene;
+        view.setScene(&scene);
+        QCOMPARE(view.scene(), &scene);
+    }
+
+    QCOMPARE(view.scene(), (QGraphicsScene *)0);
+}
+
+void tst_QGraphicsView::setScene()
+{
+    QGraphicsScene scene(-1000, -1000, 2000, 2000);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QCOMPARE(view.sceneRect(), scene.sceneRect());
+
+    QVERIFY(view.horizontalScrollBar()->isVisible());
+    QVERIFY(view.verticalScrollBar()->isVisible());
+    QVERIFY(!view.horizontalScrollBar()->isHidden());
+    QVERIFY(!view.verticalScrollBar()->isHidden());
+
+    view.setScene(0);
+
+    QTest::qWait(25);
+
+    QVERIFY(!view.horizontalScrollBar()->isVisible());
+    QVERIFY(!view.verticalScrollBar()->isVisible());
+    QVERIFY(!view.horizontalScrollBar()->isHidden());
+    QVERIFY(!view.verticalScrollBar()->isHidden());
+
+    QCOMPARE(view.sceneRect(), QRectF());
+}
+
+void tst_QGraphicsView::deleteScene()
+{
+    QGraphicsScene *scene = new QGraphicsScene;
+    QGraphicsView view1(scene);
+    view1.show();
+    QGraphicsView view2(scene);
+    view2.show();
+    QGraphicsView view3(scene);
+    view3.show();
+    delete scene;
+    QCOMPARE(view1.scene(), (QGraphicsScene *)0);
+    QCOMPARE(view2.scene(), (QGraphicsScene *)0);
+    QCOMPARE(view3.scene(), (QGraphicsScene *)0);
+}
+
+void tst_QGraphicsView::sceneRect()
+{
+    QGraphicsView view;
+    QCOMPARE(view.sceneRect(), QRectF());
+
+    view.setSceneRect(QRectF(-100, -100, 200, 200));
+    QCOMPARE(view.sceneRect(), QRectF(-100, -100, 200, 200));
+    view.setSceneRect(-100, -100, 200, 200);
+    QCOMPARE(view.sceneRect(), QRectF(-100, -100, 200, 200));
+
+    view.setSceneRect(QRectF());
+    QCOMPARE(view.sceneRect(), QRectF());
+    QGraphicsScene scene;
+    QGraphicsRectItem *item = scene.addRect(QRectF(-100, -100, 100, 100));
+
+    view.setScene(&scene);
+
+    QCOMPARE(view.sceneRect(), QRectF(-100, -100, 100, 100));
+    item->moveBy(-100, -100);
+    QCOMPARE(view.sceneRect(), QRectF(-200, -200, 200, 200));
+    item->moveBy(100, 100);
+    QCOMPARE(view.sceneRect(), QRectF(-200, -200, 200, 200));
+
+    view.setScene(0);
+    view.setSceneRect(QRectF());
+    QCOMPARE(view.sceneRect(), QRectF());
+}
+
+void tst_QGraphicsView::sceneRect_growing()
+{
+    QWidget toplevel;
+
+    QGraphicsScene scene;
+    for (int i = 0; i < 100; ++i)
+        scene.addText(QString("(0, %1)").arg((i - 50) * 20))->setPos(0, (i - 50) * 20);
+
+    QGraphicsView view(&scene, &toplevel);
+    view.setFixedSize(200, 200);
+    toplevel.show();
+
+    int size = 200;
+    scene.setSceneRect(-size, -size, size * 2, size * 2);
+    QCOMPARE(view.sceneRect(), scene.sceneRect());
+
+    QTest::qWait(25);
+
+    QPointF topLeft = view.mapToScene(0, 0);
+
+    for (int i = 0; i < 5; ++i) {
+        size *= 2;
+        scene.setSceneRect(-size, -size, size * 2, size * 2);
+
+        QApplication::processEvents();
+
+        QCOMPARE(view.sceneRect(), scene.sceneRect());
+        QCOMPARE(view.mapToScene(0, 0), topLeft);
+        view.setSceneRect(-size, -size, size * 2, size * 2);
+        QCOMPARE(view.mapToScene(0, 0), topLeft);
+        view.setSceneRect(QRectF());
+    }
+}
+
+void tst_QGraphicsView::setSceneRect()
+{
+    QRectF rect1(-100, -100, 200, 200);
+    QRectF rect2(-300, -300, 150, 150);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    scene.setSceneRect(rect1);
+    QCOMPARE(scene.sceneRect(), rect1);
+    QCOMPARE(view.sceneRect(), rect1);
+
+    scene.setSceneRect(rect2);
+    QCOMPARE(scene.sceneRect(), rect2);
+    QCOMPARE(view.sceneRect(), rect2);
+
+    view.setSceneRect(rect1);
+    QCOMPARE(scene.sceneRect(), rect2);
+    QCOMPARE(view.sceneRect(), rect1);
+
+    view.setSceneRect(rect2);
+    QCOMPARE(scene.sceneRect(), rect2);
+    QCOMPARE(view.sceneRect(), rect2);
+
+    scene.setSceneRect(rect1);
+    QCOMPARE(scene.sceneRect(), rect1);
+    QCOMPARE(view.sceneRect(), rect2);
+
+    // extreme transformations will max out the scrollbars' ranges.
+    view.setSceneRect(-2000000, -2000000, 4000000, 4000000);
+    view.scale(9000, 9000);
+    QCOMPARE(view.horizontalScrollBar()->minimum(), INT_MIN);
+    QCOMPARE(view.horizontalScrollBar()->maximum(), INT_MAX);
+    QCOMPARE(view.verticalScrollBar()->minimum(), INT_MIN);
+    QCOMPARE(view.verticalScrollBar()->maximum(), INT_MAX);
+}
+
+void tst_QGraphicsView::viewport()
+{
+    QGraphicsScene scene;
+    scene.addText("GraphicsView");
+
+    QGraphicsView view(&scene);
+    QVERIFY(view.viewport() != 0);
+
+    view.show();
+    QTest::qWait(25);
+
+    QPointer<QWidget> widget = new QWidget;
+    view.setViewport(widget);
+    QCOMPARE(view.viewport(), (QWidget *)widget);
+
+    view.show();
+    QTest::qWait(25);
+
+    view.setViewport(0);
+    QVERIFY(widget.isNull());
+    QVERIFY(view.viewport() != 0);
+    QVERIFY(view.viewport() != widget);
+
+    view.show();
+    QTest::qWait(25);
+}
+
+void tst_QGraphicsView::dragMode_scrollHand()
+{
+    for (int j = 0; j < 2; ++j) {
+        QGraphicsView view;
+        QCOMPARE(view.dragMode(), QGraphicsView::NoDrag);
+
+        view.setSceneRect(-1000, -1000, 2000, 2000);
+        view.setFixedSize(100, 100);
+        view.show();
+
+        QTest::qWaitForWindowShown(&view);
+        QApplication::processEvents();
+
+        view.setInteractive(j ? false : true);
+
+        QGraphicsScene scene;
+        scene.addRect(QRectF(-100, -100, 5, 5));
+        scene.addRect(QRectF(95, -100, 5, 5));
+        scene.addRect(QRectF(95, 95, 5, 5));
+        QGraphicsItem *item = scene.addRect(QRectF(-100, 95, 5, 5));
+        item->setFlag(QGraphicsItem::ItemIsSelectable);
+        item->setSelected(true);
+        QVERIFY(item->isSelected());
+        QVERIFY(!view.scene());
+
+        view.setDragMode(QGraphicsView::ScrollHandDrag);
+
+        for (int i = 0; i < 2; ++i) {
+            // ScrollHandDrag
+#ifndef QT_NO_CURSOR
+            Qt::CursorShape cursorShape = view.viewport()->cursor().shape();
+#endif
+            int horizontalScrollBarValue = view.horizontalScrollBar()->value();
+            int verticalScrollBarValue = view.verticalScrollBar()->value();
+            {
+                // Press
+                QMouseEvent event(QEvent::MouseButtonPress,
+                                  view.viewport()->rect().center(),
+                                  Qt::LeftButton, Qt::LeftButton, 0);
+                event.setAccepted(true);
+                QApplication::sendEvent(view.viewport(), &event);
+                QVERIFY(event.isAccepted());
+            }
+            QApplication::processEvents();
+
+            QTRY_VERIFY(item->isSelected());
+
+            for (int k = 0; k < 4; ++k) {
+#ifndef QT_NO_CURSOR
+                QCOMPARE(view.viewport()->cursor().shape(), Qt::ClosedHandCursor);
+#endif
+                {
+                    // Move
+                    QMouseEvent event(QEvent::MouseMove,
+                                      view.viewport()->rect().center() + QPoint(10, 0),
+                                      Qt::LeftButton, Qt::LeftButton, 0);
+                    event.setAccepted(true);
+                    QApplication::sendEvent(view.viewport(), &event);
+                    QVERIFY(event.isAccepted());
+                }
+                QVERIFY(item->isSelected());
+                QCOMPARE(view.horizontalScrollBar()->value(), horizontalScrollBarValue - 10);
+                QCOMPARE(view.verticalScrollBar()->value(), verticalScrollBarValue);
+                {
+                    // Move
+                    QMouseEvent event(QEvent::MouseMove,
+                                      view.viewport()->rect().center() + QPoint(10, 10),
+                                      Qt::LeftButton, Qt::LeftButton, 0);
+                    event.setAccepted(true);
+                    QApplication::sendEvent(view.viewport(), &event);
+                    QVERIFY(event.isAccepted());
+                }
+                QVERIFY(item->isSelected());
+                QCOMPARE(view.horizontalScrollBar()->value(), horizontalScrollBarValue - 10);
+                QCOMPARE(view.verticalScrollBar()->value(), verticalScrollBarValue - 10);
+            }
+
+            {
+                // Release
+                QMouseEvent event(QEvent::MouseButtonRelease,
+                                  view.viewport()->rect().center() + QPoint(10, 10),
+                                  Qt::LeftButton, Qt::LeftButton, 0);
+                event.setAccepted(true);
+                QApplication::sendEvent(view.viewport(), &event);
+                QVERIFY(event.isAccepted());
+            }
+            QApplication::processEvents();
+
+            QTRY_VERIFY(item->isSelected());
+            QCOMPARE(view.horizontalScrollBar()->value(), horizontalScrollBarValue - 10);
+            QCOMPARE(view.verticalScrollBar()->value(), verticalScrollBarValue - 10);
+#ifndef QT_NO_CURSOR
+            QCOMPARE(view.viewport()->cursor().shape(), cursorShape);
+#endif
+
+            // Check that items are not unselected because of a scroll hand drag.
+            QVERIFY(item->isSelected());
+
+            // Check that a click will still unselect the item.
+            {
+                // Press
+                QMouseEvent event(QEvent::MouseButtonPress,
+                                  view.viewport()->rect().center() + QPoint(10, 10),
+                                  Qt::LeftButton, Qt::LeftButton, 0);
+                QApplication::sendEvent(view.viewport(), &event);
+            }
+            {
+                // Release
+                QMouseEvent event(QEvent::MouseButtonRelease,
+                                  view.viewport()->rect().center() + QPoint(10, 10),
+                                  Qt::LeftButton, Qt::LeftButton, 0);
+                QApplication::sendEvent(view.viewport(), &event);
+            }
+
+            if (view.isInteractive()) {
+                if (view.scene()) {
+                    QVERIFY(!item->isSelected());
+                    item->setSelected(true);
+                } else {
+                    QVERIFY(item->isSelected());
+                }
+            } else {
+                QVERIFY(item->isSelected());
+            }
+
+            view.setScene(&scene);
+        }
+    }
+}
+
+void tst_QGraphicsView::dragMode_rubberBand()
+{
+    QGraphicsView view;
+    QCOMPARE(view.dragMode(), QGraphicsView::NoDrag);
+
+    view.setSceneRect(-1000, -1000, 2000, 2000);
+    view.show();
+
+    QGraphicsScene scene;
+    scene.addRect(QRectF(-100, -100, 25, 25))->setFlag(QGraphicsItem::ItemIsSelectable);
+    scene.addRect(QRectF(75, -100, 25, 25))->setFlag(QGraphicsItem::ItemIsSelectable);
+    scene.addRect(QRectF(75, 75, 25, 25))->setFlag(QGraphicsItem::ItemIsSelectable);
+    scene.addRect(QRectF(-100, 75, 25, 25))->setFlag(QGraphicsItem::ItemIsSelectable);
+
+    view.setDragMode(QGraphicsView::RubberBandDrag);
+
+    QTest::qWaitForWindowShown(&view);
+    QApplication::processEvents();
+
+    for (int i = 0; i < 2; ++i) {
+        // RubberBandDrag
+#ifndef QT_NO_CURSOR
+        Qt::CursorShape cursorShape = view.viewport()->cursor().shape();
+#endif
+        int horizontalScrollBarValue = view.horizontalScrollBar()->value();
+        int verticalScrollBarValue = view.verticalScrollBar()->value();
+        {
+            // Press
+            QMouseEvent event(QEvent::MouseButtonPress,
+                              view.viewport()->rect().center(),
+                              Qt::LeftButton, Qt::LeftButton, 0);
+            event.setAccepted(true);
+            QApplication::sendEvent(view.viewport(), &event);
+            QVERIFY(event.isAccepted());
+        }
+#ifndef QT_NO_CURSOR
+        QCOMPARE(view.viewport()->cursor().shape(), cursorShape);
+#endif
+
+        QApplication::processEvents();
+
+        {
+            // Move
+            QMouseEvent event(QEvent::MouseMove,
+                              view.viewport()->rect().center() + QPoint(100, 0),
+                              Qt::LeftButton, Qt::LeftButton, 0);
+            event.setAccepted(true);
+            QApplication::sendEvent(view.viewport(), &event);
+            QVERIFY(event.isAccepted());
+        }
+        QCOMPARE(view.horizontalScrollBar()->value(), horizontalScrollBarValue);
+        QCOMPARE(view.verticalScrollBar()->value(), verticalScrollBarValue);
+
+        // We don't use QRubberBand as of 4.3; the band is drawn internally.
+        QVERIFY(!qFindChild<QRubberBand *>(&view));
+
+        QTest::qWait(25);
+
+        {
+            // Move
+            QMouseEvent event(QEvent::MouseMove,
+                              view.viewport()->rect().center() + QPoint(100, 100),
+                              Qt::LeftButton, Qt::LeftButton, 0);
+            event.setAccepted(true);
+            QApplication::sendEvent(view.viewport(), &event);
+            QVERIFY(event.isAccepted());
+        }
+        QCOMPARE(view.horizontalScrollBar()->value(), horizontalScrollBarValue);
+        QCOMPARE(view.verticalScrollBar()->value(), verticalScrollBarValue);
+
+        QTest::qWait(25);
+
+        {
+            // Release
+            QMouseEvent event(QEvent::MouseButtonRelease,
+                              view.viewport()->rect().center() + QPoint(100, 100),
+                              Qt::LeftButton, Qt::LeftButton, 0);
+            event.setAccepted(true);
+            QApplication::sendEvent(view.viewport(), &event);
+            QVERIFY(event.isAccepted());
+        }
+        QCOMPARE(view.horizontalScrollBar()->value(), horizontalScrollBarValue);
+        QCOMPARE(view.verticalScrollBar()->value(), verticalScrollBarValue);
+#ifndef QT_NO_CURSOR
+        QCOMPARE(view.viewport()->cursor().shape(), cursorShape);
+#endif
+
+        QTest::qWait(25);
+
+        if (view.scene())
+            QCOMPARE(scene.selectedItems().size(), 1);
+
+        view.setScene(&scene);
+        view.centerOn(0, 0);
+    }
+}
+
+void tst_QGraphicsView::rubberBandSelectionMode()
+{
+    QWidget toplevel;
+
+    QGraphicsScene scene;
+    QGraphicsRectItem *rect = scene.addRect(QRectF(10, 10, 80, 80));
+    rect->setFlag(QGraphicsItem::ItemIsSelectable);
+
+    QGraphicsView view(&scene, &toplevel);
+    QCOMPARE(view.rubberBandSelectionMode(), Qt::IntersectsItemShape);
+    view.setDragMode(QGraphicsView::RubberBandDrag);
+    view.resize(120, 120);
+    toplevel.show();
+
+    // Disable mouse tracking to prevent the window system from sending mouse
+    // move events to the viewport while we are synthesizing events. If
+    // QGraphicsView gets a mouse move event with no buttons down, it'll
+    // terminate the rubber band.
+    view.viewport()->setMouseTracking(false);
+
+    QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>());
+    sendMousePress(view.viewport(), QPoint(), Qt::LeftButton);
+    sendMouseMove(view.viewport(), view.viewport()->rect().center(),
+                  Qt::LeftButton, Qt::LeftButton);
+    QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>() << rect);
+    sendMouseRelease(view.viewport(), QPoint(), Qt::LeftButton);
+
+    view.setRubberBandSelectionMode(Qt::ContainsItemShape);
+    QCOMPARE(view.rubberBandSelectionMode(), Qt::ContainsItemShape);
+    sendMousePress(view.viewport(), QPoint(), Qt::LeftButton);
+    QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>());
+    sendMouseMove(view.viewport(), view.viewport()->rect().center(),
+                  Qt::LeftButton, Qt::LeftButton);
+    QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>());
+    sendMouseMove(view.viewport(), view.viewport()->rect().bottomRight(),
+                  Qt::LeftButton, Qt::LeftButton);
+    QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>() << rect);
+}
+
+void tst_QGraphicsView::backgroundBrush()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    scene.setBackgroundBrush(Qt::blue);
+    QCOMPARE(scene.backgroundBrush(), QBrush(Qt::blue));
+
+    view.show();
+    QTest::qWait(25);
+
+    scene.setBackgroundBrush(QBrush());
+    QCOMPARE(scene.backgroundBrush(), QBrush());
+    QTest::qWait(25);
+
+    QRadialGradient gradient(0, 0, 10);
+    gradient.setSpread(QGradient::RepeatSpread);
+    scene.setBackgroundBrush(gradient);
+
+    QCOMPARE(scene.backgroundBrush(), QBrush(gradient));
+    QTest::qWait(25);
+}
+
+void tst_QGraphicsView::foregroundBrush()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    scene.setForegroundBrush(Qt::blue);
+    QCOMPARE(scene.foregroundBrush(), QBrush(Qt::blue));
+
+    view.show();
+    QTest::qWait(25);
+
+    scene.setForegroundBrush(QBrush());
+    QCOMPARE(scene.foregroundBrush(), QBrush());
+    QTest::qWait(25);
+
+    QRadialGradient gradient(0, 0, 10);
+    gradient.setSpread(QGradient::RepeatSpread);
+    scene.setForegroundBrush(gradient);
+
+    QCOMPARE(scene.foregroundBrush(), QBrush(gradient));
+    QTest::qWait(25);
+
+    for (int i = 0; i < 50; ++i) {
+        QRadialGradient gradient(view.rect().center() + QPoint(int(sin(i / 2.0) * 10), int(cos(i / 2.0) * 10)), 10);
+        gradient.setColorAt(0, Qt::transparent);
+        gradient.setColorAt(0.5, Qt::black);
+        gradient.setColorAt(1, Qt::transparent);
+        gradient.setSpread(QGradient::RepeatSpread);
+        scene.setForegroundBrush(gradient);
+
+        QRadialGradient gradient2(view.rect().center() + QPoint(int(sin(i / 1.7) * 10), int(cos(i / 1.7) * 10)), 10);
+        gradient2.setColorAt(0, Qt::transparent);
+        gradient2.setColorAt(0.5, Qt::black);
+        gradient2.setColorAt(1, Qt::transparent);
+        gradient2.setSpread(QGradient::RepeatSpread);
+        scene.setBackgroundBrush(gradient2);
+
+        QRadialGradient gradient3(view.rect().center() + QPoint(int(sin(i / 1.85) * 10), int(cos(i / 1.85) * 10)), 10);
+        gradient3.setColorAt(0, Qt::transparent);
+        gradient3.setColorAt(0.5, Qt::black);
+        gradient3.setColorAt(1, Qt::transparent);
+        gradient3.setSpread(QGradient::RepeatSpread);
+        scene.setBackgroundBrush(gradient3);
+
+        QApplication::processEvents();
+    }
+
+    view.setSceneRect(-1000, -1000, 2000, 2000);
+    for (int i = -500; i < 500; i += 10) {
+        view.centerOn(i, 0);
+        QApplication::processEvents();
+        QApplication::processEvents();
+    }
+    for (int i = -500; i < 500; i += 10) {
+        view.centerOn(0, i);
+        QApplication::processEvents();
+        QApplication::processEvents();
+    }
+}
+
+void tst_QGraphicsView::matrix()
+{
+    {
+        QGraphicsScene scene;
+        QGraphicsView view(&scene);
+        view.show();
+
+        // Show rendering of background with no scene
+        for (int i = 0; i < 50; ++i) {
+            view.rotate(5);
+            QRadialGradient gradient(view.rect().center() + QPoint(int(sin(i / 2.0) * 10), int(cos(i / 2.0) * 10)), 10);
+            gradient.setColorAt(0, Qt::transparent);
+            gradient.setColorAt(0.5, Qt::black);
+            gradient.setColorAt(1, Qt::transparent);
+            gradient.setSpread(QGradient::RepeatSpread);
+            scene.setForegroundBrush(gradient);
+            QRadialGradient gradient2(view.rect().center() + QPoint(int(sin(i / 1.7) * 10), int(cos(i / 1.7) * 10)), 10);
+            gradient2.setColorAt(0, Qt::transparent);
+            gradient2.setColorAt(0.5, Qt::black);
+            gradient2.setColorAt(1, Qt::transparent);
+            gradient2.setSpread(QGradient::RepeatSpread);
+            scene.setBackgroundBrush(gradient2);
+            QApplication::processEvents();
+            QApplication::processEvents();
+        }
+    }
+
+    // Test transformation extremes, see if they cause crashes
+    {
+        QGraphicsScene scene;
+        scene.addText("GraphicsView rotated clockwise");
+
+        QGraphicsView view(&scene);
+        view.show();
+        for (int i = 0; i < 160; ++i) {
+            view.rotate(18);
+            QApplication::processEvents();
+            QApplication::processEvents();
+        }
+        /*
+          // These cause a crash
+        for (int i = 0; i < 40; ++i) {
+            view.shear(1.2, 1.2);
+            QTest::qWait(20);
+        }
+        for (int i = 0; i < 40; ++i) {
+            view.shear(-1.2, -1.2);
+            QTest::qWait(20);
+        }
+        */
+        for (int i = 0; i < 20; ++i) {
+            view.scale(1.2, 1.2);
+            QApplication::processEvents();
+            QApplication::processEvents();
+        }
+        for (int i = 0; i < 20; ++i) {
+            view.scale(0.6, 0.6);
+            QApplication::processEvents();
+            QApplication::processEvents();
+        }
+    }
+}
+
+void tst_QGraphicsView::matrix_convenience()
+{
+    QGraphicsView view;
+    QCOMPARE(view.matrix(), QMatrix());
+
+    // Check the convenience functions
+    view.rotate(90);
+    QCOMPARE(view.matrix(), QMatrix().rotate(90));
+    view.scale(2, 2);
+    QCOMPARE(view.matrix(), QMatrix().scale(2, 2) * QMatrix().rotate(90));
+    view.shear(1.2, 1.2);
+    QCOMPARE(view.matrix(), QMatrix().shear(1.2, 1.2) * QMatrix().scale(2, 2) * QMatrix().rotate(90));
+    view.translate(1, 1);
+    QCOMPARE(view.matrix(), QMatrix().translate(1, 1) * QMatrix().shear(1.2, 1.2) * QMatrix().scale(2, 2) * QMatrix().rotate(90));
+}
+
+void tst_QGraphicsView::matrix_combine()
+{
+    // Check matrix combining
+    QGraphicsView view;
+    QCOMPARE(view.matrix(), QMatrix());
+    view.setMatrix(QMatrix().rotate(90), true);
+    view.setMatrix(QMatrix().rotate(90), true);
+    view.setMatrix(QMatrix().rotate(90), true);
+    view.setMatrix(QMatrix().rotate(90), true);
+    QCOMPARE(view.matrix(), QMatrix());
+
+    view.resetMatrix();
+    QCOMPARE(view.matrix(), QMatrix());
+    view.setMatrix(QMatrix().rotate(90), false);
+    view.setMatrix(QMatrix().rotate(90), false);
+    view.setMatrix(QMatrix().rotate(90), false);
+    view.setMatrix(QMatrix().rotate(90), false);
+    QCOMPARE(view.matrix(), QMatrix().rotate(90));
+}
+
+void tst_QGraphicsView::centerOnPoint()
+{
+    QWidget toplevel;
+
+    QGraphicsScene scene;
+    scene.addEllipse(QRectF(-100, -100, 50, 50));
+    scene.addEllipse(QRectF(50, -100, 50, 50));
+    scene.addEllipse(QRectF(-100, 50, 50, 50));
+    scene.addEllipse(QRectF(50, 50, 50, 50));
+
+    QGraphicsView view(&scene, &toplevel);
+    view.setSceneRect(-400, -400, 800, 800);
+    view.setFixedSize(100, 100);
+    toplevel.show();
+
+    int tolerance = 5;
+
+    for (int i = 0; i < 3; ++i) {
+        for (int y = -100; y < 100; y += 23) {
+            for (int x = -100; x < 100; x += 23) {
+                view.centerOn(x, y);
+                QPoint viewCenter = view.mapToScene(view.viewport()->rect().center()).toPoint();
+
+                // Fuzzy compare
+                if (viewCenter.x() < x - tolerance || viewCenter.x() > x + tolerance
+                    || viewCenter.y() < y - tolerance || viewCenter.y() > y + tolerance) {
+                    QString error = QString("Compared values are not the same\n\tActual: (%1, %2)\n\tExpected: (%3, %4)")
+                                    .arg(viewCenter.x()).arg(viewCenter.y()).arg(x).arg(y);
+                    QFAIL(qPrintable(error));
+                }
+
+                QApplication::processEvents();
+            }
+        }
+
+        view.rotate(13);
+        view.scale(1.5, 1.5);
+        view.shear(1.25, 1.25);
+    }
+}
+
+void tst_QGraphicsView::centerOnItem()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *items[4];
+    items[0] = scene.addEllipse(QRectF(-25, -25, 50, 50));
+    items[1] = scene.addEllipse(QRectF(-25, -25, 50, 50));
+    items[2] = scene.addEllipse(QRectF(-25, -25, 50, 50));
+    items[3] = scene.addEllipse(QRectF(-25, -25, 50, 50));
+    items[0]->setPos(-100, -100);
+    items[1]->setPos(100, -100);
+    items[2]->setPos(-100, 100);
+    items[3]->setPos(100, 100);
+
+    QGraphicsView view(&scene);
+    view.setSceneRect(-1000, -1000, 2000, 2000);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    int tolerance = 7;
+
+    for (int x = 0; x < 3; ++x) {
+        for (int i = 0; i < 4; ++i) {
+            QApplication::processEvents();
+            view.centerOn(items[i]);
+
+            QPoint viewCenter = view.mapToScene(view.viewport()->rect().center()).toPoint();
+            qreal x = items[i]->pos().x();
+            qreal y = items[i]->pos().y();
+
+            // Fuzzy compare
+            if (viewCenter.x() < x - tolerance || viewCenter.x() > x + tolerance
+                || viewCenter.y() < y - tolerance || viewCenter.y() > y + tolerance) {
+                QString error = QString("Compared values are not the same\n\tActual: (%1, %2)\n\tExpected: (%3, %4)")
+                                .arg(viewCenter.x()).arg(viewCenter.y()).arg(x).arg(y);
+                QFAIL(qPrintable(error));
+            }
+
+            QApplication::processEvents();
+        }
+
+        view.rotate(13);
+        view.scale(1.5, 1.5);
+        view.shear(1.25, 1.25);
+    }
+}
+
+void tst_QGraphicsView::ensureVisibleRect()
+{
+    QWidget toplevel;
+
+    QGraphicsScene scene;
+    QGraphicsItem *items[4];
+    items[0] = scene.addEllipse(QRectF(-25, -25, 50, 50), QPen(Qt::black), QBrush(Qt::green));
+    items[1] = scene.addEllipse(QRectF(-25, -25, 50, 50), QPen(Qt::black), QBrush(Qt::red));
+    items[2] = scene.addEllipse(QRectF(-25, -25, 50, 50), QPen(Qt::black), QBrush(Qt::blue));
+    items[3] = scene.addEllipse(QRectF(-25, -25, 50, 50), QPen(Qt::black), QBrush(Qt::yellow));
+    scene.addLine(QLineF(0, -100, 0, 100), QPen(Qt::blue, 2));
+    scene.addLine(QLineF(-100, 0, 100, 0), QPen(Qt::blue, 2));
+    items[0]->setPos(-100, -100);
+    items[1]->setPos(100, -100);
+    items[2]->setPos(-100, 100);
+    items[3]->setPos(100, 100);
+
+    QGraphicsItem *icon = scene.addEllipse(QRectF(-10, -10, 20, 20), QPen(Qt::black), QBrush(Qt::gray));
+
+    QGraphicsView view(&scene, &toplevel);
+    view.setSceneRect(-500, -500, 1000, 1000);
+    view.setFixedSize(250, 250);
+    toplevel.show();
+    QTest::qWaitForWindowShown(&toplevel);
+
+    for (int y = -100; y < 100; y += 25) {
+        for (int x = -100; x < 100; x += 13) {
+
+            icon->setPos(x, y);
+
+            switch (x & 3) {
+            case 0:
+                view.centerOn(-500, -500);
+                break;
+            case 1:
+                view.centerOn(500, -500);
+                break;
+            case 2:
+                view.centerOn(-500, 500);
+                break;
+            case 3:
+            default:
+                view.centerOn(500, 500);
+                break;
+            }
+
+            QVERIFY(!view.viewport()->rect().contains(view.mapFromScene(x, y)));
+
+            for (int margin = 10; margin < 60; margin += 15) {
+                view.ensureVisible(x, y, 0, 0, margin, margin);
+
+                QRect viewRect = view.viewport()->rect();
+                QPoint viewPoint = view.mapFromScene(x, y);
+
+                QVERIFY(viewRect.contains(viewPoint));
+                QVERIFY(qAbs(viewPoint.x() - viewRect.left()) >= margin -1);
+                QVERIFY(qAbs(viewPoint.x() - viewRect.right()) >= margin -1);
+                QVERIFY(qAbs(viewPoint.y() - viewRect.top()) >= margin -1);
+                QVERIFY(qAbs(viewPoint.y() - viewRect.bottom()) >= margin -1);
+
+                QApplication::processEvents();
+            }
+        }
+        view.rotate(5);
+        view.scale(1.05, 1.05);
+        view.translate(30, -30);
+    }
+}
+
+void tst_QGraphicsView::fitInView()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *items[4];
+    items[0] = scene.addEllipse(QRectF(-25, -25, 100, 20), QPen(Qt::black), QBrush(Qt::green));
+    items[1] = scene.addEllipse(QRectF(-25, -25, 20, 100), QPen(Qt::black), QBrush(Qt::red));
+    items[2] = scene.addEllipse(QRectF(-25, -25, 50, 50), QPen(Qt::black), QBrush(Qt::blue));
+    items[3] = scene.addEllipse(QRectF(-25, -25, 50, 50), QPen(Qt::black), QBrush(Qt::yellow));
+    scene.addLine(QLineF(0, -100, 0, 100), QPen(Qt::blue, 2));
+    scene.addLine(QLineF(-100, 0, 100, 0), QPen(Qt::blue, 2));
+    items[0]->setPos(-100, -100);
+    items[1]->setPos(100, -100);
+    items[2]->setPos(-100, 100);
+    items[3]->setPos(100, 100);
+
+    items[0]->rotate(30);
+    items[1]->rotate(-30);
+
+#if defined(Q_OS_WINCE)
+    //Is the standard scrollbar size
+    int scrollbarSize = qApp->style()->pixelMetric(QStyle::PM_ScrollBarExtent) - 13;
+#endif
+
+    QGraphicsView view(&scene);
+    view.setSceneRect(-400, -400, 800, 800);
+
+#if defined(Q_OS_WINCE)
+    //We need to take in account the scrollbar size for the WindowsMobilStyle
+    view.setFixedSize(400 + scrollbarSize, 200 + scrollbarSize);
+#else
+    view.setFixedSize(400, 200);
+#endif
+
+    if (PlatformQuirks::isAutoMaximizing())
+        view.setWindowFlags(view.windowFlags()|Qt::X11BypassWindowManagerHint);
+
+    view.show();
+    view.fitInView(scene.itemsBoundingRect(), Qt::IgnoreAspectRatio);
+    qApp->processEvents();
+
+    // Sampled coordinates.
+    QVERIFY(!view.itemAt(45, 41));
+    QVERIFY(!view.itemAt(297, 44));
+    QVERIFY(!view.itemAt(359, 143));
+    QCOMPARE(view.itemAt(79, 22), items[0]);
+    QCOMPARE(view.itemAt(329, 41), items[1]);
+    QCOMPARE(view.itemAt(38, 158), items[2]);
+    QCOMPARE(view.itemAt(332, 160), items[3]);
+
+    view.fitInView(items[0], Qt::IgnoreAspectRatio);
+    qApp->processEvents();
+
+    QCOMPARE(view.itemAt(19, 13), items[0]);
+    QCOMPARE(view.itemAt(91, 47), items[0]);
+    QCOMPARE(view.itemAt(202, 94), items[0]);
+    QCOMPARE(view.itemAt(344, 161), items[0]);
+    QVERIFY(!view.itemAt(236, 54));
+    QVERIFY(!view.itemAt(144, 11));
+    QVERIFY(!view.itemAt(29, 69));
+    QVERIFY(!view.itemAt(251, 167));
+
+    view.fitInView(items[0], Qt::KeepAspectRatio);
+    qApp->processEvents();
+
+    QCOMPARE(view.itemAt(325, 170), items[0]);
+    QCOMPARE(view.itemAt(206, 74), items[0]);
+    QCOMPARE(view.itemAt(190, 115), items[0]);
+    QCOMPARE(view.itemAt(55, 14), items[0]);
+    QVERIFY(!view.itemAt(109, 4));
+    QVERIFY(!view.itemAt(244, 68));
+    QVERIFY(!view.itemAt(310, 125));
+    QVERIFY(!view.itemAt(261, 168));
+
+    view.fitInView(items[0], Qt::KeepAspectRatioByExpanding);
+    qApp->processEvents();
+
+    QCOMPARE(view.itemAt(18, 10), items[0]);
+    QCOMPARE(view.itemAt(95, 4), items[0]);
+    QCOMPARE(view.itemAt(279, 175), items[0]);
+    QCOMPARE(view.itemAt(359, 170), items[0]);
+    QVERIFY(!view.itemAt(370, 166));
+    QVERIFY(!view.itemAt(136, 7));
+    QVERIFY(!view.itemAt(31, 44));
+    QVERIFY(!view.itemAt(203, 153));
+}
+
+void tst_QGraphicsView::itemsAtPoint()
+{
+    QGraphicsScene scene;
+    scene.addRect(QRectF(-10, -10, 20, 20))->setZValue(1);
+    scene.addRect(QRectF(-10, -10, 20, 20))->setZValue(0);
+    scene.addRect(QRectF(-10, -10, 20, 20))->setZValue(2);
+    scene.addRect(QRectF(-10, -10, 20, 20))->setZValue(-1);
+    scene.addRect(QRectF(-10, -10, 20, 20))->setZValue(3);
+
+    QGraphicsView view;
+    QVERIFY(view.items(0, 0).isEmpty());
+
+    view.setScene(&scene);
+    view.setSceneRect(-10000, -10000, 20000, 20000);
+    view.show();
+
+    QList<QGraphicsItem *> items = view.items(view.viewport()->rect().center());
+    QCOMPARE(items.size(), 5);
+    QCOMPARE(items.takeFirst()->zValue(), qreal(3));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(2));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(1));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(0));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(-1));
+}
+
+void tst_QGraphicsView::itemsInRect()
+{
+    QGraphicsScene scene;
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(1);
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(0);
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(2);
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(-1);
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(3);
+
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(5);
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(4);
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(6);
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(3);
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(7);
+
+    QGraphicsView view;
+    QVERIFY(view.items(QRect(-100, -100, 200, 200)).isEmpty());
+    view.setScene(&scene);
+    view.setSceneRect(-10000, -10000, 20000, 20000);
+    view.show();
+
+    QPoint centerPoint = view.viewport()->rect().center();
+    QRect leftRect = view.mapFromScene(-30, -10, 20, 20).boundingRect();
+    QRect rightRect = view.mapFromScene(30, -10, 20, 20).boundingRect();
+
+    QList<QGraphicsItem *> items = view.items(leftRect);
+    QCOMPARE(items.size(), 5);
+    QCOMPARE(items.takeFirst()->zValue(), qreal(3));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(2));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(1));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(0));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(-1));
+
+    items = view.items(rightRect);
+    QCOMPARE(items.size(), 5);
+    QCOMPARE(items.takeFirst()->zValue(), qreal(7));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(6));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(5));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(4));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(3));
+}
+
+class CountPaintItem : public QGraphicsRectItem
+{
+public:
+    int numPaints;
+
+    CountPaintItem(const QRectF &rect)
+        : QGraphicsRectItem(rect), numPaints(0)
+    { }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0)
+    {
+        ++numPaints;
+        QGraphicsRectItem::paint(painter, option, widget);
+    }
+};
+
+void tst_QGraphicsView::itemsInRect_cosmeticAdjust_data()
+{
+    QTest::addColumn<QRect>("updateRect");
+    QTest::addColumn<int>("numPaints");
+    QTest::addColumn<bool>("adjustForAntialiasing");
+
+    // Aliased.
+    QTest::newRow("nil") << QRect() << 1 << false;
+    QTest::newRow("0, 0, 300, 100") << QRect(0, 0, 300, 100) << 1 << false;
+    QTest::newRow("0, 0, 100, 300") << QRect(0, 0, 100, 300) << 1 << false;
+    QTest::newRow("200, 0, 100, 300") << QRect(200, 0, 100, 300) << 1 << false;
+    QTest::newRow("0, 200, 300, 100") << QRect(0, 200, 300, 100) << 1 << false;
+    QTest::newRow("0, 0, 300, 99") << QRect(0, 0, 300, 99) << 0 << false;
+    QTest::newRow("0, 0, 99, 300") << QRect(0, 0, 99, 300) << 0 << false;
+    QTest::newRow("201, 0, 99, 300") << QRect(201, 0, 99, 300) << 0 << false;
+    QTest::newRow("0, 201, 300, 99") << QRect(0, 201, 300, 99) << 0 << false;
+
+    // Anti-aliased.
+    QTest::newRow("nil") << QRect() << 1 << true;
+    QTest::newRow("0, 0, 300, 100") << QRect(0, 0, 300, 100) << 1 << true;
+    QTest::newRow("0, 0, 100, 300") << QRect(0, 0, 100, 300) << 1 << true;
+    QTest::newRow("200, 0, 100, 300") << QRect(200, 0, 100, 300) << 1 << true;
+    QTest::newRow("0, 200, 300, 100") << QRect(0, 200, 300, 100) << 1 << true;
+    QTest::newRow("0, 0, 300, 99") << QRect(0, 0, 300, 99) << 1 << true;
+    QTest::newRow("0, 0, 99, 300") << QRect(0, 0, 99, 300) << 1 << true;
+    QTest::newRow("201, 0, 99, 300") << QRect(201, 0, 99, 300) << 1 << true;
+    QTest::newRow("0, 201, 300, 99") << QRect(0, 201, 300, 99) << 1 << true;
+    QTest::newRow("0, 0, 300, 98") << QRect(0, 0, 300, 98) << 0 << false;
+    QTest::newRow("0, 0, 98, 300") << QRect(0, 0, 98, 300) << 0 << false;
+    QTest::newRow("202, 0, 98, 300") << QRect(202, 0, 98, 300) << 0 << false;
+    QTest::newRow("0, 202, 300, 98") << QRect(0, 202, 300, 98) << 0 << false;
+}
+
+void tst_QGraphicsView::itemsInRect_cosmeticAdjust()
+{
+    QFETCH(QRect, updateRect);
+    QFETCH(int, numPaints);
+    QFETCH(bool, adjustForAntialiasing);
+
+    QGraphicsScene scene(-100, -100, 200, 200);
+    CountPaintItem *rect = new CountPaintItem(QRectF(-50, -50, 100, 100));
+    scene.addItem(rect);
+
+    QGraphicsView view(&scene);
+    view.setOptimizationFlag(QGraphicsView::DontAdjustForAntialiasing, !adjustForAntialiasing);
+    view.setRenderHint(QPainter::Antialiasing, adjustForAntialiasing);
+    if (PlatformQuirks::isAutoMaximizing())
+        view.setWindowFlags(view.windowFlags()|Qt::X11BypassWindowManagerHint);
+    view.setFrameStyle(0);
+    view.resize(300, 300);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(rect->numPaints > 0);
+
+    rect->numPaints = 0;
+    if (updateRect.isNull())
+        view.viewport()->update();
+    else
+        view.viewport()->update(updateRect);
+    qApp->processEvents();
+    QTRY_COMPARE(rect->numPaints, numPaints);
+}
+
+void tst_QGraphicsView::itemsInPoly()
+{
+    QGraphicsScene scene;
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(1);
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(0);
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(2);
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(-1);
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(3);
+
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(5);
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(4);
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(6);
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(3);
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(7);
+
+    QGraphicsView view;
+    QVERIFY(view.items(QPolygon()).isEmpty());
+    view.setScene(&scene);
+    view.setSceneRect(-10000, -10000, 20000, 20000);
+    view.show();
+
+    QPoint centerPoint = view.viewport()->rect().center();
+    QPolygon leftPoly = view.mapFromScene(QRectF(-30, -10, 20, 20));
+    QPolygon rightPoly = view.mapFromScene(QRectF(30, -10, 20, 20));
+
+    QList<QGraphicsItem *> items = view.items(leftPoly);
+    QCOMPARE(items.size(), 5);
+    QCOMPARE(items.takeFirst()->zValue(), qreal(3));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(2));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(1));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(0));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(-1));
+
+    items = view.items(rightPoly);
+    QCOMPARE(items.size(), 5);
+    QCOMPARE(items.takeFirst()->zValue(), qreal(7));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(6));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(5));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(4));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(3));
+}
+
+void tst_QGraphicsView::itemsInPath()
+{
+    QGraphicsScene scene;
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(1);
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(0);
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(2);
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(-1);
+    scene.addRect(QRectF(-30, -10, 20, 20))->setZValue(3);
+
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(5);
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(4);
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(6);
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(3);
+    scene.addRect(QRectF(30, -10, 20, 20))->setZValue(7);
+
+    QGraphicsView view;
+    QVERIFY(view.items(QPainterPath()).isEmpty());
+    view.setScene(&scene);
+    view.translate(100, 400);
+    view.rotate(22.3);
+    view.setSceneRect(-10000, -10000, 20000, 20000);
+    view.show();
+
+    QPoint centerPoint = view.viewport()->rect().center();
+    QPainterPath leftPath;
+    leftPath.addEllipse(QRect(view.mapFromScene(-30, -10), QSize(20, 20)));
+
+    QPainterPath rightPath;
+    rightPath.addEllipse(QRect(view.mapFromScene(30, -10), QSize(20, 20)));
+
+    QList<QGraphicsItem *> items = view.items(leftPath);
+
+    QCOMPARE(items.size(), 5);
+    QCOMPARE(items.takeFirst()->zValue(), qreal(3));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(2));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(1));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(0));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(-1));
+
+    items = view.items(rightPath);
+    QCOMPARE(items.size(), 5);
+    QCOMPARE(items.takeFirst()->zValue(), qreal(7));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(6));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(5));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(4));
+    QCOMPARE(items.takeFirst()->zValue(), qreal(3));
+}
+
+void tst_QGraphicsView::itemAt()
+{
+    QGraphicsScene scene;
+    scene.addRect(QRectF(-10, -10, 20, 20))->setZValue(1);
+    scene.addRect(QRectF(-10, -10, 20, 20))->setZValue(0);
+    scene.addRect(QRectF(-10, -10, 20, 20))->setZValue(2);
+    scene.addRect(QRectF(-10, -10, 20, 20))->setZValue(-1);
+    scene.addRect(QRectF(-10, -10, 20, 20))->setZValue(3);
+
+    QGraphicsView view;
+    QCOMPARE(view.itemAt(0, 0), (QGraphicsItem *)0);
+
+    view.setScene(&scene);
+    view.setSceneRect(-10000, -10000, 20000, 20000);
+    view.show();
+
+    QCOMPARE(view.itemAt(0, 0), (QGraphicsItem *)0);
+    QGraphicsItem* item = view.itemAt(view.viewport()->rect().center());
+    QVERIFY(item);
+    QCOMPARE(item->zValue(), qreal(3));
+}
+
+void tst_QGraphicsView::itemAt2()
+{
+    // test precision of the itemAt() function with items that are smaller
+    // than 1 pixel.
+    QGraphicsScene scene(0, 0, 100, 100);
+
+    // Add a 0.5x0.5 item at position 0 on the scene, top-left corner at -0.25, -0.25.
+    QGraphicsItem *item = scene.addRect(QRectF(-0.25, -0.25, 0.5, 0.5), QPen(Qt::black, 0.1));
+
+    QGraphicsView view(&scene);
+    view.setFixedSize(200, 200);
+    view.setTransformationAnchor(QGraphicsView::NoAnchor);
+    view.setRenderHint(QPainter::Antialiasing);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QApplication::processEvents();
+
+    QPoint itemViewPoint = view.mapFromScene(item->scenePos());
+
+    for (int i = 0; i < 3; ++i) {
+        QVERIFY(view.itemAt(itemViewPoint));
+        QVERIFY(!view.items(itemViewPoint).isEmpty());
+        QVERIFY(view.itemAt(itemViewPoint + QPoint(-1, 0)));
+        QVERIFY(!view.items(itemViewPoint + QPoint(-1, 0)).isEmpty());
+        QVERIFY(view.itemAt(itemViewPoint + QPoint(-1, -1)));
+        QVERIFY(!view.items(itemViewPoint + QPoint(-1, -1)).isEmpty());
+        QVERIFY(view.itemAt(itemViewPoint + QPoint(0, -1)));
+        QVERIFY(!view.items(itemViewPoint + QPoint(0, -1)).isEmpty());
+        item->moveBy(0.1, 0);
+    }
+
+    // Here
+    QVERIFY(view.itemAt(itemViewPoint));
+    QVERIFY(!view.items(itemViewPoint).isEmpty());
+    QVERIFY(view.itemAt(itemViewPoint + QPoint(0, -1)));
+    QVERIFY(!view.items(itemViewPoint + QPoint(0, -1)).isEmpty());
+
+    if (sizeof(qreal) != sizeof(double)) {
+        QSKIP("Skipped due to rounding errors", SkipAll);
+    }
+    // Not here
+    QVERIFY(!view.itemAt(itemViewPoint + QPoint(-1, 0)));
+    QVERIFY(view.items(itemViewPoint + QPoint(-1, 0)).isEmpty());
+    QVERIFY(!view.itemAt(itemViewPoint + QPoint(-1, -1)));
+    QVERIFY(view.items(itemViewPoint + QPoint(-1, -1)).isEmpty());
+}
+
+void tst_QGraphicsView::mapToScene()
+{
+    // Uncomment the commented-out code to see what's going on. It doesn't
+    // affect the test; it just slows it down.
+
+    QGraphicsScene scene;
+    scene.addPixmap(QPixmap("3D-Qt-1-2.png"));
+
+    QWidget topLevel;
+    QGraphicsView view(&topLevel);
+    view.setScene(&scene);
+    view.setSceneRect(-500, -500, 1000, 1000);
+#if defined(Q_OS_WINCE)
+    QSize viewSize(200,200);
+#else
+    QSize viewSize(300,300);
+#endif
+
+    view.setFixedSize(viewSize);
+    topLevel.show();
+    QApplication::processEvents();
+    QVERIFY(view.isVisible());
+    QCOMPARE(view.size(), viewSize);
+
+    // First once without setting the scene rect
+#ifdef QT_ARCH_ARM
+    const int step = 20;
+#else
+    const int step = 1;
+#endif
+
+    for (int x = 0; x < view.width(); x += step) {
+        for (int y = 0; y < view.height(); y += step) {
+            QCOMPARE(view.mapToScene(QPoint(x, y)),
+                     QPointF(view.horizontalScrollBar()->value() + x,
+                             view.verticalScrollBar()->value() + y));
+        }
+    }
+
+    for (int sceneRectHeight = 250; sceneRectHeight < 1000; sceneRectHeight += 250) {
+        for (int sceneRectWidth = 250; sceneRectWidth < 1000; sceneRectWidth += 250) {
+            view.setSceneRect(QRectF(-int(sceneRectWidth / 2), -int(sceneRectHeight / 2),
+                                     sceneRectWidth, sceneRectHeight));
+            QApplication::processEvents();
+
+            int hmin = view.horizontalScrollBar()->minimum();
+            int hmax = view.horizontalScrollBar()->maximum();
+            int hstep = (hmax - hmin) / 3;
+            int vmin = view.verticalScrollBar()->minimum();
+            int vmax = view.verticalScrollBar()->maximum();
+            int vstep = (vmax - vmin) / 3;
+
+            for (int hscrollValue = hmin; hscrollValue < hmax; hscrollValue += hstep) {
+                for (int vscrollValue = vmin; vscrollValue < vmax; vscrollValue += vstep) {
+
+                    view.horizontalScrollBar()->setValue(hscrollValue);
+                    view.verticalScrollBar()->setValue(vscrollValue);
+                    QApplication::processEvents();
+
+                    int h = view.horizontalScrollBar()->value();
+                    int v = view.verticalScrollBar()->value();
+
+                    for (int x = 0; x < view.width(); x += step) {
+                        for (int y = 0; y < view.height(); y += step) {
+                            QCOMPARE(view.mapToScene(QPoint(x, y)), QPointF(h + x, v + y));
+                            QCOMPARE(view.mapFromScene(QPointF(h + x, v + y)), QPoint(x, y));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+void tst_QGraphicsView::mapToScenePoint()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.rotate(90);
+    view.setFixedSize(117, 117);
+    view.show();
+    QPoint center = view.viewport()->rect().center();
+    QCOMPARE(view.mapToScene(center + QPoint(10, 0)),
+             view.mapToScene(center) + QPointF(0, -10));
+}
+
+void tst_QGraphicsView::mapToSceneRect_data()
+{
+    QTest::addColumn<QRect>("viewRect");
+    QTest::addColumn<QPolygonF>("scenePoly");
+    QTest::addColumn<qreal>("rotation");
+
+    QTest::newRow("nil") << QRect() << QPolygonF() << qreal(0);
+    QTest::newRow("0, 0, 1, 1") << QRect(0, 0, 1, 1) << QPolygonF(QRectF(0, 0, 1, 1)) << qreal(0);
+    QTest::newRow("0, 0, 10, 10") << QRect(0, 0, 10, 10) << QPolygonF(QRectF(0, 0, 10, 10)) << qreal(0);
+    QTest::newRow("nil") << QRect() << QPolygonF() << qreal(90);
+    QPolygonF p;
+    p << QPointF(0, 0) << QPointF(0, -1) << QPointF(1, -1) << QPointF(1, 0) << QPointF(0, 0);
+    QTest::newRow("0, 0, 1, 1") << QRect(0, 0, 1, 1)
+                                << p
+                                << qreal(90);
+    p.clear();
+    p << QPointF(0, 0) << QPointF(0, -10) << QPointF(10, -10) << QPointF(10, 0) << QPointF(0, 0);
+    QTest::newRow("0, 0, 10, 10") << QRect(0, 0, 10, 10)
+                                  << p
+                                  << qreal(90);
+}
+
+void tst_QGraphicsView::mapToSceneRect()
+{
+    QFETCH(QRect, viewRect);
+    QFETCH(QPolygonF, scenePoly);
+    QFETCH(qreal, rotation);
+
+    QGraphicsScene scene(-1000, -1000, 2000, 2000);
+    scene.addRect(25, -25, 50, 50);
+    QGraphicsView view(&scene);
+    view.setFrameStyle(0);
+    view.setAlignment(Qt::AlignTop | Qt::AlignLeft);
+    view.setFixedSize(200, 200);
+    view.setTransformationAnchor(QGraphicsView::NoAnchor);
+    view.setResizeAnchor(QGraphicsView::NoAnchor);
+    view.show();
+
+    view.rotate(rotation);
+
+    QPolygonF poly = view.mapToScene(viewRect);
+    if (!poly.isEmpty())
+        poly << poly[0];
+
+    QCOMPARE(poly, scenePoly);
+}
+
+void tst_QGraphicsView::mapToScenePoly()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.translate(100, 100);
+    view.setFixedSize(117, 117);
+    view.show();
+    QPoint center = view.viewport()->rect().center();
+    QRect rect(center + QPoint(10, 0), QSize(10, 10));
+
+    QPolygon poly;
+    poly << rect.topLeft();
+    poly << rect.topRight();
+    poly << rect.bottomRight();
+    poly << rect.bottomLeft();
+
+    QPolygonF poly2;
+    poly2 << view.mapToScene(rect.topLeft());
+    poly2 << view.mapToScene(rect.topRight());
+    poly2 << view.mapToScene(rect.bottomRight());
+    poly2 << view.mapToScene(rect.bottomLeft());
+
+    QCOMPARE(view.mapToScene(poly), poly2);
+}
+
+void tst_QGraphicsView::mapToScenePath()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.setSceneRect(-300, -300, 600, 600);
+    view.translate(10, 10);
+    view.setFixedSize(300, 300);
+    view.show();
+    QPoint center = view.viewport()->rect().center();
+    QRect rect(QPoint(10, 0), QSize(10, 10));
+
+    QPainterPath path;
+    path.addRect(rect);
+
+    QPainterPath path2;
+    path2.addRect(rect.translated(view.horizontalScrollBar()->value() - 10,
+                                  view.verticalScrollBar()->value() - 10));
+    QCOMPARE(view.mapToScene(path), path2);
+}
+
+void tst_QGraphicsView::mapFromScenePoint()
+{
+    {
+        QGraphicsScene scene;
+        QGraphicsView view(&scene);
+        view.rotate(90);
+        view.scale(10, 10);
+        view.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+        view.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+        view.show();
+
+        QPoint mapped = view.mapFromScene(0, 0);
+        QPoint center = view.viewport()->rect().center();
+        if (qAbs(mapped.x() - center.x()) >= 2
+            || qAbs(mapped.y() - center.y()) >= 2) {
+            QString error = QString("Compared values are not the same\n\tActual: (%1, %2)\n\tExpected: (%3, %4)")
+                            .arg(mapped.x()).arg(mapped.y()).arg(center.x()).arg(center.y());
+            QFAIL(qPrintable(error));
+        }
+    }
+    {
+        QWidget toplevel;
+
+        QGraphicsScene scene(0, 0, 200, 200);
+        scene.addRect(QRectF(0, 0, 200, 200), QPen(Qt::black, 1));
+        QGraphicsView view(&scene, &toplevel);
+        view.ensurePolished();
+        view.resize(view.sizeHint());
+        toplevel.show();
+
+        QCOMPARE(view.mapFromScene(0, 0), QPoint(0, 0));
+        QCOMPARE(view.mapFromScene(0.4, 0.4), QPoint(0, 0));
+        QCOMPARE(view.mapFromScene(0.5, 0.5), QPoint(1, 1));
+        QCOMPARE(view.mapFromScene(0.9, 0.9), QPoint(1, 1));
+        QCOMPARE(view.mapFromScene(1.0, 1.0), QPoint(1, 1));
+        QCOMPARE(view.mapFromScene(100, 100), QPoint(100, 100));
+        QCOMPARE(view.mapFromScene(100.5, 100.5), QPoint(101, 101));
+        QCOMPARE(view.mapToScene(0, 0), QPointF(0, 0));
+        QCOMPARE(view.mapToScene(1, 1), QPointF(1, 1));
+        QCOMPARE(view.mapToScene(100, 100), QPointF(100, 100));
+    }
+}
+
+void tst_QGraphicsView::mapFromSceneRect()
+{
+    QGraphicsScene scene;
+    QWidget topLevel;
+    QGraphicsView view(&scene,&topLevel);
+    view.rotate(90);
+    view.setFixedSize(200, 200);
+    view.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    view.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    topLevel.show();
+    QTest::qWait(25);
+
+    QPolygon polygon;
+    polygon << QPoint(98, 98);
+    polygon << QPoint(98, 108);
+    polygon << QPoint(88, 108);
+    polygon << QPoint(88, 98);
+
+
+    QPolygon viewPolygon = view.mapFromScene(0, 0, 10, 10);
+    for (int i = 0; i < 4; ++i) {
+        QVERIFY(qAbs(viewPolygon[i].x() - polygon[i].x()) < 3);
+        QVERIFY(qAbs(viewPolygon[i].y() - polygon[i].y()) < 3);
+    }
+
+    QPoint pt = view.mapFromScene(QPointF());
+    QPolygon p;
+    p << pt << pt << pt << pt;
+    QCOMPARE(view.mapFromScene(QRectF()), p);
+}
+
+void tst_QGraphicsView::mapFromScenePoly()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.rotate(90);
+    view.setFixedSize(200, 200);
+    view.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    view.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    view.show();
+
+    QPolygonF polygon;
+    polygon << QPoint(0, 0);
+    polygon << QPoint(10, 0);
+    polygon << QPoint(10, 10);
+    polygon << QPoint(0, 10);
+
+    QPolygon polygon2;
+    polygon2 << QPoint(98, 98);
+    polygon2 << QPoint(98, 108);
+    polygon2 << QPoint(88, 108);
+    polygon2 << QPoint(88, 98);
+
+    QPolygon viewPolygon = view.mapFromScene(polygon);
+    for (int i = 0; i < 4; ++i) {
+        QVERIFY(qAbs(viewPolygon[i].x() - polygon2[i].x()) < 3);
+        QVERIFY(qAbs(viewPolygon[i].y() - polygon2[i].y()) < 3);
+    }
+}
+
+void tst_QGraphicsView::mapFromScenePath()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.rotate(90);
+    view.setFixedSize(200, 200);
+    view.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    view.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    view.show();
+
+    QPolygonF polygon;
+    polygon << QPoint(0, 0);
+    polygon << QPoint(10, 0);
+    polygon << QPoint(10, 10);
+    polygon << QPoint(0, 10);
+    QPainterPath path;
+    path.addPolygon(polygon);
+
+    QPolygon polygon2;
+    polygon2 << QPoint(98, 98);
+    polygon2 << QPoint(98, 108);
+    polygon2 << QPoint(88, 108);
+    polygon2 << QPoint(88, 98);
+    QPainterPath path2;
+    path2.addPolygon(polygon2);
+
+    QPolygonF pathPoly = view.mapFromScene(path).toFillPolygon();
+    QPolygonF path2Poly = path2.toFillPolygon();
+
+    for (int i = 0; i < pathPoly.size(); ++i) {
+        QVERIFY(qAbs(pathPoly[i].x() - path2Poly[i].x()) < 3);
+        QVERIFY(qAbs(pathPoly[i].y() - path2Poly[i].y()) < 3);
+    }
+}
+
+void tst_QGraphicsView::sendEvent()
+{
+    QGraphicsScene scene;
+
+    TestItem *item = new TestItem;
+    scene.addItem(item);
+    item->setFlag(QGraphicsItem::ItemIsFocusable);
+    item->setFlag(QGraphicsItem::ItemIsMovable);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QApplication::setActiveWindow(&view);
+    QTest::qWait(20);
+    QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&view));
+
+    item->setFocus();
+
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *)item);
+    QCOMPARE(item->events.size(), 2);
+    QCOMPARE(item->events.last(), QEvent::FocusIn);
+
+    QPoint itemPoint = view.mapFromScene(item->scenePos());
+    sendMousePress(view.viewport(), itemPoint);
+    QCOMPARE(item->events.size(), 4);
+    QCOMPARE(item->events.at(item->events.size() - 2), QEvent::GrabMouse);
+    QCOMPARE(item->events.at(item->events.size() - 1), QEvent::GraphicsSceneMousePress);
+
+    QMouseEvent mouseMoveEvent(QEvent::MouseMove, itemPoint, view.viewport()->mapToGlobal(itemPoint),
+                                Qt::LeftButton, Qt::LeftButton, 0);
+    QApplication::sendEvent(view.viewport(), &mouseMoveEvent);
+    QCOMPARE(item->events.size(), 5);
+    QCOMPARE(item->events.last(), QEvent::GraphicsSceneMouseMove);
+
+    QMouseEvent mouseReleaseEvent(QEvent::MouseButtonRelease, itemPoint,
+                                  view.viewport()->mapToGlobal(itemPoint),
+                                  Qt::LeftButton, 0, 0);
+    QApplication::sendEvent(view.viewport(), &mouseReleaseEvent);
+    QCOMPARE(item->events.size(), 7);
+    QCOMPARE(item->events.at(item->events.size() - 2), QEvent::GraphicsSceneMouseRelease);
+    QCOMPARE(item->events.at(item->events.size() - 1), QEvent::UngrabMouse);
+
+    QKeyEvent keyPress(QEvent::KeyPress, Qt::Key_Space, 0);
+    QApplication::sendEvent(view.viewport(), &keyPress);
+    QCOMPARE(item->events.size(), 9);
+    QCOMPARE(item->events.at(item->events.size() - 2), QEvent::ShortcutOverride);
+    QCOMPARE(item->events.last(), QEvent::KeyPress);
+}
+
+class MouseWheelScene : public QGraphicsScene
+{
+public:
+    Qt::Orientation orientation;
+
+    void wheelEvent(QGraphicsSceneWheelEvent *event)
+    {
+        orientation = event->orientation();
+        QGraphicsScene::wheelEvent(event);
+    }
+};
+
+void tst_QGraphicsView::wheelEvent()
+{
+    // Create a scene with an invalid orientation.
+    MouseWheelScene scene;
+    scene.orientation = Qt::Orientation(-1);
+
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    widget->setGeometry(0, 0, 400, 400);
+    widget->setFocusPolicy(Qt::WheelFocus);
+
+    EventSpy spy(widget, QEvent::GraphicsSceneWheel);
+    QCOMPARE(spy.count(), 0);
+
+    scene.addItem(widget);
+
+    // Assign a view.
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QApplication::setActiveWindow(&view);
+    QTest::qWait(20);
+    QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&view));
+
+
+    // Send a wheel event with horizontal orientation.
+    {
+        QWheelEvent event(view.mapFromScene(widget->boundingRect().center()),
+                          view.mapToGlobal(view.mapFromScene(widget->boundingRect().center())),
+                          120, 0, 0, Qt::Horizontal);
+        QApplication::sendEvent(view.viewport(), &event);
+        QCOMPARE(scene.orientation, Qt::Horizontal);
+    }
+
+    // Send a wheel event with vertical orientation.
+    {
+        QWheelEvent event(view.mapFromScene(widget->boundingRect().center()),
+                          view.mapToGlobal(view.mapFromScene(widget->boundingRect().center())),
+                          120, 0, 0, Qt::Vertical);
+        QApplication::sendEvent(view.viewport(), &event);
+        QCOMPARE(scene.orientation, Qt::Vertical);
+    }
+
+    QCOMPARE(spy.count(), 2);
+    QVERIFY(widget->hasFocus());
+}
+
+// Qt/CE does not have regular cursor support.
+#if !defined(QT_NO_CURSOR) && !defined(Q_OS_WINCE)
+void tst_QGraphicsView::cursor()
+{
+    if (PlatformQuirks::haveMouseCursor())
+        QSKIP("The Platform does not have regular cursor support", SkipAll);
+
+    QGraphicsScene scene;
+    QGraphicsItem *item = scene.addRect(QRectF(-10, -10, 20, 20));
+    item->setCursor(Qt::IBeamCursor);
+
+    QGraphicsView view(&scene);
+    view.setFixedSize(400, 400);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QCOMPARE(view.viewport()->cursor().shape(), QCursor().shape());
+    view.viewport()->setCursor(Qt::PointingHandCursor);
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
+
+    sendMouseMove(view.viewport(), view.mapFromScene(0, 0));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::IBeamCursor);
+
+    sendMouseMove(view.viewport(), QPoint(5, 5));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
+}
+#endif
+
+// Qt/CE does not have regular cursor support.
+#if !defined(QT_NO_CURSOR) && !defined(Q_OS_WINCE)
+void tst_QGraphicsView::cursor2()
+{
+    if (PlatformQuirks::haveMouseCursor())
+        QSKIP("The Platform does not have regular cursor support", SkipAll);
+
+    QGraphicsScene scene;
+    QGraphicsItem *item = scene.addRect(QRectF(-10, -10, 20, 20));
+    item->setCursor(Qt::IBeamCursor);
+    item->setZValue(1);
+
+    QGraphicsItem *item2 = scene.addRect(QRectF(-20, -20, 40, 40));
+    item2->setZValue(0);
+
+    QGraphicsView view(&scene);
+    view.viewport()->setCursor(Qt::PointingHandCursor);
+    view.setFixedSize(400, 400);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    sendMouseMove(view.viewport(), view.mapFromScene(-30, -30));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
+    sendMouseMove(view.viewport(), view.mapFromScene(0, 0));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::IBeamCursor);
+    sendMouseMove(view.viewport(), view.mapFromScene(-30, -30));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
+    sendMouseMove(view.viewport(), view.mapFromScene(0, 0));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::IBeamCursor);
+    sendMouseMove(view.viewport(), view.mapFromScene(-15, 0));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
+
+    view.setDragMode(QGraphicsView::ScrollHandDrag);
+
+    sendMouseMove(view.viewport(), view.mapFromScene(-30, -30));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::OpenHandCursor);
+    sendMouseMove(view.viewport(), view.mapFromScene(0, 0));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::IBeamCursor);
+    sendMouseMove(view.viewport(), view.mapFromScene(-15, -15));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::OpenHandCursor);
+
+    view.setDragMode(QGraphicsView::NoDrag);
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::ArrowCursor);
+    view.viewport()->setCursor(Qt::PointingHandCursor);
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
+
+    item2->setCursor(Qt::SizeAllCursor);
+
+    sendMouseMove(view.viewport(), view.mapFromScene(-30, -30));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
+    sendMouseMove(view.viewport(), view.mapFromScene(-15, -15));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::SizeAllCursor);
+    sendMouseMove(view.viewport(), view.mapFromScene(0, 0));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::IBeamCursor);
+    sendMouseMove(view.viewport(), view.mapFromScene(-15, -15));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::SizeAllCursor);
+    sendMouseMove(view.viewport(), view.mapFromScene(0, 0));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::IBeamCursor);
+    sendMouseMove(view.viewport(), view.mapFromScene(-30, -30));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
+
+    view.setDragMode(QGraphicsView::ScrollHandDrag);
+
+    sendMouseMove(view.viewport(), view.mapFromScene(-30, -30));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::OpenHandCursor);
+    sendMouseMove(view.viewport(), view.mapFromScene(0, 0));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::IBeamCursor);
+    sendMouseMove(view.viewport(), view.mapFromScene(-15, -15));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::SizeAllCursor);
+}
+#endif
+
+void tst_QGraphicsView::transformationAnchor()
+{
+    QGraphicsScene scene(-1000, -1000, 2000, 2000);
+    scene.addRect(QRectF(-50, -50, 100, 100), QPen(Qt::black), QBrush(Qt::blue));
+
+    QGraphicsView view(&scene);
+
+    for (int i = 0; i < 2; ++i) {
+        view.resize(100, 100);
+        view.show();
+
+        if (i == 0) {
+            QCOMPARE(view.transformationAnchor(), QGraphicsView::AnchorViewCenter);
+        } else {
+            view.setTransformationAnchor(QGraphicsView::NoAnchor);
+        }
+        view.centerOn(0, 0);
+        view.horizontalScrollBar()->setValue(100);
+        QApplication::processEvents();
+
+        QPointF center = view.mapToScene(view.viewport()->rect().center());
+
+        view.scale(10, 10);
+
+        QPointF newCenter = view.mapToScene(view.viewport()->rect().center());
+
+        if (i == 0) {
+            qreal slack = 3;
+            QVERIFY(qAbs(newCenter.x() - center.x()) < slack);
+            QVERIFY(qAbs(newCenter.y() - center.y()) < slack);
+        } else {
+            qreal slack = qreal(0.3);
+            QVERIFY(qAbs(newCenter.x() - center.x() / 10) < slack);
+            QVERIFY(qAbs(newCenter.y() - center.y() / 10) < slack);
+        }
+    }
+}
+
+void tst_QGraphicsView::resizeAnchor()
+{
+    QGraphicsScene scene(-1000, -1000, 2000, 2000);
+    scene.addRect(QRectF(-50, -50, 100, 100), QPen(Qt::black), QBrush(Qt::blue));
+
+    QGraphicsView view(&scene);
+
+    for (int i = 0; i < 2; ++i) {
+        view.resize(100, 100);
+        view.show();
+        QTest::qWaitForWindowShown(&view);
+        QApplication::processEvents();
+
+        if (i == 0) {
+            QCOMPARE(view.resizeAnchor(), QGraphicsView::NoAnchor);
+        } else {
+            view.setResizeAnchor(QGraphicsView::AnchorViewCenter);
+        }
+        view.centerOn(0, 0);
+        QTest::qWait(25);
+
+        QPointF f = view.mapToScene(50, 50);
+        QPointF center = view.mapToScene(view.viewport()->rect().center());
+
+        QApplication::processEvents();
+
+        for (int size = 200; size <= 400; size += 25) {
+            view.resize(size, size);
+            if (i == 0) {
+                QTRY_COMPARE(view.mapToScene(50, 50), f);
+                QTRY_VERIFY(view.mapToScene(view.viewport()->rect().center()) != center);
+            } else {
+                QTRY_VERIFY(view.mapToScene(50, 50) != f);
+
+                QPointF newCenter = view.mapToScene(view.viewport()->rect().center());
+                int slack = 3;
+                QVERIFY(qAbs(newCenter.x() - center.x()) < slack);
+                QVERIFY(qAbs(newCenter.y() - center.y()) < slack);
+            }
+            QApplication::processEvents();
+        }
+    }
+}
+
+class CustomView : public QGraphicsView
+{
+    Q_OBJECT
+public:
+    CustomView(QGraphicsScene *s = 0) : QGraphicsView(s) {}
+    CustomView(QGraphicsScene *s, QWidget *parent)
+        : QGraphicsView(s, parent) {}
+    QList<QRegion> lastUpdateRegions;
+    bool painted;
+
+protected:
+    void paintEvent(QPaintEvent *event)
+    {
+        lastUpdateRegions << event->region();
+        painted = true;
+        QGraphicsView::paintEvent(event);
+    }
+};
+
+void tst_QGraphicsView::viewportUpdateMode()
+{
+    QGraphicsScene scene(0, 0, 100, 100);
+    scene.setBackgroundBrush(Qt::red);
+
+    CustomView view;
+    QDesktopWidget desktop;
+    view.setFixedSize(QSize(500, 500).boundedTo(desktop.availableGeometry().size())); // 500 is too big for all common smartphones
+    view.setScene(&scene);
+    if(PlatformQuirks::isAutoMaximizing())
+        view.setWindowFlags(view.windowFlags()|Qt::X11BypassWindowManagerHint);
+    QCOMPARE(view.viewportUpdateMode(), QGraphicsView::MinimalViewportUpdate);
+
+    // Show the view, and initialize our test.
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(!view.lastUpdateRegions.isEmpty());
+    view.lastUpdateRegions.clear();
+
+    // Issue two scene updates.
+    scene.update(QRectF(0, 0, 10, 10));
+    scene.update(QRectF(20, 0, 10, 10));
+    QTest::qWait(50);
+
+    // The view gets two updates for the update scene updates.
+    QTRY_VERIFY(!view.lastUpdateRegions.isEmpty());
+#ifndef Q_OS_MAC //cocoa doesn't support drawing regions
+    QCOMPARE(view.lastUpdateRegions.last().rects().size(), 2);
+    QCOMPARE(view.lastUpdateRegions.last().rects().at(0).size(), QSize(14, 14));
+    QCOMPARE(view.lastUpdateRegions.last().rects().at(1).size(), QSize(14, 14));
+#endif
+
+    // Set full update mode.
+    view.setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
+    QCOMPARE(view.viewportUpdateMode(), QGraphicsView::FullViewportUpdate);
+    view.lastUpdateRegions.clear();
+
+    // Issue two scene updates.
+    scene.update(QRectF(0, 0, 10, 10));
+    scene.update(QRectF(20, 0, 10, 10));
+    qApp->processEvents();
+    qApp->processEvents();
+
+    // The view gets one full viewport update for the update scene updates.
+    QCOMPARE(view.lastUpdateRegions.last().rects().size(), 1);
+    QCOMPARE(view.lastUpdateRegions.last().rects().at(0).size(), view.viewport()->size());
+    view.lastUpdateRegions.clear();
+
+    // Set smart update mode
+    view.setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
+    QCOMPARE(view.viewportUpdateMode(), QGraphicsView::SmartViewportUpdate);
+
+    // Issue 100 mini-updates
+    for (int i = 0; i < 10; ++i) {
+        for (int j = 0; j < 10; ++j) {
+            scene.update(QRectF(i * 3, j * 3, 1, 1));
+        }
+    }
+    qApp->processEvents();
+    qApp->processEvents();
+
+    // The view gets one bounding rect update.
+    QCOMPARE(view.lastUpdateRegions.last().rects().size(), 1);
+    QCOMPARE(view.lastUpdateRegions.last().rects().at(0).size(), QSize(32, 32));
+
+    // Set no update mode
+    view.setViewportUpdateMode(QGraphicsView::NoViewportUpdate);
+    QCOMPARE(view.viewportUpdateMode(), QGraphicsView::NoViewportUpdate);
+
+    // Issue two scene updates.
+    view.lastUpdateRegions.clear();
+    TestItem item;
+    scene.addItem(&item);
+    item.moveBy(10, 10);
+    scene.update(QRectF(0, 0, 10, 10));
+    scene.update(QRectF(20, 0, 10, 10));
+    qApp->processEvents();
+    qApp->processEvents();
+
+    // The view should not get any painting calls from the scene updates
+    QCOMPARE(view.lastUpdateRegions.size(), 0);
+}
+
+void tst_QGraphicsView::viewportUpdateMode2()
+{
+    QWidget toplevel;
+
+    // Create a view with viewport rect equal to QRect(0, 0, 200, 200).
+    QGraphicsScene dummyScene;
+    CustomView view(0, &toplevel);
+    view.painted = false;
+    view.setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);
+    view.setScene(&dummyScene);
+    view.ensurePolished(); // make sure we get the right content margins
+    int left, top, right, bottom;
+    view.getContentsMargins(&left, &top, &right, &bottom);
+    view.resize(200 + left + right, 200 + top + bottom);
+    toplevel.show();
+    QTest::qWaitForWindowShown(&toplevel);
+    QTest::qWait(50);
+    QTRY_VERIFY(view.painted);
+    const QRect viewportRect = view.viewport()->rect();
+    QCOMPARE(viewportRect, QRect(0, 0, 200, 200));
+
+#if defined QT_BUILD_INTERNAL
+    QGraphicsViewPrivate *viewPrivate = static_cast<QGraphicsViewPrivate *>(qt_widget_private(&view));
+
+    QRect boundingRect;
+    const QRect rect1(0, 0, 10, 10);
+    QVERIFY(viewPrivate->updateRect(rect1));
+    QVERIFY(!viewPrivate->fullUpdatePending);
+    boundingRect |= rect1;
+    QCOMPARE(viewPrivate->dirtyBoundingRect, boundingRect);
+
+    const QRect rect2(50, 50, 10, 10);
+    QVERIFY(viewPrivate->updateRect(rect2));
+    QVERIFY(!viewPrivate->fullUpdatePending);
+    boundingRect |= rect2;
+    QCOMPARE(viewPrivate->dirtyBoundingRect, boundingRect);
+
+    const QRect rect3(190, 190, 10, 10);
+    QVERIFY(viewPrivate->updateRect(rect3));
+    QVERIFY(viewPrivate->fullUpdatePending);
+    boundingRect |= rect3;
+    QCOMPARE(viewPrivate->dirtyBoundingRect, boundingRect);
+
+    view.lastUpdateRegions.clear();
+    viewPrivate->processPendingUpdates();
+    QTest::qWait(50);
+    QCOMPARE(view.lastUpdateRegions.size(), 1);
+    // Note that we adjust by 2 for antialiasing.
+    QCOMPARE(view.lastUpdateRegions.at(0), QRegion(boundingRect.adjusted(-2, -2, 2, 2) & viewportRect));
+#endif
+}
+
+#ifndef QT_NO_DRAGANDDROP
+void tst_QGraphicsView::acceptDrops()
+{
+    QGraphicsView view;
+
+    // Excepted default behavior.
+    QVERIFY(view.acceptDrops());
+    QVERIFY(view.viewport()->acceptDrops());
+
+    // Excepted behavior with no drops.
+    view.setAcceptDrops(false);
+    QVERIFY(!view.acceptDrops());
+    QVERIFY(!view.viewport()->acceptDrops());
+
+    // Setting a widget with drops on a QGraphicsView without drops.
+    QWidget *widget = new QWidget;
+    widget->setAcceptDrops(true);
+    view.setViewport(widget);
+    QVERIFY(!view.acceptDrops());
+    QVERIFY(!view.viewport()->acceptDrops());
+
+    // Switching the view to accept drops.
+    view.setAcceptDrops(true);
+    QVERIFY(view.acceptDrops());
+    QVERIFY(view.viewport()->acceptDrops());
+
+    // Setting a widget with no drops on a QGraphicsView with drops.
+    widget = new QWidget;
+    widget->setAcceptDrops(false);
+    view.setViewport(widget);
+    QVERIFY(view.viewport()->acceptDrops());
+    QVERIFY(view.acceptDrops());
+
+    // Switching the view to not accept drops.
+    view.setAcceptDrops(false);
+    QVERIFY(!view.viewport()->acceptDrops());
+}
+#endif
+
+void tst_QGraphicsView::optimizationFlags()
+{
+    QGraphicsView view;
+    QVERIFY(!view.optimizationFlags());
+
+    view.setOptimizationFlag(QGraphicsView::DontClipPainter);
+    QVERIFY(view.optimizationFlags() & QGraphicsView::DontClipPainter);
+    view.setOptimizationFlag(QGraphicsView::DontClipPainter, false);
+    QVERIFY(!view.optimizationFlags());
+
+    view.setOptimizationFlag(QGraphicsView::DontSavePainterState);
+    QVERIFY(view.optimizationFlags() & QGraphicsView::DontSavePainterState);
+    view.setOptimizationFlag(QGraphicsView::DontSavePainterState, false);
+    QVERIFY(!view.optimizationFlags());
+
+    view.setOptimizationFlag(QGraphicsView::DontAdjustForAntialiasing);
+    QVERIFY(view.optimizationFlags() & QGraphicsView::DontAdjustForAntialiasing);
+    view.setOptimizationFlag(QGraphicsView::DontAdjustForAntialiasing, false);
+    QVERIFY(!view.optimizationFlags());
+
+    view.setOptimizationFlags(QGraphicsView::DontAdjustForAntialiasing
+                              | QGraphicsView::DontClipPainter);
+    QCOMPARE(view.optimizationFlags(), QGraphicsView::OptimizationFlags(QGraphicsView::DontAdjustForAntialiasing
+             | QGraphicsView::DontClipPainter));
+}
+
+class MessUpPainterItem : public QGraphicsRectItem
+{
+public:
+    MessUpPainterItem(const QRectF &rect) : QGraphicsRectItem(rect), dirtyPainter(false)
+    { }
+
+    bool dirtyPainter;
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+    {
+        dirtyPainter = (painter->pen().width() != 0);
+        painter->setPen(QPen(Qt::black, 1.0));
+    }
+};
+
+class MyGraphicsView : public QGraphicsView
+{
+public:
+      MyGraphicsView(QGraphicsScene * scene) : QGraphicsView(scene)
+      { }
+
+      void drawBackground(QPainter * painter, const QRectF & rect) {
+          painter->setCompositionMode(QPainter::CompositionMode_Source);
+          painter->drawRect(rect);
+      }
+
+      void drawItems (QPainter * painter, int numItems, QGraphicsItem *items[], const QStyleOptionGraphicsItem options[]) {
+           if (!(optimizationFlags() & QGraphicsView::DontSavePainterState))
+               QCOMPARE(painter->compositionMode(),QPainter::CompositionMode_SourceOver);
+           else
+               QCOMPARE(painter->compositionMode(),QPainter::CompositionMode_Source);
+           QGraphicsView::drawItems(painter,numItems,items,options);
+      }
+};
+
+void tst_QGraphicsView::optimizationFlags_dontSavePainterState()
+{
+    MessUpPainterItem *parent = new MessUpPainterItem(QRectF(0, 0, 100, 100));
+    MessUpPainterItem *child = new MessUpPainterItem(QRectF(0, 0, 100, 100));
+    child->setParentItem(parent);
+
+    QGraphicsScene scene;
+    scene.addItem(parent);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    view.viewport()->repaint();
+
+    QVERIFY(!parent->dirtyPainter);
+    QVERIFY(!child->dirtyPainter);
+
+    view.setOptimizationFlags(QGraphicsView::DontSavePainterState);
+    view.viewport()->repaint();
+
+#ifdef Q_WS_MAC
+    // Repaint on Mac OS X actually does require spinning the event loop.
+    QTest::qWait(100);
+#endif
+    QVERIFY(!parent->dirtyPainter);
+    QVERIFY(child->dirtyPainter);
+
+    MyGraphicsView painter(&scene);
+    painter.show();
+    QTest::qWaitForWindowShown(&painter);
+
+    MyGraphicsView painter2(&scene);
+    painter2.setOptimizationFlag(QGraphicsView::DontSavePainterState,true);
+    painter2.show();
+    QTest::qWaitForWindowShown(&painter2);
+}
+
+void tst_QGraphicsView::optimizationFlags_dontSavePainterState2_data()
+{
+    QTest::addColumn<bool>("savePainter");
+    QTest::addColumn<bool>("indirectPainting");
+    QTest::newRow("With painter state protection, without indirect painting") << true << false;
+    QTest::newRow("Without painter state protection, without indirect painting") << false << false;
+    QTest::newRow("With painter state protectionm, with indirect painting") << true << true;
+    QTest::newRow("Without painter state protection, with indirect painting") << false << true;
+}
+
+void tst_QGraphicsView::optimizationFlags_dontSavePainterState2()
+{
+    QFETCH(bool, savePainter);
+    QFETCH(bool, indirectPainting);
+
+    class MyScene : public QGraphicsScene
+    {
+    public:
+        void drawBackground(QPainter *p, const QRectF &)
+        { transformInDrawBackground = p->worldTransform(); opacityInDrawBackground = p->opacity(); }
+
+        void drawForeground(QPainter *p, const QRectF &)
+        { transformInDrawForeground = p->worldTransform(); opacityInDrawForeground = p->opacity(); }
+
+        QTransform transformInDrawBackground;
+        QTransform transformInDrawForeground;
+        qreal opacityInDrawBackground;
+        qreal opacityInDrawForeground;
+    };
+
+    MyScene scene;
+    // Add transformed dummy items to make sure the painter's worldTransform() is changed in drawItems.
+    scene.addRect(0, 0, 20, 20)->setTransform(QTransform::fromScale(2, 2));
+    scene.addRect(50, 50, 20, 20)->setTransform(QTransform::fromTranslate(200, 200));
+
+    foreach (QGraphicsItem *item, scene.items())
+        item->setOpacity(0.6);
+
+    CustomView view(&scene);
+    if (!savePainter)
+        view.setOptimizationFlag(QGraphicsView::DontSavePainterState);
+    view.setOptimizationFlag(QGraphicsView::IndirectPainting, indirectPainting);
+    view.rotate(45);
+    view.scale(1.5, 1.5);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+
+    // Make sure the view is repainted; otherwise the tests below will fail.
+    view.viewport()->repaint();
+    QTest::qWait(200);
+    QVERIFY(view.painted);
+
+    // Make sure the painter's world transform is preserved after drawItems.
+    QTransform expectedTransform = view.viewportTransform();
+    QVERIFY(!expectedTransform.isIdentity());
+    QCOMPARE(scene.transformInDrawForeground, expectedTransform);
+    QCOMPARE(scene.transformInDrawBackground, expectedTransform);
+
+    qreal expectedOpacity = 1.0;
+    QCOMPARE(scene.opacityInDrawBackground, expectedOpacity);
+    QCOMPARE(scene.opacityInDrawForeground, expectedOpacity);
+
+    // Trigger more painting, this time from QGraphicsScene::render.
+    QImage image(scene.sceneRect().size().toSize(), QImage::Format_RGB32);
+    QPainter painter(&image);
+    scene.render(&painter);
+    painter.end();
+
+    expectedTransform = QTransform();
+    QCOMPARE(scene.transformInDrawForeground, expectedTransform);
+    QCOMPARE(scene.transformInDrawBackground, expectedTransform);
+    QCOMPARE(scene.opacityInDrawBackground, expectedOpacity);
+    QCOMPARE(scene.opacityInDrawForeground, expectedOpacity);
+
+    // Trigger more painting with another opacity on the painter.
+    painter.begin(&image);
+    painter.setOpacity(0.4);
+    expectedOpacity = 0.4;
+    scene.render(&painter);
+    painter.end();
+
+    QCOMPARE(scene.transformInDrawForeground, expectedTransform);
+    QCOMPARE(scene.transformInDrawBackground, expectedTransform);
+    QCOMPARE(scene.opacityInDrawBackground, expectedOpacity);
+    QCOMPARE(scene.opacityInDrawForeground, expectedOpacity);
+}
+
+class LodItem : public QGraphicsRectItem
+{
+public:
+    LodItem(const QRectF &rect) : QGraphicsRectItem(rect), lastLod(-42)
+    { }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *viewport)
+    {
+        lastLod = option->levelOfDetailFromTransform(painter->worldTransform());
+        QGraphicsRectItem::paint(painter, option, viewport);
+    }
+
+    qreal lastLod;
+};
+
+void tst_QGraphicsView::levelOfDetail_data()
+{
+    QTest::addColumn<QTransform>("transform");
+    QTest::addColumn<qreal>("lod");
+
+    QTest::newRow("1:4, 1:4") << QTransform().scale(0.25, 0.25) << qreal(0.25);
+    QTest::newRow("1:2, 1:4") << QTransform().scale(0.5, 0.25) << qreal(::sqrt(0.125));
+    QTest::newRow("4:1, 1:2") << QTransform().scale(0.25, 0.5) << qreal(::sqrt(0.125));
+
+    QTest::newRow("1:2, 1:2") << QTransform().scale(0.5, 0.5) << qreal(0.5);
+    QTest::newRow("1:1, 1:2") << QTransform().scale(1, 0.5) << qreal(::sqrt(0.5));
+    QTest::newRow("2:1, 1:1") << QTransform().scale(0.5, 1) << qreal(::sqrt(0.5));
+
+    QTest::newRow("1:1, 1:1") << QTransform().scale(1, 1) << qreal(1.0);
+    QTest::newRow("2:1, 1:1") << QTransform().scale(2, 1) << qreal(::sqrt(2.0));
+    QTest::newRow("1:1, 2:1") << QTransform().scale(2, 1) << qreal(::sqrt(2.0));
+    QTest::newRow("2:1, 2:1") << QTransform().scale(2, 2) << qreal(2.0);
+    QTest::newRow("2:1, 4:1") << QTransform().scale(2, 4) << qreal(::sqrt(8.0));
+    QTest::newRow("4:1, 2:1") << QTransform().scale(4, 2) << qreal(::sqrt(8.0));
+    QTest::newRow("4:1, 4:1") << QTransform().scale(4, 4) << qreal(4.0);
+}
+
+void tst_QGraphicsView::levelOfDetail()
+{
+    QFETCH(QTransform, transform);
+    QFETCH(qreal, lod);
+
+    LodItem *item = new LodItem(QRectF(0, 0, 100, 100));
+
+    QGraphicsScene scene;
+    scene.addItem(item);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QTRY_COMPARE(item->lastLod, qreal(1));
+
+    view.setTransform(transform);
+
+    QTRY_COMPARE(item->lastLod, lod);
+}
+
+// Moved to tst_qgraphicsview_2.cpp
+extern void _scrollBarRanges_data();
+
+void tst_QGraphicsView::scrollBarRanges_data()
+{
+    _scrollBarRanges_data();
+}
+
+void tst_QGraphicsView::scrollBarRanges()
+{
+    QFETCH(QSize, viewportSize);
+    QFETCH(QRectF, sceneRect);
+    QFETCH(QTransform, transform);
+    QFETCH(Qt::ScrollBarPolicy, hbarpolicy);
+    QFETCH(Qt::ScrollBarPolicy, vbarpolicy);
+    QFETCH(int, hmin);
+    QFETCH(int, hmax);
+    QFETCH(int, vmin);
+    QFETCH(int, vmax);
+    QFETCH(bool, useMotif);
+    QFETCH(bool, useStyledPanel);
+
+    QGraphicsScene scene(sceneRect);
+    scene.addRect(sceneRect, QPen(Qt::blue), QBrush(QColor(Qt::green)));
+    QGraphicsView view(&scene);
+    view.setRenderHint(QPainter::Antialiasing);
+    view.setTransform(transform);
+    view.setFrameStyle(useStyledPanel ? QFrame::StyledPanel : QFrame::NoFrame);
+
+    if (useMotif) {
+#if !defined(QT_NO_STYLE_MOTIF)
+        view.setStyle(new QMotifStyle);
+#else
+        QSKIP("No Motif style compiled.", SkipSingle);
+#endif
+    } else {
+#if defined(Q_OS_WINCE)
+        view.setStyle(new QWindowsStyle);
+#elif !defined(QT_NO_STYLE_PLASTIQUE)
+        view.setStyle(new QPlastiqueStyle);
+#endif
+    }
+    view.setStyleSheet(" "); // enables style propagation ;-)
+
+    int adjust = 0;
+    if (useStyledPanel)
+        adjust = view.style()->pixelMetric(QStyle::PM_DefaultFrameWidth) * 2;
+    view.resize(viewportSize + QSize(adjust, adjust));
+
+    view.setHorizontalScrollBarPolicy(hbarpolicy);
+    view.setVerticalScrollBarPolicy(vbarpolicy);
+
+    view.show();
+
+    QCOMPARE(view.horizontalScrollBar()->minimum(), hmin);
+    QCOMPARE(view.verticalScrollBar()->minimum(), vmin);
+    QCOMPARE(view.horizontalScrollBar()->maximum(), hmax);
+    QCOMPARE(view.verticalScrollBar()->maximum(), vmax);
+}
+
+class TestView : public QGraphicsView
+{
+public:
+    TestView(QGraphicsScene *scene)
+        : QGraphicsView(scene), accepted(false)
+    { }
+
+    bool accepted;
+
+protected:
+    void mousePressEvent(QMouseEvent *event)
+    {
+        QGraphicsView::mousePressEvent(event);
+        accepted = event->isAccepted();
+    }
+};
+
+void tst_QGraphicsView::acceptMousePressEvent()
+{
+    QGraphicsScene scene;
+
+    TestView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QMouseEvent event(QEvent::MouseButtonPress,
+                      view.viewport()->rect().center(),
+                      view.viewport()->mapToGlobal(view.viewport()->rect().center()),
+                      Qt::LeftButton, 0, 0);
+    event.setAccepted(false);
+    QApplication::sendEvent(view.viewport(), &event);
+    QVERIFY(!view.accepted);
+
+    scene.addRect(0, 0, 2000, 2000)->setFlag(QGraphicsItem::ItemIsMovable);
+
+    qApp->processEvents(); // ensure scene rect is updated
+
+    QApplication::sendEvent(view.viewport(), &event);
+    QVERIFY(view.accepted);
+}
+
+void tst_QGraphicsView::replayMouseMove()
+{
+    // An empty scene in a view. The view will send the events to the scene in
+    // any case. Note that the view doesn't have to be shown - the mouse event
+    // sending functions below send the events directly to the viewport.
+    QGraphicsScene scene(-10000, -10000, 20000, 20000);
+    QGraphicsView view(&scene);
+
+    EventSpy sceneSpy(&scene, QEvent::GraphicsSceneMouseMove);
+    EventSpy viewSpy(view.viewport(), QEvent::MouseMove);
+
+    sendMousePress(view.viewport(), view.viewport()->rect().center());
+
+    // One mouse event should be translated into one scene event.
+    for (int i = 0; i < 3; ++i) {
+        sendMouseMove(view.viewport(), view.viewport()->rect().center(),
+                      Qt::LeftButton, Qt::MouseButtons(Qt::LeftButton));
+        QCOMPARE(viewSpy.count(), i + 1);
+        QCOMPARE(sceneSpy.count(), i + 1);
+    }
+
+    // When the view is transformed, the view should get no more events.  But
+    // the scene should get replays.
+    for (int i = 0; i < 3; ++i) {
+        view.rotate(10);
+        QCOMPARE(viewSpy.count(), 3);
+        QCOMPARE(sceneSpy.count(), 3 + i + 1);
+    }
+
+    // When the view is scrolled, the view should get no more events.  But the
+    // scene should get replays.
+    for (int i = 0; i < 3; ++i) {
+        view.horizontalScrollBar()->setValue((i + 1) * 10);
+        QCOMPARE(viewSpy.count(), 3);
+        QCOMPARE(sceneSpy.count(), 6 + i + 1);
+    }
+}
+
+void tst_QGraphicsView::itemsUnderMouse()
+{
+   QGraphicsScene scene;
+   QGraphicsProxyWidget w;
+   w.setWidget(new QPushButton("W"));
+   w.resize(50,50);
+   QGraphicsProxyWidget w2(&w);
+   w2.setWidget(new QPushButton("W2"));
+   w2.resize(50,50);
+   QGraphicsProxyWidget w3(&w2);
+   w3.setWidget(new QPushButton("W3"));
+   w3.resize(50,50);
+   w.setZValue(150);
+   w2.setZValue(50);
+   w3.setZValue(0);
+   scene.addItem(&w);
+
+   QGraphicsView view(&scene);
+   view.show();
+   QTest::qWaitForWindowShown(&view);
+
+   QCOMPARE(view.items(view.mapFromScene(w3.boundingRect().center())).first(),
+            static_cast<QGraphicsItem *>(&w3));
+   w2.setFlag(QGraphicsItem::ItemIgnoresTransformations, true);
+   QCOMPARE(view.items(view.mapFromScene(w3.boundingRect().center())).first(),
+            static_cast<QGraphicsItem *>(&w3));
+}
+
+class QGraphicsTextItem_task172231 : public QGraphicsTextItem
+{
+public:
+    QGraphicsTextItem_task172231(const QString & text, QGraphicsItem * parent = 0)
+        : QGraphicsTextItem(text, parent) {}
+    QRectF exposedRect;
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        exposedRect = option->exposedRect;
+        QGraphicsTextItem::paint(painter, option, widget);
+    }
+};
+
+void tst_QGraphicsView::task172231_untransformableItems()
+{
+    // check fix in QGraphicsView::paintEvent()
+
+    QGraphicsScene scene;
+
+    QGraphicsTextItem_task172231 *text =
+        new QGraphicsTextItem_task172231("abcdefghijklmnopqrstuvwxyz");
+    text->setFlag(QGraphicsItem::ItemIgnoresTransformations);
+    scene.addItem(text);
+
+    QGraphicsView view(&scene);
+
+    view.scale(2, 1);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QApplication::setActiveWindow(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&view));
+
+    QRectF origExposedRect = text->exposedRect;
+
+    view.resize(int(0.75 * view.width()), view.height());
+    qApp->processEvents();
+
+    QCOMPARE(text->exposedRect, origExposedRect);
+
+    // notice that the fix also goes into QGraphicsView::render()
+    // and QGraphicsScene::render(), but in duplicated code that
+    // is pending a refactoring, so for now we omit autotesting
+    // these functions separately
+}
+
+class MousePressReleaseScene : public QGraphicsScene
+{
+public:
+    MousePressReleaseScene()
+        : presses(0), releases(0)
+    { }
+    int presses;
+    int releases;
+
+protected:
+    void mousePressEvent(QGraphicsSceneMouseEvent *event)
+    { ++presses; QGraphicsScene::mousePressEvent(event); }
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+    { ++releases; QGraphicsScene::mouseReleaseEvent(event); }
+};
+
+void tst_QGraphicsView::task180429_mouseReleaseDragMode()
+{
+    MousePressReleaseScene scene;
+
+    QGraphicsView view(&scene);
+    view.show();
+
+    sendMousePress(view.viewport(), view.viewport()->rect().center());
+    QCOMPARE(scene.presses, 1);
+    QCOMPARE(scene.releases, 0);
+    sendMouseRelease(view.viewport(), view.viewport()->rect().center());
+    QCOMPARE(scene.presses, 1);
+    QCOMPARE(scene.releases, 1);
+
+    view.setDragMode(QGraphicsView::RubberBandDrag);
+    sendMousePress(view.viewport(), view.viewport()->rect().center());
+    QCOMPARE(scene.presses, 2);
+    QCOMPARE(scene.releases, 1);
+    sendMouseRelease(view.viewport(), view.viewport()->rect().center());
+    QCOMPARE(scene.presses, 2);
+    QCOMPARE(scene.releases, 2);
+}
+
+void tst_QGraphicsView::task187791_setSceneCausesUpdate()
+{
+    QGraphicsScene scene(0, 0, 200, 200);
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    EventSpy updateSpy(view.viewport(), QEvent::Paint);
+    QCOMPARE(updateSpy.count(), 0);
+
+    view.setScene(0);
+    QApplication::processEvents();
+    QTRY_COMPARE(updateSpy.count(), 1);
+    view.setScene(&scene);
+    QApplication::processEvents();
+    QTRY_COMPARE(updateSpy.count(), 2);
+}
+
+class MouseMoveCounter : public QGraphicsView
+{
+public:
+    MouseMoveCounter() : mouseMoves(0)
+    { }
+    int mouseMoves;
+protected:
+    void mouseMoveEvent(QMouseEvent *event)
+    {
+        ++mouseMoves;
+        QGraphicsView::mouseMoveEvent(event);
+        foreach (QGraphicsItem *item, scene()->items()) {
+            scene()->removeItem(item);
+            delete item;
+        }
+        scene()->addRect(0, 0, 50, 50);
+        scene()->addRect(0, 0, 100, 100);
+    }
+};
+
+void tst_QGraphicsView::task186827_deleteReplayedItem()
+{
+    // make sure the mouse is not over the window, causing spontaneous mouse moves
+    QCursor::setPos(1, 1);
+
+    QGraphicsScene scene;
+    scene.addRect(0, 0, 50, 50);
+    scene.addRect(0, 0, 100, 100);
+
+    MouseMoveCounter view;
+    view.setScene(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    view.viewport()->setMouseTracking(true);
+
+    QCOMPARE(view.mouseMoves, 0);
+    {
+        QMouseEvent event(QEvent::MouseMove, view.mapFromScene(25, 25), Qt::NoButton, 0, 0);
+        QApplication::sendEvent(view.viewport(), &event);
+    }
+    QCOMPARE(view.mouseMoves, 1);
+    QTest::qWait(25);
+    QTRY_COMPARE(view.mouseMoves, 1);
+    QTest::qWait(25);
+    {
+        QMouseEvent event(QEvent::MouseMove, view.mapFromScene(25, 25), Qt::NoButton, 0, 0);
+        QApplication::sendEvent(view.viewport(), &event);
+    }
+    QCOMPARE(view.mouseMoves, 2);
+    QTest::qWait(15);
+}
+
+void tst_QGraphicsView::task207546_focusCrash()
+{
+    class _Widget : public QWidget
+    {
+    public:
+        bool focusNextPrevChild(bool next) { return QWidget::focusNextPrevChild(next); }
+    } widget;
+
+    widget.setLayout(new QVBoxLayout());
+    QGraphicsView *gr1 = new QGraphicsView(&widget);
+    QGraphicsView *gr2 = new QGraphicsView(&widget);
+    widget.layout()->addWidget(gr1);
+    widget.layout()->addWidget(gr2);
+    widget.show();
+    QTest::qWaitForWindowShown(&widget);
+    widget.activateWindow();
+    QApplication::setActiveWindow(&widget);
+    QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&widget));
+    widget.focusNextPrevChild(true);
+    QCOMPARE(static_cast<QWidget *>(gr2), widget.focusWidget());
+}
+
+void tst_QGraphicsView::task210599_unsetDragWhileDragging()
+{
+    QGraphicsScene scene(0, 0, 400, 400);
+    QGraphicsView view(&scene);
+    view.setGeometry(0, 0, 200, 200);
+    view.show();
+
+    QPoint origPos = QPoint(100, 100);
+    QPoint step1Pos = QPoint(100, 110);
+    QPoint step2Pos = QPoint(100, 120);
+
+    // Enable and do a drag
+    {
+        view.setDragMode(QGraphicsView::ScrollHandDrag);
+        QMouseEvent press(QEvent::MouseButtonPress, origPos, Qt::LeftButton, 0, 0);
+        QMouseEvent move(QEvent::MouseMove, step1Pos, Qt::LeftButton, 0, 0);
+        QApplication::sendEvent(view.viewport(), &press);
+        QApplication::sendEvent(view.viewport(), &move);
+    }
+
+    // unset drag and release mouse, inverse order
+    {
+        view.setDragMode(QGraphicsView::NoDrag);
+        QMouseEvent release(QEvent::MouseButtonRelease, step1Pos, Qt::LeftButton, 0, 0);
+        QApplication::sendEvent(view.viewport(), &release);
+    }
+
+    QPoint basePos = view.mapFromScene(0, 0);
+
+    // reset drag, and move mouse without holding button down.
+    {
+        view.setDragMode(QGraphicsView::ScrollHandDrag);
+        QMouseEvent move(QEvent::MouseMove, step2Pos, Qt::LeftButton, 0, 0);
+        QApplication::sendEvent(view.viewport(), &move);
+    }
+
+    // Check that no draggin has occurred...
+    QCOMPARE(basePos, view.mapFromScene(0, 0));
+}
+
+void tst_QGraphicsView::task236394_sendShortcutOverrideEvent()
+{
+    QGraphicsView view;
+    view.show();
+    QKeyEvent event(QEvent::ShortcutOverride, Qt::Key_A, 0, QString("A"));
+    QApplication::sendEvent(&view, &event);
+}
+
+class ChangedListener : public QObject
+{
+    Q_OBJECT
+public:
+    QList<QList<QRectF> > changes;
+
+public slots:
+    void changed(const QList<QRectF> &dirty)
+    {
+        changes << dirty;
+    }
+};
+
+void tst_QGraphicsView::task239729_noViewUpdate_data()
+{
+    QTest::addColumn<bool>("a");
+
+    QTest::newRow("a") << false;
+    QTest::newRow("b") << true;
+}
+
+void tst_QGraphicsView::task239729_noViewUpdate()
+{
+    QFETCH(bool, a);
+    // The scene's changed signal is connected to something that isn't a view.
+    QGraphicsScene scene;
+    ChangedListener cl;
+    QGraphicsView *view = 0;
+
+    if (a) {
+        view = new QGraphicsView(&scene);
+        connect(&scene, SIGNAL(changed(const QList<QRectF> &)), &cl, SLOT(changed(const QList<QRectF> &)));
+    } else {
+        connect(&scene, SIGNAL(changed(const QList<QRectF> &)), &cl, SLOT(changed(const QList<QRectF> &)));
+        view = new QGraphicsView(&scene);
+    }
+
+    EventSpy spy(view->viewport(), QEvent::Paint);
+    QCOMPARE(spy.count(), 0);
+
+    view->show();
+    QTest::qWaitForWindowShown(view);
+
+    QTRY_VERIFY(spy.count() >= 1);
+    spy.reset();
+    scene.update();
+    QApplication::processEvents();
+    QTRY_COMPARE(spy.count(), 1);
+
+    delete view;
+}
+
+void tst_QGraphicsView::task239047_fitInViewSmallViewport()
+{
+    // Ensure that with a small viewport, fitInView doesn't mirror the
+    // scene.
+    QWidget widget;
+    QGraphicsScene scene;
+    QGraphicsView *view = new QGraphicsView(&scene, &widget);
+    view->resize(3, 3);
+    QCOMPARE(view->size(), QSize(3, 3));
+    widget.show();
+    view->fitInView(0, 0, 100, 100);
+    QPointF topLeft = view->mapToScene(0, 0);
+    QPointF bottomRight = view->mapToScene(100, 100);
+    QVERIFY(bottomRight.x() > topLeft.x());
+    QVERIFY(bottomRight.y() > topLeft.y());
+
+    view->fitInView(0, 0, 0, 100);
+
+    // Don't crash
+    view->scale(0, 0);
+    view->fitInView(0, 0, 100, 100);
+}
+
+void tst_QGraphicsView::task245469_itemsAtPointWithClip()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *parent = scene.addRect(0, 0, 100, 100);
+    QGraphicsItem *child = new QGraphicsRectItem(40, 40, 20, 20, parent);
+    parent->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+
+    QGraphicsView view(&scene);
+    view.resize(150,150);
+    view.rotate(90);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QList<QGraphicsItem *> itemsAtCenter = view.items(view.viewport()->rect().center());
+    QCOMPARE(itemsAtCenter, (QList<QGraphicsItem *>() << child << parent));
+
+    QPolygonF p = view.mapToScene(QRect(view.viewport()->rect().center(), QSize(1, 1)));
+    QList<QGraphicsItem *> itemsAtCenter2 = scene.items(p);
+    QCOMPARE(itemsAtCenter2, itemsAtCenter);
+}
+
+static QGraphicsView *createSimpleViewAndScene()
+{
+    QGraphicsView *view = new QGraphicsView;
+    QGraphicsScene *scene = new QGraphicsScene;
+    view->setScene(scene);
+
+    view->setBackgroundBrush(Qt::blue);
+
+    QGraphicsRectItem *rect = scene->addRect(0, 0, 10, 10);
+    rect->setBrush(Qt::red);
+    rect->setPen(Qt::NoPen);
+    return view;
+}
+
+class SpyItem : public QGraphicsRectItem
+{
+public:
+    SpyItem()
+        : QGraphicsRectItem(QRectF(0, 0, 100, 100))
+    {
+    }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+    {
+        transform = painter->transform();
+    }
+
+    QTransform transform;
+};
+
+void tst_QGraphicsView::embeddedViews()
+{
+    QGraphicsView *v1 = createSimpleViewAndScene();
+    QGraphicsView *v2 = createSimpleViewAndScene();
+
+    QGraphicsProxyWidget *proxy = v1->scene()->addWidget(v2);
+
+    SpyItem *item = new SpyItem;
+    v2->scene()->addItem(item);
+
+    proxy->translate(5, 5);
+
+    QImage actual(64, 64, QImage::Format_ARGB32_Premultiplied);
+    actual.fill(0);
+    v1->QWidget::render(&actual);
+    QTransform a = item->transform;
+
+    v2->QWidget::render(&actual);
+    QTransform b = item->transform;
+
+    QVERIFY(a == b);
+    delete v1;
+}
+
+void tst_QGraphicsView::scrollAfterResize_data()
+{
+    QTest::addColumn<bool>("reverse");
+    QTest::addColumn<QTransform>("x1");
+    QTest::addColumn<QTransform>("x2");
+    QTest::addColumn<QTransform>("x3");
+
+#if !defined(QT_NO_STYLE_PLASTIQUE)
+    QPlastiqueStyle style;
+#elif !defined(QT_NO_STYLE_WINDOWS)
+    QWindowsStyle style;
+#else
+    QCommonStyle style;
+#endif
+
+    int frameWidth = style.pixelMetric(QStyle::PM_DefaultFrameWidth);
+    int extent = style.pixelMetric(QStyle::PM_ScrollBarExtent);
+    int inside = style.styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents);
+    int viewportWidth = 300;
+    int scrollBarIndent = viewportWidth - extent - (inside ? 4 : 2)*frameWidth;
+
+    QTest::newRow("normal") << false
+                            << QTransform()
+                            << QTransform()
+                            << QTransform().translate(-10, 0);
+    QTest::newRow("reverse") << true
+                             << QTransform().translate(scrollBarIndent, 0)
+                             << QTransform().translate(scrollBarIndent + 100, 0)
+                             << QTransform().translate(scrollBarIndent + 110, 0);
+}
+
+void tst_QGraphicsView::scrollAfterResize()
+{
+    QFETCH(bool, reverse);
+    QFETCH(QTransform, x1);
+    QFETCH(QTransform, x2);
+    QFETCH(QTransform, x3);
+
+#if !defined(QT_NO_STYLE_PLASTIQUE)
+    QPlastiqueStyle style;
+#elif !defined(QT_NO_STYLE_WINDOWS)
+    QWindowsStyle style;
+#else
+    QCommonStyle style;
+#endif
+    QWidget toplevel;
+
+    QGraphicsView view(&toplevel);
+    view.setStyle(&style);
+    if (reverse)
+        view.setLayoutDirection(Qt::RightToLeft);
+
+    view.setSceneRect(-1000, -1000, 2000, 2000);
+    view.resize(300, 300);
+    toplevel.show();
+    QTest::qWaitForWindowShown(&toplevel);
+    view.horizontalScrollBar()->setValue(0);
+    view.verticalScrollBar()->setValue(0);
+    QCOMPARE(view.viewportTransform(), x1);
+    view.resize(400, 300);
+    QCOMPARE(view.viewportTransform(), x2);
+    view.horizontalScrollBar()->setValue(10);
+    QCOMPARE(view.viewportTransform(), x3);
+}
+
+void tst_QGraphicsView::moveItemWhileScrolling_data()
+{
+    QTest::addColumn<bool>("adjustForAntialiasing");
+    QTest::addColumn<bool>("changedConnected");
+
+    QTest::newRow("no adjust") << false << false;
+    QTest::newRow("adjust") << true << false;
+    QTest::newRow("no adjust changedConnected") << false << true;
+    QTest::newRow("adjust changedConnected") << true << true;
+}
+
+void tst_QGraphicsView::moveItemWhileScrolling()
+{
+    QFETCH(bool, adjustForAntialiasing);
+    QFETCH(bool, changedConnected);
+
+    class MoveItemScrollView : public QGraphicsView
+    {
+    public:
+        MoveItemScrollView()
+        {
+            setWindowFlags(Qt::X11BypassWindowManagerHint);
+            setScene(new QGraphicsScene(0, 0, 1000, 1000));
+            rect = scene()->addRect(0, 0, 10, 10);
+            rect->setPos(50, 50);
+            painted = false;
+        }
+        QRegion lastPaintedRegion;
+        QGraphicsItem *rect;
+        bool painted;
+        void waitForPaintEvent()
+        {
+            QTimer::singleShot(2000, &eventLoop, SLOT(quit()));
+            eventLoop.exec();
+        }
+    protected:
+        QEventLoop eventLoop;
+        void paintEvent(QPaintEvent *event)
+        {
+            painted = true;
+            lastPaintedRegion = event->region();
+            QGraphicsView::paintEvent(event);
+            if (eventLoop.isRunning())
+                eventLoop.quit();
+        }
+    };
+
+    MoveItemScrollView view;
+    view.setFrameStyle(0);
+    view.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    view.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    view.setResizeAnchor(QGraphicsView::NoAnchor);
+    view.setTransformationAnchor(QGraphicsView::NoAnchor);
+    if (!adjustForAntialiasing)
+        view.setOptimizationFlag(QGraphicsView::DontAdjustForAntialiasing);
+    view.resize(200, 200);
+    view.painted = false;
+    view.show();
+    if (changedConnected)
+        QObject::connect(view.scene(), SIGNAL(changed(QList<QRectF>)), this, SLOT(dummySlot()));
+    QTest::qWaitForWindowShown(&view);
+    QApplication::processEvents();
+    QTRY_VERIFY(view.painted);
+    view.painted = false;
+    view.lastPaintedRegion = QRegion();
+    view.horizontalScrollBar()->setValue(view.horizontalScrollBar()->value() + 10);
+    view.rect->moveBy(0, 10);
+    view.waitForPaintEvent();
+    QTRY_VERIFY(view.painted);
+
+    QRegion expectedRegion;
+    expectedRegion += QRect(0, 0, 200, 200);
+    expectedRegion -= QRect(0, 0, 190, 200);
+    int a = adjustForAntialiasing ? 2 : 1;
+    expectedRegion += QRect(40, 50, 10, 10).adjusted(-a, -a, a, a);
+    expectedRegion += QRect(40, 60, 10, 10).adjusted(-a, -a, a, a);
+#ifdef Q_OS_MAC
+    QEXPECT_FAIL("", "This will fail with Cocoa because paint events are not send in the order expected by graphicsview", Continue);
+#endif
+    COMPARE_REGIONS(view.lastPaintedRegion, expectedRegion);
+}
+
+void tst_QGraphicsView::centerOnDirtyItem()
+{
+    QWidget toplevel;
+
+    QGraphicsView view(&toplevel);
+    toplevel.setWindowFlags(view.windowFlags() | Qt::WindowStaysOnTopHint);
+    view.resize(200, 200);
+
+    QGraphicsScene *scene = new QGraphicsScene;
+    view.setScene(scene);
+    view.setSceneRect(-1000, -1000, 2000, 2000);
+
+    QGraphicsRectItem *item = new QGraphicsRectItem(0, 0, 10, 10);
+    item->setBrush(Qt::red);
+    scene->addItem(item);
+    view.centerOn(item);
+
+    toplevel.show();
+    QTest::qWaitForWindowShown(&toplevel);
+    QTest::qWait(50);
+
+    QImage before(view.viewport()->size(), QImage::Format_ARGB32);
+    view.viewport()->render(&before);
+
+    item->setPos(20, 0);
+    view.centerOn(item);
+
+    QTest::qWait(50);
+
+    QImage after(view.viewport()->size(), QImage::Format_ARGB32);
+    view.viewport()->render(&after);
+
+    QCOMPARE(before, after);
+}
+
+void tst_QGraphicsView::mouseTracking()
+{
+    // Mouse tracking should only be automatically enabled if items either accept hover events
+    // or have a cursor set. We never disable mouse tracking if it is already enabled.
+
+    { // Make sure mouse tracking is disabled by default.
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        QGraphicsView view(&scene);
+        QVERIFY(!view.viewport()->hasMouseTracking());
+    }
+
+    { // Make sure we don't disable mouse tracking in setupViewport/setScene.
+        QGraphicsView view;
+        QWidget *viewport = new QWidget;
+        viewport->setMouseTracking(true);
+        view.setViewport(viewport);
+        QVERIFY(viewport->hasMouseTracking());
+
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        view.setScene(&scene);
+        QVERIFY(viewport->hasMouseTracking());
+    }
+
+    // Make sure we enable mouse tracking when having items that accept hover events.
+    {
+        // Adding an item to the scene after the scene is set on the view.
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        QGraphicsView view(&scene);
+
+        QGraphicsRectItem *item = new QGraphicsRectItem(10, 10, 10, 10);
+        item->setAcceptHoverEvents(true);
+        scene.addItem(item);
+        QVERIFY(view.viewport()->hasMouseTracking());
+    }
+    {
+        // Adding an item to the scene before the scene is set on the view.
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        QGraphicsRectItem *item = new QGraphicsRectItem(10, 10, 10, 10);
+        item->setAcceptHoverEvents(true);
+        scene.addItem(item);
+
+        QGraphicsView view(&scene);
+        QVERIFY(view.viewport()->hasMouseTracking());
+    }
+    {
+        // QGraphicsWidget implicitly accepts hover if it has window decoration.
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        QGraphicsView view(&scene);
+
+        QGraphicsWidget *widget = new QGraphicsWidget;
+        scene.addItem(widget);
+        QVERIFY(!view.viewport()->hasMouseTracking());
+        // Enable window decoraton.
+        widget->setWindowFlags(Qt::Window | Qt::WindowTitleHint);
+        QVERIFY(view.viewport()->hasMouseTracking());
+    }
+
+    // Make sure we enable mouse tracking when having items with a cursor set.
+    {
+        // Adding an item to the scene after the scene is set on the view.
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        QGraphicsView view(&scene);
+
+        QGraphicsRectItem *item = new QGraphicsRectItem(10, 10, 10, 10);
+#ifndef QT_NO_CURSOR
+        item->setCursor(Qt::CrossCursor);
+#endif
+        scene.addItem(item);
+        QVERIFY(view.viewport()->hasMouseTracking());
+    }
+    {
+        // Adding an item to the scene before the scene is set on the view.
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        QGraphicsRectItem *item = new QGraphicsRectItem(10, 10, 10, 10);
+#ifndef QT_NO_CURSOR
+        item->setCursor(Qt::CrossCursor);
+#endif
+        scene.addItem(item);
+
+        QGraphicsView view(&scene);
+        QVERIFY(view.viewport()->hasMouseTracking());
+    }
+
+    // Make sure we propagate mouse tracking to all views.
+    {
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        QGraphicsView view1(&scene);
+        QGraphicsView view2(&scene);
+        QGraphicsView view3(&scene);
+
+        QGraphicsRectItem *item = new QGraphicsRectItem(10, 10, 10, 10);
+#ifndef QT_NO_CURSOR
+        item->setCursor(Qt::CrossCursor);
+#endif
+        scene.addItem(item);
+
+        QVERIFY(view1.viewport()->hasMouseTracking());
+        QVERIFY(view2.viewport()->hasMouseTracking());
+        QVERIFY(view3.viewport()->hasMouseTracking());
+    }
+}
+
+void tst_QGraphicsView::mouseTracking2()
+{
+    // Make sure mouse move events propagates to the scene when
+    // mouse tracking is explicitly enabled on the view,
+    // even when all items ignore hover events / use default cursor.
+
+    QGraphicsScene scene;
+    scene.addRect(0, 0, 100, 100);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QVERIFY(!view.viewport()->hasMouseTracking());
+    view.viewport()->setMouseTracking(true); // Explicitly enable mouse tracking.
+    QVERIFY(view.viewport()->hasMouseTracking());
+
+    EventSpy spy(&scene, QEvent::GraphicsSceneMouseMove);
+    QCOMPARE(spy.count(), 0);
+    QMouseEvent event(QEvent::MouseMove,view.viewport()->rect().center(), Qt::NoButton,
+                      Qt::MouseButtons(Qt::NoButton), 0);
+    QApplication::sendEvent(view.viewport(), &event);
+    QCOMPARE(spy.count(), 1);
+}
+
+void tst_QGraphicsView::mouseTracking3()
+{
+    // Mouse tracking should be automatically enabled if AnchorUnderMouse is used for
+    // view transform or resize. We never disable mouse tracking if it is already enabled.
+
+    { // Make sure we enable mouse tracking when using AnchorUnderMouse for view transformation.
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        QGraphicsView view(&scene);
+        QVERIFY(!view.viewport()->hasMouseTracking());
+
+        view.setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
+        QVERIFY(view.viewport()->hasMouseTracking());
+    }
+
+    { // Make sure we enable mouse tracking when using AnchorUnderMouse for view resizing.
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        QGraphicsView view(&scene);
+        QVERIFY(!view.viewport()->hasMouseTracking());
+
+        view.setResizeAnchor(QGraphicsView::AnchorUnderMouse);
+        QVERIFY(view.viewport()->hasMouseTracking());
+    }
+
+    { // Make sure we don't disable mouse tracking in setViewport/setScene (transformation anchor).
+        QGraphicsView view;
+        view.setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
+        QVERIFY(view.viewport()->hasMouseTracking());
+
+        QWidget *viewport = new QWidget;
+        view.setViewport(viewport);
+        QVERIFY(viewport->hasMouseTracking());
+
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        view.setScene(&scene);
+        QVERIFY(viewport->hasMouseTracking());
+    }
+
+    { // Make sure we don't disable mouse tracking in setViewport/setScene (resize anchor).
+        QGraphicsView view;
+        view.setResizeAnchor(QGraphicsView::AnchorUnderMouse);
+        QVERIFY(view.viewport()->hasMouseTracking());
+
+        QWidget *viewport = new QWidget;
+        view.setViewport(viewport);
+        QVERIFY(viewport->hasMouseTracking());
+
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        view.setScene(&scene);
+        QVERIFY(viewport->hasMouseTracking());
+    }
+
+    // Make sure we don't disable mouse tracking when adding an item (transformation anchor).
+    { // Adding an item to the scene before the scene is set on the view.
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        QGraphicsRectItem *item = new QGraphicsRectItem(10, 10, 10, 10);
+        scene.addItem(item);
+
+        QGraphicsView view;
+        view.setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
+        view.setScene(&scene);
+        QVERIFY(view.viewport()->hasMouseTracking());
+    }
+
+    { // Adding an item to the scene after the scene is set on the view.
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        QGraphicsView view(&scene);
+        view.setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
+
+        QGraphicsRectItem *item = new QGraphicsRectItem(10, 10, 10, 10);
+        scene.addItem(item);
+        QVERIFY(view.viewport()->hasMouseTracking());
+    }
+
+    // Make sure we don't disable mouse tracking when adding an item (resize anchor).
+    { // Adding an item to the scene before the scene is set on the view.
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        QGraphicsRectItem *item = new QGraphicsRectItem(10, 10, 10, 10);
+        scene.addItem(item);
+
+        QGraphicsView view;
+        view.setResizeAnchor(QGraphicsView::AnchorUnderMouse);
+        view.setScene(&scene);
+        QVERIFY(view.viewport()->hasMouseTracking());
+    }
+
+    { // Adding an item to the scene after the scene is set on the view.
+        QGraphicsScene scene(-10000, -10000, 20000, 20000);
+        QGraphicsView view(&scene);
+        view.setResizeAnchor(QGraphicsView::AnchorUnderMouse);
+
+        QGraphicsRectItem *item = new QGraphicsRectItem(10, 10, 10, 10);
+        scene.addItem(item);
+        QVERIFY(view.viewport()->hasMouseTracking());
+    }
+}
+
+class RenderTester : public QGraphicsRectItem
+{
+public:
+    RenderTester(const QRectF &rect)
+        : QGraphicsRectItem(rect), paints(0)
+    { }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
+               QWidget *widget)
+    {
+        QGraphicsRectItem::paint(painter, option, widget);
+        ++paints;
+    }
+
+    int paints;
+};
+
+void tst_QGraphicsView::render()
+{
+    // ### This test can be much more thorough - see QGraphicsScene::render.
+    QGraphicsScene scene;
+    CustomView view(&scene);
+    view.setFrameStyle(0);
+    view.resize(200, 200);
+    view.painted = false;
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QApplication::processEvents();
+    QTRY_VERIFY(view.painted > 0);
+
+    RenderTester *r1 = new RenderTester(QRectF(0, 0, 50, 50));
+    RenderTester *r2 = new RenderTester(QRectF(50, 50, 50, 50));
+    RenderTester *r3 = new RenderTester(QRectF(0, 50, 50, 50));
+    RenderTester *r4 = new RenderTester(QRectF(50, 0, 50, 50));
+    scene.addItem(r1);
+    scene.addItem(r2);
+    scene.addItem(r3);
+    scene.addItem(r4);
+
+    qApp->processEvents();
+
+    QTRY_COMPARE(r1->paints, 1);
+    QCOMPARE(r2->paints, 1);
+    QCOMPARE(r3->paints, 1);
+    QCOMPARE(r4->paints, 1);
+
+    QPixmap pix(200, 200);
+    pix.fill(Qt::transparent);
+    QPainter painter(&pix);
+    view.render(&painter);
+    painter.end();
+
+    QCOMPARE(r1->paints, 2);
+    QCOMPARE(r2->paints, 2);
+    QCOMPARE(r3->paints, 2);
+    QCOMPARE(r4->paints, 2);
+}
+
+void tst_QGraphicsView::exposeRegion()
+{
+    RenderTester *item = new RenderTester(QRectF(0, 0, 20, 20));
+    QGraphicsScene scene;
+    scene.addItem(item);
+
+    item->paints = 0;
+    CustomView view;
+    view.setScene(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(item->paints > 0);
+
+    item->paints = 0;
+    view.lastUpdateRegions.clear();
+
+    // Update a small area in the viewport's topLeft() and bottomRight().
+    // (the boundingRect() of this area covers the entire viewport).
+    QWidget *viewport = view.viewport();
+    QRegion expectedExposeRegion = QRect(0, 0, 5, 5);
+    expectedExposeRegion += QRect(viewport->rect().bottomRight() - QPoint(5, 5), QSize(5, 5));
+    viewport->update(expectedExposeRegion);
+    QApplication::processEvents();
+
+    // Make sure it triggers correct repaint on the view.
+    QTRY_COMPARE(view.lastUpdateRegions.size(), 1);
+    COMPARE_REGIONS(view.lastUpdateRegions.at(0), expectedExposeRegion);
+
+    // Make sure the item didn't get any repaints.
+#ifndef Q_OS_MAC
+    QCOMPARE(item->paints, 0);
+#endif
+}
+
+void tst_QGraphicsView::update_data()
+{
+    // In view.viewport() coordinates. (viewport rect: QRect(0, 0, 200, 200))
+    QTest::addColumn<QRect>("updateRect");
+    QTest::newRow("empty") << QRect();
+    QTest::newRow("outside left") << QRect(-200, 0, 100, 100);
+    QTest::newRow("outside right") << QRect(400, 0 ,100, 100);
+    QTest::newRow("outside top") << QRect(0, -200, 100, 100);
+    QTest::newRow("outside bottom") << QRect(0, 400, 100, 100);
+    QTest::newRow("partially inside left") << QRect(-50, 0, 100, 100);
+    QTest::newRow("partially inside right") << QRect(-150, 0, 100, 100);
+    QTest::newRow("partially inside top") << QRect(0, -150, 100, 100);
+    QTest::newRow("partially inside bottom") << QRect(0, 150, 100, 100);
+    QTest::newRow("on topLeft edge") << QRect(-100, -100, 100, 100);
+    QTest::newRow("on topRight edge") << QRect(200, -100, 100, 100);
+    QTest::newRow("on bottomRight edge") << QRect(200, 200, 100, 100);
+    QTest::newRow("on bottomLeft edge") << QRect(-200, 200, 100, 100);
+    QTest::newRow("inside topLeft") << QRect(-99, -99, 100, 100);
+    QTest::newRow("inside topRight") << QRect(199, -99, 100, 100);
+    QTest::newRow("inside bottomRight") << QRect(199, 199, 100, 100);
+    QTest::newRow("inside bottomLeft") << QRect(-199, 199, 100, 100);
+    QTest::newRow("large1") << QRect(50, -100, 100, 400);
+    QTest::newRow("large2") << QRect(-100, 50, 400, 100);
+    QTest::newRow("large3") << QRect(-100, -100, 400, 400);
+    QTest::newRow("viewport rect") << QRect(0, 0, 200, 200);
+}
+
+void tst_QGraphicsView::update()
+{
+    QFETCH(QRect, updateRect);
+
+    // some window manager resize the toplevel to max screen size
+    // so we must make our view a child (no layout!) of a dummy toplevel
+    // to ensure that it's really 200x200 pixels
+    QWidget toplevel;
+
+    // Create a view with viewport rect equal to QRect(0, 0, 200, 200).
+    QGraphicsScene dummyScene;
+    CustomView view(0, &toplevel);
+    view.setScene(&dummyScene);
+    view.ensurePolished(); // must ensure polished to get content margins right
+    int left, top, right, bottom;
+    view.getContentsMargins(&left, &top, &right, &bottom);
+    view.resize(200 + left + right, 200 + top + bottom);
+    toplevel.show();
+    QTest::qWaitForWindowShown(&toplevel);
+
+
+    QApplication::setActiveWindow(&toplevel);
+    QApplication::processEvents();
+    QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&toplevel));
+
+    const QRect viewportRect = view.viewport()->rect();
+    QCOMPARE(viewportRect, QRect(0, 0, 200, 200));
+
+#if defined QT_BUILD_INTERNAL
+    const bool intersects = updateRect.intersects(viewportRect);
+    QGraphicsViewPrivate *viewPrivate = static_cast<QGraphicsViewPrivate *>(qt_widget_private(&view));
+    QTRY_COMPARE(viewPrivate->updateRect(updateRect), intersects);
+    QApplication::processEvents();
+
+    view.lastUpdateRegions.clear();
+    viewPrivate->processPendingUpdates();
+    QVERIFY(viewPrivate->dirtyRegion.isEmpty());
+    QVERIFY(viewPrivate->dirtyBoundingRect.isEmpty());
+    QApplication::processEvents();
+    if (!intersects) {
+        QTRY_VERIFY(view.lastUpdateRegions.isEmpty());
+    } else {
+        QTRY_COMPARE(view.lastUpdateRegions.size(), 1);
+        QTRY_COMPARE(view.lastUpdateRegions.at(0), QRegion(updateRect) & viewportRect);
+    }
+    QTRY_VERIFY(!viewPrivate->fullUpdatePending);
+#endif
+}
+
+void tst_QGraphicsView::update2_data()
+{
+    QTest::addColumn<qreal>("penWidth");
+    QTest::addColumn<bool>("antialiasing");
+    QTest::addColumn<bool>("changedConnected");
+
+    // Anti-aliased.
+    QTest::newRow("pen width: 0.0, antialiasing: true") << qreal(0.0) << true << false;
+    QTest::newRow("pen width: 1.5, antialiasing: true") << qreal(1.5) << true << false;
+    QTest::newRow("pen width: 2.0, antialiasing: true") << qreal(2.0) << true << false;
+    QTest::newRow("pen width: 3.0, antialiasing: true") << qreal(3.0) << true << false;
+
+    // Aliased.
+    QTest::newRow("pen width: 0.0, antialiasing: false") << qreal(0.0) << false << false;
+    QTest::newRow("pen width: 1.5, antialiasing: false") << qreal(1.5) << false << false;
+    QTest::newRow("pen width: 2.0, antialiasing: false") << qreal(2.0) << false << false;
+    QTest::newRow("pen width: 3.0, antialiasing: false") << qreal(3.0) << false << false;
+
+    // changed() connected
+    QTest::newRow("pen width: 0.0, antialiasing: false, changed") << qreal(0.0) << false << true;
+    QTest::newRow("pen width: 1.5, antialiasing: true, changed") << qreal(1.5) << true << true;
+    QTest::newRow("pen width: 2.0, antialiasing: false, changed") << qreal(2.0) << false << true;
+    QTest::newRow("pen width: 3.0, antialiasing: true, changed") << qreal(3.0) << true << true;
+}
+
+void tst_QGraphicsView::update2()
+{
+    QFETCH(qreal, penWidth);
+    QFETCH(bool, antialiasing);
+    QFETCH(bool, changedConnected);
+
+    // Create a rect item.
+    const QRectF rawItemRect(-50.4, -50.3, 100.2, 100.1);
+    CountPaintItem *rect = new CountPaintItem(rawItemRect);
+    QPen pen;
+    pen.setWidthF(penWidth);
+    rect->setPen(pen);
+
+    // Add item to a scene.
+    QGraphicsScene scene(-100, -100, 200, 200);
+    if (changedConnected)
+        QObject::connect(&scene, SIGNAL(changed(QList<QRectF>)), this, SLOT(dummySlot()));
+
+    scene.addItem(rect);
+
+    // Create a view on the scene.
+    CustomView view(&scene);
+    view.setOptimizationFlag(QGraphicsView::DontAdjustForAntialiasing, !antialiasing);
+    view.setRenderHint(QPainter::Antialiasing, antialiasing);
+    view.setFrameStyle(0);
+    view.resize(200, 200);
+    view.show();
+    QTest::qWaitForWindowShown(&view) ;
+    QTRY_VERIFY(rect->numPaints > 0);
+
+    // Calculate expected update region for the rect.
+    QRectF expectedItemBoundingRect = rawItemRect;
+    const qreal halfPenWidth = penWidth / qreal(2.0);
+    expectedItemBoundingRect.adjust(-halfPenWidth, -halfPenWidth, halfPenWidth, halfPenWidth);
+    QCOMPARE(rect->boundingRect(), expectedItemBoundingRect);
+
+    QRect expectedItemDeviceBoundingRect = rect->deviceTransform(view.viewportTransform())
+                                           .mapRect(expectedItemBoundingRect).toAlignedRect();
+    if (antialiasing)
+        expectedItemDeviceBoundingRect.adjust(-2, -2, 2, 2);
+    else
+        expectedItemDeviceBoundingRect.adjust(-1, -1, 1, 1);
+    const QRegion expectedUpdateRegion(expectedItemDeviceBoundingRect);
+
+    // Reset.
+    rect->numPaints = 0;
+    view.lastUpdateRegions.clear();
+    view.painted = false;
+
+    rect->update();
+    QTRY_VERIFY(view.painted);
+
+#ifndef Q_OS_MAC //cocoa doesn't support drawing regions
+    QTRY_VERIFY(view.painted);
+    QCOMPARE(view.lastUpdateRegions.size(), 1);
+    QCOMPARE(view.lastUpdateRegions.at(0), expectedUpdateRegion);
+#endif
+}
+
+void tst_QGraphicsView::update_ancestorClipsChildrenToShape()
+{
+    QGraphicsScene scene(-150, -150, 300, 300);
+
+    /*
+    Add three rects:
+
+    +------------------+
+    | child            |
+    | +--------------+ |
+    | | parent       | |
+    | |  +-----------+ |
+    | |  |grandParent| |
+    | |  +-----------+ |
+    | +--------------+ |
+    +------------------+
+
+    ... where both the parent and the grand parent clips children to shape.
+    */
+    QApplication::processEvents(); // Get rid of pending update.
+
+    QGraphicsRectItem *grandParent = static_cast<QGraphicsRectItem *>(scene.addRect(0, 0, 50, 50));
+    grandParent->setBrush(Qt::black);
+    grandParent->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+
+    QGraphicsRectItem *parent = static_cast<QGraphicsRectItem *>(scene.addRect(-50, -50, 100, 100));
+    parent->setBrush(QColor(0, 0, 255, 125));
+    parent->setParentItem(grandParent);
+    parent->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+
+    QGraphicsRectItem *child = static_cast<QGraphicsRectItem *>(scene.addRect(-100, -100, 200, 200));
+    child->setBrush(QColor(255, 0, 0, 125));
+    child->setParentItem(parent);
+
+    CustomView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(view.painted);
+
+    view.lastUpdateRegions.clear();
+    view.painted = false;
+
+    // Call child->update() and make sure the updated area is within the ancestors' clip.
+    QRectF expected = child->deviceTransform(view.viewportTransform()).mapRect(child->boundingRect());
+    expected &= grandParent->deviceTransform(view.viewportTransform()).mapRect(grandParent->boundingRect());
+
+    child->update();
+    QTRY_VERIFY(view.painted);
+
+#ifndef Q_OS_MAC //cocoa doesn't support drawing regions
+    QTRY_VERIFY(view.painted);
+    QCOMPARE(view.lastUpdateRegions.size(), 1);
+    QCOMPARE(view.lastUpdateRegions.at(0), QRegion(expected.toAlignedRect()));
+#endif
+}
+
+void tst_QGraphicsView::update_ancestorClipsChildrenToShape2()
+{
+    QGraphicsScene scene(-150, -150, 300, 300);
+
+    /*
+    Add two rects:
+
+    +------------------+
+    | child            |
+    | +--------------+ |
+    | | parent       | |
+    | |              | |
+    | |              | |
+    | |              | |
+    | +--------------+ |
+    +------------------+
+
+    ... where the parent has no contents and clips the child to shape.
+    */
+    QApplication::processEvents(); // Get rid of pending update.
+
+    QGraphicsRectItem *parent = static_cast<QGraphicsRectItem *>(scene.addRect(-50, -50, 100, 100));
+    parent->setBrush(QColor(0, 0, 255, 125));
+    parent->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+    parent->setFlag(QGraphicsItem::ItemHasNoContents);
+
+    QGraphicsRectItem *child = static_cast<QGraphicsRectItem *>(scene.addRect(-100, -100, 200, 200));
+    child->setBrush(QColor(255, 0, 0, 125));
+    child->setParentItem(parent);
+
+    CustomView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_VERIFY(view.painted);
+
+    view.lastUpdateRegions.clear();
+    view.painted = false;
+
+    // Call child->update() and make sure the updated area is within its parent's clip.
+    QRectF expected = child->deviceTransform(view.viewportTransform()).mapRect(child->boundingRect());
+    expected &= parent->deviceTransform(view.viewportTransform()).mapRect(parent->boundingRect());
+
+    child->update();
+    QTRY_VERIFY(view.painted);
+
+#ifndef Q_OS_MAC //cocoa doesn't support drawing regions
+    QTRY_VERIFY(view.painted);
+    QCOMPARE(view.lastUpdateRegions.size(), 1);
+    QCOMPARE(view.lastUpdateRegions.at(0), QRegion(expected.toAlignedRect()));
+#endif
+
+    QTest::qWait(50);
+
+    view.lastUpdateRegions.clear();
+    view.painted = false;
+
+    // Invalidate the parent's geometry and trigger an update.
+    // The update area should be clipped to the parent's bounding rect for 'normal' items,
+    // but in this case the item has no contents (ItemHasNoContents) and its geometry
+    // is invalidated, which means we cannot clip the child update. So, the expected
+    // area is exactly the same as the child's bounding rect (adjusted for antialiasing).
+    parent->setRect(parent->rect().adjusted(-10, -10, -10, -10));
+    expected = child->deviceTransform(view.viewportTransform()).mapRect(child->boundingRect());
+    expected.adjust(-2, -2, 2, 2); // Antialiasing
+
+#ifndef Q_OS_MAC //cocoa doesn't support drawing regions
+    QTRY_VERIFY(view.painted);
+    QCOMPARE(view.lastUpdateRegions.size(), 1);
+    QCOMPARE(view.lastUpdateRegions.at(0), QRegion(expected.toAlignedRect()));
+#endif
+}
+
+class FocusItem : public QGraphicsRectItem
+{
+public:
+    FocusItem() : QGraphicsRectItem(0, 0, 20, 20) {
+        m_viewHasIMEnabledInFocusInEvent = false;
+    }
+
+    void focusInEvent(QFocusEvent * /* event */)
+    {
+        QGraphicsView *view = scene()->views().first();
+        m_viewHasIMEnabledInFocusInEvent = view->testAttribute(Qt::WA_InputMethodEnabled);
+    }
+
+    bool m_viewHasIMEnabledInFocusInEvent;
+};
+
+void tst_QGraphicsView::inputMethodSensitivity()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QApplication::setActiveWindow(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&view));
+
+    FocusItem *item = new FocusItem;
+
+    view.setAttribute(Qt::WA_InputMethodEnabled, true);
+
+    scene.addItem(item);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), false);
+
+    scene.removeItem(item);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), false);
+
+    item->setFlag(QGraphicsItem::ItemAcceptsInputMethod);
+    scene.addItem(item);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), false);
+
+    scene.removeItem(item);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), false);
+
+    scene.addItem(item);
+    scene.setFocusItem(item);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), false);
+
+    scene.removeItem(item);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), false);
+
+    item->setFlag(QGraphicsItem::ItemIsFocusable);
+    scene.addItem(item);
+    scene.setFocusItem(item);
+    QCOMPARE(scene.focusItem(), static_cast<QGraphicsItem *>(item));
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), true);
+    QCOMPARE(item->m_viewHasIMEnabledInFocusInEvent, true);
+
+    item->setFlag(QGraphicsItem::ItemAcceptsInputMethod, false);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), false);
+
+    item->setFlag(QGraphicsItem::ItemAcceptsInputMethod, true);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), true);
+
+    // introduce another item that is focusable but does not accept input methods
+    FocusItem *item2 = new FocusItem;
+    item2->setFlag(QGraphicsItem::ItemIsFocusable);
+    scene.addItem(item2);
+    scene.setFocusItem(item2);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), false);
+    QCOMPARE(item2->m_viewHasIMEnabledInFocusInEvent, false);
+    QCOMPARE(scene.focusItem(), static_cast<QGraphicsItem *>(item2));
+
+    scene.setFocusItem(item);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), true);
+    QCOMPARE(item->m_viewHasIMEnabledInFocusInEvent, true);
+    QCOMPARE(scene.focusItem(), static_cast<QGraphicsItem *>(item));
+
+    view.setScene(0);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), false);
+    QCOMPARE(scene.focusItem(), static_cast<QGraphicsItem *>(item));
+
+    view.setScene(&scene);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), true);
+    QCOMPARE(item->m_viewHasIMEnabledInFocusInEvent, true);
+    QCOMPARE(scene.focusItem(), static_cast<QGraphicsItem *>(item));
+
+    scene.setFocusItem(item2);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), false);
+    QCOMPARE(item2->m_viewHasIMEnabledInFocusInEvent, false);
+    QCOMPARE(scene.focusItem(), static_cast<QGraphicsItem *>(item2));
+
+    view.setScene(0);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), false);
+    QCOMPARE(scene.focusItem(), static_cast<QGraphicsItem *>(item2));
+
+    scene.setFocusItem(item);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), false);
+    QCOMPARE(scene.focusItem(), static_cast<QGraphicsItem *>(item));
+
+    view.setScene(&scene);
+    QCOMPARE(view.testAttribute(Qt::WA_InputMethodEnabled), true);
+    QCOMPARE(item->m_viewHasIMEnabledInFocusInEvent, true);
+    QCOMPARE(scene.focusItem(), static_cast<QGraphicsItem *>(item));
+}
+
+class InputContextTester : public QInputContext
+{
+    Q_OBJECT
+public:
+    QString identifierName() { return QString(); }
+    bool isComposing() const { return false; }
+    QString language() { return QString(); }
+    void reset() { ++resets; }
+    int resets;
+};
+
+void tst_QGraphicsView::inputContextReset()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QVERIFY(view.testAttribute(Qt::WA_InputMethodEnabled));
+
+    InputContextTester *inputContext = new InputContextTester;
+    qApp->setInputContext(inputContext);
+
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QApplication::setActiveWindow(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&view));
+
+    QGraphicsItem *item1 = new QGraphicsRectItem;
+    item1->setFlags(QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemAcceptsInputMethod);
+
+    inputContext->resets = 0;
+    scene.addItem(item1);
+    QCOMPARE(inputContext->resets, 0);
+
+    inputContext->resets = 0;
+    scene.setFocusItem(item1);
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *)item1);
+    QVERIFY(view.testAttribute(Qt::WA_InputMethodEnabled));
+    QCOMPARE(inputContext->resets, 0);
+
+    inputContext->resets = 0;
+    scene.setFocusItem(0);
+    // the input context is reset twice, once because an item has lost focus and again because
+    // the Qt::WA_InputMethodEnabled flag is cleared because no item has focus.
+    QCOMPARE(inputContext->resets, 2);
+
+    // introduce another item that is focusable but does not accept input methods
+    QGraphicsItem *item2 = new QGraphicsRectItem;
+    item2->setFlags(QGraphicsItem::ItemIsFocusable);
+    scene.addItem(item2);
+
+    inputContext->resets = 0;
+    scene.setFocusItem(item2);
+    QCOMPARE(inputContext->resets, 0);
+
+    inputContext->resets = 0;
+    scene.setFocusItem(item1);
+    QCOMPARE(inputContext->resets, 0);
+
+    // test changing between between items that accept input methods.
+    item2->setFlags(QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemAcceptsInputMethod);
+    scene.setFocusItem(item2);
+    QCOMPARE(inputContext->resets, 1);
+}
+
+void tst_QGraphicsView::indirectPainting()
+{
+    class MyScene : public QGraphicsScene
+    { public:
+        MyScene() : QGraphicsScene(), drawCount(0) {}
+        void drawItems(QPainter *, int, QGraphicsItem **, const QStyleOptionGraphicsItem *, QWidget *)
+        { ++drawCount; }
+        int drawCount;
+    };
+
+    MyScene scene;
+    QGraphicsItem *item = scene.addRect(0, 0, 50, 50);
+
+    QGraphicsView view(&scene);
+    view.setOptimizationFlag(QGraphicsView::IndirectPainting);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTest::qWait(100);
+
+    scene.drawCount = 0;
+    item->setPos(20, 20);
+    QApplication::processEvents();
+    QTRY_VERIFY(scene.drawCount > 0);
+}
+
+void tst_QGraphicsView::compositionModeInDrawBackground()
+{
+    class MyView : public QGraphicsView
+    { public:
+        MyView(QGraphicsScene *scene) : QGraphicsView(scene),
+        painted(false), compositionMode(QPainter::CompositionMode_SourceOver) {}
+        bool painted;
+        QPainter::CompositionMode compositionMode;
+        void drawBackground(QPainter *painter, const QRectF &)
+        {
+            compositionMode = painter->compositionMode();
+            painted = true;
+        }
+    };
+
+    QGraphicsScene dummy;
+    MyView view(&dummy);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Make sure the painter's composition mode is SourceOver in drawBackground.
+    QTRY_VERIFY(view.painted);
+    QCOMPARE(view.compositionMode, QPainter::CompositionMode_SourceOver);
+
+    view.painted = false;
+    view.setCacheMode(QGraphicsView::CacheBackground);
+    view.viewport()->update();
+
+    // Make sure the painter's composition mode is SourceOver in drawBackground
+    // with background cache enabled.
+    QTRY_VERIFY(view.painted);
+    QCOMPARE(view.compositionMode, QPainter::CompositionMode_SourceOver);
+}
+void tst_QGraphicsView::task253415_reconnectUpdateSceneOnSceneChanged()
+{
+    QGraphicsView view;
+    QGraphicsView dummyView;
+    view.setWindowFlags(view.windowFlags() | Qt::WindowStaysOnTopHint);
+    view.resize(200, 200);
+
+    QGraphicsScene scene1;
+    QObject::connect(&scene1, SIGNAL(changed(QList<QRectF>)), &dummyView, SLOT(updateScene(QList<QRectF>)));
+    view.setScene(&scene1);
+
+    QTest::qWait(12);
+
+    QGraphicsScene scene2;
+    QObject::connect(&scene2, SIGNAL(changed(QList<QRectF>)), &dummyView, SLOT(updateScene(QList<QRectF>)));
+    view.setScene(&scene2);
+
+    QTest::qWait(12);
+
+    bool wasConnected2 = QObject::disconnect(&scene2, SIGNAL(changed(QList<QRectF>)), &view, 0);
+    QVERIFY(wasConnected2);
+}
+
+// Qt/CE does not implement mouse tracking at this point.
+#ifndef Q_OS_WINCE
+void tst_QGraphicsView::task255529_transformationAnchorMouseAndViewportMargins()
+{
+    QGraphicsScene scene(-100, -100, 200, 200);
+    scene.addRect(QRectF(-50, -50, 100, 100), QPen(Qt::black), QBrush(Qt::blue));
+
+    class VpGraphicsView: public QGraphicsView
+    {
+    public:
+        VpGraphicsView(QGraphicsScene *scene, QWidget *parent=0)
+            : QGraphicsView(scene, parent)
+        {
+            setViewportMargins(8, 16, 12, 20);
+            setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
+            setMouseTracking(true);
+        }
+    };
+
+    VpGraphicsView view(&scene);
+    view.setWindowFlags(Qt::X11BypassWindowManagerHint);
+    view.show();
+
+    QTest::qWaitForWindowShown(&view);
+    QTest::qWait(50);
+    QPoint mouseViewPos(20, 20);
+    sendMouseMove(view.viewport(), mouseViewPos);
+
+    QPointF mouseScenePos = view.mapToScene(mouseViewPos);
+    view.setTransform(QTransform().scale(5, 5).rotate(5, Qt::ZAxis), true);
+
+    QPointF newMouseScenePos = view.mapToScene(mouseViewPos);
+
+    qreal slack = 1;
+    QVERIFY(qAbs(newMouseScenePos.x() - mouseScenePos.x()) < slack);
+    QVERIFY(qAbs(newMouseScenePos.y() - mouseScenePos.y()) < slack);
+}
+#endif
+
+void tst_QGraphicsView::task259503_scrollingArtifacts()
+{
+    QGraphicsScene scene(0, 0, 800, 600);
+
+    QGraphicsRectItem card;
+    card.setRect(0, 0, 50, 50);
+    card.setPen(QPen(Qt::darkRed));
+    card.setBrush(QBrush(Qt::cyan));
+    card.setZValue(2.0);
+    card.setPos(300, 300);
+    scene.addItem(&card);
+
+    class SAGraphicsView: public QGraphicsView
+    {
+    public:
+        SAGraphicsView(QGraphicsScene *scene)
+            : QGraphicsView(scene)
+            , itSTimeToTest(false)
+        {
+            setViewportUpdateMode( QGraphicsView::MinimalViewportUpdate );
+            resize(QSize(640, 480));
+        }
+
+        QRegion updateRegion;
+        bool itSTimeToTest;
+
+        void paintEvent(QPaintEvent *event)
+        {
+            QGraphicsView::paintEvent(event);
+
+            if (itSTimeToTest)
+            {
+//                qDebug() << event->region();
+//                qDebug() << updateRegion;
+                QEXPECT_FAIL("", "The event region doesn't include the original item position region. See QTBUG-4416", Continue);
+                QCOMPARE(event->region(), updateRegion);
+            }
+        }
+    };
+
+    SAGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    int hsbValue = view.horizontalScrollBar()->value();
+    view.horizontalScrollBar()->setValue(hsbValue / 2);
+    QTest::qWait(10);
+    view.horizontalScrollBar()->setValue(0);
+    QTest::qWait(10);
+
+    QRect itemDeviceBoundingRect = card.deviceTransform(view.viewportTransform()).mapRect(card.boundingRect()).toRect();
+    itemDeviceBoundingRect.adjust(-2, -2, 2, 2);
+    view.updateRegion = itemDeviceBoundingRect;
+    view.updateRegion += itemDeviceBoundingRect.translated(-100, 0);
+    view.itSTimeToTest = true;
+    card.setPos(200, 300);
+    QTest::qWait(10);
+}
+
+void tst_QGraphicsView::QTBUG_4151_clipAndIgnore_data()
+{
+    QTest::addColumn<bool>("clip");
+    QTest::addColumn<bool>("ignoreTransformations");
+    QTest::addColumn<int>("numItems");
+
+    QTest::newRow("none") << false << false << 3;
+    QTest::newRow("clip") << true << false << 3;
+    QTest::newRow("ignore") << false << true << 3;
+    QTest::newRow("clip+ignore") << true << true << 3;
+}
+
+void tst_QGraphicsView::QTBUG_4151_clipAndIgnore()
+{
+    QFETCH(bool, clip);
+    QFETCH(bool, ignoreTransformations);
+    QFETCH(int, numItems);
+
+    QGraphicsScene scene;
+
+    QGraphicsRectItem *parent = new QGraphicsRectItem(QRectF(0, 0, 50, 50), 0);
+    QGraphicsRectItem *child = new QGraphicsRectItem(QRectF(-10, -10, 40, 40), parent);
+    QGraphicsRectItem *ignore = new QGraphicsRectItem(QRectF(60, 60, 50, 50), 0);
+
+    if (clip)
+        parent->setFlags(QGraphicsItem::ItemClipsChildrenToShape);
+    if (ignoreTransformations)
+        ignore->setFlag(QGraphicsItem::ItemIgnoresTransformations);
+
+    parent->setBrush(Qt::red);
+    child->setBrush(QColor(0, 0, 255, 128));
+    ignore->setBrush(Qt::green);
+
+    scene.addItem(parent);
+    scene.addItem(ignore);
+
+    QGraphicsView view(&scene);
+    view.setFrameStyle(0);
+    view.resize(75, 75);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    view.activateWindow();
+
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget *)&view);
+
+    QCOMPARE(view.items(view.rect()).size(), numItems);
+}
+
+void tst_QGraphicsView::QTBUG_5859_exposedRect()
+{
+    class CustomScene : public QGraphicsScene
+    {
+    public:
+        CustomScene(const QRectF &rect) : QGraphicsScene(rect) { }
+        void drawBackground(QPainter * /* painter */, const QRectF &rect)
+        { lastBackgroundExposedRect = rect; }
+        QRectF lastBackgroundExposedRect;
+    };
+
+    class CustomRectItem : public QGraphicsRectItem
+    {
+    public:
+        CustomRectItem(const QRectF &rect) : QGraphicsRectItem(rect)
+        { setFlag(QGraphicsItem::ItemUsesExtendedStyleOption); }
+        void paint(QPainter * /* painter */, const QStyleOptionGraphicsItem *option, QWidget * /* widget */ = 0)
+        { lastExposedRect = option->exposedRect; }
+        QRectF lastExposedRect;
+    };
+
+    CustomScene scene(QRectF(0,0,50,50));
+
+    CustomRectItem item(scene.sceneRect());
+
+    scene.addItem(&item);
+
+    QGraphicsView view(&scene);
+    if (PlatformQuirks::isAutoMaximizing())
+        view.setWindowFlags(view.windowFlags()|Qt::X11BypassWindowManagerHint);
+    view.scale(4.15, 4.15);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    view.viewport()->repaint(10,10,20,20);
+    QApplication::processEvents();
+
+    QCOMPARE(item.lastExposedRect, scene.lastBackgroundExposedRect);
+}
+
+// Qt/CE does not have regular cursor support.
+#if !defined(QT_NO_CURSOR) && !defined(Q_OS_WINCE)
+void tst_QGraphicsView::QTBUG_7438_cursor()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item = scene.addRect(QRectF(-10, -10, 20, 20));
+    item->setFlag(QGraphicsItem::ItemIsMovable);
+
+    QGraphicsView view(&scene);
+    view.setFixedSize(400, 400);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QCOMPARE(view.viewport()->cursor().shape(), QCursor().shape());
+    view.viewport()->setCursor(Qt::PointingHandCursor);
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
+    sendMouseMove(view.viewport(), view.mapFromScene(0, 0));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
+    sendMousePress(view.viewport(), view.mapFromScene(0, 0));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
+    sendMouseRelease(view.viewport(), view.mapFromScene(0, 0));
+    QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
+}
+#endif
+
+class GraphicsItemWithHover : public QGraphicsRectItem
+{
+public:
+    GraphicsItemWithHover()
+        : receivedEnterEvent(false), receivedLeaveEvent(false),
+          enterWidget(0), leaveWidget(0)
+    {
+        setRect(0, 0, 100, 100);
+        setAcceptHoverEvents(true);
+    }
+
+    bool sceneEvent(QEvent *event)
+    {
+        if (event->type() == QEvent::GraphicsSceneHoverEnter) {
+            receivedEnterEvent = true;
+            enterWidget = static_cast<QGraphicsSceneHoverEvent *>(event)->widget();
+        } else if (event->type() == QEvent::GraphicsSceneHoverLeave) {
+            receivedLeaveEvent = true;
+            leaveWidget = static_cast<QGraphicsSceneHoverEvent *>(event)->widget();
+        }
+        return QGraphicsRectItem::sceneEvent(event);
+    }
+
+    bool receivedEnterEvent;
+    bool receivedLeaveEvent;
+    QWidget *enterWidget;
+    QWidget *leaveWidget;
+};
+
+void tst_QGraphicsView::hoverLeave()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    GraphicsItemWithHover *item = new GraphicsItemWithHover;
+    scene.addItem(item);
+
+    // move the cursor out of the way
+    QCursor::setPos(1,1);
+
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QPoint pos = view.viewport()->mapToGlobal(view.mapFromScene(item->mapToScene(10, 10)));
+    QCursor::setPos(pos);
+    QTest::qWait(200);
+    QVERIFY(item->receivedEnterEvent);
+    QCOMPARE(item->enterWidget, view.viewport());
+
+    QCursor::setPos(1,1);
+    QTest::qWait(200);
+    QVERIFY(item->receivedLeaveEvent);
+    QCOMPARE(item->leaveWidget, view.viewport());
+}
+
+class IMItem : public QGraphicsRectItem
+{
+public:
+    IMItem(QGraphicsItem *parent = 0):
+        QGraphicsRectItem(QRectF(0, 0, 20, 20), parent)
+    {
+        setFlag(QGraphicsItem::ItemIsFocusable, true);
+        setFlag(QGraphicsItem::ItemAcceptsInputMethod, true);
+    }
+
+    QVariant inputMethodQuery(Qt::InputMethodQuery) const
+    {
+        return mf;
+    }
+
+    static QRectF mf;
+};
+
+QRectF IMItem::mf(1.5, 1.6, 10, 10);
+
+void tst_QGraphicsView::QTBUG_16063_microFocusRect()
+{
+    QGraphicsScene scene;
+    IMItem *item = new IMItem();
+    scene.addItem(item);
+
+    QGraphicsView view(&scene);
+
+    view.setFixedSize(40, 40);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    scene.setFocusItem(item);
+    view.setFocus();
+    QRectF mfv = view.inputMethodQuery(Qt::ImMicroFocus).toRectF();
+    QCOMPARE(mfv, IMItem::mf.translated(-view.mapToScene(view.sceneRect().toRect()).boundingRect().topLeft()));
+}
+
+QTEST_MAIN(tst_QGraphicsView)
+#include "tst_qgraphicsview.moc"
diff --git a/tests/auto/widgets/graphicsview/qgraphicsview/tst_qgraphicsview_2.cpp b/tests/auto/widgets/graphicsview/qgraphicsview/tst_qgraphicsview_2.cpp
new file mode 100644
index 0000000000..122ffbc875
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicsview/tst_qgraphicsview_2.cpp
@@ -0,0 +1,976 @@
+/****************************************************************************
+**
+** 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 <QSize>
+#include <QRectF>
+#include <QTransform>
+
+#ifdef Q_OS_WINCE
+#include <qguifunctions_wince.h>
+
+bool qt_wince_is_high_dpi() {
+    HDC deviceContext = GetDC(0);
+    int dpi = GetDeviceCaps(deviceContext, LOGPIXELSX);
+    ReleaseDC(0, deviceContext);
+    if ((dpi < 1000) && (dpi > 0))
+        return dpi > 96;
+    else
+        return false;
+}
+#endif
+
+Q_DECLARE_METATYPE(QList<int>)
+Q_DECLARE_METATYPE(QList<QRectF>)
+Q_DECLARE_METATYPE(QMatrix)
+Q_DECLARE_METATYPE(QPainterPath)
+Q_DECLARE_METATYPE(QPointF)
+Q_DECLARE_METATYPE(QRectF)
+Q_DECLARE_METATYPE(Qt::ScrollBarPolicy)
+
+static void _scrollBarRanges_data_1(int offset)
+{    
+    // No motif, flat frame
+    QTest::newRow("1") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform()
+                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                       << 0 << 0 << 0 << 0 << false << false;
+    QTest::newRow("2") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform()
+                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                       << 0 << (50 + offset) << 0 << offset  << false << false;
+    QTest::newRow("3") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform()
+                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                       << 0 << (50 + offset) << 0 << (100 + offset) << false << false;
+    QTest::newRow("4") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform()
+                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                       << 0 << 0 << 0 << 0 << false << false;
+    QTest::newRow("5") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform()
+                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                       << -100 << (offset -50) << -100 << (-100 + offset) << false << false;
+    QTest::newRow("6") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform()
+                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                       << -100 << (offset -50) << -100 << offset << false << false;
+    QTest::newRow("7") << QSize(150, 100) << QRectF(0, 0, 151, 101) << QTransform()
+                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                       << 0 << (offset + 1)  << 0 << offset + 1 << false << false;
+    QTest::newRow("8") << QSize(150, 100) << QRectF(0, 0, 201, 101) << QTransform()
+                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                       << 0 << (50 + offset + 1) << 0 << offset + 1 << false << false;
+    QTest::newRow("9") << QSize(150, 100) << QRectF(0, 0, 201, 201) << QTransform()
+                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                       << 0 << (50 + offset + 1) << 0 << (100 + offset + 1) << false << false;
+    QTest::newRow("10") << QSize(150, 100) << QRectF(-101, -101, 151, 101) << QTransform()
+                        << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                        << -101 << (-100 + offset) << -101 << (-100 + offset) << false << false;
+    QTest::newRow("11") << QSize(150, 100) << QRectF(-101, -101, 201, 101) << QTransform()
+                        << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                        << (-101) << (offset + -50) << -101 << (-100 + offset) << false << false;
+    QTest::newRow("12") << QSize(150, 100) << QRectF(-101, -101, 201, 201) << QTransform()
+                        << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                        << (-101) << (offset -50) << (-101) << offset << false << false;
+    QTest::newRow("13") << QSize(150, 100) << QRectF(0, 0, 166, 116) << QTransform()
+                        << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                        << 0 << (offset + 16) << 0 << (offset + 16) << false << false;
+    QTest::newRow("14") << QSize(150, 100) << QRectF(0, 0, 216, 116) << QTransform()
+                        << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                        << 0 << (50 + offset + 16) << 0 << (offset + 16) << false << false;
+    QTest::newRow("15") << QSize(150, 100) << QRectF(0, 0, 216, 216) << QTransform()
+                        << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                        << 0 << (50 + offset + 16) << 0 << (100 + offset + 16) << false << false;
+    QTest::newRow("16") << QSize(150, 100) << QRectF(-116, -116, 166, 116) << QTransform()
+                        << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                        << (-100 - 16) << (-100 + offset) << (-100 - 16 ) << (-100 + offset) << false << false;
+    QTest::newRow("17") << QSize(150, 100) << QRectF(-116, -116, 216, 116) << QTransform()
+                        << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                        << (-100 - 16) << (offset -50) << (-100 - 16) << (-100 + offset) << false << false;
+    QTest::newRow("18") << QSize(150, 100) << QRectF(-116, -116, 216, 216) << QTransform()
+                        << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                        << (-100 - 16) << (offset -50) << (-100 - 16) << offset << false << false;
+    QTest::newRow("1 x2") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform().scale(2, 2)
+                          << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                          << 0 << (150 + offset) << 0 << (100 + offset) << false << false;
+    QTest::newRow("2 x2") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform().scale(2, 2)
+                          << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                          << 0 << (250 + offset) << 0 << (100 + offset) << false << false;
+    QTest::newRow("3 x2") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform().scale(2, 2)
+                          << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                          << 0 << (250 + offset) << 0 << (300 + offset) << false << false;
+    QTest::newRow("4 x2") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform().scale(2, 2)
+                          << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                          << -200 << (-50 + offset) << -200 << (-100 + offset) << false << false;
+    QTest::newRow("5 x2") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform().scale(2, 2)
+                          << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                          << -200 << (50 + offset) << -200 << (-100 + offset) << false << false;
+    QTest::newRow("6 x2") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform().scale(2, 2)
+                          << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                          << -200 << (50 + offset) << -200 << (100 + offset) << false << false;
+    QTest::newRow("1 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform()
+                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                     << 0 << 0 << 0 << 0 << false << false;
+    QTest::newRow("2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform()
+                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                     << 0 << 50 << 0 << 0 << false << false;
+    QTest::newRow("3 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform()
+                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                     << 0 << 50 << 0 << 100 << false << false;
+    QTest::newRow("4 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform()
+                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                     << 0 << 0 << 0 << 0 << false << false;
+    QTest::newRow("5 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform()
+                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                     << -100 << -50 << 0 << 0 << false << false;
+    QTest::newRow("6 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform()
+                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                     << -100 << -50 << -100 << 0 << false << false;
+    QTest::newRow("7 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 151, 101) << QTransform()
+                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                     << 0 << 1 << 0 << 1 << false << false;
+    QTest::newRow("8 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 101) << QTransform()
+                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                     << 0 << 51 << 0 << 1 << false << false;
+    QTest::newRow("9 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 201) << QTransform()
+                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                     << 0 << 51 << 0 << 101 << false << false;
+    QTest::newRow("10 No ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 151, 101) << QTransform()
+                                      << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                      << -101 << -100 << -101 << -100 << false << false;
+    QTest::newRow("11 No ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 101) << QTransform()
+                                      << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                      << -101 << -50 << -101 << -100 << false << false;
+    QTest::newRow("12 No ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 201) << QTransform()
+                                      << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                      << -101 << -50 << -101 << 0 << false << false;
+    QTest::newRow("13 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 166, 116) << QTransform()
+                                      << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                      << 0 << 16 << 0 << 16 << false << false;
+    QTest::newRow("14 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 116) << QTransform()
+                                      << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                      << 0 << (50 + 16) << 0 << 16 << false << false;
+    QTest::newRow("15 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 216) << QTransform()
+                                      << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                      << 0 << (50 + 16) << 0 << (100 + 16) << false << false;
+    QTest::newRow("16 No ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 166, 116) << QTransform()
+                                      << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                      << (-100 - 16) << -100 << (-100 - 16) << -100 << false << false;
+    QTest::newRow("17 No ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 116) << QTransform()
+                                      << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                      << (-100 - 16) << -50 << (-100 - 16) << -100 << false << false;
+    QTest::newRow("18 No ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 216) << QTransform()
+                                      << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                      << (-100 - 16) << -50 << (-100 - 16) << 0 << false << false;
+    QTest::newRow("1 x2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform().scale(2, 2)
+                                        << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                        << 0 << 150 << 0 << 100 << false << false;
+    QTest::newRow("2 x2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform().scale(2, 2)
+                                        << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                        << 0 << 250 << 0 << 100 << false << false;
+    QTest::newRow("3 x2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform().scale(2, 2)
+                                        << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                        << 0 << 250 << 0 << 300 << false << false;
+    QTest::newRow("4 x2 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform().scale(2, 2)
+                                        << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                        << -200 << -50 << -200 << -100 << false << false;
+    QTest::newRow("5 x2 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform().scale(2, 2)
+                                        << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                        << -200 << 50 << -200 << -100 << false << false;
+    QTest::newRow("6 x2 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform().scale(2, 2)
+                                        << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                        << -200 << 50 << -200 << 100 << false << false;
+    QTest::newRow("1 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform()
+                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                         << 0 << 16 << 0 << 16 << false << false;
+    QTest::newRow("2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform()
+                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                         << 0 << (50 + 16) << 0 << 16 << false << false;
+    QTest::newRow("3 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform()
+                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                         << 0 << (50 + 16) << 0 << (100 + 16) << false << false;
+    QTest::newRow("4 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform()
+                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                         << -100 << (-100 + 16) << -100 << (-100 + 16) << false << false;
+    QTest::newRow("5 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform()
+                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                         << -100 << (16-50) << -100 << (-100 + 16) << false << false;
+    QTest::newRow("6 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform()
+                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                         << -100 << (16-50) << -100 << 16 << false << false;
+    QTest::newRow("7 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 151, 101) << QTransform()
+                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                         << 0 << 17 << 0 << 17 << false << false;
+    QTest::newRow("8 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 101) << QTransform()
+                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                         << 0 << (17+50) << 0 << 17 << false << false;
+    QTest::newRow("9 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 201) << QTransform()
+                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                         << 0 << 67 << 0 << 117 << false << false;
+    QTest::newRow("10 Always ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 151, 101) << QTransform()
+                                          << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                          << -101 << (-100 + 16) << -101 << (-100 + 16) << false << false;
+    QTest::newRow("11 Always ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 101) << QTransform()
+                                          << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                          << -101 << (16-50) << -101 << (-100 + 16) << false << false;
+    QTest::newRow("12 Always ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 201) << QTransform()
+                                          << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                          << -101 << (16-50) << -101 << 16 << false << false;
+    QTest::newRow("13 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 166, 116) << QTransform()
+                                          << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                          << 0 << 32 << 0 << 32 << false << false;
+    QTest::newRow("14 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 116) << QTransform()
+                                          << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                          << 0 << (50 + 32) << 0 << 32 << false << false;
+    QTest::newRow("15 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 216) << QTransform()
+                                          << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                          << 0 << (50 + 32) << 0 << (100 + 32) << false << false;
+    QTest::newRow("16 Always ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 166, 116) << QTransform()
+                                          << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                          << (-100 - 16) << (-100 + 16) << (-100 - 16) << (-100 + 16) << false << false;
+    QTest::newRow("17 Always ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 116) << QTransform()
+                                          << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                          << (-100 - 16) << (16-50) << (-100 - 16) << (-100 + 16) << false << false;
+    QTest::newRow("18 Always ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 216) << QTransform()
+                                          << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                          << (-100 - 16) << (16-50) << (-100 - 16) << 16 << false << false;
+    QTest::newRow("1 x2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform().scale(2, 2)
+                                            << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                            << 0 << (150 + 16) << 0 << (100 + 16) << false << false;
+    QTest::newRow("2 x2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform().scale(2, 2)
+                                            << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                            << 0 << (250 + 16) << 0 << (100 + 16) << false << false;
+    QTest::newRow("3 x2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform().scale(2, 2)
+                                            << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                            << 0 << (250 + 16) << 0 << (300 + 16) << false << false;
+    QTest::newRow("4 x2 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform().scale(2, 2)
+                                            << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                            << -200 << (-50 + 16) << -200 << (-100 + 16) << false << false;
+    QTest::newRow("5 x2 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform().scale(2, 2)
+                                            << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                            << -200 << (50 + 16) << -200 << (-100 + 16) << false << false;
+    QTest::newRow("6 x2 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform().scale(2, 2)
+                                            << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                            << -200 << (50 + 16) << -200 << (100 + 16) << false << false;
+}
+
+static void _scrollBarRanges_data_2(int offset)
+{
+    // Motif, flat frame
+    QTest::newRow("Motif, 1") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform()
+                              << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                              << 0 << 0 << 0 << 0 << true << false;
+    QTest::newRow("Motif, 2") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform()
+                              << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                              << 0 << (50 + offset) << 0 << offset << true << false;
+    QTest::newRow("Motif, 3") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform()
+                              << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                              << 0 << (50 + offset) << 0 << (100 + offset) << true << false;
+    QTest::newRow("Motif, 4") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform()
+                              << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                              << 0 << 0 << 0 << 0 << true << false;
+    QTest::newRow("Motif, 5") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform()
+                              << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                              << -100 << (offset-50) << -100 << (-100 + offset) << true << false;
+    QTest::newRow("Motif, 6") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform()
+                              << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                              << -100 << (offset-50) << -100 << offset << true << false;
+    QTest::newRow("Motif, 7") << QSize(150, 100) << QRectF(0, 0, 151, 101) << QTransform()
+                              << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                              << 0 << offset + 1 << 0 << offset + 1 << true << false;
+    QTest::newRow("Motif, 8") << QSize(150, 100) << QRectF(0, 0, 201, 101) << QTransform()
+                              << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                              << 0 << (50 + offset + 1) << 0 << offset + 1 << true << false;
+    QTest::newRow("Motif, 9") << QSize(150, 100) << QRectF(0, 0, 201, 201) << QTransform()
+                              << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                              << 0 << (50 + offset + 1) << 0 << (100 + offset + 1) << true << false;
+    QTest::newRow("Motif, 10") << QSize(150, 100) << QRectF(-101, -101, 151, 101) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << -101 << (-100 + offset) << -101 << (-100 + offset) << true << false;
+    QTest::newRow("Motif, 11") << QSize(150, 100) << QRectF(-101, -101, 201, 101) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << (-101) << (offset-50) << -101 << (-100 + offset) << true << false;
+    QTest::newRow("Motif, 12") << QSize(150, 100) << QRectF(-101, -101, 201, 201) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << (-101) << (offset-50) << (-101) << offset << true << false;
+    QTest::newRow("Motif, 13") << QSize(150, 100) << QRectF(0, 0, 166, 116) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << 0 << (offset + 16) << 0 << (offset + 16) << true << false;
+    QTest::newRow("Motif, 14") << QSize(150, 100) << QRectF(0, 0, 216, 116) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << 0 << (50 + offset + 16) << 0 << (offset + 16) << true << false;
+    QTest::newRow("Motif, 15") << QSize(150, 100) << QRectF(0, 0, 216, 216) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << 0 << (50 + offset + 16) << 0 << (100 + offset + 16) << true << false;
+    QTest::newRow("Motif, 16") << QSize(150, 100) << QRectF(-116, -116, 166, 116) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << (-100 - 16) << (-100 + offset) << (-100 - 16) << (-100 + offset) << true << false;
+    QTest::newRow("Motif, 17") << QSize(150, 100) << QRectF(-116, -116, 216, 116) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << (-100 - 16) << (offset-50) << (-100 - 16) << (-100 + offset) << true << false;
+    QTest::newRow("Motif, 18") << QSize(150, 100) << QRectF(-116, -116, 216, 216) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << (-100 - 16) << (offset-50) << (-100 - 16) << offset << true << false;
+    QTest::newRow("Motif, 1 x2") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform().scale(2, 2)
+                                 << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                 << 0 << (150 + offset) << 0 << (100 + offset) << true << false;
+    QTest::newRow("Motif, 2 x2") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform().scale(2, 2)
+                                 << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                 << 0 << (250 + offset) << 0 << (100 + offset) << true << false;
+    QTest::newRow("Motif, 3 x2") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform().scale(2, 2)
+                                 << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                 << 0 << (250 + offset) << 0 << (300 + offset) << true << false;
+    QTest::newRow("Motif, 4 x2") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform().scale(2, 2)
+                                 << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                 << -200 << (-50 + offset) << -200 << (-100 + offset) << true << false;
+    QTest::newRow("Motif, 5 x2") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform().scale(2, 2)
+                                 << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                 << -200 << (50 + offset) << -200 << (-100 + offset) << true << false;
+    QTest::newRow("Motif, 6 x2") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform().scale(2, 2)
+                                 << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                 << -200 << (50 + offset) << -200 << (100 + offset) << true << false;
+    QTest::newRow("Motif, 1 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform()
+                                            << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                            << 0 << 0 << 0 << 0 << true << false;
+    QTest::newRow("Motif, 2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform()
+                                            << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                            << 0 << 50 << 0 << 0 << true << false;
+    QTest::newRow("Motif, 3 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform()
+                                            << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                            << 0 << 50 << 0 << 100 << true << false;
+    QTest::newRow("Motif, 4 No ScrollBars") << QSize(100, 100) << QRectF(-100, -100, 100, 100) << QTransform()
+                                            << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                            << 0 << 0 << 0 << 0 << true << false;
+    QTest::newRow("Motif, 5 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform()
+                                            << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                            << -100 << -50 << 0 << 0 << true << false;
+    QTest::newRow("Motif, 6 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform()
+                                            << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                            << -100 << -50 << -100 << 0 << true << false;
+    QTest::newRow("Motif, 7 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 151, 101) << QTransform()
+                                            << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                            << 0 << 1 << 0 << 1 << true << false;
+    QTest::newRow("Motif, 8 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 101) << QTransform()
+                                            << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                            << 0 << 51 << 0 << 1 << true << false;
+    QTest::newRow("Motif, 9 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 201) << QTransform()
+                                            << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                            << 0 << 51 << 0 << 101 << true << false;
+    QTest::newRow("Motif, 10 No ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 151, 101) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << -101 << -100 << -101 << -100 << true << false;
+    QTest::newRow("Motif, 11 No ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 101) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << -101 << -50 << -101 << -100 << true << false;
+    QTest::newRow("Motif, 12 No ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 201) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << -101 << -50 << -101 << 0 << true << false;
+    QTest::newRow("Motif, 13 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 166, 116) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << 0 << 16 << 0 << 16 << true << false;
+    QTest::newRow("Motif, 14 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 116) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << 0 << (50 + 16) << 0 << 16 << true << false;
+    QTest::newRow("Motif, 15 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 216) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << 0 << (50 + 16) << 0 << (100 + 16) << true << false;
+    QTest::newRow("Motif, 16 No ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 166, 116) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << (-100 - 16) << -100 << (-100 - 16) << -100 << true << false;
+    QTest::newRow("Motif, 17 No ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 116) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << (-100 - 16) << -50 << (-100 - 16) << -100 << true << false;
+    QTest::newRow("Motif, 18 No ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 216) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << (-100 - 16) << -50 << (-100 - 16) << 0 << true << false;
+    QTest::newRow("Motif, 1 x2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform().scale(2, 2)
+                                               << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                               << 0 << 150 << 0 << 100 << true << false;
+    QTest::newRow("Motif, 2 x2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform().scale(2, 2)
+                                               << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                               << 0 << 250 << 0 << 100 << true << false;
+    QTest::newRow("Motif, 3 x2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform().scale(2, 2)
+                                               << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                               << 0 << 250 << 0 << 300 << true << false;
+    QTest::newRow("Motif, 4 x2 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform().scale(2, 2)
+                                               << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                               << -200 << -50 << -200 << -100 << true << false;
+    QTest::newRow("Motif, 5 x2 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform().scale(2, 2)
+                                               << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                               << -200 << 50 << -200 << -100 << true << false;
+    QTest::newRow("Motif, 6 x2 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform().scale(2, 2)
+                                               << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                               << -200 << 50 << -200 << 100 << true << false;
+    QTest::newRow("Motif, 1 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform()
+                                                << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                << 0 << 16 << 0 << 16 << true << false;
+    QTest::newRow("Motif, 2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform()
+                                                << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                << 0 << (50 + 16) << 0 << 16 << true << false;
+    QTest::newRow("Motif, 3 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform()
+                                                << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                << 0 << (50 + 16) << 0 << (100 + 16) << true << false;
+    QTest::newRow("Motif, 4 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform()
+                                                << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                << -100 << (-100 + 16) << -100 << (-100 + 16) << true << false;
+    QTest::newRow("Motif, 5 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform()
+                                                << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                << -100 << (16-50) << -100 << (-100 + 16) << true << false;
+    QTest::newRow("Motif, 6 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform()
+                                                << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                << -100 << (16-50) << -100 << 16 << true << false;
+    QTest::newRow("Motif, 7 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 151, 101) << QTransform()
+                                                << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                << 0 << 17 << 0 << 17 << true << false;
+    QTest::newRow("Motif, 8 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 101) << QTransform()
+                                                << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                << 0 << (117-50) << 0 << 17 << true << false;
+    QTest::newRow("Motif, 9 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 201) << QTransform()
+                                                << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                << 0 << (117-50) << 0 << 117 << true << false;
+    QTest::newRow("Motif, 10 Always ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 151, 101) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << -101 << (-100 + 16) << -101 << (-100 + 16) << true << false;
+    QTest::newRow("Motif, 11 Always ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 101) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << -101 << (16-50) << -101 << (-100 + 16) << true << false;
+    QTest::newRow("Motif, 12 Always ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 201) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << -101 << (16-50) << -101 << 16 << true << false;
+    QTest::newRow("Motif, 13 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 166, 116) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << 0 << 32 << 0 << 32 << true << false;
+    QTest::newRow("Motif, 14 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 116) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << 0 << (50 + 32) << 0 << 32 << true << false;
+    QTest::newRow("Motif, 15 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 216) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << 0 << (50 + 32) << 0 << (100 + 32) << true << false;
+    QTest::newRow("Motif, 16 Always ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 166, 116) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << (-100 - 16) << (-100 + 16) << (-100 - 16) << (-100 + 16) << true << false;
+    QTest::newRow("Motif, 17 Always ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 116) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << (-100 - 16) << (16-50) << (-100 - 16) << (-100 + 16) << true << false;
+    QTest::newRow("Motif, 18 Always ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 216) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << (-100 - 16) << (16-50) << (-100 - 16) << 16 << true << false;
+    QTest::newRow("Motif, 1 x2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform().scale(2, 2)
+                                                   << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                   << 0 << (150 + 16) << 0 << (100 + 16) << true << false;
+    QTest::newRow("Motif, 2 x2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform().scale(2, 2)
+                                                   << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                   << 0 << (250 + 16) << 0 << (100 + 16) << true << false;
+    QTest::newRow("Motif, 3 x2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform().scale(2, 2)
+                                                   << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                   << 0 << (250 + 16) << 0 << (300 + 16) << true << false;
+    QTest::newRow("Motif, 4 x2 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform().scale(2, 2)
+                                                   << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                   << -200 << (-50 + 16) << -200 << (-100 + 16) << true << false;
+    QTest::newRow("Motif, 5 x2 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform().scale(2, 2)
+                                                   << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                   << -200 << (50 + 16) << -200 << (-100 + 16) << true << false;
+    QTest::newRow("Motif, 6 x2 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform().scale(2, 2)
+                                                   << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                   << -200 << (50 + 16) << -200 << (100 + 16) << true << false;
+}
+
+static void _scrollBarRanges_data_3(int offset)
+{
+    // No motif, styled panel
+    QTest::newRow("Styled, 1") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << 0 << 0 << 0 << 0 << false << true;
+    QTest::newRow("Styled, 2") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << 0 << (50 + offset) << 0 << offset << false << true;
+    QTest::newRow("Styled, 3") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << 0 << (50 + offset) << 0 << (100 + offset) << false << true;
+    QTest::newRow("Styled, 4") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << 0 << 0 << 0 << 0 << false << true;
+    QTest::newRow("Styled, 5") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << -100 << (offset-50) << -100 << (-100 + offset) << false << true;
+    QTest::newRow("Styled, 6") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << -100 << (offset-50) << -100 << offset << false << true;
+    QTest::newRow("Styled, 7") << QSize(150, 100) << QRectF(0, 0, 151, 101) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << 0 << offset + 1 << 0 << offset + 1 << false << true;
+    QTest::newRow("Styled, 8") << QSize(150, 100) << QRectF(0, 0, 201, 101) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << 0 << (50 + offset + 1) << 0 << offset + 1 << false << true;
+    QTest::newRow("Styled, 9") << QSize(150, 100) << QRectF(0, 0, 201, 201) << QTransform()
+                               << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                               << 0 << (50 + offset + 1) << 0 << (100 + offset + 1) << false << true;
+    QTest::newRow("Styled, 10") << QSize(150, 100) << QRectF(-101, -101, 151, 101) << QTransform()
+                                << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                << -101 << (-100 + offset) << -101 << (-100 + offset) << false << true;
+    QTest::newRow("Styled, 11") << QSize(150, 100) << QRectF(-101, -101, 201, 101) << QTransform()
+                                << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                << (-101) << (offset-50) << -101 << (-100 + offset) << false << true;
+    QTest::newRow("Styled, 12") << QSize(150, 100) << QRectF(-101, -101, 201, 201) << QTransform()
+                                << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                << (-101) << (offset-50) << (-101) << offset << false << true;
+    QTest::newRow("Styled, 13") << QSize(150, 100) << QRectF(0, 0, 166, 116) << QTransform()
+                                << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                << 0 << (offset + 16) << 0 << (offset + 16) << false << true;
+    QTest::newRow("Styled, 14") << QSize(150, 100) << QRectF(0, 0, 216, 116) << QTransform()
+                                << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                << 0 << (50 + offset + 16) << 0 << (offset + 16) << false << true;
+    QTest::newRow("Styled, 15") << QSize(150, 100) << QRectF(0, 0, 216, 216) << QTransform()
+                                << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                << 0 << (50 + offset + 16) << 0 << (100 + offset + 16) << false << true;
+    QTest::newRow("Styled, 16") << QSize(150, 100) << QRectF(-116, -116, 166, 116) << QTransform()
+                                << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                << (-100 - 16) << (-100 + offset) << (-100 - 16) << (-100 + offset) << false << true;
+    QTest::newRow("Styled, 17") << QSize(150, 100) << QRectF(-116, -116, 216, 116) << QTransform()
+                                << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                << (-100 - 16) << (offset-50) << (-100 - 16) << (-100 + offset) << false << true;
+    QTest::newRow("Styled, 18") << QSize(150, 100) << QRectF(-116, -116, 216, 216) << QTransform()
+                                << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                << (-100 - 16) << (offset-50) << (-100 - 16) << offset << false << true;
+    QTest::newRow("Styled, 1 x2") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform().scale(2, 2)
+                                  << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                  << 0 << (150 + offset) << 0 << (100 + offset) << false << true;
+    QTest::newRow("Styled, 2 x2") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform().scale(2, 2)
+                                  << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                  << 0 << (250 + offset) << 0 << (100 + offset) << false << true;
+    QTest::newRow("Styled, 3 x2") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform().scale(2, 2)
+                                  << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                  << 0 << (250 + offset) << 0 << (300 + offset) << false << true;
+    QTest::newRow("Styled, 4 x2") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform().scale(2, 2)
+                                  << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                  << -200 << (-50 + offset) << -200 << (-100 + offset) << false << true;
+    QTest::newRow("Styled, 5 x2") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform().scale(2, 2)
+                                  << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                  << -200 << (50 + offset) << -200 << (-100 + offset) << false << true;
+    QTest::newRow("Styled, 6 x2") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform().scale(2, 2)
+                                  << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                  << -200 << (50 + offset) << -200 << (100 + offset) << false << true;
+    QTest::newRow("Styled, 1 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << 0 << 0 << 0 << 0 << false << true;
+    QTest::newRow("Styled, 2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << 0 << 50 << 0 << 0 << false << true;
+    QTest::newRow("Styled, 3 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << 0 << 50 << 0 << 100 << false << true;
+    QTest::newRow("Styled, 4 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << 0 << 0 << 0 << 0 << false << true;
+    QTest::newRow("Styled, 5 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << -100 << -50 << 0 << 0 << false << true;
+    QTest::newRow("Styled, 6 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << -100 << -50 << -100 << 0 << false << true;
+    QTest::newRow("Styled, 7 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 151, 101) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << 0 << 1 << 0 << 1 << false << true;
+    QTest::newRow("Styled, 8 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 101) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << 0 << 51 << 0 << 1 << false << true;
+    QTest::newRow("Styled, 9 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 201) << QTransform()
+                                             << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                             << 0 << 51 << 0 << 101 << false << true;
+    QTest::newRow("Styled, 10 No ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 151, 101) << QTransform()
+                                              << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                              << -101 << -100 << -101 << -100 << false << true;
+    QTest::newRow("Styled, 11 No ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 101) << QTransform()
+                                              << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                              << -101 << -50 << -101 << -100 << false << true;
+    QTest::newRow("Styled, 12 No ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 201) << QTransform()
+                                              << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                              << -101 << -50 << -101 << 0 << false << true;
+    QTest::newRow("Styled, 13 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 166, 116) << QTransform()
+                                              << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                              << 0 << 16 << 0 << 16 << false << true;
+    QTest::newRow("Styled, 14 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 116) << QTransform()
+                                              << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                              << 0 << (50 + 16) << 0 << 16 << false << true;
+    QTest::newRow("Styled, 15 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 216) << QTransform()
+                                              << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                              << 0 << (50 + 16) << 0 << (100 + 16) << false << true;
+    QTest::newRow("Styled, 16 No ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 166, 116) << QTransform()
+                                              << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                              << (-100 - 16) << -100 << (-100 - 16) << -100 << false << true;
+    QTest::newRow("Styled, 17 No ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 116) << QTransform()
+                                              << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                              << (-100 - 16) << -50 << (-100 - 16) << -100 << false << true;
+    QTest::newRow("Styled, 18 No ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 216) << QTransform()
+                                              << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                              << (-100 - 16) << -50 << (-100 - 16) << 0 << false << true;
+    QTest::newRow("Styled, 1 x2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform().scale(2, 2)
+                                                << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                << 0 << 150 << 0 << 100 << false << true;
+    QTest::newRow("Styled, 2 x2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform().scale(2, 2)
+                                                << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                << 0 << 250 << 0 << 100 << false << true;
+    QTest::newRow("Styled, 3 x2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform().scale(2, 2)
+                                                << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                << 0 << 250 << 0 << 300 << false << true;
+    QTest::newRow("Styled, 4 x2 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform().scale(2, 2)
+                                                << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                << -200 << -50 << -200 << -100 << false << true;
+    QTest::newRow("Styled, 5 x2 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform().scale(2, 2)
+                                                << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                << -200 << 50 << -200 << -100 << false << true;
+    QTest::newRow("Styled, 6 x2 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform().scale(2, 2)
+                                                << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                << -200 << 50 << -200 << 100 << false << true;
+    QTest::newRow("Styled, 1 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << 0 << 16 << 0 << 16 << false << true;
+    QTest::newRow("Styled, 2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << 0 << (50 + 16) << 0 << 16 << false << true;
+    QTest::newRow("Styled, 3 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << 0 << (50 + 16) << 0 << (100 + 16) << false << true;
+    QTest::newRow("Styled, 4 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << -100 << (-100 + 16) << -100 << (-100 + 16) << false << true;
+    QTest::newRow("Styled, 5 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << -100 << (16-50) << -100 << (-100 + 16) << false << true;
+    QTest::newRow("Styled, 6 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << -100 << (16-50) << -100 << 16 << false << true;
+    QTest::newRow("Styled, 7 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 151, 101) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << 0 << 17 << 0 << 17 << false << true;
+    QTest::newRow("Styled, 8 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 101) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << 0 << (117-50) << 0 << 17 << false << true;
+    QTest::newRow("Styled, 9 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 201) << QTransform()
+                                                 << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                 << 0 << (117-50) << 0 << 117 << false << true;
+    QTest::newRow("Styled, 10 Always ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 151, 101) << QTransform()
+                                                  << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                  << -101 << (-100 + 16) << -101 << (-100 + 16) << false << true;
+    QTest::newRow("Styled, 11 Always ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 101) << QTransform()
+                                                  << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                  << -101 << (16-50) << -101 << (-100 + 16) << false << true;
+    QTest::newRow("Styled, 12 Always ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 201) << QTransform()
+                                                  << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                  << -101 << (16-50) << -101 << 16 << false << true;
+    QTest::newRow("Styled, 13 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 166, 116) << QTransform()
+                                                  << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                  << 0 << 32 << 0 << 32 << false << true;
+    QTest::newRow("Styled, 14 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 116) << QTransform()
+                                                  << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                  << 0 << (50 + 32) << 0 << 32 << false << true;
+    QTest::newRow("Styled, 15 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 216) << QTransform()
+                                                  << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                  << 0 << (50 + 32) << 0 << (100 + 32) << false << true;
+    QTest::newRow("Styled, 16 Always ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 166, 116) << QTransform()
+                                                  << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                  << (-100 - 16) << (-100 + 16) << (-100 - 16) << (-100 + 16) << false << true;
+    QTest::newRow("Styled, 17 Always ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 116) << QTransform()
+                                                  << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                  << (-100 - 16) << (16-50) << (-100 - 16) << (-100 + 16) << false << true;
+    QTest::newRow("Styled, 18 Always ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 216) << QTransform()
+                                                  << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                  << (-100 - 16) << (16-50) << (-100 - 16) << 16 << false << true;
+    QTest::newRow("Styled, 1 x2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform().scale(2, 2)
+                                                    << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                    << 0 << (150 + 16) << 0 << (100 + 16) << false << true;
+    QTest::newRow("Styled, 2 x2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform().scale(2, 2)
+                                                    << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                    << 0 << (250 + 16) << 0 << (100 + 16) << false << true;
+    QTest::newRow("Styled, 3 x2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform().scale(2, 2)
+                                                    << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                    << 0 << (250 + 16) << 0 << (300 + 16) << false << true;
+    QTest::newRow("Styled, 4 x2 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform().scale(2, 2)
+                                                    << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                    << -200 << (-50 + 16) << -200 << (-100 + 16) << false << true;
+    QTest::newRow("Styled, 5 x2 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform().scale(2, 2)
+                                                    << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                    << -200 << (50 + 16) << -200 << (-100 + 16) << false << true;
+    QTest::newRow("Styled, 6 x2 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform().scale(2, 2)
+                                                    << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                    << -200 << (50 + 16) << -200 << (100 + 16) << false << true;
+}
+
+static void _scrollBarRanges_data_4(int offset)
+{
+    // Motif, styled panel
+    QTest::newRow("Motif, Styled, 1") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform()
+                                      << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                      << 0 << 0 << 0 << 0 << true << true;
+    QTest::newRow("Motif, Styled, 2") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform()
+                                      << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                      << 0 << (50 + offset + 4) << 0 << (offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 3") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform()
+                                      << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                      << 0 << (50 + offset + 4) << 0 << (100 + offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 4") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform()
+                                      << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                      << 0 << 0 << 0 << 0 << true << true;
+    QTest::newRow("Motif, Styled, 5") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform()
+                                      << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                      << -100 << (offset + 4 - 50) << -100 << (-100 + offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 6") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform()
+                                      << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                      << -100 << (offset + 4 - 50) << -100 << (offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 7") << QSize(150, 100) << QRectF(0, 0, 151, 101) << QTransform()
+                                      << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                      << 0 << (offset + 1 + 4) << 0 << (offset + 1 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 8") << QSize(150, 100) << QRectF(0, 0, 201, 101) << QTransform()
+                                      << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                      << 0 << (50 + offset + 1 + 4) << 0 << (offset + 1 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 9") << QSize(150, 100) << QRectF(0, 0, 201, 201) << QTransform()
+                                      << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                      << 0 << (50 + offset + 1 + 4) << 0 << (100 + offset + 1 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 10") << QSize(150, 100) << QRectF(-101, -101, 151, 101) << QTransform()
+                                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                       << -101 << (-100 + offset + 4) << -101 << (-100 + offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 11") << QSize(150, 100) << QRectF(-101, -101, 201, 101) << QTransform()
+                                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                       << (-101) << (offset + 4 - 50) << -101 << (-100 + offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 12") << QSize(150, 100) << QRectF(-101, -101, 201, 201) << QTransform()
+                                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                       << (-101) << (offset + 4 - 50) << (-101) << (offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 13") << QSize(150, 100) << QRectF(0, 0, 166, 116) << QTransform()
+                                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                       << 0 << (offset + 16 + 4) << 0 << (offset + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 14") << QSize(150, 100) << QRectF(0, 0, 216, 116) << QTransform()
+                                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                       << 0 << (50 + offset + 16 + 4) << 0 << (offset + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 15") << QSize(150, 100) << QRectF(0, 0, 216, 216) << QTransform()
+                                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                       << 0 << (50 + offset + 16 + 4) << 0 << (100 + offset + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 16") << QSize(150, 100) << QRectF(-116, -116, 166, 116) << QTransform()
+                                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                       << (-100 - 16) << (-100 + offset + 4) << (-100 - 16) << (-100 + offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 17") << QSize(150, 100) << QRectF(-116, -116, 216, 116) << QTransform()
+                                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                       << (-100 - 16) << (offset + 4 - 50) << (-100 - 16) << (-100 + offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 18") << QSize(150, 100) << QRectF(-116, -116, 216, 216) << QTransform()
+                                       << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                       << (-100 - 16) << (offset + 4 - 50) << (-100 - 16) << (offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 1 x2") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform().scale(2, 2)
+                                         << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                         << 0 << (150 + offset + 4) << 0 << (100 + offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 2 x2") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform().scale(2, 2)
+                                         << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                         << 0 << (250 + offset + 4) << 0 << (100 + offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 3 x2") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform().scale(2, 2)
+                                         << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                         << 0 << (250 + offset + 4) << 0 << (300 + offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 4 x2") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform().scale(2, 2)
+                                         << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                         << -200 << (-50 + offset + 4) << -200 << (-100 + offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 5 x2") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform().scale(2, 2)
+                                         << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                         << -200 << (50 + offset + 4) << -200 << (-100 + offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 6 x2") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform().scale(2, 2)
+                                         << Qt::ScrollBarAsNeeded << Qt::ScrollBarAsNeeded
+                                         << -200 << (50 + offset + 4) << -200 << (100 + offset + 4) << true << true;
+    QTest::newRow("Motif, Styled, 1 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform()
+                                                    << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                    << 0 << 0 << 0 << 0 << true << true;
+    QTest::newRow("Motif, Styled, 2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform()
+                                                    << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                    << 0 << 50 << 0 << 0 << true << true;
+    QTest::newRow("Motif, Styled, 3 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform()
+                                                    << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                    << 0 << 50 << 0 << 100 << true << true;
+    QTest::newRow("Motif, Styled, 4 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform()
+                                                    << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                    << 0 << 0 << 0 << 0 << true << true;
+    QTest::newRow("Motif, Styled, 5 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform()
+                                                    << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                    << -100 << -50 << 0 << 0 << true << true;
+    QTest::newRow("Motif, Styled, 6 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform()
+                                                    << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                    << -100 << -50 << -100 << 0 << true << true;
+    QTest::newRow("Motif, Styled, 7 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 151, 101) << QTransform()
+                                                    << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                    << 0 << 1 << 0 << 1 << true << true;
+    QTest::newRow("Motif, Styled, 8 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 101) << QTransform()
+                                                    << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                    << 0 << 51 << 0 << 1 << true << true;
+    QTest::newRow("Motif, Styled, 9 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 201) << QTransform()
+                                                    << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                    << 0 << 51 << 0 << 101 << true << true;
+    QTest::newRow("Motif, Styled, 10 No ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 151, 101) << QTransform()
+                                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                     << -101 << -100 << -101 << -100 << true << true;
+    QTest::newRow("Motif, Styled, 11 No ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 101) << QTransform()
+                                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                     << -101 << -50 << -101 << -100 << true << true;
+    QTest::newRow("Motif, Styled, 12 No ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 201) << QTransform()
+                                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                     << -101 << -50 << -101 << 0 << true << true;
+    QTest::newRow("Motif, Styled, 13 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 166, 116) << QTransform()
+                                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                     << 0 << 16 << 0 << 16 << true << true;
+    QTest::newRow("Motif, Styled, 14 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 116) << QTransform()
+                                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                     << 0 << (50 + 16) << 0 << 16 << true << true;
+    QTest::newRow("Motif, Styled, 15 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 216) << QTransform()
+                                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                     << 0 << (50 + 16) << 0 << (100 + 16) << true << true;
+    QTest::newRow("Motif, Styled, 16 No ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 166, 116) << QTransform()
+                                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                     << (-100 - 16) << -100 << (-100 - 16) << -100 << true << true;
+    QTest::newRow("Motif, Styled, 17 No ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 116) << QTransform()
+                                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                     << (-100 - 16) << -50 << (-100 - 16) << -100 << true << true;
+    QTest::newRow("Motif, Styled, 18 No ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 216) << QTransform()
+                                                     << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                     << (-100 - 16) << -50 << (-100 - 16) << 0 << true << true;
+    QTest::newRow("Motif, Styled, 1 x2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform().scale(2, 2)
+                                                       << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                       << 0 << 150 << 0 << 100 << true << true;
+    QTest::newRow("Motif, Styled, 2 x2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform().scale(2, 2)
+                                                       << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                       << 0 << 250 << 0 << 100 << true << true;
+    QTest::newRow("Motif, Styled, 3 x2 No ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform().scale(2, 2)
+                                                       << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                       << 0 << 250 << 0 << 300 << true << true;
+    QTest::newRow("Motif, Styled, 4 x2 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform().scale(2, 2)
+                                                       << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                       << -200 << -50 << -200 << -100 << true << true;
+    QTest::newRow("Motif, Styled, 5 x2 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform().scale(2, 2)
+                                                       << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                       << -200 << 50 << -200 << -100 << true << true;
+    QTest::newRow("Motif, Styled, 6 x2 No ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform().scale(2, 2)
+                                                       << Qt::ScrollBarAlwaysOff << Qt::ScrollBarAlwaysOff
+                                                       << -200 << 50 << -200 << 100 << true << true;
+    QTest::newRow("Motif, Styled, 1 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform()
+                                                        << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                        << 0 << (16 + 4) << 0 << (16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform()
+                                                        << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                        << 0 << (50 + 16 + 4) << 0 << (16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 3 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform()
+                                                        << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                        << 0 << (50 + 16 + 4) << 0 << (100 + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 4 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform()
+                                                        << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                        << -100 << (-100 + 16 + 4) << -100 << (-100 + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 5 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform()
+                                                        << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                        << -100 << (16 + 4 - 50) << -100 << (-100 + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 6 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform()
+                                                        << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                        << -100 << (16 + 4 - 50) << -100 << (16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 7 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 151, 101) << QTransform()
+                                                        << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                        << 0 << (17 + 4) << 0 << (17 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 8 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 101) << QTransform()
+                                                        << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                        << 0 << (117 + 4 - 50) << 0 << (17 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 9 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 201, 201) << QTransform()
+                                                        << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                        << 0 << (117 + 4 - 50) << 0 << (117 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 10 Always ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 151, 101) << QTransform()
+                                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                         << -101 << (-100 + 16 + 4) << -101 << (-100 + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 11 Always ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 101) << QTransform()
+                                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                         << -101 << (16 + 4 - 50) << -101 << (-100 + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 12 Always ScrollBars") << QSize(150, 100) << QRectF(-101, -101, 201, 201) << QTransform()
+                                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                         << -101 << (16 + 4 - 50) << -101 << (16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 13 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 166, 116) << QTransform()
+                                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                         << 0 << (32 + 4) << 0 << (32 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 14 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 116) << QTransform()
+                                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                         << 0 << (50 + 32 + 4) << 0 << (32 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 15 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 216, 216) << QTransform()
+                                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                         << 0 << (50 + 32 + 4) << 0 << (100 + 32 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 16 Always ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 166, 116) << QTransform()
+                                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                         << (-100 - 16) << (-100 + 16 + 4) << (-100 - 16) << (-100 + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 17 Always ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 116) << QTransform()
+                                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                         << (-100 - 16) << (16 + 4 - 50) << (-100 - 16) << (-100 + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 18 Always ScrollBars") << QSize(150, 100) << QRectF(-116, -116, 216, 216) << QTransform()
+                                                         << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                         << (-100 - 16) << (16 + 4 - 50) << (-100 - 16) << (16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 1 x2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 150, 100) << QTransform().scale(2, 2)
+                                                           << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                           << 0 << (150 + 16 + 4) << 0 << (100 + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 2 x2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 100) << QTransform().scale(2, 2)
+                                                           << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                           << 0 << (250 + 16 + 4) << 0 << (100 + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 3 x2 Always ScrollBars") << QSize(150, 100) << QRectF(0, 0, 200, 200) << QTransform().scale(2, 2)
+                                                           << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                           << 0 << (250 + 16 + 4) << 0 << (300 + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 4 x2 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 150, 100) << QTransform().scale(2, 2)
+                                                           << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                           << -200 << (-50 + 16 + 4) << -200 << (-100 + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 5 x2 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 100) << QTransform().scale(2, 2)
+                                                           << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                           << -200 << (50 + 16 + 4) << -200 << (-100 + 16 + 4) << true << true;
+    QTest::newRow("Motif, Styled, 6 x2 Always ScrollBars") << QSize(150, 100) << QRectF(-100, -100, 200, 200) << QTransform().scale(2, 2)
+                                                           << Qt::ScrollBarAlwaysOn << Qt::ScrollBarAlwaysOn
+                                                           << -200 << (50 + 16 + 4) << -200 << (100 + 16 + 4) << true << true;
+}
+
+void _scrollBarRanges_data()
+{
+    QTest::addColumn<QSize>("viewportSize");
+    QTest::addColumn<QRectF>("sceneRect");
+    QTest::addColumn<QTransform>("transform");
+    QTest::addColumn<Qt::ScrollBarPolicy>("hbarpolicy");
+    QTest::addColumn<Qt::ScrollBarPolicy>("vbarpolicy");
+    QTest::addColumn<int>("hmin");
+    QTest::addColumn<int>("hmax");
+    QTest::addColumn<int>("vmin");
+    QTest::addColumn<int>("vmax");
+    QTest::addColumn<bool>("useMotif");
+    QTest::addColumn<bool>("useStyledPanel");
+
+    int offset = 16;
+#ifdef Q_OS_WINCE
+    if (qt_wince_is_high_dpi())
+        offset *= 2;
+#endif
+
+    _scrollBarRanges_data_1(offset);
+    _scrollBarRanges_data_2(offset);
+    _scrollBarRanges_data_3(offset);
+    _scrollBarRanges_data_4(offset);
+}
diff --git a/tests/auto/widgets/graphicsview/qgraphicswidget/.gitignore b/tests/auto/widgets/graphicsview/qgraphicswidget/.gitignore
new file mode 100644
index 0000000000..ae39b803e5
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicswidget/.gitignore
@@ -0,0 +1 @@
+tst_qgraphicswidget
diff --git a/tests/auto/widgets/graphicsview/qgraphicswidget/qgraphicswidget.pro b/tests/auto/widgets/graphicsview/qgraphicswidget/qgraphicswidget.pro
new file mode 100644
index 0000000000..330076eafc
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicswidget/qgraphicswidget.pro
@@ -0,0 +1,10 @@
+load(qttest_p4)
+
+QT += widgets widgets-private
+QT += core-private gui-private
+
+SOURCES  += tst_qgraphicswidget.cpp
+
+
+mac*:CONFIG+=insignificant_test
+qpa:contains(QT_CONFIG,xcb):CONFIG+=insignificant_test  # QTBUG-20778 unstable on qpa, xcb
diff --git a/tests/auto/widgets/graphicsview/qgraphicswidget/tst_qgraphicswidget.cpp b/tests/auto/widgets/graphicsview/qgraphicswidget/tst_qgraphicswidget.cpp
new file mode 100644
index 0000000000..c983016a20
--- /dev/null
+++ b/tests/auto/widgets/graphicsview/qgraphicswidget/tst_qgraphicswidget.cpp
@@ -0,0 +1,3361 @@
+/****************************************************************************
+**
+** 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 <qgraphicswidget.h>
+#include <qgraphicsscene.h>
+#include <qgraphicssceneevent.h>
+#include <qgraphicsview.h>
+#include <qstyleoption.h>
+#include <qgraphicslinearlayout.h>
+#include <qcleanlooksstyle.h>
+#include <qlineedit.h>
+#include <qboxlayout.h>
+#include <qaction.h>
+#include <qwidgetaction.h>
+#include "../../../platformquirks.h"
+
+
+class EventSpy : public QObject
+{
+    Q_OBJECT
+public:
+    EventSpy(QObject *watched, QEvent::Type type)
+        : _count(0), spied(type)
+    {
+        watched->installEventFilter(this);
+    }
+
+    int count() const { return _count; }
+
+protected:
+    bool eventFilter(QObject *watched, QEvent *event)
+    {
+        Q_UNUSED(watched);
+        if (event->type() == spied)
+            ++_count;
+        return false;
+    }
+
+    int _count;
+    QEvent::Type spied;
+};
+
+class tst_QGraphicsWidget : public QObject {
+Q_OBJECT
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+private slots:
+    void qgraphicswidget();
+
+    void activation();
+    void boundingRect_data();
+    void boundingRect();
+    void dumpFocusChain_data();
+    void dumpFocusChain();
+    void focusWidget_data();
+    void focusWidget();
+    void focusWidget2();
+    void focusWidget3();
+    void focusPolicy_data();
+    void focusPolicy();
+    void font_data();
+    void font();
+    void fontPropagation();
+    void fontChangedEvent();
+    void fontPropagationWidgetItemWidget();
+    void fontPropagationSceneChange();
+    void geometry_data();
+    void geometry();
+    void geometryChanged();
+    void width();
+    void height();
+    void getContentsMargins_data();
+    void getContentsMargins();
+    void initStyleOption_data();
+    void initStyleOption();
+    void layout_data();
+    void layout();
+    void layoutDirection_data();
+    void layoutDirection();
+    void paint_data();
+    void paint();
+    void palettePropagation();
+    void parentWidget_data();
+    void parentWidget();
+    void resize_data();
+    void resize();
+    void setAttribute_data();
+    void setAttribute();
+    void setStyle_data();
+    void setStyle();
+    void setTabOrder_data();
+    void setTabOrder();
+    void setTabOrderAndReparent();
+    void topLevelWidget_data();
+    void topLevelWidget();
+    void unsetLayoutDirection_data();
+    void unsetLayoutDirection();
+    void focusNextPrevChild_data();
+    void focusNextPrevChild();
+    void verifyFocusChain();
+    void updateFocusChainWhenChildDie();
+    void sizeHint_data();
+    void sizeHint();
+    void consistentPosSizeGeometry_data();
+    void consistentPosSizeGeometry();
+    void setSizes_data();
+    void setSizes();
+    void closePopupOnOutsideClick();
+    void defaultSize();
+    void explicitMouseGrabber();
+    void implicitMouseGrabber();
+    void doubleClickAfterExplicitMouseGrab();
+    void popupMouseGrabber();
+    void windowFlags_data();
+    void windowFlags();
+    void shortcutsDeletion();
+    void painterStateProtectionOnWindowFrame();
+    void ensureClipping();
+    void widgetSendsGeometryChanges();
+    void respectHFW();
+    void addChildInpolishEvent();
+    void polishEvent();
+    void polishEvent2();
+    void autoFillBackground();
+    void initialShow();
+    void initialShow2();
+    void itemChangeEvents();
+    void itemSendGeometryPosChangesDeactivated();
+
+    void fontPropagatesResolveToChildren();
+    void fontPropagatesResolveToGrandChildren();
+    void fontPropagatesResolveInParentChange();
+    void fontPropagatesResolveViaNonWidget();
+    void fontPropagatesResolveFromScene();
+
+    // Task fixes
+    void task236127_bspTreeIndexFails();
+    void task243004_setStyleCrash();
+    void task250119_shortcutContext();
+    void QT_BUG_6544_tabFocusFirstUnsetWhenRemovingItems();
+    void QT_BUG_12056_tabFocusFirstUnsetWhenRemovingItems();
+};
+
+
+static void sendMouseMove(QWidget *widget, const QPoint &point, Qt::MouseButton button = Qt::NoButton, Qt::MouseButtons buttons = 0)
+{
+    QTest::mouseMove(widget, point);
+    QMouseEvent event(QEvent::MouseMove, point, button, buttons, 0);
+    QApplication::sendEvent(widget, &event);
+}
+
+// Subclass that exposes the protected functions.
+class SubQGraphicsWidget : public QGraphicsWidget {
+public:
+    SubQGraphicsWidget(QGraphicsItem *parent = 0, Qt::WindowFlags windowFlags = 0)
+        : QGraphicsWidget(parent, windowFlags), eventCount(0)
+        { }
+
+    void initStyleOption(QStyleOption *option)
+        { QGraphicsWidget::initStyleOption(option); }
+
+    void call_changeEvent(QEvent* event)
+        { return QGraphicsWidget::changeEvent(event); }
+
+    bool call_event(QEvent *e)
+        { return event(e); }
+
+    void call_focusInEvent(QFocusEvent* event)
+        { return QGraphicsWidget::focusInEvent(event); }
+
+    bool call_focusNextPrevChild(bool next)
+        { return QGraphicsWidget::focusNextPrevChild(next); }
+
+    void call_focusOutEvent(QFocusEvent* event)
+        { return QGraphicsWidget::focusOutEvent(event); }
+
+    void call_hideEvent(QHideEvent* event)
+        { return QGraphicsWidget::hideEvent(event); }
+
+    QVariant call_itemChange(QGraphicsItem::GraphicsItemChange change, QVariant const& value)
+        { return QGraphicsWidget::itemChange(change, value); }
+
+    void call_moveEvent(QGraphicsSceneMoveEvent* event)
+        { return QGraphicsWidget::moveEvent(event); }
+
+    void call_polishEvent()
+        { return QGraphicsWidget::polishEvent(); }
+
+    QVariant call_propertyChange(QString const& propertyName, QVariant const& value)
+        { return QGraphicsWidget::propertyChange(propertyName, value); }
+
+    void call_resizeEvent(QGraphicsSceneResizeEvent* event)
+        { return QGraphicsWidget::resizeEvent(event); }
+
+    bool call_sceneEvent(QEvent* event)
+        { return QGraphicsWidget::sceneEvent(event); }
+
+    void call_showEvent(QShowEvent* event)
+        { return QGraphicsWidget::showEvent(event); }
+
+    QSizeF call_sizeHint(Qt::SizeHint which, QSizeF const& constraint = QSizeF()) const
+        { return QGraphicsWidget::sizeHint(which, constraint); }
+
+    void call_updateGeometry()
+        { return QGraphicsWidget::updateGeometry(); }
+
+    int eventCount;
+    Qt::LayoutDirection m_painterLayoutDirection;
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        m_painterLayoutDirection = painter->layoutDirection();
+        QGraphicsWidget::paint(painter, option, widget);
+        if (hasFocus()) {
+            painter->setPen(Qt::DotLine);
+            painter->drawRect(rect());
+        }
+        //painter->drawText(QPointF(0,15), data(0).toString());
+    }
+
+protected:
+    bool event(QEvent *event)
+    {
+        eventCount++;
+        return QGraphicsWidget::event(event);
+    }
+};
+
+// This will be called before the first test function is executed.
+// It is only called once.
+void tst_QGraphicsWidget::initTestCase()
+{
+}
+
+// This will be called after the last test function is executed.
+// It is only called once.
+void tst_QGraphicsWidget::cleanupTestCase()
+{
+}
+
+// This will be called before each test function is executed.
+void tst_QGraphicsWidget::init()
+{
+}
+
+// This will be called after every test function.
+void tst_QGraphicsWidget::cleanup()
+{
+}
+
+class SizeHinter : public QGraphicsWidget
+{
+public:
+    SizeHinter(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0,
+                const QSizeF &min = QSizeF(5,5),
+                const QSizeF &pref = QSizeF(50, 50),
+                const QSizeF &max = QSizeF(500, 500))
+        : QGraphicsWidget(parent, wFlags)
+    {
+        m_sizes[Qt::MinimumSize] = min;
+        m_sizes[Qt::PreferredSize] = pref;
+        m_sizes[Qt::MaximumSize] = max;
+
+    }
+    void setSizeHint(Qt::SizeHint which, const QSizeF &newSizeHint)
+    {
+        m_sizes[which] = newSizeHint;
+    }
+
+protected:
+    QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const
+    {
+        Q_UNUSED(constraint);
+        return m_sizes[which];
+    }
+private:
+    QSizeF m_sizes[4];
+};
+
+void tst_QGraphicsWidget::qgraphicswidget()
+{
+    SubQGraphicsWidget widget;
+    QVERIFY(widget.isVisible());
+
+    QVERIFY(!widget.isWindow());
+    QCOMPARE(widget.boundingRect(), QRectF(0, 0, 0, 0));
+    QCOMPARE(widget.focusWidget(), (QGraphicsWidget*)0);
+    QCOMPARE(widget.focusPolicy(), Qt::NoFocus);
+    QCOMPARE(widget.font(), QFont());
+    QCOMPARE(widget.geometry(), QRectF(widget.pos(), widget.size()));
+    QCOMPARE(widget.layout(), (QGraphicsLayout*)0);
+    QCOMPARE(widget.layoutDirection(), Qt::LeftToRight);
+    QCOMPARE(widget.palette(), QPalette());
+    QCOMPARE(widget.parentWidget(), (QGraphicsWidget*)0);
+    QCOMPARE(widget.rect(), QRectF(QPointF(), widget.size()));
+    QCOMPARE(widget.size(), QSizeF(0, 0));
+    QVERIFY(widget.style() != (QStyle*)0);
+    QCOMPARE(widget.testAttribute(Qt::WA_AcceptDrops), false);
+    QCOMPARE(widget.topLevelWidget(), (QGraphicsWidget*)&widget);
+    QCOMPARE(widget.type(), (int)QGraphicsWidget::Type);
+    QCOMPARE(widget.call_propertyChange(QString(), QVariant()), QVariant());
+    widget.call_sizeHint(Qt::PreferredSize, QSizeF());
+
+    QGraphicsScene scene;
+    QGraphicsWidget *parent = new QGraphicsWidget;
+    SizeHinter *child = new SizeHinter(parent);
+
+    QCOMPARE(child->minimumSize(), QSizeF(5, 5));
+}
+
+void tst_QGraphicsWidget::activation()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsWidget *window1 = new QGraphicsWidget(0, Qt::Window);
+    QGraphicsWidget *window2 = new QGraphicsWidget(0, Qt::Window);
+    QVERIFY(!widget->isActiveWindow());
+    QVERIFY(!window1->isActiveWindow());
+    QVERIFY(!window2->isActiveWindow());
+
+    QGraphicsScene scene;
+    scene.addItem(widget);
+    scene.addItem(window1);
+    scene.addItem(window2);
+
+    QVERIFY(!widget->isActiveWindow());
+    QVERIFY(!window1->isActiveWindow());
+    QVERIFY(!window2->isActiveWindow());
+
+    QEvent activateEvent(QEvent::WindowActivate);
+    QApplication::sendEvent(&scene, &activateEvent);
+
+    QVERIFY(!widget->isActiveWindow());
+    QVERIFY(window1->isActiveWindow());
+    QVERIFY(!window2->isActiveWindow());
+
+    scene.setActiveWindow(window1);
+    QVERIFY(!widget->isActiveWindow());
+    QVERIFY(window1->isActiveWindow());
+    QVERIFY(!window2->isActiveWindow());
+
+    QEvent deactivateEvent(QEvent::WindowDeactivate);
+    QApplication::sendEvent(&scene, &deactivateEvent);
+
+    QVERIFY(!widget->isActiveWindow());
+    QVERIFY(!window1->isActiveWindow());
+    QVERIFY(!window2->isActiveWindow());
+}
+
+void tst_QGraphicsWidget::boundingRect_data()
+{
+    QTest::addColumn<QSizeF>("size");
+    QTest::newRow("null") << QSizeF(0, 0);
+    QTest::newRow("avg") << QSizeF(10, 10);
+}
+
+// QRectF boundingRect() const public
+void tst_QGraphicsWidget::boundingRect()
+{
+    QFETCH(QSizeF, size);
+    SubQGraphicsWidget widget;
+    widget.resize(size);
+    QCOMPARE(widget.rect(), QRectF(QPointF(), size));
+    QCOMPARE(widget.boundingRect(), QRectF(QPointF(0, 0), size));
+}
+
+void tst_QGraphicsWidget::dumpFocusChain_data()
+{
+    QTest::addColumn<bool>("scene");
+    QTest::addColumn<int>("children");
+    QTest::addColumn<bool>("setFocus");
+    QTest::newRow("empty world") << false << 0 << false;
+    QTest::newRow("one world") << true << 2 << false;
+    QTest::newRow("one world w/focus") << true << 2 << true;
+}
+
+// void dumpFocusChain(QGraphicsScene* scene) public (static)
+void tst_QGraphicsWidget::dumpFocusChain()
+{
+    // ### this test is very strange...
+    QFETCH(bool, scene);
+    SubQGraphicsWidget *parent = new SubQGraphicsWidget;
+    QGraphicsScene *theScene = 0;
+    if (scene) {
+        theScene = new QGraphicsScene(this);
+        theScene->addItem(parent);
+    }
+    QFETCH(int, children);
+    QFETCH(bool, setFocus);
+    for (int i = 0; i < children; ++i) {
+        SubQGraphicsWidget *widget = new SubQGraphicsWidget(parent);
+        if (setFocus) {
+            widget->setFlag(QGraphicsItem::ItemIsFocusable, true);
+            if (scene)
+                theScene->setFocusItem(widget);
+        }
+    }
+
+    if (!scene)
+        delete parent;
+}
+
+void tst_QGraphicsWidget::focusWidget_data()
+{
+    QTest::addColumn<int>("childCount");
+    QTest::addColumn<int>("childWithFocus");
+    QTest::newRow("none") << 0 << 0;
+    QTest::newRow("first") << 3 << 0;
+    QTest::newRow("last") << 3 << 2;
+}
+
+// QGraphicsWidget* focusWidget() const public
+void tst_QGraphicsWidget::focusWidget()
+{
+    SubQGraphicsWidget *parent = new SubQGraphicsWidget;
+    QCOMPARE(parent->focusWidget(), (QGraphicsWidget *)0);
+    QGraphicsScene scene;
+    QEvent windowActivate(QEvent::WindowActivate);
+    qApp->sendEvent(&scene, &windowActivate);
+    scene.addItem(parent);
+
+    QFETCH(int, childCount);
+    QList<SubQGraphicsWidget *> children;
+    for (int i = 0; i < childCount; ++i) {
+        SubQGraphicsWidget *widget = new SubQGraphicsWidget(parent);
+        widget->setFlag(QGraphicsItem::ItemIsFocusable, true);
+        children.append(widget);
+    }
+    if (childCount > 0) {
+        QFETCH(int, childWithFocus);
+        SubQGraphicsWidget *widget = children[childWithFocus];
+        widget->setFocus();
+        QTRY_VERIFY(widget->hasFocus());
+        QCOMPARE(parent->focusWidget(), static_cast<QGraphicsWidget*>(widget));
+    }
+}
+
+void tst_QGraphicsWidget::focusWidget2()
+{
+    QGraphicsScene scene;
+    QEvent windowActivate(QEvent::WindowActivate);
+    qApp->sendEvent(&scene, &windowActivate);
+
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    EventSpy focusInSpy(widget, QEvent::FocusIn);
+    EventSpy focusOutSpy(widget, QEvent::FocusOut);
+
+    scene.addItem(widget);
+
+    QTRY_VERIFY(!widget->hasFocus());
+    widget->setFocusPolicy(Qt::StrongFocus);
+    QTRY_VERIFY(!widget->hasFocus());
+
+    QGraphicsWidget *subWidget = new QGraphicsWidget(widget);
+    QTRY_VERIFY(!subWidget->hasFocus());
+
+    scene.setFocus();
+
+    QTRY_VERIFY(!widget->hasFocus());
+    QTRY_VERIFY(!subWidget->hasFocus());
+
+    widget->setFocus();
+
+    QTRY_VERIFY(widget->hasFocus());
+    QTRY_COMPARE(focusInSpy.count(), 1);
+    QTRY_VERIFY(!subWidget->hasFocus());
+
+    QGraphicsWidget *otherSubWidget = new QGraphicsWidget;
+    EventSpy otherFocusInSpy(otherSubWidget, QEvent::FocusIn);
+    EventSpy otherFocusOutSpy(otherSubWidget, QEvent::FocusOut);
+
+    otherSubWidget->setFocusPolicy(Qt::StrongFocus);
+    otherSubWidget->setParentItem(widget);
+
+    QTRY_VERIFY(widget->hasFocus());
+    QCOMPARE(scene.focusItem(), (QGraphicsItem *)widget);
+    QTRY_VERIFY(!subWidget->hasFocus());
+    QTRY_VERIFY(!otherSubWidget->hasFocus());
+
+    widget->hide();
+    QTRY_VERIFY(!widget->hasFocus()); // lose but still has subfocus
+    QCOMPARE(focusInSpy.count(), 1);
+    QCOMPARE(focusOutSpy.count(), 1);
+
+    widget->show();
+    QTRY_VERIFY(!widget->hasFocus()); // no regain
+    QCOMPARE(focusInSpy.count(), 1);
+    QCOMPARE(focusOutSpy.count(), 1);
+
+    widget->hide();
+
+    // try to setup subFocus on item that can't take focus
+    subWidget->setFocus();
+    QTRY_VERIFY(!subWidget->hasFocus());
+    QVERIFY(!scene.focusItem()); // but isn't the scene's focus item
+
+    // try to setup subFocus on item that can take focus
+    otherSubWidget->setFocus();
+    QTRY_VERIFY(!otherSubWidget->hasFocus());
+    QCOMPARE(widget->focusWidget(), otherSubWidget);
+    QVERIFY(!scene.focusItem()); // but isn't the scene's focus item
+
+    widget->show();
+
+    QTRY_COMPARE(scene.focusItem(), (QGraphicsItem *)otherSubWidget); // but isn't the scene's focus item
+    QCOMPARE(otherFocusInSpy.count(), 1);
+    QCOMPARE(otherFocusOutSpy.count(), 0);
+
+    delete otherSubWidget;
+
+    QTRY_COMPARE(otherFocusOutSpy.count(), 1);
+    QVERIFY(!scene.focusItem());
+    QVERIFY(!widget->focusWidget());
+}
+
+class FocusWatchWidget : public QGraphicsWidget
+{
+public:
+    FocusWatchWidget(QGraphicsItem *parent = 0) : QGraphicsWidget(parent) { gotFocusInCount = 0; gotFocusOutCount = 0; }
+    int gotFocusInCount, gotFocusOutCount;
+protected:
+    void focusInEvent(QFocusEvent *fe) { gotFocusInCount++; QGraphicsWidget::focusInEvent(fe); }
+    void focusOutEvent(QFocusEvent *fe) { gotFocusOutCount++; QGraphicsWidget::focusOutEvent(fe); }
+};
+
+void tst_QGraphicsWidget::focusWidget3()
+{
+    QGraphicsScene scene;
+    QEvent windowActivate(QEvent::WindowActivate);
+    qApp->sendEvent(&scene, &windowActivate);
+
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    FocusWatchWidget *subWidget = new FocusWatchWidget(widget);
+    subWidget->setFocusPolicy(Qt::StrongFocus);
+
+    scene.addItem(widget);
+    widget->show();
+
+    QTRY_VERIFY(!widget->hasFocus());
+    QTRY_VERIFY(!subWidget->hasFocus());
+
+    subWidget->setFocus();
+    QCOMPARE(subWidget->gotFocusInCount, 1);
+    QCOMPARE(subWidget->gotFocusOutCount, 0);
+    widget->hide();
+    QCOMPARE(subWidget->gotFocusOutCount, 1);
+}
+
+Q_DECLARE_METATYPE(Qt::FocusPolicy)
+void tst_QGraphicsWidget::focusPolicy_data()
+{
+    QTest::addColumn<Qt::FocusPolicy>("focusPolicy1");
+    QTest::addColumn<Qt::FocusPolicy>("focusPolicy2");
+
+    for (int i = 0; i < 25; ++i) {
+        QTestData &data = QTest::newRow(QString("%1").arg(i).toLatin1());
+        switch(i % 5) {
+        case 0: data << Qt::TabFocus; break;
+        case 1: data << Qt::ClickFocus; break;
+        case 2: data << Qt::StrongFocus; break;
+        case 3: data << Qt::WheelFocus; break;
+        case 4: data << Qt::NoFocus; break;
+        }
+        switch(i / 5) {
+        case 0: data << Qt::TabFocus; break;
+        case 1: data << Qt::ClickFocus; break;
+        case 2: data << Qt::StrongFocus; break;
+        case 3: data << Qt::WheelFocus; break;
+        case 4: data << Qt::NoFocus; break;
+        }
+    }
+}
+
+// Qt::FocusPolicy focusPolicy() const public
+void tst_QGraphicsWidget::focusPolicy()
+{
+    QGraphicsScene scene;
+    QEvent windowActivate(QEvent::WindowActivate);
+    qApp->sendEvent(&scene, &windowActivate);
+
+    SubQGraphicsWidget *widget = new SubQGraphicsWidget;
+    scene.addItem(widget);
+    QTRY_COMPARE(Qt::NoFocus, widget->focusPolicy());
+
+    QFETCH(Qt::FocusPolicy, focusPolicy1);
+    widget->setFocusPolicy(focusPolicy1);
+    QTRY_COMPARE(widget->focusPolicy(), focusPolicy1);
+    bool isFocusable = widget->flags() & QGraphicsItem::ItemIsFocusable;
+    bool wasFocusable = isFocusable;
+    QTRY_VERIFY(isFocusable == (focusPolicy1 != Qt::NoFocus));
+    widget->setFocus();
+    QTRY_COMPARE(widget->hasFocus(), isFocusable);
+
+    QFETCH(Qt::FocusPolicy, focusPolicy2);
+    widget->setFocusPolicy(focusPolicy2);
+    QCOMPARE(widget->focusPolicy(), focusPolicy2);
+    isFocusable = widget->flags() & QGraphicsItem::ItemIsFocusable;
+    QVERIFY(isFocusable == (focusPolicy2 != Qt::NoFocus));
+    QCOMPARE(widget->hasFocus(), wasFocusable && isFocusable);
+}
+
+void tst_QGraphicsWidget::font_data()
+{
+    QTest::addColumn<QString>("fontName");
+    QTest::newRow("Helvetica") << "Helvetica";
+}
+
+// QFont font() const public
+void tst_QGraphicsWidget::font()
+{
+    QFETCH(QString, fontName);
+    SubQGraphicsWidget widget;
+    QCOMPARE(widget.font(), QFont());
+
+    QFont font(fontName);
+    widget.setFont(font);
+    QCOMPARE(widget.font().family(), font.family());
+}
+
+void tst_QGraphicsWidget::fontPropagatesResolveToChildren()
+{
+    QGraphicsWidget *root = new QGraphicsWidget();
+    QGraphicsWidget *child1 = new QGraphicsWidget(root);
+
+    QGraphicsScene scene;
+    scene.addItem(root);
+
+    QFont font;
+    font.setItalic(true);
+    root->setFont(font);
+
+    QGraphicsWidget *child2 = new QGraphicsWidget(root);
+    QGraphicsWidget *child3 = new QGraphicsWidget();
+    child3->setParentItem(root);
+
+    QGraphicsView view;
+    view.setScene(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QCOMPARE(font.resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(root->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(child1->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(child2->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(child3->font().resolve(), uint(QFont::StyleResolved));
+}
+
+void tst_QGraphicsWidget::fontPropagatesResolveToGrandChildren()
+{
+    QGraphicsWidget *root = new QGraphicsWidget();
+    QGraphicsWidget *child1 = new QGraphicsWidget(root);
+    QGraphicsWidget *grandChild1 = new QGraphicsWidget(child1);
+
+    QGraphicsScene scene;
+    scene.addItem(root);
+
+    QFont font;
+    font.setItalic(true);
+    root->setFont(font);
+
+    QGraphicsWidget *child2 = new QGraphicsWidget(root);
+    QGraphicsWidget *grandChild2 = new QGraphicsWidget(child2);
+    QGraphicsWidget *grandChild3 = new QGraphicsWidget(child2);
+
+    QGraphicsWidget *child3 = new QGraphicsWidget();
+    QGraphicsWidget *grandChild4 = new QGraphicsWidget(child3);
+    QGraphicsWidget *grandChild5 = new QGraphicsWidget(child3);
+    child3->setParentItem(root);
+    grandChild5->setParentItem(child3);
+
+    QGraphicsView view;
+    view.setScene(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QCOMPARE(font.resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild1->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild2->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild3->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild4->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild5->font().resolve(), uint(QFont::StyleResolved));
+}
+
+void tst_QGraphicsWidget::fontPropagatesResolveViaNonWidget()
+{
+    QGraphicsWidget *root = new QGraphicsWidget();
+    QGraphicsPixmapItem *child1 = new QGraphicsPixmapItem(root);
+    QGraphicsWidget *grandChild1 = new QGraphicsWidget(child1);
+
+    QGraphicsScene scene;
+    scene.addItem(root);
+
+    QFont font;
+    font.setItalic(true);
+    root->setFont(font);
+
+    QGraphicsPixmapItem *child2 = new QGraphicsPixmapItem(root);
+    QGraphicsWidget *grandChild2 = new QGraphicsWidget(child2);
+    QGraphicsWidget *grandChild3 = new QGraphicsWidget(child2);
+
+    QGraphicsPixmapItem *child3 = new QGraphicsPixmapItem();
+    QGraphicsWidget *grandChild4 = new QGraphicsWidget(child3);
+    QGraphicsWidget *grandChild5 = new QGraphicsWidget(child3);
+    child3->setParentItem(root);
+    grandChild5->setParentItem(child3);
+
+    QGraphicsView view;
+    view.setScene(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QCOMPARE(font.resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild1->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild2->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild3->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild4->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild5->font().resolve(), uint(QFont::StyleResolved));
+}
+
+void tst_QGraphicsWidget::fontPropagatesResolveFromScene()
+{
+    QGraphicsWidget *root = new QGraphicsWidget();
+    QGraphicsWidget *child1 = new QGraphicsWidget(root);
+    QGraphicsWidget *grandChild1 = new QGraphicsWidget(child1);
+
+    QGraphicsScene scene;
+    scene.addItem(root);
+
+    QFont font;
+    font.setItalic(true);
+    scene.setFont(font);
+
+    QGraphicsWidget *child2 = new QGraphicsWidget(root);
+    QGraphicsWidget *grandChild2 = new QGraphicsWidget(child2);
+    QGraphicsWidget *grandChild3 = new QGraphicsWidget(child2);
+
+    QGraphicsWidget *child3 = new QGraphicsWidget();
+    QGraphicsWidget *grandChild4 = new QGraphicsWidget(child3);
+    QGraphicsWidget *grandChild5 = new QGraphicsWidget(child3);
+    child3->setParentItem(root);
+    grandChild5->setParentItem(child3);
+
+    QGraphicsView view;
+    view.setScene(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QCOMPARE(font.resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(root->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(child1->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(child2->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(child3->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild1->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild2->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild3->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild4->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild5->font().resolve(), uint(QFont::StyleResolved));
+}
+
+void tst_QGraphicsWidget::fontPropagatesResolveInParentChange()
+{
+    QGraphicsWidget *root = new QGraphicsWidget();
+
+    QGraphicsWidget *child1 = new QGraphicsWidget(root);
+    QGraphicsWidget *grandChild1 = new QGraphicsWidget(child1);
+
+    QGraphicsWidget *child2 = new QGraphicsWidget(root);
+    QGraphicsWidget *grandChild2 = new QGraphicsWidget(child2);
+
+    QGraphicsScene scene;
+    scene.addItem(root);
+
+    QFont italicFont;
+    italicFont.setItalic(true);
+    child1->setFont(italicFont);
+
+    QFont boldFont;
+    boldFont.setBold(true);
+    child2->setFont(boldFont);
+
+    QVERIFY(grandChild1->font().italic());
+    QVERIFY(!grandChild1->font().bold());
+    QVERIFY(!grandChild2->font().italic());
+    QVERIFY(grandChild2->font().bold());
+
+    QCOMPARE(grandChild1->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild2->font().resolve(), uint(QFont::WeightResolved));
+
+    grandChild2->setParentItem(child1);
+
+    QGraphicsView view;
+    view.setScene(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QVERIFY(grandChild1->font().italic());
+    QVERIFY(!grandChild1->font().bold());
+    QVERIFY(grandChild2->font().italic());
+    QVERIFY(!grandChild2->font().bold());
+
+    QCOMPARE(grandChild1->font().resolve(), uint(QFont::StyleResolved));
+    QCOMPARE(grandChild2->font().resolve(), uint(QFont::StyleResolved));
+
+}
+
+void tst_QGraphicsWidget::fontPropagation()
+{
+    QGraphicsWidget *root = new QGraphicsWidget;
+    QGraphicsWidget *child0 = new QGraphicsWidget(root);
+    QGraphicsWidget *child1 = new QGraphicsWidget(child0);
+    QGraphicsWidget *child2 = new QGraphicsWidget(child1);
+    QGraphicsScene scene;
+    scene.addItem(root);
+
+    // Check that only the application fonts apply.
+    QFont appFont = QApplication::font();
+    QCOMPARE(scene.font(), appFont);
+    QCOMPARE(root->font(), appFont);
+    QCOMPARE(child0->font(), appFont);
+    QCOMPARE(child1->font(), appFont);
+
+    // Set child0's Text, and set ToolTipBase on child1.
+    QFont boldFont;
+    boldFont.setBold(true);
+    child0->setFont(boldFont);
+    QFont italicFont;
+    italicFont.setItalic(true);
+    child1->setFont(italicFont);
+
+    // Check that the above settings propagate correctly.
+    QCOMPARE(root->font(), appFont);
+    QCOMPARE(scene.font(), appFont);
+    QVERIFY(child0->font().bold());
+    QVERIFY(!child0->font().italic());
+    QVERIFY(child1->font().bold());
+    QVERIFY(child1->font().italic());
+    QVERIFY(child2->font().bold());
+    QVERIFY(child2->font().italic());
+
+    QGraphicsWidget *child3 = new QGraphicsWidget(child2);
+    QVERIFY(child3->font().bold());
+    QVERIFY(child3->font().italic());
+
+    QGraphicsWidget *child4 = new QGraphicsWidget;
+    child4->setParentItem(child3);
+    QVERIFY(child4->font().bold());
+    QVERIFY(child4->font().italic());
+
+    // Replace the app font for child2. Button should propagate but Text
+    // should still be ignored. The previous ToolTipBase setting is gone.
+    QFont sizeFont;
+    sizeFont.setPointSize(43);
+    child1->setFont(sizeFont);
+
+    // Check that the above settings propagate correctly.
+    QCOMPARE(root->font(), appFont);
+    QCOMPARE(scene.font(), appFont);
+    QVERIFY(child0->font().bold());
+    QVERIFY(!child0->font().italic());
+    QVERIFY(child1->font().bold());
+    QVERIFY(!child1->font().italic());
+    QCOMPARE(child1->font().pointSize(), 43);
+    QVERIFY(child2->font().bold());
+    QVERIFY(!child2->font().italic());
+    QCOMPARE(child2->font().pointSize(), 43);
+}
+
+void tst_QGraphicsWidget::fontChangedEvent()
+{
+    QGraphicsWidget *root = new QGraphicsWidget;
+    QGraphicsScene scene;
+    scene.addItem(root);
+
+    // Check that only the application fonts apply.
+    QFont appFont = QApplication::font();
+    QCOMPARE(scene.font(), appFont);
+    QCOMPARE(root->font(), appFont);
+
+    EventSpy rootSpyFont(root, QEvent::FontChange);
+    EventSpy rootSpyPolish(root, QEvent::Polish);
+    QTRY_COMPARE(rootSpyFont.count(), 0);
+    QTRY_COMPARE(rootSpyPolish.count(), 1);
+    //The font is still the same so no fontChangeEvent
+    QTRY_COMPARE(rootSpyFont.count(), 0);
+
+    QFont font;
+    font.setPointSize(43);
+    root->setFont(font);
+    //The font changed
+    QTRY_COMPARE(rootSpyFont.count(), 1);
+
+    //then roll back to the default one.
+    root->setFont(appFont);
+    //The font changed
+    QTRY_COMPARE(rootSpyFont.count(), 2);
+}
+
+void tst_QGraphicsWidget::fontPropagationWidgetItemWidget()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsRectItem *rect = new QGraphicsRectItem(widget);
+    QGraphicsWidget *widget2 = new QGraphicsWidget(rect);
+
+    QGraphicsScene scene;
+    scene.addItem(widget);
+
+    QFont font;
+    font.setPointSize(43);
+    widget->setFont(font);
+
+    QCOMPARE(widget2->font().pointSize(), 43);
+    QCOMPARE(widget2->font().resolve(), uint(QFont::SizeResolved));
+
+    widget->setFont(QFont());
+
+    QCOMPARE(widget2->font().pointSize(), qApp->font().pointSize());
+    QCOMPARE(widget2->font().resolve(), QFont().resolve());
+}
+
+void tst_QGraphicsWidget::fontPropagationSceneChange()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsRectItem *rect = new QGraphicsRectItem(widget);
+    QGraphicsWidget *widget2 = new QGraphicsWidget(rect);
+
+    QGraphicsScene scene;
+    QGraphicsScene scene2;
+
+    QFont font;
+    font.setPointSize(47);
+    scene.setFont(font);
+
+    QFont font2;
+    font2.setPointSize(74);
+    scene2.setFont(font2);
+
+    scene.addItem(widget);
+    QCOMPARE(widget2->font().pointSize(), 47);
+    scene2.addItem(widget);
+    QCOMPARE(widget2->font().pointSize(), 74);
+}
+
+void tst_QGraphicsWidget::geometry_data()
+{
+    QTest::addColumn<QPointF>("pos");
+    QTest::addColumn<QSizeF>("size");
+    QTest::newRow("null, null") << QPointF() << QSizeF(0, 0);
+    QTest::newRow("null, normal") << QPointF() << QSizeF(10, 10);
+    QTest::newRow("neg, normal") << QPointF(-5, -5) << QSizeF(10, 10);
+}
+
+// QRectF geometry() const public
+void tst_QGraphicsWidget::geometry()
+{
+    SubQGraphicsWidget widget;
+    QCOMPARE(widget.geometry(), QRectF(widget.pos(), widget.size()));
+    QSignalSpy spy(&widget, SIGNAL(geometryChanged()));
+    QFETCH(QPointF, pos);
+    QFETCH(QSizeF, size);
+    widget.setPos(pos);
+    widget.resize(size);
+    if (!size.isNull() && !pos.isNull())
+        QCOMPARE(spy.count(), 2);
+    if (!size.isNull() && pos.isNull())
+        QCOMPARE(spy.count(), 1);
+    QCOMPARE(widget.geometry(), QRectF(pos, size));
+}
+
+void tst_QGraphicsWidget::geometryChanged()
+{
+    QGraphicsWidget w;
+    w.setGeometry(0, 0, 200, 200);
+    QCOMPARE(w.geometry(), QRectF(0, 0, 200, 200));
+    QSignalSpy spy(&w, SIGNAL(geometryChanged()));
+    w.setGeometry(0, 0, 100, 100);
+    QCOMPARE(spy.count(), 1);
+    QCOMPARE(w.geometry(), QRectF(0, 0, 100, 100));
+    w.setPos(10, 10);
+    QCOMPARE(spy.count(), 2);
+    QCOMPARE(w.geometry(), QRectF(10, 10, 100, 100));
+
+}
+
+void tst_QGraphicsWidget::width()
+{
+    QGraphicsWidget w;
+    QCOMPARE(w.property("width").toReal(), qreal(0));
+    QSignalSpy spy(&w, SIGNAL(widthChanged()));
+    w.setProperty("width", qreal(50));
+    QCOMPARE(w.property("width").toReal(), qreal(50));
+    QCOMPARE(spy.count(), 1);
+    //calling old school setGeometry should work too
+    w.setGeometry(0, 0, 200, 200);
+    QCOMPARE(spy.count(), 2);
+}
+
+void tst_QGraphicsWidget::height()
+{
+    QGraphicsWidget w;
+    QCOMPARE(w.property("height").toReal(), qreal(0));
+    QSignalSpy spy(&w, SIGNAL(heightChanged()));
+    w.setProperty("height", qreal(50));
+    QCOMPARE(w.property("height").toReal(), qreal(50));
+    QCOMPARE(spy.count(), 1);
+    //calling old school setGeometry should work too
+    w.setGeometry(0, 0, 200, 200);
+    QCOMPARE(spy.count(), 2);
+}
+
+void tst_QGraphicsWidget::getContentsMargins_data()
+{
+    QTest::addColumn<qreal>("left");
+    QTest::addColumn<qreal>("top");
+    QTest::addColumn<qreal>("right");
+    QTest::addColumn<qreal>("bottom");
+    QTest::newRow("null") << (qreal)0 << (qreal)0 << (qreal)0 << (qreal)0;
+    QTest::newRow("something") << (qreal)10 << (qreal)5 << (qreal)3 << (qreal)7;
+    QTest::newRow("real") << (qreal)1.7 << (qreal)5.9 << (qreal)3.2 << (qreal)9.7;
+}
+
+// void getContentsMargins(qreal* left, qreal* top, qreal* right, qreal* bottom) const public
+void tst_QGraphicsWidget::getContentsMargins()
+{
+    qreal gleft;
+    qreal gtop;
+    qreal gright;
+    qreal gbottom;
+
+    SubQGraphicsWidget widget;
+    widget.getContentsMargins(&gleft, &gtop, &gright, &gbottom);
+    QCOMPARE(gleft, (qreal)0);
+    QCOMPARE(gtop, (qreal)0);
+    QCOMPARE(gright, (qreal)0);
+    QCOMPARE(gbottom, (qreal)0);
+
+    QFETCH(qreal, left);
+    QFETCH(qreal, top);
+    QFETCH(qreal, right);
+    QFETCH(qreal, bottom);
+    int oldEventCounts = widget.eventCount;
+    widget.setContentsMargins(left, top, right, bottom);
+    QVERIFY(left == 0 || oldEventCounts != widget.eventCount);
+    widget.getContentsMargins(&gleft, &gtop, &gright, &gbottom);
+    QCOMPARE(gleft, left);
+    QCOMPARE(gtop, top);
+    QCOMPARE(gright, right);
+    QCOMPARE(gbottom, bottom);
+}
+
+Q_DECLARE_METATYPE(Qt::LayoutDirection)
+void tst_QGraphicsWidget::initStyleOption_data()
+{
+    QTest::addColumn<bool>("enabled");
+    QTest::addColumn<bool>("focus");
+    QTest::addColumn<bool>("underMouse");
+    QTest::addColumn<Qt::LayoutDirection>("layoutDirection");
+    QTest::addColumn<QSizeF>("size");
+    QTest::addColumn<QPalette>("palette");
+    QTest::addColumn<QString>("fontName");
+    QTest::newRow("none") << false << false << false << Qt::LeftToRight << QSizeF(0, 0) << QPalette() << QString();
+    QTest::newRow("all") << true << true << true << Qt::RightToLeft << QSizeF(300, 300) << QPalette(Qt::magenta) << "Helvetica";
+    QTest::newRow("rand") << true << false << false << Qt::RightToLeft << QSizeF(1, 0) << QPalette(Qt::darkCyan) << "Times";
+}
+
+// void initStyleOption(QStyleOption* option) const public
+void tst_QGraphicsWidget::initStyleOption()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QApplication::setActiveWindow(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+
+    view.setAlignment(Qt::AlignTop | Qt::AlignLeft);
+    SubQGraphicsWidget *widget = new SubQGraphicsWidget;
+    widget->setAcceptsHoverEvents(true);
+    QStyleOption option;
+    scene.addItem(widget);
+
+    QFETCH(QSizeF, size);
+    widget->resize(size);
+
+    QFETCH(bool, enabled);
+    widget->setEnabled(enabled);
+    QFETCH(bool, focus);
+    if (focus) {
+        widget->setFlag(QGraphicsItem::ItemIsFocusable, true);
+        widget->setFocus();
+        QVERIFY(widget->hasFocus());
+    }
+    QFETCH(bool, underMouse);
+    if (underMouse) {
+        view.resize(300, 300);
+        view.show();
+        QTest::qWaitForWindowShown(&view);
+        sendMouseMove(view.viewport(), view.mapFromScene(widget->mapToScene(widget->boundingRect().center())));
+    }
+
+    QFETCH(QPalette, palette);
+    widget->setPalette(palette);
+
+    QFETCH(QString, fontName);
+    widget->setFont(QFont(fontName));
+
+    // The test
+    widget->initStyleOption(&option);
+
+    bool isEnabled = option.state & QStyle::State_Enabled;
+    QCOMPARE(isEnabled, enabled);
+    bool hasFocus = option.state & QStyle::State_HasFocus;
+    QCOMPARE(hasFocus, focus);
+    bool isUnderMouse = option.state & QStyle::State_MouseOver;
+#ifndef Q_OS_WINCE
+    QCOMPARE(isUnderMouse, underMouse);
+#endif
+    // if (layoutDirection != Qt::LeftToRight)
+    //QEXPECT_FAIL("", "QApplicaiton::layoutDirection doesn't propagate to QGraphicsWidget", Continue);
+    //QCOMPARE(option.direction, layoutDirection);
+    QCOMPARE(option.rect, QRectF(QPointF(), size).toRect());
+    QCOMPARE(option.palette, palette.resolve(QApplication::palette()));
+    QCOMPARE(option.fontMetrics, QFontMetrics(widget->font()));
+}
+
+void tst_QGraphicsWidget::layout_data()
+{
+    QTest::addColumn<int>("childCount");
+    QTest::newRow("empty") << 0;
+    QTest::newRow("10") << 10;
+}
+
+// QGraphicsLayout* layout() const public
+void tst_QGraphicsWidget::layout()
+{
+    SubQGraphicsWidget widget;
+    widget.setContentsMargins(10, 5, 50, 100);
+    QCOMPARE(widget.layout(), (QGraphicsLayout *)0);
+    QFETCH(int, childCount);
+
+    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout;
+    QList<SubQGraphicsWidget*> children;
+    for (int i = 0; i < childCount; ++i) {
+        SubQGraphicsWidget *item = new SubQGraphicsWidget;
+        layout->addItem(item);
+        children.append(item);
+    }
+    QSignalSpy spy(&widget, SIGNAL(layoutChanged()));
+    widget.setLayout(layout);
+
+    QTRY_COMPARE(widget.layout(), static_cast<QGraphicsLayout*>(layout));
+    for (int i = 0; i < children.count(); ++i) {
+        SubQGraphicsWidget *item = children[i];
+        QCOMPARE(item->parentWidget(), (QGraphicsWidget *)&widget);
+        QVERIFY(item->geometry() != QRectF(0, 0, -1, -1));
+    }
+    QCOMPARE(spy.count(), 1);
+    // don't crash
+    widget.setLayout(0);
+}
+
+void tst_QGraphicsWidget::layoutDirection_data()
+{
+    QTest::addColumn<Qt::LayoutDirection>("layoutDirection");
+    QTest::newRow("rtl") << Qt::RightToLeft;
+    QTest::newRow("ltr") << Qt::LeftToRight;
+}
+
+// Qt::LayoutDirection layoutDirection() const public
+void tst_QGraphicsWidget::layoutDirection()
+{
+    QFETCH(Qt::LayoutDirection, layoutDirection);
+    QGraphicsScene scene;
+    QGraphicsView *view = new QGraphicsView(&scene);
+    SubQGraphicsWidget widget;
+    scene.addItem(&widget);
+    QCOMPARE(widget.layoutDirection(), Qt::LeftToRight);
+    QCOMPARE(widget.testAttribute(Qt::WA_SetLayoutDirection), false);
+
+    QList<SubQGraphicsWidget*> children;
+    for (int i = 0; i < 10; ++i) {
+        SubQGraphicsWidget *item = new SubQGraphicsWidget(&widget);
+        children.append(item);
+        QCOMPARE(item->testAttribute(Qt::WA_SetLayoutDirection), false);
+    }
+    widget.setLayoutDirection(layoutDirection);
+    QCOMPARE(widget.testAttribute(Qt::WA_SetLayoutDirection), true);
+    view->show();
+    QTest::qWaitForWindowShown(view);
+    for (int i = 0; i < children.count(); ++i) {
+        QTRY_COMPARE(children[i]->layoutDirection(), layoutDirection);
+        QTRY_COMPARE(children[i]->testAttribute(Qt::WA_SetLayoutDirection), false);
+        view->repaint();
+        QTRY_COMPARE(children[i]->m_painterLayoutDirection, layoutDirection);
+    }
+    delete view;
+}
+
+void tst_QGraphicsWidget::paint_data()
+{
+    // currently QGraphicsWidget doesn't paint or do anything ...
+}
+
+// void paint(QPainter* painter, QStyleOptionGraphicsItem const* option, QWidget* widget) public
+void tst_QGraphicsWidget::paint()
+{
+    SubQGraphicsWidget widget;
+    QPainter painter;
+    QStyleOptionGraphicsItem option;
+    widget.paint(&painter, &option, 0); // check that widget = 0 works.
+}
+
+void tst_QGraphicsWidget::palettePropagation()
+{
+    QGraphicsWidget *root = new QGraphicsWidget;
+    QGraphicsWidget *child0 = new QGraphicsWidget(root);
+    QGraphicsWidget *child1 = new QGraphicsWidget(child0);
+    QGraphicsWidget *child2 = new QGraphicsWidget(child1);
+    QGraphicsScene scene;
+    scene.addItem(root);
+
+    // These colors are unlikely to be imposed on the default palette of
+    // QWidget ;-).
+    QColor sysPalText(21, 22, 23);
+    QColor sysPalToolTipBase(12, 13, 14);
+    QColor overridePalText(42, 43, 44);
+    QColor overridePalToolTipBase(45, 46, 47);
+    QColor sysPalButton(99, 98, 97);
+
+    // Check that only the application fonts apply.
+    QPalette appPal = QApplication::palette();
+    QCOMPARE(scene.palette(), appPal);
+    QCOMPARE(root->palette(), appPal);
+    QCOMPARE(child0->palette(), appPal);
+    QCOMPARE(child1->palette(), appPal);
+
+    // Set child0's Text, and set ToolTipBase on child1.
+    QPalette textPalette;
+    textPalette.setColor(QPalette::Text, overridePalText);
+    child0->setPalette(textPalette);
+    QPalette toolTipPalette;
+    toolTipPalette.setColor(QPalette::ToolTipBase, overridePalToolTipBase);
+    child1->setPalette(toolTipPalette);
+
+    // Check that the above settings propagate correctly.
+    QCOMPARE(root->palette(), appPal);
+    QCOMPARE(scene.palette(), appPal);
+    QCOMPARE(child0->palette().color(QPalette::Text), overridePalText);
+    QCOMPARE(child0->palette().color(QPalette::ToolTipBase), appPal.color(QPalette::ToolTipBase));
+    QCOMPARE(child1->palette().color(QPalette::Text), overridePalText);
+    QCOMPARE(child1->palette().color(QPalette::ToolTipBase), overridePalToolTipBase);
+    QCOMPARE(child2->palette().color(QPalette::Text), overridePalText);
+    QCOMPARE(child2->palette().color(QPalette::ToolTipBase), overridePalToolTipBase);
+
+    QGraphicsWidget *child3 = new QGraphicsWidget(child2);
+    QCOMPARE(child3->palette().color(QPalette::Text), overridePalText);
+    QCOMPARE(child3->palette().color(QPalette::ToolTipBase), overridePalToolTipBase);
+
+    QGraphicsWidget *child4 = new QGraphicsWidget;
+    child4->setParentItem(child3);
+    QCOMPARE(child4->palette().color(QPalette::Text), overridePalText);
+    QCOMPARE(child4->palette().color(QPalette::ToolTipBase), overridePalToolTipBase);
+
+    // Replace the app palette for child2. Button should propagate but Text
+    // should still be ignored. The previous ToolTipBase setting is gone.
+    QPalette buttonPalette;
+    buttonPalette.setColor(QPalette::Button, sysPalButton);
+    child1->setPalette(buttonPalette);
+
+    QCOMPARE(root->palette(), appPal);
+    QCOMPARE(scene.palette(), appPal);
+    QCOMPARE(child0->palette().color(QPalette::Text), overridePalText);
+    QCOMPARE(child0->palette().color(QPalette::ToolTipBase), appPal.color(QPalette::ToolTipBase));
+    QCOMPARE(child1->palette().color(QPalette::Text), overridePalText);
+    QCOMPARE(child1->palette().color(QPalette::ToolTipBase), appPal.color(QPalette::ToolTipBase));
+    QCOMPARE(child1->palette().color(QPalette::Button), sysPalButton);
+    QCOMPARE(child2->palette().color(QPalette::Text), overridePalText);
+    QCOMPARE(child2->palette().color(QPalette::ToolTipBase), appPal.color(QPalette::ToolTipBase));
+    QCOMPARE(child2->palette().color(QPalette::Button), sysPalButton);
+}
+
+void tst_QGraphicsWidget::parentWidget_data()
+{
+    QTest::addColumn<int>("childrenCount");
+    QTest::newRow("0") << 0;
+    QTest::newRow("1") << 1;
+    QTest::newRow("10") << 10;
+}
+
+// QGraphicsWidget* parentWidget() const public
+void tst_QGraphicsWidget::parentWidget()
+{
+    QFETCH(int, childrenCount);
+    SubQGraphicsWidget standAlongWidget;
+    QGraphicsLineItem standAlongItem;
+
+    SubQGraphicsWidget widgetChild(&standAlongWidget);
+    SubQGraphicsWidget itemChild(&standAlongItem);
+
+    QCOMPARE(standAlongWidget.parentWidget(), (QGraphicsWidget*)0);
+    QCOMPARE(widgetChild.parentWidget(), static_cast<QGraphicsWidget*>(&standAlongWidget));
+    QCOMPARE(itemChild.parentWidget(), (QGraphicsWidget*)0);
+
+    for (int i = 0; i < childrenCount; ++i) {
+        SubQGraphicsWidget *item = new SubQGraphicsWidget(&standAlongWidget);
+        QCOMPARE(item->parentWidget(), static_cast<QGraphicsWidget*>(&standAlongWidget));
+    }
+}
+
+void tst_QGraphicsWidget::resize_data()
+{
+    QTest::addColumn<QSizeF>("size");
+    QTest::newRow("null") << QSizeF();
+    QTest::newRow("10x10") << QSizeF(10, 10);
+    QTest::newRow("10x-1") << QSizeF(10, -1);
+}
+
+// void resize(qreal w, qreal h) public
+void tst_QGraphicsWidget::resize()
+{
+    QFETCH(QSizeF, size);
+    SubQGraphicsWidget widget;
+
+    int oldEventCounts = widget.eventCount;
+    QSizeF oldSize = widget.size();
+    widget.resize(size);
+
+    QSizeF boundedSize = size.expandedTo(widget.minimumSize()).boundedTo(widget.maximumSize());
+    QCOMPARE(widget.eventCount, oldEventCounts + ((oldSize == boundedSize) ? 0 : 1));
+    QCOMPARE(widget.size(), boundedSize);
+}
+
+Q_DECLARE_METATYPE(Qt::WidgetAttribute)
+void tst_QGraphicsWidget::setAttribute_data()
+{
+    QTest::addColumn<Qt::WidgetAttribute>("attribute");
+    QTest::addColumn<bool>("supported");
+    QTest::newRow("WA_SetLayoutDirection") << Qt::WA_SetLayoutDirection << true;
+    QTest::newRow("WA_RightToLeft") << Qt::WA_RightToLeft << true;
+    QTest::newRow("WA_SetStyle") << Qt::WA_SetStyle << true;
+    QTest::newRow("WA_Resized") << Qt::WA_Resized << true;
+    QTest::newRow("unsupported") << Qt::WA_PaintOutsidePaintEvent << false;
+}
+
+// void setAttribute(Qt::WidgetAttribute attribute, bool on = true) public
+void tst_QGraphicsWidget::setAttribute()
+{
+    QFETCH(Qt::WidgetAttribute, attribute);
+    QFETCH(bool, supported);
+    SubQGraphicsWidget widget;
+    if (attribute == Qt::WA_PaintOutsidePaintEvent)
+        QTest::ignoreMessage(QtWarningMsg, "QGraphicsWidget::setAttribute: unsupported attribute 13");
+    widget.setAttribute(attribute);
+    QCOMPARE(widget.testAttribute(attribute), supported);
+}
+
+void tst_QGraphicsWidget::setStyle_data()
+{
+    QTest::addColumn<QString>("style");
+    QTest::newRow("null") << "";
+    QTest::newRow("cleanlooks") << "QCleanlooksStyle";
+}
+
+// void setStyle(QStyle* style) public
+void tst_QGraphicsWidget::setStyle()
+{
+    SubQGraphicsWidget widget;
+    QCleanlooksStyle cleanlooksStyle;
+
+    int oldEventCounts = widget.eventCount;
+
+    QFETCH(QString, style);
+    if (style == "QCleanlooksStyle") {
+        widget.setStyle(&cleanlooksStyle);
+        QCOMPARE(widget.style(), static_cast<QStyle*>(&cleanlooksStyle));
+    } else {
+        widget.setStyle(0);
+        QVERIFY(widget.style() != (QStyle *)0);
+    }
+    QCOMPARE(widget.eventCount, oldEventCounts + 1);
+    QCOMPARE(widget.testAttribute(Qt::WA_SetStyle), !style.isEmpty());
+
+    // cleanup
+    widget.setStyle(0);
+}
+
+void tst_QGraphicsWidget::setTabOrder_data()
+{
+    QTest::addColumn<int>("childrenCount");
+    QTest::newRow("0") << 0;
+    QTest::newRow("1") << 1;
+    QTest::newRow("10") << 10;
+}
+
+// void setTabOrder(QGraphicsWidget* first, QGraphicsWidget* second) public
+void tst_QGraphicsWidget::setTabOrder()
+{
+    QFETCH(int, childrenCount);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QApplication::setActiveWindow(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+
+    QGraphicsWidget *lastItem = 0;
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsWidget::setTabOrder(0, 0) is undefined");
+    QGraphicsWidget::setTabOrder(0, 0);
+
+    QList<SubQGraphicsWidget*> children;
+    for (int i = 0; i < childrenCount; ++i) {
+        SubQGraphicsWidget *item = new SubQGraphicsWidget();
+        item->setFocusPolicy(Qt::TabFocus);
+        children.append(item);
+        scene.addItem(item);
+        if (lastItem)
+            QGraphicsWidget::setTabOrder(lastItem, item);
+        lastItem = item;
+    }
+
+    if (!children.isEmpty()) {
+        QGraphicsWidget *first = children.first();
+        view.viewport()->setFocus();
+        QTRY_VERIFY(view.viewport()->hasFocus());
+        first->setFocus();
+        QVERIFY(first->hasFocus());
+        QVERIFY(scene.hasFocus());
+        QVERIFY(view.viewport()->hasFocus());
+
+        int currentItem = 0;
+        while (currentItem < children.count() - 1) {
+            QTest::keyPress(view.viewport(), Qt::Key_Tab);
+            ++currentItem;
+            QVERIFY(children[currentItem % children.size()]->hasFocus());
+        }
+    }
+}
+
+static bool compareFocusChain(QGraphicsView *view, const QList<QGraphicsItem*> &order)
+{
+    QGraphicsScene *scene = view->scene();
+    QStringList actual;
+    QGraphicsItem *oldFocusItem = scene->focusItem();
+    for (int i = 0; i < order.count(); ++i) {
+        QGraphicsItem *focusItem = scene->focusItem();
+        actual << focusItem->data(0).toString();
+        //qDebug() << "i:" << i << "expected:" << QString::number(uint(order.at(i)), 16) << QString::number(uint(focusItem), 16);
+        if (focusItem != order.at(i)) {
+            qDebug() << "actual:"  << actual;
+            scene->setFocusItem(oldFocusItem);
+            return false;
+        }
+        if (i < order.count() - 1)
+            QTest::keyPress(view, Qt::Key_Tab);
+    }
+    scene->setFocusItem(oldFocusItem);
+    return true;
+}
+
+void tst_QGraphicsWidget::setTabOrderAndReparent()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+
+    int i;
+    QGraphicsWidget *w1, *w2, *w3, *w4;
+    for (i = 1; i < 4; ++i) {
+        QGraphicsWidget *wid = new QGraphicsWidget;
+        wid->setFocusPolicy(Qt::StrongFocus);
+        wid->setData(0, QString::fromAscii("w%1").arg(i));
+        scene.addItem(wid);
+        if (i == 1)
+            w1 = wid;
+        else if (i == 2)
+            w2 = wid;
+        else if (i == 3)
+            w3 = wid;
+    }
+
+    w1->setFocus();
+    QTRY_VERIFY(w1->hasFocus());
+    QVERIFY(compareFocusChain(&view, QList<QGraphicsItem*>() << w1 << w2 << w3));
+
+    QGraphicsWidget *p = new QGraphicsWidget;
+    p->setData(0, QLatin1String("parent"));
+    p->setFocusPolicy(Qt::StrongFocus);
+
+    w1->setFocus();
+    QVERIFY(compareFocusChain(&view, QList<QGraphicsItem*>() << w1 << w2 << w3));
+
+    w1->setParentItem(p);
+    w2->setFocus();
+    QVERIFY(compareFocusChain(&view, QList<QGraphicsItem*>() <<  w2 << w3));
+
+    w2->setParentItem(p);
+    w3->setFocus();
+    QVERIFY(compareFocusChain(&view, QList<QGraphicsItem*>() << w3));
+    w3->setParentItem(p);
+    QCOMPARE(scene.focusItem(), static_cast<QGraphicsItem*>(0));
+
+    scene.addItem(p);
+    p->setFocus();
+
+    QVERIFY(compareFocusChain(&view, QList<QGraphicsItem*>() << p << w1 << w2 << w3));
+    delete p;
+
+    for (i = 1; i < 5; ++i) {
+        QGraphicsWidget *wid = new QGraphicsWidget;
+        wid->setFocusPolicy(Qt::StrongFocus);
+        wid->setData(0, QString::fromAscii("w%1").arg(i));
+        scene.addItem(wid);
+        if (i == 1)
+            w1 = wid;
+        else if (i == 2)
+            w2 = wid;
+        else if (i == 3)
+            w3 = wid;
+        else if (i == 4)
+            w4 = wid;
+    }
+    w4->setParentItem(w1);
+    QGraphicsWidget::setTabOrder(w1, w4);
+    w1->setFocus();
+    QVERIFY(compareFocusChain(&view, QList<QGraphicsItem*>() << w1 << w4 << w2 << w3));
+
+    p = new QGraphicsWidget;
+    p->setData(0, QLatin1String("parent"));
+    p->setFocusPolicy(Qt::StrongFocus);
+
+    w1->setParentItem(p);
+    w2->setFocus();
+    QVERIFY(compareFocusChain(&view, QList<QGraphicsItem*>() << w2 << w3));
+
+    scene.addItem(p);
+    w2->setFocus();
+    QVERIFY(compareFocusChain(&view, QList<QGraphicsItem*>() << w2 << w3 << p << w1 << w4));
+}
+
+void tst_QGraphicsWidget::topLevelWidget_data()
+{
+    QTest::addColumn<QString>("str");
+    QTest::newRow("test one") << "foo";
+}
+
+// QGraphicsWidget* topLevelWidget() const public
+void tst_QGraphicsWidget::topLevelWidget()
+{
+    QFETCH(QString, str);
+    SubQGraphicsWidget widget;
+    QCOMPARE(widget.topLevelWidget(), (QGraphicsWidget *)&widget);
+}
+
+void tst_QGraphicsWidget::unsetLayoutDirection_data()
+{
+    QTest::addColumn<Qt::LayoutDirection>("layoutDirection");
+    QTest::newRow("rtl") << Qt::RightToLeft;
+    QTest::newRow("ltr") << Qt::LeftToRight;
+}
+
+// void unsetLayoutDirection() public
+void tst_QGraphicsWidget::unsetLayoutDirection()
+{
+    QApplication::setLayoutDirection(Qt::LeftToRight);
+    QFETCH(Qt::LayoutDirection, layoutDirection);
+    SubQGraphicsWidget widget;
+    QCOMPARE(Qt::LeftToRight, widget.layoutDirection());
+
+    QList<SubQGraphicsWidget*> children;
+    for (int i = 0; i < 10; ++i) {
+        SubQGraphicsWidget *item = new SubQGraphicsWidget(&widget);
+        children.append(item);
+    }
+    widget.setLayoutDirection(layoutDirection);
+    widget.unsetLayoutDirection();
+    QCOMPARE(widget.testAttribute(Qt::WA_SetLayoutDirection), false);
+    for (int i = 0; i < children.count(); ++i) {
+        QCOMPARE(children[i]->layoutDirection(), Qt::LeftToRight);
+    }
+}
+
+void tst_QGraphicsWidget::focusNextPrevChild_data()
+{
+    QTest::addColumn<QString>("str");
+    QTest::newRow("test one") << "foo";
+}
+
+// bool focusNextPrevChild(bool next) protected
+void tst_QGraphicsWidget::focusNextPrevChild()
+{
+    QFETCH(QString, str);
+    SubQGraphicsWidget widget;
+    // ### write test after just calling it stops crashing :)
+    widget.call_focusNextPrevChild(true);
+}
+
+void tst_QGraphicsWidget::verifyFocusChain()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    QTest::qWaitForWindowShown(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+
+    {
+        // parent/child focus
+        SubQGraphicsWidget *w = new SubQGraphicsWidget(0, Qt::Window);
+        w->setFocusPolicy(Qt::StrongFocus);
+        SubQGraphicsWidget *w1_1 = new SubQGraphicsWidget(w);
+        w1_1->setFocusPolicy(Qt::StrongFocus);
+        scene.addItem(w);
+        w->setFocus();
+        QVERIFY(w->hasFocus());
+        w->call_focusNextPrevChild(true);
+        QVERIFY(w1_1->hasFocus());
+        delete w;
+    }
+
+    {
+        // delete item in focus chain and verify chain
+        SubQGraphicsWidget *w = new SubQGraphicsWidget(0, Qt::Window);
+        SubQGraphicsWidget *w1_1 = new SubQGraphicsWidget(w);
+        SubQGraphicsWidget *w1_2 = new SubQGraphicsWidget(w);
+        SubQGraphicsWidget *w1_3 = new SubQGraphicsWidget(w);
+        w1_1->setFocusPolicy(Qt::StrongFocus);
+        w1_2->setFocusPolicy(Qt::StrongFocus);
+        w1_3->setFocusPolicy(Qt::StrongFocus);
+        scene.addItem(w);
+        w1_1->setFocus();
+        QVERIFY(w1_1->hasFocus());
+        QCOMPARE(w->call_focusNextPrevChild(true), true);
+        QVERIFY(w1_2->hasFocus());
+        QCOMPARE(w->call_focusNextPrevChild(true), true);
+        QVERIFY(w1_3->hasFocus());
+        w1_1->setFocus();
+        delete w1_2;
+        w->call_focusNextPrevChild(true);
+        QVERIFY(w1_3->hasFocus());
+        delete w;
+    }
+    {
+        // parent/child focus
+        SubQGraphicsWidget *w = new SubQGraphicsWidget(0, Qt::Window);
+        w->setFocusPolicy(Qt::StrongFocus);
+        SubQGraphicsWidget *w1_1 = new SubQGraphicsWidget(w);
+        w1_1->setFocusPolicy(Qt::StrongFocus);
+        scene.addItem(w);
+        w->setFocus();
+        QVERIFY(w->hasFocus());
+        w->call_focusNextPrevChild(true);
+        QVERIFY(w1_1->hasFocus());
+        delete w;
+    }
+    {
+        // remove the tabFocusFirst widget from the scene.
+        QWidget *window = new QWidget;
+        QVBoxLayout *layout = new QVBoxLayout;
+        window->setLayout(layout);
+        QLineEdit *lineEdit = new QLineEdit;
+        layout->addWidget(lineEdit);
+        QGraphicsView *view = new QGraphicsView(&scene);
+        scene.setSceneRect(-20, -20, 200, 50);
+        layout->addWidget(view);
+        view->setMinimumSize(150, 50);
+        SubQGraphicsWidget *w1_1 = new SubQGraphicsWidget;
+        w1_1->setData(0, "w1_1");
+        w1_1->setGeometry(0,0,25, 25);
+        w1_1->setFocusPolicy(Qt::StrongFocus);
+        scene.addItem(w1_1);
+        SubQGraphicsWidget *w1_2 = new SubQGraphicsWidget;
+        w1_2->setData(0, "w1_2");
+        w1_2->setGeometry(25,0,25, 25);
+        w1_2->setFocusPolicy(Qt::StrongFocus);
+        scene.addItem(w1_2);
+        window->show();
+        QApplication::setActiveWindow(window);
+        QTest::qWaitForWindowShown(window);
+
+        lineEdit->setFocus();
+        QTRY_VERIFY(lineEdit->hasFocus());
+        QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+        QTRY_VERIFY(w1_1->hasFocus());
+        QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+        QTRY_VERIFY(w1_2->hasFocus());
+
+        // remove the tabFocusFirst and insert new item
+        delete w1_1;            // calls _q_removeItemLater
+        SubQGraphicsWidget *w1_3 = new SubQGraphicsWidget;
+        w1_3->setFocusPolicy(Qt::StrongFocus);
+        w1_3->setData(0, "w1_3");
+        w1_3->setGeometry(50,0,25, 25);
+        scene.addItem(w1_3);
+        QTRY_VERIFY(w1_2->hasFocus());
+        QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+        QTRY_VERIFY(lineEdit->hasFocus());
+        // tabFocusFirst should now point to w1_2
+        QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+        QTRY_VERIFY(w1_2->hasFocus());
+        QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+        QTRY_VERIFY(w1_3->hasFocus());
+        scene.removeItem(w1_2);   // does not call _q_removeItemLater
+        delete w1_2;            // calls _q_removeItemLater
+
+        SubQGraphicsWidget *w1_4 = new SubQGraphicsWidget;
+        w1_4->setFocusPolicy(Qt::StrongFocus);
+        w1_4->setData(0, "w1_4");
+        w1_4->setGeometry(75,0,25, 25);
+        scene.addItem(w1_4);
+        QTRY_VERIFY(w1_3->hasFocus());
+        QTRY_VERIFY(compareFocusChain(view, QList<QGraphicsItem*>() << w1_3 << w1_4));
+        QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+        QTRY_VERIFY(lineEdit->hasFocus());
+        // tabFocusFirst should now point to w1_3
+        QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+        QTRY_VERIFY(w1_3->hasFocus());
+        QTRY_VERIFY(compareFocusChain(view, QList<QGraphicsItem*>() << w1_3 << w1_4));
+        delete window;
+    }
+}
+
+void tst_QGraphicsWidget::updateFocusChainWhenChildDie()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QApplication::setActiveWindow(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+
+    // delete item in focus chain with no focus and verify chain
+    SubQGraphicsWidget *parent = new SubQGraphicsWidget(0, Qt::Window);
+    SubQGraphicsWidget *w = new SubQGraphicsWidget(0, Qt::Window);
+    w->resize(50,50);
+    w->resize(100,100);
+    SubQGraphicsWidget *w1_1 = new SubQGraphicsWidget(w);
+    w1_1->setFocusPolicy(Qt::StrongFocus);
+    w->setFocusPolicy(Qt::StrongFocus);
+    scene.addItem(w);
+    scene.addItem(parent);
+    w1_1->setFocus();
+
+    QVERIFY(w1_1->hasFocus());
+    QWidget myWidget(0);
+    QLineEdit edit(&myWidget);
+    myWidget.show();
+    edit.setFocus();
+    QTRY_VERIFY(edit.hasFocus());
+    delete w1_1;
+    myWidget.hide();
+    w->setParentItem(parent);
+    //We don't crash perfect
+    QVERIFY(w);
+    QTest::mouseMove(view.viewport());
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0);
+    QTRY_COMPARE(qApp->activeWindow(), static_cast<QWidget *>(&view));
+    QTRY_COMPARE(scene.focusItem(), static_cast<QGraphicsItem *>(w));
+}
+
+void tst_QGraphicsWidget::sizeHint_data()
+{
+    QTest::addColumn<bool>("layout");
+    QTest::newRow("no layout") << false;
+    QTest::newRow("layout") << true;
+}
+
+// QSizeF sizeHint(Qt::SizeHint which, QSizeF const& constraint = QSizeF()) const protected
+void tst_QGraphicsWidget::sizeHint()
+{
+    QFETCH(bool, layout);
+    SubQGraphicsWidget widget;
+
+    if (layout) {
+        QGraphicsLinearLayout *layout = new QGraphicsLinearLayout;
+        widget.setLayout(layout);
+    }
+    widget.call_sizeHint(Qt::MinimumSize, QSizeF());
+}
+
+void tst_QGraphicsWidget::consistentPosSizeGeometry_data()
+{
+    QTest::addColumn<QSizeF>("minSize");
+    QTest::addColumn<QSizeF>("maxSize");
+    QTest::addColumn<QRectF>("geometry");
+    QTest::addColumn<QRectF>("expectedGeometry");
+
+    QTest::newRow("size is valid") << QSizeF(0, 0) << QSizeF(200, 200) << QRectF(0, 0, 100, 100) << QRectF(0, 0, 100, 100);
+    QTest::newRow("size is larger than max") << QSizeF(0, 0) << QSizeF(50, 50) << QRectF(0, 0, 100, 100) << QRectF(0, 0, 50, 50);
+    QTest::newRow("size is smaller than min") << QSizeF(50, 50) << QSizeF(150, 150) << QRectF(0, 0, 10, 10) << QRectF(0, 0, 50, 50);
+}
+
+void tst_QGraphicsWidget::consistentPosSizeGeometry()
+{
+    QFETCH(QSizeF, minSize);
+    QFETCH(QSizeF, maxSize);
+    QFETCH(QRectF, geometry);
+    QFETCH(QRectF, expectedGeometry);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *w = new QGraphicsWidget;
+    scene.addItem(w);
+    w->setMinimumSize(minSize);
+    w->setMaximumSize(maxSize);
+    w->setGeometry(geometry);
+    QCOMPARE(w->geometry(), expectedGeometry);
+    QCOMPARE(w->pos(), expectedGeometry.topLeft());
+    QCOMPARE(w->size(), expectedGeometry.size());
+
+    QRectF otherGeom = QRectF(QPointF(12.34,12.34), minSize);
+    w->setGeometry(otherGeom);
+    QCOMPARE(w->geometry(), otherGeom);
+    QCOMPARE(w->pos(), otherGeom.topLeft());
+    QCOMPARE(w->size(), otherGeom.size());
+
+    w->setPos(geometry.topLeft());
+    QCOMPARE(w->geometry().topLeft(), expectedGeometry.topLeft());
+    QCOMPARE(w->pos(), expectedGeometry.topLeft());
+
+    w->resize(geometry.size());
+    QCOMPARE(w->geometry().size(), expectedGeometry.size());
+    QCOMPARE(w->geometry(), expectedGeometry);
+
+    view.show();
+
+}
+
+
+enum WhichSize {
+    MinimumWidth,
+    PreferredWidth,
+    MaximumWidth,
+    MinimumHeight,
+    PreferredHeight,
+    MaximumHeight,
+    MinimumSize,
+    PreferredSize,
+    MaximumSize,
+    MinimumSizeHint,
+    PreferredSizeHint,
+    MaximumSizeHint,
+    Size,
+    None,
+};
+
+typedef QPair<int, QVariant> Inst;
+
+Q_DECLARE_METATYPE(Inst)
+Q_DECLARE_METATYPE(QVector<Inst>)
+
+void tst_QGraphicsWidget::setSizes_data()
+{
+
+    QTest::addColumn<QVector<Inst> >("inputInstructions");
+    QTest::addColumn<QVector<Inst> >("compareInstructions");
+
+    QTest::newRow("minSize1") << (QVector<Inst>() << Inst(Size, QSize(25, 25)) << Inst(MinimumSize, QSize(10, 10)))
+                                << (QVector<Inst>() << Inst(Size, QSize(25,25)));
+    QTest::newRow("minSize2") << (QVector<Inst>() << Inst(Size, QSizeF(20, 20)) << Inst(MinimumSize, QSizeF(25, 25)))
+                                 << (QVector<Inst>() << Inst(Size, QSizeF(25, 25)));
+    QTest::newRow("minWidth1") << (QVector<Inst>() << Inst(Size, QSizeF(20, 20)) << Inst(MinimumWidth, 5.0))
+                                 << (QVector<Inst>() << Inst(Size, QSizeF(20, 20)));
+    QTest::newRow("minWidth2") << (QVector<Inst>() << Inst(Size, QSizeF(20, 20)) << Inst(MinimumWidth, 25.0))
+                                 << (QVector<Inst>() << Inst(Size, QSizeF(25, 20)));
+    QTest::newRow("minHeight1") << (QVector<Inst>() << Inst(Size, QSizeF(20, 20)) << Inst(MinimumHeight, 5.0))
+                                 << (QVector<Inst>() << Inst(Size, QSizeF(20, 20)));
+    QTest::newRow("minHeight2") << (QVector<Inst>() << Inst(Size, QSizeF(20, 20)) << Inst(MinimumHeight, 25.0))
+                                 << (QVector<Inst>() << Inst(Size, QSizeF(20, 25)));
+    QTest::newRow("maxSize1") << (QVector<Inst>() << Inst(Size, QSizeF(40, 40)) << Inst(MaximumSize, QSizeF(30, 30)))
+                                 << (QVector<Inst>() << Inst(Size, QSizeF(30, 30)));
+    QTest::newRow("maxSize2") << (QVector<Inst>() << Inst(Size, QSizeF(40, 40)) << Inst(MaximumSize, QSizeF(30, -1)))
+                                 << (QVector<Inst>() << Inst(Size, QSizeF(30, 40)));
+    QTest::newRow("maxSize3") << (QVector<Inst>() << Inst(Size, QSizeF(40, 40)) << Inst(MaximumSize, QSizeF(-1, 30)))
+                                 << (QVector<Inst>() << Inst(Size, QSizeF(40, 30)));
+    QTest::newRow("maxWidth1")<< (QVector<Inst>() << Inst(Size, QSizeF(40, 40)) << Inst(MaximumWidth, 30))
+                                 << (QVector<Inst>() << Inst(Size, QSizeF(30, 40)));
+    QTest::newRow("maxHeight")<< (QVector<Inst>() << Inst(Size, QSizeF(40, 40)) << Inst(MaximumHeight, 20))
+                                 << (QVector<Inst>() << Inst(Size, QSizeF(40, 20)));
+    QTest::newRow("unsetMinSize")<< (QVector<Inst>() << Inst(Size, QSizeF(40, 40)) << Inst(MinimumSize, QSizeF(-1, -1)))
+                                 << (QVector<Inst>() << Inst(MinimumSize, QSizeF(5, 5)));
+    QTest::newRow("unsetMaxSize")<< (QVector<Inst>() << Inst(Size, QSizeF(40, 40)) << Inst(MaximumSize, QSizeF(-1, -1)))
+                                 << (QVector<Inst>() << Inst(MaximumSize, QSizeF(500, 500)));
+    QTest::newRow("unsetMinSize, expand size to minimumSizeHint") << (QVector<Inst>()
+                                        << Inst(MinimumSize, QSize(0, 0))
+                                        << Inst(Size, QSize(1,1))
+                                        << Inst(MinimumSize, QSize(-1.0, -1.0))
+                                        )
+                                    << (QVector<Inst>()
+                                        << Inst(Size, QSize(5,5))
+                                        << Inst(MinimumSize, QSize(5,5))
+                                        );
+
+}
+
+void tst_QGraphicsWidget::setSizes()
+{
+    QFETCH(QVector<Inst>, inputInstructions);
+    QFETCH(QVector<Inst>, compareInstructions);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    SizeHinter *widget = new SizeHinter(0, Qt::Window);
+    QSizeF min = QSizeF(10, 10);
+    QSizeF pref = QSizeF(25, 25);
+    QSizeF max = QSizeF(50, 50);
+
+    int i;
+    for (i = 0; i < inputInstructions.count(); ++i) {
+        Inst input = inputInstructions.at(i);
+
+        // defaults
+        switch (input.first) {
+            case MinimumSize:
+                min = input.second.toSizeF();
+                break;
+            case PreferredSize:
+                pref = input.second.toSizeF();
+                break;
+            case MaximumSize:
+                max = input.second.toSizeF();
+                break;
+            case Size:
+                widget->resize(input.second.toSizeF());
+                break;
+            case MinimumWidth:
+                widget->setMinimumWidth(qreal(input.second.toDouble()));
+                break;
+            case PreferredWidth:
+                widget->setPreferredWidth(qreal(input.second.toDouble()));
+                break;
+            case MaximumWidth:
+                widget->setMaximumWidth(qreal(input.second.toDouble()));
+                break;
+            case MinimumHeight:
+                widget->setMinimumHeight(qreal(input.second.toDouble()));
+                break;
+            case PreferredHeight:
+                widget->setPreferredHeight(qreal(input.second.toDouble()));
+                break;
+            case MaximumHeight:
+                widget->setMaximumHeight(qreal(input.second.toDouble()));
+                break;
+            case MinimumSizeHint:
+                widget->setSizeHint(Qt::MinimumSize, input.second.toSizeF());
+                break;
+            case PreferredSizeHint:
+                widget->setSizeHint(Qt::PreferredSize, input.second.toSizeF());
+                break;
+            case MaximumSizeHint:
+                widget->setSizeHint(Qt::MaximumSize, input.second.toSizeF());
+                break;
+            default:
+                qWarning("instruction not implemented");
+                break;
+        }
+    }
+
+    widget->setMinimumSize(min);
+    widget->setPreferredSize(pref);
+    widget->setMaximumSize(max);
+
+    for (i = 0; i < compareInstructions.count(); ++i) {
+        Inst input = compareInstructions.at(i);
+        switch (input.first) {
+            case MinimumSize:
+                QTRY_COMPARE(widget->minimumSize(), input.second.toSizeF());
+                break;
+            case PreferredSize:
+                QTRY_COMPARE(widget->preferredSize(), input.second.toSizeF());
+                break;
+            case MaximumSize:
+                QTRY_COMPARE(widget->maximumSize(), input.second.toSizeF());
+                break;
+            case Size:
+                QTRY_COMPARE(widget->size(), input.second.toSizeF());
+                break;
+            case MinimumWidth:
+                QTRY_COMPARE(widget->minimumWidth(), qreal(input.second.toDouble()));
+                break;
+            case PreferredWidth:
+                QTRY_COMPARE(widget->preferredWidth(), qreal(input.second.toDouble()));
+                break;
+            case MaximumWidth:
+                QTRY_COMPARE(widget->maximumWidth(), qreal(input.second.toDouble()));
+                break;
+            default:
+                qWarning("instruction not implemented");
+                break;
+        }
+    }
+    delete widget;
+}
+
+void tst_QGraphicsWidget::closePopupOnOutsideClick()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Popup);
+    widget->resize(100, 100);
+
+    QGraphicsScene scene;
+    scene.addItem(widget);
+
+    QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+    event.ignore();
+    event.setScenePos(QPointF(50, 50));
+    qApp->sendEvent(&scene, &event);
+
+    QVERIFY(widget->isVisible());
+    QVERIFY(event.isAccepted());
+
+    event.ignore();
+    event.setScenePos(QPointF(150, 150));
+    qApp->sendEvent(&scene, &event);
+
+    QVERIFY(!widget->isVisible());
+    QVERIFY(event.isAccepted());
+}
+
+void tst_QGraphicsWidget::task236127_bspTreeIndexFails()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsWidget *widget2 = new QGraphicsWidget;
+    widget->resize(10, 10);
+    widget2->resize(10, 10);
+    widget2->setZValue(1);
+    QCOMPARE(widget2->zValue(), qreal(1));
+    QCOMPARE(widget->zValue(), qreal(0));
+    widget->setData(0, "widget");
+    widget2->setData(0, "widget2");
+
+    QGraphicsScene scene;
+    scene.addItem(widget);
+    scene.addItem(widget2);
+
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+
+    QTRY_VERIFY(!scene.itemAt(25, 25));
+    widget->setGeometry(0, 112, 360, 528);
+    QTRY_COMPARE(scene.itemAt(15, 120), (QGraphicsItem *)widget);
+    widget2->setGeometry(0, 573, 360, 67);
+    QTRY_COMPARE(scene.itemAt(15, 120), (QGraphicsItem *)widget);
+    QTRY_COMPARE(scene.itemAt(50, 585), (QGraphicsItem *)widget2);
+}
+
+void tst_QGraphicsWidget::defaultSize()
+{
+    SubQGraphicsWidget *widget = new SubQGraphicsWidget;
+    widget->setMinimumSize(40, 40);
+    QGraphicsScene scene;
+    scene.addItem(widget);
+
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QSizeF initialSize = widget->size();
+
+    widget->resize(initialSize);
+    QCOMPARE(widget->geometry().size(), initialSize);
+    widget->setVisible(false);
+    widget->setMinimumSize(10, 10);
+    widget->setPreferredSize(60, 60);
+    widget->setMaximumSize(110, 110);
+    widget->setVisible(true);
+    // should still have its size set to initialsize
+    QTRY_COMPARE(widget->geometry().size(), initialSize);
+
+}
+
+void tst_QGraphicsWidget::explicitMouseGrabber()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    EventSpy widgetGrabEventSpy(widget, QEvent::GrabMouse);
+    EventSpy widgetUngrabEventSpy(widget, QEvent::UngrabMouse);
+
+    // Grab without scene
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsItem::grabMouse: cannot grab mouse without scene");
+    widget->grabMouse();
+    QCOMPARE(widgetGrabEventSpy.count(), 0);
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsItem::ungrabMouse: cannot ungrab mouse without scene");
+    widget->ungrabMouse();
+    QCOMPARE(widgetUngrabEventSpy.count(), 0);
+
+    // Add to scene
+    QGraphicsScene scene;
+    scene.addItem(widget);
+
+    // Ungrab while not grabber
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsItem::ungrabMouse: not a mouse grabber");
+    widget->ungrabMouse();
+
+    // Simple grab with scene
+    QVERIFY(!scene.mouseGrabberItem());
+    widget->grabMouse();
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget);
+    QCOMPARE(widgetGrabEventSpy.count(), 1);
+    widget->ungrabMouse();
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+    QCOMPARE(widgetUngrabEventSpy.count(), 1);
+
+    // Grab while grabbing
+    widget->grabMouse();
+    QCOMPARE(widgetGrabEventSpy.count(), 2);
+    QTest::ignoreMessage(QtWarningMsg, "QGraphicsItem::grabMouse: already a mouse grabber");
+    widget->grabMouse();
+    QCOMPARE(widgetGrabEventSpy.count(), 2);
+    QCOMPARE(widgetUngrabEventSpy.count(), 1);
+    widget->ungrabMouse();
+    QCOMPARE(widgetUngrabEventSpy.count(), 2);
+
+    // Add two more widgets to the scene
+    QGraphicsWidget *widget2 = new QGraphicsWidget;
+    scene.addItem(widget2);
+    EventSpy widget2GrabEventSpy(widget2, QEvent::GrabMouse);
+    EventSpy widget2UngrabEventSpy(widget2, QEvent::UngrabMouse);
+    QGraphicsWidget *widget3 = new QGraphicsWidget;
+    scene.addItem(widget3);
+    EventSpy widget3GrabEventSpy(widget3, QEvent::GrabMouse);
+    EventSpy widget3UngrabEventSpy(widget3, QEvent::UngrabMouse);
+
+    widget->setData(0, "widget");
+    widget2->setData(0, "widget2");
+    widget3->setData(0, "widget3");
+
+    // Simple nested grabbing
+    widget->grabMouse();
+    QCOMPARE(widgetGrabEventSpy.count(), 3);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget);
+    widget2->grabMouse();
+    QCOMPARE(widgetUngrabEventSpy.count(), 3);
+    QCOMPARE(widget2GrabEventSpy.count(), 1);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget2);
+    widget3->grabMouse();
+    QCOMPARE(widget2UngrabEventSpy.count(), 1);
+    QCOMPARE(widget3GrabEventSpy.count(), 1);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget3);
+    widget3->ungrabMouse();
+    QCOMPARE(widget3UngrabEventSpy.count(), 1);
+    QCOMPARE(widget2GrabEventSpy.count(), 2);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget2);
+    widget2->ungrabMouse();
+    QCOMPARE(widget2UngrabEventSpy.count(), 2);
+    QCOMPARE(widgetGrabEventSpy.count(), 4);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget);
+    widget->ungrabMouse();
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+
+    // Out of order ungrab
+    widget->grabMouse();
+    QCOMPARE(widgetGrabEventSpy.count(), 5);
+    widget2->grabMouse();
+    QCOMPARE(widget2GrabEventSpy.count(), 3);
+    widget3->grabMouse();
+    QCOMPARE(widget3GrabEventSpy.count(), 2);
+    widget2->ungrabMouse();
+    QCOMPARE(widget3UngrabEventSpy.count(), 2);
+    QCOMPARE(widget2UngrabEventSpy.count(), 4);
+    QCOMPARE(widgetGrabEventSpy.count(), 6);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget);
+}
+
+void tst_QGraphicsWidget::implicitMouseGrabber()
+{
+    QGraphicsScene scene;
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    widget->setFlag(QGraphicsItem::ItemIsMovable); // can grab mouse
+    widget->resize(200, 200);
+    EventSpy widgetGrabEventSpy(widget, QEvent::GrabMouse);
+    EventSpy widgetUngrabEventSpy(widget, QEvent::UngrabMouse);
+    scene.addItem(widget);
+
+    QVERIFY(!scene.mouseGrabberItem());
+
+    // Click on an item, see if gain and lose implicit mouse grab.
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+        event.ignore();
+        event.setButton(Qt::LeftButton);
+        event.setScenePos(QPointF(50, 50));
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget);
+    QCOMPARE(widgetGrabEventSpy.count(), 1);
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseRelease);
+        event.ignore();
+        event.setButton(Qt::LeftButton);
+        event.setScenePos(QPointF(50, 50));
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+    QCOMPARE(widgetGrabEventSpy.count(), 1);
+    QCOMPARE(widgetUngrabEventSpy.count(), 1);
+
+    // Click on an item that already grabs the mouse. Shouldn't have any effect.
+    widget->grabMouse();
+    QCOMPARE(widgetGrabEventSpy.count(), 2);
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+        event.ignore();
+        event.setButton(Qt::LeftButton);
+        event.setScenePos(QPointF(50, 50));
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget);
+    QCOMPARE(widgetGrabEventSpy.count(), 2);
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseRelease);
+        event.ignore();
+        event.setButton(Qt::LeftButton);
+        event.setScenePos(QPointF(50, 50));
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget);
+    QCOMPARE(widgetGrabEventSpy.count(), 2);
+    QCOMPARE(widgetUngrabEventSpy.count(), 1);
+    widget->ungrabMouse();
+    QCOMPARE(widgetUngrabEventSpy.count(), 2);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+
+    // Implicit mouse grabber tries to explicitly grab the mouse
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+        event.ignore();
+        event.setButton(Qt::LeftButton);
+        event.setScenePos(QPointF(50, 50));
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget);
+    QCOMPARE(widgetGrabEventSpy.count(), 3);
+    widget->grabMouse();
+    QCOMPARE(widgetUngrabEventSpy.count(), 2);
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseRelease);
+        event.ignore();
+        event.setButton(Qt::LeftButton);
+        event.setScenePos(QPointF(50, 50));
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget);
+    QCOMPARE(widgetGrabEventSpy.count(), 3);
+    QCOMPARE(widgetUngrabEventSpy.count(), 2);
+    widget->ungrabMouse();
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+    QCOMPARE(widgetGrabEventSpy.count(), 3);
+    QCOMPARE(widgetUngrabEventSpy.count(), 3);
+
+    // Arrival of a new widget
+    QGraphicsWidget *widget2 = new QGraphicsWidget;
+    widget2->setFlag(QGraphicsItem::ItemIsMovable); // can grab mouse
+    widget2->resize(200, 200);
+    widget2->setPos(205, 0);
+    EventSpy widget2GrabEventSpy(widget2, QEvent::GrabMouse);
+    EventSpy widget2UngrabEventSpy(widget2, QEvent::UngrabMouse);
+    scene.addItem(widget2);
+
+    // Implicit grab while there's an explicit grab is not possible.
+    widget->grabMouse();
+    QCOMPARE(widgetGrabEventSpy.count(), 4);
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+        event.ignore();
+        event.setButton(Qt::LeftButton);
+        event.setScenePos(QPointF(250, 50));
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget);
+    QCOMPARE(widgetGrabEventSpy.count(), 4);
+    QCOMPARE(widget2GrabEventSpy.count(), 0);
+    QCOMPARE(widget2UngrabEventSpy.count(), 0);
+
+    scene.removeItem(widget);
+    QCOMPARE(widgetUngrabEventSpy.count(), 4);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+}
+
+class GrabOnPressItem : public QGraphicsRectItem
+{
+public:
+    GrabOnPressItem(const QRectF &rect)
+        : QGraphicsRectItem(rect),
+          npress(0), nrelease(0), ndoubleClick(0),
+          ngrab(0), nungrab(0)
+    {
+    }
+    int npress;
+    int nrelease;
+    int ndoubleClick;
+    int ngrab;
+    int nungrab;
+protected:
+    bool sceneEvent(QEvent *event)
+    {
+        switch (event->type()) {
+        case QEvent::GrabMouse:
+            ++ngrab;
+            break;
+        case QEvent::UngrabMouse:
+            ++nungrab;
+            break;
+        default:
+            break;
+        }
+        return QGraphicsRectItem::sceneEvent(event);
+    }
+
+    void mousePressEvent(QGraphicsSceneMouseEvent *)
+    {
+        grabMouse();
+        ++npress;
+    }
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent *)
+    {
+        ungrabMouse();
+        ++nrelease;
+    }
+    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *)
+    {
+        ++ndoubleClick;
+    }
+};
+
+void tst_QGraphicsWidget::doubleClickAfterExplicitMouseGrab()
+{
+    QGraphicsScene scene;
+    GrabOnPressItem *item = new GrabOnPressItem(QRectF(0, 0, 100, 100));
+    scene.addItem(item);
+
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+        event.setButton(Qt::LeftButton);
+        event.setButtons(Qt::LeftButton);
+        event.ignore();
+        event.setScenePos(QPointF(50, 50));
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)item);
+    QCOMPARE(item->npress, 1);
+    QCOMPARE(item->ngrab, 1);
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseRelease);
+        event.setButton(Qt::LeftButton);
+        event.setButtons(0);
+        event.ignore();
+        event.setScenePos(QPointF(50, 50));
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+    QCOMPARE(item->nrelease, 1);
+    QCOMPARE(item->nungrab, 1);
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseDoubleClick);
+        event.setButton(Qt::LeftButton);
+        event.setButtons(Qt::LeftButton);
+        event.ignore();
+        event.setScenePos(QPointF(50, 50));
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)item);
+    QCOMPARE(item->ndoubleClick, 1);
+    QCOMPARE(item->ngrab, 2);
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseRelease);
+        event.setButton(Qt::LeftButton);
+        event.setButtons(0);
+        event.ignore();
+        event.setScenePos(QPointF(50, 50));
+        qApp->sendEvent(&scene, &event);
+    }
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+    QCOMPARE(item->nrelease, 2);
+    QCOMPARE(item->nungrab, 2);
+}
+
+void tst_QGraphicsWidget::popupMouseGrabber()
+{
+    QGraphicsScene scene;
+    QGraphicsWidget *widget = new QGraphicsWidget(0, Qt::Popup);
+    widget->setFlag(QGraphicsItem::ItemIsMovable); // can grab mouse
+    widget->resize(200, 200);
+    EventSpy widgetGrabEventSpy(widget, QEvent::GrabMouse);
+    EventSpy widgetUngrabEventSpy(widget, QEvent::UngrabMouse);
+
+    // Simply adding a visible popup to the scene immediately grabs the mouse.
+    scene.addItem(widget);
+    QCOMPARE(widgetGrabEventSpy.count(), 1);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget);
+
+    // Hiding it loses the grab again.
+    widget->hide();
+    QCOMPARE(widgetUngrabEventSpy.count(), 1);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);
+
+    // Showing it grabs the mouse again
+    widget->show();
+    QCOMPARE(widgetGrabEventSpy.count(), 2);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget);
+
+    // Add two popups
+    QGraphicsWidget *widget2 = new QGraphicsWidget(0, Qt::Popup);
+    widget2->setFlag(QGraphicsItem::ItemIsMovable); // can grab mouse
+    widget2->resize(200, 200);
+    EventSpy widget2GrabEventSpy(widget2, QEvent::GrabMouse);
+    EventSpy widget2UngrabEventSpy(widget2, QEvent::UngrabMouse);
+    QGraphicsWidget *widget3 = new QGraphicsWidget(0, Qt::Popup);
+    widget3->setFlag(QGraphicsItem::ItemIsMovable); // can grab mouse
+    widget3->resize(200, 200);
+    EventSpy widget3GrabEventSpy(widget3, QEvent::GrabMouse);
+    EventSpy widget3UngrabEventSpy(widget3, QEvent::UngrabMouse);
+
+    // Adding to the scene grabs
+    scene.addItem(widget2);
+    QCOMPARE(widgetUngrabEventSpy.count(), 2);
+    QCOMPARE(widget2GrabEventSpy.count(), 1);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget2);
+
+    // Adding to the scene grabs again
+    scene.addItem(widget3);
+    QCOMPARE(widget2UngrabEventSpy.count(), 1);
+    QCOMPARE(widget3GrabEventSpy.count(), 1);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget3);
+
+    // Hiding the topmost widget causes widget 2 to regain grab.
+    widget3->hide();
+    QCOMPARE(widget2GrabEventSpy.count(), 2);
+    QCOMPARE(widget3UngrabEventSpy.count(), 1);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget2);
+    widget3->show();
+    QCOMPARE(widget2UngrabEventSpy.count(), 2);
+    QCOMPARE(widget3GrabEventSpy.count(), 2);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget3);
+
+    // Clicking outside the popup still causes it to close (despite that it's
+    // an explicit mouse grabber).
+    {
+        QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);
+        event.ignore();
+        event.setButton(Qt::LeftButton);
+        event.setScenePos(QPointF(500, 500)); // outside
+        qApp->sendEvent(&scene, &event);
+    }
+    QVERIFY(!widget3->isVisible());
+    QCOMPARE(widget3UngrabEventSpy.count(), 2);
+    QCOMPARE(widget2GrabEventSpy.count(), 3);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget2);
+    QVERIFY(widget2->isVisible());
+    QVERIFY(widget->isVisible());
+    widget3->show();
+    QCOMPARE(widget3GrabEventSpy.count(), 3);
+    QCOMPARE(widget2UngrabEventSpy.count(), 3);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget3);
+
+    // This is something of a curiosity. What happens if you call
+    // ungrabMouse() on a popup? The answer is - it loses the grab. If you
+    // hide and show the popup again, it will regain the grab.
+    widget3->ungrabMouse();
+    QCOMPARE(widget3UngrabEventSpy.count(), 3);
+    QCOMPARE(widget2GrabEventSpy.count(), 4);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget2);
+    widget3->hide();
+    widget3->show();
+    QCOMPARE(widget3GrabEventSpy.count(), 4);
+    QCOMPARE(widget2UngrabEventSpy.count(), 4);
+    QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)widget3);
+}
+
+void tst_QGraphicsWidget::windowFlags_data()
+{
+    QTest::addColumn<int>("inputFlags");
+    QTest::addColumn<int>("outputFlags");
+
+    QTest::newRow("nil") << 0 << 0;
+
+    // Window types
+    QTest::newRow("Qt::Window") << int(Qt::Window)
+                                << int(Qt::Window | Qt::WindowTitleHint | Qt::WindowSystemMenuHint
+                                       | Qt::WindowMinimizeButtonHint | Qt::WindowMaximizeButtonHint);
+    QTest::newRow("Qt::SubWindow") << int(Qt::SubWindow)
+                                   << int(Qt::SubWindow | Qt::WindowTitleHint | Qt::WindowSystemMenuHint
+                                          | Qt::WindowMinimizeButtonHint | Qt::WindowMaximizeButtonHint);
+    QTest::newRow("Qt::Dialog") << int(Qt::Dialog)
+                                << int(Qt::Dialog | Qt::WindowTitleHint | Qt::WindowSystemMenuHint
+                                       | Qt::WindowContextHelpButtonHint);
+    QTest::newRow("Qt::Sheet") << int(Qt::Sheet)
+                               << int(Qt::Sheet | Qt::WindowTitleHint | Qt::WindowSystemMenuHint
+                                      | Qt::WindowContextHelpButtonHint);
+    QTest::newRow("Qt::Tool") << int(Qt::Tool)
+                              << int(Qt::Tool | Qt::WindowTitleHint | Qt::WindowSystemMenuHint);
+
+    // Custom window flags
+    QTest::newRow("Qt::FramelessWindowHint") << int(Qt::FramelessWindowHint)
+                                             << int(Qt::FramelessWindowHint);
+    QTest::newRow("Qt::CustomizeWindowHint") << int(Qt::CustomizeWindowHint)
+                                             << int(Qt::CustomizeWindowHint);
+}
+
+void tst_QGraphicsWidget::windowFlags()
+{
+    QFETCH(int, inputFlags);
+    QFETCH(int, outputFlags);
+
+    // Construct with flags set already
+    QGraphicsWidget widget(0, Qt::WindowFlags(inputFlags));
+    QCOMPARE(widget.windowFlags(), Qt::WindowFlags(outputFlags));
+
+    // Set flags after construction
+    QGraphicsWidget widget2;
+    widget2.setWindowFlags(Qt::WindowFlags(inputFlags));
+    QCOMPARE(widget2.windowFlags(), Qt::WindowFlags(outputFlags));
+
+    // Reset flags
+    widget2.setWindowFlags(0);
+    QVERIFY(!widget2.windowFlags());
+
+    // Set flags back again
+    widget2.setWindowFlags(Qt::WindowFlags(inputFlags));
+    QCOMPARE(widget2.windowFlags(), Qt::WindowFlags(outputFlags));
+
+    // Construct with custom flags set already
+    QGraphicsWidget widget3(0, Qt::WindowFlags(inputFlags | Qt::FramelessWindowHint));
+    QCOMPARE(widget3.windowFlags(), Qt::WindowFlags(inputFlags | Qt::FramelessWindowHint));
+
+    // Set custom flags after construction
+    QGraphicsWidget widget4;
+    widget4.setWindowFlags(Qt::WindowFlags(inputFlags | Qt::FramelessWindowHint));
+    QCOMPARE(widget4.windowFlags(), Qt::WindowFlags(inputFlags | Qt::FramelessWindowHint));
+
+    // Reset flags
+    widget4.setWindowFlags(0);
+    QVERIFY(!widget4.windowFlags());
+
+    // Set custom flags back again
+    widget4.setWindowFlags(Qt::WindowFlags(inputFlags | Qt::FramelessWindowHint));
+    QCOMPARE(widget4.windowFlags(), Qt::WindowFlags(inputFlags | Qt::FramelessWindowHint));
+
+    QGraphicsWidget *widget5 = new QGraphicsWidget;
+    widget5->setWindowFlags(Qt::WindowFlags(inputFlags));
+    QCOMPARE(widget5->windowFlags(), Qt::WindowFlags(outputFlags));
+    QGraphicsWidget window(0, Qt::Window);
+    widget5->setParentItem(&window);
+    QCOMPARE(widget5->windowFlags(), Qt::WindowFlags(outputFlags));
+}
+
+void tst_QGraphicsWidget::shortcutsDeletion()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsWidget *widget2 = new QGraphicsWidget;
+    widget->setMinimumSize(40, 40);
+    QWidgetAction *del = new QWidgetAction(widget);
+    del->setIcon(QIcon("edit-delete"));
+    del->setShortcut(Qt::Key_Delete);
+    del->setShortcutContext(Qt::WidgetShortcut);
+    widget2->addAction(del);
+    widget2->addAction(del);
+    delete widget;
+}
+
+class MessUpPainterWidget : public QGraphicsWidget
+{
+public:
+    MessUpPainterWidget(QGraphicsItem * parent = 0, Qt::WindowFlags wFlags = 0)
+    : QGraphicsWidget(parent, wFlags)
+    {}
+
+    void paintWindowFrame(QPainter * painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        QCOMPARE(painter->opacity(), 1.0);
+        painter->setOpacity(0.0);
+        QGraphicsWidget::paintWindowFrame(painter, option, widget);
+    }
+    void paint(QPainter * painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        QCOMPARE(painter->opacity(), 1.0);
+        painter->drawRect(0, 0, 100, 100);
+        QGraphicsWidget::paint(painter, option, widget);
+    }
+
+};
+
+void tst_QGraphicsWidget::painterStateProtectionOnWindowFrame()
+{
+    MessUpPainterWidget *widget = new MessUpPainterWidget(0, Qt::Window);
+    QGraphicsScene scene(0, 0, 300, 300);
+    QGraphicsView view(&scene);
+    scene.addItem(widget);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+}
+
+class ProxyStyle : public QCommonStyle
+{
+public:
+    ProxyStyle(QStyle *proxyStyle) : QCommonStyle()
+    {
+        m_proxyStyle = proxyStyle;
+    }
+
+    int pixelMetric(QStyle::PixelMetric metric, const QStyleOption *option = 0, const QWidget *widget = 0) const
+    {
+        return m_proxyStyle->pixelMetric(metric, option, widget);
+    }
+
+private:
+    QStyle *m_proxyStyle;
+};
+
+class StyledGraphicsWidget : public QGraphicsWidget
+{
+public:
+    StyledGraphicsWidget(bool useOwnStyle) : QGraphicsWidget(), m_style(0) {
+        if (useOwnStyle) {
+            QStyle *oldStyle = style();
+            m_style = new ProxyStyle(oldStyle);
+            setStyle(m_style);
+        }
+
+        style()->pixelMetric(QStyle::PM_SmallIconSize); // crash when style() is still in widgetStyles
+    }
+
+    ~StyledGraphicsWidget() {
+        delete m_style;
+    }
+
+private:
+    QStyle *m_style;
+};
+
+void tst_QGraphicsWidget::task243004_setStyleCrash()
+{
+    QGraphicsItem *item1 = new StyledGraphicsWidget(true);
+    delete item1; // item1 not removed from widgetStyles
+
+    QGraphicsItem *item2 = new StyledGraphicsWidget(false);
+    delete item2;
+}
+
+class GraphicsWidget_task250119 : public QGraphicsWidget
+{
+public:
+    GraphicsWidget_task250119()
+        : shortcutEvents(0)
+    {
+        setFocusPolicy(Qt::StrongFocus);
+        resize(100, 100);
+    }
+
+    int shortcutEvents;
+
+private:
+    bool event(QEvent *event)
+    {
+        if (event->type() == QEvent::Shortcut)
+            shortcutEvents++;
+        return QGraphicsWidget::event(event);
+    }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+    {
+        if (hasFocus()) {
+            painter->setPen(QPen(Qt::black, 0, Qt::DashLine));
+            painter->drawRect(rect());
+        }
+        painter->setPen(QPen(Qt::black, 0, Qt::SolidLine));
+        painter->fillRect(rect().adjusted(2, 2, -2, -2), Qt::yellow);
+        painter->drawRect(rect().adjusted(2, 2, -2, -2));
+    }
+};
+
+void tst_QGraphicsWidget::task250119_shortcutContext()
+{
+    QGraphicsScene scene;
+    QGraphicsView view;
+    view.setScene(&scene);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+
+
+    // *** Event: ***
+
+    GraphicsWidget_task250119 w_event;
+    scene.addItem(&w_event);
+
+    const int id = w_event.grabShortcut(Qt::Key_A, Qt::WidgetWithChildrenShortcut);
+    w_event.setShortcutEnabled(id, true);
+
+    w_event.setFocus();
+    QTest::keyPress(&view, Qt::Key_A);
+    QCOMPARE(w_event.shortcutEvents, 1);
+
+    w_event.clearFocus();
+    QTest::keyPress(&view, Qt::Key_A);
+    QCOMPARE(w_event.shortcutEvents, 1);
+
+    scene.removeItem(&w_event);
+
+
+    // *** Signal: ***
+
+    GraphicsWidget_task250119 w_signal;
+    scene.addItem(&w_signal);
+
+    QAction action(0);
+    action.setShortcut(Qt::Key_B);
+    action.setShortcutContext(Qt::WidgetWithChildrenShortcut);
+    QSignalSpy spy(&action, SIGNAL(triggered()));
+
+    w_signal.addAction(&action);
+
+    w_signal.setFocus();
+    QTest::keyPress(&view, Qt::Key_B);
+    QCOMPARE(spy.count(), 1);
+
+    w_signal.clearFocus();
+    QTest::keyPress(&view, Qt::Key_B);
+    QCOMPARE(spy.count(), 1);
+
+    scene.removeItem(&w_signal);
+}
+
+class ClippingAndTransformsScene : public QGraphicsScene
+{
+public:
+    QList<QGraphicsItem *> drawnItems;
+protected:
+    void drawItems(QPainter *painter, int numItems, QGraphicsItem *items[],
+                   const QStyleOptionGraphicsItem options[], QWidget *widget = 0)
+    {
+        drawnItems.clear();
+        for (int i = 0; i < numItems; ++i)
+            drawnItems << items[i];
+        QGraphicsScene::drawItems(painter, numItems, items, options, widget);
+    }
+};
+
+class RectWidget : public QGraphicsWidget
+{
+public:
+
+    RectWidget(Qt::GlobalColor color, QGraphicsItem *parent=0) : QGraphicsWidget(parent), mColor(color) {}
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+    {
+        painter->setBrush(QBrush(mColor));
+        painter->drawRect(boundingRect());
+    }
+
+    Qt::GlobalColor mColor;
+};
+
+class RectItem : public QGraphicsItem
+{
+public:
+
+    RectItem(Qt::GlobalColor color, QGraphicsItem *parent=0) : QGraphicsItem(parent), mColor(color) {}
+
+    QRectF boundingRect() const
+    {return QRectF(10,10,50,50);}
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+    {
+        painter->setBrush(QBrush(mColor));
+        painter->drawRect(boundingRect());
+    }
+
+    Qt::GlobalColor mColor;
+};
+
+void tst_QGraphicsWidget::ensureClipping()
+{
+    ClippingAndTransformsScene scene;
+    scene.setSceneRect(-50, -50, 200, 200);
+
+    //A root that clip children
+    RectWidget *clipWidget = new RectWidget(Qt::black);
+    scene.addItem(clipWidget);
+
+    clipWidget->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+
+    //a child
+    RectWidget *childWidget = new RectWidget(Qt::red, clipWidget);
+    clipWidget->setGeometry(QRectF(10, 10, 100, 100));
+    childWidget->setGeometry(QRectF(25, 25, 50, 50));
+
+    //We put a QGraphicsItem to be sure this one is also paint
+    RectItem *childitem = new RectItem(Qt::blue, clipWidget);
+
+    QGraphicsView view(&scene);
+    view.setOptimizationFlag(QGraphicsView::IndirectPainting);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QList<QGraphicsItem *> expected;
+    expected << clipWidget << childWidget << childitem;
+    QTRY_VERIFY(scene.drawnItems.contains(clipWidget));
+    QVERIFY(scene.drawnItems.contains(childWidget));
+    QVERIFY(scene.drawnItems.contains(childitem));
+}
+
+class ItemChangeTester : public QGraphicsWidget
+{
+public:
+    ItemChangeTester()
+    { setFlag(ItemSendsGeometryChanges); clear(); }
+    ItemChangeTester(QGraphicsItem *parent) : QGraphicsWidget(parent)
+    { setFlag(ItemSendsGeometryChanges); clear(); }
+
+    void clear()
+    {
+        changes.clear();
+        values.clear();
+        oldValues.clear();
+    }
+    QList<GraphicsItemChange> changes;
+    QList<QVariant> values;
+    QList<QVariant> oldValues;
+protected:
+    QVariant itemChange(GraphicsItemChange change, const QVariant &value)
+    {
+        changes << change;
+        values << value;
+        switch (change) {
+        case QGraphicsItem::ItemPositionChange:
+            oldValues << pos();
+            break;
+        case QGraphicsItem::ItemPositionHasChanged:
+            break;
+        default:
+            break;
+        }
+        return value;
+    }
+};
+
+void tst_QGraphicsWidget::widgetSendsGeometryChanges()
+{
+    ItemChangeTester widget;
+    widget.setFlags(0);
+    widget.clear();
+
+    QPointF pos(10, 10);
+    widget.setPos(pos);
+
+    QCOMPARE(widget.pos(), pos);
+    QCOMPARE(widget.changes.size(), 0);
+
+    widget.setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
+    QCOMPARE(widget.changes.size(), 2);
+
+    widget.setPos(QPointF());
+    QCOMPARE(widget.changes.size(), 4);
+
+    QCOMPARE(widget.pos(), QPointF());
+
+    QRectF geometry(20, 20, 50, 50);
+    widget.setGeometry(geometry);
+    QCOMPARE(widget.changes.size(), 6);
+
+    QCOMPARE(widget.geometry(), geometry);
+
+    QCOMPARE(widget.changes, QList<QGraphicsItem::GraphicsItemChange>()
+         << QGraphicsItem::ItemFlagsChange
+         << QGraphicsItem::ItemFlagsHaveChanged
+         << QGraphicsItem::ItemPositionChange
+         << QGraphicsItem::ItemPositionHasChanged
+         << QGraphicsItem::ItemPositionChange
+         << QGraphicsItem::ItemPositionHasChanged);
+}
+
+class HFWWidget : public QGraphicsWidget
+{
+public:
+    HFWWidget() : QGraphicsWidget(0, Qt::Window)
+    {
+        QSizePolicy sp;
+        sp.setHeightForWidth(true);
+        setSizePolicy(sp);
+    }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        Q_UNUSED(option);
+        Q_UNUSED(widget);
+        qreal w = rect().width();
+        QRectF box(0, 0, w, 2400/w);
+        painter->drawRoundRect(box);
+        painter->drawLine(box.topLeft(), box.bottomRight());
+        painter->drawLine(box.bottomLeft(), box.topRight());
+    }
+
+protected:
+    QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const
+    {
+        qreal w = constraint.width();
+        switch (which) {
+        case Qt::MinimumSize:
+            if (w >= 0 && constraint.height() < 0) {
+                // keep the same area of 60x40 = 2400
+                return QSizeF(w, 2400.0/w);
+            } else {
+                return QSizeF(10, 10);
+            }
+            break;
+        case Qt::PreferredSize:
+            return QSizeF(48.989794, 48.989794);
+            default:
+            break;
+        }
+        return QGraphicsWidget::sizeHint(which, constraint);
+    }
+};
+
+void tst_QGraphicsWidget::respectHFW()
+{
+#if defined(Q_OS_WINCE) || defined(Q_OS_MAC) || defined(Q_WS_QWS)
+    qDebug("This test is platform dependent, it fails on wince, mac and qws. Please fix.");
+#else
+    QGraphicsScene scene;
+    HFWWidget *window = new HFWWidget;
+    scene.addItem(window);
+    QGraphicsView *view = new QGraphicsView(&scene);
+    view->resize(400, 400);
+    view->setSceneRect(-100, -100, 300,300);
+
+    view->show();
+    window->setGeometry(0, 0, 70, 70);
+    QTest::qWaitForWindowShown(view);
+
+    {   // here we go - simulate a interactive resize of the window
+        QTest::mouseMove(view, view->mapFromScene(71, 71)); // bottom right corner
+
+        QTest::mousePress(view->viewport(), Qt::LeftButton, 0, view->mapFromScene(71, 71), 200);
+        view->grabMouse();
+        // move both mouse cursor and set correct event in order to emulate resize
+        QTest::mouseMove(view->viewport(), view->mapFromScene(60, 30), 200);
+        QMouseEvent e = QMouseEvent(QEvent::MouseMove,
+                      view->mapFromScene(60, 20),
+                      Qt::NoButton,
+                      Qt::LeftButton,
+                      Qt::NoModifier);
+        QApplication::sendEvent(view->viewport(), &e);
+        view->releaseMouse();
+    }
+    const QSizeF winSize = window->size();
+    qreal minHFW = window->effectiveSizeHint(Qt::MinimumSize, QSizeF(winSize.width(), -1)).height();
+    QTRY_VERIFY(qAbs(minHFW - winSize.height()) < 1);
+#endif
+}
+
+class PolishWidget : public QGraphicsWidget
+{
+public:
+
+    PolishWidget(Qt::GlobalColor color, QGraphicsItem *parent=0) :
+    QGraphicsWidget(parent), mColor(color)
+    {
+    }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+    {
+        painter->setBrush(QBrush(mColor));
+        painter->drawRect(boundingRect());
+    }
+
+    void polishEvent()
+    {
+        if (!parentWidget()) {
+            //We add a child in the polish event for the parent
+            PolishWidget *childWidget = new PolishWidget(Qt::black, this);
+            childWidget->setGeometry(QRectF(10,10,30,30));
+        }
+
+        QGraphicsWidget::polishEvent();
+        mColor = Qt::red;
+        update();
+        numberOfPolish++;
+    }
+
+    static int numberOfPolish;
+
+private:
+    Qt::GlobalColor mColor;
+};
+
+int PolishWidget::numberOfPolish = 0;
+
+void tst_QGraphicsWidget::addChildInpolishEvent()
+{
+    QGraphicsScene scene;
+
+    PolishWidget *parentWidget = new PolishWidget(Qt::white);
+    scene.addItem(parentWidget);
+
+    QGraphicsView view(&scene);
+    view.resize(200, 200);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    QTRY_COMPARE(PolishWidget::numberOfPolish, 2);
+}
+
+void tst_QGraphicsWidget::polishEvent()
+{
+    class MyGraphicsWidget : public QGraphicsWidget
+    { public:
+        void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *)
+        { events << QEvent::Paint; }
+        void polishEvent()
+        { events << QEvent::Polish; }
+        QList<QEvent::Type> events;
+    };
+
+    QGraphicsScene scene;
+
+    MyGraphicsWidget *widget = new MyGraphicsWidget;
+    scene.addItem(widget);
+
+    QGraphicsView view(&scene);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Make sure the item is painted.
+    QTRY_VERIFY(widget->events.contains(QEvent::Paint));
+
+    // Make sure the item got polish before paint.
+    QCOMPARE(widget->events.at(0), QEvent::Polish);
+}
+
+void tst_QGraphicsWidget::polishEvent2()
+{
+    class MyGraphicsWidget : public QGraphicsWidget
+    { public:
+    void polishEvent()
+    { events << QEvent::Polish; }
+    QList<QEvent::Type> events;
+    };
+
+    QGraphicsScene scene;
+
+    MyGraphicsWidget *widget = new MyGraphicsWidget;
+    widget->hide();
+    scene.addItem(widget);
+
+    widget->events.clear();
+
+    // Make sure the item got polish event.
+    QTRY_VERIFY(widget->events.contains(QEvent::Polish));
+}
+
+void tst_QGraphicsWidget::autoFillBackground()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QCOMPARE(widget->autoFillBackground(), false);
+    widget->setAutoFillBackground(true);
+    QCOMPARE(widget->autoFillBackground(), true);
+
+    const QColor color(Qt::red);
+    const QRect rect(0, 0, 1, 1);
+
+    QGraphicsScene scene;
+    scene.addItem(widget);
+    widget->setGeometry(rect);
+
+    QPalette palette = widget->palette();
+    palette.setColor(QPalette::Window, color);
+    widget->setPalette(palette);
+
+    QImage image(rect.size(), QImage::Format_RGB32);
+    QPainter painter;
+    painter.begin(&image);
+    scene.render(&painter, rect, rect);
+    painter.end();
+    QCOMPARE(image.pixel(0, 0), color.rgb());
+}
+
+void tst_QGraphicsWidget::initialShow()
+{
+    class MyGraphicsWidget : public QGraphicsWidget
+    { public:
+        MyGraphicsWidget() : repaints(0) {}
+        int repaints;
+        void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget*) { ++repaints; }
+        void polishEvent() { update(); }
+    };
+
+    QGraphicsScene scene;
+    MyGraphicsWidget *widget = new MyGraphicsWidget;
+
+    QGraphicsView view(&scene);
+    if(PlatformQuirks::isAutoMaximizing())
+        view.showFullScreen();
+    else
+        view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    scene.addItem(widget);
+
+    QTRY_COMPARE(widget->repaints, 1);
+}
+
+void tst_QGraphicsWidget::initialShow2()
+{
+    class MyGraphicsWidget : public QGraphicsWidget
+    { public:
+        MyGraphicsWidget() : repaints(0) {}
+        int repaints;
+        void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget*) { ++repaints; }
+        void polishEvent() { update(); }
+    };
+
+    // Don't let paint events triggered by the windowing system
+    // influence our test case. We're only interested in knowing
+    // whether a QGraphicsWidget generates an additional repaint
+    // on the initial show. Hence create a dummy scenario to find out
+    // how many repaints we should expect.
+    QGraphicsScene dummyScene(0, 0, 200, 200);
+    dummyScene.addItem(new QGraphicsRectItem(0, 0, 100, 100));
+
+    QGraphicsView *dummyView = new QGraphicsView(&dummyScene);
+    dummyView->setWindowFlags(Qt::X11BypassWindowManagerHint);
+    EventSpy paintSpy(dummyView->viewport(), QEvent::Paint);
+    dummyView->show();
+    QTest::qWaitForWindowShown(dummyView);
+    const int expectedRepaintCount = paintSpy.count();
+    delete dummyView;
+    dummyView = 0;
+
+    MyGraphicsWidget *widget = new MyGraphicsWidget;
+    widget->resize(100, 100);
+
+    QGraphicsScene scene(0, 0, 200, 200);
+    scene.addItem(widget);
+
+    QGraphicsView view(&scene);
+    view.setWindowFlags(view.windowFlags()|Qt::X11BypassWindowManagerHint);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QTRY_COMPARE(widget->repaints, expectedRepaintCount);
+}
+
+void tst_QGraphicsWidget::itemChangeEvents()
+{
+    class TestGraphicsWidget : public QGraphicsWidget
+    { public:
+        TestGraphicsWidget() : QGraphicsWidget() {}
+        QHash<QEvent::Type, QVariant> valueDuringEvents;
+        bool event(QEvent *event) {
+            Q_UNUSED(event);
+            switch (event->type()) {
+            case QEvent::EnabledChange: {
+                valueDuringEvents.insert(QEvent::EnabledChange, isEnabled());
+                break;
+            }
+            case QEvent::ParentAboutToChange: {
+                valueDuringEvents.insert(QEvent::ParentAboutToChange, qVariantFromValue(parentItem()));
+                break;
+            }
+            case QEvent::ParentChange: {
+                valueDuringEvents.insert(QEvent::ParentChange, qVariantFromValue(parentItem()));
+                break;
+            }
+            case QEvent::CursorChange: {
+                valueDuringEvents.insert(QEvent::CursorChange, int(cursor().shape()));
+                break;
+            }
+            case QEvent::ToolTipChange: {
+                valueDuringEvents.insert(QEvent::ToolTipChange, toolTip());
+                break;
+            }
+            default: {
+                break;
+            }
+            }
+            return true;
+        }
+        void showEvent(QShowEvent *event) {
+            Q_UNUSED(event);
+            valueDuringEvents.insert(QEvent::Show, isVisible());
+        }
+        void hideEvent(QHideEvent *event) {
+            Q_UNUSED(event);
+            valueDuringEvents.insert(QEvent::Hide, isVisible());
+        }
+    };
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *parent = new QGraphicsWidget;
+    scene.addItem(parent);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    TestGraphicsWidget *item = new TestGraphicsWidget;
+    item->setParentItem(parent);
+    // ParentAboutToChange should be triggered before the parent has changed
+    QTRY_COMPARE(qVariantValue<QGraphicsItem *>(item->valueDuringEvents.value(QEvent::ParentAboutToChange)),
+             static_cast<QGraphicsItem *>(0));
+    // ParentChange should be triggered after the parent has changed
+    QTRY_COMPARE(qVariantValue<QGraphicsItem *>(item->valueDuringEvents.value(QEvent::ParentChange)),
+             static_cast<QGraphicsItem *>(parent));
+
+    // ShowEvent should be triggered before the item is shown
+    QTRY_VERIFY(!item->valueDuringEvents.value(QEvent::Show).toBool());
+
+    // HideEvent should be triggered after the item is hidden
+    QVERIFY(item->isVisible());
+    item->setVisible(false);
+    QVERIFY(!item->isVisible());
+    QTRY_VERIFY(!item->valueDuringEvents.value(QEvent::Hide).toBool());
+
+    // CursorChange should be triggered after the cursor has changed
+    item->setCursor(Qt::PointingHandCursor);
+    QTRY_COMPARE(item->valueDuringEvents.value(QEvent::CursorChange).toInt(), int(item->cursor().shape()));
+
+    // ToolTipChange should be triggered after the tooltip has changed
+    item->setToolTip("tooltipText");
+    QTRY_COMPARE(item->valueDuringEvents.value(QEvent::ToolTipChange).toString(), item->toolTip());
+
+    // EnabledChange should be triggered after the enabled state has changed
+    QVERIFY(item->isEnabled());
+    item->setEnabled(false);
+    QVERIFY(!item->isEnabled());
+    QTRY_VERIFY(!item->valueDuringEvents.value(QEvent::EnabledChange).toBool());
+}
+
+void tst_QGraphicsWidget::itemSendGeometryPosChangesDeactivated()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    QGraphicsWidget *item = new QGraphicsWidget;
+    scene.addItem(item);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    item->setGeometry(QRectF(0, 0, 50, 50));
+    QTRY_COMPARE(item->geometry(), QRectF(0, 0, 50, 50));
+
+    item->setFlag(QGraphicsItem::ItemSendsGeometryChanges, false);
+    item->setGeometry(QRectF(0, 0, 60, 60));
+    QCOMPARE(item->geometry(), QRectF(0, 0, 60, 60));
+    QCOMPARE(item->pos(), QPointF(0, 0));
+    item->setPos(QPointF(10, 10));
+    QCOMPARE(item->pos(), QPointF(10, 10));
+    QCOMPARE(item->geometry(), QRectF(10, 10, 60, 60));
+
+    item->setFlag(QGraphicsItem::ItemSendsScenePositionChanges, false);
+    item->setGeometry(QRectF(0, 0, 60, 60));
+    QCOMPARE(item->geometry(), QRectF(0, 0, 60, 60));
+    QCOMPARE(item->pos(), QPointF(0, 0));
+    item->setPos(QPointF(10, 10));
+    QCOMPARE(item->pos(), QPointF(10, 10));
+    QCOMPARE(item->geometry(), QRectF(10, 10, 60, 60));
+}
+
+void tst_QGraphicsWidget::QT_BUG_6544_tabFocusFirstUnsetWhenRemovingItems()
+{
+    QGraphicsScene scene;
+    QGraphicsWidget* parent1 = new QGraphicsWidget;
+    QGraphicsWidget* child1_0 = new QGraphicsWidget;
+    QGraphicsWidget* child1_1 = new QGraphicsWidget;
+
+    QGraphicsWidget* parent2 = new QGraphicsWidget;
+
+    // Add the parent and child to the scene.
+    scene.addItem(parent1);
+    child1_0->setParentItem(parent1);
+    child1_1->setParentItem(parent1);
+
+    // Hide and show the child.
+    child1_0->setParentItem(NULL);
+    scene.removeItem(child1_0);
+
+    // Remove parent from the scene.
+    scene.removeItem(parent1);
+
+    delete child1_0;
+    delete child1_1;
+    delete parent1;
+
+    // Add an item into the scene.
+    scene.addItem(parent2);
+
+    //This should not crash
+}
+void tst_QGraphicsWidget::QT_BUG_12056_tabFocusFirstUnsetWhenRemovingItems()
+{
+    QGraphicsScene scene;
+    QGraphicsWidget* item1 = new QGraphicsWidget;
+    QGraphicsWidget* item2 = new QGraphicsWidget;
+    QGraphicsWidget* item3 = new QGraphicsWidget;
+
+    scene.addItem(item1);
+    scene.addItem(item2);
+
+    scene.removeItem(item2);
+    scene.removeItem(item1);
+    delete item2;
+    delete item1;
+
+    scene.addItem(item3);
+
+    //This should not crash
+}
+
+QTEST_MAIN(tst_QGraphicsWidget)
+#include "tst_qgraphicswidget.moc"