Merge remote-tracking branch 'origin/5.14' into 5.15

Change-Id: I065e212f0dc115efa1ffcb14cf9f679259da6b79

33 files changed, 842 insertions, 451 deletions

diff --git a/tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp b/tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp
index 6fcfe87c83..921847a087 100644
--- a/tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp
+++ b/tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp
@@ -236,6 +236,13 @@ private slots:
 
     void isSymLink_data();
     void isSymLink();
+
+    void isSymbolicLink_data();
+    void isSymbolicLink();
+
+    void isShortcut_data();
+    void isShortcut();
+
     void link_data();
     void link();
 
@@ -279,9 +286,6 @@ private slots:
     void invalidState();
     void nonExistingFile();
 
-    void type_data();
-    void type();
-
 private:
     const QString m_currentDir;
     QString m_sourceFile;
@@ -1342,7 +1346,92 @@ void tst_QFileInfo::isSymLink()
 #endif
 }
 
-Q_DECLARE_METATYPE(QFileInfo::FileType)
+void tst_QFileInfo::isShortcut_data()
+{
+    QFile::remove("link.lnk");
+    QFile::remove("symlink.lnk");
+    QFile::remove("link");
+    QFile::remove("symlink");
+    QFile::remove("directory.lnk");
+    QFile::remove("directory");
+
+    QTest::addColumn<QString>("path");
+    QTest::addColumn<bool>("isShortcut");
+
+    QFile regularFile(m_sourceFile);
+    QTest::newRow("regular")
+        << regularFile.fileName() << false;
+    QTest::newRow("directory")
+        << QDir::currentPath() << false;
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINRT)
+    // windows shortcuts
+    QVERIFY(regularFile.link("link.lnk"));
+    QTest::newRow("shortcut")
+        << "link.lnk" << true;
+    QVERIFY(regularFile.link("link"));
+    QTest::newRow("invalid-shortcut")
+        << "link" << false;
+    QVERIFY(QFile::link(QDir::currentPath(), "directory.lnk"));
+    QTest::newRow("directory-shortcut")
+        << "directory.lnk" << true;
+#endif
+}
+
+void tst_QFileInfo::isShortcut()
+{
+    QFETCH(QString, path);
+    QFETCH(bool, isShortcut);
+
+    QFileInfo fi(path);
+    QCOMPARE(fi.isShortcut(), isShortcut);
+}
+
+void tst_QFileInfo::isSymbolicLink_data()
+{
+    QTest::addColumn<QString>("path");
+    QTest::addColumn<bool>("isSymbolicLink");
+
+    QFile regularFile(m_sourceFile);
+    QTest::newRow("regular")
+        << regularFile.fileName() << false;
+    QTest::newRow("directory")
+        << QDir::currentPath() << false;
+
+#ifndef Q_NO_SYMLINKS
+#if defined(Q_OS_WIN)
+#if !defined(Q_OS_WINRT)
+    QString errorMessage;
+    const DWORD creationResult = createSymbolicLink("symlink", m_sourceFile, &errorMessage);
+    if (creationResult == ERROR_PRIVILEGE_NOT_HELD) {
+        QWARN(msgInsufficientPrivileges(errorMessage));
+    } else {
+        QVERIFY2(creationResult == ERROR_SUCCESS, qPrintable(errorMessage));
+        QTest::newRow("NTFS-symlink")
+            << "symlink" << true;
+    }
+#endif // !Q_OS_WINRT
+#else // Unix:
+    QVERIFY(regularFile.link("symlink.lnk"));
+    QTest::newRow("symlink.lnk")
+        << "symlink.lnk" << true;
+    QVERIFY(regularFile.link("symlink"));
+    QTest::newRow("symlink")
+        << "symlink" << true;
+    QVERIFY(QFile::link(QDir::currentPath(), "directory"));
+    QTest::newRow("directory-symlink")
+        << "directory" << true;
+#endif
+#endif // !Q_NO_SYMLINKS
+}
+
+void tst_QFileInfo::isSymbolicLink()
+{
+    QFETCH(QString, path);
+    QFETCH(bool, isSymbolicLink);
+
+    QFileInfo fi(path);
+    QCOMPARE(fi.isSymbolicLink(), isSymbolicLink);
+}
 
 void tst_QFileInfo::link_data()
 {
@@ -1354,23 +1443,24 @@ void tst_QFileInfo::link_data()
     QFile::remove("relative/link");
 
     QTest::addColumn<QString>("path");
-    QTest::addColumn<QFileInfo::FileType>("linkType");
+    QTest::addColumn<bool>("isShortcut");
+    QTest::addColumn<bool>("isSymbolicLink");
     QTest::addColumn<QString>("linkTarget");
 
     QFile file1(m_sourceFile);
     QFile file2("dummyfile");
     file2.open(QIODevice::WriteOnly);
 
-    QTest::newRow("existent file") << m_sourceFile << QFileInfo::Unknown << "";
+    QTest::newRow("existent file") << m_sourceFile << false << false << "";
 #if defined(Q_OS_WIN) && !defined(Q_OS_WINRT)
     // windows shortcuts
     QVERIFY(file1.link("link.lnk"));
     QTest::newRow("link.lnk")
-        << "link.lnk" << QFileInfo::Shortcut << QFileInfo(m_sourceFile).absoluteFilePath();
+        << "link.lnk" << true << false << QFileInfo(m_sourceFile).absoluteFilePath();
 
     QVERIFY(file2.link("brokenlink.lnk"));
     QTest::newRow("broken link.lnk")
-        << "brokenlink.lnk" << QFileInfo::Shortcut << QFileInfo("dummyfile").absoluteFilePath();
+        << "brokenlink.lnk" << true << false << QFileInfo("dummyfile").absoluteFilePath();
 #endif
 
 #ifndef Q_NO_SYMLINKS
@@ -1383,7 +1473,7 @@ void tst_QFileInfo::link_data()
     } else {
         QVERIFY2(creationResult == ERROR_SUCCESS, qPrintable(errorMessage));
         QTest::newRow("link")
-            << "link" << QFileInfo::SymbolicLink << QFileInfo(m_sourceFile).absoluteFilePath();
+            << "link" << false << true << QFileInfo(m_sourceFile).absoluteFilePath();
     }
 
     creationResult = createSymbolicLink("brokenlink", "dummyfile", &errorMessage);
@@ -1392,22 +1482,22 @@ void tst_QFileInfo::link_data()
     } else {
         QVERIFY2(creationResult == ERROR_SUCCESS, qPrintable(errorMessage));
         QTest::newRow("broken link")
-            << "brokenlink" << QFileInfo::SymbolicLink << QFileInfo("dummyfile").absoluteFilePath();
+            << "brokenlink" << false << true  << QFileInfo("dummyfile").absoluteFilePath();
     }
 #endif // !Q_OS_WINRT
 #else // Unix:
     QVERIFY(file1.link("link"));
     QTest::newRow("link")
-        << "link" << QFileInfo::SymbolicLink << QFileInfo(m_sourceFile).absoluteFilePath();
+        << "link" << false << true << QFileInfo(m_sourceFile).absoluteFilePath();
 
     QVERIFY(file2.link("brokenlink"));
     QTest::newRow("broken link")
-        << "brokenlink" << QFileInfo::SymbolicLink << QFileInfo("dummyfile").absoluteFilePath();
+        << "brokenlink" << false << true << QFileInfo("dummyfile").absoluteFilePath();
 
     QDir::current().mkdir("relative");
     QFile::link("../dummyfile", "relative/link");
     QTest::newRow("relative link")
-        << "relative/link" << QFileInfo::SymbolicLink << QFileInfo("dummyfile").absoluteFilePath();
+        << "relative/link" << false << true << QFileInfo("dummyfile").absoluteFilePath();
 #endif
 #endif // !Q_NO_SYMLINKS
     file2.remove();
@@ -1416,11 +1506,13 @@ void tst_QFileInfo::link_data()
 void tst_QFileInfo::link()
 {
     QFETCH(QString, path);
-    QFETCH(QFileInfo::FileType, linkType);
+    QFETCH(bool, isShortcut);
+    QFETCH(bool, isSymbolicLink);
     QFETCH(QString, linkTarget);
 
     QFileInfo fi(path);
-    QCOMPARE(fi.type() & QFileInfo::LinkTypeMask, linkType);
+    QCOMPARE(fi.isShortcut(), isShortcut);
+    QCOMPARE(fi.isSymbolicLink(), isSymbolicLink);
     QCOMPARE(fi.symLinkTarget(), linkTarget);
 }
 
@@ -2179,73 +2271,6 @@ void tst_QFileInfo::nonExistingFile()
     stateCheck(info, dirname, filename);
 }
 
-Q_DECLARE_METATYPE(QFileInfo::FileTypes)
-
-void tst_QFileInfo::type_data()
-{
-    QFile::remove("link.lnk");
-    QFile::remove("symlink.lnk");
-    QFile::remove("link");
-    QFile::remove("symlink");
-    QFile::remove("directory.lnk");
-    QFile::remove("directory");
-
-    QTest::addColumn<QString>("path");
-    QTest::addColumn<QFileInfo::FileTypes>("type");
-
-    QFile regularFile(m_sourceFile);
-    QTest::newRow("regular")
-        << regularFile.fileName() << QFileInfo::FileTypes(QFileInfo::Regular);
-    QTest::newRow("directory")
-        << QDir::currentPath() << QFileInfo::FileTypes(QFileInfo::Directory);
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINRT)
-    // windows shortcuts
-    QVERIFY(regularFile.link("link.lnk"));
-    QTest::newRow("shortcut")
-        << "link.lnk" << QFileInfo::FileTypes(QFileInfo::Shortcut | QFileInfo::Regular);
-    QVERIFY(regularFile.link("link"));
-    QTest::newRow("invalid-shortcut")
-        << "link" << QFileInfo::FileTypes(QFileInfo::Regular);
-    QVERIFY(QFile::link(QDir::currentPath(), "directory.lnk"));
-    QTest::newRow("directory-shortcut")
-        << "directory.lnk" << QFileInfo::FileTypes(QFileInfo::Shortcut | QFileInfo::Directory);
-#endif
-
-#ifndef Q_NO_SYMLINKS
-#if defined(Q_OS_WIN)
-#if !defined(Q_OS_WINRT)
-    QString errorMessage;
-    const DWORD creationResult = createSymbolicLink("symlink", m_sourceFile, &errorMessage);
-    if (creationResult == ERROR_PRIVILEGE_NOT_HELD) {
-        QWARN(msgInsufficientPrivileges(errorMessage));
-    } else {
-        QVERIFY2(creationResult == ERROR_SUCCESS, qPrintable(errorMessage));
-        QTest::newRow("NTFS-symlink")
-            << "symlink" << QFileInfo::FileTypes(QFileInfo::SymbolicLink | QFileInfo::Regular);
-    }
-#endif // !Q_OS_WINRT
-#else // Unix:
-    QVERIFY(regularFile.link("symlink.lnk"));
-    QTest::newRow("symlink.lnk")
-        << "symlink.lnk" << QFileInfo::FileTypes(QFileInfo::SymbolicLink | QFileInfo::Regular);
-    QVERIFY(regularFile.link("symlink"));
-    QTest::newRow("symlink")
-        << "symlink" << QFileInfo::FileTypes(QFileInfo::SymbolicLink | QFileInfo::Regular);
-    QVERIFY(QFile::link(QDir::currentPath(), "directory"));
-    QTest::newRow("directory-symlink")
-        << "directory" << QFileInfo::FileTypes(QFileInfo::SymbolicLink | QFileInfo::Directory);
-#endif
-#endif // !Q_NO_SYMLINKS
-}
-
-void tst_QFileInfo::type()
-{
-    QFETCH(QString, path);
-    QFETCH(QFileInfo::FileTypes, type);
-
-    QFileInfo info(path);
-    QCOMPARE(info.type(), type);
-}
 
 QTEST_MAIN(tst_QFileInfo)
 #include "tst_qfileinfo.moc"
diff --git a/tests/auto/corelib/time/qcalendar/qcalendar.pro b/tests/auto/corelib/time/qcalendar/qcalendar.pro
new file mode 100644
index 0000000000..94e8fe8606
--- /dev/null
+++ b/tests/auto/corelib/time/qcalendar/qcalendar.pro
@@ -0,0 +1,5 @@
+CONFIG += testcase
+TARGET = tst_qcalendar
+QT = core testlib
+SOURCES = \
+    tst_qcalendar.cpp
diff --git a/tests/auto/corelib/time/qcalendar/tst_qcalendar.cpp b/tests/auto/corelib/time/qcalendar/tst_qcalendar.cpp
new file mode 100644
index 0000000000..9b41014394
--- /dev/null
+++ b/tests/auto/corelib/time/qcalendar/tst_qcalendar.cpp
@@ -0,0 +1,236 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** 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 <QtTest/QtTest>
+
+#include <QCalendar>
+Q_DECLARE_METATYPE(QCalendar::System)
+
+class tst_QCalendar : public QObject
+{
+    Q_OBJECT
+private:
+    void checkYear(const QCalendar &cal, int year, bool normal=false);
+
+private slots:
+    void basic_data();
+    void basic();
+    void nameCase();
+    void specific_data();
+    void specific();
+    void daily_data() { basic_data(); }
+    void daily();
+};
+
+// Support for basic():
+void tst_QCalendar::checkYear(const QCalendar &cal, int year, bool normal)
+{
+    const int moons = cal.monthsInYear(year);
+    // Months are numbered from 1 to moons:
+    QVERIFY(moons > 0);
+    QVERIFY(!cal.isDateValid(year, moons + 1, 1));
+    QVERIFY(!cal.isDateValid(year, 0, 1));
+    QVERIFY(moons <= cal.maximumMonthsInYear());
+
+    const int days = cal.daysInYear(year);
+    QVERIFY(days > 0);
+
+    int sum = 0;
+    const int longest = cal.maximumDaysInMonth();
+    for (int i = moons; i > 0; i--) {
+        const int last = cal.daysInMonth(i, year);
+        sum += last;
+        // Valid month has some days and no more than max:
+        QVERIFY(last > 0);
+        QVERIFY(last <= longest);
+        // Days are numbered from 1 to last:
+        QVERIFY(cal.isDateValid(year, i, 1));
+        QVERIFY(cal.isDateValid(year, i, last));
+        QVERIFY(!cal.isDateValid(year, i, 0));
+        QVERIFY(!cal.isDateValid(year, i, last + 1));
+        if (normal) // Unspecified year gets same daysInMonth():
+            QCOMPARE(cal.daysInMonth(i), last);
+    }
+    // Months add up to the whole year:
+    QCOMPARE(sum, days);
+}
+
+#define CHECKYEAR(cal, year) checkYear(cal, year);   \
+    if (QTest::currentTestFailed()) \
+        return
+
+#define NORMALYEAR(cal, year) checkYear(cal, year, true); \
+    if (QTest::currentTestFailed()) \
+        return
+
+void tst_QCalendar::basic_data()
+{
+    QTest::addColumn<QCalendar::System>("system");
+
+    QMetaEnum e = QCalendar::staticMetaObject.enumerator(0);
+    Q_ASSERT(qstrcmp(e.name(), "System") == 0);
+
+    for (int i = 0; i <= int(QCalendar::System::Last); ++i) {
+        // There may be gaps in the enum's numbering; and Last is a duplicate:
+        if (e.value(i) != -1 && qstrcmp(e.key(i), "Last"))
+            QTest::newRow(e.key(i)) << QCalendar::System(e.value(i));
+    }
+}
+
+void tst_QCalendar::basic()
+{
+    QFETCH(QCalendar::System, system);
+    QCalendar cal(system);
+    QVERIFY(cal.isValid());
+    QCOMPARE(QCalendar(cal.name()).isGregorian(), cal.isGregorian());
+    QCOMPARE(QCalendar(cal.name()).name(), cal.name());
+
+    if (cal.hasYearZero()) {
+        CHECKYEAR(cal, 0);
+    } else {
+        QCOMPARE(cal.monthsInYear(0), 0);
+        QCOMPARE(cal.daysInYear(0), 0);
+        QVERIFY(!cal.isDateValid(0, 1, 1));
+    }
+
+    if (cal.isProleptic()) {
+        CHECKYEAR(cal, -1);
+    } else {
+        QCOMPARE(cal.monthsInYear(-1), 0);
+        QCOMPARE(cal.daysInYear(-1), 0);
+        QVERIFY(!cal.isDateValid(-1, 1, 1));
+    }
+
+    // Look for a leap year in the last decade.
+    int year = QDate::currentDate().year(cal);
+    for (int i = 10; i > 0 && !cal.isLeapYear(year); --i)
+        --year;
+    if (cal.isLeapYear(year)) {
+        // ... and a non-leap year within a decade before it.
+        int leap = year--;
+        for (int i = 10; i > 0 && cal.isLeapYear(year); --i)
+            year--;
+        if (!cal.isLeapYear(year))
+            QVERIFY(cal.daysInYear(year) < cal.daysInYear(leap));
+
+        CHECKYEAR(cal, leap);
+    }
+    // Either year is non-leap or we have a decade of leap years together;
+    // expect daysInMonth() to treat year the same as unspecified.
+    NORMALYEAR(cal, year);
+}
+
+void tst_QCalendar::nameCase()
+{
+    QVERIFY(QCalendar::availableCalendars().contains(QStringLiteral("Gregorian")));
+}
+
+void tst_QCalendar::specific_data()
+{
+    QTest::addColumn<QCalendar::System>("system");
+    // Date in that system:
+    QTest::addColumn<int>("sysyear");
+    QTest::addColumn<int>("sysmonth");
+    QTest::addColumn<int>("sysday");
+    // Gregorian equivalent:
+    QTest::addColumn<int>("gregyear");
+    QTest::addColumn<int>("gregmonth");
+    QTest::addColumn<int>("gregday");
+
+#define ADDROW(cal, year, month, day, gy, gm, gd) \
+    QTest::newRow(#cal) << QCalendar::System::cal << year << month << day << gy << gm << gd
+
+    ADDROW(Gregorian, 1970, 1, 1, 1970, 1, 1);
+
+    // One known specific date, for each calendar
+#ifndef QT_BOOTSTRAPPED
+    // Julian 1582-10-4 was followed by Gregorian 1582-10-15
+    ADDROW(Julian, 1582, 10, 4, 1582, 10, 14);
+    // Milankovic matches Gregorian for a few centuries
+    ADDROW(Milankovic, 1923, 3, 20, 1923, 3, 20);
+#endif
+
+#if QT_CONFIG(jalalicalendar)
+    // Jalali year 1355 started on Gregorian 1976-3-21:
+    ADDROW(Jalali, 1355, 1, 1, 1976, 3, 21);
+#endif // jalali
+#if QT_CONFIG(islamiccivilcalendar)
+    // TODO: confirm this is correct
+    ADDROW(IslamicCivil, 1, 1, 1, 622, 7, 19);
+#endif
+
+#undef ADDROW
+}
+
+void tst_QCalendar::specific()
+{
+    QFETCH(QCalendar::System, system);
+    QFETCH(int, sysyear);
+    QFETCH(int, sysmonth);
+    QFETCH(int, sysday);
+    QFETCH(int, gregyear);
+    QFETCH(int, gregmonth);
+    QFETCH(int, gregday);
+
+    const QCalendar cal(system);
+    const QDate date(sysyear, sysmonth, sysday, cal), gregory(gregyear, gregmonth, gregday);
+    QCOMPARE(date, gregory);
+    QCOMPARE(gregory.year(cal), sysyear);
+    QCOMPARE(gregory.month(cal), sysmonth);
+    QCOMPARE(gregory.day(cal), sysday);
+    QCOMPARE(date.year(), gregyear);
+    QCOMPARE(date.month(), gregmonth);
+    QCOMPARE(date.day(), gregday);
+}
+
+void tst_QCalendar::daily()
+{
+    QFETCH(QCalendar::System, system);
+    QCalendar calendar(system);
+    const quint64 startJDN = 0, endJDN = 2488070;
+    // Iterate from -4713-01-01 (Julian calendar) to 2100-01-01
+    for (quint64 expect = startJDN; expect <= endJDN; ++expect)
+    {
+        QDate date = QDate::fromJulianDay(expect);
+        auto parts = calendar.partsFromDate(date);
+        if (!parts.isValid())
+            continue;
+
+        const int year = date.year(calendar);
+        QCOMPARE(year, parts.year);
+        const int month = date.month(calendar);
+        QCOMPARE(month, parts.month);
+        const int day = date.day(calendar);
+        QCOMPARE(day, parts.day);
+        const quint64 actual = QDate(year, month, day, calendar).toJulianDay();
+        QCOMPARE(actual, expect);
+    }
+}
+
+QTEST_APPLESS_MAIN(tst_QCalendar)
+#include "tst_qcalendar.moc"
diff --git a/tests/auto/corelib/time/time.pro b/tests/auto/corelib/time/time.pro
index 6f9ff038db..6f1ee9a8bd 100644
--- a/tests/auto/corelib/time/time.pro
+++ b/tests/auto/corelib/time/time.pro
@@ -1,5 +1,6 @@
 TEMPLATE = subdirs
 SUBDIRS = \
+    qcalendar \
     qdate \
     qdatetime \
     qtime \
diff --git a/tests/auto/gui/image/qimagereader/tst_qimagereader.cpp b/tests/auto/gui/image/qimagereader/tst_qimagereader.cpp
index f6ffd7b7c5..22d96e76f9 100644
--- a/tests/auto/gui/image/qimagereader/tst_qimagereader.cpp
+++ b/tests/auto/gui/image/qimagereader/tst_qimagereader.cpp
@@ -1890,9 +1890,8 @@ void tst_QImageReader::saveFormat()
 
 void tst_QImageReader::saveColorSpace_data()
 {
-    QTest::addColumn<QColorSpace::ColorSpaceId>("colorspaceId");
+    QTest::addColumn<QColorSpace::NamedColorSpace>("namedColorSpace");
 
-    QTest::newRow("Undefined")    << QColorSpace::Undefined;
     QTest::newRow("sRGB")         << QColorSpace::SRgb;
     QTest::newRow("sRGB(linear)") << QColorSpace::SRgbLinear;
     QTest::newRow("AdobeRGB")     << QColorSpace::AdobeRgb;
@@ -1902,11 +1901,11 @@ void tst_QImageReader::saveColorSpace_data()
 
 void tst_QImageReader::saveColorSpace()
 {
-    QFETCH(QColorSpace::ColorSpaceId, colorspaceId);
+    QFETCH(QColorSpace::NamedColorSpace, namedColorSpace);
 
     QImage orig(":/images/kollada.png");
 
-    orig.setColorSpace(colorspaceId);
+    orig.setColorSpace(namedColorSpace);
     QBuffer buf;
     buf.open(QIODevice::WriteOnly);
     QVERIFY(orig.save(&buf, "png"));
diff --git a/tests/auto/gui/image/qpixmap/tst_qpixmap.cpp b/tests/auto/gui/image/qpixmap/tst_qpixmap.cpp
index 4d31d80246..ba5df809f2 100644
--- a/tests/auto/gui/image/qpixmap/tst_qpixmap.cpp
+++ b/tests/auto/gui/image/qpixmap/tst_qpixmap.cpp
@@ -267,10 +267,6 @@ void tst_QPixmap::fromImage()
     image.fill(0x7f7f7f7f);
 
     const QPixmap pixmap = QPixmap::fromImage(image);
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-    if (pixmap.handle()->classId() == QPlatformPixmap::X11Class && !pixmap.x11PictureHandle())
-        QSKIP("Requires XRender support");
-#endif
     const QImage result = pixmap.toImage();
     image = image.convertToFormat(result.format());
     QCOMPARE(result, image);
@@ -491,11 +487,6 @@ void tst_QPixmap::fill()
     else
         pm = QPixmap(400, 400);
 
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-    if (!bitmap && pm.handle()->classId() == QPlatformPixmap::X11Class && !pm.x11PictureHandle())
-        QSKIP("Requires XRender support");
-#endif
-
     pm.fill(color);
     if (syscolor && !bitmap && pm.depth() < 24) {
         QSKIP("Test does not work on displays without true color");
@@ -521,10 +512,6 @@ void tst_QPixmap::fill()
 void tst_QPixmap::fill_transparent()
 {
     QPixmap pixmap(10, 10);
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-    if (pixmap.handle()->classId() == QPlatformPixmap::X11Class && !pixmap.x11PictureHandle())
-        QSKIP("Requires XRender support");
-#endif
     pixmap.fill(Qt::transparent);
     QVERIFY(pixmap.hasAlphaChannel());
 }
diff --git a/tests/auto/gui/kernel/noqteventloop/tst_noqteventloop.cpp b/tests/auto/gui/kernel/noqteventloop/tst_noqteventloop.cpp
index 19c5c8a4a0..3d1876f00f 100644
--- a/tests/auto/gui/kernel/noqteventloop/tst_noqteventloop.cpp
+++ b/tests/auto/gui/kernel/noqteventloop/tst_noqteventloop.cpp
@@ -36,6 +36,7 @@
 #include <QtNetwork/qtcpserver.h>
 #include <QtNetwork/qtcpsocket.h>
 #include <QtCore/qelapsedtimer.h>
+#include <QtCore/qtimer.h>
 
 #include <QtCore/qt_windows.h>
 
@@ -49,7 +50,7 @@ class tst_NoQtEventLoop : public QObject
 private slots:
     void consumeMouseEvents();
     void consumeSocketEvents();
-
+    void deliverEventsInLivelock();
 };
 
 class Window : public QRasterWindow
@@ -312,6 +313,34 @@ void tst_NoQtEventLoop::consumeSocketEvents()
     QVERIFY(server.hasPendingConnections());
 }
 
+void tst_NoQtEventLoop::deliverEventsInLivelock()
+{
+    int argc = 1;
+    char *argv[] = { const_cast<char *>("test"), 0 };
+    QGuiApplication app(argc, argv);
+
+    QTimer livelockTimer;
+    livelockTimer.start(0);
+    QTimer::singleShot(100, Qt::CoarseTimer, &livelockTimer, &QTimer::stop);
+
+    QElapsedTimer elapsedTimer;
+    elapsedTimer.start();
+
+    // Exec own message loop
+    MSG msg;
+    forever {
+        if (elapsedTimer.hasExpired(3000) || !livelockTimer.isActive())
+            break;
+
+        if (::PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
+            ::TranslateMessage(&msg);
+            ::DispatchMessage(&msg);
+        }
+    }
+
+    QVERIFY(!livelockTimer.isActive());
+}
+
 #include <tst_noqteventloop.moc>
 
 QTEST_APPLESS_MAIN(tst_NoQtEventLoop)
diff --git a/tests/auto/gui/painting/qcolor/tst_qcolor.cpp b/tests/auto/gui/painting/qcolor/tst_qcolor.cpp
index 6c66519dce..07c820dc86 100644
--- a/tests/auto/gui/painting/qcolor/tst_qcolor.cpp
+++ b/tests/auto/gui/painting/qcolor/tst_qcolor.cpp
@@ -115,10 +115,6 @@ private slots:
 
     void qcolorprofile_data();
     void qcolorprofile();
-
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-    void setallowX11ColorNames();
-#endif
 };
 
 // Testing get/set functions
@@ -1649,62 +1645,6 @@ void tst_QColor::achromaticHslHue()
     QCOMPARE(hsl.hslHue(), -1);
 }
 
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-void tst_QColor::setallowX11ColorNames()
-{
-    RGBData x11RgbTbl[] = {
-        // a few standard X11 color names
-        { "DodgerBlue1", qRgb(30, 144, 255) },
-        { "DodgerBlue2", qRgb(28, 134, 238) },
-        { "DodgerBlue3", qRgb(24, 116, 205) },
-        { "DodgerBlue4", qRgb(16, 78, 139) },
-        { "SteelBlue1", qRgb(99, 184, 255) },
-        { "SteelBlue2", qRgb(92, 172, 238) },
-        { "SteelBlue3", qRgb(79, 148, 205) },
-        { "SteelBlue4", qRgb(54, 100, 139) },
-        { "DeepSkyBlue1", qRgb(0, 191, 255) },
-        { "DeepSkyBlue2", qRgb(0, 178, 238) },
-        { "DeepSkyBlue3", qRgb(0, 154, 205) },
-        { "DeepSkyBlue4", qRgb(0, 104, 139) },
-        { "SkyBlue1", qRgb(135, 206, 255) },
-        { "SkyBlue2", qRgb(126, 192, 238) },
-        { "SkyBlue3", qRgb(108, 166, 205) },
-        { "SkyBlue4", qRgb(74, 112, 139) }
-    };
-    static const int x11RgbTblSize = sizeof(x11RgbTbl) / sizeof(RGBData);
-
-    // X11 color names should not work by default
-    QVERIFY(!QColor::allowX11ColorNames());
-    for (int i = 0; i < x11RgbTblSize; ++i) {
-        QString colorName = QLatin1String(x11RgbTbl[i].name);
-        QColor color;
-        color.setNamedColor(colorName);
-        QVERIFY(!color.isValid());
-    }
-
-    // enable X11 color names
-    QColor::setAllowX11ColorNames(true);
-    QVERIFY(QColor::allowX11ColorNames());
-    for (int i = 0; i < x11RgbTblSize; ++i) {
-        QString colorName = QLatin1String(x11RgbTbl[i].name);
-        QColor color;
-        color.setNamedColor(colorName);
-        QColor expected(x11RgbTbl[i].value);
-        QCOMPARE(color, expected);
-    }
-
-    // should be able to turn off X11 color names
-    QColor::setAllowX11ColorNames(false);
-    QVERIFY(!QColor::allowX11ColorNames());
-    for (int i = 0; i < x11RgbTblSize; ++i) {
-        QString colorName = QLatin1String(x11RgbTbl[i].name);
-        QColor color;
-        color.setNamedColor(colorName);
-        QVERIFY(!color.isValid());
-    }
-}
-#endif
-
 void tst_QColor::premultiply()
 {
     // Tests that qPremultiply(qUnpremultiply(x)) returns x.
diff --git a/tests/auto/gui/painting/qcolorspace/tst_qcolorspace.cpp b/tests/auto/gui/painting/qcolorspace/tst_qcolorspace.cpp
index bc1a45013c..d51cfdee2f 100644
--- a/tests/auto/gui/painting/qcolorspace/tst_qcolorspace.cpp
+++ b/tests/auto/gui/painting/qcolorspace/tst_qcolorspace.cpp
@@ -35,7 +35,7 @@
 
 #include <private/qcolorspace_p.h>
 
-Q_DECLARE_METATYPE(QColorSpace::ColorSpaceId)
+Q_DECLARE_METATYPE(QColorSpace::NamedColorSpace)
 Q_DECLARE_METATYPE(QColorSpace::Primaries)
 Q_DECLARE_METATYPE(QColorSpace::TransferFunction)
 
@@ -47,6 +47,7 @@ public:
     tst_QColorSpace();
 
 private slots:
+    void movable();
     void namedColorSpaces_data();
     void namedColorSpaces();
 
@@ -63,8 +64,12 @@ private slots:
 
     void primaries();
     void primariesXyz();
+
+#ifdef QT_BUILD_INTERNAL
     void primaries2_data();
     void primaries2();
+#endif
+
     void invalidPrimaries();
 
     void changeTransferFunction();
@@ -75,9 +80,31 @@ tst_QColorSpace::tst_QColorSpace()
 { }
 
 
+void tst_QColorSpace::movable()
+{
+    QColorSpace cs1 = QColorSpace::SRgb;
+    QColorSpace cs2 = QColorSpace::SRgbLinear;
+    QVERIFY(cs1.isValid());
+    QVERIFY(cs2.isValid());
+    QCOMPARE(cs1, QColorSpace::SRgb);
+
+    cs2 = std::move(cs1);
+    QVERIFY(!cs1.isValid());
+    QVERIFY(cs2.isValid());
+    QCOMPARE(cs2, QColorSpace::SRgb);
+    QVERIFY(cs1 != QColorSpace::SRgb);
+    QCOMPARE(cs1, QColorSpace());
+
+    QColorSpace cs3(std::move(cs2));
+    QVERIFY(!cs2.isValid());
+    QVERIFY(cs3.isValid());
+    QCOMPARE(cs3, QColorSpace::SRgb);
+    QCOMPARE(cs2, QColorSpace());
+}
+
 void tst_QColorSpace::namedColorSpaces_data()
 {
-    QTest::addColumn<QColorSpace::ColorSpaceId>("colorSpaceId");
+    QTest::addColumn<QColorSpace::NamedColorSpace>("namedColorSpace");
     QTest::addColumn<QColorSpace::Primaries>("primariesId");
     QTest::addColumn<QColorSpace::TransferFunction>("transferFunctionId");
 
@@ -103,15 +130,15 @@ void tst_QColorSpace::namedColorSpaces_data()
 
 void tst_QColorSpace::namedColorSpaces()
 {
-    QFETCH(QColorSpace::ColorSpaceId, colorSpaceId);
+    QFETCH(QColorSpace::NamedColorSpace, namedColorSpace);
     QFETCH(QColorSpace::Primaries, primariesId);
     QFETCH(QColorSpace::TransferFunction, transferFunctionId);
 
-    QColorSpace colorSpace = colorSpaceId;
+    QColorSpace colorSpace = namedColorSpace;
 
     QVERIFY(colorSpace.isValid());
 
-    QCOMPARE(colorSpace.colorSpaceId(), colorSpaceId);
+    QCOMPARE(colorSpace, namedColorSpace);
     QCOMPARE(colorSpace.primaries(), primariesId);
     QCOMPARE(colorSpace.transferFunction(), transferFunctionId);
 }
@@ -124,14 +151,14 @@ void tst_QColorSpace::toIccProfile_data()
 
 void tst_QColorSpace::toIccProfile()
 {
-    QFETCH(QColorSpace::ColorSpaceId, colorSpaceId);
+    QFETCH(QColorSpace::NamedColorSpace, namedColorSpace);
     QFETCH(QColorSpace::Primaries, primariesId);
     QFETCH(QColorSpace::TransferFunction, transferFunctionId);
 
     Q_UNUSED(primariesId);
     Q_UNUSED(transferFunctionId);
 
-    QColorSpace colorSpace = colorSpaceId;
+    QColorSpace colorSpace = namedColorSpace;
     QByteArray iccProfile = colorSpace.iccProfile();
     QVERIFY(!iccProfile.isEmpty());
 
@@ -149,7 +176,7 @@ void tst_QColorSpace::toIccProfile()
 void tst_QColorSpace::fromIccProfile_data()
 {
     QTest::addColumn<QString>("testProfile");
-    QTest::addColumn<QColorSpace::ColorSpaceId>("colorSpaceId");
+    QTest::addColumn<QColorSpace::NamedColorSpace>("namedColorSpace");
     QTest::addColumn<QColorSpace::TransferFunction>("transferFunction");
     QTest::addColumn<QString>("description");
 
@@ -158,14 +185,14 @@ void tst_QColorSpace::fromIccProfile_data()
     QTest::newRow("sRGB2014 (ICCv2)") << prefix + "sRGB2014.icc" << QColorSpace::SRgb
                                            << QColorSpace::TransferFunction::SRgb << QString("sRGB2014");
     // My monitor's profile:
-    QTest::newRow("HP ZR30w (ICCv4)") << prefix + "HP_ZR30w.icc" << QColorSpace::Unknown
+    QTest::newRow("HP ZR30w (ICCv4)") << prefix + "HP_ZR30w.icc" << QColorSpace::NamedColorSpace(0)
                                       << QColorSpace::TransferFunction::Gamma << QString("HP Z30i");
 }
 
 void tst_QColorSpace::fromIccProfile()
 {
     QFETCH(QString, testProfile);
-    QFETCH(QColorSpace::ColorSpaceId, colorSpaceId);
+    QFETCH(QColorSpace::NamedColorSpace, namedColorSpace);
     QFETCH(QColorSpace::TransferFunction, transferFunction);
     QFETCH(QString, description);
 
@@ -175,15 +202,17 @@ void tst_QColorSpace::fromIccProfile()
     QColorSpace fileColorSpace = QColorSpace::fromIccProfile(iccProfile);
     QVERIFY(fileColorSpace.isValid());
 
-    QCOMPARE(fileColorSpace.colorSpaceId(), colorSpaceId);
+    if (namedColorSpace)
+        QCOMPARE(fileColorSpace, namedColorSpace);
+
     QCOMPARE(fileColorSpace.transferFunction(), transferFunction);
     QCOMPARE(QColorSpacePrivate::get(fileColorSpace)->description, description);
 }
 
 void tst_QColorSpace::imageConversion_data()
 {
-    QTest::addColumn<QColorSpace::ColorSpaceId>("fromColorSpace");
-    QTest::addColumn<QColorSpace::ColorSpaceId>("toColorSpace");
+    QTest::addColumn<QColorSpace::NamedColorSpace>("fromColorSpace");
+    QTest::addColumn<QColorSpace::NamedColorSpace>("toColorSpace");
     QTest::addColumn<int>("tolerance");
 
     QTest::newRow("sRGB -> Display-P3") << QColorSpace::SRgb << QColorSpace::DisplayP3 << 0;
@@ -197,8 +226,8 @@ void tst_QColorSpace::imageConversion_data()
 
 void tst_QColorSpace::imageConversion()
 {
-    QFETCH(QColorSpace::ColorSpaceId, fromColorSpace);
-    QFETCH(QColorSpace::ColorSpaceId, toColorSpace);
+    QFETCH(QColorSpace::NamedColorSpace, fromColorSpace);
+    QFETCH(QColorSpace::NamedColorSpace, toColorSpace);
     QFETCH(int, tolerance);
 
     QImage testImage(256, 1, QImage::Format_RGB32);
@@ -252,7 +281,7 @@ void tst_QColorSpace::loadImage()
 
     QVERIFY(!image.isNull());
     QVERIFY(image.colorSpace().isValid());
-    QCOMPARE(image.colorSpace().colorSpaceId(), QColorSpace::ProPhotoRgb);
+    QCOMPARE(image.colorSpace(), QColorSpace::ProPhotoRgb);
     QVERIFY(!image.colorSpace().iccProfile().isEmpty());
 
     QColorSpace defaultProPhotoRgb = QColorSpace::ProPhotoRgb;
@@ -332,6 +361,7 @@ void tst_QColorSpace::primariesXyz()
     QCOMPARE(QColorSpacePrivate::get(bt2020)->toXyz, QColorMatrix::toXyzFromBt2020());
 }
 
+#ifdef QT_BUILD_INTERNAL
 void tst_QColorSpace::primaries2_data()
 {
     QTest::addColumn<QColorSpace::Primaries>("primariesId");
@@ -370,12 +400,12 @@ void tst_QColorSpace::primaries2()
     QCOMPARE(color3.blue(),  color1.blue());
     QCOMPARE(color3.alpha(), color1.alpha());
 }
+#endif
 
 void tst_QColorSpace::invalidPrimaries()
 {
     QColorSpace custom(QPointF(), QPointF(), QPointF(), QPointF(), QColorSpace::TransferFunction::Linear);
     QVERIFY(!custom.isValid());
-    QCOMPARE(custom.colorSpaceId(), QColorSpace::Undefined);
 }
 
 void tst_QColorSpace::changeTransferFunction()
@@ -386,7 +416,7 @@ void tst_QColorSpace::changeTransferFunction()
     QCOMPARE(sRgbLinear.transferFunction(), QColorSpace::TransferFunction::Linear);
     QCOMPARE(sRgbLinear.gamma(), 1.0f);
     QCOMPARE(sRgbLinear.primaries(), QColorSpace::Primaries::SRgb);
-    QCOMPARE(sRgbLinear.colorSpaceId(), QColorSpace::SRgbLinear);
+    QCOMPARE(sRgbLinear, QColorSpace::SRgbLinear);
     QCOMPARE(sRgbLinear, QColorSpace(QColorSpace::SRgbLinear));
     QVERIFY(sRgbLinear != sRgb);
     QCOMPARE(sRgbLinear.withTransferFunction(QColorSpace::TransferFunction::SRgb), sRgb);
@@ -395,7 +425,6 @@ void tst_QColorSpace::changeTransferFunction()
     aRgb.setTransferFunction(QColorSpace::TransferFunction::SRgb);
     QCOMPARE(aRgb.transferFunction(), QColorSpace::TransferFunction::SRgb);
     QCOMPARE(aRgb.primaries(), QColorSpace::Primaries::AdobeRgb);
-    QCOMPARE(aRgb.colorSpaceId(), QColorSpace::Unknown);
     QVERIFY(aRgb != QColorSpace(QColorSpace::AdobeRgb));
     QVERIFY(aRgb != sRgb);
     QCOMPARE(aRgb.withTransferFunction(QColorSpace::TransferFunction::Gamma, 2.2f),
diff --git a/tests/auto/gui/painting/qpainter/tst_qpainter.cpp b/tests/auto/gui/painting/qpainter/tst_qpainter.cpp
index 61867ec65a..d2a4dfc3e9 100644
--- a/tests/auto/gui/painting/qpainter/tst_qpainter.cpp
+++ b/tests/auto/gui/painting/qpainter/tst_qpainter.cpp
@@ -461,11 +461,6 @@ void tst_QPainter::drawPixmap_comp()
     destPm.fill(c1);
     srcPm.fill(c2);
 
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-    if (!destPm.x11PictureHandle())
-        QSKIP("Requires XRender support");
-#endif
-
     QPainter p(&destPm);
     p.drawPixmap(0, 0, srcPm);
     p.end();
diff --git a/tests/auto/gui/painting/qregion/tst_qregion.cpp b/tests/auto/gui/painting/qregion/tst_qregion.cpp
index 24c4583819..d1ea7706b9 100644
--- a/tests/auto/gui/painting/qregion/tst_qregion.cpp
+++ b/tests/auto/gui/painting/qregion/tst_qregion.cpp
@@ -33,9 +33,6 @@
 #include <qbitmap.h>
 #include <qpainter.h>
 #include <qpolygon.h>
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-#include <private/qt_x11_p.h>
-#endif
 
 class tst_QRegion : public QObject
 {
@@ -79,9 +76,6 @@ private slots:
 
     void isEmpty_data();
     void isEmpty();
-#if 0 /* Used to be included in Qt4 for Q_WS_X11 */ && defined(QT_BUILD_INTERNAL)
-    void clipRectangles();
-#endif
 
     void regionFromPath();
     void scaleRegions_data();
@@ -910,24 +904,6 @@ void tst_QRegion::isEmpty()
 #endif
 }
 
-#if 0 /* Used to be included in Qt4 for Q_WS_X11 */ && defined(QT_BUILD_INTERNAL)
-void tst_QRegion::clipRectangles()
-{
-    QRegion region(30, 30, 30, 30);
-    int num = 0;
-    qt_getClipRects(region, num);
-    QCOMPARE(num, 1);
-
-    region += QRegion(10, 10, 10, 10);
-    XRectangle *rects2 = static_cast<XRectangle *>(qt_getClipRects(region, num));
-    QCOMPARE(num, 2);
-
-    // Here's the important part (Y-sorted):
-    QCOMPARE(int(rects2[0].y), 10);
-    QCOMPARE(int(rects2[1].y), 30);
-}
-#endif
-
 void tst_QRegion::regionFromPath()
 {
     {
diff --git a/tests/auto/opengl/qglthreads/tst_qglthreads.cpp b/tests/auto/opengl/qglthreads/tst_qglthreads.cpp
index 8a38d0f517..e12f6d9c18 100644
--- a/tests/auto/opengl/qglthreads/tst_qglthreads.cpp
+++ b/tests/auto/opengl/qglthreads/tst_qglthreads.cpp
@@ -606,9 +606,6 @@ void tst_QGLThreads::painterOnPixmapInThread()
     if (!QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::ThreadedOpenGL)
         || !QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::ThreadedPixmaps))
         QSKIP("No platformsupport for ThreadedOpenGL or ThreadedPixmaps");
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-    QSKIP("Drawing text in threads onto X11 drawables currently crashes on some X11 servers.");
-#endif
     PaintThreadManager<PixmapWrapper> painterThreads(5);
     painterThreads.start();
 
diff --git a/tests/auto/other/lancelot/paintcommands.cpp b/tests/auto/other/lancelot/paintcommands.cpp
index dc71253f3e..032580e0f6 100644
--- a/tests/auto/other/lancelot/paintcommands.cpp
+++ b/tests/auto/other/lancelot/paintcommands.cpp
@@ -2478,12 +2478,6 @@ void PaintCommands::command_surface_begin(QRegularExpressionMatch re)
         m_painter->fillRect(QRect(0, 0, qRound(w), qRound(h)), Qt::transparent);
         m_painter->restore();
 #endif
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-    } else if (m_type == WidgetType) {
-        m_surface_pixmap = QPixmap(qRound(w), qRound(h));
-        m_surface_pixmap.fill(Qt::transparent);
-        m_painter = new QPainter(&m_surface_pixmap);
-#endif
     } else {
         QImage::Format surface_format;
         if (QImage::toPixelFormat(m_format).alphaUsage() != QPixelFormat::UsesAlpha)
@@ -2535,11 +2529,6 @@ void PaintCommands::command_surface_end(QRegularExpressionMatch)
         m_painter->beginNativePainting();
         m_painter->endNativePainting();
 #endif
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-    } else if (m_type == WidgetType) {
-        m_painter->drawPixmap(m_surface_rect.topLeft(), m_surface_pixmap);
-        m_surface_pixmap = QPixmap();
-#endif
     } else {
         m_painter->drawImage(m_surface_rect, m_surface_image);
         m_surface_image = QImage();
diff --git a/tests/auto/tools/qmake/tst_qmake.cpp b/tests/auto/tools/qmake/tst_qmake.cpp
index 99d41d3583..9b434a7b5b 100644
--- a/tests/auto/tools/qmake/tst_qmake.cpp
+++ b/tests/auto/tools/qmake/tst_qmake.cpp
@@ -711,9 +711,6 @@ void tst_qmake::qinstall()
         QFile srcfile(src.filePath("main.cpp"));
         QVERIFY(srcfile.setPermissions(srcfile.permissions() & ~writeFlags));
         QDir dst("zort");
-#ifdef Q_OS_WIN
-        QEXPECT_FAIL("", "QTBUG-77299", Abort);
-#endif
         QVERIFY(qinstall(src.absolutePath(), dst.absolutePath()));
         QCOMPARE(src.entryList(QDir::Files, QDir::Name), dst.entryList(QDir::Files, QDir::Name));
     }
diff --git a/tests/auto/widgets/graphicsview/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/auto/widgets/graphicsview/qgraphicsitem/tst_qgraphicsitem.cpp
index 72ea2ae31a..0b08586f7d 100644
--- a/tests/auto/widgets/graphicsview/qgraphicsitem/tst_qgraphicsitem.cpp
+++ b/tests/auto/widgets/graphicsview/qgraphicsitem/tst_qgraphicsitem.cpp
@@ -4451,6 +4451,7 @@ protected:
             break;
         case QGraphicsItem::ItemPositionHasChanged:
             break;
+#if QT_DEPRECATED_SINCE(5, 14)
         case QGraphicsItem::ItemMatrixChange: {
 #if QT_DEPRECATED_SINCE(5, 13)
 QT_WARNING_PUSH
@@ -4462,6 +4463,7 @@ QT_WARNING_POP
 #endif
         }
             break;
+#endif
         case QGraphicsItem::ItemTransformChange: {
             QVariant variant;
             variant.setValue<QTransform>(transform());
diff --git a/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp b/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
index 39aa65a478..a437b05479 100644
--- a/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
+++ b/tests/auto/widgets/graphicsview/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
@@ -2768,9 +2768,6 @@ void tst_QGraphicsProxyWidget::windowOpacity()
     // disabled on platforms without alpha channel support in QPixmap (e.g.,
     // X11 without XRender).
     int paints = 0;
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-    paints = !X11->use_xrender;
-#endif
     QTRY_COMPARE(eventSpy.counts[QEvent::UpdateRequest], 0);
     QTRY_COMPARE(eventSpy.counts[QEvent::Paint], paints);
 
diff --git a/tests/auto/widgets/itemviews/qabstractitemview/tst_qabstractitemview.cpp b/tests/auto/widgets/itemviews/qabstractitemview/tst_qabstractitemview.cpp
index 6f7dca86eb..bcfc477733 100644
--- a/tests/auto/widgets/itemviews/qabstractitemview/tst_qabstractitemview.cpp
+++ b/tests/auto/widgets/itemviews/qabstractitemview/tst_qabstractitemview.cpp
@@ -1024,9 +1024,6 @@ void tst_QAbstractItemView::setItemDelegate()
     centerOnScreen(&v);
     moveCursorAway(&v);
     v.show();
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-    QCursor::setPos(v.geometry().center());
-#endif
     QApplication::setActiveWindow(&v);
     QVERIFY(QTest::qWaitForWindowActive(&v));
 
diff --git a/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp b/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
index 715bbbec0f..51049ecd81 100644
--- a/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
+++ b/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
@@ -46,7 +46,7 @@
 #include <qstylefactory.h>
 #include <qdesktopwidget.h>
 #include <private/qwidget_p.h>
-#include <private/qwidgetbackingstore_p.h>
+#include <private/qwidgetrepaintmanager_p.h>
 #include <private/qapplication_p.h>
 #include <private/qhighdpiscaling_p.h>
 #include <qcalendarwidget.h>
@@ -1139,6 +1139,7 @@ void tst_QWidget::visible()
     QVERIFY( !childWidget->isVisible() );
 
     testWidget->show();
+    QVERIFY(testWidget->screen());
     QVERIFY( testWidget->isVisible() );
     QVERIFY( childWidget->isVisible() );
 
@@ -9565,7 +9566,7 @@ void tst_QWidget::destroyBackingStore()
     QTRY_VERIFY(w.numPaintEvents > 0);
     w.reset();
     w.update();
-    qt_widget_private(&w)->topData()->widgetBackingStore.reset(new QWidgetBackingStore(&w));
+    qt_widget_private(&w)->topData()->repaintManager.reset(new QWidgetRepaintManager(&w));
 
     w.update();
     QApplication::processEvents();
@@ -9580,14 +9581,14 @@ void tst_QWidget::destroyBackingStore()
 #endif // QT_BUILD_INTERNAL
 
 // Helper function
-QWidgetBackingStore* backingStore(QWidget &widget)
+QWidgetRepaintManager* repaintManager(QWidget &widget)
 {
-    QWidgetBackingStore *backingStore = nullptr;
+    QWidgetRepaintManager *repaintManager = nullptr;
 #ifdef QT_BUILD_INTERNAL
     if (QTLWExtra *topExtra = qt_widget_private(&widget)->maybeTopData())
-        backingStore = topExtra->widgetBackingStore.get();
+        repaintManager = topExtra->repaintManager.get();
 #endif
-    return backingStore;
+    return repaintManager;
 }
 
 // Tables of 5000 elements do not make sense on Windows Mobile.
@@ -9785,12 +9786,12 @@ class scrollWidgetWBS : public QWidget
 public:
     void deleteBackingStore()
     {
-        static_cast<QWidgetPrivate*>(d_ptr.data())->topData()->widgetBackingStore.reset(nullptr);
+        static_cast<QWidgetPrivate*>(d_ptr.data())->topData()->repaintManager.reset(nullptr);
     }
     void enableBackingStore()
     {
-        if (!static_cast<QWidgetPrivate*>(d_ptr.data())->maybeBackingStore()) {
-            static_cast<QWidgetPrivate*>(d_ptr.data())->topData()->widgetBackingStore.reset(new QWidgetBackingStore(this));
+        if (!static_cast<QWidgetPrivate*>(d_ptr.data())->maybeRepaintManager()) {
+            static_cast<QWidgetPrivate*>(d_ptr.data())->topData()->repaintManager.reset(new QWidgetRepaintManager(this));
             static_cast<QWidgetPrivate*>(d_ptr.data())->invalidateBackingStore(this->rect());
             repaint();
         }
diff --git a/tests/auto/widgets/widgets/qdatetimeedit/tst_qdatetimeedit.cpp b/tests/auto/widgets/widgets/qdatetimeedit/tst_qdatetimeedit.cpp
index 810f081b73..26b4b7d020 100644
--- a/tests/auto/widgets/widgets/qdatetimeedit/tst_qdatetimeedit.cpp
+++ b/tests/auto/widgets/widgets/qdatetimeedit/tst_qdatetimeedit.cpp
@@ -348,8 +348,7 @@ static QLatin1String sectionToName(const QDateTimeEdit::Section section)
     }
 }
 
-static QDate stepDate(const QDate& startDate, const QDateTimeEdit::Section section,
-                      const int steps)
+static QDate stepDate(QDate startDate, const QDateTimeEdit::Section section, const int steps)
 {
     switch (section) {
     case QDateTimeEdit::DaySection:
@@ -364,8 +363,7 @@ static QDate stepDate(const QDate& startDate, const QDateTimeEdit::Section secti
     }
 }
 
-static QTime stepTime(const QTime& startTime, const QDateTimeEdit::Section section,
-                      const int steps)
+static QTime stepTime(QTime startTime, const QDateTimeEdit::Section section, const int steps)
 {
     switch (section) {
     case QDateTimeEdit::SecondSection:
diff --git a/tests/auto/widgets/widgets/qlineedit/tst_qlineedit.cpp b/tests/auto/widgets/widgets/qlineedit/tst_qlineedit.cpp
index 1c68a5f752..0cfbc651ad 100644
--- a/tests/auto/widgets/widgets/qlineedit/tst_qlineedit.cpp
+++ b/tests/auto/widgets/widgets/qlineedit/tst_qlineedit.cpp
@@ -4860,6 +4860,7 @@ void tst_QLineEdit::inputRejected()
     QCOMPARE(spyInputRejected.count(), 0);
     QTest::keyClicks(testWidget, "fgh");
     QCOMPARE(spyInputRejected.count(), 3);
+#if QT_CONFIG(clipboard)
     testWidget->clear();
     spyInputRejected.clear();
     QApplication::clipboard()->setText("ijklmno");
@@ -4867,6 +4868,7 @@ void tst_QLineEdit::inputRejected()
     // The first 5 characters are accepted, but
     // the last 2 are not.
     QCOMPARE(spyInputRejected.count(), 1);
+#endif
 
     testWidget->setMaxLength(INT_MAX);
     testWidget->clear();
@@ -4877,11 +4879,13 @@ void tst_QLineEdit::inputRejected()
     QCOMPARE(spyInputRejected.count(), 0);
     QTest::keyClicks(testWidget, "a#");
     QCOMPARE(spyInputRejected.count(), 2);
+#if QT_CONFIG(clipboard)
     testWidget->clear();
     spyInputRejected.clear();
     QApplication::clipboard()->setText("a#");
     testWidget->paste();
     QCOMPARE(spyInputRejected.count(), 1);
+#endif
 
     testWidget->clear();
     testWidget->setValidator(0);
diff --git a/tests/auto/widgets/widgets/qmdiarea/tst_qmdiarea.cpp b/tests/auto/widgets/widgets/qmdiarea/tst_qmdiarea.cpp
index b8abd78657..6d38dc262f 100644
--- a/tests/auto/widgets/widgets/qmdiarea/tst_qmdiarea.cpp
+++ b/tests/auto/widgets/widgets/qmdiarea/tst_qmdiarea.cpp
@@ -479,9 +479,6 @@ void tst_QMdiArea::subWindowActivated2()
     // Check that we only emit _one_ signal and the active window
     // is unchanged after hide/show.
     mdiArea.hide();
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-    qt_x11_wait_for_window_manager(&mdiArea);
-#endif
     QTest::qWait(100);
     QTRY_COMPARE(spy.count(), 1);
     QVERIFY(!mdiArea.activeSubWindow());
diff --git a/tests/auto/widgets/widgets/qmdisubwindow/tst_qmdisubwindow.cpp b/tests/auto/widgets/widgets/qmdisubwindow/tst_qmdisubwindow.cpp
index b8891fab95..3ee9c72209 100644
--- a/tests/auto/widgets/widgets/qmdisubwindow/tst_qmdisubwindow.cpp
+++ b/tests/auto/widgets/widgets/qmdisubwindow/tst_qmdisubwindow.cpp
@@ -52,9 +52,7 @@
 #include <QVector>
 
 QT_BEGIN_NAMESPACE
-#if 1 // Used to be excluded in Qt4 for Q_WS_WIN
 extern bool qt_tab_all_widgets();
-#endif
 QT_END_NAMESPACE
 
 static inline bool tabAllWidgets()
diff --git a/tests/benchmarks/corelib/time/qdate/tst_bench_qdate.cpp b/tests/benchmarks/corelib/time/qdate/tst_bench_qdate.cpp
index 399ac44065..10c013c080 100644
--- a/tests/benchmarks/corelib/time/qdate/tst_bench_qdate.cpp
+++ b/tests/benchmarks/corelib/time/qdate/tst_bench_qdate.cpp
@@ -26,27 +26,187 @@
 **
 ****************************************************************************/
 
-#include <QDateTime>
+#include <QDate>
 #include <QTest>
+#include <QVector>
 
 class tst_QDate : public QObject
 {
     Q_OBJECT
 
+    enum : qint64
+    {
+        JULIAN_DAY_2010 = 2455198,
+        JULIAN_DAY_2011 = 2455563,
+        JULIAN_DAY_2020 = 2458850,
+    };
+
+    static QVector<QDate> daily(qint64 start, qint64 end);
+    static QVector<QDate> yearly(qint32 first, qint32 last);
+
 private Q_SLOTS:
-    void monthLengths();
+    void create();
+    void year();
+    void month();
+    void day();
+    void dayOfWeek();
+    void dayOfYear();
+    void monthLengths(); // isValid() and daysInMonth()
+    void daysInYear();
+    void isLeapYear();
+    void getSetDate();
+    void addDays();
+    void addMonths();
+    void addYears();
 };
 
+QVector<QDate> tst_QDate::daily(qint64 start, qint64 end)
+{
+    QVector<QDate> list;
+    list.reserve(end - start);
+    for (qint64 jd = start; jd < end; ++jd)
+        list.append(QDate::fromJulianDay(jd));
+    return list;
+}
+
+QVector<QDate> tst_QDate::yearly(qint32 first, qint32 last)
+{
+    QVector<QDate> list;
+    list.reserve(last + 1 - first);
+    for (qint32 year = first; year <= last; ++year)
+        list.append(QDate(year, 3, 21));
+    return list;
+}
+
+void tst_QDate::create()
+{
+    QDate test;
+    QBENCHMARK {
+        for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
+            test = QDate::fromJulianDay(jd);
+    }
+    Q_UNUSED(test);
+}
+
+void tst_QDate::year()
+{
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
+    QBENCHMARK {
+        for (const QDate &test : list)
+            test.year();
+    }
+}
+
+void tst_QDate::month()
+{
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
+    QBENCHMARK {
+        for (const QDate &test : list)
+            test.month();
+    }
+}
+
+void tst_QDate::day()
+{
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
+    QBENCHMARK {
+        for (const QDate &test : list)
+            test.day();
+    }
+}
+
+void tst_QDate::dayOfWeek()
+{
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
+    QBENCHMARK {
+        for (const QDate &test : list)
+            test.dayOfWeek();
+    }
+}
+
+void tst_QDate::dayOfYear()
+{
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
+    QBENCHMARK {
+        for (const QDate &test : list)
+            test.dayOfYear();
+    }
+}
+
 void tst_QDate::monthLengths()
 {
+    bool check = true;
     QBENCHMARK {
         for (int year = 1900; year <= 2100; year++) {
-            bool check = true;
             for (int month = 1; month <= 12; month++)
-                check &= QDate::isValid(year, month, QDate(year, month, 1).daysInMonth());
-            Q_UNUSED(check);
+                check = QDate::isValid(year, month, QDate(year, month, 1).daysInMonth());
+        }
+    }
+    Q_UNUSED(check);
+}
+
+void tst_QDate::daysInYear()
+{
+    const auto list = yearly(1601, 2401);
+    QBENCHMARK {
+        for (const QDate date : list)
+            date.daysInYear();
+    }
+}
+
+void tst_QDate::isLeapYear()
+{
+    QBENCHMARK {
+        for (qint32 year = 1601; year <= 2401; year++)
+            QDate::isLeapYear(year);
+    }
+}
+
+void tst_QDate::getSetDate()
+{
+    QDate store;
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
+    QBENCHMARK {
+        for (const auto test : list) {
+            int year, month, day;
+            test.getDate(&year, &month, &day);
+            store.setDate(year, month, day);
         }
     }
+    Q_UNUSED(store);
+}
+
+void tst_QDate::addDays()
+{
+    QDate store;
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
+    QBENCHMARK {
+        for (const auto test : list)
+            store = test.addDays(17);
+    }
+    Q_UNUSED(store);
+}
+
+void tst_QDate::addMonths()
+{
+    QDate store;
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
+    QBENCHMARK {
+        for (const auto test : list)
+            store = test.addMonths(17);
+    }
+    Q_UNUSED(store);
+}
+
+void tst_QDate::addYears()
+{
+    QDate store;
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
+    QBENCHMARK {
+        for (const auto test : list)
+            store = test.addYears(17);
+    }
+    Q_UNUSED(store);
 }
 
 QTEST_MAIN(tst_QDate)
diff --git a/tests/benchmarks/corelib/time/qdatetime/main.cpp b/tests/benchmarks/corelib/time/qdatetime/main.cpp
index b693400376..740e08cc46 100644
--- a/tests/benchmarks/corelib/time/qdatetime/main.cpp
+++ b/tests/benchmarks/corelib/time/qdatetime/main.cpp
@@ -29,6 +29,7 @@
 #include <QDateTime>
 #include <QTimeZone>
 #include <QTest>
+#include <QVector>
 #include <qdebug.h>
 
 class tst_QDateTime : public QObject
@@ -41,6 +42,7 @@ class tst_QDateTime : public QObject
         MSECS_PER_DAY = 86400000,
         JULIAN_DAY_1950 = 2433283,
         JULIAN_DAY_1960 = 2436935,
+        JULIAN_DAY_1970 = 2440588, // Epoch
         JULIAN_DAY_2010 = 2455198,
         JULIAN_DAY_2011 = 2455563,
         JULIAN_DAY_2020 = 2458850,
@@ -48,6 +50,9 @@ class tst_QDateTime : public QObject
         JULIAN_DAY_2060 = 2473460
     };
 
+    static QVector<QDateTime> daily(qint64 start, qint64 end);
+    static QVector<QDateTime> norse(qint64 start, qint64 end);
+
 private Q_SLOTS:
     void create();
     void isNull();
@@ -97,6 +102,25 @@ private Q_SLOTS:
     void fromMSecsSinceEpochTz();
 };
 
+QVector<QDateTime> tst_QDateTime::daily(qint64 start, qint64 end)
+{
+    QVector<QDateTime> list;
+    list.reserve(end - start);
+    for (int jd = start; jd < end; ++jd)
+        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    return list;
+}
+
+QVector<QDateTime> tst_QDateTime::norse(qint64 start, qint64 end)
+{
+    const QTimeZone cet("Europe/Oslo");
+    QVector<QDateTime> list;
+    list.reserve(end - start);
+    for (int jd = start; jd < end; ++jd)
+        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0), cet));
+    return list;
+}
+
 void tst_QDateTime::create()
 {
     QBENCHMARK {
@@ -109,339 +133,286 @@ void tst_QDateTime::create()
 
 void tst_QDateTime::isNull()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.isNull();
     }
 }
 
 void tst_QDateTime::isValid()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.isValid();
     }
 }
 
 void tst_QDateTime::date()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.date();
     }
 }
 
 void tst_QDateTime::time()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.time();
     }
 }
 
 void tst_QDateTime::timeSpec()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.timeSpec();
     }
 }
 
 void tst_QDateTime::offsetFromUtc()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.offsetFromUtc();
     }
 }
 
 void tst_QDateTime::timeZoneAbbreviation()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.timeZoneAbbreviation();
     }
 }
 
 void tst_QDateTime::toMSecsSinceEpoch()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.toMSecsSinceEpoch();
     }
 }
 
 void tst_QDateTime::toMSecsSinceEpoch1950()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_1950; jd < JULIAN_DAY_1960; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_1950, JULIAN_DAY_1960);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.toMSecsSinceEpoch();
     }
 }
 
 void tst_QDateTime::toMSecsSinceEpoch2050()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2050; jd < JULIAN_DAY_2060; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2050, JULIAN_DAY_2060);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.toMSecsSinceEpoch();
     }
 }
 
 void tst_QDateTime::toMSecsSinceEpochTz()
 {
-    QTimeZone cet = QTimeZone("Europe/Oslo");
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0), cet));
+    qint64 result;
+    const auto list = norse(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
-            qint64 result = test.toMSecsSinceEpoch();
+        for (const QDateTime &test : list)
+            result = test.toMSecsSinceEpoch();
     }
+    Q_UNUSED(result);
 }
 
 void tst_QDateTime::toMSecsSinceEpoch1950Tz()
 {
-    QTimeZone cet = QTimeZone("Europe/Oslo");
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_1950; jd < JULIAN_DAY_1960; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0), cet));
+    qint64 result;
+    const auto list = norse(JULIAN_DAY_1950, JULIAN_DAY_1960);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
-            qint64 result = test.toMSecsSinceEpoch();
+        for (const QDateTime &test : list)
+            result = test.toMSecsSinceEpoch();
     }
+    Q_UNUSED(result);
 }
 
 void tst_QDateTime::toMSecsSinceEpoch2050Tz()
 {
-    QTimeZone cet = QTimeZone("Europe/Oslo");
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2050; jd < JULIAN_DAY_2060; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0), cet));
+    qint64 result;
+    const auto list = norse(JULIAN_DAY_2050, JULIAN_DAY_2060);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
-            qint64 result = test.toMSecsSinceEpoch();
+        for (const QDateTime &test : list)
+            result = test.toMSecsSinceEpoch();
     }
+    Q_UNUSED(result);
 }
 
 void tst_QDateTime::setDate()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (QDateTime test, list)
+        for (QDateTime test : list)
             test.setDate(QDate::fromJulianDay(JULIAN_DAY_2010));
     }
 }
 
 void tst_QDateTime::setTime()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (QDateTime test, list)
+        for (QDateTime test : list)
             test.setTime(QTime(12, 0, 0));
     }
 }
 
 void tst_QDateTime::setTimeSpec()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (QDateTime test, list)
+        for (QDateTime test : list)
             test.setTimeSpec(Qt::UTC);
     }
 }
 
 void tst_QDateTime::setOffsetFromUtc()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (QDateTime test, list)
+        for (QDateTime test : list)
             test.setOffsetFromUtc(3600);
     }
 }
 
 void tst_QDateTime::setMSecsSinceEpoch()
 {
-    qint64 msecs = qint64(JULIAN_DAY_2010 + 180) * MSECS_PER_DAY;
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    qint64 msecs = qint64(JULIAN_DAY_2010 - JULIAN_DAY_1970 + 180) * MSECS_PER_DAY;
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (QDateTime test, list)
+        for (QDateTime test : list)
             test.setMSecsSinceEpoch(msecs);
     }
 }
 
 void tst_QDateTime::setMSecsSinceEpochTz()
 {
-    QTimeZone cet = QTimeZone("Europe/Oslo");
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0), cet));
+    const qint64 msecs = qint64(JULIAN_DAY_2010 - JULIAN_DAY_1970 + 180) * MSECS_PER_DAY;
+    const auto list = norse(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (QDateTime test, list)
-            test.setMSecsSinceEpoch((JULIAN_DAY_2010 + 180) * MSECS_PER_DAY);
+        for (QDateTime test : list)
+            test.setMSecsSinceEpoch(msecs);
     }
 }
 
 void tst_QDateTime::toString()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2011; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2011);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.toString(QStringLiteral("yyy-MM-dd hh:mm:ss.zzz t"));
     }
 }
 
 void tst_QDateTime::toStringTextFormat()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2011; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2011);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.toString(Qt::TextDate);
     }
 }
 
 void tst_QDateTime::toStringIsoFormat()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2011; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2011);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.toString(Qt::ISODate);
     }
 }
 
 void tst_QDateTime::addDays()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
+    QDateTime next;
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
-            test.addDays(1);
+        for (const QDateTime &test : list)
+            next = test.addDays(1);
     }
+    Q_UNUSED(next);
 }
 
 void tst_QDateTime::addDaysTz()
 {
-    QTimeZone cet = QTimeZone("Europe/Oslo");
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0), cet));
+    const auto list = norse(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             QDateTime result = test.addDays(1);
     }
 }
 
 void tst_QDateTime::addMSecs()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
+    QDateTime next;
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
-            test.addMSecs(1);
+        for (const QDateTime &test : list)
+            next = test.addMSecs(1);
     }
+    Q_UNUSED(next);
 }
 
 void tst_QDateTime::addMSecsTz()
 {
-    QTimeZone cet = QTimeZone("Europe/Oslo");
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0), cet));
+    const auto list = norse(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             QDateTime result = test.addMSecs(1);
     }
 }
 
 void tst_QDateTime::toTimeSpec()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.toTimeSpec(Qt::UTC);
     }
 }
 
 void tst_QDateTime::toOffsetFromUtc()
 {
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.toOffsetFromUtc(3600);
     }
 }
 
 void tst_QDateTime::daysTo()
 {
-    QDateTime other = QDateTime::fromMSecsSinceEpoch(qint64(JULIAN_DAY_2010) * MSECS_PER_DAY);
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const QDateTime other = QDateTime::fromMSecsSinceEpoch(
+        qint64(JULIAN_DAY_2010 - JULIAN_DAY_1970) * MSECS_PER_DAY);
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.daysTo(other);
     }
 }
 
 void tst_QDateTime::msecsTo()
 {
-    QDateTime other = QDateTime::fromMSecsSinceEpoch(qint64(JULIAN_DAY_2010) * MSECS_PER_DAY);
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const QDateTime other = QDateTime::fromMSecsSinceEpoch(
+        qint64(JULIAN_DAY_2010 - JULIAN_DAY_1970) * MSECS_PER_DAY);
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             test.msecsTo(other);
     }
 }
@@ -449,12 +420,11 @@ void tst_QDateTime::msecsTo()
 void tst_QDateTime::equivalent()
 {
     bool result;
-    QDateTime other = QDateTime::fromMSecsSinceEpoch(qint64(JULIAN_DAY_2010) * MSECS_PER_DAY);
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const QDateTime other = QDateTime::fromMSecsSinceEpoch(
+        qint64(JULIAN_DAY_2010 - JULIAN_DAY_1970) * MSECS_PER_DAY);
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             result = (test == other);
     }
     Q_UNUSED(result)
@@ -463,12 +433,11 @@ void tst_QDateTime::equivalent()
 void tst_QDateTime::equivalentUtc()
 {
     bool result = false;
-    QDateTime other = QDateTime::fromMSecsSinceEpoch(qint64(JULIAN_DAY_2010) * MSECS_PER_DAY, Qt::UTC);
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const QDateTime other = QDateTime::fromMSecsSinceEpoch(
+        qint64(JULIAN_DAY_2010 - JULIAN_DAY_1970) * MSECS_PER_DAY, Qt::UTC);
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             result = (test == other);
     }
     Q_UNUSED(result)
@@ -477,12 +446,11 @@ void tst_QDateTime::equivalentUtc()
 void tst_QDateTime::lessThan()
 {
     bool result = false;
-    QDateTime other = QDateTime::fromMSecsSinceEpoch(qint64(JULIAN_DAY_2010) * MSECS_PER_DAY);
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const QDateTime other = QDateTime::fromMSecsSinceEpoch(
+        qint64(JULIAN_DAY_2010 - JULIAN_DAY_1970) * MSECS_PER_DAY);
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             result = (test < other);
     }
     Q_UNUSED(result)
@@ -491,12 +459,11 @@ void tst_QDateTime::lessThan()
 void tst_QDateTime::lessThanUtc()
 {
     bool result = false;
-    QDateTime other = QDateTime::fromMSecsSinceEpoch(qint64(JULIAN_DAY_2010) * MSECS_PER_DAY, Qt::UTC);
-    QList<QDateTime> list;
-    for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
-        list.append(QDateTime(QDate::fromJulianDay(jd), QTime::fromMSecsSinceStartOfDay(0)));
+    const QDateTime other = QDateTime::fromMSecsSinceEpoch(
+        qint64(JULIAN_DAY_2010 - JULIAN_DAY_1970) * MSECS_PER_DAY, Qt::UTC);
+    const auto list = daily(JULIAN_DAY_2010, JULIAN_DAY_2020);
     QBENCHMARK {
-        foreach (const QDateTime &test, list)
+        for (const QDateTime &test : list)
             result = (test < other);
     }
     Q_UNUSED(result)
@@ -573,25 +540,31 @@ void tst_QDateTime::fromStringIso()
 
 void tst_QDateTime::fromMSecsSinceEpoch()
 {
+    const int start = JULIAN_DAY_2010 - JULIAN_DAY_1970;
+    const int end = JULIAN_DAY_2020 - JULIAN_DAY_1970;
     QBENCHMARK {
-        for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
+        for (int jd = start; jd < end; ++jd)
             QDateTime::fromMSecsSinceEpoch(jd * MSECS_PER_DAY, Qt::LocalTime);
     }
 }
 
 void tst_QDateTime::fromMSecsSinceEpochUtc()
 {
+    const int start = JULIAN_DAY_2010 - JULIAN_DAY_1970;
+    const int end = JULIAN_DAY_2020 - JULIAN_DAY_1970;
     QBENCHMARK {
-        for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
+        for (int jd = start; jd < end; ++jd)
             QDateTime::fromMSecsSinceEpoch(jd * MSECS_PER_DAY, Qt::UTC);
     }
 }
 
 void tst_QDateTime::fromMSecsSinceEpochTz()
 {
-    QTimeZone cet = QTimeZone("Europe/Oslo");
+    const int start = JULIAN_DAY_2010 - JULIAN_DAY_1970;
+    const int end = JULIAN_DAY_2020 - JULIAN_DAY_1970;
+    const QTimeZone cet("Europe/Oslo");
     QBENCHMARK {
-        for (int jd = JULIAN_DAY_2010; jd < JULIAN_DAY_2020; ++jd)
+        for (int jd = start; jd < end; ++jd)
             QDateTime test = QDateTime::fromMSecsSinceEpoch(jd * MSECS_PER_DAY, cet);
     }
 }
diff --git a/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/chipTest/view.cpp b/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/chipTest/view.cpp
index de4e9e5ad7..6e0ac445a6 100644
--- a/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/chipTest/view.cpp
+++ b/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/chipTest/view.cpp
@@ -30,12 +30,7 @@
 
 #include <QtGui>
 
-#if 0 // Used to be included in Qt4 for Q_WS_WIN
-#define CALLGRIND_START_INSTRUMENTATION  {}
-#define CALLGRIND_STOP_INSTRUMENTATION   {}
-#else
 #include "valgrind/callgrind.h"
-#endif
 
 #ifndef QT_NO_OPENGL
 #include <QtOpenGL>
diff --git a/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/moveItems/main.cpp b/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/moveItems/main.cpp
index e0cc0f8eb4..140278b8f6 100644
--- a/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/moveItems/main.cpp
+++ b/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/moveItems/main.cpp
@@ -27,16 +27,7 @@
 ****************************************************************************/
 #include <QtGui>
 
-#if 0 // Used to be included in Qt4 for Q_WS_WIN
-#define CALLGRIND_START_INSTRUMENTATION  {}
-#define CALLGRIND_STOP_INSTRUMENTATION   {}
-#else
 #include "valgrind/callgrind.h"
-#endif
-
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-extern void qt_x11_wait_for_window_manager(QWidget *);
-#endif
 
 class View : public QGraphicsView
 {
@@ -89,9 +80,6 @@ int main(int argc, char *argv[])
     View view(&scene, item);
     view.resize(300, 300);
     view.show();
-#if 0 // Used to be included in Qt4 for Q_WS_X11
-    qt_x11_wait_for_window_manager(&view);
-#endif
 
     return app.exec();
 }
diff --git a/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/scrolltest/main.cpp b/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/scrolltest/main.cpp
index 1fbb229cd8..566d16ca51 100644
--- a/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/scrolltest/main.cpp
+++ b/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/scrolltest/main.cpp
@@ -27,12 +27,7 @@
 ****************************************************************************/
 #include <QtGui>
 
-#if 0 // Used to be included in Qt4 for Q_WS_WIN
-#define CALLGRIND_START_INSTRUMENTATION  {}
-#define CALLGRIND_STOP_INSTRUMENTATION   {}
-#else
 #include "valgrind/callgrind.h"
-#endif
 
 class ItemMover : public QObject
 {
diff --git a/tests/manual/highdpi/highdpi.pro b/tests/manual/highdpi/highdpi.pro
index 9db083cd82..2de8ed3bb5 100644
--- a/tests/manual/highdpi/highdpi.pro
+++ b/tests/manual/highdpi/highdpi.pro
@@ -15,3 +15,4 @@ HEADERS += \
 RESOURCES += \
     highdpi.qrc
 
+DEFINES += HAVE_SCREEN_BASE_DPI
diff --git a/tests/manual/highdpi/main.cpp b/tests/manual/highdpi/main.cpp
index 7225587ac0..8884c5feed 100644
--- a/tests/manual/highdpi/main.cpp
+++ b/tests/manual/highdpi/main.cpp
@@ -37,10 +37,12 @@
 #include <QPushButton>
 #include <QButtonGroup>
 #include <QLineEdit>
+#include <QPlainTextEdit>
 #include <QScrollBar>
 #include <QSlider>
 #include <QSpinBox>
 #include <QTabBar>
+#include <QTextBrowser>
 #include <QIcon>
 #include <QPainter>
 #include <QWindow>
@@ -55,9 +57,16 @@
 #include <QCommandLineOption>
 #include <QDebug>
 #include <private/qhighdpiscaling_p.h>
+#include <qpa/qplatformscreen.h>
 
 #include "dragwidget.h"
 
+static QTextStream &operator<<(QTextStream &str, const QRect &r)
+{
+    str << r.width() << 'x' << r.height() << forcesign << r.x() << r.y() << noforcesign;
+    return str;
+}
+
 class DemoContainerBase
 {
 public:
@@ -1176,6 +1185,85 @@ public:
     }
 };
 
+class MetricsTest : public QWidget
+{
+    QPlainTextEdit *m_textEdit;
+
+public:
+    MetricsTest()
+    {
+        qDebug() << R"(
+MetricsTest
+Relevant environment variables are:
+QT_FONT_DPI=N
+QT_SCALE_FACTOR=n
+QT_ENABLE_HIGHDPI_SCALING=0|1
+QT_USE_PHYSICAL_DPI=0|1
+QT_SCREEN_SCALE_FACTORS=N;N;N or QT_SCREEN_SCALE_FACTORS=name:N
+QT_SCALE_FACTOR_ROUNDING_POLICY=Round|Ceil|Floor|RoundPreferFloor|PassThrough
+QT_DPI_ADJUSTMENT_POLICY=AdjustDpi|DontAdjustDpi|AdjustUpOnly)";
+
+        resize(480, 360);
+
+        QVBoxLayout *layout = new QVBoxLayout();
+        setLayout(layout);
+
+        m_textEdit = new QPlainTextEdit;
+        m_textEdit->setReadOnly(true);
+        layout->addWidget(m_textEdit);
+    }
+
+    void updateMetrics()
+    {
+        QString text;
+        QTextStream str(&text);
+
+        auto currentScreen = windowHandle()->screen();
+        const auto screens = QGuiApplication::screens();
+        for (int i = 0, size = screens.size(); i < size; ++i) {
+            auto screen = screens.at(i);
+            auto platformScreen = screen->handle();
+            str << "Screen #" << i << " \"" << screen->name() << '"';
+            if (screen == currentScreen)
+                str << " [current]";
+            if (screen == QGuiApplication::primaryScreen())
+                str << " [primary]";
+            str << "\n  screen geometry: " << screen->geometry()
+                << "\n  platform screen geometry: " << platformScreen->geometry()
+                << "\n  platform screen logicalDpi: " << platformScreen->logicalDpi().first;
+
+#ifdef HAVE_SCREEN_BASE_DPI
+            str << "\n  platform screen logicalBaseDpi: " << platformScreen->logicalBaseDpi().first;
+#endif
+            str << "\n  platform screen devicePixelRatio: " <<platformScreen->devicePixelRatio()
+                << "\n  platform screen physicalDpi: " << screen->physicalDotsPerInch()
+                << "\n\n";
+        }
+
+        str << "widget devicePixelRatio: " << this->devicePixelRatioF()
+            << "\nwidget logicalDpi: " << this->logicalDpiX()
+            << "\n\nQT_FONT_DPI: " << qgetenv("QT_FONT_DPI")
+            << "\nQT_SCALE_FACTOR: " << qgetenv("QT_SCALE_FACTOR")
+            << "\nQT_ENABLE_HIGHDPI_SCALING: " << qgetenv("QT_ENABLE_HIGHDPI_SCALING")
+            << "\nQT_SCREEN_SCALE_FACTORS: " << qgetenv("QT_SCREEN_SCALE_FACTORS")
+            << "\nQT_USE_PHYSICAL_DPI: " << qgetenv("QT_USE_PHYSICAL_DPI")
+            << "\nQT_SCALE_FACTOR_ROUNDING_POLICY: " << qgetenv("QT_SCALE_FACTOR_ROUNDING_POLICY")
+            << "\nQT_DPI_ADJUSTMENT_POLICY: " << qgetenv("QT_DPI_ADJUSTMENT_POLICY")
+            << '\n';
+
+        m_textEdit->setPlainText(text);
+    }
+
+    void paintEvent(QPaintEvent *ev)
+    {
+        // We get a paint event on screen change, so this is a convenient place
+        // to update the metrics, at the possible risk of doing something else
+        // than painting in a paint event.
+        updateMetrics();
+        QWidget::paintEvent(ev);
+    }
+};
+
 int main(int argc, char **argv)
 {
     QApplication app(argc, argv);
@@ -1212,6 +1300,7 @@ int main(int argc, char **argv)
     demoList << new DemoContainer<ScreenDisplayer>("screens", "Test screen and window positioning");
     demoList << new DemoContainer<PhysicalSizeTest>("physicalsize", "Test manual highdpi support using physicalDotsPerInch");
     demoList << new DemoContainer<GraphicsViewCaching>("graphicsview", "Test QGraphicsView caching");
+    demoList << new DemoContainer<MetricsTest>("metrics", "Show display metrics");
 
     foreach (DemoContainerBase *demo, demoList)
         parser.addOption(demo->option());
diff --git a/tests/manual/lance/main.cpp b/tests/manual/lance/main.cpp
index 7f5af2d908..6dc5e2076a 100644
--- a/tests/manual/lance/main.cpp
+++ b/tests/manual/lance/main.cpp
@@ -334,20 +334,7 @@ int main(int argc, char **argv)
                 checkers_background = false;
             }
         } else {
-#if 0 // Used to be included in Qt4 for Q_WS_WIN
-            QString input = QString::fromLocal8Bit(argv[i]);
-            if (input.indexOf('*') >= 0) {
-                QFileInfo info(input);
-                QDir dir = info.dir();
-                QFileInfoList infos = dir.entryInfoList(QStringList(info.fileName()));
-                for (int ii=0; ii<infos.size(); ++ii)
-                    files.append(infos.at(ii).absoluteFilePath());
-            } else {
-                files.append(input);
-            }
-#else
             files.append(QString(argv[i]));
-#endif
         }
     }
     scaledWidth = int(width * scalefactor);
diff --git a/tests/manual/rhi/shared/examplefw.h b/tests/manual/rhi/shared/examplefw.h
index 450aa172c2..1a29ef5f7e 100644
--- a/tests/manual/rhi/shared/examplefw.h
+++ b/tests/manual/rhi/shared/examplefw.h
@@ -124,6 +124,7 @@ QString graphicsApiName()
 QRhi::Flags rhiFlags = QRhi::EnableDebugMarkers;
 int sampleCount = 1;
 QRhiSwapChain::Flags scFlags = 0;
+QRhi::BeginFrameFlags beginFrameFlags = 0;
 QRhi::EndFrameFlags endFrameFlags = 0;
 
 class Window : public QWindow
@@ -375,7 +376,7 @@ void Window::render()
     // GPU/present, and that's what throttles the thread to the refresh rate.
     // (except for OpenGL where it happens either in endFrame or somewhere else
     // depending on the GL implementation)
-    QRhi::FrameOpResult r = m_r->beginFrame(m_sc);
+    QRhi::FrameOpResult r = m_r->beginFrame(m_sc, beginFrameFlags);
     if (r == QRhi::FrameOpSwapChainOutOfDate) {
         resizeSwapChain();
         if (!m_hasSwapChain)
diff --git a/tests/manual/rhi/triquadcube/triquadcube.cpp b/tests/manual/rhi/triquadcube/triquadcube.cpp
index 4165e96127..76dbe558ab 100644
--- a/tests/manual/rhi/triquadcube/triquadcube.cpp
+++ b/tests/manual/rhi/triquadcube/triquadcube.cpp
@@ -71,6 +71,7 @@
 //#define READBACK_SWAPCHAIN
 //#define NO_VSYNC
 //#define USE_MIN_SWAPCHAIN_BUFFERS
+//#define DECLARE_EXT_CONTENTS
 
 struct {
     TriangleRenderer triRenderer;
@@ -118,6 +119,10 @@ void preInit()
     scFlags |= QRhiSwapChain::MinimalBufferCount;
 #endif
 
+#ifdef DECLARE_EXT_CONTENTS
+    beginFrameFlags |= QRhi::ExternalContentsInPass;
+#endif
+
     // For OpenGL some of these are incorporated into the QSurfaceFormat by
     // examplefw.h after returning from here as that is out of the RHI's control.
 }
diff --git a/tests/manual/textrendering/glyphshaping/main.cpp b/tests/manual/textrendering/glyphshaping/main.cpp
index c3acda953d..c1e49b3b7e 100644
--- a/tests/manual/textrendering/glyphshaping/main.cpp
+++ b/tests/manual/textrendering/glyphshaping/main.cpp
@@ -160,8 +160,6 @@ bool dumpHtml(const QString &pathName)
     QString platformName = QString::fromLatin1(
 #if defined(Q_OS_WIN)
             "Win32"
-#elif 0 // Used to be included in Qt4 for Q_WS_X11
-            "X11"
 #else
             ""
 #endif