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

Conflicts:
	config_help.txt
	configure
	mkspecs/features/uikit/sdk.prf
	src/corelib/global/qhooks.cpp
	src/corelib/io/qfilesystemwatcher.cpp
	src/corelib/io/qlockfile_unix.cpp
	src/corelib/tools/qalgorithms.h
	src/gui/kernel/qwindowsysteminterface.h
	src/gui/text/qtextdocument_p.cpp
	src/network/access/access.pri
	src/network/access/qnetworkaccessmanager.cpp
	src/network/access/qnetworkreplynsurlconnectionimpl.mm
	src/src.pro
	src/testlib/qtestcase.cpp
	src/widgets/kernel/qwidgetbackingstore_p.h
	src/widgets/styles/qwindowscestyle.cpp
	src/widgets/styles/qwindowsmobilestyle.cpp
	tests/auto/corelib/io/qdiriterator/qdiriterator.pro
	tests/auto/corelib/io/qfileinfo/qfileinfo.pro
	tests/auto/gui/kernel/qwindow/BLACKLIST
	tests/auto/widgets/dialogs/qfilesystemmodel/tst_qfilesystemmodel.cpp
	tools/configure/configureapp.cpp

Change-Id: Ibf7fb9c8cf263a810ade82f821345d0725c57c67

11 files changed, 298 insertions, 82 deletions

diff --git a/tests/auto/corelib/io/qdebug/tst_qdebug.cpp b/tests/auto/corelib/io/qdebug/tst_qdebug.cpp
index abec4e7aba..7147405f3b 100644
--- a/tests/auto/corelib/io/qdebug/tst_qdebug.cpp
+++ b/tests/auto/corelib/io/qdebug/tst_qdebug.cpp
@@ -359,14 +359,14 @@ void tst_QDebug::qDebugQChar() const
     MessageHandlerSetter mhs(myMessageHandler);
     {
         QDebug d = qDebug();
-        d << QChar('f');
-        d.nospace().noquote() << QChar('o') << QChar('o');
+        d << QChar('f') << QChar(QLatin1Char('\xE4')); // f, ä
+        d.nospace().noquote() << QChar('o') << QChar('o')  << QChar(QLatin1Char('\xC4')); // o, o, Ä
     }
 #ifndef QT_NO_MESSAGELOGCONTEXT
     file = __FILE__; line = __LINE__ - 5; function = Q_FUNC_INFO;
 #endif
     QCOMPARE(s_msgType, QtDebugMsg);
-    QCOMPARE(s_msg, QString::fromLatin1("'f' oo"));
+    QCOMPARE(s_msg, QString::fromLatin1("'f' '\\u00e4' oo\\u00c4"));
     QCOMPARE(QString::fromLatin1(s_file), file);
     QCOMPARE(s_line, line);
     QCOMPARE(QString::fromLatin1(s_function), function);
diff --git a/tests/auto/corelib/io/qdir/qdir.pro b/tests/auto/corelib/io/qdir/qdir.pro
index e5739f7e0a..4870922312 100644
--- a/tests/auto/corelib/io/qdir/qdir.pro
+++ b/tests/auto/corelib/io/qdir/qdir.pro
@@ -11,5 +11,3 @@ contains(CONFIG, builtin_testdata): DEFINES += BUILTIN_TESTDATA
 android {
     RESOURCES += android_testdata.qrc
 }
-
-win32: CONFIG += insignificant_test # Crashes on Windows in release builds
diff --git a/tests/auto/corelib/io/qdir/tst_qdir.cpp b/tests/auto/corelib/io/qdir/tst_qdir.cpp
index c450bad2de..294a53645e 100644
--- a/tests/auto/corelib/io/qdir/tst_qdir.cpp
+++ b/tests/auto/corelib/io/qdir/tst_qdir.cpp
@@ -207,6 +207,7 @@ private slots:
 
     void cdNonreadable();
 
+    void cdBelowRoot_data();
     void cdBelowRoot();
 
 private:
@@ -2220,31 +2221,37 @@ void tst_QDir::cdNonreadable()
 #endif
 }
 
+void tst_QDir::cdBelowRoot_data()
+{
+    QTest::addColumn<QString>("rootPath");
+    QTest::addColumn<QString>("cdInto");
+    QTest::addColumn<QString>("targetPath");
+
+#if defined(Q_OS_ANDROID)
+    QTest::newRow("android") << "/" << "system" << "/system";
+#elif defined(Q_OS_UNIX)
+    QTest::newRow("unix") << "/" << "tmp" << "/tmp";
+#elif defined(Q_OS_WINRT)
+    QTest::newRow("winrt") << QDir::rootPath() << QDir::rootPath() << QDir::rootPath();
+#else // Windows+CE
+    const QString systemDrive = QString::fromLocal8Bit(qgetenv("SystemDrive")) + QLatin1Char('/');
+    const QString systemRoot = QString::fromLocal8Bit(qgetenv("SystemRoot"));
+    QTest::newRow("windows-drive")
+        << systemDrive << systemRoot.mid(3) << QDir::cleanPath(systemRoot);
+#endif // Windows
+}
+
 void tst_QDir::cdBelowRoot()
 {
-#if defined (Q_OS_ANDROID)
-#define ROOT QString("/")
-#define DIR QString("/system")
-#define CD_INTO "system"
-#elif defined (Q_OS_UNIX)
-#define ROOT QString("/")
-#define DIR QString("/tmp")
-#define CD_INTO "tmp"
-#elif defined (Q_OS_WINRT)
-#define ROOT QDir::rootPath()
-#define DIR QDir::rootPath()
-#define CD_INTO QDir::rootPath()
-#else
-#define ROOT QString::fromLocal8Bit(qgetenv("SystemDrive"))+"/"
-#define DIR QString::fromLocal8Bit(qgetenv("SystemRoot")).replace('\\', '/')
-#define CD_INTO QString::fromLocal8Bit(qgetenv("SystemRoot")).mid(3)
-#endif
+    QFETCH(QString, rootPath);
+    QFETCH(QString, cdInto);
+    QFETCH(QString, targetPath);
 
-    QDir root(ROOT);
-    QVERIFY(!root.cd(".."));
-    QCOMPARE(root.path(), ROOT);
-    QVERIFY(root.cd(CD_INTO));
-    QCOMPARE(root.path(), DIR);
+    QDir root(rootPath);
+    QVERIFY2(!root.cd(".."), qPrintable(root.absolutePath()));
+    QCOMPARE(root.path(), rootPath);
+    QVERIFY(root.cd(cdInto));
+    QCOMPARE(root.path(), targetPath);
 #ifdef Q_OS_UNIX
     if (::getuid() == 0)
         QSKIP("Running this test as root doesn't make sense");
@@ -2252,13 +2259,13 @@ void tst_QDir::cdBelowRoot()
 #ifdef Q_OS_WINRT
     QSKIP("WinRT has no concept of system root");
 #endif
-    QDir dir(DIR);
-    QVERIFY(!dir.cd("../.."));
-    QCOMPARE(dir.path(), DIR);
-    QVERIFY(!dir.cd("../abs/../.."));
-    QCOMPARE(dir.path(), DIR);
+    QDir dir(targetPath);
+    QVERIFY2(!dir.cd("../.."), qPrintable(dir.absolutePath()));
+    QCOMPARE(dir.path(), targetPath);
+    QVERIFY2(!dir.cd("../abs/../.."), qPrintable(dir.absolutePath()));
+    QCOMPARE(dir.path(), targetPath);
     QVERIFY(dir.cd(".."));
-    QCOMPARE(dir.path(), ROOT);
+    QCOMPARE(dir.path(), rootPath);
 }
 
 QTEST_MAIN(tst_QDir)
diff --git a/tests/auto/corelib/io/qdiriterator/qdiriterator.pro b/tests/auto/corelib/io/qdiriterator/qdiriterator.pro
index b5ac614ad1..7c1f026bdb 100644
--- a/tests/auto/corelib/io/qdiriterator/qdiriterator.pro
+++ b/tests/auto/corelib/io/qdiriterator/qdiriterator.pro
@@ -6,5 +6,3 @@ RESOURCES += qdiriterator.qrc
 
 TESTDATA += entrylist
 contains(CONFIG, builtin_testdata): DEFINES += BUILTIN_TESTDATA
-
-win32: CONFIG += insignificant_test # Crashes on Windows in release builds
diff --git a/tests/auto/corelib/io/qfileinfo/qfileinfo.pro b/tests/auto/corelib/io/qfileinfo/qfileinfo.pro
index 8d443c27ec..48673b20a9 100644
--- a/tests/auto/corelib/io/qfileinfo/qfileinfo.pro
+++ b/tests/auto/corelib/io/qfileinfo/qfileinfo.pro
@@ -5,6 +5,4 @@ SOURCES = tst_qfileinfo.cpp
 RESOURCES += qfileinfo.qrc \
     testdata.qrc
 
-win32:!winrt:LIBS += -ladvapi32 -lnetapi32
-
-win32: CONFIG += insignificant_test # Crashes on Windows in release builds
+win32:!wince:!winrt:LIBS += -ladvapi32 -lnetapi32
diff --git a/tests/auto/corelib/io/qtemporaryfile/tst_qtemporaryfile.cpp b/tests/auto/corelib/io/qtemporaryfile/tst_qtemporaryfile.cpp
index 921136e79b..9b46121981 100644
--- a/tests/auto/corelib/io/qtemporaryfile/tst_qtemporaryfile.cpp
+++ b/tests/auto/corelib/io/qtemporaryfile/tst_qtemporaryfile.cpp
@@ -29,6 +29,7 @@
 #include <QtTest/QtTest>
 #include <qcoreapplication.h>
 #include <qstring.h>
+#include <qtemporarydir.h>
 #include <qtemporaryfile.h>
 #include <qfile.h>
 #include <qdir.h>
@@ -81,13 +82,15 @@ private slots:
     void QTBUG_4796();
     void guaranteeUnique();
 private:
+    QTemporaryDir m_temporaryDir;
     QString m_previousCurrent;
 };
 
 void tst_QTemporaryFile::initTestCase()
 {
+    QVERIFY2(m_temporaryDir.isValid(), qPrintable(m_temporaryDir.errorString()));
     m_previousCurrent = QDir::currentPath();
-    QDir::setCurrent(QDir::tempPath());
+    QVERIFY(QDir::setCurrent(m_temporaryDir.path()));
 
     // For QTBUG_4796
     QVERIFY(QDir("test-XXXXXX").exists() || QDir().mkdir("test-XXXXXX"));
@@ -114,9 +117,6 @@ void tst_QTemporaryFile::initTestCase()
 
 void tst_QTemporaryFile::cleanupTestCase()
 {
-    // From QTBUG_4796
-    QVERIFY(QDir().rmdir("test-XXXXXX"));
-
     QDir::setCurrent(m_previousCurrent);
 }
 
diff --git a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
index d1d3738879..81d902ad20 100644
--- a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
+++ b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
@@ -129,11 +129,13 @@ private slots:
     void returnValue2_data();
     void returnValue2();
     void connectVirtualSlots();
+    void connectSlotsVMIClass();  // VMI = Virtual or Multiple Inheritance
     void connectPrivateSlots();
     void connectFunctorArgDifference();
     void connectFunctorOverloads();
     void connectFunctorQueued();
     void connectFunctorWithContext();
+    void connectFunctorWithContextUnique();
     void connectFunctorDeadlock();
     void connectStaticSlotWithObject();
     void disconnectDoesNotLeakFunctor();
@@ -5602,6 +5604,112 @@ void tst_QObject::connectVirtualSlots()
     */
 }
 
+struct VirtualBase
+{
+    int virtual_base_count;
+    VirtualBase() : virtual_base_count(0) {}
+    virtual ~VirtualBase() {}
+    virtual void slot2() = 0;
+};
+
+class ObjectWithVirtualBase : public VirtualSlotsObject, public virtual VirtualBase
+{
+    Q_OBJECT
+public:
+    ObjectWithVirtualBase() : regular_call_count(0), derived_counter2(0) {}
+    int regular_call_count;
+    int derived_counter2;
+
+public slots:
+    void regularSlot() { ++regular_call_count; }
+    virtual void slot1() { ++derived_counter2; }
+    virtual void slot2() { ++virtual_base_count; }
+};
+
+// VMI = Virtual or Multiple Inheritance
+// (in this case, both)
+void tst_QObject::connectSlotsVMIClass()
+{
+    // test connecting by the base
+    {
+        ObjectWithVirtualBase obj;
+        QVERIFY( QObject::connect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &VirtualSlotsObjectBase::slot1, Qt::UniqueConnection));
+        QVERIFY(!QObject::connect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &VirtualSlotsObjectBase::slot1, Qt::UniqueConnection));
+
+        emit obj.signal1();
+        QCOMPARE(obj.base_counter1, 0);
+        QCOMPARE(obj.derived_counter1, 0);
+        QCOMPARE(obj.derived_counter2, 1);
+        QCOMPARE(obj.virtual_base_count, 0);
+
+        QVERIFY(QObject::disconnect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &VirtualSlotsObjectBase::slot1));
+        QVERIFY(!QObject::disconnect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &VirtualSlotsObjectBase::slot1));
+
+        emit obj.signal1();
+        QCOMPARE(obj.base_counter1, 0);
+        QCOMPARE(obj.derived_counter1, 0);
+        QCOMPARE(obj.derived_counter2, 1);
+        QCOMPARE(obj.virtual_base_count, 0);
+    }
+
+    // test connecting with the actual class
+    {
+        ObjectWithVirtualBase obj;
+        QVERIFY( QObject::connect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &ObjectWithVirtualBase::regularSlot, Qt::UniqueConnection));
+        QVERIFY(!QObject::connect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &ObjectWithVirtualBase::regularSlot, Qt::UniqueConnection));
+        QVERIFY( QObject::connect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &ObjectWithVirtualBase::slot1, Qt::UniqueConnection));
+        QVERIFY(!QObject::connect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &ObjectWithVirtualBase::slot1, Qt::UniqueConnection));
+
+        emit obj.signal1();
+        QCOMPARE(obj.base_counter1, 0);
+        QCOMPARE(obj.derived_counter1, 0);
+        QCOMPARE(obj.derived_counter2, 1);
+        QCOMPARE(obj.regular_call_count, 1);
+        QCOMPARE(obj.virtual_base_count, 0);
+
+        QVERIFY( QObject::disconnect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &ObjectWithVirtualBase::regularSlot));
+        QVERIFY(!QObject::disconnect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &ObjectWithVirtualBase::regularSlot));
+        QVERIFY( QObject::disconnect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &ObjectWithVirtualBase::slot1));
+        QVERIFY(!QObject::disconnect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &ObjectWithVirtualBase::slot1));
+
+        emit obj.signal1();
+        QCOMPARE(obj.base_counter1, 0);
+        QCOMPARE(obj.derived_counter1, 0);
+        QCOMPARE(obj.derived_counter2, 1);
+        QCOMPARE(obj.regular_call_count, 1);
+        QCOMPARE(obj.virtual_base_count, 0);
+
+        /* the C++ standard say the comparison between pointer to virtual member function is unspecified
+        QVERIFY( QObject::connect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &VirtualSlotsObjectBase::slot1, Qt::UniqueConnection));
+        QVERIFY(!QObject::connect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &ObjectWithVirtualBase::slot1, Qt::UniqueConnection));
+        */
+    }
+
+    // test connecting a slot that is virtual from the virtual base
+    {
+        ObjectWithVirtualBase obj;
+        QVERIFY( QObject::connect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &ObjectWithVirtualBase::slot2, Qt::UniqueConnection));
+        QVERIFY(!QObject::connect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &ObjectWithVirtualBase::slot2, Qt::UniqueConnection));
+
+        emit obj.signal1();
+        QCOMPARE(obj.base_counter1, 0);
+        QCOMPARE(obj.derived_counter1, 0);
+        QCOMPARE(obj.derived_counter2, 0);
+        QCOMPARE(obj.virtual_base_count, 1);
+        QCOMPARE(obj.regular_call_count, 0);
+
+        QVERIFY( QObject::disconnect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &ObjectWithVirtualBase::slot2));
+        QVERIFY(!QObject::disconnect(&obj, &VirtualSlotsObjectBase::signal1, &obj, &ObjectWithVirtualBase::slot2));
+
+        emit obj.signal1();
+        QCOMPARE(obj.base_counter1, 0);
+        QCOMPARE(obj.derived_counter1, 0);
+        QCOMPARE(obj.derived_counter2, 0);
+        QCOMPARE(obj.virtual_base_count, 1);
+        QCOMPARE(obj.regular_call_count, 0);
+    }
+}
+
 #ifndef QT_BUILD_INTERNAL
 void tst_QObject::connectPrivateSlots()
 {QSKIP("Needs QT_BUILD_INTERNAL");}
@@ -5888,6 +5996,22 @@ void tst_QObject::deleteLaterInAboutToBlockHandler()
     QCOMPARE(statusAboutToBlock, 2);
 }
 
+void tst_QObject::connectFunctorWithContextUnique()
+{
+    // Qt::UniqueConnections currently don't work for functors, but we need to
+    // be sure that they don't crash. If that is implemented, change this test.
+
+    SenderObject sender;
+    ReceiverObject receiver;
+    QObject::connect(&sender, &SenderObject::signal1, &receiver, &ReceiverObject::slot1);
+    receiver.count_slot1 = 0;
+
+    QObject::connect(&sender, &SenderObject::signal1, &receiver, SlotFunctor(), Qt::UniqueConnection);
+
+    sender.emitSignal1();
+    QCOMPARE(receiver.count_slot1, 1);
+}
+
 class MyFunctor
 {
 public:
diff --git a/tests/auto/corelib/plugin/qplugin/qplugin.pro b/tests/auto/corelib/plugin/qplugin/qplugin.pro
index 918ffb44bd..5283c2d52b 100644
--- a/tests/auto/corelib/plugin/qplugin/qplugin.pro
+++ b/tests/auto/corelib/plugin/qplugin/qplugin.pro
@@ -1,27 +1,17 @@
-QT = core
 TEMPLATE = subdirs
+TESTPLUGINS =
+
 win32 {
-    exists($$[QT_INSTALL_LIBS/get]/QtCore4.dll) {
-        SUBDIRS = releaseplugin
-    }
-    exists($$[QT_INSTALL_LIBS/get]/QtCored4.dll) {
-        SUBDIRS += debugplugin
-    }
-}
-mac {
-    CONFIG(debug, debug|release): {
-         SUBDIRS += debugplugin 
-         tst_qplugin_pro.depends += debugplugin
-    }
-    CONFIG(release, debug|release): {
-        SUBDIRS += releaseplugin 
-        tst_qplugin_pro.depends += releaseplugin
-    }
+    contains(QT_CONFIG, debug): TESTPLUGINS += debugplugin
+    contains(QT_CONFIG, release): TESTPLUGINS += releaseplugin
+} else:osx {
+    CONFIG(debug, debug|release): TESTPLUGINS += debugplugin
+    CONFIG(release, debug|release): TESTPLUGINS += releaseplugin
+} else {
+    TESTPLUGINS = debugplugin releaseplugin
 }
-!win32:!mac:{
-    SUBDIRS = debugplugin releaseplugin
-    tst_qplugin_pro.depends += debugplugin releaseplugin
-} 
-SUBDIRS += tst_qplugin.pro
 
+SUBDIRS += main $$TESTPLUGINS
+main.file = tst_qplugin.pro
+main.depends = $$TESTPLUGINS
 
diff --git a/tests/auto/corelib/tools/qbytearray/tst_qbytearray.cpp b/tests/auto/corelib/tools/qbytearray/tst_qbytearray.cpp
index 586a4446b4..88c505601a 100644
--- a/tests/auto/corelib/tools/qbytearray/tst_qbytearray.cpp
+++ b/tests/auto/corelib/tools/qbytearray/tst_qbytearray.cpp
@@ -104,7 +104,7 @@ private slots:
     void number();
     void toInt_data();
     void toInt();
-    void qAllocMore();
+    void blockSizeCalculations();
 
     void resizeAfterFromRawData();
     void appendAfterFromRawData();
@@ -1334,28 +1334,80 @@ void tst_QByteArray::toULongLong()
     QCOMPARE(b, ok);
 }
 
-// global function defined in qbytearray.cpp
-void tst_QByteArray::qAllocMore()
+static bool checkSize(size_t value, uint min)
 {
-    using QT_PREPEND_NAMESPACE(qAllocMore);
+    return value >= min && value <= INT_MAX;
+}
 
+// global functions defined in qbytearray.cpp
+void tst_QByteArray::blockSizeCalculations()
+{
     // Not very important, but please behave :-)
-    QVERIFY(qAllocMore(0, 0) >= 0);
-
-    for (int i = 1; i < 1 << 8; i <<= 1)
-        QVERIFY(qAllocMore(i, 0) >= i);
-
-    for (int i = 1 << 8; i < 1 << 30; i <<= 1) {
-        const int alloc = qAllocMore(i, 0);
+    QCOMPARE(qCalculateBlockSize(0, 1), size_t(0));
+    QVERIFY(qCalculateGrowingBlockSize(0, 1).size <= MaxAllocSize);
+    QVERIFY(qCalculateGrowingBlockSize(0, 1).elementCount <= MaxAllocSize);
+
+    // boundary condition
+    QCOMPARE(qCalculateBlockSize(MaxAllocSize, 1), size_t(MaxAllocSize));
+    QCOMPARE(qCalculateBlockSize(MaxAllocSize/2, 2), size_t(MaxAllocSize) - 1);
+    QCOMPARE(qCalculateBlockSize(MaxAllocSize/2, 2, 1), size_t(MaxAllocSize));
+    QCOMPARE(qCalculateGrowingBlockSize(MaxAllocSize, 1).size, size_t(MaxAllocSize));
+    QCOMPARE(qCalculateGrowingBlockSize(MaxAllocSize, 1).elementCount, size_t(MaxAllocSize));
+    QCOMPARE(qCalculateGrowingBlockSize(MaxAllocSize/2, 2, 1).size, size_t(MaxAllocSize));
+    QCOMPARE(qCalculateGrowingBlockSize(MaxAllocSize/2, 2, 1).elementCount, size_t(MaxAllocSize)/2);
+
+    // error conditions
+    QCOMPARE(qCalculateBlockSize(uint(MaxAllocSize) + 1, 1), size_t(~0));
+    QCOMPARE(qCalculateBlockSize(size_t(-1), 1), size_t(~0));
+    QCOMPARE(qCalculateBlockSize(MaxAllocSize, 1, 1), size_t(~0));
+    QCOMPARE(qCalculateBlockSize(MaxAllocSize/2 + 1, 2), size_t(~0));
+    QCOMPARE(qCalculateGrowingBlockSize(uint(MaxAllocSize) + 1, 1).size, size_t(~0));
+    QCOMPARE(qCalculateGrowingBlockSize(MaxAllocSize/2 + 1, 2).size, size_t(~0));
+
+    // overflow conditions
+    // on 32-bit platforms, (1 << 16) * (1 << 16) = (1 << 32) which is zero
+    QCOMPARE(qCalculateBlockSize(1 << 16, 1 << 16), size_t(~0));
+    QCOMPARE(qCalculateBlockSize(MaxAllocSize/4, 16), size_t(~0));
+    // on 32-bit platforms, (1 << 30) * 3 + (1 << 30) would overflow to zero
+    QCOMPARE(qCalculateBlockSize(1U << 30, 3, 1U << 30), size_t(~0));
+
+    // exact block sizes
+    for (int i = 1; i < 1 << 31; i <<= 1) {
+        QCOMPARE(qCalculateBlockSize(0, 1, i), size_t(i));
+        QCOMPARE(qCalculateBlockSize(i, 1), size_t(i));
+        QCOMPARE(qCalculateBlockSize(i + i/2, 1), size_t(i + i/2));
+    }
+    for (int i = 1; i < 1 << 30; i <<= 1) {
+        QCOMPARE(qCalculateBlockSize(i, 2), 2 * size_t(i));
+        QCOMPARE(qCalculateBlockSize(i, 2, 1), 2 * size_t(i) + 1);
+        QCOMPARE(qCalculateBlockSize(i, 2, 16), 2 * size_t(i) + 16);
+    }
 
-        QVERIFY(alloc >= i);
-        QCOMPARE(qAllocMore(i - 8, 8), alloc - 8);
-        QCOMPARE(qAllocMore(i - 16, 16), alloc - 16);
-        QCOMPARE(qAllocMore(i - 24, 24), alloc - 24);
-        QCOMPARE(qAllocMore(i - 32, 32), alloc - 32);
+    // growing sizes
+    for (int i = 1; i < 1 << 31; i <<= 1) {
+        QVERIFY(checkSize(qCalculateGrowingBlockSize(i, 1).size, i));
+        QVERIFY(checkSize(qCalculateGrowingBlockSize(i, 1).elementCount, i));
+        QVERIFY(checkSize(qCalculateGrowingBlockSize(i, 1, 16).size, i));
+        QVERIFY(checkSize(qCalculateGrowingBlockSize(i, 1, 16).elementCount, i));
+        QVERIFY(checkSize(qCalculateGrowingBlockSize(i, 1, 24).size, i));
+        QVERIFY(checkSize(qCalculateGrowingBlockSize(i, 1, 16).elementCount, i));
+    }
 
-        QVERIFY(qAllocMore(i - 1, 0) >= i - 1);
-        QVERIFY(qAllocMore(i + 1, 0) >= i + 1);
+    // growth should be limited
+    for (int elementSize = 1; elementSize < (1<<8); elementSize <<= 1) {
+        size_t alloc = 1;
+        forever {
+            QVERIFY(checkSize(qCalculateGrowingBlockSize(alloc, elementSize).size, alloc * elementSize));
+            size_t newAlloc = qCalculateGrowingBlockSize(alloc, elementSize).elementCount;
+            QVERIFY(checkSize(newAlloc, alloc));
+            if (newAlloc == alloc)
+                break;  // no growth, we're at limit
+            alloc = newAlloc;
+        }
+        QVERIFY(checkSize(alloc, size_t(MaxAllocSize) / elementSize));
+
+        // the next allocation should be invalid
+        QCOMPARE(qCalculateGrowingBlockSize(alloc + 1, elementSize).size, size_t(~0));
     }
 }
 
diff --git a/tests/auto/corelib/tools/qtimezone/tst_qtimezone.cpp b/tests/auto/corelib/tools/qtimezone/tst_qtimezone.cpp
index 9fd418742c..c631b395f8 100644
--- a/tests/auto/corelib/tools/qtimezone/tst_qtimezone.cpp
+++ b/tests/auto/corelib/tools/qtimezone/tst_qtimezone.cpp
@@ -842,6 +842,16 @@ void tst_QTimeZone::tzTest()
     QTzTimeZonePrivate::Data datatz2 = tztz2.data(std);
     QTzTimeZonePrivate::Data datautc2 = tzutc2.data(std);
     QCOMPARE(datatz2.offsetFromUtc, datautc2.offsetFromUtc);
+
+    // Test a timezone with a name that isn't all letters
+    QTzTimeZonePrivate tzBarnaul("Asia/Barnaul");
+    if (tzBarnaul.isValid()) {
+        QCOMPARE(tzBarnaul.data(std).abbreviation, QString("+07"));
+
+        // first full day of the new rule (tzdata2016b)
+        QDateTime dt(QDate(2016, 3, 28), QTime(0, 0, 0), Qt::UTC);
+        QCOMPARE(tzBarnaul.data(dt.toMSecsSinceEpoch()).abbreviation, QString("+07"));
+    }
 #endif // Q_OS_UNIX
 }
 
diff --git a/tests/auto/corelib/xml/qxmlstream/tst_qxmlstream.cpp b/tests/auto/corelib/xml/qxmlstream/tst_qxmlstream.cpp
index 8a153a4599..26d443c2c6 100644
--- a/tests/auto/corelib/xml/qxmlstream/tst_qxmlstream.cpp
+++ b/tests/auto/corelib/xml/qxmlstream/tst_qxmlstream.cpp
@@ -556,6 +556,7 @@ private slots:
     void checkCommentIndentation() const;
     void checkCommentIndentation_data() const;
     void crashInXmlStreamReader() const;
+    void write8bitCodec() const;
     void hasError() const;
 
 private:
@@ -1576,5 +1577,43 @@ void tst_QXmlStream::hasError() const
 
 }
 
+void tst_QXmlStream::write8bitCodec() const
+{
+    QBuffer outBuffer;
+    QVERIFY(outBuffer.open(QIODevice::WriteOnly));
+    QXmlStreamWriter writer(&outBuffer);
+    writer.setAutoFormatting(false);
+
+    QTextCodec *codec = QTextCodec::codecForName("IBM500");
+    if (!codec) {
+        QSKIP("Encoding IBM500 not available.");
+    }
+    writer.setCodec(codec);
+
+    writer.writeStartDocument();
+    writer.writeStartElement("root");
+    writer.writeAttribute("attrib", "1");
+    writer.writeEndElement();
+    writer.writeEndDocument();
+    outBuffer.close();
+
+    // test 8 bit encoding
+    QByteArray values = outBuffer.data();
+    QVERIFY(values.size() > 1);
+    // check '<'
+    QCOMPARE(values[0] & 0x00FF, 0x4c);
+    // check '?'
+    QCOMPARE(values[1] & 0x00FF, 0x6F);
+
+    // convert the start of the XML
+    const QString expected = ("<?xml version=\"1.0\" encoding=\"IBM500\"?>");
+    QTextDecoder *decoder = codec->makeDecoder();
+    QVERIFY(decoder);
+    QString decodedText = decoder->toUnicode(values);
+    delete decoder;
+    QVERIFY(decodedText.startsWith(expected));
+}
+
+
 #include "tst_qxmlstream.moc"
 // vim: et:ts=4:sw=4:sts=4