Merge branch 'kinetic-declarativeui' of git@scm.dev.nokia.troll.no:qt/kinetic into kinetic-declarativeui

19 files changed, 871 insertions, 76 deletions

diff --git a/tests/auto/bic/bic.pro b/tests/auto/bic/bic.pro
index a168d77..82711c9 100644
--- a/tests/auto/bic/bic.pro
+++ b/tests/auto/bic/bic.pro
@@ -2,3 +2,9 @@ load(qttest_p4)
 SOURCES += tst_bic.cpp qbic.cpp
 QT = core
 
+wince*:{
+    DEFINES += SRCDIR=\\\"\\\"
+} else {
+    DEFINES += SRCDIR=\\\"$$PWD/\\\"
+}
+
diff --git a/tests/auto/bic/tst_bic.cpp b/tests/auto/bic/tst_bic.cpp
index 181c275..8bc8d4f 100644
--- a/tests/auto/bic/tst_bic.cpp
+++ b/tests/auto/bic/tst_bic.cpp
@@ -165,30 +165,30 @@ void tst_Bic::sizesAndVTables_data()
 
 #if defined Q_OS_LINUX && defined Q_WS_X11
 # if defined(__powerpc__) && !defined(__powerpc64__)
-    archFileName400 = "data/%1.4.0.0.linux-gcc-ppc32.txt";
-    archFileName410 = "data/%1.4.1.0.linux-gcc-ppc32.txt";
-    archFileName420 = "data/%1.4.2.0.linux-gcc-ppc32.txt";
+    archFileName400 = SRCDIR "data/%1.4.0.0.linux-gcc-ppc32.txt";
+    archFileName410 = SRCDIR "data/%1.4.1.0.linux-gcc-ppc32.txt";
+    archFileName420 = SRCDIR "data/%1.4.2.0.linux-gcc-ppc32.txt";
 # elif defined(__amd64__)
-    archFileName400 = "data/%1.4.0.0.linux-gcc-amd64.txt";
+    archFileName400 = SRCDIR "data/%1.4.0.0.linux-gcc-amd64.txt";
 # elif defined(__i386__)
-    archFileName400 = "data/%1.4.0.0.linux-gcc-ia32.txt";
-    archFileName410 = "data/%1.4.1.0.linux-gcc-ia32.txt";
-    archFileName420 = "data/%1.4.2.0.linux-gcc-ia32.txt";
-    archFileName430 = "data/%1.4.3.0.linux-gcc-ia32.txt";
+    archFileName400 = SRCDIR "data/%1.4.0.0.linux-gcc-ia32.txt";
+    archFileName410 = SRCDIR "data/%1.4.1.0.linux-gcc-ia32.txt";
+    archFileName420 = SRCDIR "data/%1.4.2.0.linux-gcc-ia32.txt";
+    archFileName430 = SRCDIR "data/%1.4.3.0.linux-gcc-ia32.txt";
 # endif
 #elif defined Q_OS_AIX
     if (sizeof(void*) == 4)
-        archFileName400 = "data/%1.4.0.0.aix-gcc-power32.txt";
+        archFileName400 = SRCDIR "data/%1.4.0.0.aix-gcc-power32.txt";
 #elif defined Q_OS_MAC && defined(__powerpc__)
-    archFileName400 = "data/%1.4.0.0.macx-gcc-ppc32.txt";
-    archFileName410 = "data/%1.4.1.0.macx-gcc-ppc32.txt";
-    archFileName420 = "data/%1.4.2.0.macx-gcc-ppc32.txt";
+    archFileName400 = SRCDIR "data/%1.4.0.0.macx-gcc-ppc32.txt";
+    archFileName410 = SRCDIR "data/%1.4.1.0.macx-gcc-ppc32.txt";
+    archFileName420 = SRCDIR "data/%1.4.2.0.macx-gcc-ppc32.txt";
 #elif defined Q_OS_MAC && defined(__i386__)
-    archFileName410 = "data/%1.4.1.0.macx-gcc-ia32.txt";
-    archFileName420 = "data/%1.4.2.0.macx-gcc-ia32.txt";
+    archFileName410 = SRCDIR "data/%1.4.1.0.macx-gcc-ia32.txt";
+    archFileName420 = SRCDIR "data/%1.4.2.0.macx-gcc-ia32.txt";
 #elif defined Q_OS_WIN && defined Q_CC_GNU
-    archFileName410 = "data/%1.4.1.0.win32-gcc-ia32.txt";
-    archFileName420 = "data/%1.4.2.0.win32-gcc-ia32.txt";
+    archFileName410 = SRCDIR "data/%1.4.1.0.win32-gcc-ia32.txt";
+    archFileName420 = SRCDIR "data/%1.4.2.0.win32-gcc-ia32.txt";
 #endif
 
     if (archFileName400.isEmpty() && archFileName410.isEmpty()
@@ -293,6 +293,7 @@ void tst_Bic::sizesAndVTables()
 
     bool isFailed = false;
 
+    qDebug() << oldLib.arg(libName);
     if (oldLib.isEmpty() || !QFile::exists(oldLib.arg(libName)))
         QSKIP("No platform spec found for this platform/version.", SkipSingle);
 
diff --git a/tests/auto/declarative/numberformatter/tst_numberformatter.cpp b/tests/auto/declarative/numberformatter/tst_numberformatter.cpp
index e70d651..9a2f4f3 100644
--- a/tests/auto/declarative/numberformatter/tst_numberformatter.cpp
+++ b/tests/auto/declarative/numberformatter/tst_numberformatter.cpp
@@ -1,4 +1,5 @@
 #include <qtest.h>
+#include <QDebug>
 #include <QtDeclarative/qmlengine.h>
 #include <QtDeclarative/qmlcomponent.h>
 #include <QtDeclarative/qnumberformat.h>
diff --git a/tests/auto/math3d/qmatrixnxn/tst_qmatrixnxn.cpp b/tests/auto/math3d/qmatrixnxn/tst_qmatrixnxn.cpp
index 4d51e89..dd3e396 100644
--- a/tests/auto/math3d/qmatrixnxn/tst_qmatrixnxn.cpp
+++ b/tests/auto/math3d/qmatrixnxn/tst_qmatrixnxn.cpp
@@ -3,7 +3,7 @@
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
 ** Contact: Qt Software Information (qt-info@nokia.com)
 **
-** This file is part of the $MODULE$ of the Qt Toolkit.
+** This file is part of the test suite of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** No Commercial Usage
diff --git a/tests/auto/math3d/qquaternion/tst_qquaternion.cpp b/tests/auto/math3d/qquaternion/tst_qquaternion.cpp
index f25f858..5d70e4d 100644
--- a/tests/auto/math3d/qquaternion/tst_qquaternion.cpp
+++ b/tests/auto/math3d/qquaternion/tst_qquaternion.cpp
@@ -3,7 +3,7 @@
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
 ** Contact: Qt Software Information (qt-info@nokia.com)
 **
-** This file is part of the $MODULE$ of the Qt Toolkit.
+** This file is part of the test suite of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** No Commercial Usage
diff --git a/tests/auto/math3d/qvectornd/tst_qvectornd.cpp b/tests/auto/math3d/qvectornd/tst_qvectornd.cpp
index a092fb0..f7d2411 100644
--- a/tests/auto/math3d/qvectornd/tst_qvectornd.cpp
+++ b/tests/auto/math3d/qvectornd/tst_qvectornd.cpp
@@ -3,7 +3,7 @@
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
 ** Contact: Qt Software Information (qt-info@nokia.com)
 **
-** This file is part of the $MODULE$ of the Qt Toolkit.
+** This file is part of the test suite of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** No Commercial Usage
diff --git a/tests/auto/math3d/shared/math3dincludes.h b/tests/auto/math3d/shared/math3dincludes.h
index 1ac0c08..a77090b 100644
--- a/tests/auto/math3d/shared/math3dincludes.h
+++ b/tests/auto/math3d/shared/math3dincludes.h
@@ -3,7 +3,7 @@
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
 ** Contact: Qt Software Information (qt-info@nokia.com)
 **
-** This file is part of the $MODULE$ of the Qt Toolkit.
+** This file is part of the test suite of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** No Commercial Usage
diff --git a/tests/auto/qcssparser/tst_cssparser.cpp b/tests/auto/qcssparser/tst_cssparser.cpp
index b41a745..27258b7 100644
--- a/tests/auto/qcssparser/tst_cssparser.cpp
+++ b/tests/auto/qcssparser/tst_cssparser.cpp
@@ -114,11 +114,52 @@ void tst_CssParser::scanner_data()
     }
 }
 
+
+static char *tokenName(QCss::TokenType t)
+{
+    switch (t) {
+        case QCss::NONE: return "NONE";
+        case QCss::S: return "S";
+        case QCss::CDO: return "CDO";
+        case QCss::CDC: return "CDC";
+        case QCss::INCLUDES: return "INCLUDES";
+        case QCss::DASHMATCH: return "DASHMATCH";
+        case QCss::LBRACE: return "LBRACE";
+        case QCss::PLUS: return "PLUS";
+        case QCss::GREATER: return "GREATER";
+        case QCss::COMMA: return "COMMA";
+        case QCss::STRING: return "STRING";
+        case QCss::INVALID: return "INVALID";
+        case QCss::IDENT: return "IDENT";
+        case QCss::HASH: return "HASH";
+        case QCss::ATKEYWORD_SYM: return "ATKEYWORD_SYM";
+        case QCss::EXCLAMATION_SYM: return "EXCLAMATION_SYM";
+        case QCss::LENGTH: return "LENGTH";
+        case QCss::PERCENTAGE: return "PERCENTAGE";
+        case QCss::NUMBER: return "NUMBER";
+        case QCss::FUNCTION: return "FUNCTION";
+        case QCss::COLON: return "COLON";
+        case QCss::SEMICOLON: return "SEMICOLON";
+        case QCss::RBRACE: return "RBRACE";
+        case QCss::SLASH: return "SLASH";
+        case QCss::MINUS: return "MINUS";
+        case QCss::DOT: return "DOT";
+        case QCss::STAR: return "STAR";
+        case QCss::LBRACKET: return "LBRACKET";
+        case QCss::RBRACKET: return "RBRACKET";
+        case QCss::EQUAL: return "EQUAL";
+        case QCss::LPAREN: return "LPAREN";
+        case QCss::RPAREN: return "RPAREN";
+        case QCss::OR: return "OR";
+    }
+    return "";
+}
+
 static void debug(const QVector<QCss::Symbol> &symbols, int index = -1)
 {
     qDebug() << "all symbols:";
     for (int i = 0; i < symbols.count(); ++i)
-        qDebug() << "(" << i << "); Token:" << QCss::Scanner::tokenName(symbols.at(i).token) << "; Lexem:" << symbols.at(i).lexem();
+        qDebug() << "(" << i << "); Token:" << tokenName(symbols.at(i).token) << "; Lexem:" << symbols.at(i).lexem();
     if (index != -1)
         qDebug() << "failure at index" << index;
 }
@@ -160,7 +201,7 @@ void tst_CssParser::scanner()
         QCOMPARE(l.count(), 2);
         const QString expectedToken = l.at(0);
         const QString expectedLexem = l.at(1);
-        QString actualToken = QString::fromLatin1(QCss::Scanner::tokenName(symbols.at(i).token));
+        QString actualToken = QString::fromLatin1(tokenName(symbols.at(i).token));
         if (actualToken != expectedToken) {
             debug(symbols, i);
             QCOMPARE(actualToken, expectedToken);
diff --git a/tests/auto/qfileinfo/tst_qfileinfo.cpp b/tests/auto/qfileinfo/tst_qfileinfo.cpp
index 3d7e6f8..cccdd64 100644
--- a/tests/auto/qfileinfo/tst_qfileinfo.cpp
+++ b/tests/auto/qfileinfo/tst_qfileinfo.cpp
@@ -61,6 +61,7 @@
 #include <qdebug.h>
 
 #include "../network-settings.h"
+#include <private/qfileinfo_p.h>
 
 //TESTED_CLASS=
 //TESTED_FILES=
@@ -75,6 +76,9 @@ public:
 
 private slots:
     void getSetCheck();
+
+    void copy();
+
     void isFile_data();
     void isFile();
 
@@ -178,6 +182,58 @@ void tst_QFileInfo::getSetCheck()
     QCOMPARE(true, obj1.caching());
 }
 
+static QFileInfoPrivate* getPrivate(QFileInfo &info)
+{
+    return (*reinterpret_cast<QFileInfoPrivate**>(&info));
+}
+
+void tst_QFileInfo::copy()
+{
+    QTemporaryFile *t;
+    t = new QTemporaryFile;
+    t->open();
+    QFileInfo info(t->fileName());
+    QVERIFY(info.exists());
+
+    //copy constructor
+    QFileInfo info2(info);
+    QFileInfoPrivate *privateInfo = getPrivate(info);
+    QFileInfoPrivate *privateInfo2 = getPrivate(info2);
+    QCOMPARE(privateInfo->data, privateInfo2->data);
+
+    //operator =
+    QFileInfo info3 = info;
+    QFileInfoPrivate *privateInfo3 = getPrivate(info3);
+    QCOMPARE(privateInfo->data, privateInfo3->data);
+    QCOMPARE(privateInfo2->data, privateInfo3->data);
+
+    //refreshing info3 will detach it
+    QFile file(info.absoluteFilePath());
+    QVERIFY(file.open(QFile::WriteOnly));
+    QCOMPARE(file.write("JAJAJAA"), qint64(7));
+    file.flush();
+
+    QTest::qWait(250);
+#if defined(Q_OS_WIN) || defined(Q_OS_WINCE)
+    if (QSysInfo::windowsVersion() & QSysInfo::WV_VISTA ||
+                QSysInfo::windowsVersion() & QSysInfo::WV_CE_based)
+        file.close();
+#endif
+#if defined(Q_OS_WINCE)
+    // On Windows CE we need to close the file.
+    // Otherwise the content will be cached and not
+    // flushed to the storage, although we flushed it
+    // manually!!! CE has interim cache, we cannot influence.
+    QTest::qWait(5000);
+#endif
+    info3.refresh();
+    QVERIFY(privateInfo->data != privateInfo3->data);
+    QVERIFY(privateInfo2->data != privateInfo3->data);
+    QCOMPARE(privateInfo->data, privateInfo2->data);
+
+
+}
+
 tst_QFileInfo::tst_QFileInfo()
 {
 }
diff --git a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
index 8afdeb4..481dc6b 100644
--- a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
+++ b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
@@ -44,6 +44,7 @@
 
 #include <private/qtextcontrol_p.h>
 #include <private/qgraphicsitem_p.h>
+#include <QStyleOptionGraphicsItem>
 #include <QAbstractTextDocumentLayout>
 #include <QBitmap>
 #include <QCursor>
@@ -219,8 +220,14 @@ private slots:
     void updateCachedItemAfterMove();
     void deviceTransform_data();
     void deviceTransform();
+    void update();
     void setTransformProperties_data();
     void setTransformProperties();
+    void itemUsesExtendedStyleOption();
+    void itemSendsGeometryChanges();
+    void moveItem();
+    void sorting_data();
+    void sorting();
 
     // task specific tests below me
     void task141694_textItemEnsureVisible();
@@ -231,6 +238,9 @@ private slots:
     void task240400_clickOnTextItem();
     void task243707_addChildBeforeParent();
     void task197802_childrenVisibility();
+
+private:
+    QList<QGraphicsItem *> paintedItems;
 };
 
 void tst_QGraphicsItem::init()
@@ -1790,15 +1800,15 @@ void tst_QGraphicsItem::setMatrix()
     QCOMPARE(rlist.at(2), unrotatedRect); // From post-update      (update current state)
 }
 
-static QList<QGraphicsItem *> paintedItems;
+static QList<QGraphicsItem *> _paintedItems;
 class PainterItem : public QGraphicsItem
 {
 protected:
     QRectF boundingRect() const
     { return QRectF(-10, -10, 20, 20); }
 
-    void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *)
-    { paintedItems << this; }
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+    { _paintedItems << this; painter->fillRect(boundingRect(), Qt::red); }
 };
 
 void tst_QGraphicsItem::zValue()
@@ -1830,10 +1840,10 @@ void tst_QGraphicsItem::zValue()
     QApplication::sendPostedEvents(); //glib workaround
 #endif
 
-    QVERIFY(!paintedItems.isEmpty());
-    QVERIFY((paintedItems.size() % 4) == 0);
+    QVERIFY(!_paintedItems.isEmpty());
+    QVERIFY((_paintedItems.size() % 4) == 0);
     for (int i = 0; i < 3; ++i)
-        QVERIFY(paintedItems.at(i)->zValue() < paintedItems.at(i + 1)->zValue());
+        QVERIFY(_paintedItems.at(i)->zValue() < _paintedItems.at(i + 1)->zValue());
 }
 
 void tst_QGraphicsItem::shape()
@@ -3726,8 +3736,20 @@ void tst_QGraphicsItem::defaultItemTest_QGraphicsEllipseItem()
 class ItemChangeTester : public QGraphicsRectItem
 {
 public:
-    ItemChangeTester(){}
-    ItemChangeTester(QGraphicsItem *parent) : QGraphicsRectItem(parent) {}
+    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;
 
@@ -3928,7 +3950,8 @@ void tst_QGraphicsItem::itemChange()
         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);
-        QCOMPARE(tester.values.at(tester.values.size() - 2), qVariantFromValue<quint32>(QGraphicsItem::ItemIsSelectable));
+        QVariant expectedFlags = qVariantFromValue<quint32>(QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemSendsGeometryChanges);
+        QCOMPARE(tester.values.at(tester.values.size() - 2), expectedFlags);
         QCOMPARE(tester.values.at(tester.values.size() - 1), qVariantFromValue<quint32>(QGraphicsItem::ItemIsSelectable));
     }
     {
@@ -5775,19 +5798,36 @@ void tst_QGraphicsItem::opacity2()
     QCOMPARE(grandChild->repaints, 0);
 }
 
+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()
 {
-    QGraphicsRectItem *parent1 = new QGraphicsRectItem(QRectF(0, 0, 100, 50));
-    QGraphicsRectItem *child11 = new QGraphicsRectItem(QRectF(-10, 10, 50, 50), parent1);
-    QGraphicsRectItem *grandChild111 = new QGraphicsRectItem(QRectF(-20, 20, 50, 50), child11);
-    QGraphicsRectItem *child12 = new QGraphicsRectItem(QRectF(60, 10, 50, 50), parent1);
-    QGraphicsRectItem *grandChild121 = new QGraphicsRectItem(QRectF(70, 20, 50, 50), child12);
+    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);
 
-    QGraphicsRectItem *parent2 = new QGraphicsRectItem(QRectF(0, 0, 100, 50));
-    QGraphicsRectItem *child21 = new QGraphicsRectItem(QRectF(-10, 10, 50, 50), parent2);
-    QGraphicsRectItem *grandChild211 = new QGraphicsRectItem(QRectF(-20, 20, 50, 50), child21);
-    QGraphicsRectItem *child22 = new QGraphicsRectItem(QRectF(60, 10, 50, 50), parent2);
-    QGraphicsRectItem *grandChild221 = new QGraphicsRectItem(QRectF(70, 20, 50, 50), child22);
+    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");
@@ -5809,25 +5849,57 @@ void tst_QGraphicsItem::itemStacksBehindParent()
     scene.addItem(parent1);
     scene.addItem(parent2);
 
+    paintedItems.clear();
+
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(250);
+
     QCOMPARE(scene.items(0, 0, 100, 100), (QList<QGraphicsItem *>()
                                            << grandChild111 << child11
                                            << grandChild121 << child12 << parent1
                                            << grandChild211 << child21
                                            << grandChild221 << child22 << parent2));
+    QCOMPARE(paintedItems, QList<QGraphicsItem *>()
+             << parent2 << child22 << grandChild221
+             << child21 << grandChild211
+             << parent1 << child12 << grandChild121
+             << child11 << grandChild111);
 
     child11->setFlag(QGraphicsItem::ItemStacksBehindParent);
+    scene.update();
+    paintedItems.clear();
+    QTest::qWait(250);
+
     QCOMPARE(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();
+    QTest::qWait(250);
+
     QCOMPARE(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
@@ -5876,6 +5948,7 @@ void tst_QGraphicsItem::nestedClipping()
     l3->setData(0, "l3");
 
     QGraphicsView view(&scene);
+    view.setOptimizationFlag(QGraphicsView::IndirectPainting);
     view.show();
 #ifdef Q_WS_X11
     qt_x11_wait_for_window_manager(&view);
@@ -6428,6 +6501,71 @@ 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;
+    MyGraphicsView view(&scene);
+
+    view.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);
+    const QRect itemDeviceBoundingRect = item->deviceTransform(view.viewportTransform())
+                                         .mapRect(item->boundingRect()).toRect();
+    const 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);
+}
+
 void tst_QGraphicsItem::setTransformProperties_data()
 {
     QTest::addColumn<QPointF>("origin");
@@ -6440,26 +6578,26 @@ void tst_QGraphicsItem::setTransformProperties_data()
     QTest::addColumn<qreal>("shearY");
 
     QTest::newRow("nothing") << QPointF() << qreal(0.0) << qreal(0.0) << qreal(0.0)
-                                          << qreal(1) << qreal(1) << qreal(0.0) << qreal(0.0);
+                                          << qreal(1.0) << qreal(1.0) << qreal(0.0) << qreal(0.0);
 
     QTest::newRow("rotationZ") << QPointF() << qreal(0.0) << qreal(0.0) << qreal(42.2)
-                                          << qreal(1) << qreal(1) << qreal(0.0) << qreal(0.0);
+                                          << qreal(1.0) << qreal(1.0) << qreal(0.0) << qreal(0.0);
 
     QTest::newRow("rotationXY") << QPointF() << qreal(12.5) << qreal(53.6) << qreal(0.0)
-                                          << qreal(1) << qreal(1) << qreal(0.0) << qreal(0.0);
+                                          << qreal(1.0) << qreal(1.0) << qreal(0.0) << qreal(0.0);
 
     QTest::newRow("rotationXYZ") << QPointF() << qreal(-25) << qreal(12) << qreal(556)
-                                          << qreal(1) << qreal(1) << qreal(0.0) << qreal(0.0);
+                                          << qreal(1.0) << qreal(1.0) << qreal(0.0) << qreal(0.0);
 
     QTest::newRow("rotationXYZ dicentred") << QPointF(-53, 25.2) 
                                 << qreal(-2578.2) << qreal(4565.2) << qreal(56)
-                                << qreal(1) << qreal(1) << qreal(0.0) << qreal(0.0);
+                                << qreal(1.0) << qreal(1.0) << qreal(0.0) << qreal(0.0);
 
     QTest::newRow("Scale")    << QPointF() << qreal(0.0) << qreal(0.0) << qreal(0.0)
                                           << qreal(6) << qreal(0.5) << qreal(0.0) << qreal(0.0);
 
     QTest::newRow("Shear")    << QPointF() << qreal(0.0) << qreal(0.0) << qreal(0.0)
-                                          << qreal(1) << qreal(1) << qreal(2.2) << qreal(0.5);
+                                          << qreal(1.0) << qreal(1.0) << qreal(2.2) << qreal(0.5);
 
     QTest::newRow("Scale and Shear")    << QPointF() << qreal(0.0) << qreal(0.0) << qreal(0.0)
                                           << qreal(5.2) << qreal(2.1) << qreal(5.2) << qreal(5.5);
@@ -6471,6 +6609,11 @@ void tst_QGraphicsItem::setTransformProperties_data()
                                         << qreal(4) << qreal(2) << qreal(2.56) << qreal(0.8);
 }
 
+/**
+ * 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);
@@ -6494,7 +6637,6 @@ void tst_QGraphicsItem::setTransformProperties()
     QGraphicsScene scene;
     QGraphicsRectItem *item = new QGraphicsRectItem(QRectF(0, 0, 100, 100));
     scene.addItem(item);
-    item->setPos(100, 100);
 
     item->setRotation(rotationX, rotationY, rotationZ);
     item->setScale(scaleX, scaleY);
@@ -6510,7 +6652,8 @@ void tst_QGraphicsItem::setTransformProperties()
     QCOMPARE(item->verticalShear(), shearY);
     QCOMPARE(item->transformOrigin(), origin);
 
-    QCOMPARE(result, item->transform());
+    QCOMPARE(QTransform(), item->transform());
+    QCOMPARE(result, item->sceneTransform());
 
     //-----------------------------------------------------------------
     //Change the rotation Z
@@ -6533,24 +6676,311 @@ void tst_QGraphicsItem::setTransformProperties()
     QCOMPARE(item->verticalShear(), shearY);
     QCOMPARE(item->transformOrigin(), origin);
 
-    QCOMPARE(result2, item->transform());
+    QCOMPARE(QTransform(), item->transform());
+    QCOMPARE(result2, item->sceneTransform());
 
     //-----------------------------------------------------------------
-    // calling setTransform() should reset the properties to their default
+    // calling setTransform() and setPos shoukld change the sceneTransform
     item->setTransform(result);
+    item->setPos(100, -150.5);
 
-    QCOMPARE(item->xRotation(), 0.0);
-    QCOMPARE(item->yRotation(), 0.0);
-    QCOMPARE(item->zRotation(), 0.0);
-    QCOMPARE(item->xScale(), 1.0);
-    QCOMPARE(item->yScale(), 1.0);
-    QCOMPARE(item->horizontalShear(), 0.0);
-    QCOMPARE(item->verticalShear(), 0.0);
-    QCOMPARE(item->transformOrigin(), QPointF(0,0));
-
+    QCOMPARE(item->xRotation(), rotationX);
+    QCOMPARE(item->yRotation(), rotationY);
+    QCOMPARE(item->zRotation(), 45.0);
+    QCOMPARE(item->xScale(), scaleX);
+    QCOMPARE(item->yScale(), scaleY);
+    QCOMPARE(item->horizontalShear(), shearX);
+    QCOMPARE(item->verticalShear(), shearY);
+    QCOMPARE(item->transformOrigin(), origin);
     QCOMPARE(result, item->transform());
+
+    QTransform result3;
+
+    result3.translate(origin.x(), origin.y());
+    result3 = result * result3;
+    result3.rotate(rotationX, Qt::XAxis);
+    result3.rotate(rotationY, Qt::YAxis);
+    result3.rotate(45, Qt::ZAxis);
+    result3.shear(shearX, shearY);
+    result3.scale(scaleX, scaleY);
+    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(rotationX, rotationY, rotationZ);
+        item1->setScale(scaleX, scaleY);
+        item1->setShear(shearX, shearY);
+        item1->setTransformOrigin(origin);
+
+        item2->setTransform(result);
+
+        QCOMPARE_TRANSFORM(item1->sceneTransform(), item2->sceneTransform());
+
+        QCOMPARE_TRANSFORM(item1->itemTransform(item2), QTransform()); 
+        QCOMPARE_TRANSFORM(item2->itemTransform(item1), QTransform());
+    }
+
+    {//with center origin on the item
+        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->setTransformOrigin(origin);
+        item2->setTransformOrigin(origin);
+
+        item1->setRotation(rotationX, rotationY, rotationZ);
+        item1->setScale(scaleX, scaleY);
+        item1->setShear(shearX, shearY);
+
+        QTransform tr;
+        tr.rotate(rotationX, Qt::XAxis);
+        tr.rotate(rotationY, Qt::YAxis);
+        tr.rotate(rotationZ, Qt::ZAxis);
+        tr.shear(shearX, shearY);
+        tr.scale(scaleX, scaleY);
+
+        item2->setTransform(tr);
+
+        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());
+            } else {
+                QVERIFY(option->exposedRect != QRect());
+                QVERIFY(option->exposedRect != boundingRect());
+            }
+        }
+        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);
+    QGraphicsView view(&scene);
+    QTest::qWait(500);
+    rect->startTrack = true;
+    rect->update(10, 10, 10, 10);
+    QTest::qWait(125);
+    rect->startTrack = false;
+    rect->setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, true);
+    QVERIFY((rect->flags() & QGraphicsItem::ItemUsesExtendedStyleOption));
+    QTest::qWait(125);
+    rect->startTrack = true;
+    rect->update(10, 10, 10, 10);
+    QTest::qWait(125);
+}
+
+void tst_QGraphicsItem::itemSendsGeometryChanges()
+{
+    ItemChangeTester item;
+    item.setFlags(0);
+    item.clear();
+
+    QTransform x = QTransform().rotate(45);
+    QPointF pos(10, 10);
+    qreal o(0.5);
+    item.setTransform(x);
+    item.setPos(pos);
+    QCOMPARE(item.transform(), x);
+    QCOMPARE(item.pos(), pos);
+    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);
+
+    QCOMPARE(item.changes, QList<QGraphicsItem::GraphicsItemChange>()
+             << QGraphicsItem::ItemOpacityChange
+             << QGraphicsItem::ItemOpacityHasChanged
+             << QGraphicsItem::ItemFlagsChange
+             << QGraphicsItem::ItemFlagsHaveChanged
+             << QGraphicsItem::ItemTransformChange
+             << QGraphicsItem::ItemTransformHasChanged
+             << QGraphicsItem::ItemPositionChange
+             << QGraphicsItem::ItemPositionHasChanged);
+}
+
+// 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()).toRect()
+                                     .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
+    QCOMPARE(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);
+    QCOMPARE(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);
+    QCOMPARE(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);
+    QCOMPARE(view.paintedRegion, expectedParentRegion);
 }
 
+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()
+{
+    _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(100, 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();
+
+    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]
+                 << item1 << item2);
+}
 
 QTEST_MAIN(tst_QGraphicsItem)
 #include "tst_qgraphicsitem.moc"
diff --git a/tests/auto/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp b/tests/auto/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
index d856024..fa0e035 100644
--- a/tests/auto/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
+++ b/tests/auto/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
@@ -1487,7 +1487,7 @@ void tst_QGraphicsProxyWidget::scrollUpdate()
 	     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, 13) << QRect(0, 13, 103, 10));
+             QVector<QRect>() << QRect(0, 0, 200, 12) << QRect(0, 12, 102, 10));
 }
 
 void tst_QGraphicsProxyWidget::setWidget_simple()
diff --git a/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp b/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp
index 0c5ebf6..8bb9122 100644
--- a/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp
+++ b/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp
@@ -274,7 +274,9 @@ void tst_QGraphicsScene::sceneRect()
     QCOMPARE(scene.sceneRect(), QRectF());
 
     QGraphicsItem *item = scene.addRect(QRectF(0, 0, 10, 10));
+    qApp->processEvents();
     item->setPos(-5, -5);
+    qApp->processEvents();
 
     QCOMPARE(scene.itemAt(0, 0), item);
     QCOMPARE(scene.itemAt(10, 10), (QGraphicsItem *)0);
@@ -1317,8 +1319,9 @@ void tst_QGraphicsScene::removeItem()
     scene.removeItem(hoverItem);
     hoverItem->setAcceptsHoverEvents(false);
     scene.addItem(hoverItem);
-    qApp->processEvents(); // update
-    qApp->processEvents(); // draw
+    qApp->processEvents(); // <- delayed update is called
+    qApp->processEvents(); // <- scene schedules pending update
+    qApp->processEvents(); // <- pending update is sent to view
     QVERIFY(!hoverItem->isHovered);
 }
 
@@ -2712,6 +2715,7 @@ void tst_QGraphicsScene::update()
 
     QGraphicsRectItem *rect = new QGraphicsRectItem(0, 0, 100, 100);
     scene.addItem(rect);
+    qApp->processEvents();
     rect->setPos(-100, -100);
 
     // This function forces indexing
diff --git a/tests/auto/qgraphicsview/tst_qgraphicsview.cpp b/tests/auto/qgraphicsview/tst_qgraphicsview.cpp
index 8e490ad..5167682 100644
--- a/tests/auto/qgraphicsview/tst_qgraphicsview.cpp
+++ b/tests/auto/qgraphicsview/tst_qgraphicsview.cpp
@@ -191,6 +191,7 @@ private slots:
     void centerOnDirtyItem();
     void mouseTracking();
     void mouseTracking2();
+    void render();
 
     // task specific tests below me
     void task172231_untransformableItems();
@@ -2525,6 +2526,8 @@ void tst_QGraphicsView::acceptMousePressEvent()
 
     scene.addRect(0, 0, 2000, 2000)->setFlag(QGraphicsItem::ItemIsMovable);
 
+    qApp->processEvents(); // ensure scene rect is updated
+
     QApplication::sendEvent(view.viewport(), &event);
     QVERIFY(view.accepted);
 }
@@ -3201,6 +3204,62 @@ void tst_QGraphicsView::mouseTracking2()
     QCOMPARE(spy.count(), 1);
 }
 
+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;
+    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);
+
+    QGraphicsView view(&scene);
+    view.setFrameStyle(0);
+    view.resize(200, 200);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(200);
+
+    QCOMPARE(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::task253415_reconnectUpdateSceneOnSceneChanged()
 {
     QGraphicsView view;
diff --git a/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp b/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp
index 56d42c3..00f3155 100644
--- a/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp
+++ b/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp
@@ -155,6 +155,7 @@ private slots:
     void windowFlags_data();
     void windowFlags();
     void shortcutsDeletion();
+    void painterStateProtectionOnWindowFrame();
 
     // Task fixes
     void task236127_bspTreeIndexFails();
@@ -2282,6 +2283,41 @@ void tst_QGraphicsWidget::shortcutsDeletion()
     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();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(500);
+}
+
 class ProxyStyle : public QCommonStyle
 {
 public:
diff --git a/tests/auto/qimagereader/qimagereader.qrc b/tests/auto/qimagereader/qimagereader.qrc
index 3c674ad..c6b963b 100644
--- a/tests/auto/qimagereader/qimagereader.qrc
+++ b/tests/auto/qimagereader/qimagereader.qrc
@@ -30,7 +30,7 @@
         <file>images/image.pgm</file>
         <file>images/image.png</file>
         <file>images/image.ppm</file>
-        <file>images/image.tif</file>
+        <file>images/image_100dpi.tif</file>
         <file>images/kollada.png</file>
         <file>images/marble.xpm</file>
         <file>images/namedcolors.xpm</file>
diff --git a/tests/auto/qimagereader/tst_qimagereader.cpp b/tests/auto/qimagereader/tst_qimagereader.cpp
index f5313eb..0b32f0a 100644
--- a/tests/auto/qimagereader/tst_qimagereader.cpp
+++ b/tests/auto/qimagereader/tst_qimagereader.cpp
@@ -156,6 +156,9 @@ private slots:
 
     void pixelCompareWithBaseline_data();
     void pixelCompareWithBaseline();
+
+    void task255627_setNullScaledSize_data();
+    void task255627_setNullScaledSize();
 };
 
 static const QLatin1String prefix(SRCDIR "/images/");
@@ -333,6 +336,29 @@ void tst_QImageReader::setScaledSize()
     QCOMPARE(image.size(), newSize);
 }
 
+void tst_QImageReader::task255627_setNullScaledSize_data()
+{
+    setScaledSize_data();
+}
+
+void tst_QImageReader::task255627_setNullScaledSize()
+{
+    QFETCH(QString, fileName);
+    QFETCH(QByteArray, format);
+
+    if (!format.isEmpty() && !QImageReader::supportedImageFormats().contains(format))
+        QSKIP("Qt does not support reading the \"" + format + "\" format", SkipSingle);
+
+    QImageReader reader(prefix + fileName);
+
+    // set a null size
+    reader.setScaledSize(QSize(0, 0));
+    reader.setQuality(0);
+    QImage image = reader.read();
+    QVERIFY(image.isNull());
+    QCOMPARE(image.size(), QSize(0, 0));
+}
+
 void tst_QImageReader::setClipRect_data()
 {
     QTest::addColumn<QString>("fileName");
diff --git a/tests/auto/qimagewriter/tst_qimagewriter.cpp b/tests/auto/qimagewriter/tst_qimagewriter.cpp
index 349afa5..3ceb2c2 100644
--- a/tests/auto/qimagewriter/tst_qimagewriter.cpp
+++ b/tests/auto/qimagewriter/tst_qimagewriter.cpp
@@ -59,6 +59,7 @@ Q_DECLARE_METATYPE(QStringMap)
 Q_DECLARE_METATYPE(QIntList)
 Q_DECLARE_METATYPE(QImageWriter::ImageWriterError)
 Q_DECLARE_METATYPE(QIODevice *)
+Q_DECLARE_METATYPE(QImage::Format)
 
 //TESTED_FILES=
 
@@ -82,6 +83,9 @@ private slots:
     void writeImage2();
     void supportedFormats();
 
+    void readWriteNonDestructive_data();
+    void readWriteNonDestructive();
+
 #if defined QTEST_HAVE_TIFF
     void largeTiff();
 #endif
@@ -376,6 +380,28 @@ void tst_QImageWriter::supportedFormats()
     QCOMPARE(formatSet.size(), formats.size());
 }
 
+void tst_QImageWriter::readWriteNonDestructive_data()
+{
+    QTest::addColumn<QImage::Format>("format");
+    QTest::addColumn<QImage::Format>("expectedFormat");
+    QTest::newRow("tiff mono") << QImage::Format_Mono << QImage::Format_Mono;
+    QTest::newRow("tiff indexed") << QImage::Format_Indexed8 << QImage::Format_Indexed8;
+    QTest::newRow("tiff rgb32") << QImage::Format_ARGB32 << QImage::Format_ARGB32;
+}
+
+void tst_QImageWriter::readWriteNonDestructive()
+{
+    QFETCH(QImage::Format, format);
+    QFETCH(QImage::Format, expectedFormat);
+    QImage image = QImage(prefix + "colorful.bmp").convertToFormat(format);
+    QVERIFY(image.save(prefix + "gen-readWriteNonDestructive.tiff"));
+
+    QImage image2 = QImage(prefix + "gen-readWriteNonDestructive.tiff");
+    QImage::Format readFormat = image2.format();
+    QCOMPARE(readFormat, expectedFormat);
+    QCOMPARE(image, image2);
+}
+
 void tst_QImageWriter::setDescription_data()
 {
     QTest::addColumn<QString>("fileName");
diff --git a/tests/auto/qlistwidget/tst_qlistwidget.cpp b/tests/auto/qlistwidget/tst_qlistwidget.cpp
index 8d15aa4..8468cf3 100644
--- a/tests/auto/qlistwidget/tst_qlistwidget.cpp
+++ b/tests/auto/qlistwidget/tst_qlistwidget.cpp
@@ -883,31 +883,46 @@ void tst_QListWidget::itemStreaming()
 void tst_QListWidget::sortItems_data()
 {
     QTest::addColumn<int>("order");
-    QTest::addColumn<QStringList>("initialList");
-    QTest::addColumn<QStringList>("expectedList");
+    QTest::addColumn<QVariantList>("initialList");
+    QTest::addColumn<QVariantList>("expectedList");
     QTest::addColumn<IntList>("expectedRows");
 
-    QTest::newRow("ascending order")
+    QTest::newRow("ascending strings")
         << static_cast<int>(Qt::AscendingOrder)
-        << (QStringList() << "c" << "d" << "a" << "b")
-        << (QStringList() << "a" << "b" << "c" << "d")
+        << (QVariantList() << QString("c") << QString("d") << QString("a") << QString("b"))
+        << (QVariantList() << QString("a") << QString("b") << QString("c") << QString("d"))
         << (IntList() << 2 << 3 << 0 << 1);
 
-    QTest::newRow("descending order")
+    QTest::newRow("descending strings")
         << static_cast<int>(Qt::DescendingOrder)
-        << (QStringList() << "c" << "d" << "a" << "b")
-        << (QStringList() << "d" << "c" << "b" << "a")
+        << (QVariantList() << QString("c") << QString("d") << QString("a") << QString("b"))
+        << (QVariantList() << QString("d") << QString("c") << QString("b") << QString("a"))
         << (IntList() << 1 << 0 << 3 << 2);
+
+    QTest::newRow("ascending numbers")
+        << static_cast<int>(Qt::AscendingOrder)
+        << (QVariantList() << 1 << 11 << 2 << 22)
+        << (QVariantList() << 1 << 2 << 11 << 22)
+        << (IntList() << 0 << 2 << 1 << 3);
+
+    QTest::newRow("descending numbers")
+        << static_cast<int>(Qt::DescendingOrder)
+        << (QVariantList() << 1 << 11 << 2 << 22)
+        << (QVariantList() << 22 << 11 << 2 << 1)
+        << (IntList() << 3 << 1 << 2 << 0);
 }
 
 void tst_QListWidget::sortItems()
 {
     QFETCH(int, order);
-    QFETCH(QStringList, initialList);
-    QFETCH(QStringList, expectedList);
+    QFETCH(QVariantList, initialList);
+    QFETCH(QVariantList, expectedList);
     QFETCH(IntList, expectedRows);
 
-    testWidget->addItems(initialList);
+    foreach (const QVariant &data, initialList) {
+        QListWidgetItem *item = new QListWidgetItem(testWidget);
+        item->setData(Qt::DisplayRole, data);
+    }
 
     QAbstractItemModel *model = testWidget->model();
     QList<QPersistentModelIndex> persistent;
@@ -918,7 +933,7 @@ void tst_QListWidget::sortItems()
 
     QCOMPARE(testWidget->count(), expectedList.count());
     for (int i = 0; i < testWidget->count(); ++i)
-        QCOMPARE(testWidget->item(i)->text(), expectedList.at(i));
+        QCOMPARE(testWidget->item(i)->text(), expectedList.at(i).toString());
 
     for (int k = 0; k < testWidget->count(); ++k)
         QCOMPARE(persistent.at(k).row(), expectedRows.at(k));
diff --git a/tests/auto/qwidget/tst_qwidget.cpp b/tests/auto/qwidget/tst_qwidget.cpp
index 041aa7a..85d7de1 100644
--- a/tests/auto/qwidget/tst_qwidget.cpp
+++ b/tests/auto/qwidget/tst_qwidget.cpp
@@ -288,6 +288,7 @@ private slots:
     void render_systemClip3_data();
     void render_systemClip3();
     void render_task252837();
+    void render_worldTransform();
 
     void setContentsMargins();
 
@@ -7151,6 +7152,99 @@ void tst_QWidget::render_task252837()
     // Please do not crash.
     widget.render(&painter);
 }
+
+void tst_QWidget::render_worldTransform()
+{
+    class MyWidget : public QWidget
+    { public:
+        void paintEvent(QPaintEvent *)
+        {
+            QPainter painter(this);
+            // Make sure world transform is identity.
+            QCOMPARE(painter.worldTransform(), QTransform());
+
+            // Make sure device transform is correct.
+            const QPoint widgetOffset = geometry().topLeft();
+            QTransform expectedDeviceTransform = QTransform::fromTranslate(105, 5);
+            expectedDeviceTransform.rotate(90);
+            expectedDeviceTransform.translate(widgetOffset.x(), widgetOffset.y());
+            QCOMPARE(painter.deviceTransform(), expectedDeviceTransform);
+
+            // Set new world transform.
+            QTransform newWorldTransform = QTransform::fromTranslate(10, 10);
+            newWorldTransform.rotate(90);
+            painter.setWorldTransform(newWorldTransform);
+            QCOMPARE(painter.worldTransform(), newWorldTransform);
+
+            // Again, check device transform.
+            expectedDeviceTransform.translate(10, 10);
+            expectedDeviceTransform.rotate(90);
+            QCOMPARE(painter.deviceTransform(), expectedDeviceTransform);
+
+            painter.fillRect(QRect(0, 0, 20, 10), Qt::green);
+        }
+    };
+
+    MyWidget widget;
+    widget.setFixedSize(100, 100);
+    widget.setPalette(Qt::red);
+    widget.setAutoFillBackground(true);
+
+    MyWidget child;
+    child.setParent(&widget);
+    child.move(50, 50);
+    child.setFixedSize(50, 50);
+    child.setPalette(Qt::blue);
+    child.setAutoFillBackground(true);
+
+    QImage image(QSize(110, 110), QImage::Format_RGB32);
+    image.fill(QColor(Qt::black).rgb());
+
+    QPainter painter(&image);
+    painter.translate(105, 5);
+    painter.rotate(90);
+
+    const QTransform worldTransform = painter.worldTransform();
+    const QTransform deviceTransform = painter.deviceTransform();
+
+    // Render widgets onto image.
+    widget.render(&painter);
+#ifdef RENDER_DEBUG
+    image.save("render_worldTransform_image.png");
+#endif
+
+    // Ensure the transforms are unchanged after render.
+    QCOMPARE(painter.worldTransform(), painter.worldTransform());
+    QCOMPARE(painter.deviceTransform(), painter.deviceTransform());
+    painter.end();
+
+    // Paint expected image.
+    QImage expected(QSize(110, 110), QImage::Format_RGB32);
+    expected.fill(QColor(Qt::black).rgb());
+
+    QPainter expectedPainter(&expected);
+    expectedPainter.translate(105, 5);
+    expectedPainter.rotate(90);
+    expectedPainter.save();
+    expectedPainter.fillRect(widget.rect(),Qt::red);
+    expectedPainter.translate(10, 10);
+    expectedPainter.rotate(90);
+    expectedPainter.fillRect(QRect(0, 0, 20, 10), Qt::green);
+    expectedPainter.restore();
+    expectedPainter.translate(50, 50);
+    expectedPainter.fillRect(child.rect(),Qt::blue);
+    expectedPainter.translate(10, 10);
+    expectedPainter.rotate(90);
+    expectedPainter.fillRect(QRect(0, 0, 20, 10), Qt::green);
+    expectedPainter.end();
+
+#ifdef RENDER_DEBUG
+    expected.save("render_worldTransform_expected.png");
+#endif
+
+    QCOMPARE(image, expected);
+}
+
 void tst_QWidget::setContentsMargins()
 {
     QLabel label("why does it always rain on me?");