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

20 files changed, 992 insertions, 94 deletions

diff --git a/tests/auto/auto.pro b/tests/auto/auto.pro
index 8e3ce8149b..0f7a7f1eb2 100644
--- a/tests/auto/auto.pro
+++ b/tests/auto/auto.pro
@@ -127,6 +127,7 @@ SUBDIRS += \
            qexplicitlyshareddatapointer \
            qfile \
            qfiledialog \
+           qfiledialog2 \
            qfileinfo \
            qfilesystemwatcher \
            qfilesystemmodel \
diff --git a/tests/auto/gestures/tst_gestures.cpp b/tests/auto/gestures/tst_gestures.cpp
index 46ed45e5ad..92f979f86d 100644
--- a/tests/auto/gestures/tst_gestures.cpp
+++ b/tests/auto/gestures/tst_gestures.cpp
@@ -56,6 +56,11 @@
 //TESTED_CLASS=
 //TESTED_FILES=
 
+static QPointF mapToGlobal(const QPointF &pt, QGraphicsItem *item, QGraphicsView *view)
+{
+    return view->mapToGlobal(view->mapFromScene(item->mapToScene(pt)));
+}
+
 class CustomGesture : public QGesture
 {
     Q_OBJECT
@@ -63,11 +68,10 @@ public:
     static Qt::GestureType GestureType;
 
     CustomGesture(QObject *parent = 0)
-        : QGesture(parent), target(0), serial(0)
+        : QGesture(parent), serial(0)
     {
     }
 
-    QObject *target;
     int serial;
 
     static const int SerialMaybeThreshold;
@@ -86,13 +90,13 @@ public:
 
     CustomEvent(int serial_ = 0)
         : QEvent(QEvent::Type(CustomEvent::EventType)),
-          serial(serial_), targetObject(0)
+          serial(serial_), hasHotSpot(false)
     {
     }
 
     int serial;
-    QObject *targetObject;
-    QPoint hotSpot;
+    QPointF hotSpot;
+    bool hasHotSpot;
 };
 int CustomEvent::EventType = 0;
 
@@ -101,8 +105,8 @@ class CustomGestureRecognizer : public QGestureRecognizer
 public:
     CustomGestureRecognizer()
     {
-        CustomEvent::EventType = QEvent::registerEventType();
-        eventsCounter = 0;
+        if (!CustomEvent::EventType)
+            CustomEvent::EventType = QEvent::registerEventType();
     }
 
     QGesture* createGesture(QObject *)
@@ -117,9 +121,8 @@ public:
             CustomGesture *g = static_cast<CustomGesture*>(state);
             CustomEvent *e = static_cast<CustomEvent*>(event);
             g->serial = e->serial;
-            g->setTargetObject(e->targetObject);
-            g->setHotSpot(e->hotSpot);
-            ++eventsCounter;
+            if (e->hasHotSpot)
+                g->setHotSpot(e->hotSpot);
             if (g->serial >= CustomGesture::SerialFinishedThreshold)
                 result |= QGestureRecognizer::GestureFinished;
             else if (g->serial >= CustomGesture::SerialStartedThreshold)
@@ -139,16 +142,57 @@ public:
         g->serial = 0;
         QGestureRecognizer::reset(state);
     }
+};
+
+// same as CustomGestureRecognizer but triggers early without the maybe state
+class CustomContinuousGestureRecognizer : public QGestureRecognizer
+{
+public:
+    CustomContinuousGestureRecognizer()
+    {
+        if (!CustomEvent::EventType)
+            CustomEvent::EventType = QEvent::registerEventType();
+    }
+
+    QGesture* createGesture(QObject *)
+    {
+        return new CustomGesture;
+    }
+
+    QGestureRecognizer::Result filterEvent(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);
+            g->serial = e->serial;
+            if (e->hasHotSpot)
+                g->setHotSpot(e->hotSpot);
+            if (g->serial >= CustomGesture::SerialFinishedThreshold)
+                result |= QGestureRecognizer::GestureFinished;
+            else if (g->serial >= CustomGesture::SerialMaybeThreshold)
+                result |= QGestureRecognizer::GestureTriggered;
+            else
+                result = QGestureRecognizer::NotGesture;
+            return result;
+        }
+        return QGestureRecognizer::Ignore;
+    }
 
-    int eventsCounter;
-    QString name;
+    void reset(QGesture *state)
+    {
+        CustomGesture *g = static_cast<CustomGesture*>(state);
+        g->serial = 0;
+        QGestureRecognizer::reset(state);
+    }
 };
 
 class GestureWidget : public QWidget
 {
     Q_OBJECT
 public:
-    GestureWidget(const char *name = 0)
+    GestureWidget(const char *name = 0, QWidget *parent = 0)
+        : QWidget(parent)
     {
         if (name)
             setObjectName(QLatin1String(name));
@@ -162,6 +206,7 @@ public:
         gestureOverrideEventsReceived = 0;
         events.clear();
         overrideEvents.clear();
+        ignoredGestures.clear();
     }
 
     int customEventsReceived;
@@ -186,14 +231,18 @@ public:
     } events, overrideEvents;
 
     bool acceptGestureOverride;
+    QSet<Qt::GestureType> ignoredGestures;
 
 protected:
     bool event(QEvent *event)
     {
         Events *eventsPtr = 0;
         if (event->type() == QEvent::Gesture) {
+            QGestureEvent *e = static_cast<QGestureEvent*>(event);
             ++gestureEventsReceived;
             eventsPtr = &events;
+            foreach(Qt::GestureType type, ignoredGestures)
+                e->ignore(e->gesture(type));
         } else if (event->type() == QEvent::GestureOverride) {
             ++gestureOverrideEventsReceived;
             eventsPtr = &overrideEvents;
@@ -231,14 +280,15 @@ protected:
     }
 };
 
-static void sendCustomGesture(QObject *object)
+static void sendCustomGesture(CustomEvent *event, QObject *object, QGraphicsScene *scene = 0)
 {
-    CustomEvent ev;
-    ev.targetObject = object;
     for (int i = CustomGesture::SerialMaybeThreshold;
          i <= CustomGesture::SerialFinishedThreshold; ++i) {
-        ev.serial = i;
-        QApplication::sendEvent(object, &ev);
+        event->serial = i;
+        if (scene)
+            scene->sendEvent(qobject_cast<QGraphicsObject *>(object), event);
+        else
+            QApplication::sendEvent(object, event);
     }
 }
 
@@ -265,6 +315,13 @@ private slots:
     void finishedWithoutStarted();
     void unknownGesture();
     void graphicsItemGesture();
+    void graphicsItemTreeGesture();
+    void explicitGraphicsObjectTarget();
+    void gestureOverChildGraphicsItem();
+    void twoGesturesOnDifferentLevel();
+    void multipleGesturesInTree();
+    void multipleGesturesInComplexTree();
+    void testMapToScene();
 };
 
 tst_Gestures::tst_Gestures()
@@ -298,7 +355,8 @@ void tst_Gestures::customGesture()
 {
     GestureWidget widget;
     widget.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
-    sendCustomGesture(&widget);
+    CustomEvent event;
+    sendCustomGesture(&event, &widget);
 
     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
@@ -343,7 +401,8 @@ void tst_Gestures::gestureOverChild()
 
     widget.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
 
-    sendCustomGesture(child);
+    CustomEvent event;
+    sendCustomGesture(&event, child);
 
     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
@@ -361,7 +420,7 @@ void tst_Gestures::gestureOverChild()
     widget.reset();
     child->reset();
 
-    sendCustomGesture(child);
+    sendCustomGesture(&event, child);
 
     QCOMPARE(child->customEventsReceived, TotalCustomEventsCount);
     QCOMPARE(widget.customEventsReceived, 0);
@@ -392,7 +451,8 @@ void tst_Gestures::multipleWidgetOnlyGestureInTree()
     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
     // sending events to the child and making sure there is no conflict
-    sendCustomGesture(child);
+    CustomEvent event;
+    sendCustomGesture(&event, child);
 
     QCOMPARE(child->customEventsReceived, TotalCustomEventsCount);
     QCOMPARE(parent.customEventsReceived, 0);
@@ -405,7 +465,7 @@ void tst_Gestures::multipleWidgetOnlyGestureInTree()
     child->reset();
 
     // same for the parent widget
-    sendCustomGesture(&parent);
+    sendCustomGesture(&event, &parent);
 
     QCOMPARE(child->customEventsReceived, 0);
     QCOMPARE(parent.customEventsReceived, TotalCustomEventsCount);
@@ -432,10 +492,11 @@ void tst_Gestures::conflictingGestures()
     child->acceptGestureOverride = true;
 
     // sending events to the child and making sure there is no conflict
-    sendCustomGesture(child);
+    CustomEvent event;
+    sendCustomGesture(&event, child);
 
-    QCOMPARE(child->gestureOverrideEventsReceived, TotalGestureEventsCount);
-    QCOMPARE(child->gestureEventsReceived, 0);
+    QCOMPARE(child->gestureOverrideEventsReceived, 1);
+    QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);
     QCOMPARE(parent.gestureOverrideEventsReceived, 0);
     QCOMPARE(parent.gestureEventsReceived, 0);
 
@@ -447,12 +508,12 @@ void tst_Gestures::conflictingGestures()
     child->acceptGestureOverride = false;
 
     // sending events to the child and making sure there is no conflict
-    sendCustomGesture(child);
+    sendCustomGesture(&event, child);
 
-    QCOMPARE(child->gestureOverrideEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(child->gestureOverrideEventsReceived, 1);
     QCOMPARE(child->gestureEventsReceived, 0);
-    QCOMPARE(parent.gestureOverrideEventsReceived, TotalGestureEventsCount);
-    QCOMPARE(parent.gestureEventsReceived, 0);
+    QCOMPARE(parent.gestureOverrideEventsReceived, 1);
+    QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
 
     parent.reset();
     child->reset();
@@ -460,13 +521,31 @@ void tst_Gestures::conflictingGestures()
     // nobody accepts the override, we will send normal events to the closest context (to the child)
     parent.acceptGestureOverride = false;
     child->acceptGestureOverride = false;
+    child->ignoredGestures << CustomGesture::GestureType;
 
     // sending events to the child and making sure there is no conflict
-    sendCustomGesture(child);
+    sendCustomGesture(&event, child);
 
-    QCOMPARE(child->gestureOverrideEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(child->gestureOverrideEventsReceived, 1);
     QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);
-    QCOMPARE(parent.gestureOverrideEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(parent.gestureOverrideEventsReceived, 1);
+    QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
+
+    parent.reset();
+    child->reset();
+
+    Qt::GestureType ContinuousGesture = qApp->registerGestureRecognizer(new CustomContinuousGestureRecognizer);
+    static const int ContinuousGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
+    child->grabGesture(ContinuousGesture);
+    // child accepts override. And it also receives another custom gesture.
+    parent.acceptGestureOverride = false;
+    child->acceptGestureOverride = true;
+    sendCustomGesture(&event, child);
+
+    QCOMPARE(child->gestureOverrideEventsReceived, 1);
+    QVERIFY(child->gestureEventsReceived > TotalGestureEventsCount);
+    QCOMPARE(child->events.all.count(), TotalGestureEventsCount + ContinuousGestureEventsCount);
+    QCOMPARE(parent.gestureOverrideEventsReceived, 0);
     QCOMPARE(parent.gestureEventsReceived, 0);
 }
 
@@ -497,18 +576,28 @@ void tst_Gestures::unknownGesture()
     widget.grabGesture(Qt::CustomGesture, Qt::WidgetGesture);
     widget.grabGesture(Qt::GestureType(Qt::PanGesture+512), Qt::WidgetGesture);
 
-    sendCustomGesture(&widget);
+    CustomEvent event;
+    sendCustomGesture(&event, &widget);
 
     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
     QCOMPARE(widget.gestureEventsReceived, TotalGestureEventsCount);
 }
 
+static const QColor InstanceColors[] = {
+    Qt::blue, Qt::red, Qt::green, Qt::gray, Qt::yellow
+};
+
 class GestureItem : public QGraphicsObject
 {
+    static int InstanceCount;
+
 public:
-    GestureItem()
+    GestureItem(const char *name = 0)
     {
+        instanceNumber = InstanceCount++;
+        if (name)
+            setObjectName(QLatin1String(name));
         size = QRectF(0, 0, 100, 100);
         customEventsReceived = 0;
         gestureEventsReceived = 0;
@@ -517,6 +606,10 @@ public:
         overrideEvents.clear();
         acceptGestureOverride = false;
     }
+    ~GestureItem()
+    {
+        --InstanceCount;
+    }
 
     int customEventsReceived;
     int gestureEventsReceived;
@@ -540,8 +633,20 @@ public:
     } events, overrideEvents;
 
     bool acceptGestureOverride;
+    QSet<Qt::GestureType> ignoredGestures;
 
     QRectF size;
+    int instanceNumber;
+
+    void reset()
+    {
+        customEventsReceived = 0;
+        gestureEventsReceived = 0;
+        gestureOverrideEventsReceived = 0;
+        events.clear();
+        overrideEvents.clear();
+        ignoredGestures.clear();
+    }
 
 protected:
     QRectF boundingRect() const
@@ -550,7 +655,8 @@ protected:
     }
     void paint(QPainter *p, const QStyleOptionGraphicsItem *, QWidget *)
     {
-        p->fillRect(boundingRect(), Qt::blue);
+        QColor color = InstanceColors[instanceNumber % (sizeof(InstanceColors)/sizeof(InstanceColors[0]))];
+        p->fillRect(boundingRect(), color);
     }
 
     bool event(QEvent *event)
@@ -559,6 +665,9 @@ protected:
         if (event->type() == QEvent::Gesture) {
             ++gestureEventsReceived;
             eventsPtr = &events;
+            QGestureEvent *e = static_cast<QGestureEvent *>(event);
+            foreach(Qt::GestureType type, ignoredGestures)
+                e->ignore(e->gesture(type));
         } else if (event->type() == QEvent::GestureOverride) {
             ++gestureOverrideEventsReceived;
             eventsPtr = &overrideEvents;
@@ -595,23 +704,46 @@ protected:
         return true;
     }
 };
+int GestureItem::InstanceCount = 0;
 
 void tst_Gestures::graphicsItemGesture()
 {
     QGraphicsScene scene;
     QGraphicsView view(&scene);
 
-    GestureItem *item = new GestureItem;
+    GestureItem *item = new GestureItem("item");
     scene.addItem(item);
     item->setPos(100, 100);
 
-    item->grabGesture(CustomGesture::GestureType);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    view.ensureVisible(scene.sceneRect());
 
-    sendCustomGesture(item);
+    view.viewport()->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
+    item->grabGesture(CustomGesture::GestureType);
 
     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
+    CustomEvent event;
+    // gesture without hotspot should not be delivered to items in the view
+    QTest::ignoreMessage(QtWarningMsg, "QGestureManager::deliverEvent: could not find the target for gesture");
+    QTest::ignoreMessage(QtWarningMsg, "QGestureManager::deliverEvent: could not find the target for gesture");
+    QTest::ignoreMessage(QtWarningMsg, "QGestureManager::deliverEvent: could not find the target for gesture");
+    QTest::ignoreMessage(QtWarningMsg, "QGestureManager::deliverEvent: could not find the target for gesture");
+    sendCustomGesture(&event, item, &scene);
+
+    QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);
+    QCOMPARE(item->gestureEventsReceived, 0);
+    QCOMPARE(item->gestureOverrideEventsReceived, 0);
+
+    item->reset();
+
+    // make sure the event is properly delivered if only the hotspot is set.
+    event.hotSpot = mapToGlobal(QPointF(10, 10), item, &view);
+    event.hasHotSpot = true;
+    sendCustomGesture(&event, item, &scene);
+
     QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);
     QCOMPARE(item->gestureEventsReceived, TotalGestureEventsCount);
     QCOMPARE(item->gestureOverrideEventsReceived, 0);
@@ -622,6 +754,416 @@ void tst_Gestures::graphicsItemGesture()
     QCOMPARE(item->events.updated.size(), TotalGestureEventsCount - 2);
     QCOMPARE(item->events.finished.size(), 1);
     QCOMPARE(item->events.canceled.size(), 0);
+
+    item->reset();
+
+    // send gesture to the item which ignores it.
+    item->ignoredGestures << CustomGesture::GestureType;
+
+    event.hotSpot = mapToGlobal(QPointF(10, 10), item, &view);
+    event.hasHotSpot = true;
+    sendCustomGesture(&event, item, &scene);
+    QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);
+    QCOMPARE(item->gestureEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(item->gestureOverrideEventsReceived, 0);
+}
+
+void tst_Gestures::graphicsItemTreeGesture()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    GestureItem *item1 = new GestureItem("item1");
+    item1->setPos(100, 100);
+    item1->size = QRectF(0, 0, 350, 200);
+    scene.addItem(item1);
+
+    GestureItem *item1_child1 = new GestureItem("item1_child1");
+    item1_child1->setPos(50, 50);
+    item1_child1->size = QRectF(0, 0, 100, 100);
+    item1_child1->setParentItem(item1);
+
+    GestureItem *item1_child2 = new GestureItem("item1_child2");
+    item1_child2->size = QRectF(0, 0, 100, 100);
+    item1_child2->setPos(200, 50);
+    item1_child2->setParentItem(item1);
+
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    view.ensureVisible(scene.sceneRect());
+
+    view.viewport()->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
+    item1->grabGesture(CustomGesture::GestureType);
+
+    static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
+
+    CustomEvent event;
+    event.hotSpot = mapToGlobal(QPointF(10, 10), item1_child1, &view);
+    event.hasHotSpot = true;
+
+    item1->ignoredGestures << CustomGesture::GestureType;
+    sendCustomGesture(&event, item1_child1, &scene);
+    QCOMPARE(item1_child1->gestureOverrideEventsReceived, 0);
+    QCOMPARE(item1_child1->gestureEventsReceived, 0);
+    QCOMPARE(item1_child2->gestureEventsReceived, 0);
+    QCOMPARE(item1_child2->gestureOverrideEventsReceived, 0);
+    QCOMPARE(item1->gestureOverrideEventsReceived, 0);
+    QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
+
+    item1->reset(); item1_child1->reset(); item1_child2->reset();
+
+    item1_child1->grabGesture(CustomGesture::GestureType);
+
+    item1->ignoredGestures << CustomGesture::GestureType;
+    item1_child1->ignoredGestures << CustomGesture::GestureType;
+    sendCustomGesture(&event, item1_child1, &scene);
+    QCOMPARE(item1_child1->gestureOverrideEventsReceived, 1);
+    QCOMPARE(item1_child1->gestureEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(item1_child2->gestureEventsReceived, 0);
+    QCOMPARE(item1_child2->gestureOverrideEventsReceived, 0);
+    QCOMPARE(item1->gestureOverrideEventsReceived, 1);
+    QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
+}
+
+void tst_Gestures::explicitGraphicsObjectTarget()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    GestureItem *item1 = new GestureItem("item1");
+    scene.addItem(item1);
+    item1->setPos(100, 100);
+    item1->setZValue(1);
+
+    GestureItem *item2 = new GestureItem("item2");
+    scene.addItem(item2);
+    item2->setPos(100, 100);
+    item2->setZValue(5);
+
+    GestureItem *item2_child1 = new GestureItem("item2_child1");
+    scene.addItem(item2_child1);
+    item2_child1->setParentItem(item2);
+    item2_child1->setPos(10, 10);
+
+    view.show();
+    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);
+
+    static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
+
+    // sending events to item1, but the hotSpot is set to item2
+    CustomEvent event;
+    event.hotSpot = mapToGlobal(QPointF(15, 15), item2, &view);
+    event.hasHotSpot = true;
+
+    sendCustomGesture(&event, item1, &scene);
+
+    QCOMPARE(item1->gestureEventsReceived, 0);
+    QCOMPARE(item1->gestureOverrideEventsReceived, 1);
+    QCOMPARE(item2_child1->gestureEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(item2_child1->gestureOverrideEventsReceived, 1);
+    QCOMPARE(item2_child1->events.all.size(), TotalGestureEventsCount);
+    for(int i = 0; i < item2_child1->events.all.size(); ++i)
+        QCOMPARE(item2_child1->events.all.at(i), CustomGesture::GestureType);
+    QCOMPARE(item2_child1->events.started.size(), 1);
+    QCOMPARE(item2_child1->events.updated.size(), TotalGestureEventsCount - 2);
+    QCOMPARE(item2_child1->events.finished.size(), 1);
+    QCOMPARE(item2_child1->events.canceled.size(), 0);
+    QCOMPARE(item2->gestureEventsReceived, 0);
+    QCOMPARE(item2->gestureOverrideEventsReceived, 1);
+}
+
+void tst_Gestures::gestureOverChildGraphicsItem()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    GestureItem *item0 = new GestureItem("item0");
+    scene.addItem(item0);
+    item0->setPos(0, 0);
+    item0->grabGesture(CustomGesture::GestureType);
+    item0->setZValue(1);
+
+    GestureItem *item1 = new GestureItem("item1");
+    scene.addItem(item1);
+    item1->setPos(100, 100);
+    item1->setZValue(5);
+
+    GestureItem *item2 = new GestureItem("item2");
+    scene.addItem(item2);
+    item2->setPos(100, 100);
+    item2->setZValue(10);
+
+    GestureItem *item2_child1 = new GestureItem("item2_child1");
+    scene.addItem(item2_child1);
+    item2_child1->setParentItem(item2);
+    item2_child1->setPos(0, 0);
+
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+    view.ensureVisible(scene.sceneRect());
+
+    view.viewport()->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
+    item1->grabGesture(CustomGesture::GestureType);
+
+    static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
+    static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
+
+    CustomEvent event;
+    event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);
+    event.hasHotSpot = true;
+    sendCustomGesture(&event, item0, &scene);
+
+    QCOMPARE(item0->customEventsReceived, TotalCustomEventsCount);
+    QCOMPARE(item2_child1->gestureEventsReceived, 0);
+    QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);
+    QCOMPARE(item2->gestureEventsReceived, 0);
+    QCOMPARE(item2->gestureOverrideEventsReceived, 0);
+    QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(item1->gestureOverrideEventsReceived, 0);
+
+    item0->reset(); item1->reset(); item2->reset(); item2_child1->reset();
+    item2->grabGesture(CustomGesture::GestureType);
+    item2->ignoredGestures << CustomGesture::GestureType;
+
+    event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);
+    event.hasHotSpot = true;
+    sendCustomGesture(&event, item0, &scene);
+
+    QCOMPARE(item0->customEventsReceived, TotalCustomEventsCount);
+    QCOMPARE(item2_child1->gestureEventsReceived, 0);
+    QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);
+    QCOMPARE(item2->gestureEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(item2->gestureOverrideEventsReceived, 1);
+    QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(item1->gestureOverrideEventsReceived, 1);
+}
+
+void tst_Gestures::twoGesturesOnDifferentLevel()
+{
+    GestureWidget parent("parent");
+    QVBoxLayout *l = new QVBoxLayout(&parent);
+    GestureWidget *child = new GestureWidget("child");
+    l->addWidget(child);
+
+    Qt::GestureType SecondGesture = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
+
+    parent.grabGesture(CustomGesture::GestureType, Qt::WidgetWithChildrenGesture);
+    child->grabGesture(SecondGesture, Qt::WidgetWithChildrenGesture);
+
+    CustomEvent event;
+    // sending events that form a gesture to one widget, but they will be
+    // filtered by two different gesture recognizers and will generate two
+    // QGesture objects. Check that those gesture objects are delivered to
+    // different widgets properly.
+    sendCustomGesture(&event, child);
+
+    static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
+    static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
+
+    QCOMPARE(child->customEventsReceived, TotalCustomEventsCount);
+    QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(child->gestureOverrideEventsReceived, 0);
+    QCOMPARE(child->events.all.size(), TotalGestureEventsCount);
+    for(int i = 0; i < child->events.all.size(); ++i)
+        QCOMPARE(child->events.all.at(i), SecondGesture);
+
+    QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
+    QCOMPARE(parent.gestureOverrideEventsReceived, 0);
+    QCOMPARE(parent.events.all.size(), TotalGestureEventsCount);
+    for(int i = 0; i < child->events.all.size(); ++i)
+        QCOMPARE(parent.events.all.at(i), CustomGesture::GestureType);
+}
+
+void tst_Gestures::multipleGesturesInTree()
+{
+    GestureWidget a("A");
+    GestureWidget *A = &a;
+    GestureWidget *B = new GestureWidget("B", A);
+    GestureWidget *C = new GestureWidget("C", B);
+    GestureWidget *D = new GestureWidget("D", C);
+
+    Qt::GestureType FirstGesture  = CustomGesture::GestureType;
+    Qt::GestureType SecondGesture = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType ThirdGesture  = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
+
+    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);
+
+    // make sure all widgets ignore events, so they get propagated.
+    A->ignoredGestures << FirstGesture << ThirdGesture;
+    B->ignoredGestures << SecondGesture << ThirdGesture;
+    C->ignoredGestures << FirstGesture << SecondGesture << ThirdGesture;
+    D->ignoredGestures << FirstGesture << ThirdGesture;
+
+    CustomEvent event;
+    sendCustomGesture(&event, D);
+
+    static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
+
+    // gesture override events
+    QCOMPARE(D->overrideEvents.all.count(FirstGesture), 1);
+    QCOMPARE(D->overrideEvents.all.count(SecondGesture), 0);
+    QCOMPARE(D->overrideEvents.all.count(ThirdGesture), 1);
+
+    QCOMPARE(C->overrideEvents.all.count(FirstGesture), 1);
+    QCOMPARE(C->overrideEvents.all.count(SecondGesture), 1);
+    QCOMPARE(C->overrideEvents.all.count(ThirdGesture), 1);
+
+    QCOMPARE(B->overrideEvents.all.count(FirstGesture), 0);
+    QCOMPARE(B->overrideEvents.all.count(SecondGesture), 1);
+    QCOMPARE(B->overrideEvents.all.count(ThirdGesture), 1);
+
+    QCOMPARE(A->overrideEvents.all.count(FirstGesture), 1);
+    QCOMPARE(A->overrideEvents.all.count(SecondGesture), 0);
+    QCOMPARE(A->overrideEvents.all.count(ThirdGesture), 1);
+
+    // normal gesture events
+    QCOMPARE(D->events.all.count(FirstGesture), TotalGestureEventsCount);
+    QCOMPARE(D->events.all.count(SecondGesture), 0);
+    QCOMPARE(D->events.all.count(ThirdGesture), TotalGestureEventsCount);
+
+    QCOMPARE(C->events.all.count(FirstGesture), TotalGestureEventsCount);
+    QCOMPARE(C->events.all.count(SecondGesture), TotalGestureEventsCount);
+    QCOMPARE(C->events.all.count(ThirdGesture), TotalGestureEventsCount);
+
+    QCOMPARE(B->events.all.count(FirstGesture), 0);
+    QCOMPARE(B->events.all.count(SecondGesture), TotalGestureEventsCount);
+    QCOMPARE(B->events.all.count(ThirdGesture), TotalGestureEventsCount);
+
+    QCOMPARE(A->events.all.count(FirstGesture), TotalGestureEventsCount);
+    QCOMPARE(A->events.all.count(SecondGesture), 0);
+    QCOMPARE(A->events.all.count(ThirdGesture), TotalGestureEventsCount);
+}
+
+void tst_Gestures::multipleGesturesInComplexTree()
+{
+    GestureWidget a("A");
+    GestureWidget *A = &a;
+    GestureWidget *B = new GestureWidget("B", A);
+    GestureWidget *C = new GestureWidget("C", B);
+    GestureWidget *D = new GestureWidget("D", C);
+
+    Qt::GestureType FirstGesture   = CustomGesture::GestureType;
+    Qt::GestureType SecondGesture  = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType ThirdGesture   = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType FourthGesture  = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType FifthGesture   = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType SixthGesture   = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
+    Qt::GestureType SeventhGesture = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
+
+    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);
+
+    // make sure all widgets ignore events, so they get propagated.
+    QSet<Qt::GestureType> allGestureTypes;
+    allGestureTypes << FirstGesture << SecondGesture << ThirdGesture
+            << FourthGesture << FifthGesture << SixthGesture << SeventhGesture;
+    A->ignoredGestures = B->ignoredGestures = allGestureTypes;
+    C->ignoredGestures = D->ignoredGestures = allGestureTypes;
+
+    CustomEvent event;
+    sendCustomGesture(&event, D);
+
+    static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
+
+    // gesture override events
+    QCOMPARE(D->overrideEvents.all.count(FirstGesture), 1);
+    QCOMPARE(D->overrideEvents.all.count(SecondGesture), 0);
+    QCOMPARE(D->overrideEvents.all.count(ThirdGesture), 1);
+
+    QCOMPARE(C->overrideEvents.all.count(FirstGesture), 1);
+    QCOMPARE(C->overrideEvents.all.count(SecondGesture), 1);
+    QCOMPARE(C->overrideEvents.all.count(ThirdGesture), 1);
+
+    QCOMPARE(B->overrideEvents.all.count(FirstGesture), 0);
+    QCOMPARE(B->overrideEvents.all.count(SecondGesture), 1);
+    QCOMPARE(B->overrideEvents.all.count(ThirdGesture), 1);
+
+    QCOMPARE(A->overrideEvents.all.count(FirstGesture), 1);
+    QCOMPARE(A->overrideEvents.all.count(SecondGesture), 0);
+    QCOMPARE(A->overrideEvents.all.count(ThirdGesture), 1);
+
+    // normal gesture events
+    QCOMPARE(D->events.all.count(FirstGesture), TotalGestureEventsCount);
+    QCOMPARE(D->events.all.count(SecondGesture), 0);
+    QCOMPARE(D->events.all.count(ThirdGesture), TotalGestureEventsCount);
+    QCOMPARE(D->events.all.count(FourthGesture), 0);
+    QCOMPARE(D->events.all.count(FifthGesture), 0);
+    QCOMPARE(D->events.all.count(SixthGesture), 0);
+    QCOMPARE(D->events.all.count(SeventhGesture), TotalGestureEventsCount);
+
+    QCOMPARE(C->events.all.count(FirstGesture), TotalGestureEventsCount);
+    QCOMPARE(C->events.all.count(SecondGesture), TotalGestureEventsCount);
+    QCOMPARE(C->events.all.count(ThirdGesture), TotalGestureEventsCount);
+    QCOMPARE(C->events.all.count(FourthGesture), 0);
+    QCOMPARE(C->events.all.count(FifthGesture), 0);
+    QCOMPARE(C->events.all.count(SixthGesture), TotalGestureEventsCount);
+    QCOMPARE(C->events.all.count(SeventhGesture), 0);
+
+    QCOMPARE(B->events.all.count(FirstGesture), 0);
+    QCOMPARE(B->events.all.count(SecondGesture), TotalGestureEventsCount);
+    QCOMPARE(B->events.all.count(ThirdGesture), TotalGestureEventsCount);
+    QCOMPARE(B->events.all.count(FourthGesture), 0);
+    QCOMPARE(B->events.all.count(FifthGesture), TotalGestureEventsCount);
+    QCOMPARE(B->events.all.count(SixthGesture), 0);
+    QCOMPARE(B->events.all.count(SeventhGesture), 0);
+
+    QCOMPARE(A->events.all.count(FirstGesture), TotalGestureEventsCount);
+    QCOMPARE(A->events.all.count(SecondGesture), 0);
+    QCOMPARE(A->events.all.count(ThirdGesture), TotalGestureEventsCount);
+    QCOMPARE(A->events.all.count(FourthGesture), TotalGestureEventsCount);
+    QCOMPARE(A->events.all.count(FifthGesture), 0);
+    QCOMPARE(A->events.all.count(SixthGesture), 0);
+    QCOMPARE(A->events.all.count(SeventhGesture), 0);
+}
+
+void tst_Gestures::testMapToScene()
+{
+    QGesture gesture;
+    QList<QGesture*> list;
+    list << &gesture;
+    QGestureEvent event(list);
+    QCOMPARE(event.mapToScene(gesture.hotSpot()), QPointF()); // not set, can't do much
+
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    GestureItem *item0 = new GestureItem;
+    scene.addItem(item0);
+    item0->setPos(14, 16);
+
+    view.show(); // need to show to give it a global coordinate
+    QTest::qWaitForWindowShown(&view);
+    view.ensureVisible(scene.sceneRect());
+
+    QPoint origin = view.mapToGlobal(QPoint());
+    event.setWidget(view.viewport());
+
+    QCOMPARE(event.mapToScene(origin + QPoint(100, 200)), view.mapToScene(QPoint(100, 200)));
 }
 
 QTEST_MAIN(tst_Gestures)
diff --git a/tests/auto/linguist/lrelease/testdata/idbased.ts b/tests/auto/linguist/lrelease/testdata/idbased.ts
index 61497deecb..c7555c846e 100644
--- a/tests/auto/linguist/lrelease/testdata/idbased.ts
+++ b/tests/auto/linguist/lrelease/testdata/idbased.ts
@@ -9,6 +9,7 @@
     </message>
     <message id="untranslated_id">
         <source>This has no translation.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message id="this_another_id">
         <source>Foo bar.</source>
@@ -17,5 +18,11 @@
     <message>
         <source>Drop me!</source>
     </message>
+    <message id="one_id">
+        <source></source>
+    </message>
+    <message id="two_id">
+        <source></source>
+    </message>
 </context>
 </TS>
diff --git a/tests/auto/qdom/tst_qdom.cpp b/tests/auto/qdom/tst_qdom.cpp
index 6637202a08..0d58554ea8 100644
--- a/tests/auto/qdom/tst_qdom.cpp
+++ b/tests/auto/qdom/tst_qdom.cpp
@@ -322,6 +322,7 @@ void tst_QDom::toString_01_data()
 */
 void tst_QDom::toString_01()
 {
+    QFAIL("make test fail instead of timing out, will be fixed later (QT-2357)");
     QFETCH(QString, fileName);
 
     QFile f(fileName);
diff --git a/tests/auto/qfiledialog2/tst_qfiledialog2.cpp b/tests/auto/qfiledialog2/tst_qfiledialog2.cpp
index 18f94a9ef2..83ddd39e11 100644
--- a/tests/auto/qfiledialog2/tst_qfiledialog2.cpp
+++ b/tests/auto/qfiledialog2/tst_qfiledialog2.cpp
@@ -136,7 +136,10 @@ private:
 };
 
 tst_QFiledialog::tst_QFiledialog()
-{
+{   
+#if defined(Q_OS_WINCE)
+    qApp->setAutoMaximizeThreshold(-1);
+#endif
 }
 
 tst_QFiledialog::~tst_QFiledialog()
@@ -168,13 +171,21 @@ void tst_QFiledialog::cleanup()
 void tst_QFiledialog::listRoot()
 {
 #if defined QT_BUILD_INTERNAL
+    QFileInfoGatherer fileInfoGatherer;
+    fileInfoGatherer.start();
+    QTest::qWait(1500);
+
     QFileInfoGatherer::fetchedRoot = false;
     QString dir(QDir::currentPath());
     QNonNativeFileDialog fd(0, QString(), dir);
     fd.show();
     QCOMPARE(QFileInfoGatherer::fetchedRoot,false);
     fd.setDirectory("");
+#ifdef Q_OS_WINCE
+    QTest::qWait(1500);
+#else
     QTest::qWait(500);
+#endif
     QCOMPARE(QFileInfoGatherer::fetchedRoot,true);
 #endif
 }
@@ -297,6 +308,7 @@ void tst_QFiledialog::emptyUncPath()
 void tst_QFiledialog::task178897_minimumSize()
 {
     QNonNativeFileDialog fd;
+    QSize oldMs = fd.layout()->minimumSize();
     QStringList history = fd.history();
     history << QDir::toNativeSeparators("/verylongdirectory/"
             "aaaaaaaaaabbbbbbbbcccccccccccddddddddddddddeeeeeeeeeeeeffffffffffgggtggggggggghhhhhhhhiiiiiijjjk");
@@ -304,7 +316,7 @@ void tst_QFiledialog::task178897_minimumSize()
     fd.show();
 
     QSize ms = fd.layout()->minimumSize();
-    QVERIFY(ms.width() < 400);
+    QVERIFY(ms.width() <= oldMs.width());
 }
 
 void tst_QFiledialog::task180459_lastDirectory_data()
@@ -653,22 +665,33 @@ void tst_QFiledialog::task228844_ensurePreviousSorting()
     fd.setDirectory(current.absolutePath());
     fd.setViewMode(QFileDialog::Detail);
     fd.show();
+#if defined(Q_OS_WINCE)
+    QTest::qWait(1500);
+#else
     QTest::qWait(500);
+#endif
     QTreeView *tree = qFindChild<QTreeView*>(&fd, "treeView");
     tree->header()->setSortIndicator(3,Qt::DescendingOrder);
     QTest::qWait(200);
     QDialogButtonBox *buttonBox = qFindChild<QDialogButtonBox*>(&fd, "buttonBox");
     QPushButton *button = buttonBox->button(QDialogButtonBox::Open);
     QTest::mouseClick(button, Qt::LeftButton);
+#if defined(Q_OS_WINCE)
+    QTest::qWait(1500);
+#else
     QTest::qWait(500);
-
+#endif
     QNonNativeFileDialog fd2;
     fd2.setFileMode(QFileDialog::Directory);
     fd2.restoreState(fd.saveState());
     current.cd("aaaaaaaaaaaaaaaaaa");
     fd2.setDirectory(current.absolutePath());
     fd2.show();
+#if defined(Q_OS_WINCE)
+    QTest::qWait(1500);
+#else
     QTest::qWait(500);
+#endif
     QTreeView *tree2 = qFindChild<QTreeView*>(&fd2, "treeView");
     tree2->setFocus();
 
@@ -678,15 +701,22 @@ void tst_QFiledialog::task228844_ensurePreviousSorting()
     QPushButton *button2 = buttonBox2->button(QDialogButtonBox::Open);
     fd2.selectFile("g");
     QTest::mouseClick(button2, Qt::LeftButton);
+#if defined(Q_OS_WINCE)
+    QTest::qWait(1500);
+#else
     QTest::qWait(500);
-
+#endif
     QCOMPARE(fd2.selectedFiles().first(), current.absolutePath() + QChar('/') + QLatin1String("g"));
 
     QNonNativeFileDialog fd3(0, "This is a third file dialog", tempFile->fileName());
     fd3.restoreState(fd.saveState());
     fd3.setFileMode(QFileDialog::Directory);
     fd3.show();
+#if defined(Q_OS_WINCE)
+    QTest::qWait(1500);
+#else
     QTest::qWait(500);
+#endif
     QTreeView *tree3 = qFindChild<QTreeView*>(&fd3, "treeView");
     tree3->setFocus();
 
@@ -695,8 +725,11 @@ void tst_QFiledialog::task228844_ensurePreviousSorting()
     QDialogButtonBox *buttonBox3 = qFindChild<QDialogButtonBox*>(&fd3, "buttonBox");
     QPushButton *button3 = buttonBox3->button(QDialogButtonBox::Open);
     QTest::mouseClick(button3, Qt::LeftButton);
+#if defined(Q_OS_WINCE)
+    QTest::qWait(1500);
+#else
     QTest::qWait(500);
-
+#endif
     QCOMPARE(fd3.selectedFiles().first(), tempFile->fileName());
 
     current.cd("aaaaaaaaaaaaaaaaaa");
@@ -777,7 +810,12 @@ void tst_QFiledialog::task251321_sideBarHiddenEntries()
     sidebar->setFocus();
     sidebar->selectUrl(QUrl::fromLocalFile(hiddenSubDir.absolutePath()));
     QTest::mouseClick(sidebar->viewport(), Qt::LeftButton, 0, sidebar->visualRect(sidebar->model()->index(0, 0)).center());
+    // give the background processes more time on windows mobile
+#ifdef Q_OS_WINCE
+    QTest::qWait(1000);
+#else
     QTest::qWait(250);
+#endif
 
     QFileSystemModel *model = qFindChild<QFileSystemModel*>(&fd, "qt_filesystem_model");
     QCOMPARE(model->rowCount(model->index(hiddenSubDir.absolutePath())), 2);
diff --git a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
index 0a6f60ed20..dcad8e17c8 100644
--- a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
+++ b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
@@ -398,6 +398,7 @@ private slots:
     void modality_mouseGrabber();
     void modality_clickFocus();
     void modality_keyEvents();
+    void itemIsInFront();
 
     // task specific tests below me
     void task141694_textItemEnsureVisible();
@@ -9541,5 +9542,47 @@ void tst_QGraphicsItem::modality_keyEvents()
     QCOMPARE(rect1Spy.counts[QEvent::KeyRelease], 0);
 }
 
+void tst_QGraphicsItem::itemIsInFront()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem *rect1 = new QGraphicsRectItem;
+    rect1->setData(0, "rect1");
+    scene.addItem(rect1);
+
+    QGraphicsRectItem *rect1child1 = new QGraphicsRectItem(rect1);
+    rect1child1->setZValue(1);
+    rect1child1->setData(0, "rect1child1");
+
+    QGraphicsRectItem *rect1child2 = new QGraphicsRectItem(rect1);
+    rect1child2->setParentItem(rect1);
+    rect1child2->setData(0, "rect1child2");
+
+    QGraphicsRectItem *rect1child1_1 = new QGraphicsRectItem(rect1child1);
+    rect1child1_1->setData(0, "rect1child1_1");
+
+    QGraphicsRectItem *rect1child1_2 = new QGraphicsRectItem(rect1child1);
+    rect1child1_2->setFlag(QGraphicsItem::ItemStacksBehindParent);
+    rect1child1_2->setData(0, "rect1child1_2");
+
+    QGraphicsRectItem *rect2 = new QGraphicsRectItem;
+    rect2->setData(0, "rect2");
+    scene.addItem(rect2);
+
+    QGraphicsRectItem *rect2child1 = new QGraphicsRectItem(rect2);
+    rect2child1->setData(0, "rect2child1");
+
+    QCOMPARE(qt_closestItemFirst(rect1, rect1), false);
+    QCOMPARE(qt_closestItemFirst(rect1, rect2), false);
+    QCOMPARE(qt_closestItemFirst(rect1child1, rect2child1), false);
+    QCOMPARE(qt_closestItemFirst(rect1child1, rect1child2), true);
+    QCOMPARE(qt_closestItemFirst(rect1child1_1, rect1child2), true);
+    QCOMPARE(qt_closestItemFirst(rect1child1_1, rect1child1), true);
+    QCOMPARE(qt_closestItemFirst(rect1child1_2, rect1child2), true);
+    QCOMPARE(qt_closestItemFirst(rect1child1_2, rect1child1), false);
+    QCOMPARE(qt_closestItemFirst(rect1child1_2, rect1), true);
+    QCOMPARE(qt_closestItemFirst(rect1child1_2, rect2), false);
+    QCOMPARE(qt_closestItemFirst(rect1child1_2, rect2child1), false);
+}
+
 QTEST_MAIN(tst_QGraphicsItem)
 #include "tst_qgraphicsitem.moc"
diff --git a/tests/auto/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp b/tests/auto/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
index 2426ce93f2..9269164898 100644
--- a/tests/auto/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
+++ b/tests/auto/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
@@ -2007,8 +2007,10 @@ void tst_QGraphicsProxyWidget::tabFocus_complexTwoWidgets()
     edit1->setText("QLineEdit 1");
     QLineEdit *edit2 = new QLineEdit;
     edit2->setText("QLineEdit 2");
+    QFontComboBox *fontComboBox = new QFontComboBox;
     QVBoxLayout *vlayout = new QVBoxLayout;
     vlayout->addWidget(edit1);
+    vlayout->addWidget(fontComboBox);
     vlayout->addWidget(edit2);
 
     QGroupBox *box = new QGroupBox("QGroupBox");
@@ -2020,8 +2022,10 @@ void tst_QGraphicsProxyWidget::tabFocus_complexTwoWidgets()
     edit1_2->setText("QLineEdit 1_2");
     QLineEdit *edit2_2 = new QLineEdit;
     edit2_2->setText("QLineEdit 2_2");
+    QFontComboBox *fontComboBox2 = new QFontComboBox;
     vlayout = new QVBoxLayout;
     vlayout->addWidget(edit1_2);
+    vlayout->addWidget(fontComboBox2);
     vlayout->addWidget(edit2_2);
 
     QGroupBox *box_2 = new QGroupBox("QGroupBox 2");
@@ -2062,8 +2066,10 @@ void tst_QGraphicsProxyWidget::tabFocus_complexTwoWidgets()
 
     EventSpy eventSpy(edit1);
     EventSpy eventSpy2(edit2);
+    EventSpy eventSpy3(fontComboBox);
     EventSpy eventSpy1_2(edit1_2);
     EventSpy eventSpy2_2(edit2_2);
+    EventSpy eventSpy2_3(fontComboBox2);
     EventSpy eventSpyBox(box);
 
     // Tab into group box
@@ -2084,11 +2090,24 @@ void tst_QGraphicsProxyWidget::tabFocus_complexTwoWidgets()
     QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
     QCOMPARE(eventSpy.counts[QEvent::FocusOut], 0);
 
+    // Tab to the font combobox
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    fontComboBox->hasFocus();
+    QVERIFY(!edit2->hasFocus());
+    QCOMPARE(eventSpy3.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy3.counts[QEvent::FocusOut], 0);
+    QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy.counts[QEvent::FocusOut], 1);
+
     // Tab into line edit 2
     QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
     QApplication::processEvents();
     edit2->hasFocus();
     QVERIFY(!edit1->hasFocus());
+    QCOMPARE(eventSpy2.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy2.counts[QEvent::FocusOut], 0);
+    QCOMPARE(eventSpy3.counts[QEvent::FocusOut], 1);
     QCOMPARE(eventSpy.counts[QEvent::FocusIn], 1);
     QCOMPARE(eventSpy.counts[QEvent::FocusOut], 1);
 
@@ -2106,6 +2125,16 @@ void tst_QGraphicsProxyWidget::tabFocus_complexTwoWidgets()
     QCOMPARE(eventSpy1_2.counts[QEvent::FocusIn], 1);
     QCOMPARE(eventSpy1_2.counts[QEvent::FocusOut], 0);
 
+    // Tab into right font combobox
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
+    QApplication::processEvents();
+    QVERIFY(!edit1_2->hasFocus());
+    fontComboBox2->hasFocus();
+    QCOMPARE(eventSpy1_2.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy1_2.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpy2_3.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy2_3.counts[QEvent::FocusOut], 0);
+
     // Tab into right bottom line edit
     QTest::keyPress(QApplication::focusWidget(), Qt::Key_Tab);
     QApplication::processEvents();
@@ -2113,6 +2142,8 @@ void tst_QGraphicsProxyWidget::tabFocus_complexTwoWidgets()
     edit2_2->hasFocus();
     QCOMPARE(eventSpy1_2.counts[QEvent::FocusIn], 1);
     QCOMPARE(eventSpy1_2.counts[QEvent::FocusOut], 1);
+    QCOMPARE(eventSpy2_3.counts[QEvent::FocusIn], 1);
+    QCOMPARE(eventSpy2_3.counts[QEvent::FocusOut], 1);
     QCOMPARE(eventSpy2_2.counts[QEvent::FocusIn], 1);
     QCOMPARE(eventSpy2_2.counts[QEvent::FocusOut], 0);
 
@@ -2129,6 +2160,12 @@ void tst_QGraphicsProxyWidget::tabFocus_complexTwoWidgets()
     QVERIFY(!rightDial->hasFocus());
     edit2_2->hasFocus();
 
+    // Backtab into the right font combobox
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!edit2_2->hasFocus());
+    fontComboBox2->hasFocus();
+
     // Backtab into line edit 1
     QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
     QApplication::processEvents();
@@ -2147,10 +2184,16 @@ void tst_QGraphicsProxyWidget::tabFocus_complexTwoWidgets()
     QVERIFY(!rightDial->hasFocus());
     edit2->hasFocus();
 
-    // Backtab into line edit 1
+    // Backtab into the font combobox
     QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
     QApplication::processEvents();
     QVERIFY(!edit2->hasFocus());
+    fontComboBox->hasFocus();
+
+    // Backtab into line edit 1
+    QTest::keyPress(QApplication::focusWidget(), Qt::Key_Backtab);
+    QApplication::processEvents();
+    QVERIFY(!fontComboBox->hasFocus());
     edit1->hasFocus();
 
     // Backtab into line box
diff --git a/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp b/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp
index b407fef2a2..eb5c09959f 100644
--- a/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp
+++ b/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp
@@ -88,7 +88,7 @@ static QTransform transform2D(const QGraphicsTransform& t)
 {
     QMatrix4x4 m;
     t.applyTo(&m);
-    return m.toTransform();
+    return m.toTransform(0);
 }
 
 void tst_QGraphicsTransform::scale()
diff --git a/tests/auto/qhttp/tst_qhttp.cpp b/tests/auto/qhttp/tst_qhttp.cpp
index f6d5e3e5fc..0ea0d15fdc 100644
--- a/tests/auto/qhttp/tst_qhttp.cpp
+++ b/tests/auto/qhttp/tst_qhttp.cpp
@@ -484,6 +484,7 @@ void tst_QHttp::post_data()
     QTest::addColumn<bool>("useProxy");
     QTest::addColumn<QString>("host");
     QTest::addColumn<int>("port");
+    QTest::addColumn<bool>("ssl");
     QTest::addColumn<QString>("path");
     QTest::addColumn<QByteArray>("result");
 
@@ -491,25 +492,48 @@ void tst_QHttp::post_data()
     md5sum = "d41d8cd98f00b204e9800998ecf8427e";
     QTest::newRow("empty-data")
         << QString() << false << false
-        << QtNetworkSettings::serverName() << 80 << "/qtest/cgi-bin/md5sum.cgi" << md5sum;
+        << QtNetworkSettings::serverName() << 80 << false << "/qtest/cgi-bin/md5sum.cgi" << md5sum;
     QTest::newRow("empty-device")
         << QString() << true << false
-        << QtNetworkSettings::serverName() << 80 << "/qtest/cgi-bin/md5sum.cgi" << md5sum;
+        << QtNetworkSettings::serverName() << 80 << false << "/qtest/cgi-bin/md5sum.cgi" << md5sum;
     QTest::newRow("proxy-empty-data")
         << QString() << false << true
-        << QtNetworkSettings::serverName() << 80 << "/qtest/cgi-bin/md5sum.cgi" << md5sum;
+        << QtNetworkSettings::serverName() << 80 << false << "/qtest/cgi-bin/md5sum.cgi" << md5sum;
 
     md5sum = "b3e32ac459b99d3f59318f3ac31e4bee";
     QTest::newRow("data") << "rfc3252.txt" << false << false
-                          << QtNetworkSettings::serverName() << 80 << "/qtest/cgi-bin/md5sum.cgi"
+                          << QtNetworkSettings::serverName() << 80 << false << "/qtest/cgi-bin/md5sum.cgi"
                           << md5sum;
     QTest::newRow("device") << "rfc3252.txt" << true << false
-                          << QtNetworkSettings::serverName() << 80 << "/qtest/cgi-bin/md5sum.cgi"
+                          << QtNetworkSettings::serverName() << 80 << false << "/qtest/cgi-bin/md5sum.cgi"
                           << md5sum;
     QTest::newRow("proxy-data") << "rfc3252.txt" << false << true
-                                << QtNetworkSettings::serverName() << 80 << "/qtest/cgi-bin/md5sum.cgi"
+                                << QtNetworkSettings::serverName() << 80 << false << "/qtest/cgi-bin/md5sum.cgi"
                                 << md5sum;
 
+#ifndef QT_NO_OPENSSL
+    md5sum = "d41d8cd98f00b204e9800998ecf8427e";
+    QTest::newRow("empty-data-ssl")
+        << QString() << false << false
+        << QtNetworkSettings::serverName() << 443 << true << "/qtest/cgi-bin/md5sum.cgi" << md5sum;
+    QTest::newRow("empty-device-ssl")
+        << QString() << true << false
+        << QtNetworkSettings::serverName() << 443 << true << "/qtest/cgi-bin/md5sum.cgi" << md5sum;
+    QTest::newRow("proxy-empty-data-ssl")
+        << QString() << false << true
+        << QtNetworkSettings::serverName() << 443 << true << "/qtest/cgi-bin/md5sum.cgi" << md5sum;
+    md5sum = "b3e32ac459b99d3f59318f3ac31e4bee";
+    QTest::newRow("data-ssl") << "rfc3252.txt" << false << false
+        << QtNetworkSettings::serverName() << 443 << true << "/qtest/cgi-bin/md5sum.cgi"
+        << md5sum;
+    QTest::newRow("device-ssl") << "rfc3252.txt" << true << false
+        << QtNetworkSettings::serverName() << 443 << true << "/qtest/cgi-bin/md5sum.cgi"
+        << md5sum;
+    QTest::newRow("proxy-data-ssl") << "rfc3252.txt" << false << true
+        << QtNetworkSettings::serverName() << 443 << true << "/qtest/cgi-bin/md5sum.cgi"
+        << md5sum;
+#endif
+
     // the following test won't work. See task 185996
 /*
     QTest::newRow("proxy-device") << "rfc3252.txt" << true << true
@@ -525,14 +549,19 @@ void tst_QHttp::post()
     QFETCH(bool, useProxy);
     QFETCH(QString, host);
     QFETCH(int, port);
+    QFETCH(bool, ssl);
     QFETCH(QString, path);
 
     http = newHttp(useProxy);
+#ifndef QT_NO_OPENSSL
+    QObject::connect(http, SIGNAL(sslErrors(const QList<QSslError> &)),
+        http, SLOT(ignoreSslErrors()));
+#endif
     QCOMPARE(http->currentId(), 0);
     QCOMPARE((int)http->state(), (int)QHttp::Unconnected);
     if (useProxy)
         addRequest(QHttpRequestHeader(), http->setProxy(QtNetworkSettings::serverName(), 3129));
-    addRequest(QHttpRequestHeader(), http->setHost(host, port));
+    addRequest(QHttpRequestHeader(), http->setHost(host, (ssl ? QHttp::ConnectionModeHttps : QHttp::ConnectionModeHttp), port));
 
     // add the POST request
     QFile file(SRCDIR + source);
diff --git a/tests/auto/qlayout/tst_qlayout.cpp b/tests/auto/qlayout/tst_qlayout.cpp
index 9d6110dfa7..efe14c37ca 100644
--- a/tests/auto/qlayout/tst_qlayout.cpp
+++ b/tests/auto/qlayout/tst_qlayout.cpp
@@ -83,6 +83,7 @@ private slots:
     void layoutItemRect();
     void warnIfWrongParent();
     void controlTypes();
+    void adjustSizeShouldMakeSureLayoutIsActivated();
 };
 
 tst_QLayout::tst_QLayout()
@@ -110,8 +111,8 @@ void tst_QLayout::getSetCheck()
 class SizeHinterFrame : public QFrame
 {
 public:
-    SizeHinterFrame(const QSize &s) 
-    : QFrame(0), sh(s) {
+    SizeHinterFrame(const QSize &sh, const QSize &msh = QSize())
+    : QFrame(0), sh(sh), msh(msh) {
         setFrameStyle(QFrame::Box | QFrame::Plain);
     }
 
@@ -119,9 +120,11 @@ public:
 
     void setSizeHint(const QSize &s) { sh = s; }
     QSize sizeHint() const { return sh; }
+    QSize minimumSizeHint() const { return msh; }
 
 private:
     QSize sh;
+    QSize msh;
 };
 
 
@@ -333,5 +336,26 @@ void tst_QLayout::controlTypes()
 
 }
 
+void tst_QLayout::adjustSizeShouldMakeSureLayoutIsActivated()
+{
+    QWidget main;
+
+    QVBoxLayout *const layout = new QVBoxLayout(&main);
+    layout->setMargin(0);
+    SizeHinterFrame *frame = new SizeHinterFrame(QSize(200, 10), QSize(200, 8));
+    frame->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+    layout->addWidget(frame);
+
+    SizeHinterFrame *frame2 = new SizeHinterFrame(QSize(200, 10), QSize(200, 8));
+    frame2->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+    layout->addWidget(frame2);
+
+    main.show();
+
+    frame2->hide();
+    main.adjustSize();
+    QCOMPARE(main.size(), QSize(200, 10));
+}
+
 QTEST_MAIN(tst_QLayout)
 #include "tst_qlayout.moc"
diff --git a/tests/auto/qlistview/tst_qlistview.cpp b/tests/auto/qlistview/tst_qlistview.cpp
index 3ee6889f50..6e211ae045 100644
--- a/tests/auto/qlistview/tst_qlistview.cpp
+++ b/tests/auto/qlistview/tst_qlistview.cpp
@@ -117,6 +117,8 @@ private slots:
     void shiftSelectionWithNonUniformItemSizes();
     void clickOnViewportClearsSelection();
     void task262152_setModelColumnNavigate();
+    void taskQTBUG_2233_scrollHiddenItems_data();
+    void taskQTBUG_2233_scrollHiddenItems();
 };
 
 // Testing get/set functions
@@ -1780,17 +1782,52 @@ void tst_QListView::task262152_setModelColumnNavigate()
     view.setModelColumn(1);
 
     view.show();
-    QTest::qWait(30);
+    QTest::qWait(100);
     QTest::keyClick(&view, Qt::Key_Down);
-    QTest::qWait(10);
+    QTest::qWait(100);
     QCOMPARE(view.currentIndex(), model.index(1,1));
     QTest::keyClick(&view, Qt::Key_Down);
-    QTest::qWait(10);
+    QTest::qWait(100);
     QCOMPARE(view.currentIndex(), model.index(2,1));
 
 }
 
+void tst_QListView::taskQTBUG_2233_scrollHiddenItems_data()
+{
+    QTest::addColumn<int>("flow");
+
+    QTest::newRow("TopToBottom") << static_cast<int>(QListView::TopToBottom);
+    QTest::newRow("LeftToRight") << static_cast<int>(QListView::LeftToRight);
+}
+
+void tst_QListView::taskQTBUG_2233_scrollHiddenItems()
+{
+    QFETCH(int, flow);
+    const int rowCount = 200;
 
+    QListView view;
+    QStringListModel model(&view);
+    QStringList list;
+    for (int i = 0; i < rowCount; ++i)
+        list << QString::fromAscii("Item %1").arg(i);
+
+    model.setStringList(list);
+    view.setModel(&model);
+    view.setViewMode(QListView::ListMode);
+    for (int i = 0; i < rowCount / 2; ++i)
+        view.setRowHidden(2 * i, true);
+    view.setFlow(static_cast<QListView::Flow>(flow));
+    view.resize(130, 130);
+
+    for (int i = 0; i < 10; ++i) {
+        (view.flow() == QListView::TopToBottom
+            ? view.verticalScrollBar()
+            : view.horizontalScrollBar())->setValue(i);
+        QModelIndex index = view.indexAt(QPoint(0,0));
+        QVERIFY(index.isValid());
+        QCOMPARE(index.row(), 2 * i + 1);
+    }
+}
 
 QTEST_MAIN(tst_QListView)
 #include "tst_qlistview.moc"
diff --git a/tests/auto/qpauseanimation/tst_qpauseanimation.cpp b/tests/auto/qpauseanimation/tst_qpauseanimation.cpp
index 62b43c4f0a..b11efa0c8f 100644
--- a/tests/auto/qpauseanimation/tst_qpauseanimation.cpp
+++ b/tests/auto/qpauseanimation/tst_qpauseanimation.cpp
@@ -169,7 +169,7 @@ void tst_QPauseAnimation::noTimerUpdates()
     animation.start();
     QTest::qWait(animation.totalDuration() + 100);
     QVERIFY(animation.state() == QAbstractAnimation::Stopped);
-    QCOMPARE(animation.m_updateCurrentTimeCount, 2);
+    QCOMPARE(animation.m_updateCurrentTimeCount, 1 + loopCount);
 
     timer->setConsistentTiming(false);
 }
@@ -399,6 +399,7 @@ void tst_QPauseAnimation::multipleSequentialGroups()
 void tst_QPauseAnimation::zeroDuration()
 {
     TestablePauseAnimation animation;
+    animation.setDuration(0);
     animation.start();
     QTest::qWait(animation.totalDuration() + 100);
     QVERIFY(animation.state() == QAbstractAnimation::Stopped);
diff --git a/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
index 51ef2dad1a..7dd17e532f 100644
--- a/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
+++ b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
@@ -130,6 +130,7 @@ private slots:
     void valueChanged();
     void twoAnimations();
     void deletedInUpdateCurrentTime();
+    void totalDuration();
 };
 
 tst_QPropertyAnimation::tst_QPropertyAnimation()
@@ -1199,5 +1200,18 @@ void tst_QPropertyAnimation::deletedInUpdateCurrentTime()
     QCOMPARE(o.value(), 1000);
 }
 
+void tst_QPropertyAnimation::totalDuration()
+{
+    QPropertyAnimation anim;
+    QCOMPARE(anim.totalDuration(), 250);
+    anim.setLoopCount(2);
+    QCOMPARE(anim.totalDuration(), 2*250);
+    anim.setLoopCount(-1);
+    QCOMPARE(anim.totalDuration(), -1);
+    anim.setDuration(0);
+    QCOMPARE(anim.totalDuration(), 0);
+}
+
+
 QTEST_MAIN(tst_QPropertyAnimation)
 #include "tst_qpropertyanimation.moc"
diff --git a/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp b/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp
index 320a429d04..44adf7e45d 100644
--- a/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp
+++ b/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp
@@ -317,6 +317,11 @@ public:
     Q_INVOKABLE QObject* myInvokableReturningMyQObjectAsQObject()
         { m_qtFunctionInvoked = 57; return this; }
 
+    Q_INVOKABLE QObjectList findObjects() const
+    {  return findChildren<QObject *>();  }
+    Q_INVOKABLE QList<int> myInvokableNumbers() const
+    {  return QList<int>() << 1 << 2 << 3; }
+
     void emitMySignal()
         { emit mySignal(); }
     void emitMySignalWithIntArg(int arg)
@@ -493,6 +498,7 @@ protected slots:
     }
 
 private slots:
+    void registeredTypes();
     void getSetStaticProperty();
     void getSetDynamicProperty();
     void getSetChildren();
@@ -543,6 +549,24 @@ void tst_QScriptExtQObject::cleanup()
     delete m_myObject;
 }
 
+// this test has to be first and test that some types are automatically registered
+void tst_QScriptExtQObject::registeredTypes()
+{
+    QScriptEngine e;
+    QObject *t = new MyQObject;
+    QObject *c = new QObject(t);
+    c->setObjectName ("child1");
+
+    e.globalObject().setProperty("MyTest", e.newQObject(t));
+
+    QScriptValue v1 = e.evaluate("MyTest.findObjects()[0].objectName;");
+    QCOMPARE(v1.toString(), c->objectName());
+
+    QScriptValue v2 = e.evaluate("MyTest.myInvokableNumbers()");
+    QCOMPARE(qscriptvalue_cast<QList<int> >(v2), (QList<int>() << 1 << 2 << 3));
+}
+
+
 static QScriptValue getSetProperty(QScriptContext *ctx, QScriptEngine *)
 {
     if (ctx->argumentCount() != 0)
diff --git a/tests/auto/qsslsocket/tst_qsslsocket.cpp b/tests/auto/qsslsocket/tst_qsslsocket.cpp
index d57620194e..2bd1684a76 100644
--- a/tests/auto/qsslsocket/tst_qsslsocket.cpp
+++ b/tests/auto/qsslsocket/tst_qsslsocket.cpp
@@ -170,6 +170,7 @@ private slots:
     void setEmptyKey();
     void spontaneousWrite();
     void setReadBufferSize();
+    void setReadBufferSize_task_250027();
     void waitForMinusOne();
     void verifyMode();
     void verifyDepth();
@@ -1241,6 +1242,66 @@ void tst_QSslSocket::setReadBufferSize()
     QVERIFY(receiver->bytesAvailable() > oldBytesAvailable);
 }
 
+class SetReadBufferSize_task_250027_handler : public QObject {
+    Q_OBJECT
+public slots:
+    void readyReadSlot() {
+        QTestEventLoop::instance().exitLoop();
+    }
+    void waitSomeMore(QSslSocket *socket) {
+        QTime t;
+        t.start();
+        while (!socket->encryptedBytesAvailable()) {
+            QCoreApplication::processEvents(QEventLoop::AllEvents | QEventLoop::WaitForMoreEvents, 250);
+            if (t.elapsed() > 1000 || socket->state() != QAbstractSocket::ConnectedState)
+                return;
+        }
+    }
+};
+
+void tst_QSslSocket::setReadBufferSize_task_250027()
+{
+    // do not execute this when a proxy is set.
+    QFETCH_GLOBAL(bool, setProxy);
+    if (setProxy)
+        return;
+
+    QSslSocketPtr socket = newSocket();
+    socket->setReadBufferSize(1000); // limit to 1 kb/sec
+    socket->ignoreSslErrors();
+    socket->connectToHostEncrypted(QtNetworkSettings::serverName(), 443);
+    socket->ignoreSslErrors();
+    QVERIFY(socket->waitForConnected(10*1000));
+    QVERIFY(socket->waitForEncrypted(10*1000));
+
+    // exit the event loop as soon as we receive a readyRead()
+    SetReadBufferSize_task_250027_handler setReadBufferSize_task_250027_handler;
+    connect(socket, SIGNAL(readyRead()), &setReadBufferSize_task_250027_handler, SLOT(readyReadSlot()));
+
+    // provoke a response by sending a request
+    socket->write("GET /gif/fluke.gif HTTP/1.0\n"); // this file is 27 KB
+    socket->write("Host: ");
+    socket->write(QtNetworkSettings::serverName().toLocal8Bit().constData());
+    socket->write("\n");
+    socket->write("Connection: close\n");
+    socket->write("\n");
+    socket->flush();
+
+    QTestEventLoop::instance().enterLoop(10);
+    setReadBufferSize_task_250027_handler.waitSomeMore(socket);
+    QByteArray firstRead = socket->readAll();
+    // First read should be some data, but not the whole file
+    QVERIFY(firstRead.size() > 0 && firstRead.size() < 20*1024);
+
+    QTestEventLoop::instance().enterLoop(10);
+    setReadBufferSize_task_250027_handler.waitSomeMore(socket);
+    QByteArray secondRead = socket->readAll();
+    // second read should be some more data
+    QVERIFY(secondRead.size() > 0);
+
+    socket->close();
+}
+
 class SslServer3 : public QTcpServer
 {
     Q_OBJECT
diff --git a/tests/auto/qtreeview/tst_qtreeview.cpp b/tests/auto/qtreeview/tst_qtreeview.cpp
index 91b2cc5529..da58725c7c 100644
--- a/tests/auto/qtreeview/tst_qtreeview.cpp
+++ b/tests/auto/qtreeview/tst_qtreeview.cpp
@@ -172,6 +172,7 @@ private slots:
     void expandAndCollapse_data();
     void expandAndCollapse();
     void expandAndCollapseAll();
+    void expandWithNoChildren();
     void keyboardNavigation();
     void headerSections();
     void moveCursor_data();
@@ -1548,6 +1549,19 @@ void tst_QTreeView::expandAndCollapseAll()
 //    QCOMPARE(collapsedSpy.count(), count);
 }
 
+void tst_QTreeView::expandWithNoChildren()
+{
+    QTreeView tree;
+    QStandardItemModel model(1,1);
+    tree.setModel(&model);
+    tree.setAnimated(true);
+    tree.doItemsLayout();
+    //this test should not output warnings
+    tree.expand(model.index(0,0));
+}
+
+
+
 void tst_QTreeView::keyboardNavigation()
 {
     const int rows = 10;
diff --git a/tests/manual/gestures/graphicsview/main.cpp b/tests/manual/gestures/graphicsview/main.cpp
index 263a963678..e9065eb0b7 100644
--- a/tests/manual/gestures/graphicsview/main.cpp
+++ b/tests/manual/gestures/graphicsview/main.cpp
@@ -66,11 +66,11 @@ protected:
                 default: qDebug("view: Pan: <unknown state>"); break;
                 }
 
-                const QSizeF offset = pan->offset();
+                const QPointF offset = pan->offset();
                 QScrollBar *vbar = verticalScrollBar();
                 QScrollBar *hbar = horizontalScrollBar();
-                vbar->setValue(vbar->value() - offset.height());
-                hbar->setValue(hbar->value() - offset.width());
+                vbar->setValue(vbar->value() - offset.y());
+                hbar->setValue(hbar->value() - offset.x());
                 ge->accept(pan);
                 return true;
             }
@@ -126,6 +126,8 @@ public:
         scene = new QGraphicsScene(this);
         scene->setSceneRect(-2000, -2000, 4000, 4000);
         view = new QGraphicsView(scene, 0);
+        view->viewport()->grabGesture(Qt::PanGesture);
+        view->viewport()->grabGesture(ThreeFingerSlideGesture::Type);
         QVBoxLayout *l = new QVBoxLayout(this);
         l->addWidget(view);
     }
diff --git a/tests/manual/gestures/graphicsview/mousepangesturerecognizer.cpp b/tests/manual/gestures/graphicsview/mousepangesturerecognizer.cpp
index 0e7f538198..6cdbe12847 100644
--- a/tests/manual/gestures/graphicsview/mousepangesturerecognizer.cpp
+++ b/tests/manual/gestures/graphicsview/mousepangesturerecognizer.cpp
@@ -42,6 +42,8 @@
 #include "mousepangesturerecognizer.h"
 
 #include <QEvent>
+#include <QVariant>
+#include <QGraphicsSceneMouseEvent>
 #include <QMouseEvent>
 #include <QGesture>
 
@@ -57,21 +59,36 @@ QGesture* MousePanGestureRecognizer::createGesture(QObject *)
 QGestureRecognizer::Result MousePanGestureRecognizer::filterEvent(QGesture *state, QObject *, QEvent *event)
 {
     QPanGesture *g = static_cast<QPanGesture *>(state);
-    QMouseEvent *me = static_cast<QMouseEvent *>(event);
+    QPoint globalPos;
+    switch (event->type()) {
+    case QEvent::GraphicsSceneMousePress:
+    case QEvent::GraphicsSceneMouseDoubleClick:
+    case QEvent::GraphicsSceneMouseMove:
+    case QEvent::GraphicsSceneMouseRelease:
+        globalPos = static_cast<QGraphicsSceneMouseEvent *>(event)->screenPos();
+        break;
+    case QEvent::MouseButtonPress:
+    case QEvent::MouseMove:
+    case QEvent::MouseButtonRelease:
+        globalPos = static_cast<QMouseEvent *>(event)->globalPos();
+        break;
+    default:
+        break;
+    }
     if (event->type() == QEvent::MouseButtonPress || event->type() == QEvent::MouseButtonDblClick
         || event->type() == QEvent::GraphicsSceneMousePress || event->type() == QEvent::GraphicsSceneMouseDoubleClick) {
-        g->setHotSpot(me->globalPos());
-        g->setProperty("lastPos", me->globalPos());
+        g->setHotSpot(globalPos);
+        g->setProperty("lastPos", globalPos);
         g->setProperty("pressed", QVariant::fromValue<bool>(true));
         return QGestureRecognizer::GestureTriggered | QGestureRecognizer::ConsumeEventHint;
     } else if (event->type() == QEvent::MouseMove || event->type() == QEvent::GraphicsSceneMouseMove) {
         if (g->property("pressed").toBool()) {
-            QPoint pos = me->globalPos();
+            QPoint pos = globalPos;
             QPoint lastPos = g->property("lastPos").toPoint();
             g->setLastOffset(g->offset());
             lastPos = pos - lastPos;
-            g->setOffset(QSizeF(lastPos.x(), lastPos.y()));
-            g->setTotalOffset(g->totalOffset() + QSizeF(lastPos.x(), lastPos.y()));
+            g->setOffset(QPointF(lastPos.x(), lastPos.y()));
+            g->setTotalOffset(g->totalOffset() + QPointF(lastPos.x(), lastPos.y()));
             g->setProperty("lastPos", pos);
             return QGestureRecognizer::GestureTriggered | QGestureRecognizer::ConsumeEventHint;
         }
@@ -85,9 +102,9 @@ QGestureRecognizer::Result MousePanGestureRecognizer::filterEvent(QGesture *stat
 void MousePanGestureRecognizer::reset(QGesture *state)
 {
     QPanGesture *g = static_cast<QPanGesture *>(state);
-    g->setTotalOffset(QSizeF());
-    g->setLastOffset(QSizeF());
-    g->setOffset(QSizeF());
+    g->setTotalOffset(QPointF());
+    g->setLastOffset(QPointF());
+    g->setOffset(QPointF());
     g->setAcceleration(0);
     g->setProperty("lastPos", QVariant());
     g->setProperty("pressed", QVariant::fromValue<bool>(false));
diff --git a/tests/manual/gestures/scrollarea/main.cpp b/tests/manual/gestures/scrollarea/main.cpp
index 27966370da..f90f6c66e4 100644
--- a/tests/manual/gestures/scrollarea/main.cpp
+++ b/tests/manual/gestures/scrollarea/main.cpp
@@ -87,23 +87,23 @@ protected:
             if (outside)
                 return;
 
-            const QSizeF offset = pan->offset();
-            const QSizeF totalOffset = pan->totalOffset();
+            const QPointF offset = pan->offset();
+            const QPointF totalOffset = pan->totalOffset();
             QScrollBar *vbar = verticalScrollBar();
             QScrollBar *hbar = horizontalScrollBar();
 
-            if ((vbar->value() == vbar->minimum() && totalOffset.height() > 10) ||
-                (vbar->value() == vbar->maximum() && totalOffset.height() < -10)) {
+            if ((vbar->value() == vbar->minimum() && totalOffset.y() > 10) ||
+                (vbar->value() == vbar->maximum() && totalOffset.y() < -10)) {
                 outside = true;
                 return;
             }
-            if ((hbar->value() == hbar->minimum() && totalOffset.width() > 10) ||
-                (hbar->value() == hbar->maximum() && totalOffset.width() < -10)) {
+            if ((hbar->value() == hbar->minimum() && totalOffset.x() > 10) ||
+                (hbar->value() == hbar->maximum() && totalOffset.x() < -10)) {
                 outside = true;
                 return;
             }
-            vbar->setValue(vbar->value() - offset.height());
-            hbar->setValue(hbar->value() - offset.width());
+            vbar->setValue(vbar->value() - offset.y());
+            hbar->setValue(hbar->value() - offset.x());
             event->accept(pan);
         }
     }
@@ -147,28 +147,28 @@ protected:
             event->ignore(pan);
             if (outside)
                 return;
-            const QSizeF offset = pan->offset();
-            const QSizeF totalOffset = pan->totalOffset();
+            const QPointF offset = pan->offset();
+            const QPointF totalOffset = pan->totalOffset();
             if (orientation() == Qt::Horizontal) {
-                if ((value() == minimum() && totalOffset.width() < -10) ||
-                    (value() == maximum() && totalOffset.width() > 10)) {
+                if ((value() == minimum() && totalOffset.x() < -10) ||
+                    (value() == maximum() && totalOffset.x() > 10)) {
                     outside = true;
                     return;
                 }
-                if (totalOffset.height() < 40 && totalOffset.height() > -40) {
-                    setValue(value() + offset.width());
+                if (totalOffset.y() < 40 && totalOffset.y() > -40) {
+                    setValue(value() + offset.x());
                     event->accept(pan);
                 } else {
                     outside = true;
                 }
             } else if (orientation() == Qt::Vertical) {
-                if ((value() == maximum() && totalOffset.height() < -10) ||
-                    (value() == minimum() && totalOffset.height() > 10)) {
+                if ((value() == maximum() && totalOffset.y() < -10) ||
+                    (value() == minimum() && totalOffset.y() > 10)) {
                     outside = true;
                     return;
                 }
-                if (totalOffset.width() < 40 && totalOffset.width() > -40) {
-                    setValue(value() - offset.height());
+                if (totalOffset.x() < 40 && totalOffset.x() > -40) {
+                    setValue(value() - offset.y());
                     event->accept(pan);
                 } else {
                     outside = true;
diff --git a/tests/manual/gestures/scrollarea/mousepangesturerecognizer.cpp b/tests/manual/gestures/scrollarea/mousepangesturerecognizer.cpp
index 79b633e0d3..5f94dbc862 100644
--- a/tests/manual/gestures/scrollarea/mousepangesturerecognizer.cpp
+++ b/tests/manual/gestures/scrollarea/mousepangesturerecognizer.cpp
@@ -69,8 +69,8 @@ QGestureRecognizer::Result MousePanGestureRecognizer::filterEvent(QGesture *stat
             QPoint lastPos = g->property("lastPos").toPoint();
             g->setLastOffset(g->offset());
             lastPos = pos - lastPos;
-            g->setOffset(QSizeF(lastPos.x(), lastPos.y()));
-            g->setTotalOffset(g->totalOffset() + QSizeF(lastPos.x(), lastPos.y()));
+            g->setOffset(QPointF(lastPos.x(), lastPos.y()));
+            g->setTotalOffset(g->totalOffset() + QPointF(lastPos.x(), lastPos.y()));
             g->setProperty("lastPos", pos);
             return QGestureRecognizer::GestureTriggered | QGestureRecognizer::ConsumeEventHint;
         }
@@ -84,9 +84,9 @@ QGestureRecognizer::Result MousePanGestureRecognizer::filterEvent(QGesture *stat
 void MousePanGestureRecognizer::reset(QGesture *state)
 {
     QPanGesture *g = static_cast<QPanGesture *>(state);
-    g->setTotalOffset(QSizeF());
-    g->setLastOffset(QSizeF());
-    g->setOffset(QSizeF());
+    g->setTotalOffset(QPointF());
+    g->setLastOffset(QPointF());
+    g->setOffset(QPointF());
     g->setAcceleration(0);
     g->setProperty("lastPos", QVariant());
     g->setProperty("pressed", QVariant::fromValue<bool>(false));