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

Conflicts:
	configure.exe
	src/corelib/animation/qabstractanimation.cpp
	src/gui/graphicsview/qgraphicsview.cpp
	src/s60installs/s60installs.pro
	tools/configure/configureapp.cpp
	tools/qdoc3/node.h

67 files changed, 2720 insertions, 1225 deletions

diff --git a/tests/auto/checkxmlfiles/checkxmlfiles.pro b/tests/auto/checkxmlfiles/checkxmlfiles.pro
index c368c02..d53c11c 100644
--- a/tests/auto/checkxmlfiles/checkxmlfiles.pro
+++ b/tests/auto/checkxmlfiles/checkxmlfiles.pro
@@ -12,7 +12,7 @@ addFiles.sources = \
 	$$QT_SOURCE_TREE/examples/sql/masterdetail/albumdetails.xml \
 	$$QT_SOURCE_TREE/examples/xmlpatterns/xquery/globalVariables/globals.gccxml \
 	$$QT_SOURCE_TREE/doc/src/diagrams/stylesheet/treeview.svg \
-	$$QT_SOURCE_TREE/doc/src/diagrams/designer-mainwindow-actions.ui \
+	$$QT_SOURCE_TREE/doc/src/diagrams/designer-manual/designer-mainwindow-actions.ui \
 	$$QT_SOURCE_TREE/demos/undo/undo.qrc
 addFiles.path = xmlfiles
 DEPLOYMENT += addFiles
diff --git a/tests/auto/gestures/tst_gestures.cpp b/tests/auto/gestures/tst_gestures.cpp
index 02c8232..20b53f2 100644
--- a/tests/auto/gestures/tst_gestures.cpp
+++ b/tests/auto/gestures/tst_gestures.cpp
@@ -111,12 +111,12 @@ public:
             CustomEvent::EventType = QEvent::registerEventType();
     }
 
-    QGesture* createGesture(QObject *)
+    QGesture* create(QObject *)
     {
         return new CustomGesture;
     }
 
-    QGestureRecognizer::Result filterEvent(QGesture *state, QObject*, QEvent *event)
+    QGestureRecognizer::Result recognize(QGesture *state, QObject*, QEvent *event)
     {
         if (event->type() == CustomEvent::EventType) {
             QGestureRecognizer::Result result = 0;
@@ -128,13 +128,13 @@ public:
             if (e->hasHotSpot)
                 g->setHotSpot(e->hotSpot);
             if (g->serial >= CustomGesture::SerialFinishedThreshold)
-                result |= QGestureRecognizer::GestureFinished;
+                result |= QGestureRecognizer::FinishGesture;
             else if (g->serial >= CustomGesture::SerialStartedThreshold)
-                result |= QGestureRecognizer::GestureTriggered;
+                result |= QGestureRecognizer::TriggerGesture;
             else if (g->serial >= CustomGesture::SerialMaybeThreshold)
-                result |= QGestureRecognizer::MaybeGesture;
+                result |= QGestureRecognizer::MayBeGesture;
             else
-                result = QGestureRecognizer::NotGesture;
+                result = QGestureRecognizer::CancelGesture;
             return result;
         }
         return QGestureRecognizer::Ignore;
@@ -142,7 +142,7 @@ public:
 
     void reset(QGesture *state)
     {
-        CustomGesture *g = static_cast<CustomGesture*>(state);
+        CustomGesture *g = static_cast<CustomGesture *>(state);
         g->serial = 0;
         QGestureRecognizer::reset(state);
     }
@@ -159,26 +159,26 @@ public:
             CustomEvent::EventType = QEvent::registerEventType();
     }
 
-    QGesture* createGesture(QObject *)
+    QGesture* create(QObject *)
     {
         return new CustomGesture;
     }
 
-    QGestureRecognizer::Result filterEvent(QGesture *state, QObject*, QEvent *event)
+    QGestureRecognizer::Result recognize(QGesture *state, QObject*, QEvent *event)
     {
         if (event->type() == CustomEvent::EventType) {
             QGestureRecognizer::Result result = QGestureRecognizer::ConsumeEventHint;
-            CustomGesture *g = static_cast<CustomGesture*>(state);
-            CustomEvent *e = static_cast<CustomEvent*>(event);
+            CustomGesture *g = static_cast<CustomGesture *>(state);
+            CustomEvent *e = static_cast<CustomEvent *>(event);
             g->serial = e->serial;
             if (e->hasHotSpot)
                 g->setHotSpot(e->hotSpot);
             if (g->serial >= CustomGesture::SerialFinishedThreshold)
-                result |= QGestureRecognizer::GestureFinished;
+                result |= QGestureRecognizer::FinishGesture;
             else if (g->serial >= CustomGesture::SerialMaybeThreshold)
-                result |= QGestureRecognizer::GestureTriggered;
+                result |= QGestureRecognizer::TriggerGesture;
             else
-                result = QGestureRecognizer::NotGesture;
+                result = QGestureRecognizer::CancelGesture;
             return result;
         }
         return QGestureRecognizer::Ignore;
@@ -186,7 +186,7 @@ public:
 
     void reset(QGesture *state)
     {
-        CustomGesture *g = static_cast<CustomGesture*>(state);
+        CustomGesture *g = static_cast<CustomGesture *>(state);
         g->serial = 0;
         QGestureRecognizer::reset(state);
     }
@@ -256,7 +256,7 @@ protected:
         }
         if (eventsPtr) {
             QGestureEvent *e = static_cast<QGestureEvent*>(event);
-            QList<QGesture*> gestures = e->allGestures();
+            QList<QGesture*> gestures = e->gestures();
             foreach(QGesture *g, gestures) {
                 eventsPtr->all << g->gestureType();
                 switch(g->state()) {
@@ -332,6 +332,7 @@ private slots:
     void consumeEventHint();
     void unregisterRecognizer();
     void autoCancelGestures();
+    void autoCancelGestures2();
 };
 
 tst_Gestures::tst_Gestures()
@@ -344,14 +345,14 @@ tst_Gestures::~tst_Gestures()
 
 void tst_Gestures::initTestCase()
 {
-    CustomGesture::GestureType = QApplication::registerGestureRecognizer(new CustomGestureRecognizer);
+    CustomGesture::GestureType = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
     QVERIFY(CustomGesture::GestureType != Qt::GestureType(0));
     QVERIFY(CustomGesture::GestureType != Qt::CustomGesture);
 }
 
 void tst_Gestures::cleanupTestCase()
 {
-    QApplication::unregisterGestureRecognizer(CustomGesture::GestureType);
+    QGestureRecognizer::unregisterRecognizer(CustomGesture::GestureType);
 }
 
 void tst_Gestures::init()
@@ -365,7 +366,7 @@ void tst_Gestures::cleanup()
 void tst_Gestures::customGesture()
 {
     GestureWidget widget;
-    widget.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
+    widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
     CustomEvent event;
     sendCustomGesture(&event, &widget);
 
@@ -386,7 +387,7 @@ void tst_Gestures::customGesture()
 void tst_Gestures::consumeEventHint()
 {
     GestureWidget widget;
-    widget.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
+    widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
     CustomGestureRecognizer::ConsumeEvents = true;
     CustomEvent event;
@@ -399,7 +400,7 @@ void tst_Gestures::consumeEventHint()
 void tst_Gestures::autoCancelingGestures()
 {
     GestureWidget widget;
-    widget.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
+    widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
     // send partial gesture. The gesture will be in the "maybe" state, but will
     // never get enough events to fire, so Qt will have to kill it.
     CustomEvent ev;
@@ -423,7 +424,7 @@ void tst_Gestures::gestureOverChild()
     GestureWidget *child = new GestureWidget("child");
     l->addWidget(child);
 
-    widget.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
+    widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
     CustomEvent event;
     sendCustomGesture(&event, child);
@@ -439,7 +440,7 @@ void tst_Gestures::gestureOverChild()
     QCOMPARE(widget.gestureOverrideEventsReceived, 0);
 
     // enable gestures over the children
-    widget.grabGesture(CustomGesture::GestureType, Qt::WidgetWithChildrenGesture);
+    widget.grabGesture(CustomGesture::GestureType);
 
     widget.reset();
     child->reset();
@@ -468,8 +469,8 @@ void tst_Gestures::multipleWidgetOnlyGestureInTree()
     GestureWidget *child = new GestureWidget("child");
     l->addWidget(child);
 
-    parent.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
-    child->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
+    parent.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
+    child->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
@@ -506,8 +507,8 @@ void tst_Gestures::conflictingGestures()
     GestureWidget *child = new GestureWidget("child");
     l->addWidget(child);
 
-    parent.grabGesture(CustomGesture::GestureType, Qt::WidgetWithChildrenGesture);
-    child->grabGesture(CustomGesture::GestureType, Qt::WidgetWithChildrenGesture);
+    parent.grabGesture(CustomGesture::GestureType);
+    child->grabGesture(CustomGesture::GestureType);
 
     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
@@ -542,7 +543,9 @@ void tst_Gestures::conflictingGestures()
     parent.reset();
     child->reset();
 
-    // nobody accepts the override, we will send normal events to the closest context (to the child)
+    // nobody accepts the override, we will send normal events to the closest
+    // context (i.e. to the child widget) and it will be propagated and
+    // accepted by the parent widget
     parent.acceptGestureOverride = false;
     child->acceptGestureOverride = false;
     child->ignoredGestures << CustomGesture::GestureType;
@@ -551,6 +554,41 @@ void tst_Gestures::conflictingGestures()
     sendCustomGesture(&event, child);
 
     QCOMPARE(child->gestureOverrideEventsReceived, 1);
+    QCOMPARE(child->gestureEventsReceived, 1);
+    QCOMPARE(parent.gestureOverrideEventsReceived, 1);
+    QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
+
+    parent.reset();
+    child->reset();
+
+    // nobody accepts the override, and nobody accepts the gesture event
+    parent.acceptGestureOverride = false;
+    child->acceptGestureOverride = false;
+    parent.ignoredGestures << CustomGesture::GestureType;
+    child->ignoredGestures << CustomGesture::GestureType;
+
+    // sending events to the child and making sure there is no conflict
+    sendCustomGesture(&event, child);
+
+    QCOMPARE(child->gestureOverrideEventsReceived, 1);
+    QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(parent.gestureOverrideEventsReceived, 1);
+    QCOMPARE(parent.gestureEventsReceived, 1);
+
+    parent.reset();
+    child->reset();
+
+    // we set an attribute to make sure all gesture events are propagated
+    parent.grabGesture(CustomGesture::GestureType, Qt::ReceivePartialGestures);
+    parent.acceptGestureOverride = false;
+    child->acceptGestureOverride = false;
+    parent.ignoredGestures << CustomGesture::GestureType;
+    child->ignoredGestures << CustomGesture::GestureType;
+
+    // sending events to the child and making sure there is no conflict
+    sendCustomGesture(&event, child);
+
+    QCOMPARE(child->gestureOverrideEventsReceived, 1);
     QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);
     QCOMPARE(parent.gestureOverrideEventsReceived, 1);
     QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
@@ -558,7 +596,7 @@ void tst_Gestures::conflictingGestures()
     parent.reset();
     child->reset();
 
-    Qt::GestureType ContinuousGesture = QApplication::registerGestureRecognizer(new CustomContinuousGestureRecognizer);
+    Qt::GestureType ContinuousGesture = QGestureRecognizer::registerRecognizer(new CustomContinuousGestureRecognizer);
     static const int ContinuousGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
     child->grabGesture(ContinuousGesture);
     // child accepts override. And it also receives another custom gesture.
@@ -572,13 +610,13 @@ void tst_Gestures::conflictingGestures()
     QCOMPARE(parent.gestureOverrideEventsReceived, 0);
     QCOMPARE(parent.gestureEventsReceived, 0);
 
-    QApplication::unregisterGestureRecognizer(ContinuousGesture);
+    QGestureRecognizer::unregisterRecognizer(ContinuousGesture);
 }
 
 void tst_Gestures::finishedWithoutStarted()
 {
     GestureWidget widget;
-    widget.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
+    widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
     // the gesture will claim it finished, but it was never started.
     CustomEvent ev;
@@ -598,9 +636,9 @@ void tst_Gestures::finishedWithoutStarted()
 void tst_Gestures::unknownGesture()
 {
     GestureWidget widget;
-    widget.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
-    widget.grabGesture(Qt::CustomGesture, Qt::WidgetGesture);
-    widget.grabGesture(Qt::GestureType(Qt::PanGesture+512), Qt::WidgetGesture);
+    widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
+    widget.grabGesture(Qt::CustomGesture, Qt::DontStartGestureOnChildren);
+    widget.grabGesture(Qt::GestureType(Qt::PanGesture+512), Qt::DontStartGestureOnChildren);
 
     CustomEvent event;
     sendCustomGesture(&event, &widget);
@@ -702,7 +740,7 @@ protected:
         }
         if (eventsPtr) {
             QGestureEvent *e = static_cast<QGestureEvent*>(event);
-            QList<QGesture*> gestures = e->allGestures();
+            QList<QGesture*> gestures = e->gestures();
             foreach(QGesture *g, gestures) {
                 eventsPtr->all << g->gestureType();
                 switch(g->state()) {
@@ -746,7 +784,7 @@ void tst_Gestures::graphicsItemGesture()
     QTest::qWaitForWindowShown(&view);
     view.ensureVisible(scene.sceneRect());
 
-    view.viewport()->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
+    view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
     item->grabGesture(CustomGesture::GestureType);
 
     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
@@ -820,7 +858,7 @@ void tst_Gestures::graphicsItemTreeGesture()
     QTest::qWaitForWindowShown(&view);
     view.ensureVisible(scene.sceneRect());
 
-    view.viewport()->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
+    view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
     item1->grabGesture(CustomGesture::GestureType);
 
     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
@@ -850,7 +888,7 @@ void tst_Gestures::graphicsItemTreeGesture()
     QCOMPARE(item1_child2->gestureEventsReceived, 0);
     QCOMPARE(item1_child2->gestureOverrideEventsReceived, 0);
     QCOMPARE(item1->gestureOverrideEventsReceived, 1);
-    QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(item1->gestureEventsReceived, 1);
 }
 
 void tst_Gestures::explicitGraphicsObjectTarget()
@@ -878,10 +916,10 @@ void tst_Gestures::explicitGraphicsObjectTarget()
     QTest::qWaitForWindowShown(&view);
     view.ensureVisible(scene.sceneRect());
 
-    view.viewport()->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
-    item1->grabGesture(CustomGesture::GestureType, Qt::ItemGesture);
-    item2->grabGesture(CustomGesture::GestureType, Qt::ItemGesture);
-    item2_child1->grabGesture(CustomGesture::GestureType, Qt::ItemGesture);
+    view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
+    item1->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
+    item2->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
+    item2_child1->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
@@ -938,7 +976,7 @@ void tst_Gestures::gestureOverChildGraphicsItem()
     QTest::qWaitForWindowShown(&view);
     view.ensureVisible(scene.sceneRect());
 
-    view.viewport()->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
+    view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
     item1->grabGesture(CustomGesture::GestureType);
 
     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
@@ -965,7 +1003,39 @@ void tst_Gestures::gestureOverChildGraphicsItem()
     event.hasHotSpot = true;
     sendCustomGesture(&event, item0, &scene);
 
-    QCOMPARE(item0->customEventsReceived, TotalCustomEventsCount);
+    QCOMPARE(item2_child1->gestureEventsReceived, 0);
+    QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);
+    QCOMPARE(item2->gestureEventsReceived, 1);
+    QCOMPARE(item2->gestureOverrideEventsReceived, 1);
+    QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(item1->gestureOverrideEventsReceived, 1);
+
+    item0->reset(); item1->reset(); item2->reset(); item2_child1->reset();
+    item2->grabGesture(CustomGesture::GestureType);
+    item2->ignoredGestures << CustomGesture::GestureType;
+    item1->ignoredGestures << CustomGesture::GestureType;
+
+    event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);
+    event.hasHotSpot = true;
+    sendCustomGesture(&event, item0, &scene);
+
+    QCOMPARE(item2_child1->gestureEventsReceived, 0);
+    QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);
+    QCOMPARE(item2->gestureEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(item2->gestureOverrideEventsReceived, 1);
+    QCOMPARE(item1->gestureEventsReceived, 1);
+    QCOMPARE(item1->gestureOverrideEventsReceived, 1);
+
+    item0->reset(); item1->reset(); item2->reset(); item2_child1->reset();
+    item2->grabGesture(CustomGesture::GestureType);
+    item2->ignoredGestures << CustomGesture::GestureType;
+    item1->ignoredGestures << CustomGesture::GestureType;
+    item1->grabGesture(CustomGesture::GestureType, Qt::ReceivePartialGestures);
+
+    event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);
+    event.hasHotSpot = true;
+    sendCustomGesture(&event, item0, &scene);
+
     QCOMPARE(item2_child1->gestureEventsReceived, 0);
     QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);
     QCOMPARE(item2->gestureEventsReceived, TotalGestureEventsCount);
@@ -981,10 +1051,10 @@ void tst_Gestures::twoGesturesOnDifferentLevel()
     GestureWidget *child = new GestureWidget("child");
     l->addWidget(child);
 
-    Qt::GestureType SecondGesture = QApplication::registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType SecondGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
 
-    parent.grabGesture(CustomGesture::GestureType, Qt::WidgetWithChildrenGesture);
-    child->grabGesture(SecondGesture, Qt::WidgetWithChildrenGesture);
+    parent.grabGesture(CustomGesture::GestureType);
+    child->grabGesture(SecondGesture);
 
     CustomEvent event;
     // sending events that form a gesture to one widget, but they will be
@@ -1009,7 +1079,7 @@ void tst_Gestures::twoGesturesOnDifferentLevel()
     for(int i = 0; i < child->events.all.size(); ++i)
         QCOMPARE(parent.events.all.at(i), CustomGesture::GestureType);
 
-    QApplication::unregisterGestureRecognizer(SecondGesture);
+    QGestureRecognizer::unregisterRecognizer(SecondGesture);
 }
 
 void tst_Gestures::multipleGesturesInTree()
@@ -1021,18 +1091,19 @@ void tst_Gestures::multipleGesturesInTree()
     GestureWidget *D = new GestureWidget("D", C);
 
     Qt::GestureType FirstGesture  = CustomGesture::GestureType;
-    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);   // |
-    B->grabGesture(SecondGesture, Qt::WidgetWithChildrenGesture);  // B [  2 3]
-    B->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);   // |
-    C->grabGesture(FirstGesture, Qt::WidgetWithChildrenGesture);   // C [1 2 3]
-    C->grabGesture(SecondGesture, Qt::WidgetWithChildrenGesture);  // |
-    C->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);   // D [1   3]
-    D->grabGesture(FirstGesture, Qt::WidgetWithChildrenGesture);
-    D->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);
+    Qt::GestureType SecondGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType ThirdGesture  = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
+
+    Qt::GestureFlags flags = Qt::ReceivePartialGestures;
+    A->grabGesture(FirstGesture,  flags);   // A [1   3]
+    A->grabGesture(ThirdGesture,  flags);   // |
+    B->grabGesture(SecondGesture, flags);   // B [  2 3]
+    B->grabGesture(ThirdGesture,  flags);   // |
+    C->grabGesture(FirstGesture,  flags);   // C [1 2 3]
+    C->grabGesture(SecondGesture, flags);   // |
+    C->grabGesture(ThirdGesture,  flags);   // D [1   3]
+    D->grabGesture(FirstGesture,  flags);
+    D->grabGesture(ThirdGesture,  flags);
 
     // make sure all widgets ignore events, so they get propagated.
     A->ignoredGestures << FirstGesture << ThirdGesture;
@@ -1079,8 +1150,8 @@ void tst_Gestures::multipleGesturesInTree()
     QCOMPARE(A->events.all.count(SecondGesture), 0);
     QCOMPARE(A->events.all.count(ThirdGesture), TotalGestureEventsCount);
 
-    QApplication::unregisterGestureRecognizer(SecondGesture);
-    QApplication::unregisterGestureRecognizer(ThirdGesture);
+    QGestureRecognizer::unregisterRecognizer(SecondGesture);
+    QGestureRecognizer::unregisterRecognizer(ThirdGesture);
 }
 
 void tst_Gestures::multipleGesturesInComplexTree()
@@ -1092,26 +1163,27 @@ void tst_Gestures::multipleGesturesInComplexTree()
     GestureWidget *D = new GestureWidget("D", C);
 
     Qt::GestureType FirstGesture   = CustomGesture::GestureType;
-    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);   // |
-    A->grabGesture(FourthGesture, Qt::WidgetWithChildrenGesture);  // B [2,3,5]
-    B->grabGesture(SecondGesture, Qt::WidgetWithChildrenGesture);  // |
-    B->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);   // C [1,2,3,6]
-    B->grabGesture(FifthGesture, Qt::WidgetWithChildrenGesture);   // |
-    C->grabGesture(FirstGesture, Qt::WidgetWithChildrenGesture);   // D [1,3,7]
-    C->grabGesture(SecondGesture, Qt::WidgetWithChildrenGesture);
-    C->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);
-    C->grabGesture(SixthGesture, Qt::WidgetWithChildrenGesture);
-    D->grabGesture(FirstGesture, Qt::WidgetWithChildrenGesture);
-    D->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);
-    D->grabGesture(SeventhGesture, Qt::WidgetWithChildrenGesture);
+    Qt::GestureType SecondGesture  = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType ThirdGesture   = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType FourthGesture  = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType FifthGesture   = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType SixthGesture   = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType SeventhGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
+
+    Qt::GestureFlags flags = Qt::ReceivePartialGestures;
+    A->grabGesture(FirstGesture,   flags); // A [1,3,4]
+    A->grabGesture(ThirdGesture,   flags); // |
+    A->grabGesture(FourthGesture,  flags); // B [2,3,5]
+    B->grabGesture(SecondGesture,  flags); // |
+    B->grabGesture(ThirdGesture,   flags); // C [1,2,3,6]
+    B->grabGesture(FifthGesture,   flags); // |
+    C->grabGesture(FirstGesture,   flags); // D [1,3,7]
+    C->grabGesture(SecondGesture,  flags);
+    C->grabGesture(ThirdGesture,   flags);
+    C->grabGesture(SixthGesture,   flags);
+    D->grabGesture(FirstGesture,   flags);
+    D->grabGesture(ThirdGesture,   flags);
+    D->grabGesture(SeventhGesture, flags);
 
     // make sure all widgets ignore events, so they get propagated.
     QSet<Qt::GestureType> allGestureTypes;
@@ -1175,12 +1247,12 @@ void tst_Gestures::multipleGesturesInComplexTree()
     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);
+    QGestureRecognizer::unregisterRecognizer(SecondGesture);
+    QGestureRecognizer::unregisterRecognizer(ThirdGesture);
+    QGestureRecognizer::unregisterRecognizer(FourthGesture);
+    QGestureRecognizer::unregisterRecognizer(FifthGesture);
+    QGestureRecognizer::unregisterRecognizer(SixthGesture);
+    QGestureRecognizer::unregisterRecognizer(SeventhGesture);
 }
 
 void tst_Gestures::testMapToScene()
@@ -1189,7 +1261,7 @@ void tst_Gestures::testMapToScene()
     QList<QGesture*> list;
     list << &gesture;
     QGestureEvent event(list);
-    QCOMPARE(event.mapToScene(gesture.hotSpot()), QPointF()); // not set, can't do much
+    QCOMPARE(event.mapToGraphicsScene(gesture.hotSpot()), QPointF()); // not set, can't do much
 
     QGraphicsScene scene;
     QGraphicsView view(&scene);
@@ -1206,7 +1278,7 @@ void tst_Gestures::testMapToScene()
     QPoint origin = view.mapToGlobal(QPoint());
     event.setWidget(view.viewport());
 
-    QCOMPARE(event.mapToScene(origin + QPoint(100, 200)), view.mapToScene(QPoint(100, 200)));
+    QCOMPARE(event.mapToGraphicsScene(origin + QPoint(100, 200)), view.mapToScene(QPoint(100, 200)));
 }
 
 void tst_Gestures::ungrabGesture() // a method on QWidget
@@ -1224,7 +1296,7 @@ void tst_Gestures::ungrabGesture() // a method on QWidget
             if (event->type() == QEvent::Gesture) {
                 QGestureEvent *gestureEvent = static_cast<QGestureEvent*>(event);
                 if (gestureEvent)
-                    foreach (QGesture *g, gestureEvent->allGestures())
+                    foreach (QGesture *g, gestureEvent->gestures())
                         gestures.insert(g);
             }
             return GestureWidget::event(event);
@@ -1235,8 +1307,8 @@ void tst_Gestures::ungrabGesture() // a method on QWidget
     MockGestureWidget *a = &parent;
     MockGestureWidget *b = new MockGestureWidget("B", a);
 
-    a->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
-    b->grabGesture(CustomGesture::GestureType, Qt::WidgetWithChildrenGesture);
+    a->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
+    b->grabGesture(CustomGesture::GestureType);
     b->ignoredGestures << CustomGesture::GestureType;
 
     CustomEvent event;
@@ -1295,20 +1367,6 @@ void tst_Gestures::unregisterRecognizer() // a method on QApplication
 
 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) { }
@@ -1317,21 +1375,25 @@ void tst_Gestures::autoCancelGestures()
         {
             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);
+                Q_ASSERT(ge->gestures().count() == 1); // can't use QCOMPARE here...
+                ge->gestures().first()->setGestureCancelPolicy(QGesture::CancelAllInContext);
             }
             return GestureWidget::event(event);
         }
     };
 
+    const Qt::GestureType secondGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
+
     MockWidget parent("parent"); // this one sets the cancel policy to CancelAllInContext
     parent.resize(300, 100);
+    parent.setWindowFlags(Qt::X11BypassWindowManagerHint);
     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);
+    parent.grabGesture(CustomGesture::GestureType);
+    child->grabGesture(secondGesture);
+    parent.show();
+    QTest::qWaitForWindowShown(&parent);
 
     /*
       An event is send to both the child and the parent, when the child gets it a gesture is triggered
@@ -1340,18 +1402,73 @@ void tst_Gestures::autoCancelGestures()
       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);
+    CustomEvent event;
+    event.serial = CustomGesture::SerialStartedThreshold;
     QApplication::sendEvent(child, &event);
+    QCOMPARE(child->events.all.count(), 2);
     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(child->events.canceled.count(), 1);
     QCOMPARE(parent.events.all.count(), 1);
-    QCOMPARE(parent.events.started.count(), 1);
-    QCOMPARE(child->events.started.count(), 0);
-    QCOMPARE(child->events.all.count(), 1);
+
+    // clean up, make the parent gesture finish
+    event.serial = CustomGesture::SerialFinishedThreshold;
+    QApplication::sendEvent(child, &event);
+    QCOMPARE(parent.events.all.count(), 2);
+}
+
+void tst_Gestures::autoCancelGestures2()
+{
+    class MockItem : public GestureItem {
+      public:
+        MockItem(const char *name) : GestureItem(name) { }
+
+        bool event(QEvent *event) {
+            if (event->type() == QEvent::Gesture) {
+                QGestureEvent *ge = static_cast<QGestureEvent*>(event);
+                Q_ASSERT(ge->gestures().count() == 1); // can't use QCOMPARE here...
+                ge->gestures().first()->setGestureCancelPolicy(QGesture::CancelAllInContext);
+            }
+            return GestureItem::event(event);
+        }
+    };
+
+    const Qt::GestureType secondGesture = QGestureRecognizer ::registerRecognizer(new CustomGestureRecognizer);
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.setWindowFlags(Qt::X11BypassWindowManagerHint);
+
+    MockItem *parent = new MockItem("parent");
+    GestureItem *child = new GestureItem("child");
+    child->setParentItem(parent);
+    parent->setPos(0, 0);
+    child->setPos(10, 10);
+    scene.addItem(parent);
+    view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
+    view.viewport()->grabGesture(secondGesture, Qt::DontStartGestureOnChildren);
+    parent->grabGesture(CustomGesture::GestureType);
+    child->grabGesture(secondGesture);
+
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    view.ensureVisible(scene.sceneRect());
+
+    CustomEvent event;
+    event.serial = CustomGesture::SerialStartedThreshold;
+    event.hasHotSpot = true;
+    event.hotSpot = mapToGlobal(QPointF(5, 5), child, &view);
+    // qDebug() << event.hotSpot;
+    scene.sendEvent(child, &event);
+    //QEventLoop().exec();
+    QCOMPARE(parent->events.all.count(), 1);
+    QCOMPARE(child->events.started.count(), 1);
     QCOMPARE(child->events.canceled.count(), 1);
+    QCOMPARE(child->events.all.count(), 2);
+
+    // clean up, make the parent gesture finish
+    event.serial = CustomGesture::SerialFinishedThreshold;
+    scene.sendEvent(child, &event);
+    QCOMPARE(parent->events.all.count(), 2);
 }
 
 QTEST_MAIN(tst_Gestures)
diff --git a/tests/auto/linguist/lrelease/tst_lrelease.cpp b/tests/auto/linguist/lrelease/tst_lrelease.cpp
index 39de8a1..93cb97c 100644
--- a/tests/auto/linguist/lrelease/tst_lrelease.cpp
+++ b/tests/auto/linguist/lrelease/tst_lrelease.cpp
@@ -60,6 +60,7 @@ private slots:
     void mixedcodecs();
     void compressed();
     void idbased();
+    void markuntranslated();
     void dupes();
 
 private:
@@ -210,6 +211,18 @@ void tst_lrelease::idbased()
     QCOMPARE(qtTrId("untranslated_id"), QString::fromAscii("This has no translation."));
 }
 
+void tst_lrelease::markuntranslated()
+{
+    QVERIFY(!QProcess::execute(binDir + "/lrelease -markuntranslated # -idbased testdata/idbased.ts"));
+
+    QTranslator translator;
+    QVERIFY(translator.load("testdata/idbased.qm"));
+    qApp->installTranslator(&translator);
+
+    QCOMPARE(qtTrId("test_id"), QString::fromAscii("This is a test string."));
+    QCOMPARE(qtTrId("untranslated_id"), QString::fromAscii("#This has no translation."));
+}
+
 void tst_lrelease::dupes()
 {
     QProcess proc;
diff --git a/tests/auto/linguist/lupdate/testdata/good/parsecpp2/main.cpp b/tests/auto/linguist/lupdate/testdata/good/parsecpp2/main.cpp
index eaa271a..7ddb68f 100644
--- a/tests/auto/linguist/lupdate/testdata/good/parsecpp2/main.cpp
+++ b/tests/auto/linguist/lupdate/testdata/good/parsecpp2/main.cpp
@@ -63,3 +63,52 @@ line c++ comment } (with brace)
 #define This is another // comment in } define \
      something } comment
 } // complain here
+
+
+
+// Nested class in same file
+class TopLevel {
+    Q_OBJECT
+
+    class Nested;
+};
+
+class TopLevel::Nested {
+    void foo();
+};
+
+TopLevel::Nested::foo()
+{
+    TopLevel::tr("TopLevel");
+}
+
+// Nested class in other file
+#include "main.h"
+
+class TopLevel2::Nested {
+    void foo();
+};
+
+TopLevel2::Nested::foo()
+{
+    TopLevel2::tr("TopLevel2");
+}
+
+
+
+namespace NameSpace {
+class ToBeUsed;
+}
+
+// using statement before class definition
+using NameSpace::ToBeUsed;
+
+class NameSpace::ToBeUsed {
+    Q_OBJECT
+    void caller();
+};
+
+void ToBeUsed::caller()
+{
+    tr("NameSpace::ToBeUsed");
+}
diff --git a/tests/auto/linguist/lupdate/testdata/good/parsecpp2/main.h b/tests/auto/linguist/lupdate/testdata/good/parsecpp2/main.h
new file mode 100644
index 0000000..54a76ab
--- /dev/null
+++ b/tests/auto/linguist/lupdate/testdata/good/parsecpp2/main.h
@@ -0,0 +1,51 @@
+/****************************************************************************
+**
+** 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 QtCore module 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$
+**
+****************************************************************************/
+
+// IMPORTANT!!!! If you want to add testdata to this file,
+// always add it to the end in order to not change the linenumbers of translations!!!
+
+class TopLevel2 {
+    Q_OBJECT
+
+    class Nested;
+};
+
+
diff --git a/tests/auto/linguist/lupdate/testdata/good/parsecpp2/project.ts.result b/tests/auto/linguist/lupdate/testdata/good/parsecpp2/project.ts.result
index 07a7469..6f48e27 100644
--- a/tests/auto/linguist/lupdate/testdata/good/parsecpp2/project.ts.result
+++ b/tests/auto/linguist/lupdate/testdata/good/parsecpp2/project.ts.result
@@ -1,4 +1,28 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE TS>
 <TS version="2.0">
+<context>
+    <name>NameSpace::ToBeUsed</name>
+    <message>
+        <location filename="main.cpp" line="113"/>
+        <source>NameSpace::ToBeUsed</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>TopLevel</name>
+    <message>
+        <location filename="main.cpp" line="82"/>
+        <source>TopLevel</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>TopLevel2</name>
+    <message>
+        <location filename="main.cpp" line="94"/>
+        <source>TopLevel2</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 </TS>
diff --git a/tests/auto/q3filedialog/tst_q3filedialog.cpp b/tests/auto/q3filedialog/tst_q3filedialog.cpp
index 2585f60..e2686eb 100644
--- a/tests/auto/q3filedialog/tst_q3filedialog.cpp
+++ b/tests/auto/q3filedialog/tst_q3filedialog.cpp
@@ -59,7 +59,9 @@ public:
     virtual ~tst_Q3FileDialog();
 
 private slots:
+#ifndef QT_MAC_USE_COCOA
     void getSetCheck();
+#endif
 };
 
 tst_Q3FileDialog::tst_Q3FileDialog()
@@ -70,6 +72,7 @@ tst_Q3FileDialog::~tst_Q3FileDialog()
 {
 }
 
+#ifndef QT_MAC_USE_COCOA
   class Preview : public QLabel, public Q3FilePreview
   {
   public:
@@ -125,6 +128,7 @@ void tst_Q3FileDialog::getSetCheck()
     obj1.setPreviewMode(Q3FileDialog::PreviewMode(Q3FileDialog::Info));
     QCOMPARE(obj1.previewMode(), Q3FileDialog::PreviewMode(Q3FileDialog::Info));
 }
+#endif
 
 QTEST_MAIN(tst_Q3FileDialog)
 #include "tst_q3filedialog.moc"
diff --git a/tests/auto/qabstractvideosurface/tst_qabstractvideosurface.cpp b/tests/auto/qabstractvideosurface/tst_qabstractvideosurface.cpp
index 20ca759..b4d2ac8 100644
--- a/tests/auto/qabstractvideosurface/tst_qabstractvideosurface.cpp
+++ b/tests/auto/qabstractvideosurface/tst_qabstractvideosurface.cpp
@@ -61,6 +61,8 @@ private slots:
     void setError();
     void isFormatSupported_data();
     void isFormatSupported();
+    void nearestFormat_data();
+    void nearestFormat();
     void start_data();
     void start();
 };
@@ -232,6 +234,22 @@ void tst_QAbstractVideoSurface::isFormatSupported()
     QCOMPARE(surface.isFormatSupported(format), supported);
 }
 
+void tst_QAbstractVideoSurface::nearestFormat_data()
+{
+    isFormatSupported_data();
+}
+
+void tst_QAbstractVideoSurface::nearestFormat()
+{
+    QFETCH(SupportedFormatMap, supportedFormats);
+    QFETCH(QVideoSurfaceFormat, format);
+    QFETCH(bool, supported);
+
+    QtTestVideoSurface surface(supportedFormats);
+
+    QCOMPARE(surface.nearestFormat(format) == format, supported);
+}
+
 void tst_QAbstractVideoSurface::start_data()
 {
     QTest::addColumn<QVideoSurfaceFormat>("format");
@@ -256,35 +274,35 @@ void tst_QAbstractVideoSurface::start()
     surface.setError(QAbstractVideoSurface::ResourceError);
 
     QSignalSpy formatSpy(&surface, SIGNAL(surfaceFormatChanged(QVideoSurfaceFormat)));
-    QSignalSpy startedSpy(&surface, SIGNAL(startedChanged(bool)));
+    QSignalSpy activeSpy(&surface, SIGNAL(activeChanged(bool)));
 
-    QVERIFY(!surface.isStarted());
+    QVERIFY(!surface.isActive());
     QCOMPARE(surface.surfaceFormat(), QVideoSurfaceFormat());
 
     QVERIFY(surface.start(format));
 
-    QVERIFY(surface.isStarted());
+    QVERIFY(surface.isActive());
     QCOMPARE(surface.surfaceFormat(), format);
 
     QCOMPARE(formatSpy.count(), 1);
-    QCOMPARE(qvariant_cast<QVideoSurfaceFormat>(formatSpy.at(0).at(0)), format);
+    QCOMPARE(qvariant_cast<QVideoSurfaceFormat>(formatSpy.last().at(0)), format);
 
-    QCOMPARE(startedSpy.count(), 1);
-    QCOMPARE(startedSpy.at(0).at(0).toBool(), true);
+    QCOMPARE(activeSpy.count(), 1);
+    QCOMPARE(activeSpy.last().at(0).toBool(), true);
 
     // error() is reset on a successful start.
     QCOMPARE(surface.error(), QAbstractVideoSurface::NoError);
 
     surface.stop();
 
-    QVERIFY(!surface.isStarted());
+    QVERIFY(!surface.isActive());
     QCOMPARE(surface.surfaceFormat(), QVideoSurfaceFormat());
 
     QCOMPARE(formatSpy.count(), 2);
-    QCOMPARE(qvariant_cast<QVideoSurfaceFormat>(formatSpy.at(1).at(0)), QVideoSurfaceFormat());
+    QCOMPARE(qvariant_cast<QVideoSurfaceFormat>(formatSpy.last().at(0)), QVideoSurfaceFormat());
 
-    QCOMPARE(startedSpy.count(), 2);
-    QCOMPARE(startedSpy.at(1).at(0).toBool(), false);
+    QCOMPARE(activeSpy.count(), 2);
+    QCOMPARE(activeSpy.last().at(0).toBool(), false);
 }
 
 QTEST_MAIN(tst_QAbstractVideoSurface)
diff --git a/tests/auto/qaccessibility/tst_qaccessibility.cpp b/tests/auto/qaccessibility/tst_qaccessibility.cpp
index 9f2e4e7..25c2649 100644
--- a/tests/auto/qaccessibility/tst_qaccessibility.cpp
+++ b/tests/auto/qaccessibility/tst_qaccessibility.cpp
@@ -4034,6 +4034,27 @@ void tst_QAccessibility::labelTest()
     delete acc_label;
     delete label;
     QTestAccessibility::clearEvents();
+
+    QPixmap testPixmap(50, 50);
+    testPixmap.fill();
+
+    QLabel imageLabel;
+    imageLabel.setPixmap(testPixmap);
+    imageLabel.setToolTip("Test Description");
+
+    acc_label = QAccessible::queryAccessibleInterface(&imageLabel);
+    QVERIFY(acc_label);
+
+    QAccessibleImageInterface *imageInterface = acc_label->imageInterface();
+    QVERIFY(imageInterface);
+
+    QCOMPARE(imageInterface->imageSize(), testPixmap.size());
+    QCOMPARE(imageInterface->imageDescription(), QString::fromLatin1("Test Description"));
+    QCOMPARE(imageInterface->imagePosition(QAccessible2::RelativeToParent), imageLabel.geometry());
+
+    delete acc_label;
+
+    QTestAccessibility::clearEvents();
 #else
     QSKIP("Test needs accessibility support.", SkipAll);
 #endif
diff --git a/tests/auto/qanimationgroup/tst_qanimationgroup.cpp b/tests/auto/qanimationgroup/tst_qanimationgroup.cpp
index 81c51ed..b4e4a49 100644
--- a/tests/auto/qanimationgroup/tst_qanimationgroup.cpp
+++ b/tests/auto/qanimationgroup/tst_qanimationgroup.cpp
@@ -165,9 +165,9 @@ void tst_QAnimationGroup::emptyGroup()
 
     QCOMPARE(groupStateChangedSpy.count(), 2);
 
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(1).first()),
              QAnimationGroup::Stopped);
 
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
@@ -180,9 +180,9 @@ void tst_QAnimationGroup::emptyGroup()
 
     group.start();
 
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(2).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(2).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(3).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(3).first()),
              QAnimationGroup::Stopped);
 
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
@@ -259,54 +259,54 @@ void tst_QAnimationGroup::setCurrentTime()
     QCOMPARE(notTimeDriven->state(), QAnimationGroup::Stopped);
     QCOMPARE(loopsForever->state(), QAnimationGroup::Stopped);
 
-    QCOMPARE(group.currentTime(), 1);
-    QCOMPARE(sequence->currentTime(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 1);
-    QCOMPARE(a2_s_o1->currentTime(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 1);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
-    QCOMPARE(a1_p_o1->currentTime(), 1);
-    QCOMPARE(a1_p_o2->currentTime(), 1);
-    QCOMPARE(a1_p_o3->currentTime(), 1);
-    QCOMPARE(notTimeDriven->currentTime(), 1);
-    QCOMPARE(loopsForever->currentTime(), 1);
+    QCOMPARE(group.currentLoopTime(), 1);
+    QCOMPARE(sequence->currentLoopTime(), 1);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 1);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 1);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
+    QCOMPARE(a1_p_o1->currentLoopTime(), 1);
+    QCOMPARE(a1_p_o2->currentLoopTime(), 1);
+    QCOMPARE(a1_p_o3->currentLoopTime(), 1);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 1);
+    QCOMPARE(loopsForever->currentLoopTime(), 1);
 
     // Current time = 250
     group.setCurrentTime(250);
-    QCOMPARE(group.currentTime(), 250);
-    QCOMPARE(sequence->currentTime(), 250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
-    QCOMPARE(a1_p_o1->currentTime(), 250);
-    QCOMPARE(a1_p_o2->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 250);
+    QCOMPARE(sequence->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
+    QCOMPARE(a1_p_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_p_o2->currentLoopTime(), 0);
     QCOMPARE(a1_p_o2->currentLoop(), 1);
-    QCOMPARE(a1_p_o3->currentTime(), 250);
-    QCOMPARE(notTimeDriven->currentTime(), 250);
-    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(a1_p_o3->currentLoopTime(), 250);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 250);
+    QCOMPARE(loopsForever->currentLoopTime(), 0);
     QCOMPARE(loopsForever->currentLoop(), 1);
     QCOMPARE(sequence->currentAnimation(), a2_s_o1);
 
     // Current time = 251
     group.setCurrentTime(251);
-    QCOMPARE(group.currentTime(), 251);
-    QCOMPARE(sequence->currentTime(), 251);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 1);
+    QCOMPARE(group.currentLoopTime(), 251);
+    QCOMPARE(sequence->currentLoopTime(), 251);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 1);
     QCOMPARE(a2_s_o1->currentLoop(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(sequence2->currentTime(), 251);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 1);
-    QCOMPARE(a1_p_o1->currentTime(), 250);
-    QCOMPARE(a1_p_o2->currentTime(), 1);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(sequence2->currentLoopTime(), 251);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 1);
+    QCOMPARE(a1_p_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_p_o2->currentLoopTime(), 1);
     QCOMPARE(a1_p_o2->currentLoop(), 1);
-    QCOMPARE(a1_p_o3->currentTime(), 250);
-    QCOMPARE(notTimeDriven->currentTime(), 251);
-    QCOMPARE(loopsForever->currentTime(), 1);
+    QCOMPARE(a1_p_o3->currentLoopTime(), 250);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 251);
+    QCOMPARE(loopsForever->currentLoopTime(), 1);
     QCOMPARE(sequence->currentAnimation(), a2_s_o1);
 }
 
@@ -356,7 +356,7 @@ void tst_QAnimationGroup::addChildTwice()
     parent->addAnimation(subGroup);
     QCOMPARE(parent->animationCount(), 1);
 
-    parent->clearAnimations();
+    parent->clear();
 
     QCOMPARE(parent->animationCount(), 0);
 
diff --git a/tests/auto/qclipboard/test/test.pro b/tests/auto/qclipboard/test/test.pro
index 508eba1..62a38af 100644
--- a/tests/auto/qclipboard/test/test.pro
+++ b/tests/auto/qclipboard/test/test.pro
@@ -13,7 +13,18 @@ win32 {
 wince*|symbian*: {
   copier.sources = ../copier/copier.exe
   copier.path = copier
-  paster.sources = ../paster/paster.exe
+  paster.sources = ../paster/paster.exe  
   paster.path = paster
-  DEPLOYMENT = copier paster
+  
+  symbian*: {
+    load(data_caging_paths)
+    rsc.sources = $${EPOCROOT}$$HW_ZDIR$$APP_RESOURCE_DIR/copier.rsc
+    rsc.sources += $${EPOCROOT}$$HW_ZDIR$$APP_RESOURCE_DIR/paster.rsc
+    rsc.path = $$APP_RESOURCE_DIR
+    reg_resource.sources = $${EPOCROOT}$$HW_ZDIR$$REG_RESOURCE_IMPORT_DIR/copier_reg.rsc
+    reg_resource.sources += $${EPOCROOT}$$HW_ZDIR$$REG_RESOURCE_IMPORT_DIR/paster_reg.rsc
+    reg_resource.path = $$REG_RESOURCE_IMPORT_DIR
+  }
+  
+  DEPLOYMENT = copier paster rsc reg_resource
 }
\ No newline at end of file
diff --git a/tests/auto/qcombobox/tst_qcombobox.cpp b/tests/auto/qcombobox/tst_qcombobox.cpp
index 51a7ff8..18ebddc 100644
--- a/tests/auto/qcombobox/tst_qcombobox.cpp
+++ b/tests/auto/qcombobox/tst_qcombobox.cpp
@@ -57,6 +57,7 @@
 #include <qtreewidget.h>
 #include <qtablewidget.h>
 #include <qscrollbar.h>
+#include <qboxlayout.h>
 #ifdef Q_WS_MAC
 #include <qmacstyle_mac.h>
 #elif defined Q_WS_X11
@@ -154,6 +155,7 @@ private slots:
     void removeItem();
     void resetModel();
     void keyBoardNavigationWithMouse();
+    void task_QTBUG_1071_changingFocusEmitsActivated();
 
 protected slots:
     void onEditTextChanged( const QString &newString );
@@ -813,21 +815,25 @@ void tst_QComboBox::autoCompletionCaseSensitivity()
 
     // case insensitive
     testWidget->clearEditText();
+    QSignalSpy spyReturn(testWidget, SIGNAL(activated(int)));
     testWidget->setAutoCompletionCaseSensitivity(Qt::CaseInsensitive);
     QVERIFY(testWidget->autoCompletionCaseSensitivity() == Qt::CaseInsensitive);
 
     QTest::keyClick(testWidget->lineEdit(), Qt::Key_A);
     qApp->processEvents();
     QCOMPARE(testWidget->currentText(), QString("aww"));
+    QCOMPARE(spyReturn.count(), 0);
 
     QTest::keyClick(testWidget->lineEdit(), Qt::Key_B);
     qApp->processEvents();
     // autocompletions preserve userkey-case from 4.2
     QCOMPARE(testWidget->currentText(), QString("abCDEF"));
+    QCOMPARE(spyReturn.count(), 0);
 
     QTest::keyClick(testWidget->lineEdit(), Qt::Key_Enter);
     qApp->processEvents();
     QCOMPARE(testWidget->currentText(), QString("aBCDEF")); // case restored to item's case
+    QCOMPARE(spyReturn.count(), 1);
 
     testWidget->clearEditText();
     QTest::keyClick(testWidget->lineEdit(), 'c');
@@ -2500,6 +2506,31 @@ void tst_QComboBox::keyBoardNavigationWithMouse()
     QTRY_COMPARE(combo.currentText(), QString::number(final));
 }
 
+void tst_QComboBox::task_QTBUG_1071_changingFocusEmitsActivated()
+{
+    QWidget w;
+    QVBoxLayout layout(&w);
+    QComboBox cb;
+    cb.setEditable(true);
+    QSignalSpy spy(&cb, SIGNAL(activated(int)));
+    cb.addItem("0");
+    cb.addItem("1");
+    cb.addItem("2");
+    QLineEdit edit;
+    layout.add(&cb);
+    layout.add(&edit);
+
+    w.show();
+    QTest::qWaitForWindowShown(&w);
+    cb.clearEditText();
+    cb.setFocus();
+    QApplication::processEvents();
+    QTest::keyClick(0, '1');
+    QCOMPARE(spy.count(), 0);
+    edit.setFocus();
+    QTRY_VERIFY(edit.hasFocus());
+    QTRY_COMPARE(spy.count(), 1);
+}
 
 QTEST_MAIN(tst_QComboBox)
 #include "tst_qcombobox.moc"
diff --git a/tests/auto/qcssparser/tst_qcssparser.cpp b/tests/auto/qcssparser/tst_qcssparser.cpp
index 150f131..3580252 100644
--- a/tests/auto/qcssparser/tst_qcssparser.cpp
+++ b/tests/auto/qcssparser/tst_qcssparser.cpp
@@ -1556,8 +1556,11 @@ void tst_QCssParser::extractFontFamily_data()
     QTest::newRow("shorthand") << "font: 12pt Times New Roman" << QString("Times New Roman");
     QTest::newRow("shorthand multiple quote") << "font: 12pt invalid, \"Times New Roman\" " << QString("Times New Roman");
     QTest::newRow("shorthand multiple") << "font: 12pt invalid, Times New Roman " << QString("Times New Roman");
+    QTest::newRow("invalid spaces") << "font-family: invalid spaces, Times New Roman " << QString("Times New Roman");
+    QTest::newRow("invalid spaces quotes") << "font-family: 'invalid spaces', 'Times New Roman' " << QString("Times New Roman");
 }
 
+
 void tst_QCssParser::extractFontFamily()
 {
     QFETCH(QString, css);
diff --git a/tests/auto/qdatetime/tst_qdatetime.cpp b/tests/auto/qdatetime/tst_qdatetime.cpp
index c53780e..1140402 100644
--- a/tests/auto/qdatetime/tst_qdatetime.cpp
+++ b/tests/auto/qdatetime/tst_qdatetime.cpp
@@ -450,11 +450,12 @@ void tst_QDateTime::toString_enumformat()
     qDebug() << str3;
     QVERIFY(!str3.isEmpty());
     //check for date/time components in any order
-    QVERIFY(str3.contains("1995"));
+    //year may be 2 or 4 digits
+    QVERIFY(str3.contains("95"));
     //day and month may be in numeric or word form
     QVERIFY(str3.contains("12"));
     QVERIFY(str3.contains("34"));
-    QVERIFY(str3.contains("56"));
+    //seconds may be absent
 }
 
 void tst_QDateTime::addDays()
diff --git a/tests/auto/qfile/largefile/largefile.pro b/tests/auto/qfile/largefile/largefile.pro
new file mode 100644
index 0000000..0f96865
--- /dev/null
+++ b/tests/auto/qfile/largefile/largefile.pro
@@ -0,0 +1,4 @@
+load(qttest_p4)
+
+QT = core
+SOURCES += tst_largefile.cpp
diff --git a/tests/auto/qfile/largefile/tst_largefile.cpp b/tests/auto/qfile/largefile/tst_largefile.cpp
new file mode 100644
index 0000000..9105063
--- /dev/null
+++ b/tests/auto/qfile/largefile/tst_largefile.cpp
@@ -0,0 +1,537 @@
+/****************************************************************************
+**
+** 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 <QTest>
+
+#include <QtAlgorithms>
+#include <QFile>
+#include <QFileInfo>
+#include <qplatformdefs.h>
+
+#include <QDebug>
+
+#include <cstdlib>
+#include <cstdio>
+
+#ifdef Q_OS_WIN
+
+#include <windows.h>
+#include <io.h>
+
+#ifndef FSCTL_SET_SPARSE
+// MinGW doesn't define this.
+#define FSCTL_SET_SPARSE (0x900C4)
+#endif
+
+#endif // Q_OS_WIN
+
+class tst_LargeFile
+    : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_LargeFile()
+        : blockSize(1 << 12)
+        , maxSizeBits()
+        , fd_(-1)
+        , stream_(0)
+    {
+    #if defined(QT_LARGEFILE_SUPPORT) && !defined(Q_OS_MAC)
+        maxSizeBits = 36; // 64 GiB
+    #elif defined(Q_OS_MAC)
+        // HFS+ does not support sparse files, so we limit file size for the test
+        // on Mac OS.
+        maxSizeBits = 32; // 4 GiB
+    #else
+        maxSizeBits = 24; // 16 MiB
+    #endif
+    }
+
+private:
+    void sparseFileData();
+    QByteArray const &getDataBlock(int index, qint64 position);
+
+private slots:
+    // The LargeFile test case was designed to be run in order as a single unit
+
+    void initTestCase();
+    void cleanupTestCase();
+
+    void init();
+    void cleanup();
+
+    // Create and fill large file
+    void createSparseFile();
+    void fillFileSparsely();
+    void closeSparseFile();
+
+    // Verify file was created
+    void fileCreated();
+
+    // Positioning in large files
+    void filePositioning();
+    void fdPositioning();
+    void streamPositioning();
+
+    // Read data from file
+    void openFileForReading();
+    void readFile();
+
+    // Map/unmap large file
+    void mapFile();
+    void mapOffsetOverflow();
+
+    void closeFile() { largeFile.close(); }
+
+    // Test data
+    void fillFileSparsely_data() { sparseFileData(); }
+    void filePositioning_data() { sparseFileData(); }
+    void fdPositioning_data() { sparseFileData(); }
+    void streamPositioning_data() { sparseFileData(); }
+    void readFile_data() { sparseFileData(); }
+    void mapFile_data() { sparseFileData(); }
+
+private:
+    const int blockSize;
+    int maxSizeBits;
+
+    QFile largeFile;
+
+    QVector<QByteArray> generatedBlocks;
+
+    int fd_;
+    FILE *stream_;
+};
+
+/*
+    Convenience function to hide reinterpret_cast when copying a POD directly
+    into a QByteArray.
+ */
+template <class T>
+static inline void appendRaw(QByteArray &array, T data)
+{
+    array.append(reinterpret_cast<char *>(&data), sizeof(T));
+}
+
+/*
+    Pad array with filler up to size. On return, array.size() returns size.
+ */
+static inline void topUpWith(QByteArray &array, QByteArray filler, int size)
+{
+    Q_ASSERT(filler.size() > 0);
+
+    for (int i = (size - array.size()) / filler.size(); i > 0; --i)
+        array.append(filler);
+
+    if (array.size() < size) {
+        Q_ASSERT(size - array.size() < filler.size());
+        array.append(filler.left(size - array.size()));
+    }
+}
+
+/*
+   Generate a unique data block containing identifiable data. Unaligned,
+   overlapping and partial blocks should not compare equal.
+ */
+static inline QByteArray generateDataBlock(int blockSize, QString text, qint64 userBits = -1)
+{
+    QByteArray block;
+    block.reserve(blockSize);
+
+    // Use of counter and randomBits means content of block will be dependent
+    // on the generation order. For (file-)systems that do not support sparse
+    // files, these can be removed so the test file can be reused and doesn't
+    // have to be generated for every run.
+
+    static qint64 counter = 0;
+
+    qint64 randomBits = ((qint64)qrand() << 32)
+            | ((qint64)qrand() & 0x00000000ffffffff);
+
+    appendRaw(block, randomBits);
+    appendRaw(block, userBits);
+    appendRaw(block, counter);
+    appendRaw(block, (qint32)0xdeadbeef);
+    appendRaw(block, blockSize);
+
+    QByteArray userContent = text.toUtf8();
+    appendRaw(block, userContent.size());
+    block.append(userContent);
+    appendRaw(block, (qint64)0);
+
+    // size, so far
+    appendRaw(block, block.size());
+
+    QByteArray filler("0123456789");
+    block.append(filler.right(10 - block.size() % 10));
+    topUpWith(block, filler, blockSize - 2 * sizeof(qint64));
+
+    appendRaw(block, counter);
+    appendRaw(block, userBits);
+    appendRaw(block, randomBits);
+
+    Q_ASSERT( block.size() >= blockSize );
+    block.resize(blockSize);
+
+    ++counter;
+    return block;
+}
+
+/*
+   Generates data blocks the first time they are requested. Keeps copies for reuse.
+ */
+QByteArray const &tst_LargeFile::getDataBlock(int index, qint64 position)
+{
+    if (index >= generatedBlocks.size())
+        generatedBlocks.resize(index + 1);
+
+    if (generatedBlocks[index].isNull()) {
+        QString text = QString("Current %1-byte block (index = %2) "
+            "starts %3 bytes into the file '%4'.")
+                .arg(blockSize)
+                .arg(index)
+                .arg(position)
+                .arg("qt_largefile.tmp");
+
+        generatedBlocks[index] = generateDataBlock(blockSize, text, (qint64)1 << index);
+    }
+
+    return generatedBlocks[index];
+}
+
+void tst_LargeFile::initTestCase()
+{
+    QFile file("qt_largefile.tmp");
+    QVERIFY( !file.exists() || file.remove() );
+}
+
+void tst_LargeFile::cleanupTestCase()
+{
+    if (largeFile.isOpen())
+        largeFile.close();
+
+    QFile file("qt_largefile.tmp");
+    QVERIFY( !file.exists() || file.remove() );
+}
+
+void tst_LargeFile::init()
+{
+    fd_ = -1;
+    stream_ = 0;
+}
+
+void tst_LargeFile::cleanup()
+{
+    if (-1 != fd_)
+        QT_CLOSE(fd_);
+    if (stream_)
+        ::fclose(stream_);
+}
+
+void tst_LargeFile::sparseFileData()
+{
+    QTest::addColumn<int>("index");
+    QTest::addColumn<qint64>("position");
+    QTest::addColumn<QByteArray>("block");
+
+    QTest::newRow(QString("block[%1] @%2)")
+            .arg(0).arg(0)
+            .toLocal8Bit().constData())
+        << 0 << (qint64)0 << getDataBlock(0, 0);
+
+    // While on Linux sparse files scale well, on Windows, testing at every
+    // power of 2 leads to very large files. i += 4 gives us a good coverage
+    // without taxing too much on resources.
+    for (int index = 12; index <= maxSizeBits; index += 4) {
+        qint64 position = (qint64)1 << index;
+        QByteArray block = getDataBlock(index, position);
+
+        QTest::newRow(
+            QString("block[%1] @%2)")
+                .arg(index).arg(position)
+                .toLocal8Bit().constData())
+            << index << position << block;
+    }
+}
+
+void tst_LargeFile::createSparseFile()
+{
+#if defined(Q_OS_WIN)
+    // On Windows platforms, we must explicitly set the file to be sparse,
+    // so disk space is not allocated for the full file when writing to it.
+    HANDLE handle = ::CreateFileA("qt_largefile.tmp",
+        GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);
+    QVERIFY( INVALID_HANDLE_VALUE != handle );
+
+    DWORD bytes;
+    if (!::DeviceIoControl(handle, FSCTL_SET_SPARSE, NULL, 0, NULL, 0,
+            &bytes, NULL)) {
+        QWARN("Unable to set test file as sparse. "
+            "Limiting test file to 16MiB.");
+        maxSizeBits = 24;
+    }
+
+    int fd = ::_open_osfhandle((intptr_t)handle, 0);
+    QVERIFY( -1 != fd );
+    QVERIFY( largeFile.open(fd, QIODevice::WriteOnly | QIODevice::Unbuffered) );
+#else // !Q_OS_WIN
+    largeFile.setFileName("qt_largefile.tmp");
+    QVERIFY( largeFile.open(QIODevice::WriteOnly | QIODevice::Unbuffered) );
+#endif
+}
+
+void tst_LargeFile::closeSparseFile()
+{
+#if defined(Q_OS_WIN)
+    int fd = largeFile.handle();
+#endif
+
+    largeFile.close();
+
+#if defined(Q_OS_WIN)
+    if (-1 != fd)
+        ::_close(fd);
+#endif
+}
+
+void tst_LargeFile::fillFileSparsely()
+{
+    QFETCH( qint64, position );
+    QFETCH( QByteArray, block );
+    QCOMPARE( block.size(), blockSize );
+
+    static int lastKnownGoodIndex = 0;
+    struct ScopeGuard {
+        ScopeGuard(tst_LargeFile* test)
+            : this_(test)
+            , failed(true)
+        {
+            QFETCH( int, index );
+            index_ = index;
+        }
+
+        ~ScopeGuard()
+        {
+            if (failed) {
+                this_->maxSizeBits = lastKnownGoodIndex;
+                QWARN( qPrintable(
+                    QString("QFile::error %1: '%2'. Maximum size bits reset to %3.")
+                        .arg(this_->largeFile.error())
+                        .arg(this_->largeFile.errorString())
+                        .arg(this_->maxSizeBits)) );
+            } else
+                lastKnownGoodIndex = qMax<int>(index_, lastKnownGoodIndex);
+        }
+
+    private:
+        tst_LargeFile * const this_;
+        int index_;
+
+    public:
+        bool failed;
+    };
+
+    ScopeGuard resetMaxSizeBitsOnFailure(this);
+
+    QVERIFY( largeFile.seek(position) );
+    QCOMPARE( largeFile.pos(), position );
+
+    QCOMPARE( largeFile.write(block), (qint64)blockSize );
+    QCOMPARE( largeFile.pos(), position + blockSize );
+    QVERIFY( largeFile.flush() );
+
+    resetMaxSizeBitsOnFailure.failed = false;
+}
+
+void tst_LargeFile::fileCreated()
+{
+    QFileInfo info("qt_largefile.tmp");
+
+    QVERIFY( info.exists() );
+    QVERIFY( info.isFile() );
+    QVERIFY( info.size() >= ((qint64)1 << maxSizeBits) + blockSize );
+}
+
+void tst_LargeFile::filePositioning()
+{
+    QFETCH( qint64, position );
+
+    QFile file("qt_largefile.tmp");
+    QVERIFY( file.open(QIODevice::ReadOnly) );
+
+    QVERIFY( file.seek(position) );
+    QCOMPARE( file.pos(), position );
+}
+
+void tst_LargeFile::fdPositioning()
+{
+    QFETCH( qint64, position );
+
+    fd_ = QT_OPEN("qt_largefile.tmp",
+            QT_OPEN_RDONLY | QT_OPEN_LARGEFILE);
+    QVERIFY( -1 != fd_ );
+
+    QFile file;
+    QVERIFY( file.open(fd_, QIODevice::ReadOnly) );
+    QCOMPARE( file.pos(), (qint64)0 );
+    QVERIFY( file.seek(position) );
+    QCOMPARE( file.pos(), position );
+
+    file.close();
+
+    QCOMPARE( QT_LSEEK(fd_, QT_OFF_T(0), SEEK_SET), QT_OFF_T(0) );
+    QCOMPARE( QT_LSEEK(fd_, QT_OFF_T(position), SEEK_SET), QT_OFF_T(position) );
+
+    QVERIFY( file.open(fd_, QIODevice::ReadOnly) );
+    QCOMPARE( QT_LSEEK(fd_, QT_OFF_T(0), SEEK_CUR), QT_OFF_T(position) );
+    QCOMPARE( file.pos(), position );
+    QVERIFY( file.seek(0) );
+    QCOMPARE( file.pos(), (qint64)0 );
+
+    file.close();
+
+    QVERIFY( !QT_CLOSE(fd_) );
+    fd_ = -1;
+}
+
+void tst_LargeFile::streamPositioning()
+{
+    QFETCH( qint64, position );
+
+#if defined(QT_LARGEFILE_SUPPORT) && defined(Q_CC_MSVC) && _MSC_VER < 1400
+    if (position >= (qint64)1 << 31)
+        QSKIP("MSVC 2003 doesn't have 64 bit versions of fseek/ftell.", SkipSingle);
+#endif
+
+    stream_ = QT_FOPEN("qt_largefile.tmp", "rb");
+    QVERIFY( 0 != stream_ );
+
+    QFile file;
+    QVERIFY( file.open(stream_, QIODevice::ReadOnly) );
+    QCOMPARE( file.pos(), (qint64)0 );
+    QVERIFY( file.seek(position) );
+    QCOMPARE( file.pos(), position );
+
+    file.close();
+
+    QVERIFY( !QT_FSEEK(stream_, QT_OFF_T(0), SEEK_SET) );
+    QCOMPARE( QT_FTELL(stream_), QT_OFF_T(0) );
+    QVERIFY( !QT_FSEEK(stream_, QT_OFF_T(position), SEEK_SET) );
+    QCOMPARE( QT_FTELL(stream_), QT_OFF_T(position) );
+
+    QVERIFY( file.open(stream_, QIODevice::ReadOnly) );
+    QCOMPARE( QT_FTELL(stream_), QT_OFF_T(position) );
+    QCOMPARE( file.pos(), position );
+    QVERIFY( file.seek(0) );
+    QCOMPARE( file.pos(), (qint64)0 );
+
+    file.close();
+
+    QVERIFY( !::fclose(stream_) );
+    stream_ = 0;
+}
+
+void tst_LargeFile::openFileForReading()
+{
+    largeFile.setFileName("qt_largefile.tmp");
+    QVERIFY( largeFile.open(QIODevice::ReadOnly) );
+}
+
+void tst_LargeFile::readFile()
+{
+    QFETCH( qint64, position );
+    QFETCH( QByteArray, block );
+    QCOMPARE( block.size(), blockSize );
+
+    QVERIFY( largeFile.size() >= position + blockSize );
+
+    QVERIFY( largeFile.seek(position) );
+    QCOMPARE( largeFile.pos(), position );
+
+    QCOMPARE( largeFile.read(blockSize), block );
+    QCOMPARE( largeFile.pos(), position + blockSize );
+}
+
+void tst_LargeFile::mapFile()
+{
+    QFETCH( qint64, position );
+    QFETCH( QByteArray, block );
+    QCOMPARE( block.size(), blockSize );
+
+    // Keep full block mapped to facilitate OS and/or internal reuse by Qt.
+    uchar *baseAddress = largeFile.map(position, blockSize);
+    QVERIFY( baseAddress );
+    QVERIFY( qEqual(block.begin(), block.end(), reinterpret_cast<char*>(baseAddress)) );
+
+    for (int offset = 1; offset <  blockSize; ++offset) {
+        uchar *address = largeFile.map(position + offset, blockSize - offset);
+
+        QVERIFY( address );
+        if ( !qEqual(block.begin() + offset, block.end(), reinterpret_cast<char*>(address)) ) {
+            qDebug() << "Expected:" << block.toHex();
+            qDebug() << "Actual  :" << QByteArray(reinterpret_cast<char*>(address), blockSize).toHex();
+            QVERIFY(false);
+        }
+
+        QVERIFY( largeFile.unmap( address ) );
+    }
+
+    QVERIFY( largeFile.unmap( baseAddress ) );
+}
+
+void tst_LargeFile::mapOffsetOverflow()
+{
+    // Out-of-range mappings should fail, and not silently clip the offset
+    for (int i = 50; i < 63; ++i) {
+        uchar *address = 0;
+
+        address = largeFile.map(((qint64)1 << i), blockSize);
+        QVERIFY( !address );
+
+        address = largeFile.map(((qint64)1 << i) + blockSize, blockSize);
+        QVERIFY( !address );
+    }
+}
+
+QTEST_APPLESS_MAIN(tst_LargeFile)
+#include "tst_largefile.moc"
+
diff --git a/tests/auto/qfile/qfile.pro b/tests/auto/qfile/qfile.pro
index eebfcda..f70f750 100644
--- a/tests/auto/qfile/qfile.pro
+++ b/tests/auto/qfile/qfile.pro
@@ -5,5 +5,5 @@ wince*:{
   SUBDIRS = test stdinprocess
 }
 
-
+SUBDIRS += largefile
 
diff --git a/tests/auto/qfile/tst_qfile.cpp b/tests/auto/qfile/tst_qfile.cpp
index 19fbecd..55cc286 100644
--- a/tests/auto/qfile/tst_qfile.cpp
+++ b/tests/auto/qfile/tst_qfile.cpp
@@ -79,6 +79,18 @@
 # define SRCDIR ""
 #endif
 
+#ifndef STDIN_FILENO
+#define STDIN_FILENO 0
+#endif
+
+#ifndef STDOUT_FILENO
+#define STDOUT_FILENO 1
+#endif
+
+#ifndef STDERR_FILENO
+#define STDERR_FILENO 2
+#endif
+
 Q_DECLARE_METATYPE(QFile::FileError)
 
 //TESTED_CLASS=
@@ -105,6 +117,7 @@ private slots:
     void openUnbuffered();
     void size_data();
     void size();
+    void sizeNoExist();
     void seek();
     void setSize();
     void setSizeSeek();
@@ -187,6 +200,8 @@ private slots:
     void mapOpenMode_data();
     void mapOpenMode();
 
+    void openStandardStreams();
+
     // --- Task related tests below this line
     void task167217();
 
@@ -438,23 +453,57 @@ void tst_QFile::openUnbuffered()
 void tst_QFile::size_data()
 {
     QTest::addColumn<QString>("filename");
-    QTest::addColumn<int>("size");
+    QTest::addColumn<qint64>("size");
 
-    QTest::newRow( "exist01" ) << QString(SRCDIR "testfile.txt") << 245;
-    QTest::newRow( "nonexist01" ) << QString("foo.txt") << 0;
+    QTest::newRow( "exist01" ) << QString(SRCDIR "testfile.txt") << (qint64)245;
 #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
     // Only test UNC on Windows./
-    QTest::newRow("unc") << "//" + QString(QtNetworkSettings::winServerName() + "/testsharewritable/test.pri") << 34;
+    QTest::newRow("unc") << "//" + QString(QtNetworkSettings::winServerName() + "/testsharewritable/test.pri") << (qint64)34;
 #endif
 }
 
 void tst_QFile::size()
 {
     QFETCH( QString, filename );
-    QFile f( filename );
-    QTEST( (int)f.size(), "size" );
-    if (f.open(QFile::ReadOnly))
-        QTEST( (int)f.size(), "size" );
+    QFETCH( qint64, size );
+
+    {
+        QFile f( filename );
+        QCOMPARE( f.size(), size );
+
+        QVERIFY( f.open(QIODevice::ReadOnly) );
+        QCOMPARE( f.size(), size );
+    }
+
+    {
+        QFile f;
+        int fd = QT_OPEN(filename.toLocal8Bit().constData(), QT_OPEN_RDONLY);
+        QVERIFY( fd != -1 );
+        QVERIFY( f.open(fd, QIODevice::ReadOnly) );
+        QCOMPARE( f.size(), size );
+
+        f.close();
+        QT_CLOSE(fd);
+    }
+
+    {
+        QFile f;
+        FILE* stream = QT_FOPEN(filename.toLocal8Bit().constData(), "rb");
+        QVERIFY( stream );
+        QVERIFY( f.open(stream, QIODevice::ReadOnly) );
+        QCOMPARE( f.size(), size );
+
+        f.close();
+        fclose(stream);
+    }
+}
+
+void tst_QFile::sizeNoExist()
+{
+    QFile file("nonexist01");
+    QVERIFY( !file.exists() );
+    QCOMPARE( file.size(), (qint64)0 );
+    QVERIFY( !file.open(QIODevice::ReadOnly) );
 }
 
 void tst_QFile::seek()
@@ -2634,5 +2683,58 @@ void tst_QFile::openDirectory()
     QVERIFY(!f1.open(QIODevice::ReadOnly|QIODevice::Unbuffered));
 }
 
+void tst_QFile::openStandardStreams()
+{
+    // Using file descriptors
+    {
+        QFile in;
+        in.open(STDIN_FILENO, QIODevice::ReadOnly);
+        QCOMPARE( in.pos(), (qint64)0 );
+        QCOMPARE( in.size(), (qint64)0 );
+        QVERIFY( in.isSequential() );
+    }
+
+    {
+        QFile out;
+        out.open(STDOUT_FILENO, QIODevice::WriteOnly);
+        QCOMPARE( out.pos(), (qint64)0 );
+        QCOMPARE( out.size(), (qint64)0 );
+        QVERIFY( out.isSequential() );
+    }
+
+    {
+        QFile err;
+        err.open(STDERR_FILENO, QIODevice::WriteOnly);
+        QCOMPARE( err.pos(), (qint64)0 );
+        QCOMPARE( err.size(), (qint64)0 );
+        QVERIFY( err.isSequential() );
+    }
+
+    // Using streams
+    {
+        QFile in;
+        in.open(stdin, QIODevice::ReadOnly);
+        QCOMPARE( in.pos(), (qint64)0 );
+        QCOMPARE( in.size(), (qint64)0 );
+        QVERIFY( in.isSequential() );
+    }
+
+    {
+        QFile out;
+        out.open(stdout, QIODevice::WriteOnly);
+        QCOMPARE( out.pos(), (qint64)0 );
+        QCOMPARE( out.size(), (qint64)0 );
+        QVERIFY( out.isSequential() );
+    }
+
+    {
+        QFile err;
+        err.open(stderr, QIODevice::WriteOnly);
+        QCOMPARE( err.pos(), (qint64)0 );
+        QCOMPARE( err.size(), (qint64)0 );
+        QVERIFY( err.isSequential() );
+    }
+}
+
 QTEST_MAIN(tst_QFile)
 #include "tst_qfile.moc"
diff --git a/tests/auto/qgl/tst_qgl.cpp b/tests/auto/qgl/tst_qgl.cpp
index e036e4b..c680dec 100644
--- a/tests/auto/qgl/tst_qgl.cpp
+++ b/tests/auto/qgl/tst_qgl.cpp
@@ -82,7 +82,6 @@ private slots:
     void glPBufferRendering();
     void glWidgetReparent();
     void glWidgetRenderPixmap();
-    void stackedFBOs();
     void colormap();
     void fboFormat();
     void testDontCrashOnDanglingResources();
@@ -118,6 +117,16 @@ public:
     void setAutoBufferSwap(bool on) { QGLWidget::setAutoBufferSwap(on); }
 };
 
+static int appDefaultDepth()
+{
+    static int depth = 0;
+    if (depth == 0) {
+        QPixmap pm(1, 1);
+        depth = pm.depth();
+    }
+    return depth;
+}
+
 // Using INT_MIN and INT_MAX will cause failures on systems
 // where "int" is 64-bit, so use the explicit values instead.
 #define TEST_INT_MIN    (-2147483647 - 1)
@@ -714,6 +723,8 @@ public:
 
 void tst_QGL::graphicsViewClipping()
 {
+    if (appDefaultDepth() < 24)
+        QSKIP("This test won't work for bit depths < 24", SkipAll);
     const int size = 64;
     UnclippedWidget *widget = new UnclippedWidget;
     widget->setFixedSize(size, size);
@@ -866,6 +877,8 @@ public:
 
 void tst_QGL::glWidgetRendering()
 {
+    if (appDefaultDepth() < 24)
+        QSKIP("This test won't work for bit depths < 24", SkipAll);
     GLWidget w;
     w.show();
 
@@ -1089,6 +1102,8 @@ protected:
 
 void tst_QGL::glFBOUseInGLWidget()
 {
+    if (appDefaultDepth() < 24)
+        QSKIP("This test won't work for bit depths < 24", SkipAll);
     if (!QGLFramebufferObject::hasOpenGLFramebufferObjects())
         QSKIP("QGLFramebufferObject not supported on this platform", SkipSingle);
 
@@ -1116,6 +1131,8 @@ void tst_QGL::glFBOUseInGLWidget()
 
 void tst_QGL::glWidgetReparent()
 {
+    if (appDefaultDepth() < 24)
+        QSKIP("This test won't work for bit depths < 24", SkipAll);
     // Try it as a top-level first:
     GLWidget *widget = new GLWidget;
     widget->setGeometry(0, 0, 200, 30);
@@ -1208,110 +1225,6 @@ void tst_QGL::glWidgetRenderPixmap()
     QCOMPARE(fb, reference);
 }
 
-
-// When using multiple FBOs at the same time, unbinding one FBO should re-bind the
-// previous. I.e. It should be possible to have a stack of FBOs where pop'ing there
-// top re-binds the one underneeth.
-void tst_QGL::stackedFBOs()
-{
-    if (!QGLFramebufferObject::hasOpenGLFramebufferObjects())
-        QSKIP("QGLFramebufferObject not supported on this platform", SkipSingle);
-
-    QGLWidget glw;
-    glw.show();
-
-#ifdef Q_WS_X11
-    qt_x11_wait_for_window_manager(&glw);
-#endif
-    QTest::qWait(200);
-
-    glw.makeCurrent();
-
-    // No multisample with combined depth/stencil attachment:
-    QGLFramebufferObjectFormat fboFormat;
-    fboFormat.setAttachment(QGLFramebufferObject::CombinedDepthStencil);
-
-    // Don't complicate things by using NPOT:
-    QGLFramebufferObject *fbo1 = new QGLFramebufferObject(128, 128, fboFormat);
-    QGLFramebufferObject *fbo2 = new QGLFramebufferObject(128, 128, fboFormat);
-    QGLFramebufferObject *fbo3 = new QGLFramebufferObject(128, 128, fboFormat);
-
-    glClearColor(1.0, 0.0, 1.0, 1.0);
-    glClear(GL_COLOR_BUFFER_BIT);
-
-    fbo1->bind();
-        glClearColor(1.0, 0.0, 0.0, 1.0);
-        glClear(GL_COLOR_BUFFER_BIT);
-
-        fbo2->bind();
-            glClearColor(0.0, 1.0, 0.0, 1.0);
-            glClear(GL_COLOR_BUFFER_BIT);
-
-            fbo3->bind();
-                glClearColor(0.0, 0.0, 1.0, 1.0);
-                glClear(GL_COLOR_BUFFER_BIT);
-                glScissor(32, 32, 64, 64);
-                glEnable(GL_SCISSOR_TEST);
-                glClearColor(0.0, 1.0, 1.0, 1.0);
-                glClear(GL_COLOR_BUFFER_BIT);
-            fbo3->release();
-
-            // Scissor rect & test should be left untouched by the fbo release...
-            glClearColor(0.0, 0.0, 0.0, 1.0);
-            glClear(GL_COLOR_BUFFER_BIT);
-        fbo2->release();
-
-        glClearColor(1.0, 1.0, 1.0, 1.0);
-        glClear(GL_COLOR_BUFFER_BIT);
-    fbo1->release();
-
-    glClearColor(1.0, 1.0, 0.0, 1.0);
-    glClear(GL_COLOR_BUFFER_BIT);
-
-    glw.swapBuffers();
-
-    QImage widgetFB = glw.grabFrameBuffer(false).convertToFormat(QImage::Format_RGB32);
-    QImage fb1 = fbo1->toImage().convertToFormat(QImage::Format_RGB32);
-    QImage fb2 = fbo2->toImage().convertToFormat(QImage::Format_RGB32);
-    QImage fb3 = fbo3->toImage().convertToFormat(QImage::Format_RGB32);
-
-    delete fbo1;
-    delete fbo2;
-    delete fbo3;
-
-    QImage widgetReference(widgetFB.size(), widgetFB.format());
-    QImage fb1Reference(fb1.size(), fb1.format());
-    QImage fb2Reference(fb2.size(), fb2.format());
-    QImage fb3Reference(fb3.size(), fb3.format());
-
-    QPainter widgetReferencePainter(&widgetReference);
-    QPainter fb1ReferencePainter(&fb1Reference);
-    QPainter fb2ReferencePainter(&fb2Reference);
-    QPainter fb3ReferencePainter(&fb3Reference);
-
-    widgetReferencePainter.fillRect(0, 0, widgetReference.width(), widgetReference.height(), Qt::magenta);
-    fb1ReferencePainter.fillRect(0, 0, fb1Reference.width(), fb1Reference.height(), Qt::red);
-    fb2ReferencePainter.fillRect(0, 0, fb2Reference.width(), fb2Reference.height(), Qt::green);
-    fb3ReferencePainter.fillRect(0, 0, fb3Reference.width(), fb3Reference.height(), Qt::blue);
-
-    // Flip y-coords to match GL for the widget (which can be any size)
-    widgetReferencePainter.fillRect(32, glw.height() - 96, 64, 64, Qt::yellow);
-    fb1ReferencePainter.fillRect(32, 32, 64, 64, Qt::white);
-    fb2ReferencePainter.fillRect(32, 32, 64, 64, Qt::black);
-    fb3ReferencePainter.fillRect(32, 32, 64, 64, Qt::cyan);
-
-    widgetReferencePainter.end();
-    fb1ReferencePainter.end();
-    fb2ReferencePainter.end();
-    fb3ReferencePainter.end();
-
-    QCOMPARE(widgetFB, widgetReference);
-    QCOMPARE(fb1, fb1Reference);
-    QCOMPARE(fb2, fb2Reference);
-    QCOMPARE(fb3, fb3Reference);
-}
-
-
 class ColormapExtended : public QGLColormap
 {
 public:
@@ -1582,6 +1495,8 @@ protected:
 
 void tst_QGL::replaceClipping()
 {
+    if (appDefaultDepth() < 24)
+        QSKIP("This test won't work for bit depths < 24", SkipAll);
     ReplaceClippingGLWidget glw;
     glw.resize(300, 300);
     glw.show();
@@ -1707,6 +1622,8 @@ protected:
 
 void tst_QGL::clipTest()
 {
+    if (appDefaultDepth() < 24)
+        QSKIP("This test won't work for bit depths < 24", SkipAll);
     ClipTestGLWidget glw;
     glw.resize(220, 220);
     glw.show();
diff --git a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
index c8a9fac..c7ed309 100644
--- a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
+++ b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
@@ -79,13 +79,12 @@ private slots:
     void delete_anchor();
     void conflicts();
     void sizePolicy();
-    void expandingSequence();
-    void expandingSequenceFairDistribution();
-    void expandingParallel();
     void floatConflict();
     void infiniteMaxSizes();
     void simplifiableUnfeasible();
     void simplificationVsOrder();
+    void parallelSimplificationOfCenter();
+    void simplificationVsRedundance();
 };
 
 class RectWidget : public QGraphicsWidget
@@ -342,8 +341,10 @@ void tst_QGraphicsAnchorLayout::layoutDirection()
 
     QCOMPARE(checkReverseDirection(p), true);
 
-    QVERIFY(usedSimplex(l, Qt::Horizontal));
-    QVERIFY(!usedSimplex(l, Qt::Vertical));
+    if (hasSimplification) {
+        QVERIFY(usedSimplex(l, Qt::Horizontal));
+        QVERIFY(!usedSimplex(l, Qt::Vertical));
+    }
 
     delete p;
     delete view;
@@ -1609,217 +1610,6 @@ void tst_QGraphicsAnchorLayout::conflicts()
     delete p;
 }
 
-void tst_QGraphicsAnchorLayout::expandingSequence()
-{
-    QSizeF min(10, 10);
-    QSizeF pref(50, 10);
-    QSizeF max(100, 10);
-
-    QGraphicsWidget *a = createItem(min, pref, max, "a");
-    QGraphicsWidget *b = createItem(min, pref, max, "b");
-
-    b->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
-
-    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
-    l->setContentsMargins(0, 0, 0, 0);
-
-    // horizontal
-    setAnchor(l, l, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);
-    setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft, 0);
-    setAnchor(l, b, Qt::AnchorRight, l, Qt::AnchorRight, 0);
-
-    // vertical
-    l->addAnchors(l, a, Qt::Vertical);
-    l->addAnchors(l, b, Qt::Vertical);
-
-    QCOMPARE(l->count(), 2);
-
-    QGraphicsWidget p;
-    p.setLayout(l);
-
-    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
-    QCOMPARE(layoutMinimumSize.width(), qreal(20));
-
-    QSizeF layoutExpandedSize(pref.width() + max.width(), layoutMinimumSize.height());
-    p.resize(layoutExpandedSize);
-
-    QCOMPARE(a->geometry().size(), pref);
-    QCOMPARE(b->geometry().size(), max);
-
-    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
-    QCOMPARE(layoutMaximumSize.width(), qreal(200));
-
-    if (hasSimplification) {
-        QVERIFY(!usedSimplex(l, Qt::Horizontal));
-        QVERIFY(!usedSimplex(l, Qt::Vertical));
-    }
-}
-
-void tst_QGraphicsAnchorLayout::expandingSequenceFairDistribution()
-{
-    QSizeF min(10, 10);
-    QSizeF pref(50, 10);
-    QSizeF max(100, 10);
-
-    QGraphicsWidget *a = createItem(min, pref, max, "a");
-    QGraphicsWidget *b = createItem(min, pref, max, "b");
-    QGraphicsWidget *c = createItem(min, pref, max, "c");
-    QGraphicsWidget *d = createItem(min, pref, max, "d");
-
-    b->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
-    d->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
-
-    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
-    l->setContentsMargins(0, 0, 0, 0);
-
-    // horizontal
-    setAnchor(l, l, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);
-    setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft, 0);
-    setAnchor(l, b, Qt::AnchorRight, c, Qt::AnchorLeft, 0);
-    setAnchor(l, c, Qt::AnchorRight, d, Qt::AnchorLeft, 0);
-    setAnchor(l, d, Qt::AnchorRight, l, Qt::AnchorRight, 0);
-
-    // vertical
-    l->addAnchors(l, a, Qt::Vertical);
-    l->addAnchors(l, b, Qt::Vertical);
-    l->addAnchors(l, c, Qt::Vertical);
-    l->addAnchors(l, d, Qt::Vertical);
-
-    QCOMPARE(l->count(), 4);
-
-    QGraphicsWidget p;
-    p.setLayout(l);
-
-    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
-    QCOMPARE(layoutMinimumSize.width(), qreal(40));
-
-    QSizeF layoutPartialExpandedSize((2 * pref.width()) + (2 * (pref.width() + 10)),
-                                     layoutMinimumSize.height());
-    p.resize(layoutPartialExpandedSize);
-
-    QCOMPARE(a->geometry().size(), pref);
-    QCOMPARE(b->geometry().size(), pref + QSizeF(10, 0));
-    QCOMPARE(c->geometry().size(), pref);
-    QCOMPARE(d->geometry().size(), pref + QSizeF(10, 0));
-
-    QSizeF layoutExpandedSize((2 * pref.width()) + (2 * max.width()),
-                              layoutMinimumSize.height());
-    p.resize(layoutExpandedSize);
-
-    QCOMPARE(a->geometry().size(), pref);
-    QCOMPARE(b->geometry().size(), max);
-    QCOMPARE(c->geometry().size(), pref);
-    QCOMPARE(d->geometry().size(), max);
-
-    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
-    QCOMPARE(layoutMaximumSize.width(), qreal(400));
-
-    if (hasSimplification) {
-        QVERIFY(!usedSimplex(l, Qt::Horizontal));
-        QVERIFY(!usedSimplex(l, Qt::Vertical));
-    }
-
-    // Now we change D to have more "room for growth" from its preferred size
-    // to its maximum size. We expect a proportional fair distribution. Note that
-    // this seems to not conform with what QGraphicsLinearLayout does.
-    d->setMaximumSize(QSizeF(150, 10));
-
-    QSizeF newLayoutExpandedSize((2 * pref.width()) + (max.width() + 150),
-                              layoutMinimumSize.height());
-    p.resize(newLayoutExpandedSize);
-
-    QCOMPARE(a->geometry().size(), pref);
-    QCOMPARE(b->geometry().size(), max);
-    QCOMPARE(c->geometry().size(), pref);
-    QCOMPARE(d->geometry().size(), QSizeF(150, 10));
-
-    QSizeF newLayoutPartialExpandedSize((4 * pref.width()) + 75,
-                                        layoutMinimumSize.height());
-    p.resize(newLayoutPartialExpandedSize);
-
-    QCOMPARE(a->geometry().size(), pref);
-    QCOMPARE(b->geometry().size(), pref + QSizeF(25, 0));
-    QCOMPARE(c->geometry().size(), pref);
-    QCOMPARE(d->geometry().size(), pref + QSizeF(50, 0));
-
-    if (hasSimplification) {
-        QVERIFY(!usedSimplex(l, Qt::Horizontal));
-        QVERIFY(!usedSimplex(l, Qt::Vertical));
-    }
-}
-
-void tst_QGraphicsAnchorLayout::expandingParallel()
-{
-    QSizeF min(10, 10);
-    QSizeF pref(50, 10);
-    QSizeF max(100, 10);
-    QSizeF max2(100, 50);
-
-    QGraphicsWidget *a = createItem(min, pref, max, "a");
-    QGraphicsWidget *b = createItem(min, pref, max, "b");
-    QGraphicsWidget *c = createItem(min, pref, max2, "c");
-
-    b->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
-
-    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
-    l->setContentsMargins(0, 0, 0, 0);
-
-    // horizontal
-    setAnchor(l, l, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);
-    setAnchor(l, l, Qt::AnchorLeft, b, Qt::AnchorLeft, 0);
-
-    setAnchor(l, a, Qt::AnchorRight, c, Qt::AnchorLeft, 0);
-    setAnchor(l, b, Qt::AnchorRight, c, Qt::AnchorLeft, 0);
-
-    setAnchor(l, c, Qt::AnchorRight, l, Qt::AnchorRight, 0);
-
-    // vertical
-    l->addAnchors(l, c, Qt::Vertical);
-    setAnchor(l, l, Qt::AnchorTop, a, Qt::AnchorTop, 0);
-    setAnchor(l, a, Qt::AnchorBottom, c, Qt::AnchorVerticalCenter, 0);
-    setAnchor(l, b, Qt::AnchorTop, c, Qt::AnchorVerticalCenter, 0);
-    setAnchor(l, b, Qt::AnchorBottom, l, Qt::AnchorBottom, 0);
-
-    QCOMPARE(l->count(), 3);
-
-    QGraphicsWidget p;
-    p.setLayout(l);
-
-    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
-    QCOMPARE(layoutMinimumSize.width(), qreal(20));
-
-    QSizeF layoutExpandedSize(pref.width() + max.width(), layoutMinimumSize.height());
-    p.resize(layoutExpandedSize);
-
-    QCOMPARE(a->geometry().size(), max);
-    QCOMPARE(b->geometry().size(), max);
-    QCOMPARE(c->geometry().size(), QSizeF(pref.width(), 20));
-
-    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
-    QCOMPARE(layoutMaximumSize.width(), qreal(200));
-
-    //
-    // Change the parallel connection to a paralell connection of b with a center...
-    //
-    QGraphicsAnchor *anchor = l->anchor(b, Qt::AnchorRight, c, Qt::AnchorLeft);
-    delete anchor;
-    setAnchor(l, b, Qt::AnchorRight, a, Qt::AnchorHorizontalCenter, 0);
-    a->setMaximumSize(max + QSizeF(100, 0));
-
-    QSizeF newLayoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
-    QCOMPARE(newLayoutMinimumSize.width(), qreal(30));
-
-    QSizeF newLayoutExpandedSize = layoutExpandedSize + QSizeF(100, 0);
-    p.resize(newLayoutExpandedSize);
-
-    QCOMPARE(a->geometry().size(), max + QSizeF(100, 0));
-    QCOMPARE(b->geometry().size(), max);
-    QCOMPARE(c->geometry().size(), QSizeF(pref.width(), 20));
-
-    QSizeF newLayoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
-    QCOMPARE(newLayoutMaximumSize.width(), qreal(300));
-}
-
 void tst_QGraphicsAnchorLayout::floatConflict()
 {
     QGraphicsWidget *a = createItem(QSizeF(80,10), QSizeF(90,10), QSizeF(100,10), "a");
@@ -1882,6 +1672,7 @@ void tst_QGraphicsAnchorLayout::infiniteMaxSizes()
     QGraphicsWidget *b = createItem(min, pref, max, "b");
     QGraphicsWidget *c = createItem(min, pref, max, "c");
     QGraphicsWidget *d = createItem(min, pref, max, "d");
+    QGraphicsWidget *e = createItem(min, pref, max, "e");
 
     //<!-- Trunk -->
     setAnchor(l, l, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);
@@ -1889,34 +1680,32 @@ void tst_QGraphicsAnchorLayout::infiniteMaxSizes()
     setAnchor(l, b, Qt::AnchorRight, c, Qt::AnchorLeft, 0);
     setAnchor(l, c, Qt::AnchorRight, d, Qt::AnchorLeft, 0);
     setAnchor(l, d, Qt::AnchorRight, l, Qt::AnchorRight, 0);
-
-    a->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
-    c->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
+    setAnchor(l, b, Qt::AnchorHorizontalCenter, e, Qt::AnchorLeft, 0);
+    setAnchor(l, e, Qt::AnchorRight, c, Qt::AnchorHorizontalCenter, 0);
 
     QGraphicsWidget p;
     p.setLayout(l);
 
+    QCOMPARE(int(p.effectiveSizeHint(Qt::MaximumSize).width()),
+             QWIDGETSIZE_MAX);
+
     p.resize(200, 10);
     QCOMPARE(a->geometry(), QRectF(0, 0, 50, 10));
     QCOMPARE(b->geometry(), QRectF(50, 0, 50, 10));
     QCOMPARE(c->geometry(), QRectF(100, 0, 50, 10));
     QCOMPARE(d->geometry(), QRectF(150, 0, 50, 10));
 
-    if (!hasSimplification)
-        QEXPECT_FAIL("", "Without simplification there is no fair distribution.", Abort);
-
     p.resize(1000, 10);
-    QCOMPARE(a->geometry(), QRectF(0, 0, 450, 10));
-    QCOMPARE(b->geometry(), QRectF(450, 0, 50, 10));
-    QCOMPARE(c->geometry(), QRectF(500, 0, 450, 10));
-    QCOMPARE(d->geometry(), QRectF(950, 0, 50, 10));
-
-    qreal expMaxSize = (QWIDGETSIZE_MAX - 100.0) / 2;
-    p.resize(QWIDGETSIZE_MAX, 10);
-    QCOMPARE(a->geometry(), QRectF(0, 0, expMaxSize, 10));
-    QCOMPARE(b->geometry(), QRectF(expMaxSize, 0, 50, 10));
-    QCOMPARE(c->geometry(), QRectF(expMaxSize + 50, 0, expMaxSize, 10));
-    QCOMPARE(d->geometry(), QRectF(QWIDGETSIZE_MAX - 50, 0, 50, 10));
+    QCOMPARE(a->geometry(), QRectF(0, 0, 250, 10));
+    QCOMPARE(b->geometry(), QRectF(250, 0, 250, 10));
+    QCOMPARE(c->geometry(), QRectF(500, 0, 250, 10));
+    QCOMPARE(d->geometry(), QRectF(750, 0, 250, 10));
+
+    p.resize(40000, 10);
+    QCOMPARE(a->geometry(), QRectF(0, 0, 10000, 10));
+    QCOMPARE(b->geometry(), QRectF(10000, 0, 10000, 10));
+    QCOMPARE(c->geometry(), QRectF(20000, 0, 10000, 10));
+    QCOMPARE(d->geometry(), QRectF(30000, 0, 10000, 10));
 }
 
 void tst_QGraphicsAnchorLayout::simplifiableUnfeasible()
@@ -1951,7 +1740,7 @@ void tst_QGraphicsAnchorLayout::simplifiableUnfeasible()
     if (hasSimplification)
         QVERIFY(!usedSimplex(l, Qt::Horizontal));
 
-    // Now we make it valid again
+    // Now we make it valid
     b->setMinimumWidth(100);
 
     l->invalidate();
@@ -1979,9 +1768,9 @@ void tst_QGraphicsAnchorLayout::simplificationVsOrder()
     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);
+    QGraphicsWidget *a = createItem(min, pref, max, "A");
+    QGraphicsWidget *b = createItem(min, pref, max, "B");
+    QGraphicsWidget *c = createItem(min, pref, max, "C");
 
     QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
 
@@ -2014,5 +1803,68 @@ void tst_QGraphicsAnchorLayout::simplificationVsOrder()
     }
 }
 
+void tst_QGraphicsAnchorLayout::parallelSimplificationOfCenter()
+{
+    QSizeF min(10, 10);
+    QSizeF pref(20, 10);
+    QSizeF max(50, 10);
+
+    QGraphicsWidget *a = createItem(min, pref, max, "A");
+    QGraphicsWidget *b = createItem(min, pref, max, "B");
+
+    QGraphicsWidget parent;
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout(&parent);
+    l->setContentsMargins(0, 0, 0, 0);
+
+    l->addAnchor(l, Qt::AnchorLeft, a, Qt::AnchorLeft);
+    l->addAnchor(l, Qt::AnchorRight, a, Qt::AnchorRight);
+
+    l->addAnchor(a, Qt::AnchorHorizontalCenter, b, Qt::AnchorLeft);
+    l->addAnchor(b, Qt::AnchorRight, a, Qt::AnchorRight);
+
+    parent.resize(l->effectiveSizeHint(Qt::PreferredSize));
+
+    QCOMPARE(a->geometry(), QRectF(0, 0, 40, 10));
+    QCOMPARE(b->geometry(), QRectF(20, 0, 20, 10));
+}
+
+/*
+    Test whether redundance of anchors (in this case by using addCornerAnchors), will
+    prevent simplification to take place when it should.
+*/
+void tst_QGraphicsAnchorLayout::simplificationVsRedundance()
+{
+    QSizeF min(10, 10);
+    QSizeF pref(20, 10);
+    QSizeF max(50, 30);
+
+    QGraphicsWidget *a = createItem(min, pref, max, "A");
+    QGraphicsWidget *b = createItem(min, pref, max, "B");
+    QGraphicsWidget *c = createItem(min, pref, max, "C");
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+
+    l->addCornerAnchors(a, Qt::TopLeftCorner, l, Qt::TopLeftCorner);
+    l->addCornerAnchors(a, Qt::BottomLeftCorner, l, Qt::BottomLeftCorner);
+
+    l->addCornerAnchors(b, Qt::TopLeftCorner, a, Qt::TopRightCorner);
+    l->addCornerAnchors(b, Qt::TopRightCorner, l, Qt::TopRightCorner);
+
+    l->addCornerAnchors(c, Qt::TopLeftCorner, b, Qt::BottomLeftCorner);
+    l->addCornerAnchors(c, Qt::BottomLeftCorner, a, Qt::BottomRightCorner);
+    l->addCornerAnchors(c, Qt::TopRightCorner, b, Qt::BottomRightCorner);
+    l->addCornerAnchors(c, Qt::BottomRightCorner, l, Qt::BottomRightCorner);
+
+    l->effectiveSizeHint(Qt::MinimumSize);
+
+    QCOMPARE(layoutHasConflict(l), false);
+
+    if (!hasSimplification)
+        QEXPECT_FAIL("", "Test depends on simplification.", Abort);
+
+    QCOMPARE(usedSimplex(l, Qt::Horizontal), false);
+    QCOMPARE(usedSimplex(l, Qt::Vertical), false);
+}
+
 QTEST_MAIN(tst_QGraphicsAnchorLayout)
 #include "tst_qgraphicsanchorlayout.moc"
diff --git a/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp b/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp
index 1c7a159..0fbd069 100644
--- a/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp
+++ b/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp
@@ -162,10 +162,14 @@ Q_DECLARE_METATYPE(AnchorItemSizeHintList)
 class TestWidget : public QGraphicsWidget
 {
 public:
-    inline TestWidget(QGraphicsItem *parent = 0)
+    inline TestWidget(QGraphicsItem *parent = 0, const QString &name = QString())
         : QGraphicsWidget(parent)
         {
             setContentsMargins( 0,0,0,0 );
+            if (name.isEmpty())
+                setData(0, QString::fromAscii("w%1").arg(int(this)));
+            else
+                setData(0, name);
         }
     ~TestWidget()
         {
@@ -419,7 +423,6 @@ void tst_QGraphicsAnchorLayout1::testAddAndRemoveAnchor()
     layout->setAnchor(layout, Qt::AnchorLeft, widget5, Qt::AnchorTop, 10);
     QCOMPARE( layout->count(), 4 );
 
-    // ###: NOT SUPPORTED
     // anchor two edges of a widget (to define width / height)
     QTest::ignoreMessage(QtWarningMsg, "QGraphicsAnchorLayout::addAnchor(): Cannot anchor the item to itself");
     layout->setAnchor(widget5, Qt::AnchorLeft, widget5, Qt::AnchorRight, 10);
@@ -516,8 +519,6 @@ void tst_QGraphicsAnchorLayout1::testIsValid()
     widget->setLayout(layout);
 
     widget->setGeometry(QRectF(0,0,100,100));
-    // ###: this shall change once isValid() is ready
-    // QCOMPARE(layout->isValid(), false);
     QCOMPARE(layout->isValid(), true);
     delete widget;
     }
@@ -694,9 +695,8 @@ void tst_QGraphicsAnchorLayout1::testSpecialCases()
     layout2->setAnchor(widget1, Qt::AnchorRight, layout2, Qt::AnchorRight, 1);
     layout2->setAnchor(widget1, Qt::AnchorBottom, layout2, Qt::AnchorBottom, 1);
 
-    // ###: uncomment when simplification bug is solved
-    //widget->setGeometry(QRectF(0,0,100,100));
-    //QCOMPARE(widget1->geometry(), QRectF(51,2,47,96));
+    widget->setGeometry(QRectF(0,0,100,100));
+    QCOMPARE(widget1->geometry(), QRectF(51,2,47,96));
     delete widget;
     }
 
@@ -896,9 +896,6 @@ void tst_QGraphicsAnchorLayout1::testBasicLayout_data()
             << BasicData(-1, Qt::AnchorLeft, 1, Qt::AnchorRight, 20)
             ;
 
-        // ### SIMPLIFICATION BUG FOR ITEM 1
-        // ### remove this when bug is solved
-
         theResult
             << BasicResult(0, QRectF(10, 10, 180, 80) )
             << BasicResult(1, QRectF(10, 80, 10, 10) )
@@ -1664,6 +1661,18 @@ inline QGraphicsLayoutItem *getItem(
     return widgets[index];
 }
 
+static QRectF truncate(QRectF original)
+{
+    QRectF result;
+
+    result.setX(qRound(original.x() * 1000000) / 1000000.0);
+    result.setY(qRound(original.y() * 1000000) / 1000000.0);
+    result.setWidth(qRound(original.width() * 1000000) / 1000000.0);
+    result.setHeight(qRound(original.height() * 1000000) / 1000000.0);
+
+    return result;
+}
+
 void tst_QGraphicsAnchorLayout1::testBasicLayout()
 {
     QFETCH(QSizeF, size);
@@ -1684,7 +1693,7 @@ void tst_QGraphicsAnchorLayout1::testBasicLayout()
     // Create dummy widgets
     QList<QGraphicsWidget *> widgets;
     for (int i = 0; i < widgetCount; ++i) {
-        TestWidget *w = new TestWidget;
+        TestWidget *w = new TestWidget(0, QString::fromAscii("W%1").arg(i));
         widgets << w;
     }
 
@@ -1704,19 +1713,18 @@ void tst_QGraphicsAnchorLayout1::testBasicLayout()
     widget->setLayout(layout);
     widget->setContentsMargins(0,0,0,0);
 
-    widget->setMinimumSize(size);
-    widget->setMaximumSize(size);
-
-//    QTest::qWait(500); // layouting is asynchronous..
+    widget->resize(size);
+    QCOMPARE(widget->size(), size);
 
     // Validate
     for (int i = 0; i < result.count(); ++i) {
         const BasicLayoutTestResult item = result[i];
-        QCOMPARE(widgets[item.index]->geometry(), item.rect);
+        QRectF expected = truncate(item.rect);
+        QRectF actual = truncate(widgets[item.index]->geometry());
+
+        QCOMPARE(expected, actual);
     }
 
-    // ###: not supported yet
-/*
     // Test mirrored mode
     widget->setLayoutDirection(Qt::RightToLeft);
     layout->activate();
@@ -1728,10 +1736,13 @@ void tst_QGraphicsAnchorLayout1::testBasicLayout()
         if (mirroredRect.isValid()){
             mirroredRect.moveLeft(size.width()-item.rect.width()-item.rect.left());
         }
-        QCOMPARE(widgets[item.index]->geometry(), mirroredRect);
+        QRectF expected = truncate(mirroredRect);
+        QRectF actual = truncate(widgets[item.index]->geometry());
+
+        QCOMPARE(expected, actual);
         delete widgets[item.index];
     }
-*/
+
     delete widget;
 }
 
@@ -2212,8 +2223,8 @@ void tst_QGraphicsAnchorLayout1::testRemoveCenterAnchor()
     widget->setLayout(layout);
     widget->setContentsMargins(0,0,0,0);
 
-    widget->setMinimumSize(size);
-    widget->setMaximumSize(size);
+    widget->resize(size);
+    QCOMPARE(widget->size(), size);
 
     // Validate
     for (int i = 0; i < result.count(); ++i) {
@@ -2430,6 +2441,8 @@ void tst_QGraphicsAnchorLayout1::testDoubleSizePolicy_data()
         QTest::newRow("double size policy: expanding-preferred") << sizePolicy1 << sizePolicy2 << width1 << width2;
     }
 
+    // QGAL handling of ignored flag is different
+    if (0)
     {
         QSizePolicy sizePolicy1( QSizePolicy::Ignored, QSizePolicy::Ignored );
         QSizePolicy sizePolicy2( QSizePolicy::Preferred, QSizePolicy::Preferred );
@@ -2497,9 +2510,6 @@ void tst_QGraphicsAnchorLayout1::testDoubleSizePolicy_data()
 
 void tst_QGraphicsAnchorLayout1::testDoubleSizePolicy()
 {
-    // ### Size policy is not yet supported
-    return;
-
     QFETCH(QSizePolicy, policy1);
     QFETCH(QSizePolicy, policy2);
     QFETCH(qreal, width1);
@@ -3053,8 +3063,8 @@ void tst_QGraphicsAnchorLayout1::testComplexCases()
     widget->setLayout(layout);
     widget->setContentsMargins(0,0,0,0);
 
-    widget->setMinimumSize(size);
-    widget->setMaximumSize(size);
+    widget->resize(size);
+    QCOMPARE(widget->size(), size);
 
 //    QTest::qWait(500); // layouting is asynchronous..
 
diff --git a/tests/auto/qgraphicseffectsource/tst_qgraphicseffectsource.cpp b/tests/auto/qgraphicseffectsource/tst_qgraphicseffectsource.cpp
index fbeb425..55294d5 100644
--- a/tests/auto/qgraphicseffectsource/tst_qgraphicseffectsource.cpp
+++ b/tests/auto/qgraphicseffectsource/tst_qgraphicseffectsource.cpp
@@ -357,7 +357,7 @@ void tst_QGraphicsEffectSource::pixmapPadding_data()
 
     QTest::newRow("log,transparent") << int(Qt::LogicalCoordinates)
                                      << int(QGraphicsEffectSource::ExpandToTransparentBorderPadMode)
-                                     << QSize(12, 12) << QPoint(-1, -1)
+                                     << QSize(14, 14) << QPoint(-2, -2)
                                      << 0x00000000u;
 
     QTest::newRow("log,effectrect") << int(Qt::LogicalCoordinates)
@@ -372,7 +372,7 @@ void tst_QGraphicsEffectSource::pixmapPadding_data()
 
     QTest::newRow("dev,transparent") << int(Qt::DeviceCoordinates)
                                      << int(QGraphicsEffectSource::ExpandToTransparentBorderPadMode)
-                                     << QSize(22, 22) << QPoint(39, 39)
+                                     << QSize(24, 24) << QPoint(38, 38)
                                      << 0x00000000u;
 
     QTest::newRow("dev,effectrect") << int(Qt::DeviceCoordinates)
diff --git a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
index 684ad4f..d65c6ec 100644
--- a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
+++ b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
@@ -401,6 +401,7 @@ private slots:
     void modality_clickFocus();
     void modality_keyEvents();
     void itemIsInFront();
+    void scenePosChange();
 
     // task specific tests below me
     void task141694_textItemEnsureVisible();
@@ -4229,6 +4230,8 @@ protected:
             break;
         case QGraphicsItem::ItemOpacityHasChanged:
             break;
+        case QGraphicsItem::ItemScenePositionHasChanged:
+            break;
         }
         return itemChangeReturnValue.isValid() ? itemChangeReturnValue : value;
     }
@@ -7676,20 +7679,6 @@ void tst_QGraphicsItem::hitTestGraphicsEffectItem()
     QCOMPARE(items.size(), 1);
     QCOMPARE(items.at(0), static_cast<QGraphicsItem *>(item3));
 
-    item1->repaints = 0;
-    item2->repaints = 0;
-    item3->repaints = 0;
-
-    view.viewport()->update(75, 75, 20, 20);
-    QTest::qWait(50);
-
-    // item1 is the effect source and must therefore be repainted.
-    // item2 intersects with the exposed region
-    // item3 is just another child outside the exposed region
-    QCOMPARE(item1->repaints, 1);
-    QCOMPARE(item2->repaints, 1);
-    QCOMPARE(item3->repaints, 0);
-
     scene.setItemIndexMethod(QGraphicsScene::NoIndex);
     QTest::qWait(100);
 
@@ -9691,5 +9680,76 @@ void tst_QGraphicsItem::itemIsInFront()
     QCOMPARE(qt_closestItemFirst(rect1child1_2, rect2child1), false);
 }
 
+class ScenePosChangeTester : public ItemChangeTester
+{
+public:
+    ScenePosChangeTester()
+    { }
+    ScenePosChangeTester(QGraphicsItem *parent) : ItemChangeTester(parent)
+    { }
+};
+
+void tst_QGraphicsItem::scenePosChange()
+{
+    ScenePosChangeTester* root = new ScenePosChangeTester;
+    ScenePosChangeTester* child1 = new ScenePosChangeTester(root);
+    ScenePosChangeTester* grandChild1 = new ScenePosChangeTester(child1);
+    ScenePosChangeTester* child2 = new ScenePosChangeTester(root);
+    ScenePosChangeTester* grandChild2 = new ScenePosChangeTester(child2);
+
+    child1->setFlag(QGraphicsItem::ItemSendsScenePositionChanges, true);
+    grandChild2->setFlag(QGraphicsItem::ItemSendsScenePositionChanges, true);
+
+    QGraphicsScene scene;
+    scene.addItem(root);
+
+    // ignore uninteresting changes
+    child1->clear();
+    child2->clear();
+    grandChild1->clear();
+    grandChild2->clear();
+
+    // move whole tree
+    root->moveBy(1.0, 1.0);
+    QCOMPARE(child1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 1);
+    QCOMPARE(grandChild1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+    QCOMPARE(child2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+    QCOMPARE(grandChild2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 1);
+
+    // move subtree
+    child2->moveBy(1.0, 1.0);
+    QCOMPARE(child1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 1);
+    QCOMPARE(grandChild1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+    QCOMPARE(child2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+    QCOMPARE(grandChild2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 2);
+
+    // reparent
+    grandChild2->setParentItem(child1);
+    child1->moveBy(1.0, 1.0);
+    QCOMPARE(child1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 2);
+    QCOMPARE(grandChild1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+    QCOMPARE(child2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+    QCOMPARE(grandChild2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 3);
+
+    // change flags
+    grandChild1->setFlag(QGraphicsItem::ItemSendsScenePositionChanges, true);
+    grandChild2->setFlag(QGraphicsItem::ItemSendsScenePositionChanges, false);
+    QCoreApplication::processEvents(); // QGraphicsScenePrivate::_q_updateScenePosDescendants()
+    child1->moveBy(1.0, 1.0);
+    QCOMPARE(child1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 3);
+    QCOMPARE(grandChild1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 1);
+    QCOMPARE(child2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+    QCOMPARE(grandChild2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 3);
+
+    // remove
+    scene.removeItem(grandChild1);
+    delete grandChild2; grandChild2 = 0;
+    QCoreApplication::processEvents(); // QGraphicsScenePrivate::_q_updateScenePosDescendants()
+    root->moveBy(1.0, 1.0);
+    QCOMPARE(child1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 4);
+    QCOMPARE(grandChild1->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 1);
+    QCOMPARE(child2->changes.count(QGraphicsItem::ItemScenePositionHasChanged), 0);
+}
+
 QTEST_MAIN(tst_QGraphicsItem)
 #include "tst_qgraphicsitem.moc"
diff --git a/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp b/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp
index 0589994..9a561eb 100644
--- a/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp
+++ b/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp
@@ -225,6 +225,7 @@ private slots:
     void focusItem();
     void focusItemLostFocus();
     void setFocusItem();
+    void setFocusItem_inactive();
     void mouseGrabberItem();
     void hoverEvents_siblings();
     void hoverEvents_parentChild();
@@ -267,6 +268,7 @@ private slots:
     void initialFocus_data();
     void initialFocus();
     void polishItems();
+    void isActive();
 
     // task specific tests below me
     void task139710_bspTreeCrash();
@@ -1453,6 +1455,13 @@ void tst_QGraphicsScene::focusItemLostFocus()
     item->clearFocus();
 }
 
+class ClearTestItem : public QGraphicsRectItem
+{
+public:
+    ~ClearTestItem() { qDeleteAll(items); }
+    QList<QGraphicsItem *> items;
+};
+
 void tst_QGraphicsScene::clear()
 {
     QGraphicsScene scene;
@@ -1463,6 +1472,19 @@ void tst_QGraphicsScene::clear()
     scene.clear();
     QVERIFY(scene.items().isEmpty());
     QCOMPARE(scene.sceneRect(), QRectF(0, 0, 100, 100));
+
+    ClearTestItem *firstItem = new ClearTestItem;
+    QGraphicsItem *secondItem = new QGraphicsRectItem;
+    firstItem->items += secondItem;
+
+    scene.setItemIndexMethod(QGraphicsScene::NoIndex);
+    scene.addItem(firstItem);
+    scene.addItem(secondItem);
+    QCOMPARE(scene.items().at(0), firstItem);
+    QCOMPARE(scene.items().at(1), secondItem);
+    // must not crash even if firstItem deletes secondItem
+    scene.clear();
+    QVERIFY(scene.items().isEmpty());
 }
 
 void tst_QGraphicsScene::setFocusItem()
@@ -1514,6 +1536,26 @@ void tst_QGraphicsScene::setFocusItem()
     QVERIFY(!item2->hasFocus());
 }
 
+void tst_QGraphicsScene::setFocusItem_inactive()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item = scene.addText("Qt");
+    QVERIFY(!scene.focusItem());
+    QVERIFY(!scene.hasFocus());
+    scene.setFocusItem(item);
+    QVERIFY(!scene.hasFocus());
+    QVERIFY(!scene.focusItem());
+    item->setFlag(QGraphicsItem::ItemIsFocusable);
+
+    for (int i = 0; i < 3; ++i) {
+        scene.setFocusItem(item);
+        QCOMPARE(scene.focusItem(), item);
+        QVERIFY(!item->hasFocus());
+    }
+
+}
+
+
 void tst_QGraphicsScene::mouseGrabberItem()
 {
     QGraphicsScene scene;
@@ -3110,6 +3152,7 @@ void tst_QGraphicsScene::tabFocus_sceneWithFocusableItems()
     QVERIFY(!view->viewport()->hasFocus());
     QVERIFY(!scene.hasFocus());
     QVERIFY(!item->hasFocus());
+    QCOMPARE(scene.focusItem(), static_cast<QGraphicsItem *>(item));
 
     // Check that the correct item regains focus.
     widget.show();
@@ -3117,8 +3160,10 @@ void tst_QGraphicsScene::tabFocus_sceneWithFocusableItems()
     widget.activateWindow();
     QTest::qWaitForWindowShown(&widget);
     QTRY_VERIFY(view->hasFocus());
+    QTRY_VERIFY(scene.isActive());
     QVERIFY(view->viewport()->hasFocus());
     QVERIFY(scene.hasFocus());
+    QCOMPARE(scene.focusItem(), static_cast<QGraphicsItem *>(item));
     QVERIFY(item->hasFocus());
 }
 
@@ -3910,5 +3955,180 @@ void tst_QGraphicsScene::polishItems()
     QMetaObject::invokeMethod(&scene,"_q_polishItems");
 }
 
+void tst_QGraphicsScene::isActive()
+{
+    QGraphicsScene scene1;
+    QVERIFY(!scene1.isActive());
+    QGraphicsScene scene2;
+    QVERIFY(!scene2.isActive());
+
+    {
+        QWidget toplevel1;
+        QHBoxLayout *layout = new QHBoxLayout;
+        toplevel1.setLayout(layout);
+        QGraphicsView *view1 = new QGraphicsView(&scene1);
+        QGraphicsView *view2 = new QGraphicsView(&scene2);
+        layout->addWidget(view1);
+        layout->addWidget(view2);
+
+        QVERIFY(!scene1.isActive());
+        QVERIFY(!scene2.isActive());
+
+        view1->setVisible(false);
+
+        toplevel1.show();
+        QApplication::setActiveWindow(&toplevel1);
+        QTest::qWaitForWindowShown(&toplevel1);
+        QTRY_COMPARE(QApplication::activeWindow(), &toplevel1);
+
+        QVERIFY(!scene1.isActive()); //it is hidden;
+        QVERIFY(scene2.isActive());
+
+        view1->show();
+        QVERIFY(scene1.isActive());
+        QVERIFY(scene2.isActive());
+
+        view2->hide();
+
+        QVERIFY(scene1.isActive());
+        QVERIFY(!scene2.isActive());
+
+        toplevel1.hide();
+        QTest::qWait(12);
+        QTRY_VERIFY(!scene1.isActive());
+        QTRY_VERIFY(!scene2.isActive());
+
+        toplevel1.show();
+        QApplication::setActiveWindow(&toplevel1);
+        QApplication::processEvents();
+        QTRY_COMPARE(QApplication::activeWindow(), &toplevel1);
+
+        QTRY_VERIFY(scene1.isActive());
+        QTRY_VERIFY(!scene2.isActive());
+
+        view2->show();
+        QVERIFY(scene1.isActive());
+        QVERIFY(scene2.isActive());
+    }
+
+    QVERIFY(!scene1.isActive());
+    QVERIFY(!scene2.isActive());
+
+    {
+        QWidget toplevel2;
+        QHBoxLayout *layout = new QHBoxLayout;
+        toplevel2.setLayout(layout);
+        QGraphicsView *view1 = new QGraphicsView(&scene1);
+        QGraphicsView *view2 = new QGraphicsView();
+        layout->addWidget(view1);
+        layout->addWidget(view2);
+
+        QVERIFY(!scene1.isActive());
+        QVERIFY(!scene2.isActive());
+
+        toplevel2.show();
+        QApplication::setActiveWindow(&toplevel2);
+        QTest::qWaitForWindowShown(&toplevel2);
+        QTRY_COMPARE(QApplication::activeWindow(), &toplevel2);
+
+        QVERIFY(scene1.isActive());
+        QVERIFY(!scene2.isActive());
+
+        view2->setScene(&scene2);
+
+        QVERIFY(scene1.isActive());
+        QVERIFY(scene2.isActive());
+
+        view1->setScene(&scene2);
+        QVERIFY(!scene1.isActive());
+        QVERIFY(scene2.isActive());
+
+        view1->hide();
+        QVERIFY(!scene1.isActive());
+        QVERIFY(scene2.isActive());
+
+        view1->setScene(&scene1);
+        QVERIFY(!scene1.isActive());
+        QVERIFY(scene2.isActive());
+
+        view1->show();
+
+        view1->show();
+        QVERIFY(scene1.isActive());
+        QVERIFY(scene2.isActive());
+
+        view2->hide();
+        QVERIFY(scene1.isActive());
+        QVERIFY(!scene2.isActive());
+
+        QGraphicsView topLevelView;
+        topLevelView.show();
+        QApplication::setActiveWindow(&topLevelView);
+        QTest::qWaitForWindowShown(&topLevelView);
+        QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&topLevelView));
+
+        QVERIFY(!scene1.isActive());
+        QVERIFY(!scene2.isActive());
+
+        topLevelView.setScene(&scene1);
+        QVERIFY(scene1.isActive());
+        QVERIFY(!scene2.isActive());
+
+        view2->show();
+        QVERIFY(scene1.isActive());
+        QVERIFY(!scene2.isActive());
+
+        view1->hide();
+        QVERIFY(scene1.isActive());
+        QVERIFY(!scene2.isActive());
+
+        QApplication::setActiveWindow(&toplevel2);
+        QTRY_COMPARE(QApplication::activeWindow(), &toplevel2);
+
+        QVERIFY(!scene1.isActive());
+        QVERIFY(scene2.isActive());
+
+
+    }
+
+    QVERIFY(!scene1.isActive());
+    QVERIFY(!scene2.isActive());
+
+    {
+        QWidget toplevel3;
+        QHBoxLayout *layout = new QHBoxLayout;
+        toplevel3.setLayout(layout);
+        QGraphicsView *view1 = new QGraphicsView(&scene1);
+        QGraphicsView *view2 = new QGraphicsView(&scene2);
+        layout->addWidget(view1);
+
+        QVERIFY(!scene1.isActive());
+        QVERIFY(!scene2.isActive());
+
+        toplevel3.show();
+        QApplication::setActiveWindow(&toplevel3);
+        QTest::qWaitForWindowShown(&toplevel3);
+        QTRY_COMPARE(QApplication::activeWindow(), &toplevel3);
+
+        QVERIFY(scene1.isActive());
+        QVERIFY(!scene2.isActive());
+
+        layout->addWidget(view2);
+        QApplication::processEvents();
+        QVERIFY(scene1.isActive());
+        QVERIFY(scene2.isActive());
+
+        view1->setParent(0);
+        QVERIFY(!scene1.isActive());
+        QVERIFY(scene2.isActive());
+        delete view1;
+    }
+
+    QVERIFY(!scene1.isActive());
+    QVERIFY(!scene2.isActive());
+
+}
+
+
 QTEST_MAIN(tst_QGraphicsScene)
 #include "tst_qgraphicsscene.moc"
diff --git a/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp b/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp
index d8ab06e..9b15ab1 100644
--- a/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp
+++ b/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp
@@ -259,7 +259,7 @@ void tst_QGraphicsTransform::rotation3d()
 
     // Check that "rotation" produces the 4x4 form of the 3x3 matrix.
     // i.e. third row and column are 0 0 1 0.
-    t.setIdentity();
+    t.setToIdentity();
     rotation.applyTo(&t);
     QMatrix4x4 r(expected);
     if (sizeof(qreal) == sizeof(float) && angle == 268) {
@@ -274,7 +274,7 @@ void tst_QGraphicsTransform::rotation3d()
     rotation.setAxis(QVector3D(0, 0, 0));
     rotation.setOrigin(QVector3D(10, 10, 0));
 
-    t.setIdentity();
+    t.setToIdentity();
     rotation.applyTo(&t);
 
     QVERIFY(t.isIdentity());
@@ -337,7 +337,7 @@ void tst_QGraphicsTransform::rotation3dArbitraryAxis()
 
     // Check that "rotation" produces the 4x4 form of the 3x3 matrix.
     // i.e. third row and column are 0 0 1 0.
-    t.setIdentity();
+    t.setToIdentity();
     rotation.applyTo(&t);
     QMatrix4x4 r(expected);
     QVERIFY(qFuzzyCompare(t, r));
diff --git a/tests/auto/qgraphicsview/tst_qgraphicsview.cpp b/tests/auto/qgraphicsview/tst_qgraphicsview.cpp
index f07453c..9c6aa39 100644
--- a/tests/auto/qgraphicsview/tst_qgraphicsview.cpp
+++ b/tests/auto/qgraphicsview/tst_qgraphicsview.cpp
@@ -217,6 +217,7 @@ private slots:
     void update();
     void inputMethodSensitivity();
     void inputContextReset();
+    void defaultClipIntersectToView();
 
     // task specific tests below me
     void task172231_untransformableItems();
@@ -3692,6 +3693,77 @@ void tst_QGraphicsView::inputContextReset()
     QCOMPARE(inputContext.resets, 0);
 }
 
+class ViewClipTester : public QGraphicsView
+{
+public:
+    ViewClipTester(QGraphicsScene *scene = 0)
+        : QGraphicsView(scene)
+    { }
+    QRegion clipRegion;
+
+protected:
+    void drawBackground(QPainter *painter, const QRectF &rect)
+    {
+        clipRegion = painter->clipRegion();
+    }
+};
+
+class ItemClipTester : public QGraphicsRectItem
+{
+public:
+    ItemClipTester() : QGraphicsRectItem(0, 0, 20, 20)
+    {
+        setBrush(Qt::blue);
+    }
+    QRegion clipRegion;
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0)
+    {
+        clipRegion = painter->clipRegion();
+        QGraphicsRectItem::paint(painter, option, widget);
+    }
+};
+
+void tst_QGraphicsView::defaultClipIntersectToView()
+{
+    QGraphicsScene scene;
+    ItemClipTester *tester = new ItemClipTester;
+    scene.addItem(tester);
+
+    ViewClipTester view(&scene);
+    view.setAlignment(Qt::AlignTop | Qt::AlignLeft);
+    view.setFrameStyle(0);
+    view.resize(200, 200);
+    view.show();
+    QTRY_COMPARE(QApplication::activeWindow(), (QWidget *)&view);
+
+    QRect viewRect(0, 0, 200, 200);
+    QCOMPARE(view.clipRegion, QRegion(viewRect));
+    QCOMPARE(tester->clipRegion, QRegion(viewRect));
+
+    view.viewport()->update(0, 0, 5, 5);
+    view.viewport()->update(10, 10, 5, 5);
+    qApp->processEvents();
+    viewRect = QRect(0, 0, 15, 15);
+    QCOMPARE(view.clipRegion, QRegion(viewRect));
+    QCOMPARE(tester->clipRegion, QRegion(viewRect));
+
+    view.scale(2, 2);
+    qApp->processEvents();
+
+    viewRect.moveTop(-viewRect.height());
+    viewRect = QRect(0, 0, 100, 100);
+    QCOMPARE(view.clipRegion, QRegion(viewRect));
+    QCOMPARE(tester->clipRegion, QRegion(viewRect));
+
+    view.viewport()->update(0, 0, 5, 5);
+    view.viewport()->update(10, 10, 5, 5);
+    qApp->processEvents();
+    viewRect = QRect(0, 0, 8, 8);
+    QCOMPARE(view.clipRegion, QRegion(viewRect));
+    QCOMPARE(tester->clipRegion, QRegion(viewRect));
+}
+
 void tst_QGraphicsView::task253415_reconnectUpdateSceneOnSceneChanged()
 {
     QGraphicsView view;
diff --git a/tests/auto/qgridlayout/tst_qgridlayout.cpp b/tests/auto/qgridlayout/tst_qgridlayout.cpp
index 7c320be..46e2a03 100644
--- a/tests/auto/qgridlayout/tst_qgridlayout.cpp
+++ b/tests/auto/qgridlayout/tst_qgridlayout.cpp
@@ -920,9 +920,9 @@ void tst_QGridLayout::minMaxSize()
 #if defined(Q_WS_X11)
         qt_x11_wait_for_window_manager(m_toplevel);     // wait for the show
 #endif
-        QTest::qWait(20);
+        QTest::qWait(40);
         m_toplevel->adjustSize();
-        QTest::qWait(120);                              // wait for the implicit adjustSize
+        QTest::qWait(240);                              // wait for the implicit adjustSize
         // If the following fails we might have to wait longer.
         // If that does not help there is likely a problem with the implicit adjustSize in show()
         if (!fixedSize.isValid()) {
diff --git a/tests/auto/qlabel/tst_qlabel.cpp b/tests/auto/qlabel/tst_qlabel.cpp
index 9eae9c9..9d957a5 100644
--- a/tests/auto/qlabel/tst_qlabel.cpp
+++ b/tests/auto/qlabel/tst_qlabel.cpp
@@ -328,14 +328,14 @@ void tst_QLabel::eventPropagation_data()
     QTest::addColumn<bool>("propagation");
 
     QTest::newRow("plain text1") << QString("plain text") << int(Qt::LinksAccessibleByMouse) << int(Qt::NoFocus) << true;
-    QTest::newRow("plain text2") << QString("plain text") << (int)Qt::TextSelectableByKeyboard << (int)Qt::ClickFocus << false;
+    QTest::newRow("plain text2") << QString("plain text") << (int)Qt::TextSelectableByKeyboard << (int)Qt::ClickFocus << true;
     QTest::newRow("plain text3") << QString("plain text") << (int)Qt::TextSelectableByMouse << (int)Qt::ClickFocus << false;
     QTest::newRow("plain text4") << QString("plain text") << (int)Qt::NoTextInteraction << (int)Qt::NoFocus << true;
-    QTest::newRow("rich text1") << QString("<b>rich text</b>") << (int)Qt::LinksAccessibleByMouse << (int)Qt::NoFocus << false;
-    QTest::newRow("rich text2") << QString("<b>rich text</b>") << (int)Qt::TextSelectableByKeyboard << (int)Qt::ClickFocus << false;
+    QTest::newRow("rich text1") << QString("<b>rich text</b>") << (int)Qt::LinksAccessibleByMouse << (int)Qt::NoFocus << true;
+    QTest::newRow("rich text2") << QString("<b>rich text</b>") << (int)Qt::TextSelectableByKeyboard << (int)Qt::ClickFocus << true;
     QTest::newRow("rich text3") << QString("<b>rich text</b>") << (int)Qt::TextSelectableByMouse << (int)Qt::ClickFocus << false;
     QTest::newRow("rich text4") << QString("<b>rich text</b>") << (int)Qt::NoTextInteraction << (int)Qt::NoFocus << true;
-    QTest::newRow("rich text4") << QString("<b>rich text</b>") << (int)Qt::LinksAccessibleByKeyboard << (int)Qt::StrongFocus << false;
+    QTest::newRow("rich text4") << QString("<b>rich text</b>") << (int)Qt::LinksAccessibleByKeyboard << (int)Qt::StrongFocus << true;
 
     if (!test_box)
         test_box = new Widget;
diff --git a/tests/auto/qlineedit/tst_qlineedit.cpp b/tests/auto/qlineedit/tst_qlineedit.cpp
index c676959..b4dfbba 100644
--- a/tests/auto/qlineedit/tst_qlineedit.cpp
+++ b/tests/auto/qlineedit/tst_qlineedit.cpp
@@ -260,6 +260,7 @@ private slots:
     void task233101_cursorPosAfterInputMethod();
     void task241436_passwordEchoOnEditRestoreEchoMode();
     void task248948_redoRemovedSelection();
+    void taskQTBUG_4401_enterKeyClearsPassword();
 
 protected slots:
 #ifdef QT3_SUPPORT
@@ -3532,5 +3533,20 @@ void tst_QLineEdit::task248948_redoRemovedSelection()
     QCOMPARE(testWidget->text(), QLatin1String("ab"));
 }
 
+void tst_QLineEdit::taskQTBUG_4401_enterKeyClearsPassword()
+{
+    QString password("Wanna guess?");
+
+    testWidget->setText(password);
+    testWidget->setEchoMode(QLineEdit::PasswordEchoOnEdit);
+    testWidget->setFocus();
+    testWidget->selectAll();
+    QApplication::setActiveWindow(testWidget);
+    QTRY_VERIFY(testWidget->hasFocus());
+
+    QTest::keyPress(testWidget, Qt::Key_Enter);
+    QTRY_COMPARE(testWidget->text(), password);
+}
+
 QTEST_MAIN(tst_QLineEdit)
 #include "tst_qlineedit.moc"
diff --git a/tests/auto/qlistview/tst_qlistview.cpp b/tests/auto/qlistview/tst_qlistview.cpp
index a5ff153..1c8fecf 100644
--- a/tests/auto/qlistview/tst_qlistview.cpp
+++ b/tests/auto/qlistview/tst_qlistview.cpp
@@ -121,6 +121,7 @@ private slots:
     void taskQTBUG_2233_scrollHiddenItems();
     void taskQTBUG_633_changeModelData();
     void taskQTBUG_435_deselectOnViewportClick();
+    void taskQTBUG_2678_spacingAndWrappedText();
 };
 
 // Testing get/set functions
@@ -1787,13 +1788,13 @@ void tst_QListView::task262152_setModelColumnNavigate()
 
     view.show();
     QTest::qWaitForWindowShown(&view);
-    QTest::qWait(100);
+    QTest::qWait(120);
     QTest::keyClick(&view, Qt::Key_Down);
-    QTest::qWait(100);
-    QCOMPARE(view.currentIndex(), model.index(1,1));
+    QTest::qWait(30);
+    QTRY_COMPARE(view.currentIndex(), model.index(1,1));
     QTest::keyClick(&view, Qt::Key_Down);
-    QTest::qWait(100);
-    QCOMPARE(view.currentIndex(), model.index(2,1));
+    QTest::qWait(30);
+    QTRY_COMPARE(view.currentIndex(), model.index(2,1));
 
 }
 
@@ -1861,7 +1862,7 @@ void tst_QListView::taskQTBUG_435_deselectOnViewportClick()
     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
@@ -1876,5 +1877,19 @@ void tst_QListView::taskQTBUG_435_deselectOnViewportClick()
     QVERIFY(!view.selectionModel()->hasSelection());
 }
 
+void tst_QListView::taskQTBUG_2678_spacingAndWrappedText()
+{
+    static const QString lorem("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.");
+    QStringListModel model(QStringList() << lorem << lorem << "foo" << lorem << "bar" << lorem << lorem);
+    QListView w;
+    w.setModel(&model);
+    w.setViewMode(QListView::ListMode);
+    w.setWordWrap(true);
+    w.setSpacing(10);
+    w.show();
+    QTest::qWaitForWindowShown(&w);
+    QCOMPARE(w.horizontalScrollBar()->minimum(), w.horizontalScrollBar()->maximum());
+}
+
 QTEST_MAIN(tst_QListView)
 #include "tst_qlistview.moc"
diff --git a/tests/auto/qmatrixnxn/tst_qmatrixnxn.cpp b/tests/auto/qmatrixnxn/tst_qmatrixnxn.cpp
index ff5e00f..d6d217f2 100644
--- a/tests/auto/qmatrixnxn/tst_qmatrixnxn.cpp
+++ b/tests/auto/qmatrixnxn/tst_qmatrixnxn.cpp
@@ -151,14 +151,8 @@ private slots:
 
     void convertGeneric();
 
-    void extractAxisRotation_data();
-    void extractAxisRotation();
-
-    void extractTranslation_data();
-    void extractTranslation();
-
-    void inferSpecialType_data();
-    void inferSpecialType();
+    void optimize_data();
+    void optimize();
 
     void columnsAndRows();
 
@@ -515,13 +509,13 @@ void tst_QMatrixNxN::create2x2()
     m5 = m3;
     QVERIFY(isSame(m5, uniqueValues2));
 
-    m5.setIdentity();
+    m5.setToIdentity();
     QVERIFY(isIdentity(m5));
 
     QMatrix2x2 m6(uniqueValues2);
     QVERIFY(isSame(m6, uniqueValues2));
     qreal vals[4];
-    m6.toValueArray(vals);
+    m6.copyDataTo(vals);
     for (int index = 0; index < 4; ++index)
         QCOMPARE(vals[index], uniqueValues2[index]);
 }
@@ -550,13 +544,13 @@ void tst_QMatrixNxN::create3x3()
     m5 = m3;
     QVERIFY(isSame(m5, uniqueValues3));
 
-    m5.setIdentity();
+    m5.setToIdentity();
     QVERIFY(isIdentity(m5));
 
     QMatrix3x3 m6(uniqueValues3);
     QVERIFY(isSame(m6, uniqueValues3));
     qreal vals[9];
-    m6.toValueArray(vals);
+    m6.copyDataTo(vals);
     for (int index = 0; index < 9; ++index)
         QCOMPARE(vals[index], uniqueValues3[index]);
 }
@@ -585,13 +579,13 @@ void tst_QMatrixNxN::create4x4()
     m5 = m3;
     QVERIFY(isSame(m5, uniqueValues4));
 
-    m5.setIdentity();
+    m5.setToIdentity();
     QVERIFY(isIdentity(m5));
 
     QMatrix4x4 m6(uniqueValues4);
     QVERIFY(isSame(m6, uniqueValues4));
     qreal vals[16];
-    m6.toValueArray(vals);
+    m6.copyDataTo(vals);
     for (int index = 0; index < 16; ++index)
         QCOMPARE(vals[index], uniqueValues4[index]);
 
@@ -627,13 +621,13 @@ void tst_QMatrixNxN::create4x3()
     m5 = m3;
     QVERIFY(isSame(m5, uniqueValues4x3));
 
-    m5.setIdentity();
+    m5.setToIdentity();
     QVERIFY(isIdentity(m5));
 
     QMatrix4x3 m6(uniqueValues4x3);
     QVERIFY(isSame(m6, uniqueValues4x3));
     qreal vals[12];
-    m6.toValueArray(vals);
+    m6.copyDataTo(vals);
     for (int index = 0; index < 12; ++index)
         QCOMPARE(vals[index], uniqueValues4x3[index]);
 }
@@ -802,7 +796,7 @@ void tst_QMatrixNxN::transposed4x3()
     QMatrix4x3 m3(uniqueValues4x3);
     QMatrix3x4 m4 = m3.transposed();
     qreal values[12];
-    m4.toValueArray(values);
+    m4.copyDataTo(values);
     for (int index = 0; index < 12; ++index)
         QCOMPARE(values[index], transposedValues3x4[index]);
 }
@@ -1296,7 +1290,7 @@ void tst_QMatrixNxN::multiply4x3()
     QGenericMatrix<3, 3, qreal> m4;
     m4 = m1 * m2;
     qreal values[9];
-    m4.toValueArray(values);
+    m4.copyDataTo(values);
     for (int index = 0; index < 9; ++index)
         QCOMPARE(values[index], ((const qreal *)m3Values)[index]);
 }
@@ -1898,7 +1892,7 @@ void tst_QMatrixNxN::inverted4x4()
     }
 
     // Test again, after inferring the special matrix type.
-    m1.inferSpecialType();
+    m1.optimize();
     m2 = m1.inverted(&inv);
     QVERIFY(isSame(m2, (const qreal *)m2Values));
     QCOMPARE(inv, invertible);
@@ -1913,12 +1907,12 @@ void tst_QMatrixNxN::orthonormalInverse4x4()
     m2.rotate(45.0, 1.0, 0.0, 0.0);
     m2.translate(10.0, 0.0, 0.0);
 
-    // Use inferSpecialType() to drop the internal flags that
+    // Use optimize() to drop the internal flags that
     // mark the matrix as orthonormal.  This will force inverted()
     // to compute m3.inverted() the long way.  We can then compare
     // the result to what the faster algorithm produces on m2.
     QMatrix4x4 m3 = m2;
-    m3.inferSpecialType();
+    m3.optimize();
     bool invertible;
     QVERIFY(qFuzzyCompare(m2.inverted(&invertible), m3.inverted()));
     QVERIFY(invertible);
@@ -1926,7 +1920,7 @@ void tst_QMatrixNxN::orthonormalInverse4x4()
     QMatrix4x4 m4;
     m4.rotate(45.0, 0.0, 1.0, 0.0);
     QMatrix4x4 m5 = m4;
-    m5.inferSpecialType();
+    m5.optimize();
     QVERIFY(qFuzzyCompare(m4.inverted(), m5.inverted()));
 
     QMatrix4x4 m6;
@@ -1934,7 +1928,7 @@ void tst_QMatrixNxN::orthonormalInverse4x4()
     m1.translate(-20.0, 20.0, 15.0);
     m1.rotate(25, 1.0, 0.0, 0.0);
     QMatrix4x4 m7 = m6;
-    m7.inferSpecialType();
+    m7.optimize();
     QVERIFY(qFuzzyCompare(m6.inverted(), m7.inverted()));
 }
 
@@ -2081,7 +2075,7 @@ void tst_QMatrixNxN::scale4x4()
         m8.scale(x);
         QVERIFY(isSame(m8, (const qreal *)resultValues));
 
-        m8.inferSpecialType();
+        m8.optimize();
         m8.scale(1.0f);
         QVERIFY(isSame(m8, (const qreal *)resultValues));
 
@@ -2412,7 +2406,7 @@ void tst_QMatrixNxN::rotate4x4()
 
     if (x != 0 || y != 0 || z != 0) {
         QQuaternion q = QQuaternion::fromAxisAndAngle(QVector3D(x, y, z), angle);
-        QVector3D vq = q.rotateVector(v1);
+        QVector3D vq = q.rotatedVector(v1);
         QVERIFY(fuzzyCompare(vq.x(), v1x));
         QVERIFY(fuzzyCompare(vq.y(), v1y));
         QVERIFY(fuzzyCompare(vq.z(), v1z));
@@ -2509,7 +2503,7 @@ void tst_QMatrixNxN::normalMatrix()
 
     // Perform the test again, after inferring special matrix types.
     // This tests the optimized paths in the normalMatrix() function.
-    m1.inferSpecialType();
+    m1.optimize();
     n1 = m1.normalMatrix();
 
     if (invertible)
@@ -2850,120 +2844,6 @@ void tst_QMatrixNxN::convertGeneric()
     QVERIFY(isSame(m11, conv4x4));
 }
 
-void tst_QMatrixNxN::extractAxisRotation_data()
-{
-    QTest::addColumn<float>("x");
-    QTest::addColumn<float>("y");
-    QTest::addColumn<float>("z");
-    QTest::addColumn<float>("angle");
-    
-    QTest::newRow("1, 0, 0, 0 deg") << 1.0f << 0.0f << 0.0f << 0.0f;
-    QTest::newRow("1, 0, 0, 90 deg") << 1.0f << 0.0f << 0.0f << 90.0f;
-    QTest::newRow("1, 0, 0, 270 deg") << 1.0f << 0.0f << 0.0f << 270.0f;
-    QTest::newRow("1, 0, 0, 45 deg") << 1.0f << 0.0f << 0.0f << 45.0f;
-    QTest::newRow("1, 0, 0, 120 deg") << 1.0f << 0.0f << 0.0f << 120.0f;
-    QTest::newRow("1, 0, 0, 300 deg") << 1.0f << 0.0f << 0.0f << 300.0f;
-
-    QTest::newRow("0, 1, 0, 90 deg") << 0.0f << 1.0f << 0.0f << 90.0f;
-    QTest::newRow("0, 1, 0, 270 deg") << 0.0f << 1.0f << 0.0f << 270.0f;
-    QTest::newRow("0, 1, 0, 45 deg") << 0.0f << 1.0f << 0.0f << 45.0f;
-    QTest::newRow("0, 1, 0, 120 deg") << 0.0f << 1.0f << 0.0f << 120.0f;
-    QTest::newRow("0, 1, 0, 300 deg") << 0.0f << 1.0f << 0.0f << 300.0f;
-    
-    QTest::newRow("0, 0, 1, 90 deg") << 0.0f << 0.0f << 1.0f << 90.0f;
-    QTest::newRow("0, 0, 1, 270 deg") << 0.0f << 0.0f << 1.0f << 270.0f;
-    QTest::newRow("0, 0, 1, 45 deg") << 0.0f << 0.0f << 1.0f << 45.0f;
-    QTest::newRow("0, 0, 1, 120 deg") << 0.0f << 0.0f << 1.0f << 120.0f;
-    QTest::newRow("0, 0, 1, 300 deg") << 0.0f << 0.0f << 1.0f << 300.0f;
-
-    QTest::newRow("1, 1, 1, 90 deg") << 1.0f << 1.0f << 1.0f << 90.0f;
-    QTest::newRow("1, 1, 1, 270 deg") << 1.0f << 1.0f << 1.0f << 270.0f;
-    QTest::newRow("1, 1, 1, 45 deg") << 1.0f << 1.0f << 1.0f << 45.0f;
-    QTest::newRow("1, 1, 1, 120 deg") << 1.0f << 1.0f << 1.0f << 120.0f;
-    QTest::newRow("1, 1, 1, 300 deg") << 1.0f << 1.0f << 1.0f << 300.0f;
-}
-
-void tst_QMatrixNxN::extractAxisRotation()
-{
-    QFETCH(float, x);
-    QFETCH(float, y);
-    QFETCH(float, z);
-    QFETCH(float, angle);
-
-    QMatrix4x4 m;
-    QVector3D origAxis(x, y, z);
-
-    m.rotate(angle, x, y, z);
-
-    origAxis.normalize();
-    QVector3D extractedAxis;
-    qreal extractedAngle;
-
-    m.extractAxisRotation(extractedAngle, extractedAxis);
- 
-    if (angle > 180) {
-        QVERIFY(fuzzyCompare(360.0f - angle, extractedAngle));
-        QVERIFY(fuzzyCompare(extractedAxis, -origAxis));
-    } else {
-        QVERIFY(fuzzyCompare(angle, extractedAngle));
-        QVERIFY(fuzzyCompare(extractedAxis, origAxis));
-    }
-}
-
-void tst_QMatrixNxN::extractTranslation_data()
-{
-    QTest::addColumn<QMatrix4x4>("rotation");
-    QTest::addColumn<float>("x");
-    QTest::addColumn<float>("y");
-    QTest::addColumn<float>("z");
-
-    static QMatrix4x4 m1;
-
-    QTest::newRow("identity, 100, 50, 25")
-        << m1 << 100.0f << 50.0f << 250.0f;
-
-    m1.rotate(45.0, 1.0, 0.0, 0.0);
-    QTest::newRow("rotX 45 + 100, 50, 25") << m1 << 100.0f << 50.0f << 25.0f;
-
-    m1.setIdentity();
-    m1.rotate(45.0, 0.0, 1.0, 0.0);
-    QTest::newRow("rotY 45 + 100, 50, 25") << m1 << 100.0f << 50.0f << 25.0f;
-
-    m1.setIdentity();
-    m1.rotate(75, 0.0, 0.0, 1.0);
-    m1.rotate(25, 1.0, 0.0, 0.0);
-    m1.rotate(45, 0.0, 1.0, 0.0);
-    QTest::newRow("rotZ 75, rotX 25, rotY 45, 100, 50, 25") << m1 << 100.0f << 50.0f << 25.0f;
-}
-
-void tst_QMatrixNxN::extractTranslation()
-{
-    QFETCH(QMatrix4x4, rotation);
-    QFETCH(float, x);
-    QFETCH(float, y);
-    QFETCH(float, z);
-
-    rotation.translate(x, y, z);
-
-    QVector3D vec = rotation.extractTranslation();
-
-    QVERIFY(fuzzyCompare(vec.x(), x));
-    QVERIFY(fuzzyCompare(vec.y(), y));
-    QVERIFY(fuzzyCompare(vec.z(), z));
-
-    QMatrix4x4 lookAt;
-    QVector3D eye(1.5f, -2.5f, 2.5f);
-    lookAt.lookAt(eye,
-                  QVector3D(10.0f, 10.0f, 10.0f), 
-                  QVector3D(0.0f, 1.0f, 0.0f));
-
-   QVector3D extEye = lookAt.extractTranslation();
-
-   QVERIFY(fuzzyCompare(eye.x(), -extEye.x()));
-   QVERIFY(fuzzyCompare(eye.y(), -extEye.y()));
-   QVERIFY(fuzzyCompare(eye.z(), -extEye.z()));
-}
-
 // Copy of "flagBits" in qmatrix4x4.h.
 enum {
     Identity        = 0x0001,   // Identity matrix
@@ -2981,7 +2861,7 @@ struct Matrix4x4
 };
 
 // Test the inferring of special matrix types.
-void tst_QMatrixNxN::inferSpecialType_data()
+void tst_QMatrixNxN::optimize_data()
 {
     QTest::addColumn<void *>("mValues");
     QTest::addColumn<int>("flagBits");
@@ -3029,13 +2909,13 @@ void tst_QMatrixNxN::inferSpecialType_data()
     QTest::newRow("below")
         << (void *)belowValues << (int)General;
 }
-void tst_QMatrixNxN::inferSpecialType()
+void tst_QMatrixNxN::optimize()
 {
     QFETCH(void *, mValues);
     QFETCH(int, flagBits);
 
     QMatrix4x4 m((const qreal *)mValues);
-    m.inferSpecialType();
+    m.optimize();
 
     QCOMPARE(reinterpret_cast<Matrix4x4 *>(&m)->flagBits, flagBits);
 }
@@ -3362,7 +3242,7 @@ void tst_QMatrixNxN::mapVector()
     QFETCH(void *, mValues);
 
     QMatrix4x4 m1((const qreal *)mValues);
-    m1.inferSpecialType();
+    m1.optimize();
 
     QVector3D v(3.5f, -1.0f, 2.5f);
 
diff --git a/tests/auto/qpainter/tst_qpainter.cpp b/tests/auto/qpainter/tst_qpainter.cpp
index 8ed83cb..4d2c626 100644
--- a/tests/auto/qpainter/tst_qpainter.cpp
+++ b/tests/auto/qpainter/tst_qpainter.cpp
@@ -239,9 +239,12 @@ private slots:
     void taskQT4444_dontOverflowDashOffset();
 
     void painterBegin();
+    void setPenColorOnImage();
+    void setPenColorOnPixmap();
 
 private:
     void fillData();
+    void setPenColor(QPainter& p);
     QColor baseColor( int k, int intensity=255 );
     QImage getResImage( const QString &dir, const QString &addition, const QString &extension );
     QBitmap getBitmap( const QString &dir, const QString &filename, bool mask );
@@ -4193,9 +4196,9 @@ void tst_QPainter::extendedBlendModes()
 
     QVERIFY(testCompositionMode(255, 255, 255, QPainter::CompositionMode_SoftLight));
     QVERIFY(testCompositionMode(  0,   0,   0, QPainter::CompositionMode_SoftLight));
-    QVERIFY(testCompositionMode(127, 127, 127, QPainter::CompositionMode_SoftLight));
-    QVERIFY(testCompositionMode( 63,  63,  86, QPainter::CompositionMode_SoftLight));
-    QVERIFY(testCompositionMode(127,  63,  63, QPainter::CompositionMode_SoftLight));
+    QVERIFY(testCompositionMode(127, 127, 126, QPainter::CompositionMode_SoftLight));
+    QVERIFY(testCompositionMode( 63,  63,  39, QPainter::CompositionMode_SoftLight));
+    QVERIFY(testCompositionMode(127,  63,  62, QPainter::CompositionMode_SoftLight));
 
     QVERIFY(testCompositionMode(255, 255,   0, QPainter::CompositionMode_Difference));
     QVERIFY(testCompositionMode(  0,   0,   0, QPainter::CompositionMode_Difference));
@@ -4352,5 +4355,41 @@ void tst_QPainter::painterBegin()
     QVERIFY(!p.end());
 }
 
+void tst_QPainter::setPenColor(QPainter& p)
+{
+    p.setPen(Qt::NoPen);
+
+    // Setting color, then style
+    // Should work even though the pen is "NoPen with color", temporarily.
+    QPen newPen(p.pen());
+    newPen.setColor(Qt::red);
+    QCOMPARE(p.pen().style(), newPen.style());
+    QCOMPARE(p.pen().style(), Qt::NoPen);
+    p.setPen(newPen);
+
+    QCOMPARE(p.pen().color().name(), QString("#ff0000"));
+
+    QPen newPen2(p.pen());
+    newPen2.setStyle(Qt::SolidLine);
+    p.setPen(newPen2);
+
+    QCOMPARE(p.pen().color().name(), QString("#ff0000"));
+}
+
+void tst_QPainter::setPenColorOnImage()
+{
+    QImage img(QSize(10, 10), QImage::Format_ARGB32_Premultiplied);
+    QPainter p(&img);
+    setPenColor(p);
+}
+
+void tst_QPainter::setPenColorOnPixmap()
+{
+    QPixmap pix(10, 10);
+    QPainter p(&pix);
+    setPenColor(p);
+}
+
 QTEST_MAIN(tst_QPainter)
+
 #include "tst_qpainter.moc"
diff --git a/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp b/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
index 8d937e9..a26e0eb 100644
--- a/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
+++ b/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
@@ -119,8 +119,8 @@ class TestAnimation : public QVariantAnimation
     Q_OBJECT
 public:
     virtual void updateCurrentValue(const QVariant &value) { Q_UNUSED(value)};
-    virtual void updateState(QAbstractAnimation::State oldState,
-                             QAbstractAnimation::State newState)
+    virtual void updateState(QAbstractAnimation::State newState,
+                             QAbstractAnimation::State oldState)
     {
         Q_UNUSED(oldState)
         Q_UNUSED(newState)
@@ -135,8 +135,8 @@ public:
     TestAnimation2(int duration, QAbstractAnimation *animation) : QVariantAnimation(animation), m_duration(duration) {}
 
     virtual void updateCurrentValue(const QVariant &value) { Q_UNUSED(value)};
-    virtual void updateState(QAbstractAnimation::State oldState,
-                             QAbstractAnimation::State newState)
+    virtual void updateState(QAbstractAnimation::State newState,
+                             QAbstractAnimation::State oldState)
     {
         Q_UNUSED(oldState)
         Q_UNUSED(newState)
@@ -223,33 +223,33 @@ void tst_QParallelAnimationGroup::setCurrentTime()
     QCOMPARE(notTimeDriven->state(), QAnimationGroup::Stopped);
     QCOMPARE(loopsForever->state(), QAnimationGroup::Stopped);
 
-    QCOMPARE(group.currentTime(), 1);
-    QCOMPARE(a1_p_o1->currentTime(), 1);
-    QCOMPARE(a1_p_o2->currentTime(), 1);
-    QCOMPARE(a1_p_o3->currentTime(), 1);
-    QCOMPARE(notTimeDriven->currentTime(), 1);
-    QCOMPARE(loopsForever->currentTime(), 1);
+    QCOMPARE(group.currentLoopTime(), 1);
+    QCOMPARE(a1_p_o1->currentLoopTime(), 1);
+    QCOMPARE(a1_p_o2->currentLoopTime(), 1);
+    QCOMPARE(a1_p_o3->currentLoopTime(), 1);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 1);
+    QCOMPARE(loopsForever->currentLoopTime(), 1);
 
     // Current time = 250
     group.setCurrentTime(250);
-    QCOMPARE(group.currentTime(), 250);
-    QCOMPARE(a1_p_o1->currentTime(), 250);
-    QCOMPARE(a1_p_o2->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 250);
+    QCOMPARE(a1_p_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_p_o2->currentLoopTime(), 0);
     QCOMPARE(a1_p_o2->currentLoop(), 1);
-    QCOMPARE(a1_p_o3->currentTime(), 250);
-    QCOMPARE(notTimeDriven->currentTime(), 250);
-    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(a1_p_o3->currentLoopTime(), 250);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 250);
+    QCOMPARE(loopsForever->currentLoopTime(), 0);
     QCOMPARE(loopsForever->currentLoop(), 1);
 
     // Current time = 251
     group.setCurrentTime(251);
-    QCOMPARE(group.currentTime(), 251);
-    QCOMPARE(a1_p_o1->currentTime(), 250);
-    QCOMPARE(a1_p_o2->currentTime(), 1);
+    QCOMPARE(group.currentLoopTime(), 251);
+    QCOMPARE(a1_p_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_p_o2->currentLoopTime(), 1);
     QCOMPARE(a1_p_o2->currentLoop(), 1);
-    QCOMPARE(a1_p_o3->currentTime(), 250);
-    QCOMPARE(notTimeDriven->currentTime(), 251);
-    QCOMPARE(loopsForever->currentTime(), 1);
+    QCOMPARE(a1_p_o3->currentLoopTime(), 250);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 251);
+    QCOMPARE(loopsForever->currentLoopTime(), 1);
 }
 
 void tst_QParallelAnimationGroup::stateChanged()
@@ -278,18 +278,18 @@ void tst_QParallelAnimationGroup::stateChanged()
     group.start();
     //all the animations should be started
     QCOMPARE(spy1.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Running);
     QCOMPARE(spy2.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Running);
     QCOMPARE(spy3.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Running);
     QCOMPARE(spy4.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Running);
 
     group.setCurrentTime(1500); //anim1 should be finished
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(spy1.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Stopped);
     QCOMPARE(spy2.count(), 1); //no change
     QCOMPARE(spy3.count(), 1); //no change
     QCOMPARE(spy4.count(), 1); //no change
@@ -298,7 +298,7 @@ void tst_QParallelAnimationGroup::stateChanged()
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(spy1.count(), 2); //no change
     QCOMPARE(spy2.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Stopped);
     QCOMPARE(spy3.count(), 1); //no change
     QCOMPARE(spy4.count(), 1); //no change
 
@@ -307,9 +307,9 @@ void tst_QParallelAnimationGroup::stateChanged()
     QCOMPARE(spy1.count(), 2); //no change
     QCOMPARE(spy2.count(), 2); //no change
     QCOMPARE(spy3.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Stopped);
     QCOMPARE(spy4.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Stopped);
 
     //cleanup
     spy1.clear();
@@ -326,22 +326,22 @@ void tst_QParallelAnimationGroup::stateChanged()
     QCOMPARE(spy1.count(), 0);
     QCOMPARE(spy2.count(), 0);
     QCOMPARE(spy3.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Running);
     QCOMPARE(spy4.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Running);
 
     group.setCurrentTime(1500); //anim2 should be started
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(spy1.count(), 0); //no change
     QCOMPARE(spy2.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Running);
     QCOMPARE(spy3.count(), 1); //no change
     QCOMPARE(spy4.count(), 1); //no change
 
     group.setCurrentTime(500); //anim1 is finally also started
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(spy1.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Running);
     QCOMPARE(spy2.count(), 1); //no change
     QCOMPARE(spy3.count(), 1); //no change
     QCOMPARE(spy4.count(), 1); //no change
@@ -349,13 +349,13 @@ void tst_QParallelAnimationGroup::stateChanged()
     group.setCurrentTime(0); //everything should be stopped
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
     QCOMPARE(spy1.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Stopped);
     QCOMPARE(spy2.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Stopped);
     QCOMPARE(spy3.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Stopped);
     QCOMPARE(spy4.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Stopped);
 }
 
 void tst_QParallelAnimationGroup::clearGroup()
@@ -375,9 +375,9 @@ void tst_QParallelAnimationGroup::clearGroup()
         children[i] = group.animationAt(i);
     }
 
-    group.clearAnimations();
+    group.clear();
     QCOMPARE(group.animationCount(), 0);
-    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
     for (int i = 0; i < animationCount; ++i)
         QVERIFY(children[i].isNull());
 }
@@ -460,9 +460,9 @@ void tst_QParallelAnimationGroup::updateChildrenWithRunningGroup()
     QCOMPARE(groupStateChangedSpy.count(), 1);
     QCOMPARE(childStateChangedSpy.count(), 1);
 
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(childStateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(childStateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
 
     // starting directly a running child will not have any effect
@@ -501,13 +501,13 @@ void tst_QParallelAnimationGroup::deleteChildrenWithRunningGroup()
     QCOMPARE(anim1->state(), QAnimationGroup::Running);
 
     QTest::qWait(80);
-    QVERIFY(group.currentTime() > 0);
+    QVERIFY(group.currentLoopTime() > 0);
 
     delete anim1;
     QVERIFY(group.animationCount() == 0);
     QCOMPARE(group.duration(), 0);
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
-    QCOMPARE(group.currentTime(), 0); //that's the invariant
+    QCOMPARE(group.currentLoopTime(), 0); //that's the invariant
 }
 
 void tst_QParallelAnimationGroup::startChildrenWithStoppedGroup()
@@ -622,11 +622,11 @@ void tst_QParallelAnimationGroup::startGroupWithRunningChild()
     anim2.start();
     anim2.pause();
 
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(1).first()),
              QAnimationGroup::Paused);
 
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
@@ -636,15 +636,15 @@ void tst_QParallelAnimationGroup::startGroupWithRunningChild()
     group.start();
 
     QCOMPARE(stateChangedSpy1.count(), 3);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(1).first()),
              QAnimationGroup::Stopped);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(2).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(2).first()),
              QAnimationGroup::Running);
 
     QCOMPARE(stateChangedSpy2.count(), 4);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(2).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(2).first()),
              QAnimationGroup::Stopped);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(3).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(3).first()),
              QAnimationGroup::Running);
 
     QCOMPARE(group.state(), QAnimationGroup::Running);
@@ -687,19 +687,19 @@ void tst_QParallelAnimationGroup::zeroDurationAnimation()
     group.start();
     QCOMPARE(stateChangedSpy1.count(), 2);
     QCOMPARE(finishedSpy1.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(1).first()),
              QAnimationGroup::Stopped);
 
     QCOMPARE(stateChangedSpy2.count(), 1);
     QCOMPARE(finishedSpy2.count(), 0);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
              QAnimationGroup::Running);
 
     QCOMPARE(stateChangedSpy3.count(), 1);
     QCOMPARE(finishedSpy3.count(), 0);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy3.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy3.at(0).first()),
              QAnimationGroup::Running);
 
 
@@ -762,9 +762,9 @@ void tst_QParallelAnimationGroup::stopUncontrolledAnimations()
     group.start();
 
     QCOMPARE(stateChangedSpy.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(1).first()),
              QAnimationGroup::Stopped);
 
     QCOMPARE(group.state(), QAnimationGroup::Running);
@@ -915,9 +915,9 @@ void tst_QParallelAnimationGroup::loopCount()
 
     group.setCurrentTime(currentGroupTime);
 
-    QCOMPARE(anim1.currentTime(), expected1.time);
-    QCOMPARE(anim2.currentTime(), expected2.time);
-    QCOMPARE(anim3.currentTime(), expected3.time);
+    QCOMPARE(anim1.currentLoopTime(), expected1.time);
+    QCOMPARE(anim2.currentLoopTime(), expected2.time);
+    QCOMPARE(anim3.currentLoopTime(), expected3.time);
 
     if (expected1.state >=0)
         QCOMPARE(int(anim1.state()), expected1.state);
@@ -968,22 +968,22 @@ void tst_QParallelAnimationGroup::pauseResume()
     QCOMPARE(anim->state(), QAnimationGroup::Running);
     QCOMPARE(spy.count(), 1);
     spy.clear();
-    const int currentTime = group.currentTime();
-    QCOMPARE(anim->currentTime(), currentTime);
+    const int currentTime = group.currentLoopTime();
+    QCOMPARE(anim->currentLoopTime(), currentTime);
 
     group.pause();
     QCOMPARE(group.state(), QAnimationGroup::Paused);
-    QCOMPARE(group.currentTime(), currentTime);
+    QCOMPARE(group.currentLoopTime(), currentTime);
     QCOMPARE(anim->state(), QAnimationGroup::Paused);
-    QCOMPARE(anim->currentTime(), currentTime);
+    QCOMPARE(anim->currentLoopTime(), currentTime);
     QCOMPARE(spy.count(), 1);
     spy.clear();
 
     group.resume();
     QCOMPARE(group.state(), QAnimationGroup::Running);
-    QCOMPARE(group.currentTime(), currentTime);
+    QCOMPARE(group.currentLoopTime(), currentTime);
     QCOMPARE(anim->state(), QAnimationGroup::Running);
-    QCOMPARE(anim->currentTime(), currentTime);
+    QCOMPARE(anim->currentLoopTime(), currentTime);
     QCOMPARE(spy.count(), 1);
 
     group.stop();
@@ -991,10 +991,10 @@ void tst_QParallelAnimationGroup::pauseResume()
     new TestAnimation2(500, &group);
     group.start();
     QCOMPARE(spy.count(), 1); //the animation should have been started
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy.last().first()), TestAnimation::Running);
     group.setCurrentTime(250); //end of first animation
     QCOMPARE(spy.count(), 2); //the animation should have been stopped
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy.last().first()), TestAnimation::Stopped);
     group.pause();
     QCOMPARE(spy.count(), 2); //this shouldn't have changed
     group.resume();
diff --git a/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
index 56c1ced..f41fff1 100644
--- a/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
+++ b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
@@ -225,7 +225,7 @@ void tst_QPropertyAnimation::setCurrentTime()
     animation.setLoopCount(loopCount);
     animation.setCurrentTime(currentTime);
 
-    QCOMPARE(animation.currentTime(), testCurrentTime);
+    QCOMPARE(animation.currentLoopTime(), testCurrentTime);
     QCOMPARE(animation.currentLoop(), testCurrentLoop);
 }
 
@@ -280,7 +280,7 @@ void tst_QPropertyAnimation::statesAndSignals()
     QCOMPARE(anim->state(), QAnimationGroup::Stopped);
     QCOMPARE(runningSpy.count(), 1); //anim must have stopped
     QCOMPARE(finishedSpy.count(), 0);
-    QCOMPARE(anim->currentTime(), 0);
+    QCOMPARE(anim->currentLoopTime(), 0);
     QCOMPARE(anim->currentLoop(), 0);
     QCOMPARE(currentLoopSpy.count(), 2);
     runningSpy.clear();
@@ -291,7 +291,7 @@ void tst_QPropertyAnimation::statesAndSignals()
     QCOMPARE(runningSpy.count(), 2); //started and stopped again
     runningSpy.clear();
     QCOMPARE(finishedSpy.count(), 1);
-    QCOMPARE(anim->currentTime(), 100);
+    QCOMPARE(anim->currentLoopTime(), 100);
     QCOMPARE(anim->currentLoop(), 2);
     QCOMPARE(currentLoopSpy.count(), 4);
 
@@ -312,7 +312,7 @@ void tst_QPropertyAnimation::statesAndSignals()
     QCOMPARE(anim->currentLoop(), 2);
     QCOMPARE(runningSpy.count(), 1); // anim has stopped
     QCOMPARE(finishedSpy.count(), 2);
-    QCOMPARE(anim->currentTime(), 100);
+    QCOMPARE(anim->currentLoopTime(), 100);
 
     delete anim;
 }
@@ -864,16 +864,16 @@ void tst_QPropertyAnimation::zeroDurationStart()
     //let's check the first state change
     const QVariantList firstChange = spy.first();
     //old state
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.first()), QAbstractAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.last()), QAbstractAnimation::Stopped);
     //new state
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.last()), QAbstractAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.first()), QAbstractAnimation::Running);
 
     //let's check the first state change
     const QVariantList secondChange = spy.last();
     //old state
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.first()), QAbstractAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.last()), QAbstractAnimation::Running);
     //new state
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.last()), QAbstractAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.first()), QAbstractAnimation::Stopped);
 }
 
 #define Pause 1
@@ -1171,9 +1171,9 @@ public:
         innerAnim->start();
     }
 
-    void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState)
+    void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
     {
-        QPropertyAnimation::updateState(oldState, newState);
+        QPropertyAnimation::updateState(newState, oldState);
         if (newState == QAbstractAnimation::Stopped)
             delete innerAnim;
     }
diff --git a/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp b/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
index f6afc5b..28fccac 100644
--- a/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
+++ b/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
@@ -87,7 +87,7 @@ private slots:
     void currentAnimation();
     void currentAnimationWithZeroDuration();
     void insertAnimation();
-    void clearAnimations();
+    void clear();
     void pauseResume();
 };
 
@@ -134,8 +134,8 @@ class TestAnimation : public QVariantAnimation
     Q_OBJECT
 public:
     virtual void updateCurrentValue(const QVariant &value) { Q_UNUSED(value)};
-    virtual void updateState(QAbstractAnimation::State oldState,
-                             QAbstractAnimation::State newState)
+    virtual void updateState(QAbstractAnimation::State newState,
+                             QAbstractAnimation::State oldState)
     {
         Q_UNUSED(oldState)
         Q_UNUSED(newState)
@@ -208,119 +208,119 @@ void tst_QSequentialAnimationGroup::setCurrentTime()
     QCOMPARE(sequence2->state(), QAnimationGroup::Stopped);
     QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
 
-    QCOMPARE(group.currentTime(), 1);
-    QCOMPARE(sequence->currentTime(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 1);
-    QCOMPARE(a2_s_o1->currentTime(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 1);
+    QCOMPARE(sequence->currentLoopTime(), 1);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 1);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 250
     group.setCurrentTime(250);
-    QCOMPARE(group.currentTime(), 250);
-    QCOMPARE(sequence->currentTime(), 250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 250);
+    QCOMPARE(sequence->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 251
     group.setCurrentTime(251);
-    QCOMPARE(group.currentTime(), 251);
-    QCOMPARE(sequence->currentTime(), 251);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 1);
+    QCOMPARE(group.currentLoopTime(), 251);
+    QCOMPARE(sequence->currentLoopTime(), 251);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 1);
     QCOMPARE(a2_s_o1->currentLoop(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(sequence2->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(sequence2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 750
     group.setCurrentTime(750);
-    QCOMPARE(group.currentTime(), 750);
-    QCOMPARE(sequence->currentTime(), 750);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 750);
+    QCOMPARE(sequence->currentLoopTime(), 750);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 0);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(sequence2->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(sequence2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 1000
     group.setCurrentTime(1000);
-    QCOMPARE(group.currentTime(), 1000);
-    QCOMPARE(sequence->currentTime(), 1000);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1000);
+    QCOMPARE(sequence->currentLoopTime(), 1000);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(sequence2->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(sequence2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 1010
     group.setCurrentTime(1010);
-    QCOMPARE(group.currentTime(), 1010);
-    QCOMPARE(sequence->currentTime(), 1010);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1010);
+    QCOMPARE(sequence->currentLoopTime(), 1010);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 10);
-    QCOMPARE(sequence2->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 10);
+    QCOMPARE(sequence2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 1250
     group.setCurrentTime(1250);
-    QCOMPARE(group.currentTime(), 1250);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1250);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 1500
     group.setCurrentTime(1500);
-    QCOMPARE(group.currentTime(), 1500);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1500);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 250);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 1750
     group.setCurrentTime(1750);
-    QCOMPARE(group.currentTime(), 1750);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1750);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 500);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 250);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 250);
 
     // Current time = 2000
     group.setCurrentTime(2000);
-    QCOMPARE(group.currentTime(), 1750);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1750);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 500);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 250);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 250);
 }
 
 void tst_QSequentialAnimationGroup::setCurrentTimeWithUncontrolledAnimation()
@@ -357,40 +357,40 @@ void tst_QSequentialAnimationGroup::setCurrentTimeWithUncontrolledAnimation()
     QCOMPARE(notTimeDriven->state(), QAnimationGroup::Stopped);
     QCOMPARE(loopsForever->state(), QAnimationGroup::Stopped);
 
-    QCOMPARE(group.currentTime(), 1);
-    QCOMPARE(sequence->currentTime(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 1);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(notTimeDriven->currentTime(), 0);
-    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 1);
+    QCOMPARE(sequence->currentLoopTime(), 1);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 1);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 0);
+    QCOMPARE(loopsForever->currentLoopTime(), 0);
 
     // Current time = 250
     group.setCurrentTime(250);
-    QCOMPARE(group.currentTime(), 250);
-    QCOMPARE(sequence->currentTime(), 250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(notTimeDriven->currentTime(), 0);
-    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 250);
+    QCOMPARE(sequence->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 0);
+    QCOMPARE(loopsForever->currentLoopTime(), 0);
 
     // Current time = 500
     group.setCurrentTime(500);
-    QCOMPARE(group.currentTime(), 500);
-    QCOMPARE(sequence->currentTime(), 500);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(notTimeDriven->currentTime(), 0);
-    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 500);
+    QCOMPARE(sequence->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 0);
+    QCOMPARE(loopsForever->currentLoopTime(), 0);
     QCOMPARE(group.currentAnimation(), notTimeDriven);
 
     // Current time = 505
     group.setCurrentTime(505);
-    QCOMPARE(group.currentTime(), 505);
-    QCOMPARE(sequence->currentTime(), 500);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(notTimeDriven->currentTime(), 5);
-    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 505);
+    QCOMPARE(sequence->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 5);
+    QCOMPARE(loopsForever->currentLoopTime(), 0);
     QCOMPARE(group.currentAnimation(), notTimeDriven);
     QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
     QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
@@ -400,12 +400,12 @@ void tst_QSequentialAnimationGroup::setCurrentTimeWithUncontrolledAnimation()
 
     // Current time = 750 (end of notTimeDriven animation)
     group.setCurrentTime(750);
-    QCOMPARE(group.currentTime(), 750);
-    QCOMPARE(sequence->currentTime(), 500);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(notTimeDriven->currentTime(), 250);
-    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 750);
+    QCOMPARE(sequence->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 250);
+    QCOMPARE(loopsForever->currentLoopTime(), 0);
     QCOMPARE(group.currentAnimation(), loopsForever);
     QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
     QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
@@ -415,13 +415,13 @@ void tst_QSequentialAnimationGroup::setCurrentTimeWithUncontrolledAnimation()
 
     // Current time = 800 (as notTimeDriven was finished at 750, loopsforever should still run)
     group.setCurrentTime(800);
-    QCOMPARE(group.currentTime(), 800);
+    QCOMPARE(group.currentLoopTime(), 800);
     QCOMPARE(group.currentAnimation(), loopsForever);
-    QCOMPARE(sequence->currentTime(), 500);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(notTimeDriven->currentTime(), 250);
-    QCOMPARE(loopsForever->currentTime(), 50);
+    QCOMPARE(sequence->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 250);
+    QCOMPARE(loopsForever->currentLoopTime(), 50);
 
     loopsForever->stop(); // this should stop the group
 
@@ -466,26 +466,26 @@ void tst_QSequentialAnimationGroup::seekingForwards()
     QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
     QCOMPARE(a1_s_o3->state(), QAnimationGroup::Stopped);
 
-    QCOMPARE(group.currentTime(), 1);
-    QCOMPARE(sequence->currentTime(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 1);
-    QCOMPARE(a2_s_o1->currentTime(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(sequence2->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 1);
+    QCOMPARE(sequence->currentLoopTime(), 1);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 1);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(sequence2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 1500
     group.setCurrentTime(1500);
-    QCOMPARE(group.currentTime(), 1500);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1500);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 250);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // this will restart the group
     group.start();
@@ -499,15 +499,15 @@ void tst_QSequentialAnimationGroup::seekingForwards()
 
     // Current time = 1750
     group.setCurrentTime(1750);
-    QCOMPARE(group.currentTime(), 1750);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1750);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 500);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 250);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 250);
 }
 
 void tst_QSequentialAnimationGroup::seekingBackwards()
@@ -537,15 +537,15 @@ void tst_QSequentialAnimationGroup::seekingBackwards()
 
     // Current time = 1600
     group.setCurrentTime(1600);
-    QCOMPARE(group.currentTime(), 1600);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1600);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 350);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 100);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 350);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 100);
 
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
@@ -556,22 +556,22 @@ void tst_QSequentialAnimationGroup::seekingBackwards()
 
     // Seeking backwards, current time = 1
     group.setCurrentTime(1);
-    QCOMPARE(group.currentTime(), 1);
-    QCOMPARE(sequence->currentTime(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 1);
+    QCOMPARE(group.currentLoopTime(), 1);
+    QCOMPARE(sequence->currentLoopTime(), 1);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 1);
 
     QEXPECT_FAIL("", "rewinding in nested groups is considered as a restart from the children,"
         "hence they don't reset from their current animation", Continue);
-    QCOMPARE(a2_s_o1->currentTime(), 0);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 0);
     QEXPECT_FAIL("", "rewinding in nested groups is considered as a restart from the children,"
         "hence they don't reset from their current animation", Continue);
     QCOMPARE(a2_s_o1->currentLoop(), 0);
     QEXPECT_FAIL("", "rewinding in nested groups is considered as a restart from the children,"
         "hence they don't reset from their current animation", Continue);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(sequence2->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(sequence2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(sequence->state(), QAnimationGroup::Running);
@@ -582,15 +582,15 @@ void tst_QSequentialAnimationGroup::seekingBackwards()
 
     // Current time = 2000
     group.setCurrentTime(2000);
-    QCOMPARE(group.currentTime(), 1750);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1750);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 500);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 250);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 250);
 
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
     QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
@@ -612,7 +612,7 @@ static bool compareStates(const QSignalSpy& spy, const StateList &expectedStates
         }
         QList<QVariant> args = spy.at(i);
         QAbstractAnimation::State st = expectedStates.at(i);
-        QAbstractAnimation::State actual = qVariantValue<QAbstractAnimation::State>(args.value(1));
+        QAbstractAnimation::State actual = qVariantValue<QAbstractAnimation::State>(args.first());
         if (equals && actual != st) {
             equals = false;
             break;
@@ -672,14 +672,14 @@ void tst_QSequentialAnimationGroup::pauseAndResume()
 
     // Current time = 1751
     group.setCurrentTime(1751);
-    QCOMPARE(group.currentTime(), 1751);
-    QCOMPARE(sequence->currentTime(), 751);
+    QCOMPARE(group.currentLoopTime(), 1751);
+    QCOMPARE(sequence->currentLoopTime(), 751);
     QCOMPARE(sequence->currentLoop(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 1);
     QCOMPARE(a3_s_o1->currentLoop(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 1);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 1);
 
     QCOMPARE(group.state(), QAnimationGroup::Paused);
     QCOMPARE(sequence->state(), QAnimationGroup::Paused);
@@ -696,20 +696,20 @@ void tst_QSequentialAnimationGroup::pauseAndResume()
                                               << QAbstractAnimation::Running
                                               << QAbstractAnimation::Stopped)));
 
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(1).first()),
              QAnimationGroup::Paused);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(2).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(2).first()),
              QAnimationGroup::Stopped);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(3).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(3).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(4).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(4).first()),
              QAnimationGroup::Stopped);
 
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(1).first()),
              QAnimationGroup::Paused);
 
     group.resume();
@@ -720,17 +720,17 @@ void tst_QSequentialAnimationGroup::pauseAndResume()
     QCOMPARE(a2_s_o1->state(), QAnimationGroup::Stopped);
     QCOMPARE(a3_s_o1->state(), QAnimationGroup::Running);
 
-    QVERIFY(group.currentTime() >= 1751);
-    QVERIFY(sequence->currentTime() >= 751);
+    QVERIFY(group.currentLoopTime() >= 1751);
+    QVERIFY(sequence->currentLoopTime() >= 751);
     QCOMPARE(sequence->currentLoop(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 1);
     QCOMPARE(a3_s_o1->currentLoop(), 0);
-    QVERIFY(a3_s_o1->currentTime() >= 1);
+    QVERIFY(a3_s_o1->currentLoopTime() >= 1);
 
     QCOMPARE(seqStateChangedSpy.count(), 3);    // Running,Paused,Running
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(2).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(2).first()),
              QAnimationGroup::Running);
 
     group.pause();
@@ -741,23 +741,23 @@ void tst_QSequentialAnimationGroup::pauseAndResume()
     QCOMPARE(a2_s_o1->state(), QAnimationGroup::Stopped);
     QCOMPARE(a3_s_o1->state(), QAnimationGroup::Paused);
 
-    QVERIFY(group.currentTime() >= 1751);
-    QVERIFY(sequence->currentTime() >= 751);
+    QVERIFY(group.currentLoopTime() >= 1751);
+    QVERIFY(sequence->currentLoopTime() >= 751);
     QCOMPARE(sequence->currentLoop(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 1);
     QCOMPARE(a3_s_o1->currentLoop(), 0);
-    QVERIFY(a3_s_o1->currentTime() >= 1);
+    QVERIFY(a3_s_o1->currentLoopTime() >= 1);
 
     QCOMPARE(seqStateChangedSpy.count(), 4);    // Running,Paused,Running,Paused
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(3).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(3).first()),
              QAnimationGroup::Paused);
 
     group.stop();
 
     QCOMPARE(seqStateChangedSpy.count(), 5);    // Running,Paused,Running,Paused,Stopped
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(4).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(4).first()),
              QAnimationGroup::Stopped);
 }
 
@@ -797,20 +797,20 @@ void tst_QSequentialAnimationGroup::restart()
 
     for (int i = 0; i < 3; i++) {
         QCOMPARE(animsStateChanged[i]->count(), 4);
-        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(0).at(1)),
+        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(0).first()),
                  QAnimationGroup::Running);
-        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(1).at(1)),
+        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(1).first()),
                  QAnimationGroup::Stopped);
-        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(2).at(1)),
+        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(2).first()),
                  QAnimationGroup::Running);
-        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(3).at(1)),
+        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(3).first()),
                  QAnimationGroup::Stopped);
     }
 
     QCOMPARE(seqStateChangedSpy.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(1).first()),
              QAnimationGroup::Stopped);
 
     QCOMPARE(seqCurrentAnimChangedSpy.count(), 6);
@@ -855,15 +855,15 @@ void tst_QSequentialAnimationGroup::looping()
 
     // Current time = 1750
     group.setCurrentTime(1750);
-    QCOMPARE(group.currentTime(), 1750);
-    QCOMPARE(sequence->currentTime(), 750);
+    QCOMPARE(group.currentLoopTime(), 1750);
+    QCOMPARE(sequence->currentLoopTime(), 750);
     QCOMPARE(sequence->currentLoop(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 1);
     // this animation is at the beginning because it is the current one inside sequence
     QCOMPARE(a3_s_o1->currentLoop(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
     QCOMPARE(sequence->currentAnimation(), a3_s_o1);
 
     QCOMPARE(group.state(), QAnimationGroup::Paused);
@@ -890,16 +890,16 @@ void tst_QSequentialAnimationGroup::looping()
 
     // Looping, current time = duration + 1
     group.setCurrentTime(group.duration() + 1);
-    QCOMPARE(group.currentTime(), 1);
+    QCOMPARE(group.currentLoopTime(), 1);
     QCOMPARE(group.currentLoop(), 1);
-    QCOMPARE(sequence->currentTime(), 1);
+    QCOMPARE(sequence->currentLoopTime(), 1);
     QCOMPARE(sequence->currentLoop(), 0);
-    QCOMPARE(a1_s_o1->currentTime(), 1);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 1);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 1);
     // this animation is at the end because it was run on the previous loop
     QCOMPARE(a3_s_o1->currentLoop(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
 
     QCOMPARE(group.state(), QAnimationGroup::Paused);
     QCOMPARE(sequence->state(), QAnimationGroup::Paused);
@@ -934,7 +934,7 @@ void tst_QSequentialAnimationGroup::startDelay()
 
     QTest::qWait(500);
 
-    QVERIFY(group.currentTime() == 375);
+    QVERIFY(group.currentLoopTime() == 375);
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
 }
 
@@ -958,9 +958,9 @@ void tst_QSequentialAnimationGroup::clearGroup()
         children[i] = group.animationAt(i);
     }
 
-    group.clearAnimations();
+    group.clear();
     QCOMPARE(group.animationCount(), 0);
-    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
     for (int i = 0; i < animationCount; ++i)
         QVERIFY(children[i].isNull());
 }
@@ -1130,9 +1130,9 @@ void tst_QSequentialAnimationGroup::updateChildrenWithRunningGroup()
     QCOMPARE(groupStateChangedSpy.count(), 1);
     QCOMPARE(childStateChangedSpy.count(), 1);
 
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(childStateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(childStateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
 
     // starting directly a running child will not have any effect
@@ -1171,13 +1171,13 @@ void tst_QSequentialAnimationGroup::deleteChildrenWithRunningGroup()
     QCOMPARE(anim1->state(), QAnimationGroup::Running);
 
     QTest::qWait(100);
-    QVERIFY(group.currentTime() > 0);
+    QVERIFY(group.currentLoopTime() > 0);
 
     delete anim1;
     QCOMPARE(group.animationCount(), 0);
     QCOMPARE(group.duration(), 0);
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
-    QCOMPARE(group.currentTime(), 0); //that's the invariant
+    QCOMPARE(group.currentLoopTime(), 0); //that's the invariant
 }
 
 void tst_QSequentialAnimationGroup::startChildrenWithStoppedGroup()
@@ -1320,9 +1320,9 @@ void tst_QSequentialAnimationGroup::startGroupWithRunningChild()
     QCOMPARE(anim2->state(), QAnimationGroup::Running);
 
     QCOMPARE(stateChangedSpy2.count(), 4);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(2).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(2).first()),
              QAnimationGroup::Stopped);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(3).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(3).first()),
              QAnimationGroup::Running);
 
     group.stop();
@@ -1359,9 +1359,9 @@ void tst_QSequentialAnimationGroup::zeroDurationAnimation()
     group.start();
 
     QCOMPARE(stateChangedSpy.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(1).first()),
              QAnimationGroup::Stopped);
 
     QCOMPARE(anim1->state(), QAnimationGroup::Stopped);
@@ -1426,14 +1426,14 @@ void tst_QSequentialAnimationGroup::finishWithUncontrolledAnimation()
     group.start();
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(notTimeDriven.state(), QAnimationGroup::Running);
-    QCOMPARE(group.currentTime(), 0);
-    QCOMPARE(notTimeDriven.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
+    QCOMPARE(notTimeDriven.currentLoopTime(), 0);
 
     QTest::qWait(300); //wait for the end of notTimeDriven
     QCOMPARE(notTimeDriven.state(), QAnimationGroup::Stopped);
-    const int actualDuration = notTimeDriven.currentTime();
+    const int actualDuration = notTimeDriven.currentLoopTime();
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
-    QCOMPARE(group.currentTime(), actualDuration);
+    QCOMPARE(group.currentLoopTime(), actualDuration);
     QCOMPARE(spy.count(), 1);
 
     //2nd case:
@@ -1444,7 +1444,7 @@ void tst_QSequentialAnimationGroup::finishWithUncontrolledAnimation()
 
     group.setCurrentTime(300);
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
-    QCOMPARE(notTimeDriven.currentTime(), actualDuration);
+    QCOMPARE(notTimeDriven.currentLoopTime(), actualDuration);
     QCOMPARE(group.currentAnimation(), static_cast<QAbstractAnimation*>(&anim));
 
     //3rd case:
@@ -1453,8 +1453,8 @@ void tst_QSequentialAnimationGroup::finishWithUncontrolledAnimation()
     group.start();
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(notTimeDriven.state(), QAnimationGroup::Running);
-    QCOMPARE(group.currentTime(), 0);
-    QCOMPARE(notTimeDriven.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
+    QCOMPARE(notTimeDriven.currentLoopTime(), 0);
 
     QCOMPARE(animStateChangedSpy.count(), 0);
 
@@ -1467,12 +1467,12 @@ void tst_QSequentialAnimationGroup::finishWithUncontrolledAnimation()
     QTest::qWait(300); //wait for the end of anim
 
     QCOMPARE(anim.state(), QAnimationGroup::Stopped);
-    QCOMPARE(anim.currentTime(), anim.duration());
+    QCOMPARE(anim.currentLoopTime(), anim.duration());
 
     //we should simply be at the end
     QCOMPARE(spy.count(), 1);
     QCOMPARE(animStateChangedSpy.count(), 2);
-    QCOMPARE(group.currentTime(), notTimeDriven.currentTime() + anim.currentTime());
+    QCOMPARE(group.currentLoopTime(), notTimeDriven.currentLoopTime() + anim.currentLoopTime());
 }
 
 void tst_QSequentialAnimationGroup::addRemoveAnimation()
@@ -1481,48 +1481,48 @@ void tst_QSequentialAnimationGroup::addRemoveAnimation()
     QSequentialAnimationGroup group;
 
     QCOMPARE(group.duration(), 0);
-    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
     QAbstractAnimation *anim1 = new QPropertyAnimation;
     group.addAnimation(anim1);
     QCOMPARE(group.duration(), 250);
-    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
     QCOMPARE(group.currentAnimation(), anim1);
 
     //let's append an animation
     QAbstractAnimation *anim2 = new QPropertyAnimation;
     group.addAnimation(anim2);
     QCOMPARE(group.duration(), 500);
-    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
     QCOMPARE(group.currentAnimation(), anim1);
 
     //let's prepend an animation
     QAbstractAnimation *anim0 = new QPropertyAnimation;
-    group.insertAnimationAt(0, anim0);
+    group.insertAnimation(0, anim0);
     QCOMPARE(group.duration(), 750);
-    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
     QCOMPARE(group.currentAnimation(), anim0); //anim0 has become the new currentAnimation
 
     group.setCurrentTime(300); //anim0 | anim1 | anim2
-    QCOMPARE(group.currentTime(), 300);
+    QCOMPARE(group.currentLoopTime(), 300);
     QCOMPARE(group.currentAnimation(), anim1);
-    QCOMPARE(anim1->currentTime(), 50);
+    QCOMPARE(anim1->currentLoopTime(), 50);
 
     group.removeAnimation(anim0); //anim1 | anim2
-    QCOMPARE(group.currentTime(), 50);
+    QCOMPARE(group.currentLoopTime(), 50);
     QCOMPARE(group.currentAnimation(), anim1);
-    QCOMPARE(anim1->currentTime(), 50);
+    QCOMPARE(anim1->currentLoopTime(), 50);
 
     group.setCurrentTime(0);
-    group.insertAnimationAt(0, anim0); //anim0 | anim1 | anim2
+    group.insertAnimation(0, anim0); //anim0 | anim1 | anim2
     group.setCurrentTime(300);
-    QCOMPARE(group.currentTime(), 300);
+    QCOMPARE(group.currentLoopTime(), 300);
     QCOMPARE(group.currentAnimation(), anim1);
-    QCOMPARE(anim1->currentTime(), 50);
+    QCOMPARE(anim1->currentLoopTime(), 50);
 
     group.removeAnimation(anim1); //anim0 | anim2
-    QCOMPARE(group.currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 250);
     QCOMPARE(group.currentAnimation(), anim2);
-    QCOMPARE(anim0->currentTime(), 250);
+    QCOMPARE(anim0->currentLoopTime(), 250);
 }
 
 void tst_QSequentialAnimationGroup::currentAnimation()
@@ -1595,15 +1595,15 @@ class SequentialAnimationGroup : public QSequentialAnimationGroup
 {
     Q_OBJECT
 public slots:
-    void clearAnimations()
+    void clear()
     {
-        QSequentialAnimationGroup::clearAnimations();
+        QSequentialAnimationGroup::clear();
     }
 
     void refill()
     {
         stop();
-        clearAnimations();
+        clear();
         new DummyPropertyAnimation(this);
         start();
     }
@@ -1611,11 +1611,11 @@ public slots:
 };
 
 
-void tst_QSequentialAnimationGroup::clearAnimations()
+void tst_QSequentialAnimationGroup::clear()
 {
     SequentialAnimationGroup group;
     QPointer<QAbstractAnimation> anim1 = new DummyPropertyAnimation(&group);
-    group.connect(anim1, SIGNAL(finished()), SLOT(clearAnimations()));
+    group.connect(anim1, SIGNAL(finished()), SLOT(clear()));
     new DummyPropertyAnimation(&group);
     QCOMPARE(group.animationCount(), 2);
 
@@ -1623,7 +1623,7 @@ void tst_QSequentialAnimationGroup::clearAnimations()
     QTest::qWait(anim1->duration() + 100);
     QCOMPARE(group.animationCount(), 0);
     QCOMPARE(group.state(), QAbstractAnimation::Stopped);
-    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
 
     anim1 = new DummyPropertyAnimation(&group);
     group.connect(anim1, SIGNAL(finished()), SLOT(refill()));
@@ -1649,22 +1649,22 @@ void tst_QSequentialAnimationGroup::pauseResume()
     QCOMPARE(anim->state(), QAnimationGroup::Running);
     QCOMPARE(spy.count(), 1);
     spy.clear();
-    const int currentTime = group.currentTime();
-    QCOMPARE(anim->currentTime(), currentTime);
+    const int currentTime = group.currentLoopTime();
+    QCOMPARE(anim->currentLoopTime(), currentTime);
 
     group.pause();
     QCOMPARE(group.state(), QAnimationGroup::Paused);
-    QCOMPARE(group.currentTime(), currentTime);
+    QCOMPARE(group.currentLoopTime(), currentTime);
     QCOMPARE(anim->state(), QAnimationGroup::Paused);
-    QCOMPARE(anim->currentTime(), currentTime);
+    QCOMPARE(anim->currentLoopTime(), currentTime);
     QCOMPARE(spy.count(), 1);
     spy.clear();
 
     group.resume();
     QCOMPARE(group.state(), QAnimationGroup::Running);
-    QCOMPARE(group.currentTime(), currentTime);
+    QCOMPARE(group.currentLoopTime(), currentTime);
     QCOMPARE(anim->state(), QAnimationGroup::Running);
-    QCOMPARE(anim->currentTime(), currentTime);
+    QCOMPARE(anim->currentLoopTime(), currentTime);
     QCOMPARE(spy.count(), 1);
 }
 
diff --git a/tests/auto/qsound/tst_qsound.cpp b/tests/auto/qsound/tst_qsound.cpp
index 56a330b..73eca98 100644
--- a/tests/auto/qsound/tst_qsound.cpp
+++ b/tests/auto/qsound/tst_qsound.cpp
@@ -55,20 +55,32 @@ public:
     tst_QSound( QObject* parent=0) : QObject(parent) {}
 
 private slots:
-        void checkFinished();
+    void checkFinished();
+
+    // Manual tests
+    void staticPlay();
 };
 
 void tst_QSound::checkFinished()
 {
-            QSound sound(SRCDIR"4.wav");
-            sound.setLoops(3);
-            sound.play();
-            QTest::qWait(5000);
+    QSound sound(SRCDIR"4.wav");
+    sound.setLoops(3);
+    sound.play();
+    QTest::qWait(5000);
 
 #if defined(Q_WS_QWS)
-            QEXPECT_FAIL("", "QSound buggy on embedded (task QTBUG-157)", Abort);
+    QEXPECT_FAIL("", "QSound buggy on embedded (task QTBUG-157)", Abort);
 #endif
-            QVERIFY(sound.isFinished() );
+    QVERIFY(sound.isFinished() );
+}
+
+void tst_QSound::staticPlay()
+{
+    QSKIP("Test disabled -- only for manual purposes", SkipAll);
+
+    // Check that you hear sound with static play also.
+    QSound::play(SRCDIR"4.wav");
+    QTest::qWait(2000);
 }
 
 QTEST_MAIN(tst_QSound);
diff --git a/tests/auto/qsqlquery/tst_qsqlquery.cpp b/tests/auto/qsqlquery/tst_qsqlquery.cpp
index 4d9e50f..4264a70 100644
--- a/tests/auto/qsqlquery/tst_qsqlquery.cpp
+++ b/tests/auto/qsqlquery/tst_qsqlquery.cpp
@@ -193,9 +193,13 @@ private slots:
 
     void sqlServerReturn0_data() { generic_data(); }
     void sqlServerReturn0();
+
     void QTBUG_551_data() { generic_data("QOCI"); }
     void QTBUG_551();
 
+    void QTBUG_5251_data() { generic_data("QPSQL"); }
+    void QTBUG_5251();
+
 private:
     // returns all database connections
     void generic_data(const QString &engine=QString());
@@ -2901,5 +2905,35 @@ void tst_QSqlQuery::QTBUG_551()
     QCOMPARE(res_outLst[2].toString(), QLatin1String("3. Value is 2"));
 }
 
+void tst_QSqlQuery::QTBUG_5251()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if (!db.driverName().startsWith( "QPSQL" )) return;
+
+    QSqlQuery q(db);
+    q.exec("DROP TABLE " + qTableName("timetest"));
+    QVERIFY_SQL(q, exec("CREATE TABLE  " + qTableName("timetest") + " (t  TIME)"));
+    QVERIFY_SQL(q, exec("INSERT INTO " + qTableName("timetest") +  " VALUES ('1:2:3.666')"));
+
+    QSqlTableModel timetestModel(0,db);
+    timetestModel.setEditStrategy(QSqlTableModel::OnManualSubmit);
+    timetestModel.setTable(qTableName("timetest"));
+    QVERIFY_SQL(timetestModel, select());
+
+    QCOMPARE(timetestModel.record(0).field(0).value().toTime().toString("HH:mm:ss.zzz"), QString("01:02:03.666"));
+    QVERIFY_SQL(timetestModel,setData(timetestModel.index(0, 0), QTime(0,12,34,500)));
+    QCOMPARE(timetestModel.record(0).field(0).value().toTime().toString("HH:mm:ss.zzz"), QString("00:12:34.500"));
+    QVERIFY_SQL(timetestModel, submitAll());
+    QCOMPARE(timetestModel.record(0).field(0).value().toTime().toString("HH:mm:ss.zzz"), QString("00:12:34.500"));
+
+    QVERIFY_SQL(q, exec("UPDATE " + qTableName("timetest") + " SET t = '0:11:22.33'"));
+    QVERIFY_SQL(timetestModel, select());
+    QCOMPARE(timetestModel.record(0).field(0).value().toTime().toString("HH:mm:ss.zzz"), QString("00:11:22.330"));
+
+}
+
 QTEST_MAIN( tst_QSqlQuery )
 #include "tst_qsqlquery.moc"
diff --git a/tests/auto/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp b/tests/auto/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp
index cb24a9f..8c840cd 100644
--- a/tests/auto/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp
+++ b/tests/auto/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp
@@ -86,6 +86,7 @@ private slots:
     void escapedRelations();
     void escapedTableName();
     void whiteSpaceInIdentifiers();
+    void psqlSchemaTest();
 
 private:
     void dropTestTables( QSqlDatabase db );
@@ -150,10 +151,11 @@ void tst_QSqlRelationalTableModel::initTestCase()
         if (db.driverName().startsWith("QIBASE"))
             db.exec("SET DIALECT 3");
         else if (tst_Databases::isSqlServer(db)) {
-            QSqlQuery q(db);
-            QVERIFY_SQL(q, exec("SET ANSI_DEFAULTS ON"));
-            QVERIFY_SQL(q, exec("SET IMPLICIT_TRANSACTIONS OFF"));
+            db.exec("SET ANSI_DEFAULTS ON");
+            db.exec("SET IMPLICIT_TRANSACTIONS OFF");
         }
+        else if(tst_Databases::isPostgreSQL(db))
+            db.exec("set client_min_messages='warning'");
         recreateTestTables(db);
     }
 }
@@ -181,6 +183,9 @@ void tst_QSqlRelationalTableModel::dropTestTables( QSqlDatabase db )
             << qTableName("CASETEST1" )
             << qTableName("casetest1" );
     tst_Databases::safeDropTables( db, tableNames );
+
+    db.exec("DROP SCHEMA "+qTableName("QTBUG_5373")+" CASCADE");
+    db.exec("DROP SCHEMA "+qTableName("QTBUG_5373_s2")+" CASCADE");
 }
 
 void tst_QSqlRelationalTableModel::init()
@@ -1118,8 +1123,8 @@ void tst_QSqlRelationalTableModel::escapedTableName()
     }
 }
 
-void tst_QSqlRelationalTableModel::whiteSpaceInIdentifiers() {
-
+void tst_QSqlRelationalTableModel::whiteSpaceInIdentifiers()
+{
     QFETCH_GLOBAL(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
@@ -1193,5 +1198,26 @@ void tst_QSqlRelationalTableModel::whiteSpaceInIdentifiers() {
     QCOMPARE(model.data(model.index(0, 2)).toInt(), 6);
 }
 
+void tst_QSqlRelationalTableModel::psqlSchemaTest()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if(!tst_Databases::isPostgreSQL(db)) {
+        QSKIP("Postgresql specific test", SkipSingle);
+        return;
+    }
+    QSqlRelationalTableModel model(0, db);
+    QSqlQuery q(db);
+    QVERIFY_SQL(q, exec("create schema "+qTableName("QTBUG_5373")));
+    QVERIFY_SQL(q, exec("create schema "+qTableName("QTBUG_5373_s2")));
+    QVERIFY_SQL(q, exec("create table "+qTableName("QTBUG_5373")+"."+qTableName("user")+"(userid int primary key, relatingid int)"));
+    QVERIFY_SQL(q, exec("create table "+qTableName("QTBUG_5373_s2")+"."+qTableName("user2")+"(userid2 int primary key, username2 char(40))"));
+    model.setTable(qTableName("QTBUG_5373")+"."+qTableName("user"));
+    model.setRelation(1, QSqlRelation(qTableName("QTBUG_5373_s2")+"."+qTableName("user2"), "userid2", "username2"));
+    QVERIFY_SQL(model, select());
+}
+
 QTEST_MAIN(tst_QSqlRelationalTableModel)
 #include "tst_qsqlrelationaltablemodel.moc"
diff --git a/tests/auto/qstatemachine/tst_qstatemachine.cpp b/tests/auto/qstatemachine/tst_qstatemachine.cpp
index 975b301..fd39515 100644
--- a/tests/auto/qstatemachine/tst_qstatemachine.cpp
+++ b/tests/auto/qstatemachine/tst_qstatemachine.cpp
@@ -162,7 +162,7 @@ private slots:
 
     void defaultGlobalRestorePolicy();
     void globalRestorePolicySetToRestore();
-    void globalRestorePolicySetToDoNotRestore();
+    void globalRestorePolicySetToDontRestore();
 
     void noInitialStateForInitialState();
 
@@ -184,7 +184,7 @@ private slots:
     void twoAnimatedTransitions();
     void playAnimationTwice();
     void nestedTargetStateForAnimation();
-    void polishedSignalTransitionsReuseAnimationGroup();
+    void propertiesAssignedSignalTransitionsReuseAnimationGroup();
     void animatedGlobalRestoreProperty();
     void specificTargetValueOfAnimation();
 
@@ -208,6 +208,7 @@ private slots:
 
     void task260403_clonedSignals();
     void postEventFromOtherThread();
+    void eventFilterForApplication();
 };
 
 tst_QStateMachine::tst_QStateMachine()
@@ -286,8 +287,8 @@ void tst_QStateMachine::transitionToRootState()
     machine.addState(initialState);
     machine.setInitialState(initialState);
 
-    QAbstractTransition *trans = initialState->addTransition(new EventTransition(QEvent::User, &machine));
-    QVERIFY(trans != 0);
+    QAbstractTransition *trans = new EventTransition(QEvent::User, &machine);
+    initialState->addTransition(trans);
     QCOMPARE(trans->sourceState(), initialState);
     QCOMPARE(trans->targetState(), static_cast<QAbstractState *>(&machine));
 
@@ -310,7 +311,7 @@ void tst_QStateMachine::transitionFromRootState()
     QState *root = &machine;
     QState *s1 = new QState(root);
     EventTransition *trans = new EventTransition(QEvent::User, s1);
-    QCOMPARE(root->addTransition(trans), static_cast<QAbstractTransition *>(trans));
+    root->addTransition(trans);
     QCOMPARE(trans->sourceState(), root);
     QCOMPARE(trans->targetState(), static_cast<QAbstractState *>(s1));
 }
@@ -984,7 +985,7 @@ void tst_QStateMachine::customErrorStateNotInGraph()
 void tst_QStateMachine::restoreProperties()
 {
     QStateMachine machine;
-    QCOMPARE(machine.globalRestorePolicy(), QStateMachine::DoNotRestoreProperties);
+    QCOMPARE(machine.globalRestorePolicy(), QStateMachine::DontRestoreProperties);
     machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);
 
     QObject *object = new QObject(&machine);
@@ -1155,7 +1156,7 @@ void tst_QStateMachine::stateEntryAndExit()
         QCOMPARE(t->targetState(), (QAbstractState*)s2);
         QCOMPARE(t->targetStates().size(), 1);
         QCOMPARE(t->targetStates().at(0), (QAbstractState*)s2);
-        QCOMPARE(s1->addTransition(t), (QAbstractTransition*)t);
+        s1->addTransition(t);
         QCOMPARE(t->sourceState(), (QState*)s1);
         QCOMPARE(t->machine(), &machine);
 
@@ -1173,7 +1174,7 @@ void tst_QStateMachine::stateEntryAndExit()
             s2->removeTransition(trans);
             QCOMPARE(trans->sourceState(), (QState*)0);
             QCOMPARE(trans->targetState(), (QAbstractState*)s3);
-            QCOMPARE(s2->addTransition(trans), trans);
+            s2->addTransition(trans);
             QCOMPARE(trans->sourceState(), (QState*)s2);
         }
 
@@ -1319,9 +1320,9 @@ void tst_QStateMachine::assignProperty()
     QCOMPARE(s1->objectName(), QString::fromLatin1("foo"));
 
     {
-        QSignalSpy polishedSpy(s1, SIGNAL(polished()));
+        QSignalSpy propertiesAssignedSpy(s1, SIGNAL(propertiesAssigned()));
         machine.start();
-        QTRY_COMPARE(polishedSpy.count(), 1);
+        QTRY_COMPARE(propertiesAssignedSpy.count(), 1);
     }
 
     // nested states
@@ -1340,11 +1341,11 @@ void tst_QStateMachine::assignPropertyWithAnimation()
     // Single animation
     {
         QStateMachine machine;
-        QVERIFY(machine.animationsEnabled());
-        machine.setAnimationsEnabled(false);
-        QVERIFY(!machine.animationsEnabled());
-        machine.setAnimationsEnabled(true);
-        QVERIFY(machine.animationsEnabled());
+        QVERIFY(machine.isAnimated());
+        machine.setAnimated(false);
+        QVERIFY(!machine.isAnimated());
+        machine.setAnimated(true);
+        QVERIFY(machine.isAnimated());
         QObject obj;
         obj.setProperty("foo", 321);
         obj.setProperty("bar", 654);
@@ -1371,7 +1372,7 @@ void tst_QStateMachine::assignPropertyWithAnimation()
         QCOMPARE(trans->animations().size(), 1);
         QCOMPARE(trans->animations().at(0), (QAbstractAnimation*)&anim);
         QFinalState *s3 = new QFinalState(&machine);
-        s2->addTransition(s2, SIGNAL(polished()), s3);
+        s2->addTransition(s2, SIGNAL(propertiesAssigned()), s3);
 
         machine.setInitialState(s1);
         QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
@@ -1399,7 +1400,7 @@ void tst_QStateMachine::assignPropertyWithAnimation()
         anim2.setDuration(150);
         trans->addAnimation(&anim2);
         QFinalState *s3 = new QFinalState(&machine);
-        s2->addTransition(s2, SIGNAL(polished()), s3);
+        s2->addTransition(s2, SIGNAL(propertiesAssigned()), s3);
 
         machine.setInitialState(s1);
         QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
@@ -1427,7 +1428,7 @@ void tst_QStateMachine::assignPropertyWithAnimation()
         group.addAnimation(new QPropertyAnimation(&obj, "bar"));
         trans->addAnimation(&group);
         QFinalState *s3 = new QFinalState(&machine);
-        s2->addTransition(s2, SIGNAL(polished()), s3);
+        s2->addTransition(s2, SIGNAL(propertiesAssigned()), s3);
 
         machine.setInitialState(s1);
         QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
@@ -1473,10 +1474,10 @@ void tst_QStateMachine::assignPropertyWithAnimation()
         anim2.setDuration(250);
         trans->addAnimation(&anim2);
 
-        s21->addTransition(s21, SIGNAL(polished()), s22);
+        s21->addTransition(s21, SIGNAL(propertiesAssigned()), s22);
 
         QFinalState *s3 = new QFinalState(&machine);
-        s22->addTransition(s2, SIGNAL(polished()), s3);
+        s22->addTransition(s2, SIGNAL(propertiesAssigned()), s3);
 
         machine.setInitialState(s1);
         QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
@@ -1513,13 +1514,13 @@ void tst_QStateMachine::assignPropertyWithAnimation()
         machine.setInitialState(group);
         machine.start();
         QTRY_COMPARE(machine.configuration().contains(s1), true);
-        QSignalSpy polishedSpy(s2, SIGNAL(polished()));
+        QSignalSpy propertiesAssignedSpy(s2, SIGNAL(propertiesAssigned()));
         emitter.emitSignalWithNoArg();
         QTRY_COMPARE(machine.configuration().contains(s2), true);
-        QVERIFY(polishedSpy.isEmpty());
+        QVERIFY(propertiesAssignedSpy.isEmpty());
         emitter.emitSignalWithNoArg(); // will cause animations from s1-->s2 to abort
         QTRY_COMPARE(machine.configuration().contains(s3), true);
-        QVERIFY(polishedSpy.isEmpty());
+        QVERIFY(propertiesAssignedSpy.isEmpty());
         QCOMPARE(obj.property("foo").toInt(), 911);
         QCOMPARE(obj.property("bar").toInt(), 789);
     }
@@ -2736,10 +2737,10 @@ void tst_QStateMachine::restorePolicyNotInherited()
 
 }*/
 
-void tst_QStateMachine::globalRestorePolicySetToDoNotRestore()
+void tst_QStateMachine::globalRestorePolicySetToDontRestore()
 {
     QStateMachine machine;
-    machine.setGlobalRestorePolicy(QStateMachine::DoNotRestoreProperties);
+    machine.setGlobalRestorePolicy(QStateMachine::DontRestoreProperties);
 
     QObject *propertyHolder = new QObject(&machine);
     propertyHolder->setProperty("a", 1);
@@ -3089,7 +3090,7 @@ void tst_QStateMachine::twoAnimations()
 
     QState *s3 = new QState(&machine);
     QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
-    s2->addTransition(s2, SIGNAL(polished()), s3);
+    s2->addTransition(s2, SIGNAL(propertiesAssigned()), s3);
 
     machine.setInitialState(s1);
     machine.start();
@@ -3117,7 +3118,9 @@ void tst_QStateMachine::twoAnimatedTransitions()
     QState *s2 = new QState(&machine);
     s2->assignProperty(object, "foo", 5.0);
     QPropertyAnimation *fooAnimation = new QPropertyAnimation(object, "foo", s2);
-    s1->addTransition(new EventTransition(QEvent::User, s2))->addAnimation(fooAnimation);
+    EventTransition *trans = new EventTransition(QEvent::User, s2);
+    s1->addTransition(trans);
+    trans->addAnimation(fooAnimation);
 
     QState *s3 = new QState(&machine);
     QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
@@ -3126,7 +3129,9 @@ void tst_QStateMachine::twoAnimatedTransitions()
     QState *s4 = new QState(&machine);
     s4->assignProperty(object, "foo", 2.0);
     QPropertyAnimation *fooAnimation2 = new QPropertyAnimation(object, "foo", s4);
-    s3->addTransition(new EventTransition(QEvent::User, s4))->addAnimation(fooAnimation2);
+    trans = new EventTransition(QEvent::User, s4);
+    s3->addTransition(trans);
+    trans->addAnimation(fooAnimation2);
 
     QState *s5 = new QState(&machine);
     QObject::connect(s5, SIGNAL(entered()), QApplication::instance(), SLOT(quit()));
@@ -3161,7 +3166,9 @@ void tst_QStateMachine::playAnimationTwice()
     QState *s2 = new QState(&machine);
     s2->assignProperty(object, "foo", 5.0);
     QPropertyAnimation *fooAnimation = new QPropertyAnimation(object, "foo", s2);
-    s1->addTransition(new EventTransition(QEvent::User, s2))->addAnimation(fooAnimation);
+    EventTransition *trans = new EventTransition(QEvent::User, s2);
+    s1->addTransition(trans);
+    trans->addAnimation(fooAnimation);
 
     QState *s3 = new QState(&machine);
     QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
@@ -3169,7 +3176,9 @@ void tst_QStateMachine::playAnimationTwice()
 
     QState *s4 = new QState(&machine);
     s4->assignProperty(object, "foo", 2.0);
-    s3->addTransition(new EventTransition(QEvent::User, s4))->addAnimation(fooAnimation);
+    trans = new EventTransition(QEvent::User, s4);
+    s3->addTransition(trans);
+    trans->addAnimation(fooAnimation);
 
     QState *s5 = new QState(&machine);
     QObject::connect(s5, SIGNAL(entered()), QApplication::instance(), SLOT(quit()));
@@ -3213,14 +3222,16 @@ void tst_QStateMachine::nestedTargetStateForAnimation()
 
     QState *s2Child2 = new QState(s2);
     s2Child2->assignProperty(object, "bar", 11.0);
-    QAbstractTransition *at = s2Child->addTransition(new EventTransition(QEvent::User, s2Child2));
+    QAbstractTransition *at = new EventTransition(QEvent::User, s2Child2);
+    s2Child->addTransition(at);
 
     QPropertyAnimation *animation = new QPropertyAnimation(object, "bar", s2);
     animation->setDuration(2000);
     connect(animation, SIGNAL(finished()), &counter, SLOT(slot()));
     at->addAnimation(animation);
 
-    at = s1->addTransition(new EventTransition(QEvent::User, s2));
+    at = new EventTransition(QEvent::User, s2);
+    s1->addTransition(at);
 
     animation = new QPropertyAnimation(object, "foo", s2);
     connect(animation, SIGNAL(finished()), &counter, SLOT(slot()));
@@ -3231,7 +3242,7 @@ void tst_QStateMachine::nestedTargetStateForAnimation()
     at->addAnimation(animation);
 
     QState *s3 = new QState(&machine);
-    s2->addTransition(s2Child, SIGNAL(polished()), s3);
+    s2->addTransition(s2Child, SIGNAL(propertiesAssigned()), s3);
 
     QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
 
@@ -3248,7 +3259,7 @@ void tst_QStateMachine::nestedTargetStateForAnimation()
     QCOMPARE(counter.counter, 2);
 }
 
-void tst_QStateMachine::polishedSignalTransitionsReuseAnimationGroup()
+void tst_QStateMachine::propertiesAssignedSignalTransitionsReuseAnimationGroup()
 {
     QStateMachine machine;
     QObject *object = new QObject(&machine);
@@ -3265,9 +3276,9 @@ void tst_QStateMachine::polishedSignalTransitionsReuseAnimationGroup()
     QParallelAnimationGroup animationGroup;
     animationGroup.addAnimation(new QPropertyAnimation(object, "foo"));
     QSignalSpy animationFinishedSpy(&animationGroup, SIGNAL(finished()));
-    s1->addTransition(s1, SIGNAL(polished()), s2)->addAnimation(&animationGroup);
-    s2->addTransition(s2, SIGNAL(polished()), s3)->addAnimation(&animationGroup);
-    s3->addTransition(s3, SIGNAL(polished()), s4);
+    s1->addTransition(s1, SIGNAL(propertiesAssigned()), s2)->addAnimation(&animationGroup);
+    s2->addTransition(s2, SIGNAL(propertiesAssigned()), s3)->addAnimation(&animationGroup);
+    s3->addTransition(s3, SIGNAL(propertiesAssigned()), s4);
 
     machine.setInitialState(s1);
     QSignalSpy machineFinishedSpy(&machine, SIGNAL(finished()));
@@ -3299,7 +3310,8 @@ void tst_QStateMachine::animatedGlobalRestoreProperty()
     QState *s4 = new QState(&machine);
     QObject::connect(s4, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
 
-    QAbstractTransition *at = s1->addTransition(new EventTransition(QEvent::User, s2));
+    QAbstractTransition *at = new EventTransition(QEvent::User, s2);
+    s1->addTransition(at);
     QPropertyAnimation *pa = new QPropertyAnimation(object, "foo", s2);
     connect(pa, SIGNAL(finished()), &counter, SLOT(slot()));
     at->addAnimation(pa);
@@ -3341,7 +3353,9 @@ void tst_QStateMachine::specificTargetValueOfAnimation()
 
     QPropertyAnimation *anim = new QPropertyAnimation(object, "foo");
     anim->setEndValue(10.0);
-    s1->addTransition(new EventTransition(QEvent::User, s2))->addAnimation(anim);
+    EventTransition *trans = new EventTransition(QEvent::User, s2);
+    s1->addTransition(trans);
+    trans->addAnimation(anim);
 
     QState *s3 = new QState(&machine);
     QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
@@ -3495,7 +3509,8 @@ void tst_QStateMachine::overrideDefaultAnimationWithSpecific()
     QState *s3 = new QState(&machine);
     QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
 
-    QAbstractTransition *at = s1->addTransition(new EventTransition(QEvent::User, s2));
+    QAbstractTransition *at = new EventTransition(QEvent::User, s2);
+    s1->addTransition(at);
 
     QPropertyAnimation *defaultAnimation = new QPropertyAnimation(object, "foo");
     connect(defaultAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), &counter, SLOT(slot()));
@@ -4262,5 +4277,35 @@ void tst_QStateMachine::postEventFromOtherThread()
     QTRY_COMPARE(finishedSpy.count(), 1);
 }
 
+void tst_QStateMachine::eventFilterForApplication()
+{
+    QStateMachine machine;
+
+    QState *s1 = new QState(&machine);
+    {
+        machine.setInitialState(s1);
+    }
+
+    QState *s2 = new QState(&machine);
+
+    QEventTransition *transition = new QEventTransition(QCoreApplication::instance(),
+                                                        QEvent::ApplicationActivate);
+    transition->setTargetState(s2);
+    s1->addTransition(transition);
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 1);
+    QVERIFY(machine.configuration().contains(s1));
+
+    QCoreApplication::postEvent(QCoreApplication::instance(),
+                                new QEvent(QEvent::ApplicationActivate));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 1);
+    QVERIFY(machine.configuration().contains(s2));
+}
+
 QTEST_MAIN(tst_QStateMachine)
 #include "tst_qstatemachine.moc"
diff --git a/tests/auto/qstringbuilder1/stringbuilder.cpp b/tests/auto/qstringbuilder1/stringbuilder.cpp
index f35d4d2..9dc467e 100644
--- a/tests/auto/qstringbuilder1/stringbuilder.cpp
+++ b/tests/auto/qstringbuilder1/stringbuilder.cpp
@@ -41,8 +41,15 @@
 
 #define LITERAL "some literal"
 
+// "some literal", but replacing all vocals by their umlauted UTF-8 string :)
+#define UTF8_LITERAL "s\xc3\xb6m\xc3\xab l\xc3\xaft\xc3\xabr\xc3\xa4l"
+
 void runScenario()
 {
+    // set codec for C strings to 0, enforcing Latin1
+    QTextCodec::setCodecForCStrings(0);
+    QVERIFY(!QTextCodec::codecForCStrings());
+
     QLatin1Literal l1literal(LITERAL);
     QLatin1String l1string(LITERAL);
     QString string(l1string);
@@ -75,5 +82,24 @@ void runScenario()
     QCOMPARE(r, r2);
     r = string P ba;
     QCOMPARE(r, r2);
+
+    // now test with codec for C strings set
+    QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
+    QVERIFY(QTextCodec::codecForCStrings());
+    QCOMPARE(QTextCodec::codecForCStrings()->name(), QByteArray("UTF-8"));
+
+    string = QString::fromUtf8(UTF8_LITERAL);
+    r2 = QString::fromUtf8(UTF8_LITERAL UTF8_LITERAL);
+    ba = UTF8_LITERAL;
+
+    r = string P UTF8_LITERAL;
+    QCOMPARE(r.size(), r2.size());
+    QCOMPARE(r, r2);
+    r = UTF8_LITERAL P string;
+    QCOMPARE(r, r2);
+    r = ba P string;
+    QCOMPARE(r, r2);
+    r = string P ba;
+    QCOMPARE(r, r2);
 #endif
 }
diff --git a/tests/auto/qtableview/tst_qtableview.cpp b/tests/auto/qtableview/tst_qtableview.cpp
index 227ca6f..f571e8a 100644
--- a/tests/auto/qtableview/tst_qtableview.cpp
+++ b/tests/auto/qtableview/tst_qtableview.cpp
@@ -197,6 +197,7 @@ private slots:
     void task259308_scrollVerticalHeaderSwappedSections();
     void task191545_dragSelectRows();
     void taskQTBUG_5062_spansInconsistency();
+    void taskQTBUG_4516_clickOnRichTextLabel();
 
     void mouseWheel_data();
     void mouseWheel();
@@ -3885,6 +3886,24 @@ void tst_QTableView::taskQTBUG_5062_spansInconsistency()
     VERIFY_SPANS_CONSISTENCY(&view);
 }
 
+void tst_QTableView::taskQTBUG_4516_clickOnRichTextLabel()
+{
+    QTableView view;
+    QStandardItemModel model(5,5);
+    view.setModel(&model);
+    QLabel label("rich text");
+    label.setTextFormat(Qt::RichText);
+    view.setIndexWidget(model.index(1,1), &label);
+    view.setCurrentIndex(model.index(0,0));
+    QCOMPARE(view.currentIndex(), model.index(0,0));
+
+    QTest::mouseClick(&label, Qt::LeftButton);
+    QCOMPARE(view.currentIndex(), model.index(1,1));
+
+
+}
+
+
 void tst_QTableView::changeHeaderData()
 {
     QTableView view;
diff --git a/tests/auto/qtextdocumentfragment/tst_qtextdocumentfragment.cpp b/tests/auto/qtextdocumentfragment/tst_qtextdocumentfragment.cpp
index 8c4d8fd..4dc732c 100644
--- a/tests/auto/qtextdocumentfragment/tst_qtextdocumentfragment.cpp
+++ b/tests/auto/qtextdocumentfragment/tst_qtextdocumentfragment.cpp
@@ -2197,6 +2197,16 @@ void tst_QTextDocumentFragment::html_quotedFontFamily()
 
     setHtml("<div style='font-family: \"Foo Bar\";'>Test</div>");
     QCOMPARE(doc->begin().begin().fragment().charFormat().fontFamily(), QString("Foo Bar"));
+
+    setHtml("<div style='font-family: \"Foo  Bar\";'>Test</div>");
+    QCOMPARE(doc->begin().begin().fragment().charFormat().fontFamily(), QString("Foo  Bar"));
+
+    setHtml("<div style='font-family: Foo\n  Bar;'>Test</div>");
+    QCOMPARE(doc->begin().begin().fragment().charFormat().fontFamily(), QString("Foo Bar"));
+
+    setHtml("<div style='font-family: Foo\n  Bar, serif, \"bar foo\";'>Test</div>");
+    QCOMPARE(doc->begin().begin().fragment().charFormat().fontFamily(), QString("Foo Bar,serif,bar foo"));
+
 }
 
 void tst_QTextDocumentFragment::defaultFont()
diff --git a/tests/auto/qtextlayout/tst_qtextlayout.cpp b/tests/auto/qtextlayout/tst_qtextlayout.cpp
index fe87dfb..7c3f4f2 100644
--- a/tests/auto/qtextlayout/tst_qtextlayout.cpp
+++ b/tests/auto/qtextlayout/tst_qtextlayout.cpp
@@ -118,6 +118,7 @@ private slots:
     void smallTextLengthWordWrap();
     void smallTextLengthWrapAtWordBoundaryOrAnywhere();
     void testLineBreakingAllSpaces();
+    void lineWidthFromBOM();
 
 
 private:
@@ -1306,6 +1307,18 @@ void tst_QTextLayout::columnWrapWithTabs()
 
 }
 
+void tst_QTextLayout::lineWidthFromBOM()
+{
+    const QString string(QChar(0xfeff)); // BYTE ORDER MARK
+    QTextLayout layout(string);
+    layout.beginLayout();
+    QTextLine line = layout.createLine();
+    line.setLineWidth(INT_MAX / 256);
+    layout.endLayout();
+
+    // Don't spin into an infinite loop
+ }
+
 
 QTEST_MAIN(tst_QTextLayout)
 #include "tst_qtextlayout.moc"
diff --git a/tests/auto/qtextscriptengine/generate/generate.pro b/tests/auto/qtextscriptengine/generate/generate.pro
index 355633d..354e0e5 100644
--- a/tests/auto/qtextscriptengine/generate/generate.pro
+++ b/tests/auto/qtextscriptengine/generate/generate.pro
@@ -5,6 +5,7 @@
 TEMPLATE = app
 CONFIG -= moc
 INCLUDEPATH += . /usr/include/freetype2
+INCLUDEPATH += $$QT_SOURCE_TREE/src/3rdparty/harfbuzz/src
 
 # Input
 SOURCES += main.cpp
diff --git a/tests/auto/qtextscriptengine/generate/main.cpp b/tests/auto/qtextscriptengine/generate/main.cpp
index 853c726..15fbc47 100644
--- a/tests/auto/qtextscriptengine/generate/main.cpp
+++ b/tests/auto/qtextscriptengine/generate/main.cpp
@@ -40,7 +40,7 @@
 ****************************************************************************/
 
 
-#include <QtTest/QtTest>
+#include <QApplication>
 #include <QTextEdit>
 #include <QLineEdit>
 #include <QVBoxLayout>
@@ -85,7 +85,7 @@ void MyEdit::setText(const QString &str)
         result += "0x" + QString::number(str.at(i).unicode(), 16) + ", ";
     result += "0x0 },\n  { ";
     for (int i = 0; i < e->layoutData->items[0].num_glyphs; ++i)
-	result += "0x" + QString::number(e->layoutData->glyphPtr[i].glyph, 16) + ", ";
+        result += "0x" + QString::number(e->layoutData->glyphLayout.glyphs[i], 16) + ", ";
     result += "0x0 } }";
 
     setPlainText(result);
diff --git a/tests/auto/qtextscriptengine/tst_qtextscriptengine.cpp b/tests/auto/qtextscriptengine/tst_qtextscriptengine.cpp
index 226348a..78e0ce6 100644
--- a/tests/auto/qtextscriptengine/tst_qtextscriptengine.cpp
+++ b/tests/auto/qtextscriptengine/tst_qtextscriptengine.cpp
@@ -98,7 +98,7 @@ private slots:
     void telugu();
     void kannada();
     void malayalam();
-    // sinhala missing
+    void sinhala();
 
     void khmer();
     void linearB();
@@ -379,7 +379,11 @@ void tst_QTextScriptEngine::bengali()
                   { 0x151, 0x276, 0x172, 0x143, 0x0 } },
                 { { 0x9b0, 0x9cd, 0x995, 0x9be, 0x983, 0x0 },
                   { 0x151, 0x276, 0x172, 0x144, 0x0 } }, 
-
+                // test decomposed two parts matras
+                { { 0x995, 0x9c7, 0x9be, 0x0 },
+                  { 0x179, 0x151, 0x172, 0x0 } },
+                { { 0x995, 0x9c7, 0x9d7, 0x0 },
+                  { 0x179, 0x151, 0x17e, 0x0 } },
 		{ {0}, {0} }
 	    };
 
@@ -502,16 +506,16 @@ void tst_QTextScriptEngine::bengali()
         if (QFontDatabase().families(QFontDatabase::Bengali).contains("Likhan")) {
             QFont f("Likhan");
 	    const ShapeTable shape_table [] = {
-		{ { 0x09a8, 0x09cd, 0x09af, 0x0 },
-		  { 0x0192, 0x0 } },
+                { { 0x9a8, 0x9cd, 0x9af, 0x0 },
+                  { 0x1ca, 0x0 } },
 		{ { 0x09b8, 0x09cd, 0x09af, 0x0 },
-		  { 0x01d6, 0x0 } },
+                  { 0x020e, 0x0 } },
 		{ { 0x09b6, 0x09cd, 0x09af, 0x0 },
-		  { 0x01bc, 0x0 } },
+                  { 0x01f4, 0x0 } },
 		{ { 0x09b7, 0x09cd, 0x09af, 0x0 },
-		  { 0x01c6, 0x0 } },
+                  { 0x01fe, 0x0 } },
 		{ { 0x09b0, 0x09cd, 0x09a8, 0x09cd, 0x200d, 0x0 },
-		  { 0xd3, 0x12f, 0x0 } },
+                  { 0x10b, 0x167, 0x0 } },
 
 		{ {0}, {0} }
 	    };
@@ -647,6 +651,12 @@ void tst_QTextScriptEngine::tamil()
 		  { 0x0025, 0x0 } },
 		{ { 0x0b83, 0x0b95, 0x0 },
 		  { 0x0025, 0x0031, 0x0 } },
+                { { 0xb95, 0xbc6, 0xbbe, 0x0 },
+                  { 0xa, 0x31, 0x7, 0x0 } },
+                { { 0xb95, 0xbc7, 0xbbe, 0x0 },
+                  { 0xb, 0x31, 0x7, 0x0 } },
+                { { 0xb95, 0xbc6, 0xbd7, 0x0 },
+                  { 0xa, 0x31, 0x40, 0x0 } },
 
 		{ {0}, {0} }
 	    };
@@ -694,7 +704,9 @@ void tst_QTextScriptEngine::telugu()
                   { 0xe6, 0xb3, 0x83, 0x0 } },
                 { { 0xc15, 0xc4d, 0xc30, 0xc48, 0x0 },
                   { 0xe6, 0xb3, 0x9f, 0x0 } }, 
-		{ {0}, {0} }
+                { { 0xc15, 0xc46, 0xc56, 0x0 },
+                  { 0xe6, 0xb3, 0x0 } },
+                { {0}, {0} }
 
             };
 
@@ -762,7 +774,16 @@ void tst_QTextScriptEngine::kannada()
 		  { 0x00b0, 0x006c, 0x0 } },
 		{ { 0x0cb7, 0x0ccd, 0x0 },
 		  { 0x0163, 0x0 } },
-
+                { { 0xc95, 0xcbf, 0xcd5, 0x0 },
+                  { 0x114, 0x73, 0x0 } },
+                { { 0xc95, 0xcc6, 0xcd5, 0x0 },
+                  { 0x90, 0x6c, 0x73, 0x0 } },
+                { { 0xc95, 0xcc6, 0xcd6, 0x0 },
+                  { 0x90, 0x6c, 0x74, 0x0 } },
+                { { 0xc95, 0xcc6, 0xcc2, 0x0 },
+                  { 0x90, 0x6c, 0x69, 0x0 } },
+                { { 0xc95, 0xcca, 0xcd5, 0x0 },
+                  { 0x90, 0x6c, 0x69, 0x73, 0x0 } },
 		{ {0}, {0} }
 	    };
 
@@ -816,8 +837,14 @@ void tst_QTextScriptEngine::malayalam()
 		  { 0x009e, 0x0 } },
 		{ { 0x0d30, 0x0d4d, 0x200d, 0x0 },
 		  { 0x009e, 0x0 } },
-
-
+                { { 0xd15, 0xd46, 0xd3e, 0x0 },
+                  { 0x5e, 0x34, 0x58, 0x0 } },
+                { { 0xd15, 0xd47, 0xd3e, 0x0 },
+                  { 0x5f, 0x34, 0x58, 0x0 } },
+                { { 0xd15, 0xd46, 0xd57, 0x0 },
+                  { 0x5e, 0x34, 0x65, 0x0 } },
+                { { 0xd15, 0xd57, 0x0 },
+                  { 0x34, 0x65, 0x0 } },
 		{ {0}, {0} }
 	    };
 
@@ -836,6 +863,42 @@ void tst_QTextScriptEngine::malayalam()
 #endif
 }
 
+void tst_QTextScriptEngine::sinhala()
+{
+#if defined(Q_WS_X11)
+    {
+        if (QFontDatabase().families(QFontDatabase::Sinhala).contains("Malithi Web")) {
+            QFont f("Malithi Web");
+            const ShapeTable shape_table [] = {
+                { { 0xd9a, 0xdd9, 0xdcf, 0x0 },
+                  { 0x4a, 0x61, 0x42, 0x0 } },
+                { { 0xd9a, 0xdd9, 0xddf, 0x0 },
+                  { 0x4a, 0x61, 0x50, 0x0 } },
+                { { 0xd9a, 0xdd9, 0xdca, 0x0 },
+                  { 0x4a, 0x62, 0x0 } },
+                { { 0xd9a, 0xddc, 0xdca, 0x0 },
+                  { 0x4a, 0x61, 0x42, 0x41, 0x0 } },
+                { { 0xd9a, 0xdda, 0x0 },
+                  { 0x4a, 0x62, 0x0 } },
+                { { 0xd9a, 0xddd, 0x0 },
+                  { 0x4a, 0x61, 0x42, 0x41, 0x0 } },
+                { {0}, {0} }
+            };
+
+
+            const ShapeTable *s = shape_table;
+            while (s->unicode[0]) {
+                QVERIFY( shaping(f, s) );
+                ++s;
+            }
+        } else {
+            QSKIP("couln't find Malithi Web", SkipAll);
+        }
+    }
+#else
+    QSKIP("X11 specific test", SkipAll);
+#endif
+}
 
 
 void tst_QTextScriptEngine::khmer()
diff --git a/tests/auto/qtreeview/tst_qtreeview.cpp b/tests/auto/qtreeview/tst_qtreeview.cpp
index 90e6c5c..58f059b 100644
--- a/tests/auto/qtreeview/tst_qtreeview.cpp
+++ b/tests/auto/qtreeview/tst_qtreeview.cpp
@@ -3669,11 +3669,11 @@ void tst_QTreeView::doubleClickedWithSpans()
 
     //end the previous edition
     QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p);
-    QTest::qWait(100);
+    QTest::qWait(150);
     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);
+    QTRY_COMPARE(spy.count(), 2);
 }
 
 QTEST_MAIN(tst_QTreeView)
diff --git a/tests/auto/qvariant/tst_qvariant.cpp b/tests/auto/qvariant/tst_qvariant.cpp
index e2a606f..3d68a73 100644
--- a/tests/auto/qvariant/tst_qvariant.cpp
+++ b/tests/auto/qvariant/tst_qvariant.cpp
@@ -1432,8 +1432,10 @@ void tst_QVariant::matrix4x4()
     QVariant variant;
     QMatrix4x4 matrix = qVariantValue<QMatrix4x4>(variant);
     QVERIFY(matrix.isIdentity());
-    qVariantSetValue(variant, QMatrix4x4().scale(2.0));
-    QCOMPARE(QMatrix4x4().scale(2.0), qVariantValue<QMatrix4x4>(variant));
+    QMatrix4x4 m;
+    m.scale(2.0f);
+    qVariantSetValue(variant, m);
+    QCOMPARE(m, qVariantValue<QMatrix4x4>(variant));
 
     void *mmatrix = QMetaType::construct(QVariant::Matrix4x4, 0);
     QVERIFY(mmatrix);
diff --git a/tests/auto/qvideoframe/tst_qvideoframe.cpp b/tests/auto/qvideoframe/tst_qvideoframe.cpp
index b231069..432ef5c 100644
--- a/tests/auto/qvideoframe/tst_qvideoframe.cpp
+++ b/tests/auto/qvideoframe/tst_qvideoframe.cpp
@@ -524,7 +524,7 @@ void tst_QVideoFrame::assign()
 void tst_QVideoFrame::map_data()
 {
     QTest::addColumn<QSize>("size");
-    QTest::addColumn<int>("numBytes");
+    QTest::addColumn<int>("mappedBytes");
     QTest::addColumn<int>("bytesPerLine");
     QTest::addColumn<QVideoFrame::PixelFormat>("pixelFormat");
     QTest::addColumn<QAbstractVideoBuffer::MapMode>("mode");
@@ -554,29 +554,29 @@ void tst_QVideoFrame::map_data()
 void tst_QVideoFrame::map()
 {
     QFETCH(QSize, size);
-    QFETCH(int, numBytes);
+    QFETCH(int, mappedBytes);
     QFETCH(int, bytesPerLine);
     QFETCH(QVideoFrame::PixelFormat, pixelFormat);
     QFETCH(QAbstractVideoBuffer::MapMode, mode);
 
-    QVideoFrame frame(numBytes, size, bytesPerLine, pixelFormat);
+    QVideoFrame frame(mappedBytes, size, bytesPerLine, pixelFormat);
 
     QVERIFY(!frame.bits());
-    QCOMPARE(frame.numBytes(), 0);
+    QCOMPARE(frame.mappedBytes(), 0);
     QCOMPARE(frame.bytesPerLine(), 0);
     QCOMPARE(frame.mapMode(), QAbstractVideoBuffer::NotMapped);
 
     QVERIFY(frame.map(mode));
 
     QVERIFY(frame.bits());
-    QCOMPARE(frame.numBytes(), numBytes);
+    QCOMPARE(frame.mappedBytes(), mappedBytes);
     QCOMPARE(frame.bytesPerLine(), bytesPerLine);
     QCOMPARE(frame.mapMode(), mode);
 
     frame.unmap();
 
     QVERIFY(!frame.bits());
-    QCOMPARE(frame.numBytes(), 0);
+    QCOMPARE(frame.mappedBytes(), 0);
     QCOMPARE(frame.bytesPerLine(), 0);
     QCOMPARE(frame.mapMode(), QAbstractVideoBuffer::NotMapped);
 }
@@ -614,21 +614,21 @@ void tst_QVideoFrame::mapImage()
     QVideoFrame frame(image);
 
     QVERIFY(!frame.bits());
-    QCOMPARE(frame.numBytes(), 0);
+    QCOMPARE(frame.mappedBytes(), 0);
     QCOMPARE(frame.bytesPerLine(), 0);
     QCOMPARE(frame.mapMode(), QAbstractVideoBuffer::NotMapped);
 
     QVERIFY(frame.map(mode));
 
     QVERIFY(frame.bits());
-    QCOMPARE(frame.numBytes(), image.numBytes());
+    QCOMPARE(frame.mappedBytes(), image.numBytes());
     QCOMPARE(frame.bytesPerLine(), image.bytesPerLine());
     QCOMPARE(frame.mapMode(), mode);
 
     frame.unmap();
 
     QVERIFY(!frame.bits());
-    QCOMPARE(frame.numBytes(), 0);
+    QCOMPARE(frame.mappedBytes(), 0);
     QCOMPARE(frame.bytesPerLine(), 0);
     QCOMPARE(frame.mapMode(), QAbstractVideoBuffer::NotMapped);
 }
diff --git a/tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp b/tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp
index 9623e80..a47cb48 100644
--- a/tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp
+++ b/tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp
@@ -68,8 +68,8 @@ private slots:
     void scanLineDirection();
     void frameRate_data();
     void frameRate();
-    void yuvColorSpace_data();
-    void yuvColorSpace();
+    void yCbCrColorSpace_data();
+    void yCbCrColorSpace();
     void pixelAspectRatio_data();
     void pixelAspectRatio();
     void sizeHint_data();
@@ -81,9 +81,6 @@ private slots:
     void assign();
 };
 
-Q_DECLARE_METATYPE(QVideoSurfaceFormat::ViewportMode)
-
-
 tst_QVideoSurfaceFormat::tst_QVideoSurfaceFormat()
 {
 }
@@ -122,7 +119,7 @@ void tst_QVideoSurfaceFormat::constructNull()
     QCOMPARE(format.scanLineDirection(), QVideoSurfaceFormat::TopToBottom);
     QCOMPARE(format.frameRate(), 0.0);
     QCOMPARE(format.pixelAspectRatio(), QSize(1, 1));
-    QCOMPARE(format.yuvColorSpace(), QVideoSurfaceFormat::YCbCr_Undefined);
+    QCOMPARE(format.yCbCrColorSpace(), QVideoSurfaceFormat::YCbCr_Undefined);
 }
 
 void tst_QVideoSurfaceFormat::construct_data()
@@ -161,7 +158,7 @@ void tst_QVideoSurfaceFormat::construct()
     QCOMPARE(format.scanLineDirection(), QVideoSurfaceFormat::TopToBottom);
     QCOMPARE(format.frameRate(), 0.0);
     QCOMPARE(format.pixelAspectRatio(), QSize(1, 1));
-    QCOMPARE(format.yuvColorSpace(), QVideoSurfaceFormat::YCbCr_Undefined);
+    QCOMPARE(format.yCbCrColorSpace(), QVideoSurfaceFormat::YCbCr_Undefined);
 }
 
 void tst_QVideoSurfaceFormat::frameSize_data()
@@ -202,45 +199,23 @@ void tst_QVideoSurfaceFormat::viewport_data()
     QTest::addColumn<QSize>("initialSize");
     QTest::addColumn<QRect>("viewport");
     QTest::addColumn<QSize>("newSize");
-    QTest::addColumn<QVideoSurfaceFormat::ViewportMode>("viewportMode");
     QTest::addColumn<QRect>("expectedViewport");
 
     QTest::newRow("grow reset")
             << QSize(64, 64)
             << QRect(8, 8, 48, 48)
             << QSize(1024, 1024)
-            << QVideoSurfaceFormat::ResetViewport
             << QRect(0, 0, 1024, 1024);
-    QTest::newRow("grow keep")
-            << QSize(64, 64)
-            << QRect(8, 8, 48, 48)
-            << QSize(1024, 1024)
-            << QVideoSurfaceFormat::KeepViewport
-            << QRect(8, 8, 48, 48);
     QTest::newRow("shrink reset")
             << QSize(1024, 1024)
             << QRect(8, 8, 1008, 1008)
             << QSize(64, 64)
-            << QVideoSurfaceFormat::ResetViewport
             << QRect(0, 0, 64, 64);
-    QTest::newRow("shrink keep")
-            << QSize(1024, 1024)
-            << QRect(8, 8, 1008, 1008)
-            << QSize(64, 64)
-            << QVideoSurfaceFormat::KeepViewport
-            << QRect(8, 8, 56, 56);
     QTest::newRow("unchanged reset")
             << QSize(512, 512)
             << QRect(8, 8, 496, 496)
             << QSize(512, 512)
-            << QVideoSurfaceFormat::ResetViewport
             << QRect(0, 0, 512, 512);
-    QTest::newRow("unchanged keep")
-            << QSize(512, 512)
-            << QRect(8, 8, 496, 496)
-            << QSize(512, 512)
-            << QVideoSurfaceFormat::KeepViewport
-            << QRect(8, 8, 496, 496);
 }
 
 void tst_QVideoSurfaceFormat::viewport()
@@ -248,7 +223,6 @@ void tst_QVideoSurfaceFormat::viewport()
     QFETCH(QSize, initialSize);
     QFETCH(QRect, viewport);
     QFETCH(QSize, newSize);
-    QFETCH(QVideoSurfaceFormat::ViewportMode, viewportMode);
     QFETCH(QRect, expectedViewport);
 
     {
@@ -261,7 +235,7 @@ void tst_QVideoSurfaceFormat::viewport()
         QCOMPARE(format.viewport(), viewport);
         QCOMPARE(format.property("viewport").toRect(), viewport);
 
-        format.setFrameSize(newSize, viewportMode);
+        format.setFrameSize(newSize);
 
         QCOMPARE(format.viewport(), expectedViewport);
         QCOMPARE(format.property("viewport").toRect(), expectedViewport);
@@ -350,9 +324,9 @@ void tst_QVideoSurfaceFormat::frameRate()
     }
 }
 
-void tst_QVideoSurfaceFormat::yuvColorSpace_data()
+void tst_QVideoSurfaceFormat::yCbCrColorSpace_data()
 {
-    QTest::addColumn<QVideoSurfaceFormat::YuvColorSpace>("colorspace");
+    QTest::addColumn<QVideoSurfaceFormat::YCbCrColorSpace>("colorspace");
 
     QTest::newRow("undefined")
             << QVideoSurfaceFormat::YCbCr_Undefined;
@@ -364,24 +338,24 @@ void tst_QVideoSurfaceFormat::yuvColorSpace_data()
             << QVideoSurfaceFormat::YCbCr_JPEG;
 }
 
-void tst_QVideoSurfaceFormat::yuvColorSpace()
+void tst_QVideoSurfaceFormat::yCbCrColorSpace()
 {
-    QFETCH(QVideoSurfaceFormat::YuvColorSpace, colorspace);
+    QFETCH(QVideoSurfaceFormat::YCbCrColorSpace, colorspace);
 
     {
         QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
-        format.setYuvColorSpace(colorspace);
+        format.setYCbCrColorSpace(colorspace);
 
-        QCOMPARE(format.yuvColorSpace(), colorspace);
-        QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YuvColorSpace>(format.property("yuvColorSpace")),
+        QCOMPARE(format.yCbCrColorSpace(), colorspace);
+        QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YCbCrColorSpace>(format.property("yCbCrColorSpace")),
                 colorspace);
     }
     {
         QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
-        format.setProperty("yuvColorSpace", qVariantFromValue(colorspace));
+        format.setProperty("yCbCrColorSpace", qVariantFromValue(colorspace));
 
-        QCOMPARE(format.yuvColorSpace(), colorspace);
-        QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YuvColorSpace>(format.property("yuvColorSpace")),
+        QCOMPARE(format.yCbCrColorSpace(), colorspace);
+        QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YCbCrColorSpace>(format.property("yCbCrColorSpace")),
                 colorspace);
     }
 }
@@ -483,7 +457,7 @@ void tst_QVideoSurfaceFormat::staticPropertyNames()
     QVERIFY(propertyNames.contains("scanLineDirection"));
     QVERIFY(propertyNames.contains("frameRate"));
     QVERIFY(propertyNames.contains("pixelAspectRatio"));
-    QVERIFY(propertyNames.contains("yuvColorSpace"));
+    QVERIFY(propertyNames.contains("yCbCrColorSpace"));
     QVERIFY(propertyNames.contains("sizeHint"));
     QCOMPARE(propertyNames.count(), 10);
 }
@@ -566,19 +540,26 @@ void tst_QVideoSurfaceFormat::compare()
     QCOMPARE(format1 == format4, false);
     QCOMPARE(format1 != format4, true);
 
-    format2.setFrameSize(1024, 768, QVideoSurfaceFormat::ResetViewport);
+    format2.setFrameSize(1024, 768);
 
     // Not equal, frame size differs.
     QCOMPARE(format1 == format2, false);
     QCOMPARE(format1 != format2, true);
 
-    format1.setFrameSize(1024, 768, QVideoSurfaceFormat::KeepViewport);
+    format1.setFrameSize(1024, 768);
+
+    // Equal.
+    QCOMPARE(format1 == format2, true);
+    QCOMPARE(format1 != format2, false);
+
+    format1.setViewport(QRect(0, 0, 800, 600));
+    format2.setViewport(QRect(112, 84, 800, 600));
 
-    // Not equal, viewport differs.
+    // Not equal, viewports differ.
     QCOMPARE(format1 == format2, false);
     QCOMPARE(format1 != format2, true);
 
-    format1.setViewport(QRect(0, 0, 1024, 768));
+    format1.setViewport(QRect(112, 84, 800, 600));
 
     // Equal.
     QCOMPARE(format1 == format2, true);
@@ -620,13 +601,13 @@ void tst_QVideoSurfaceFormat::compare()
     QCOMPARE(format1 == format2, true);
     QCOMPARE(format1 != format2, false);
 
-    format2.setYuvColorSpace(QVideoSurfaceFormat::YCbCr_xvYCC601);
+    format2.setYCbCrColorSpace(QVideoSurfaceFormat::YCbCr_xvYCC601);
 
     // Not equal yuv color space differs.
     QCOMPARE(format1 == format2, false);
     QCOMPARE(format1 != format2, true);
 
-    format1.setYuvColorSpace(QVideoSurfaceFormat::YCbCr_xvYCC601);
+    format1.setYCbCrColorSpace(QVideoSurfaceFormat::YCbCr_xvYCC601);
 
     // Equal.
     QCOMPARE(format1 == format2, true);
diff --git a/tests/auto/qwidget/tst_qwidget.cpp b/tests/auto/qwidget/tst_qwidget.cpp
index 3d801cc..e027dd1 100644
--- a/tests/auto/qwidget/tst_qwidget.cpp
+++ b/tests/auto/qwidget/tst_qwidget.cpp
@@ -3328,9 +3328,10 @@ void tst_QWidget::widgetAt()
     w2->lower();
     qApp->processEvents();
     QTRY_VERIFY((wr = QApplication::widgetAt(100, 100)));
-    QCOMPARE(wr->objectName(), QString("w1"));
-
+    const bool match = (wr->objectName() == QString("w1"));
     w2->raise();
+    QVERIFY(match);
+
     qApp->processEvents();
     QTRY_VERIFY((wr = QApplication::widgetAt(100, 100)));
     QCOMPARE(wr->objectName(), QString("w2"));
diff --git a/tests/auto/qwidgetaction/tst_qwidgetaction.cpp b/tests/auto/qwidgetaction/tst_qwidgetaction.cpp
index 50b3337..d25738f 100644
--- a/tests/auto/qwidgetaction/tst_qwidgetaction.cpp
+++ b/tests/auto/qwidgetaction/tst_qwidgetaction.cpp
@@ -395,7 +395,9 @@ void tst_QWidgetAction::releaseWidgetCrash()
     QMainWindow *w = new QMainWindow;
     QAction *a = new CrashedAction(w);
     QMenu *menu = w->menuBar()->addMenu("Test");
+    menu->addAction("foo");
     menu->addAction(a);
+    menu->addAction("bar");
     delete w;
 }
 
diff --git a/tests/auto/qxmlnodemodelindex/tst_qxmlnodemodelindex.cpp b/tests/auto/qxmlnodemodelindex/tst_qxmlnodemodelindex.cpp
index cb6bd4d..c19deb6 100644
--- a/tests/auto/qxmlnodemodelindex/tst_qxmlnodemodelindex.cpp
+++ b/tests/auto/qxmlnodemodelindex/tst_qxmlnodemodelindex.cpp
@@ -178,7 +178,7 @@ void tst_QXmlNodeModelIndex::model() const
     /* Check default value. */
     {
         const QXmlNodeModelIndex index;
-        QCOMPARE(index.model(), static_cast<void *>(0));
+        QCOMPARE(index.model(), static_cast<const QAbstractXmlNodeModel *>(0));
     }
 }
 
diff --git a/tests/auto/qxmlquery/tst_qxmlquery.cpp b/tests/auto/qxmlquery/tst_qxmlquery.cpp
index 8a9d4ef..49f2b08 100644
--- a/tests/auto/qxmlquery/tst_qxmlquery.cpp
+++ b/tests/auto/qxmlquery/tst_qxmlquery.cpp
@@ -345,8 +345,8 @@ void tst_QXmlQuery::copyConstructor() const
         query1.setInitialTemplateName(name);
 
         const QXmlQuery query2(query1);
-        QCOMPARE(query2.messageHandler(), &silencer);
-        QCOMPARE(query2.uriResolver(), &resolver);
+        QCOMPARE(query2.messageHandler(), static_cast<QAbstractMessageHandler *>(&silencer));
+        QCOMPARE(query2.uriResolver(), static_cast<const QAbstractUriResolver *>(&resolver));
         QCOMPARE(query2.queryLanguage(), QXmlQuery::XSLT20);
         QCOMPARE(query2.initialTemplateName(), name);
         QCOMPARE(query2.networkAccessManager(), &networkManager);
@@ -522,7 +522,7 @@ void tst_QXmlQuery::assignmentOperator() const
 
             QVERIFY(copy.isValid());
             QCOMPARE(copy.uriResolver(), static_cast<const QAbstractUriResolver *>(&returnURI));
-            QCOMPARE(copy.messageHandler(), &silencer);
+            QCOMPARE(copy.messageHandler(), static_cast<QAbstractMessageHandler *>(&silencer));
             QCOMPARE(testName.localName(copy.namePool()), QString::fromLatin1("somethingToCheck"));
 
             QXmlResultItems result;
@@ -559,7 +559,7 @@ void tst_QXmlQuery::assignmentOperator() const
                 /* Check that the copy picked up the new things. */
                 QVERIFY(copy.isValid());
                 QCOMPARE(copy.uriResolver(), static_cast<const QAbstractUriResolver *>(&secondUriResolver));
-                QCOMPARE(copy.messageHandler(), &secondSilencer);
+                QCOMPARE(copy.messageHandler(), static_cast<QAbstractMessageHandler *>(&secondSilencer));
 
                 QXmlResultItems resultCopy;
                 copy.evaluateTo(&resultCopy);
@@ -577,7 +577,7 @@ void tst_QXmlQuery::assignmentOperator() const
                 /* Check that the original is unchanged. */
                 QVERIFY(original.isValid());
                 QCOMPARE(original.uriResolver(), static_cast<const QAbstractUriResolver *>(&returnURI));
-                QCOMPARE(original.messageHandler(), &silencer);
+                QCOMPARE(original.messageHandler(), static_cast<QAbstractMessageHandler *>(&silencer));
 
                 QXmlResultItems resultOriginal;
                 original.evaluateTo(&resultOriginal);
@@ -931,7 +931,7 @@ void tst_QXmlQuery::setMessageHandler() const
     QXmlQuery query;
     MessageSilencer silencer;
     query.setMessageHandler(&silencer);
-    QCOMPARE(&silencer, query.messageHandler());
+    QCOMPARE(static_cast<QAbstractMessageHandler *>(&silencer), query.messageHandler());
 }
 
 void tst_QXmlQuery::evaluateToReceiver()
@@ -1691,7 +1691,7 @@ void tst_QXmlQuery::setUriResolver() const
         TestURIResolver resolver;
         QXmlQuery query;
         query.setUriResolver(&resolver);
-        QCOMPARE(query.uriResolver(), &resolver);
+        QCOMPARE(query.uriResolver(), static_cast<const QAbstractUriResolver *>(&resolver));
     }
 }
 
diff --git a/tests/auto/qxmlschema/tst_qxmlschema.cpp b/tests/auto/qxmlschema/tst_qxmlschema.cpp
index 79f5587..ec91f88 100644
--- a/tests/auto/qxmlschema/tst_qxmlschema.cpp
+++ b/tests/auto/qxmlschema/tst_qxmlschema.cpp
@@ -357,7 +357,7 @@ void tst_QXmlSchema::messageHandler() const
 
         QXmlSchema schema;
         schema.setMessageHandler(&handler);
-        QCOMPARE(schema.messageHandler(), &handler);
+        QCOMPARE(schema.messageHandler(), static_cast<QAbstractMessageHandler *>(&handler));
     }
 }
 
@@ -394,7 +394,7 @@ void tst_QXmlSchema::uriResolver() const
 
         QXmlSchema schema;
         schema.setUriResolver(&resolver);
-        QCOMPARE(schema.uriResolver(), &resolver);
+        QCOMPARE(schema.uriResolver(), static_cast<const QAbstractUriResolver *>(&resolver));
     }
 }
 
diff --git a/tests/auto/qxmlschemavalidator/tst_qxmlschemavalidator.cpp b/tests/auto/qxmlschemavalidator/tst_qxmlschemavalidator.cpp
index 519f864..9fc784b 100644
--- a/tests/auto/qxmlschemavalidator/tst_qxmlschemavalidator.cpp
+++ b/tests/auto/qxmlschemavalidator/tst_qxmlschemavalidator.cpp
@@ -149,8 +149,8 @@ void tst_QXmlSchemaValidator::propertyInitialization() const
         schema.setNetworkAccessManager(&manager);
 
         QXmlSchemaValidator validator(schema);
-        QCOMPARE(validator.messageHandler(), &handler);
-        QCOMPARE(validator.uriResolver(), &resolver);
+        QCOMPARE(validator.messageHandler(), static_cast<QAbstractMessageHandler *>(&handler));
+        QCOMPARE(validator.uriResolver(), static_cast<const QAbstractUriResolver *>(&resolver));
         QCOMPARE(validator.networkAccessManager(), &manager);
     }
 }
@@ -384,7 +384,7 @@ void tst_QXmlSchemaValidator::messageHandler() const
         QXmlSchemaValidator validator(schema);
 
         validator.setMessageHandler(&handler);
-        QCOMPARE(validator.messageHandler(), &handler);
+        QCOMPARE(validator.messageHandler(), static_cast<QAbstractMessageHandler *>(&handler));
     }
 
     /* Test that we return the message handler that was set, even if the schema changed in between. */
@@ -399,7 +399,7 @@ void tst_QXmlSchemaValidator::messageHandler() const
         const QXmlSchema schema2;
         validator.setSchema(schema2);
 
-        QCOMPARE(validator.messageHandler(), &handler);
+        QCOMPARE(validator.messageHandler(), static_cast<QAbstractMessageHandler *>(&handler));
     }
 }
 
@@ -452,7 +452,7 @@ void tst_QXmlSchemaValidator::uriResolver() const
         QXmlSchemaValidator validator(schema);
 
         validator.setUriResolver(&resolver);
-        QCOMPARE(validator.uriResolver(), &resolver);
+        QCOMPARE(validator.uriResolver(), static_cast<const QAbstractUriResolver *>(&resolver));
     }
 
     /* Test that we return the uri resolver that was set, even if the schema changed in between. */
@@ -467,7 +467,7 @@ void tst_QXmlSchemaValidator::uriResolver() const
         const QXmlSchema schema2;
         validator.setSchema(schema2);
 
-        QCOMPARE(validator.uriResolver(), &resolver);
+        QCOMPARE(validator.uriResolver(), static_cast<const QAbstractUriResolver *>(&resolver));
     }
 }
 
diff --git a/tests/auto/qxmlserializer/tst_qxmlserializer.cpp b/tests/auto/qxmlserializer/tst_qxmlserializer.cpp
index aeca140..51044ff 100644
--- a/tests/auto/qxmlserializer/tst_qxmlserializer.cpp
+++ b/tests/auto/qxmlserializer/tst_qxmlserializer.cpp
@@ -148,7 +148,7 @@ void tst_QXmlSerializer::outputDevice() const
     {
         const QXmlQuery query;
         const QXmlSerializer serializer(query, &file);
-        QCOMPARE(serializer.outputDevice(), &file);
+        QCOMPARE(serializer.outputDevice(), static_cast< QIODevice *>(&file));
     }
 }
 
@@ -158,7 +158,7 @@ void tst_QXmlSerializer::serializationError() const
     QXmlQuery query;
     MessageSilencer silencer;
     query.setMessageHandler(&silencer);
-    
+
     query.setQuery(queryString);
 
     QByteArray output;
diff --git a/tests/auto/uiloader/baseline/css_itemview_task258382.ui b/tests/auto/uiloader/baseline/css_itemview_task258382.ui
new file mode 100644
index 0000000..11c56b4
--- /dev/null
+++ b/tests/auto/uiloader/baseline/css_itemview_task258382.ui
@@ -0,0 +1,179 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>437</width>
+    <height>352</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <property name="styleSheet">
+   <string notr="true">::item { border: 1px solid black;  background-color: purple; }
+::item {margin-left: 20px; }
+
+QAbstractItemView { selection-background-color: red;
+show-decoration- selected: 0;
+ }
+
+::item:selected {  background-color: yellow; }</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="0" column="0">
+    <widget class="QTreeWidget" name="treeWidget">
+     <column>
+      <property name="text">
+       <string>1</string>
+      </property>
+     </column>
+     <column>
+      <property name="text">
+       <string>New Column</string>
+      </property>
+     </column>
+     <item>
+      <property name="text">
+       <string>New Item</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>New Item</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>New Item</string>
+      </property>
+      <item>
+       <property name="text">
+        <string>New Subitem</string>
+       </property>
+       <item>
+        <property name="text">
+         <string>New Subitem</string>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>New Item</string>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>New Item</string>
+        </property>
+       </item>
+      </item>
+     </item>
+    </widget>
+   </item>
+   <item row="1" column="0">
+    <widget class="QTableWidget" name="tableWidget">
+     <row>
+      <property name="text">
+       <string>New Row</string>
+      </property>
+     </row>
+     <row>
+      <property name="text">
+       <string>New Row</string>
+      </property>
+     </row>
+     <row>
+      <property name="text">
+       <string>New Row</string>
+      </property>
+     </row>
+     <row>
+      <property name="text">
+       <string>New Row</string>
+      </property>
+     </row>
+     <row>
+      <property name="text">
+       <string>New Row</string>
+      </property>
+     </row>
+     <column>
+      <property name="text">
+       <string>New Column</string>
+      </property>
+     </column>
+     <column>
+      <property name="text">
+       <string>New Column</string>
+      </property>
+     </column>
+     <column>
+      <property name="text">
+       <string>New Column</string>
+      </property>
+     </column>
+     <column>
+      <property name="text">
+       <string>New Column</string>
+      </property>
+     </column>
+     <item row="0" column="0">
+      <property name="text">
+       <string>mljkh mh mjl</string>
+      </property>
+     </item>
+     <item row="0" column="1">
+      <property name="text">
+       <string>h jlh mjklh </string>
+      </property>
+     </item>
+     <item row="0" column="2">
+      <property name="text">
+       <string>mjklh mlhj mjlh m</string>
+      </property>
+     </item>
+     <item row="1" column="3">
+      <property name="text">
+       <string>mlhj lmhj </string>
+      </property>
+     </item>
+     <item row="2" column="0">
+      <property name="text">
+       <string>mlkj l</string>
+      </property>
+     </item>
+     <item row="2" column="1">
+      <property name="text">
+       <string>mlkj </string>
+      </property>
+     </item>
+     <item row="2" column="2">
+      <property name="text">
+       <string>mlkj lmkj </string>
+      </property>
+     </item>
+     <item row="2" column="3">
+      <property name="text">
+       <string>mlkhj mlh</string>
+      </property>
+     </item>
+     <item row="3" column="1">
+      <property name="text">
+       <string>mlkj lmkj </string>
+      </property>
+     </item>
+     <item row="4" column="0">
+      <property name="text">
+       <string>mlkj lmkj </string>
+      </property>
+     </item>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/tests/auto/xmlpatterns.pri b/tests/auto/xmlpatterns.pri
index 7cdd67f..8c8ccad 100644
--- a/tests/auto/xmlpatterns.pri
+++ b/tests/auto/xmlpatterns.pri
@@ -15,8 +15,9 @@ QT -= gui
 
 XMLPATTERNS_SDK = QtXmlPatternsSDK
 if(!debug_and_release|build_pass):CONFIG(debug, debug|release) {
-    win32:XMLPATTERNS_SDK = $${XMLPATTERNS_SDK}d
-    else: XMLPATTERNS_SDK = $${XMLPATTERNS_SDK}_debug
+    symbian:    XMLPATTERNS_SDK = $${XMLPATTERNS_SDK}
+    else:win32: XMLPATTERNS_SDK = $${XMLPATTERNS_SDK}d
+    else:       XMLPATTERNS_SDK = $${XMLPATTERNS_SDK}_debug
 }
 
 INCLUDEPATH += \
diff --git a/tests/auto/xmlpatterns/tst_xmlpatterns.cpp b/tests/auto/xmlpatterns/tst_xmlpatterns.cpp
index 0dcb070..22f6693 100644
--- a/tests/auto/xmlpatterns/tst_xmlpatterns.cpp
+++ b/tests/auto/xmlpatterns/tst_xmlpatterns.cpp
@@ -48,6 +48,10 @@
 #include "../qxmlquery/TestFundament.h"
 #include "../network-settings.h"
 
+#if defined(Q_OS_SYMBIAN)
+#define SRCDIR ""
+#endif
+
 /*!
  \class tst_XmlPatterns
  \internal
@@ -130,6 +134,8 @@ void tst_XmlPatterns::xquerySupport()
 
 #ifdef Q_OS_WINCE
     QSKIP("WinCE: This test uses unsupported WinCE functionality", SkipAll);
+#elif defined(Q_OS_SYMBIAN)
+    QSKIP("Symbian: This test uses unsupported Symbian functionality (QProcess with std streams)", SkipAll);
 #endif
 
     QFETCH(int,         expectedExitCode);
@@ -218,7 +224,7 @@ void tst_XmlPatterns::xquerySupport()
 
 void tst_XmlPatterns::xquerySupport_data() const
 {
-#ifdef Q_OS_WINCE
+#if defined(Q_OS_WINCE) || defined(Q_OS_SYMBIAN)
     return;
 #endif
 
@@ -849,6 +855,8 @@ void tst_XmlPatterns::xsltSupport_data() const
 
 #ifdef Q_OS_WINCE
     QSKIP("WinCE: This test uses unsupported WinCE functionality", SkipAll);
+#elif defined(Q_OS_SYMBIAN)
+    QSKIP("Symbian: This test uses unsupported Symbian functionality (QProcess with std streams)", SkipAll);
 #endif
 
     QTest::addColumn<int>("expectedExitCode");
diff --git a/tests/auto/xmlpatterns/xmlpatterns.pro b/tests/auto/xmlpatterns/xmlpatterns.pro
index 01e3b2b..54dd9aa 100644
--- a/tests/auto/xmlpatterns/xmlpatterns.pro
+++ b/tests/auto/xmlpatterns/xmlpatterns.pro
@@ -2,10 +2,10 @@ load(qttest_p4)
 SOURCES += tst_xmlpatterns.cpp \
            ../qxmlquery/TestFundament.cpp
 
-!wince* {
-DEFINES += SRCDIR=\\\"$$PWD/\\\"
-} else {
+wince* {
 DEFINES += SRCDIR=\\\"./\\\"
+} else:!symbian {
+DEFINES += SRCDIR=\\\"$$PWD/\\\"
 }
 
 include (../xmlpatterns.pri)
diff --git a/tests/auto/xmlpatternsdiagnosticsts/test/test.pro b/tests/auto/xmlpatternsdiagnosticsts/test/test.pro
index aeff896..acd71e4 100644
--- a/tests/auto/xmlpatternsdiagnosticsts/test/test.pro
+++ b/tests/auto/xmlpatternsdiagnosticsts/test/test.pro
@@ -25,8 +25,8 @@ INCLUDEPATH += $$(QTSRCDIR)/tests/auto/xmlpatternsxqts/lib/ \
                ../../xmlpatternsxqts/test                   \
                ../../xmlpatternsxqts/lib
 
-wince*: {
-   catalog.sources = TestSuite Baseline.xml
+wince*|symbian {
+   catalog.sources = ../TestSuite ../Baseline.xml
    catalog.path = .
    DEPLOYMENT += catalog
 }
diff --git a/tests/auto/xmlpatternsschemats/xmlpatternsschemats.pro b/tests/auto/xmlpatternsschemats/xmlpatternsschemats.pro
index bcc988a..0f55078 100644
--- a/tests/auto/xmlpatternsschemats/xmlpatternsschemats.pro
+++ b/tests/auto/xmlpatternsschemats/xmlpatternsschemats.pro
@@ -11,8 +11,9 @@ SOURCES += ../xmlpatternsxqts/test/tst_suitetest.cpp
 
 PATTERNIST_SDK = QtXmlPatternsSDK
 if(!debug_and_release|build_pass):CONFIG(debug, debug|release) {
-    win32:PATTERNIST_SDK = $${PATTERNIST_SDK}d
-    else: PATTERNIST_SDK = $${PATTERNIST_SDK}_debug
+    symbian:    PATTERNIST_SDK = $${PATTERNIST_SDK}
+    else:win32: PATTERNIST_SDK = $${PATTERNIST_SDK}d
+    else:       PATTERNIST_SDK = $${PATTERNIST_SDK}_debug
 }
 
 LIBS += -l$$PATTERNIST_SDK
diff --git a/tests/auto/xmlpatternsxqts/lib/Global.h b/tests/auto/xmlpatternsxqts/lib/Global.h
index eadb940..a620417 100644
--- a/tests/auto/xmlpatternsxqts/lib/Global.h
+++ b/tests/auto/xmlpatternsxqts/lib/Global.h
@@ -47,7 +47,7 @@
 #include "private/qitem_p.h"
 #include "private/qnamepool_p.h"
 
-#ifdef Q_WS_WIN
+#if defined(Q_WS_WIN) || defined(Q_OS_SYMBIAN)
 #   ifdef Q_PATTERNISTSDK_BUILDING
         #define Q_PATTERNISTSDK_EXPORT __declspec(dllexport)
     #else
diff --git a/tests/auto/xmlpatternsxqts/lib/lib.pro b/tests/auto/xmlpatternsxqts/lib/lib.pro
index cb9453a..f5b0a06 100644
--- a/tests/auto/xmlpatternsxqts/lib/lib.pro
+++ b/tests/auto/xmlpatternsxqts/lib/lib.pro
@@ -13,6 +13,12 @@ mac {
     INSTALLS += target
 }
 
+symbian {
+    TARGET.EPOCALLOWDLLDATA=1
+    TARGET.CAPABILITY = All -Tcb
+    MMP_RULES += EXPORTUNFROZEN
+}
+
 # We add gui, because xmlpatterns.pri pull it out.
 QT      += xmlpatterns xml network testlib gui
 
diff --git a/tests/auto/xmlpatternsxqts/test/test.pro b/tests/auto/xmlpatternsxqts/test/test.pro
index 603ae65..a69838a 100644
--- a/tests/auto/xmlpatternsxqts/test/test.pro
+++ b/tests/auto/xmlpatternsxqts/test/test.pro
@@ -24,5 +24,3 @@ win32 {
     else: DESTDIR = ../release
 }
 TARGET = tst_xmlpatternsxqts
-
-include (../../xmlpatterns.pri)
diff --git a/tests/auto/xmlpatternsxqts/xmlpatternsxqts.pro b/tests/auto/xmlpatternsxqts/xmlpatternsxqts.pro
index a3b13da..39267c8 100644
--- a/tests/auto/xmlpatternsxqts/xmlpatternsxqts.pro
+++ b/tests/auto/xmlpatternsxqts/xmlpatternsxqts.pro
@@ -1,10 +1,10 @@
 TEMPLATE = subdirs
-SUBDIRS = test
 contains(QT_CONFIG,xmlpatterns) {
   SUBDIRS += lib
   !wince*:lib.file = lib/lib.pro
   test.depends = lib
 }
+SUBDIRS += test
 
 # Needed on the win32-g++ setup and on the test machine arsia.
 INCLUDEPATH += $$QT_BUILD_TREE/include/QtXmlPatterns/private \