Merge remote-tracking branch 'origin/5.4' into dev

Conflicts:
	src/gui/text/qfontdatabase.cpp

Change-Id: I6ac1f55faa22b8e7b591386fb67f0333d0ea443d

17 files changed, 763 insertions, 6 deletions

diff --git a/tests/auto/widgets/dialogs/qfontdialog/qfontdialog.pro b/tests/auto/widgets/dialogs/qfontdialog/qfontdialog.pro
index 8116fe379a..dc1702971e 100644
--- a/tests/auto/widgets/dialogs/qfontdialog/qfontdialog.pro
+++ b/tests/auto/widgets/dialogs/qfontdialog/qfontdialog.pro
@@ -7,6 +7,8 @@ QT += core-private gui-private
 
 SOURCES  += tst_qfontdialog.cpp
 
+RESOURCES += testfonts.qrc
+
 mac {
 #    ### fixme
 #    OBJECTIVE_SOURCES += tst_qfontdialog_mac_helpers.mm
diff --git a/tests/auto/widgets/dialogs/qfontdialog/testfonts.qrc b/tests/auto/widgets/dialogs/qfontdialog/testfonts.qrc
new file mode 100644
index 0000000000..cdfa287b39
--- /dev/null
+++ b/tests/auto/widgets/dialogs/qfontdialog/testfonts.qrc
@@ -0,0 +1,6 @@
+<RCC>
+    <qresource prefix="/">
+        <file alias="test.ttf">../../../shared/resources/test.ttf</file>
+        <file alias="testfont.ttf">../../../shared/resources/testfont.ttf</file>
+    </qresource>
+</RCC>
diff --git a/tests/auto/widgets/dialogs/qfontdialog/tst_qfontdialog.cpp b/tests/auto/widgets/dialogs/qfontdialog/tst_qfontdialog.cpp
index 22c84c2244..92ea7e5e57 100644
--- a/tests/auto/widgets/dialogs/qfontdialog/tst_qfontdialog.cpp
+++ b/tests/auto/widgets/dialogs/qfontdialog/tst_qfontdialog.cpp
@@ -36,6 +36,7 @@
 
 
 #include <qapplication.h>
+#include <qfontdatabase.h>
 #include <qfontinfo.h>
 #include <qtimer.h>
 #include <qmainwindow.h>
@@ -70,6 +71,10 @@ private slots:
     void setFont();
     void task256466_wrongStyle();
     void setNonStandardFontSize();
+#ifndef QT_NO_STYLE_STYLESHEET
+    void qtbug_41513_stylesheetStyle();
+#endif
+
 
 private:
     void runSlotWithFailsafeTimer(const char *member);
@@ -201,6 +206,31 @@ void tst_QFontDialog::setNonStandardFontSize()
 {
     runSlotWithFailsafeTimer(SLOT(testNonStandardFontSize()));
 }
+#ifndef QT_NO_STYLE_STYLESHEET
+static const QString offendingStyleSheet = QStringLiteral("* { font-family: \"QtBidiTestFont\"; }");
+
+void tst_QFontDialog::qtbug_41513_stylesheetStyle()
+{
+    if (QFontDatabase::addApplicationFont(QFINDTESTDATA("test.ttf")) < 0)
+        QSKIP("Test fonts not found.");
+    if (QFontDatabase::addApplicationFont(QFINDTESTDATA("testfont.ttf")) < 0)
+        QSKIP("Test fonts not found.");
+    QFont testFont = QFont(QStringLiteral("QtsSpecialTestFont"));
+    qApp->setStyleSheet(offendingStyleSheet);
+    bool accepted = false;
+    QTimer::singleShot(2000, this, SLOT(postKeyReturn()));
+    QFont resultFont = QFontDialog::getFont(&accepted, testFont,
+        QApplication::activeWindow(),
+        QLatin1String("QFontDialog - Stylesheet Test"),
+        QFontDialog::DontUseNativeDialog);
+    QVERIFY(accepted);
+
+    QCOMPARE(resultFont, testFont);
+
+    // reset stylesheet
+    qApp->setStyleSheet(QString());
+}
+#endif // QT_NO_STYLE_STYLESHEET
 
 void tst_QFontDialog::testNonStandardFontSize()
 {
diff --git a/tests/auto/widgets/gestures/gestures.pro b/tests/auto/widgets/gestures/gestures.pro
new file mode 100644
index 0000000000..5a87a01ee2
--- /dev/null
+++ b/tests/auto/widgets/gestures/gestures.pro
@@ -0,0 +1,6 @@
+TEMPLATE=subdirs
+SUBDIRS=\
+   qgesturerecognizer \
+
+mac: SUBDIRS -= \ # Uses native recognizers
+   qgesturerecognizer \
diff --git a/tests/auto/widgets/gestures/qgesturerecognizer/qgesturerecognizer.pro b/tests/auto/widgets/gestures/qgesturerecognizer/qgesturerecognizer.pro
new file mode 100644
index 0000000000..7c9ddcfb03
--- /dev/null
+++ b/tests/auto/widgets/gestures/qgesturerecognizer/qgesturerecognizer.pro
@@ -0,0 +1,4 @@
+CONFIG += testcase
+TARGET = tst_qgesturerecognizer
+QT +=  widgets testlib gui-private core-private
+SOURCES += tst_qgesturerecognizer.cpp
diff --git a/tests/auto/widgets/gestures/qgesturerecognizer/tst_qgesturerecognizer.cpp b/tests/auto/widgets/gestures/qgesturerecognizer/tst_qgesturerecognizer.cpp
new file mode 100644
index 0000000000..833494f25e
--- /dev/null
+++ b/tests/auto/widgets/gestures/qgesturerecognizer/tst_qgesturerecognizer.cpp
@@ -0,0 +1,336 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia. For licensing terms and
+** conditions see http://qt.digia.com/licensing. For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** 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 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights. These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QTest>
+#include <QtWidgets/QApplication>
+#include <QtWidgets/QWidget>
+#include <QtWidgets/QGestureEvent>
+#include <QtGui/QScreen>
+#include <QtGui/QTouchDevice>
+#include <QtCore/QVector>
+#include <QtCore/QString>
+#include <QtCore/QHash>
+#include <QtCore/QDebug>
+
+#include <qpa/qwindowsysteminterface.h>
+
+class tst_QGestureRecognizer : public QObject
+{
+    Q_OBJECT
+public:
+    tst_QGestureRecognizer();
+
+private Q_SLOTS:
+    void initTestCase();
+#ifndef QT_NO_GESTURES
+    void panGesture_data();
+    void panGesture();
+    void pinchGesture_data();
+    void pinchGesture();
+    void swipeGesture_data();
+    void swipeGesture();
+#endif // !QT_NO_GESTURES
+
+private:
+    const int m_fingerDistance;
+    QTouchDevice *m_touchDevice;
+};
+
+tst_QGestureRecognizer::tst_QGestureRecognizer()
+    : m_fingerDistance(qRound(QGuiApplication::primaryScreen()->physicalDotsPerInch() / 2.0))
+    , m_touchDevice(new QTouchDevice)
+{
+}
+
+void tst_QGestureRecognizer::initTestCase()
+{
+    m_touchDevice->setType(QTouchDevice::TouchScreen);
+    QWindowSystemInterface::registerTouchDevice(m_touchDevice);
+}
+
+#ifndef QT_NO_GESTURES
+
+typedef QVector<Qt::GestureType> GestureTypeVector;
+
+class TestWidget : public QWidget
+{
+public:
+    explicit TestWidget(const GestureTypeVector &gestureTypes);
+
+    bool gestureReceived(Qt::GestureType gestureType) const
+        { return m_receivedGestures.value(gestureType); }
+
+protected:
+    bool event(QEvent * event) Q_DECL_OVERRIDE;
+
+private:
+    typedef QHash<Qt::GestureType, bool> GestureTypeHash;
+    GestureTypeHash m_receivedGestures;
+};
+
+TestWidget::TestWidget(const GestureTypeVector &gestureTypes)
+{
+    setAttribute(Qt::WA_AcceptTouchEvents);
+
+    foreach (Qt::GestureType gestureType, gestureTypes) {
+        grabGesture(gestureType);
+        m_receivedGestures.insert(gestureType, false);
+    }
+
+    const QRect geometry = QGuiApplication::primaryScreen()->availableGeometry();
+    const QSize size = geometry.size() / 2;
+    resize(size);
+    move(geometry.center() - QPoint(size.width() / 2, size.height() / 2));
+}
+
+bool TestWidget::event(QEvent * event)
+{
+    switch (event->type()) {
+    case QEvent::Gesture: {
+        const QGestureEvent *gestureEvent = static_cast<QGestureEvent *>(event);
+        const GestureTypeHash::iterator hend = m_receivedGestures.end();
+        for (GestureTypeHash::iterator it = m_receivedGestures.begin(); it != hend; ++it) {
+            if (const QGesture *gesture = gestureEvent->gesture(it.key())) {
+                if (gesture->state() == Qt::GestureFinished)
+                    it.value() = true;
+            }
+        }
+    }
+        break;
+    default:
+        break;
+    }
+    return QWidget::event(event);
+}
+
+static void pressSequence(QTest::QTouchEventSequence &sequence,
+                          QVector<QPoint> &points,
+                          QWidget *widget)
+{
+    const int pointCount = points.size();
+    for (int p = 0; p < pointCount; ++p)
+        sequence.press(p, points.at(p), widget);
+    sequence.commit();
+}
+
+static void linearSequence(int n, const QPoint &delta,
+                           QTest::QTouchEventSequence &sequence,
+                           QVector<QPoint> &points,
+                           QWidget *widget)
+{
+    const int pointCount = points.size();
+    for (int s = 0; s < n; ++s) {
+        for (int p = 0; p < pointCount; ++p) {
+            points[p] += delta;
+            sequence.move(p, points[p], widget);
+        }
+        sequence.commit();
+    }
+}
+
+static void releaseSequence(QTest::QTouchEventSequence &sequence,
+                            QVector<QPoint> &points,
+                            QWidget *widget)
+{
+    const int pointCount = points.size();
+    for (int p = 0; p < pointCount; ++p)
+        sequence.release(p, points[p], widget);
+    sequence.commit();
+}
+
+// --- Pan
+
+enum PanSubTest {
+    TwoFingerPanSubTest
+};
+
+void tst_QGestureRecognizer::panGesture_data()
+{
+    QTest::addColumn<int>("panSubTest");
+    QTest::addColumn<bool>("gestureExpected");
+    QTest::newRow("Two finger") << int(TwoFingerPanSubTest) << true;
+}
+
+void tst_QGestureRecognizer::panGesture()
+{
+    QFETCH(int, panSubTest);
+    QFETCH(bool, gestureExpected);
+
+    Q_UNUSED(panSubTest) // Single finger pan will be added later.
+
+    const int panPoints = 2;
+    const Qt::GestureType gestureType = Qt::PanGesture;
+    TestWidget widget(GestureTypeVector(1, gestureType));
+    widget.setWindowTitle(QTest::currentTestFunction());
+    widget.show();
+    QVERIFY(QTest::qWaitForWindowExposed(&widget));
+
+    QVector<QPoint> points;
+    for (int i = 0; i < panPoints; ++i)
+        points.append(QPoint(10 + i *20, 10 + i *20));
+
+    QTest::QTouchEventSequence panSequence = QTest::touchEvent(&widget, m_touchDevice);
+    pressSequence(panSequence, points, &widget);
+    linearSequence(5, QPoint(20, 20), panSequence, points, &widget);
+    releaseSequence(panSequence, points, &widget);
+
+    if (gestureExpected) {
+        QTRY_VERIFY(widget.gestureReceived(gestureType));
+    } else {
+        QCoreApplication::processEvents();
+        QVERIFY(!widget.gestureReceived(gestureType));
+    }
+}
+
+// --- Pinch
+
+enum PinchSubTest {
+    StandardPinchSubTest
+};
+
+void tst_QGestureRecognizer::pinchGesture_data()
+{
+    QTest::addColumn<int>("pinchSubTest");
+    QTest::addColumn<bool>("gestureExpected");
+    QTest::newRow("Standard") << int(StandardPinchSubTest) << true;
+}
+
+void tst_QGestureRecognizer::pinchGesture()
+{
+    QFETCH(int, pinchSubTest);
+    QFETCH(bool, gestureExpected);
+
+    Q_UNUSED(pinchSubTest)
+
+    const Qt::GestureType gestureType = Qt::PinchGesture;
+    TestWidget widget(GestureTypeVector(1, gestureType));
+    widget.setWindowTitle(QTest::currentTestFunction());
+    widget.show();
+    QVERIFY(QTest::qWaitForWindowExposed(&widget));
+
+    QVector<QPoint> points;
+    points.append(widget.rect().center());
+    points.append(points.front() + QPoint(0, 20));
+
+    QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(&widget, m_touchDevice);
+    pressSequence(pinchSequence, points, &widget);
+
+    for (int s = 0; s < 5; ++s) {
+        points[0] += QPoint(5, 30);
+        pinchSequence.move(0, points[0], &widget);
+        points[1] += QPoint(5, -30);
+        pinchSequence.move(1, points[1], &widget);
+        pinchSequence.commit();
+    }
+
+    releaseSequence(pinchSequence, points, &widget);
+
+    if (gestureExpected) {
+        QTRY_VERIFY(widget.gestureReceived(gestureType));
+    } else {
+        QCoreApplication::processEvents();
+        QVERIFY(!widget.gestureReceived(gestureType));
+    }
+}
+
+// --- Swipe
+
+enum SwipeSubTest {
+    SwipeLineSubTest,
+    SwipeChangeDirectionSubTest,
+};
+
+void tst_QGestureRecognizer::swipeGesture_data()
+{
+    QTest::addColumn<int>("swipeSubTest");
+    QTest::addColumn<bool>("gestureExpected");
+    QTest::newRow("Line") << int(SwipeLineSubTest) << true;
+    QTest::newRow("ChangeDirection") << int(SwipeChangeDirectionSubTest) << false;
+}
+
+void tst_QGestureRecognizer::swipeGesture()
+{
+    enum { swipePoints = 3 };
+
+    QFETCH(int, swipeSubTest);
+    QFETCH(bool, gestureExpected);
+
+    const Qt::GestureType gestureType = Qt::SwipeGesture;
+    TestWidget widget(GestureTypeVector(1, gestureType));
+    widget.setWindowTitle(QTest::currentTestFunction());
+    widget.show();
+    QVERIFY(QTest::qWaitForWindowExposed(&widget));
+
+    // Start a swipe sequence with 2 points (QTBUG-15768)
+    const QPoint fingerDistance(m_fingerDistance, m_fingerDistance);
+    QVector<QPoint> points;
+    for (int i = 0; i < swipePoints - 1; ++i)
+        points.append(fingerDistance + i * fingerDistance);
+
+    QTest::QTouchEventSequence swipeSequence = QTest::touchEvent(&widget, m_touchDevice);
+    pressSequence(swipeSequence, points, &widget);
+
+    // Press point #3
+    points.append(points.last() + fingerDistance);
+    swipeSequence.press(points.size() - 1, points.last(), &widget);
+    swipeSequence.commit();
+    Q_ASSERT(points.size() == swipePoints);
+
+    // Move.
+    const QPoint moveDelta(60, 20);
+    switch (swipeSubTest) {
+    case SwipeLineSubTest:
+        linearSequence(5, moveDelta, swipeSequence, points, &widget);
+        break;
+    case SwipeChangeDirectionSubTest:
+        linearSequence(5, moveDelta, swipeSequence, points, &widget);
+        linearSequence(3, QPoint(-moveDelta.x(), moveDelta.y()), swipeSequence, points, &widget);
+        break;
+    }
+
+    releaseSequence(swipeSequence, points, &widget);
+
+    if (gestureExpected) {
+        QTRY_VERIFY(widget.gestureReceived(gestureType));
+    } else {
+        QCoreApplication::processEvents();
+        QVERIFY(!widget.gestureReceived(gestureType));
+    }
+}
+
+#endif // !QT_NO_GESTURES
+
+QTEST_MAIN(tst_QGestureRecognizer)
+
+#include "tst_qgesturerecognizer.moc"
diff --git a/tests/auto/widgets/graphicsview/qgraphicsgridlayout/tst_qgraphicsgridlayout.cpp b/tests/auto/widgets/graphicsview/qgraphicsgridlayout/tst_qgraphicsgridlayout.cpp
index c90c431d8b..3b55fcd5fc 100644
--- a/tests/auto/widgets/graphicsview/qgraphicsgridlayout/tst_qgraphicsgridlayout.cpp
+++ b/tests/auto/widgets/graphicsview/qgraphicsgridlayout/tst_qgraphicsgridlayout.cpp
@@ -124,6 +124,7 @@ private slots:
     void heightForWidthWithSpanning();
     void stretchAndHeightForWidth();
     void testDefaultAlignment();
+    void hiddenItems();
 };
 
 class RectWidget : public QGraphicsWidget
@@ -3485,6 +3486,94 @@ void tst_QGraphicsGridLayout::testDefaultAlignment()
     QCOMPARE(w->geometry(), QRectF(0,0,50,50));
     QCOMPARE(w2->geometry(), QRectF(0,50,100,100));
 }
+
+static RectWidget *addWidget(QGraphicsGridLayout *grid, int row, int column)
+{
+    RectWidget *w = new RectWidget;
+    w->setPreferredSize(20, 20);
+    grid->addItem(w, row, column);
+    return w;
+}
+
+static void setVisible(bool visible, QGraphicsWidget **widgets)
+{
+    for (int i = 0; i < 3; ++i)
+        if (widgets[i]) widgets[i]->setVisible(visible);
+}
+
+static void setRetainSizeWhenHidden(bool retainSize, QGraphicsWidget **widgets)
+{
+    QSizePolicy sp = widgets[0]->sizePolicy();
+    sp.setRetainSizeWhenHidden(retainSize);
+    for (int i = 0; i < 3; ++i)
+        if (widgets[i]) widgets[i]->setSizePolicy(sp);
+}
+
+void tst_QGraphicsGridLayout::hiddenItems()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsGridLayout *layout = new QGraphicsGridLayout(widget);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(2);
+
+    // Create a 3x3 layout
+    addWidget(layout, 0, 0);
+    RectWidget *w01 = addWidget(layout, 0, 1);
+    addWidget(layout, 0, 2);
+    RectWidget *w10 = addWidget(layout, 1, 0);
+    RectWidget *w11 = addWidget(layout, 1, 1);
+    RectWidget *w12 = addWidget(layout, 1, 2);
+    addWidget(layout, 2, 0);
+    RectWidget *w21 = addWidget(layout, 2, 1);
+    addWidget(layout, 2, 2);
+
+    QGraphicsWidget *middleColumn[] = {w01, w11, w21 };
+    QGraphicsWidget *topTwoOfMiddleColumn[] = {w01, w11, 0 };
+
+    // hide and show middle column
+    QCOMPARE(layout->preferredWidth(), qreal(64));
+    setVisible(false, middleColumn);   // hide middle column
+    QCOMPARE(layout->preferredWidth(), qreal(42));
+    setVisible(true, middleColumn);    // show middle column
+    QCOMPARE(layout->preferredWidth(), qreal(64));
+    setRetainSizeWhenHidden(true, middleColumn);
+    QCOMPARE(layout->preferredWidth(), qreal(64));
+    setVisible(false, middleColumn);   // hide middle column
+    QCOMPARE(layout->preferredWidth(), qreal(64));
+    setRetainSizeWhenHidden(false, middleColumn);
+    QCOMPARE(layout->preferredWidth(), qreal(42));
+    setVisible(true, middleColumn);
+    QCOMPARE(layout->preferredWidth(), qreal(64));
+
+    // Hide only two items, => column should not collapse
+    setVisible(false, topTwoOfMiddleColumn);
+    QCOMPARE(layout->preferredWidth(), qreal(64));
+
+
+    QGraphicsWidget *middleRow[] = {w10, w11, w12 };
+    QGraphicsWidget *leftMostTwoOfMiddleRow[] = {w10, w11, 0 };
+
+    // hide and show middle row
+    QCOMPARE(layout->preferredHeight(), qreal(64));
+    setVisible(false, middleRow);
+    QCOMPARE(layout->preferredHeight(), qreal(42));
+    setVisible(true, middleRow);
+    QCOMPARE(layout->preferredHeight(), qreal(64));
+    setRetainSizeWhenHidden(true, middleColumn);
+    QCOMPARE(layout->preferredHeight(), qreal(64));
+    setVisible(false, middleRow);
+    QCOMPARE(layout->preferredHeight(), qreal(64));
+    setRetainSizeWhenHidden(false, middleRow);
+    QCOMPARE(layout->preferredHeight(), qreal(42));
+    setVisible(true, middleRow);
+    QCOMPARE(layout->preferredHeight(), qreal(64));
+
+    // Hide only two items => row should not collapse
+    setVisible(false, leftMostTwoOfMiddleRow);
+    QCOMPARE(layout->preferredHeight(), qreal(64));
+
+}
+
 QTEST_MAIN(tst_QGraphicsGridLayout)
 #include "tst_qgraphicsgridlayout.moc"
 
diff --git a/tests/auto/widgets/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp b/tests/auto/widgets/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp
index d35667f215..107e3eb48a 100644
--- a/tests/auto/widgets/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp
+++ b/tests/auto/widgets/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp
@@ -50,6 +50,7 @@ private slots:
     void compressLayoutRequest();
     void automaticReparenting();
     void verifyActivate();
+    void sizeHintOfHiddenLayout();
     void invalidate();
     void constructors();
     void alternativeLayoutItems();
@@ -279,6 +280,30 @@ void tst_QGraphicsLayout::verifyActivate()
 
 }
 
+
+void tst_QGraphicsLayout::sizeHintOfHiddenLayout()
+{
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    QGraphicsWidget *window = new QGraphicsWidget(0, Qt::Window);
+    scene.addItem(window);
+    TestLayout *lout = new TestLayout(window);
+    lout->setContentsMargins(1,2,2,1);
+    QGraphicsWidget *w = new QGraphicsWidget;
+    w->setPreferredSize(20, 20);
+    w->setMaximumSize(50, 50);
+    lout->addItem(w);
+    window->setLayout(lout);
+
+    for (int pass = 0; pass < 3; ++pass) {
+        QCOMPARE(lout->sizeHint(Qt::MinimumSize), QSizeF(3,3));
+        QCOMPARE(lout->sizeHint(Qt::PreferredSize), QSizeF(23,23));
+        QCOMPARE(lout->sizeHint(Qt::MaximumSize), QSizeF(53,53));
+        window->setVisible(pass % 2);
+    }
+}
+
 static void clearAllCounters(TestGraphicsWidget *widget)
 {
     if (!widget)
diff --git a/tests/auto/widgets/graphicsview/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp b/tests/auto/widgets/graphicsview/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp
index 7147bb8cce..1513abf0b1 100644
--- a/tests/auto/widgets/graphicsview/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp
+++ b/tests/auto/widgets/graphicsview/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp
@@ -103,6 +103,7 @@ private slots:
     void testOffByOneInLargerLayout();
     void testDefaultAlignment();
     void combineSizePolicies();
+    void hiddenItems();
 
     // Task specific tests
     void task218400_insertStretchCrash();
@@ -1721,6 +1722,41 @@ void tst_QGraphicsLinearLayout::combineSizePolicies()
     QCOMPARE(layout->maximumHeight(), qreal(200));
 }
 
+void tst_QGraphicsLinearLayout::hiddenItems()
+{
+    QGraphicsWidget *widget = new QGraphicsWidget;
+    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Horizontal, widget);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(2);
+
+    RectWidget *w1 = new RectWidget;
+    w1->setPreferredSize(QSizeF(20, 20));
+    layout->addItem(w1);
+
+    RectWidget *w2 = new RectWidget;
+    w2->setPreferredSize(QSizeF(20, 20));
+    layout->addItem(w2);
+
+    RectWidget *w3 = new RectWidget;
+    w3->setPreferredSize(QSizeF(20, 20));
+    layout->addItem(w3);
+
+    QCOMPARE(layout->preferredWidth(), qreal(64));
+    w2->hide();
+    QCOMPARE(layout->preferredWidth(), qreal(42));
+    w2->show();
+    QCOMPARE(layout->preferredWidth(), qreal(64));
+    QSizePolicy sp = w2->sizePolicy();
+    sp.setRetainSizeWhenHidden(true);
+    w2->setSizePolicy(sp);
+    QCOMPARE(layout->preferredWidth(), qreal(64));
+    w2->hide();
+    QCOMPARE(layout->preferredWidth(), qreal(64));
+    sp.setRetainSizeWhenHidden(false);
+    w2->setSizePolicy(sp);
+    QCOMPARE(layout->preferredWidth(), qreal(42));
+}
+
 QTEST_MAIN(tst_QGraphicsLinearLayout)
 #include "tst_qgraphicslinearlayout.moc"
 
diff --git a/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp b/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
index ab84c9e482..66d0f64ceb 100644
--- a/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
+++ b/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
@@ -174,6 +174,7 @@ private slots:
     void clickFocus();
     void windowFrameMargins();
     void QTBUG_6986_sendMouseEventToAlienWidget();
+    void mapToGlobal();
 };
 
 // Subclass that exposes the protected functions.
@@ -3659,5 +3660,32 @@ void tst_QGraphicsProxyWidget::QTBUG_6986_sendMouseEventToAlienWidget()
     QTRY_COMPARE(scene.hoverButton->hoverLeaveReceived, true);
 }
 
+void tst_QGraphicsProxyWidget::mapToGlobal() // QTBUG-41135
+{
+    const QRect availableGeometry = QGuiApplication::primaryScreen()->availableGeometry();
+    const QSize size = availableGeometry.size() / 5;
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+    view.setWindowTitle(QTest::currentTestFunction());
+    view.resize(size);
+    view.move(availableGeometry.bottomRight() - QPoint(size.width(), size.height()) - QPoint(100, 100));
+    QWidget *embeddedWidget = new QWidget;
+    embeddedWidget->setFixedSize(size / 2);
+    scene.addWidget(embeddedWidget);
+    QApplication::setActiveWindow(&view);
+    view.show();
+    QVERIFY(QTest::qWaitForWindowExposed(&view));
+    const QPoint embeddedCenter = embeddedWidget->geometry().center();
+    const QPoint embeddedCenterGlobal = embeddedWidget->mapToGlobal(embeddedCenter);
+    QCOMPARE(embeddedWidget->mapFromGlobal(embeddedCenterGlobal), embeddedCenter);
+    // This should be equivalent to the view center give or take rounding
+    // errors due to odd window margins
+    const QPoint viewCenter = view.geometry().center();
+    QVERIFY2((viewCenter - embeddedCenterGlobal).manhattanLength() <= 2,
+             qPrintable(QStringLiteral("%1, %2 != %3, %4")
+                        .arg(viewCenter.x()).arg(viewCenter.y())
+                        .arg(embeddedCenterGlobal.x()).arg(embeddedCenterGlobal.y())));
+}
+
 QTEST_MAIN(tst_QGraphicsProxyWidget)
 #include "tst_qgraphicsproxywidget.moc"
diff --git a/tests/auto/widgets/graphicsview/qgraphicsscene/tst_qgraphicsscene.cpp b/tests/auto/widgets/graphicsview/qgraphicsscene/tst_qgraphicsscene.cpp
index 70448f9813..bd1c6a0dc5 100644
--- a/tests/auto/widgets/graphicsview/qgraphicsscene/tst_qgraphicsscene.cpp
+++ b/tests/auto/widgets/graphicsview/qgraphicsscene/tst_qgraphicsscene.cpp
@@ -242,6 +242,7 @@ private slots:
     void style();
     void sorting_data();
     void sorting();
+    void insertionOrder();
     void changedSignal_data();
     void changedSignal();
     void stickyFocus_data();
@@ -3633,6 +3634,42 @@ void tst_QGraphicsScene::sorting()
              << t_1);
 }
 
+void tst_QGraphicsScene::insertionOrder()
+{
+    QGraphicsScene scene;
+    const int numItems = 5;
+    QList<QGraphicsItem*> items;
+
+    for (int i = 0; i < numItems; ++i) {
+        QGraphicsRectItem* item = new QGraphicsRectItem(i * 20, i * 20, 200, 200);
+        item->setData(0, i);
+        items.append(item);
+        scene.addItem(item);
+    }
+
+    {
+        QList<QGraphicsItem*> itemList = scene.items();
+        QCOMPARE(itemList.count(), numItems);
+        for (int i = 0; i < itemList.count(); ++i) {
+            QCOMPARE(numItems-1-i, itemList.at(i)->data(0).toInt());
+        }
+    }
+
+    for (int i = 0; i < items.size(); ++i)
+    {
+        scene.removeItem(items.at(i));
+        scene.addItem(items.at(i));
+    }
+
+    {
+        QList<QGraphicsItem*> itemList = scene.items();
+        QCOMPARE(itemList.count(), numItems);
+        for (int i = 0; i < itemList.count(); ++i) {
+            QCOMPARE(numItems-1-i, itemList.at(i)->data(0).toInt());
+        }
+    }
+}
+
 class ChangedListener : public QObject
 {
     Q_OBJECT
diff --git a/tests/auto/widgets/graphicsview/qgraphicsview/tst_qgraphicsview.cpp b/tests/auto/widgets/graphicsview/qgraphicsview/tst_qgraphicsview.cpp
index d38bb86487..afd8be71e8 100644
--- a/tests/auto/widgets/graphicsview/qgraphicsview/tst_qgraphicsview.cpp
+++ b/tests/auto/widgets/graphicsview/qgraphicsview/tst_qgraphicsview.cpp
@@ -160,6 +160,7 @@ private slots:
     void dragMode_scrollHand();
     void dragMode_rubberBand();
     void rubberBandSelectionMode();
+    void rotated_rubberBand();
     void backgroundBrush();
     void foregroundBrush();
     void matrix();
@@ -935,6 +936,48 @@ void tst_QGraphicsView::rubberBandSelectionMode()
     QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>() << rect);
 }
 
+void tst_QGraphicsView::rotated_rubberBand()
+{
+    QWidget toplevel;
+    setFrameless(&toplevel);
+
+    QGraphicsScene scene;
+    const int dim = 3;
+    for (int i = 0; i < dim; i++) {
+        for (int j = 0; j < dim; j ++) {
+            QGraphicsRectItem *rect = new QGraphicsRectItem(i * 20, j * 20, 10, 10);
+            rect->setFlag(QGraphicsItem::ItemIsSelectable);
+            rect->setData(0, (i == j));
+            scene.addItem(rect);
+        }
+    }
+
+    QGraphicsView view(&scene, &toplevel);
+    QCOMPARE(view.rubberBandSelectionMode(), Qt::IntersectsItemShape);
+    view.setDragMode(QGraphicsView::RubberBandDrag);
+    view.resize(120, 120);
+    view.rotate(45);
+    toplevel.show();
+    QVERIFY(QTest::qWaitForWindowExposed(&toplevel));
+
+    // Disable mouse tracking to prevent the window system from sending mouse
+    // move events to the viewport while we are synthesizing events. If
+    // QGraphicsView gets a mouse move event with no buttons down, it'll
+    // terminate the rubber band.
+    view.viewport()->setMouseTracking(false);
+
+    QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>());
+    int midWidth = view.viewport()->width() / 2;
+    sendMousePress(view.viewport(), QPoint(midWidth - 2, 0), Qt::LeftButton);
+    sendMouseMove(view.viewport(), QPoint(midWidth + 2, view.viewport()->height()),
+                  Qt::LeftButton, Qt::LeftButton);
+    QCOMPARE(scene.selectedItems().count(), dim);
+    foreach (const QGraphicsItem *item, scene.items()) {
+        QCOMPARE(item->isSelected(), item->data(0).toBool());
+    }
+    sendMouseRelease(view.viewport(), QPoint(), Qt::LeftButton);
+}
+
 void tst_QGraphicsView::backgroundBrush()
 {
     QGraphicsScene scene;
diff --git a/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp b/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
index ec3e8ece6a..44d7671ca3 100644
--- a/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
+++ b/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
@@ -55,6 +55,7 @@
 #include <qmainwindow.h>
 #include <qdockwidget.h>
 #include <qtoolbar.h>
+#include <qtoolbutton.h>
 #include <QtGui/qpaintengine.h>
 #include <QtGui/qbackingstore.h>
 #include <QtGui/qguiapplication.h>
@@ -268,6 +269,7 @@ private slots:
     void winIdChangeEvent();
     void persistentWinId();
     void showNativeChild();
+    void transientParent();
     void qobject_castInDestroyedSlot();
 
     void showHideEvent_data();
@@ -3992,6 +3994,21 @@ void tst_QWidget::persistentWinId()
     QCOMPARE(w3->winId(), winId3);
 }
 
+void tst_QWidget::transientParent()
+{
+    QWidget topLevel;
+    topLevel.setGeometry(QRect(m_availableTopLeft + QPoint(100, 100), m_testWidgetSize));
+    topLevel.setWindowTitle(__FUNCTION__);
+    QWidget *child = new QWidget(&topLevel);
+    QMenu *menu = new QMenu(child); // QTBUG-41898: Use top level as transient parent for native widgets as well.
+    QToolButton *toolButton = new QToolButton(child);
+    toolButton->setMenu(menu);
+    toolButton->winId();
+    topLevel.show();
+    QVERIFY(QTest::qWaitForWindowExposed(&topLevel));
+    QCOMPARE(menu->windowHandle()->transientParent(), topLevel.windowHandle());
+}
+
 void tst_QWidget::showNativeChild()
 {
     QWidget topLevel;
diff --git a/tests/auto/widgets/widgets.pro b/tests/auto/widgets/widgets.pro
index 8b6c4722be..efcc47171d 100644
--- a/tests/auto/widgets/widgets.pro
+++ b/tests/auto/widgets/widgets.pro
@@ -8,3 +8,4 @@ SUBDIRS=\
     styles \
     util \
     widgets \
+    gestures \
diff --git a/tests/auto/widgets/widgets/qcalendarwidget/tst_qcalendarwidget.cpp b/tests/auto/widgets/widgets/qcalendarwidget/tst_qcalendarwidget.cpp
index e3e7b13cbe..d0a787d32a 100644
--- a/tests/auto/widgets/widgets/qcalendarwidget/tst_qcalendarwidget.cpp
+++ b/tests/auto/widgets/widgets/qcalendarwidget/tst_qcalendarwidget.cpp
@@ -67,6 +67,8 @@ private slots:
     void showPrevNext();
 
     void firstDayOfWeek();
+
+    void contentsMargins();
 };
 
 // Testing get/set functions
@@ -391,5 +393,13 @@ void tst_QCalendarWidget::firstDayOfWeek()
     QCOMPARE(calendar.firstDayOfWeek(), germanLocale.firstDayOfWeek());
 }
 
+void tst_QCalendarWidget::contentsMargins()
+{
+    QCalendarWidget calendar1;
+    QCalendarWidget calendar2;
+    calendar2.setContentsMargins(10, 5, 20, 30);
+    QCOMPARE(calendar1.minimumSizeHint() + QSize(30, 35), calendar2.minimumSizeHint());
+}
+
 QTEST_MAIN(tst_QCalendarWidget)
 #include "tst_qcalendarwidget.moc"
diff --git a/tests/auto/widgets/widgets/qcombobox/tst_qcombobox.cpp b/tests/auto/widgets/widgets/qcombobox/tst_qcombobox.cpp
index 54cf1af5d3..ac32ee4968 100644
--- a/tests/auto/widgets/widgets/qcombobox/tst_qcombobox.cpp
+++ b/tests/auto/widgets/widgets/qcombobox/tst_qcombobox.cpp
@@ -152,6 +152,7 @@ private slots:
     void resetModel();
     void keyBoardNavigationWithMouse();
     void task_QTBUG_1071_changingFocusEmitsActivated();
+    void maxVisibleItems_data();
     void maxVisibleItems();
     void task_QTBUG_10491_currentIndexAndModelColumn();
     void highlightedSignal();
@@ -159,6 +160,7 @@ private slots:
     void task_QTBUG_31146_popupCompletion();
     void keyboardSelection();
     void setCustomModelAndView();
+    void updateDelegateOnEditableChange();
 };
 
 class MyAbstractItemDelegate : public QAbstractItemDelegate
@@ -2749,8 +2751,18 @@ void tst_QComboBox::task_QTBUG_1071_changingFocusEmitsActivated()
     QTRY_COMPARE(spy.count(), 1);
 }
 
+void tst_QComboBox::maxVisibleItems_data()
+{
+    QTest::addColumn<int>("spacing");
+    QTest::newRow("Default")  << -1;
+    QTest::newRow("No spacing") << 0;
+    QTest::newRow("20")  << -1;
+}
+
 void tst_QComboBox::maxVisibleItems()
 {
+    QFETCH(int, spacing);
+
     QComboBox comboBox;
     QCOMPARE(comboBox.maxVisibleItems(), 10); //default value.
 
@@ -2771,15 +2783,18 @@ void tst_QComboBox::maxVisibleItems()
     QTRY_VERIFY(comboBox.view());
     QTRY_VERIFY(comboBox.view()->isVisible());
 
-    QAbstractItemView *v = comboBox.view();
-    int itemHeight = v->visualRect(v->model()->index(0,0)).height();
-    QListView *lv = qobject_cast<QListView*>(v);
-    if (lv)
-        itemHeight += lv->spacing();
+    QListView *listView = qobject_cast<QListView*>(comboBox.view());
+    QVERIFY(listView);
+    if (spacing >= 0)
+        listView->setSpacing(spacing);
+
+    const int itemHeight = listView->visualRect(listView->model()->index(0,0)).height()
+        + 2 * listView->spacing();
+
     QStyleOptionComboBox opt;
     opt.initFrom(&comboBox);
     if (!comboBox.style()->styleHint(QStyle::SH_ComboBox_Popup, &opt))
-        QCOMPARE(v->viewport()->height(), itemHeight * comboBox.maxVisibleItems());
+        QCOMPARE(listView->viewport()->height(), itemHeight * comboBox.maxVisibleItems());
 }
 
 void tst_QComboBox::task_QTBUG_10491_currentIndexAndModelColumn()
@@ -3035,5 +3050,32 @@ void tst_QComboBox::keyboardSelection()
     QCOMPARE(comboBox.currentText(), list.at(1));
 }
 
+void tst_QComboBox::updateDelegateOnEditableChange()
+{
+
+    QComboBox box;
+    box.addItem(QStringLiteral("Foo"));
+    box.addItem(QStringLiteral("Bar"));
+    box.setEditable(false);
+
+    QComboBoxPrivate *d = static_cast<QComboBoxPrivate *>(QComboBoxPrivate::get(&box));
+
+    {
+        bool menuDelegateBefore = qobject_cast<QComboMenuDelegate *>(box.itemDelegate()) != 0;
+        d->updateDelegate();
+        bool menuDelegateAfter = qobject_cast<QComboMenuDelegate *>(box.itemDelegate()) != 0;
+        QCOMPARE(menuDelegateAfter, menuDelegateBefore);
+    }
+
+    box.setEditable(true);
+
+    {
+        bool menuDelegateBefore = qobject_cast<QComboMenuDelegate *>(box.itemDelegate()) != 0;
+        d->updateDelegate();
+        bool menuDelegateAfter = qobject_cast<QComboMenuDelegate *>(box.itemDelegate()) != 0;
+        QCOMPARE(menuDelegateAfter, menuDelegateBefore);
+    }
+}
+
 QTEST_MAIN(tst_QComboBox)
 #include "tst_qcombobox.moc"
diff --git a/tests/auto/widgets/widgets/qmainwindow/tst_qmainwindow.cpp b/tests/auto/widgets/widgets/qmainwindow/tst_qmainwindow.cpp
index ebda07ee0c..27c803b43d 100644
--- a/tests/auto/widgets/widgets/qmainwindow/tst_qmainwindow.cpp
+++ b/tests/auto/widgets/widgets/qmainwindow/tst_qmainwindow.cpp
@@ -137,6 +137,7 @@ private slots:
 #endif
     void addToolbarAfterShow();
     void centralWidgetSize();
+    void fixedSizeCentralWidget();
     void dockWidgetSize();
     void QTBUG2774_stylechange();
     void QTBUG15080_restoreState();
@@ -1737,6 +1738,50 @@ void tst_QMainWindow::centralWidgetSize()
     QTRY_COMPARE(widget.size(), widget.sizeHint());
 }
 
+void tst_QMainWindow::fixedSizeCentralWidget()
+{
+    // QTBUG-40410: dock widgets does not get all the available space when
+    // central widget is fixed size
+    QMainWindow mainWindow;
+    mainWindow.setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
+
+    MyWidget widget;
+    widget.setFixedSize(100,100);
+    mainWindow.setCentralWidget(&widget);
+
+    QDockWidget dock("D1");
+    QWidget *child = new MyWidget;
+    dock.setWidget(child);
+    mainWindow.addDockWidget(Qt::TopDockWidgetArea, &dock);
+
+    QDockWidget dock2("D2");
+    dock2.setWidget(new MyWidget);
+    mainWindow.addDockWidget(Qt::LeftDockWidgetArea, &dock2);
+
+    QSize sizeH = mainWindow.sizeHint();
+    QSize mwSize = QSize(sizeH.width(), sizeH.height() * 2);
+    mainWindow.resize(mwSize);
+    mainWindow.show();
+    QVERIFY(QTest::qWaitForWindowExposed(&mainWindow));
+    if (mainWindow.height() < mwSize.height())
+        QSKIP("The screen is too small for this test");
+
+    // first, check that we get more than the size hint when we have more space
+    QTRY_VERIFY(child->height() > child->sizeHint().height());
+    int childHeight = child->height();
+
+    if (qGuiApp->styleHints()->showIsFullScreen())
+        QSKIP("The platform is auto maximizing, so we cannot resize the window");
+
+    // then, check that we get nothing when there is no space
+    mainWindow.resize(100,100);
+    QTRY_COMPARE(child->height(), 0);
+
+    // finally verify that we get the space back when we resize to the old size
+    mainWindow.resize(mwSize);
+    QTRY_COMPARE(child->height(), childHeight);
+}
+
 void tst_QMainWindow::dockWidgetSize()
 {
     QMainWindow mainWindow;