Merge 5.10 into 5.10.0

Change-Id: Ibfbaa8ef89cf45b87a2c65f1da4a708e5464f259

15 files changed, 360 insertions, 129 deletions

diff --git a/tests/auto/corelib/animation/qsequentialanimationgroup/BLACKLIST b/tests/auto/corelib/animation/qsequentialanimationgroup/BLACKLIST
index 391e3f67af..2a31afd735 100644
--- a/tests/auto/corelib/animation/qsequentialanimationgroup/BLACKLIST
+++ b/tests/auto/corelib/animation/qsequentialanimationgroup/BLACKLIST
@@ -3,3 +3,5 @@ windows
 [finishWithUncontrolledAnimation]
 windows
 osx-10.12
+[groupWithZeroDurationAnimations]
+osx
diff --git a/tests/auto/corelib/global/qrandomgenerator/tst_qrandomgenerator.cpp b/tests/auto/corelib/global/qrandomgenerator/tst_qrandomgenerator.cpp
index 4b38d46317..220ec9a2f8 100644
--- a/tests/auto/corelib/global/qrandomgenerator/tst_qrandomgenerator.cpp
+++ b/tests/auto/corelib/global/qrandomgenerator/tst_qrandomgenerator.cpp
@@ -43,8 +43,8 @@
 #define COMMA   ,
 #define QVERIFY_3TIMES(statement)    \
     do {\
-        if (!QTest::qVerify(static_cast<bool>(statement), #statement, "1st try", __FILE__, __LINE__))\
-            if (!QTest::qVerify(static_cast<bool>(statement), #statement, "2nd try", __FILE__, __LINE__))\
+        if (!static_cast<bool>(statement))\
+            if (!static_cast<bool>(statement))\
                 if (!QTest::qVerify(static_cast<bool>(statement), #statement, "3rd try", __FILE__, __LINE__))\
                     return;\
     } while (0)
@@ -71,6 +71,15 @@ public slots:
     void cleanup() { setRNGControl(0); }
 
 private slots:
+    void basics();
+    void knownSequence();
+    void discard();
+    void copying();
+    void copyingGlobal();
+    void copyingSystem();
+    void systemRng();
+    void securelySeeding();
+
     void generate32_data();
     void generate32();
     void generate64_data() { generate32_data(); }
@@ -110,19 +119,212 @@ private slots:
     void stdRandomDistributions();
 };
 
+// The first 20 results of the sequence:
+static const quint32 defaultRngResults[] = {
+    853323747U, 2396352728U, 3025954838U, 2985633182U, 2815751046U,
+    340588426U, 3587208406U, 298087538U, 2912478009U, 3642122814U,
+    3202916223U, 799257577U, 1872145992U, 639469699U, 3201121432U,
+    2388658094U, 1735523408U, 2215232359U, 668106566U, 2554687763U
+};
+
+
 using namespace std;
 QT_WARNING_DISABLE_GCC("-Wfloat-equal")
 QT_WARNING_DISABLE_CLANG("-Wfloat-equal")
 
+struct RandomGenerator : public QRandomGenerator
+{
+    RandomGenerator(uint control)
+        : QRandomGenerator(control ?
+                               QRandomGenerator(control & RandomDataMask) :
+                               *QRandomGenerator::global())
+    {
+        setRNGControl(control);
+    }
+};
+
+void tst_QRandomGenerator::basics()
+{
+    // default constructible
+    QRandomGenerator rng;
+
+    // copyable && movable
+    rng = rng;
+    rng = std::move(rng);
+
+    // 64-bit
+    QRandomGenerator64 rng64;
+    rng64 = rng64;
+    rng64 = std::move(rng64);
+
+    // 32- and 64-bit should be interchangeable:
+    rng = rng64;
+    rng64 = rng;
+    rng = std::move(rng64);
+    rng64 = std::move(rng);
+
+    rng = QRandomGenerator64::securelySeeded();
+    rng64 = QRandomGenerator::securelySeeded();
+
+    // access global
+    QRandomGenerator *global = QRandomGenerator::global();
+    QRandomGenerator globalCopy = *global;
+    globalCopy = *global;
+    QRandomGenerator64 *global64 = QRandomGenerator64::global();
+    QRandomGenerator64 globalCopy64 = *global64;
+    globalCopy64 = *global64;
+
+    // access system
+    QRandomGenerator *system = QRandomGenerator::system();
+    QRandomGenerator systemRng = *system;
+    systemRng = *system;
+
+    QRandomGenerator64 *system64 = QRandomGenerator64::system();
+    QRandomGenerator64 systemRng64 = *system64;
+    systemRng64 = *system64;
+
+    Q_STATIC_ASSERT(std::is_same<decltype(rng64.generate()) COMMA quint64>::value);
+    Q_STATIC_ASSERT(std::is_same<decltype(system64->generate()) COMMA quint64>::value);
+}
+
+void tst_QRandomGenerator::knownSequence()
+{
+    QRandomGenerator rng;
+    for (quint32 x : defaultRngResults)
+        QCOMPARE(rng(), x);
+
+    // should work again if we reseed it
+    rng.seed();
+    for (quint32 x : defaultRngResults)
+        QCOMPARE(rng(), x);
+}
+
+void tst_QRandomGenerator::discard()
+{
+    QRandomGenerator rng;
+    rng.discard(1);
+    QCOMPARE(rng(), defaultRngResults[1]);
+
+    rng.discard(9);
+    QCOMPARE(rng(), defaultRngResults[11]);
+}
+
+void tst_QRandomGenerator::copying()
+{
+    QRandomGenerator rng1;
+    QRandomGenerator rng2 = rng1;
+    QCOMPARE(rng1, rng2);
+
+    quint32 samples[20];
+    rng1.fillRange(samples);
+
+    // not equal anymore
+    QVERIFY(rng1 != rng2);
+
+    // should produce the same sequence, whichever it was
+    for (quint32 x : samples)
+        QCOMPARE(rng2(), x);
+
+    // now they should compare equal again
+    QCOMPARE(rng1, rng2);
+}
+
+void tst_QRandomGenerator::copyingGlobal()
+{
+    QRandomGenerator &global = *QRandomGenerator::global();
+    QRandomGenerator copy = global;
+    QCOMPARE(copy, global);
+    QCOMPARE(global, copy);
+
+    quint32 samples[20];
+    global.fillRange(samples);
+
+    // not equal anymore
+    QVERIFY(copy != global);
+
+    // should produce the same sequence, whichever it was
+    for (quint32 x : samples)
+        QCOMPARE(copy(), x);
+
+    // equal again
+    QCOMPARE(copy, global);
+    QCOMPARE(global, copy);
+}
+
+void tst_QRandomGenerator::copyingSystem()
+{
+    QRandomGenerator &system = *QRandomGenerator::system();
+    QRandomGenerator copy = system;
+    QRandomGenerator copy2 = copy;
+    copy2 = copy;
+    QCOMPARE(system, copy);
+    QCOMPARE(copy, copy2);
+
+    quint32 samples[20];
+    copy2.fillRange(samples);
+
+    // they still compre equally
+    QCOMPARE(system, copy);
+    QCOMPARE(copy, copy2);
+
+    // should NOT produce the same sequence, whichever it was
+    int sameCount = 0;
+    for (quint32 x : samples)
+        sameCount += (copy() == x);
+    QVERIFY(sameCount < 20);
+
+    QCOMPARE(system, copy);
+    QCOMPARE(copy, copy2);
+}
+
+void tst_QRandomGenerator::systemRng()
+{
+    QRandomGenerator *rng = QRandomGenerator::system();
+    rng->generate();
+    rng->generate64();
+    rng->generateDouble();
+    rng->bounded(100);
+    rng->bounded(100U);
+
+#ifdef QT_BUILD_INTERNAL
+    quint32 setpoint = std::numeric_limits<int>::max();
+    ++setpoint;
+    quint64 setpoint64 = quint64(setpoint) << 32 | setpoint;
+    setRNGControl(SetRandomData | setpoint);
+
+    QCOMPARE(rng->generate(), setpoint);
+    QCOMPARE(rng->generate64(), setpoint64);
+    QCOMPARE(rng->generateDouble(), ldexp(setpoint64, -64));
+    QCOMPARE(rng->bounded(100), 50);
+#endif
+}
+
+void tst_QRandomGenerator::securelySeeding()
+{
+    QRandomGenerator rng1 = QRandomGenerator::securelySeeded();
+    QRandomGenerator rng2 = QRandomGenerator::securelySeeded();
+
+    quint32 samples[20];
+    rng1.fillRange(samples);
+
+    // should NOT produce the same sequence, whichever it was
+    int sameCount = 0;
+    for (quint32 x : samples)
+        sameCount += (rng2() == x);
+    QVERIFY(sameCount < 20);
+}
+
 void tst_QRandomGenerator::generate32_data()
 {
     QTest::addColumn<uint>("control");
-    QTest::newRow("default") << 0U;
+    QTest::newRow("fixed") << (RandomValue32 & RandomDataMask);
+    QTest::newRow("global") << 0U;
 #ifdef QT_BUILD_INTERNAL
-    QTest::newRow("direct") << uint(SkipMemfill);
-    QTest::newRow("system") << uint(SkipHWRNG);
+    if (qt_has_hwrng())
+        QTest::newRow("hwrng") << uint(UseSystemRNG);
+    QTest::newRow("system") << uint(UseSystemRNG | SkipHWRNG);
 #  ifdef HAVE_FALLBACK_ENGINE
-    QTest::newRow("fallback") << uint(SkipHWRNG | SkipSystemRNG);
+    QTest::newRow("system-fallback") << uint(UseSystemRNG | SkipHWRNG | SkipSystemRNG);
 #  endif
 #endif
 }
@@ -130,39 +332,40 @@ void tst_QRandomGenerator::generate32_data()
 void tst_QRandomGenerator::generate32()
 {
     QFETCH(uint, control);
-    setRNGControl(control);
+    RandomGenerator rng(control);
 
     for (int i = 0; i < 4; ++i) {
-        QVERIFY_3TIMES([] {
-            quint32 value = QRandomGenerator::generate();
+        QVERIFY_3TIMES([&] {
+            quint32 value = rng.generate();
             return value != 0 && value != RandomValue32;
         }());
     }
 
     // and should hopefully be different from repeated calls
     for (int i = 0; i < 4; ++i)
-        QVERIFY_3TIMES(QRandomGenerator::generate() != QRandomGenerator::generate());
+        QVERIFY_3TIMES(rng.generate() != rng.generate());
 }
 
 void tst_QRandomGenerator::generate64()
 {
     QFETCH(uint, control);
-    setRNGControl(control);
+    RandomGenerator rng(control);
 
+    QVERIFY_3TIMES(rng.generate64() > std::numeric_limits<quint32>::max());
     for (int i = 0; i < 4; ++i) {
-        QVERIFY_3TIMES([] {
-            quint64 value = QRandomGenerator::generate();
+        QVERIFY_3TIMES([&] {
+            quint64 value = rng.generate64();
             return value != 0 && value != RandomValue32 && value != RandomValue64;
         }());
     }
 
     // and should hopefully be different from repeated calls
     for (int i = 0; i < 4; ++i)
-        QVERIFY_3TIMES(QRandomGenerator::generate64() != QRandomGenerator::generate64());
+        QVERIFY_3TIMES(rng.generate64() != rng.generate64());
     for (int i = 0; i < 4; ++i)
-        QVERIFY_3TIMES(QRandomGenerator::generate() != quint32(QRandomGenerator::generate64()));
+        QVERIFY_3TIMES(rng.generate() != quint32(rng.generate64()));
     for (int i = 0; i < 4; ++i)
-        QVERIFY_3TIMES(QRandomGenerator::generate() != (QRandomGenerator::generate64() >> 32));
+        QVERIFY_3TIMES(rng.generate() != (rng.generate64() >> 32));
 }
 
 void tst_QRandomGenerator::quality()
@@ -191,7 +394,9 @@ void tst_QRandomGenerator::quality()
     Q_STATIC_ASSERT(FailureThreshold > AcceptableThreshold);
 
     QFETCH(uint, control);
-    setRNGControl(control);
+    if (control & RandomDataMask)
+        return;
+    RandomGenerator rng(control);
 
     int histogram[UCHAR_MAX + 1];
     memset(histogram, 0, sizeof(histogram));
@@ -200,7 +405,7 @@ void tst_QRandomGenerator::quality()
         // test the quality of the generator
         quint32 buffer[BufferCount];
         memset(buffer, 0xcc, sizeof(buffer));
-        generate_n(buffer, +BufferCount, [] { return QRandomGenerator::generate(); });
+        generate_n(buffer, +BufferCount, [&] { return rng.generate(); });
 
         quint8 *ptr = reinterpret_cast<quint8 *>(buffer);
         quint8 *end = ptr + sizeof(buffer);
@@ -225,20 +430,20 @@ void tst_QRandomGenerator::quality()
 template <typename T> void fillRange_template()
 {
     QFETCH(uint, control);
-    setRNGControl(control);
+    RandomGenerator rng(control);
 
     for (int i = 0; i < 4; ++i) {
-        QVERIFY_3TIMES([] {
+        QVERIFY_3TIMES([&] {
             T value[1] = { RandomValue32 };
-            QRandomGenerator::fillRange(value);
+            rng.fillRange(value);
             return value[0] != 0 && value[0] != RandomValue32;
         }());
     }
 
     for (int i = 0; i < 4; ++i) {
-        QVERIFY_3TIMES([] {
+        QVERIFY_3TIMES([&] {
             T array[2] = {};
-            QRandomGenerator::fillRange(array);
+            rng.fillRange(array);
             return array[0] != array[1];
         }());
     }
@@ -246,18 +451,18 @@ template <typename T> void fillRange_template()
     if (sizeof(T) > sizeof(quint32)) {
         // just to shut up a warning about shifting uint more than the width
         enum { Shift = sizeof(T) / 2 * CHAR_BIT };
-        QVERIFY_3TIMES([] {
+        QVERIFY_3TIMES([&] {
             T value[1] = { };
-            QRandomGenerator::fillRange(value);
+            rng.fillRange(value);
             return quint32(value[0] >> Shift) != quint32(value[0]);
         }());
     }
 
     // fill in a longer range
-    auto longerArrayCheck = [] {
+    auto longerArrayCheck = [&] {
         T array[32];
         memset(array, 0, sizeof(array));
-        QRandomGenerator::fillRange(array);
+        rng.fillRange(array);
         if (sizeof(T) == sizeof(RandomValue64)
                 && find(begin(array), end(array), RandomValue64) != end(array))
             return false;
@@ -274,11 +479,11 @@ void tst_QRandomGenerator::fillRangeULLong() { fillRange_template<qulonglong>();
 template <typename T> void generate_template()
 {
     QFETCH(uint, control);
-    setRNGControl(control);
+    RandomGenerator rng(control);
 
     // almost the same as fillRange, but limited to 32 bits
     for (int i = 0; i < 4; ++i) {
-        QVERIFY_3TIMES([] {
+        QVERIFY_3TIMES([&] {
             T value[1] = { RandomValue32 };
             QRandomGenerator().generate(begin(value), end(value));
             return value[0] != 0 && value[0] != RandomValue32
@@ -287,10 +492,10 @@ template <typename T> void generate_template()
     }
 
     // fill in a longer range
-    auto longerArrayCheck = [] {
+    auto longerArrayCheck = [&] {
         T array[72] = {};   // at least 256 bytes
         QRandomGenerator().generate(begin(array), end(array));
-        return find_if(begin(array), end(array), [](T cur) {
+        return find_if(begin(array), end(array), [&](T cur) {
                 return cur == 0 || cur == RandomValue32 ||
                         cur == RandomValue64 || cur > numeric_limits<quint32>::max();
             }) == end(array);
@@ -304,12 +509,12 @@ void tst_QRandomGenerator::generateULLong() { generate_template<qulonglong>(); }
 void tst_QRandomGenerator::generateNonContiguous()
 {
     QFETCH(uint, control);
-    setRNGControl(control);
+    RandomGenerator rng(control);
 
     QLinkedList<quint64> list = { 0, 0, 0, 0,  0, 0, 0, 0 };
     auto longerArrayCheck = [&] {
         QRandomGenerator().generate(list.begin(), list.end());
-        return find_if(list.begin(), list.end(), [](quint64 cur) {
+        return find_if(list.begin(), list.end(), [&](quint64 cur) {
                 return cur == 0 || cur == RandomValue32 ||
                         cur == RandomValue64 || cur > numeric_limits<quint32>::max();
             }) == list.end();
@@ -327,7 +532,7 @@ void tst_QRandomGenerator::bounded_data()
     QTest::addColumn<quint32>("sup");
     QTest::addColumn<quint32>("expected");
 
-    auto newRow = [](quint32 val, quint32 sup) {
+    auto newRow = [&](quint32 val, quint32 sup) {
         // calculate the scaled value
         quint64 scaled = val;
         scaled <<= 32;
@@ -353,31 +558,31 @@ void tst_QRandomGenerator::bounded()
     QFETCH(uint, control);
     QFETCH(quint32, sup);
     QFETCH(quint32, expected);
-    setRNGControl(control);
+    RandomGenerator rng(control);
 
-    quint32 value = QRandomGenerator::bounded(sup);
+    quint32 value = rng.bounded(sup);
     QVERIFY(value < sup);
     QCOMPARE(value, expected);
 
-    int ivalue = QRandomGenerator::bounded(sup);
+    int ivalue = rng.bounded(sup);
     QVERIFY(ivalue < int(sup));
     QCOMPARE(ivalue, int(expected));
 
     // confirm only the bound now
-    setRNGControl(control & (SkipHWRNG|SkipSystemRNG));
-    value = QRandomGenerator::bounded(sup);
+    setRNGControl(control & (SkipHWRNG|SkipSystemRNG|UseSystemRNG));
+    value = rng.bounded(sup);
     QVERIFY(value < sup);
 
-    value = QRandomGenerator::bounded(sup / 2, 3 * sup / 2);
+    value = rng.bounded(sup / 2, 3 * sup / 2);
     QVERIFY(value >= sup / 2);
     QVERIFY(value < 3 * sup / 2);
 
-    ivalue = QRandomGenerator::bounded(-int(sup), int(sup));
+    ivalue = rng.bounded(-int(sup), int(sup));
     QVERIFY(ivalue >= -int(sup));
     QVERIFY(ivalue < int(sup));
 
     // wholly negative range
-    ivalue = QRandomGenerator::bounded(-int(sup), 0);
+    ivalue = rng.bounded(-int(sup), 0);
     QVERIFY(ivalue >= -int(sup));
     QVERIFY(ivalue < 0);
 }
@@ -408,7 +613,9 @@ void tst_QRandomGenerator::boundedQuality()
     Q_STATIC_ASSERT(FailureThreshold > AcceptableThreshold);
 
     QFETCH(uint, control);
-    setRNGControl(control);
+    if (control & RandomDataMask)
+        return;
+    RandomGenerator rng(control);
 
     int histogram[Bound];
     memset(histogram, 0, sizeof(histogram));
@@ -416,7 +623,7 @@ void tst_QRandomGenerator::boundedQuality()
     {
         // test the quality of the generator
         QVector<quint32> buffer(BufferCount, 0xcdcdcdcd);
-        generate(buffer.begin(), buffer.end(), [] { return QRandomGenerator::bounded(Bound); });
+        generate(buffer.begin(), buffer.end(), [&] { return rng.bounded(Bound); });
 
         for (quint32 value : qAsConst(buffer)) {
             QVERIFY(value < Bound);
@@ -442,24 +649,26 @@ void tst_QRandomGenerator::boundedQuality()
 void tst_QRandomGenerator::generateReal()
 {
     QFETCH(uint, control);
-    setRNGControl(control);
+    RandomGenerator rng(control);
 
     for (int i = 0; i < 4; ++i) {
-        QVERIFY_3TIMES([] {
-            qreal value = QRandomGenerator::generateDouble();
+        QVERIFY_3TIMES([&] {
+            qreal value = rng.generateDouble();
             return value >= 0 && value < 1 && value != RandomValueFP;
         }());
     }
 
     // and should hopefully be different from repeated calls
     for (int i = 0; i < 4; ++i)
-        QVERIFY_3TIMES(QRandomGenerator::generateDouble() != QRandomGenerator::generateDouble());
+        QVERIFY_3TIMES(rng.generateDouble() != rng.generateDouble());
 }
 
 void tst_QRandomGenerator::qualityReal()
 {
     QFETCH(uint, control);
-    setRNGControl(control);
+    if (control & RandomDataMask)
+        return;
+    RandomGenerator rng(control);
 
     enum {
         SampleSize = 160,
@@ -475,7 +684,7 @@ void tst_QRandomGenerator::qualityReal()
     };
 
     double data[SampleSize];
-    std::generate(std::begin(data), std::end(data), &QRandomGenerator::generateDouble);
+    std::generate(std::begin(data), std::end(data), [&rng] { return rng.generateDouble(); });
 
     int aboveHalf = 0;
     int belowOneEighth = 0;
@@ -504,12 +713,22 @@ void tst_QRandomGenerator::qualityReal()
 
 template <typename Engine> void seedStdRandomEngine()
 {
-    QRandomGenerator rd;
-    Engine e(rd);
-    QVERIFY_3TIMES(e() != 0);
+    {
+        QRandomGenerator &rd = *QRandomGenerator::system();
+        Engine e(rd);
+        QVERIFY_3TIMES(e() != 0);
+
+        e.seed(rd);
+        QVERIFY_3TIMES(e() != 0);
+    }
+    {
+        QRandomGenerator64 &rd = *QRandomGenerator64::system();
+        Engine e(rd);
+        QVERIFY_3TIMES(e() != 0);
 
-    e.seed(rd);
-    QVERIFY_3TIMES(e() != 0);
+        e.seed(rd);
+        QVERIFY_3TIMES(e() != 0);
+    }
 }
 
 void tst_QRandomGenerator::seedStdRandomEngines()
@@ -534,12 +753,16 @@ void tst_QRandomGenerator::stdUniformIntDistribution_data()
     QTest::addColumn<uint>("control");
     QTest::addColumn<quint32>("max");
 
-    auto newRow = [](quint32 max) {
-        QTest::addRow("default:%u", max) << 0U << max;
-        QTest::addRow("system:%u", max) << uint(SkipHWRNG) << max;
-    #ifdef HAVE_FALLBACK_ENGINE
-        QTest::addRow("fallback:%u", max) << uint(SkipHWRNG | SkipSystemRNG) << max;
-    #endif
+    auto newRow = [&](quint32 max) {
+#ifdef QT_BUILD_INTERNAL
+        if (qt_has_hwrng())
+            QTest::addRow("hwrng:%u", max) << uint(UseSystemRNG) << max;
+        QTest::addRow("system:%u", max) << uint(UseSystemRNG | SkipHWRNG) << max;
+#  ifdef HAVE_FALLBACK_ENGINE
+        QTest::addRow("system-fallback:%u", max) << uint(UseSystemRNG | SkipHWRNG | SkipSystemRNG) << max;
+#  endif
+#endif
+        QTest::addRow("global:%u", max) << 0U << max;
     };
 
     // useless: we can only generate zeroes:
@@ -554,7 +777,7 @@ void tst_QRandomGenerator::stdUniformIntDistribution()
 {
     QFETCH(uint, control);
     QFETCH(quint32, max);
-    setRNGControl(control & (SkipHWRNG|SkipSystemRNG));
+    RandomGenerator rng(control);
 
     {
         QRandomGenerator rd;
@@ -622,21 +845,19 @@ void tst_QRandomGenerator::stdGenerateCanonical()
     QSKIP("MSVC 2013's std::generate_canonical is broken");
 #else
     QFETCH(uint, control);
-    setRNGControl(control);
+    RandomGenerator rng(control);
 
     for (int i = 0; i < 4; ++i) {
-        QVERIFY_3TIMES([] {
-            QRandomGenerator rd;
-            qreal value = std::generate_canonical<qreal COMMA 32>(rd);
+        QVERIFY_3TIMES([&] {
+            qreal value = std::generate_canonical<qreal COMMA 32>(rng);
             return value > 0 && value < 1 && value != RandomValueFP;
         }());
     }
 
     // and should hopefully be different from repeated calls
-    QRandomGenerator rd;
     for (int i = 0; i < 4; ++i)
-        QVERIFY_3TIMES(std::generate_canonical<qreal COMMA 32>(rd) !=
-                std::generate_canonical<qreal COMMA 32>(rd));
+        QVERIFY_3TIMES(std::generate_canonical<qreal COMMA 32>(rng) !=
+                std::generate_canonical<qreal COMMA 32>(rng));
 #endif
 }
 
@@ -650,12 +871,16 @@ void tst_QRandomGenerator::stdUniformRealDistribution_data()
     QTest::addColumn<double>("min");
     QTest::addColumn<double>("sup");
 
-    auto newRow = [](double min, double sup) {
-        QTest::addRow("default:%g-%g", min, sup) << 0U << min << sup;
-        QTest::addRow("system:%g-%g", min, sup) << uint(SkipHWRNG) << min << sup;
-    #ifdef HAVE_FALLBACK_ENGINE
-        QTest::addRow("fallback:%g-%g", min, sup) << uint(SkipHWRNG | SkipSystemRNG) << min << sup;
-    #endif
+    auto newRow = [&](double min, double sup) {
+#ifdef QT_BUILD_INTERNAL
+        if (qt_has_hwrng())
+            QTest::addRow("hwrng:%g-%g", min, sup) << uint(UseSystemRNG) << min << sup;
+        QTest::addRow("system:%g-%g", min, sup) << uint(UseSystemRNG | SkipHWRNG) << min << sup;
+#  ifdef HAVE_FALLBACK_ENGINE
+        QTest::addRow("system-fallback:%g-%g", min, sup) << uint(UseSystemRNG | SkipHWRNG | SkipSystemRNG) << min << sup;
+#  endif
+#endif
+        QTest::addRow("global:%g-%g", min, sup) << 0U << min << sup;
     };
 
     newRow(0, 0);   // useless: we can only generate zeroes
@@ -671,7 +896,7 @@ void tst_QRandomGenerator::stdUniformRealDistribution()
     QFETCH(uint, control);
     QFETCH(double, min);
     QFETCH(double, sup);
-    setRNGControl(control & (SkipHWRNG|SkipSystemRNG));
+    RandomGenerator rng(control & (SkipHWRNG|SkipSystemRNG|UseSystemRNG));
 
     {
         QRandomGenerator rd;
@@ -696,13 +921,9 @@ void tst_QRandomGenerator::stdUniformRealDistribution()
     }
 }
 
-void tst_QRandomGenerator::stdRandomDistributions()
+template <typename Generator> void stdRandomDistributions_template()
 {
-    // just a compile check for some of the distributions, besides
-    // std::uniform_int_distribution and std::uniform_real_distribution (tested
-    // above)
-
-    QRandomGenerator rd;
+    Generator rd;
 
     std::bernoulli_distribution()(rd);
 
@@ -724,6 +945,16 @@ void tst_QRandomGenerator::stdRandomDistributions()
     }
 }
 
+void tst_QRandomGenerator::stdRandomDistributions()
+{
+    // just a compile check for some of the distributions, besides
+    // std::uniform_int_distribution and std::uniform_real_distribution (tested
+    // above)
+
+    stdRandomDistributions_template<QRandomGenerator>();
+    stdRandomDistributions_template<QRandomGenerator64>();
+}
+
 QTEST_APPLESS_MAIN(tst_QRandomGenerator)
 
 #include "tst_qrandomgenerator.moc"
diff --git a/tests/auto/corelib/io/largefile/tst_largefile.cpp b/tests/auto/corelib/io/largefile/tst_largefile.cpp
index 5975303ca6..2d13e6166d 100644
--- a/tests/auto/corelib/io/largefile/tst_largefile.cpp
+++ b/tests/auto/corelib/io/largefile/tst_largefile.cpp
@@ -31,6 +31,7 @@
 #include <QtAlgorithms>
 #include <QFile>
 #include <QFileInfo>
+#include <QRandomGenerator>
 #include <qplatformdefs.h>
 
 #include <QDebug>
@@ -174,8 +175,7 @@ static inline QByteArray generateDataBlock(int blockSize, QString text, qint64 u
 
     static qint64 counter = 0;
 
-    qint64 randomBits = ((qint64)qrand() << 32)
-            | ((qint64)qrand() & 0x00000000ffffffff);
+    qint64 randomBits = QRandomGenerator::global()->generate64();
 
     appendRaw(block, randomBits);
     appendRaw(block, userBits);
diff --git a/tests/auto/corelib/io/qfile/tst_qfile.cpp b/tests/auto/corelib/io/qfile/tst_qfile.cpp
index 9026864b12..c173a87a41 100644
--- a/tests/auto/corelib/io/qfile/tst_qfile.cpp
+++ b/tests/auto/corelib/io/qfile/tst_qfile.cpp
@@ -405,6 +405,8 @@ void tst_QFile::cleanup()
                 QDir remainingDir(absoluteFilePath);
                 QVERIFY2(remainingDir.removeRecursively(), qPrintable(absoluteFilePath));
             } else {
+                if (!(QFile::permissions(absoluteFilePath) & QFile::WriteUser))
+                    QVERIFY2(QFile::setPermissions(absoluteFilePath, QFile::WriteUser), qPrintable(absoluteFilePath));
                 QVERIFY2(QFile::remove(absoluteFilePath), qPrintable(absoluteFilePath));
             }
         }
@@ -443,8 +445,6 @@ void tst_QFile::initTestCase()
     m_stdinProcessDir = QFINDTESTDATA("stdinprocess");
     QVERIFY(!m_stdinProcessDir.isEmpty());
 #endif
-    m_testSourceFile = QFINDTESTDATA("tst_qfile.cpp");
-    QVERIFY(!m_testSourceFile.isEmpty());
     m_testLogFile = QFINDTESTDATA("testlog.txt");
     QVERIFY(!m_testLogFile.isEmpty());
     m_dosFile = QFINDTESTDATA("dosfile.txt");
@@ -457,15 +457,19 @@ void tst_QFile::initTestCase()
     QVERIFY(!m_twoDotsFile.isEmpty());
 
 #ifndef BUILTIN_TESTDATA
+    m_testSourceFile = QFINDTESTDATA("tst_qfile.cpp");
+    QVERIFY(!m_testSourceFile.isEmpty());
     m_testFile = QFINDTESTDATA("testfile.txt");
     QVERIFY(!m_testFile.isEmpty());
+    m_resourcesDir = QFINDTESTDATA("resources");
+    QVERIFY(!m_resourcesDir.isEmpty());
 #else
     m_dataDir = QEXTRACTTESTDATA("/");
     QVERIFY2(!m_dataDir.isNull(), qPrintable("Could not extract test data"));
     m_testFile = m_dataDir->path() + "/testfile.txt";
+    m_testSourceFile = m_dataDir->path() + "/tst_qfile.cpp";
+    m_resourcesDir = m_dataDir->path() + "/resources";
 #endif
-    m_resourcesDir = QFINDTESTDATA("resources");
-    QVERIFY(!m_resourcesDir.isEmpty());
     m_noEndOfLineFile = QFINDTESTDATA("noendofline.txt");
     QVERIFY(!m_noEndOfLineFile.isEmpty());
 
@@ -2189,12 +2193,20 @@ public:
         if (fileName.startsWith(":!")) {
             QDir dir;
 
-            QString realFile = QFINDTESTDATA(fileName.mid(2));
+#ifndef BUILTIN_TESTDATA
+            const QString realFile = QFINDTESTDATA(fileName.mid(2));
+#else
+            const QString realFile = m_dataDir->filePath(fileName.mid(2));
+#endif
             if (dir.exists(realFile))
                 return new QFSFileEngine(realFile);
         }
         return 0;
     }
+
+#ifdef BUILTIN_TESTDATA
+    QSharedPointer<QTemporaryDir> m_dataDir;
+#endif
 };
 #endif
 
@@ -2203,6 +2215,9 @@ void tst_QFile::useQFileInAFileHandler()
 {
     // This test should not dead-lock
     MyRecursiveHandler handler;
+#ifdef BUILTIN_TESTDATA
+    handler.m_dataDir = m_dataDir;
+#endif
     QFile file(":!tst_qfile.cpp");
     QVERIFY(file.exists());
 }
diff --git a/tests/auto/corelib/io/qstandardpaths/BLACKLIST b/tests/auto/corelib/io/qstandardpaths/BLACKLIST
new file mode 100644
index 0000000000..d5ee9650cd
--- /dev/null
+++ b/tests/auto/corelib/io/qstandardpaths/BLACKLIST
@@ -0,0 +1,3 @@
+[testFindExecutable]
+# QTBUG-64404
+b2qt 64bit
diff --git a/tests/auto/corelib/io/qtemporarydir/qtemporarydir.pro b/tests/auto/corelib/io/qtemporarydir/qtemporarydir.pro
index 351e263093..5908648378 100644
--- a/tests/auto/corelib/io/qtemporarydir/qtemporarydir.pro
+++ b/tests/auto/corelib/io/qtemporarydir/qtemporarydir.pro
@@ -4,4 +4,4 @@ SOURCES       += tst_qtemporarydir.cpp
 INCLUDEPATH += ../../../../shared/
 HEADERS += ../../../../shared/emulationdetector.h
 
-QT = core testlib
+QT = core testlib testlib-private
diff --git a/tests/auto/corelib/io/qtemporarydir/tst_qtemporarydir.cpp b/tests/auto/corelib/io/qtemporarydir/tst_qtemporarydir.cpp
index fcd9133099..76462be376 100644
--- a/tests/auto/corelib/io/qtemporarydir/tst_qtemporarydir.cpp
+++ b/tests/auto/corelib/io/qtemporarydir/tst_qtemporarydir.cpp
@@ -35,6 +35,7 @@
 #include <qdir.h>
 #include <qset.h>
 #include <qtextcodec.h>
+#include <QtTest/private/qtesthelpers_p.h>
 #ifdef Q_OS_WIN
 # include <windows.h>
 #endif
@@ -112,16 +113,6 @@ void tst_QTemporaryDir::getSetCheck()
     QCOMPARE(true, obj1.autoRemove());
 }
 
-static inline bool canHandleUnicodeFileNames()
-{
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
-    return true;
-#else
-    // Check for UTF-8 by converting the Euro symbol (see tst_utf8)
-    return QFile::encodeName(QString(QChar(0x20AC))) == QByteArrayLiteral("\342\202\254");
-#endif
-}
-
 static QString hanTestText()
 {
     QString text;
@@ -159,7 +150,7 @@ void tst_QTemporaryDir::fileTemplate_data()
     QTest::newRow("4Xsuffix") << "qt_XXXXXX_XXXX" << "qt_" << "_XXXX";
     QTest::newRow("4Xprefix") << "qt_XXXX" << "qt_XXXX" << "";
     QTest::newRow("5Xprefix") << "qt_XXXXX" << "qt_XXXXX" << "";
-    if (canHandleUnicodeFileNames()) {
+    if (QTestPrivate::canHandleUnicodeFileNames()) {
         // Test Umlauts (contained in Latin1)
         QString prefix = "qt_" + umlautTestText();
         QTest::newRow("Umlauts") << (prefix + "XXXXXX") << prefix << "";
diff --git a/tests/auto/corelib/io/qtemporaryfile/qtemporaryfile.pro b/tests/auto/corelib/io/qtemporaryfile/qtemporaryfile.pro
index a89e5c66ff..e17cb05cd8 100644
--- a/tests/auto/corelib/io/qtemporaryfile/qtemporaryfile.pro
+++ b/tests/auto/corelib/io/qtemporaryfile/qtemporaryfile.pro
@@ -1,6 +1,6 @@
 CONFIG += testcase
 TARGET = tst_qtemporaryfile
-QT = core testlib
+QT = core testlib testlib-private
 SOURCES = tst_qtemporaryfile.cpp
 TESTDATA += tst_qtemporaryfile.cpp
 RESOURCES += qtemporaryfile.qrc
diff --git a/tests/auto/corelib/io/qtemporaryfile/tst_qtemporaryfile.cpp b/tests/auto/corelib/io/qtemporaryfile/tst_qtemporaryfile.cpp
index 11c24ca86f..f3ce902bbd 100644
--- a/tests/auto/corelib/io/qtemporaryfile/tst_qtemporaryfile.cpp
+++ b/tests/auto/corelib/io/qtemporaryfile/tst_qtemporaryfile.cpp
@@ -38,6 +38,8 @@
 #include <qset.h>
 #include <qtextcodec.h>
 
+#include <QtTest/private/qtesthelpers_p.h>
+
 #if defined(Q_OS_WIN)
 # include <windows.h>
 #endif
@@ -143,16 +145,6 @@ void tst_QTemporaryFile::getSetCheck()
     QCOMPARE(true, obj1.autoRemove());
 }
 
-static inline bool canHandleUnicodeFileNames()
-{
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
-    return true;
-#else
-    // Check for UTF-8 by converting the Euro symbol (see tst_utf8)
-    return QFile::encodeName(QString(QChar(0x20AC))) == QByteArrayLiteral("\342\202\254");
-#endif
-}
-
 static QString hanTestText()
 {
     QString text;
@@ -201,7 +193,7 @@ void tst_QTemporaryFile::fileTemplate_data()
     QTest::newRow("set template, with xxx") << "" << "qt_" << ".xxx" << "qt_XXXXXX.xxx";
     QTest::newRow("set template, with >6 X's") << "" << "qt_" << ".xxx" << "qt_XXXXXXXXXXXXXX.xxx";
     QTest::newRow("set template, with >6 X's, no suffix") << "" << "qt_" << "" << "qt_XXXXXXXXXXXXXX";
-    if (canHandleUnicodeFileNames()) {
+    if (QTestPrivate::canHandleUnicodeFileNames()) {
         // Test Umlauts (contained in Latin1)
         QString prefix = "qt_" + umlautTestText();
         QTest::newRow("Umlauts") << (prefix + "XXXXXX") << prefix << QString() << QString();
@@ -824,7 +816,7 @@ void tst_QTemporaryFile::QTBUG_4796_data()
     QTest::newRow("XXXXXXbla") << QString() << QString("bla") << true;
     QTest::newRow("does-not-exist/qt_temp.XXXXXX") << QString("does-not-exist/qt_temp") << QString() << false;
 
-    if (canHandleUnicodeFileNames()) {
+    if (QTestPrivate::canHandleUnicodeFileNames()) {
         QTest::newRow("XXXXXX<unicode>") << QString() << unicode << true;
         QTest::newRow("<unicode>XXXXXX") << unicode << QString() << true;
         QTest::newRow("<unicode>XXXXXX<unicode>") << unicode << unicode << true;
diff --git a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
index 3a52c684d0..5ecdd92228 100644
--- a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
+++ b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
@@ -2362,8 +2362,8 @@ void tst_QObject::testUserData()
 
     // Randomize the table a bit
     for (int i=0; i<100; ++i) {
-        int p1 = rand() % USER_DATA_COUNT;
-        int p2 = rand() % USER_DATA_COUNT;
+        int p1 = QRandomGenerator::global()->bounded(USER_DATA_COUNT);
+        int p2 = QRandomGenerator::global()->bounded(USER_DATA_COUNT);
 
         int tmp = user_data_ids[p1];
         user_data_ids[p1] = user_data_ids[p2];
diff --git a/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.cpp b/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.cpp
index 8a46bc1c55..8883b6360f 100644
--- a/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.cpp
+++ b/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.cpp
@@ -115,7 +115,6 @@ Q_CONSTRUCTOR_FUNCTION(initializeLang)
 
 static QString seedAndTemplate()
 {
-    qsrand(QDateTime::currentSecsSinceEpoch());
     return QDir::tempPath() + "/tst_qmimedatabase-XXXXXX";
 }
 
diff --git a/tests/auto/corelib/plugin/quuid/testProcessUniqueness/main.cpp b/tests/auto/corelib/plugin/quuid/testProcessUniqueness/main.cpp
index daf9b1579a..d1e138d8eb 100644
--- a/tests/auto/corelib/plugin/quuid/testProcessUniqueness/main.cpp
+++ b/tests/auto/corelib/plugin/quuid/testProcessUniqueness/main.cpp
@@ -35,9 +35,6 @@ int main(int argc, char **argv)
     Q_UNUSED(argc)
     Q_UNUSED(argv)
 
-    // First, break QUuid.
-    qrand();
-
     // Now print a few uuids.
     printf("%s", qPrintable(QUuid::createUuid().toString()));
     printf("%s", qPrintable(QUuid::createUuid().toString()));
diff --git a/tests/auto/corelib/thread/qfuture/tst_qfuture.cpp b/tests/auto/corelib/thread/qfuture/tst_qfuture.cpp
index 37b052bf1d..58bebe19ac 100644
--- a/tests/auto/corelib/thread/qfuture/tst_qfuture.cpp
+++ b/tests/auto/corelib/thread/qfuture/tst_qfuture.cpp
@@ -36,6 +36,7 @@
 #include <qresultstore.h>
 #include <qthreadpool.h>
 #include <qexception.h>
+#include <qrandom.h>
 #include <private/qfutureinterface_p.h>
 
 // COM interface macro.
@@ -1456,7 +1457,7 @@ void tst_QFuture::nonGlobalThreadPool()
 
         void run() Q_DECL_OVERRIDE
         {
-            const int ms = 100 + (qrand() % 100 - 100/2);
+            const int ms = 100 + (QRandomGenerator::global()->bounded(100) - 100/2);
             QThread::msleep(ms);
             reportResult(Answer);
             reportFinished();
diff --git a/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp b/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp
index e13c2894af..72299402f0 100644
--- a/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp
+++ b/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp
@@ -37,6 +37,7 @@
 #include <qalgorithms.h>
 #include <QStringList>
 #include <QString>
+#include <QRandomGenerator>
 #include <QVector>
 
 #define Q_TEST_PERFORMANCE 0
@@ -133,7 +134,7 @@ QVector<DataType> generateData(QString dataSetType, const int length)
     QVector<DataType> container;
     if (dataSetType == "Random") {
         for (int i = 0; i < length; ++i)
-            container.append(rand());
+            container.append(QRandomGenerator::global()->generate());
     } else if (dataSetType == "Ascending") {
         for (int i = 0; i < length; ++i)
             container.append(i);
@@ -1082,12 +1083,12 @@ void tst_QAlgorithms::popCount_data_impl(size_t sizeof_T_Int)
     // and some random ones:
     if (sizeof_T_Int >= 8)
         for (size_t i = 0; i < 1000; ++i) {
-            const quint64 input = quint64(qrand()) << 32 | quint32(qrand());
+            const quint64 input = QRandomGenerator::global()->generate64();
             QTest::addRow("0x%016llx", input) << input << bitsSetInInt64(input);
         }
         else if (sizeof_T_Int >= 2)
             for (size_t i = 0; i < 1000 ; ++i) {
-                const quint32 input = qrand();
+                const quint32 input = QRandomGenerator::global()->generate();
                 if (sizeof_T_Int >= 4)
                     QTest::addRow("0x%08x", input) << quint64(input) << bitsSetInInt(input);
                 else
@@ -1129,7 +1130,7 @@ void tst_QAlgorithms::countTrailing_data_impl(size_t sizeof_T_Int)
     // and some random ones:
     for (uint i = 0; i < sizeof_T_Int*8; ++i) {
         for (uint j = 0; j < sizeof_T_Int*3; ++j) {  // 3 is arbitrary
-            const quint64 r = quint64(qrand()) << 32 | quint32(qrand());
+            const quint64 r = QRandomGenerator::global()->generate64();
             const quint64 b = Q_UINT64_C(1) << i;
             const quint64 mask = ((~(b-1)) ^ b) & type_mask;
             const quint64 input = (r&mask) | b;
@@ -1166,7 +1167,7 @@ void tst_QAlgorithms::countLeading_data_impl(size_t sizeof_T_Int)
     // and some random ones:
     for (uint i = 0; i < sizeof_T_Int*8; ++i) {
         for (uint j = 0; j < sizeof_T_Int*3; ++j) {  // 3 is arbitrary
-            const quint64 r = quint64(qrand()) << 32 | quint32(qrand());
+            const quint64 r = QRandomGenerator::global()->generate64();
             const quint64 b = Q_UINT64_C(1) << i;
             const quint64 mask = b-1;
             const quint64 input = (r&mask) | b;
diff --git a/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp b/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp
index 442d4d089c..e1dcdb8407 100644
--- a/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp
+++ b/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp
@@ -1884,7 +1884,7 @@ class StrongThread: public QThread
 protected:
     void run()
     {
-        usleep(rand() % 2000);
+        usleep(QRandomGenerator::global()->bounded(2000));
         ptr->ref();
         ptr.clear();
     }
@@ -1897,7 +1897,7 @@ class WeakThread: public QThread
 protected:
     void run()
     {
-        usleep(rand() % 2000);
+        usleep(QRandomGenerator::global()->bounded(2000));
         QSharedPointer<ThreadData> ptr = weak;
         if (ptr)
             ptr->ref();
@@ -1959,7 +1959,6 @@ void tst_QSharedPointer::threadStressTest()
 
         base.clear();
 
-        srand(time(NULL));
         // start threads
         for (int i = 0; i < allThreads.count(); ++i)
             if (allThreads[i]) allThreads[i]->start();