Merge dev into 5.8

Change-Id: I41ee7b50534b01cf042bed8bb8824ba2e5026a29
author: Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com> 2016-08-22 11:30:00 +0200
committer: Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com> 2016-08-22 11:30:01 +0200
commit: d314819fc02139e05e16c56657898c704f7fb48f (patch)
tree: a61ba968233634948401c8339f9613844de1c2b5 /tests/auto
parent: 9f888d2fde9c5413e5519e0914e9b13638760985 (diff)
parent: e0e9e196a72ffe5457034894eaaadc90ed0d34ef (diff)
109 files changed, 1578 insertions, 640 deletions
diff --git a/tests/auto/auto.pro b/tests/auto/auto.pro
index 8a3c39e9b1..cadd97fb3a 100644
--- a/tests/auto/auto.pro
+++ b/tests/auto/auto.pro
@@ -34,7 +34,7 @@ cross_compile:                              SUBDIRS -= tools cmake installed_cma
 # Disable the QtDBus tests if we can't connect to the session bus
 !cross_compile:qtHaveModule(dbus) {
     !system("dbus-send --session --type=signal / local.AutotestCheck.Hello >/dev/null 2>&1") {
-        contains(QT_CONFIG, dbus-linked): \
+        qtConfig(dbus-linked): \
             error("QtDBus is enabled but session bus is not available. Please check the installation.")
         else: \
             warning("QtDBus is enabled with runtime support, but session bus is not available. Skipping QtDBus tests.")
diff --git a/tests/auto/corelib/global/qflags/qflags.pro b/tests/auto/corelib/global/qflags/qflags.pro
index 29dfb0684c..c3c11fa81b 100644
--- a/tests/auto/corelib/global/qflags/qflags.pro
+++ b/tests/auto/corelib/global/qflags/qflags.pro
@@ -2,5 +2,5 @@ CONFIG += testcase
 TARGET = tst_qflags
 QT = core testlib
 SOURCES = tst_qflags.cpp
-contains(QT_CONFIG, c++11): CONFIG += c++11
-contains(QT_CONFIG, c++14): CONFIG += c++14
+qtConfig(c++11): CONFIG += c++11
+qtConfig(c++14): CONFIG += c++14
diff --git a/tests/auto/corelib/global/qlogging/test/test.pro b/tests/auto/corelib/global/qlogging/test/test.pro
index b5b75be3a6..93eee7307a 100644
--- a/tests/auto/corelib/global/qlogging/test/test.pro
+++ b/tests/auto/corelib/global/qlogging/test/test.pro
@@ -1,7 +1,7 @@
 CONFIG += testcase
 CONFIG -= app_bundle debug_and_release_target
-contains(QT_CONFIG, c++11): CONFIG += c++11
-contains(QT_CONFIG, c++14): CONFIG += c++14
+qtConfig(c++11): CONFIG += c++11
+qtConfig(c++14): CONFIG += c++14
 TARGET = ../tst_qlogging
 QT = core testlib
 SOURCES = ../tst_qlogging.cpp
diff --git a/tests/auto/corelib/io/io.pro b/tests/auto/corelib/io/io.pro
index 24c762ed84..0542833456 100644
--- a/tests/auto/corelib/io/io.pro
+++ b/tests/auto/corelib/io/io.pro
@@ -49,14 +49,14 @@ SUBDIRS=\
     qprocess \
     qtextstream
 
-!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
     qabstractfileengine \
     qfileinfo \
     qipaddress \
     qurlinternal \
     qloggingregistry
 
-win32:!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+win32:!qtConfig(private_tests): SUBDIRS -= \
     qfilesystementry
 
 winrt: SUBDIRS -= \
diff --git a/tests/auto/corelib/io/qfile/tst_qfile.cpp b/tests/auto/corelib/io/qfile/tst_qfile.cpp
index 4c9986d50e..021d581aac 100644
--- a/tests/auto/corelib/io/qfile/tst_qfile.cpp
+++ b/tests/auto/corelib/io/qfile/tst_qfile.cpp
@@ -155,10 +155,12 @@ private slots:
     void copyRemovesTemporaryFile() const;
     void copyShouldntOverwrite();
     void copyFallback();
+#ifndef Q_OS_WINRT
     void link();
     void linkToDir();
     void absolutePathLinkToRelativePath();
     void readBrokenLink();
+#endif
     void readTextFile_data();
     void readTextFile();
     void readTextFile2();
@@ -568,7 +570,7 @@ void tst_QFile::open()
         QSKIP("Running this test as root doesn't make sense");
 #endif
 
-#if defined(Q_OS_WIN32)
+#if defined(Q_OS_WIN32) || defined(Q_OS_WINRT)
     QEXPECT_FAIL("noreadfile", "Windows does not currently support non-readable files.", Abort);
 #endif
     if (filename.isEmpty())
@@ -1226,7 +1228,7 @@ void tst_QFile::permissions()
         QFile::remove(file);
     }
 
-#ifdef Q_OS_WIN
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINRT)
     if (qt_ntfs_permission_lookup)
         QEXPECT_FAIL("readonly", "QTBUG-25630", Abort);
 #endif
@@ -1413,6 +1415,7 @@ static QString getWorkingDirectoryForLink(const QString &linkFileName)
 }
 #endif
 
+#ifndef Q_OS_WINRT
 void tst_QFile::link()
 {
     QFile::remove("myLink.lnk");
@@ -1433,7 +1436,7 @@ void tst_QFile::link()
 
     QCOMPARE(QFile::symLinkTarget("myLink.lnk"), referenceTarget);
 
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINRT)
+#if defined(Q_OS_WIN)
     QString wd = getWorkingDirectoryForLink(info2.absoluteFilePath());
     QCOMPARE(QDir::fromNativeSeparators(wd), QDir::cleanPath(info1.absolutePath()));
 #endif
@@ -1487,6 +1490,7 @@ void tst_QFile::readBrokenLink()
     QVERIFY(QFile::link("ole/..", "myLink2.lnk"));
     QCOMPARE(QFileInfo("myLink2.lnk").symLinkTarget(), QDir::currentPath());
 }
+#endif // Q_OS_WINRT
 
 void tst_QFile::readTextFile_data()
 {
@@ -2505,7 +2509,7 @@ void tst_QFile::rename()
  \since 4.5
 
  Some special files have QFile::atEnd() returning true, even though there is
- more data available. True for corner cases, as well as some mounts on OS X.
+ more data available. True for corner cases, as well as some mounts on \macos.
 
  Here, we reproduce that condition by having a QFile sub-class with this
  peculiar atEnd() behavior.
diff --git a/tests/auto/corelib/io/qprocess/tst_qprocess.cpp b/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
index 0bc1e77925..3f3533c9a1 100644
--- a/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
+++ b/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
@@ -734,6 +734,7 @@ void tst_QProcess::restartProcess()
 
 void tst_QProcess::closeWriteChannel()
 {
+    QByteArray testData("Data to read");
     QProcess more;
     more.start("testProcessEOF/testProcessEOF");
 
@@ -741,19 +742,21 @@ void tst_QProcess::closeWriteChannel()
     QVERIFY(!more.waitForReadyRead(250));
     QCOMPARE(more.error(), QProcess::Timedout);
 
-    QVERIFY(more.write("Data to read") != -1);
+    QCOMPARE(more.write(testData), qint64(testData.size()));
 
     QVERIFY(!more.waitForReadyRead(250));
     QCOMPARE(more.error(), QProcess::Timedout);
 
     more.closeWriteChannel();
-
-    QVERIFY(more.waitForReadyRead(5000));
-    QVERIFY(more.readAll().startsWith("Data to read"));
+    // During closeWriteChannel() call, we might also get an I/O completion
+    // on the read pipe. So, take this into account before waiting for
+    // the new incoming data.
+    while (more.bytesAvailable() < testData.size())
+        QVERIFY(more.waitForReadyRead(5000));
+    QCOMPARE(more.readAll(), testData);
 
     if (more.state() == QProcess::Running)
-        more.write("q");
-    QVERIFY(more.waitForFinished(5000));
+        QVERIFY(more.waitForFinished(5000));
     QCOMPARE(more.exitStatus(), QProcess::NormalExit);
     QCOMPARE(more.exitCode(), 0);
 }
diff --git a/tests/auto/corelib/io/qurl/tst_qurl.cpp b/tests/auto/corelib/io/qurl/tst_qurl.cpp
index e982660bef..f589fe1d6d 100644
--- a/tests/auto/corelib/io/qurl/tst_qurl.cpp
+++ b/tests/auto/corelib/io/qurl/tst_qurl.cpp
@@ -898,13 +898,11 @@ void tst_QUrl::resolving_data()
 
     // Some parsers allow the scheme name to be present in a relative URI
     // reference if it is the same as the base URI scheme.  This is
-    // considered to be a loophole in prior specifications of partial URI
-    // [RFC1630]. Its use should be avoided, but is allowed for backward
-    // compatibility.
-    // For strict parsers :
-//    QTest::newRow("http:g [for strict parsers]")         << QString::fromLatin1("http://a/b/c/d;p?q") << QString::fromLatin1("http:g") << QString::fromLatin1("http:g");
-    // For backward compatibility :
-    QTest::newRow("http:g [for backward compatibility]") << QString::fromLatin1("http://a/b/c/d;p?q") << QString::fromLatin1("http:g") << QString::fromLatin1("http://a/b/c/g");
+    // considered to be a loophole in prior specifications of partial URI [RFC1630],
+    //QTest::newRow("http:g [for backward compatibility]") << QString::fromLatin1("http://a/b/c/d;p?q") << QString::fromLatin1("http:g") << QString::fromLatin1("http://a/b/c/g");
+    // However we don't do that anymore, as per RFC3986, in order for the data:subpage testcase below to work.
+    QTest::newRow("http:g")       << QString::fromLatin1("http://a/b/c/d;p?q") << QString::fromLatin1("http:g") << QString::fromLatin1("http:g");
+    QTest::newRow("data:subpage") << QString::fromLatin1("data:text/plain, main page") << QString::fromLatin1("data:text/plain, subpage") << QString::fromLatin1("data:text/plain, subpage");
 
     // Resolve relative with relative
     QTest::newRow("../a (1)")  << QString::fromLatin1("b") << QString::fromLatin1("../a")  << QString::fromLatin1("a");
@@ -916,6 +914,10 @@ void tst_QUrl::resolving_data()
     QTest::newRow("../a (6)")  << QString::fromLatin1("/b/a") << QString::fromLatin1("../a")  << QString::fromLatin1("/a");
     QTest::newRow("../a (7)")  << QString::fromLatin1("/b/c/a") << QString::fromLatin1("../a")  << QString::fromLatin1("/b/a");
     QTest::newRow("../a (8)")  << QString::fromLatin1("/b") << QString::fromLatin1("/a")  << QString::fromLatin1("/a");
+
+    // More tests from KDE
+    QTest::newRow("brackets")  << QString::fromLatin1("http://www.calorieking.com/personal/diary/") << QString::fromLatin1("/personal/diary/rpc.php?C=jsrs1&F=getDiaryDay&P0=[2006-3-8]&U=1141858921458") << QString::fromLatin1("http://www.calorieking.com/personal/diary/rpc.php?C=jsrs1&F=getDiaryDay&P0=[2006-3-8]&U=1141858921458");
+    QTest::newRow("javascript")<< QString::fromLatin1("http://www.youtube.com/?v=JvOSnRD5aNk") << QString::fromLatin1("javascript:window.location+\"__flashplugin_unique__\"")  << QString::fromLatin1("javascript:window.location+%22__flashplugin_unique__%22");
 }
 
 void tst_QUrl::resolving()
diff --git a/tests/auto/corelib/io/qurlinternal/qurlinternal.pro b/tests/auto/corelib/io/qurlinternal/qurlinternal.pro
index ae5e023446..3828512dce 100644
--- a/tests/auto/corelib/io/qurlinternal/qurlinternal.pro
+++ b/tests/auto/corelib/io/qurlinternal/qurlinternal.pro
@@ -1,5 +1,5 @@
 CONFIG += testcase
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
 TARGET = tst_qurlinternal
 SOURCES += tst_qurlinternal.cpp ../../codecs/utf8/utf8data.cpp
 QT = core core-private testlib
diff --git a/tests/auto/corelib/itemmodels/qsortfilterproxymodel/tst_qsortfilterproxymodel.cpp b/tests/auto/corelib/itemmodels/qsortfilterproxymodel/tst_qsortfilterproxymodel.cpp
index 8e2d583961..38e3c6890d 100644
--- a/tests/auto/corelib/itemmodels/qsortfilterproxymodel/tst_qsortfilterproxymodel.cpp
+++ b/tests/auto/corelib/itemmodels/qsortfilterproxymodel/tst_qsortfilterproxymodel.cpp
@@ -143,6 +143,7 @@ private slots:
     void noMapAfterSourceDelete();
     void forwardDropApi();
     void canDropMimeData();
+    void filterHint();
 
 protected:
     void buildHierarchy(const QStringList &data, QAbstractItemModel *model);
@@ -2128,17 +2129,23 @@ void tst_QSortFilterProxyModel::changeSourceDataForwardsRoles_qtbug35440()
 
     QModelIndex index;
 
+    // QStringListModel doesn't distinguish between edit and display roles,
+    // so changing one always changes the other, too.
+    QVector<int> expectedChangedRoles;
+    expectedChangedRoles.append(Qt::DisplayRole);
+    expectedChangedRoles.append(Qt::EditRole);
+
     index = model.index(0, 0);
     QVERIFY(index.isValid());
     model.setData(index, QStringLiteral("teststring"), Qt::DisplayRole);
     QCOMPARE(spy.length(), 1);
-    QCOMPARE(spy.at(0).at(2).value<QVector<int> >(), QVector<int>() << Qt::DisplayRole);
+    QCOMPARE(spy.at(0).at(2).value<QVector<int> >(), expectedChangedRoles);
 
     index = model.index(1, 0);
     QVERIFY(index.isValid());
     model.setData(index, QStringLiteral("teststring2"), Qt::EditRole);
     QCOMPARE(spy.length(), 2);
-    QCOMPARE(spy.at(1).at(2).value<QVector<int> >(), QVector<int>() << Qt::EditRole);
+    QCOMPARE(spy.at(1).at(2).value<QVector<int> >(), expectedChangedRoles);
 }
 
 void tst_QSortFilterProxyModel::sortFilterRole()
@@ -3802,6 +3809,12 @@ void tst_QSortFilterProxyModel::moveSourceRows()
     QCOMPARE(filterBeforeParents.size(), 1);
     QCOMPARE(filterAfterParents.size(), 1);
 
+    QCOMPARE(
+        filterBeforeParentLayoutSpy.first().at(1).value<QAbstractItemModel::LayoutChangeHint>(),
+        QAbstractItemModel::NoLayoutChangeHint);
+    QCOMPARE(filterAfterParentLayoutSpy.first().at(1).value<QAbstractItemModel::LayoutChangeHint>(),
+             QAbstractItemModel::NoLayoutChangeHint);
+
     QCOMPARE(filterBothBeforeParentLayoutSpy.size(), 0);
     QCOMPARE(filterBothAfterParentLayoutSpy.size(), 0);
 }
@@ -4123,5 +4136,50 @@ void tst_QSortFilterProxyModel::resortingDoesNotBreakTreeModels()
     QCOMPARE(proxy.rowCount(pi1), 1);
 }
 
+void tst_QSortFilterProxyModel::filterHint()
+{
+    // test that a filtering model does not emit layoutChanged with a hint
+    QStringListModel model(QStringList() << "one"
+                                         << "two"
+                                         << "three"
+                                         << "four"
+                                         << "five"
+                                         << "six");
+    QSortFilterProxyModel proxy1;
+    proxy1.setSourceModel(&model);
+    proxy1.setSortRole(Qt::DisplayRole);
+    proxy1.setDynamicSortFilter(true);
+    proxy1.sort(0);
+
+    QSortFilterProxyModel proxy2;
+    proxy2.setSourceModel(&proxy1);
+    proxy2.setFilterRole(Qt::DisplayRole);
+    proxy2.setFilterRegExp("^[^ ]*$");
+    proxy2.setDynamicSortFilter(true);
+
+    QSignalSpy proxy1BeforeSpy(&proxy1, &QSortFilterProxyModel::layoutAboutToBeChanged);
+    QSignalSpy proxy1AfterSpy(&proxy1, &QSortFilterProxyModel::layoutChanged);
+    QSignalSpy proxy2BeforeSpy(&proxy2, &QSortFilterProxyModel::layoutAboutToBeChanged);
+    QSignalSpy proxy2AfterSpy(&proxy2, &QSortFilterProxyModel::layoutChanged);
+
+    model.setData(model.index(2), QStringLiteral("modified three"), Qt::DisplayRole);
+
+    // The first proxy was re-sorted as one item as changed.
+    QCOMPARE(proxy1BeforeSpy.size(), 1);
+    QCOMPARE(proxy1BeforeSpy.first().at(1).value<QAbstractItemModel::LayoutChangeHint>(),
+             QAbstractItemModel::VerticalSortHint);
+    QCOMPARE(proxy1AfterSpy.size(), 1);
+    QCOMPARE(proxy1AfterSpy.first().at(1).value<QAbstractItemModel::LayoutChangeHint>(),
+             QAbstractItemModel::VerticalSortHint);
+
+    // But the second proxy must not have the VerticalSortHint since an item was filtered
+    QCOMPARE(proxy2BeforeSpy.size(), 1);
+    QCOMPARE(proxy2BeforeSpy.first().at(1).value<QAbstractItemModel::LayoutChangeHint>(),
+             QAbstractItemModel::NoLayoutChangeHint);
+    QCOMPARE(proxy2AfterSpy.size(), 1);
+    QCOMPARE(proxy2AfterSpy.first().at(1).value<QAbstractItemModel::LayoutChangeHint>(),
+             QAbstractItemModel::NoLayoutChangeHint);
+}
+
 QTEST_MAIN(tst_QSortFilterProxyModel)
 #include "tst_qsortfilterproxymodel.moc"
diff --git a/tests/auto/corelib/itemmodels/qstringlistmodel/tst_qstringlistmodel.cpp b/tests/auto/corelib/itemmodels/qstringlistmodel/tst_qstringlistmodel.cpp
index 61dda782d8..f99241da3b 100644
--- a/tests/auto/corelib/itemmodels/qstringlistmodel/tst_qstringlistmodel.cpp
+++ b/tests/auto/corelib/itemmodels/qstringlistmodel/tst_qstringlistmodel.cpp
@@ -35,6 +35,8 @@
 #include "qmodellistener.h"
 #include <qstringlistmodel.h>
 
+#include <algorithm>
+
 void QModelListener::rowsAboutToBeRemovedOrInserted(const QModelIndex & parent, int start, int end )
 {
     for (int i = 0; start + i <= end; i++) {
@@ -75,6 +77,9 @@ private slots:
 
     void rowsAboutToBeInserted_rowsInserted();
     void rowsAboutToBeInserted_rowsInserted_data();
+
+    void setData_emits_both_roles_data();
+    void setData_emits_both_roles();
 };
 
 void tst_QStringListModel::rowsAboutToBeRemoved_rowsRemoved_data()
@@ -129,22 +134,19 @@ void tst_QStringListModel::rowsAboutToBeRemoved_rowsRemoved()
     QFETCH(QStringList, aboutto);
     QFETCH(QStringList, res);
 
-    QStringListModel *model = new QStringListModel(input);
-    QModelListener *pListener = new QModelListener(&aboutto, &res, model);
-    pListener->connect(model,       SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
-                       pListener,   SLOT(rowsAboutToBeRemovedOrInserted(QModelIndex,int,int))    );
+    QStringListModel model(input);
+    QModelListener listener(&aboutto, &res, &model);
+    connect(&model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
+            &listener, SLOT(rowsAboutToBeRemovedOrInserted(QModelIndex,int,int)));
 
-    pListener->connect(model,       SIGNAL(rowsRemoved(QModelIndex,int,int)),
-                       pListener,   SLOT(rowsRemovedOrInserted(QModelIndex,int,int))    );
+    connect(&model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
+            &listener, SLOT(rowsRemovedOrInserted(QModelIndex,int,int)));
 
-    model->removeRows(row,count);
+    model.removeRows(row, count);
     // At this point, control goes to our connected slots inn this order:
     // 1. rowsAboutToBeRemovedOrInserted
     // 2. rowsRemovedOrInserted
     // Control returns here
-
-    delete pListener;
-    delete model;
 }
 
 void tst_QStringListModel::rowsAboutToBeInserted_rowsInserted_data()
@@ -193,22 +195,59 @@ void tst_QStringListModel::rowsAboutToBeInserted_rowsInserted()
     QFETCH(QStringList, aboutto);
     QFETCH(QStringList, res);
 
-    QStringListModel *model = new QStringListModel(input);
-    QModelListener *pListener = new QModelListener(&aboutto, &res, model);
-    connect(model,       SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
-                       pListener,   SLOT(rowsAboutToBeRemovedOrInserted(QModelIndex,int,int))    );
+    QStringListModel model(input);
+    QModelListener listener(&aboutto, &res, &model);
+    connect(&model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
+            &listener, SLOT(rowsAboutToBeRemovedOrInserted(QModelIndex,int,int)));
 
-    connect(model,       SIGNAL(rowsInserted(QModelIndex,int,int)),
-                       pListener,   SLOT(rowsRemovedOrInserted(QModelIndex,int,int))    );
+    connect(&model, SIGNAL(rowsInserted(QModelIndex,int,int)),
+            &listener, SLOT(rowsRemovedOrInserted(QModelIndex,int,int)));
 
-    model->insertRows(row,count);
+    model.insertRows(row, count);
     // At this point, control goes to our connected slots inn this order:
     // 1. rowsAboutToBeRemovedOrInserted
     // 2. rowsRemovedOrInserted
     // Control returns here
+}
 
-    delete pListener;
-    delete model;
+void tst_QStringListModel::setData_emits_both_roles_data()
+{
+    QTest::addColumn<int>("row");
+    QTest::addColumn<QString>("data");
+    QTest::addColumn<int>("role");
+
+#define ROW(row, string, role) \
+    QTest::newRow(#row " -> " string) << row << QString(string) << int(Qt::role)
+    ROW(0, "1", EditRole);
+    ROW(1, "2", DisplayRole);
+#undef ROW
+}
+
+template <class C>
+C sorted(C c)
+{
+    std::sort(c.begin(), c.end());
+    return qMove(c);
+}
+
+void tst_QStringListModel::setData_emits_both_roles()
+{
+    QFETCH(int, row);
+    QFETCH(QString, data);
+    QFETCH(int, role);
+
+    QStringListModel model(QStringList() << "one" << "two");
+    QVector<int> expected;
+    expected.reserve(2);
+    expected.append(Qt::DisplayRole);
+    expected.append(Qt::EditRole);
+
+    QSignalSpy spy(&model, &QAbstractItemModel::dataChanged);
+    QVERIFY(spy.isValid());
+    model.setData(model.index(row, 0), data, role);
+    QCOMPARE(spy.size(), 1);
+    QCOMPARE(sorted(spy.at(0).at(2).value<QVector<int> >()),
+             expected);
 }
 
 QTEST_MAIN(tst_QStringListModel)
diff --git a/tests/auto/corelib/json/json.pro b/tests/auto/corelib/json/json.pro
index b3038d7ca1..dc9cd3e383 100644
--- a/tests/auto/corelib/json/json.pro
+++ b/tests/auto/corelib/json/json.pro
@@ -6,7 +6,7 @@ CONFIG += testcase
 !android:TESTDATA += bom.json test.json test.bjson test3.json test2.json
     else:RESOURCES += json.qrc
 
-!contains(QT_CONFIG, doubleconversion):!contains(QT_CONFIG, system-doubleconversion) {
+!qtConfig(doubleconversion):!qtConfig(system-doubleconversion) {
     DEFINES += QT_NO_DOUBLECONVERSION
 }
 
diff --git a/tests/auto/corelib/kernel/kernel.pro b/tests/auto/corelib/kernel/kernel.pro
index 431d483339..75b98bcd09 100644
--- a/tests/auto/corelib/kernel/kernel.pro
+++ b/tests/auto/corelib/kernel/kernel.pro
@@ -1,6 +1,7 @@
 TEMPLATE=subdirs
 SUBDIRS=\
     qcoreapplication \
+    qdeadlinetimer \
     qelapsedtimer \
     qeventdispatcher \
     qeventloop \
@@ -32,11 +33,11 @@ SUBDIRS=\
     qobject \
     qsocketnotifier
 
-!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
     qsocketnotifier \
     qsharedmemory
 
 # This test is only applicable on Windows
 !win32*|winrt: SUBDIRS -= qwineventnotifier
 
-android|uikit: SUBDIRS -= qsharedmemory qsystemsemaphore
+android|uikit: SUBDIRS -= qclipboard qobject qsharedmemory qsystemsemaphore
diff --git a/tests/auto/corelib/kernel/qcoreapplication/qcoreapplication.pro b/tests/auto/corelib/kernel/qcoreapplication/qcoreapplication.pro
index a49bb9ae1f..d166351490 100644
--- a/tests/auto/corelib/kernel/qcoreapplication/qcoreapplication.pro
+++ b/tests/auto/corelib/kernel/qcoreapplication/qcoreapplication.pro
@@ -3,4 +3,4 @@ TARGET = tst_qcoreapplication
 QT = core testlib core-private
 SOURCES = tst_qcoreapplication.cpp
 HEADERS = tst_qcoreapplication.h
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
diff --git a/tests/auto/corelib/kernel/qdeadlinetimer/qdeadlinetimer.pro b/tests/auto/corelib/kernel/qdeadlinetimer/qdeadlinetimer.pro
new file mode 100644
index 0000000000..12ad7dabc2
--- /dev/null
+++ b/tests/auto/corelib/kernel/qdeadlinetimer/qdeadlinetimer.pro
@@ -0,0 +1,5 @@
+CONFIG += testcase
+TARGET = tst_qdeadlinetimer
+QT = core testlib
+SOURCES = tst_qdeadlinetimer.cpp
+
diff --git a/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp b/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp
new file mode 100644
index 0000000000..7642604cfe
--- /dev/null
+++ b/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp
@@ -0,0 +1,625 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 Intel Corporation.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/QString>
+#include <QtCore/QTime>
+#include <QtCore/QDeadlineTimer>
+#include <QtTest/QtTest>
+
+#if QT_HAS_INCLUDE(<chrono>)
+#  include <chrono>
+#endif
+
+static const int minResolution = 100; // the minimum resolution for the tests
+
+Q_DECLARE_METATYPE(Qt::TimerType)
+
+class tst_QDeadlineTimer : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void initTestCase_data();
+    void basics();
+    void foreverness();
+    void current();
+    void deadlines();
+    void setDeadline();
+    void expire();
+    void stdchrono();
+};
+
+void tst_QDeadlineTimer::initTestCase_data()
+{
+    qRegisterMetaType<Qt::TimerType>();
+    QTest::addColumn<Qt::TimerType>("timerType");
+    QTest::newRow("precise") << Qt::PreciseTimer;
+    QTest::newRow("coarse") << Qt::CoarseTimer;
+}
+
+void tst_QDeadlineTimer::basics()
+{
+    QDeadlineTimer deadline;
+    QCOMPARE(deadline.timerType(), Qt::CoarseTimer);
+
+    QFETCH_GLOBAL(Qt::TimerType, timerType);
+    deadline = QDeadlineTimer(timerType);
+    QCOMPARE(deadline.timerType(), timerType);
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline, QDeadlineTimer(timerType));
+    QVERIFY(!(deadline != QDeadlineTimer(timerType)));
+    QVERIFY(!(deadline < QDeadlineTimer()));
+    QVERIFY(deadline <= QDeadlineTimer());
+    QVERIFY(deadline >= QDeadlineTimer());
+    QVERIFY(!(deadline > QDeadlineTimer()));
+    QVERIFY(!(deadline < deadline));
+    QVERIFY(deadline <= deadline);
+    QVERIFY(deadline >= deadline);
+    QVERIFY(!(deadline > deadline));
+
+    // should have expired, but we may be running too early after boot
+    QTRY_VERIFY_WITH_TIMEOUT(deadline.hasExpired(), 100);
+
+    QCOMPARE(deadline.remainingTime(), qint64(0));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(0));
+    QCOMPARE(deadline.deadline(), qint64(0));
+    QCOMPARE(deadline.deadlineNSecs(), qint64(0));
+
+    deadline.setRemainingTime(0, timerType);
+    QCOMPARE(deadline.remainingTime(), qint64(0));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(0));
+    QVERIFY(deadline.deadline() != 0);
+    QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max());
+    QVERIFY(deadline.deadlineNSecs() != 0);
+    QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max());
+
+    deadline.setPreciseRemainingTime(0, 0, timerType);
+    QCOMPARE(deadline.remainingTime(), qint64(0));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(0));
+    QVERIFY(deadline.deadline() != 0);
+    QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max());
+    QVERIFY(deadline.deadlineNSecs() != 0);
+    QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max());
+
+    deadline.setDeadline(0, timerType);
+    QCOMPARE(deadline.remainingTime(), qint64(0));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(0));
+    QCOMPARE(deadline.deadline(), qint64(0));
+    QCOMPARE(deadline.deadlineNSecs(), qint64(0));
+
+    deadline.setPreciseDeadline(0, 0, timerType);
+    QCOMPARE(deadline.remainingTime(), qint64(0));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(0));
+    QCOMPARE(deadline.deadline(), qint64(0));
+    QCOMPARE(deadline.deadlineNSecs(), qint64(0));
+}
+
+void tst_QDeadlineTimer::foreverness()
+{
+    QFETCH_GLOBAL(Qt::TimerType, timerType);
+    // we don't check whether timerType() is our type since it's possible it detects it's forever
+
+    QDeadlineTimer deadline = QDeadlineTimer::Forever;
+    QCOMPARE(deadline.timerType(), Qt::CoarseTimer);
+    QVERIFY(deadline.isForever());
+    QVERIFY(!deadline.hasExpired());
+    QCOMPARE(deadline.remainingTime(), qint64(-1));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(-1));
+    QCOMPARE(deadline.deadline(), std::numeric_limits<qint64>::max());
+    QCOMPARE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max());
+
+    deadline = QDeadlineTimer(-1, timerType);
+    QVERIFY(deadline.isForever());
+    QVERIFY(!deadline.hasExpired());
+    QCOMPARE(deadline.remainingTime(), qint64(-1));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(-1));
+    QCOMPARE(deadline.deadline(), std::numeric_limits<qint64>::max());
+    QCOMPARE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max());
+
+    deadline.setRemainingTime(-1, timerType);
+    QVERIFY(deadline.isForever());
+    QVERIFY(!deadline.hasExpired());
+    QCOMPARE(deadline.remainingTime(), qint64(-1));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(-1));
+    QCOMPARE(deadline.deadline(), std::numeric_limits<qint64>::max());
+    QCOMPARE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max());
+
+    deadline.setPreciseRemainingTime(-1, 0, timerType);
+    QVERIFY(deadline.isForever());
+    QVERIFY(!deadline.hasExpired());
+    QCOMPARE(deadline.remainingTime(), qint64(-1));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(-1));
+    QCOMPARE(deadline.deadline(), std::numeric_limits<qint64>::max());
+    QCOMPARE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max());
+
+    deadline.setPreciseRemainingTime(-1, -1, timerType);
+    QVERIFY(deadline.isForever());
+    QVERIFY(!deadline.hasExpired());
+    QCOMPARE(deadline.remainingTime(), qint64(-1));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(-1));
+    QCOMPARE(deadline.deadline(), std::numeric_limits<qint64>::max());
+    QCOMPARE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max());
+
+    deadline.setDeadline(std::numeric_limits<qint64>::max(), timerType);
+    QVERIFY(deadline.isForever());
+    QVERIFY(!deadline.hasExpired());
+    QCOMPARE(deadline.remainingTime(), qint64(-1));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(-1));
+    QCOMPARE(deadline.deadline(), std::numeric_limits<qint64>::max());
+    QCOMPARE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max());
+
+    deadline.setPreciseDeadline(std::numeric_limits<qint64>::max(), 0, timerType);
+    QVERIFY(deadline.isForever());
+    QVERIFY(!deadline.hasExpired());
+    QCOMPARE(deadline.remainingTime(), qint64(-1));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(-1));
+    QCOMPARE(deadline.deadline(), std::numeric_limits<qint64>::max());
+    QCOMPARE(deadline.deadlineNSecs(), std::numeric_limits<qint64>::max());
+
+    QCOMPARE(deadline, deadline);
+    QVERIFY(!(deadline < deadline));
+    QVERIFY(deadline <= deadline);
+    QVERIFY(deadline >= deadline);
+    QVERIFY(!(deadline > deadline));
+
+    // adding to forever must still be forever
+    QDeadlineTimer deadline2 = deadline + 1;
+    QVERIFY(deadline2.isForever());
+    QVERIFY(!deadline2.hasExpired());
+    QCOMPARE(deadline2.remainingTime(), qint64(-1));
+    QCOMPARE(deadline2.remainingTimeNSecs(), qint64(-1));
+    QCOMPARE(deadline2.deadline(), std::numeric_limits<qint64>::max());
+    QCOMPARE(deadline2.deadlineNSecs(), std::numeric_limits<qint64>::max());
+    QCOMPARE(deadline2.timerType(), deadline.timerType());
+
+    QCOMPARE(deadline2 - deadline, qint64(0));
+    QCOMPARE(deadline2, deadline);
+    QVERIFY(!(deadline2 < deadline));
+    QVERIFY(deadline2 <= deadline);
+    QVERIFY(deadline2 >= deadline);
+    QVERIFY(!(deadline2 > deadline));
+
+    // subtracting from forever is *also* forever
+    deadline2 = deadline - 1;
+    QVERIFY(deadline2.isForever());
+    QVERIFY(!deadline2.hasExpired());
+    QCOMPARE(deadline2.remainingTime(), qint64(-1));
+    QCOMPARE(deadline2.remainingTimeNSecs(), qint64(-1));
+    QCOMPARE(deadline2.deadline(), std::numeric_limits<qint64>::max());
+    QCOMPARE(deadline2.deadlineNSecs(), std::numeric_limits<qint64>::max());
+    QCOMPARE(deadline2.timerType(), deadline.timerType());
+
+    QCOMPARE(deadline2 - deadline, qint64(0));
+    QCOMPARE(deadline2, deadline);
+    QVERIFY(!(deadline2 < deadline));
+    QVERIFY(deadline2 <= deadline);
+    QVERIFY(deadline2 >= deadline);
+    QVERIFY(!(deadline2 > deadline));
+
+    // compare and order against a default-constructed object
+    QDeadlineTimer expired;
+    QVERIFY(!(deadline == expired));
+    QVERIFY(deadline != expired);
+    QVERIFY(!(deadline < expired));
+    QVERIFY(!(deadline <= expired));
+    QVERIFY(deadline >= expired);
+    QVERIFY(deadline > expired);
+}
+
+void tst_QDeadlineTimer::current()
+{
+    QFETCH_GLOBAL(Qt::TimerType, timerType);
+    auto deadline = QDeadlineTimer::current(timerType);
+    QVERIFY(deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    QCOMPARE(deadline.remainingTime(), qint64(0));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(0));
+    QVERIFY(deadline.deadline() != 0);
+    QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max());
+    QVERIFY(deadline.deadlineNSecs() != 0);
+    QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max());
+
+    // subtracting from current should be "more expired"
+    QDeadlineTimer earlierDeadline = deadline - 1;
+    QVERIFY(earlierDeadline.hasExpired());
+    QVERIFY(!earlierDeadline.isForever());
+    QCOMPARE(earlierDeadline.timerType(), timerType);
+    QCOMPARE(earlierDeadline.remainingTime(), qint64(0));
+    QCOMPARE(earlierDeadline.remainingTimeNSecs(), qint64(0));
+    QVERIFY(earlierDeadline.deadline() != 0);
+    QVERIFY(earlierDeadline.deadline() != std::numeric_limits<qint64>::max());
+    QVERIFY(earlierDeadline.deadlineNSecs() != 0);
+    QVERIFY(earlierDeadline.deadlineNSecs() != std::numeric_limits<qint64>::max());
+    QCOMPARE(earlierDeadline.deadline(), deadline.deadline() - 1);
+    QCOMPARE(earlierDeadline.deadlineNSecs(), deadline.deadlineNSecs() - 1000*1000);
+
+    QCOMPARE(earlierDeadline - deadline, qint64(-1));
+    QVERIFY(earlierDeadline != deadline);
+    QVERIFY(earlierDeadline < deadline);
+    QVERIFY(earlierDeadline <= deadline);
+    QVERIFY(!(earlierDeadline >= deadline));
+    QVERIFY(!(earlierDeadline > deadline));
+}
+
+void tst_QDeadlineTimer::deadlines()
+{
+    QFETCH_GLOBAL(Qt::TimerType, timerType);
+
+    QDeadlineTimer deadline(4 * minResolution, timerType);
+    QVERIFY(!deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    QVERIFY(deadline.remainingTime() > (3 * minResolution));
+    QVERIFY(deadline.remainingTime() <= (4 * minResolution));
+    QVERIFY(deadline.remainingTimeNSecs() > (3000000 * minResolution));
+    QVERIFY(deadline.remainingTimeNSecs() <= (4000000 * minResolution));
+    QVERIFY(deadline.deadline() != 0);
+    QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max());
+    QVERIFY(deadline.deadlineNSecs() != 0);
+    QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max());
+
+    deadline.setRemainingTime(4 * minResolution, timerType);
+    QVERIFY(!deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    QVERIFY(deadline.remainingTime() > (3 * minResolution));
+    QVERIFY(deadline.remainingTime() <= (4 * minResolution));
+    QVERIFY(deadline.remainingTimeNSecs() > (3000000 * minResolution));
+    QVERIFY(deadline.remainingTimeNSecs() <= (4000000 * minResolution));
+    QVERIFY(deadline.deadline() != 0);
+    QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max());
+    QVERIFY(deadline.deadlineNSecs() != 0);
+    QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max());
+
+    deadline.setPreciseRemainingTime(0, 4000000 * minResolution, timerType);
+    QVERIFY(!deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    QVERIFY(deadline.remainingTime() > (3 * minResolution));
+    QVERIFY(deadline.remainingTime() <= (4 * minResolution));
+    QVERIFY(deadline.remainingTimeNSecs() > (3000000 * minResolution));
+    QVERIFY(deadline.remainingTimeNSecs() <= (4000000 * minResolution));
+    QVERIFY(deadline.deadline() != 0);
+    QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max());
+    QVERIFY(deadline.deadlineNSecs() != 0);
+    QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max());
+
+    deadline.setPreciseRemainingTime(1, 0, timerType); // 1 sec
+    QVERIFY(!deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    QVERIFY(deadline.remainingTime() > (1000 - minResolution));
+    QVERIFY(deadline.remainingTime() <= 1000);
+    QVERIFY(deadline.remainingTimeNSecs() > (1000 - minResolution)*1000*1000);
+    QVERIFY(deadline.remainingTimeNSecs() <= (1000*1000*1000));
+    QVERIFY(deadline.deadline() != 0);
+    QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max());
+    QVERIFY(deadline.deadlineNSecs() != 0);
+    QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max());
+
+    // adding to a future deadline must still be further in the future
+    QDeadlineTimer laterDeadline = deadline + 1;
+    QVERIFY(!laterDeadline.hasExpired());
+    QVERIFY(!laterDeadline.isForever());
+    QCOMPARE(laterDeadline.timerType(), timerType);
+    QVERIFY(laterDeadline.remainingTime() > (1000 - minResolution));
+    QVERIFY(laterDeadline.remainingTime() <= 1001);
+    QVERIFY(laterDeadline.remainingTimeNSecs() > (1001 - minResolution)*1000*1000);
+    QVERIFY(laterDeadline.remainingTimeNSecs() <= (1001*1000*1000));
+    QVERIFY(laterDeadline.deadline() != 0);
+    QVERIFY(laterDeadline.deadline() != std::numeric_limits<qint64>::max());
+    QVERIFY(laterDeadline.deadlineNSecs() != 0);
+    QVERIFY(laterDeadline.deadlineNSecs() != std::numeric_limits<qint64>::max());
+    QCOMPARE(laterDeadline.deadline(), deadline.deadline() + 1);
+    QCOMPARE(laterDeadline.deadlineNSecs(), deadline.deadlineNSecs() + 1000*1000);
+
+    QCOMPARE(laterDeadline - deadline, qint64(1));
+    QVERIFY(laterDeadline != deadline);
+    QVERIFY(!(laterDeadline < deadline));
+    QVERIFY(!(laterDeadline <= deadline));
+    QVERIFY(laterDeadline >= deadline);
+    QVERIFY(laterDeadline > deadline);
+
+    // compare and order against a default-constructed object
+    QDeadlineTimer expired;
+    QVERIFY(!(deadline == expired));
+    QVERIFY(deadline != expired);
+    QVERIFY(!(deadline < expired));
+    QVERIFY(!(deadline <= expired));
+    QVERIFY(deadline >= expired);
+    QVERIFY(deadline > expired);
+
+    // compare and order against a forever deadline
+    QDeadlineTimer forever_(QDeadlineTimer::Forever);
+    QVERIFY(!(deadline == forever_));
+    QVERIFY(deadline != forever_);
+    QVERIFY(deadline < forever_);
+    QVERIFY(deadline <= forever_);
+    QVERIFY(!(deadline >= forever_));
+    QVERIFY(!(deadline > forever_));
+}
+
+void tst_QDeadlineTimer::setDeadline()
+{
+    QFETCH_GLOBAL(Qt::TimerType, timerType);
+    auto now = QDeadlineTimer::current(timerType);
+    QDeadlineTimer deadline;
+
+    deadline.setDeadline(now.deadline(), timerType);
+    QVERIFY(deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    QCOMPARE(deadline.remainingTime(), qint64(0));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(0));
+    QCOMPARE(deadline.deadline(), now.deadline());
+    // don't check deadlineNSecs!
+
+    deadline.setPreciseDeadline(now.deadlineNSecs() / (1000 * 1000 * 1000),
+                                now.deadlineNSecs() % (1000 * 1000 * 1000), timerType);
+    QVERIFY(deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    QCOMPARE(deadline.remainingTime(), qint64(0));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(0));
+    QCOMPARE(deadline.deadline(), now.deadline());
+    QCOMPARE(deadline.deadlineNSecs(), now.deadlineNSecs());
+
+    now = QDeadlineTimer::current(timerType);
+    deadline.setDeadline(now.deadline() + 4 * minResolution, timerType);
+    QVERIFY(!deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    QVERIFY(deadline.remainingTime() > (3 * minResolution));
+    QVERIFY(deadline.remainingTime() <= (4 * minResolution));
+    QVERIFY(deadline.remainingTimeNSecs() > (3000000 * minResolution));
+    QVERIFY(deadline.remainingTimeNSecs() <= (4000000 * minResolution));
+    QCOMPARE(deadline.deadline(), now.deadline() + 4 * minResolution);  // yes, it's exact
+    // don't check deadlineNSecs!
+
+    now = QDeadlineTimer::current(timerType);
+    qint64 nsec = now.deadlineNSecs() + 4000000 * minResolution;
+    deadline.setPreciseDeadline(nsec / (1000 * 1000 * 1000),
+                                nsec % (1000 * 1000 * 1000), timerType);
+    QVERIFY(!deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    QVERIFY(deadline.remainingTime() > (3 * minResolution));
+    QVERIFY(deadline.remainingTime() <= (4 * minResolution));
+    QVERIFY(deadline.remainingTimeNSecs() > (3000000 * minResolution));
+    QVERIFY(deadline.remainingTimeNSecs() <= (4000000 * minResolution));
+    QCOMPARE(deadline.deadline(), nsec / (1000 * 1000));
+    QCOMPARE(deadline.deadlineNSecs(), nsec);
+}
+
+void tst_QDeadlineTimer::expire()
+{
+    QFETCH_GLOBAL(Qt::TimerType, timerType);
+
+    QDeadlineTimer deadline(minResolution, timerType);
+    QVERIFY(!deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+
+    qint64 previousDeadline = deadline.deadlineNSecs();
+
+    QTest::qSleep(2 * minResolution);
+
+    QCOMPARE(deadline.remainingTime(), qint64(0));
+    QCOMPARE(deadline.remainingTimeNSecs(), qint64(0));
+    QVERIFY(deadline.deadline() != 0);
+    QVERIFY(deadline.deadline() != std::numeric_limits<qint64>::max());
+    QVERIFY(deadline.deadlineNSecs() != 0);
+    QVERIFY(deadline.deadlineNSecs() != std::numeric_limits<qint64>::max());
+    QCOMPARE(deadline.deadlineNSecs(), previousDeadline);
+}
+
+void tst_QDeadlineTimer::stdchrono()
+{
+#if !QT_HAS_INCLUDE(<chrono>)
+    QSKIP("std::chrono not found on this system");
+#else
+    using namespace std::chrono;
+    QFETCH_GLOBAL(Qt::TimerType, timerType);
+
+    // create some forevers
+    QDeadlineTimer deadline = milliseconds::max();
+    QVERIFY(deadline.isForever());
+    deadline = milliseconds::max();
+    QVERIFY(deadline.isForever());
+    deadline.setRemainingTime(milliseconds::max(), timerType);
+    QVERIFY(deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    deadline = nanoseconds::max();
+    QVERIFY(deadline.isForever());
+    deadline.setRemainingTime(nanoseconds::max(), timerType);
+    QVERIFY(deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    deadline = hours::max();
+    QVERIFY(deadline.isForever());
+    deadline.setRemainingTime(hours::max(), timerType);
+    QVERIFY(deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+
+    deadline = time_point<system_clock>::max();
+    QVERIFY(deadline.isForever());
+    deadline.setDeadline(time_point<system_clock>::max(), timerType);
+    QVERIFY(deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    deadline = time_point<steady_clock>::max();
+    QVERIFY(deadline.isForever());
+    deadline.setDeadline(time_point<steady_clock>::max(), timerType);
+    QVERIFY(deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+
+    QVERIFY(deadline == time_point<steady_clock>::max());
+    QVERIFY(deadline == time_point<system_clock>::max());
+    QCOMPARE(deadline.remainingTimeAsDuration(), nanoseconds::max());
+
+    // make it expired
+    deadline = time_point<system_clock>();
+    QVERIFY(deadline.hasExpired());
+    deadline.setDeadline(time_point<system_clock>(), timerType);
+    QVERIFY(deadline.hasExpired());
+    QCOMPARE(deadline.timerType(), timerType);
+    deadline = time_point<steady_clock>();
+    QVERIFY(deadline.hasExpired());
+    deadline.setDeadline(time_point<steady_clock>(), timerType);
+    QVERIFY(deadline.hasExpired());
+    QCOMPARE(deadline.timerType(), timerType);
+
+    QCOMPARE(deadline.remainingTimeAsDuration(), nanoseconds::zero());
+
+    auto steady_before = steady_clock::now();
+    auto system_before = system_clock::now();
+
+    QTest::qSleep(minResolution);
+    auto now = QDeadlineTimer::current(timerType);
+    QTest::qSleep(minResolution);
+
+    auto steady_after = steady_clock::now();
+    auto system_after = system_clock::now();
+
+    {
+        auto diff = duration_cast<milliseconds>(steady_after - now.deadline<steady_clock>());
+        QVERIFY2(diff.count() > minResolution/2, QByteArray::number(qint64(diff.count())));
+        QVERIFY2(diff.count() < 3*minResolution/2, QByteArray::number(qint64(diff.count())));
+        QDeadlineTimer dt_after(steady_after, timerType);
+        QVERIFY2(now < dt_after,
+                 ("now = " + QLocale().toString(now.deadlineNSecs()) +
+                 "; after = " + QLocale().toString(dt_after.deadlineNSecs())).toLatin1());
+
+        diff = duration_cast<milliseconds>(now.deadline<steady_clock>() - steady_before);
+        QVERIFY2(diff.count() > minResolution/2, QByteArray::number(qint64(diff.count())));
+        QVERIFY2(diff.count() < 3*minResolution/2, QByteArray::number(qint64(diff.count())));
+        QDeadlineTimer dt_before(steady_before, timerType);
+        QVERIFY2(now > dt_before,
+                 ("now = " + QLocale().toString(now.deadlineNSecs()) +
+                 "; before = " + QLocale().toString(dt_before.deadlineNSecs())).toLatin1());
+    }
+    {
+        auto diff = duration_cast<milliseconds>(system_after - now.deadline<system_clock>());
+        QVERIFY2(diff.count() > minResolution/2, QByteArray::number(qint64(diff.count())));
+        QVERIFY2(diff.count() < 3*minResolution/2, QByteArray::number(qint64(diff.count())));
+        QDeadlineTimer dt_after(system_after, timerType);
+        QVERIFY2(now < dt_after,
+                 ("now = " + QLocale().toString(now.deadlineNSecs()) +
+                 "; after = " + QLocale().toString(dt_after.deadlineNSecs())).toLatin1());
+
+        diff = duration_cast<milliseconds>(now.deadline<system_clock>() - system_before);
+        QVERIFY2(diff.count() > minResolution/2, QByteArray::number(qint64(diff.count())));
+        QVERIFY2(diff.count() < 3*minResolution/2, QByteArray::number(qint64(diff.count())));
+        QDeadlineTimer dt_before(system_before, timerType);
+        QVERIFY2(now > dt_before,
+                 ("now = " + QLocale().toString(now.deadlineNSecs()) +
+                 "; before = " + QLocale().toString(dt_before.deadlineNSecs())).toLatin1());
+    }
+
+    // make it regular
+    now = QDeadlineTimer::current(timerType);
+    deadline.setRemainingTime(milliseconds(4 * minResolution), timerType);
+    QVERIFY(!deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    QVERIFY(deadline.remainingTimeAsDuration() > milliseconds(3 * minResolution));
+    QVERIFY(deadline.remainingTimeAsDuration() < milliseconds(5 * minResolution));
+    QVERIFY(deadline.remainingTimeAsDuration() > nanoseconds(3000000 * minResolution));
+    QVERIFY(deadline.remainingTimeAsDuration() < nanoseconds(5000000 * minResolution));
+    QVERIFY(deadline.deadline<steady_clock>() > (steady_clock::now() + milliseconds(3 * minResolution)));
+    QVERIFY(deadline.deadline<steady_clock>() < (steady_clock::now() + milliseconds(5 * minResolution)));
+    QVERIFY(deadline.deadline<system_clock>() > (system_clock::now() + milliseconds(3 * minResolution)));
+    QVERIFY(deadline.deadline<system_clock>() < (system_clock::now() + milliseconds(5 * minResolution)));
+    if (timerType == Qt::CoarseTimer) {
+        QVERIFY(deadline > (now + milliseconds(3 * minResolution)));
+        QVERIFY(deadline < (now + milliseconds(5 * minResolution)));
+        QVERIFY(deadline > (now + nanoseconds(3000000 * minResolution)));
+        QVERIFY(deadline < (now + nanoseconds(5000000 * minResolution)));
+        QVERIFY(deadline > milliseconds(3 * minResolution));
+        QVERIFY(deadline < milliseconds(5 * minResolution));
+        QVERIFY(deadline > nanoseconds(3000000 * minResolution));
+        QVERIFY(deadline < nanoseconds(5000000 * minResolution));
+        QVERIFY(deadline >= steady_clock::now());
+        QVERIFY(deadline >= system_clock::now());
+    }
+
+    now = QDeadlineTimer::current(timerType);
+    deadline = QDeadlineTimer(seconds(1), timerType);
+    QVERIFY(!deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    QVERIFY(deadline.remainingTimeAsDuration() > (seconds(1) - milliseconds(minResolution)));
+    QVERIFY(deadline.remainingTimeAsDuration() <= seconds(1));
+    QVERIFY(deadline.deadline<steady_clock>() > (steady_clock::now() + seconds(1) - milliseconds(minResolution)));
+    QVERIFY(deadline.deadline<steady_clock>() <= (steady_clock::now() + seconds(1) + milliseconds(minResolution)));
+    QVERIFY(deadline.deadline<system_clock>() > (system_clock::now() + seconds(1) - milliseconds(minResolution)));
+    QVERIFY(deadline.deadline<system_clock>() <= (system_clock::now() + seconds(1) + milliseconds(minResolution)));
+    if (timerType == Qt::CoarseTimer) {
+        QVERIFY(deadline > (seconds(1) - milliseconds(minResolution)));
+        QVERIFY(deadline <= seconds(1));
+    }
+
+    now = QDeadlineTimer::current(timerType);
+    deadline.setRemainingTime(hours(1), timerType);
+    QVERIFY(!deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    QVERIFY(deadline.remainingTimeAsDuration() > (hours(1) - milliseconds(minResolution)));
+    QVERIFY(deadline.remainingTimeAsDuration() <= hours(1));
+    QVERIFY(deadline.deadline<steady_clock>() > (steady_clock::now() + hours(1) - milliseconds(minResolution)));
+    QVERIFY(deadline.deadline<steady_clock>() <= (steady_clock::now() + hours(1) + milliseconds(minResolution)));
+    QVERIFY(deadline.deadline<system_clock>() > (system_clock::now() + hours(1) - milliseconds(minResolution)));
+    QVERIFY(deadline.deadline<system_clock>() <= (system_clock::now() + hours(1) + milliseconds(minResolution)));
+
+    now = QDeadlineTimer::current(timerType);
+    deadline.setDeadline(system_clock::now() + seconds(1), timerType);
+    QVERIFY(!deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    QVERIFY(deadline.remainingTimeAsDuration() > (seconds(1) - milliseconds(minResolution)));
+    QVERIFY(deadline.remainingTimeAsDuration() <= seconds(1));
+    QVERIFY(deadline.deadline<steady_clock>() > (steady_clock::now() + seconds(1) - milliseconds(minResolution)));
+    QVERIFY(deadline.deadline<steady_clock>() <= (steady_clock::now() + seconds(1) + milliseconds(minResolution)));
+    QVERIFY(deadline.deadline<system_clock>() > (system_clock::now() + seconds(1) - milliseconds(minResolution)));
+    QVERIFY(deadline.deadline<system_clock>() <= (system_clock::now() + seconds(1) + milliseconds(minResolution)));
+
+    now = QDeadlineTimer::current(timerType);
+    deadline.setDeadline(steady_clock::now() + seconds(1), timerType);
+    QVERIFY(!deadline.hasExpired());
+    QVERIFY(!deadline.isForever());
+    QCOMPARE(deadline.timerType(), timerType);
+    QVERIFY(deadline.remainingTimeAsDuration() > (seconds(1) - milliseconds(minResolution)));
+    QVERIFY(deadline.remainingTimeAsDuration() <= seconds(1));
+    QVERIFY(deadline.deadline<steady_clock>() > (steady_clock::now() + seconds(1) - milliseconds(minResolution)));
+    QVERIFY(deadline.deadline<steady_clock>() <= (steady_clock::now() + seconds(1) + milliseconds(minResolution)));
+    QVERIFY(deadline.deadline<system_clock>() > (system_clock::now() + seconds(1) - milliseconds(minResolution)));
+    QVERIFY(deadline.deadline<system_clock>() <= (system_clock::now() + seconds(1) + milliseconds(minResolution)));
+#endif
+}
+
+QTEST_MAIN(tst_QDeadlineTimer)
+
+#include "tst_qdeadlinetimer.moc"
diff --git a/tests/auto/corelib/kernel/qeventloop/qeventloop.pro b/tests/auto/corelib/kernel/qeventloop/qeventloop.pro
index 50072dc612..295a42aa9c 100644
--- a/tests/auto/corelib/kernel/qeventloop/qeventloop.pro
+++ b/tests/auto/corelib/kernel/qeventloop/qeventloop.pro
@@ -5,4 +5,4 @@ SOURCES = $$PWD/tst_qeventloop.cpp
 
 win32:!winrt: LIBS += -luser32
 
-contains(QT_CONFIG, glib): DEFINES += HAVE_GLIB
+qtConfig(glib): DEFINES += HAVE_GLIB
diff --git a/tests/auto/corelib/kernel/qsocketnotifier/qsocketnotifier.pro b/tests/auto/corelib/kernel/qsocketnotifier/qsocketnotifier.pro
index 58e4b98af7..04806de5f7 100644
--- a/tests/auto/corelib/kernel/qsocketnotifier/qsocketnotifier.pro
+++ b/tests/auto/corelib/kernel/qsocketnotifier/qsocketnotifier.pro
@@ -3,6 +3,6 @@ TARGET = tst_qsocketnotifier
 QT = core-private network-private testlib
 SOURCES = tst_qsocketnotifier.cpp
 
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
 
 include(../../../network/socket/platformsocketengine/platformsocketengine.pri)
diff --git a/tests/auto/corelib/kernel/qvariant/qvariant.pro b/tests/auto/corelib/kernel/qvariant/qvariant.pro
index 33e8b6e2ad..96071f9f73 100644
--- a/tests/auto/corelib/kernel/qvariant/qvariant.pro
+++ b/tests/auto/corelib/kernel/qvariant/qvariant.pro
@@ -5,7 +5,7 @@ INCLUDEPATH += $$PWD/../../../other/qvariant_common
 SOURCES = tst_qvariant.cpp
 RESOURCES += qvariant.qrc
 DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0
-contains(QT_CONFIG, c++11): CONFIG += c++11
-!contains(QT_CONFIG, doubleconversion):!contains(QT_CONFIG, system-doubleconversion) {
+qtConfig(c++11): CONFIG += c++11
+!qtConfig(doubleconversion):!qtConfig(system-doubleconversion) {
     DEFINES += QT_NO_DOUBLECONVERSION
 }
diff --git a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
index 262d8ad44b..75fa424ab1 100644
--- a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
+++ b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
@@ -275,6 +275,7 @@ private slots:
     void metaEnums();
     void compareSanity_data();
     void compareSanity();
+    void compareRich();
 
     void accessSequentialContainerKey();
 
@@ -4775,6 +4776,60 @@ void tst_QVariant::compareSanity()
     }
 }
 
+static void richComparison(const QVariant& less, const QVariant& more)
+{
+    QVERIFY(less.type() == more.type());
+
+    QVERIFY(less < more);
+    QVERIFY(!(more < less));
+
+    QVERIFY(more > less);
+    QVERIFY(!(less > more));
+
+    QVERIFY(less <= more);
+    QVERIFY(!(more <= less));
+    QVERIFY(less <= less);
+
+    QVERIFY(more >= less);
+    QVERIFY(!(less >= more));
+    QVERIFY(more >= more);
+}
+
+void tst_QVariant::compareRich()
+{
+    richComparison(QUuid("{49d8ad2a-2ee8-4c3d-949f-1b5a3765ddf0}"),
+                   QUuid("{f6d56824-16e9-4543-a375-add2877c2d05}"));
+    richComparison(QByteArray::fromRawData("a", 1),
+                   QByteArray::fromRawData("b", 1));
+    richComparison(QStringLiteral("a"), QStringLiteral("b"));
+    richComparison(QLatin1String("a"), QLatin1String("b"));
+    richComparison(QChar('a'), QChar('b'));
+    richComparison(QDate(2016, 7, 23), QDate(2016, 7, 24));
+    richComparison(QTime(0, 0), QTime(0, 1));
+    richComparison(QDateTime(QDate(2016, 7, 23), QTime(0, 0)),
+                   QDateTime(QDate(2016, 7, 23), QTime(0, 1)));
+
+    richComparison(QStringList(), QStringList() << QStringLiteral("a"));
+    richComparison(QStringList(), QStringList() << QStringLiteral("a")
+                                                << QStringLiteral("b"));
+    richComparison(QStringList() << QStringLiteral("a"),
+                   QStringList() << QStringLiteral("b"));
+    richComparison(QStringList() << QStringLiteral("a"),
+                   QStringList() << QStringLiteral("b")
+                                 << QStringLiteral("c"));
+    richComparison(QStringList() << QStringLiteral("a")
+                                 << QStringLiteral("c"),
+                   QStringList() << QStringLiteral("b"));
+    richComparison(QStringList() << QStringLiteral("a")
+                                 << QStringLiteral("c"),
+                   QStringList() << QStringLiteral("b")
+                                 << QStringLiteral("d"));
+    richComparison(QStringList() << QStringLiteral("a")
+                                 << QStringLiteral("c"),
+                   QStringList() << QStringLiteral("a")
+                                 << QStringLiteral("d"));
+}
+
 void tst_QVariant::accessSequentialContainerKey()
 {
     QString nameResult;
diff --git a/tests/auto/corelib/mimetypes/mimetypes.pro b/tests/auto/corelib/mimetypes/mimetypes.pro
index 9063d677e7..9dd091374f 100644
--- a/tests/auto/corelib/mimetypes/mimetypes.pro
+++ b/tests/auto/corelib/mimetypes/mimetypes.pro
@@ -4,5 +4,5 @@ SUBDIRS = \
     qmimetype \
     qmimedatabase
 
-!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
     qmimetype
diff --git a/tests/auto/corelib/plugin/qpluginloader/qpluginloader.pro b/tests/auto/corelib/plugin/qpluginloader/qpluginloader.pro
index 83d00f7cd8..c681f5585c 100644
--- a/tests/auto/corelib/plugin/qpluginloader/qpluginloader.pro
+++ b/tests/auto/corelib/plugin/qpluginloader/qpluginloader.pro
@@ -5,7 +5,7 @@ SUBDIRS	=	lib \
                 theplugin \
 		tst
 !android: !win32: !mac: SUBDIRS += almostplugin
-macx-*: contains(QT_CONFIG, private_tests): SUBDIRS += machtest
+macx-*: qtConfig(private_tests): SUBDIRS += machtest
 TARGET = tst_qpluginloader
 
 # no special install rule for subdir
diff --git a/tests/auto/corelib/plugin/qpluginloader/tst/tst.pro b/tests/auto/corelib/plugin/qpluginloader/tst/tst.pro
index 101392927c..5f9fa6664b 100644
--- a/tests/auto/corelib/plugin/qpluginloader/tst/tst.pro
+++ b/tests/auto/corelib/plugin/qpluginloader/tst/tst.pro
@@ -1,7 +1,7 @@
 CONFIG += testcase
 TARGET  = ../tst_qpluginloader
 QT = core testlib
-contains(QT_CONFIG, private_tests): QT += core-private
+qtConfig(private_tests): QT += core-private
 SOURCES = ../tst_qpluginloader.cpp ../fakeplugin.cpp
 HEADERS = ../theplugin/plugininterface.h
 CONFIG -= app_bundle
diff --git a/tests/auto/corelib/thread/qthreadstorage/tst_qthreadstorage.cpp b/tests/auto/corelib/thread/qthreadstorage/tst_qthreadstorage.cpp
index 4e582cc346..49a3b3e4db 100644
--- a/tests/auto/corelib/thread/qthreadstorage/tst_qthreadstorage.cpp
+++ b/tests/auto/corelib/thread/qthreadstorage/tst_qthreadstorage.cpp
@@ -200,6 +200,13 @@ void testAdoptedThreadStorageWin(void *p)
     }
     QObject::connect(QThread::currentThread(), SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
 }
+#ifdef Q_OS_WINRT
+unsigned __stdcall testAdoptedThreadStorageWinRT(void *p)
+{
+    testAdoptedThreadStorageWin(p);
+    return 0;
+}
+#endif
 void *testAdoptedThreadStorageUnix(void *pointers)
 {
     testAdoptedThreadStorageWin(pointers);
@@ -217,7 +224,12 @@ void tst_QThreadStorage::adoptedThreads()
         const int state = pthread_create(&thread, 0, testAdoptedThreadStorageUnix, &pointers);
         QCOMPARE(state, 0);
         pthread_join(thread, 0);
-#elif defined Q_OS_WIN && !defined(Q_OS_WINRT)
+#elif defined Q_OS_WINRT
+        HANDLE thread;
+        thread = (HANDLE) _beginthreadex(NULL, 0, testAdoptedThreadStorageWinRT, &pointers, 0, 0);
+        QVERIFY(thread);
+        WaitForSingleObjectEx(thread, INFINITE, FALSE);
+#elif defined Q_OS_WIN
         HANDLE thread;
         thread = (HANDLE)_beginthread(testAdoptedThreadStorageWin, 0, &pointers);
         QVERIFY(thread);
diff --git a/tests/auto/corelib/tools/qcollator/qcollator.pro b/tests/auto/corelib/tools/qcollator/qcollator.pro
index ed879ee70e..7725194e3d 100644
--- a/tests/auto/corelib/tools/qcollator/qcollator.pro
+++ b/tests/auto/corelib/tools/qcollator/qcollator.pro
@@ -3,4 +3,4 @@ TARGET = tst_qcollator
 QT = core testlib
 SOURCES = tst_qcollator.cpp
 DEFINES += QT_NO_CAST_TO_ASCII
-contains(QT_CONFIG,icu):DEFINES += QT_USE_ICU
+qtConfig(icu): DEFINES += QT_USE_ICU
diff --git a/tests/auto/corelib/tools/qfreelist/qfreelist.pro b/tests/auto/corelib/tools/qfreelist/qfreelist.pro
index fb108338bd..4825987bcf 100644
--- a/tests/auto/corelib/tools/qfreelist/qfreelist.pro
+++ b/tests/auto/corelib/tools/qfreelist/qfreelist.pro
@@ -2,4 +2,4 @@ CONFIG += testcase
 TARGET = tst_qfreelist
 QT = core-private testlib
 SOURCES = tst_qfreelist.cpp
-!contains(QT_CONFIG,private_tests): SOURCES += $$QT_SOURCE_TREE/src/corelib/tools/qfreelist.cpp
+!qtConfig(private_tests): SOURCES += $$QT_SOURCE_TREE/src/corelib/tools/qfreelist.cpp
diff --git a/tests/auto/corelib/tools/qlatin1string/qlatin1string.pro b/tests/auto/corelib/tools/qlatin1string/qlatin1string.pro
index a996dab23e..61054b40e4 100644
--- a/tests/auto/corelib/tools/qlatin1string/qlatin1string.pro
+++ b/tests/auto/corelib/tools/qlatin1string/qlatin1string.pro
@@ -3,7 +3,7 @@ TARGET = tst_qlatin1string
 QT = core testlib
 SOURCES = tst_qlatin1string.cpp
 DEFINES += QT_NO_CAST_TO_ASCII
-contains(QT_CONFIG,c++11): CONFIG += c++11
-contains(QT_CONFIG,c++14): CONFIG += c++14
+qtConfig(c++11): CONFIG += c++11
+qtConfig(c++14): CONFIG += c++14
 
 DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0
diff --git a/tests/auto/corelib/tools/qlocale/test/test.pro b/tests/auto/corelib/tools/qlocale/test/test.pro
index d9004d1eb6..595ee258e7 100644
--- a/tests/auto/corelib/tools/qlocale/test/test.pro
+++ b/tests/auto/corelib/tools/qlocale/test/test.pro
@@ -4,7 +4,7 @@ QT = core testlib core-private
 embedded: QT += gui
 SOURCES = ../tst_qlocale.cpp
 
-!contains(QT_CONFIG, doubleconversion):!contains(QT_CONFIG, system-doubleconversion) {
+!qtConfig(doubleconversion):!qtConfig(system-doubleconversion) {
     DEFINES += QT_NO_DOUBLECONVERSION
 }
 
diff --git a/tests/auto/corelib/tools/qregularexpression/qregularexpression.pro b/tests/auto/corelib/tools/qregularexpression/qregularexpression.pro
index c030f04a27..e1840808ff 100644
--- a/tests/auto/corelib/tools/qregularexpression/qregularexpression.pro
+++ b/tests/auto/corelib/tools/qregularexpression/qregularexpression.pro
@@ -1,3 +1,3 @@
 TEMPLATE = subdirs
 SUBDIRS = defaultoptimize forceoptimize
-contains(QT_CONFIG,private_tests):SUBDIRS += alwaysoptimize
+qtConfig(private_tests): SUBDIRS += alwaysoptimize
diff --git a/tests/auto/corelib/tools/qstring/qstring.pro b/tests/auto/corelib/tools/qstring/qstring.pro
index 1ff9a4fc9e..a94ad3405a 100644
--- a/tests/auto/corelib/tools/qstring/qstring.pro
+++ b/tests/auto/corelib/tools/qstring/qstring.pro
@@ -3,11 +3,11 @@ TARGET = tst_qstring
 QT = core testlib
 SOURCES = tst_qstring.cpp
 DEFINES += QT_NO_CAST_TO_ASCII
-contains(QT_CONFIG,icu):DEFINES += QT_USE_ICU
-contains(QT_CONFIG,c++11): CONFIG += c++11
+qtConfig(icu): DEFINES += QT_USE_ICU
+qtConfig(c++11): CONFIG += c++11
 DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0
 
-!contains(QT_CONFIG, doubleconversion):!contains(QT_CONFIG, system-doubleconversion) {
+!qtConfig(doubleconversion):!qtConfig(system-doubleconversion) {
     DEFINES += QT_NO_DOUBLECONVERSION
 }
 
diff --git a/tests/auto/corelib/tools/qstring/tst_qstring.cpp b/tests/auto/corelib/tools/qstring/tst_qstring.cpp
index 2e35c961c6..a0a872710c 100644
--- a/tests/auto/corelib/tools/qstring/tst_qstring.cpp
+++ b/tests/auto/corelib/tools/qstring/tst_qstring.cpp
@@ -123,7 +123,7 @@ template <>
 class Arg<QStringRef> : ArgBase
 {
     QStringRef ref() const
-    { return this->pinned.isNull() ? QStringRef() : this->pinned.midRef(0) ; }
+    { return QStringRef(&pinned); }
 public:
     explicit Arg(const char *str) : ArgBase(str) {}
 
@@ -499,6 +499,8 @@ private slots:
     void fromLocal8Bit();
     void local8Bit_data();
     void local8Bit();
+    void invalidToLocal8Bit_data();
+    void invalidToLocal8Bit();
     void nullFromLocal8Bit();
     void fromLatin1Roundtrip_data();
     void fromLatin1Roundtrip();
@@ -4293,6 +4295,66 @@ void tst_QString::local8Bit()
     QCOMPARE(local8Bit.toLocal8Bit(), QByteArray(result));
 }
 
+void tst_QString::invalidToLocal8Bit_data()
+{
+    QTest::addColumn<QString>("unicode");
+    QTest::addColumn<QByteArray>("expect"); // Initial validly-converted prefix
+
+    {
+        const QChar malformed[] = { 'A', 0xd800, 'B', 0 };
+        const char expected[] = "A";
+        QTest::newRow("LoneHighSurrogate")
+            << QString(malformed, sizeof(malformed) / sizeof(QChar))
+            // Don't include the terminating '\0' of expected:
+            << QByteArray(expected, sizeof(expected) / sizeof(char) - 1);
+    }
+    {
+        const QChar malformed[] = { 'A', 0xdc00, 'B', 0 };
+        const char expected[] = "A";
+        QTest::newRow("LoneLowSurrogate")
+            << QString(malformed, sizeof(malformed) / sizeof(QChar))
+            << QByteArray(expected, sizeof(expected) / sizeof(char) - 1);
+    }
+    {
+        const QChar malformed[] = { 'A', 0xd800, 0xd801, 'B', 0 };
+        const char expected[] = "A";
+        QTest::newRow("DoubleHighSurrogate")
+            << QString(malformed, sizeof(malformed) / sizeof(QChar))
+            << QByteArray(expected, sizeof(expected) / sizeof(char) - 1);
+    }
+    {
+        const QChar malformed[] = { 'A', 0xdc00, 0xdc01, 'B', 0 };
+        const char expected[] = "A";
+        QTest::newRow("DoubleLowSurrogate")
+            << QString(malformed, sizeof(malformed) / sizeof(QChar))
+            << QByteArray(expected, sizeof(expected) / sizeof(char) - 1);
+    }
+    {
+        const QChar malformed[] = { 'A', 0xdc00, 0xd800, 'B', 0 };
+        const char expected[] = "A";
+        QTest::newRow("ReversedSurrogates") // low before high
+            << QString(malformed, sizeof(malformed) / sizeof(QChar))
+            << QByteArray(expected, sizeof(expected) / sizeof(char) - 1);
+    }
+}
+
+void tst_QString::invalidToLocal8Bit()
+{
+    QFETCH(QString, unicode);
+    QFETCH(QByteArray, expect);
+    QByteArray local = unicode.toLocal8Bit();
+    /*
+      The main concern of this test is to check that any error-reporting that
+      toLocal8Bit() prompts on failure isn't dependent on outputting the data
+      it's converting via toLocal8Bit(), which would be apt to recurse.  So the
+      real purpose of this QVERIFY(), for all that we should indeed check we get
+      the borked output that matches what we can reliably expect (despite
+      variation in how codecs respond to errors), is to verify that we got here
+      - i.e. we didn't crash in such a recursive stack over-flow.
+     */
+    QVERIFY(local.startsWith(expect));
+}
+
 void tst_QString::nullFromLocal8Bit()
 {
     QString a;
diff --git a/tests/auto/corelib/tools/qstringapisymmetry/qstringapisymmetry.pro b/tests/auto/corelib/tools/qstringapisymmetry/qstringapisymmetry.pro
index 76e89c9acd..bc38b17949 100644
--- a/tests/auto/corelib/tools/qstringapisymmetry/qstringapisymmetry.pro
+++ b/tests/auto/corelib/tools/qstringapisymmetry/qstringapisymmetry.pro
@@ -2,4 +2,4 @@ CONFIG += testcase
 TARGET = tst_qstringapisymmetry
 QT = core testlib
 SOURCES = tst_qstringapisymmetry.cpp
-contains(QT_CONFIG,c++14): CONFIG += c++14
+qtConfig(c++14): CONFIG += c++14
diff --git a/tests/auto/corelib/tools/qtimezone/qtimezone.pro b/tests/auto/corelib/tools/qtimezone/qtimezone.pro
index 4459ed6020..afc4c59dfe 100644
--- a/tests/auto/corelib/tools/qtimezone/qtimezone.pro
+++ b/tests/auto/corelib/tools/qtimezone/qtimezone.pro
@@ -2,6 +2,6 @@ CONFIG += testcase
 TARGET = tst_qtimezone
 QT = core-private testlib
 SOURCES = tst_qtimezone.cpp
-contains(QT_CONFIG,icu) {
+qtConfig(icu) {
     DEFINES += QT_USE_ICU
 }
diff --git a/tests/auto/corelib/tools/qvector/qvector.pro b/tests/auto/corelib/tools/qvector/qvector.pro
index d49516923f..b9a4ae747b 100644
--- a/tests/auto/corelib/tools/qvector/qvector.pro
+++ b/tests/auto/corelib/tools/qvector/qvector.pro
@@ -1,5 +1,5 @@
 CONFIG += testcase
-contains(QT_CONFIG, c++11):CONFIG += c++11
+qtConfig(c++11): CONFIG += c++11
 TARGET = tst_qvector
 QT = core testlib
 SOURCES = $$PWD/tst_qvector.cpp
diff --git a/tests/auto/corelib/tools/qversionnumber/qversionnumber.pro b/tests/auto/corelib/tools/qversionnumber/qversionnumber.pro
index 834fc85a29..e2ae91cb64 100644
--- a/tests/auto/corelib/tools/qversionnumber/qversionnumber.pro
+++ b/tests/auto/corelib/tools/qversionnumber/qversionnumber.pro
@@ -1,6 +1,6 @@
 CONFIG += testcase
-contains(QT_CONFIG, c++11):CONFIG += c++11
-contains(QT_CONFIG, c++14):CONFIG += c++14
+qtConfig(c++11): CONFIG += c++11
+qtConfig(c++14): CONFIG += c++14
 TARGET = tst_qversionnumber
 QT = core testlib
 SOURCES = tst_qversionnumber.cpp
diff --git a/tests/auto/dbus/dbus.pro b/tests/auto/dbus/dbus.pro
index c5cddee5f5..1769583fca 100644
--- a/tests/auto/dbus/dbus.pro
+++ b/tests/auto/dbus/dbus.pro
@@ -26,6 +26,6 @@ SUBDIRS+=\
            qdbusthreading \
            qdbusxmlparser
 
-!contains(QT_CONFIG,private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
            qdbusmarshall \
 
diff --git a/tests/auto/dbus/qdbusconnection/tst_qdbusconnection.cpp b/tests/auto/dbus/qdbusconnection/tst_qdbusconnection.cpp
index 602de58b2c..95daa256b5 100644
--- a/tests/auto/dbus/qdbusconnection/tst_qdbusconnection.cpp
+++ b/tests/auto/dbus/qdbusconnection/tst_qdbusconnection.cpp
@@ -1087,6 +1087,16 @@ void tst_QDBusConnection::connectSignal()
     QTest::qWait(100);
     QCOMPARE(recv.argumentReceived, signal.arguments().at(0).toString());
     QCOMPARE(recv.signalsReceived, 1);
+
+    // confirm that we are, indeed, a unique connection
+    recv.argumentReceived.clear();
+    recv.signalsReceived = 0;
+    QVERIFY(!con.connect(con.baseService(), signal.path(), signal.interface(),
+                        signal.member(), "s", &recv, SLOT(oneSlot(QString))));
+    QVERIFY(con.send(signal));
+    QTest::qWait(100);
+    QCOMPARE(recv.argumentReceived, signal.arguments().at(0).toString());
+    QCOMPARE(recv.signalsReceived, 1);
 }
 
 void tst_QDBusConnection::slotsWithLessParameters()
@@ -1118,6 +1128,15 @@ void tst_QDBusConnection::slotsWithLessParameters()
     QTest::qWait(100);
     QCOMPARE(recv.argumentReceived, QString());
     QCOMPARE(recv.signalsReceived, 1);
+
+    // confirm that we are, indeed, a unique connection
+    recv.signalsReceived = 0;
+    QVERIFY(!con.connect(con.baseService(), signal.path(), signal.interface(),
+                         signal.member(), "s", &recv, SLOT(oneSlot())));
+    QVERIFY(con.send(signal));
+    QTest::qWait(100);
+    QCOMPARE(recv.argumentReceived, QString());
+    QCOMPARE(recv.signalsReceived, 1);
 }
 
 void SignalReceiver::secondCallWithCallback()
diff --git a/tests/auto/dbus/qdbusmarshall/qdbusmarshall.pro b/tests/auto/dbus/qdbusmarshall/qdbusmarshall.pro
index e9a41c0fb4..caedb5a0f2 100644
--- a/tests/auto/dbus/qdbusmarshall/qdbusmarshall.pro
+++ b/tests/auto/dbus/qdbusmarshall/qdbusmarshall.pro
@@ -6,4 +6,4 @@ SUBDIRS = qpong qdbusmarshall
 
 QT = core-private testlib
 
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
diff --git a/tests/auto/dbus/qdbusmarshall/qdbusmarshall/qdbusmarshall.pro b/tests/auto/dbus/qdbusmarshall/qdbusmarshall/qdbusmarshall.pro
index 21e665fa37..031cc252c8 100644
--- a/tests/auto/dbus/qdbusmarshall/qdbusmarshall/qdbusmarshall.pro
+++ b/tests/auto/dbus/qdbusmarshall/qdbusmarshall/qdbusmarshall.pro
@@ -5,10 +5,9 @@ DESTDIR = ./
 
 QT = core-private dbus-private testlib
 
-contains(QT_CONFIG, dbus-linked) {
+qtConfig(dbus-linked) {
     DEFINES += QT_LINKED_LIBDBUS
-    LIBS += $$QMAKE_LIBS_DBUS
-    QMAKE_CXXFLAGS += $$QMAKE_CFLAGS_DBUS
+    QMAKE_USE += dbus
 } else {
     SOURCES += ../../../../../src/dbus/qdbus_symbols.cpp
 }
diff --git a/tests/auto/dbus/qdbustype/qdbustype.pro b/tests/auto/dbus/qdbustype/qdbustype.pro
index e65b9ec5b3..75a9980732 100644
--- a/tests/auto/dbus/qdbustype/qdbustype.pro
+++ b/tests/auto/dbus/qdbustype/qdbustype.pro
@@ -2,10 +2,9 @@ CONFIG += testcase parallel_test
 TARGET = tst_qdbustype
 QT = core-private dbus-private testlib
 SOURCES += tst_qdbustype.cpp
-contains(QT_CONFIG, dbus-linked) {
+qtConfig(dbus-linked) {
     DEFINES += QT_LINKED_LIBDBUS
-    LIBS += $$QMAKE_LIBS_DBUS
-    QMAKE_CXXFLAGS += $$QMAKE_CFLAGS_DBUS
+    QMAKE_USE += dbus
 } else {
     SOURCES += ../../../../src/dbus/qdbus_symbols.cpp
 }
diff --git a/tests/auto/gui/gui.pro b/tests/auto/gui/gui.pro
index d6aa5e01ae..8d8a2df393 100644
--- a/tests/auto/gui/gui.pro
+++ b/tests/auto/gui/gui.pro
@@ -13,4 +13,4 @@ SUBDIRS = \
     util \
     itemmodels \
 
-!contains(QT_CONFIG, opengl(es2)?): SUBDIRS -= qopengl qopenglconfig
+!qtConfig(opengl(es2)?): SUBDIRS -= qopengl qopenglconfig
diff --git a/tests/auto/gui/image/image.pro b/tests/auto/gui/image/image.pro
index 9199763c40..5a74df4c78 100644
--- a/tests/auto/gui/image/image.pro
+++ b/tests/auto/gui/image/image.pro
@@ -14,6 +14,6 @@ SUBDIRS=\
 !qtHaveModule(network): SUBDIRS -= \
     qimagereader
 
-!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
            qpixmapcache \
 
diff --git a/tests/auto/gui/image/qimage/qimage.pro b/tests/auto/gui/image/qimage/qimage.pro
index 36d64a275f..39ce4e26cb 100644
--- a/tests/auto/gui/image/qimage/qimage.pro
+++ b/tests/auto/gui/image/qimage/qimage.pro
@@ -3,7 +3,7 @@ TARGET = tst_qimage
 SOURCES  += tst_qimage.cpp
 
 QT += core-private gui-private testlib
-contains(QT_CONFIG, c++11): CONFIG += c++11
+qtConfig(c++11): CONFIG += c++11
 
 android: RESOURCES+=qimage.qrc
 
diff --git a/tests/auto/gui/image/qimage/tst_qimage.cpp b/tests/auto/gui/image/qimage/tst_qimage.cpp
index 18812fd090..a1ab812aaa 100644
--- a/tests/auto/gui/image/qimage/tst_qimage.cpp
+++ b/tests/auto/gui/image/qimage/tst_qimage.cpp
@@ -39,6 +39,10 @@
 #include <private/qimage_p.h>
 #include <private/qdrawhelper_p.h>
 
+#ifdef Q_OS_DARWIN
+#include <CoreGraphics/CoreGraphics.h>
+#endif
+
 Q_DECLARE_METATYPE(QImage::Format)
 Q_DECLARE_METATYPE(Qt::GlobalColor)
 
@@ -201,6 +205,11 @@ private slots:
     void ditherGradient_data();
     void ditherGradient();
 
+#ifdef Q_OS_DARWIN
+    void toCGImage_data();
+    void toCGImage();
+#endif
+
 private:
     const QString m_prefix;
 };
@@ -3307,5 +3316,41 @@ void tst_QImage::ditherGradient()
     QVERIFY(observedGradientSteps >= minimumExpectedGradient);
 }
 
+#ifdef Q_OS_DARWIN
+
+void tst_QImage::toCGImage_data()
+{
+    QTest::addColumn<QImage::Format>("format");
+    QTest::addColumn<bool>("supported");
+
+    // Populate test data with supported status for all QImage formats.
+    QSet<QImage::Format> supported =
+        { QImage::Format_ARGB32, QImage::Format_RGB32, QImage::Format_RGBA8888_Premultiplied,
+          QImage::Format_RGBA8888, QImage::Format_RGBX8888, QImage::Format_ARGB32_Premultiplied };
+
+    for (int i = QImage::Format_Invalid; i < QImage::Format_Grayscale8; ++i) {
+        QTest::newRow(qPrintable(formatToString(QImage::Format(i))))
+            << QImage::Format(i) << supported.contains(QImage::Format(i));
+    }
+}
+
+// Verify that toCGImage() returns a valid CGImageRef for supported image formats.
+void tst_QImage::toCGImage()
+{
+    QFETCH(QImage::Format, format);
+    QFETCH(bool, supported);
+
+    QImage qimage(64, 64, format);
+    qimage.fill(Qt::red);
+
+    CGImageRef cgimage = qimage.toCGImage();
+    QCOMPARE(cgimage != nullptr, supported);
+
+    CGImageRelease(cgimage);
+}
+
+#endif
+
+
 QTEST_GUILESS_MAIN(tst_QImage)
 #include "tst_qimage.moc"
diff --git a/tests/auto/gui/image/qimagewriter/tst_qimagewriter.cpp b/tests/auto/gui/image/qimagewriter/tst_qimagewriter.cpp
index 9e747f8b11..b66eef5759 100644
--- a/tests/auto/gui/image/qimagewriter/tst_qimagewriter.cpp
+++ b/tests/auto/gui/image/qimagewriter/tst_qimagewriter.cpp
@@ -55,9 +55,6 @@ class tst_QImageWriter : public QObject
 {
     Q_OBJECT
 
-public:
-    virtual ~tst_QImageWriter();
-
 public slots:
     void initTestCase();
 
@@ -155,16 +152,6 @@ void tst_QImageWriter::getSetCheck()
     QCOMPARE(1.1f, obj1.gamma());
 }
 
-tst_QImageWriter::~tst_QImageWriter()
-{
-    QDir dir(prefix);
-    QStringList filesToDelete = dir.entryList(QStringList() << "gen-*" , QDir::NoDotAndDotDot | QDir::Files);
-    foreach( QString file, filesToDelete) {
-        QFile::remove(dir.absoluteFilePath(file));
-    }
-
-}
-
 void tst_QImageWriter::writeImage_data()
 {
     QTest::addColumn<QString>("fileName");
diff --git a/tests/auto/gui/image/qmovie/qmovie.pro b/tests/auto/gui/image/qmovie/qmovie.pro
index 4a741ec154..6a7e23be99 100644
--- a/tests/auto/gui/image/qmovie/qmovie.pro
+++ b/tests/auto/gui/image/qmovie/qmovie.pro
@@ -5,8 +5,8 @@ qtHaveModule(widgets): QT += widgets
 SOURCES += tst_qmovie.cpp
 MOC_DIR=tmp
 
-contains(QT_CONFIG, gif):DEFINES += QTEST_HAVE_GIF
-contains(QT_CONFIG, jpeg):DEFINES += QTEST_HAVE_JPEG
+qtConfig(gif): DEFINES += QTEST_HAVE_GIF
+qtConfig(jpeg): DEFINES += QTEST_HAVE_JPEG
 
 RESOURCES += resources.qrc
 TESTDATA += animations/*
diff --git a/tests/auto/gui/kernel/kernel.pro b/tests/auto/gui/kernel/kernel.pro
index 317d8c1ff9..631962ad34 100644
--- a/tests/auto/gui/kernel/kernel.pro
+++ b/tests/auto/gui/kernel/kernel.pro
@@ -34,4 +34,6 @@ win32:!winrt:qtHaveModule(network): SUBDIRS += noqteventloop
 !qtHaveModule(network): SUBDIRS -= \
    qguieventloop
 
-!contains(QT_CONFIG, opengl(es2)?): SUBDIRS -= qopenglwindow
+!qtConfig(opengl(es2)?): SUBDIRS -= qopenglwindow
+
+uikit: SUBDIRS -= qclipboard
diff --git a/tests/auto/gui/kernel/noqteventloop/noqteventloop.pro b/tests/auto/gui/kernel/noqteventloop/noqteventloop.pro
index 5e4875d1e7..7e98704aea 100644
--- a/tests/auto/gui/kernel/noqteventloop/noqteventloop.pro
+++ b/tests/auto/gui/kernel/noqteventloop/noqteventloop.pro
@@ -5,4 +5,4 @@ QT += core-private network gui-private testlib
 
 SOURCES  += tst_noqteventloop.cpp
 
-contains(QT_CONFIG,dynamicgl):win32:!winrt: LIBS += -luser32
+qtConfig(dynamicgl):win32:!winrt: LIBS += -luser32
diff --git a/tests/auto/gui/kernel/qwindow/qwindow.pro b/tests/auto/gui/kernel/qwindow/qwindow.pro
index f975e00ffa..844b3e8507 100644
--- a/tests/auto/gui/kernel/qwindow/qwindow.pro
+++ b/tests/auto/gui/kernel/qwindow/qwindow.pro
@@ -5,4 +5,4 @@ QT += core-private gui-private testlib
 
 SOURCES  += tst_qwindow.cpp
 
-contains(QT_CONFIG,dynamicgl):win32:!winrt: LIBS += -luser32
+qtConfig(dynamicgl):win32:!winrt: LIBS += -luser32
diff --git a/tests/auto/gui/painting/painting.pro b/tests/auto/gui/painting/painting.pro
index 0f7595c871..831fffab30 100644
--- a/tests/auto/gui/painting/painting.pro
+++ b/tests/auto/gui/painting/painting.pro
@@ -16,7 +16,7 @@ SUBDIRS=\
    qwmatrix \
    qpolygon \
 
-!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
     qpathclipper \
 
 
diff --git a/tests/auto/gui/painting/qcolor/tst_qcolor.cpp b/tests/auto/gui/painting/qcolor/tst_qcolor.cpp
index cffa444c97..00e7436c0f 100644
--- a/tests/auto/gui/painting/qcolor/tst_qcolor.cpp
+++ b/tests/auto/gui/painting/qcolor/tst_qcolor.cpp
@@ -279,6 +279,8 @@ void tst_QColor::name_data()
     QTest::newRow("global color darkMagenta") << QColor(Qt::darkMagenta) << "#800080" << QColor::HexRgb;
     QTest::newRow("global color darkYellow") << QColor(Qt::darkYellow) << "#808000" << QColor::HexRgb;
     QTest::newRow("transparent red") << QColor(255, 0, 0, 102) << "#66ff0000" << QColor::HexArgb;
+    QTest::newRow("fully_transparent_green_rgb") << QColor(0, 0, 255, 0) << "#0000ff" << QColor::HexRgb;
+    QTest::newRow("fully_transparent_green_argb") << QColor(0, 0, 255, 0) << "#000000ff" << QColor::HexArgb;
 }
 
 void tst_QColor::name()
diff --git a/tests/auto/gui/painting/qpathclipper/qpathclipper.pro b/tests/auto/gui/painting/qpathclipper/qpathclipper.pro
index e153460bf2..671220f94b 100644
--- a/tests/auto/gui/painting/qpathclipper/qpathclipper.pro
+++ b/tests/auto/gui/painting/qpathclipper/qpathclipper.pro
@@ -5,6 +5,6 @@ HEADERS += paths.h
 SOURCES  += tst_qpathclipper.cpp paths.cpp
 QT += gui-private testlib
 
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
 
 unix:!darwin:!haiku:!integrity: LIBS += -lm
diff --git a/tests/auto/gui/qopengl/qopengl.pro b/tests/auto/gui/qopengl/qopengl.pro
index a4ef016e39..aaef6e5125 100644
--- a/tests/auto/gui/qopengl/qopengl.pro
+++ b/tests/auto/gui/qopengl/qopengl.pro
@@ -8,4 +8,4 @@ QT += gui-private core-private testlib
 
 SOURCES   += tst_qopengl.cpp
 
-linux:contains(QT_CONFIG, xcb-glx):contains(QT_CONFIG, xcb-xlib):!contains(QT_CONFIG, egl): DEFINES += USE_GLX
+linux:qtConfig(xcb-glx):qtConfig(xcb-xlib):!qtConfig(egl): DEFINES += USE_GLX
diff --git a/tests/auto/gui/text/qabstracttextdocumentlayout/BLACKLIST b/tests/auto/gui/text/qabstracttextdocumentlayout/BLACKLIST
deleted file mode 100644
index fa033cee09..0000000000
--- a/tests/auto/gui/text/qabstracttextdocumentlayout/BLACKLIST
+++ /dev/null
@@ -1,7 +0,0 @@
-#QTBUG-53648
-[imageAt]
-opensuse-42.1
-rhel-7.2
-#QTBUG-52991
-[formatAt]
-opensuse-42.1
diff --git a/tests/auto/gui/text/qabstracttextdocumentlayout/tst_qabstracttextdocumentlayout.cpp b/tests/auto/gui/text/qabstracttextdocumentlayout/tst_qabstracttextdocumentlayout.cpp
index 9542d306ba..be3ef968ef 100644
--- a/tests/auto/gui/text/qabstracttextdocumentlayout/tst_qabstracttextdocumentlayout.cpp
+++ b/tests/auto/gui/text/qabstracttextdocumentlayout/tst_qabstracttextdocumentlayout.cpp
@@ -194,7 +194,7 @@ void tst_QAbstractTextDocumentLayout::imageAt()
     QCOMPARE(documentLayout->anchorAt(imagePoint), QString("link"));
 
     // imageAt on start returns nothing (there's the "foo" text)
-    QPointF fooPoint(fooBr.width() + blockStart.x(), (fooBr.height() / 2) + blockStart.y());
+    QPointF fooPoint(blockStart.x() + (fooBr.width() / 2), (fooBr.height() / 2) + blockStart.y());
     QCOMPARE(documentLayout->imageAt(fooPoint), QString());
 }
 
@@ -221,7 +221,7 @@ void tst_QAbstractTextDocumentLayout::formatAt()
     QVERIFY(format.isImageFormat());
 
     // move over the unformatted "foo" text)
-    QPointF fooPoint(fooBr.width() + blockStart.x(), (fooBr.height() / 2) + blockStart.y());
+    QPointF fooPoint(blockStart.x() + (fooBr.width() / 2), (fooBr.height() / 2) + blockStart.y());
     format = documentLayout->formatAt(fooPoint);
     QVERIFY(format.isCharFormat());
     QVERIFY(!format.toCharFormat().isAnchor());
diff --git a/tests/auto/gui/text/qcssparser/qcssparser.pro b/tests/auto/gui/text/qcssparser/qcssparser.pro
index b92859d4fb..e2bb3eeea8 100644
--- a/tests/auto/gui/text/qcssparser/qcssparser.pro
+++ b/tests/auto/gui/text/qcssparser/qcssparser.pro
@@ -3,7 +3,7 @@ TARGET = tst_qcssparser
 SOURCES += tst_qcssparser.cpp
 QT += xml gui-private testlib
 
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
 DEFINES += SRCDIR=\\\"$$PWD\\\"
 
 android {
diff --git a/tests/auto/gui/text/qstatictext/qstatictext.pro b/tests/auto/gui/text/qstatictext/qstatictext.pro
index 0f4906ce4d..09d0dd4126 100644
--- a/tests/auto/gui/text/qstatictext/qstatictext.pro
+++ b/tests/auto/gui/text/qstatictext/qstatictext.pro
@@ -4,4 +4,4 @@ QT += testlib
 
 SOURCES  += tst_qstatictext.cpp
 
-contains(QT_CONFIG, private_tests): QT += core-private gui-private
+qtConfig(private_tests): QT += core-private gui-private
diff --git a/tests/auto/gui/text/qtextpiecetable/qtextpiecetable.pro b/tests/auto/gui/text/qtextpiecetable/qtextpiecetable.pro
index 1419e32012..0bbe0c8c4e 100644
--- a/tests/auto/gui/text/qtextpiecetable/qtextpiecetable.pro
+++ b/tests/auto/gui/text/qtextpiecetable/qtextpiecetable.pro
@@ -6,5 +6,5 @@ SOURCES  += tst_qtextpiecetable.cpp
 HEADERS += ../qtextdocument/common.h
 
 requires(!win32)
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
 
diff --git a/tests/auto/gui/text/qzip/tst_qzip.cpp b/tests/auto/gui/text/qzip/tst_qzip.cpp
index 50e9a0f0ef..c0bf5fef8e 100644
--- a/tests/auto/gui/text/qzip/tst_qzip.cpp
+++ b/tests/auto/gui/text/qzip/tst_qzip.cpp
@@ -50,7 +50,7 @@ void tst_QZip::basicUnpack()
 
     QZipReader::FileInfo fi = files.at(0);
     QVERIFY(fi.isValid());
-    QCOMPARE(fi.filePath, QString("test/"));
+    QCOMPARE(fi.filePath, QString("test"));
     QCOMPARE(uint(fi.isDir), (uint) 1);
     QCOMPARE(uint(fi.isFile), (uint) 0);
     QCOMPARE(uint(fi.isSymLink), (uint) 0);
diff --git a/tests/auto/gui/text/text.pro b/tests/auto/gui/text/text.pro
index dc67794a98..bb4984767f 100644
--- a/tests/auto/gui/text/text.pro
+++ b/tests/auto/gui/text/text.pro
@@ -22,13 +22,15 @@ SUBDIRS=\
    qtextpiecetable \
    qtextscriptengine \
    qtexttable \
-
-contains(QT_CONFIG, OdfWriter):SUBDIRS += qzip qtextodfwriter
+   qzip \
+   qtextodfwriter
 
 win32:SUBDIRS -= qtextpiecetable
 
-!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
            qfontcache \
            qcssparser \
            qtextlayout \
            qtextpiecetable \
+           qzip \
+           qtextodfwriter
diff --git a/tests/auto/network/access/access.pro b/tests/auto/network/access/access.pro
index ef0aeac3c8..1d78cf253b 100644
--- a/tests/auto/network/access/access.pro
+++ b/tests/auto/network/access/access.pro
@@ -12,17 +12,12 @@ SUBDIRS=\
    qftp \
    qhttpnetworkreply \
    qabstractnetworkcache \
-   hpack
+   hpack \
+   http2
 
-!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
           qhttpnetworkconnection \
           qhttpnetworkreply \
           qftp \
-          hpack
-
-contains(QT_CONFIG, openssl) | contains(QT_CONFIG, openssl-linked) {
-    contains(QT_CONFIG, private_tests) {
-        SUBDIRS += \
-            http2
-    }
-}
+          hpack \
+          http2
diff --git a/tests/auto/network/access/http2/http2.pro b/tests/auto/network/access/http2/http2.pro
index 5dd8bdf9ae..e130f30784 100644
--- a/tests/auto/network/access/http2/http2.pro
+++ b/tests/auto/network/access/http2/http2.pro
@@ -1,7 +1,6 @@
 QT += core core-private network network-private testlib
 
 CONFIG += testcase parallel_test c++11
-TEMPLATE = app
 TARGET = tst_http2
 HEADERS += http2srv.h
 SOURCES += tst_http2.cpp http2srv.cpp
diff --git a/tests/auto/network/access/http2/http2srv.cpp b/tests/auto/network/access/http2/http2srv.cpp
index eb09569cdd..f919937fc3 100644..100755
--- a/tests/auto/network/access/http2/http2srv.cpp
+++ b/tests/auto/network/access/http2/http2srv.cpp
@@ -33,9 +33,14 @@
 
 #include "http2srv.h"
 
+#ifndef QT_NO_SSL
 #include <QtNetwork/qsslconfiguration.h>
-#include <QtNetwork/qhostaddress.h>
+#include <QtNetwork/qsslsocket.h>
 #include <QtNetwork/qsslkey.h>
+#endif
+
+#include <QtNetwork/qtcpsocket.h>
+
 #include <QtCore/qdebug.h>
 #include <QtCore/qlist.h>
 #include <QtCore/qfile.h>
@@ -60,8 +65,9 @@ inline bool is_valid_client_stream(quint32 streamID)
 
 }
 
-Http2Server::Http2Server(const Http2Settings &ss, const Http2Settings &cs)
-    : serverSettings(ss)
+Http2Server::Http2Server(bool h2c, const Http2Settings &ss, const Http2Settings &cs)
+    : serverSettings(ss),
+      clearTextHTTP2(h2c)
 {
     for (const auto &s : cs)
         expectedClientSettings[quint16(s.identifier)] = s.value;
@@ -97,6 +103,11 @@ void Http2Server::setResponseBody(const QByteArray &body)
 
 void Http2Server::startServer()
 {
+#ifdef QT_NO_SSL
+    // Let the test fail with timeout.
+    if (!clearTextHTTP2)
+        return;
+#endif
     if (listen())
         emit serverStarted(serverPort());
 }
@@ -109,14 +120,14 @@ void Http2Server::sendServerSettings()
     if (!serverSettings.size())
         return;
 
-    outboundFrame.start(FrameType::SETTINGS, FrameFlag::EMPTY, connectionStreamID);
+    writer.start(FrameType::SETTINGS, FrameFlag::EMPTY, connectionStreamID);
     for (const auto &s : serverSettings) {
-        outboundFrame.append(s.identifier);
-        outboundFrame.append(s.value);
+        writer.append(s.identifier);
+        writer.append(s.value);
         if (s.identifier == Settings::INITIAL_WINDOW_SIZE_ID)
             streamRecvWindowSize = s.value;
     }
-    outboundFrame.write(*socket);
+    writer.write(*socket);
     // Now, let's update our peer on a session recv window size:
     const quint32 updatedSize = 10 * streamRecvWindowSize;
     if (sessionRecvWindowSize < updatedSize) {
@@ -134,19 +145,19 @@ void Http2Server::sendGOAWAY(quint32 streamID, quint32 error, quint32 lastStream
 {
     Q_ASSERT(socket);
 
-    outboundFrame.start(FrameType::GOAWAY, FrameFlag::EMPTY, streamID);
-    outboundFrame.append(lastStreamID);
-    outboundFrame.append(error);
-    outboundFrame.write(*socket);
+    writer.start(FrameType::GOAWAY, FrameFlag::EMPTY, streamID);
+    writer.append(lastStreamID);
+    writer.append(error);
+    writer.write(*socket);
 }
 
 void Http2Server::sendRST_STREAM(quint32 streamID, quint32 error)
 {
     Q_ASSERT(socket);
 
-    outboundFrame.start(FrameType::RST_STREAM, FrameFlag::EMPTY, streamID);
-    outboundFrame.append(error);
-    outboundFrame.write(*socket);
+    writer.start(FrameType::RST_STREAM, FrameFlag::EMPTY, streamID);
+    writer.append(error);
+    writer.write(*socket);
 }
 
 void Http2Server::sendDATA(quint32 streamID, quint32 windowSize)
@@ -160,19 +171,17 @@ void Http2Server::sendDATA(quint32 streamID, quint32 windowSize)
     Q_ASSERT(offset < quint32(responseBody.size()));
 
     const quint32 bytes = std::min<quint32>(windowSize, responseBody.size() - offset);
-    outboundFrame.start(FrameType::DATA, FrameFlag::EMPTY, streamID);
+    const quint32 frameSizeLimit(clientSetting(Settings::MAX_FRAME_SIZE_ID, Http2::maxFrameSize));
+    const uchar *src = reinterpret_cast<const uchar *>(responseBody.constData() + offset);
     const bool last = offset + bytes == quint32(responseBody.size());
 
-    const quint32 frameSizeLimit(clientSetting(Settings::MAX_FRAME_SIZE_ID, Http2::maxFrameSize));
-    outboundFrame.writeDATA(*socket, frameSizeLimit,
-                            reinterpret_cast<const uchar *>(responseBody.constData() + offset),
-                            bytes);
+    writer.start(FrameType::DATA, FrameFlag::EMPTY, streamID);
+    writer.writeDATA(*socket, frameSizeLimit, src, bytes);
 
     if (last) {
-        outboundFrame.start(FrameType::DATA, FrameFlag::END_STREAM, streamID);
-        outboundFrame.setPayloadSize(0);
-        outboundFrame.write(*socket);
-
+        writer.start(FrameType::DATA, FrameFlag::END_STREAM, streamID);
+        writer.setPayloadSize(0);
+        writer.write(*socket);
         suspendedStreams.erase(it);
         activeRequests.erase(streamID);
 
@@ -187,38 +196,52 @@ void Http2Server::sendWINDOW_UPDATE(quint32 streamID, quint32 delta)
 {
     Q_ASSERT(socket);
 
-    outboundFrame.start(FrameType::WINDOW_UPDATE, FrameFlag::EMPTY, streamID);
-    outboundFrame.append(delta);
-    outboundFrame.write(*socket);
+    writer.start(FrameType::WINDOW_UPDATE, FrameFlag::EMPTY, streamID);
+    writer.append(delta);
+    writer.write(*socket);
 }
 
 void Http2Server::incomingConnection(qintptr socketDescriptor)
 {
-    socket.reset(new QSslSocket);
-    // Add HTTP2 as supported protocol:
-    auto conf = QSslConfiguration::defaultConfiguration();
-    auto protos = conf.allowedNextProtocols();
-    protos.prepend(QSslConfiguration::ALPNProtocolHTTP2);
-    conf.setAllowedNextProtocols(protos);
-    socket->setSslConfiguration(conf);
-    // SSL-related setup ...
-    socket->setPeerVerifyMode(QSslSocket::VerifyNone);
-    socket->setProtocol(QSsl::TlsV1_2OrLater);
-    connect(socket.data(), SIGNAL(sslErrors(QList<QSslError>)),
-            this, SLOT(ignoreErrorSlot()));
-    QFile file(SRCDIR "certs/fluke.key");
-    file.open(QIODevice::ReadOnly);
-    QSslKey key(file.readAll(), QSsl::Rsa, QSsl::Pem, QSsl::PrivateKey);
-    socket->setPrivateKey(key);
-    auto localCert = QSslCertificate::fromPath(SRCDIR "certs/fluke.cert");
-    socket->setLocalCertificateChain(localCert);
-    socket->setSocketDescriptor(socketDescriptor, QAbstractSocket::ConnectedState);
-    // Stop listening.
-    close();
-    // Start SSL handshake and ALPN:
-    connect(socket.data(), SIGNAL(encrypted()),
-            this, SLOT(connectionEncrypted()));
-    socket->startServerEncryption();
+    if (clearTextHTTP2) {
+        socket.reset(new QTcpSocket);
+        const bool set = socket->setSocketDescriptor(socketDescriptor);
+        Q_UNUSED(set) Q_ASSERT(set);
+        // Stop listening:
+        close();
+        QMetaObject::invokeMethod(this, "connectionEstablished",
+                                  Qt::QueuedConnection);
+    } else {
+#ifndef QT_NO_SSL
+        socket.reset(new QSslSocket);
+        QSslSocket *sslSocket = static_cast<QSslSocket *>(socket.data());
+        // Add HTTP2 as supported protocol:
+        auto conf = QSslConfiguration::defaultConfiguration();
+        auto protos = conf.allowedNextProtocols();
+        protos.prepend(QSslConfiguration::ALPNProtocolHTTP2);
+        conf.setAllowedNextProtocols(protos);
+        sslSocket->setSslConfiguration(conf);
+        // SSL-related setup ...
+        sslSocket->setPeerVerifyMode(QSslSocket::VerifyNone);
+        sslSocket->setProtocol(QSsl::TlsV1_2OrLater);
+        connect(sslSocket, SIGNAL(sslErrors(QList<QSslError>)),
+                this, SLOT(ignoreErrorSlot()));
+        QFile file(SRCDIR "certs/fluke.key");
+        file.open(QIODevice::ReadOnly);
+        QSslKey key(file.readAll(), QSsl::Rsa, QSsl::Pem, QSsl::PrivateKey);
+        sslSocket->setPrivateKey(key);
+        auto localCert = QSslCertificate::fromPath(SRCDIR "certs/fluke.cert");
+        sslSocket->setLocalCertificateChain(localCert);
+        sslSocket->setSocketDescriptor(socketDescriptor, QAbstractSocket::ConnectedState);
+        // Stop listening.
+        close();
+        // Start SSL handshake and ALPN:
+        connect(sslSocket, SIGNAL(encrypted()), this, SLOT(connectionEstablished()));
+        sslSocket->startServerEncryption();
+#else
+        Q_UNREACHABLE();
+#endif
+    }
 }
 
 quint32 Http2Server::clientSetting(Http2::Settings identifier, quint32 defaultValue)
@@ -229,7 +252,7 @@ quint32 Http2Server::clientSetting(Http2::Settings identifier, quint32 defaultVa
     return defaultValue;
 }
 
-void Http2Server::connectionEncrypted()
+void Http2Server::connectionEstablished()
 {
     using namespace Http2;
 
@@ -250,7 +273,9 @@ void Http2Server::connectionEncrypted()
 
 void Http2Server::ignoreErrorSlot()
 {
-    socket->ignoreSslErrors();
+#ifndef QT_NO_SSL
+    static_cast<QSslSocket *>(socket.data())->ignoreSslErrors();
+#endif
 }
 
 // Now HTTP2 "server" part:
@@ -273,7 +298,7 @@ void Http2Server::readReady()
     if (waitingClientPreface) {
         handleConnectionPreface();
     } else {
-        const auto status = inboundFrame.read(*socket);
+        const auto status = reader.read(*socket);
         switch (status) {
         case FrameStatus::incompleteFrame:
             break;
@@ -324,9 +349,11 @@ void Http2Server::handleIncomingFrame()
     // 7. RST_STREAM
     // 8. GOAWAY
 
+    inboundFrame = std::move(reader.inboundFrame());
+
     if (continuedRequest.size()) {
-        if (inboundFrame.type != FrameType::CONTINUATION ||
-            inboundFrame.streamID != continuedRequest.front().streamID) {
+        if (inboundFrame.type() != FrameType::CONTINUATION ||
+            inboundFrame.streamID() != continuedRequest.front().streamID()) {
             sendGOAWAY(connectionStreamID, PROTOCOL_ERROR, connectionStreamID);
             emit invalidFrame();
             connectionError = true;
@@ -334,7 +361,7 @@ void Http2Server::handleIncomingFrame()
         }
     }
 
-    switch (inboundFrame.type) {
+    switch (inboundFrame.type()) {
     case FrameType::SETTINGS:
         handleSETTINGS();
         break;
@@ -366,9 +393,9 @@ void Http2Server::handleSETTINGS()
 {
     // SETTINGS is either a part of the connection preface,
     // or a SETTINGS ACK.
-    Q_ASSERT(inboundFrame.type == FrameType::SETTINGS);
+    Q_ASSERT(inboundFrame.type() == FrameType::SETTINGS);
 
-    if (inboundFrame.flags.testFlag(FrameFlag::ACK)) {
+    if (inboundFrame.flags().testFlag(FrameFlag::ACK)) {
         if (!waitingClientAck || inboundFrame.dataSize()) {
             emit invalidFrame();
             connectionError = true;
@@ -409,17 +436,17 @@ void Http2Server::handleSETTINGS()
     }
 
     // Send SETTINGS ACK:
-    outboundFrame.start(FrameType::SETTINGS, FrameFlag::ACK, connectionStreamID);
-    outboundFrame.write(*socket);
+    writer.start(FrameType::SETTINGS, FrameFlag::ACK, connectionStreamID);
+    writer.write(*socket);
     waitingClientSettings = false;
     emit clientPrefaceOK();
 }
 
 void Http2Server::handleDATA()
 {
-    Q_ASSERT(inboundFrame.type == FrameType::DATA);
+    Q_ASSERT(inboundFrame.type() == FrameType::DATA);
 
-    const auto streamID = inboundFrame.streamID;
+    const auto streamID = inboundFrame.streamID();
 
     if (!is_valid_client_stream(streamID) ||
         closedStreams.find(streamID) != closedStreams.end()) {
@@ -429,7 +456,8 @@ void Http2Server::handleDATA()
         return;
     }
 
-    if (sessionCurrRecvWindow < inboundFrame.payloadSize) {
+    const auto payloadSize = inboundFrame.payloadSize();
+    if (sessionCurrRecvWindow < payloadSize) {
         // Client does not respect our session window size!
         emit invalidRequest(streamID);
         connectionError = true;
@@ -441,20 +469,21 @@ void Http2Server::handleDATA()
     if (it == streamWindows.end())
         it = streamWindows.insert(std::make_pair(streamID, streamRecvWindowSize)).first;
 
-    if (it->second < inboundFrame.payloadSize) {
+
+    if (it->second < payloadSize) {
         emit invalidRequest(streamID);
         connectionError = true;
         sendGOAWAY(connectionStreamID, FLOW_CONTROL_ERROR, connectionStreamID);
         return;
     }
 
-    it->second -= inboundFrame.payloadSize;
+    it->second -= payloadSize;
     if (it->second < streamRecvWindowSize / 2) {
         sendWINDOW_UPDATE(streamID, streamRecvWindowSize / 2);
         it->second += streamRecvWindowSize / 2;
     }
 
-    sessionCurrRecvWindow -= inboundFrame.payloadSize;
+    sessionCurrRecvWindow -= payloadSize;
 
     if (sessionCurrRecvWindow < sessionRecvWindowSize / 2) {
         // This is some quite naive and trivial logic on when to update.
@@ -463,7 +492,7 @@ void Http2Server::handleDATA()
         sessionCurrRecvWindow += sessionRecvWindowSize / 2;
     }
 
-    if (inboundFrame.flags.testFlag(FrameFlag::END_STREAM)) {
+    if (inboundFrame.flags().testFlag(FrameFlag::END_STREAM)) {
         closedStreams.insert(streamID); // Enter "half-closed remote" state.
         streamWindows.erase(it);
         emit receivedData(streamID);
@@ -472,7 +501,7 @@ void Http2Server::handleDATA()
 
 void Http2Server::handleWINDOW_UPDATE()
 {
-    const auto streamID = inboundFrame.streamID;
+    const auto streamID = inboundFrame.streamID();
     if (!streamID) // We ignore this for now to keep things simple.
         return;
 
@@ -502,9 +531,9 @@ void Http2Server::sendResponse(quint32 streamID, bool emptyBody)
 {
     Q_ASSERT(activeRequests.find(streamID) != activeRequests.end());
 
-    outboundFrame.start(FrameType::HEADERS, FrameFlag::END_HEADERS, streamID);
+    writer.start(FrameType::HEADERS, FrameFlag::END_HEADERS, streamID);
     if (emptyBody)
-        outboundFrame.addFlag(FrameFlag::END_STREAM);
+        writer.addFlag(FrameFlag::END_STREAM);
 
     HttpHeader header = {{":status", "200"}};
     if (!emptyBody) {
@@ -512,13 +541,13 @@ void Http2Server::sendResponse(quint32 streamID, bool emptyBody)
                          QString("%1").arg(responseBody.size()).toLatin1()));
     }
 
-    HPack::BitOStream ostream(outboundFrame.rawFrameBuffer());
+    HPack::BitOStream ostream(writer.outboundFrame().buffer);
     const bool result = encoder.encodeResponse(ostream, header);
     Q_ASSERT(result);
     Q_UNUSED(result)
 
     const quint32 maxFrameSize(clientSetting(Settings::MAX_FRAME_SIZE_ID, Http2::maxFrameSize));
-    outboundFrame.writeHEADERS(*socket, maxFrameSize);
+    writer.writeHEADERS(*socket, maxFrameSize);
 
     if (!emptyBody) {
         Q_ASSERT(suspendedStreams.find(streamID) == suspendedStreams.end());
@@ -538,7 +567,7 @@ void Http2Server::processRequest()
 {
     Q_ASSERT(continuedRequest.size());
 
-    if (!continuedRequest.back().flags.testFlag(FrameFlag::END_HEADERS))
+    if (!continuedRequest.back().flags().testFlag(FrameFlag::END_HEADERS))
         return;
 
     // We test here:
@@ -546,7 +575,7 @@ void Http2Server::processRequest()
     // 2. has priority set and dependency (it's 0x0 at the moment).
     // 3. header can be decompressed.
     const auto &headersFrame = continuedRequest.front();
-    const auto streamID = headersFrame.streamID;
+    const auto streamID = headersFrame.streamID();
     if (!is_valid_client_stream(streamID)) {
         emit invalidRequest(streamID);
         connectionError = true;
@@ -600,12 +629,12 @@ void Http2Server::processRequest()
         return;
     }
 
-    continuedRequest.clear();
     // Actually, if needed, we can do a comparison here.
     activeRequests[streamID] = decoder.decodedHeader();
-    if (headersFrame.flags.testFlag(FrameFlag::END_STREAM))
+    if (headersFrame.flags().testFlag(FrameFlag::END_STREAM))
         emit receivedRequest(streamID);
     // else - we're waiting for incoming DATA frames ...
+    continuedRequest.clear();
 }
 
 QT_END_NAMESPACE
diff --git a/tests/auto/network/access/http2/http2srv.h b/tests/auto/network/access/http2/http2srv.h
index 00cfde944b..73b1d80f8e 100644..100755
--- a/tests/auto/network/access/http2/http2srv.h
+++ b/tests/auto/network/access/http2/http2srv.h
@@ -33,9 +33,9 @@
 #include <QtNetwork/private/http2frames_p.h>
 #include <QtNetwork/private/hpack_p.h>
 
+#include <QtNetwork/qabstractsocket.h>
 #include <QtCore/qscopedpointer.h>
 #include <QtNetwork/qtcpserver.h>
-#include <QtNetwork/qsslsocket.h>
 #include <QtCore/qbytearray.h>
 #include <QtCore/qglobal.h>
 
@@ -62,7 +62,7 @@ class Http2Server : public QTcpServer
 {
     Q_OBJECT
 public:
-    Http2Server(const Http2Settings &serverSettings,
+    Http2Server(bool clearText, const Http2Settings &serverSettings,
                 const Http2Settings &clientSettings);
 
     ~Http2Server();
@@ -105,7 +105,7 @@ Q_SIGNALS:
     void windowUpdate(quint32 streamID);
 
 private slots:
-    void connectionEncrypted();
+    void connectionEstablished();
     void readReady();
 
 private:
@@ -113,7 +113,7 @@ private:
 
     quint32 clientSetting(Http2::Settings identifier, quint32 defaultValue);
 
-    QScopedPointer<QSslSocket> socket;
+    QScopedPointer<QAbstractSocket> socket;
 
     // Connection preface:
     bool waitingClientPreface = false;
@@ -126,10 +126,11 @@ private:
 
     bool connectionError = false;
 
-    Http2::FrameReader inboundFrame;
-    Http2::FrameWriter outboundFrame;
+    Http2::FrameReader reader;
+    Http2::Frame inboundFrame;
+    Http2::FrameWriter writer;
 
-    using FrameSequence = std::vector<Http2::FrameReader>;
+    using FrameSequence = std::vector<Http2::Frame>;
     FrameSequence continuedRequest;
 
     std::map<quint32, quint32> streamWindows;
@@ -155,6 +156,7 @@ private:
     quint32 streamRecvWindowSize = Http2::defaultSessionWindowSize;
 
     QByteArray responseBody;
+    bool clearTextHTTP2 = false;
 
 protected slots:
     void ignoreErrorSlot();
diff --git a/tests/auto/network/access/http2/tst_http2.cpp b/tests/auto/network/access/http2/tst_http2.cpp
index dbb89db0f9..582a103b2e 100644
--- a/tests/auto/network/access/http2/tst_http2.cpp
+++ b/tests/auto/network/access/http2/tst_http2.cpp
@@ -49,7 +49,9 @@
 
 // At the moment our HTTP/2 imlpementation requires ALPN and this means OpenSSL.
 #if !defined(QT_NO_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10002000L && !defined(OPENSSL_NO_TLSEXT)
-#define QT_ALPN
+const bool clearTextHTTP2 = false;
+#else
+const bool clearTextHTTP2 = true;
 #endif
 
 QT_BEGIN_NAMESPACE
@@ -139,9 +141,6 @@ tst_Http2::~tst_Http2()
 
 void tst_Http2::singleRequest()
 {
-#ifndef QT_ALPN
-    QSKIP("This test requires ALPN support");
-#endif
     clearHTTP2State();
 
     serverPort = 0;
@@ -154,7 +153,9 @@ void tst_Http2::singleRequest()
 
     QVERIFY(serverPort != 0);
 
-    const QUrl url(QString("https://127.0.0.1:%1/index.html").arg(serverPort));
+    const QString urlAsString(clearTextHTTP2 ? QString("http://127.0.0.1:%1/index.html")
+                                             : QString("https://127.0.0.1:%1/index.html"));
+    const QUrl url(urlAsString.arg(serverPort));
 
     QNetworkRequest request(url);
     request.setAttribute(QNetworkRequest::HTTP2AllowedAttribute, QVariant(true));
@@ -179,9 +180,6 @@ void tst_Http2::singleRequest()
 
 void tst_Http2::multipleRequests()
 {
-#ifndef QT_ALPN
-    QSKIP("This test requires ALPN support");
-#endif
     clearHTTP2State();
 
     serverPort = 0;
@@ -216,16 +214,12 @@ void tst_Http2::multipleRequests()
 
 void tst_Http2::flowControlClientSide()
 {
-#ifndef QT_ALPN
-    QSKIP("This test requires ALPN support");
-#endif
     // Create a server but impose limits:
     // 1. Small MAX frame size, so we test CONTINUATION frames.
     // 2. Small client windows so server responses cause client streams
     //    to suspend and server sends WINDOW_UPDATE frames.
     // 3. Few concurrent streams, to test protocol handler can resume
     //    suspended requests.
-
     using namespace Http2;
 
     clearHTTP2State();
@@ -238,7 +232,7 @@ void tst_Http2::flowControlClientSide()
 
     auto srv = newServer(serverSettings);
 
-    const QByteArray respond(int(Http2::defaultSessionWindowSize * 100), 'x');
+    const QByteArray respond(int(Http2::defaultSessionWindowSize * 50), 'x');
     srv->setResponseBody(respond);
 
     QMetaObject::invokeMethod(srv, "startServer", Qt::QueuedConnection);
@@ -249,7 +243,7 @@ void tst_Http2::flowControlClientSide()
     for (int i = 0; i < nRequests; ++i)
         sendRequest(i);
 
-    runEventLoop(10000);
+    runEventLoop(120000);
 
     QVERIFY(nRequests == 0);
     QVERIFY(prefaceOK);
@@ -261,9 +255,6 @@ void tst_Http2::flowControlClientSide()
 
 void tst_Http2::flowControlServerSide()
 {
-#ifndef QT_ALPN
-    QSKIP("This test requires ALPN support");
-#endif
     // Quite aggressive test:
     // low MAX_FRAME_SIZE forces a lot of small DATA frames,
     // payload size exceedes stream/session RECV window sizes
@@ -281,7 +272,7 @@ void tst_Http2::flowControlServerSide()
 
     auto srv = newServer(serverSettings);
 
-    const QByteArray payload(int(Http2::defaultSessionWindowSize * 1000), 'x');
+    const QByteArray payload(int(Http2::defaultSessionWindowSize * 500), 'x');
 
     QMetaObject::invokeMethod(srv, "startServer", Qt::QueuedConnection);
 
@@ -333,7 +324,7 @@ Http2Server *tst_Http2::newServer(const Http2Settings &serverSettings)
     // Client's settings are fixed by qhttp2protocolhandler.
     const Http2Settings clientSettings = {{Settings::MAX_FRAME_SIZE_ID, quint32(Http2::maxFrameSize)},
                                           {Settings::ENABLE_PUSH_ID, quint32(0)}};
-    auto srv = new Http2Server(serverSettings, clientSettings);
+    auto srv = new Http2Server(clearTextHTTP2, serverSettings, clientSettings);
 
     using Srv = Http2Server;
     using Cl = tst_Http2;
@@ -357,7 +348,8 @@ void tst_Http2::sendRequest(int streamNumber,
                             QNetworkRequest::Priority priority,
                             const QByteArray &payload)
 {
-    static const QString urlAsString("https://127.0.0.1:%1/stream%2.html");
+    static const QString urlAsString(clearTextHTTP2 ? "http://127.0.0.1:%1/stream%2.html"
+                                                    : "https://127.0.0.1:%1/stream%2.html");
 
     const QUrl url(urlAsString.arg(serverPort).arg(streamNumber));
     QNetworkRequest request(url);
diff --git a/tests/auto/network/access/qftp/qftp.pro b/tests/auto/network/access/qftp/qftp.pro
index 6f1a4a7543..1959c1acac 100644
--- a/tests/auto/network/access/qftp/qftp.pro
+++ b/tests/auto/network/access/qftp/qftp.pro
@@ -2,5 +2,5 @@ CONFIG += testcase
 TARGET = tst_qftp
 SOURCES  += tst_qftp.cpp
 
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
 QT = core network network-private testlib
diff --git a/tests/auto/network/access/qhttpnetworkconnection/qhttpnetworkconnection.pro b/tests/auto/network/access/qhttpnetworkconnection/qhttpnetworkconnection.pro
index bd20fd33dd..d32b651b86 100644
--- a/tests/auto/network/access/qhttpnetworkconnection/qhttpnetworkconnection.pro
+++ b/tests/auto/network/access/qhttpnetworkconnection/qhttpnetworkconnection.pro
@@ -1,6 +1,6 @@
 CONFIG += testcase
 TARGET = tst_qhttpnetworkconnection
 SOURCES  += tst_qhttpnetworkconnection.cpp
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
 
 QT = core-private network-private testlib
diff --git a/tests/auto/network/access/qhttpnetworkreply/qhttpnetworkreply.pro b/tests/auto/network/access/qhttpnetworkreply/qhttpnetworkreply.pro
index 1810a38f6e..31570e6f01 100644
--- a/tests/auto/network/access/qhttpnetworkreply/qhttpnetworkreply.pro
+++ b/tests/auto/network/access/qhttpnetworkreply/qhttpnetworkreply.pro
@@ -1,6 +1,6 @@
 CONFIG += testcase
 TARGET = tst_qhttpnetworkreply
 SOURCES  += tst_qhttpnetworkreply.cpp
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
 
 QT = core-private network-private testlib
diff --git a/tests/auto/network/access/qnetworkreply/test/test.pro b/tests/auto/network/access/qnetworkreply/test/test.pro
index 772bb55990..47e7f5ed15 100644
--- a/tests/auto/network/access/qnetworkreply/test/test.pro
+++ b/tests/auto/network/access/qnetworkreply/test/test.pro
@@ -10,7 +10,7 @@ RESOURCES += ../qnetworkreply.qrc
 TESTDATA += ../empty ../rfc3252.txt ../resource ../bigfile ../*.jpg ../certs \
             ../index.html ../smb-file.txt
 
-contains(QT_CONFIG,xcb): CONFIG+=insignificant_test  # unstable, QTBUG-21102
+qtConfig(xcb): CONFIG+=insignificant_test  # unstable, QTBUG-21102
 win32:CONFIG += insignificant_test # QTBUG-24226
 
 !winrt: TEST_HELPER_INSTALLS = ../echo/echo
diff --git a/tests/auto/network/kernel/kernel.pro b/tests/auto/network/kernel/kernel.pro
index 6c3a234de5..42df80dfa1 100644
--- a/tests/auto/network/kernel/kernel.pro
+++ b/tests/auto/network/kernel/kernel.pro
@@ -18,7 +18,7 @@ winrt: SUBDIRS -= \
 osx: SUBDIRS -= \ # QTBUG-41847
     qhostinfo \
 
-!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
     qauthenticator \
     qhostinfo \
 
diff --git a/tests/auto/network/kernel/qauthenticator/qauthenticator.pro b/tests/auto/network/kernel/qauthenticator/qauthenticator.pro
index 5e4759b690..5038eea9af 100644
--- a/tests/auto/network/kernel/qauthenticator/qauthenticator.pro
+++ b/tests/auto/network/kernel/qauthenticator/qauthenticator.pro
@@ -1,6 +1,6 @@
 CONFIG += testcase
 TARGET = tst_qauthenticator
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
 QT = core network-private testlib
 SOURCES  += tst_qauthenticator.cpp
 DEFINES += SRCDIR=\\\"$$PWD/\\\"
diff --git a/tests/auto/network/kernel/qhostinfo/qhostinfo.pro b/tests/auto/network/kernel/qhostinfo/qhostinfo.pro
index 4ea415c529..67a37faeb5 100644
--- a/tests/auto/network/kernel/qhostinfo/qhostinfo.pro
+++ b/tests/auto/network/kernel/qhostinfo/qhostinfo.pro
@@ -3,7 +3,7 @@ TARGET = tst_qhostinfo
 
 SOURCES  += tst_qhostinfo.cpp
 
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
 QT = core-private network-private testlib
 
 win32:LIBS += -lws2_32
diff --git a/tests/auto/network/socket/platformsocketengine/platformsocketengine.pri b/tests/auto/network/socket/platformsocketengine/platformsocketengine.pri
index 6c7857ea1d..46c722deba 100644
--- a/tests/auto/network/socket/platformsocketengine/platformsocketengine.pri
+++ b/tests/auto/network/socket/platformsocketengine/platformsocketengine.pri
@@ -6,7 +6,7 @@ INCLUDEPATH += $$QNETWORK_SRC
 
 win32:LIBS += -lws2_32
 
-unix:contains(QT_CONFIG, reduce_exports) {
+unix:qtConfig(reduce_exports) {
     SOURCES += $$QNETWORK_SRC/socket/qnativesocketengine_unix.cpp
     SOURCES += $$QNETWORK_SRC/socket/qnativesocketengine.cpp
     SOURCES += $$QNETWORK_SRC/socket/qabstractsocketengine.cpp
diff --git a/tests/auto/network/socket/platformsocketengine/platformsocketengine.pro b/tests/auto/network/socket/platformsocketengine/platformsocketengine.pro
index eee762037d..ab96bb444e 100644
--- a/tests/auto/network/socket/platformsocketengine/platformsocketengine.pro
+++ b/tests/auto/network/socket/platformsocketengine/platformsocketengine.pro
@@ -4,7 +4,7 @@ SOURCES  += tst_platformsocketengine.cpp
 
 include(../platformsocketengine/platformsocketengine.pri)
 
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
 
 MOC_DIR=tmp
 
diff --git a/tests/auto/network/socket/platformsocketengine/tst_platformsocketengine.cpp b/tests/auto/network/socket/platformsocketengine/tst_platformsocketengine.cpp
index bc9d3cc9bf..43b5422635 100644
--- a/tests/auto/network/socket/platformsocketengine/tst_platformsocketengine.cpp
+++ b/tests/auto/network/socket/platformsocketengine/tst_platformsocketengine.cpp
@@ -111,6 +111,7 @@ void tst_PlatformSocketEngine::construction()
     QCOMPARE(socketDevice.peerAddress(), QHostAddress());
     QCOMPARE(socketDevice.peerPort(), quint16(0));
     QCOMPARE(socketDevice.error(), QAbstractSocket::UnknownSocketError);
+    QCOMPARE(socketDevice.option(QNativeSocketEngine::NonBlockingSocketOption), -1);
 
     QTest::ignoreMessage(QtWarningMsg, PLATFORMSOCKETENGINESTRING "::bytesAvailable() was called in QAbstractSocket::UnconnectedState");
     QCOMPARE(socketDevice.bytesAvailable(), -1);
diff --git a/tests/auto/network/socket/qhttpsocketengine/qhttpsocketengine.pro b/tests/auto/network/socket/qhttpsocketengine/qhttpsocketengine.pro
index 12ce576e23..56a4fb8aee 100644
--- a/tests/auto/network/socket/qhttpsocketengine/qhttpsocketengine.pro
+++ b/tests/auto/network/socket/qhttpsocketengine/qhttpsocketengine.pro
@@ -7,6 +7,6 @@ include(../platformsocketengine/platformsocketengine.pri)
 
 MOC_DIR=tmp
 
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
 QT = core-private network-private testlib
 
diff --git a/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp b/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp
index 00e01094a4..8cc06a77ba 100644
--- a/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp
+++ b/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp
@@ -181,6 +181,7 @@ private slots:
     void slotConnected()
     {
         QCOMPARE(state(), QLocalSocket::ConnectedState);
+        QVERIFY(isOpen());
     }
     void slotDisconnected()
     {
diff --git a/tests/auto/network/socket/qsocks5socketengine/qsocks5socketengine.pro b/tests/auto/network/socket/qsocks5socketengine/qsocks5socketengine.pro
index f3c24e19fd..71ceafa133 100644
--- a/tests/auto/network/socket/qsocks5socketengine/qsocks5socketengine.pro
+++ b/tests/auto/network/socket/qsocks5socketengine/qsocks5socketengine.pro
@@ -10,4 +10,4 @@ MOC_DIR=tmp
 
 QT = core-private network-private testlib
 
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
diff --git a/tests/auto/network/socket/qtcpsocket/qtcpsocket.pro b/tests/auto/network/socket/qtcpsocket/qtcpsocket.pro
index 5686f4a697..1183b23556 100644
--- a/tests/auto/network/socket/qtcpsocket/qtcpsocket.pro
+++ b/tests/auto/network/socket/qtcpsocket/qtcpsocket.pro
@@ -3,4 +3,4 @@ TEMPLATE = subdirs
 SUBDIRS = test
 !vxworks: SUBDIRS += stressTest
 
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
diff --git a/tests/auto/network/socket/socket.pro b/tests/auto/network/socket/socket.pro
index 75f9e3f3a0..307f7e92de 100644
--- a/tests/auto/network/socket/socket.pro
+++ b/tests/auto/network/socket/socket.pro
@@ -10,13 +10,13 @@ SUBDIRS=\
    platformsocketengine \
    qsctpsocket \
 
-!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
    platformsocketengine \
    qtcpsocket \
    qhttpsocketengine \
    qsocks5socketengine \
 
-!contains(QT_CONFIG, sctp): SUBDIRS -= \
+!qtConfig(sctp): SUBDIRS -= \
    qsctpsocket \
 
 winrt: SUBDIRS -= \
diff --git a/tests/auto/network/ssl/qssldiffiehellmanparameters/tst_qssldiffiehellmanparameters.cpp b/tests/auto/network/ssl/qssldiffiehellmanparameters/tst_qssldiffiehellmanparameters.cpp
index 32cc982a65..f3b9003fbb 100644
--- a/tests/auto/network/ssl/qssldiffiehellmanparameters/tst_qssldiffiehellmanparameters.cpp
+++ b/tests/auto/network/ssl/qssldiffiehellmanparameters/tst_qssldiffiehellmanparameters.cpp
@@ -81,7 +81,7 @@ void tst_QSslDiffieHellmanParameters::constructionDefault()
 void tst_QSslDiffieHellmanParameters::constructionDER()
 {
     // Uniquely generated with 'openssl dhparam -outform DER -out out.der -check -2 4096'
-    QSslDiffieHellmanParameters dh(QByteArray::fromBase64(QByteArrayLiteral(
+    const auto dh = QSslDiffieHellmanParameters::fromEncoded(QByteArray::fromBase64(QByteArrayLiteral(
         "MIICCAKCAgEAsbQYx57ZlyEyWF8jD5WYEswGR2aTVFsHqP3026SdyTwcjY+YlMOae0EagK"
         "jDA0UlPcih1kguQOvOVgyc5gI3YbBb4pCNEdy048xITlsdqG7qC3+2VvFR3vfixEbQQll9"
         "2cGIIneD/36p7KJcDnBNUwwWj/VJKhTwelTfKTj2T39si9xGMkqZiQuCaXRk6vSKZ4ZDPk"
@@ -103,7 +103,7 @@ void tst_QSslDiffieHellmanParameters::constructionDER()
 void tst_QSslDiffieHellmanParameters::constructionPEM()
 {
     // Uniquely generated with 'openssl dhparam -outform PEM -out out.pem -check -2 4096'
-    QSslDiffieHellmanParameters dh(QByteArrayLiteral(
+    const auto dh = QSslDiffieHellmanParameters::fromEncoded(QByteArrayLiteral(
         "-----BEGIN DH PARAMETERS-----\n"
         "MIICCAKCAgEA9QTdqhQkbGuhWzBsW5X475AjjrITpg1BHX5+mp1sstUd84Lshq1T\n"
         "+S2QQQtdl25EPoUblpyyLAf8krFSH4YwR7jjLWklA8paDOwRYod0zLmVZ1Wx6og3\n"
@@ -128,7 +128,7 @@ void tst_QSslDiffieHellmanParameters::constructionPEM()
 void tst_QSslDiffieHellmanParameters::unsafe512Bits()
 {
     // Uniquely generated with 'openssl dhparam -outform PEM -out out.pem -check -2 512'
-    QSslDiffieHellmanParameters dh(QByteArrayLiteral(
+    const auto dh = QSslDiffieHellmanParameters::fromEncoded(QByteArrayLiteral(
         "-----BEGIN DH PARAMETERS-----\n"
         "MEYCQQCf8goDn56akiliAtEL1ZG7VH+9wfLxsv8/B1emTUG+rMKB1yaVAU7HaAiM\n"
         "Gtmo2bAWUqBczUTOTzqmWTm28P6bAgEC\n"
@@ -145,7 +145,7 @@ void tst_QSslDiffieHellmanParameters::unsafeNonPrime()
 {
     // Uniquely generated with 'openssl dhparam -outform DER -out out.der -check -2 1024'
     // and then modified by hand to make P not be a prime number.
-    QSslDiffieHellmanParameters dh(QByteArray::fromBase64(QByteArrayLiteral(
+    const auto dh = QSslDiffieHellmanParameters::fromEncoded(QByteArray::fromBase64(QByteArrayLiteral(
         "MIGHAoGBALLcOLg+ow8TMnbCUeNjwys6wUTIH9mn4ZSeIbD6qvCsJgg4cUxXwJQmPY"
         "Xl15AsKXgkXWh0n+/N6tjH0sSRJnzDvN2H3KxFLKkvxmBYrDOJMdCuMgZD50aOsVyd"
         "vholAW9zilkoYkB6sqwxY1Z2dbpTWajCsUAWZQ0AIP4Y5nesAgEC"
diff --git a/tests/auto/network/ssl/qsslkey/qsslkey.pro b/tests/auto/network/ssl/qsslkey/qsslkey.pro
index 52377a9005..8c3877631a 100644
--- a/tests/auto/network/ssl/qsslkey/qsslkey.pro
+++ b/tests/auto/network/ssl/qsslkey/qsslkey.pro
@@ -3,7 +3,7 @@ CONFIG += testcase
 SOURCES += tst_qsslkey.cpp
 win32:LIBS += -lws2_32
 QT = core network testlib
-contains(QT_CONFIG, private_tests) {
+qtConfig(private_tests) {
     QT += core-private network-private
 }
 
diff --git a/tests/auto/network/ssl/qsslsocket/qsslsocket.pro b/tests/auto/network/ssl/qsslsocket/qsslsocket.pro
index 9a525408fd..5c92ca833a 100644
--- a/tests/auto/network/ssl/qsslsocket/qsslsocket.pro
+++ b/tests/auto/network/ssl/qsslsocket/qsslsocket.pro
@@ -15,11 +15,11 @@ win32 {
 }
 
 # OpenSSL support
-contains(QT_CONFIG, openssl) | contains(QT_CONFIG, openssl-linked) {
+qtConfig(openssl)|qtConfig(openssl-linked) {
     # Add optional SSL libs
     LIBS += $$OPENSSL_LIBS
 }
 
 DEFINES += SRCDIR=\\\"$$PWD/\\\"
 
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
diff --git a/tests/auto/network/ssl/qsslsocket/tst_qsslsocket.cpp b/tests/auto/network/ssl/qsslsocket/tst_qsslsocket.cpp
index bf38a09aeb..03ddd4d6f8 100644
--- a/tests/auto/network/ssl/qsslsocket/tst_qsslsocket.cpp
+++ b/tests/auto/network/ssl/qsslsocket/tst_qsslsocket.cpp
@@ -57,7 +57,7 @@
 #include "private/qsslconfiguration_p.h"
 
 Q_DECLARE_METATYPE(QSslSocket::SslMode)
-typedef QList<QSslError::SslError> SslErrorList;
+typedef QVector<QSslError::SslError> SslErrorList;
 Q_DECLARE_METATYPE(SslErrorList)
 Q_DECLARE_METATYPE(QSslError)
 Q_DECLARE_METATYPE(QSslKey)
@@ -386,14 +386,14 @@ void tst_QSslSocket::cleanup()
 #ifndef QT_NO_SSL
 QSslSocketPtr tst_QSslSocket::newSocket()
 {
-    QSslSocket *socket = new QSslSocket;
+    const auto socket = QSslSocketPtr::create();
 
     proxyAuthCalled = 0;
-    connect(socket, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
+    connect(socket.data(), SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
             SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
             Qt::DirectConnection);
 
-    return QSslSocketPtr(socket);
+    return socket;
 }
 #endif
 
@@ -633,7 +633,8 @@ void tst_QSslSocket::sslErrors()
     // check the SSL errors contain HostNameMismatch and an error due to
     // the certificate being self-signed
     SslErrorList sslErrors;
-    foreach (const QSslError &err, socket->sslErrors())
+    const auto socketSslErrors = socket->sslErrors();
+    for (const QSslError &err : socketSslErrors)
         sslErrors << err.error();
     qSort(sslErrors);
     QVERIFY(sslErrors.contains(QSslError::HostNameMismatch));
@@ -642,7 +643,8 @@ void tst_QSslSocket::sslErrors()
     // check the same errors were emitted by sslErrors
     QVERIFY(!sslErrorsSpy.isEmpty());
     SslErrorList emittedErrors;
-    foreach (const QSslError &err, qvariant_cast<QList<QSslError> >(sslErrorsSpy.first().first()))
+    const auto sslErrorsSpyErrors = qvariant_cast<QList<QSslError> >(qAsConst(sslErrorsSpy).first().first());
+    for (const QSslError &err : sslErrorsSpyErrors)
         emittedErrors << err.error();
     qSort(emittedErrors);
     QCOMPARE(sslErrors, emittedErrors);
@@ -651,7 +653,7 @@ void tst_QSslSocket::sslErrors()
     QVERIFY(!peerVerifyErrorSpy.isEmpty());
     SslErrorList peerErrors;
     const QList<QVariantList> &peerVerifyList = peerVerifyErrorSpy;
-    foreach (const QVariantList &args, peerVerifyList)
+    for (const QVariantList &args : peerVerifyList)
         peerErrors << qvariant_cast<QSslError>(args.first()).error();
     qSort(peerErrors);
     QCOMPARE(sslErrors, peerErrors);
@@ -1261,8 +1263,8 @@ void tst_QSslSocket::protocolServerSide()
     QEventLoop loop;
     QTimer::singleShot(5000, &loop, SLOT(quit()));
 
-    QSslSocketPtr client(new QSslSocket);
-    socket = client.data();
+    QSslSocket client;
+    socket = &client;
     QFETCH(QSsl::SslProtocol, clientProtocol);
     socket->setProtocol(clientProtocol);
     // upon SSL wrong version error, error will be triggered, not sslErrors
@@ -1270,14 +1272,14 @@ void tst_QSslSocket::protocolServerSide()
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
-    client->connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
+    client.connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
 
     loop.exec();
 
     QFETCH(bool, works);
     QAbstractSocket::SocketState expectedState = (works) ? QAbstractSocket::ConnectedState : QAbstractSocket::UnconnectedState;
-    QCOMPARE(int(client->state()), int(expectedState));
-    QCOMPARE(client->isEncrypted(), works);
+    QCOMPARE(int(client.state()), int(expectedState));
+    QCOMPARE(client.isEncrypted(), works);
 }
 
 #ifndef QT_NO_OPENSSL
@@ -1302,8 +1304,8 @@ void tst_QSslSocket::serverCipherPreferences()
         QEventLoop loop;
         QTimer::singleShot(5000, &loop, SLOT(quit()));
 
-        QSslSocketPtr client(new QSslSocket);
-        socket = client.data();
+        QSslSocket client;
+        socket = &client;
         socket->setCiphers("AES256-SHA:AES128-SHA");
 
         // upon SSL wrong version error, error will be triggered, not sslErrors
@@ -1311,12 +1313,12 @@ void tst_QSslSocket::serverCipherPreferences()
         connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
         connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
-        client->connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
+        client.connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
 
         loop.exec();
 
-        QVERIFY(client->isEncrypted());
-        QCOMPARE(client->sessionCipher().name(), QString("AES128-SHA"));
+        QVERIFY(client.isEncrypted());
+        QCOMPARE(client.sessionCipher().name(), QString("AES128-SHA"));
     }
 
     {
@@ -1331,8 +1333,8 @@ void tst_QSslSocket::serverCipherPreferences()
         QEventLoop loop;
         QTimer::singleShot(5000, &loop, SLOT(quit()));
 
-        QSslSocketPtr client(new QSslSocket);
-        socket = client.data();
+        QSslSocket client;
+        socket = &client;
         socket->setCiphers("AES256-SHA:AES128-SHA");
 
         // upon SSL wrong version error, error will be triggered, not sslErrors
@@ -1340,12 +1342,12 @@ void tst_QSslSocket::serverCipherPreferences()
         connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
         connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
-        client->connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
+        client.connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
 
         loop.exec();
 
-        QVERIFY(client->isEncrypted());
-        QCOMPARE(client->sessionCipher().name(), QString("AES256-SHA"));
+        QVERIFY(client.isEncrypted());
+        QCOMPARE(client.sessionCipher().name(), QString("AES256-SHA"));
     }
 }
 
@@ -1402,7 +1404,8 @@ void tst_QSslSocket::setLocalCertificateChain()
     QEventLoop loop;
     QTimer::singleShot(5000, &loop, SLOT(quit()));
 
-    socket = new QSslSocket();
+    const QScopedPointer<QSslSocket, QScopedPointerDeleteLater> client(new QSslSocket);
+    socket = client.data();
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
     connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
@@ -1414,8 +1417,6 @@ void tst_QSslSocket::setLocalCertificateChain()
     QCOMPARE(chain.size(), 2);
     QCOMPARE(chain[0].serialNumber(), QByteArray("10:a0:ad:77:58:f6:6e:ae:46:93:a3:43:f9:59:8a:9e"));
     QCOMPARE(chain[1].serialNumber(), QByteArray("3b:eb:99:c5:ea:d8:0b:5d:0b:97:5d:4f:06:75:4b:e1"));
-
-    socket->deleteLater();
 }
 
 void tst_QSslSocket::setPrivateKey()
@@ -1437,21 +1438,21 @@ void tst_QSslSocket::setSocketDescriptor()
     QEventLoop loop;
     QTimer::singleShot(5000, &loop, SLOT(quit()));
 
-    QSslSocketPtr client(new QSslSocket);
-    socket = client.data();;
+    QSslSocket client;
+    socket = &client;
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
-    client->connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
+    client.connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
 
     loop.exec();
 
-    QCOMPARE(client->state(), QAbstractSocket::ConnectedState);
-    QVERIFY(client->isEncrypted());
-    QVERIFY(!client->peerAddress().isNull());
-    QVERIFY(client->peerPort() != 0);
-    QVERIFY(!client->localAddress().isNull());
-    QVERIFY(client->localPort() != 0);
+    QCOMPARE(client.state(), QAbstractSocket::ConnectedState);
+    QVERIFY(client.isEncrypted());
+    QVERIFY(!client.peerAddress().isNull());
+    QVERIFY(client.peerPort() != 0);
+    QVERIFY(!client.localAddress().isNull());
+    QVERIFY(client.localPort() != 0);
 }
 
 void tst_QSslSocket::setSslConfiguration_data()
@@ -2878,16 +2879,16 @@ void tst_QSslSocket::dhServer()
     QEventLoop loop;
     QTimer::singleShot(5000, &loop, SLOT(quit()));
 
-    QSslSocketPtr client(new QSslSocket);
-    socket = client.data();
+    QSslSocket client;
+    socket = &client;
     connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
-    client->connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
+    client.connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
 
     loop.exec();
-    QCOMPARE(client->state(), QAbstractSocket::ConnectedState);
+    QCOMPARE(client.state(), QAbstractSocket::ConnectedState);
 }
 
 #ifndef QT_NO_OPENSSL
@@ -2912,17 +2913,17 @@ void tst_QSslSocket::dhServerCustomParamsNull()
     QEventLoop loop;
     QTimer::singleShot(5000, &loop, SLOT(quit()));
 
-    QSslSocketPtr client(new QSslSocket);
-    socket = client.data();
+    QSslSocket client;
+    socket = &client;
     connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
-    client->connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
+    client.connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
 
     loop.exec();
 
-    QVERIFY(client->state() != QAbstractSocket::ConnectedState);
+    QVERIFY(client.state() != QAbstractSocket::ConnectedState);
 }
 #endif // QT_NO_OPENSSL
 
@@ -2942,7 +2943,7 @@ void tst_QSslSocket::dhServerCustomParams()
     QSslConfiguration cfg = server.config;
 
     // Custom 2048-bit DH parameters generated with 'openssl dhparam -outform DER -out out.der -check -2 2048'
-    QSslDiffieHellmanParameters dh(QByteArray::fromBase64(QByteArrayLiteral(
+    const auto dh = QSslDiffieHellmanParameters::fromEncoded(QByteArray::fromBase64(QByteArrayLiteral(
         "MIIBCAKCAQEAvVA7b8keTfjFutCtTJmP/pnQfw/prKa+GMed/pBWjrC4N1YwnI8h/A861d9WE/VWY7XMTjvjX3/0"
         "aaU8wEe0EXNpFdlTH+ZMQctQTSJOyQH0RCTwJfDGPCPT9L+c9GKwEKWORH38Earip986HJc0w3UbnfIwXUdsWHiXi"
         "Z6r3cpyBmTKlsXTFiDVAOUXSiO8d/zOb6zHZbDfyB/VbtZRmnA7TXVn9oMzC0g9+FXHdrV4K+XfdvNZdCegvoAZiy"
@@ -2957,17 +2958,17 @@ void tst_QSslSocket::dhServerCustomParams()
     QEventLoop loop;
     QTimer::singleShot(5000, &loop, SLOT(quit()));
 
-    QSslSocketPtr client(new QSslSocket);
-    socket = client.data();
+    QSslSocket client;
+    socket = &client;
     connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
-    client->connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
+    client.connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
 
     loop.exec();
 
-    QVERIFY(client->state() == QAbstractSocket::ConnectedState);
+    QVERIFY(client.state() == QAbstractSocket::ConnectedState);
 }
 #endif // QT_NO_OPENSSL
 
@@ -2989,16 +2990,16 @@ void tst_QSslSocket::ecdhServer()
     QEventLoop loop;
     QTimer::singleShot(5000, &loop, SLOT(quit()));
 
-    QSslSocketPtr client(new QSslSocket);
-    socket = client.data();
+    QSslSocket client;
+    socket = &client;
     connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
-    client->connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
+    client.connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
 
     loop.exec();
-    QCOMPARE(client->state(), QAbstractSocket::ConnectedState);
+    QCOMPARE(client.state(), QAbstractSocket::ConnectedState);
 }
 
 void tst_QSslSocket::verifyClientCertificate_data()
@@ -3100,16 +3101,16 @@ void tst_QSslSocket::verifyClientCertificate()
 
     QFETCH(QList<QSslCertificate>, clientCerts);
     QFETCH(QSslKey, clientKey);
-    QSslSocketPtr client(new QSslSocket);
-    client->setLocalCertificateChain(clientCerts);
-    client->setPrivateKey(clientKey);
-    socket = client.data();
+    QSslSocket client;
+    client.setLocalCertificateChain(clientCerts);
+    client.setPrivateKey(clientKey);
+    socket = &client;
 
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
     connect(socket, SIGNAL(disconnected()), &loop, SLOT(quit()));
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
-    client->connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
+    client.connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
 
     loop.exec();
 
@@ -3131,8 +3132,8 @@ void tst_QSslSocket::verifyClientCertificate()
     }
 
     // check client socket
-    QCOMPARE(int(client->state()), int(expectedState));
-    QCOMPARE(client->isEncrypted(), works);
+    QCOMPARE(int(client.state()), int(expectedState));
+    QCOMPARE(client.isEncrypted(), works);
 }
 
 void tst_QSslSocket::setEmptyDefaultConfiguration() // this test should be last, as it has some side effects
@@ -3280,7 +3281,7 @@ void tst_QSslSocket::simplePskConnect()
 
     bool pskCipherFound = false;
     const QList<QSslCipher> supportedCiphers = QSslSocket::supportedCiphers();
-    foreach (const QSslCipher &cipher, supportedCiphers) {
+    for (const QSslCipher &cipher : supportedCiphers) {
         if (cipher.name() == PSK_CIPHER_WITHOUT_AUTH) {
             pskCipherFound = true;
             break;
diff --git a/tests/auto/network/ssl/qsslsocket_onDemandCertificates_member/qsslsocket_onDemandCertificates_member.pro b/tests/auto/network/ssl/qsslsocket_onDemandCertificates_member/qsslsocket_onDemandCertificates_member.pro
index 4ea878f840..c862b3d3ae 100644
--- a/tests/auto/network/ssl/qsslsocket_onDemandCertificates_member/qsslsocket_onDemandCertificates_member.pro
+++ b/tests/auto/network/ssl/qsslsocket_onDemandCertificates_member/qsslsocket_onDemandCertificates_member.pro
@@ -17,4 +17,4 @@ win32 {
 
 DEFINES += SRCDIR=\\\"$$PWD/\\\"
 
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
diff --git a/tests/auto/network/ssl/qsslsocket_onDemandCertificates_static/qsslsocket_onDemandCertificates_static.pro b/tests/auto/network/ssl/qsslsocket_onDemandCertificates_static/qsslsocket_onDemandCertificates_static.pro
index d69ea7fb3d..c27a58fcd2 100644
--- a/tests/auto/network/ssl/qsslsocket_onDemandCertificates_static/qsslsocket_onDemandCertificates_static.pro
+++ b/tests/auto/network/ssl/qsslsocket_onDemandCertificates_static/qsslsocket_onDemandCertificates_static.pro
@@ -16,4 +16,4 @@ win32 {
 
 DEFINES += SRCDIR=\\\"$$PWD/\\\"
 
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
diff --git a/tests/auto/network/ssl/ssl.pro b/tests/auto/network/ssl/ssl.pro
index df7c10ed19..65e35ea4c0 100644
--- a/tests/auto/network/ssl/ssl.pro
+++ b/tests/auto/network/ssl/ssl.pro
@@ -6,8 +6,8 @@ SUBDIRS=\
    qsslerror \
    qsslkey \
 
-contains(QT_CONFIG, ssl) | contains(QT_CONFIG, openssl) | contains(QT_CONFIG, openssl-linked) {
-    contains(QT_CONFIG, private_tests) {
+qtConfig(ssl)|qtConfig(openssl)|qtConfig(openssl-linked) {
+    qtConfig(private_tests) {
         SUBDIRS += \
             qsslsocket \
             qsslsocket_onDemandCertificates_member \
@@ -19,8 +19,8 @@ winrt: SUBDIRS -= \
    qsslsocket_onDemandCertificates_member \
    qsslsocket_onDemandCertificates_static \
 
-contains(QT_CONFIG, ssl) | contains(QT_CONFIG, openssl) | contains(QT_CONFIG, openssl-linked) {
-    contains(QT_CONFIG, private_tests) {
+qtConfig(ssl)|qtConfig(openssl)|qtConfig(openssl-linked) {
+    qtConfig(private_tests) {
         SUBDIRS += qasn1element \
                    qssldiffiehellmanparameters
     }
diff --git a/tests/auto/opengl/qglthreads/qglthreads.pro b/tests/auto/opengl/qglthreads/qglthreads.pro
index ab8bda741e..9aa21fb3a2 100644
--- a/tests/auto/opengl/qglthreads/qglthreads.pro
+++ b/tests/auto/opengl/qglthreads/qglthreads.pro
@@ -5,10 +5,3 @@ QT += opengl widgets testlib gui-private core-private
 
 HEADERS += tst_qglthreads.h
 SOURCES += tst_qglthreads.cpp
-
-x11 {
-    LIBS += $$QMAKE_LIBS_X11
-}
-
-
-
diff --git a/tests/auto/other/compiler/compiler.pro b/tests/auto/other/compiler/compiler.pro
index 19f86582e9..5a00e53878 100644
--- a/tests/auto/other/compiler/compiler.pro
+++ b/tests/auto/other/compiler/compiler.pro
@@ -3,7 +3,7 @@ TARGET = tst_compiler
 SOURCES += tst_compiler.cpp baseclass.cpp derivedclass.cpp othersource.cpp
 HEADERS += baseclass.h derivedclass.h
 QT = core testlib
-contains(QT_CONFIG, c++11): CONFIG += c++11
-contains(QT_CONFIG, c++14): CONFIG += c++14
+qtConfig(c++11): CONFIG += c++11
+qtConfig(c++14): CONFIG += c++14
 
 
diff --git a/tests/auto/other/other.pro b/tests/auto/other/other.pro
index 3b264e6b72..94b5847b2e 100644
--- a/tests/auto/other/other.pro
+++ b/tests/auto/other/other.pro
@@ -51,9 +51,9 @@ cross_compile: SUBDIRS -= \
    atwrapper \
    compiler
 
-!contains(QT_CONFIG, accessibility): SUBDIRS -= qaccessibility
+!qtConfig(accessibility): SUBDIRS -= qaccessibility
 
-!contains(QT_CONFIG, accessibility-atspi-bridge): SUBDIRS -= qaccessibilitylinux
+!qtConfig(accessibility-atspi-bridge): SUBDIRS -= qaccessibilitylinux
 
 !mac: SUBDIRS -= \
            macgui \
diff --git a/tests/auto/other/qaccessibility/qaccessibility.pro b/tests/auto/other/qaccessibility/qaccessibility.pro
index f697aee38f..fb9de6f450 100644
--- a/tests/auto/other/qaccessibility/qaccessibility.pro
+++ b/tests/auto/other/qaccessibility/qaccessibility.pro
@@ -1,6 +1,6 @@
 CONFIG += testcase
 TARGET = tst_qaccessibility
-requires(contains(QT_CONFIG,accessibility))
+requires(qtConfig(accessibility))
 QT += testlib core-private gui-private widgets-private
 SOURCES += tst_qaccessibility.cpp
 HEADERS += accessiblewidgets.h
diff --git a/tests/auto/tools/moc/tst_moc.cpp b/tests/auto/tools/moc/tst_moc.cpp
index dc28422294..714ae19a10 100644
--- a/tests/auto/tools/moc/tst_moc.cpp
+++ b/tests/auto/tools/moc/tst_moc.cpp
@@ -78,6 +78,73 @@ const char *string_hash_hash = STRING_HASH_HASH("baz");
 
 Q_DECLARE_METATYPE(const QMetaObject*);
 
+namespace TestNonQNamespace {
+
+struct TestGadget {
+    Q_GADGET
+    Q_CLASSINFO("key", "value")
+public:
+    enum class TestGEnum1 {
+        Key1 = 11,
+        Key2
+    };
+    Q_ENUM(TestGEnum1)
+
+    enum class TestGEnum2 {
+        Key1 = 17,
+        Key2
+    };
+    Q_ENUM(TestGEnum2)
+};
+
+}
+
+namespace TestQNamespace {
+    Q_NAMESPACE
+    enum class TestEnum1 {
+        Key1 = 11,
+        Key2
+    };
+    Q_ENUM_NS(TestEnum1)
+
+    enum class TestEnum2 {
+        Key1 = 17,
+        Key2
+    };
+    Q_ENUM_NS(TestEnum2)
+
+    // try to dizzy moc by adding a struct in between
+    struct TestGadget {
+        Q_GADGET
+    public:
+        enum class TestGEnum1 {
+            Key1 = 13,
+            Key2
+        };
+        enum class TestGEnum2 {
+            Key1 = 23,
+            Key2
+        };
+        Q_ENUM(TestGEnum1)
+        Q_ENUM(TestGEnum2)
+    };
+
+    enum class TestFlag1 {
+        None = 0,
+        Flag1 = 1,
+        Flag2 = 2,
+        Any = Flag1 | Flag2
+    };
+    Q_FLAG_NS(TestFlag1)
+
+    enum class TestFlag2 {
+        None = 0,
+        Flag1 = 4,
+        Flag2 = 8,
+        Any = Flag1 | Flag2
+    };
+    Q_FLAG_NS(TestFlag2)
+}
 
 QT_USE_NAMESPACE
 
@@ -627,6 +694,7 @@ private slots:
     void gadgetHierarchy();
     void optionsFileError_data();
     void optionsFileError();
+    void testQNamespace();
 
 signals:
     void sigWithUnsignedArg(unsigned foo);
@@ -2007,6 +2075,13 @@ void tst_Moc::warnings_data()
         << QString()
         << QString("standard input:5: Error: Class declaration lacks Q_OBJECT macro.");
 
+    QTest::newRow("Namespace declaration lacks Q_NAMESPACE macro.")
+        << QByteArray("namespace X {\nQ_CLASSINFO(\"key\",\"value\")\nenum class MyEnum {Key1 = 1}\nQ_ENUMS(MyEnum)\n}\n")
+        << QStringList()
+        << 1
+        << QString()
+        << QString("standard input:1: Error: Namespace declaration lacks Q_NAMESPACE macro.");
+
     QTest::newRow("Invalid macro definition")
         << QByteArray("#define Foo(a, b, c) a b c #a #b #c a##b##c #d\n Foo(45, 42, 39);")
         << QStringList()
@@ -3637,6 +3712,41 @@ void tst_Moc::optionsFileError()
 #endif
 }
 
+static void checkEnum(const QMetaEnum &enumerator, const QByteArray &name, const QVector<QPair<QByteArray, int >> &keys)
+{
+    QCOMPARE(name, QByteArray{enumerator.name()});
+    QCOMPARE(keys.size(), enumerator.keyCount());
+    for (int i = 0; i < enumerator.keyCount(); ++i) {
+        QCOMPARE(keys[i].first, QByteArray{enumerator.key(i)});
+        QCOMPARE(keys[i].second, enumerator.value(i));
+    }
+}
+
+void tst_Moc::testQNamespace()
+{
+    QCOMPARE(TestQNamespace::staticMetaObject.enumeratorCount(), 4);
+    checkEnum(TestQNamespace::staticMetaObject.enumerator(0), "TestEnum1",
+                {{"Key1", 11}, {"Key2", 12}});
+    checkEnum(TestQNamespace::staticMetaObject.enumerator(1), "TestEnum2",
+                {{"Key1", 17}, {"Key2", 18}});
+    checkEnum(TestQNamespace::staticMetaObject.enumerator(2), "TestFlag1",
+                {{"None", 0}, {"Flag1", 1}, {"Flag2", 2}, {"Any", 1 | 2}});
+    checkEnum(TestQNamespace::staticMetaObject.enumerator(3), "TestFlag2",
+                {{"None", 0}, {"Flag1", 4}, {"Flag2", 8}, {"Any", 4 | 8}});
+
+    QCOMPARE(TestQNamespace::TestGadget::staticMetaObject.enumeratorCount(), 2);
+    checkEnum(TestQNamespace::TestGadget::staticMetaObject.enumerator(0), "TestGEnum1",
+                {{"Key1", 13}, {"Key2", 14}});
+    checkEnum(TestQNamespace::TestGadget::staticMetaObject.enumerator(1), "TestGEnum2",
+                {{"Key1", 23}, {"Key2", 24}});
+
+    QMetaEnum meta = QMetaEnum::fromType<TestQNamespace::TestEnum1>();
+    QVERIFY(meta.isValid());
+    QCOMPARE(meta.name(), "TestEnum1");
+    QCOMPARE(meta.enclosingMetaObject(), &TestQNamespace::staticMetaObject);
+    QCOMPARE(meta.keyCount(), 2);
+}
+
 QTEST_MAIN(tst_Moc)
 
 // the generated code must compile with QT_NO_KEYWORDS
diff --git a/tests/auto/tools/qmakelib/evaltest.cpp b/tests/auto/tools/qmakelib/evaltest.cpp
index 21c1759b08..1cd5c71531 100644
--- a/tests/auto/tools/qmakelib/evaltest.cpp
+++ b/tests/auto/tools/qmakelib/evaltest.cpp
@@ -1326,9 +1326,9 @@ void tst_qmakelib::addReplaceFunctions(const QString &qindir)
             << true;
 
     QTest::newRow("$$system(): bad number of arguments")
-            << "VAR = $$system(1, 2, 3)"
+            << "VAR = $$system(1, 2, 3, 4)"
             << "VAR ="
-            << "##:1: system(execute) requires one or two arguments."
+            << "##:1: system(command, [mode], [stsvar]) requires one to three arguments."
             << true;
 
     QTest::newRow("$$unique()")
@@ -2346,12 +2346,18 @@ void tst_qmakelib::addTestFunctions(const QString &qindir)
             << "Project WARNING: World, be warned!"
             << true;
 
-    QTest::newRow("error()")
+    QTest::newRow("error(message)")
             << "error('World, you FAIL!'): OK = 1\nOKE = 1"
             << "OK = UNDEF\nOKE = UNDEF"
             << "Project ERROR: World, you FAIL!"
             << false;
 
+    QTest::newRow("error(empty)")
+            << "error(): OK = 1\nOKE = 1"
+            << "OK = UNDEF\nOKE = UNDEF"
+            << ""
+            << false;
+
     QTest::newRow("if(error())")
             << "if(error(\\'World, you FAIL!\\')): OK = 1\nOKE = 1"
             << "OK = UNDEF\nOKE = UNDEF"
diff --git a/tests/auto/tools/uic/baseline/imagedialog.ui.h b/tests/auto/tools/uic/baseline/imagedialog.ui.h
index c02c40c2c1..99e853b7a8 100644
--- a/tests/auto/tools/uic/baseline/imagedialog.ui.h
+++ b/tests/auto/tools/uic/baseline/imagedialog.ui.h
@@ -155,7 +155,7 @@ public:
 
         vboxLayout->addLayout(gridLayout);
 
-        spacerItem = new QSpacerItem(QSizePolicy::Minimum, QSizePolicy::Expanding);
+        spacerItem = new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding);
 
         vboxLayout->addItem(spacerItem);
 
@@ -166,7 +166,7 @@ public:
         hboxLayout->setContentsMargins(1, 1, 1, 1);
         hboxLayout->setObjectName(QStringLiteral("hboxLayout"));
         hboxLayout->setObjectName(QStringLiteral(""));
-        spacerItem1 = new QSpacerItem(QSizePolicy::Expanding, QSizePolicy::Minimum);
+        spacerItem1 = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum);
 
         hboxLayout->addItem(spacerItem1);
 
diff --git a/tests/auto/tools/uic/baseline/newdynamicpropertydialog.ui.h b/tests/auto/tools/uic/baseline/newdynamicpropertydialog.ui.h
index ca7bd253a8..3c4e0ba09e 100644
--- a/tests/auto/tools/uic/baseline/newdynamicpropertydialog.ui.h
+++ b/tests/auto/tools/uic/baseline/newdynamicpropertydialog.ui.h
@@ -91,7 +91,7 @@ public:
 
         verticalLayout->addLayout(formLayout);
 
-        spacerItem = new QSpacerItem(QSizePolicy::Minimum, QSizePolicy::Expanding);
+        spacerItem = new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding);
 
         verticalLayout->addItem(spacerItem);
 
diff --git a/tests/auto/widgets/dialogs/dialogs.pro b/tests/auto/widgets/dialogs/dialogs.pro
index c6667824d9..cf548f2dea 100644
--- a/tests/auto/widgets/dialogs/dialogs.pro
+++ b/tests/auto/widgets/dialogs/dialogs.pro
@@ -13,7 +13,7 @@ SUBDIRS=\
    qsidebar \
    qwizard \
 
-!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
           qsidebar \
 
 mac:qinputdialog.CONFIG += no_check_target # QTBUG-25496
diff --git a/tests/auto/widgets/graphicsview/graphicsview.pro b/tests/auto/widgets/graphicsview/graphicsview.pro
index dce3c6dda9..e99897a4f6 100644
--- a/tests/auto/widgets/graphicsview/graphicsview.pro
+++ b/tests/auto/widgets/graphicsview/graphicsview.pro
@@ -19,7 +19,7 @@ SUBDIRS=\
    qgraphicsview \
    qgraphicswidget \
 
-!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
            qgraphicsanchorlayout \
            qgraphicsanchorlayout1 \
            qgraphicsitem \
diff --git a/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp b/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
index a3aa90168a..6faeb10ce7 100644
--- a/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
+++ b/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
@@ -392,6 +392,7 @@ void tst_QGraphicsProxyWidget::setWidget()
     QGraphicsScene scene;
     QGraphicsView view(&scene);
     view.show();
+    QScopedPointer<QStyle> style(QStyleFactory::create(QLatin1String("Fusion")));
     QVERIFY(QTest::qWaitForWindowExposed(&view));
     QPointer<SubQGraphicsProxyWidget> proxy = new SubQGraphicsProxyWidget;
     SubQGraphicsProxyWidget parentProxy;
@@ -414,7 +415,7 @@ void tst_QGraphicsProxyWidget::setWidget()
 #endif
     widget->setPalette(QPalette(Qt::magenta));
     widget->setLayoutDirection(Qt::RightToLeft);
-    widget->setStyle(QStyleFactory::create(QLatin1String("Fusion")));
+    widget->setStyle(style.data());
     widget->setFont(QFont("Times"));
     widget->setVisible(true);
     QApplication::setActiveWindow(widget);
diff --git a/tests/auto/widgets/graphicsview/qgraphicssceneindex/qgraphicssceneindex.pro b/tests/auto/widgets/graphicsview/qgraphicssceneindex/qgraphicssceneindex.pro
index 3b74ab0c75..42c260d480 100644
--- a/tests/auto/widgets/graphicsview/qgraphicssceneindex/qgraphicssceneindex.pro
+++ b/tests/auto/widgets/graphicsview/qgraphicssceneindex/qgraphicssceneindex.pro
@@ -1,6 +1,6 @@
 CONFIG += testcase
 TARGET = tst_qgraphicssceneindex
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
 QT += widgets widgets-private testlib
 QT += core-private gui-private
 SOURCES  += tst_qgraphicssceneindex.cpp
diff --git a/tests/auto/widgets/itemviews/itemviews.pro b/tests/auto/widgets/itemviews/itemviews.pro
index 2bd8ec43d3..af0b6aeef0 100644
--- a/tests/auto/widgets/itemviews/itemviews.pro
+++ b/tests/auto/widgets/itemviews/itemviews.pro
@@ -17,7 +17,7 @@ SUBDIRS=\
    qtreewidget \
    qtreewidgetitemiterator \
 
-!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
     qcolumnview \
     qlistwidget \
 
diff --git a/tests/auto/widgets/itemviews/qabstractitemview/tst_qabstractitemview.cpp b/tests/auto/widgets/itemviews/qabstractitemview/tst_qabstractitemview.cpp
index 1050fa2561..7412637354 100644
--- a/tests/auto/widgets/itemviews/qabstractitemview/tst_qabstractitemview.cpp
+++ b/tests/auto/widgets/itemviews/qabstractitemview/tst_qabstractitemview.cpp
@@ -77,108 +77,6 @@ static inline void moveCursorAway(const QWidget *topLevel)
 #endif
 }
 
-class TestView : public QAbstractItemView
-{
-    Q_OBJECT
-public:
-    inline void tst_dataChanged(const QModelIndex &tl, const QModelIndex &br)
-        { dataChanged(tl, br); }
-    inline void tst_setHorizontalStepsPerItem(int steps)
-        { setHorizontalStepsPerItem(steps); }
-    inline int tst_horizontalStepsPerItem() const
-        { return horizontalStepsPerItem(); }
-    inline void tst_setVerticalStepsPerItem(int steps)
-        { setVerticalStepsPerItem(steps); }
-    inline int tst_verticalStepsPerItem() const
-        { return verticalStepsPerItem(); }
-
-    inline void tst_rowsInserted(const QModelIndex &parent, int start, int end)
-        { rowsInserted(parent, start, end); }
-    inline void tst_rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
-        { rowsAboutToBeRemoved(parent, start, end); }
-    inline void tst_selectionChanged(const QItemSelection &selected,
-                                     const QItemSelection &deselected)
-        { selectionChanged(selected, deselected); }
-    inline void tst_currentChanged(const QModelIndex &current, const QModelIndex &previous)
-        { currentChanged(current, previous); }
-    inline void tst_updateEditorData()
-        { updateEditorData(); }
-    inline void tst_updateEditorGeometries()
-        { updateEditorGeometries(); }
-    inline void tst_updateGeometries()
-        { updateGeometries(); }
-    inline void tst_verticalScrollbarAction(int action)
-        { verticalScrollbarAction(action); }
-    inline void tst_horizontalScrollbarAction(int action)
-        { horizontalScrollbarAction(action); }
-    inline void tst_verticalScrollbarValueChanged(int value)
-        { verticalScrollbarValueChanged(value); }
-    inline void tst_horizontalScrollbarValueChanged(int value)
-        { horizontalScrollbarValueChanged(value); }
-    inline void tst_closeEditor(QWidget *editor, QAbstractItemDelegate::EndEditHint hint)
-        { closeEditor(editor, hint); }
-    inline void tst_commitData(QWidget *editor)
-        { commitData(editor); }
-    inline void tst_editorDestroyed(QObject *editor)
-        { editorDestroyed(editor); }
-    enum tst_CursorAction {
-        MoveUp = QAbstractItemView::MoveUp,
-        MoveDown = QAbstractItemView::MoveDown,
-        MoveLeft = QAbstractItemView::MoveLeft,
-        MoveRight = QAbstractItemView::MoveRight,
-        MoveHome = QAbstractItemView::MoveHome,
-        MoveEnd = QAbstractItemView::MoveEnd,
-        MovePageUp = QAbstractItemView::MovePageUp,
-        MovePageDown = QAbstractItemView::MovePageDown,
-        MoveNext = QAbstractItemView::MoveNext,
-        MovePrevious = QAbstractItemView::MovePrevious
-    };
-    inline QModelIndex tst_moveCursor(tst_CursorAction cursorAction,
-                                      Qt::KeyboardModifiers modifiers)
-        { return moveCursor(QAbstractItemView::CursorAction(cursorAction), modifiers); }
-    inline int tst_horizontalOffset() const
-        { return horizontalOffset(); }
-    inline int tst_verticalOffset() const
-        { return verticalOffset(); }
-    inline bool tst_isIndexHidden(const QModelIndex &index) const
-        { return isIndexHidden(index); }
-    inline void tst_setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags command)
-        { setSelection(rect, command); }
-    inline QRegion tst_visualRegionForSelection(const QItemSelection &selection) const
-        { return visualRegionForSelection(selection); }
-    inline QModelIndexList tst_selectedIndexes() const
-        { return selectedIndexes(); }
-    inline bool tst_edit(const QModelIndex &index, EditTrigger trigger, QEvent *event)
-        { return edit(index, trigger, event); }
-    inline QItemSelectionModel::SelectionFlags tst_selectionCommand(const QModelIndex &index,
-                                                                    const QEvent *event = 0) const
-        { return selectionCommand(index, event); }
-#ifndef QT_NO_DRAGANDDROP
-    inline void tst_startDrag(Qt::DropActions supportedActions)
-        { startDrag(supportedActions); }
-#endif
-    inline QStyleOptionViewItem tst_viewOptions() const
-        { return viewOptions(); }
-    enum tst_State {
-        NoState = QAbstractItemView::NoState,
-        DraggingState = QAbstractItemView::DraggingState,
-        DragSelectingState = QAbstractItemView::DragSelectingState,
-        EditingState = QAbstractItemView::EditingState,
-        ExpandingState = QAbstractItemView::ExpandingState,
-        CollapsingState = QAbstractItemView::CollapsingState
-    };
-    inline tst_State tst_state() const
-        { return (tst_State)state(); }
-    inline void tst_setState(tst_State state)
-        { setState(QAbstractItemView::State(state)); }
-    inline void tst_startAutoScroll()
-        { startAutoScroll(); }
-    inline void tst_stopAutoScroll()
-        { stopAutoScroll(); }
-    inline void tst_doAutoScroll()
-        { doAutoScroll(); }
-};
-
 class GeometriesTestView : public QTableView
 {
     Q_OBJECT
@@ -194,7 +92,7 @@ class tst_QAbstractItemView : public QObject
     Q_OBJECT
 
 public:
-    void basic_tests(TestView *view);
+    void basic_tests(QAbstractItemView *view);
 
 private slots:
     void cleanup();
@@ -278,7 +176,7 @@ public:
 void tst_QAbstractItemView::getSetCheck()
 {
     QListView view;
-    TestView *obj1 = reinterpret_cast<TestView*>(&view);
+    QAbstractItemView *obj1 = &view;
     // QAbstractItemDelegate * QAbstractItemView::itemDelegate()
     // void QAbstractItemView::setItemDelegate(QAbstractItemDelegate *)
     MyAbstractItemDelegate *var1 = new MyAbstractItemDelegate;
@@ -329,18 +227,18 @@ void tst_QAbstractItemView::getSetCheck()
 
     // State QAbstractItemView::state()
     // void QAbstractItemView::setState(State)
-    obj1->tst_setState(TestView::tst_State(TestView::NoState));
-    QCOMPARE(TestView::tst_State(TestView::NoState), obj1->tst_state());
-    obj1->tst_setState(TestView::tst_State(TestView::DraggingState));
-    QCOMPARE(TestView::tst_State(TestView::DraggingState), obj1->tst_state());
-    obj1->tst_setState(TestView::tst_State(TestView::DragSelectingState));
-    QCOMPARE(TestView::tst_State(TestView::DragSelectingState), obj1->tst_state());
-    obj1->tst_setState(TestView::tst_State(TestView::EditingState));
-    QCOMPARE(TestView::tst_State(TestView::EditingState), obj1->tst_state());
-    obj1->tst_setState(TestView::tst_State(TestView::ExpandingState));
-    QCOMPARE(TestView::tst_State(TestView::ExpandingState), obj1->tst_state());
-    obj1->tst_setState(TestView::tst_State(TestView::CollapsingState));
-    QCOMPARE(TestView::tst_State(TestView::CollapsingState), obj1->tst_state());
+    obj1->setState(QAbstractItemView::NoState);
+    QCOMPARE(QAbstractItemView::NoState, obj1->state());
+    obj1->setState(QAbstractItemView::DraggingState);
+    QCOMPARE(QAbstractItemView::DraggingState, obj1->state());
+    obj1->setState(QAbstractItemView::DragSelectingState);
+    QCOMPARE(QAbstractItemView::DragSelectingState, obj1->state());
+    obj1->setState(QAbstractItemView::EditingState);
+    QCOMPARE(QAbstractItemView::EditingState, obj1->state());
+    obj1->setState(QAbstractItemView::ExpandingState);
+    QCOMPARE(QAbstractItemView::ExpandingState, obj1->state());
+    obj1->setState(QAbstractItemView::CollapsingState);
+    QCOMPARE(QAbstractItemView::CollapsingState, obj1->state());
 
     // QWidget QAbstractScrollArea::viewport()
     // void setViewport(QWidget*)
@@ -394,7 +292,7 @@ void tst_QAbstractItemView::emptyModels()
     QVERIFY(!view->selectionModel());
     //QVERIFY(view->itemDelegate() != 0);
 
-    basic_tests(reinterpret_cast<TestView*>(view.data()));
+    basic_tests(view.data());
 }
 
 void tst_QAbstractItemView::setModel_data()
@@ -431,10 +329,10 @@ void tst_QAbstractItemView::setModel()
     QStandardItemModel model(20,20);
     view->setModel(0);
     view->setModel(&model);
-    basic_tests(reinterpret_cast<TestView*>(view.data()));
+    basic_tests(view.data());
 }
 
-void tst_QAbstractItemView::basic_tests(TestView *view)
+void tst_QAbstractItemView::basic_tests(QAbstractItemView *view)
 {
     // setSelectionModel
     // Will assert as it should
@@ -559,73 +457,73 @@ void tst_QAbstractItemView::basic_tests(TestView *view)
     view->setCurrentIndex(QModelIndex());
 
     // protected methods
-    view->tst_dataChanged(QModelIndex(), QModelIndex());
-    view->tst_rowsInserted(QModelIndex(), -1, -1);
-    view->tst_rowsAboutToBeRemoved(QModelIndex(), -1, -1);
-    view->tst_selectionChanged(QItemSelection(), QItemSelection());
+    view->dataChanged(QModelIndex(), QModelIndex());
+    view->rowsInserted(QModelIndex(), -1, -1);
+    view->rowsAboutToBeRemoved(QModelIndex(), -1, -1);
+    view->selectionChanged(QItemSelection(), QItemSelection());
     if (view->model()){
-        view->tst_currentChanged(QModelIndex(), QModelIndex());
-        view->tst_currentChanged(QModelIndex(), view->model()->index(0,0));
+        view->currentChanged(QModelIndex(), QModelIndex());
+        view->currentChanged(QModelIndex(), view->model()->index(0,0));
     }
-    view->tst_updateEditorData();
-    view->tst_updateEditorGeometries();
-    view->tst_updateGeometries();
-    view->tst_verticalScrollbarAction(QAbstractSlider::SliderSingleStepAdd);
-    view->tst_horizontalScrollbarAction(QAbstractSlider::SliderSingleStepAdd);
-    view->tst_verticalScrollbarValueChanged(10);
-    view->tst_horizontalScrollbarValueChanged(10);
-    view->tst_closeEditor(0, QAbstractItemDelegate::NoHint);
-    view->tst_commitData(0);
-    view->tst_editorDestroyed(0);
-
-    view->tst_setHorizontalStepsPerItem(2);
-    view->tst_horizontalStepsPerItem();
-    view->tst_setVerticalStepsPerItem(2);
-    view->tst_verticalStepsPerItem();
+    view->updateEditorData();
+    view->updateEditorGeometries();
+    view->updateGeometries();
+    view->verticalScrollbarAction(QAbstractSlider::SliderSingleStepAdd);
+    view->horizontalScrollbarAction(QAbstractSlider::SliderSingleStepAdd);
+    view->verticalScrollbarValueChanged(10);
+    view->horizontalScrollbarValueChanged(10);
+    view->closeEditor(0, QAbstractItemDelegate::NoHint);
+    view->commitData(0);
+    view->editorDestroyed(0);
+
+    view->setHorizontalStepsPerItem(2);
+    view->horizontalStepsPerItem();
+    view->setVerticalStepsPerItem(2);
+    view->verticalStepsPerItem();
 
     // Will assert as it should
     // view->setIndexWidget(QModelIndex(), 0);
 
-    view->tst_moveCursor(TestView::MoveUp, Qt::NoModifier);
-    view->tst_horizontalOffset();
-    view->tst_verticalOffset();
+    view->moveCursor(QAbstractItemView::MoveUp, Qt::NoModifier);
+    view->horizontalOffset();
+    view->verticalOffset();
 
-//    view->tst_isIndexHidden(QModelIndex()); // will (correctly) assert
+//    view->isIndexHidden(QModelIndex()); // will (correctly) assert
     if(view->model())
-        view->tst_isIndexHidden(view->model()->index(0,0));
+        view->isIndexHidden(view->model()->index(0,0));
 
-    view->tst_setSelection(QRect(0, 0, 10, 10), QItemSelectionModel::ClearAndSelect);
-    view->tst_setSelection(QRect(-1, -1, -1, -1), QItemSelectionModel::ClearAndSelect);
-    view->tst_visualRegionForSelection(QItemSelection());
-    view->tst_selectedIndexes();
+    view->setSelection(QRect(0, 0, 10, 10), QItemSelectionModel::ClearAndSelect);
+    view->setSelection(QRect(-1, -1, -1, -1), QItemSelectionModel::ClearAndSelect);
+    view->visualRegionForSelection(QItemSelection());
+    view->selectedIndexes();
 
-    view->tst_edit(QModelIndex(), QAbstractItemView::NoEditTriggers, 0);
+    view->edit(QModelIndex(), QAbstractItemView::NoEditTriggers, 0);
 
-    view->tst_selectionCommand(QModelIndex(), 0);
+    view->selectionCommand(QModelIndex(), 0);
 
 #ifndef QT_NO_DRAGANDDROP
     if (!view->model())
-        view->tst_startDrag(Qt::CopyAction);
-
-    view->tst_viewOptions();
-
-    view->tst_setState(TestView::NoState);
-    QVERIFY(view->tst_state()==TestView::NoState);
-    view->tst_setState(TestView::DraggingState);
-    QVERIFY(view->tst_state()==TestView::DraggingState);
-    view->tst_setState(TestView::DragSelectingState);
-    QVERIFY(view->tst_state()==TestView::DragSelectingState);
-    view->tst_setState(TestView::EditingState);
-    QVERIFY(view->tst_state()==TestView::EditingState);
-    view->tst_setState(TestView::ExpandingState);
-    QVERIFY(view->tst_state()==TestView::ExpandingState);
-    view->tst_setState(TestView::CollapsingState);
-    QVERIFY(view->tst_state()==TestView::CollapsingState);
+        view->startDrag(Qt::CopyAction);
+
+    view->viewOptions();
+
+    view->setState(QAbstractItemView::NoState);
+    QVERIFY(view->state()==QAbstractItemView::NoState);
+    view->setState(QAbstractItemView::DraggingState);
+    QVERIFY(view->state()==QAbstractItemView::DraggingState);
+    view->setState(QAbstractItemView::DragSelectingState);
+    QVERIFY(view->state()==QAbstractItemView::DragSelectingState);
+    view->setState(QAbstractItemView::EditingState);
+    QVERIFY(view->state()==QAbstractItemView::EditingState);
+    view->setState(QAbstractItemView::ExpandingState);
+    QVERIFY(view->state()==QAbstractItemView::ExpandingState);
+    view->setState(QAbstractItemView::CollapsingState);
+    QVERIFY(view->state()==QAbstractItemView::CollapsingState);
 #endif
 
-    view->tst_startAutoScroll();
-    view->tst_stopAutoScroll();
-    view->tst_doAutoScroll();
+    view->startAutoScroll();
+    view->stopAutoScroll();
+    view->doAutoScroll();
 
     // testing mouseFoo and key functions
 //     QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0,0));
@@ -760,11 +658,11 @@ void tst_QAbstractItemView::selectAll()
     QTableView view;
     view.setModel(&model);
 
-    TestView *tst_view = (TestView*)&view;
+    QAbstractItemView *tst_view = &view;
 
-    QCOMPARE(tst_view->tst_selectedIndexes().count(), 0);
+    QCOMPARE(tst_view->selectedIndexes().count(), 0);
     view.selectAll();
-    QCOMPARE(tst_view->tst_selectedIndexes().count(), 4*4);
+    QCOMPARE(tst_view->selectedIndexes().count(), 4*4);
 }
 
 void tst_QAbstractItemView::ctrlA()
@@ -773,11 +671,11 @@ void tst_QAbstractItemView::ctrlA()
     QTableView view;
     view.setModel(&model);
 
-    TestView *tst_view = (TestView*)&view;
+    QAbstractItemView *tst_view = &view;
 
-    QCOMPARE(tst_view->tst_selectedIndexes().count(), 0);
+    QCOMPARE(tst_view->selectedIndexes().count(), 0);
     QTest::keyClick(&view, Qt::Key_A, Qt::ControlModifier);
-    QCOMPARE(tst_view->tst_selectedIndexes().count(), 4*4);
+    QCOMPARE(tst_view->selectedIndexes().count(), 4*4);
 }
 
 void tst_QAbstractItemView::persistentEditorFocus()
@@ -1590,9 +1488,9 @@ void tst_QAbstractItemView::testDelegateDestroyEditor()
     MyAbstractItemDelegate delegate;
     table.setItemDelegate(&delegate);
     table.edit(table.model()->index(1, 1));
-    TestView *tv = reinterpret_cast<TestView*>(&table);
+    QAbstractItemView *tv = &table;
     QVERIFY(!delegate.calledVirtualDtor);
-    tv->tst_closeEditor(delegate.openedEditor, QAbstractItemDelegate::NoHint);
+    tv->closeEditor(delegate.openedEditor, QAbstractItemDelegate::NoHint);
     QVERIFY(delegate.calledVirtualDtor);
 }
 
@@ -2069,11 +1967,18 @@ void tst_QAbstractItemView::QTBUG50535_update_on_new_selection_model()
     {
     public:
         ListView()
-            : m_paintEventsCount(0)
+            : m_paintEventsCount(0), m_deselectedMustBeEmpty(false), m_selectionChangedOk(true)
         {
         }
 
+        void setSelectionModel(QItemSelectionModel *model) Q_DECL_OVERRIDE
+        {
+            m_deselectedMustBeEmpty = !selectionModel() || !model || selectionModel()->model() != model->model();
+            QListView::setSelectionModel(model);
+            m_deselectedMustBeEmpty = false;
+        }
         int m_paintEventsCount;
+        bool selectionChangedOk() const { return m_selectionChangedOk; }
 
     protected:
         bool viewportEvent(QEvent *event) Q_DECL_OVERRIDE
@@ -2082,6 +1987,24 @@ void tst_QAbstractItemView::QTBUG50535_update_on_new_selection_model()
                 ++m_paintEventsCount;
             return QListView::viewportEvent(event);
         }
+
+        void selectionChanged(const QItemSelection &selected,
+                              const QItemSelection &deselected) Q_DECL_OVERRIDE
+        {
+            if (m_deselectedMustBeEmpty && !deselected.isEmpty())
+                m_selectionChangedOk = false;
+
+            // Make sure both selections belong to the same model
+            foreach (const QModelIndex &nmi, selected.indexes()) {
+                foreach (const QModelIndex &omi, deselected.indexes()) {
+                    m_selectionChangedOk = m_selectionChangedOk && (nmi.model() == omi.model());
+                }
+            }
+            QListView::selectionChanged(selected, deselected);
+        }
+    private:
+        bool m_deselectedMustBeEmpty;
+        bool m_selectionChangedOk;
     };
 
     // keep the current/selected row in the "low range", i.e. be sure it's visible, otherwise we
@@ -2092,7 +2015,7 @@ void tst_QAbstractItemView::QTBUG50535_update_on_new_selection_model()
     view.selectionModel()->setCurrentIndex(model.index(1, 0), QItemSelectionModel::SelectCurrent);
     view.show();
     QVERIFY(QTest::qWaitForWindowExposed(&view));
-
+    QVERIFY(view.selectionChangedOk());
 
     QItemSelectionModel selectionModel(&model);
     selectionModel.setCurrentIndex(model.index(2, 0), QItemSelectionModel::Current);
@@ -2100,6 +2023,7 @@ void tst_QAbstractItemView::QTBUG50535_update_on_new_selection_model()
     int oldPaintEventsCount = view.m_paintEventsCount;
     view.setSelectionModel(&selectionModel);
     QTRY_VERIFY(view.m_paintEventsCount > oldPaintEventsCount);
+    QVERIFY(view.selectionChangedOk());
 
 
     QItemSelectionModel selectionModel2(&model);
@@ -2109,6 +2033,19 @@ void tst_QAbstractItemView::QTBUG50535_update_on_new_selection_model()
     oldPaintEventsCount = view.m_paintEventsCount;
     view.setSelectionModel(&selectionModel2);
     QTRY_VERIFY(view.m_paintEventsCount > oldPaintEventsCount);
+    QVERIFY(view.selectionChangedOk());
+
+    // Tests QAbstractItemView::selectionChanged
+    QStandardItemModel model1;
+    for (int i = 0; i < 10; ++i)
+        model1.appendRow(new QStandardItem(QString::number(i)));
+    view.setModel(&model1);
+
+    QItemSelectionModel selectionModel1(&model1);
+    selectionModel1.select(model1.index(0, 0), QItemSelectionModel::ClearAndSelect);
+    selectionModel1.setCurrentIndex(model1.index(1, 0), QItemSelectionModel::Current);
+    view.setSelectionModel(&selectionModel1);
+    QVERIFY(view.selectionChangedOk());
 }
 
 void tst_QAbstractItemView::testSelectionModelInSyncWithView()
diff --git a/tests/auto/widgets/itemviews/qheaderview/tst_qheaderview.cpp b/tests/auto/widgets/itemviews/qheaderview/tst_qheaderview.cpp
index bc8b08997f..32a324b888 100644
--- a/tests/auto/widgets/itemviews/qheaderview/tst_qheaderview.cpp
+++ b/tests/auto/widgets/itemviews/qheaderview/tst_qheaderview.cpp
@@ -2991,6 +2991,11 @@ void tst_QHeaderView::stretchAndRestoreLastSection()
     header.swapSections(1, 11);
     QCOMPARE(header.sectionSize(1), someOtherSectionSize);
 
+    // Clear and re-add. This triggers a different code path than seColumnCount(0)
+    m.clear();
+    m.setColumnCount(3);
+    QVERIFY(header.sectionSize(2) >= biggerSizeThanAnySection);
+
     // Test import/export of the original (not stretched) sectionSize.
     m.setColumnCount(0);
     m.setColumnCount(10);
diff --git a/tests/auto/widgets/itemviews/qtreeview/tst_qtreeview.cpp b/tests/auto/widgets/itemviews/qtreeview/tst_qtreeview.cpp
index 81ce1deca4..c7b7ffaf95 100644
--- a/tests/auto/widgets/itemviews/qtreeview/tst_qtreeview.cpp
+++ b/tests/auto/widgets/itemviews/qtreeview/tst_qtreeview.cpp
@@ -31,7 +31,7 @@
 #include <QtTest/QtTest>
 #include <QtGui/QtGui>
 #include <QtWidgets/QtWidgets>
-#include <private/qabstractitemview_p.h>
+#include <private/qtreeview_p.h>
 
 #ifndef QT_NO_DRAGANDDROP
 Q_DECLARE_METATYPE(QAbstractItemView::DragDropMode)
@@ -57,49 +57,6 @@ static void initStandardTreeModel(QStandardItemModel *model)
     model->insertRow(2, item);
 }
 
-class tst_QTreeView;
-struct PublicView : public QTreeView
-{
-    friend class tst_QTreeView;
-    inline void executeDelayedItemsLayout()
-    { QTreeView::executeDelayedItemsLayout(); }
-
-    enum PublicCursorAction {
-        MoveUp = QAbstractItemView::MoveUp,
-        MoveDown = QAbstractItemView::MoveDown,
-        MoveLeft = QAbstractItemView::MoveLeft,
-        MoveRight = QAbstractItemView::MoveRight,
-        MoveHome = QAbstractItemView::MoveHome,
-        MoveEnd = QAbstractItemView::MoveEnd,
-        MovePageUp = QAbstractItemView::MovePageUp,
-        MovePageDown = QAbstractItemView::MovePageDown,
-        MoveNext = QAbstractItemView::MoveNext,
-        MovePrevious = QAbstractItemView::MovePrevious
-    };
-
-    // enum PublicCursorAction and moveCursor() are protected in QTreeView.
-    inline QModelIndex doMoveCursor(PublicCursorAction ca, Qt::KeyboardModifiers kbm)
-    { return QTreeView::moveCursor((CursorAction)ca, kbm); }
-
-    inline void setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags command)
-    {
-        QTreeView::setSelection(rect, command);
-    }
-    inline int state()
-    {
-        return QTreeView::state();
-    }
-
-    inline int rowHeight(QModelIndex idx) { return QTreeView::rowHeight(idx); }
-    inline int indexRowSizeHint(const QModelIndex &index) const { return QTreeView::indexRowSizeHint(index); }
-
-    inline QModelIndexList selectedIndexes() const { return QTreeView::selectedIndexes(); }
-
-    inline QStyleOptionViewItem viewOptions() const { return QTreeView::viewOptions(); }
-    inline int sizeHintForColumn(int column) const { return QTreeView::sizeHintForColumn(column); }
-    QAbstractItemViewPrivate* aiv_priv() { return static_cast<QAbstractItemViewPrivate*>(d_ptr.data()); }
-};
-
 // Make a widget frameless to prevent size constraints of title bars
 // from interfering (Windows).
 static inline void setFrameless(QWidget *w)
@@ -631,33 +588,34 @@ void tst_QTreeView::dragDropModeFromDragEnabledAndAcceptDrops_data()
     QTest::addColumn<bool>("dragEnabled");
     QTest::addColumn<bool>("acceptDrops");
     QTest::addColumn<QAbstractItemView::DragDropMode>("dragDropMode");
-    QTest::addColumn<QAbstractItemView::DragDropMode>("setBehavior");
-
-    QTest::newRow("NoDragDrop -1") << false << false << QAbstractItemView::NoDragDrop << QAbstractItemView::DragDropMode(-1);
-    QTest::newRow("NoDragDrop 0") << false << false << QAbstractItemView::NoDragDrop << QAbstractItemView::NoDragDrop;
-    QTest::newRow("NoDragDrop 1") << false << false << QAbstractItemView::NoDragDrop << QAbstractItemView::DragOnly;
-    QTest::newRow("NoDragDrop 2") << false << false << QAbstractItemView::NoDragDrop << QAbstractItemView::DropOnly;
-    QTest::newRow("NoDragDrop 3") << false << false << QAbstractItemView::NoDragDrop << QAbstractItemView::DragDrop;
-    QTest::newRow("NoDragDrop 4") << false << false << QAbstractItemView::NoDragDrop << QAbstractItemView::InternalMove;
-    QTest::newRow("DragOnly -1") << true << false << QAbstractItemView::DragOnly << QAbstractItemView::DragDropMode(-1);
-    QTest::newRow("DragOnly 0") << true << false << QAbstractItemView::DragOnly << QAbstractItemView::NoDragDrop;
-    QTest::newRow("DragOnly 1") << true << false << QAbstractItemView::DragOnly << QAbstractItemView::DragOnly;
-    QTest::newRow("DragOnly 2") << true << false << QAbstractItemView::DragOnly << QAbstractItemView::DropOnly;
-    QTest::newRow("DragOnly 3") << true << false << QAbstractItemView::DragOnly << QAbstractItemView::DragDrop;
-    QTest::newRow("DragOnly 4") << true << false << QAbstractItemView::DragOnly << QAbstractItemView::InternalMove;
-    QTest::newRow("DropOnly -1") << false << true << QAbstractItemView::DropOnly << QAbstractItemView::DragDropMode(-1);
-    QTest::newRow("DropOnly 0") << false << true << QAbstractItemView::DropOnly << QAbstractItemView::NoDragDrop;
-    QTest::newRow("DropOnly 1") << false << true << QAbstractItemView::DropOnly << QAbstractItemView::DragOnly;
-    QTest::newRow("DropOnly 2") << false << true << QAbstractItemView::DropOnly << QAbstractItemView::DropOnly;
-    QTest::newRow("DropOnly 3") << false << true << QAbstractItemView::DropOnly << QAbstractItemView::DragDrop;
-    QTest::newRow("DropOnly 4") << false << true << QAbstractItemView::DropOnly << QAbstractItemView::InternalMove;
-    QTest::newRow("DragDrop -1") << true << true << QAbstractItemView::DragDrop << QAbstractItemView::DragDropMode(-1);
-    QTest::newRow("DragDrop 0") << true << true << QAbstractItemView::DragDrop << QAbstractItemView::DragDropMode(-1);
-    QTest::newRow("DragDrop 1") << true << true << QAbstractItemView::DragDrop << QAbstractItemView::NoDragDrop;
-    QTest::newRow("DragDrop 2") << true << true << QAbstractItemView::DragDrop << QAbstractItemView::DragOnly;
-    QTest::newRow("DragDrop 3") << true << true << QAbstractItemView::DragDrop << QAbstractItemView::DropOnly;
-    QTest::newRow("DragDrop 4") << true << true << QAbstractItemView::DragDrop << QAbstractItemView::DragDrop;
-    QTest::newRow("DragDrop 5") << true << true << QAbstractItemView::InternalMove << QAbstractItemView::InternalMove;
+    QTest::addColumn<bool>("setBehavior");
+    QTest::addColumn<QAbstractItemView::DragDropMode>("behavior");
+
+    QTest::newRow("NoDragDrop -1") << false << false << QAbstractItemView::NoDragDrop << false << QAbstractItemView::DragDropMode();
+    QTest::newRow("NoDragDrop 0") << false << false << QAbstractItemView::NoDragDrop << true << QAbstractItemView::NoDragDrop;
+    QTest::newRow("NoDragDrop 1") << false << false << QAbstractItemView::NoDragDrop << true << QAbstractItemView::DragOnly;
+    QTest::newRow("NoDragDrop 2") << false << false << QAbstractItemView::NoDragDrop << true << QAbstractItemView::DropOnly;
+    QTest::newRow("NoDragDrop 3") << false << false << QAbstractItemView::NoDragDrop << true << QAbstractItemView::DragDrop;
+    QTest::newRow("NoDragDrop 4") << false << false << QAbstractItemView::NoDragDrop << true << QAbstractItemView::InternalMove;
+    QTest::newRow("DragOnly -1") << true << false << QAbstractItemView::DragOnly << false << QAbstractItemView::DragDropMode();
+    QTest::newRow("DragOnly 0") << true << false << QAbstractItemView::DragOnly << true << QAbstractItemView::NoDragDrop;
+    QTest::newRow("DragOnly 1") << true << false << QAbstractItemView::DragOnly << true << QAbstractItemView::DragOnly;
+    QTest::newRow("DragOnly 2") << true << false << QAbstractItemView::DragOnly << true << QAbstractItemView::DropOnly;
+    QTest::newRow("DragOnly 3") << true << false << QAbstractItemView::DragOnly << true << QAbstractItemView::DragDrop;
+    QTest::newRow("DragOnly 4") << true << false << QAbstractItemView::DragOnly << true << QAbstractItemView::InternalMove;
+    QTest::newRow("DropOnly -1") << false << true << QAbstractItemView::DropOnly << false << QAbstractItemView::DragDropMode();
+    QTest::newRow("DropOnly 0") << false << true << QAbstractItemView::DropOnly << true << QAbstractItemView::NoDragDrop;
+    QTest::newRow("DropOnly 1") << false << true << QAbstractItemView::DropOnly << true << QAbstractItemView::DragOnly;
+    QTest::newRow("DropOnly 2") << false << true << QAbstractItemView::DropOnly << true << QAbstractItemView::DropOnly;
+    QTest::newRow("DropOnly 3") << false << true << QAbstractItemView::DropOnly << true << QAbstractItemView::DragDrop;
+    QTest::newRow("DropOnly 4") << false << true << QAbstractItemView::DropOnly << true << QAbstractItemView::InternalMove;
+    QTest::newRow("DragDrop -1") << true << true << QAbstractItemView::DragDrop << false << QAbstractItemView::DragDropMode();
+    QTest::newRow("DragDrop 0") << true << true << QAbstractItemView::DragDrop << false << QAbstractItemView::DragDropMode();
+    QTest::newRow("DragDrop 1") << true << true << QAbstractItemView::DragDrop << true << QAbstractItemView::NoDragDrop;
+    QTest::newRow("DragDrop 2") << true << true << QAbstractItemView::DragDrop << true << QAbstractItemView::DragOnly;
+    QTest::newRow("DragDrop 3") << true << true << QAbstractItemView::DragDrop << true << QAbstractItemView::DropOnly;
+    QTest::newRow("DragDrop 4") << true << true << QAbstractItemView::DragDrop << true << QAbstractItemView::DragDrop;
+    QTest::newRow("DragDrop 5") << true << true << QAbstractItemView::InternalMove << true << QAbstractItemView::InternalMove;
 }
 
 void tst_QTreeView::dragDropModeFromDragEnabledAndAcceptDrops()
@@ -665,13 +623,14 @@ void tst_QTreeView::dragDropModeFromDragEnabledAndAcceptDrops()
     QFETCH(bool, acceptDrops);
     QFETCH(bool, dragEnabled);
     QFETCH(QAbstractItemView::DragDropMode, dragDropMode);
-    QFETCH(QAbstractItemView::DragDropMode, setBehavior);
+    QFETCH(bool, setBehavior);
+    QFETCH(QAbstractItemView::DragDropMode, behavior);
 
     QTreeView view;
     QCOMPARE(view.dragDropMode(), QAbstractItemView::NoDragDrop);
 
-    if (setBehavior != QAbstractItemView::DragDropMode(-1))
-        view.setDragDropMode(setBehavior);
+    if (setBehavior)
+        view.setDragDropMode(behavior);
 
     view.setAcceptDrops(acceptDrops);
     view.setDragEnabled(dragEnabled);
@@ -1743,7 +1702,7 @@ void tst_QTreeView::moveCursor()
     QFETCH(bool, scrollPerPixel);
     QtTestModel model(8, 6);
 
-    PublicView view;
+    QTreeView view;
     view.setUniformRowHeights(uniformRowHeights);
     view.setModel(&model);
     view.setRowHidden(0, QModelIndex(), true);
@@ -1762,7 +1721,7 @@ void tst_QTreeView::moveCursor()
     QCOMPARE(view.currentIndex(), expected);
 
     //then pressing down should go to the next line
-    QModelIndex actual = view.doMoveCursor(PublicView::MoveDown, Qt::NoModifier);
+    QModelIndex actual = view.moveCursor(QTreeView::MoveDown, Qt::NoModifier);
     expected = model.index(2, 1, QModelIndex());
     QCOMPARE(actual, expected);
 
@@ -1771,7 +1730,7 @@ void tst_QTreeView::moveCursor()
 
     // PageUp was broken with uniform row heights turned on
     view.setCurrentIndex(model.index(1, 0));
-    actual = view.doMoveCursor(PublicView::MovePageUp, Qt::NoModifier);
+    actual = view.moveCursor(QTreeView::MovePageUp, Qt::NoModifier);
     expected = model.index(0, 0, QModelIndex());
     QCOMPARE(actual, expected);
 
@@ -1870,7 +1829,7 @@ void tst_QTreeView::setSelection()
     QtTestModel model(10, 5);
     model.levels = 1;
     model.setDecorationsEnabled(true);
-    PublicView view;
+    QTreeView view;
     view.resize(400, 300);
     view.show();
     view.setRootIsDecorated(false);
@@ -2058,7 +2017,7 @@ void tst_QTreeView::rowsAboutToBeRemoved()
         }
     }
 
-    PublicView view;
+    QTreeView view;
     view.setModel(&model);
     view.show();
     QModelIndex index = model.index(0,0, QModelIndex());
@@ -2072,7 +2031,7 @@ void tst_QTreeView::rowsAboutToBeRemoved()
     QSignalSpy spy1(&model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)));
 
     model.removeRows(1,1);
-    QCOMPARE(view.state(), 0);
+    QCOMPARE(int(view.state()), 0);
     // Should not be 5 (or any other number for that sake :)
     QCOMPARE(spy1.count(), 1);
 
@@ -2175,7 +2134,7 @@ void tst_QTreeView::rowsAboutToBeRemoved_move()
     view.resize(600,800);
     view.show();
     view.doItemsLayout();
-    static_cast<PublicView *>(&view)->executeDelayedItemsLayout();
+    static_cast<QTreeView *>(&view)->executeDelayedItemsLayout();
     parent = indexThatWantsToLiveButWillDieDieITellYou.parent();
     QCOMPARE(view.isExpanded(indexThatWantsToLiveButWillDieDieITellYou), true);
     QCOMPARE(parent.isValid(), true);
@@ -2283,7 +2242,7 @@ void tst_QTreeView::spanningItems()
 {
     QtTestModel model;
     model.rows = model.cols = 10;
-    PublicView view;
+    QTreeView view;
     view.setModel(&model);
     view.show();
 
@@ -2422,7 +2381,7 @@ void tst_QTreeView::selectionWithHiddenItems()
 void tst_QTreeView::selectAll()
 {
     QStandardItemModel model(4,4);
-    PublicView view2;
+    QTreeView view2;
     view2.setModel(&model);
     view2.setSelectionMode(QAbstractItemView::ExtendedSelection);
     view2.selectAll();  // Should work with an empty model
@@ -2431,13 +2390,13 @@ void tst_QTreeView::selectAll()
 
     for (int i = 0; i < model.rowCount(); ++i)
         model.setData(model.index(i,0), QLatin1String("row ") + QString::number(i));
-    PublicView view;
+    QTreeView view;
     view.setModel(&model);
     int selectedCount = view.selectedIndexes().count();
     view.selectAll();
     QCOMPARE(view.selectedIndexes().count(), selectedCount);
 
-    PublicView view3;
+    QTreeView view3;
     view3.setModel(&model);
     view3.setSelectionMode(QAbstractItemView::NoSelection);
     view3.selectAll();
@@ -2800,7 +2759,7 @@ void tst_QTreeView::evilModel()
 {
     QFETCH(bool, visible);
     // init
-    PublicView view;
+    QTreeView view;
     EvilModel model;
     view.setModel(&model);
     view.setVisible(visible);
@@ -2858,7 +2817,7 @@ void tst_QTreeView::evilModel()
     view.setSelection(rect, QItemSelectionModel::Select);
     model.change();
 
-    view.doMoveCursor(PublicView::MoveDown, Qt::NoModifier);
+    view.moveCursor(QTreeView::MoveDown, Qt::NoModifier);
     model.change();
 
     view.resizeColumnToContents(1);
@@ -2969,7 +2928,7 @@ void tst_QTreeView::evilModel()
 void tst_QTreeView::indexRowSizeHint()
 {
     QStandardItemModel model(10, 1);
-    PublicView view;
+    QTreeView view;
 
     view.setModel(&model);
 
@@ -3015,7 +2974,7 @@ void tst_QTreeView::renderToPixmap_data()
 void tst_QTreeView::renderToPixmap()
 {
     QFETCH(int, row);
-    PublicView view;
+    QTreeView view;
     QStandardItemModel model;
 
     model.appendRow(new QStandardItem("Spanning"));
@@ -3031,7 +2990,7 @@ void tst_QTreeView::renderToPixmap()
         // We select the index at row=1 for coverage.
         QItemSelection sel(model.index(row,0), model.index(row,1));
         QRect rect;
-        view.aiv_priv()->renderToPixmap(sel.indexes(), &rect);
+        view.d_func()->renderToPixmap(sel.indexes(), &rect);
     }
 #endif
 }
@@ -3093,7 +3052,7 @@ void tst_QTreeView::styleOptionViewItem()
             bool allCollapsed;
     };
 
-    PublicView view;
+    QTreeView view;
     QStandardItemModel model;
     view.setModel(&model);
     MyDelegate delegate;
@@ -3149,7 +3108,7 @@ void tst_QTreeView::styleOptionViewItem()
         delegate.count = 0;
         QItemSelection sel(model.index(0,0), model.index(0,modelColumns-1));
         QRect rect;
-        view.aiv_priv()->renderToPixmap(sel.indexes(), &rect);
+        view.d_func()->renderToPixmap(sel.indexes(), &rect);
         if (delegate.count != visibleColumns) {
             qDebug() << rect << view.rect() << view.isVisible();
         }
@@ -3177,7 +3136,7 @@ void tst_QTreeView::styleOptionViewItem()
     delegate.count = 0;
     QItemSelection sel(model.index(0,0), model.index(0,modelColumns-1));
     QRect rect;
-    view.aiv_priv()->renderToPixmap(sel.indexes(), &rect);
+    view.d_func()->renderToPixmap(sel.indexes(), &rect);
     if (delegate.count != visibleColumns) {
         qDebug() << rect << view.rect() << view.isVisible();
     }
@@ -4139,7 +4098,7 @@ void tst_QTreeView::taskQTBUG_13567_removeLastItemRegression()
 // Note: define QT_BUILD_INTERNAL to run this test
 void tst_QTreeView::taskQTBUG_25333_adjustViewOptionsForIndex()
 {
-    PublicView view;
+    QTreeView view;
     QStandardItemModel model;
     QStandardItem *item1 = new QStandardItem("Item1");
     QStandardItem *item2 = new QStandardItem("Item2");
@@ -4165,9 +4124,9 @@ void tst_QTreeView::taskQTBUG_25333_adjustViewOptionsForIndex()
     {
         QStyleOptionViewItem option;
 
-        view.aiv_priv()->adjustViewOptionsForIndex(&option, model.indexFromItem(item1));
+        view.d_func()->adjustViewOptionsForIndex(&option, model.indexFromItem(item1));
 
-        view.aiv_priv()->adjustViewOptionsForIndex(&option, model.indexFromItem(item3));
+        view.d_func()->adjustViewOptionsForIndex(&option, model.indexFromItem(item3));
     }
 #endif
 
@@ -4273,7 +4232,7 @@ void tst_QTreeView::quickExpandCollapse()
     //this unit tests makes sure the state after the animation is restored correctly
     //after starting a 2nd animation while the first one was still on-going
     //this tests that the stateBeforeAnimation is not set to AnimatingState
-    PublicView tree;
+    QTreeView tree;
     tree.setAnimated(true);
     QStandardItemModel model;
     QStandardItem *root = new QStandardItem("root");
@@ -4287,13 +4246,13 @@ void tst_QTreeView::quickExpandCollapse()
     tree.show();
     QTest::qWaitForWindowExposed(&tree);
 
-    int initialState = tree.state();
+    const QAbstractItemView::State initialState = tree.state();
 
     tree.expand(rootIndex);
-    QCOMPARE(tree.state(), (int)PublicView::AnimatingState);
+    QCOMPARE(tree.state(), QTreeView::AnimatingState);
 
     tree.collapse(rootIndex);
-    QCOMPARE(tree.state(), (int)PublicView::AnimatingState);
+    QCOMPARE(tree.state(), QTreeView::AnimatingState);
 
     QTest::qWait(500); //the animation lasts for 250ms max so 500 should be enough
 
diff --git a/tests/auto/widgets/kernel/qwidget/BLACKLIST b/tests/auto/widgets/kernel/qwidget/BLACKLIST
index 3346fb131c..6fe6bd2f67 100644
--- a/tests/auto/widgets/kernel/qwidget/BLACKLIST
+++ b/tests/auto/widgets/kernel/qwidget/BLACKLIST
@@ -3,6 +3,7 @@
 ubuntu-14.04
 [saveRestoreGeometry]
 ubuntu-14.04
+ubuntu-16.04
 [restoreVersion1Geometry]
 ubuntu-14.04
 osx
diff --git a/tests/auto/widgets/kernel/qwidget/qwidget.pro b/tests/auto/widgets/kernel/qwidget/qwidget.pro
index ba4e51a416..499ca65516 100644
--- a/tests/auto/widgets/kernel/qwidget/qwidget.pro
+++ b/tests/auto/widgets/kernel/qwidget/qwidget.pro
@@ -16,8 +16,4 @@ mac {
     OBJECTIVE_SOURCES += tst_qwidget_mac_helpers.mm
 }
 
-x11 {
-    LIBS += $$QMAKE_LIBS_X11
-}
-
 win32:!winrt: LIBS += -luser32 -lgdi32
diff --git a/tests/auto/widgets/kernel/qwidget_window/qwidget_window.pro b/tests/auto/widgets/kernel/qwidget_window/qwidget_window.pro
index 8672c363a2..a6248dfd16 100644
--- a/tests/auto/widgets/kernel/qwidget_window/qwidget_window.pro
+++ b/tests/auto/widgets/kernel/qwidget_window/qwidget_window.pro
@@ -2,8 +2,3 @@ CONFIG += testcase
 TARGET = tst_qwidget_window
 QT += widgets testlib core-private gui-private
 SOURCES  += tst_qwidget_window.cpp
-
-x11 {
-    LIBS += $$QMAKE_LIBS_X11
-}
-
diff --git a/tests/auto/widgets/kernel/qwidget_window/tst_qwidget_window.cpp b/tests/auto/widgets/kernel/qwidget_window/tst_qwidget_window.cpp
index a59dd8c80e..6aaac6d135 100644
--- a/tests/auto/widgets/kernel/qwidget_window/tst_qwidget_window.cpp
+++ b/tests/auto/widgets/kernel/qwidget_window/tst_qwidget_window.cpp
@@ -332,8 +332,9 @@ void tst_QWidget_window::tst_showWithoutActivating()
     else if (platformName != QStringLiteral("xcb")
             && platformName != QStringLiteral("windows")
             && platformName != QStringLiteral("ios")
-            && platformName != QStringLiteral("tvos"))
-        QSKIP("Qt::WA_ShowWithoutActivating is currently supported only on xcb, windows, and ios/tvos platforms.");
+            && platformName != QStringLiteral("tvos")
+            && platformName != QStringLiteral("watchos"))
+        QSKIP("Qt::WA_ShowWithoutActivating is currently supported only on xcb, windows, and ios/tvos/watchos platforms.");
 
     QWidget w1;
     w1.setAttribute(Qt::WA_ShowWithoutActivating);
diff --git a/tests/auto/widgets/styles/qstylesheetstyle/qstylesheetstyle.pro b/tests/auto/widgets/styles/qstylesheetstyle/qstylesheetstyle.pro
index c96004bd5d..7d9a8576d3 100644
--- a/tests/auto/widgets/styles/qstylesheetstyle/qstylesheetstyle.pro
+++ b/tests/auto/widgets/styles/qstylesheetstyle/qstylesheetstyle.pro
@@ -5,4 +5,4 @@ QT += widgets widgets-private gui-private testlib
 SOURCES += tst_qstylesheetstyle.cpp
 RESOURCES += resources.qrc
 
-requires(contains(QT_CONFIG,private_tests))
+requires(qtConfig(private_tests))
diff --git a/tests/auto/widgets/styles/styles.pro b/tests/auto/widgets/styles/styles.pro
index 952a659eaa..9d7464cb5b 100644
--- a/tests/auto/widgets/styles/styles.pro
+++ b/tests/auto/widgets/styles/styles.pro
@@ -5,7 +5,7 @@ SUBDIRS=\
    qstyleoption \
    qstylesheetstyle \
 
-!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
            qstylesheetstyle \
 
 # This test can only be run on Mac OS:
diff --git a/tests/auto/widgets/widgets/widgets.pro b/tests/auto/widgets/widgets/widgets.pro
index 0651583867..a8e8f6d865 100644
--- a/tests/auto/widgets/widgets/widgets.pro
+++ b/tests/auto/widgets/widgets/widgets.pro
@@ -48,10 +48,10 @@ SUBDIRS=\
    qtoolbutton \
 
 # The following tests depend on private API:
-!contains(QT_CONFIG, private_tests): SUBDIRS -= \
+!qtConfig(private_tests): SUBDIRS -= \
            qcombobox \
            qmainwindow \
            qtextedit \
            qtoolbar \
 
-contains(QT_CONFIG, opengl): SUBDIRS += qopenglwidget
+qtConfig(opengl): SUBDIRS += qopenglwidget
author	Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com>	2016-08-22 11:30:00 +0200
committer	Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com>	2016-08-22 11:30:01 +0200
commit	d314819fc02139e05e16c56657898c704f7fb48f (patch)
tree	a61ba968233634948401c8339f9613844de1c2b5 /tests/auto
parent	9f888d2fde9c5413e5519e0914e9b13638760985 (diff)
parent	e0e9e196a72ffe5457034894eaaadc90ed0d34ef (diff)