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

64 files changed, 3159 insertions, 268 deletions

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/gestures/tst_gestures.cpp b/tests/auto/gestures/tst_gestures.cpp
index 92f979f..02c8232 100644
--- a/tests/auto/gestures/tst_gestures.cpp
+++ b/tests/auto/gestures/tst_gestures.cpp
@@ -103,6 +103,8 @@ int CustomEvent::EventType = 0;
 class CustomGestureRecognizer : public QGestureRecognizer
 {
 public:
+    static bool ConsumeEvents;
+
     CustomGestureRecognizer()
     {
         if (!CustomEvent::EventType)
@@ -117,7 +119,9 @@ public:
     QGestureRecognizer::Result filterEvent(QGesture *state, QObject*, QEvent *event)
     {
         if (event->type() == CustomEvent::EventType) {
-            QGestureRecognizer::Result result = QGestureRecognizer::ConsumeEventHint;
+            QGestureRecognizer::Result result = 0;
+            if (CustomGestureRecognizer::ConsumeEvents)
+                result |= QGestureRecognizer::ConsumeEventHint;
             CustomGesture *g = static_cast<CustomGesture*>(state);
             CustomEvent *e = static_cast<CustomEvent*>(event);
             g->serial = e->serial;
@@ -143,6 +147,7 @@ public:
         QGestureRecognizer::reset(state);
     }
 };
+bool CustomGestureRecognizer::ConsumeEvents = false;
 
 // same as CustomGestureRecognizer but triggers early without the maybe state
 class CustomContinuousGestureRecognizer : public QGestureRecognizer
@@ -280,6 +285,7 @@ protected:
     }
 };
 
+// TODO rename to sendGestureSequence
 static void sendCustomGesture(CustomEvent *event, QObject *object, QGraphicsScene *scene = 0)
 {
     for (int i = CustomGesture::SerialMaybeThreshold;
@@ -322,6 +328,10 @@ private slots:
     void multipleGesturesInTree();
     void multipleGesturesInComplexTree();
     void testMapToScene();
+    void ungrabGesture();
+    void consumeEventHint();
+    void unregisterRecognizer();
+    void autoCancelGestures();
 };
 
 tst_Gestures::tst_Gestures()
@@ -334,13 +344,14 @@ tst_Gestures::~tst_Gestures()
 
 void tst_Gestures::initTestCase()
 {
-    CustomGesture::GestureType = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
+    CustomGesture::GestureType = QApplication::registerGestureRecognizer(new CustomGestureRecognizer);
     QVERIFY(CustomGesture::GestureType != Qt::GestureType(0));
     QVERIFY(CustomGesture::GestureType != Qt::CustomGesture);
 }
 
 void tst_Gestures::cleanupTestCase()
 {
+    QApplication::unregisterGestureRecognizer(CustomGesture::GestureType);
 }
 
 void tst_Gestures::init()
@@ -372,6 +383,19 @@ void tst_Gestures::customGesture()
     QCOMPARE(widget.events.canceled.size(), 0);
 }
 
+void tst_Gestures::consumeEventHint()
+{
+    GestureWidget widget;
+    widget.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
+
+    CustomGestureRecognizer::ConsumeEvents = true;
+    CustomEvent event;
+    sendCustomGesture(&event, &widget);
+    CustomGestureRecognizer::ConsumeEvents = false;
+
+    QCOMPARE(widget.customEventsReceived, 0);
+}
+
 void tst_Gestures::autoCancelingGestures()
 {
     GestureWidget widget;
@@ -534,7 +558,7 @@ void tst_Gestures::conflictingGestures()
     parent.reset();
     child->reset();
 
-    Qt::GestureType ContinuousGesture = qApp->registerGestureRecognizer(new CustomContinuousGestureRecognizer);
+    Qt::GestureType ContinuousGesture = QApplication::registerGestureRecognizer(new CustomContinuousGestureRecognizer);
     static const int ContinuousGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
     child->grabGesture(ContinuousGesture);
     // child accepts override. And it also receives another custom gesture.
@@ -547,6 +571,8 @@ void tst_Gestures::conflictingGestures()
     QCOMPARE(child->events.all.count(), TotalGestureEventsCount + ContinuousGestureEventsCount);
     QCOMPARE(parent.gestureOverrideEventsReceived, 0);
     QCOMPARE(parent.gestureEventsReceived, 0);
+
+    QApplication::unregisterGestureRecognizer(ContinuousGesture);
 }
 
 void tst_Gestures::finishedWithoutStarted()
@@ -710,6 +736,7 @@ void tst_Gestures::graphicsItemGesture()
 {
     QGraphicsScene scene;
     QGraphicsView view(&scene);
+    view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
     GestureItem *item = new GestureItem("item");
     scene.addItem(item);
@@ -772,6 +799,7 @@ void tst_Gestures::graphicsItemTreeGesture()
 {
     QGraphicsScene scene;
     QGraphicsView view(&scene);
+    view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
     GestureItem *item1 = new GestureItem("item1");
     item1->setPos(100, 100);
@@ -829,6 +857,7 @@ void tst_Gestures::explicitGraphicsObjectTarget()
 {
     QGraphicsScene scene;
     QGraphicsView view(&scene);
+    view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
     GestureItem *item1 = new GestureItem("item1");
     scene.addItem(item1);
@@ -882,6 +911,7 @@ void tst_Gestures::gestureOverChildGraphicsItem()
 {
     QGraphicsScene scene;
     QGraphicsView view(&scene);
+    view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
     GestureItem *item0 = new GestureItem("item0");
     scene.addItem(item0);
@@ -951,7 +981,7 @@ void tst_Gestures::twoGesturesOnDifferentLevel()
     GestureWidget *child = new GestureWidget("child");
     l->addWidget(child);
 
-    Qt::GestureType SecondGesture = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType SecondGesture = QApplication::registerGestureRecognizer(new CustomGestureRecognizer);
 
     parent.grabGesture(CustomGesture::GestureType, Qt::WidgetWithChildrenGesture);
     child->grabGesture(SecondGesture, Qt::WidgetWithChildrenGesture);
@@ -978,6 +1008,8 @@ void tst_Gestures::twoGesturesOnDifferentLevel()
     QCOMPARE(parent.events.all.size(), TotalGestureEventsCount);
     for(int i = 0; i < child->events.all.size(); ++i)
         QCOMPARE(parent.events.all.at(i), CustomGesture::GestureType);
+
+    QApplication::unregisterGestureRecognizer(SecondGesture);
 }
 
 void tst_Gestures::multipleGesturesInTree()
@@ -989,8 +1021,8 @@ void tst_Gestures::multipleGesturesInTree()
     GestureWidget *D = new GestureWidget("D", C);
 
     Qt::GestureType FirstGesture  = CustomGesture::GestureType;
-    Qt::GestureType SecondGesture = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
-    Qt::GestureType ThirdGesture  = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType SecondGesture = QApplication::registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType ThirdGesture  = QApplication::registerGestureRecognizer(new CustomGestureRecognizer);
 
     A->grabGesture(FirstGesture, Qt::WidgetWithChildrenGesture);   // A [1   3]
     A->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);   // |
@@ -1046,6 +1078,9 @@ void tst_Gestures::multipleGesturesInTree()
     QCOMPARE(A->events.all.count(FirstGesture), TotalGestureEventsCount);
     QCOMPARE(A->events.all.count(SecondGesture), 0);
     QCOMPARE(A->events.all.count(ThirdGesture), TotalGestureEventsCount);
+
+    QApplication::unregisterGestureRecognizer(SecondGesture);
+    QApplication::unregisterGestureRecognizer(ThirdGesture);
 }
 
 void tst_Gestures::multipleGesturesInComplexTree()
@@ -1057,12 +1092,12 @@ void tst_Gestures::multipleGesturesInComplexTree()
     GestureWidget *D = new GestureWidget("D", C);
 
     Qt::GestureType FirstGesture   = CustomGesture::GestureType;
-    Qt::GestureType SecondGesture  = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
-    Qt::GestureType ThirdGesture   = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
-    Qt::GestureType FourthGesture  = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
-    Qt::GestureType FifthGesture   = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
-    Qt::GestureType SixthGesture   = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
-    Qt::GestureType SeventhGesture = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType SecondGesture  = QApplication::registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType ThirdGesture   = QApplication::registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType FourthGesture  = QApplication::registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType FifthGesture   = QApplication::registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType SixthGesture   = QApplication::registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType SeventhGesture = QApplication::registerGestureRecognizer(new CustomGestureRecognizer);
 
     A->grabGesture(FirstGesture, Qt::WidgetWithChildrenGesture);   // A [1,3,4]
     A->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);   // |
@@ -1139,6 +1174,13 @@ void tst_Gestures::multipleGesturesInComplexTree()
     QCOMPARE(A->events.all.count(FifthGesture), 0);
     QCOMPARE(A->events.all.count(SixthGesture), 0);
     QCOMPARE(A->events.all.count(SeventhGesture), 0);
+
+    QApplication::unregisterGestureRecognizer(SecondGesture);
+    QApplication::unregisterGestureRecognizer(ThirdGesture);
+    QApplication::unregisterGestureRecognizer(FourthGesture);
+    QApplication::unregisterGestureRecognizer(FifthGesture);
+    QApplication::unregisterGestureRecognizer(SixthGesture);
+    QApplication::unregisterGestureRecognizer(SeventhGesture);
 }
 
 void tst_Gestures::testMapToScene()
@@ -1151,6 +1193,7 @@ void tst_Gestures::testMapToScene()
 
     QGraphicsScene scene;
     QGraphicsView view(&scene);
+    view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
     GestureItem *item0 = new GestureItem;
     scene.addItem(item0);
@@ -1166,5 +1209,150 @@ void tst_Gestures::testMapToScene()
     QCOMPARE(event.mapToScene(origin + QPoint(100, 200)), view.mapToScene(QPoint(100, 200)));
 }
 
+void tst_Gestures::ungrabGesture() // a method on QWidget
+{
+    class MockGestureWidget : public GestureWidget {
+    public:
+        MockGestureWidget(const char *name = 0, QWidget *parent = 0)
+            : GestureWidget(name, parent) { }
+
+
+        QSet<QGesture*> gestures;
+    protected:
+        bool event(QEvent *event)
+        {
+            if (event->type() == QEvent::Gesture) {
+                QGestureEvent *gestureEvent = static_cast<QGestureEvent*>(event);
+                if (gestureEvent)
+                    foreach (QGesture *g, gestureEvent->allGestures())
+                        gestures.insert(g);
+            }
+            return GestureWidget::event(event);
+        }
+    };
+
+    MockGestureWidget parent("A");
+    MockGestureWidget *a = &parent;
+    MockGestureWidget *b = new MockGestureWidget("B", a);
+
+    a->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
+    b->grabGesture(CustomGesture::GestureType, Qt::WidgetWithChildrenGesture);
+    b->ignoredGestures << CustomGesture::GestureType;
+
+    CustomEvent event;
+    // sending an event will cause the QGesture objects to be instantiated for the widgets
+    sendCustomGesture(&event, b);
+
+    QCOMPARE(a->gestures.count(), 1);
+    QPointer<QGesture> customGestureA;
+    customGestureA = *(a->gestures.begin());
+    QVERIFY(!customGestureA.isNull());
+    QCOMPARE(customGestureA->gestureType(), CustomGesture::GestureType);
+
+    QCOMPARE(b->gestures.count(), 1);
+    QPointer<QGesture> customGestureB;
+    customGestureB = *(b->gestures.begin());
+    QVERIFY(!customGestureB.isNull());
+    QVERIFY(customGestureA.data() == customGestureB.data());
+    QCOMPARE(customGestureB->gestureType(), CustomGesture::GestureType);
+
+    a->gestures.clear();
+    // sending an event will cause the QGesture objects to be instantiated for the widget
+    sendCustomGesture(&event, a);
+
+    QCOMPARE(a->gestures.count(), 1);
+    customGestureA = *(a->gestures.begin());
+    QVERIFY(!customGestureA.isNull());
+    QCOMPARE(customGestureA->gestureType(), CustomGesture::GestureType);
+    QVERIFY(customGestureA.data() != customGestureB.data());
+
+    a->ungrabGesture(CustomGesture::GestureType);
+    QVERIFY(customGestureA.isNull());
+    QVERIFY(!customGestureB.isNull());
+
+    a->gestures.clear();
+    a->reset();
+    // send again to 'b' and make sure a never gets it.
+    sendCustomGesture(&event, b);
+    QCOMPARE(a->gestureEventsReceived, 0);
+    QCOMPARE(a->gestureOverrideEventsReceived, 0);
+}
+
+void tst_Gestures::unregisterRecognizer() // a method on QApplication
+{
+    /*
+     The hardest usecase to get right is when we remove a recognizer while several
+     of the gestures it created are in active state and we immediately add a new recognizer
+     for the same type (thus replacing the old one).
+     The expected result is that all old gestures continue till they are finished/cancelled
+     and the new recognizer starts creating gestures immediately at registration.
+
+     This implies that deleting of the recognizer happens only when there are no more gestures
+     that it created. (since gestures might have a pointer to the recognizer)
+     */
+
+}
+
+void tst_Gestures::autoCancelGestures()
+{
+    class MockRecognizer : public QGestureRecognizer {
+      public:
+        QGestureRecognizer::Result filterEvent(QGesture *gesture, QObject *watched, QEvent *event)
+        {
+            Q_UNUSED(gesture);
+            Q_UNUSED(watched);
+            if (event->type() == QEvent::MouseButtonPress)
+                return QGestureRecognizer::GestureTriggered;
+            if (event->type() == QEvent::MouseButtonRelease)
+                return QGestureRecognizer::GestureFinished;
+            return QGestureRecognizer::Ignore;
+        }
+    };
+
+    class MockWidget : public GestureWidget {
+      public:
+        MockWidget(const char *name) : GestureWidget(name) { }
+
+        bool event(QEvent *event)
+        {
+            if (event->type() == QEvent::Gesture) {
+                QGestureEvent *ge = static_cast<QGestureEvent*>(event);
+                Q_ASSERT(ge->allGestures().count() == 1); // can't use QCOMPARE here...
+                ge->allGestures().first()->setGestureCancelPolicy(QGesture::CancelAllInContext);
+            }
+            return GestureWidget::event(event);
+        }
+    };
+
+    MockWidget parent("parent"); // this one sets the cancel policy to CancelAllInContext
+    parent.resize(300, 100);
+    GestureWidget *child = new GestureWidget("child", &parent);
+    child->setGeometry(10, 10, 100, 80);
+
+    Qt::GestureType type = QApplication::registerGestureRecognizer(new MockRecognizer());
+    parent.grabGesture(type, Qt::WidgetWithChildrenGesture);
+    child->grabGesture(type, Qt::WidgetWithChildrenGesture);
+
+    /*
+      An event is send to both the child and the parent, when the child gets it a gesture is triggered
+      and send to the child.
+      When the parent gets the event a new gesture is triggered and delivered to the parent. When the
+      parent gets it he accepts it and that causes the cancel policy to activate.
+      The cause of that is the gesture for the child is cancelled and send to the child as such.
+    */
+    QMouseEvent event(QEvent::MouseButtonPress, QPoint(20,20), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+    QApplication::sendEvent(child, &event);
+    QCOMPARE(child->events.started.count(), 1);
+    QCOMPARE(child->events.all.count(), 1);
+    QCOMPARE(parent.events.all.count(), 0);
+    child->reset();
+    QApplication::sendEvent(&parent, &event);
+    QCOMPARE(parent.events.all.count(), 1);
+    QCOMPARE(parent.events.started.count(), 1);
+    QCOMPARE(child->events.started.count(), 0);
+    QCOMPARE(child->events.all.count(), 1);
+    QCOMPARE(child->events.canceled.count(), 1);
+}
+
 QTEST_MAIN(tst_Gestures)
 #include "tst_gestures.moc"
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/qapplication/tst_qapplication.cpp b/tests/auto/qapplication/tst_qapplication.cpp
index 675e559..5888866 100644
--- a/tests/auto/qapplication/tst_qapplication.cpp
+++ b/tests/auto/qapplication/tst_qapplication.cpp
@@ -129,6 +129,7 @@ private slots:
     void style();
 
     void allWidgets();
+    void topLevelWidgets();
 
     void setAttribute();
 
@@ -1795,6 +1796,27 @@ void tst_QApplication::allWidgets()
     QVERIFY(!app.allWidgets().contains(w)); // removal test
 }
 
+void tst_QApplication::topLevelWidgets()
+{
+    int argc = 1;
+    QApplication app(argc, &argv0, QApplication::GuiServer);
+    QWidget *w = new QWidget;
+    w->show();
+#ifndef QT_NO_CLIPBOARD
+    QClipboard *clipboard = QApplication::clipboard();
+    QString originalText = clipboard->text();
+    clipboard->setText(QString("newText"));
+#endif
+    app.processEvents();
+    QVERIFY(QApplication::topLevelWidgets().contains(w));
+    QCOMPARE(QApplication::topLevelWidgets().count(), 1);
+    delete w;
+    w = 0;
+    app.processEvents();
+    QCOMPARE(QApplication::topLevelWidgets().count(), 0);
+}
+
+
 
 void tst_QApplication::setAttribute()
 {
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/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/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/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
index d8cd375..684ad4f 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");
@@ -8431,7 +8466,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 +8475,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 +8528,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 +8545,7 @@ void tst_QGraphicsItem::focusScope()
     scopeB->setFocus();
 
     scene.addItem(rectA);
-    QVERIFY(!rect5->hasFocus());
+    QVERIFY(rect5->hasFocus());
     QVERIFY(!scopeB->hasFocus());
 
     scopeA->setFocus();
@@ -8516,6 +8553,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 +8642,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 +8681,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/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/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/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/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/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/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/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..e2a606f 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()
@@ -3127,7 +3137,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/qwidget/tst_qwidget.cpp b/tests/auto/qwidget/tst_qwidget.cpp
index 5630370..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();
@@ -6319,6 +6320,7 @@ void tst_QWidget::compatibilityChildInsertedEvents()
         widget.show();
         expected =
             EventRecorder::EventList()
+            << qMakePair(&widget, QEvent::WinIdChange)
             << qMakePair(&widget, QEvent::Polish)
             << qMakePair(&widget, QEvent::Move)
             << qMakePair(&widget, QEvent::Resize)
@@ -6404,6 +6406,7 @@ void tst_QWidget::compatibilityChildInsertedEvents()
         widget.show();
         expected =
             EventRecorder::EventList()
+            << qMakePair(&widget, QEvent::WinIdChange)
             << qMakePair(&widget, QEvent::Polish)
 #ifdef QT_HAS_QT3SUPPORT
             << qMakePair(&widget, QEvent::ChildInserted)
@@ -6501,6 +6504,7 @@ void tst_QWidget::compatibilityChildInsertedEvents()
         widget.show();
         expected =
             EventRecorder::EventList()
+            << qMakePair(&widget, QEvent::WinIdChange)
             << qMakePair(&widget, QEvent::Polish)
 #ifdef QT_HAS_QT3SUPPORT
             << qMakePair(&widget, QEvent::ChildInserted)
@@ -8272,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/manual/gestures/graphicsview/main.cpp b/tests/manual/gestures/graphicsview/main.cpp
index e9065eb..de92afe 100644
--- a/tests/manual/gestures/graphicsview/main.cpp
+++ b/tests/manual/gestures/graphicsview/main.cpp
@@ -152,8 +152,8 @@ private:
 
 MainWindow::MainWindow()
 {
-    (void)qApp->registerGestureRecognizer(new MousePanGestureRecognizer);
-    ThreeFingerSlideGesture::Type = qApp->registerGestureRecognizer(new ThreeFingerSlideGestureRecognizer);
+    (void)QApplication::registerGestureRecognizer(new MousePanGestureRecognizer);
+    ThreeFingerSlideGesture::Type = QApplication::registerGestureRecognizer(new ThreeFingerSlideGestureRecognizer);
 
     tabWidget = new QTabWidget;
 
diff --git a/tests/manual/gestures/scrollarea/mousepangesturerecognizer.cpp b/tests/manual/gestures/scrollarea/mousepangesturerecognizer.cpp
index 5f94dbc..63d3e76 100644
--- a/tests/manual/gestures/scrollarea/mousepangesturerecognizer.cpp
+++ b/tests/manual/gestures/scrollarea/mousepangesturerecognizer.cpp
@@ -49,7 +49,7 @@ MousePanGestureRecognizer::MousePanGestureRecognizer()
 {
 }
 
-QGesture* MousePanGestureRecognizer::createGesture(QObject *) const
+QGesture* MousePanGestureRecognizer::createGesture(QObject *)
 {
     return new QPanGesture;
 }
diff --git a/tests/manual/gestures/scrollarea/mousepangesturerecognizer.h b/tests/manual/gestures/scrollarea/mousepangesturerecognizer.h
index c92d477..b062fd0 100644
--- a/tests/manual/gestures/scrollarea/mousepangesturerecognizer.h
+++ b/tests/manual/gestures/scrollarea/mousepangesturerecognizer.h
@@ -49,7 +49,7 @@ class MousePanGestureRecognizer : public QGestureRecognizer
 public:
     MousePanGestureRecognizer();
 
-    QGesture* createGesture(QObject *target) const;
+    QGesture* createGesture(QObject *target);
     QGestureRecognizer::Result filterEvent(QGesture *state, QObject *watched, QEvent *event);
     void reset(QGesture *state);
 };
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