Merge "Merge remote-tracking branch 'origin/5.6' into 5.7" into refs/staging/5.7

19 files changed, 487 insertions, 131 deletions

diff --git a/tests/auto/corelib/io/qprocess/tst_qprocess.cpp b/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
index e5195000aa..c47e88b0e6 100644
--- a/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
+++ b/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
@@ -141,6 +141,8 @@ private slots:
     void startStopStartStop();
     void startStopStartStopBuffers_data();
     void startStopStartStopBuffers();
+    void processEventsInAReadyReadSlot_data();
+    void processEventsInAReadyReadSlot();
 
     // keep these at the end, since they use lots of processes and sometimes
     // caused obscure failures to occur in tests that followed them (esp. on the Mac)
@@ -153,6 +155,7 @@ private slots:
 protected slots:
     void readFromProcess();
     void exitLoopSlot();
+    void processApplicationEvents();
 #ifndef Q_OS_WINCE
     void restartProcess();
     void waitForReadyReadInAReadyReadSlotSlot();
@@ -471,6 +474,11 @@ void tst_QProcess::exitLoopSlot()
     QTestEventLoop::instance().exitLoop();
 }
 
+void tst_QProcess::processApplicationEvents()
+{
+    QCoreApplication::processEvents();
+}
+
 #ifndef Q_OS_WINCE
 // Reading and writing to a process is not supported on Qt/CE
 void tst_QProcess::echoTest2()
@@ -688,11 +696,7 @@ void tst_QProcess::waitForFinished()
 
     process.start("testProcessOutput/testProcessOutput");
 
-#if !defined(Q_OS_WINCE)
-    QVERIFY(process.waitForFinished(5000));
-#else
-    QVERIFY(process.waitForFinished(30000));
-#endif
+    QVERIFY(process.waitForFinished());
     QCOMPARE(process.exitStatus(), QProcess::NormalExit);
 
 #if defined (Q_OS_WINCE)
@@ -916,12 +920,7 @@ void tst_QProcess::hardExit()
     proc.start("testProcessEcho/testProcessEcho");
 #endif
 
-#ifndef Q_OS_WINCE
-    QVERIFY(proc.waitForStarted(5000));
-#else
-    QVERIFY(proc.waitForStarted(10000));
-#endif
-
+    QVERIFY2(proc.waitForStarted(), qPrintable(proc.errorString()));
     proc.kill();
 
     QVERIFY(proc.waitForFinished(5000));
@@ -1417,24 +1416,17 @@ void tst_QProcess::spaceArgsTest()
         QString program = programs.at(i);
         process.start(program, args);
 
-#if defined(Q_OS_WINCE)
-        const int timeOutMS = 10000;
-#else
-        const int timeOutMS = 5000;
-#endif
         QByteArray errorMessage;
-        bool started = process.waitForStarted(timeOutMS);
+        bool started = process.waitForStarted();
         if (!started)
             errorMessage = startFailMessage(program, process);
         QVERIFY2(started, errorMessage.constData());
-        QVERIFY(process.waitForFinished(timeOutMS));
+        QVERIFY(process.waitForFinished());
         QCOMPARE(process.exitStatus(), QProcess::NormalExit);
         QCOMPARE(process.exitCode(), 0);
 
 #if !defined(Q_OS_WINCE)
         QStringList actual = QString::fromLatin1(process.readAll()).split("|");
-#endif
-#if !defined(Q_OS_WINCE)
         QVERIFY(!actual.isEmpty());
         // not interested in the program name, it might be different.
         actual.removeFirst();
@@ -1459,8 +1451,6 @@ void tst_QProcess::spaceArgsTest()
 
 #if !defined(Q_OS_WINCE)
         actual = QString::fromLatin1(process.readAll()).split("|");
-#endif
-#if !defined(Q_OS_WINCE)
         QVERIFY(!actual.isEmpty());
         // not interested in the program name, it might be different.
         actual.removeFirst();
@@ -1482,13 +1472,8 @@ void tst_QProcess::nativeArguments()
 
     proc.start(QString::fromLatin1("testProcessSpacesArgs/nospace"), QStringList());
 
-#if !defined(Q_OS_WINCE)
-    QVERIFY(proc.waitForStarted(5000));
-    QVERIFY(proc.waitForFinished(5000));
-#else
-    QVERIFY(proc.waitForStarted(10000));
-    QVERIFY(proc.waitForFinished(10000));
-#endif
+    QVERIFY2(proc.waitForStarted(), qPrintable(proc.errorString()));
+    QVERIFY(proc.waitForFinished());
     QCOMPARE(proc.exitStatus(), QProcess::NormalExit);
     QCOMPARE(proc.exitCode(), 0);
 
@@ -2550,6 +2535,31 @@ void tst_QProcess::startStopStartStopBuffers()
     }
 }
 
+void tst_QProcess::processEventsInAReadyReadSlot_data()
+{
+    QTest::addColumn<bool>("callWaitForReadyRead");
+
+    QTest::newRow("no waitForReadyRead") << false;
+    QTest::newRow("waitForReadyRead") << true;
+}
+
+void tst_QProcess::processEventsInAReadyReadSlot()
+{
+    // Test whether processing events in a readyReadXXX slot crashes. (QTBUG-48697)
+    QFETCH(bool, callWaitForReadyRead);
+    QProcess process;
+    QObject::connect(&process, &QProcess::readyReadStandardOutput,
+                     this, &tst_QProcess::processApplicationEvents);
+    process.start("testProcessEcho/testProcessEcho");
+    QVERIFY(process.waitForStarted());
+    const QByteArray data(156, 'x');
+    process.write(data.constData(), data.size() + 1);
+    if (callWaitForReadyRead)
+        QVERIFY(process.waitForReadyRead());
+    if (process.state() == QProcess::Running)
+        QVERIFY(process.waitForFinished());
+}
+
 #endif //QT_NO_PROCESS
 
 QTEST_MAIN(tst_QProcess)
diff --git a/tests/auto/corelib/io/qtextstream/tst_qtextstream.cpp b/tests/auto/corelib/io/qtextstream/tst_qtextstream.cpp
index 439da8b1a3..2852420557 100644
--- a/tests/auto/corelib/io/qtextstream/tst_qtextstream.cpp
+++ b/tests/auto/corelib/io/qtextstream/tst_qtextstream.cpp
@@ -223,6 +223,8 @@ private slots:
     void alignAccountingStyle();
     void setCodec();
 
+    void textModeOnEmptyRead();
+
 private:
     void generateLineData(bool for_QString);
     void generateAllData(bool for_QString);
@@ -3040,6 +3042,21 @@ void tst_QTextStream::int_write_with_locale()
     QCOMPARE(result, output);
 }
 
+void tst_QTextStream::textModeOnEmptyRead()
+{
+    const QString filename("textmodetest.txt");
+    QFile::remove(filename); // Remove file if exists
+
+
+    QFile file(filename);
+    QVERIFY(file.open(QIODevice::ReadWrite | QIODevice::Text));
+    QTextStream stream(&file);
+    QVERIFY(file.isTextModeEnabled());
+    QString emptyLine = stream.readLine(); // Text mode flag cleared here
+    QVERIFY(file.isTextModeEnabled());
+}
+
+
 // ------------------------------------------------------------------------------
 
 QTEST_MAIN(tst_QTextStream)
diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
index b1ae4292d0..fbb6a30917 100644
--- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
+++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
@@ -1473,7 +1473,7 @@ static QByteArray createTypeName(const char *begin, const char *va)
     }
     if (tn.endsWith('>'))
         tn += ' ';
-        tn += ">";
+    tn += '>';
     return tn;
 }
 #endif
diff --git a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
index 540cd66715..23f8ff5857 100644
--- a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
+++ b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
@@ -275,8 +275,10 @@ static void playWithObjects()
 
 void tst_QObject::initTestCase()
 {
+#ifndef QT_NO_PROCESS
     const QString testDataDir = QFileInfo(QFINDTESTDATA("signalbug")).absolutePath();
     QVERIFY2(QDir::setCurrent(testDataDir), qPrintable("Could not chdir to " + testDataDir));
+#endif
 }
 
 void tst_QObject::disconnect()
diff --git a/tests/auto/corelib/kernel/qsharedmemory/qsharedmemory.pro b/tests/auto/corelib/kernel/qsharedmemory/qsharedmemory.pro
index a36b15c906..69062a9741 100644
--- a/tests/auto/corelib/kernel/qsharedmemory/qsharedmemory.pro
+++ b/tests/auto/corelib/kernel/qsharedmemory/qsharedmemory.pro
@@ -1,3 +1,5 @@
 TEMPLATE = subdirs
 
-SUBDIRS = sharedmemoryhelper test
+!winrt: SUBDIRS = sharedmemoryhelper
+
+SUBDIRS += test
diff --git a/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp b/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp
index a4c918ed23..b6f6d2a7f3 100644
--- a/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp
+++ b/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp
@@ -133,7 +133,9 @@ tst_QSharedMemory::~tst_QSharedMemory()
 
 void tst_QSharedMemory::initTestCase()
 {
+#ifndef QT_NO_PROCESS
     QVERIFY2(!m_helperBinary.isEmpty(), "Could not find helper binary");
+#endif
 }
 
 void tst_QSharedMemory::init()
diff --git a/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp b/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp
index 3bed64a76a..fe465df395 100644
--- a/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp
+++ b/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp
@@ -357,28 +357,46 @@ void tst_QAtomicIntegerXX::loadAcquireStoreRelease()
 void tst_QAtomicIntegerXX::refDeref()
 {
     QFETCH(LargeInt, value);
-    T nextValue = T(value + 1);
-    T prevValue = T(value - 1);
+    const bool needToPreventOverflow  = TypeIsSigned && value == std::numeric_limits<T>::max();
+    const bool needToPreventUnderflow = TypeIsSigned && value == std::numeric_limits<T>::min();
+    T nextValue = T(value);
+    if (!needToPreventOverflow)
+        ++nextValue;
+    T prevValue = T(value);
+    if (!needToPreventUnderflow)
+        --prevValue;
 
     QAtomicInteger<T> atomic(value);
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.ref(), (nextValue != 0));
     QCOMPARE(atomic.load(), nextValue);
     QCOMPARE(atomic.deref(), (value != 0));
+    }
     QCOMPARE(atomic.load(), T(value));
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.deref(), (prevValue != 0));
     QCOMPARE(atomic.load(), prevValue);
     QCOMPARE(atomic.ref(), (value != 0));
+    }
     QCOMPARE(atomic.load(), T(value));
 
+    if (!needToPreventOverflow) {
     QCOMPARE(++atomic, nextValue);
     QCOMPARE(--atomic, T(value));
+    }
+    if (!needToPreventUnderflow) {
     QCOMPARE(--atomic, prevValue);
     QCOMPARE(++atomic, T(value));
+    }
 
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic++, T(value));
     QCOMPARE(atomic--, nextValue);
+    }
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic--, T(value));
     QCOMPARE(atomic++, prevValue);
+    }
     QCOMPARE(atomic.load(), T(value));
 }
 
@@ -481,53 +499,80 @@ void tst_QAtomicIntegerXX::fetchAndAdd()
     QFETCH(LargeInt, value);
     QAtomicInteger<T> atomic(value);
 
-    // note: this test has undefined behavior for signed max and min
     T parcel1 = 42;
     T parcel2 = T(0-parcel1);
-    T newValue1 = T(value) + parcel1;
-    T newValue2 = T(value) + parcel2;
 
+    const bool needToPreventOverflow  = TypeIsSigned && value > std::numeric_limits<T>::max() + parcel2;
+    const bool needToPreventUnderflow = TypeIsSigned && value < std::numeric_limits<T>::min() + parcel1;
+
+    T newValue1 = T(value);
+    if (!needToPreventOverflow)
+        newValue1 += parcel1;
+    T newValue2 = T(value);
+    if (!needToPreventUnderflow)
+        newValue2 += parcel2;
+
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndAddRelaxed(parcel1), T(value));
     QCOMPARE(atomic.load(), newValue1);
     QCOMPARE(atomic.fetchAndAddRelaxed(parcel2), newValue1);
+    }
     QCOMPARE(atomic.load(), T(value));
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndAddRelaxed(parcel2), T(value));
     QCOMPARE(atomic.load(), newValue2);
     QCOMPARE(atomic.fetchAndAddRelaxed(parcel1), newValue2);
+    }
     QCOMPARE(atomic.load(), T(value));
 
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndAddAcquire(parcel1), T(value));
     QCOMPARE(atomic.load(), newValue1);
     QCOMPARE(atomic.fetchAndAddAcquire(parcel2), newValue1);
+    }
     QCOMPARE(atomic.load(), T(value));
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndAddAcquire(parcel2), T(value));
     QCOMPARE(atomic.load(), newValue2);
     QCOMPARE(atomic.fetchAndAddAcquire(parcel1), newValue2);
+    }
     QCOMPARE(atomic.load(), T(value));
 
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndAddRelease(parcel1), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue1);
     QCOMPARE(atomic.fetchAndAddRelease(parcel2), newValue1);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndAddRelease(parcel2), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue2);
     QCOMPARE(atomic.fetchAndAddRelease(parcel1), newValue2);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
 
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndAddOrdered(parcel1), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue1);
     QCOMPARE(atomic.fetchAndAddOrdered(parcel2), newValue1);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndAddOrdered(parcel2), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue2);
     QCOMPARE(atomic.fetchAndAddOrdered(parcel1), newValue2);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
 
     // operator+=
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic += parcel1, newValue1);
     QCOMPARE(atomic += parcel2, T(value));
+    }
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic += parcel2, newValue2);
     QCOMPARE(atomic += parcel1, T(value));
+    }
 }
 
 void tst_QAtomicIntegerXX::fetchAndSub()
@@ -535,53 +580,80 @@ void tst_QAtomicIntegerXX::fetchAndSub()
     QFETCH(LargeInt, value);
     QAtomicInteger<T> atomic(value);
 
-    // note: this test has undefined behavior for signed max and min
     T parcel1 = 42;
     T parcel2 = T(0-parcel1);
-    T newValue1 = T(value) - parcel1;
-    T newValue2 = T(value) - parcel2;
 
+    const bool needToPreventOverflow  = TypeIsSigned && value > std::numeric_limits<T>::max() - parcel1;
+    const bool needToPreventUnderflow = TypeIsSigned && value < std::numeric_limits<T>::min() - parcel2;
+
+    T newValue1 = T(value);
+    if (!needToPreventUnderflow)
+        newValue1 -= parcel1;
+    T newValue2 = T(value);
+    if (!needToPreventOverflow)
+        newValue2 -= parcel2;
+
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndSubRelaxed(parcel1), T(value));
     QCOMPARE(atomic.load(), newValue1);
     QCOMPARE(atomic.fetchAndSubRelaxed(parcel2), newValue1);
+    }
     QCOMPARE(atomic.load(), T(value));
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndSubRelaxed(parcel2), T(value));
     QCOMPARE(atomic.load(), newValue2);
     QCOMPARE(atomic.fetchAndSubRelaxed(parcel1), newValue2);
+    }
     QCOMPARE(atomic.load(), T(value));
 
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndSubAcquire(parcel1), T(value));
     QCOMPARE(atomic.load(), newValue1);
     QCOMPARE(atomic.fetchAndSubAcquire(parcel2), newValue1);
+    }
     QCOMPARE(atomic.load(), T(value));
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndSubAcquire(parcel2), T(value));
     QCOMPARE(atomic.load(), newValue2);
     QCOMPARE(atomic.fetchAndSubAcquire(parcel1), newValue2);
+    }
     QCOMPARE(atomic.load(), T(value));
 
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndSubRelease(parcel1), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue1);
     QCOMPARE(atomic.fetchAndSubRelease(parcel2), newValue1);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndSubRelease(parcel2), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue2);
     QCOMPARE(atomic.fetchAndSubRelease(parcel1), newValue2);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
 
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndSubOrdered(parcel1), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue1);
     QCOMPARE(atomic.fetchAndSubOrdered(parcel2), newValue1);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndSubOrdered(parcel2), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue2);
     QCOMPARE(atomic.fetchAndSubOrdered(parcel1), newValue2);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
 
     // operator-=
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic -= parcel1, newValue1);
     QCOMPARE(atomic -= parcel2, T(value));
+    }
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic -= parcel2, newValue2);
     QCOMPARE(atomic -= parcel1, T(value));
+    }
 }
 
 void tst_QAtomicIntegerXX::addSub()
diff --git a/tests/auto/gui/image/qimagewriter/tst_qimagewriter.cpp b/tests/auto/gui/image/qimagewriter/tst_qimagewriter.cpp
index ba5cfd1757..c12c8a9cf4 100644
--- a/tests/auto/gui/image/qimagewriter/tst_qimagewriter.cpp
+++ b/tests/auto/gui/image/qimagewriter/tst_qimagewriter.cpp
@@ -109,7 +109,7 @@ void tst_QImageWriter::initTestCase()
     prefix = QFINDTESTDATA("images/");
     if (prefix.isEmpty())
         QFAIL("Can't find images directory!");
-    writePrefix = m_temporaryDir.path();
+    writePrefix = m_temporaryDir.path() + QLatin1Char('/');
 }
 
 // Testing get/set functions
diff --git a/tests/auto/gui/kernel/qkeyevent/tst_qkeyevent.cpp b/tests/auto/gui/kernel/qkeyevent/tst_qkeyevent.cpp
index bd68400047..db0bfaf622 100644
--- a/tests/auto/gui/kernel/qkeyevent/tst_qkeyevent.cpp
+++ b/tests/auto/gui/kernel/qkeyevent/tst_qkeyevent.cpp
@@ -137,7 +137,7 @@ void tst_QKeyEvent::modifiers_data()
     for (quint64 bitmask = 1; bitmask < (1 << kNumModifiers) ; ++bitmask) {
         QVector<int> modifierCombination;
         for (quint64 modifier = 0; modifier < kNumModifiers; ++modifier) {
-            if (bitmask & (1 << modifier))
+            if (bitmask & (quint64(1) << modifier))
                 modifierCombination.append(modifier);
         }
         modifierCombinations.append(modifierCombination);
diff --git a/tests/auto/gui/text/qstatictext/tst_qstatictext.cpp b/tests/auto/gui/text/qstatictext/tst_qstatictext.cpp
index 7f4a11c5a5..096b820004 100644
--- a/tests/auto/gui/text/qstatictext/tst_qstatictext.cpp
+++ b/tests/auto/gui/text/qstatictext/tst_qstatictext.cpp
@@ -592,6 +592,29 @@ void tst_QStaticText::plainTextVsRichText()
     QCOMPARE(imagePlainText, imageRichText);
 }
 
+static bool checkPixels(const QImage &image,
+                        Qt::GlobalColor expectedColor1, Qt::GlobalColor expectedColor2,
+                        QByteArray *errorMessage)
+{
+    const QRgb expectedRgb1 = QColor(expectedColor1).rgba();
+    const QRgb expectedRgb2 = QColor(expectedColor2).rgba();
+
+    for (int x = 0, w = image.width(); x < w; ++x) {
+        for (int y = 0, h = image.height(); y < h; ++y) {
+            const QRgb pixel = image.pixel(x, y);
+            if (pixel != expectedRgb1 && pixel != expectedRgb2) {
+                QString message;
+                QDebug(&message) << "Color mismatch in image" << image
+                    << "at" << x << ',' << y << ':' << showbase << hex << pixel
+                    << "(expected: " << expectedRgb1 << ',' << expectedRgb2 << ')';
+                *errorMessage = message.toLocal8Bit();
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 void tst_QStaticText::setPenPlainText_data()
 {
     QTest::addColumn<QImage::Format>("format");
@@ -622,13 +645,9 @@ void tst_QStaticText::setPenPlainText()
         p.drawStaticText(0, 0, staticText);
     }
 
-    for (int x=0; x<image.width(); ++x) {
-        for (int y=0; y<image.height(); ++y) {
-            QRgb pixel = image.pixel(x, y);
-            QVERIFY(pixel == QColor(Qt::white).rgba()
-                    || pixel == QColor(Qt::yellow).rgba());
-        }
-    }
+    QByteArray errorMessage;
+    QVERIFY2(checkPixels(image, Qt::yellow, Qt::white, &errorMessage),
+             errorMessage.constData());
 }
 
 void tst_QStaticText::setPenRichText()
@@ -650,14 +669,9 @@ void tst_QStaticText::setPenRichText()
         p.drawStaticText(0, 0, staticText);
     }
 
-    QImage img = image.toImage();
-    for (int x=0; x<img.width(); ++x) {
-        for (int y=0; y<img.height(); ++y) {
-            QRgb pixel = img.pixel(x, y);
-            QVERIFY(pixel == QColor(Qt::white).rgba()
-                    || pixel == QColor(Qt::green).rgba());
-        }
-    }
+    QByteArray errorMessage;
+    QVERIFY2(checkPixels(image.toImage(), Qt::green, Qt::white, &errorMessage),
+             errorMessage.constData());
 }
 
 void tst_QStaticText::richTextOverridesPen()
@@ -679,14 +693,9 @@ void tst_QStaticText::richTextOverridesPen()
         p.drawStaticText(0, 0, staticText);
     }
 
-    QImage img = image.toImage();
-    for (int x=0; x<img.width(); ++x) {
-        for (int y=0; y<img.height(); ++y) {
-            QRgb pixel = img.pixel(x, y);
-            QVERIFY(pixel == QColor(Qt::white).rgba()
-                    || pixel == QColor(Qt::red).rgba());
-        }
-    }
+    QByteArray errorMessage;
+    QVERIFY2(checkPixels(image.toImage(), Qt::red, Qt::white, &errorMessage),
+             errorMessage.constData());
 }
 
 void tst_QStaticText::drawStruckOutText()
diff --git a/tests/auto/network/access/qhttpnetworkreply/tst_qhttpnetworkreply.cpp b/tests/auto/network/access/qhttpnetworkreply/tst_qhttpnetworkreply.cpp
index 3373324c19..ec965a61b2 100644
--- a/tests/auto/network/access/qhttpnetworkreply/tst_qhttpnetworkreply.cpp
+++ b/tests/auto/network/access/qhttpnetworkreply/tst_qhttpnetworkreply.cpp
@@ -28,6 +28,9 @@
 
 
 #include <QtTest/QtTest>
+#include <QtCore/QBuffer>
+#include <QtCore/QByteArray>
+
 #include "private/qhttpnetworkconnection_p.h"
 
 class tst_QHttpNetworkReply: public QObject
@@ -36,6 +39,9 @@ class tst_QHttpNetworkReply: public QObject
 private Q_SLOTS:
     void parseHeader_data();
     void parseHeader();
+
+    void parseEndOfHeader_data();
+    void parseEndOfHeader();
 };
 
 void tst_QHttpNetworkReply::parseHeader_data()
@@ -95,5 +101,66 @@ void tst_QHttpNetworkReply::parseHeader()
     }
 }
 
+class TestHeaderSocket : public QAbstractSocket
+{
+public:
+    explicit TestHeaderSocket(const QByteArray &input) : QAbstractSocket(QAbstractSocket::TcpSocket, Q_NULLPTR)
+    {
+        inputBuffer.setData(input);
+        inputBuffer.open(QIODevice::ReadOnly | QIODevice::Unbuffered);
+        open(QIODevice::ReadOnly | QIODevice::Unbuffered);
+    }
+
+    qint64 readData(char *data, qint64 maxlen) { return inputBuffer.read(data, maxlen); }
+
+    QBuffer inputBuffer;
+};
+
+class TestHeaderReply : public QHttpNetworkReply
+{
+public:
+    QHttpNetworkReplyPrivate *replyPrivate() { return static_cast<QHttpNetworkReplyPrivate *>(d_ptr.data()); }
+};
+
+void tst_QHttpNetworkReply::parseEndOfHeader_data()
+{
+    QTest::addColumn<QByteArray>("headers");
+    QTest::addColumn<qint64>("lengths");
+
+    QTest::newRow("CRLFCRLF") << QByteArray("Content-Type: text/html; charset=utf-8\r\n"
+                                            "Content-Length:\r\n 1024\r\n"
+                                            "Content-Encoding: gzip\r\n\r\nHTTPBODY")
+                               << qint64(90);
+
+    QTest::newRow("CRLFLF") << QByteArray("Content-Type: text/html; charset=utf-8\r\n"
+                                          "Content-Length:\r\n 1024\r\n"
+                                          "Content-Encoding: gzip\r\n\nHTTPBODY")
+                            << qint64(89);
+
+    QTest::newRow("LFCRLF") << QByteArray("Content-Type: text/html; charset=utf-8\r\n"
+                                          "Content-Length:\r\n 1024\r\n"
+                                          "Content-Encoding: gzip\n\r\nHTTPBODY")
+                            << qint64(89);
+
+    QTest::newRow("LFLF") << QByteArray("Content-Type: text/html; charset=utf-8\r\n"
+                                        "Content-Length:\r\n 1024\r\n"
+                                        "Content-Encoding: gzip\n\nHTTPBODY")
+                          << qint64(88);
+}
+
+void tst_QHttpNetworkReply::parseEndOfHeader()
+{
+    QFETCH(QByteArray, headers);
+    QFETCH(qint64, lengths);
+
+    TestHeaderSocket socket(headers);
+
+    TestHeaderReply reply;
+
+    QHttpNetworkReplyPrivate *replyPrivate = reply.replyPrivate();
+    qint64 headerBytes = replyPrivate->readHeader(&socket);
+    QCOMPARE(headerBytes, lengths);
+}
+
 QTEST_MAIN(tst_QHttpNetworkReply)
 #include "tst_qhttpnetworkreply.moc"
diff --git a/tests/auto/network/access/qnetworkreply/BLACKLIST b/tests/auto/network/access/qnetworkreply/BLACKLIST
index 3ec580ddde..0605677e29 100644
--- a/tests/auto/network/access/qnetworkreply/BLACKLIST
+++ b/tests/auto/network/access/qnetworkreply/BLACKLIST
@@ -7,3 +7,7 @@ ubuntu-14.04
 *
 [backgroundRequestInterruption:ftp, bg, nobg]
 *
+[authenticationCacheAfterCancel:http+socksauth]
+rhel-7.1
+[authenticationCacheAfterCancel:https+socksauth]
+rhel-7.1
diff --git a/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp b/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp
index d037826410..ef47b45e9e 100644
--- a/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp
+++ b/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp
@@ -490,7 +490,11 @@ void tst_QLocalSocket::connectWithOldOpen()
 
 void tst_QLocalSocket::sendData_data()
 {
-    listenAndConnect_data();
+    QTest::addColumn<QString>("name");
+    QTest::addColumn<bool>("canListen");
+
+    QTest::newRow("null") << QString() << false;
+    QTest::newRow("tst_localsocket") << "tst_localsocket" << true;
 }
 
 void tst_QLocalSocket::sendData()
diff --git a/tests/auto/tools/moc/tst_moc.cpp b/tests/auto/tools/moc/tst_moc.cpp
index 8895c652a5..5154351bb1 100644
--- a/tests/auto/tools/moc/tst_moc.cpp
+++ b/tests/auto/tools/moc/tst_moc.cpp
@@ -126,6 +126,33 @@ typedef struct {
     int doNotConfuseMoc;
 } OldStyleCStruct;
 
+namespace {
+
+    class GadgetInUnnamedNS
+    {
+        Q_GADGET
+        Q_PROPERTY(int x READ x WRITE setX)
+        Q_PROPERTY(int y READ y WRITE setY)
+    public:
+        explicit GadgetInUnnamedNS(int x, int y) : m_x(x), m_y(y) {}
+        int x() const { return m_x; }
+        int y() const { return m_y; }
+        void setX(int x) { m_x = x; }
+        void setY(int y) { m_y = y; }
+
+    private:
+        int m_x, m_y;
+    };
+
+    class ObjectInUnnamedNS : public QObject
+    {
+        Q_OBJECT
+    public:
+        explicit ObjectInUnnamedNS(QObject *parent = Q_NULLPTR) : QObject(parent) {}
+    };
+
+}
+
 class Sender : public QObject
 {
     Q_OBJECT
@@ -592,6 +619,7 @@ private slots:
     void relatedMetaObjectsNameConflict_data();
     void relatedMetaObjectsNameConflict();
     void strignLiteralsInMacroExtension();
+    void unnamedNamespaceObjectsAndGadgets();
     void veryLongStringData();
     void gadgetHierarchy();
 
@@ -3417,6 +3445,28 @@ class VeryLongStringData : public QObject
     #undef repeat65534
 };
 
+void tst_Moc::unnamedNamespaceObjectsAndGadgets()
+{
+    // these just test very basic functionality of gadgets and objects
+    // defined in unnamed namespaces.
+    {
+        GadgetInUnnamedNS gadget(21, 42);
+        QCOMPARE(gadget.x(), 21);
+        QCOMPARE(gadget.y(), 42);
+        gadget.staticMetaObject.property(0).writeOnGadget(&gadget, 12);
+        gadget.staticMetaObject.property(1).writeOnGadget(&gadget, 24);
+        QCOMPARE(gadget.x(), 12);
+        QCOMPARE(gadget.y(), 24);
+    }
+
+    {
+        ObjectInUnnamedNS object;
+        QObject *qObject = &object;
+        QCOMPARE(static_cast<ObjectInUnnamedNS *>(qObject),
+                 qobject_cast<ObjectInUnnamedNS *>(qObject));
+    }
+}
+
 void tst_Moc::veryLongStringData()
 {
     const QMetaObject *mobj = &VeryLongStringData::staticMetaObject;
diff --git a/tests/auto/tools/uic/baseline/enumnostdset.ui b/tests/auto/tools/uic/baseline/enumnostdset.ui
new file mode 100644
index 0000000000..59e27b1be3
--- /dev/null
+++ b/tests/auto/tools/uic/baseline/enumnostdset.ui
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <widget class="WorldTimeClock" name="worldTimeClock">
+   <property name="geometry">
+    <rect>
+     <x>100</x>
+     <y>100</y>
+     <width>100</width>
+     <height>100</height>
+    </rect>
+   </property>
+   <property name="penStyle" stdset="0">
+    <enum>Qt::DashDotLine</enum>
+   </property>
+  </widget>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>WorldTimeClock</class>
+   <extends>QWidget</extends>
+   <header>worldtimeclock.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/tests/auto/tools/uic/baseline/enumnostdset.ui.h b/tests/auto/tools/uic/baseline/enumnostdset.ui.h
new file mode 100644
index 0000000000..89a8411b4a
--- /dev/null
+++ b/tests/auto/tools/uic/baseline/enumnostdset.ui.h
@@ -0,0 +1,55 @@
+/********************************************************************************
+** Form generated from reading UI file 'enumnostdset.ui'
+**
+** Created by: Qt User Interface Compiler version 5.6.1
+**
+** WARNING! All changes made in this file will be lost when recompiling UI file!
+********************************************************************************/
+
+#ifndef ENUMNOSTDSET_H
+#define ENUMNOSTDSET_H
+
+#include <QtCore/QVariant>
+#include <QtWidgets/QAction>
+#include <QtWidgets/QApplication>
+#include <QtWidgets/QButtonGroup>
+#include <QtWidgets/QHeaderView>
+#include <QtWidgets/QWidget>
+#include "worldtimeclock.h"
+
+QT_BEGIN_NAMESPACE
+
+class Ui_Form
+{
+public:
+    WorldTimeClock *worldTimeClock;
+
+    void setupUi(QWidget *Form)
+    {
+        if (Form->objectName().isEmpty())
+            Form->setObjectName(QStringLiteral("Form"));
+        Form->resize(400, 300);
+        worldTimeClock = new WorldTimeClock(Form);
+        worldTimeClock->setObjectName(QStringLiteral("worldTimeClock"));
+        worldTimeClock->setGeometry(QRect(100, 100, 100, 100));
+        worldTimeClock->setProperty("penStyle", QVariant::fromValue(Qt::DashDotLine));
+
+        retranslateUi(Form);
+
+        QMetaObject::connectSlotsByName(Form);
+    } // setupUi
+
+    void retranslateUi(QWidget *Form)
+    {
+        Form->setWindowTitle(QApplication::translate("Form", "Form", 0));
+    } // retranslateUi
+
+};
+
+namespace Ui {
+    class Form: public Ui_Form {};
+} // namespace Ui
+
+QT_END_NAMESPACE
+
+#endif // ENUMNOSTDSET_H
diff --git a/tests/auto/widgets/dialogs/qdialog/tst_qdialog.cpp b/tests/auto/widgets/dialogs/qdialog/tst_qdialog.cpp
index 6528c24c1a..e6a0c5e86b 100644
--- a/tests/auto/widgets/dialogs/qdialog/tst_qdialog.cpp
+++ b/tests/auto/widgets/dialogs/qdialog/tst_qdialog.cpp
@@ -50,7 +50,7 @@ QT_FORWARD_DECLARE_CLASS(QDialog)
 class DummyDialog : public QDialog
 {
 public:
-    DummyDialog(): QDialog(0, Qt::X11BypassWindowManagerHint) {}
+    DummyDialog(): QDialog() {}
     using QDialog::showExtension;
 };
 
@@ -60,10 +60,8 @@ class tst_QDialog : public QObject
 public:
     tst_QDialog();
 
-public slots:
-    void initTestCase();
-    void cleanupTestCase();
 private slots:
+    void cleanup();
     void getSetCheck();
     void showExtension_data();
     void showExtension();
@@ -86,9 +84,6 @@ private slots:
     void transientParent_data();
     void transientParent();
     void dialogInGraphicsView();
-
-private:
-    DummyDialog *testWidget;
 };
 
 // Testing get/set functions
@@ -144,25 +139,12 @@ private:
 };
 
 tst_QDialog::tst_QDialog()
-
 {
 }
 
-void tst_QDialog::initTestCase()
+void tst_QDialog::cleanup()
 {
-    // Create the test class
-    testWidget = new DummyDialog;
-    testWidget->resize(200,200);
-    testWidget->show();
-    qApp->setActiveWindow(testWidget);
-}
-
-void tst_QDialog::cleanupTestCase()
-{
-    if (testWidget) {
-        delete testWidget;
-        testWidget = 0;
-    }
+    QVERIFY(QApplication::topLevelWidgets().isEmpty());
 }
 
 void tst_QDialog::showExtension_data()
@@ -185,44 +167,52 @@ void tst_QDialog::showExtension()
     QFETCH( QSize, extSize );
     QFETCH( bool, horizontal );
 
-    // set geometry of main dialog and extension widget
-    testWidget->setFixedSize( dlgSize );
-    QWidget *ext = new QWidget( testWidget );
+    DummyDialog testWidget;
+    testWidget.resize(200, 200);
+    testWidget.setWindowTitle(QLatin1String(QTest::currentTestFunction()) + QLatin1Char(':')
+                              + QLatin1String(QTest::currentDataTag()));
+    testWidget.show();
+    QVERIFY(QTest::qWaitForWindowExposed(&testWidget));
+
+    testWidget.setFixedSize( dlgSize );
+    QWidget *ext = new QWidget( &testWidget );
     ext->setFixedSize( extSize );
-    testWidget->setExtension( ext );
-    testWidget->setOrientation( horizontal ? Qt::Horizontal : Qt::Vertical );
+    testWidget.setExtension( ext );
+    testWidget.setOrientation( horizontal ? Qt::Horizontal : Qt::Vertical );
 
-    QCOMPARE( testWidget->size(), dlgSize );
-    QPoint oldPosition = testWidget->pos();
+    QCOMPARE( testWidget.size(), dlgSize );
+    QPoint oldPosition = testWidget.pos();
 
     // show
-    testWidget->showExtension( true );
+    testWidget.showExtension( true );
 //     while ( testWidget->size() == dlgSize )
 //         qApp->processEvents();
 
-    QTEST( testWidget->size(), "result"  );
+    QTEST( testWidget.size(), "result"  );
 
-    QCOMPARE(testWidget->pos(), oldPosition);
+    QCOMPARE(testWidget.pos(), oldPosition);
 
     // hide extension. back to old size ?
-    testWidget->showExtension( false );
-    QCOMPARE( testWidget->size(), dlgSize );
+    testWidget.showExtension( false );
+    QCOMPARE( testWidget.size(), dlgSize );
 
-    testWidget->setExtension( 0 );
+    testWidget.setExtension( 0 );
 }
 
 void tst_QDialog::defaultButtons()
 {
-    QLineEdit *lineEdit = new QLineEdit(testWidget);
-    QPushButton *push = new QPushButton("Button 1", testWidget);
-    QPushButton *pushTwo = new QPushButton("Button 2", testWidget);
-    QPushButton *pushThree = new QPushButton("Button 3", testWidget);
+    DummyDialog testWidget;
+    testWidget.resize(200, 200);
+    testWidget.setWindowTitle(QTest::currentTestFunction());
+    QLineEdit *lineEdit = new QLineEdit(&testWidget);
+    QPushButton *push = new QPushButton("Button 1", &testWidget);
+    QPushButton *pushTwo = new QPushButton("Button 2", &testWidget);
+    QPushButton *pushThree = new QPushButton("Button 3", &testWidget);
     pushThree->setAutoDefault(false);
 
-    //we need to show the buttons. Otherwise they won't get the focus
-    push->show();
-    pushTwo->show();
-    pushThree->show();
+    testWidget.show();
+    QApplication::setActiveWindow(&testWidget);
+    QVERIFY(QTest::qWaitForWindowActive(&testWidget));
 
     push->setDefault(true);
     QVERIFY(push->isDefault());
@@ -375,11 +365,15 @@ void tst_QDialog::showAsTool()
 #if defined(Q_OS_UNIX)
     QSKIP("Qt/X11: Skipped since activeWindow() is not respected by all window managers");
 #endif
-    ToolDialog dialog(testWidget);
-    testWidget->activateWindow();
+    DummyDialog testWidget;
+    testWidget.resize(200, 200);
+    testWidget.setWindowTitle(QTest::currentTestFunction());
+    ToolDialog dialog(&testWidget);
+    testWidget.show();
+    testWidget.activateWindow();
+    QVERIFY(QTest::qWaitForWindowActive(&testWidget));
     dialog.exec();
-    QTest::qWait(100);
-    if (testWidget->style()->styleHint(QStyle::SH_Widget_ShareActivation, 0, testWidget)) {
+    if (testWidget.style()->styleHint(QStyle::SH_Widget_ShareActivation, 0, &testWidget)) {
         QCOMPARE(dialog.wasActive(), true);
     } else {
         QCOMPARE(dialog.wasActive(), false);
@@ -602,7 +596,6 @@ void tst_QDialog::transientParent_data()
 void tst_QDialog::transientParent()
 {
     QFETCH(bool, nativewidgets);
-    testWidget->hide();
     QWidget topLevel;
     topLevel.resize(200, 200);
     topLevel.move(QGuiApplication::primaryScreen()->availableGeometry().center() - QPoint(100, 100));
diff --git a/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp b/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
index 515ddf480f..ae48445363 100644
--- a/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
+++ b/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
@@ -442,6 +442,7 @@ private slots:
 
     void touchEventSynthesizedMouseEvent();
     void touchUpdateOnNewTouch();
+    void touchEventsForGesturePendingWidgets();
 
     void styleSheetPropagation();
 
@@ -9783,6 +9784,7 @@ public:
           m_touchUpdateCount(0),
           m_touchEndCount(0),
           m_touchEventCount(0),
+          m_gestureEventCount(0),
           m_acceptTouch(false),
           m_mouseEventCount(0),
           m_acceptMouse(true)
@@ -9820,6 +9822,9 @@ protected:
             else
                 e->ignore();
             return true;
+        case QEvent::Gesture:
+            ++m_gestureEventCount;
+            return true;
 
         case QEvent::MouseButtonPress:
         case QEvent::MouseMove:
@@ -9842,6 +9847,7 @@ public:
     int m_touchUpdateCount;
     int m_touchEndCount;
     int m_touchEventCount;
+    int m_gestureEventCount;
     bool m_acceptTouch;
     int m_mouseEventCount;
     bool m_acceptMouse;
@@ -9997,6 +10003,48 @@ void tst_QWidget::touchUpdateOnNewTouch()
     QCOMPARE(widget.m_touchEndCount, 1);
 }
 
+void tst_QWidget::touchEventsForGesturePendingWidgets()
+{
+    QTouchDevice *device = new QTouchDevice;
+    device->setType(QTouchDevice::TouchScreen);
+    QWindowSystemInterface::registerTouchDevice(device);
+
+    TouchMouseWidget parent;
+    TouchMouseWidget child(&parent);
+    parent.grabGesture(Qt::TapAndHoldGesture);
+    parent.show();
+
+    QWindow* window = parent.windowHandle();
+    QVERIFY(QTest::qWaitForWindowExposed(window));
+    QTest::qWait(500); // needed for QApplication::topLevelAt(), which is used by QGestureManager
+    QCOMPARE(child.m_touchEventCount, 0);
+    QCOMPARE(child.m_gestureEventCount, 0);
+    QCOMPARE(parent.m_touchEventCount, 0);
+    QCOMPARE(parent.m_gestureEventCount, 0);
+    QTest::touchEvent(window, device).press(0, QPoint(20, 20), window);
+    QCOMPARE(child.m_touchEventCount, 0);
+    QCOMPARE(child.m_gestureEventCount, 0);
+    QCOMPARE(parent.m_touchBeginCount, 1); // QTapAndHoldGestureRecognizer::create() sets Qt::WA_AcceptTouchEvents
+    QCOMPARE(parent.m_touchUpdateCount, 0);
+    QCOMPARE(parent.m_touchEndCount, 0);
+    QCOMPARE(parent.m_gestureEventCount, 0);
+    QTest::touchEvent(window, device).move(0, QPoint(25, 25), window);
+    QCOMPARE(child.m_touchEventCount, 0);
+    QCOMPARE(child.m_gestureEventCount, 0);
+    QCOMPARE(parent.m_touchBeginCount, 1);
+    QCOMPARE(parent.m_touchUpdateCount, 0);
+    QCOMPARE(parent.m_touchEndCount, 0);
+    QCOMPARE(parent.m_gestureEventCount, 0);
+    QTest::qWait(1000);
+    QTest::touchEvent(window, device).release(0, QPoint(25, 25), window);
+    QCOMPARE(child.m_touchEventCount, 0);
+    QCOMPARE(child.m_gestureEventCount, 0);
+    QCOMPARE(parent.m_touchBeginCount, 1);
+    QCOMPARE(parent.m_touchUpdateCount, 0);
+    QCOMPARE(parent.m_touchEndCount, 0);
+    QVERIFY(parent.m_gestureEventCount > 0);
+}
+
 void tst_QWidget::styleSheetPropagation()
 {
     QTableView tw;
diff --git a/tests/manual/touch/main.cpp b/tests/manual/touch/main.cpp
index 588fef9fd0..fb0c8559f9 100644
--- a/tests/manual/touch/main.cpp
+++ b/tests/manual/touch/main.cpp
@@ -86,24 +86,6 @@ static void drawArrow(const QPointF &center, qreal length, qreal angleDegrees,
     painter.restore();
 }
 
-QDebug operator<<(QDebug debug, const QTouchDevice *d)
-{
-    QDebugStateSaver saver(debug);
-    debug.nospace();
-    debug << "QTouchDevice(" << d->name() << ',';
-    switch (d->type()) {
-    case QTouchDevice::TouchScreen:
-        debug << "TouchScreen";
-        break;
-    case QTouchDevice::TouchPad:
-        debug << "TouchPad";
-        break;
-    }
-    debug << ", capabilities=" << d->capabilities()
-        << ", maximumTouchPoints=" << d->maximumTouchPoints() << ')';
-    return debug;
-}
-
 // Hierarchy of classes containing gesture parameters and drawing functionality.
 class Gesture {
     Q_DISABLE_COPY(Gesture)