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

 Conflicts:
	src/gui/painting/qdrawhelper.cpp

Change-Id: I4916e07b635e1d3830e9b46ef7914f99bec3098e

14 files changed, 241 insertions, 87 deletions

diff --git a/tests/auto/corelib/global/qlogging/BLACKLIST b/tests/auto/corelib/global/qlogging/BLACKLIST
index 1dcee92361..e474064f54 100644
--- a/tests/auto/corelib/global/qlogging/BLACKLIST
+++ b/tests/auto/corelib/global/qlogging/BLACKLIST
@@ -1,3 +1,7 @@
+[qMessagePattern:backtrace]
+# QTBUG-63915
+b2qt 64bit
+
 [qMessagePattern:backtrace depth,separator]
 # QTBUG-63915
 b2qt 64bit
diff --git a/tests/auto/corelib/io/qstandardpaths/BLACKLIST b/tests/auto/corelib/io/qstandardpaths/BLACKLIST
deleted file mode 100644
index d5ee9650cd..0000000000
--- a/tests/auto/corelib/io/qstandardpaths/BLACKLIST
+++ /dev/null
@@ -1,3 +0,0 @@
-[testFindExecutable]
-# QTBUG-64404
-b2qt 64bit
diff --git a/tests/auto/corelib/io/qstandardpaths/qstandardpaths.pro b/tests/auto/corelib/io/qstandardpaths/qstandardpaths.pro
index 9fd7047405..44b1ce8dd8 100644
--- a/tests/auto/corelib/io/qstandardpaths/qstandardpaths.pro
+++ b/tests/auto/corelib/io/qstandardpaths/qstandardpaths.pro
@@ -5,3 +5,6 @@ INCLUDEPATH += ../../../../shared/
 HEADERS += ../../../../shared/emulationdetector.h
 SOURCES = tst_qstandardpaths.cpp
 TESTDATA += tst_qstandardpaths.cpp qstandardpaths.pro
+
+# QTBUG-64404
+boot2qt: DEFINES+=SKIP_FINDEXECUTABLE
diff --git a/tests/auto/corelib/io/qstandardpaths/tst_qstandardpaths.cpp b/tests/auto/corelib/io/qstandardpaths/tst_qstandardpaths.cpp
index 5cb130f631..1379c788d1 100644
--- a/tests/auto/corelib/io/qstandardpaths/tst_qstandardpaths.cpp
+++ b/tests/auto/corelib/io/qstandardpaths/tst_qstandardpaths.cpp
@@ -371,6 +371,12 @@ static inline QFileInfo findSh()
 
 void tst_qstandardpaths::testFindExecutable_data()
 {
+#ifdef SKIP_FINDEXECUTABLE
+    // Test needs to be skipped or Q_ASSERT below will cancel the test
+    // and report FAIL regardless of BLACKLIST contents
+    QSKIP("QTBUG-64404");
+#endif
+
     QTest::addColumn<QString>("directory");
     QTest::addColumn<QString>("needle");
     QTest::addColumn<QString>("expected");
diff --git a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
index 936cbd3894..68a92ebcc3 100644
--- a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
+++ b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
@@ -6727,16 +6727,16 @@ void tst_QObject::connectWarnings()
     r1.reset();
 
     QTest::ignoreMessage(QtWarningMsg, "QObject::connect(SenderObject, ReceiverObject): invalid null parameter");
-    connect(nullptr, &SubSender::signal1, &r1, &ReceiverObject::slot1);
+    connect(static_cast<const SenderObject *>(nullptr), &SubSender::signal1, &r1, &ReceiverObject::slot1);
 
     QTest::ignoreMessage(QtWarningMsg, "QObject::connect(SubSender, Unknown): invalid null parameter");
-    connect(&sub, &SubSender::signal1, nullptr, &ReceiverObject::slot1);
+    connect(&sub, &SubSender::signal1, static_cast<ReceiverObject *>(nullptr), &ReceiverObject::slot1);
 
     QTest::ignoreMessage(QtWarningMsg, "QObject::connect(SenderObject, ReceiverObject): invalid null parameter");
-    connect(nullptr, &SenderObject::signal1, &r1, &ReceiverObject::slot1);
+    connect(static_cast<const SenderObject *>(nullptr), &SenderObject::signal1, &r1, &ReceiverObject::slot1);
 
     QTest::ignoreMessage(QtWarningMsg, "QObject::connect(SenderObject, Unknown): invalid null parameter");
-    connect(&obj, &SenderObject::signal1, nullptr, &ReceiverObject::slot1);
+    connect(&obj, &SenderObject::signal1, static_cast<ReceiverObject *>(nullptr), &ReceiverObject::slot1);
 }
 
 struct QmlReceiver : public QtPrivate::QSlotObjectBase
diff --git a/tests/auto/corelib/plugin/qpluginloader/machtest/machtest.pri b/tests/auto/corelib/plugin/qpluginloader/machtest/machtest.pri
new file mode 100644
index 0000000000..ca4a0a07e9
--- /dev/null
+++ b/tests/auto/corelib/plugin/qpluginloader/machtest/machtest.pri
@@ -0,0 +1,13 @@
+TEMPLATE = aux
+
+# Needs explicit load()ing due to aux template. Relies on QT being non-empty.
+load(qt)
+
+goodlib.target = good.$${QMAKE_APPLE_DEVICE_ARCHS}.dylib
+goodlib.commands = $(CXX) $(CXXFLAGS) -shared -o $@ -I$(INCPATH) $<
+goodlib.depends += $$PWD/../fakeplugin.cpp
+
+all.depends += goodlib
+
+QMAKE_EXTRA_TARGETS += goodlib all
+QMAKE_CLEAN += $$goodlib.target
diff --git a/tests/auto/corelib/plugin/qpluginloader/machtest/machtest.pro b/tests/auto/corelib/plugin/qpluginloader/machtest/machtest.pro
index 7f7caa7f76..795dd89895 100644
--- a/tests/auto/corelib/plugin/qpluginloader/machtest/machtest.pro
+++ b/tests/auto/corelib/plugin/qpluginloader/machtest/machtest.pro
@@ -1,64 +1,15 @@
-TEMPLATE = aux
-OTHER_FILES += \
-    ppcconverter.pl \
-    generate-bad.pl
+TEMPLATE = subdirs
 
-# Needs explicit load()ing due to aux template. Relies on QT being non-empty.
-load(qt)
-
-i386_d.target = good.i386.dylib
-i386_d.depends = EXPORT_VALID_ARCHS=i386
-i386.target = good.i386.dylib
-i386.commands = $(CXX) $(CXXFLAGS) -shared -o $@ -I$(INCPATH) $<
-i386.depends += $$PWD/../fakeplugin.cpp
-
-x86_64_d.target = good.x86_64.dylib
-x86_64_d.depends = EXPORT_VALID_ARCHS=x86_64
-x86_64.target = good.x86_64.dylib
-x86_64.commands = $(CXX) $(CXXFLAGS) -shared -o $@ -I$(INCPATH) $<
-x86_64.depends += $$PWD/../fakeplugin.cpp
-
-# Current Mac OS X toolchains have no compiler for PPC anymore
-# So we fake it by converting an x86-64 binary to (little-endian!) PPC64
-ppc64.target = good.ppc64.dylib
-ppc64.commands = $$PWD/ppcconverter.pl $< $@
-ppc64.depends = x86_64 $$PWD/ppcconverter.pl
-
-# Generate a fat binary with three architectures
-fat_all.target = good.fat.all.dylib
-fat_all.commands = lipo -create -output $@ \
-                              -arch ppc64 $$ppc64.target \
-                              -arch i386 $$i386.target \
-                              -arch x86_64 $$x86_64.target
-fat_all.depends += i386 x86_64 ppc64
-
-fat_no_i386.target = good.fat.no-i386.dylib
-fat_no_i386.commands = lipo -create -output $@ -arch x86_64 $$x86_64.target -arch ppc64 $$ppc64.target
-fat_no_i386.depends += x86_64 ppc64
-
-fat_no_x86_64.target = good.fat.no-x86_64.dylib
-fat_no_x86_64.commands = lipo -create -output $@ -arch i386 $$i386.target -arch ppc64 $$ppc64.target
-fat_no_x86_64.depends += i386 ppc64
-
-fat_stub_i386.target = good.fat.stub-i386.dylib
-fat_stub_i386.commands = lipo -create -output $@ -arch ppc64 $$ppc64.target -arch_blank i386
-fat_stub_i386.depends += x86_64 ppc64
-
-fat_stub_x86_64.target = good.fat.stub-x86_64.dylib
-fat_stub_x86_64.commands = lipo -create -output $@ -arch ppc64 $$ppc64.target -arch_blank x86_64
-fat_stub_x86_64.depends += i386 ppc64
-
-bad.commands = $$PWD/generate-bad.pl
-bad.depends += $$PWD/generate-bad.pl
-
-MYTARGETS = $$fat_all.depends fat_all fat_no_x86_64 fat_no_i386 \
-            fat_stub_i386 fat_stub_x86_64 bad
-all.depends += $$MYTARGETS
-QMAKE_EXTRA_TARGETS += i386_d x86_64_d $$MYTARGETS all
-
-QMAKE_CLEAN += $$i386.target $$x86_64.target $$ppc64.target $$fat_all.target \
-            $$fat_no_i386.target $$fat_no_x86_64.target \
-            $$fat_stub_i386.target $$fat_stub_x86_64.target \
-            "bad*.dylib"
+SUBDIRS = \
+    machtest_i386.pro \
+    machtest_x86_64.pro \
+    machtest_ppc64.pro \
+    machtest_fat.pro
 
+machtest_fat-pro.depends = \
+    machtest_i386.pro \
+    machtest_x86_64.pro \
+    machtest_ppc64.pro
 
+machtest_ppc64-pro.depends = \
+    machtest_x86_64.pro
diff --git a/tests/auto/corelib/plugin/qpluginloader/machtest/machtest_fat.pro b/tests/auto/corelib/plugin/qpluginloader/machtest/machtest_fat.pro
new file mode 100644
index 0000000000..8daa343e2b
--- /dev/null
+++ b/tests/auto/corelib/plugin/qpluginloader/machtest/machtest_fat.pro
@@ -0,0 +1,41 @@
+TEMPLATE = aux
+OTHER_FILES += generate-bad.pl
+
+# Needs explicit load()ing due to aux template. Relies on QT being non-empty.
+load(qt)
+
+# Generate a fat binary with three architectures
+fat_all.target = good.fat.all.dylib
+fat_all.commands = lipo -create -output $@ \
+                              -arch ppc64 good.ppc64.dylib \
+                              -arch i386 good.i386.dylib \
+                              -arch x86_64 good.x86_64.dylib
+fat_all.depends += good.i386.dylib good.x86_64.dylib good.ppc64.dylib
+
+fat_no_i386.target = good.fat.no-i386.dylib
+fat_no_i386.commands = lipo -create -output $@ -arch x86_64 good.x86_64.dylib -arch ppc64 good.ppc64.dylib
+fat_no_i386.depends += good.x86_64.dylib good.ppc64.dylib
+
+fat_no_x86_64.target = good.fat.no-x86_64.dylib
+fat_no_x86_64.commands = lipo -create -output $@ -arch i386 good.i386.dylib -arch ppc64 good.ppc64.dylib
+fat_no_x86_64.depends += good.i386.dylib good.ppc64.dylib
+
+fat_stub_i386.target = good.fat.stub-i386.dylib
+fat_stub_i386.commands = lipo -create -output $@ -arch ppc64 good.ppc64.dylib -arch_blank i386
+fat_stub_i386.depends += good.x86_64.dylib good.ppc64.dylib
+
+fat_stub_x86_64.target = good.fat.stub-x86_64.dylib
+fat_stub_x86_64.commands = lipo -create -output $@ -arch ppc64 good.ppc64.dylib -arch_blank x86_64
+fat_stub_x86_64.depends += good.i386.dylib good.ppc64.dylib
+
+bad.commands = $$PWD/generate-bad.pl
+bad.depends += $$PWD/generate-bad.pl
+
+MYTARGETS = $$fat_all.depends fat_all fat_no_x86_64 fat_no_i386 \
+            fat_stub_i386 fat_stub_x86_64 bad
+all.depends += $$MYTARGETS
+QMAKE_EXTRA_TARGETS += $$MYTARGETS all
+
+QMAKE_CLEAN += $$fat_all.target $$fat_no_i386.target $$fat_no_x86_64.target \
+            $$fat_stub_i386.target $$fat_stub_x86_64.target \
+            "bad*.dylib"
diff --git a/tests/auto/corelib/plugin/qpluginloader/machtest/machtest_i386.pro b/tests/auto/corelib/plugin/qpluginloader/machtest/machtest_i386.pro
new file mode 100644
index 0000000000..bfb2e0930c
--- /dev/null
+++ b/tests/auto/corelib/plugin/qpluginloader/machtest/machtest_i386.pro
@@ -0,0 +1,3 @@
+QMAKE_APPLE_DEVICE_ARCHS = i386
+include(machtest.pri)
+
diff --git a/tests/auto/corelib/plugin/qpluginloader/machtest/machtest_ppc64.pro b/tests/auto/corelib/plugin/qpluginloader/machtest/machtest_ppc64.pro
new file mode 100644
index 0000000000..a73f97ccc6
--- /dev/null
+++ b/tests/auto/corelib/plugin/qpluginloader/machtest/machtest_ppc64.pro
@@ -0,0 +1,9 @@
+QMAKE_APPLE_DEVICE_ARCHS = ppc64
+include(machtest.pri)
+
+OTHER_FILES += ppcconverter.pl
+
+# Current macOS toolchains have no compiler for PPC anymore
+# So we fake it by converting an x86-64 binary to (little-endian!) PPC64
+goodlib.commands = $$PWD/ppcconverter.pl $< $@
+goodlib.depends = good.x86_64.dylib $$PWD/ppcconverter.pl
diff --git a/tests/auto/corelib/plugin/qpluginloader/machtest/machtest_x86_64.pro b/tests/auto/corelib/plugin/qpluginloader/machtest/machtest_x86_64.pro
new file mode 100644
index 0000000000..9dbae5c4ee
--- /dev/null
+++ b/tests/auto/corelib/plugin/qpluginloader/machtest/machtest_x86_64.pro
@@ -0,0 +1,2 @@
+QMAKE_APPLE_DEVICE_ARCHS = x86_64
+include(machtest.pri)
diff --git a/tests/auto/corelib/serialization/qtextstream/test/test.pro b/tests/auto/corelib/serialization/qtextstream/test/test.pro
index 3dcfa0b414..0f289a5ce1 100644
--- a/tests/auto/corelib/serialization/qtextstream/test/test.pro
+++ b/tests/auto/corelib/serialization/qtextstream/test/test.pro
@@ -3,6 +3,8 @@ TARGET = ../tst_qtextstream
 QT = core network testlib
 SOURCES = ../tst_qtextstream.cpp
 RESOURCES += ../qtextstream.qrc
+INCLUDEPATH += ../../../../../shared/
+HEADERS += ../../../../../shared/emulationdetector.h
 
 win32 {
     CONFIG(debug, debug|release) {
diff --git a/tests/auto/corelib/serialization/qtextstream/tst_qtextstream.cpp b/tests/auto/corelib/serialization/qtextstream/tst_qtextstream.cpp
index 1c1631760b..8bb35554c8 100644
--- a/tests/auto/corelib/serialization/qtextstream/tst_qtextstream.cpp
+++ b/tests/auto/corelib/serialization/qtextstream/tst_qtextstream.cpp
@@ -44,7 +44,7 @@
 # include <QProcess>
 #endif
 #include "../../../network-settings.h"
-
+#include "emulationdetector.h"
 
 QT_BEGIN_NAMESPACE
 template<> struct QMetaTypeId<QIODevice::OpenModeFlag>
@@ -1460,6 +1460,9 @@ void tst_QTextStream::pos2()
 // ------------------------------------------------------------------------------
 void tst_QTextStream::pos3LargeFile()
 {
+    if (EmulationDetector::isRunningArmOnX86())
+        QSKIP("Running QTextStream::pos() in tight loop is too slow on emulator");
+
     {
         QFile file(testFileName);
         file.open(QIODevice::WriteOnly | QIODevice::Text);
diff --git a/tests/auto/corelib/tools/qlocale/tst_qlocale.cpp b/tests/auto/corelib/tools/qlocale/tst_qlocale.cpp
index ff36beadcb..9bb0c6811d 100644
--- a/tests/auto/corelib/tools/qlocale/tst_qlocale.cpp
+++ b/tests/auto/corelib/tools/qlocale/tst_qlocale.cpp
@@ -84,6 +84,8 @@ private slots:
     void matchingLocales();
     void stringToDouble_data();
     void stringToDouble();
+    void stringToFloat_data();
+    void stringToFloat();
     void doubleToString_data();
     void doubleToString();
     void strtod_data();
@@ -160,6 +162,17 @@ private:
     QString m_sysapp;
     QStringList cleanEnv;
     bool europeanTimeZone;
+    void toReal_data();
+
+    class TransientLocale
+    {
+        const int m_category;
+        const char *const m_prior;
+    public:
+        TransientLocale(int category, const char *locale)
+            : m_category(category), m_prior(setlocale(category, locale)) {}
+        ~TransientLocale() { setlocale(m_category, m_prior); }
+    };
 };
 
 tst_QLocale::tst_QLocale()
@@ -741,7 +754,7 @@ void tst_QLocale::unixLocaleName()
     QCOMPARE(locale.name(), expect);
 }
 
-void tst_QLocale::stringToDouble_data()
+void tst_QLocale::toReal_data()
 {
     QTest::addColumn<QString>("locale_name");
     QTest::addColumn<QString>("num_str");
@@ -754,6 +767,8 @@ void tst_QLocale::stringToDouble_data()
     QTest::newRow("C 1.234e-10")       << QString("C") << QString("1.234e-10")       << true  << 1.234e-10;
     QTest::newRow("C 1.234E10")        << QString("C") << QString("1.234E10")        << true  << 1.234e10;
     QTest::newRow("C 1e10")            << QString("C") << QString("1e10")            << true  << 1.0e10;
+    QTest::newRow("C 1e310")           << QString("C") << QString("1e310")           << false << std::numeric_limits<double>::infinity();
+    QTest::newRow("C 1E310")           << QString("C") << QString("1E310")           << false << std::numeric_limits<double>::infinity();
     QTest::newRow("C  1")              << QString("C") << QString(" 1")              << true  << 1.0;
     QTest::newRow("C   1")             << QString("C") << QString("  1")             << true  << 1.0;
     QTest::newRow("C 1 ")              << QString("C") << QString("1 ")              << true  << 1.0;
@@ -863,9 +878,35 @@ void tst_QLocale::stringToDouble_data()
     QTest::newRow("de_DE 9.876543,0e--2") << QString("de_DE") << QString("9.876543,0e")+QChar(8722)+QString("2")   << false << 0.0;
 }
 
+void tst_QLocale::stringToDouble_data()
+{
+    toReal_data();
+    if (std::numeric_limits<double>::has_infinity) {
+        double huge = std::numeric_limits<double>::infinity();
+        QTest::newRow("C inf") << QString("C") << QString("inf") << true << huge;
+        QTest::newRow("C +inf") << QString("C") << QString("+inf") << true << +huge;
+        QTest::newRow("C -inf") << QString("C") << QString("-inf") << true << -huge;
+        // Overflow:
+        QTest::newRow("C huge") << QString("C") << QString("2e308") << false << huge;
+        QTest::newRow("C -huge") << QString("C") << QString("-2e308") << false << -huge;
+    }
+    if (std::numeric_limits<double>::has_quiet_NaN)
+        QTest::newRow("C qnan") << QString("C") << QString("NaN") << true << std::numeric_limits<double>::quiet_NaN();
+
+    // In range (but outside float's range):
+    QTest::newRow("C big") << QString("C") << QString("3.5e38") << true << 3.5e38;
+    QTest::newRow("C -big") << QString("C") << QString("-3.5e38") << true << -3.5e38;
+    QTest::newRow("C small") << QString("C") << QString("1e-45") << true << 1e-45;
+    QTest::newRow("C -small") << QString("C") << QString("-1e-45") << true << -1e-45;
+
+    // Underflow:
+    QTest::newRow("C tiny") << QString("C") << QString("2e-324") << false << 0.;
+    QTest::newRow("C -tiny") << QString("C") << QString("-2e-324") << false << 0.;
+}
+
 void tst_QLocale::stringToDouble()
 {
-#define MY_DOUBLE_EPSILON (2.22045e-16)
+#define MY_DOUBLE_EPSILON (2.22045e-16) // 1/2^{52}; double has a 53-bit mantissa
 
     QFETCH(QString, locale_name);
     QFETCH(QString, num_str);
@@ -880,27 +921,107 @@ void tst_QLocale::stringToDouble()
     double d = locale.toDouble(num_str, &ok);
     QCOMPARE(ok, good);
 
-    char *currentLocale = setlocale(LC_ALL, "de_DE");
-    QCOMPARE(locale.toDouble(num_str, &ok), d); // make sure result is independent of locale
-    QCOMPARE(ok, good);
-    setlocale(LC_ALL, currentLocale);
+    {
+        // Make sure result is independent of locale:
+        TransientLocale ignoreme(LC_ALL, "ar_SA");
+        QCOMPARE(locale.toDouble(num_str, &ok), d);
+        QCOMPARE(ok, good);
+    }
 
-    if (ok) {
-        double diff = d - num;
-        if (diff < 0)
-            diff = -diff;
-        QVERIFY(diff <= MY_DOUBLE_EPSILON);
+    if (ok || std::isinf(num)) {
+        // First use fuzzy-compare, then a more precise check:
+        QCOMPARE(d, num);
+        if (std::isfinite(num)) {
+            double diff = d > num ? d - num : num - d;
+            QVERIFY(diff <= MY_DOUBLE_EPSILON);
+        }
     }
 
     d = locale.toDouble(num_strRef, &ok);
     QCOMPARE(ok, good);
 
-    if (ok) {
-        double diff = d - num;
-        if (diff < 0)
-            diff = -diff;
-        QVERIFY(diff <= MY_DOUBLE_EPSILON);
+    if (ok || std::isinf(num)) {
+        QCOMPARE(d, num);
+        if (std::isfinite(num)) {
+            double diff = d > num ? d - num : num - d;
+            QVERIFY(diff <= MY_DOUBLE_EPSILON);
+        }
+    }
+#undef MY_DOUBLE_EPSILON
+}
+
+void tst_QLocale::stringToFloat_data()
+{
+    toReal_data();
+    if (std::numeric_limits<float>::has_infinity) {
+        double huge = std::numeric_limits<float>::infinity();
+        QTest::newRow("C inf") << QString("C") << QString("inf") << true << huge;
+        QTest::newRow("C +inf") << QString("C") << QString("+inf") << true << +huge;
+        QTest::newRow("C -inf") << QString("C") << QString("-inf") << true << -huge;
+        // Overflow float, but not double:
+        QTest::newRow("C big") << QString("C") << QString("3.5e38") << false << huge;
+        QTest::newRow("C -big") << QString("C") << QString("-3.5e38") << false << -huge;
+        // Overflow double, too:
+        QTest::newRow("C huge") << QString("C") << QString("2e308") << false << huge;
+        QTest::newRow("C -huge") << QString("C") << QString("-2e308") << false << -huge;
+    }
+    if (std::numeric_limits<float>::has_quiet_NaN)
+        QTest::newRow("C qnan") << QString("C") << QString("NaN") << true << double(std::numeric_limits<float>::quiet_NaN());
+
+    // Underflow float, but not double:
+    QTest::newRow("C small") << QString("C") << QString("1e-45") << false << 0.;
+    QTest::newRow("C -small") << QString("C") << QString("-1e-45") << false << 0.;
+
+    // Underflow double, too:
+    QTest::newRow("C tiny") << QString("C") << QString("2e-324") << false << 0.;
+    QTest::newRow("C -tiny") << QString("C") << QString("-2e-324") << false << 0.;
+}
+
+void tst_QLocale::stringToFloat()
+{
+#define MY_FLOAT_EPSILON (2.384e-7) // 1/2^{22}; float has a 23-bit mantissa
+
+    QFETCH(QString, locale_name);
+    QFETCH(QString, num_str);
+    QFETCH(bool, good);
+    QFETCH(double, num);
+    QStringRef num_strRef = num_str.leftRef(-1);
+    float fnum = num;
+
+    QLocale locale(locale_name);
+    QCOMPARE(locale.name(), locale_name);
+
+    bool ok;
+    float f = locale.toFloat(num_str, &ok);
+    QCOMPARE(ok, good);
+
+    {
+        // Make sure result is independent of locale:
+        TransientLocale ignoreme(LC_ALL, "ar_SA");
+        QCOMPARE(locale.toFloat(num_str, &ok), f);
+        QCOMPARE(ok, good);
+    }
+
+    if (ok || std::isinf(fnum)) {
+        // First use fuzzy-compare, then a more precise check:
+        QCOMPARE(f, fnum);
+        if (std::isfinite(fnum)) {
+            float diff = f > fnum ? f - fnum : fnum - f;
+            QVERIFY(diff <= MY_FLOAT_EPSILON);
+        }
+    }
+
+    f = locale.toFloat(num_strRef, &ok);
+    QCOMPARE(ok, good);
+
+    if (ok || std::isinf(fnum)) {
+        QCOMPARE(f, fnum);
+        if (std::isfinite(fnum)) {
+            float diff = f > fnum ? f - fnum : fnum - f;
+            QVERIFY(diff <= MY_FLOAT_EPSILON);
+        }
     }
+#undef MY_FLOAT_EPSILON
 }
 
 void tst_QLocale::doubleToString_data()
@@ -1013,9 +1134,8 @@ void tst_QLocale::doubleToString()
     const QLocale locale(locale_name);
     QCOMPARE(locale.toString(num, mode, precision), num_str);
 
-    char *currentLocale = setlocale(LC_ALL, "de_DE");
+    TransientLocale ignoreme(LC_ALL, "de_DE");
     QCOMPARE(locale.toString(num, mode, precision), num_str);
-    setlocale(LC_ALL, currentLocale);
 }
 
 void tst_QLocale::strtod_data()