Merge remote branch 'qt-official/4.6' into 4.6

author: Morten Johan Sørvig <morten.sorvig@nokia.com> 2009-11-05 06:26:24 (GMT)
committer: Morten Johan Sørvig <morten.sorvig@nokia.com> 2009-11-05 06:26:24 (GMT)
commit: ee88b2d8408396188eb2ce52d740c395c6cd4656 (patch)
tree: 1f59ea0612fecbaca595594d3812dd2aab64cf63 /tests
parent: 673973acc20ce4e068d63fa5b0391f5c785be8a3 (diff)
parent: aa58293b57a05cd52b36ba14a05958dceb65c603 (diff)
download: Qt-ee88b2d8408396188eb2ce52d740c395c6cd4656.zip
Qt-ee88b2d8408396188eb2ce52d740c395c6cd4656.tar.gz
Qt-ee88b2d8408396188eb2ce52d740c395c6cd4656.tar.bz2
93 files changed, 3364 insertions, 621 deletions
diff --git a/tests/auto/auto.pro b/tests/auto/auto.pro
index 0f7a7f1..1ec4c16 100644
--- a/tests/auto/auto.pro
+++ b/tests/auto/auto.pro
@@ -501,3 +501,5 @@ contains(QT_CONFIG, webkit): SUBDIRS += \
            qwebhistoryinterface \
            qwebelement \
            qwebhistory
+
+contains(QT_CONFIG, declarative): SUBDIRS += declarative
diff --git a/tests/auto/checkxmlfiles/checkxmlfiles.pro b/tests/auto/checkxmlfiles/checkxmlfiles.pro
index c368c02..d53c11c 100644
--- a/tests/auto/checkxmlfiles/checkxmlfiles.pro
+++ b/tests/auto/checkxmlfiles/checkxmlfiles.pro
@@ -12,7 +12,7 @@ addFiles.sources = \
 	$$QT_SOURCE_TREE/examples/sql/masterdetail/albumdetails.xml \
 	$$QT_SOURCE_TREE/examples/xmlpatterns/xquery/globalVariables/globals.gccxml \
 	$$QT_SOURCE_TREE/doc/src/diagrams/stylesheet/treeview.svg \
-	$$QT_SOURCE_TREE/doc/src/diagrams/designer-mainwindow-actions.ui \
+	$$QT_SOURCE_TREE/doc/src/diagrams/designer-manual/designer-mainwindow-actions.ui \
 	$$QT_SOURCE_TREE/demos/undo/undo.qrc
 addFiles.path = xmlfiles
 DEPLOYMENT += addFiles
diff --git a/tests/auto/collections/tst_collections.cpp b/tests/auto/collections/tst_collections.cpp
index 670cff0..f97805e 100644
--- a/tests/auto/collections/tst_collections.cpp
+++ b/tests/auto/collections/tst_collections.cpp
@@ -164,6 +164,7 @@ private slots:
     void qtimerList();
     void containerTypedefs();
     void forwardDeclared();
+    void alignment();
 };
 
 struct LargeStatic {
@@ -3481,5 +3482,113 @@ void tst_Collections::forwardDeclared()
     { typedef QSet<T1> C; C *x = 0; /* C::iterator i; */ C::const_iterator j; Q_UNUSED(x) }
 }
 
+#if defined(Q_ALIGNOF) && defined(Q_DECL_ALIGN)
+
+class Q_DECL_ALIGN(4) Aligned4
+{
+    char i;
+public:
+    Aligned4(int i = 0) : i(i) {}
+    bool checkAligned() const
+    {
+        return (quintptr(this) & 3) == 0;
+    }
+
+    inline bool operator==(const Aligned4 &other) const { return i == other.i; }
+    inline bool operator<(const Aligned4 &other) const { return i < other.i; }
+    friend inline int qHash(const Aligned4 &a) { return qHash(a.i); }
+};
+
+class Q_DECL_ALIGN(128) Aligned128
+{
+    char i;
+public:
+    Aligned128(int i = 0) : i(i) {}
+    bool checkAligned() const
+    {
+        return (quintptr(this) & 127) == 0;
+    }
+
+    inline bool operator==(const Aligned128 &other) const { return i == other.i; }
+    inline bool operator<(const Aligned128 &other) const { return i < other.i; }
+    friend inline int qHash(const Aligned128 &a) { return qHash(a.i); }
+};
+
+template<typename C>
+void testVectorAlignment()
+{
+    typedef typename C::value_type Aligned;
+    C container;
+    container.append(Aligned());
+    QVERIFY(container[0].checkAligned());
+
+    for (int i = 0; i < 200; ++i)
+        container.append(Aligned());
+    
+    for (int i = 0; i < container.size(); ++i)
+        QVERIFY(container.at(i).checkAligned());
+}
+
+template<typename C>
+void testContiguousCacheAlignment()
+{
+    typedef typename C::value_type Aligned;
+    C container(150);
+    container.append(Aligned());
+    QVERIFY(container[container.firstIndex()].checkAligned());
+
+    for (int i = 0; i < 200; ++i)
+        container.append(Aligned());
+
+    for (int i = container.firstIndex(); i < container.lastIndex(); ++i)
+        QVERIFY(container.at(i).checkAligned());
+}
+
+template<typename C>
+void testAssociativeContainerAlignment()
+{
+    typedef typename C::key_type Key;
+    typedef typename C::mapped_type Value;
+    C container;
+    container.insert(Key(), Value());
+
+    typename C::const_iterator it = container.constBegin();
+    QVERIFY(it.key().checkAligned());
+    QVERIFY(it.value().checkAligned());
+
+    // add some more elements
+    for (int i = 0; i < 200; ++i)
+        container.insert(Key(i), Value(i));
+
+    it = container.constBegin();
+    for ( ; it != container.constEnd(); ++it) {
+        QVERIFY(it.key().checkAligned());
+        QVERIFY(it.value().checkAligned());
+    }
+}
+
+void tst_Collections::alignment()
+{
+    testVectorAlignment<QVector<Aligned4> >();
+    testVectorAlignment<QVector<Aligned128> >();
+    testContiguousCacheAlignment<QContiguousCache<Aligned4> >();
+    testContiguousCacheAlignment<QContiguousCache<Aligned128> >();
+    testAssociativeContainerAlignment<QMap<Aligned4, Aligned4> >();
+    testAssociativeContainerAlignment<QMap<Aligned4, Aligned128> >();
+    testAssociativeContainerAlignment<QMap<Aligned128, Aligned4> >();
+    testAssociativeContainerAlignment<QMap<Aligned128, Aligned128> >();
+    testAssociativeContainerAlignment<QHash<Aligned4, Aligned4> >();
+    testAssociativeContainerAlignment<QHash<Aligned4, Aligned128> >();
+    testAssociativeContainerAlignment<QHash<Aligned128, Aligned4> >();
+    testAssociativeContainerAlignment<QHash<Aligned128, Aligned128> >();
+}
+
+#else
+void tst_Collections::alignment()
+{
+    QSKIP("Compiler doesn't support necessary extension keywords", SkipAll)
+}
+#endif
+
 QTEST_APPLESS_MAIN(tst_Collections)
 #include "tst_collections.moc"
diff --git a/tests/auto/qabstractvideosurface/tst_qabstractvideosurface.cpp b/tests/auto/qabstractvideosurface/tst_qabstractvideosurface.cpp
index 20ca759..b4d2ac8 100644
--- a/tests/auto/qabstractvideosurface/tst_qabstractvideosurface.cpp
+++ b/tests/auto/qabstractvideosurface/tst_qabstractvideosurface.cpp
@@ -61,6 +61,8 @@ private slots:
     void setError();
     void isFormatSupported_data();
     void isFormatSupported();
+    void nearestFormat_data();
+    void nearestFormat();
     void start_data();
     void start();
 };
@@ -232,6 +234,22 @@ void tst_QAbstractVideoSurface::isFormatSupported()
     QCOMPARE(surface.isFormatSupported(format), supported);
 }
 
+void tst_QAbstractVideoSurface::nearestFormat_data()
+{
+    isFormatSupported_data();
+}
+
+void tst_QAbstractVideoSurface::nearestFormat()
+{
+    QFETCH(SupportedFormatMap, supportedFormats);
+    QFETCH(QVideoSurfaceFormat, format);
+    QFETCH(bool, supported);
+
+    QtTestVideoSurface surface(supportedFormats);
+
+    QCOMPARE(surface.nearestFormat(format) == format, supported);
+}
+
 void tst_QAbstractVideoSurface::start_data()
 {
     QTest::addColumn<QVideoSurfaceFormat>("format");
@@ -256,35 +274,35 @@ void tst_QAbstractVideoSurface::start()
     surface.setError(QAbstractVideoSurface::ResourceError);
 
     QSignalSpy formatSpy(&surface, SIGNAL(surfaceFormatChanged(QVideoSurfaceFormat)));
-    QSignalSpy startedSpy(&surface, SIGNAL(startedChanged(bool)));
+    QSignalSpy activeSpy(&surface, SIGNAL(activeChanged(bool)));
 
-    QVERIFY(!surface.isStarted());
+    QVERIFY(!surface.isActive());
     QCOMPARE(surface.surfaceFormat(), QVideoSurfaceFormat());
 
     QVERIFY(surface.start(format));
 
-    QVERIFY(surface.isStarted());
+    QVERIFY(surface.isActive());
     QCOMPARE(surface.surfaceFormat(), format);
 
     QCOMPARE(formatSpy.count(), 1);
-    QCOMPARE(qvariant_cast<QVideoSurfaceFormat>(formatSpy.at(0).at(0)), format);
+    QCOMPARE(qvariant_cast<QVideoSurfaceFormat>(formatSpy.last().at(0)), format);
 
-    QCOMPARE(startedSpy.count(), 1);
-    QCOMPARE(startedSpy.at(0).at(0).toBool(), true);
+    QCOMPARE(activeSpy.count(), 1);
+    QCOMPARE(activeSpy.last().at(0).toBool(), true);
 
     // error() is reset on a successful start.
     QCOMPARE(surface.error(), QAbstractVideoSurface::NoError);
 
     surface.stop();
 
-    QVERIFY(!surface.isStarted());
+    QVERIFY(!surface.isActive());
     QCOMPARE(surface.surfaceFormat(), QVideoSurfaceFormat());
 
     QCOMPARE(formatSpy.count(), 2);
-    QCOMPARE(qvariant_cast<QVideoSurfaceFormat>(formatSpy.at(1).at(0)), QVideoSurfaceFormat());
+    QCOMPARE(qvariant_cast<QVideoSurfaceFormat>(formatSpy.last().at(0)), QVideoSurfaceFormat());
 
-    QCOMPARE(startedSpy.count(), 2);
-    QCOMPARE(startedSpy.at(1).at(0).toBool(), false);
+    QCOMPARE(activeSpy.count(), 2);
+    QCOMPARE(activeSpy.last().at(0).toBool(), false);
 }
 
 QTEST_MAIN(tst_QAbstractVideoSurface)
diff --git a/tests/auto/qactiongroup/tst_qactiongroup.cpp b/tests/auto/qactiongroup/tst_qactiongroup.cpp
index 2d215a0..7259479 100644
--- a/tests/auto/qactiongroup/tst_qactiongroup.cpp
+++ b/tests/auto/qactiongroup/tst_qactiongroup.cpp
@@ -70,6 +70,7 @@ private slots:
 
     void separators();
     void testActionInTwoQActionGroup();
+	void unCheckCurrentAction();
 };
 
 tst_QActionGroup::tst_QActionGroup()
@@ -278,5 +279,25 @@ void tst_QActionGroup::testActionInTwoQActionGroup()
     QCOMPARE(group1.actions().isEmpty(), true);
 }
 
+void tst_QActionGroup::unCheckCurrentAction()
+{
+    QActionGroup group(0);
+    QAction action1(&group) ,action2(&group);
+    action1.setCheckable(true);
+    action2.setCheckable(true);
+    QVERIFY(!action1.isChecked());
+    QVERIFY(!action2.isChecked());
+    action1.setChecked(true);
+    QVERIFY(action1.isChecked());
+    QVERIFY(!action2.isChecked());
+    QAction *current = group.checkedAction();
+    QCOMPARE(current, &action1);
+    current->setChecked(false);
+    QVERIFY(!action1.isChecked());
+    QVERIFY(!action2.isChecked());
+    QVERIFY(group.checkedAction() == 0);
+}
+
+
 QTEST_MAIN(tst_QActionGroup)
 #include "tst_qactiongroup.moc"
diff --git a/tests/auto/qalgorithms/tst_qalgorithms.cpp b/tests/auto/qalgorithms/tst_qalgorithms.cpp
index 1f1de82..176a451 100644
--- a/tests/auto/qalgorithms/tst_qalgorithms.cpp
+++ b/tests/auto/qalgorithms/tst_qalgorithms.cpp
@@ -602,9 +602,15 @@ void tst_QAlgorithms::test_qUpperBound()
 void tst_QAlgorithms::test_qBinaryFind_data()
 {
     QTest::addColumn<QList<int> >("data");
-    QTest::addColumn<int>("resultValue");
+    QTest::addColumn<int>("resultValue"); // -42 means not found
 
     QTest::newRow("sorted-duplicate") << (QList<int>() << 1 << 2 << 2 << 3) << 2;
+    QTest::newRow("sorted-end") << (QList<int>() << -5 << -2 << 0 << 8) << 8;
+    QTest::newRow("sorted-beginning") << (QList<int>() << -5 << -2 << 0 << 8) << -5;
+    QTest::newRow("sorted-duplicate-beginning") << (QList<int>() << -5 << -5 << -2 << 0 << 8) << -5;
+    QTest::newRow("empty") << (QList<int>()) << -42;
+    QTest::newRow("not found 1 ") << (QList<int>() << 1 << 5 << 8 << 65) << -42;
+    QTest::newRow("not found 2 ") << (QList<int>() << -456 << -5 << 8 << 65) << -42;
 }
 
 void tst_QAlgorithms::test_qBinaryFind()
@@ -612,6 +618,15 @@ void tst_QAlgorithms::test_qBinaryFind()
     QFETCH(QList<int>, data);
     QFETCH(int, resultValue);
 
+    //-42 means not found
+    if (resultValue == -42) {
+        QVERIFY(qBinaryFind(data.constBegin(), data.constEnd(), resultValue) == data.end());
+        QVERIFY(qBinaryFind(data, resultValue) == data.end());
+        QVERIFY(qBinaryFind(data.begin(), data.end(), resultValue) == data.end());
+        QVERIFY(qBinaryFind(data.begin(), data.end(), resultValue, qLess<int>()) == data.end());
+        return;
+    }
+
     QCOMPARE(*qBinaryFind(data.constBegin(), data.constEnd(), resultValue), resultValue);
     QCOMPARE(*qBinaryFind(data.begin(), data.end(), resultValue), resultValue);
     QCOMPARE(*qBinaryFind(data, resultValue), resultValue);
diff --git a/tests/auto/qboxlayout/tst_qboxlayout.cpp b/tests/auto/qboxlayout/tst_qboxlayout.cpp
index 7ff444b..8887288 100644
--- a/tests/auto/qboxlayout/tst_qboxlayout.cpp
+++ b/tests/auto/qboxlayout/tst_qboxlayout.cpp
@@ -211,7 +211,6 @@ void tst_QBoxLayout::setGeometry()
 
     QRect newGeom(0, 0, 70, 70);
     lay2->setGeometry(newGeom);
-    QApplication::processEvents();
     QVERIFY2(newGeom.contains(dial->geometry()), "dial->geometry() should be smaller and within newGeom");
 }
 
diff --git a/tests/auto/qclipboard/test/test.pro b/tests/auto/qclipboard/test/test.pro
index 508eba1..62a38af 100644
--- a/tests/auto/qclipboard/test/test.pro
+++ b/tests/auto/qclipboard/test/test.pro
@@ -13,7 +13,18 @@ win32 {
 wince*|symbian*: {
   copier.sources = ../copier/copier.exe
   copier.path = copier
-  paster.sources = ../paster/paster.exe
+  paster.sources = ../paster/paster.exe  
   paster.path = paster
-  DEPLOYMENT = copier paster
+  
+  symbian*: {
+    load(data_caging_paths)
+    rsc.sources = $${EPOCROOT}$$HW_ZDIR$$APP_RESOURCE_DIR/copier.rsc
+    rsc.sources += $${EPOCROOT}$$HW_ZDIR$$APP_RESOURCE_DIR/paster.rsc
+    rsc.path = $$APP_RESOURCE_DIR
+    reg_resource.sources = $${EPOCROOT}$$HW_ZDIR$$REG_RESOURCE_IMPORT_DIR/copier_reg.rsc
+    reg_resource.sources += $${EPOCROOT}$$HW_ZDIR$$REG_RESOURCE_IMPORT_DIR/paster_reg.rsc
+    reg_resource.path = $$REG_RESOURCE_IMPORT_DIR
+  }
+  
+  DEPLOYMENT = copier paster rsc reg_resource
 }
 \ No newline at end of file
diff --git a/tests/auto/qcombobox/tst_qcombobox.cpp b/tests/auto/qcombobox/tst_qcombobox.cpp
index 0d3469d..51a7ff8 100644
--- a/tests/auto/qcombobox/tst_qcombobox.cpp
+++ b/tests/auto/qcombobox/tst_qcombobox.cpp
@@ -152,6 +152,8 @@ private slots:
     void subControlRectsWithOffset();
     void task260974_menuItemRectangleForComboBoxPopup();
     void removeItem();
+    void resetModel();
+    void keyBoardNavigationWithMouse();
 
 protected slots:
     void onEditTextChanged( const QString &newString );
@@ -2416,5 +2418,88 @@ void tst_QComboBox::removeItem()
     QCOMPARE(cb.count(), 0);
 }
 
+void tst_QComboBox::resetModel()
+{
+    class StringListModel : public QStringListModel
+    {
+    public:
+        StringListModel(const QStringList &list) : QStringListModel(list)
+        {
+        }
+
+        void reset()
+        {
+            QStringListModel::reset();
+        }
+    };
+    QComboBox cb;
+    StringListModel model( QStringList() << "1" << "2");
+    QSignalSpy spy(&cb, SIGNAL(currentIndexChanged(int)));
+    QCOMPARE(spy.count(), 0);
+    QCOMPARE(cb.currentIndex(), -1); //no selection
+
+    cb.setModel(&model);
+
+    QCOMPARE(spy.count(), 1);
+    QCOMPARE(cb.currentIndex(), 0); //first item selected
+
+    model.reset();
+    QCOMPARE(spy.count(), 2);
+    QCOMPARE(cb.currentIndex(), -1); //no selection
+
+}
+
+void tst_QComboBox::keyBoardNavigationWithMouse()
+{
+    QComboBox combo;
+    combo.setEditable(false);
+    for (int i = 0; i < 80; i++)
+        combo.addItem( QString::number(i));
+    combo.show();
+    QApplication::setActiveWindow(&combo);
+    QTest::qWaitForWindowShown(&combo);
+    QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&combo));
+
+    QCOMPARE(combo.currentText(), QLatin1String("0"));
+
+    combo.setFocus();
+    QTRY_VERIFY(combo.hasFocus());
+
+    QTest::keyClick(testWidget->lineEdit(), Qt::Key_Space);
+    QTest::qWait(30);
+    QTRY_VERIFY(combo.view());
+    QTRY_VERIFY(combo.view()->isVisible());
+    QTest::qWait(130);
+
+    QCOMPARE(combo.currentText(), QLatin1String("0"));
+
+    QCursor::setPos(combo.view()->mapToGlobal(combo.view()->rect().center()));
+    QTest::qWait(200);
+
+#define GET_SELECTION(SEL) \
+    QCOMPARE(combo.view()->selectionModel()->selection().count(), 1); \
+    QCOMPARE(combo.view()->selectionModel()->selection().indexes().count(), 1); \
+    SEL = combo.view()->selectionModel()->selection().indexes().first().row()
+
+    int selection;
+    GET_SELECTION(selection);
+
+    //since we moved the mouse is in the middle it should even be around 5;
+    QVERIFY(selection > 3);
+
+    static const int final = 40;
+    for (int i = selection + 1;  i <= final; i++)
+    {
+        QTest::keyClick(combo.view(), Qt::Key_Down);
+        QTest::qWait(20);
+        GET_SELECTION(selection);
+        QCOMPARE(selection, i);
+    }
+
+    QTest::keyClick(combo.view(), Qt::Key_Enter);
+    QTRY_COMPARE(combo.currentText(), QString::number(final));
+}
+
+
 QTEST_MAIN(tst_QComboBox)
 #include "tst_qcombobox.moc"
diff --git a/tests/auto/qdatastream/tst_qdatastream.cpp b/tests/auto/qdatastream/tst_qdatastream.cpp
index add0945..56fc53a 100644
--- a/tests/auto/qdatastream/tst_qdatastream.cpp
+++ b/tests/auto/qdatastream/tst_qdatastream.cpp
@@ -3100,22 +3100,6 @@ void tst_QDataStream::streamToAndFromQByteArray()
 
 void tst_QDataStream::streamRealDataTypes()
 {
-#if defined(Q_OS_WINCE)
-    // Note: Probably actually same 'qreal being typedeffed as float instead of double' issue as in Symbian
-    // instead of what CE skip message says.
-    QSKIP("Skipped on CE as it demands too much memory and fragments", SkipAll);
-#elif defined(Q_OS_SYMBIAN)
-    // qreal is typedeffed float in symbian instead of double like in most platforms, so reference stream
-    // gets corrupted. Basically this test is flawed, as one shouldn't use naked typedeffed types in
-    // streams that are meant to work cross-platform.
-    // As this test also tests other floating point using classes, we do not simply skip it, but work around
-    // the qreal issue by redefining qreal as double for the duration of this function.
-    // Note that streaming classes works because they do explicitly use double instead of qreal when
-    // writing/reading to/from stream.
-#   define qreal double
-    qWarning("Note: streamRealDataTypes test redefines qreal as double in symbian!!!");
-#endif
-
     // Generate QPicture from SVG.
     QSvgRenderer renderer(svgFile);
     QVERIFY(renderer.isValid());
@@ -3163,7 +3147,6 @@ void tst_QDataStream::streamRealDataTypes()
             file.close();
         }
 
-        qreal a, b, c, d, e, f;
         QPointF point;
         QRectF rect;
         QPolygonF polygon;
@@ -3180,28 +3163,50 @@ void tst_QDataStream::streamRealDataTypes()
         QDataStream stream(&file);
         stream.setVersion(QDataStream::Qt_4_2);
 
-        stream >> a >> b >> c >> d >> e >> f >> point
-               >> rect >> polygon >> matrix >> p;
-        if (i == 1)
-            stream >> pict;
-        stream >> textLength >> col >> rGrad >> cGrad
-               >> pen;
-
-        QCOMPARE(stream.status(), QDataStream::Ok);
-
-        QCOMPARE(a, qreal(0));
-        QCOMPARE(b, qreal(1.0));
-        QCOMPARE(c, qreal(1.1));
-        QCOMPARE(d, qreal(3.14));
-        QCOMPARE(e, qreal(-3.14));
-        QCOMPARE(f, qreal(-1));
+        if (i == 0) {
+            // the reference stream for 4.2 contains doubles,
+            // so we must read them out as doubles!
+            double a, b, c, d, e, f;
+            stream >> a;
+            QCOMPARE(a, 0.0);
+            stream >> b;
+            QCOMPARE(b, 1.0);
+            stream >> c;
+            QCOMPARE(c, 1.1);
+            stream >> d;
+            QCOMPARE(d, 3.14);
+            stream >> e;
+            QCOMPARE(e, -3.14);
+            stream >> f;
+            QCOMPARE(f, -1.0);
+        } else {
+            qreal a, b, c, d, e, f;
+            stream >> a;
+            QCOMPARE(a, qreal(0));
+            stream >> b;
+            QCOMPARE(b, qreal(1.0));
+            stream >> c;
+            QCOMPARE(c, qreal(1.1));
+            stream >> d;
+            QCOMPARE(d, qreal(3.14));
+            stream >> e;
+            QCOMPARE(e, qreal(-3.14));
+            stream >> f;
+            QCOMPARE(f, qreal(-1));
+        }
+        stream >> point;
         QCOMPARE(point, QPointF(3, 5));
+        stream >> rect;
         QCOMPARE(rect, QRectF(-1, -2, 3, 4));
+        stream >> polygon;
         QCOMPARE((QVector<QPointF> &)polygon, (QPolygonF() << QPointF(0, 0) << QPointF(1, 2)));
+        stream >> matrix;
         QCOMPARE(matrix, QMatrix().rotate(90).scale(2, 2));
+        stream >> p;
         QCOMPARE(p, path);
+        if (i == 1) {
+            stream >> pict;
 
-        if (i == 0) {
             QByteArray pictA, pictB;
             QBuffer bufA, bufB;
             QVERIFY(bufA.open(QIODevice::ReadWrite));
@@ -3212,8 +3217,11 @@ void tst_QDataStream::streamRealDataTypes()
 
             QCOMPARE(pictA, pictB);
         }
+        stream >> textLength;
         QCOMPARE(textLength, QTextLength(QTextLength::VariableLength, 1.5));
+        stream >> col;
         QCOMPARE(col, color);
+        stream >> rGrad;
         QCOMPARE(rGrad.style(), radialBrush.style());
         QCOMPARE(rGrad.matrix(), radialBrush.matrix());
         QCOMPARE(rGrad.gradient()->type(), radialBrush.gradient()->type());
@@ -3222,6 +3230,7 @@ void tst_QDataStream::streamRealDataTypes()
         QCOMPARE(((QRadialGradient *)rGrad.gradient())->center(), ((QRadialGradient *)radialBrush.gradient())->center());
         QCOMPARE(((QRadialGradient *)rGrad.gradient())->focalPoint(), ((QRadialGradient *)radialBrush.gradient())->focalPoint());
         QCOMPARE(((QRadialGradient *)rGrad.gradient())->radius(), ((QRadialGradient *)radialBrush.gradient())->radius());
+        stream >> cGrad;
         QCOMPARE(cGrad.style(), conicalBrush.style());
         QCOMPARE(cGrad.matrix(), conicalBrush.matrix());
         QCOMPARE(cGrad.gradient()->type(), conicalBrush.gradient()->type());
@@ -3231,11 +3240,11 @@ void tst_QDataStream::streamRealDataTypes()
         QCOMPARE(((QConicalGradient *)cGrad.gradient())->angle(), ((QConicalGradient *)conicalBrush.gradient())->angle());
 
         QCOMPARE(cGrad, conicalBrush);
+        stream >> pen;
         QCOMPARE(pen.widthF(), qreal(1.5));
+
+        QCOMPARE(stream.status(), QDataStream::Ok);
     }
-#if defined(Q_OS_SYMBIAN)
-    #undef qreal
-#endif
 }
 
 #ifdef QT3_SUPPORT
diff --git a/tests/auto/qdatetime/tst_qdatetime.cpp b/tests/auto/qdatetime/tst_qdatetime.cpp
index 8fb0c91..1140402 100644
--- a/tests/auto/qdatetime/tst_qdatetime.cpp
+++ b/tests/auto/qdatetime/tst_qdatetime.cpp
@@ -447,7 +447,15 @@ void tst_QDateTime::toString_enumformat()
     QCOMPARE(str2, QString("1995-05-20T12:34:56"));
 
     QString str3 = dt1.toString(Qt::LocalDate);
+    qDebug() << str3;
     QVERIFY(!str3.isEmpty());
+    //check for date/time components in any order
+    //year may be 2 or 4 digits
+    QVERIFY(str3.contains("95"));
+    //day and month may be in numeric or word form
+    QVERIFY(str3.contains("12"));
+    QVERIFY(str3.contains("34"));
+    //seconds may be absent
 }
 
 void tst_QDateTime::addDays()
diff --git a/tests/auto/qdbusabstractinterface/tst_qdbusabstractinterface.cpp b/tests/auto/qdbusabstractinterface/tst_qdbusabstractinterface.cpp
index baf769f..91050f5 100644
--- a/tests/auto/qdbusabstractinterface/tst_qdbusabstractinterface.cpp
+++ b/tests/auto/qdbusabstractinterface/tst_qdbusabstractinterface.cpp
@@ -103,6 +103,8 @@ private slots:
     void getComplexSignal_data();
     void getComplexSignal();
 
+    void followSignal();
+
     void createErrors_data();
     void createErrors();
 
@@ -130,6 +132,9 @@ tst_QDBusAbstractInterface::tst_QDBusAbstractInterface()
 
 void tst_QDBusAbstractInterface::initTestCase()
 {
+    // enable debugging temporarily:
+    putenv("QDBUS_DEBUG=1");
+
     // register the object
     QDBusConnection con = QDBusConnection::sessionBus();
     QVERIFY(con.isConnected());
@@ -432,6 +437,60 @@ void tst_QDBusAbstractInterface::getComplexSignal()
     QCOMPARE(s[0][0].value<RegisteredType>(), expectedValue);
 }
 
+void tst_QDBusAbstractInterface::followSignal()
+{
+    const QString serviceToFollow = "com.trolltech.tst_qdbusabstractinterface.FollowMe";
+    Pinger p = getPinger(serviceToFollow);
+    QVERIFY2(p, "Not connected to D-Bus");
+
+    QDBusConnection con = p->connection();
+    QVERIFY(!con.interface()->isServiceRegistered(serviceToFollow));
+    Pinger control = getPinger("");
+
+    // we need to connect the signal somewhere in order for D-Bus to enable the rules
+    QTestEventLoop::instance().connect(p.data(), SIGNAL(voidSignal()), SLOT(exitLoop()));
+    QTestEventLoop::instance().connect(control.data(), SIGNAL(voidSignal()), SLOT(exitLoop()));
+    QSignalSpy s(p.data(), SIGNAL(voidSignal()));
+
+    emit targetObj.voidSignal();
+    QTestEventLoop::instance().enterLoop(200);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+
+    // signal must not have been received because the service isn't registered
+    QVERIFY(s.isEmpty());
+
+    // now register the service
+    QDBusReply<QDBusConnectionInterface::RegisterServiceReply> r =
+            con.interface()->registerService(serviceToFollow, QDBusConnectionInterface::DontQueueService,
+                                             QDBusConnectionInterface::DontAllowReplacement);
+    QVERIFY(r.isValid() && r.value() == QDBusConnectionInterface::ServiceRegistered);
+    QVERIFY(con.interface()->isServiceRegistered(serviceToFollow));
+
+    // emit the signal again:
+    emit targetObj.voidSignal();
+    QTestEventLoop::instance().enterLoop(2);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+
+    // now the signal must have been received:
+    QCOMPARE(s.size(), 1);
+    QVERIFY(s.at(0).size() == 0);
+    s.clear();
+
+    // disconnect the signal
+    disconnect(p.data(), SIGNAL(voidSignal()), &QTestEventLoop::instance(), 0);
+
+    // emit the signal again:
+    emit targetObj.voidSignal();
+    QTestEventLoop::instance().enterLoop(2);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+
+    // and now it mustn't have been received
+    QVERIFY(s.isEmpty());
+
+    // cleanup:
+    con.interface()->unregisterService(serviceToFollow);
+}
+
 void tst_QDBusAbstractInterface::createErrors_data()
 {
     QTest::addColumn<QString>("service");
diff --git a/tests/auto/qdbusinterface/tst_qdbusinterface.cpp b/tests/auto/qdbusinterface/tst_qdbusinterface.cpp
index e31a3a0..62d6342 100644
--- a/tests/auto/qdbusinterface/tst_qdbusinterface.cpp
+++ b/tests/auto/qdbusinterface/tst_qdbusinterface.cpp
@@ -171,6 +171,13 @@ class tst_QDBusInterface: public QObject
 {
     Q_OBJECT
     MyObject obj;
+public slots:
+    void testServiceOwnerChanged(const QString &service)
+    {
+        if (service == "com.example.Test")
+            QTestEventLoop::instance().exitLoop();
+    }
+
 private slots:
     void initTestCase();
 
@@ -235,32 +242,13 @@ void tst_QDBusInterface::invalidAfterServiceOwnerChanged()
     QDBusInterface invalidInterface("com.example.Test", "/");
     QVERIFY(!invalidInterface.isValid());
 
+    QTestEventLoop::instance().connect(connIface, SIGNAL(serviceOwnerChanged(QString, QString, QString)),
+                                       SLOT(exitLoop()));
     QVERIFY(connIface->registerService("com.example.Test") == QDBusConnectionInterface::ServiceRegistered);
 
-    QSignalSpy serviceOwnerChangedSpy(connIface, SIGNAL(serviceOwnerChanged(QString, QString, QString)));
-
-    QEventLoop loop;
-    QObject::connect(connIface, SIGNAL(serviceOwnerChanged(QString, QString, QString)),
-                     &loop, SLOT(quit()));
-    loop.exec();
-
-    // at least once, but other services might have changed while running the test, too.
-    QVERIFY(serviceOwnerChangedSpy.count() >= 1);
-    bool foundOurService = false;
-    for (int i = 0; i < serviceOwnerChangedSpy.count(); ++i) {
-        QList<QVariant> args = serviceOwnerChangedSpy.at(i);
-        QString name = args[0].toString();
-        QString oldOwner = args[1].toString();
-        QString newOwner = args[2].toString();
-        if (name == QLatin1String("com.example.Test")) {
-            if (newOwner == conn.baseService()) {
-                foundOurService = true;
-                break;
-            }
-        }
-    }
-    QVERIFY(foundOurService);
+    QTestEventLoop::instance().enterLoop(5);
 
+    QVERIFY(!QTestEventLoop::instance().timeout());
     QVERIFY(!invalidInterface.isValid());
 }
 
diff --git a/tests/auto/qdbusservicewatcher/qdbusservicewatcher.pro b/tests/auto/qdbusservicewatcher/qdbusservicewatcher.pro
new file mode 100644
index 0000000..4970f16
--- /dev/null
+++ b/tests/auto/qdbusservicewatcher/qdbusservicewatcher.pro
@@ -0,0 +1,8 @@
+load(qttest_p4)
+QT = core
+contains(QT_CONFIG,dbus): {
+        SOURCES += tst_qdbusservicewatcher.cpp
+        QT += dbus
+} else {
+        SOURCES += ../qdbusmarshall/dummy.cpp
+}
diff --git a/tests/auto/qdbusservicewatcher/tst_qdbusservicewatcher.cpp b/tests/auto/qdbusservicewatcher/tst_qdbusservicewatcher.cpp
new file mode 100644
index 0000000..10b43b1
--- /dev/null
+++ b/tests/auto/qdbusservicewatcher/tst_qdbusservicewatcher.cpp
@@ -0,0 +1,273 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 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$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtDBus/QDBusServiceWatcher>
+#include <QtDBus>
+#include <QtTest>
+
+class tst_QDBusServiceWatcher: public QObject
+{
+    Q_OBJECT
+    QString serviceName;
+public:
+    tst_QDBusServiceWatcher();
+
+private slots:
+    void initTestCase();
+    void cleanup();
+
+    void watchForCreation();
+    void watchForDisappearance();
+    void watchForOwnerChange();
+    void modeChange();
+};
+
+tst_QDBusServiceWatcher::tst_QDBusServiceWatcher()
+    : serviceName("com.example.TestName")
+{
+}
+
+void tst_QDBusServiceWatcher::initTestCase()
+{
+    QDBusConnection con = QDBusConnection::sessionBus();
+    QVERIFY(con.isConnected());
+}
+
+void tst_QDBusServiceWatcher::cleanup()
+{
+    // ensure that the name isn't registered
+    QDBusConnection::sessionBus().unregisterService(serviceName);
+}
+
+void tst_QDBusServiceWatcher::watchForCreation()
+{
+    QDBusConnection con = QDBusConnection::sessionBus();
+    QVERIFY(con.isConnected());
+
+    QDBusServiceWatcher watcher(serviceName, con, QDBusServiceWatcher::WatchForRegistration);
+
+    QSignalSpy spyR(&watcher, SIGNAL(serviceRegistered(QString)));
+    QSignalSpy spyU(&watcher, SIGNAL(serviceUnregistered(QString)));
+    QSignalSpy spyO(&watcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)));
+    QTestEventLoop::instance().connect(&watcher, SIGNAL(serviceRegistered(QString)), SLOT(exitLoop()));
+
+    // register a name
+    QVERIFY(con.registerService(serviceName));
+
+    QTestEventLoop::instance().enterLoop(1);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+
+    QCOMPARE(spyR.count(), 1);
+    QCOMPARE(spyR.at(0).at(0).toString(), serviceName);
+
+    QCOMPARE(spyU.count(), 0);
+
+    QCOMPARE(spyO.count(), 1);
+    QCOMPARE(spyO.at(0).at(0).toString(), serviceName);
+    QVERIFY(spyO.at(0).at(1).toString().isEmpty());
+    QCOMPARE(spyO.at(0).at(2).toString(), con.baseService());
+
+    spyR.clear();
+    spyU.clear();
+    spyO.clear();
+
+    // unregister it:
+    con.unregisterService(serviceName);
+
+    // and register again
+    QVERIFY(con.registerService(serviceName));
+
+    QTestEventLoop::instance().enterLoop(1);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+
+    QCOMPARE(spyR.count(), 1);
+    QCOMPARE(spyR.at(0).at(0).toString(), serviceName);
+
+    QCOMPARE(spyU.count(), 0);
+
+    QCOMPARE(spyO.count(), 1);
+    QCOMPARE(spyO.at(0).at(0).toString(), serviceName);
+    QVERIFY(spyO.at(0).at(1).toString().isEmpty());
+    QCOMPARE(spyO.at(0).at(2).toString(), con.baseService());
+}
+
+void tst_QDBusServiceWatcher::watchForDisappearance()
+{
+    QDBusConnection con = QDBusConnection::sessionBus();
+    QVERIFY(con.isConnected());
+
+    QDBusServiceWatcher watcher(serviceName, con, QDBusServiceWatcher::WatchForUnregistration);
+
+    QSignalSpy spyR(&watcher, SIGNAL(serviceRegistered(QString)));
+    QSignalSpy spyU(&watcher, SIGNAL(serviceUnregistered(QString)));
+    QSignalSpy spyO(&watcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)));
+    QTestEventLoop::instance().connect(&watcher, SIGNAL(serviceUnregistered(QString)), SLOT(exitLoop()));
+
+    // register a name
+    QVERIFY(con.registerService(serviceName));
+
+    // unregister it:
+    con.unregisterService(serviceName);
+
+    QTestEventLoop::instance().enterLoop(1);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+
+    QCOMPARE(spyR.count(), 0);
+
+    QCOMPARE(spyU.count(), 1);
+    QCOMPARE(spyU.at(0).at(0).toString(), serviceName);
+
+    QCOMPARE(spyO.count(), 1);
+    QCOMPARE(spyO.at(0).at(0).toString(), serviceName);
+    QCOMPARE(spyO.at(0).at(1).toString(), con.baseService());
+    QVERIFY(spyO.at(0).at(2).toString().isEmpty());
+}
+
+void tst_QDBusServiceWatcher::watchForOwnerChange()
+{
+    QDBusConnection con = QDBusConnection::sessionBus();
+    QVERIFY(con.isConnected());
+
+    QDBusServiceWatcher watcher(serviceName, con, QDBusServiceWatcher::WatchForOwnerChange);
+
+    QSignalSpy spyR(&watcher, SIGNAL(serviceRegistered(QString)));
+    QSignalSpy spyU(&watcher, SIGNAL(serviceUnregistered(QString)));
+    QSignalSpy spyO(&watcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)));
+    QTestEventLoop::instance().connect(&watcher, SIGNAL(serviceRegistered(QString)), SLOT(exitLoop()));
+
+    // register a name
+    QVERIFY(con.registerService(serviceName));
+
+    QTestEventLoop::instance().enterLoop(1);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+
+    QCOMPARE(spyR.count(), 1);
+    QCOMPARE(spyR.at(0).at(0).toString(), serviceName);
+
+    QCOMPARE(spyU.count(), 0);
+
+    QCOMPARE(spyO.count(), 1);
+    QCOMPARE(spyO.at(0).at(0).toString(), serviceName);
+    QVERIFY(spyO.at(0).at(1).toString().isEmpty());
+    QCOMPARE(spyO.at(0).at(2).toString(), con.baseService());
+
+    spyR.clear();
+    spyU.clear();
+    spyO.clear();
+
+    // unregister it:
+    con.unregisterService(serviceName);
+
+    // and register again
+    QVERIFY(con.registerService(serviceName));
+
+    QTestEventLoop::instance().enterLoop(1);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+
+    QCOMPARE(spyR.count(), 1);
+    QCOMPARE(spyR.at(0).at(0).toString(), serviceName);
+
+    QCOMPARE(spyU.count(), 1);
+    QCOMPARE(spyU.at(0).at(0).toString(), serviceName);
+
+    QCOMPARE(spyO.count(), 2);
+    QCOMPARE(spyO.at(0).at(0).toString(), serviceName);
+    QCOMPARE(spyO.at(0).at(1).toString(), con.baseService());
+    QVERIFY(spyO.at(0).at(2).toString().isEmpty());
+    QCOMPARE(spyO.at(1).at(0).toString(), serviceName);
+    QVERIFY(spyO.at(1).at(1).toString().isEmpty());
+    QCOMPARE(spyO.at(1).at(2).toString(), con.baseService());
+}
+
+void tst_QDBusServiceWatcher::modeChange()
+{
+    QDBusConnection con = QDBusConnection::sessionBus();
+    QVERIFY(con.isConnected());
+
+    QDBusServiceWatcher watcher(serviceName, con, QDBusServiceWatcher::WatchForRegistration);
+
+    QSignalSpy spyR(&watcher, SIGNAL(serviceRegistered(QString)));
+    QSignalSpy spyU(&watcher, SIGNAL(serviceUnregistered(QString)));
+    QSignalSpy spyO(&watcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)));
+    QTestEventLoop::instance().connect(&watcher, SIGNAL(serviceRegistered(QString)), SLOT(exitLoop()));
+
+    // register a name
+    QVERIFY(con.registerService(serviceName));
+
+    QTestEventLoop::instance().enterLoop(1);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+
+    QCOMPARE(spyR.count(), 1);
+    QCOMPARE(spyR.at(0).at(0).toString(), serviceName);
+
+    QCOMPARE(spyU.count(), 0);
+
+    QCOMPARE(spyO.count(), 1);
+    QCOMPARE(spyO.at(0).at(0).toString(), serviceName);
+    QVERIFY(spyO.at(0).at(1).toString().isEmpty());
+    QCOMPARE(spyO.at(0).at(2).toString(), con.baseService());
+
+    spyR.clear();
+    spyU.clear();
+    spyO.clear();
+
+    watcher.setWatchMode(QDBusServiceWatcher::WatchForUnregistration);
+
+    // unregister it:
+    con.unregisterService(serviceName);
+
+    QTestEventLoop::instance().connect(&watcher, SIGNAL(serviceUnregistered(QString)), SLOT(exitLoop()));
+    QTestEventLoop::instance().enterLoop(1);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+
+    QCOMPARE(spyR.count(), 0);
+
+    QCOMPARE(spyU.count(), 1);
+    QCOMPARE(spyU.at(0).at(0).toString(), serviceName);
+
+    QCOMPARE(spyO.count(), 1);
+    QCOMPARE(spyO.at(0).at(0).toString(), serviceName);
+    QCOMPARE(spyO.at(0).at(1).toString(), con.baseService());
+    QVERIFY(spyO.at(0).at(2).toString().isEmpty());
+}
+
+QTEST_MAIN(tst_QDBusServiceWatcher)
+#include "tst_qdbusservicewatcher.moc"
diff --git a/tests/auto/qdockwidget/tst_qdockwidget.cpp b/tests/auto/qdockwidget/tst_qdockwidget.cpp
index dc67f36..e62ba8c 100644
--- a/tests/auto/qdockwidget/tst_qdockwidget.cpp
+++ b/tests/auto/qdockwidget/tst_qdockwidget.cpp
@@ -86,6 +86,7 @@ private slots:
     void visibilityChanged();
     void dockLocationChanged();
     void setTitleBarWidget();
+    void titleBarDoubleClick();
     // task specific tests:
     void task165177_deleteFocusWidget();
     void task169808_setFloating();
@@ -694,6 +695,24 @@ void tst_QDockWidget::setTitleBarWidget()
     QCOMPARE(w2.isVisible(), false);
 }
 
+void tst_QDockWidget::titleBarDoubleClick()
+{
+    QMainWindow win;
+    QDockWidget dock(&win);
+    win.show();
+    dock.setFloating(true);
+
+    QEvent e(QEvent::NonClientAreaMouseButtonDblClick);
+    QApplication::sendEvent(&dock, &e);
+    QVERIFY(dock.isFloating());
+    QCOMPARE(win.dockWidgetArea(&dock), Qt::NoDockWidgetArea);
+
+    win.addDockWidget(Qt::TopDockWidgetArea, &dock);
+    dock.setFloating(true);
+    QApplication::sendEvent(&dock, &e);
+    QVERIFY(!dock.isFloating());
+    QCOMPARE(win.dockWidgetArea(&dock), Qt::TopDockWidgetArea);
+}
 
 void tst_QDockWidget::task165177_deleteFocusWidget()
 {
diff --git a/tests/auto/qdom/tst_qdom.cpp b/tests/auto/qdom/tst_qdom.cpp
index 0d58554e..6637202 100644
--- a/tests/auto/qdom/tst_qdom.cpp
+++ b/tests/auto/qdom/tst_qdom.cpp
@@ -322,7 +322,6 @@ void tst_QDom::toString_01_data()
 */
 void tst_QDom::toString_01()
 {
-    QFAIL("make test fail instead of timing out, will be fixed later (QT-2357)");
     QFETCH(QString, fileName);
 
     QFile f(fileName);
diff --git a/tests/auto/qfontmetrics/tst_qfontmetrics.cpp b/tests/auto/qfontmetrics/tst_qfontmetrics.cpp
index 6b2f0fe..e80f8e0 100644
--- a/tests/auto/qfontmetrics/tst_qfontmetrics.cpp
+++ b/tests/auto/qfontmetrics/tst_qfontmetrics.cpp
@@ -100,6 +100,20 @@ void tst_QFontMetrics::same()
     QFontMetrics fm(font);
     const QString text = QLatin1String("Some stupid STRING");
     QCOMPARE(fm.size(0, text), fm.size(0, text)) ;
+
+    {
+        QImage image;
+        QFontMetrics fm2(font, &image);
+        QString text2 =  QLatin1String("Foo Foo");
+        QCOMPARE(fm2.size(0, text2), fm2.size(0, text2));  //used to crash
+    }
+
+    {
+        QImage image;
+        QFontMetricsF fm3(font, &image);
+        QString text2 =  QLatin1String("Foo Foo");
+        QCOMPARE(fm3.size(0, text2), fm3.size(0, text2));  //used to crash
+    }
 }
 
 
diff --git a/tests/auto/qgl/tst_qgl.cpp b/tests/auto/qgl/tst_qgl.cpp
index e036e4b..e9f0476 100644
--- a/tests/auto/qgl/tst_qgl.cpp
+++ b/tests/auto/qgl/tst_qgl.cpp
@@ -118,6 +118,16 @@ public:
     void setAutoBufferSwap(bool on) { QGLWidget::setAutoBufferSwap(on); }
 };
 
+static int appDefaultDepth()
+{
+    static int depth = 0;
+    if (depth == 0) {
+        QPixmap pm(1, 1);
+        depth = pm.depth();
+    }
+    return depth;
+}
+
 // Using INT_MIN and INT_MAX will cause failures on systems
 // where "int" is 64-bit, so use the explicit values instead.
 #define TEST_INT_MIN    (-2147483647 - 1)
@@ -714,6 +724,8 @@ public:
 
 void tst_QGL::graphicsViewClipping()
 {
+    if (appDefaultDepth() < 24)
+        QSKIP("This test won't work for bit depths < 24", SkipAll);
     const int size = 64;
     UnclippedWidget *widget = new UnclippedWidget;
     widget->setFixedSize(size, size);
@@ -866,6 +878,8 @@ public:
 
 void tst_QGL::glWidgetRendering()
 {
+    if (appDefaultDepth() < 24)
+        QSKIP("This test won't work for bit depths < 24", SkipAll);
     GLWidget w;
     w.show();
 
@@ -1089,6 +1103,8 @@ protected:
 
 void tst_QGL::glFBOUseInGLWidget()
 {
+    if (appDefaultDepth() < 24)
+        QSKIP("This test won't work for bit depths < 24", SkipAll);
     if (!QGLFramebufferObject::hasOpenGLFramebufferObjects())
         QSKIP("QGLFramebufferObject not supported on this platform", SkipSingle);
 
@@ -1116,6 +1132,8 @@ void tst_QGL::glFBOUseInGLWidget()
 
 void tst_QGL::glWidgetReparent()
 {
+    if (appDefaultDepth() < 24)
+        QSKIP("This test won't work for bit depths < 24", SkipAll);
     // Try it as a top-level first:
     GLWidget *widget = new GLWidget;
     widget->setGeometry(0, 0, 200, 30);
@@ -1582,6 +1600,8 @@ protected:
 
 void tst_QGL::replaceClipping()
 {
+    if (appDefaultDepth() < 24)
+        QSKIP("This test won't work for bit depths < 24", SkipAll);
     ReplaceClippingGLWidget glw;
     glw.resize(300, 300);
     glw.show();
@@ -1707,6 +1727,8 @@ protected:
 
 void tst_QGL::clipTest()
 {
+    if (appDefaultDepth() < 24)
+        QSKIP("This test won't work for bit depths < 24", SkipAll);
     ClipTestGLWidget glw;
     glw.resize(220, 220);
     glw.show();
diff --git a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
index 7b87969..c8a9fac 100644
--- a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
+++ b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
@@ -45,6 +45,7 @@
 #include <QtGui/qgraphicswidget.h>
 #include <QtGui/qgraphicsproxywidget.h>
 #include <QtGui/qgraphicsview.h>
+#include <QtGui/qwindowsstyle.h>
 
 class tst_QGraphicsAnchorLayout : public QObject {
     Q_OBJECT;
@@ -72,6 +73,7 @@ private slots:
     void proportionalPreferred();
     void example();
     void setSpacing();
+    void styleDefaults();
     void hardComplexS60();
     void stability();
     void delete_anchor();
@@ -82,6 +84,8 @@ private slots:
     void expandingParallel();
     void floatConflict();
     void infiniteMaxSizes();
+    void simplifiableUnfeasible();
+    void simplificationVsOrder();
 };
 
 class RectWidget : public QGraphicsWidget
@@ -1102,6 +1106,166 @@ void tst_QGraphicsAnchorLayout::setSpacing()
     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 min (10, 10);
+    QSizeF pref(20, 20);
+    QSizeF max (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(min, pref, max);
+    QSizePolicy spRadioButton = a->sizePolicy();
+    spRadioButton.setControlType(QSizePolicy::RadioButton);
+    a->setSizePolicy(spRadioButton);
+
+    QGraphicsWidget *b = createItem(min, pref, max);
+    b->setSizePolicy(spRadioButton);
+
+    QGraphicsWidget *c = createItem(min, pref, max);
+    QSizePolicy spPushButton = c->sizePolicy();
+    spPushButton.setControlType(QSizePolicy::PushButton);
+    c->setSizePolicy(spPushButton);
+
+    QGraphicsWidget *d = createItem(min, pref, max);
+    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 = new QGraphicsView(&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));
+}
+
+
 /*!
     Taken from "hard" complex case, found at
     https://cwiki.nokia.com/S60QTUI/AnchorLayoutComplexCases
@@ -1755,5 +1919,100 @@ void tst_QGraphicsAnchorLayout::infiniteMaxSizes()
     QCOMPARE(d->geometry(), QRectF(QWIDGETSIZE_MAX - 50, 0, 50, 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 again
+    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 min(10, 10);
+    QSizeF pref(20, 10);
+    QSizeF max(50, 10);
+
+    QGraphicsWidget *a = createItem(min, pref, max);
+    QGraphicsWidget *b = createItem(min, pref, max);
+    QGraphicsWidget *c = createItem(min, pref, max);
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+
+    // 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) {
+        QEXPECT_FAIL("", "Sequential anchors cannot handle children of opposite directions", Continue);
+        QCOMPARE(usedSimplex(l, Qt::Horizontal), false);
+        QCOMPARE(usedSimplex(l, Qt::Vertical), false);
+    }
+}
+
 QTEST_MAIN(tst_QGraphicsAnchorLayout)
 #include "tst_qgraphicsanchorlayout.moc"
diff --git a/tests/auto/qgraphicseffectsource/tst_qgraphicseffectsource.cpp b/tests/auto/qgraphicseffectsource/tst_qgraphicseffectsource.cpp
index fbeb425..55294d5 100644
--- a/tests/auto/qgraphicseffectsource/tst_qgraphicseffectsource.cpp
+++ b/tests/auto/qgraphicseffectsource/tst_qgraphicseffectsource.cpp
@@ -357,7 +357,7 @@ void tst_QGraphicsEffectSource::pixmapPadding_data()
 
     QTest::newRow("log,transparent") << int(Qt::LogicalCoordinates)
                                      << int(QGraphicsEffectSource::ExpandToTransparentBorderPadMode)
-                                     << QSize(12, 12) << QPoint(-1, -1)
+                                     << QSize(14, 14) << QPoint(-2, -2)
                                      << 0x00000000u;
 
     QTest::newRow("log,effectrect") << int(Qt::LogicalCoordinates)
@@ -372,7 +372,7 @@ void tst_QGraphicsEffectSource::pixmapPadding_data()
 
     QTest::newRow("dev,transparent") << int(Qt::DeviceCoordinates)
                                      << int(QGraphicsEffectSource::ExpandToTransparentBorderPadMode)
-                                     << QSize(22, 22) << QPoint(39, 39)
+                                     << QSize(24, 24) << QPoint(38, 38)
                                      << 0x00000000u;
 
     QTest::newRow("dev,effectrect") << int(Qt::DeviceCoordinates)
diff --git a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
index d8cd375..3bc6db5 100644
--- a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
+++ b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
@@ -372,6 +372,7 @@ private slots:
     void itemUsesExtendedStyleOption();
     void itemSendsGeometryChanges();
     void moveItem();
+    void moveLineItem();
     void sorting_data();
     void sorting();
     void itemHasNoContents();
@@ -390,6 +391,7 @@ private slots:
     void moveWhileDeleting();
     void ensureDirtySceneTransform();
     void focusScope();
+    void focusScope2();
     void stackBefore();
     void sceneModality();
     void panelModality();
@@ -7438,6 +7440,39 @@ void tst_QGraphicsItem::moveItem()
     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();
+
+    const QRect itemDeviceBoundingRect = item->deviceTransform(view.viewportTransform())
+                                         .mapRect(item->boundingRect()).toRect();
+    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");
@@ -7641,20 +7676,6 @@ void tst_QGraphicsItem::hitTestGraphicsEffectItem()
     QCOMPARE(items.size(), 1);
     QCOMPARE(items.at(0), static_cast<QGraphicsItem *>(item3));
 
-    item1->repaints = 0;
-    item2->repaints = 0;
-    item3->repaints = 0;
-
-    view.viewport()->update(75, 75, 20, 20);
-    QTest::qWait(50);
-
-    // item1 is the effect source and must therefore be repainted.
-    // item2 intersects with the exposed region
-    // item3 is just another child outside the exposed region
-    QCOMPARE(item1->repaints, 1);
-    QCOMPARE(item2->repaints, 1);
-    QCOMPARE(item3->repaints, 0);
-
     scene.setItemIndexMethod(QGraphicsScene::NoIndex);
     QTest::qWait(100);
 
@@ -8431,7 +8452,7 @@ void tst_QGraphicsItem::focusScope()
     QVERIFY(!scope2->focusScopeItem());
     scope3->setParentItem(scope2);
     QCOMPARE(scope2->focusScopeItem(), (QGraphicsItem *)scope3);
-    QCOMPARE(scope2->focusItem(), (QGraphicsItem *)scope2);
+    QCOMPARE(scope2->focusItem(), (QGraphicsItem *)scope3);
 
     QGraphicsRectItem *scope1 = new QGraphicsRectItem;
     scope1->setData(0, "scope1");
@@ -8440,9 +8461,9 @@ void tst_QGraphicsItem::focusScope()
     QVERIFY(!scope1->focusScopeItem());
     scope2->setParentItem(scope1);
 
-    QCOMPARE(scope1->focusItem(), (QGraphicsItem *)scope1);
-    QCOMPARE(scope2->focusItem(), (QGraphicsItem *)0);
-    QCOMPARE(scope3->focusItem(), (QGraphicsItem *)0);
+    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);
@@ -8493,11 +8514,13 @@ void tst_QGraphicsItem::focusScope()
     rect5->setFocus();
     rect5->setParentItem(rect4);
     QCOMPARE(scope3->focusScopeItem(), (QGraphicsItem *)rect5);
-    QVERIFY(!rect5->hasFocus());
+    QVERIFY(rect5->hasFocus());
 
     rect4->setParentItem(0);
+    QVERIFY(rect5->hasFocus());
     QCOMPARE(scope3->focusScopeItem(), (QGraphicsItem *)0);
-    QVERIFY(scope3->hasFocus());
+    QCOMPARE(scope3->focusItem(), (QGraphicsItem *)0);
+    QVERIFY(!scope3->hasFocus());
 
     QGraphicsRectItem *rectA = new QGraphicsRectItem;
     QGraphicsRectItem *scopeA = new QGraphicsRectItem(rectA);
@@ -8508,7 +8531,7 @@ void tst_QGraphicsItem::focusScope()
     scopeB->setFocus();
 
     scene.addItem(rectA);
-    QVERIFY(!rect5->hasFocus());
+    QVERIFY(rect5->hasFocus());
     QVERIFY(!scopeB->hasFocus());
 
     scopeA->setFocus();
@@ -8516,6 +8539,76 @@ void tst_QGraphicsItem::focusScope()
     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;
@@ -8535,24 +8628,24 @@ void tst_QGraphicsItem::stackBefore()
     QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child1 << child3 << child4 << child2));
 
     // Move child2 before child1
-    child2->stackBefore(child1);
+    child2->stackBefore(child1); // 2134
     QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child2 << child1 << child3 << child4));
-    child2->stackBefore(child2);
+    child2->stackBefore(child2); // 2134
     QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child2 << child1 << child3 << child4));
-    child1->setZValue(1);
+    child1->setZValue(1); // 2341
     QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child2 << child3 << child4 << child1));
-    child1->stackBefore(child2); // no effect
+    child1->stackBefore(child2); // 2341
     QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child2 << child3 << child4 << child1));
-    child1->setZValue(0);
-    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child2 << child1 << child3 << child4));
-    child4->stackBefore(child1);
-    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child2 << child4 << child1 << child3));
-    child4->setZValue(1);
-    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child2 << child1 << child3 << child4));
-    child3->stackBefore(child1);
-    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child2 << child3 << child1 << child4));
-    child4->setZValue(0);
-    QCOMPARE(parent.childItems(), (QList<QGraphicsItem *>() << child2 << child4 << child3 << 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);
@@ -8574,24 +8667,24 @@ void tst_QGraphicsItem::stackBefore()
     QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child1 << child3 << child4 << child2));
 
     // Move child2 before child1
-    child2->stackBefore(child1);
+    child2->stackBefore(child1); // 2134
     QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child2 << child1 << child3 << child4));
-    child2->stackBefore(child2);
+    child2->stackBefore(child2); // 2134
     QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child2 << child1 << child3 << child4));
-    child1->setZValue(1);
+    child1->setZValue(1); // 2341
     QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child2 << child3 << child4 << child1));
-    child1->stackBefore(child2); // no effect
+    child1->stackBefore(child2); // 2341
     QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child2 << child3 << child4 << child1));
-    child1->setZValue(0);
-    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child2 << child1 << child3 << child4));
-    child4->stackBefore(child1);
-    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child2 << child4 << child1 << child3));
-    child4->setZValue(1);
-    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child2 << child1 << child3 << child4));
-    child3->stackBefore(child1);
-    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child2 << child3 << child1 << child4));
-    child4->setZValue(0);
-    QCOMPARE(scene.items(QPointF(2, 2), Qt::IntersectsItemBoundingRect, Qt::AscendingOrder), (QList<QGraphicsItem *>() << child2 << child4 << child3 << 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()
diff --git a/tests/auto/qgraphicsobject/tst_qgraphicsobject.cpp b/tests/auto/qgraphicsobject/tst_qgraphicsobject.cpp
index a9fd55a..194665d 100644
--- a/tests/auto/qgraphicsobject/tst_qgraphicsobject.cpp
+++ b/tests/auto/qgraphicsobject/tst_qgraphicsobject.cpp
@@ -46,6 +46,7 @@
 #include <qgraphicssceneevent.h>
 #include <qgraphicsview.h>
 #include <qstyleoption.h>
+#include <private/qobject_p.h>
 #include "../../shared/util.h"
 
 class tst_QGraphicsObject : public QObject {
@@ -65,6 +66,7 @@ private slots:
     void opacity();
     void enabled();
     void visible();
+    void deleted();
 };
 
 
@@ -249,6 +251,46 @@ void tst_QGraphicsObject::visible()
     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);
+    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/qgraphicssceneindex/tst_qgraphicssceneindex.cpp b/tests/auto/qgraphicssceneindex/tst_qgraphicssceneindex.cpp
index 1109e5e..7d98748 100644
--- a/tests/auto/qgraphicssceneindex/tst_qgraphicssceneindex.cpp
+++ b/tests/auto/qgraphicssceneindex/tst_qgraphicssceneindex.cpp
@@ -45,6 +45,8 @@
 #include <private/qgraphicsscenebsptreeindex_p.h>
 #include <private/qgraphicssceneindex_p.h>
 #include <private/qgraphicsscenelinearindex_p.h>
+#include "../../shared/util.h"
+
 
 //TESTED_CLASS=
 //TESTED_FILES=
@@ -66,6 +68,7 @@ private slots:
     void movingItems();
     void connectedToSceneRectChanged();
     void items();
+    void removeItems();
     void clear();
 
 private:
@@ -268,6 +271,63 @@ void tst_QGraphicsSceneIndex::items()
     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
@@ -298,7 +358,7 @@ void tst_QGraphicsSceneIndex::clear()
     MyItem *item = new MyItem;
     scene.addItem(item);
     qApp->processEvents();
-    QCOMPARE(item->numPaints, 1);
+    QTRY_COMPARE(item->numPaints, 1);
 }
 
 QTEST_MAIN(tst_QGraphicsSceneIndex)
diff --git a/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp b/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp
index d8ab06e..9b15ab1 100644
--- a/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp
+++ b/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp
@@ -259,7 +259,7 @@ void tst_QGraphicsTransform::rotation3d()
 
     // Check that "rotation" produces the 4x4 form of the 3x3 matrix.
     // i.e. third row and column are 0 0 1 0.
-    t.setIdentity();
+    t.setToIdentity();
     rotation.applyTo(&t);
     QMatrix4x4 r(expected);
     if (sizeof(qreal) == sizeof(float) && angle == 268) {
@@ -274,7 +274,7 @@ void tst_QGraphicsTransform::rotation3d()
     rotation.setAxis(QVector3D(0, 0, 0));
     rotation.setOrigin(QVector3D(10, 10, 0));
 
-    t.setIdentity();
+    t.setToIdentity();
     rotation.applyTo(&t);
 
     QVERIFY(t.isIdentity());
@@ -337,7 +337,7 @@ void tst_QGraphicsTransform::rotation3dArbitraryAxis()
 
     // Check that "rotation" produces the 4x4 form of the 3x3 matrix.
     // i.e. third row and column are 0 0 1 0.
-    t.setIdentity();
+    t.setToIdentity();
     rotation.applyTo(&t);
     QMatrix4x4 r(expected);
     QVERIFY(qFuzzyCompare(t, r));
diff --git a/tests/auto/qgraphicsview/tst_qgraphicsview.cpp b/tests/auto/qgraphicsview/tst_qgraphicsview.cpp
index 9b5e114..f07453c 100644
--- a/tests/auto/qgraphicsview/tst_qgraphicsview.cpp
+++ b/tests/auto/qgraphicsview/tst_qgraphicsview.cpp
@@ -194,6 +194,8 @@ private slots:
     void acceptDrops();
     void optimizationFlags();
     void optimizationFlags_dontSavePainterState();
+    void optimizationFlags_dontSavePainterState2_data();
+    void optimizationFlags_dontSavePainterState2();
     void levelOfDetail_data();
     void levelOfDetail();
     void scrollBarRanges_data();
@@ -2455,6 +2457,57 @@ void tst_QGraphicsView::optimizationFlags_dontSavePainterState()
     QTest::qWaitForWindowShown(&painter2);
 }
 
+void tst_QGraphicsView::optimizationFlags_dontSavePainterState2_data()
+{
+    QTest::addColumn<bool>("savePainter");
+    QTest::newRow("With painter state protection") << true;
+    QTest::newRow("Without painter state protection") << false;
+}
+
+void tst_QGraphicsView::optimizationFlags_dontSavePainterState2()
+{
+    QFETCH(bool, savePainter);
+
+    class MyScene : public QGraphicsScene
+    {
+    public:
+        void drawBackground(QPainter *p, const QRectF &)
+        { transformInDrawBackground = p->worldTransform(); }
+
+        void drawForeground(QPainter *p, const QRectF &)
+        { transformInDrawForeground = p->worldTransform(); }
+
+        QTransform transformInDrawBackground;
+        QTransform transformInDrawForeground;
+    };
+
+    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));
+
+    CustomView view(&scene);
+    if (!savePainter)
+        view.setOptimizationFlag(QGraphicsView::DontSavePainterState);
+    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.
+    const QTransform expectedTransform = view.viewportTransform();
+    QVERIFY(!expectedTransform.isIdentity());
+    QCOMPARE(scene.transformInDrawForeground, expectedTransform);
+    QCOMPARE(scene.transformInDrawBackground, expectedTransform);
+}
+
 class LodItem : public QGraphicsRectItem
 {
 public:
diff --git a/tests/auto/qlistview/tst_qlistview.cpp b/tests/auto/qlistview/tst_qlistview.cpp
index 6e211ae..a5ff153 100644
--- a/tests/auto/qlistview/tst_qlistview.cpp
+++ b/tests/auto/qlistview/tst_qlistview.cpp
@@ -119,6 +119,8 @@ private slots:
     void task262152_setModelColumnNavigate();
     void taskQTBUG_2233_scrollHiddenItems_data();
     void taskQTBUG_2233_scrollHiddenItems();
+    void taskQTBUG_633_changeModelData();
+    void taskQTBUG_435_deselectOnViewportClick();
 };
 
 // Testing get/set functions
@@ -1132,6 +1134,7 @@ void tst_QListView::selection()
 #endif
 
     v.show();
+    QTest::qWaitForWindowShown(&v);
     QApplication::processEvents();
 
     v.setSelection(selectionRect, QItemSelectionModel::ClearAndSelect);
@@ -1184,6 +1187,7 @@ void tst_QListView::scrollTo()
     lv.setModel(&model);
     lv.setFixedSize(100, 200);
     lv.show();
+    QTest::qWaitForWindowShown(&lv);
 
     //by default, the list view scrolls per item and has no wrapping
     QModelIndex index = model.index(6,0);
@@ -1782,6 +1786,7 @@ void tst_QListView::task262152_setModelColumnNavigate()
     view.setModelColumn(1);
 
     view.show();
+    QTest::qWaitForWindowShown(&view);
     QTest::qWait(100);
     QTest::keyClick(&view, Qt::Key_Down);
     QTest::qWait(100);
@@ -1829,5 +1834,47 @@ void tst_QListView::taskQTBUG_2233_scrollHiddenItems()
     }
 }
 
+void tst_QListView::taskQTBUG_633_changeModelData()
+{
+    QListView view;
+    view.setFlow(QListView::LeftToRight);
+    QStandardItemModel model(5,1);
+    for (int i = 0; i < model.rowCount(); ++i) {
+        model.setData( model.index(i, 0), QString::number(i));
+    }
+
+    view.setModel(&model);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    model.setData( model.index(1, 0), QLatin1String("long long text"));
+    QTest::qWait(100); //leave time for relayouting the items
+    QRect rectLongText = view.visualRect(model.index(1,0));
+    QRect rect2 = view.visualRect(model.index(2,0));
+    QVERIFY( ! rectLongText.intersects(rect2) );
+}
+
+void tst_QListView::taskQTBUG_435_deselectOnViewportClick()
+{
+    QListView view;
+    QStringListModel model( QStringList() << "1" << "2" << "3" << "4");
+    view.setModel(&model);
+    view.setSelectionMode(QAbstractItemView::ExtendedSelection);
+    view.selectAll();
+    QCOMPARE(view.selectionModel()->selectedIndexes().count(), model.rowCount());
+    
+
+    QPoint p = view.visualRect(model.index(model.rowCount() - 1)).center() + QPoint(0, 20);
+    //first the left button
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p);
+    QVERIFY(!view.selectionModel()->hasSelection());
+
+    view.selectAll();
+    QCOMPARE(view.selectionModel()->selectedIndexes().count(), model.rowCount());
+
+    //and now the right button
+    QTest::mouseClick(view.viewport(), Qt::RightButton, 0, p);
+    QVERIFY(!view.selectionModel()->hasSelection());
+}
+
 QTEST_MAIN(tst_QListView)
 #include "tst_qlistview.moc"
diff --git a/tests/auto/qlistwidget/tst_qlistwidget.cpp b/tests/auto/qlistwidget/tst_qlistwidget.cpp
index e825c8f..5c6ed54 100644
--- a/tests/auto/qlistwidget/tst_qlistwidget.cpp
+++ b/tests/auto/qlistwidget/tst_qlistwidget.cpp
@@ -46,6 +46,7 @@
 #include <qlist.h>
 
 #include <qlistwidget.h>
+#include <private/qlistwidget_p.h>
 
 //TESTED_CLASS=
 //TESTED_FILES=
@@ -95,6 +96,8 @@ private slots:
     void insertItem();
     void insertItems_data();
     void insertItems();
+    void moveItemsPriv_data();
+    void moveItemsPriv();
 
     void itemAssignment();
     void item_data();
@@ -849,6 +852,62 @@ void tst_QListWidget::removeItems()
 
 }
 
+void tst_QListWidget::moveItemsPriv_data()
+{
+    QTest::addColumn<int>("rowCount");
+    QTest::addColumn<int>("srcRow");
+    QTest::addColumn<int>("dstRow");
+    QTest::addColumn<bool>("shouldHaveSignaled");
+
+    QTest::newRow("Empty") << 0 << 0 << 0 << false;
+    QTest::newRow("Overflow src") << 5 << 5 << 2 << false;
+    QTest::newRow("Underflow src") << 5 << -1 << 2 << false;
+    QTest::newRow("Overflow dst") << 5 << 2 << 5 << false;
+    QTest::newRow("Underflow dst") << 5 << 2 << -1 << false;
+    QTest::newRow("Same place") << 5 << 2 << 2 << false;
+    QTest::newRow("Up") << 5 << 4 << 2 << true;
+    QTest::newRow("Down") << 5 << 2 << 4 << true;
+}
+
+void tst_QListWidget::moveItemsPriv()
+{
+    QFETCH(int, rowCount);
+    QFETCH(int, srcRow);
+    QFETCH(int, dstRow);
+    QFETCH(bool, shouldHaveSignaled);
+
+    for (int r = 0; r < rowCount; ++r)
+        new QListWidgetItem(QString::number(r), testWidget);
+
+    QListModel *model = dynamic_cast<QListModel *>(testWidget->model());
+    QVERIFY(model);
+    QSignalSpy beginMoveSpy(model, SIGNAL(rowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)));
+    QSignalSpy movedSpy(model, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)));
+    model->move(srcRow, dstRow);
+
+    if (shouldHaveSignaled) {
+        if (srcRow < dstRow)
+            QCOMPARE(testWidget->item(dstRow - 1)->text(), QString::number(srcRow));
+        else
+            QCOMPARE(testWidget->item(dstRow)->text(), QString::number(srcRow));
+
+        QCOMPARE(beginMoveSpy.count(), 1);
+        const QList<QVariant> &beginMoveArgs = beginMoveSpy.takeFirst();
+        QCOMPARE(beginMoveArgs.at(1).toInt(), srcRow);
+        QCOMPARE(beginMoveArgs.at(2).toInt(), srcRow);
+        QCOMPARE(beginMoveArgs.at(4).toInt(), dstRow);
+
+        QCOMPARE(movedSpy.count(), 1);
+        const QList<QVariant> &movedArgs = movedSpy.takeFirst();
+        QCOMPARE(movedArgs.at(1).toInt(), srcRow);
+        QCOMPARE(movedArgs.at(2).toInt(), srcRow);
+        QCOMPARE(movedArgs.at(4).toInt(), dstRow);
+    } else {
+        QCOMPARE(beginMoveSpy.count(), 0);
+        QCOMPARE(movedSpy.count(), 0);
+    }
+}
+
 void tst_QListWidget::itemStreaming_data()
 {
     QTest::addColumn<QString>("text");
diff --git a/tests/auto/qlocalsocket/tst_qlocalsocket.cpp b/tests/auto/qlocalsocket/tst_qlocalsocket.cpp
index be39d00..ab7b0ac 100644
--- a/tests/auto/qlocalsocket/tst_qlocalsocket.cpp
+++ b/tests/auto/qlocalsocket/tst_qlocalsocket.cpp
@@ -976,7 +976,7 @@ void tst_QLocalSocket::writeOnlySocket()
 #if defined(Q_OS_SYMBIAN)
         QTest::qWait(250);
 #endif
-    QVERIFY(server.waitForNewConnection());
+    QVERIFY(server.waitForNewConnection(200));
     QLocalSocket* serverSocket = server.nextPendingConnection();
     QVERIFY(serverSocket);
 
diff --git a/tests/auto/qmatrixnxn/tst_qmatrixnxn.cpp b/tests/auto/qmatrixnxn/tst_qmatrixnxn.cpp
index ff5e00f..d6d217f2 100644
--- a/tests/auto/qmatrixnxn/tst_qmatrixnxn.cpp
+++ b/tests/auto/qmatrixnxn/tst_qmatrixnxn.cpp
@@ -151,14 +151,8 @@ private slots:
 
     void convertGeneric();
 
-    void extractAxisRotation_data();
-    void extractAxisRotation();
-
-    void extractTranslation_data();
-    void extractTranslation();
-
-    void inferSpecialType_data();
-    void inferSpecialType();
+    void optimize_data();
+    void optimize();
 
     void columnsAndRows();
 
@@ -515,13 +509,13 @@ void tst_QMatrixNxN::create2x2()
     m5 = m3;
     QVERIFY(isSame(m5, uniqueValues2));
 
-    m5.setIdentity();
+    m5.setToIdentity();
     QVERIFY(isIdentity(m5));
 
     QMatrix2x2 m6(uniqueValues2);
     QVERIFY(isSame(m6, uniqueValues2));
     qreal vals[4];
-    m6.toValueArray(vals);
+    m6.copyDataTo(vals);
     for (int index = 0; index < 4; ++index)
         QCOMPARE(vals[index], uniqueValues2[index]);
 }
@@ -550,13 +544,13 @@ void tst_QMatrixNxN::create3x3()
     m5 = m3;
     QVERIFY(isSame(m5, uniqueValues3));
 
-    m5.setIdentity();
+    m5.setToIdentity();
     QVERIFY(isIdentity(m5));
 
     QMatrix3x3 m6(uniqueValues3);
     QVERIFY(isSame(m6, uniqueValues3));
     qreal vals[9];
-    m6.toValueArray(vals);
+    m6.copyDataTo(vals);
     for (int index = 0; index < 9; ++index)
         QCOMPARE(vals[index], uniqueValues3[index]);
 }
@@ -585,13 +579,13 @@ void tst_QMatrixNxN::create4x4()
     m5 = m3;
     QVERIFY(isSame(m5, uniqueValues4));
 
-    m5.setIdentity();
+    m5.setToIdentity();
     QVERIFY(isIdentity(m5));
 
     QMatrix4x4 m6(uniqueValues4);
     QVERIFY(isSame(m6, uniqueValues4));
     qreal vals[16];
-    m6.toValueArray(vals);
+    m6.copyDataTo(vals);
     for (int index = 0; index < 16; ++index)
         QCOMPARE(vals[index], uniqueValues4[index]);
 
@@ -627,13 +621,13 @@ void tst_QMatrixNxN::create4x3()
     m5 = m3;
     QVERIFY(isSame(m5, uniqueValues4x3));
 
-    m5.setIdentity();
+    m5.setToIdentity();
     QVERIFY(isIdentity(m5));
 
     QMatrix4x3 m6(uniqueValues4x3);
     QVERIFY(isSame(m6, uniqueValues4x3));
     qreal vals[12];
-    m6.toValueArray(vals);
+    m6.copyDataTo(vals);
     for (int index = 0; index < 12; ++index)
         QCOMPARE(vals[index], uniqueValues4x3[index]);
 }
@@ -802,7 +796,7 @@ void tst_QMatrixNxN::transposed4x3()
     QMatrix4x3 m3(uniqueValues4x3);
     QMatrix3x4 m4 = m3.transposed();
     qreal values[12];
-    m4.toValueArray(values);
+    m4.copyDataTo(values);
     for (int index = 0; index < 12; ++index)
         QCOMPARE(values[index], transposedValues3x4[index]);
 }
@@ -1296,7 +1290,7 @@ void tst_QMatrixNxN::multiply4x3()
     QGenericMatrix<3, 3, qreal> m4;
     m4 = m1 * m2;
     qreal values[9];
-    m4.toValueArray(values);
+    m4.copyDataTo(values);
     for (int index = 0; index < 9; ++index)
         QCOMPARE(values[index], ((const qreal *)m3Values)[index]);
 }
@@ -1898,7 +1892,7 @@ void tst_QMatrixNxN::inverted4x4()
     }
 
     // Test again, after inferring the special matrix type.
-    m1.inferSpecialType();
+    m1.optimize();
     m2 = m1.inverted(&inv);
     QVERIFY(isSame(m2, (const qreal *)m2Values));
     QCOMPARE(inv, invertible);
@@ -1913,12 +1907,12 @@ void tst_QMatrixNxN::orthonormalInverse4x4()
     m2.rotate(45.0, 1.0, 0.0, 0.0);
     m2.translate(10.0, 0.0, 0.0);
 
-    // Use inferSpecialType() to drop the internal flags that
+    // Use optimize() to drop the internal flags that
     // mark the matrix as orthonormal.  This will force inverted()
     // to compute m3.inverted() the long way.  We can then compare
     // the result to what the faster algorithm produces on m2.
     QMatrix4x4 m3 = m2;
-    m3.inferSpecialType();
+    m3.optimize();
     bool invertible;
     QVERIFY(qFuzzyCompare(m2.inverted(&invertible), m3.inverted()));
     QVERIFY(invertible);
@@ -1926,7 +1920,7 @@ void tst_QMatrixNxN::orthonormalInverse4x4()
     QMatrix4x4 m4;
     m4.rotate(45.0, 0.0, 1.0, 0.0);
     QMatrix4x4 m5 = m4;
-    m5.inferSpecialType();
+    m5.optimize();
     QVERIFY(qFuzzyCompare(m4.inverted(), m5.inverted()));
 
     QMatrix4x4 m6;
@@ -1934,7 +1928,7 @@ void tst_QMatrixNxN::orthonormalInverse4x4()
     m1.translate(-20.0, 20.0, 15.0);
     m1.rotate(25, 1.0, 0.0, 0.0);
     QMatrix4x4 m7 = m6;
-    m7.inferSpecialType();
+    m7.optimize();
     QVERIFY(qFuzzyCompare(m6.inverted(), m7.inverted()));
 }
 
@@ -2081,7 +2075,7 @@ void tst_QMatrixNxN::scale4x4()
         m8.scale(x);
         QVERIFY(isSame(m8, (const qreal *)resultValues));
 
-        m8.inferSpecialType();
+        m8.optimize();
         m8.scale(1.0f);
         QVERIFY(isSame(m8, (const qreal *)resultValues));
 
@@ -2412,7 +2406,7 @@ void tst_QMatrixNxN::rotate4x4()
 
     if (x != 0 || y != 0 || z != 0) {
         QQuaternion q = QQuaternion::fromAxisAndAngle(QVector3D(x, y, z), angle);
-        QVector3D vq = q.rotateVector(v1);
+        QVector3D vq = q.rotatedVector(v1);
         QVERIFY(fuzzyCompare(vq.x(), v1x));
         QVERIFY(fuzzyCompare(vq.y(), v1y));
         QVERIFY(fuzzyCompare(vq.z(), v1z));
@@ -2509,7 +2503,7 @@ void tst_QMatrixNxN::normalMatrix()
 
     // Perform the test again, after inferring special matrix types.
     // This tests the optimized paths in the normalMatrix() function.
-    m1.inferSpecialType();
+    m1.optimize();
     n1 = m1.normalMatrix();
 
     if (invertible)
@@ -2850,120 +2844,6 @@ void tst_QMatrixNxN::convertGeneric()
     QVERIFY(isSame(m11, conv4x4));
 }
 
-void tst_QMatrixNxN::extractAxisRotation_data()
-{
-    QTest::addColumn<float>("x");
-    QTest::addColumn<float>("y");
-    QTest::addColumn<float>("z");
-    QTest::addColumn<float>("angle");
-    
-    QTest::newRow("1, 0, 0, 0 deg") << 1.0f << 0.0f << 0.0f << 0.0f;
-    QTest::newRow("1, 0, 0, 90 deg") << 1.0f << 0.0f << 0.0f << 90.0f;
-    QTest::newRow("1, 0, 0, 270 deg") << 1.0f << 0.0f << 0.0f << 270.0f;
-    QTest::newRow("1, 0, 0, 45 deg") << 1.0f << 0.0f << 0.0f << 45.0f;
-    QTest::newRow("1, 0, 0, 120 deg") << 1.0f << 0.0f << 0.0f << 120.0f;
-    QTest::newRow("1, 0, 0, 300 deg") << 1.0f << 0.0f << 0.0f << 300.0f;
-
-    QTest::newRow("0, 1, 0, 90 deg") << 0.0f << 1.0f << 0.0f << 90.0f;
-    QTest::newRow("0, 1, 0, 270 deg") << 0.0f << 1.0f << 0.0f << 270.0f;
-    QTest::newRow("0, 1, 0, 45 deg") << 0.0f << 1.0f << 0.0f << 45.0f;
-    QTest::newRow("0, 1, 0, 120 deg") << 0.0f << 1.0f << 0.0f << 120.0f;
-    QTest::newRow("0, 1, 0, 300 deg") << 0.0f << 1.0f << 0.0f << 300.0f;
-    
-    QTest::newRow("0, 0, 1, 90 deg") << 0.0f << 0.0f << 1.0f << 90.0f;
-    QTest::newRow("0, 0, 1, 270 deg") << 0.0f << 0.0f << 1.0f << 270.0f;
-    QTest::newRow("0, 0, 1, 45 deg") << 0.0f << 0.0f << 1.0f << 45.0f;
-    QTest::newRow("0, 0, 1, 120 deg") << 0.0f << 0.0f << 1.0f << 120.0f;
-    QTest::newRow("0, 0, 1, 300 deg") << 0.0f << 0.0f << 1.0f << 300.0f;
-
-    QTest::newRow("1, 1, 1, 90 deg") << 1.0f << 1.0f << 1.0f << 90.0f;
-    QTest::newRow("1, 1, 1, 270 deg") << 1.0f << 1.0f << 1.0f << 270.0f;
-    QTest::newRow("1, 1, 1, 45 deg") << 1.0f << 1.0f << 1.0f << 45.0f;
-    QTest::newRow("1, 1, 1, 120 deg") << 1.0f << 1.0f << 1.0f << 120.0f;
-    QTest::newRow("1, 1, 1, 300 deg") << 1.0f << 1.0f << 1.0f << 300.0f;
-}
-
-void tst_QMatrixNxN::extractAxisRotation()
-{
-    QFETCH(float, x);
-    QFETCH(float, y);
-    QFETCH(float, z);
-    QFETCH(float, angle);
-
-    QMatrix4x4 m;
-    QVector3D origAxis(x, y, z);
-
-    m.rotate(angle, x, y, z);
-
-    origAxis.normalize();
-    QVector3D extractedAxis;
-    qreal extractedAngle;
-
-    m.extractAxisRotation(extractedAngle, extractedAxis);
- 
-    if (angle > 180) {
-        QVERIFY(fuzzyCompare(360.0f - angle, extractedAngle));
-        QVERIFY(fuzzyCompare(extractedAxis, -origAxis));
-    } else {
-        QVERIFY(fuzzyCompare(angle, extractedAngle));
-        QVERIFY(fuzzyCompare(extractedAxis, origAxis));
-    }
-}
-
-void tst_QMatrixNxN::extractTranslation_data()
-{
-    QTest::addColumn<QMatrix4x4>("rotation");
-    QTest::addColumn<float>("x");
-    QTest::addColumn<float>("y");
-    QTest::addColumn<float>("z");
-
-    static QMatrix4x4 m1;
-
-    QTest::newRow("identity, 100, 50, 25")
-        << m1 << 100.0f << 50.0f << 250.0f;
-
-    m1.rotate(45.0, 1.0, 0.0, 0.0);
-    QTest::newRow("rotX 45 + 100, 50, 25") << m1 << 100.0f << 50.0f << 25.0f;
-
-    m1.setIdentity();
-    m1.rotate(45.0, 0.0, 1.0, 0.0);
-    QTest::newRow("rotY 45 + 100, 50, 25") << m1 << 100.0f << 50.0f << 25.0f;
-
-    m1.setIdentity();
-    m1.rotate(75, 0.0, 0.0, 1.0);
-    m1.rotate(25, 1.0, 0.0, 0.0);
-    m1.rotate(45, 0.0, 1.0, 0.0);
-    QTest::newRow("rotZ 75, rotX 25, rotY 45, 100, 50, 25") << m1 << 100.0f << 50.0f << 25.0f;
-}
-
-void tst_QMatrixNxN::extractTranslation()
-{
-    QFETCH(QMatrix4x4, rotation);
-    QFETCH(float, x);
-    QFETCH(float, y);
-    QFETCH(float, z);
-
-    rotation.translate(x, y, z);
-
-    QVector3D vec = rotation.extractTranslation();
-
-    QVERIFY(fuzzyCompare(vec.x(), x));
-    QVERIFY(fuzzyCompare(vec.y(), y));
-    QVERIFY(fuzzyCompare(vec.z(), z));
-
-    QMatrix4x4 lookAt;
-    QVector3D eye(1.5f, -2.5f, 2.5f);
-    lookAt.lookAt(eye,
-                  QVector3D(10.0f, 10.0f, 10.0f), 
-                  QVector3D(0.0f, 1.0f, 0.0f));
-
-   QVector3D extEye = lookAt.extractTranslation();
-
-   QVERIFY(fuzzyCompare(eye.x(), -extEye.x()));
-   QVERIFY(fuzzyCompare(eye.y(), -extEye.y()));
-   QVERIFY(fuzzyCompare(eye.z(), -extEye.z()));
-}
-
 // Copy of "flagBits" in qmatrix4x4.h.
 enum {
     Identity        = 0x0001,   // Identity matrix
@@ -2981,7 +2861,7 @@ struct Matrix4x4
 };
 
 // Test the inferring of special matrix types.
-void tst_QMatrixNxN::inferSpecialType_data()
+void tst_QMatrixNxN::optimize_data()
 {
     QTest::addColumn<void *>("mValues");
     QTest::addColumn<int>("flagBits");
@@ -3029,13 +2909,13 @@ void tst_QMatrixNxN::inferSpecialType_data()
     QTest::newRow("below")
         << (void *)belowValues << (int)General;
 }
-void tst_QMatrixNxN::inferSpecialType()
+void tst_QMatrixNxN::optimize()
 {
     QFETCH(void *, mValues);
     QFETCH(int, flagBits);
 
     QMatrix4x4 m((const qreal *)mValues);
-    m.inferSpecialType();
+    m.optimize();
 
     QCOMPARE(reinterpret_cast<Matrix4x4 *>(&m)->flagBits, flagBits);
 }
@@ -3362,7 +3242,7 @@ void tst_QMatrixNxN::mapVector()
     QFETCH(void *, mValues);
 
     QMatrix4x4 m1((const qreal *)mValues);
-    m1.inferSpecialType();
+    m1.optimize();
 
     QVector3D v(3.5f, -1.0f, 2.5f);
 
diff --git a/tests/auto/qmenubar/tst_qmenubar.cpp b/tests/auto/qmenubar/tst_qmenubar.cpp
index 07aa9f4..4291c3e 100644
--- a/tests/auto/qmenubar/tst_qmenubar.cpp
+++ b/tests/auto/qmenubar/tst_qmenubar.cpp
@@ -86,6 +86,18 @@ private:
     uint sel_count;
 };
 
+class Menu : public QMenu
+{
+    Q_OBJECT
+        public slots:
+            void addActions()
+            {
+                //this will change the geometry of the menu
+                addAction("action1");
+                addAction("action2");
+            }
+};
+
 class tst_QMenuBar : public QObject
 {
     Q_OBJECT
@@ -1442,7 +1454,7 @@ void tst_QMenuBar::check_menuPosition()
 #ifdef Q_OS_WINCE_WM
     QSKIP("Qt/CE uses native menubar", SkipAll);
 #endif
-    QMenu menu;
+    Menu menu;
 #ifdef QT3_SUPPORT
     initComplexMenubar();
 #else
@@ -1496,6 +1508,21 @@ void tst_QMenuBar::check_menuPosition()
         menu.close();
     }
 
+    //in RTL, the menu should be stuck at the right of the action geometry
+    {
+        Qt::LayoutDirection dir = qApp->layoutDirection();
+        qApp->setLayoutDirection(Qt::RightToLeft);
+        menu.clear();
+        QObject::connect(&menu, SIGNAL(aboutToShow()), &menu, SLOT(addActions()));
+        QRect mbItemRect = mw->menuBar()->actionGeometry(menu_action);
+        mbItemRect.moveTo(mw->menuBar()->mapToGlobal(mbItemRect.topLeft()));
+        QTest::keyClick(mw, Qt::Key_M, Qt::AltModifier );
+        QVERIFY(menu.isActiveWindow());
+        QCOMPARE(menu.geometry().right(), mbItemRect.right());
+        menu.close();
+        qApp->setLayoutDirection(dir);
+    }
+
 }
 
 void tst_QMenuBar::task223138_triggered()
diff --git a/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp b/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
index 8578d36..8d937e9 100644
--- a/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
+++ b/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
@@ -56,8 +56,7 @@ public:
     virtual ~tst_QParallelAnimationGroup();
 
 public Q_SLOTS:
-    void init();
-    void cleanup();
+    void initTestCase();
 
 private slots:
     void construction();
@@ -86,13 +85,13 @@ tst_QParallelAnimationGroup::~tst_QParallelAnimationGroup()
 {
 }
 
-void tst_QParallelAnimationGroup::init()
+void tst_QParallelAnimationGroup::initTestCase()
 {
     qRegisterMetaType<QAbstractAnimation::State>("QAbstractAnimation::State");
-}
-
-void tst_QParallelAnimationGroup::cleanup()
-{
+#if defined(Q_OS_SYMBIAN) || defined(Q_WS_MAC) || defined(Q_WS_WINCE)
+    // give the Symbian and mac app start event queue time to clear
+    QTest::qWait(1000);
+#endif
 }
 
 void tst_QParallelAnimationGroup::construction()
@@ -486,10 +485,6 @@ void tst_QParallelAnimationGroup::updateChildrenWithRunningGroup()
 
 void tst_QParallelAnimationGroup::deleteChildrenWithRunningGroup()
 {
-#if defined(Q_OS_SYMBIAN)
-    // give the Symbian app start event queue time to clear
-    QTest::qWait(1000);
-#endif
     // test if children can be activated when their group is stopped
     QParallelAnimationGroup group;
 
diff --git a/tests/auto/qpauseanimation/tst_qpauseanimation.cpp b/tests/auto/qpauseanimation/tst_qpauseanimation.cpp
index b11efa0..4d0a7a7 100644
--- a/tests/auto/qpauseanimation/tst_qpauseanimation.cpp
+++ b/tests/auto/qpauseanimation/tst_qpauseanimation.cpp
@@ -93,8 +93,7 @@ public:
     virtual ~tst_QPauseAnimation();
 
 public Q_SLOTS:
-    void init();
-    void cleanup();
+    void initTestCase();
 
 private slots:
     void changeDirectionWhileRunning();
@@ -117,20 +116,15 @@ tst_QPauseAnimation::~tst_QPauseAnimation()
 {
 }
 
-void tst_QPauseAnimation::init()
+void tst_QPauseAnimation::initTestCase()
 {
     qRegisterMetaType<QAbstractAnimation::State>("QAbstractAnimation::State");
     qRegisterMetaType<QAbstractAnimation::DeletionPolicy>("QAbstractAnimation::DeletionPolicy");
 }
 
-void tst_QPauseAnimation::cleanup()
-{
-}
-
 void tst_QPauseAnimation::changeDirectionWhileRunning()
 {
-    QUnifiedTimer *timer = QUnifiedTimer::instance();
-    timer->setConsistentTiming(true);
+    EnableConsistentTiming enabled;
 
     TestablePauseAnimation animation;
     animation.setDuration(400);
@@ -140,8 +134,6 @@ void tst_QPauseAnimation::changeDirectionWhileRunning()
     animation.setDirection(QAbstractAnimation::Backward);
     QTest::qWait(animation.totalDuration() + 50);
     QVERIFY(animation.state() == QAbstractAnimation::Stopped);
-
-    timer->setConsistentTiming(false);
 }
 
 void tst_QPauseAnimation::noTimerUpdates_data()
@@ -157,8 +149,7 @@ void tst_QPauseAnimation::noTimerUpdates_data()
 
 void tst_QPauseAnimation::noTimerUpdates()
 {
-    QUnifiedTimer *timer = QUnifiedTimer::instance();
-    timer->setConsistentTiming(true);
+    EnableConsistentTiming enabled;
 
     QFETCH(int, duration);
     QFETCH(int, loopCount);
@@ -168,16 +159,19 @@ void tst_QPauseAnimation::noTimerUpdates()
     animation.setLoopCount(loopCount);
     animation.start();
     QTest::qWait(animation.totalDuration() + 100);
+
+#ifdef Q_OS_WIN
+    if (animation.state() != QAbstractAnimation::Stopped)
+        QEXPECT_FAIL("", "On windows, consistent timing is not working properly due to bad timer resolution", Abort);
+#endif
+
     QVERIFY(animation.state() == QAbstractAnimation::Stopped);
     QCOMPARE(animation.m_updateCurrentTimeCount, 1 + loopCount);
-
-    timer->setConsistentTiming(false);
 }
 
 void tst_QPauseAnimation::mulitplePauseAnimations()
 {
-    QUnifiedTimer *timer = QUnifiedTimer::instance();
-    timer->setConsistentTiming(true);
+    EnableConsistentTiming enabled;
 
     TestablePauseAnimation animation;
     animation.setDuration(200);
@@ -188,16 +182,26 @@ void tst_QPauseAnimation::mulitplePauseAnimations()
     animation.start();
     animation2.start();
     QTest::qWait(animation.totalDuration() + 100);
+
+#ifdef Q_OS_WIN
+    if (animation.state() != QAbstractAnimation::Stopped)
+        QEXPECT_FAIL("", "On windows, consistent timing is not working properly due to bad timer resolution", Abort);
+#endif
+
     QVERIFY(animation.state() == QAbstractAnimation::Stopped);
     QVERIFY(animation2.state() == QAbstractAnimation::Running);
     QCOMPARE(animation.m_updateCurrentTimeCount, 2);
     QCOMPARE(animation2.m_updateCurrentTimeCount, 2);
 
     QTest::qWait(550);
+
+#ifdef Q_OS_WIN
+    if (animation2.state() != QAbstractAnimation::Stopped)
+        QEXPECT_FAIL("", "On windows, consistent timing is not working properly due to bad timer resolution", Abort);
+#endif
+
     QVERIFY(animation2.state() == QAbstractAnimation::Stopped);
     QCOMPARE(animation2.m_updateCurrentTimeCount, 3);
-
-    timer->setConsistentTiming(false);
 }
 
 void tst_QPauseAnimation::pauseAndPropertyAnimations()
@@ -243,7 +247,7 @@ void tst_QPauseAnimation::pauseResume()
     animation.pause();
     QVERIFY(animation.state() == QAbstractAnimation::Paused);
     animation.start();
-    QTest::qWait(250);
+    QTest::qWait(300);
     QVERIFY(animation.state() == QAbstractAnimation::Stopped);
     QCOMPARE(animation.m_updateCurrentTimeCount, 3);
 }
@@ -260,6 +264,9 @@ void tst_QPauseAnimation::sequentialPauseGroup()
     animation3.setDuration(200);
 
     group.start();
+    QCOMPARE(animation1.m_updateCurrentTimeCount, 1);
+    QCOMPARE(animation2.m_updateCurrentTimeCount, 0);
+    QCOMPARE(animation3.m_updateCurrentTimeCount, 0);
 
     QVERIFY(group.state() == QAbstractAnimation::Running);
     QVERIFY(animation1.state() == QAbstractAnimation::Running);
@@ -267,6 +274,9 @@ void tst_QPauseAnimation::sequentialPauseGroup()
     QVERIFY(animation3.state() == QAbstractAnimation::Stopped);
 
     group.setCurrentTime(250);
+    QCOMPARE(animation1.m_updateCurrentTimeCount, 2);
+    QCOMPARE(animation2.m_updateCurrentTimeCount, 1);
+    QCOMPARE(animation3.m_updateCurrentTimeCount, 0);
 
     QVERIFY(group.state() == QAbstractAnimation::Running);
     QVERIFY(animation1.state() == QAbstractAnimation::Stopped);
@@ -275,6 +285,9 @@ void tst_QPauseAnimation::sequentialPauseGroup()
     QVERIFY(animation3.state() == QAbstractAnimation::Stopped);
 
     group.setCurrentTime(500);
+    QCOMPARE(animation1.m_updateCurrentTimeCount, 2);
+    QCOMPARE(animation2.m_updateCurrentTimeCount, 2);
+    QCOMPARE(animation3.m_updateCurrentTimeCount, 1);
 
     QVERIFY(group.state() == QAbstractAnimation::Running);
     QVERIFY(animation1.state() == QAbstractAnimation::Stopped);
diff --git a/tests/auto/qpixmap/tst_qpixmap.cpp b/tests/auto/qpixmap/tst_qpixmap.cpp
index 53b6230..8e02c74 100644
--- a/tests/auto/qpixmap/tst_qpixmap.cpp
+++ b/tests/auto/qpixmap/tst_qpixmap.cpp
@@ -1134,6 +1134,8 @@ void tst_QPixmap::fromSymbianCFbsBitmap_data()
     QTest::newRow("EColor4K big") << EColor4K << largeWidth << largeHeight << QColor(Qt::red);
     QTest::newRow("EColor64K small") << EColor64K << smallWidth << smallHeight << QColor(Qt::green);
     QTest::newRow("EColor64K big") << EColor64K << largeWidth << largeHeight << QColor(Qt::green);
+    QTest::newRow("EColor16M small") << EColor16M << smallWidth << smallHeight << QColor(Qt::yellow);
+    QTest::newRow("EColor16M big") << EColor16M << largeWidth << largeHeight << QColor(Qt::yellow);
     QTest::newRow("EColor16MU small") << EColor16MU << smallWidth << smallHeight << QColor(Qt::red);
     QTest::newRow("EColor16MU big") << EColor16MU << largeWidth << largeHeight << QColor(Qt::red);
     QTest::newRow("EColor16MA small opaque") << EColor16MA << smallWidth << smallHeight << QColor(255, 255, 0);
diff --git a/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
index 7dd17e5..56c1ced 100644
--- a/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
+++ b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
@@ -495,7 +495,7 @@ void tst_QPropertyAnimation::startWhenAnotherIsRunning()
         anim->setEndValue(100);
         QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
         anim->start(QVariantAnimation::DeleteWhenStopped);
-        QTest::qWait(anim->duration() + 50);
+        QTest::qWait(anim->duration() + 100);
         QCOMPARE(runningSpy.count(), 2); //started and then stopped
         QVERIFY(!anim);
     }
@@ -659,7 +659,7 @@ void tst_QPropertyAnimation::playForwardBackward()
     anim.setStartValue(0);
     anim.setEndValue(100);
     anim.start();
-    QTest::qWait(anim.duration() + 50);
+    QTest::qWait(anim.duration() + 100);
     QCOMPARE(anim.state(), QAbstractAnimation::Stopped);
     QCOMPARE(anim.currentTime(), anim.duration());
 
@@ -667,7 +667,7 @@ void tst_QPropertyAnimation::playForwardBackward()
     anim.setDirection(QVariantAnimation::Backward);
     anim.start();
     QCOMPARE(anim.state(), QAbstractAnimation::Running);
-    QTest::qWait(anim.duration() + 50);
+    QTest::qWait(anim.duration() + 100);
     QCOMPARE(anim.state(), QAbstractAnimation::Stopped);
     QCOMPARE(anim.currentTime(), 0);
 
@@ -676,7 +676,7 @@ void tst_QPropertyAnimation::playForwardBackward()
     anim.start();
     QCOMPARE(anim.state(), QAbstractAnimation::Running);
     QCOMPARE(anim.currentTime(), anim.duration());
-    QTest::qWait(anim.duration() + 50);
+    QTest::qWait(anim.duration() + 100);
     QCOMPARE(anim.state(), QAbstractAnimation::Stopped);
     QCOMPARE(anim.currentTime(), 0);
 }
@@ -1093,7 +1093,7 @@ void tst_QPropertyAnimation::valueChanged()
     QSignalSpy spy(&anim, SIGNAL(valueChanged(QVariant)));
     anim.start();
 
-    QTest::qWait(anim.duration() + 50);
+    QTest::qWait(anim.duration() + 100);
 
     QCOMPARE(anim.state(), QAbstractAnimation::Stopped);
     QCOMPARE(anim.currentTime(), anim.duration());
@@ -1144,7 +1144,7 @@ void tst_QPropertyAnimation::twoAnimations()
     o1.anim.start();
     o2.anim.start();
 
-    QTest::qWait(o1.anim.duration() + 50);
+    QTest::qWait(o1.anim.duration() + 100);
     QCOMPARE(o1.anim.state(), QAbstractAnimation::Stopped);
     QCOMPARE(o2.anim.state(), QAbstractAnimation::Stopped);
 
@@ -1194,7 +1194,7 @@ void tst_QPropertyAnimation::deletedInUpdateCurrentTime()
     MyComposedAnimation composedAnimation(&o, "value", "realValue");
     composedAnimation.start();
     QCOMPARE(composedAnimation.state(), QAbstractAnimation::Running);
-    QTest::qWait(composedAnimation.duration() + 50);
+    QTest::qWait(composedAnimation.duration() + 100);
 
     QCOMPARE(composedAnimation.state(), QAbstractAnimation::Stopped);
     QCOMPARE(o.value(), 1000);
diff --git a/tests/auto/qscriptstring/tst_qscriptstring.cpp b/tests/auto/qscriptstring/tst_qscriptstring.cpp
index e1a4bc1..1229f4a 100644
--- a/tests/auto/qscriptstring/tst_qscriptstring.cpp
+++ b/tests/auto/qscriptstring/tst_qscriptstring.cpp
@@ -59,6 +59,8 @@ public:
 private slots:
     void test();
     void hash();
+    void toArrayIndex_data();
+    void toArrayIndex();
 };
 
 tst_QScriptString::tst_QScriptString()
@@ -155,5 +157,40 @@ void tst_QScriptString::hash()
     QCOMPARE(stringToInt.value(foo), 123);
 }
 
+void tst_QScriptString::toArrayIndex_data()
+{
+    QTest::addColumn<QString>("input");
+    QTest::addColumn<bool>("expectSuccess");
+    QTest::addColumn<quint32>("expectedIndex");
+    QTest::newRow("foo") << QString::fromLatin1("foo") << false << quint32(0xffffffff);
+    QTest::newRow("empty") << QString::fromLatin1("") << false << quint32(0xffffffff);
+    QTest::newRow("0") << QString::fromLatin1("0") << true << quint32(0);
+    QTest::newRow("00") << QString::fromLatin1("00") << false << quint32(0xffffffff);
+    QTest::newRow("1") << QString::fromLatin1("1") << true << quint32(1);
+    QTest::newRow("123") << QString::fromLatin1("123") << true << quint32(123);
+    QTest::newRow("-1") << QString::fromLatin1("-1") << false << quint32(0xffffffff);
+    QTest::newRow("0a") << QString::fromLatin1("0a") << false << quint32(0xffffffff);
+    QTest::newRow("0x1") << QString::fromLatin1("0x1") << false << quint32(0xffffffff);
+    QTest::newRow("01") << QString::fromLatin1("01") << false << quint32(0xffffffff);
+    QTest::newRow("4294967294") << QString::fromLatin1("4294967294") << true << quint32(0xfffffffe);
+    QTest::newRow("4294967295") << QString::fromLatin1("4294967295") << false << quint32(0xffffffff);
+}
+
+void tst_QScriptString::toArrayIndex()
+{
+    QFETCH(QString, input);
+    QFETCH(bool, expectSuccess);
+    QFETCH(quint32, expectedIndex);
+    QScriptEngine engine;
+    for (int x = 0; x < 2; ++x) {
+        bool isArrayIndex;
+        bool *ptr = (x == 0) ? &isArrayIndex : (bool*)0;
+        quint32 result = engine.toStringHandle(input).toArrayIndex(ptr);
+        if (x == 0)
+            QCOMPARE(isArrayIndex, expectSuccess);
+        QCOMPARE(result, expectedIndex);
+    }
+}
+
 QTEST_MAIN(tst_QScriptString)
 #include "tst_qscriptstring.moc"
diff --git a/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp b/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
index aa6801a..f6afc5b 100644
--- a/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
+++ b/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
@@ -929,16 +929,13 @@ void tst_QSequentialAnimationGroup::startDelay()
     group.addPause(125);
     QCOMPARE(group.totalDuration(), 375);
 
-    QEventLoop loop;
-    QObject::connect(&group, SIGNAL(finished()), &loop, SLOT(quit()));
-
-    QTime time;
-    time.start();
     group.start();
-    loop.exec();
+    QCOMPARE(group.state(), QAnimationGroup::Running);
 
-    QVERIFY(time.elapsed() >= 375);
-    QVERIFY(time.elapsed() < 1000);
+    QTest::qWait(500);
+
+    QVERIFY(group.currentTime() == 375);
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
 }
 
 void tst_QSequentialAnimationGroup::clearGroup()
diff --git a/tests/auto/qsound/tst_qsound.cpp b/tests/auto/qsound/tst_qsound.cpp
index 56a330b..73eca98 100644
--- a/tests/auto/qsound/tst_qsound.cpp
+++ b/tests/auto/qsound/tst_qsound.cpp
@@ -55,20 +55,32 @@ public:
     tst_QSound( QObject* parent=0) : QObject(parent) {}
 
 private slots:
-        void checkFinished();
+    void checkFinished();
+
+    // Manual tests
+    void staticPlay();
 };
 
 void tst_QSound::checkFinished()
 {
-            QSound sound(SRCDIR"4.wav");
-            sound.setLoops(3);
-            sound.play();
-            QTest::qWait(5000);
+    QSound sound(SRCDIR"4.wav");
+    sound.setLoops(3);
+    sound.play();
+    QTest::qWait(5000);
 
 #if defined(Q_WS_QWS)
-            QEXPECT_FAIL("", "QSound buggy on embedded (task QTBUG-157)", Abort);
+    QEXPECT_FAIL("", "QSound buggy on embedded (task QTBUG-157)", Abort);
 #endif
-            QVERIFY(sound.isFinished() );
+    QVERIFY(sound.isFinished() );
+}
+
+void tst_QSound::staticPlay()
+{
+    QSKIP("Test disabled -- only for manual purposes", SkipAll);
+
+    // Check that you hear sound with static play also.
+    QSound::play(SRCDIR"4.wav");
+    QTest::qWait(2000);
 }
 
 QTEST_MAIN(tst_QSound);
diff --git a/tests/auto/qsplitter/tst_qsplitter.cpp b/tests/auto/qsplitter/tst_qsplitter.cpp
index cf16421..b832f3a 100644
--- a/tests/auto/qsplitter/tst_qsplitter.cpp
+++ b/tests/auto/qsplitter/tst_qsplitter.cpp
@@ -102,6 +102,8 @@ private slots:
     void task187373_addAbstractScrollAreas();
     void task187373_addAbstractScrollAreas_data();
     void task169702_sizes();
+    void taskQTBUG_4101_ensureOneNonCollapsedWidget_data();
+    void taskQTBUG_4101_ensureOneNonCollapsedWidget();
 
 private:
     void removeThirdWidget();
@@ -1281,6 +1283,8 @@ class MyFriendlySplitter : public QSplitter
 public:
     MyFriendlySplitter(QWidget *parent = 0) : QSplitter(parent) {}
     void setRubberBand(int pos) { QSplitter::setRubberBand(pos); }
+
+    friend class tst_QSplitter;
 };
 
 void tst_QSplitter::rubberBandNotInSplitter()
@@ -1403,5 +1407,35 @@ void tst_QSplitter::task169702_sizes()
     QCOMPARE(testW->size().height(), testW->minimumSizeHint().height());
 }
 
+void tst_QSplitter::taskQTBUG_4101_ensureOneNonCollapsedWidget_data()
+{
+    QTest::addColumn<bool>("testingHide");
+
+    QTest::newRow("last non collapsed hidden") << true;
+    QTest::newRow("last non collapsed deleted") << false;
+}
+
+void tst_QSplitter::taskQTBUG_4101_ensureOneNonCollapsedWidget()
+{
+    QFETCH(bool, testingHide);
+
+    MyFriendlySplitter s;
+    QLabel *l;
+    for (int i = 0; i < 5; ++i) {
+        l = new QLabel(QString("Label ") + QChar('A' + i));
+        l->setAlignment(Qt::AlignCenter);
+        s.addWidget(l);
+        s.moveSplitter(0, i);  // Collapse all the labels except the last one.
+    }
+
+    s.show();
+    if (testingHide)
+        l->hide();
+    else
+        delete l;
+    QTest::qWait(100);
+    QVERIFY(s.sizes().at(0) > 0);
+}
+
 QTEST_MAIN(tst_QSplitter)
 #include "tst_qsplitter.moc"
diff --git a/tests/auto/qsqldatabase/tst_qsqldatabase.cpp b/tests/auto/qsqldatabase/tst_qsqldatabase.cpp
index 82b6066..fe7c3ea 100644
--- a/tests/auto/qsqldatabase/tst_qsqldatabase.cpp
+++ b/tests/auto/qsqldatabase/tst_qsqldatabase.cpp
@@ -1234,6 +1234,7 @@ void tst_QSqlDatabase::recordSQLite()
 
         FieldDef("integer", QVariant::Int,              QVariant(13)),
         FieldDef("int", QVariant::Int,                  QVariant(12)),
+        FieldDef("real", QVariant::String,              QVariant(1.234567890123456)),
 
         FieldDef()
     };
diff --git a/tests/auto/qsqlquerymodel/tst_qsqlquerymodel.cpp b/tests/auto/qsqlquerymodel/tst_qsqlquerymodel.cpp
index 3131f35..02b48fa 100644
--- a/tests/auto/qsqlquerymodel/tst_qsqlquerymodel.cpp
+++ b/tests/auto/qsqlquerymodel/tst_qsqlquerymodel.cpp
@@ -96,6 +96,7 @@ private slots:
 
     void task_180617();
     void task_180617_data() { generic_data(); }
+    void task_QTBUG_4963_setHeaderDataWithProxyModel();
 
 private:
     void generic_data(const QString &engine=QString());
@@ -428,6 +429,8 @@ void tst_QSqlQueryModel::setHeaderData()
     QVERIFY(!model.setHeaderData(5, Qt::Vertical, "foo"));
     QVERIFY(model.headerData(5, Qt::Vertical).isValid());
 
+    model.setQuery(QSqlQuery("select * from " + qTableName("test"), db));
+
     qRegisterMetaType<Qt::Orientation>("Qt::Orientation");
     QSignalSpy spy(&model, SIGNAL(headerDataChanged(Qt::Orientation, int, int)));
     QVERIFY(model.setHeaderData(2, Qt::Horizontal, "bar"));
@@ -437,10 +440,8 @@ void tst_QSqlQueryModel::setHeaderData()
     QCOMPARE(spy.value(0).value(1).toInt(), 2);
     QCOMPARE(spy.value(0).value(2).toInt(), 2);
 
-    QVERIFY(model.setHeaderData(7, Qt::Horizontal, "foo", Qt::ToolTipRole));
-    QVERIFY(model.headerData(7, Qt::Horizontal, Qt::ToolTipRole).isValid());
-
-    model.setQuery(QSqlQuery("select * from " + qTableName("test"), db));
+    QVERIFY(!model.setHeaderData(7, Qt::Horizontal, "foo", Qt::ToolTipRole));
+    QVERIFY(!model.headerData(7, Qt::Horizontal, Qt::ToolTipRole).isValid());
 
     bool isToUpper = db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2");
     QCOMPARE(model.headerData(0, Qt::Horizontal).toString(), isToUpper ? QString("ID") : QString("id"));
@@ -603,5 +604,14 @@ void tst_QSqlQueryModel::task_180617()
     QCOMPARE(view.rowAt(0), -1);
 }
 
+void tst_QSqlQueryModel::task_QTBUG_4963_setHeaderDataWithProxyModel()
+{
+    QSqlQueryModel plainModel;
+    QSortFilterProxyModel proxyModel;
+    proxyModel.setSourceModel(&plainModel);
+    QVERIFY(!plainModel.setHeaderData(0, Qt::Horizontal, QObject::tr("ID")));
+    // And it should not crash.
+}
+
 QTEST_MAIN(tst_QSqlQueryModel)
 #include "tst_qsqlquerymodel.moc"
diff --git a/tests/auto/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp b/tests/auto/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp
index cb24a9f..8c840cd 100644
--- a/tests/auto/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp
+++ b/tests/auto/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp
@@ -86,6 +86,7 @@ private slots:
     void escapedRelations();
     void escapedTableName();
     void whiteSpaceInIdentifiers();
+    void psqlSchemaTest();
 
 private:
     void dropTestTables( QSqlDatabase db );
@@ -150,10 +151,11 @@ void tst_QSqlRelationalTableModel::initTestCase()
         if (db.driverName().startsWith("QIBASE"))
             db.exec("SET DIALECT 3");
         else if (tst_Databases::isSqlServer(db)) {
-            QSqlQuery q(db);
-            QVERIFY_SQL(q, exec("SET ANSI_DEFAULTS ON"));
-            QVERIFY_SQL(q, exec("SET IMPLICIT_TRANSACTIONS OFF"));
+            db.exec("SET ANSI_DEFAULTS ON");
+            db.exec("SET IMPLICIT_TRANSACTIONS OFF");
         }
+        else if(tst_Databases::isPostgreSQL(db))
+            db.exec("set client_min_messages='warning'");
         recreateTestTables(db);
     }
 }
@@ -181,6 +183,9 @@ void tst_QSqlRelationalTableModel::dropTestTables( QSqlDatabase db )
             << qTableName("CASETEST1" )
             << qTableName("casetest1" );
     tst_Databases::safeDropTables( db, tableNames );
+
+    db.exec("DROP SCHEMA "+qTableName("QTBUG_5373")+" CASCADE");
+    db.exec("DROP SCHEMA "+qTableName("QTBUG_5373_s2")+" CASCADE");
 }
 
 void tst_QSqlRelationalTableModel::init()
@@ -1118,8 +1123,8 @@ void tst_QSqlRelationalTableModel::escapedTableName()
     }
 }
 
-void tst_QSqlRelationalTableModel::whiteSpaceInIdentifiers() {
-
+void tst_QSqlRelationalTableModel::whiteSpaceInIdentifiers()
+{
     QFETCH_GLOBAL(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
@@ -1193,5 +1198,26 @@ void tst_QSqlRelationalTableModel::whiteSpaceInIdentifiers() {
     QCOMPARE(model.data(model.index(0, 2)).toInt(), 6);
 }
 
+void tst_QSqlRelationalTableModel::psqlSchemaTest()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if(!tst_Databases::isPostgreSQL(db)) {
+        QSKIP("Postgresql specific test", SkipSingle);
+        return;
+    }
+    QSqlRelationalTableModel model(0, db);
+    QSqlQuery q(db);
+    QVERIFY_SQL(q, exec("create schema "+qTableName("QTBUG_5373")));
+    QVERIFY_SQL(q, exec("create schema "+qTableName("QTBUG_5373_s2")));
+    QVERIFY_SQL(q, exec("create table "+qTableName("QTBUG_5373")+"."+qTableName("user")+"(userid int primary key, relatingid int)"));
+    QVERIFY_SQL(q, exec("create table "+qTableName("QTBUG_5373_s2")+"."+qTableName("user2")+"(userid2 int primary key, username2 char(40))"));
+    model.setTable(qTableName("QTBUG_5373")+"."+qTableName("user"));
+    model.setRelation(1, QSqlRelation(qTableName("QTBUG_5373_s2")+"."+qTableName("user2"), "userid2", "username2"));
+    QVERIFY_SQL(model, select());
+}
+
 QTEST_MAIN(tst_QSqlRelationalTableModel)
 #include "tst_qsqlrelationaltablemodel.moc"
diff --git a/tests/auto/qsslsocket/tst_qsslsocket.cpp b/tests/auto/qsslsocket/tst_qsslsocket.cpp
index 2bd1684..db46b66 100644
--- a/tests/auto/qsslsocket/tst_qsslsocket.cpp
+++ b/tests/auto/qsslsocket/tst_qsslsocket.cpp
@@ -1755,9 +1755,7 @@ void tst_QSslSocket::readFromClosedSocket()
     socket->close();
     QVERIFY(!socket->bytesAvailable());
     QVERIFY(!socket->bytesToWrite());
-    socket->waitForDisconnected();
-    QVERIFY(!socket->bytesAvailable());
-    QVERIFY(!socket->bytesToWrite());
+    QVERIFY(socket->state() == QAbstractSocket::UnconnectedState);
 }
 
 void tst_QSslSocket::writeBigChunk()
diff --git a/tests/auto/qstatemachine/tst_qstatemachine.cpp b/tests/auto/qstatemachine/tst_qstatemachine.cpp
index 975b301..9a2b2ed 100644
--- a/tests/auto/qstatemachine/tst_qstatemachine.cpp
+++ b/tests/auto/qstatemachine/tst_qstatemachine.cpp
@@ -162,7 +162,7 @@ private slots:
 
     void defaultGlobalRestorePolicy();
     void globalRestorePolicySetToRestore();
-    void globalRestorePolicySetToDoNotRestore();
+    void globalRestorePolicySetToDontRestore();
 
     void noInitialStateForInitialState();
 
@@ -184,7 +184,7 @@ private slots:
     void twoAnimatedTransitions();
     void playAnimationTwice();
     void nestedTargetStateForAnimation();
-    void polishedSignalTransitionsReuseAnimationGroup();
+    void propertiesAssignedSignalTransitionsReuseAnimationGroup();
     void animatedGlobalRestoreProperty();
     void specificTargetValueOfAnimation();
 
@@ -286,8 +286,8 @@ void tst_QStateMachine::transitionToRootState()
     machine.addState(initialState);
     machine.setInitialState(initialState);
 
-    QAbstractTransition *trans = initialState->addTransition(new EventTransition(QEvent::User, &machine));
-    QVERIFY(trans != 0);
+    QAbstractTransition *trans = new EventTransition(QEvent::User, &machine);
+    initialState->addTransition(trans);
     QCOMPARE(trans->sourceState(), initialState);
     QCOMPARE(trans->targetState(), static_cast<QAbstractState *>(&machine));
 
@@ -310,7 +310,7 @@ void tst_QStateMachine::transitionFromRootState()
     QState *root = &machine;
     QState *s1 = new QState(root);
     EventTransition *trans = new EventTransition(QEvent::User, s1);
-    QCOMPARE(root->addTransition(trans), static_cast<QAbstractTransition *>(trans));
+    root->addTransition(trans);
     QCOMPARE(trans->sourceState(), root);
     QCOMPARE(trans->targetState(), static_cast<QAbstractState *>(s1));
 }
@@ -984,7 +984,7 @@ void tst_QStateMachine::customErrorStateNotInGraph()
 void tst_QStateMachine::restoreProperties()
 {
     QStateMachine machine;
-    QCOMPARE(machine.globalRestorePolicy(), QStateMachine::DoNotRestoreProperties);
+    QCOMPARE(machine.globalRestorePolicy(), QStateMachine::DontRestoreProperties);
     machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);
 
     QObject *object = new QObject(&machine);
@@ -1155,7 +1155,7 @@ void tst_QStateMachine::stateEntryAndExit()
         QCOMPARE(t->targetState(), (QAbstractState*)s2);
         QCOMPARE(t->targetStates().size(), 1);
         QCOMPARE(t->targetStates().at(0), (QAbstractState*)s2);
-        QCOMPARE(s1->addTransition(t), (QAbstractTransition*)t);
+        s1->addTransition(t);
         QCOMPARE(t->sourceState(), (QState*)s1);
         QCOMPARE(t->machine(), &machine);
 
@@ -1173,7 +1173,7 @@ void tst_QStateMachine::stateEntryAndExit()
             s2->removeTransition(trans);
             QCOMPARE(trans->sourceState(), (QState*)0);
             QCOMPARE(trans->targetState(), (QAbstractState*)s3);
-            QCOMPARE(s2->addTransition(trans), trans);
+            s2->addTransition(trans);
             QCOMPARE(trans->sourceState(), (QState*)s2);
         }
 
@@ -1319,9 +1319,9 @@ void tst_QStateMachine::assignProperty()
     QCOMPARE(s1->objectName(), QString::fromLatin1("foo"));
 
     {
-        QSignalSpy polishedSpy(s1, SIGNAL(polished()));
+        QSignalSpy propertiesAssignedSpy(s1, SIGNAL(propertiesAssigned()));
         machine.start();
-        QTRY_COMPARE(polishedSpy.count(), 1);
+        QTRY_COMPARE(propertiesAssignedSpy.count(), 1);
     }
 
     // nested states
@@ -1340,11 +1340,11 @@ void tst_QStateMachine::assignPropertyWithAnimation()
     // Single animation
     {
         QStateMachine machine;
-        QVERIFY(machine.animationsEnabled());
-        machine.setAnimationsEnabled(false);
-        QVERIFY(!machine.animationsEnabled());
-        machine.setAnimationsEnabled(true);
-        QVERIFY(machine.animationsEnabled());
+        QVERIFY(machine.isAnimated());
+        machine.setAnimated(false);
+        QVERIFY(!machine.isAnimated());
+        machine.setAnimated(true);
+        QVERIFY(machine.isAnimated());
         QObject obj;
         obj.setProperty("foo", 321);
         obj.setProperty("bar", 654);
@@ -1371,7 +1371,7 @@ void tst_QStateMachine::assignPropertyWithAnimation()
         QCOMPARE(trans->animations().size(), 1);
         QCOMPARE(trans->animations().at(0), (QAbstractAnimation*)&anim);
         QFinalState *s3 = new QFinalState(&machine);
-        s2->addTransition(s2, SIGNAL(polished()), s3);
+        s2->addTransition(s2, SIGNAL(propertiesAssigned()), s3);
 
         machine.setInitialState(s1);
         QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
@@ -1399,7 +1399,7 @@ void tst_QStateMachine::assignPropertyWithAnimation()
         anim2.setDuration(150);
         trans->addAnimation(&anim2);
         QFinalState *s3 = new QFinalState(&machine);
-        s2->addTransition(s2, SIGNAL(polished()), s3);
+        s2->addTransition(s2, SIGNAL(propertiesAssigned()), s3);
 
         machine.setInitialState(s1);
         QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
@@ -1427,7 +1427,7 @@ void tst_QStateMachine::assignPropertyWithAnimation()
         group.addAnimation(new QPropertyAnimation(&obj, "bar"));
         trans->addAnimation(&group);
         QFinalState *s3 = new QFinalState(&machine);
-        s2->addTransition(s2, SIGNAL(polished()), s3);
+        s2->addTransition(s2, SIGNAL(propertiesAssigned()), s3);
 
         machine.setInitialState(s1);
         QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
@@ -1473,10 +1473,10 @@ void tst_QStateMachine::assignPropertyWithAnimation()
         anim2.setDuration(250);
         trans->addAnimation(&anim2);
 
-        s21->addTransition(s21, SIGNAL(polished()), s22);
+        s21->addTransition(s21, SIGNAL(propertiesAssigned()), s22);
 
         QFinalState *s3 = new QFinalState(&machine);
-        s22->addTransition(s2, SIGNAL(polished()), s3);
+        s22->addTransition(s2, SIGNAL(propertiesAssigned()), s3);
 
         machine.setInitialState(s1);
         QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
@@ -1513,13 +1513,13 @@ void tst_QStateMachine::assignPropertyWithAnimation()
         machine.setInitialState(group);
         machine.start();
         QTRY_COMPARE(machine.configuration().contains(s1), true);
-        QSignalSpy polishedSpy(s2, SIGNAL(polished()));
+        QSignalSpy propertiesAssignedSpy(s2, SIGNAL(propertiesAssigned()));
         emitter.emitSignalWithNoArg();
         QTRY_COMPARE(machine.configuration().contains(s2), true);
-        QVERIFY(polishedSpy.isEmpty());
+        QVERIFY(propertiesAssignedSpy.isEmpty());
         emitter.emitSignalWithNoArg(); // will cause animations from s1-->s2 to abort
         QTRY_COMPARE(machine.configuration().contains(s3), true);
-        QVERIFY(polishedSpy.isEmpty());
+        QVERIFY(propertiesAssignedSpy.isEmpty());
         QCOMPARE(obj.property("foo").toInt(), 911);
         QCOMPARE(obj.property("bar").toInt(), 789);
     }
@@ -2736,10 +2736,10 @@ void tst_QStateMachine::restorePolicyNotInherited()
 
 }*/
 
-void tst_QStateMachine::globalRestorePolicySetToDoNotRestore()
+void tst_QStateMachine::globalRestorePolicySetToDontRestore()
 {
     QStateMachine machine;
-    machine.setGlobalRestorePolicy(QStateMachine::DoNotRestoreProperties);
+    machine.setGlobalRestorePolicy(QStateMachine::DontRestoreProperties);
 
     QObject *propertyHolder = new QObject(&machine);
     propertyHolder->setProperty("a", 1);
@@ -3089,7 +3089,7 @@ void tst_QStateMachine::twoAnimations()
 
     QState *s3 = new QState(&machine);
     QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
-    s2->addTransition(s2, SIGNAL(polished()), s3);
+    s2->addTransition(s2, SIGNAL(propertiesAssigned()), s3);
 
     machine.setInitialState(s1);
     machine.start();
@@ -3117,7 +3117,9 @@ void tst_QStateMachine::twoAnimatedTransitions()
     QState *s2 = new QState(&machine);
     s2->assignProperty(object, "foo", 5.0);
     QPropertyAnimation *fooAnimation = new QPropertyAnimation(object, "foo", s2);
-    s1->addTransition(new EventTransition(QEvent::User, s2))->addAnimation(fooAnimation);
+    EventTransition *trans = new EventTransition(QEvent::User, s2);
+    s1->addTransition(trans);
+    trans->addAnimation(fooAnimation);
 
     QState *s3 = new QState(&machine);
     QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
@@ -3126,7 +3128,9 @@ void tst_QStateMachine::twoAnimatedTransitions()
     QState *s4 = new QState(&machine);
     s4->assignProperty(object, "foo", 2.0);
     QPropertyAnimation *fooAnimation2 = new QPropertyAnimation(object, "foo", s4);
-    s3->addTransition(new EventTransition(QEvent::User, s4))->addAnimation(fooAnimation2);
+    trans = new EventTransition(QEvent::User, s4);
+    s3->addTransition(trans);
+    trans->addAnimation(fooAnimation2);
 
     QState *s5 = new QState(&machine);
     QObject::connect(s5, SIGNAL(entered()), QApplication::instance(), SLOT(quit()));
@@ -3161,7 +3165,9 @@ void tst_QStateMachine::playAnimationTwice()
     QState *s2 = new QState(&machine);
     s2->assignProperty(object, "foo", 5.0);
     QPropertyAnimation *fooAnimation = new QPropertyAnimation(object, "foo", s2);
-    s1->addTransition(new EventTransition(QEvent::User, s2))->addAnimation(fooAnimation);
+    EventTransition *trans = new EventTransition(QEvent::User, s2);
+    s1->addTransition(trans);
+    trans->addAnimation(fooAnimation);
 
     QState *s3 = new QState(&machine);
     QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
@@ -3169,7 +3175,9 @@ void tst_QStateMachine::playAnimationTwice()
 
     QState *s4 = new QState(&machine);
     s4->assignProperty(object, "foo", 2.0);
-    s3->addTransition(new EventTransition(QEvent::User, s4))->addAnimation(fooAnimation);
+    trans = new EventTransition(QEvent::User, s4);
+    s3->addTransition(trans);
+    trans->addAnimation(fooAnimation);
 
     QState *s5 = new QState(&machine);
     QObject::connect(s5, SIGNAL(entered()), QApplication::instance(), SLOT(quit()));
@@ -3213,14 +3221,16 @@ void tst_QStateMachine::nestedTargetStateForAnimation()
 
     QState *s2Child2 = new QState(s2);
     s2Child2->assignProperty(object, "bar", 11.0);
-    QAbstractTransition *at = s2Child->addTransition(new EventTransition(QEvent::User, s2Child2));
+    QAbstractTransition *at = new EventTransition(QEvent::User, s2Child2);
+    s2Child->addTransition(at);
 
     QPropertyAnimation *animation = new QPropertyAnimation(object, "bar", s2);
     animation->setDuration(2000);
     connect(animation, SIGNAL(finished()), &counter, SLOT(slot()));
     at->addAnimation(animation);
 
-    at = s1->addTransition(new EventTransition(QEvent::User, s2));
+    at = new EventTransition(QEvent::User, s2);
+    s1->addTransition(at);
 
     animation = new QPropertyAnimation(object, "foo", s2);
     connect(animation, SIGNAL(finished()), &counter, SLOT(slot()));
@@ -3231,7 +3241,7 @@ void tst_QStateMachine::nestedTargetStateForAnimation()
     at->addAnimation(animation);
 
     QState *s3 = new QState(&machine);
-    s2->addTransition(s2Child, SIGNAL(polished()), s3);
+    s2->addTransition(s2Child, SIGNAL(propertiesAssigned()), s3);
 
     QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
 
@@ -3248,7 +3258,7 @@ void tst_QStateMachine::nestedTargetStateForAnimation()
     QCOMPARE(counter.counter, 2);
 }
 
-void tst_QStateMachine::polishedSignalTransitionsReuseAnimationGroup()
+void tst_QStateMachine::propertiesAssignedSignalTransitionsReuseAnimationGroup()
 {
     QStateMachine machine;
     QObject *object = new QObject(&machine);
@@ -3265,9 +3275,9 @@ void tst_QStateMachine::polishedSignalTransitionsReuseAnimationGroup()
     QParallelAnimationGroup animationGroup;
     animationGroup.addAnimation(new QPropertyAnimation(object, "foo"));
     QSignalSpy animationFinishedSpy(&animationGroup, SIGNAL(finished()));
-    s1->addTransition(s1, SIGNAL(polished()), s2)->addAnimation(&animationGroup);
-    s2->addTransition(s2, SIGNAL(polished()), s3)->addAnimation(&animationGroup);
-    s3->addTransition(s3, SIGNAL(polished()), s4);
+    s1->addTransition(s1, SIGNAL(propertiesAssigned()), s2)->addAnimation(&animationGroup);
+    s2->addTransition(s2, SIGNAL(propertiesAssigned()), s3)->addAnimation(&animationGroup);
+    s3->addTransition(s3, SIGNAL(propertiesAssigned()), s4);
 
     machine.setInitialState(s1);
     QSignalSpy machineFinishedSpy(&machine, SIGNAL(finished()));
@@ -3299,7 +3309,8 @@ void tst_QStateMachine::animatedGlobalRestoreProperty()
     QState *s4 = new QState(&machine);
     QObject::connect(s4, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
 
-    QAbstractTransition *at = s1->addTransition(new EventTransition(QEvent::User, s2));
+    QAbstractTransition *at = new EventTransition(QEvent::User, s2);
+    s1->addTransition(at);
     QPropertyAnimation *pa = new QPropertyAnimation(object, "foo", s2);
     connect(pa, SIGNAL(finished()), &counter, SLOT(slot()));
     at->addAnimation(pa);
@@ -3341,7 +3352,9 @@ void tst_QStateMachine::specificTargetValueOfAnimation()
 
     QPropertyAnimation *anim = new QPropertyAnimation(object, "foo");
     anim->setEndValue(10.0);
-    s1->addTransition(new EventTransition(QEvent::User, s2))->addAnimation(anim);
+    EventTransition *trans = new EventTransition(QEvent::User, s2);
+    s1->addTransition(trans);
+    trans->addAnimation(anim);
 
     QState *s3 = new QState(&machine);
     QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
@@ -3495,7 +3508,8 @@ void tst_QStateMachine::overrideDefaultAnimationWithSpecific()
     QState *s3 = new QState(&machine);
     QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
 
-    QAbstractTransition *at = s1->addTransition(new EventTransition(QEvent::User, s2));
+    QAbstractTransition *at = new EventTransition(QEvent::User, s2);
+    s1->addTransition(at);
 
     QPropertyAnimation *defaultAnimation = new QPropertyAnimation(object, "foo");
     connect(defaultAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), &counter, SLOT(slot()));
diff --git a/tests/auto/qstringbuilder1/qstringbuilder1.pro b/tests/auto/qstringbuilder1/qstringbuilder1.pro
index 1ca9d45..5bb14d4 100644
--- a/tests/auto/qstringbuilder1/qstringbuilder1.pro
+++ b/tests/auto/qstringbuilder1/qstringbuilder1.pro
@@ -3,7 +3,4 @@ load(qttest_p4)
 QT = core
 
 SOURCES  += tst_qstringbuilder1.cpp
-HEADERS  += ../qstringbuilder1/stringbuilder.h
-
-DEFINES += SCENARIO=1
 
diff --git a/tests/auto/qstringbuilder1/stringbuilder.cpp b/tests/auto/qstringbuilder1/stringbuilder.cpp
index 9fea137..f35d4d2 100644
--- a/tests/auto/qstringbuilder1/stringbuilder.cpp
+++ b/tests/auto/qstringbuilder1/stringbuilder.cpp
@@ -39,61 +39,9 @@
 **
 ****************************************************************************/
 
-// This is included in various .cpp files as a compile test for various scenarios
-// depending on NO_CAST_*  and  QT_USE_FAST_OPERATOR_PLUS and QT_USE_FAST_CONCATENATION
-
-#if SCENARIO == 1
-// this is the "no harm done" version. Only operator% is active,
-// with NO_CAST * defined
-#define P %
-#undef QT_USE_FAST_OPERATOR_PLUS
-#undef QT_USE_FAST_CONCATENATION
-#define QT_NO_CAST_FROM_ASCII
-#define QT_NO_CAST_TO_ASCII
-#endif
-
-
-#if SCENARIO == 2
-// this is the "full" version. Operator+ is replaced by a QStringBuilder
-// based version
-// with NO_CAST * defined
-#define P +
-#define QT_USE_FAST_OPERATOR_PLUS
-#define QT_USE_FAST_CONCATENATION
-#define QT_NO_CAST_FROM_ASCII
-#define QT_NO_CAST_TO_ASCII
-#endif
-
-#if SCENARIO == 3
-// this is the "no harm done" version. Only operator% is active,
-// with NO_CAST * _not_ defined
-#define P %
-#undef QT_USE_FAST_OPERATOR_PLUS
-#undef QT_USE_FAST_CONCATENATION
-#undef QT_NO_CAST_FROM_ASCII
-#undef QT_NO_CAST_TO_ASCII
-#endif
-
-#if SCENARIO == 4
-// this is the "full" version. Operator+ is replaced by a QStringBuilder
-// based version
-// with NO_CAST * _not_ defined
-#define P +
-#define QT_USE_FAST_OPERATOR_PLUS
-#define QT_USE_FAST_CONCATENATION
-#undef QT_NO_CAST_FROM_ASCII
-#undef QT_NO_CAST_TO_ASCII
-#endif
-
-#include <QtTest/QtTest>
-#include "stringbuilder.h"
-
-//TESTED_CLASS=QStringBuilder
-//TESTED_FILES=qstringbuilder.cpp
-
 #define LITERAL "some literal"
 
-void tst_QStringBuilder::scenario()
+void runScenario()
 {
     QLatin1Literal l1literal(LITERAL);
     QLatin1String l1string(LITERAL);
@@ -129,5 +77,3 @@ void tst_QStringBuilder::scenario()
     QCOMPARE(r, r2);
 #endif
 }
-
-QTEST_APPLESS_MAIN(tst_QStringBuilder)
diff --git a/tests/auto/qstringbuilder1/stringbuilder.h b/tests/auto/qstringbuilder1/stringbuilder.h
deleted file mode 100644
index 5ac9dbe..0000000
--- a/tests/auto/qstringbuilder1/stringbuilder.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 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$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights.  These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef TST_QSTRINGBUILDER_H
-#define TST_QSTRINGBUILDER_H
-
-#include <qobject.h>
-
-class tst_QStringBuilder : public QObject
-{
-    Q_OBJECT
-
-private slots:
-    void scenario();
-};
-
-#endif
diff --git a/tests/auto/qstringbuilder1/tst_qstringbuilder1.cpp b/tests/auto/qstringbuilder1/tst_qstringbuilder1.cpp
index bd2e4b0..d0a613c 100644
--- a/tests/auto/qstringbuilder1/tst_qstringbuilder1.cpp
+++ b/tests/auto/qstringbuilder1/tst_qstringbuilder1.cpp
@@ -39,4 +39,35 @@
 **
 ****************************************************************************/
 
-#include "../qstringbuilder1/stringbuilder.cpp"
+
+// SCENARIO 1
+// this is the "no harm done" version. Only operator% is active,
+// with NO_CAST * defined
+#define P %
+#undef QT_USE_FAST_OPERATOR_PLUS
+#undef QT_USE_FAST_CONCATENATION
+#define QT_NO_CAST_FROM_ASCII
+#define QT_NO_CAST_TO_ASCII
+
+
+#include <QtTest/QtTest>
+
+//TESTED_CLASS=QStringBuilder
+//TESTED_FILES=qstringbuilder.cpp
+
+#define LITERAL "some literal"
+
+void runScenario(); // Defined in stringbuilder.cpp #included below.
+
+class tst_QStringBuilder1 : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void scenario() { runScenario(); }
+};
+
+#include "stringbuilder.cpp"
+#include "tst_qstringbuilder1.moc"
+
+QTEST_APPLESS_MAIN(tst_QStringBuilder1)
diff --git a/tests/auto/qstringbuilder2/qstringbuilder2.pro b/tests/auto/qstringbuilder2/qstringbuilder2.pro
index c0b3ebc..4152dc3 100644
--- a/tests/auto/qstringbuilder2/qstringbuilder2.pro
+++ b/tests/auto/qstringbuilder2/qstringbuilder2.pro
@@ -3,6 +3,3 @@ load(qttest_p4)
 QT = core
 
 SOURCES  += tst_qstringbuilder2.cpp
-HEADERS  += ../qstringbuilder1/stringbuilder.h
-
-DEFINES += SCENARIO=2
diff --git a/tests/auto/qstringbuilder2/tst_qstringbuilder2.cpp b/tests/auto/qstringbuilder2/tst_qstringbuilder2.cpp
index bd2e4b0..4470928 100644
--- a/tests/auto/qstringbuilder2/tst_qstringbuilder2.cpp
+++ b/tests/auto/qstringbuilder2/tst_qstringbuilder2.cpp
@@ -39,4 +39,36 @@
 **
 ****************************************************************************/
 
+
+// SCENARIO 2
+// this is the "full" version. Operator+ is replaced by a QStringBuilder
+// based version
+// with NO_CAST * defined
+#define P +
+#define QT_USE_FAST_OPERATOR_PLUS
+#define QT_USE_FAST_CONCATENATION
+#define QT_NO_CAST_FROM_ASCII
+#define QT_NO_CAST_TO_ASCII
+
+
+#include <QtTest/QtTest>
+
+//TESTED_CLASS=QStringBuilder
+//TESTED_FILES=qstringbuilder.cpp
+
+#define LITERAL "some literal"
+
+void runScenario(); // Defined in stringbuilder.cpp #included below.
+
+class tst_QStringBuilder2 : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void scenario() { runScenario(); }
+};
+
 #include "../qstringbuilder1/stringbuilder.cpp"
+#include "tst_qstringbuilder2.moc"
+
+QTEST_APPLESS_MAIN(tst_QStringBuilder2)
diff --git a/tests/auto/qstringbuilder3/qstringbuilder3.pro b/tests/auto/qstringbuilder3/qstringbuilder3.pro
index 93d1a39..b4d2225 100644
--- a/tests/auto/qstringbuilder3/qstringbuilder3.pro
+++ b/tests/auto/qstringbuilder3/qstringbuilder3.pro
@@ -3,6 +3,3 @@ load(qttest_p4)
 QT = core
 
 SOURCES  += tst_qstringbuilder3.cpp
-HEADERS  += ../qstringbuilder1/stringbuilder.h
-
-DEFINES += SCENARIO=3
diff --git a/tests/auto/qstringbuilder3/tst_qstringbuilder3.cpp b/tests/auto/qstringbuilder3/tst_qstringbuilder3.cpp
index bd2e4b0..30f0181 100644
--- a/tests/auto/qstringbuilder3/tst_qstringbuilder3.cpp
+++ b/tests/auto/qstringbuilder3/tst_qstringbuilder3.cpp
@@ -39,4 +39,35 @@
 **
 ****************************************************************************/
 
+
+// SCENARIO 3
+// this is the "no harm done" version. Only operator% is active,
+// with NO_CAST * _not_ defined
+#define P %
+#undef QT_USE_FAST_OPERATOR_PLUS
+#undef QT_USE_FAST_CONCATENATION
+#undef QT_NO_CAST_FROM_ASCII
+#undef QT_NO_CAST_TO_ASCII
+
+
+#include <QtTest/QtTest>
+
+//TESTED_CLASS=QStringBuilder
+//TESTED_FILES=qstringbuilder.cpp
+
+#define LITERAL "some literal"
+
+void runScenario(); // Defined in stringbuilder.cpp #included below.
+
+class tst_QStringBuilder3 : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void scenario() { runScenario(); }
+};
+
 #include "../qstringbuilder1/stringbuilder.cpp"
+#include "tst_qstringbuilder3.moc"
+
+QTEST_APPLESS_MAIN(tst_QStringBuilder3)
diff --git a/tests/auto/qstringbuilder4/qstringbuilder4.pro b/tests/auto/qstringbuilder4/qstringbuilder4.pro
index eeec447..6ec5228 100644
--- a/tests/auto/qstringbuilder4/qstringbuilder4.pro
+++ b/tests/auto/qstringbuilder4/qstringbuilder4.pro
@@ -3,6 +3,3 @@ load(qttest_p4)
 QT = core
 
 SOURCES  += tst_qstringbuilder4.cpp
-HEADERS  += ../qstringbuilder1/stringbuilder.h
-
-DEFINES += SCENARIO=4
diff --git a/tests/auto/qstringbuilder4/tst_qstringbuilder4.cpp b/tests/auto/qstringbuilder4/tst_qstringbuilder4.cpp
index 2159283..95b4ec3 100644
--- a/tests/auto/qstringbuilder4/tst_qstringbuilder4.cpp
+++ b/tests/auto/qstringbuilder4/tst_qstringbuilder4.cpp
@@ -4,7 +4,7 @@
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
-** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+** This file is part of the test suite module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** No Commercial Usage
@@ -39,4 +39,36 @@
 **
 ****************************************************************************/
 
+
+// SCENARIO 4
+// this is the "full" version. Operator+ is replaced by a QStringBuilder
+// based version
+// with NO_CAST * _not_ defined
+#define P +
+#define QT_USE_FAST_OPERATOR_PLUS
+#define QT_USE_FAST_CONCATENATION
+#undef QT_NO_CAST_FROM_ASCII
+#undef QT_NO_CAST_TO_ASCII
+
+
+#include <QtTest/QtTest>
+
+//TESTED_CLASS=QStringBuilder
+//TESTED_FILES=qstringbuilder.cpp
+
+#define LITERAL "some literal"
+
+void runScenario(); // Defined in stringbuilder.cpp #included below.
+
+class tst_QStringBuilder4 : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void scenario() { runScenario(); }
+};
+
 #include "../qstringbuilder1/stringbuilder.cpp"
+#include "tst_qstringbuilder4.moc"
+
+QTEST_APPLESS_MAIN(tst_QStringBuilder4)
diff --git a/tests/auto/qtableview/tst_qtableview.cpp b/tests/auto/qtableview/tst_qtableview.cpp
index d8110e1..227ca6f 100644
--- a/tests/auto/qtableview/tst_qtableview.cpp
+++ b/tests/auto/qtableview/tst_qtableview.cpp
@@ -41,6 +41,7 @@
 
 
 #include <QtGui/QtGui>
+#include <private/qtablewidget_p.h>
 #include <QtTest/QtTest>
 #include "../../shared/util.h"
 #include "private/qapplication_p.h"
@@ -58,6 +59,13 @@
         } \
     } while(0)
 
+#ifdef QT_BUILD_INTERNAL
+#define VERIFY_SPANS_CONSISTENCY(TEST_VIEW_) \
+    QVERIFY(static_cast<QTableViewPrivate*>(QObjectPrivate::get(TEST_VIEW_))->spans.checkConsistency())
+#else
+#define VERIFY_SPANS_CONSISTENCY(TEST_VIEW_) (void)false
+#endif
+
 typedef QList<int> IntList;
 Q_DECLARE_METATYPE(IntList)
 
@@ -188,12 +196,15 @@ private slots:
     void task248688_autoScrollNavigation();
     void task259308_scrollVerticalHeaderSwappedSections();
     void task191545_dragSelectRows();
+    void taskQTBUG_5062_spansInconsistency();
 
     void mouseWheel_data();
     void mouseWheel();
 
     void addColumnWhileEditing();
     void task234926_setHeaderSorting();
+
+    void changeHeaderData();
 };
 
 // Testing get/set functions
@@ -2017,8 +2028,9 @@ void tst_QTableView::resizeRowsToContents()
     view.resizeRowsToContents();
 
     QCOMPARE(resizedSpy.count(), model.rowCount());
-    for (int r = 0; r < model.rowCount(); ++r)
+    for (int r = 0; r < model.rowCount(); ++r) {
         QCOMPARE(view.rowHeight(r), rowHeight);
+    }
 }
 
 void tst_QTableView::resizeColumnsToContents_data()
@@ -2898,6 +2910,8 @@ void tst_QTableView::span()
     view.clearSpans();
     QCOMPARE(view.rowSpan(row, column), 1);
     QCOMPARE(view.columnSpan(row, column), 1);
+
+    VERIFY_SPANS_CONSISTENCY(&view);
 }
 
 typedef QVector<QRect> SpanList;
@@ -3033,6 +3047,8 @@ void tst_QTableView::spans()
 
     QCOMPARE(view.columnSpan(pos.x(), pos.y()), expectedColumnSpan);
     QCOMPARE(view.rowSpan(pos.x(), pos.y()), expectedRowSpan);
+
+    VERIFY_SPANS_CONSISTENCY(&view);
 }
 
 void tst_QTableView::spansAfterRowInsertion()
@@ -3067,6 +3083,8 @@ void tst_QTableView::spansAfterRowInsertion()
     view.model()->insertRows(12, 2);
     QCOMPARE(view.rowSpan(7, 3), 5);
     QCOMPARE(view.columnSpan(7, 3), 3);
+
+    VERIFY_SPANS_CONSISTENCY(&view);
 }
 
 void tst_QTableView::spansAfterColumnInsertion()
@@ -3101,6 +3119,8 @@ void tst_QTableView::spansAfterColumnInsertion()
     view.model()->insertColumns(12, 2);
     QCOMPARE(view.rowSpan(3, 7), 3);
     QCOMPARE(view.columnSpan(3, 7), 5);
+
+    VERIFY_SPANS_CONSISTENCY(&view);
 }
 
 void tst_QTableView::spansAfterRowRemoval()
@@ -3138,6 +3158,8 @@ void tst_QTableView::spansAfterRowRemoval()
         QCOMPARE(view.columnSpan(span.top(), span.left()), span.width());
         QCOMPARE(view.rowSpan(span.top(), span.left()), span.height());
     }
+
+    VERIFY_SPANS_CONSISTENCY(&view);
 }
 
 void tst_QTableView::spansAfterColumnRemoval()
@@ -3176,6 +3198,8 @@ void tst_QTableView::spansAfterColumnRemoval()
         QCOMPARE(view.columnSpan(span.left(), span.top()), span.height());
         QCOMPARE(view.rowSpan(span.left(), span.top()), span.width());
     }
+
+    VERIFY_SPANS_CONSISTENCY(&view);
 }
 
 class Model : public QAbstractTableModel {
@@ -3267,12 +3291,12 @@ void tst_QTableView::resizeToContents()
 
     //now let's check the row/col sizes
     for(int i = 0;i<table.columnCount();i++) {
-        QVERIFY( table.columnWidth(i) == table2.columnWidth(i));
-        QVERIFY( table2.columnWidth(i) == table3.columnWidth(i));
+        QCOMPARE( table.columnWidth(i), table2.columnWidth(i));
+        QCOMPARE( table2.columnWidth(i), table3.columnWidth(i));
     }
     for(int i = 0;i<table.rowCount();i++) {
-        QVERIFY( table.rowHeight(i) == table2.rowHeight(i));
-        QVERIFY( table2.rowHeight(i) == table3.rowHeight(i));
+        QCOMPARE( table.rowHeight(i), table2.rowHeight(i));
+        QCOMPARE( table2.rowHeight(i), table3.rowHeight(i));
     }
 
 }
@@ -3844,5 +3868,41 @@ void tst_QTableView::task234926_setHeaderSorting()
     QCOMPARE(model.stringList() , sortedDataD);
 }
 
+void tst_QTableView::taskQTBUG_5062_spansInconsistency()
+{
+    const int nRows = 5;
+    const int nColumns = 5;
+
+    QtTestTableModel model(nRows, nColumns);
+    QtTestTableView view;
+    view.setModel(&model);
+
+    for (int i = 0; i < nRows; ++i)
+       view.setSpan(i, 0, 1, nColumns);
+    view.setSpan(2, 0, 1, 1);
+    view.setSpan(3, 0, 1, 1);
+
+    VERIFY_SPANS_CONSISTENCY(&view);
+}
+
+void tst_QTableView::changeHeaderData()
+{
+    QTableView view;
+    QStandardItemModel model(5,5);
+    view.setModel(&model);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QString text = "long long long text";
+    const int textWidth = view.fontMetrics().width(text);
+    QVERIFY(view.verticalHeader()->width() < textWidth);
+
+    model.setHeaderData(2, Qt::Vertical, text);
+    QTest::qWait(100); //leave time for layout
+
+    QVERIFY(view.verticalHeader()->width() > textWidth);
+}
+
+
 QTEST_MAIN(tst_QTableView)
 #include "tst_qtableview.moc"
diff --git a/tests/auto/qtextdocument/qtextdocument.pro b/tests/auto/qtextdocument/qtextdocument.pro
index d3ec45d..1e44a9c 100644
--- a/tests/auto/qtextdocument/qtextdocument.pro
+++ b/tests/auto/qtextdocument/qtextdocument.pro
@@ -1,4 +1,5 @@
 load(qttest_p4)
+QT += xml
 HEADERS += common.h
 SOURCES += tst_qtextdocument.cpp 
 
diff --git a/tests/auto/qtextdocument/tst_qtextdocument.cpp b/tests/auto/qtextdocument/tst_qtextdocument.cpp
index f393393..5237438 100644
--- a/tests/auto/qtextdocument/tst_qtextdocument.cpp
+++ b/tests/auto/qtextdocument/tst_qtextdocument.cpp
@@ -59,6 +59,7 @@
 #include <qfontmetrics.h>
 #include <qimage.h>
 #include <qtextlayout.h>
+#include <QDomDocument>
 #include "common.h"
 
 
@@ -175,6 +176,8 @@ private slots:
     void testUndoBlocks();
 
     void receiveCursorPositionChangedAfterContentsChange();
+    void escape_data();
+    void escape();
 
 private:
     void backgroundImage_checkExpectedHtml(const QTextDocument &doc);
@@ -576,7 +579,7 @@ void tst_QTextDocument::task240325()
 }
 
 void tst_QTextDocument::stylesheetFont_data()
-{    
+{
     QTest::addColumn<QString>("stylesheet");
     QTest::addColumn<QFont>("font");
 
@@ -732,7 +735,7 @@ void tst_QTextDocument::toHtml_data()
         cursor.insertText("Blah", fmt);
 
         QTest::newRow("font-family-with-quotes1") << QTextDocumentFragment(&doc)
-                                  << QString("<p DEFAULTBLOCKSTYLE><span style=\" font-family:\"Foo's Family\";\">Blah</span></p>");
+                                  << QString("<p DEFAULTBLOCKSTYLE><span style=\" font-family:&quot;Foo's Family&quot;;\">Blah</span></p>");
     }
 
     {
@@ -743,7 +746,7 @@ void tst_QTextDocument::toHtml_data()
         cursor.insertText("Blah", fmt);
 
         QTest::newRow("font-family-with-quotes2") << QTextDocumentFragment(&doc)
-                                  << QString("<p DEFAULTBLOCKSTYLE><span style=\" font-family:'Foo\"s Family';\">Blah</span></p>");
+                                  << QString("<p DEFAULTBLOCKSTYLE><span style=\" font-family:'Foo&quot;s Family';\">Blah</span></p>");
     }
 
     {
@@ -974,6 +977,30 @@ void tst_QTextDocument::toHtml_data()
     {
         CREATE_DOC_AND_CURSOR();
 
+        QTextCharFormat fmt;
+        fmt.setAnchor(true);
+        fmt.setAnchorHref("http://www.kde.org/?a=1&b=2");
+        cursor.insertText("Blah", fmt);
+
+        QTest::newRow("href anchor with &") << QTextDocumentFragment(&doc)
+                                  << QString("<p DEFAULTBLOCKSTYLE><a href=\"http://www.kde.org/?a=1&amp;b=2\">Blah</a></p>");
+    }
+
+    {
+        CREATE_DOC_AND_CURSOR();
+
+        QTextCharFormat fmt;
+        fmt.setAnchor(true);
+        fmt.setAnchorHref("http://www.kde.org/?a='&b=\"");
+        cursor.insertText("Blah", fmt);
+
+        QTest::newRow("href anchor with ' and \"") << QTextDocumentFragment(&doc)
+                                  << QString("<p DEFAULTBLOCKSTYLE><a href=\"http://www.kde.org/?a='&amp;b=&quot;\">Blah</a></p>");
+    }
+
+    {
+        CREATE_DOC_AND_CURSOR();
+
         cursor.insertTable(2, 2);
 
         QTest::newRow("simpletable") << QTextDocumentFragment(&doc)
@@ -1541,6 +1568,9 @@ void tst_QTextDocument::toHtml()
     QString output = doc->toHtml();
 
     QCOMPARE(output, expectedOutput);
+
+    QDomDocument document;
+    QVERIFY2(document.setContent(output), "Output was not valid XML");
 }
 
 void tst_QTextDocument::toHtml2()
@@ -2652,5 +2682,25 @@ void tst_QTextDocument::receiveCursorPositionChangedAfterContentsChange()
     QCOMPARE(rec.first, QString("contentsChanged"));
 }
 
+void tst_QTextDocument::escape_data()
+{
+    QTest::addColumn<QString>("original");
+    QTest::addColumn<QString>("expected");
+
+    QTest::newRow("1") << "Hello World\n" << "Hello World\n";
+    QTest::newRow("2") << "#include <QtCore>" << "#include &lt;QtCore&gt;";
+    QTest::newRow("3") << "<p class=\"cool\"><a href=\"http://example.com/?foo=bar&amp;bar=foo\">plop --&gt; </a></p>"
+                       << "&lt;p class=&quot;cool&quot;&gt;&lt;a href=&quot;http://example.com/?foo=bar&amp;amp;bar=foo&quot;&gt;plop --&amp;gt; &lt;/a&gt;&lt;/p&gt;";
+    QTest::newRow("4") << QString::fromUtf8("<\320\222\321\201>") << QString::fromUtf8("&lt;\320\222\321\201&gt;");
+}
+
+void tst_QTextDocument::escape()
+{
+    QFETCH(QString, original);
+    QFETCH(QString, expected);
+
+    QCOMPARE(Qt::escape(original), expected);
+}
+
 QTEST_MAIN(tst_QTextDocument)
 #include "tst_qtextdocument.moc"
diff --git a/tests/auto/qtextedit/fullWidthSelection/centered-fully-selected.png b/tests/auto/qtextedit/fullWidthSelection/centered-fully-selected.png
index 7467478..ced6eb6 100644
--- a/tests/auto/qtextedit/fullWidthSelection/centered-fully-selected.png
+++ b/tests/auto/qtextedit/fullWidthSelection/centered-fully-selected.png
diff --git a/tests/auto/qtextedit/fullWidthSelection/centered-partly-selected.png b/tests/auto/qtextedit/fullWidthSelection/centered-partly-selected.png
index 7a10e63..481b99c 100644
--- a/tests/auto/qtextedit/fullWidthSelection/centered-partly-selected.png
+++ b/tests/auto/qtextedit/fullWidthSelection/centered-partly-selected.png
diff --git a/tests/auto/qtextedit/fullWidthSelection/last-char-on-line.png b/tests/auto/qtextedit/fullWidthSelection/last-char-on-line.png
index df5b92e..292d3f9 100644
--- a/tests/auto/qtextedit/fullWidthSelection/last-char-on-line.png
+++ b/tests/auto/qtextedit/fullWidthSelection/last-char-on-line.png
diff --git a/tests/auto/qtextedit/fullWidthSelection/last-char-on-parag.png b/tests/auto/qtextedit/fullWidthSelection/last-char-on-parag.png
index d58d4cc..69b72ed 100644
--- a/tests/auto/qtextedit/fullWidthSelection/last-char-on-parag.png
+++ b/tests/auto/qtextedit/fullWidthSelection/last-char-on-parag.png
diff --git a/tests/auto/qtextedit/fullWidthSelection/multiple-full-width-lines.png b/tests/auto/qtextedit/fullWidthSelection/multiple-full-width-lines.png
index c5c3c22..467b91e 100644
--- a/tests/auto/qtextedit/fullWidthSelection/multiple-full-width-lines.png
+++ b/tests/auto/qtextedit/fullWidthSelection/multiple-full-width-lines.png
diff --git a/tests/auto/qtextedit/fullWidthSelection/nowrap_long.png b/tests/auto/qtextedit/fullWidthSelection/nowrap_long.png
index 7ded254..cce921b 100644
--- a/tests/auto/qtextedit/fullWidthSelection/nowrap_long.png
+++ b/tests/auto/qtextedit/fullWidthSelection/nowrap_long.png
diff --git a/tests/auto/qtextedit/fullWidthSelection/single-full-width-line.png b/tests/auto/qtextedit/fullWidthSelection/single-full-width-line.png
index d2fd629..937494a 100644
--- a/tests/auto/qtextedit/fullWidthSelection/single-full-width-line.png
+++ b/tests/auto/qtextedit/fullWidthSelection/single-full-width-line.png
diff --git a/tests/auto/qtextedit/tst_qtextedit.cpp b/tests/auto/qtextedit/tst_qtextedit.cpp
index 59abbd5..fee030c 100644
--- a/tests/auto/qtextedit/tst_qtextedit.cpp
+++ b/tests/auto/qtextedit/tst_qtextedit.cpp
@@ -1967,7 +1967,7 @@ void tst_QTextEdit::fullWidthSelection()
     qt_setQtEnableTestFont(true);
     QFont testFont;
     testFont.setFamily("__Qt__Box__Engine__");
-    testFont.setPixelSize(12);
+    testFont.setPixelSize(11);
     testFont.setWeight(QFont::Normal);
     QTextCharFormat cf;
     cf.setFont(testFont);
@@ -2015,7 +2015,7 @@ void tst_QTextEdit::fullWidthSelection2()
     qt_setQtEnableTestFont(true);
     QFont testFont;
     testFont.setFamily("__Qt__Box__Engine__");
-    testFont.setPixelSize(12);
+    testFont.setPixelSize(11);
     testFont.setWeight(QFont::Normal);
     QTextCharFormat cf;
     cf.setFont(testFont);
diff --git a/tests/auto/qtextlayout/tst_qtextlayout.cpp b/tests/auto/qtextlayout/tst_qtextlayout.cpp
index fe87dfb..7c3f4f2 100644
--- a/tests/auto/qtextlayout/tst_qtextlayout.cpp
+++ b/tests/auto/qtextlayout/tst_qtextlayout.cpp
@@ -118,6 +118,7 @@ private slots:
     void smallTextLengthWordWrap();
     void smallTextLengthWrapAtWordBoundaryOrAnywhere();
     void testLineBreakingAllSpaces();
+    void lineWidthFromBOM();
 
 
 private:
@@ -1306,6 +1307,18 @@ void tst_QTextLayout::columnWrapWithTabs()
 
 }
 
+void tst_QTextLayout::lineWidthFromBOM()
+{
+    const QString string(QChar(0xfeff)); // BYTE ORDER MARK
+    QTextLayout layout(string);
+    layout.beginLayout();
+    QTextLine line = layout.createLine();
+    line.setLineWidth(INT_MAX / 256);
+    layout.endLayout();
+
+    // Don't spin into an infinite loop
+ }
+
 
 QTEST_MAIN(tst_QTextLayout)
 #include "tst_qtextlayout.moc"
diff --git a/tests/auto/qtextscriptengine/generate/generate.pro b/tests/auto/qtextscriptengine/generate/generate.pro
index 355633d..354e0e5 100644
--- a/tests/auto/qtextscriptengine/generate/generate.pro
+++ b/tests/auto/qtextscriptengine/generate/generate.pro
@@ -5,6 +5,7 @@
 TEMPLATE = app
 CONFIG -= moc
 INCLUDEPATH += . /usr/include/freetype2
+INCLUDEPATH += $$QT_SOURCE_TREE/src/3rdparty/harfbuzz/src
 
 # Input
 SOURCES += main.cpp
diff --git a/tests/auto/qtextscriptengine/generate/main.cpp b/tests/auto/qtextscriptengine/generate/main.cpp
index 853c726..15fbc47 100644
--- a/tests/auto/qtextscriptengine/generate/main.cpp
+++ b/tests/auto/qtextscriptengine/generate/main.cpp
@@ -40,7 +40,7 @@
 ****************************************************************************/
 
 
-#include <QtTest/QtTest>
+#include <QApplication>
 #include <QTextEdit>
 #include <QLineEdit>
 #include <QVBoxLayout>
@@ -85,7 +85,7 @@ void MyEdit::setText(const QString &str)
         result += "0x" + QString::number(str.at(i).unicode(), 16) + ", ";
     result += "0x0 },\n  { ";
     for (int i = 0; i < e->layoutData->items[0].num_glyphs; ++i)
-	result += "0x" + QString::number(e->layoutData->glyphPtr[i].glyph, 16) + ", ";
+        result += "0x" + QString::number(e->layoutData->glyphLayout.glyphs[i], 16) + ", ";
     result += "0x0 } }";
 
     setPlainText(result);
diff --git a/tests/auto/qtextscriptengine/tst_qtextscriptengine.cpp b/tests/auto/qtextscriptengine/tst_qtextscriptengine.cpp
index 226348a..78e0ce6 100644
--- a/tests/auto/qtextscriptengine/tst_qtextscriptengine.cpp
+++ b/tests/auto/qtextscriptengine/tst_qtextscriptengine.cpp
@@ -98,7 +98,7 @@ private slots:
     void telugu();
     void kannada();
     void malayalam();
-    // sinhala missing
+    void sinhala();
 
     void khmer();
     void linearB();
@@ -379,7 +379,11 @@ void tst_QTextScriptEngine::bengali()
                   { 0x151, 0x276, 0x172, 0x143, 0x0 } },
                 { { 0x9b0, 0x9cd, 0x995, 0x9be, 0x983, 0x0 },
                   { 0x151, 0x276, 0x172, 0x144, 0x0 } }, 
-
+                // test decomposed two parts matras
+                { { 0x995, 0x9c7, 0x9be, 0x0 },
+                  { 0x179, 0x151, 0x172, 0x0 } },
+                { { 0x995, 0x9c7, 0x9d7, 0x0 },
+                  { 0x179, 0x151, 0x17e, 0x0 } },
 		{ {0}, {0} }
 	    };
 
@@ -502,16 +506,16 @@ void tst_QTextScriptEngine::bengali()
         if (QFontDatabase().families(QFontDatabase::Bengali).contains("Likhan")) {
             QFont f("Likhan");
 	    const ShapeTable shape_table [] = {
-		{ { 0x09a8, 0x09cd, 0x09af, 0x0 },
-		  { 0x0192, 0x0 } },
+                { { 0x9a8, 0x9cd, 0x9af, 0x0 },
+                  { 0x1ca, 0x0 } },
 		{ { 0x09b8, 0x09cd, 0x09af, 0x0 },
-		  { 0x01d6, 0x0 } },
+                  { 0x020e, 0x0 } },
 		{ { 0x09b6, 0x09cd, 0x09af, 0x0 },
-		  { 0x01bc, 0x0 } },
+                  { 0x01f4, 0x0 } },
 		{ { 0x09b7, 0x09cd, 0x09af, 0x0 },
-		  { 0x01c6, 0x0 } },
+                  { 0x01fe, 0x0 } },
 		{ { 0x09b0, 0x09cd, 0x09a8, 0x09cd, 0x200d, 0x0 },
-		  { 0xd3, 0x12f, 0x0 } },
+                  { 0x10b, 0x167, 0x0 } },
 
 		{ {0}, {0} }
 	    };
@@ -647,6 +651,12 @@ void tst_QTextScriptEngine::tamil()
 		  { 0x0025, 0x0 } },
 		{ { 0x0b83, 0x0b95, 0x0 },
 		  { 0x0025, 0x0031, 0x0 } },
+                { { 0xb95, 0xbc6, 0xbbe, 0x0 },
+                  { 0xa, 0x31, 0x7, 0x0 } },
+                { { 0xb95, 0xbc7, 0xbbe, 0x0 },
+                  { 0xb, 0x31, 0x7, 0x0 } },
+                { { 0xb95, 0xbc6, 0xbd7, 0x0 },
+                  { 0xa, 0x31, 0x40, 0x0 } },
 
 		{ {0}, {0} }
 	    };
@@ -694,7 +704,9 @@ void tst_QTextScriptEngine::telugu()
                   { 0xe6, 0xb3, 0x83, 0x0 } },
                 { { 0xc15, 0xc4d, 0xc30, 0xc48, 0x0 },
                   { 0xe6, 0xb3, 0x9f, 0x0 } }, 
-		{ {0}, {0} }
+                { { 0xc15, 0xc46, 0xc56, 0x0 },
+                  { 0xe6, 0xb3, 0x0 } },
+                { {0}, {0} }
 
             };
 
@@ -762,7 +774,16 @@ void tst_QTextScriptEngine::kannada()
 		  { 0x00b0, 0x006c, 0x0 } },
 		{ { 0x0cb7, 0x0ccd, 0x0 },
 		  { 0x0163, 0x0 } },
-
+                { { 0xc95, 0xcbf, 0xcd5, 0x0 },
+                  { 0x114, 0x73, 0x0 } },
+                { { 0xc95, 0xcc6, 0xcd5, 0x0 },
+                  { 0x90, 0x6c, 0x73, 0x0 } },
+                { { 0xc95, 0xcc6, 0xcd6, 0x0 },
+                  { 0x90, 0x6c, 0x74, 0x0 } },
+                { { 0xc95, 0xcc6, 0xcc2, 0x0 },
+                  { 0x90, 0x6c, 0x69, 0x0 } },
+                { { 0xc95, 0xcca, 0xcd5, 0x0 },
+                  { 0x90, 0x6c, 0x69, 0x73, 0x0 } },
 		{ {0}, {0} }
 	    };
 
@@ -816,8 +837,14 @@ void tst_QTextScriptEngine::malayalam()
 		  { 0x009e, 0x0 } },
 		{ { 0x0d30, 0x0d4d, 0x200d, 0x0 },
 		  { 0x009e, 0x0 } },
-
-
+                { { 0xd15, 0xd46, 0xd3e, 0x0 },
+                  { 0x5e, 0x34, 0x58, 0x0 } },
+                { { 0xd15, 0xd47, 0xd3e, 0x0 },
+                  { 0x5f, 0x34, 0x58, 0x0 } },
+                { { 0xd15, 0xd46, 0xd57, 0x0 },
+                  { 0x5e, 0x34, 0x65, 0x0 } },
+                { { 0xd15, 0xd57, 0x0 },
+                  { 0x34, 0x65, 0x0 } },
 		{ {0}, {0} }
 	    };
 
@@ -836,6 +863,42 @@ void tst_QTextScriptEngine::malayalam()
 #endif
 }
 
+void tst_QTextScriptEngine::sinhala()
+{
+#if defined(Q_WS_X11)
+    {
+        if (QFontDatabase().families(QFontDatabase::Sinhala).contains("Malithi Web")) {
+            QFont f("Malithi Web");
+            const ShapeTable shape_table [] = {
+                { { 0xd9a, 0xdd9, 0xdcf, 0x0 },
+                  { 0x4a, 0x61, 0x42, 0x0 } },
+                { { 0xd9a, 0xdd9, 0xddf, 0x0 },
+                  { 0x4a, 0x61, 0x50, 0x0 } },
+                { { 0xd9a, 0xdd9, 0xdca, 0x0 },
+                  { 0x4a, 0x62, 0x0 } },
+                { { 0xd9a, 0xddc, 0xdca, 0x0 },
+                  { 0x4a, 0x61, 0x42, 0x41, 0x0 } },
+                { { 0xd9a, 0xdda, 0x0 },
+                  { 0x4a, 0x62, 0x0 } },
+                { { 0xd9a, 0xddd, 0x0 },
+                  { 0x4a, 0x61, 0x42, 0x41, 0x0 } },
+                { {0}, {0} }
+            };
+
+
+            const ShapeTable *s = shape_table;
+            while (s->unicode[0]) {
+                QVERIFY( shaping(f, s) );
+                ++s;
+            }
+        } else {
+            QSKIP("couln't find Malithi Web", SkipAll);
+        }
+    }
+#else
+    QSKIP("X11 specific test", SkipAll);
+#endif
+}
 
 
 void tst_QTextScriptEngine::khmer()
diff --git a/tests/auto/qtreeview/tst_qtreeview.cpp b/tests/auto/qtreeview/tst_qtreeview.cpp
index da58725..90e6c5c 100644
--- a/tests/auto/qtreeview/tst_qtreeview.cpp
+++ b/tests/auto/qtreeview/tst_qtreeview.cpp
@@ -235,6 +235,7 @@ private slots:
     void task254234_proxySort();
     void task248022_changeSelection();
     void task245654_changeModelAndExpandAll();
+    void doubleClickedWithSpans();
 };
 
 class QtTestModel: public QAbstractItemModel
@@ -2891,7 +2892,10 @@ void tst_QTreeView::styleOptionViewItem()
 
                 QVERIFY(!opt.text.isEmpty());
                 QCOMPARE(opt.index, index);
-                QCOMPARE(!(opt.features & QStyleOptionViewItemV2::Alternate), !(index.row() % 2));
+                //qDebug() << index << opt.text;
+
+                if (allCollapsed)
+                    QCOMPARE(!(opt.features & QStyleOptionViewItemV2::Alternate), !(index.row() % 2));
                 QCOMPARE(!(opt.features & QStyleOptionViewItemV2::HasCheckIndicator), !opt.text.contains("Checkable"));
 
                 if (opt.text.contains("Beginning"))
@@ -2911,12 +2915,16 @@ void tst_QTreeView::styleOptionViewItem()
                 else
                     QCOMPARE(opt.checkState, Qt::Unchecked);
 
+                QCOMPARE(!(opt.state & QStyle::State_Children) , !opt.text.contains("HasChildren"));
+                QCOMPARE(!!(opt.state & QStyle::State_Sibling) , !opt.text.contains("Last"));
+
                 QVERIFY(!opt.text.contains("Assert"));
 
                 QStyledItemDelegate::paint(painter, option, index);
                 count++;
             }
             mutable int count;
+            bool allCollapsed;
     };
 
     QTreeView view;
@@ -2926,8 +2934,9 @@ void tst_QTreeView::styleOptionViewItem()
     view.setItemDelegate(&delegate);
     model.appendRow(QList<QStandardItem*>()
         << new QStandardItem("Beginning") <<  new QStandardItem("Middle") << new QStandardItem("Middle") << new QStandardItem("End") );
+    QStandardItem *par1 = new QStandardItem("Beginning HasChildren");
     model.appendRow(QList<QStandardItem*>()
-        << new QStandardItem("Beginning") <<  new QStandardItem("Middle") << new QStandardItem("Middle") << new QStandardItem("End") );
+        << par1 <<  new QStandardItem("Middle HasChildren") << new QStandardItem("Middle HasChildren") << new QStandardItem("End HasChildren") );
     model.appendRow(QList<QStandardItem*>()
         << new QStandardItem("OnlyOne") <<  new QStandardItem("Assert") << new QStandardItem("Assert") << new QStandardItem("Assert") );
     QStandardItem *checkable = new QStandardItem("Checkable");
@@ -2937,13 +2946,143 @@ void tst_QTreeView::styleOptionViewItem()
     checked->setCheckState(Qt::Checked);
     model.appendRow(QList<QStandardItem*>()
         << new QStandardItem("Beginning") <<  checkable << checked << new QStandardItem("End") );
+    model.appendRow(QList<QStandardItem*>()
+        << new QStandardItem("Beginning Last") <<  new QStandardItem("Middle Last") << new QStandardItem("Middle Last") << new QStandardItem("End Last") );
+
+    par1->appendRow(QList<QStandardItem*>()
+        << new QStandardItem("Beginning") <<  new QStandardItem("Middle") << new QStandardItem("Middle") << new QStandardItem("End") );
+    QStandardItem *par2 = new QStandardItem("Beginning HasChildren");
+    par1->appendRow(QList<QStandardItem*>()
+        << par2 <<  new QStandardItem("Middle HasChildren") << new QStandardItem("Middle HasChildren") << new QStandardItem("End HasChildren") );
+    par2->appendRow(QList<QStandardItem*>()
+        << new QStandardItem("Beginning Last") <<  new QStandardItem("Middle Last") << new QStandardItem("Middle Last") << new QStandardItem("End Last") );
+
+    QStandardItem *par3 = new QStandardItem("Beginning Last");
+    par1->appendRow(QList<QStandardItem*>()
+        << par3 <<  new QStandardItem("Middle Last") << new QStandardItem("Middle Last") << new QStandardItem("End Last") );
+    par3->appendRow(QList<QStandardItem*>()
+        << new QStandardItem("Assert") <<  new QStandardItem("Assert") << new QStandardItem("Assert") << new QStandardItem("Asser") );
+    view.setRowHidden(0, par3->index(), true);
+    par1->appendRow(QList<QStandardItem*>()
+        << new QStandardItem("Assert") <<  new QStandardItem("Assert") << new QStandardItem("Assert") << new QStandardItem("Asser") );
+    view.setRowHidden(3, par1->index(), true);
+
 
     view.setFirstColumnSpanned(2, QModelIndex(), true);
     view.setAlternatingRowColors(true);
 
     delegate.count = 0;
+    delegate.allCollapsed = true;
     view.showMaximized();
+    QApplication::processEvents();
     QTRY_VERIFY(delegate.count >= 13);
+    delegate.count = 0;
+    delegate.allCollapsed = false;
+    view.expandAll();
+    QApplication::processEvents();
+    QTRY_VERIFY(delegate.count >= 13);
+    delegate.count = 0;
+    view.collapse(par2->index());
+    QApplication::processEvents();
+    QTRY_VERIFY(delegate.count >= 4);
+
+
+    //test dynamic models
+    {
+        delegate.count = 0;
+        QStandardItemModel model2;
+        QStandardItem *item0 = new QStandardItem("OnlyOne Last");
+        model2.appendRow(QList<QStandardItem*>() << item0);
+        view.setModel(&model2);
+        QApplication::processEvents();
+        QTRY_VERIFY(delegate.count >= 1);
+        QApplication::processEvents();
+
+        QStandardItem *item00 = new QStandardItem("OnlyOne Last");
+        item0->appendRow(QList<QStandardItem*>() << item00);
+        item0->setText("OnlyOne Last HasChildren");
+        QApplication::processEvents();
+        delegate.count = 0;
+        view.expandAll();
+        QApplication::processEvents();
+        QTRY_VERIFY(delegate.count >= 2);
+        QApplication::processEvents();
+
+        QStandardItem *item1 = new QStandardItem("OnlyOne Last");
+        delegate.count = 0;
+        item0->setText("OnlyOne HasChildren");
+        model2.appendRow(QList<QStandardItem*>() << item1);
+        QApplication::processEvents();
+        QTRY_VERIFY(delegate.count >= 3);
+        QApplication::processEvents();
+
+        QStandardItem *item01 = new QStandardItem("OnlyOne Last");
+        delegate.count = 0;
+        item00->setText("OnlyOne");
+        item0->appendRow(QList<QStandardItem*>() << item01);
+        QApplication::processEvents();
+        QTRY_VERIFY(delegate.count >= 4);
+        QApplication::processEvents();
+
+        QStandardItem *item000 = new QStandardItem("OnlyOne Last");
+        delegate.count = 0;
+        item00->setText("OnlyOne HasChildren");
+        item00->appendRow(QList<QStandardItem*>() << item000);
+        QApplication::processEvents();
+        QTRY_VERIFY(delegate.count >= 5);
+        QApplication::processEvents();
+
+        delegate.count = 0;
+        item0->removeRow(0);
+        QApplication::processEvents();
+        QTRY_VERIFY(delegate.count >= 3);
+        QApplication::processEvents();
+
+        item00 = new QStandardItem("OnlyOne");
+        item0->insertRow(0, QList<QStandardItem*>() << item00);
+        QApplication::processEvents();
+        delegate.count = 0;
+        view.expandAll();
+        QApplication::processEvents();
+        QTRY_VERIFY(delegate.count >= 4);
+        QApplication::processEvents();
+
+        delegate.count = 0;
+        item0->removeRow(1);
+        item00->setText("OnlyOne Last");
+        QApplication::processEvents();
+        QTRY_VERIFY(delegate.count >= 3);
+        QApplication::processEvents();
+
+        delegate.count = 0;
+        item0->removeRow(0);
+        item0->setText("OnlyOne");
+        QApplication::processEvents();
+        QTRY_VERIFY(delegate.count >= 2);
+        QApplication::processEvents();
+
+        //with hidden items
+        item0->setText("OnlyOne HasChildren");
+        item00 = new QStandardItem("OnlyOne");
+        item0->appendRow(QList<QStandardItem*>() << item00);
+        item01 = new QStandardItem("Assert");
+        item0->appendRow(QList<QStandardItem*>() << item01);
+        view.setRowHidden(1, item0->index(), true);
+        view.expandAll();
+        QStandardItem *item02 = new QStandardItem("OnlyOne Last");
+        item0->appendRow(QList<QStandardItem*>() << item02);
+        delegate.count = 0;
+        QApplication::processEvents();
+        QTRY_VERIFY(delegate.count >= 4);
+        QApplication::processEvents();
+
+        item0->removeRow(2);
+        item00->setText("OnlyOne Last");
+        delegate.count = 0;
+        QApplication::processEvents();
+        QTRY_VERIFY(delegate.count >= 3);
+        QApplication::processEvents();
+    }
 }
 
 class task174627_TreeView : public QTreeView
@@ -3507,7 +3646,35 @@ void tst_QTreeView::task245654_changeModelAndExpandAll()
 
 }
 
+void tst_QTreeView::doubleClickedWithSpans()
+{
+    QTreeView view;
+    QStandardItemModel model(1, 2);
+    view.setModel(&model);
+    view.setFirstColumnSpanned(0, QModelIndex(), true);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QPoint p(10, 10);
+    QCOMPARE(view.indexAt(p), model.index(0, 0));
+    QSignalSpy spy(&view, SIGNAL(doubleClicked(QModelIndex)));
+    QTest::mousePress(view.viewport(), Qt::LeftButton, 0, p);
+    QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, p);
+    QTest::mouseRelease(view.viewport(), Qt::LeftButton, 0, p);
+    QCOMPARE(spy.count(), 1);
 
+    //let's click on the 2nd column
+    p.setX(p.x() + view.header()->sectionSize(0));
+    QCOMPARE(view.indexAt(p), model.index(0, 0));
+
+    //end the previous edition
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p);
+    QTest::qWait(100);
+    QTest::mousePress(view.viewport(), Qt::LeftButton, 0, p);
+    QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, p);
+    QTest::mouseRelease(view.viewport(), Qt::LeftButton, 0, p);
+    QCOMPARE(spy.count(), 2);
+}
 
 QTEST_MAIN(tst_QTreeView)
 #include "tst_qtreeview.moc"
diff --git a/tests/auto/qudpsocket/tst_qudpsocket.cpp b/tests/auto/qudpsocket/tst_qudpsocket.cpp
index 7ea2163..9418be0 100644
--- a/tests/auto/qudpsocket/tst_qudpsocket.cpp
+++ b/tests/auto/qudpsocket/tst_qudpsocket.cpp
@@ -719,6 +719,8 @@ void tst_QUdpSocket::outOfProcessConnectedClientServerTest()
     QProcess serverProcess;
     serverProcess.start(QLatin1String("clientserver/clientserver server 1 1"),
                         QIODevice::ReadWrite | QIODevice::Text);
+    QVERIFY2(serverProcess.waitForStarted(3000),
+             qPrintable("Failed to start subprocess: " + serverProcess.errorString()));
 
     // Wait until the server has started and reports success.
     while (!serverProcess.canReadLine())
@@ -732,6 +734,9 @@ void tst_QUdpSocket::outOfProcessConnectedClientServerTest()
     clientProcess.start(QString::fromLatin1("clientserver/clientserver connectedclient %1 %2")
                         .arg(QLatin1String("127.0.0.1")).arg(serverPort),
                         QIODevice::ReadWrite | QIODevice::Text);
+    QVERIFY2(clientProcess.waitForStarted(3000),
+             qPrintable("Failed to start subprocess: " + clientProcess.errorString()));
+
     // Wait until the server has started and reports success.
     while (!clientProcess.canReadLine())
         QVERIFY(clientProcess.waitForReadyRead(3000));
@@ -779,6 +784,8 @@ void tst_QUdpSocket::outOfProcessUnconnectedClientServerTest()
     QProcess serverProcess;
     serverProcess.start(QLatin1String("clientserver/clientserver server 1 1"),
                         QIODevice::ReadWrite | QIODevice::Text);
+    QVERIFY2(serverProcess.waitForStarted(3000),
+             qPrintable("Failed to start subprocess: " + serverProcess.errorString()));
 
     // Wait until the server has started and reports success.
     while (!serverProcess.canReadLine())
@@ -792,6 +799,9 @@ void tst_QUdpSocket::outOfProcessUnconnectedClientServerTest()
     clientProcess.start(QString::fromLatin1("clientserver/clientserver unconnectedclient %1 %2")
                         .arg(QLatin1String("127.0.0.1")).arg(serverPort),
                         QIODevice::ReadWrite | QIODevice::Text);
+    QVERIFY2(clientProcess.waitForStarted(3000),
+             qPrintable("Failed to start subprocess: " + clientProcess.errorString()));
+
     // Wait until the server has started and reports success.
     while (!clientProcess.canReadLine())
         QVERIFY(clientProcess.waitForReadyRead(3000));
diff --git a/tests/auto/qvariant/tst_qvariant.cpp b/tests/auto/qvariant/tst_qvariant.cpp
index 9295897..3d68a73 100644
--- a/tests/auto/qvariant/tst_qvariant.cpp
+++ b/tests/auto/qvariant/tst_qvariant.cpp
@@ -270,6 +270,8 @@ private slots:
     void task256984_setValue();
 
     void numericalConvert();
+    void moreCustomTypes();
+    void variantInVariant();
 };
 
 Q_DECLARE_METATYPE(QDate)
@@ -318,6 +320,14 @@ void tst_QVariant::constructor()
     QVariant var6(qlonglong(0));
     QCOMPARE(var6.type(), QVariant::LongLong);
     QCOMPARE(var6.typeName(), "qlonglong");
+
+    QVariant var7 = 5;
+    QVERIFY(var7.isValid());
+    QVERIFY(!var7.isNull());
+    QVariant var8;
+    var8.setValue<int>(5);
+    QVERIFY(var8.isValid());
+    QVERIFY(!var8.isNull());
 }
 
 void tst_QVariant::copy_constructor()
@@ -1422,8 +1432,10 @@ void tst_QVariant::matrix4x4()
     QVariant variant;
     QMatrix4x4 matrix = qVariantValue<QMatrix4x4>(variant);
     QVERIFY(matrix.isIdentity());
-    qVariantSetValue(variant, QMatrix4x4().scale(2.0));
-    QCOMPARE(QMatrix4x4().scale(2.0), qVariantValue<QMatrix4x4>(variant));
+    QMatrix4x4 m;
+    m.scale(2.0f);
+    qVariantSetValue(variant, m);
+    QCOMPARE(m, qVariantValue<QMatrix4x4>(variant));
 
     void *mmatrix = QMetaType::construct(QVariant::Matrix4x4, 0);
     QVERIFY(mmatrix);
@@ -3127,7 +3139,254 @@ void tst_QVariant::numericalConvert()
 }
 
 
+template<class T> void playWithVariant(const T &orig, bool isNull, const QString &toString, double toDouble, bool toBool)
+{
+    QVariant v = QVariant::fromValue(orig);
+    QVERIFY(v.isValid());
+    QCOMPARE(v.isNull(), isNull);
+    QCOMPARE(v.toString(), toString);
+    QCOMPARE(v.toDouble(), toDouble);
+    QCOMPARE(v.toBool(), toBool);
+    QCOMPARE(qvariant_cast<T>(v), orig);
+
+    {
+        QVariant v2 = v;
+        QCOMPARE(v2, v);
+        QVERIFY(v2.isValid());
+        QCOMPARE(v2.isNull(), isNull);
+        QCOMPARE(v2.toString(), toString);
+        QCOMPARE(v2.toDouble(), toDouble);
+        QCOMPARE(v2.toBool(), toBool);
+        QCOMPARE(qvariant_cast<T>(v2), orig);
+
+        QVariant v3;
+        v = QVariant();
+        QCOMPARE(v3, v);
+        v = v2;
+        QCOMPARE(v, v2);
+        QCOMPARE(qvariant_cast<T>(v2), qvariant_cast<T>(v));
+        QCOMPARE(v2.toString(), toString);
+        v3 = qVariantFromValue(orig);
+
+        QVERIFY(v3.isValid());
+        QCOMPARE(v3.isNull(), isNull);
+        QCOMPARE(v3.toString(), toString);
+        QCOMPARE(v3.toDouble(), toDouble);
+        QCOMPARE(v3.toBool(), toBool);
+        QCOMPARE(qvariant_cast<T>(v3), qvariant_cast<T>(v));
+    }
+
+    QVERIFY(v.isValid());
+    QCOMPARE(v.isNull(), isNull);
+    QCOMPARE(v.toString(), toString);
+    QCOMPARE(v.toDouble(), toDouble);
+    QCOMPARE(v.toBool(), toBool);
+    QCOMPARE(qvariant_cast<T>(v), orig);
+
+    if (qMetaTypeId<T>() != qMetaTypeId<QVariant>()) {
+        QCOMPARE(v.userType(), qMetaTypeId<T>());
+        QCOMPARE(QVariant::typeToName(QVariant::Type(v.userType())), QMetaType::typeName(qMetaTypeId<T>()));
+    }
+}
+
+
+struct MyPrimitive
+{
+    char x, y;
+    bool operator==(const MyPrimitive &o) const
+    {
+        return x == o.x && y == o.y;
+    }
+};
+Q_DECLARE_TYPEINFO(MyPrimitive, Q_PRIMITIVE_TYPE);
+
+struct MyData
+{
+    void *ptr;
+    MyData() : ptr(this) {}
+    ~MyData() { Q_ASSERT(ptr == this); }
+    MyData(const MyData& o) : ptr(this) { Q_ASSERT(o.ptr == &o); }
+    MyData &operator=(const MyData &o)
+    {
+        Q_ASSERT(ptr == this);
+        Q_ASSERT(o.ptr == &o);
+        return *this;
+    }
+    bool operator==(const MyData &o) const
+    {
+        Q_ASSERT(ptr == this);
+        Q_ASSERT(o.ptr == &o);
+        return true;
+    }
+};
+
+struct MyMovable
+{
+    static int count;
+    int v;
+    MyMovable() { v = count++; }
+    ~MyMovable() { count--; }
+    MyMovable(const MyMovable &o) : v(o.v) { count++; }
+
+    bool operator==(const MyMovable &o) const
+    {
+        return v == o.v;
+    }
+};
+
+int MyMovable::count  = 0;
+
+
+Q_DECLARE_TYPEINFO(MyMovable, Q_MOVABLE_TYPE);
+
+Q_DECLARE_METATYPE(QList<QSize>)
+Q_DECLARE_METATYPE(MyPrimitive)
+Q_DECLARE_METATYPE(MyData)
+Q_DECLARE_METATYPE(MyMovable)
+Q_DECLARE_METATYPE(QList<MyPrimitive>)
+Q_DECLARE_METATYPE(QList<MyData>)
+Q_DECLARE_METATYPE(QList<MyMovable>)
+Q_DECLARE_METATYPE(MyPrimitive *)
+Q_DECLARE_METATYPE(MyData *)
+Q_DECLARE_METATYPE(MyMovable *)
 
 
+void tst_QVariant::moreCustomTypes()
+{
+    {
+        QList<QSize> listSize;
+        playWithVariant(listSize, false, QString(), 0, false);
+        listSize << QSize(4,5) << QSize(89,23) << QSize(5,6);
+        playWithVariant(listSize, false, QString(), 0, false);
+    }
+
+    {
+        QString str;
+        playWithVariant(str, true, QString(), 0, false);
+        str = QString::fromLatin1("123456789.123");
+        playWithVariant(str, false, str, 123456789.123, true);
+    }
+
+    {
+        QSize size;
+        playWithVariant(size, false, QString(), 0, false);
+        playWithVariant(QSize(45,78), false, QString(), 0, false);
+    }
+
+    {
+        MyData d;
+        playWithVariant(d, false, QString(), 0, false);
+        playWithVariant(&d, false, QString(), 0, false);
+        QList<MyData> l;
+        playWithVariant(l, false, QString(), 0, false);
+        l << MyData() << MyData();
+        playWithVariant(l, false, QString(), 0, false);
+    }
+
+    {
+        MyPrimitive d = { 4, 5 };
+        playWithVariant(d, false, QString(), 0, false);
+        playWithVariant(&d, false, QString(), 0, false);
+        QList<MyPrimitive> l;
+        playWithVariant(l, false, QString(), 0, false);
+        l << d;
+        playWithVariant(l, false, QString(), 0, false);
+    }
+
+    {
+        MyMovable d;
+        playWithVariant(d, false, QString(), 0, false);
+        playWithVariant(&d, false, QString(), 0, false);
+        QList<MyMovable> l;
+        playWithVariant(l, false, QString(), 0, false);
+        l << MyMovable() << d;
+        playWithVariant(l, false, QString(), 0, false);
+    }
+    QCOMPARE(MyMovable::count, 0);
+
+    {
+        playWithVariant(12.12, false, "12.12", 12.12, true);
+        playWithVariant(12.12f, false, "12.12", 12.12f, true);
+        playWithVariant('a', false, "a", 'a', true);
+        playWithVariant((unsigned char)('a'), false, "a", 'a', true);
+        playWithVariant( quint8(12), false, "\xc", 12, true);
+        playWithVariant(  qint8(13), false, "\xd", 13, true);
+        playWithVariant(quint16(14), false, "14", 14, true);
+        playWithVariant( qint16(15), false, "15", 15, true);
+        playWithVariant(quint32(16), false, "16", 16, true);
+        playWithVariant( qint32(17), false, "17", 17, true);
+        playWithVariant(quint64(18), false, "18", 18, true);
+        playWithVariant( qint64(19), false, "19", 19, true);
+        playWithVariant(  qint8(-12), false, "\xf4", -12, true);
+        playWithVariant( qint16(-13), false, "-13", -13, true);
+        playWithVariant( qint32(-14), false, "-14", -14, true);
+        playWithVariant( qint64(-15), false, "-15", -15, true);
+        playWithVariant(quint64(0), false, "0", 0, false);
+        playWithVariant( true, false, "true", 1, true);
+        playWithVariant( false, false, "false", 0, false);
+
+        playWithVariant(QString("hello\n"), false, "hello\n", 0, true);
+    }
+
+    {
+        int i = 5;
+        playWithVariant((void *)(&i), false, QString(), 0, false);
+        playWithVariant((void *)(0), false, QString(), 0, false);
+    }
+
+    {
+        QVariant v1 = QVariant::fromValue(5);
+        QVariant v2 = QVariant::fromValue(5.0);
+        QVariant v3 = QVariant::fromValue(quint16(5));
+        QVariant v4 = 5;
+        QVariant v5 = QVariant::fromValue(MyPrimitive());
+        QVariant v6 = QVariant::fromValue(MyMovable());
+        QVariant v7 = QVariant::fromValue(MyData());
+        playWithVariant(v1, false, "5", 5, true);
+        playWithVariant(v2, false, "5", 5, true);
+        playWithVariant(v3, false, "5", 5, true);
+        playWithVariant(v4, false, "5", 5, true);
+
+        playWithVariant(v5, false, QString(), 0, false);
+    }
+}
+
+
+void tst_QVariant::variantInVariant()
+{
+    QVariant var1 = 5;
+    QCOMPARE(var1.type(), QVariant::Int);
+    QVariant var2 = var1;
+    QCOMPARE(var2, var1);
+    QCOMPARE(var2.type(), QVariant::Int);
+    QVariant var3 = QVariant::fromValue(var1);
+    QCOMPARE(var3, var1);
+    QCOMPARE(var3.type(), QVariant::Int);
+    QVariant var4 = qvariant_cast<QVariant>(var1);
+    QCOMPARE(var4, var1);
+    QCOMPARE(var4.type(), QVariant::Int);
+    QVariant var5;
+    var5 = var1;
+    QCOMPARE(var5, var1);
+    QCOMPARE(var5.type(), QVariant::Int);
+    QVariant var6;
+    var6.setValue(var1);
+    QCOMPARE(var6, var1);
+    QCOMPARE(var6.type(), QVariant::Int);
+
+    QCOMPARE(QVariant::fromValue(var1), QVariant::fromValue(var2));
+    QCOMPARE(qvariant_cast<QVariant>(var3), QVariant::fromValue(var4));
+    QCOMPARE(qvariant_cast<QVariant>(var5), qvariant_cast<QVariant>(var6));
+
+    QString str("hello");
+    QVariant var8 = qvariant_cast<QVariant>(QVariant::fromValue(QVariant::fromValue(str)));
+    QCOMPARE((int)var8.type(), (int)QVariant::String);
+    QCOMPARE(qvariant_cast<QString>(QVariant(qvariant_cast<QVariant>(var8))), str);
+
+    QVariant var9(qMetaTypeId<QVariant>(), &var1);
+    QCOMPARE(var9.userType(), qMetaTypeId<QVariant>());
+    QCOMPARE(qvariant_cast<QVariant>(var9), var1);
+}
+
 QTEST_MAIN(tst_QVariant)
 #include "tst_qvariant.moc"
diff --git a/tests/auto/qvideoframe/tst_qvideoframe.cpp b/tests/auto/qvideoframe/tst_qvideoframe.cpp
index b231069..432ef5c 100644
--- a/tests/auto/qvideoframe/tst_qvideoframe.cpp
+++ b/tests/auto/qvideoframe/tst_qvideoframe.cpp
@@ -524,7 +524,7 @@ void tst_QVideoFrame::assign()
 void tst_QVideoFrame::map_data()
 {
     QTest::addColumn<QSize>("size");
-    QTest::addColumn<int>("numBytes");
+    QTest::addColumn<int>("mappedBytes");
     QTest::addColumn<int>("bytesPerLine");
     QTest::addColumn<QVideoFrame::PixelFormat>("pixelFormat");
     QTest::addColumn<QAbstractVideoBuffer::MapMode>("mode");
@@ -554,29 +554,29 @@ void tst_QVideoFrame::map_data()
 void tst_QVideoFrame::map()
 {
     QFETCH(QSize, size);
-    QFETCH(int, numBytes);
+    QFETCH(int, mappedBytes);
     QFETCH(int, bytesPerLine);
     QFETCH(QVideoFrame::PixelFormat, pixelFormat);
     QFETCH(QAbstractVideoBuffer::MapMode, mode);
 
-    QVideoFrame frame(numBytes, size, bytesPerLine, pixelFormat);
+    QVideoFrame frame(mappedBytes, size, bytesPerLine, pixelFormat);
 
     QVERIFY(!frame.bits());
-    QCOMPARE(frame.numBytes(), 0);
+    QCOMPARE(frame.mappedBytes(), 0);
     QCOMPARE(frame.bytesPerLine(), 0);
     QCOMPARE(frame.mapMode(), QAbstractVideoBuffer::NotMapped);
 
     QVERIFY(frame.map(mode));
 
     QVERIFY(frame.bits());
-    QCOMPARE(frame.numBytes(), numBytes);
+    QCOMPARE(frame.mappedBytes(), mappedBytes);
     QCOMPARE(frame.bytesPerLine(), bytesPerLine);
     QCOMPARE(frame.mapMode(), mode);
 
     frame.unmap();
 
     QVERIFY(!frame.bits());
-    QCOMPARE(frame.numBytes(), 0);
+    QCOMPARE(frame.mappedBytes(), 0);
     QCOMPARE(frame.bytesPerLine(), 0);
     QCOMPARE(frame.mapMode(), QAbstractVideoBuffer::NotMapped);
 }
@@ -614,21 +614,21 @@ void tst_QVideoFrame::mapImage()
     QVideoFrame frame(image);
 
     QVERIFY(!frame.bits());
-    QCOMPARE(frame.numBytes(), 0);
+    QCOMPARE(frame.mappedBytes(), 0);
     QCOMPARE(frame.bytesPerLine(), 0);
     QCOMPARE(frame.mapMode(), QAbstractVideoBuffer::NotMapped);
 
     QVERIFY(frame.map(mode));
 
     QVERIFY(frame.bits());
-    QCOMPARE(frame.numBytes(), image.numBytes());
+    QCOMPARE(frame.mappedBytes(), image.numBytes());
     QCOMPARE(frame.bytesPerLine(), image.bytesPerLine());
     QCOMPARE(frame.mapMode(), mode);
 
     frame.unmap();
 
     QVERIFY(!frame.bits());
-    QCOMPARE(frame.numBytes(), 0);
+    QCOMPARE(frame.mappedBytes(), 0);
     QCOMPARE(frame.bytesPerLine(), 0);
     QCOMPARE(frame.mapMode(), QAbstractVideoBuffer::NotMapped);
 }
diff --git a/tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp b/tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp
index 9623e80..a47cb48 100644
--- a/tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp
+++ b/tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp
@@ -68,8 +68,8 @@ private slots:
     void scanLineDirection();
     void frameRate_data();
     void frameRate();
-    void yuvColorSpace_data();
-    void yuvColorSpace();
+    void yCbCrColorSpace_data();
+    void yCbCrColorSpace();
     void pixelAspectRatio_data();
     void pixelAspectRatio();
     void sizeHint_data();
@@ -81,9 +81,6 @@ private slots:
     void assign();
 };
 
-Q_DECLARE_METATYPE(QVideoSurfaceFormat::ViewportMode)
-
-
 tst_QVideoSurfaceFormat::tst_QVideoSurfaceFormat()
 {
 }
@@ -122,7 +119,7 @@ void tst_QVideoSurfaceFormat::constructNull()
     QCOMPARE(format.scanLineDirection(), QVideoSurfaceFormat::TopToBottom);
     QCOMPARE(format.frameRate(), 0.0);
     QCOMPARE(format.pixelAspectRatio(), QSize(1, 1));
-    QCOMPARE(format.yuvColorSpace(), QVideoSurfaceFormat::YCbCr_Undefined);
+    QCOMPARE(format.yCbCrColorSpace(), QVideoSurfaceFormat::YCbCr_Undefined);
 }
 
 void tst_QVideoSurfaceFormat::construct_data()
@@ -161,7 +158,7 @@ void tst_QVideoSurfaceFormat::construct()
     QCOMPARE(format.scanLineDirection(), QVideoSurfaceFormat::TopToBottom);
     QCOMPARE(format.frameRate(), 0.0);
     QCOMPARE(format.pixelAspectRatio(), QSize(1, 1));
-    QCOMPARE(format.yuvColorSpace(), QVideoSurfaceFormat::YCbCr_Undefined);
+    QCOMPARE(format.yCbCrColorSpace(), QVideoSurfaceFormat::YCbCr_Undefined);
 }
 
 void tst_QVideoSurfaceFormat::frameSize_data()
@@ -202,45 +199,23 @@ void tst_QVideoSurfaceFormat::viewport_data()
     QTest::addColumn<QSize>("initialSize");
     QTest::addColumn<QRect>("viewport");
     QTest::addColumn<QSize>("newSize");
-    QTest::addColumn<QVideoSurfaceFormat::ViewportMode>("viewportMode");
     QTest::addColumn<QRect>("expectedViewport");
 
     QTest::newRow("grow reset")
             << QSize(64, 64)
             << QRect(8, 8, 48, 48)
             << QSize(1024, 1024)
-            << QVideoSurfaceFormat::ResetViewport
             << QRect(0, 0, 1024, 1024);
-    QTest::newRow("grow keep")
-            << QSize(64, 64)
-            << QRect(8, 8, 48, 48)
-            << QSize(1024, 1024)
-            << QVideoSurfaceFormat::KeepViewport
-            << QRect(8, 8, 48, 48);
     QTest::newRow("shrink reset")
             << QSize(1024, 1024)
             << QRect(8, 8, 1008, 1008)
             << QSize(64, 64)
-            << QVideoSurfaceFormat::ResetViewport
             << QRect(0, 0, 64, 64);
-    QTest::newRow("shrink keep")
-            << QSize(1024, 1024)
-            << QRect(8, 8, 1008, 1008)
-            << QSize(64, 64)
-            << QVideoSurfaceFormat::KeepViewport
-            << QRect(8, 8, 56, 56);
     QTest::newRow("unchanged reset")
             << QSize(512, 512)
             << QRect(8, 8, 496, 496)
             << QSize(512, 512)
-            << QVideoSurfaceFormat::ResetViewport
             << QRect(0, 0, 512, 512);
-    QTest::newRow("unchanged keep")
-            << QSize(512, 512)
-            << QRect(8, 8, 496, 496)
-            << QSize(512, 512)
-            << QVideoSurfaceFormat::KeepViewport
-            << QRect(8, 8, 496, 496);
 }
 
 void tst_QVideoSurfaceFormat::viewport()
@@ -248,7 +223,6 @@ void tst_QVideoSurfaceFormat::viewport()
     QFETCH(QSize, initialSize);
     QFETCH(QRect, viewport);
     QFETCH(QSize, newSize);
-    QFETCH(QVideoSurfaceFormat::ViewportMode, viewportMode);
     QFETCH(QRect, expectedViewport);
 
     {
@@ -261,7 +235,7 @@ void tst_QVideoSurfaceFormat::viewport()
         QCOMPARE(format.viewport(), viewport);
         QCOMPARE(format.property("viewport").toRect(), viewport);
 
-        format.setFrameSize(newSize, viewportMode);
+        format.setFrameSize(newSize);
 
         QCOMPARE(format.viewport(), expectedViewport);
         QCOMPARE(format.property("viewport").toRect(), expectedViewport);
@@ -350,9 +324,9 @@ void tst_QVideoSurfaceFormat::frameRate()
     }
 }
 
-void tst_QVideoSurfaceFormat::yuvColorSpace_data()
+void tst_QVideoSurfaceFormat::yCbCrColorSpace_data()
 {
-    QTest::addColumn<QVideoSurfaceFormat::YuvColorSpace>("colorspace");
+    QTest::addColumn<QVideoSurfaceFormat::YCbCrColorSpace>("colorspace");
 
     QTest::newRow("undefined")
             << QVideoSurfaceFormat::YCbCr_Undefined;
@@ -364,24 +338,24 @@ void tst_QVideoSurfaceFormat::yuvColorSpace_data()
             << QVideoSurfaceFormat::YCbCr_JPEG;
 }
 
-void tst_QVideoSurfaceFormat::yuvColorSpace()
+void tst_QVideoSurfaceFormat::yCbCrColorSpace()
 {
-    QFETCH(QVideoSurfaceFormat::YuvColorSpace, colorspace);
+    QFETCH(QVideoSurfaceFormat::YCbCrColorSpace, colorspace);
 
     {
         QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
-        format.setYuvColorSpace(colorspace);
+        format.setYCbCrColorSpace(colorspace);
 
-        QCOMPARE(format.yuvColorSpace(), colorspace);
-        QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YuvColorSpace>(format.property("yuvColorSpace")),
+        QCOMPARE(format.yCbCrColorSpace(), colorspace);
+        QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YCbCrColorSpace>(format.property("yCbCrColorSpace")),
                 colorspace);
     }
     {
         QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
-        format.setProperty("yuvColorSpace", qVariantFromValue(colorspace));
+        format.setProperty("yCbCrColorSpace", qVariantFromValue(colorspace));
 
-        QCOMPARE(format.yuvColorSpace(), colorspace);
-        QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YuvColorSpace>(format.property("yuvColorSpace")),
+        QCOMPARE(format.yCbCrColorSpace(), colorspace);
+        QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YCbCrColorSpace>(format.property("yCbCrColorSpace")),
                 colorspace);
     }
 }
@@ -483,7 +457,7 @@ void tst_QVideoSurfaceFormat::staticPropertyNames()
     QVERIFY(propertyNames.contains("scanLineDirection"));
     QVERIFY(propertyNames.contains("frameRate"));
     QVERIFY(propertyNames.contains("pixelAspectRatio"));
-    QVERIFY(propertyNames.contains("yuvColorSpace"));
+    QVERIFY(propertyNames.contains("yCbCrColorSpace"));
     QVERIFY(propertyNames.contains("sizeHint"));
     QCOMPARE(propertyNames.count(), 10);
 }
@@ -566,19 +540,26 @@ void tst_QVideoSurfaceFormat::compare()
     QCOMPARE(format1 == format4, false);
     QCOMPARE(format1 != format4, true);
 
-    format2.setFrameSize(1024, 768, QVideoSurfaceFormat::ResetViewport);
+    format2.setFrameSize(1024, 768);
 
     // Not equal, frame size differs.
     QCOMPARE(format1 == format2, false);
     QCOMPARE(format1 != format2, true);
 
-    format1.setFrameSize(1024, 768, QVideoSurfaceFormat::KeepViewport);
+    format1.setFrameSize(1024, 768);
+
+    // Equal.
+    QCOMPARE(format1 == format2, true);
+    QCOMPARE(format1 != format2, false);
+
+    format1.setViewport(QRect(0, 0, 800, 600));
+    format2.setViewport(QRect(112, 84, 800, 600));
 
-    // Not equal, viewport differs.
+    // Not equal, viewports differ.
     QCOMPARE(format1 == format2, false);
     QCOMPARE(format1 != format2, true);
 
-    format1.setViewport(QRect(0, 0, 1024, 768));
+    format1.setViewport(QRect(112, 84, 800, 600));
 
     // Equal.
     QCOMPARE(format1 == format2, true);
@@ -620,13 +601,13 @@ void tst_QVideoSurfaceFormat::compare()
     QCOMPARE(format1 == format2, true);
     QCOMPARE(format1 != format2, false);
 
-    format2.setYuvColorSpace(QVideoSurfaceFormat::YCbCr_xvYCC601);
+    format2.setYCbCrColorSpace(QVideoSurfaceFormat::YCbCr_xvYCC601);
 
     // Not equal yuv color space differs.
     QCOMPARE(format1 == format2, false);
     QCOMPARE(format1 != format2, true);
 
-    format1.setYuvColorSpace(QVideoSurfaceFormat::YCbCr_xvYCC601);
+    format1.setYCbCrColorSpace(QVideoSurfaceFormat::YCbCr_xvYCC601);
 
     // Equal.
     QCOMPARE(format1 == format2, true);
diff --git a/tests/auto/qwidget/tst_qwidget.cpp b/tests/auto/qwidget/tst_qwidget.cpp
index 3595b84..3d801cc 100644
--- a/tests/auto/qwidget/tst_qwidget.cpp
+++ b/tests/auto/qwidget/tst_qwidget.cpp
@@ -332,6 +332,7 @@ private slots:
     void doubleRepaint();
 #ifndef Q_WS_MAC
     void resizeInPaintEvent();
+    void opaqueChildren();
 #endif
 
     void setMaskInResizeEvent();
@@ -8275,6 +8276,47 @@ void tst_QWidget::resizeInPaintEvent()
     // Make sure the resize triggers another update.
     QTRY_COMPARE(widget.numPaintEvents, 1);
 }
+
+void tst_QWidget::opaqueChildren()
+{
+    QWidget widget;
+    widget.resize(200, 200);
+
+    QWidget child(&widget);
+    child.setGeometry(-700, -700, 200, 200);
+
+    QWidget grandChild(&child);
+    grandChild.resize(200, 200);
+
+    QWidget greatGrandChild(&grandChild);
+    greatGrandChild.setGeometry(50, 50, 200, 200);
+    greatGrandChild.setPalette(Qt::red);
+    greatGrandChild.setAutoFillBackground(true); // Opaque child widget.
+
+    widget.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&widget);
+#endif
+    QTest::qWait(100);
+
+    // Child, grandChild and greatGrandChild are outside the ancestor clip.
+    QRegion expectedOpaqueRegion(50, 50, 150, 150);
+    QCOMPARE(qt_widget_private(&grandChild)->getOpaqueChildren(), expectedOpaqueRegion);
+
+    // Now they are all inside the ancestor clip.
+    child.setGeometry(50, 50, 150, 150);
+    QCOMPARE(qt_widget_private(&grandChild)->getOpaqueChildren(), expectedOpaqueRegion);
+
+    // Set mask on greatGrandChild.
+    const QRegion mask(10, 10, 50, 50);
+    greatGrandChild.setMask(mask);
+    expectedOpaqueRegion &= mask.translated(50, 50);
+    QCOMPARE(qt_widget_private(&grandChild)->getOpaqueChildren(), expectedOpaqueRegion);
+
+    // Make greatGrandChild "transparent".
+    greatGrandChild.setAutoFillBackground(false);
+    QCOMPARE(qt_widget_private(&grandChild)->getOpaqueChildren(), QRegion());
+}
 #endif
 
 
diff --git a/tests/auto/qxmlnodemodelindex/tst_qxmlnodemodelindex.cpp b/tests/auto/qxmlnodemodelindex/tst_qxmlnodemodelindex.cpp
index cb6bd4d..c19deb6 100644
--- a/tests/auto/qxmlnodemodelindex/tst_qxmlnodemodelindex.cpp
+++ b/tests/auto/qxmlnodemodelindex/tst_qxmlnodemodelindex.cpp
@@ -178,7 +178,7 @@ void tst_QXmlNodeModelIndex::model() const
     /* Check default value. */
     {
         const QXmlNodeModelIndex index;
-        QCOMPARE(index.model(), static_cast<void *>(0));
+        QCOMPARE(index.model(), static_cast<const QAbstractXmlNodeModel *>(0));
     }
 }
 
diff --git a/tests/auto/qxmlquery/tst_qxmlquery.cpp b/tests/auto/qxmlquery/tst_qxmlquery.cpp
index 8a9d4ef..49f2b08 100644
--- a/tests/auto/qxmlquery/tst_qxmlquery.cpp
+++ b/tests/auto/qxmlquery/tst_qxmlquery.cpp
@@ -345,8 +345,8 @@ void tst_QXmlQuery::copyConstructor() const
         query1.setInitialTemplateName(name);
 
         const QXmlQuery query2(query1);
-        QCOMPARE(query2.messageHandler(), &silencer);
-        QCOMPARE(query2.uriResolver(), &resolver);
+        QCOMPARE(query2.messageHandler(), static_cast<QAbstractMessageHandler *>(&silencer));
+        QCOMPARE(query2.uriResolver(), static_cast<const QAbstractUriResolver *>(&resolver));
         QCOMPARE(query2.queryLanguage(), QXmlQuery::XSLT20);
         QCOMPARE(query2.initialTemplateName(), name);
         QCOMPARE(query2.networkAccessManager(), &networkManager);
@@ -522,7 +522,7 @@ void tst_QXmlQuery::assignmentOperator() const
 
             QVERIFY(copy.isValid());
             QCOMPARE(copy.uriResolver(), static_cast<const QAbstractUriResolver *>(&returnURI));
-            QCOMPARE(copy.messageHandler(), &silencer);
+            QCOMPARE(copy.messageHandler(), static_cast<QAbstractMessageHandler *>(&silencer));
             QCOMPARE(testName.localName(copy.namePool()), QString::fromLatin1("somethingToCheck"));
 
             QXmlResultItems result;
@@ -559,7 +559,7 @@ void tst_QXmlQuery::assignmentOperator() const
                 /* Check that the copy picked up the new things. */
                 QVERIFY(copy.isValid());
                 QCOMPARE(copy.uriResolver(), static_cast<const QAbstractUriResolver *>(&secondUriResolver));
-                QCOMPARE(copy.messageHandler(), &secondSilencer);
+                QCOMPARE(copy.messageHandler(), static_cast<QAbstractMessageHandler *>(&secondSilencer));
 
                 QXmlResultItems resultCopy;
                 copy.evaluateTo(&resultCopy);
@@ -577,7 +577,7 @@ void tst_QXmlQuery::assignmentOperator() const
                 /* Check that the original is unchanged. */
                 QVERIFY(original.isValid());
                 QCOMPARE(original.uriResolver(), static_cast<const QAbstractUriResolver *>(&returnURI));
-                QCOMPARE(original.messageHandler(), &silencer);
+                QCOMPARE(original.messageHandler(), static_cast<QAbstractMessageHandler *>(&silencer));
 
                 QXmlResultItems resultOriginal;
                 original.evaluateTo(&resultOriginal);
@@ -931,7 +931,7 @@ void tst_QXmlQuery::setMessageHandler() const
     QXmlQuery query;
     MessageSilencer silencer;
     query.setMessageHandler(&silencer);
-    QCOMPARE(&silencer, query.messageHandler());
+    QCOMPARE(static_cast<QAbstractMessageHandler *>(&silencer), query.messageHandler());
 }
 
 void tst_QXmlQuery::evaluateToReceiver()
@@ -1691,7 +1691,7 @@ void tst_QXmlQuery::setUriResolver() const
         TestURIResolver resolver;
         QXmlQuery query;
         query.setUriResolver(&resolver);
-        QCOMPARE(query.uriResolver(), &resolver);
+        QCOMPARE(query.uriResolver(), static_cast<const QAbstractUriResolver *>(&resolver));
     }
 }
 
diff --git a/tests/auto/qxmlschema/tst_qxmlschema.cpp b/tests/auto/qxmlschema/tst_qxmlschema.cpp
index 79f5587..ec91f88 100644
--- a/tests/auto/qxmlschema/tst_qxmlschema.cpp
+++ b/tests/auto/qxmlschema/tst_qxmlschema.cpp
@@ -357,7 +357,7 @@ void tst_QXmlSchema::messageHandler() const
 
         QXmlSchema schema;
         schema.setMessageHandler(&handler);
-        QCOMPARE(schema.messageHandler(), &handler);
+        QCOMPARE(schema.messageHandler(), static_cast<QAbstractMessageHandler *>(&handler));
     }
 }
 
@@ -394,7 +394,7 @@ void tst_QXmlSchema::uriResolver() const
 
         QXmlSchema schema;
         schema.setUriResolver(&resolver);
-        QCOMPARE(schema.uriResolver(), &resolver);
+        QCOMPARE(schema.uriResolver(), static_cast<const QAbstractUriResolver *>(&resolver));
     }
 }
 
diff --git a/tests/auto/qxmlschemavalidator/tst_qxmlschemavalidator.cpp b/tests/auto/qxmlschemavalidator/tst_qxmlschemavalidator.cpp
index 519f864..9fc784b 100644
--- a/tests/auto/qxmlschemavalidator/tst_qxmlschemavalidator.cpp
+++ b/tests/auto/qxmlschemavalidator/tst_qxmlschemavalidator.cpp
@@ -149,8 +149,8 @@ void tst_QXmlSchemaValidator::propertyInitialization() const
         schema.setNetworkAccessManager(&manager);
 
         QXmlSchemaValidator validator(schema);
-        QCOMPARE(validator.messageHandler(), &handler);
-        QCOMPARE(validator.uriResolver(), &resolver);
+        QCOMPARE(validator.messageHandler(), static_cast<QAbstractMessageHandler *>(&handler));
+        QCOMPARE(validator.uriResolver(), static_cast<const QAbstractUriResolver *>(&resolver));
         QCOMPARE(validator.networkAccessManager(), &manager);
     }
 }
@@ -384,7 +384,7 @@ void tst_QXmlSchemaValidator::messageHandler() const
         QXmlSchemaValidator validator(schema);
 
         validator.setMessageHandler(&handler);
-        QCOMPARE(validator.messageHandler(), &handler);
+        QCOMPARE(validator.messageHandler(), static_cast<QAbstractMessageHandler *>(&handler));
     }
 
     /* Test that we return the message handler that was set, even if the schema changed in between. */
@@ -399,7 +399,7 @@ void tst_QXmlSchemaValidator::messageHandler() const
         const QXmlSchema schema2;
         validator.setSchema(schema2);
 
-        QCOMPARE(validator.messageHandler(), &handler);
+        QCOMPARE(validator.messageHandler(), static_cast<QAbstractMessageHandler *>(&handler));
     }
 }
 
@@ -452,7 +452,7 @@ void tst_QXmlSchemaValidator::uriResolver() const
         QXmlSchemaValidator validator(schema);
 
         validator.setUriResolver(&resolver);
-        QCOMPARE(validator.uriResolver(), &resolver);
+        QCOMPARE(validator.uriResolver(), static_cast<const QAbstractUriResolver *>(&resolver));
     }
 
     /* Test that we return the uri resolver that was set, even if the schema changed in between. */
@@ -467,7 +467,7 @@ void tst_QXmlSchemaValidator::uriResolver() const
         const QXmlSchema schema2;
         validator.setSchema(schema2);
 
-        QCOMPARE(validator.uriResolver(), &resolver);
+        QCOMPARE(validator.uriResolver(), static_cast<const QAbstractUriResolver *>(&resolver));
     }
 }
 
diff --git a/tests/auto/qxmlserializer/tst_qxmlserializer.cpp b/tests/auto/qxmlserializer/tst_qxmlserializer.cpp
index aeca140..51044ff 100644
--- a/tests/auto/qxmlserializer/tst_qxmlserializer.cpp
+++ b/tests/auto/qxmlserializer/tst_qxmlserializer.cpp
@@ -148,7 +148,7 @@ void tst_QXmlSerializer::outputDevice() const
     {
         const QXmlQuery query;
         const QXmlSerializer serializer(query, &file);
-        QCOMPARE(serializer.outputDevice(), &file);
+        QCOMPARE(serializer.outputDevice(), static_cast< QIODevice *>(&file));
     }
 }
 
@@ -158,7 +158,7 @@ void tst_QXmlSerializer::serializationError() const
     QXmlQuery query;
     MessageSilencer silencer;
     query.setMessageHandler(&silencer);
-    
+
     query.setQuery(queryString);
 
     QByteArray output;
diff --git a/tests/auto/xmlpatterns.pri b/tests/auto/xmlpatterns.pri
index 7cdd67f..8c8ccad 100644
--- a/tests/auto/xmlpatterns.pri
+++ b/tests/auto/xmlpatterns.pri
@@ -15,8 +15,9 @@ QT -= gui
 
 XMLPATTERNS_SDK = QtXmlPatternsSDK
 if(!debug_and_release|build_pass):CONFIG(debug, debug|release) {
-    win32:XMLPATTERNS_SDK = $${XMLPATTERNS_SDK}d
-    else: XMLPATTERNS_SDK = $${XMLPATTERNS_SDK}_debug
+    symbian:    XMLPATTERNS_SDK = $${XMLPATTERNS_SDK}
+    else:win32: XMLPATTERNS_SDK = $${XMLPATTERNS_SDK}d
+    else:       XMLPATTERNS_SDK = $${XMLPATTERNS_SDK}_debug
 }
 
 INCLUDEPATH += \
diff --git a/tests/auto/xmlpatterns/tst_xmlpatterns.cpp b/tests/auto/xmlpatterns/tst_xmlpatterns.cpp
index 0dcb070..22f6693 100644
--- a/tests/auto/xmlpatterns/tst_xmlpatterns.cpp
+++ b/tests/auto/xmlpatterns/tst_xmlpatterns.cpp
@@ -48,6 +48,10 @@
 #include "../qxmlquery/TestFundament.h"
 #include "../network-settings.h"
 
+#if defined(Q_OS_SYMBIAN)
+#define SRCDIR ""
+#endif
+
 /*!
  \class tst_XmlPatterns
  \internal
@@ -130,6 +134,8 @@ void tst_XmlPatterns::xquerySupport()
 
 #ifdef Q_OS_WINCE
     QSKIP("WinCE: This test uses unsupported WinCE functionality", SkipAll);
+#elif defined(Q_OS_SYMBIAN)
+    QSKIP("Symbian: This test uses unsupported Symbian functionality (QProcess with std streams)", SkipAll);
 #endif
 
     QFETCH(int,         expectedExitCode);
@@ -218,7 +224,7 @@ void tst_XmlPatterns::xquerySupport()
 
 void tst_XmlPatterns::xquerySupport_data() const
 {
-#ifdef Q_OS_WINCE
+#if defined(Q_OS_WINCE) || defined(Q_OS_SYMBIAN)
     return;
 #endif
 
@@ -849,6 +855,8 @@ void tst_XmlPatterns::xsltSupport_data() const
 
 #ifdef Q_OS_WINCE
     QSKIP("WinCE: This test uses unsupported WinCE functionality", SkipAll);
+#elif defined(Q_OS_SYMBIAN)
+    QSKIP("Symbian: This test uses unsupported Symbian functionality (QProcess with std streams)", SkipAll);
 #endif
 
     QTest::addColumn<int>("expectedExitCode");
diff --git a/tests/auto/xmlpatterns/xmlpatterns.pro b/tests/auto/xmlpatterns/xmlpatterns.pro
index 01e3b2b..54dd9aa 100644
--- a/tests/auto/xmlpatterns/xmlpatterns.pro
+++ b/tests/auto/xmlpatterns/xmlpatterns.pro
@@ -2,10 +2,10 @@ load(qttest_p4)
 SOURCES += tst_xmlpatterns.cpp \
            ../qxmlquery/TestFundament.cpp
 
-!wince* {
-DEFINES += SRCDIR=\\\"$$PWD/\\\"
-} else {
+wince* {
 DEFINES += SRCDIR=\\\"./\\\"
+} else:!symbian {
+DEFINES += SRCDIR=\\\"$$PWD/\\\"
 }
 
 include (../xmlpatterns.pri)
diff --git a/tests/auto/xmlpatternsdiagnosticsts/test/test.pro b/tests/auto/xmlpatternsdiagnosticsts/test/test.pro
index aeff896..acd71e4 100644
--- a/tests/auto/xmlpatternsdiagnosticsts/test/test.pro
+++ b/tests/auto/xmlpatternsdiagnosticsts/test/test.pro
@@ -25,8 +25,8 @@ INCLUDEPATH += $$(QTSRCDIR)/tests/auto/xmlpatternsxqts/lib/ \
                ../../xmlpatternsxqts/test                   \
                ../../xmlpatternsxqts/lib
 
-wince*: {
-   catalog.sources = TestSuite Baseline.xml
+wince*|symbian {
+   catalog.sources = ../TestSuite ../Baseline.xml
    catalog.path = .
    DEPLOYMENT += catalog
 }
diff --git a/tests/auto/xmlpatternsschemats/xmlpatternsschemats.pro b/tests/auto/xmlpatternsschemats/xmlpatternsschemats.pro
index bcc988a..0f55078 100644
--- a/tests/auto/xmlpatternsschemats/xmlpatternsschemats.pro
+++ b/tests/auto/xmlpatternsschemats/xmlpatternsschemats.pro
@@ -11,8 +11,9 @@ SOURCES += ../xmlpatternsxqts/test/tst_suitetest.cpp
 
 PATTERNIST_SDK = QtXmlPatternsSDK
 if(!debug_and_release|build_pass):CONFIG(debug, debug|release) {
-    win32:PATTERNIST_SDK = $${PATTERNIST_SDK}d
-    else: PATTERNIST_SDK = $${PATTERNIST_SDK}_debug
+    symbian:    PATTERNIST_SDK = $${PATTERNIST_SDK}
+    else:win32: PATTERNIST_SDK = $${PATTERNIST_SDK}d
+    else:       PATTERNIST_SDK = $${PATTERNIST_SDK}_debug
 }
 
 LIBS += -l$$PATTERNIST_SDK
diff --git a/tests/auto/xmlpatternsxqts/lib/Global.h b/tests/auto/xmlpatternsxqts/lib/Global.h
index eadb940..a620417 100644
--- a/tests/auto/xmlpatternsxqts/lib/Global.h
+++ b/tests/auto/xmlpatternsxqts/lib/Global.h
@@ -47,7 +47,7 @@
 #include "private/qitem_p.h"
 #include "private/qnamepool_p.h"
 
-#ifdef Q_WS_WIN
+#if defined(Q_WS_WIN) || defined(Q_OS_SYMBIAN)
 #   ifdef Q_PATTERNISTSDK_BUILDING
         #define Q_PATTERNISTSDK_EXPORT __declspec(dllexport)
     #else
diff --git a/tests/auto/xmlpatternsxqts/lib/lib.pro b/tests/auto/xmlpatternsxqts/lib/lib.pro
index cb9453a..f5b0a06 100644
--- a/tests/auto/xmlpatternsxqts/lib/lib.pro
+++ b/tests/auto/xmlpatternsxqts/lib/lib.pro
@@ -13,6 +13,12 @@ mac {
     INSTALLS += target
 }
 
+symbian {
+    TARGET.EPOCALLOWDLLDATA=1
+    TARGET.CAPABILITY = All -Tcb
+    MMP_RULES += EXPORTUNFROZEN
+}
+
 # We add gui, because xmlpatterns.pri pull it out.
 QT      += xmlpatterns xml network testlib gui
 
diff --git a/tests/benchmarks/qmatrix4x4/tst_qmatrix4x4.cpp b/tests/benchmarks/qmatrix4x4/tst_qmatrix4x4.cpp
index 71f45ff..f80b579 100644
--- a/tests/benchmarks/qmatrix4x4/tst_qmatrix4x4.cpp
+++ b/tests/benchmarks/qmatrix4x4/tst_qmatrix4x4.cpp
@@ -220,7 +220,7 @@ void tst_QMatrix4x4::mapVector3D()
     QVector3D v(10.5f, -2.0f, 3.0f);
     QVector3D result;
 
-    m1.inferSpecialType();
+    m1.optimize();
 
     QBENCHMARK {
         result = m1 * v;
@@ -244,7 +244,7 @@ void tst_QMatrix4x4::mapVector2D()
     QPointF v(10.5f, -2.0f);
     QPointF result;
 
-    m1.inferSpecialType();
+    m1.optimize();
 
     QBENCHMARK {
         result = m1 * v;
diff --git a/tests/manual/textrendering/glyphshaping/glyphshaping.pro b/tests/manual/textrendering/glyphshaping/glyphshaping.pro
new file mode 100644
index 0000000..caa9028
--- /dev/null
+++ b/tests/manual/textrendering/glyphshaping/glyphshaping.pro
@@ -0,0 +1,5 @@
+SOURCES = main.cpp
+OTHER_FILES = glyphshaping_data.xml
+glyphshaping_data.path = .
+glyphshaping_data.sources = $$PWD/glyphshaping_data.xml
+DEPLOYMENT += glyphshaping_data
diff --git a/tests/manual/textrendering/glyphshaping/glyphshaping_data.xml b/tests/manual/textrendering/glyphshaping/glyphshaping_data.xml
new file mode 100644
index 0000000..040804e
--- /dev/null
+++ b/tests/manual/textrendering/glyphshaping/glyphshaping_data.xml
@@ -0,0 +1,251 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<shapingtests>
+
+    <language name="Vietnamese">
+        <test
+            name="capital U, combining horn"
+            inpututf16="0x0055, 0x031B"
+            outpututf16="0x01AF"
+        />
+        <test
+            name="capital U, apostrophe"
+            inpututf16="0x0055, 0x0027"
+            outpututf16="0x0055"
+        />
+        <test
+            name="capital U, modifier prime"
+            inpututf16="0x0055, 0x02B9"
+            outpututf16="0x0055"
+        />
+        <test
+            name="capital U, modifier apostrophe"
+            inpututf16="0x0055, 0x02BC"
+            outpututf16="0x0055"
+        />
+        <test
+            name="capital U, combining comma above right"
+            inpututf16="0x0055, 0x0315"
+            outpututf16="0x0055, 0x0315"
+        />
+        <test
+            name="capital U, right single quote mark"
+            inpututf16="0x0055, 0x2019"
+            outpututf16="0x0055"
+        />
+        <test
+            name="capital U with horn, space"
+            inpututf16="0x01AF, 0x0020"
+            outpututf16="0x01AF"
+        />
+        <test
+            name="capital E, combining horn"
+            inpututf16="0x0045, 0x031B"
+            outpututf16="0x0045, 0x031B"
+        />
+        <test
+            name="capital A, combining breve, combining acute"
+            inpututf16="0x0041, 0x0306, 0x0301"
+            outpututf16="0x1EAE"
+        />
+        <test
+            name="capital A with breve, combining acute"
+            inpututf16="0x0102, 0x0301"
+            outpututf16="0x1EAE"
+        />
+        <test
+            name="capital A, combining acute, combining breve"
+            inpututf16="0x0041, 0x0301, 0x0306"
+            outpututf16="0x0041, 0x0301, 0x0306"
+        />
+        <test
+            name="capital A, combining dot below, combining breve"
+            inpututf16="0x0041, 0x0323"
+            outpututf16="0x0306"
+        />
+        <test
+            name="capital A with dot below, combining breve"
+            inpututf16="0x1EA0, 0x0306"
+            outpututf16="0x1EB6"
+        />
+        <test
+            name="capital A with breve, combining dot below"
+            inpututf16="0x0102, 0x0323"
+            outpututf16="0x0102, 0x0323"
+        />
+        <test
+            name="capital E, combining circumflex, combining acute"
+            inpututf16="0x0045, 0x0302, 0x0301"
+            outpututf16="0x1EBE"
+        />
+        <test
+            name="capital E with circumflex, combining acute"
+            inpututf16="0x00CA, 0x0301"
+            outpututf16="0x1EBE"
+        />
+        <test
+            name="capital O, combining horn, combining hook above"
+            inpututf16="0x004F, 0x031B, 0x0309"
+            outpututf16="0x1EDE"
+        />
+        <test
+            name="capital O with horn, combining hook above"
+            inpututf16="0x01A0, 0x0309"
+            outpututf16="0x1EDE"
+        />
+    </language>
+
+    <language name="Tamil">
+        <test
+            name="Tamil Ka"
+            inpututf16="0x0B95"
+            outputglyphids="0x0bf6"
+        />
+        <test
+            name="Tamil e"
+            inpututf16="0x0B8E"
+            outputglyphids="0x0bf0"
+        />
+        <test
+            name="Latin A"
+            inpututf16="0x0061"
+            outpututf16="0x0061"
+        />
+        <test
+            name="Hindi Ka"
+            inpututf16="0x0905"
+            outputglyphids="0x0528"
+        />
+        <test
+            name="03 - 1: Latin 06"
+            inpututf16="0x0036"
+            outputglyphids="0x077A"
+        />
+        <test
+            name="03 - 2: Tamil 06"
+            inpututf16="0x0BEC"
+            outputglyphids="0x0c20"
+        />
+        <test
+            name="10 1.3.6 - 1: Pa, Virama, Ka, Virama, Tta, -e"
+            inpututf16="0x0BAA, 0x0BCD, 0x0B95, 0x0BCD, 0x0B9F, 0x0BC7"
+            outputglyphids="0x0c3a, 0x0c30, 0x0c13, 0x0bfb"
+        />
+        <test
+            name="10 1.3.6 - 2: Pa, Virama, Ka, AU"
+            inpututf16="0x0BAA, 0x0BCD, 0x0B95, 0x0BCC"
+            outputglyphids="0x0c3a, 0x0c12, 0x0bf6, 0x0c19"
+        />
+        <test
+            name="10 1.3.6 - 3: Ka, Virama, Ssa, OO"
+            inpututf16="0x0B95, 0x0BCD, 0x0BB7, 0x0BCB"
+            outputglyphids="0x0c13, 0x0c2f, 0x0c0d"
+        />
+        <test
+            name="11: Ka, -e"
+            inpututf16="0x0B95, 0x0BC7"
+            outputglyphids="0x0c13, 0x0bf6"
+        />
+        <test
+            name="12 1.3.5.2: Ka, O"
+            inpututf16="0x0B95, 0x0BCA"
+            outputglyphids="0x0c12, 0x0bf6, 0x0c0d"
+        />
+        <test
+            name="13 - 1: Ka"
+            inpututf16="0x0B95"
+            outputglyphids="0x0bf6"
+        />
+        <test
+            name="13 - 2: Aythem, A"
+            inpututf16="0x0B83, 0x0B85"
+        />
+        <test
+            name="14 - 1: Ka, Anusvara"
+            inpututf16="0x0B95, 0x0B82"
+            outputglyphids="0x0bf6, 0x0be8"
+        />
+        <test
+            name="14 - 2: Ka"
+            inpututf16="0x0B95"
+            outputglyphids="0x0bf6"
+        />
+        <test
+            name="15 - 1: Ra, Virama"
+            inpututf16="0x0BB0, 0x0BCD"
+            outputglyphids="0x0c03"
+        />
+        <test
+            name="15 - 2: ZWJ"
+            inpututf16="0x8205"
+        />
+        <test
+            name="16: Ka, Anusvara"
+            inpututf16="0x0B95, 0x0B82"
+            outputglyphids="0x0bf6"
+        />
+        <test
+            name="17 1.3.11 - 1: Tta, I"
+            inpututf16="0x0B9F, 0x0BBF"
+            outputglyphids="0x0c51"
+        />
+        <test
+            name="17 1.3.11 - 2: Tta, Ii"
+            inpututf16="0x0B9F, 0x0BC0"
+            outputglyphids="0x0c52"
+        />
+        <test
+            name="18 - 1: Ra, I"
+            inpututf16="0x0BB0, 0x0BBF"
+            outputglyphids="0x0c0d, 0x0c0e"
+        />
+        <test
+            name="18 - 2: Ra, Ii"
+            inpututf16="0x0BB0, 0x0BC0"
+            outputglyphids="0x0c0d, 0x0c0f"
+        />
+        <test
+            name="19 - 1: Nga, I"
+            inpututf16="0x0B99, 0x0BBF"
+            outputglyphids="0x0bf7, 0x0c0e"
+        />
+        <test
+            name="19 - 2: Nga, Ii"
+            inpututf16="0x0B99, 0x0BC0"
+            outputglyphids="0x0c4a"
+        />
+        <test
+            name="20 - 1: Ja, U"
+            inpututf16="0x0B9C, 0x0BC1"
+            outputglyphids="0x0bf9, 0x0c10"
+        />
+        <test
+            name="20 - 2: Ja, Uu"
+            inpututf16="0x0B9C, 0x0BC2"
+            outputglyphids="0x0bf9, 0x0c11"
+        />
+        <test
+            name="21 1.3.15: Ka, Ai"
+            inpututf16="0x0B95, 0x0BC8"
+            outputglyphids="0x0c14, 0x0bf6"
+        />
+        <test
+            name="22: Ka, Virama, Ssa"
+            inpututf16="0x0B95, 0x0BCD, 0x0BB7"
+            outputglyphids="0x0c2f"
+        />
+        <test
+            name="23 1.3.17: Sa, Virama, Ra, Matra I"
+            inpututf16="0x0BB8, 0x0BCD, 0x0BB0, 0x0BC0"
+            outputglyphids="0x0c79"
+        />
+        <test
+            name="24 1.3.18 - 1: Ka"
+            inpututf16="0x0B95"
+            outputglyphids="0x0bf6"
+        />
+        <test
+            name="24 1.3.18 - 2: Virama, ZWJ"
+            inpututf16="0x0BCD, 0x8205"
+        />
+    </language>
+</shapingtests>
diff --git a/tests/manual/textrendering/glyphshaping/main.cpp b/tests/manual/textrendering/glyphshaping/main.cpp
new file mode 100644
index 0000000..d2b53a0
--- /dev/null
+++ b/tests/manual/textrendering/glyphshaping/main.cpp
@@ -0,0 +1,269 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 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$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtGui>
+
+static const int fontPixelSize = 25;
+static const QLatin1String fontFamily("Series 60 Sans");
+
+struct testDataSet
+{
+    QString language;
+    QString name;
+    QString input;
+    QString inputOriginal;
+    QString output;
+    QString outputOriginal;
+    QVector<uint> outputGlyphIDs;
+    QString outputGlyphIDsOriginal;
+};
+
+QString charHexCsv2String(const QString &csv)
+{
+    QString result;
+    foreach (const QString &charString, csv.split(QLatin1Char(','), QString::SkipEmptyParts)) {
+        bool isOk;
+        const uint charUInt = charString.toUInt(&isOk, 16);
+        Q_ASSERT(isOk);
+        const int size = charUInt >= SHRT_MAX ? 2:1;
+        result.append(QString::fromUtf16((const ushort*)&charUInt, size));
+    }
+    return result;
+}
+
+QList<testDataSet> testDataSetList()
+{
+    QList<testDataSet> result;
+    QFile file("glyphshaping_data.xml");
+    const bool success = file.open(QIODevice::ReadOnly);
+    Q_ASSERT(success);
+
+    const QLatin1String language("language");
+    const QLatin1String test("test");
+    const QLatin1String inputUtf16("inpututf16");
+    const QLatin1String outputUtf16("outpututf16");
+    const QLatin1String outputGlyphIDs("outputglyphids");
+    const QLatin1String name("name");
+
+    QString languageName;
+
+    QXmlStreamReader reader(&file);
+    while (!reader.atEnd()) {
+        const QXmlStreamReader::TokenType token = reader.readNext();
+        switch (token) {
+        case QXmlStreamReader::StartElement:
+            if (reader.name() == language) {
+                Q_ASSERT(reader.attributes().hasAttribute(name));
+                languageName = reader.attributes().value(name).toString();
+            } else if (reader.name() == test) {
+                if (!reader.attributes().hasAttribute(outputUtf16)
+                    && !reader.attributes().hasAttribute(outputGlyphIDs))
+                    continue;
+                Q_ASSERT(!languageName.isEmpty());
+                Q_ASSERT(reader.attributes().hasAttribute(name));
+                Q_ASSERT(reader.attributes().hasAttribute(inputUtf16));
+                testDataSet set;
+                set.language = languageName;
+                set.name = reader.attributes().value(name).toString();
+                set.inputOriginal = reader.attributes().value(inputUtf16).toString();
+                set.input = charHexCsv2String(set.inputOriginal);
+                set.outputOriginal = reader.attributes().value(outputUtf16).toString();
+                set.output = charHexCsv2String(set.outputOriginal);
+                set.outputGlyphIDsOriginal = reader.attributes().value(outputGlyphIDs).toString();
+                result.append(set);
+            }
+            break;
+        default:
+            break;
+        }
+    }
+    return result;
+}
+
+QImage renderedText(const QString &text, const QFont &font)
+{
+    const QFontMetrics metrics(font);
+    const QRect boundingRect = metrics.boundingRect(text);
+    QImage result(boundingRect.size(), QImage::Format_ARGB32);
+    result.fill(0);
+
+    QPainter p(&result);
+    p.setFont(font);
+    p.drawText(boundingRect.translated(-boundingRect.topLeft()), text);
+
+    return result;
+}
+
+QString dumpImageHtml(const QString &text, const QString &pathName)
+{
+    if (text.isEmpty())
+        return QLatin1String("<td/>");
+    QFont font(fontFamily);
+    font.setPixelSize(fontPixelSize);
+    const QImage textImage = renderedText(text, font);
+    const QString imageFileName =
+            (pathName + QDir::separator() + QLatin1String("%1.png"))
+            .arg(textImage.cacheKey());
+    const bool success = textImage.save(imageFileName);
+    Q_ASSERT(success);
+    return
+        QString::fromLatin1("<td title=\"%2\"><img src=\"%1\" alt=\"%2\" width=\"%3\" height=\"%4\"/></td>")
+        .arg(QDir::cleanPath(imageFileName)).arg(text).arg(textImage.width()).arg(textImage.height());
+}
+
+QString dlItem(const QString &dt, const QString &dd)
+{
+    if (!dd.trimmed().isEmpty())
+        return QString::fromLatin1("\t\t\t\t\t\t<dt>%1</dt><dd>%2</dd>\n").arg(dt).arg(dd);
+    return QString();
+}
+
+bool dumpHtml(const QString &pathName)
+{
+    QFile htmlPage(pathName + QDir::separator() + QLatin1String("index.html"));
+    if (!htmlPage.open(QFile::WriteOnly))
+        return false;
+
+    QString platformName = QString::fromLatin1(
+#if defined(Q_OS_WIN)
+            "Win32"
+#elif defined(Q_WS_X11)
+            "X11"
+#elif defined(Q_OS_SYMBIAN)
+            "Symbian"
+#else
+            ""
+#endif
+    );
+
+    QString result = QString::fromLatin1(
+            "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"\n"
+            " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n\n"
+            "<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" lang=\"en\">\n"
+            "\t<head>\n"
+            "\t\t<title>Qt on %1 glyph shaping (%2)</title>\n"
+            "\t\t<meta http-equiv=\"content-type\" content=\"text/html;charset=utf-8\" />\n"
+            "\t\t<style type=\"text/css\" media=\"screen\">\n"
+            "\t\t\ttable { font-family: Arial; background-color: #ccccff; font-size: 12pt; }\n"
+            "\t\t\ttd { font-family:\"%2\"; background-color: #eeeeee; font-size: %3px; }\n"
+            "\t\t\tth { font-weight:normal; }\n"
+            "\t\t\tdl { font-family: Arial; font-size: 8pt; margin: 3px; }\n"
+            "\t\t\tdt { font-weight: bold; float: left; }\n"
+            "\t\t\ttr:hover { background-color: #ddddff; }\n"
+            "\t\t\ttd:hover { background-color: #ddddff; }\n"
+            "\t\t</style>\n"
+            "\t</head>\n"
+            "\t<body>\n"
+            "\t\t<h1>Qt on %1 glyph shaping (%2)</h1>\n"
+            "\t\t<dl>\n"
+            "\t\t\t<dt>I</dt><dd>Input Utf-16 to shaper</dd>\n"
+            "\t\t\t<dt>O-Utf</dt><dd>expected output Utf-16</dd>\n"
+            "\t\t\t<dt>O-ID</dt><dd>expected output Glyph IDs for \"Series 60 Sans\"</dd>\n"
+            "\t\t</dl>\n"
+            "\t\t<table>\n"
+            ).arg(platformName).arg(fontFamily).arg(fontPixelSize);
+
+    QString languageName;
+    foreach (const testDataSet &dataSet, testDataSetList()) {
+        if (languageName != dataSet.language) {
+            result.append(QString::fromLatin1(
+                    "\t\t\t<tr>\n"
+                    "\t\t\t\t<th rowspan=\"2\"><h2>%1</h2></th>\n"
+                    "\t\t\t\t<th colspan=\"2\">Qt/%2</th>\n"
+                    "\t\t\t\t<th rowspan=\"2\">Glyphs</th>\n"
+                    "\t\t\t\t<th colspan=\"2\">Browser</th>\n"
+                    "\t\t\t</tr>\n"
+                    "\t\t\t<tr>\n"
+                    "\t\t\t\t<th>In</th>\n"
+                    "\t\t\t\t<th>Out</th>\n"
+                    "\t\t\t\t<th>In</th>\n"
+                    "\t\t\t\t<th>Out</th>\n"
+                    "\t\t\t</tr>\n"
+                    ).arg(dataSet.language).arg(platformName));
+            languageName = dataSet.language;
+        }
+        QString glyphsData;
+        if (!dataSet.inputOriginal.isEmpty())
+            glyphsData.append(dlItem(QLatin1String("I"), dataSet.inputOriginal));
+        if (!dataSet.outputOriginal.isEmpty())
+            glyphsData.append(dlItem(QLatin1String("O-Utf"), dataSet.outputOriginal));
+        if (!dataSet.outputGlyphIDsOriginal.isEmpty())
+            glyphsData.append(dlItem(QLatin1String("O-ID"), dataSet.outputGlyphIDsOriginal));
+        if (!glyphsData.isEmpty()) {
+            glyphsData.prepend(QLatin1String("\t\t\t\t\t<dl>\n"));
+            glyphsData.append(QLatin1String("\t\t\t\t\t</dl>\n"));
+        }
+        result.append(QString::fromLatin1(
+                "\t\t\t<tr>\n"
+                "\t\t\t\t<th>%1</th>\n"
+                "\t\t\t\t%2\n"
+                "\t\t\t\t%3\n"
+                "\t\t\t\t<td>\n"
+                "%4"
+                "\t\t\t\t</td>\n"
+                "\t\t\t\t<td>%5</td>\n"
+                "\t\t\t\t<td>%6</td>\n"
+                "\t\t\t</tr>\n"
+                ).arg(dataSet.name)
+                .arg(dumpImageHtml(dataSet.input, pathName))
+                .arg(dumpImageHtml(dataSet.output, pathName))
+                .arg(glyphsData)
+                .arg(dataSet.input)
+                .arg(dataSet.output)
+        );
+    }
+
+    result.append(QString::fromLatin1(
+            "\t\t</table>\n"
+            "\t</body>\n"
+            "</html>")
+    );
+
+    htmlPage.write(result.toUtf8());
+
+    return true;
+}
+
+int main(int argc, char *argv[])
+{
+    QApplication a(argc, argv);
+    return dumpHtml(QLatin1String(".")) ? 0 : 1;
+}
diff --git a/tests/manual/textrendering/textperformance/main.cpp b/tests/manual/textrendering/textperformance/main.cpp
new file mode 100644
index 0000000..47e0a88
--- /dev/null
+++ b/tests/manual/textrendering/textperformance/main.cpp
@@ -0,0 +1,231 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 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$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtGui>
+
+static const int lastMeasurementsCount = 50;
+
+class FontBlaster: public QWidget
+{
+    Q_OBJECT
+
+public:
+    FontBlaster(QWidget *parent = 0)
+        : QWidget(parent)
+        , m_currentMode(0)
+    {
+        setFocusPolicy(Qt::StrongFocus);
+    }
+
+    void paintEvent(QPaintEvent *event)
+    {
+        Q_UNUSED(event);
+        QPainter p(this);
+
+        if (!m_timer.isNull())
+            m_lastMeasurements.append(m_timer.elapsed());
+        m_timer.start();
+
+        p.save();
+        m_modes[m_currentMode].function(p, size());
+        p.restore();
+
+        const QFontMetrics fm = p.fontMetrics();
+        p.setOpacity(0.7);
+        p.fillRect(0, 0, width(), fm.height(), Qt::gray);
+        p.fillRect(0, height() - fm.height(), width(), height(), Qt::gray);
+        p.setOpacity(1);
+        p.setPen(palette().color(QPalette::Text));
+        p.drawText(2, fm.ascent(), m_modes[m_currentMode].name);
+
+        if (m_lastMeasurements.count() == lastMeasurementsCount) {
+            m_lastMeasurements.removeFirst();
+            int lastMsecsSum = 0;
+            foreach(const int measurement, m_lastMeasurements)
+                lastMsecsSum += measurement;
+
+            p.drawText(2, height() - fm.descent(),
+                QLatin1String("Fps: ") +
+                QString::number(1000 / ((qreal)lastMsecsSum / lastMeasurementsCount), 'f', 1)
+            );
+        }
+
+        QTimer::singleShot(0, this, SLOT(repaint()));
+    }
+
+    /*
+      Creating all kinds of size/weight/italic combinations, stress testing
+      the glyph cache.
+      Also: painting with different opacities, stress testing blitting.
+    */
+    static void paintDifferentFontStyles(QPainter &p, const QSize &size)
+    {
+        static const QString text = QLatin1String("Qt rocks!!!");
+        static const int textsPerPaint = 30;
+        for (int i = 0; i < textsPerPaint; i++) {
+            const int fontSize = 4 + (qrand() % 5);
+            const int fontWeight = (qrand() % 2) == 1 ? QFont::Normal : QFont::Bold;
+            const bool fontItalic = (qrand() % 2) == 1;
+            const QFont font("Default", fontSize, fontWeight, fontItalic);
+            p.setFont(font);
+            p.setPen(QColor::fromHsv(qrand() % 359, 155 + qrand() % 100,
+                                     155 + qrand() % 100, 100 + qrand() % 155));
+            const QSize textSize(p.fontMetrics().boundingRect(text).size());
+            const QPoint position(
+                -textSize.width() / 2 + (qrand() % size.width()),
+                textSize.height() / 2 + (qrand() % size.height()));
+            p.drawText(position, text);
+        }
+    }
+
+    /*
+      Drawing a multiline latin text, stress testing the text layout system.
+    */
+    static void paintLongLatinText(QPainter &p, const QSize &size)
+    {
+        static const char* const pieces[] = {
+            "lorem ipsum",
+            "dolor sit amet",
+            "consectetuer",
+            "sed diam nonumy",
+            "eos et accusam",
+            "sea takimata sanctus"
+        };
+        static const int piecesCount = (int)(sizeof pieces / sizeof pieces[0]);
+        static const int piecesPerPaint = 30;
+
+        QString text;
+        for (int i = 0; i < piecesPerPaint; ++i) {
+            QString piece = QLatin1String(pieces[qrand() % piecesCount]);
+            if (i == 0 || qrand() % 2) {
+                // Make this piece the beginning of a new sentence.
+                piece[0] = piece[0].toUpper();
+                if (i > 0)
+                    piece.prepend(QLatin1String(". "));
+            } else {
+                piece.prepend(QLatin1String(", "));
+            }
+            text.append(piece);
+        }
+        text.append(QLatin1Char('.'));
+
+        p.drawText(QRectF(QPointF(0, 0), QSizeF(size)),
+                   Qt::AlignTop | Qt::AlignAbsolute | Qt::TextWordWrap, text);
+    }
+
+    /*
+      Drawing one text with several snippets of different writingSystems, stress
+      testing the font merging in the font database.
+    */
+    static void paintInternationalText(QPainter &p, const QSize &size)
+    {
+        static QStringList samples;
+        if (samples.isEmpty()) {
+            foreach (const QFontDatabase::WritingSystem system, QFontDatabase().writingSystems())
+                if (system != QFontDatabase::Ogham && system != QFontDatabase::Runic)
+                    samples.append(QFontDatabase::writingSystemSample(system));
+        }
+        static const int systemsPerPaint = 65;
+        QString text;
+        for (int i = 0; i < systemsPerPaint; i++) {
+            if (i > 0)
+                text.append(QLatin1Char(' '));
+            text.append(samples.at(qrand() % samples.count()));
+        }
+        p.drawText(QRectF(QPointF(0, 0), QSizeF(size)),
+                   Qt::AlignTop | Qt::AlignAbsolute | Qt::TextWordWrap, text);
+    }
+
+protected:
+    void nextMode()
+    {
+        m_currentMode = (m_currentMode + 1) % m_modesCount;
+        m_lastMeasurements.clear();
+    }
+
+    void keyPressEvent(QKeyEvent *event)
+    {
+        Q_UNUSED(event);
+        nextMode();
+    }
+
+    void mousePressEvent(QMouseEvent *event)
+    {
+        Q_UNUSED(event);
+        nextMode();
+    }
+
+private:
+    static const struct mode {
+        QString name;
+        void (*function)(QPainter &, const QSize&);
+    } m_modes[];
+    static const int m_modesCount;
+
+    int m_currentMode;
+    QList<int> m_lastMeasurements;
+    QTime m_timer;
+};
+
+const struct FontBlaster::mode FontBlaster::m_modes[] = {
+    { QLatin1String("Qt rocks!!!"), FontBlaster::paintDifferentFontStyles },
+    { QLatin1String("Latin"), FontBlaster::paintLongLatinText },
+    { QLatin1String("International"), FontBlaster::paintInternationalText }
+};
+
+const int FontBlaster::m_modesCount =
+    (int)(sizeof m_modes / sizeof m_modes[0]);
+
+int main(int argc, char *argv[])
+{
+    QApplication a(argc, argv);
+
+    FontBlaster dlg;
+#ifdef Q_OS_SYMBIAN
+    dlg.showFullScreen();
+#else
+    dlg.show();
+#endif
+
+    return a.exec();
+}
+
+#include "main.moc"
diff --git a/tests/manual/textrendering/textperformance/textperformance.pro b/tests/manual/textrendering/textperformance/textperformance.pro
new file mode 100644
index 0000000..bba41b9
--- /dev/null
+++ b/tests/manual/textrendering/textperformance/textperformance.pro
@@ -0,0 +1 @@
+SOURCES = main.cpp
author	Morten Johan Sørvig <morten.sorvig@nokia.com>	2009-11-05 06:26:24 (GMT)
committer	Morten Johan Sørvig <morten.sorvig@nokia.com>	2009-11-05 06:26:24 (GMT)
commit	ee88b2d8408396188eb2ce52d740c395c6cd4656 (patch)
tree	1f59ea0612fecbaca595594d3812dd2aab64cf63 /tests
parent	673973acc20ce4e068d63fa5b0391f5c785be8a3 (diff)
parent	aa58293b57a05cd52b36ba14a05958dceb65c603 (diff)
download	Qt-ee88b2d8408396188eb2ce52d740c395c6cd4656.zip Qt-ee88b2d8408396188eb2ce52d740c395c6cd4656.tar.gz Qt-ee88b2d8408396188eb2ce52d740c395c6cd4656.tar.bz2