Merge branch '4.6' of scm.dev.nokia.troll.no:qt/oslo-staging-2 into 4.6-integration

* '4.6' of scm.dev.nokia.troll.no:qt/oslo-staging-2: (22 commits)
  Make DSFLIP_ONSYNC part of the default flip flags.
  Fixed a failure in tst_qgl.
  4.6.2 changes
  Avoids a possible crash when saving the state of a main window
  Implemented QGifHandler::imageCount().
  Fixed compilation of the GL2 engine for OpenGL ES 2.
  fix whitespace
  Document that QModelIndex::child does not work for the root item
  Fixed missing textures in the boxes demo.
  Fix QTBUG_7714_fullUpdateDiscardingOpacityUpdate2 autotest in qws-linux
  Assert failure when setting a widget focus proxy as its successor in tab order
  Fixed garbled 3D Qt logo in the overpainting example.
  fix crash in Phonon::DS9 backend
  Don't crash when running Qt on KDE with Oxygen style.
  Fixes missing update when setting opacity on an item that had opacity 0.0
  Avoids missing opacity updates by not propagating the ignoreOpacity flag
  Cleanup in graphicsitem autotest
  Adds convenience functions QGraphicsItemPrivate::isOpacityNull
  Fixed a crash when QPixmaps are destroyed after the ~QApplication.
  Fix GL texture leaks when pixmaps are deleted
  ...

6 files changed, 377 insertions, 54 deletions

diff --git a/tests/auto/qgl/qgl.pro b/tests/auto/qgl/qgl.pro
index 420c4bb..9116f39 100644
--- a/tests/auto/qgl/qgl.pro
+++ b/tests/auto/qgl/qgl.pro
@@ -6,6 +6,6 @@ load(qttest_p4)
 requires(contains(QT_CONFIG,opengl))
 QT += opengl
 
-SOURCES += tst_qgl.cpp
-
+SOURCES   += tst_qgl.cpp
+RESOURCES  = qgl.qrc
 
diff --git a/tests/auto/qgl/qgl.qrc b/tests/auto/qgl/qgl.qrc
new file mode 100644
index 0000000..653794a
--- /dev/null
+++ b/tests/auto/qgl/qgl.qrc
@@ -0,0 +1,5 @@
+<!DOCTYPE RCC><RCC version="1.0">
+<qresource>
+    <file alias="designer.png">../qpixmap/images/designer.png</file>
+</qresource>
+</RCC>
diff --git a/tests/auto/qgl/tst_qgl.cpp b/tests/auto/qgl/tst_qgl.cpp
index cf4616e..d37d727 100644
--- a/tests/auto/qgl/tst_qgl.cpp
+++ b/tests/auto/qgl/tst_qgl.cpp
@@ -56,6 +56,7 @@
 
 #ifdef QT_BUILD_INTERNAL
 #include <QtOpenGL/private/qgl_p.h>
+#include <QtGui/private/qpixmapdata_p.h>
 #endif
 
 //TESTED_CLASS=
@@ -91,6 +92,8 @@ private slots:
     void clipTest();
     void destroyFBOAfterContext();
     void shareRegister();
+    void qglContextDefaultBindTexture();
+    void textureCleanup();
 };
 
 tst_QGL::tst_QGL()
@@ -1938,5 +1941,242 @@ void tst_QGL::shareRegister()
 #endif
 }
 
+// Tests QGLContext::bindTexture with default options
+void tst_QGL::qglContextDefaultBindTexture()
+{
+#ifdef QT_BUILD_INTERNAL
+    QGLWidget w;
+    w.makeCurrent();
+
+    QGLContext *ctx = const_cast<QGLContext*>(w.context());
+
+    QImage *boundImage = new QImage(256, 256, QImage::Format_RGB32);
+    boundImage->fill(0xFFFFFFFF);
+    QPixmap *boundPixmap = new QPixmap(256, 256);
+    boundPixmap->fill(Qt::red);
+
+    // Check that calling QGLContext::bindTexture with default args adds textures to cache
+    int startCacheItemCount = QGLTextureCache::instance()->size();
+    GLuint boundImageTextureId = ctx->bindTexture(*boundImage);
+    GLuint boundPixmapTextureId = ctx->bindTexture(*boundPixmap);
+    QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+2);
+
+    // Make sure the texture IDs returned are valid:
+    QCOMPARE((bool)glIsTexture(boundImageTextureId), GL_TRUE);
+    QCOMPARE((bool)glIsTexture(boundPixmapTextureId), GL_TRUE);
+
+    // Make sure the textures are still there after we delete the image/pixmap:
+    delete boundImage;
+    boundImage = 0;
+    delete boundPixmap;
+    boundPixmap = 0;
+    QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+2);
+
+    // Make sure the textures are deleted from the cache after calling QGLContext::deleteTexture()
+    ctx->deleteTexture(boundImageTextureId);
+    ctx->deleteTexture(boundPixmapTextureId);
+    QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount);
+
+    // Finally, make sure QGLContext::deleteTexture also deleted the texture IDs:
+    QCOMPARE((bool)glIsTexture(boundImageTextureId), GL_FALSE);
+    QCOMPARE((bool)glIsTexture(boundPixmapTextureId), GL_FALSE);
+#endif
+}
+
+void tst_QGL::textureCleanup()
+{
+#ifdef QT_BUILD_INTERNAL
+    QGLWidget w;
+    w.resize(200,200);
+    w.show();
+    w.makeCurrent();
+
+    // Test pixmaps which have been loaded via QPixmapCache are removed from the texture cache
+    // when the pixmap cache is cleared
+    {
+        int startCacheItemCount = QGLTextureCache::instance()->size();
+        QPainter p(&w);
+
+        QPixmap boundPixmap(":designer.png");
+
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount);
+
+        p.drawPixmap(0, 0, boundPixmap);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+1);
+
+        // Need to call end for the GL2 paint engine to release references to pixmap if using tfp
+        p.end();
+
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+1);
+
+        // Check that the texture doesn't get removed from the cache when the pixmap is cleared
+        // as it should still be in the cache:
+        boundPixmap = QPixmap();
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+1);
+
+        QPixmapCache::clear();
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount);
+    }
+
+    // Test pixmaps which have been loaded via QPixmapCache are removed from the texture cache
+    // when they are explicitly removed from the pixmap cache
+    {
+        int startCacheItemCount = QGLTextureCache::instance()->size();
+        QPainter p(&w);
+
+        QPixmap boundPixmap(128, 128);
+        QString cacheKey = QString::fromLatin1("myPixmap");
+        QPixmapCache::insert(cacheKey, boundPixmap);
+
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount);
+
+        p.drawPixmap(0, 0, boundPixmap);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+1);
+
+        // Need to call end for the GL2 paint engine to release references to pixmap if using tfp
+        p.end();
+
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+1);
+
+        // Check that the texture doesn't get removed from the cache when the pixmap is cleared
+        // as it should still be in the cache:
+        boundPixmap = QPixmap();
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+1);
+
+        // Finally, we check that the texture cache entry is removed when we remove the
+        // pixmap cache entry, which should hold the last reference:
+        QPixmapCache::remove(cacheKey);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount);
+    }
+
+    // Check images & pixmaps are removed from the cache when they are deleted
+    {
+        int startCacheItemCount = QGLTextureCache::instance()->size();
+        QPainter p(&w);
+
+        QImage *boundImage = new QImage(256, 256, QImage::Format_RGB32);
+        boundImage->fill(0xFFFFFFFF);
+        QPixmap *boundPixmap = new QPixmap(256, 256);
+        boundPixmap->fill(Qt::red);
+
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount);
+
+        p.drawImage(0, 0, *boundImage);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+1);
+
+        p.drawPixmap(0, 0, *boundPixmap);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+2);
+
+        // Need to call end for the GL2 paint engine to release references to pixmap if using tfp
+        p.end();
+
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+2);
+
+        delete boundImage;
+        boundImage = 0;
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+1);
+
+        delete boundPixmap;
+        boundPixmap = 0;
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount);
+    }
+
+    // Check images & pixmaps are removed from the cache when they are assigned to
+    {
+        int startCacheItemCount = QGLTextureCache::instance()->size();
+        QPainter p(&w);
+
+        QImage boundImage(256, 256, QImage::Format_RGB32);
+        boundImage.fill(0xFFFFFFFF);
+        QPixmap boundPixmap(256, 256);
+        boundPixmap.fill(Qt::red);
+
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount);
+
+        p.drawImage(0, 0, boundImage);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+1);
+
+        p.drawPixmap(0, 0, boundPixmap);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+2);
+
+        // Need to call end for the GL2 paint engine to release references to pixmap if using tfp
+        p.end();
+
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+2);
+
+        boundImage = QImage(64, 64, QImage::Format_RGB32);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+1);
+
+        boundPixmap = QPixmap(64, 64);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount);
+    }
+
+    // Check images & pixmaps are removed from the cache when they are modified (detached)
+    {
+        int startCacheItemCount = QGLTextureCache::instance()->size();
+        QPainter p(&w);
+
+        QImage boundImage(256, 256, QImage::Format_RGB32);
+        boundImage.fill(0xFFFFFFFF);
+        QPixmap boundPixmap(256, 256);
+        boundPixmap.fill(Qt::red);
+
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount);
+
+        p.drawImage(0, 0, boundImage);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+1);
+
+        p.drawPixmap(0, 0, boundPixmap);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+2);
+
+        // Need to call end for the GL2 paint engine to release references to pixmap if using tfp
+        p.end();
+
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+2);
+
+        boundImage.fill(0x00000000);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+1);
+
+        boundPixmap.fill(Qt::blue);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount);
+    }
+
+    // Check that images/pixmaps aren't removed from the cache if a shallow copy has been made
+    QImage copyOfImage;
+    QPixmap copyOfPixmap;
+    int startCacheItemCount = QGLTextureCache::instance()->size();
+    {
+        QPainter p(&w);
+
+        QImage boundImage(256, 256, QImage::Format_RGB32);
+        boundImage.fill(0xFFFFFFFF);
+        QPixmap boundPixmap(256, 256);
+        boundPixmap.fill(Qt::red);
+
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount);
+
+        p.drawImage(0, 0, boundImage);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+1);
+
+        p.drawPixmap(0, 0, boundPixmap);
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+2);
+
+        // Need to call end for the GL2 paint engine to release references to pixmap if using tfp
+        p.end();
+
+        copyOfImage = boundImage;
+        copyOfPixmap = boundPixmap;
+        QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+2);
+    } // boundImage & boundPixmap would have been deleted when they went out of scope
+    QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+2);
+
+    copyOfImage = QImage();
+    QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount+1);
+
+    copyOfPixmap = QPixmap();
+    QCOMPARE(QGLTextureCache::instance()->size(), startCacheItemCount);
+#endif
+}
+
 QTEST_MAIN(tst_QGL)
 #include "tst_qgl.moc"
diff --git a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
index 14b9ef0..7b54a3b 100644
--- a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
+++ b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
@@ -251,6 +251,21 @@ public:
     QBrush brush;
 };
 
+class MyGraphicsView : public QGraphicsView
+{
+public:
+    int repaints;
+    QRegion paintedRegion;
+    MyGraphicsView(QGraphicsScene *scene) : QGraphicsView(scene), 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
@@ -419,6 +434,8 @@ private slots:
     void QTBUG_4233_updateCachedWithSceneRect();
     void QTBUG_5418_textItemSetDefaultColor();
     void QTBUG_6738_missingUpdateWithSetParent();
+    void QTBUG_7714_fullUpdateDiscardingOpacityUpdate2();
+    void QT_2653_fullUpdateDiscardingOpacityUpdate();
 
 private:
     QList<QGraphicsItem *> paintedItems;
@@ -3165,7 +3182,6 @@ void tst_QGraphicsItem::childrenBoundingRect()
     childChild->setPos(500, 500);
     child->rotate(90);
 
-
     scene.addPolygon(parent->mapToScene(parent->boundingRect() | parent->childrenBoundingRect()))->setPen(QPen(Qt::red));;
 
     QGraphicsView view(&scene);
@@ -6252,13 +6268,6 @@ void tst_QGraphicsItem::opacity2()
     QGraphicsScene scene;
     scene.addItem(parent);
 
-    class MyGraphicsView : public QGraphicsView
-    { public:
-        int repaints;
-        MyGraphicsView(QGraphicsScene *scene) : QGraphicsView(scene), repaints(0) {}
-        void paintEvent(QPaintEvent *e) { ++repaints; QGraphicsView::paintEvent(e); }
-    };
-
     MyGraphicsView view(&scene);
     view.show();
     QTest::qWaitForWindowShown(&view);
@@ -6336,20 +6345,6 @@ void tst_QGraphicsItem::opacityZeroUpdates()
     QGraphicsScene scene;
     scene.addItem(parent);
 
-    class MyGraphicsView : public QGraphicsView
-    { public:
-        int repaints;
-        QRegion paintedRegion;
-        MyGraphicsView(QGraphicsScene *scene) : QGraphicsView(scene), repaints(0) {}
-        void paintEvent(QPaintEvent *e)
-        {
-            ++repaints;
-            paintedRegion += e->region();
-            QGraphicsView::paintEvent(e);
-        }
-        void reset() { repaints = 0; paintedRegion = QRegion(); }
-    };
-
     MyGraphicsView view(&scene);
     view.show();
     QTest::qWaitForWindowShown(&view);
@@ -7076,21 +7071,6 @@ void tst_QGraphicsItem::deviceTransform()
     QCOMPARE(rect3->deviceTransform(deviceX).map(QPointF(50, 50)), mapResult3);
 }
 
-class MyGraphicsView : public QGraphicsView
-{
-public:
-    int repaints;
-    QRegion paintedRegion;
-    MyGraphicsView(QGraphicsScene *scene) : QGraphicsView(scene), repaints(0) {}
-    void paintEvent(QPaintEvent *e)
-    {
-        paintedRegion += e->region();
-        ++repaints;
-        QGraphicsView::paintEvent(e);
-    }
-    void reset() { repaints = 0; paintedRegion = QRegion(); }
-};
-
 void tst_QGraphicsItem::update()
 {
     QGraphicsScene scene;
@@ -9835,7 +9815,7 @@ void tst_QGraphicsItem::scenePosChange()
     QCOMPARE(child2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
 }
 
-void  tst_QGraphicsItem::QTBUG_5418_textItemSetDefaultColor()
+void tst_QGraphicsItem::QTBUG_5418_textItemSetDefaultColor()
 {
     struct Item : public QGraphicsTextItem
     {
@@ -9914,20 +9894,6 @@ void tst_QGraphicsItem::QTBUG_6738_missingUpdateWithSetParent()
     QGraphicsScene scene;
     scene.addItem(parent);
 
-    class MyGraphicsView : public QGraphicsView
-    { public:
-        int repaints;
-        QRegion paintedRegion;
-        MyGraphicsView(QGraphicsScene *scene) : QGraphicsView(scene), repaints(0) {}
-        void paintEvent(QPaintEvent *e)
-        {
-            ++repaints;
-            paintedRegion += e->region();
-            QGraphicsView::paintEvent(e);
-        }
-        void reset() { repaints = 0; paintedRegion = QRegion(); }
-    };
-
     MyGraphicsView view(&scene);
     view.show();
     QTest::qWaitForWindowShown(&view);
@@ -9955,5 +9921,84 @@ void tst_QGraphicsItem::QTBUG_6738_missingUpdateWithSetParent()
     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);
+
+    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);
+}
+
 QTEST_MAIN(tst_QGraphicsItem)
 #include "tst_qgraphicsitem.moc"
diff --git a/tests/auto/qimagereader/tst_qimagereader.cpp b/tests/auto/qimagereader/tst_qimagereader.cpp
index e7cfe68..debc090 100644
--- a/tests/auto/qimagereader/tst_qimagereader.cpp
+++ b/tests/auto/qimagereader/tst_qimagereader.cpp
@@ -765,6 +765,8 @@ void tst_QImageReader::gifImageCount()
         QVERIFY(io.canRead());
         QImage greenFrame = io.read();
 
+        QVERIFY(io.imageCount() == 4);
+
         QVERIFY(io.canRead());
         QImage blueFrame = io.read();
 
@@ -876,6 +878,10 @@ void tst_QImageReader::gifImageCount()
         QCOMPARE(blueFrame.size(), QSize(64,64));
         QVERIFY(emptyFrame.isNull());
     }
+    {
+        QImageReader io(":images/trolltech.gif");
+        QVERIFY(io.imageCount() == 34);
+    }
 }
 #endif
 
@@ -1641,10 +1647,16 @@ void tst_QImageReader::pixelCompareWithBaseline()
 {
     QFETCH(QString, fileName);
 
+    static int enteredCount = 0;    // Used for better error diagnostics if something fails. We
+    static int loadFailCount = 0;   // don't know if the reason load() fails is that the plugin
+                                    // does not exist or because of a bug in the plugin. But if at
+                                    // least one file succeeded we know that the plugin was built.
+                                    // The other failures are then real failures.
     QImage icoImg;
     const QString inputFileName(QString::fromAscii("images/%1").arg(fileName));
     QFileInfo fi(inputFileName);
 
+    ++enteredCount;
     // might fail if the plugin does not exist, which is ok.
     if (icoImg.load(inputFileName)) {
         icoImg = icoImg.convertToFormat(QImage::Format_ARGB32_Premultiplied);
@@ -1658,6 +1670,13 @@ void tst_QImageReader::pixelCompareWithBaseline()
         QCOMPARE(int(baseImg.format()), int(icoImg.format()));
         QCOMPARE(baseImg, icoImg);
 #endif
+    } else {
+        ++loadFailCount;
+        if (enteredCount != loadFailCount) {
+            QFAIL("Plugin is built, but some did not load properly");
+        } else {
+            qWarning("loading failed, check if ico plugin is built");
+        }
     }
 }
 
diff --git a/tests/auto/qwidget/tst_qwidget.cpp b/tests/auto/qwidget/tst_qwidget.cpp
index ea90ae3..1fb323e 100644
--- a/tests/auto/qwidget/tst_qwidget.cpp
+++ b/tests/auto/qwidget/tst_qwidget.cpp
@@ -396,6 +396,8 @@ private slots:
     void focusProxyAndInputMethods();
     void scrollWithoutBackingStore();
 
+    void taskQTBUG_7532_tabOrderWithFocusProxy();
+
 private:
     bool ensureScreenSize(int width, int height);
     QWidget *testWidget;
@@ -9783,5 +9785,17 @@ void tst_QWidget::scrollWithoutBackingStore()
     QCOMPARE(child.pos(),QPoint(25,25));
 }
 
+void tst_QWidget::taskQTBUG_7532_tabOrderWithFocusProxy()
+{
+    QWidget w;
+    w.setFocusPolicy(Qt::TabFocus);
+    QWidget *fp = new QWidget(&w);
+    fp->setFocusPolicy(Qt::TabFocus);
+    w.setFocusProxy(fp);
+    QWidget::setTabOrder(&w, fp);
+
+    // No Q_ASSERT, then it's allright.
+}
+
 QTEST_MAIN(tst_QWidget)
 #include "tst_qwidget.moc"