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

Conflicts:
	qmake/library/qmakeevaluator.cpp
	(cherry picked from commit 1af6dc2c8fb4d91400fddc5050166f972ae57c9a in qttools)
	src/corelib/kernel/qcore_mac_objc.mm
	src/gui/painting/qcolor.h
	src/plugins/platforms/cocoa/qcocoawindow.mm

Change-Id: I5b3ec468a5a9a73911b528d3d24ff8e19f339f31

5 files changed, 467 insertions, 265 deletions

diff --git a/tests/auto/corelib/io/qsettings/qsettings.pro b/tests/auto/corelib/io/qsettings/qsettings.pro
index 3aa5ea6766..7da73a549a 100644
--- a/tests/auto/corelib/io/qsettings/qsettings.pro
+++ b/tests/auto/corelib/io/qsettings/qsettings.pro
@@ -3,6 +3,7 @@ TARGET = tst_qsettings
 QT = core-private gui testlib
 SOURCES = tst_qsettings.cpp
 RESOURCES += qsettings.qrc
+INCLUDEPATH += $$PWD/../../kernel/qmetatype
 
 win32-msvc*:LIBS += advapi32.lib
 DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0
diff --git a/tests/auto/corelib/io/qsettings/tst_qsettings.cpp b/tests/auto/corelib/io/qsettings/tst_qsettings.cpp
index 0e8a784423..fcff13b416 100644
--- a/tests/auto/corelib/io/qsettings/tst_qsettings.cpp
+++ b/tests/auto/corelib/io/qsettings/tst_qsettings.cpp
@@ -41,6 +41,10 @@
 #include <QtCore/QSysInfo>
 #include <QtGui/QKeySequence>
 
+#include <QtCore>
+#include <QtGui>
+#include "tst_qmetatype.h"
+
 #include <cctype>
 #include <stdlib.h>
 #if defined(Q_OS_WIN) && defined(Q_CC_GNU)
@@ -54,6 +58,10 @@
 #include <unistd.h>
 #endif
 
+#if defined(Q_OS_DARWIN)
+#include <CoreFoundation/CoreFoundation.h>
+#endif
+
 Q_DECLARE_METATYPE(QSettings::Format)
 
 #ifndef QSETTINGS_P_H_VERSION
@@ -72,7 +80,19 @@ static inline bool canWriteNativeSystemSettings()
     else
         qErrnoWarning(result, "RegOpenKeyEx failed");
     return result == ERROR_SUCCESS;
-#else // Q_OS_WIN && !Q_OS_WINRT
+#elif defined(Q_OS_DARWIN)
+    CFStringRef key = CFSTR("canWriteNativeSystemSettings");
+    #define ANY_APP_USER_AND_HOST kCFPreferencesAnyApplication, kCFPreferencesAnyUser, kCFPreferencesAnyHost
+    CFPreferencesSetValue(key, CFSTR("true"), ANY_APP_USER_AND_HOST);
+    if (CFPreferencesSynchronize(ANY_APP_USER_AND_HOST)) {
+        // Cleanup
+        CFPreferencesSetValue(key, 0, ANY_APP_USER_AND_HOST);
+        CFPreferencesSynchronize(ANY_APP_USER_AND_HOST);
+        return true;
+    } else {
+        return false;
+    }
+#else
     return true;
 #endif
 }
@@ -149,6 +169,8 @@ private slots:
     void testNormalizedKey();
     void testVariantTypes_data();
     void testVariantTypes();
+    void testMetaTypes_data();
+    void testMetaTypes();
 #endif
     void rainersSyncBugOnMac_data();
     void rainersSyncBugOnMac();
@@ -158,6 +180,8 @@ private slots:
     void testByteArray();
     void iniCodec();
     void bom();
+    void embeddedZeroByte_data();
+    void embeddedZeroByte();
 
     void testXdg();
 private:
@@ -628,7 +652,6 @@ void tst_QSettings::testByteArray_data()
 #ifndef QT_NO_COMPRESS
     QTest::newRow("compressed") << qCompress(bytes);
 #endif
-    QTest::newRow("with \\0") << bytes + '\0' + bytes;
 }
 
 void tst_QSettings::testByteArray()
@@ -679,6 +702,53 @@ void tst_QSettings::bom()
     QVERIFY(allkeys.contains("section2/foo2"));
 }
 
+void tst_QSettings::embeddedZeroByte_data()
+{
+    QTest::addColumn<QVariant>("value");
+
+    QByteArray bytes("hello\0world", 11);
+
+    QTest::newRow("bytearray\\0") << QVariant(bytes);
+    QTest::newRow("string\\0") << QVariant(QString::fromLatin1(bytes.data(), bytes.size()));
+
+    bytes = QByteArray("@String(");
+
+    QTest::newRow("@bytearray") << QVariant(bytes);
+    QTest::newRow("@string") << QVariant(QString(bytes));
+
+    bytes = QByteArray("@String(\0test", 13);
+
+    QTest::newRow("@bytearray\\0") << QVariant(bytes);
+    QTest::newRow("@string\\0") << QVariant(QString::fromLatin1(bytes.data(), bytes.size()));
+}
+
+void tst_QSettings::embeddedZeroByte()
+{
+    QFETCH(QVariant, value);
+    {
+        QSettings settings("QtProject", "tst_qsettings");
+        settings.setValue(QTest::currentDataTag(), value);
+    }
+    {
+        QSettings settings("QtProject", "tst_qsettings");
+        QVariant outValue = settings.value(QTest::currentDataTag());
+
+        switch (value.type()) {
+        case QVariant::ByteArray:
+            QCOMPARE(outValue.toByteArray(), value.toByteArray());
+            break;
+        case QVariant::String:
+            QCOMPARE(outValue.toString(), value.toString());
+            break;
+        default:
+            Q_UNREACHABLE();
+        }
+
+        if (value.toByteArray().contains(QChar::Null))
+            QVERIFY(outValue.toByteArray().contains(QChar::Null));
+    }
+}
+
 void tst_QSettings::testErrorHandling_data()
 {
     QTest::addColumn<int>("filePerms"); // -1 means file should not exist
@@ -1058,6 +1128,102 @@ void tst_QSettings::setValue()
 }
 
 #ifdef QT_BUILD_INTERNAL
+
+template<int MetaTypeId>
+static void testMetaTypesHelper(QSettings::Format format)
+{
+    typedef typename MetaEnumToType<MetaTypeId>::Type Type;
+    const char *key = QMetaType::typeName(MetaTypeId);
+    Type *value = TestValueFactory<MetaTypeId>::create();
+    QVariant inputVariant = QVariant::fromValue(*value);
+
+    static const QSettings::Scope scope = QSettings::UserScope;
+    static const QString organization("example.org");
+    static const QString applicationName("FooApp");
+
+    {
+        QSettings settings(format, scope, organization, applicationName);
+        settings.setValue(key, inputVariant);
+    }
+
+    QConfFile::clearCache();
+
+    {
+        QSettings settings(format, scope, organization, applicationName);
+        QVariant outputVariant = settings.value(key);
+        if (MetaTypeId != QMetaType::QVariant)
+            QVERIFY(outputVariant.canConvert(MetaTypeId));
+        if (outputVariant.type() != inputVariant.type())
+            qWarning() << "type mismatch between" << inputVariant << "and" << outputVariant;
+        QCOMPARE(qvariant_cast<Type >(outputVariant), *value);
+    }
+
+    delete value;
+}
+
+#define FOR_EACH_NONSUPPORTED_METATYPE(F)\
+    F(Void) \
+    F(Nullptr) \
+    F(QObjectStar) \
+    F(QModelIndex) \
+    F(QJsonObject) \
+    F(QJsonValue) \
+    F(QJsonArray) \
+    F(QJsonDocument) \
+    F(QPersistentModelIndex) \
+
+#define EXCLUDE_NON_SUPPORTED_METATYPES(MetaTypeName) \
+template<> void testMetaTypesHelper<QMetaType::MetaTypeName>(QSettings::Format) \
+{ \
+    QSKIP("This metatype is not supported by QSettings."); \
+}
+FOR_EACH_NONSUPPORTED_METATYPE(EXCLUDE_NON_SUPPORTED_METATYPES)
+#undef EXCLUDE_NON_SUPPORTED_METATYPES
+
+void tst_QSettings::testMetaTypes_data()
+{
+    QTest::addColumn<QSettings::Format>("format");
+    QTest::addColumn<int>("type");
+
+#define ADD_METATYPE_TEST_ROW(MetaTypeName, MetaTypeId, RealType) \
+    { \
+        const char *formatName = QMetaEnum::fromType<QSettings::Format>().valueToKey(formats[i]); \
+        const char *typeName = QMetaType::typeName(QMetaType::MetaTypeName); \
+        QTest::newRow(QString("%1:%2").arg(formatName).arg(typeName).toLatin1().constData()) \
+            << QSettings::Format(formats[i]) << int(QMetaType::MetaTypeName); \
+    }
+    int formats[] = { QSettings::NativeFormat, QSettings::IniFormat };
+    for (int i = 0; i < int(sizeof(formats) / sizeof(int)); ++i) {
+        FOR_EACH_CORE_METATYPE(ADD_METATYPE_TEST_ROW)
+    }
+#undef ADD_METATYPE_TEST_ROW
+}
+
+typedef void (*TypeTestFunction)(QSettings::Format);
+
+void tst_QSettings::testMetaTypes()
+{
+    struct TypeTestFunctionGetter
+    {
+        static TypeTestFunction get(int type)
+        {
+            switch (type) {
+#define RETURN_CREATE_FUNCTION(MetaTypeName, MetaTypeId, RealType) \
+            case QMetaType::MetaTypeName: \
+            return testMetaTypesHelper<QMetaType::MetaTypeName>;
+FOR_EACH_CORE_METATYPE(RETURN_CREATE_FUNCTION)
+#undef RETURN_CREATE_FUNCTION
+            }
+            return 0;
+        }
+    };
+
+    QFETCH(QSettings::Format, format);
+    QFETCH(int, type);
+
+    TypeTestFunctionGetter::get(type)(format);
+}
+
 void tst_QSettings::testVariantTypes_data()
 {
     populateWithFormats();
@@ -1731,10 +1897,10 @@ void tst_QSettings::testChildKeysAndGroups()
 
 void tst_QSettings::testUpdateRequestEvent()
 {
-#ifdef Q_OS_WINRT
     const QString oldCur = QDir::currentPath();
-    QDir::setCurrent(QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation));
-#endif
+    QString dataLocation = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation);
+    QVERIFY(QDir::root().mkpath(dataLocation));
+    QDir::setCurrent(dataLocation);
 
     QFile::remove("foo");
     QVERIFY(!QFile::exists("foo"));
@@ -1762,9 +1928,7 @@ void tst_QSettings::testUpdateRequestEvent()
 
     QTRY_COMPARE(QFileInfo("foo").size(), qint64(0));
 
-#ifdef Q_OS_WINRT
     QDir::setCurrent(oldCur);
-#endif
 }
 
 const int NumIterations = 5;
@@ -2063,13 +2227,10 @@ void tst_QSettings::fromFile()
 {
     QFETCH(QSettings::Format, format);
 
-    // Sandboxed WinRT applications cannot write into the
-    // application directory. Hence reset the current
-    // directory
-#ifdef Q_OS_WINRT
     const QString oldCur = QDir::currentPath();
-    QDir::setCurrent(QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation));
-#endif
+    QString dataLocation = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation);
+    QVERIFY(QDir::root().mkpath(dataLocation));
+    QDir::setCurrent(dataLocation);
 
     QFile::remove("foo");
     QVERIFY(!QFile::exists("foo"));
@@ -2118,9 +2279,8 @@ void tst_QSettings::fromFile()
         QCOMPARE(settings1.value("gamma/foo.bar").toInt(), 4);
         QCOMPARE(settings1.allKeys().size(), 3);
     }
-#ifdef Q_OS_WINRT
+
     QDir::setCurrent(oldCur);
-#endif
 }
 
 #ifdef QT_BUILD_INTERNAL
@@ -2855,7 +3015,7 @@ void tst_QSettings::isWritable()
         QSettings s2(format, QSettings::SystemScope, "software.org", "Something Different");
         QSettings s3(format, QSettings::SystemScope, "foo.org", "Something Different");
 
-        if (s1.contains("foo")) {
+        if (s1.status() == QSettings::NoError && s1.contains("foo")) {
 #if defined(Q_OS_MACX)
             QVERIFY(s1.isWritable());
             if (format == QSettings::NativeFormat) {
@@ -3304,9 +3464,9 @@ void tst_QSettings::rainersSyncBugOnMac()
 {
     QFETCH(QSettings::Format, format);
 
-#if defined(Q_OS_OSX) || defined(Q_OS_WINRT)
+#if defined(Q_OS_DARWIN) || defined(Q_OS_WINRT)
     if (format == QSettings::NativeFormat)
-        QSKIP("OSX does not support direct reads from and writes to .plist files, due to caching and background syncing. See QTBUG-34899.");
+        QSKIP("Apple OSes do not support direct reads from and writes to .plist files, due to caching and background syncing. See QTBUG-34899.");
 #endif
 
     QString fileName;
diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
index 86f47f3511..caceda86be 100644
--- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
+++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
@@ -30,6 +30,7 @@
 #include <QtCore>
 #include <QtTest/QtTest>
 
+#include "tst_qmetatype.h"
 #include "tst_qvariant_common.h"
 
 #ifdef Q_OS_LINUX
@@ -464,18 +465,6 @@ void tst_QMetaType::type_fromSubString()
     QCOMPARE(QMetaType::type(ba), expectedType);
 }
 
-#define FOR_EACH_PRIMITIVE_METATYPE(F) \
-    QT_FOR_EACH_STATIC_PRIMITIVE_TYPE(F) \
-    QT_FOR_EACH_STATIC_CORE_POINTER(F) \
-
-#define FOR_EACH_COMPLEX_CORE_METATYPE(F) \
-    QT_FOR_EACH_STATIC_CORE_CLASS(F) \
-    QT_FOR_EACH_STATIC_CORE_TEMPLATE(F)
-
-#define FOR_EACH_CORE_METATYPE(F) \
-    FOR_EACH_PRIMITIVE_METATYPE(F) \
-    FOR_EACH_COMPLEX_CORE_METATYPE(F) \
-
 namespace {
     template <typename T>
     struct static_assert_trigger {
@@ -495,237 +484,6 @@ Q_STATIC_ASSERT((!QMetaTypeId2<QList<int> >::IsBuiltIn));
 Q_STATIC_ASSERT((!QMetaTypeId2<QMap<int,int> >::IsBuiltIn));
 Q_STATIC_ASSERT((!QMetaTypeId2<QMetaType::Type>::IsBuiltIn));
 
-template <int ID>
-struct MetaEnumToType {};
-
-#define DEFINE_META_ENUM_TO_TYPE(MetaTypeName, MetaTypeId, RealType) \
-template<> \
-struct MetaEnumToType<QMetaType::MetaTypeName> { \
-    typedef RealType Type; \
-};
-FOR_EACH_CORE_METATYPE(DEFINE_META_ENUM_TO_TYPE)
-#undef DEFINE_META_ENUM_TO_TYPE
-
-template <int ID>
-struct DefaultValueFactory
-{
-    typedef typename MetaEnumToType<ID>::Type Type;
-    static Type *create() { return new Type; }
-};
-
-template <>
-struct DefaultValueFactory<QMetaType::Void>
-{
-    typedef MetaEnumToType<QMetaType::Void>::Type Type;
-    static Type *create() { return 0; }
-};
-
-template <int ID>
-struct DefaultValueTraits
-{
-    // By default we assume that a default-constructed value (new T) is
-    // initialized; e.g. QCOMPARE(*(new T), *(new T)) should succeed
-    enum { IsInitialized = true };
-};
-
-#define DEFINE_NON_INITIALIZED_DEFAULT_VALUE_TRAITS(MetaTypeName, MetaTypeId, RealType) \
-template<> struct DefaultValueTraits<QMetaType::MetaTypeName> { \
-    enum { IsInitialized = false }; \
-};
-// Primitive types (int et al) aren't initialized
-FOR_EACH_PRIMITIVE_METATYPE(DEFINE_NON_INITIALIZED_DEFAULT_VALUE_TRAITS)
-#undef DEFINE_NON_INITIALIZED_DEFAULT_VALUE_TRAITS
-
-template <int ID>
-struct TestValueFactory {};
-
-template<> struct TestValueFactory<QMetaType::Void> {
-    static void *create() { return 0; }
-};
-
-template<> struct TestValueFactory<QMetaType::QString> {
-    static QString *create() { return new QString(QString::fromLatin1("QString")); }
-};
-template<> struct TestValueFactory<QMetaType::Int> {
-    static int *create() { return new int(0x12345678); }
-};
-template<> struct TestValueFactory<QMetaType::UInt> {
-    static uint *create() { return new uint(0x12345678); }
-};
-template<> struct TestValueFactory<QMetaType::Bool> {
-    static bool *create() { return new bool(true); }
-};
-template<> struct TestValueFactory<QMetaType::Double> {
-    static double *create() { return new double(3.14); }
-};
-template<> struct TestValueFactory<QMetaType::QByteArray> {
-    static QByteArray *create() { return new QByteArray(QByteArray("QByteArray")); }
-};
-template<> struct TestValueFactory<QMetaType::QByteArrayList> {
-    static QByteArrayList *create() { return new QByteArrayList(QByteArrayList() << "Q" << "Byte" << "Array" << "List"); }
-};
-template<> struct TestValueFactory<QMetaType::QVariantMap> {
-    static QVariantMap *create() { return new QVariantMap(); }
-};
-template<> struct TestValueFactory<QMetaType::QVariantHash> {
-    static QVariantHash *create() { return new QVariantHash(); }
-};
-template<> struct TestValueFactory<QMetaType::QVariantList> {
-    static QVariantList *create() { return new QVariantList(QVariantList() << 123 << "Q" << "Variant" << "List"); }
-};
-template<> struct TestValueFactory<QMetaType::QChar> {
-    static QChar *create() { return new QChar(QChar('q')); }
-};
-template<> struct TestValueFactory<QMetaType::Long> {
-    static long *create() { return new long(0x12345678); }
-};
-template<> struct TestValueFactory<QMetaType::Short> {
-    static short *create() { return new short(0x1234); }
-};
-template<> struct TestValueFactory<QMetaType::Char> {
-    static char *create() { return new char('c'); }
-};
-template<> struct TestValueFactory<QMetaType::ULong> {
-    static ulong *create() { return new ulong(0x12345678); }
-};
-template<> struct TestValueFactory<QMetaType::UShort> {
-    static ushort *create() { return new ushort(0x1234); }
-};
-template<> struct TestValueFactory<QMetaType::SChar> {
-    static signed char *create() { return new signed char(-12); }
-};
-template<> struct TestValueFactory<QMetaType::UChar> {
-    static uchar *create() { return new uchar('u'); }
-};
-template<> struct TestValueFactory<QMetaType::Float> {
-    static float *create() { return new float(3.14f); }
-};
-template<> struct TestValueFactory<QMetaType::QObjectStar> {
-    static QObject * *create() { return new QObject *(0); }
-};
-template<> struct TestValueFactory<QMetaType::VoidStar> {
-    static void * *create() { return new void *(0); }
-};
-template<> struct TestValueFactory<QMetaType::LongLong> {
-    static qlonglong *create() { return new qlonglong(0x12345678); }
-};
-template<> struct TestValueFactory<QMetaType::ULongLong> {
-    static qulonglong *create() { return new qulonglong(0x12345678); }
-};
-template<> struct TestValueFactory<QMetaType::QStringList> {
-    static QStringList *create() { return new QStringList(QStringList() << "Q" << "t"); }
-};
-template<> struct TestValueFactory<QMetaType::QBitArray> {
-    static QBitArray *create() { return new QBitArray(QBitArray(256, true)); }
-};
-template<> struct TestValueFactory<QMetaType::QDate> {
-    static QDate *create() { return new QDate(QDate::currentDate()); }
-};
-template<> struct TestValueFactory<QMetaType::QTime> {
-    static QTime *create() { return new QTime(QTime::currentTime()); }
-};
-template<> struct TestValueFactory<QMetaType::QDateTime> {
-    static QDateTime *create() { return new QDateTime(QDateTime::currentDateTime()); }
-};
-template<> struct TestValueFactory<QMetaType::QUrl> {
-    static QUrl *create() { return new QUrl("http://www.example.org"); }
-};
-template<> struct TestValueFactory<QMetaType::QLocale> {
-    static QLocale *create() { return new QLocale(QLocale::c()); }
-};
-template<> struct TestValueFactory<QMetaType::QRect> {
-    static QRect *create() { return new QRect(10, 20, 30, 40); }
-};
-template<> struct TestValueFactory<QMetaType::QRectF> {
-    static QRectF *create() { return new QRectF(10, 20, 30, 40); }
-};
-template<> struct TestValueFactory<QMetaType::QSize> {
-    static QSize *create() { return new QSize(10, 20); }
-};
-template<> struct TestValueFactory<QMetaType::QSizeF> {
-    static QSizeF *create() { return new QSizeF(10, 20); }
-};
-template<> struct TestValueFactory<QMetaType::QLine> {
-    static QLine *create() { return new QLine(10, 20, 30, 40); }
-};
-template<> struct TestValueFactory<QMetaType::QLineF> {
-    static QLineF *create() { return new QLineF(10, 20, 30, 40); }
-};
-template<> struct TestValueFactory<QMetaType::QPoint> {
-    static QPoint *create() { return new QPoint(10, 20); }
-};
-template<> struct TestValueFactory<QMetaType::QPointF> {
-    static QPointF *create() { return new QPointF(10, 20); }
-};
-template<> struct TestValueFactory<QMetaType::QEasingCurve> {
-    static QEasingCurve *create() { return new QEasingCurve(QEasingCurve::InOutElastic); }
-};
-template<> struct TestValueFactory<QMetaType::QUuid> {
-    static QUuid *create() { return new QUuid(); }
-};
-template<> struct TestValueFactory<QMetaType::QModelIndex> {
-    static QModelIndex *create() { return new QModelIndex(); }
-};
-template<> struct TestValueFactory<QMetaType::QPersistentModelIndex> {
-    static QPersistentModelIndex *create() { return new QPersistentModelIndex(); }
-};
-template<> struct TestValueFactory<QMetaType::Nullptr> {
-    static std::nullptr_t *create() { return new std::nullptr_t; }
-};
-template<> struct TestValueFactory<QMetaType::QRegExp> {
-    static QRegExp *create()
-    {
-#ifndef QT_NO_REGEXP
-        return new QRegExp("A*");
-#else
-        return 0;
-#endif
-    }
-};
-template<> struct TestValueFactory<QMetaType::QRegularExpression> {
-    static QRegularExpression *create()
-    {
-#ifndef QT_NO_REGEXP
-        return new QRegularExpression("abc.*def");
-#else
-        return 0;
-#endif
-    }
-};
-template<> struct TestValueFactory<QMetaType::QJsonValue> {
-    static QJsonValue *create() { return new QJsonValue(123.); }
-};
-template<> struct TestValueFactory<QMetaType::QJsonObject> {
-    static QJsonObject *create() {
-        QJsonObject *o = new QJsonObject();
-        o->insert("a", 123.);
-        o->insert("b", true);
-        o->insert("c", QJsonValue::Null);
-        o->insert("d", QLatin1String("ciao"));
-        return o;
-    }
-};
-template<> struct TestValueFactory<QMetaType::QJsonArray> {
-    static QJsonArray *create() {
-        QJsonArray *a = new QJsonArray();
-        a->append(123.);
-        a->append(true);
-        a->append(QJsonValue::Null);
-        a->append(QLatin1String("ciao"));
-        return a;
-    }
-};
-template<> struct TestValueFactory<QMetaType::QJsonDocument> {
-    static QJsonDocument *create() {
-        return new QJsonDocument(
-            QJsonDocument::fromJson("{ 'foo': 123, 'bar': [true, null, 'ciao'] }")
-        );
-    }
-};
-template<> struct TestValueFactory<QMetaType::QVariant> {
-    static QVariant *create() { return new QVariant(QStringList(QStringList() << "Q" << "t")); }
-};
-
 void tst_QMetaType::create_data()
 {
     QTest::addColumn<int>("type");
diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.h b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.h
new file mode 100644
index 0000000000..93ff33bb67
--- /dev/null
+++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.h
@@ -0,0 +1,280 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 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$
+**
+****************************************************************************/
+
+// Used by both tst_qmetatype and tst_qsettings
+
+#ifndef TST_QMETATYPE_H
+#define TST_QMETATYPE_H
+
+#include <qmetatype.h>
+#include <float.h>
+
+#define FOR_EACH_PRIMITIVE_METATYPE(F) \
+    QT_FOR_EACH_STATIC_PRIMITIVE_TYPE(F) \
+    QT_FOR_EACH_STATIC_CORE_POINTER(F) \
+
+#define FOR_EACH_COMPLEX_CORE_METATYPE(F) \
+    QT_FOR_EACH_STATIC_CORE_CLASS(F) \
+    QT_FOR_EACH_STATIC_CORE_TEMPLATE(F)
+
+#define FOR_EACH_CORE_METATYPE(F) \
+    FOR_EACH_PRIMITIVE_METATYPE(F) \
+    FOR_EACH_COMPLEX_CORE_METATYPE(F) \
+
+template <int ID>
+struct MetaEnumToType {};
+
+#define DEFINE_META_ENUM_TO_TYPE(MetaTypeName, MetaTypeId, RealType) \
+template<> \
+struct MetaEnumToType<QMetaType::MetaTypeName> { \
+    typedef RealType Type; \
+};
+FOR_EACH_CORE_METATYPE(DEFINE_META_ENUM_TO_TYPE)
+#undef DEFINE_META_ENUM_TO_TYPE
+
+template <int ID>
+struct DefaultValueFactory
+{
+    typedef typename MetaEnumToType<ID>::Type Type;
+    static Type *create() { return new Type; }
+};
+
+template <>
+struct DefaultValueFactory<QMetaType::Void>
+{
+    typedef MetaEnumToType<QMetaType::Void>::Type Type;
+    static Type *create() { return 0; }
+};
+
+template <int ID>
+struct DefaultValueTraits
+{
+    // By default we assume that a default-constructed value (new T) is
+    // initialized; e.g. QCOMPARE(*(new T), *(new T)) should succeed
+    enum { IsInitialized = true };
+};
+
+#define DEFINE_NON_INITIALIZED_DEFAULT_VALUE_TRAITS(MetaTypeName, MetaTypeId, RealType) \
+template<> struct DefaultValueTraits<QMetaType::MetaTypeName> { \
+    enum { IsInitialized = false }; \
+};
+// Primitive types (int et al) aren't initialized
+FOR_EACH_PRIMITIVE_METATYPE(DEFINE_NON_INITIALIZED_DEFAULT_VALUE_TRAITS)
+#undef DEFINE_NON_INITIALIZED_DEFAULT_VALUE_TRAITS
+
+template <int ID>
+struct TestValueFactory {};
+
+template<> struct TestValueFactory<QMetaType::Void> {
+    static void *create() { return 0; }
+};
+
+template<> struct TestValueFactory<QMetaType::QString> {
+    static QString *create() { return new QString(QString::fromLatin1("QString")); }
+};
+template<> struct TestValueFactory<QMetaType::Int> {
+    static int *create() { return new int(INT_MIN); }
+};
+template<> struct TestValueFactory<QMetaType::UInt> {
+    static uint *create() { return new uint(UINT_MAX); }
+};
+template<> struct TestValueFactory<QMetaType::Bool> {
+    static bool *create() { return new bool(true); }
+};
+template<> struct TestValueFactory<QMetaType::Double> {
+    static double *create() { return new double(DBL_MIN); }
+};
+template<> struct TestValueFactory<QMetaType::QByteArray> {
+    static QByteArray *create() { return new QByteArray(QByteArray("QByteArray")); }
+};
+template<> struct TestValueFactory<QMetaType::QByteArrayList> {
+    static QByteArrayList *create() { return new QByteArrayList(QByteArrayList() << "Q" << "Byte" << "Array" << "List"); }
+};
+template<> struct TestValueFactory<QMetaType::QVariantMap> {
+    static QVariantMap *create() { return new QVariantMap(); }
+};
+template<> struct TestValueFactory<QMetaType::QVariantHash> {
+    static QVariantHash *create() { return new QVariantHash(); }
+};
+template<> struct TestValueFactory<QMetaType::QVariantList> {
+    static QVariantList *create() { return new QVariantList(QVariantList() << 123 << "Q" << "Variant" << "List"); }
+};
+template<> struct TestValueFactory<QMetaType::QChar> {
+    static QChar *create() { return new QChar(QChar('q')); }
+};
+template<> struct TestValueFactory<QMetaType::Long> {
+    static long *create() { return new long(LONG_MIN); }
+};
+template<> struct TestValueFactory<QMetaType::Short> {
+    static short *create() { return new short(SHRT_MIN); }
+};
+template<> struct TestValueFactory<QMetaType::Char> {
+    static char *create() { return new char('c'); }
+};
+template<> struct TestValueFactory<QMetaType::ULong> {
+    static ulong *create() { return new ulong(ULONG_MAX); }
+};
+template<> struct TestValueFactory<QMetaType::UShort> {
+    static ushort *create() { return new ushort(USHRT_MAX); }
+};
+template<> struct TestValueFactory<QMetaType::SChar> {
+    static signed char *create() { return new signed char(CHAR_MIN); }
+};
+template<> struct TestValueFactory<QMetaType::UChar> {
+    static uchar *create() { return new uchar(UCHAR_MAX); }
+};
+template<> struct TestValueFactory<QMetaType::Float> {
+    static float *create() { return new float(FLT_MIN); }
+};
+template<> struct TestValueFactory<QMetaType::QObjectStar> {
+    static QObject * *create() { return new QObject *(0); }
+};
+template<> struct TestValueFactory<QMetaType::VoidStar> {
+    static void * *create() { return new void *(0); }
+};
+template<> struct TestValueFactory<QMetaType::LongLong> {
+    static qlonglong *create() { return new qlonglong(LLONG_MIN); }
+};
+template<> struct TestValueFactory<QMetaType::ULongLong> {
+    static qulonglong *create() { return new qulonglong(ULLONG_MAX); }
+};
+template<> struct TestValueFactory<QMetaType::QStringList> {
+    static QStringList *create() { return new QStringList(QStringList() << "Q" << "t"); }
+};
+template<> struct TestValueFactory<QMetaType::QBitArray> {
+    static QBitArray *create() { return new QBitArray(QBitArray(256, true)); }
+};
+template<> struct TestValueFactory<QMetaType::QDate> {
+    static QDate *create() { return new QDate(QDate::currentDate()); }
+};
+template<> struct TestValueFactory<QMetaType::QTime> {
+    static QTime *create() { return new QTime(QTime::currentTime()); }
+};
+template<> struct TestValueFactory<QMetaType::QDateTime> {
+    static QDateTime *create() { return new QDateTime(QDateTime::currentDateTime()); }
+};
+template<> struct TestValueFactory<QMetaType::QUrl> {
+    static QUrl *create() { return new QUrl("http://www.example.org"); }
+};
+template<> struct TestValueFactory<QMetaType::QLocale> {
+    static QLocale *create() { return new QLocale(QLocale::c()); }
+};
+template<> struct TestValueFactory<QMetaType::QRect> {
+    static QRect *create() { return new QRect(10, 20, 30, 40); }
+};
+template<> struct TestValueFactory<QMetaType::QRectF> {
+    static QRectF *create() { return new QRectF(10, 20, 30, 40); }
+};
+template<> struct TestValueFactory<QMetaType::QSize> {
+    static QSize *create() { return new QSize(10, 20); }
+};
+template<> struct TestValueFactory<QMetaType::QSizeF> {
+    static QSizeF *create() { return new QSizeF(10, 20); }
+};
+template<> struct TestValueFactory<QMetaType::QLine> {
+    static QLine *create() { return new QLine(10, 20, 30, 40); }
+};
+template<> struct TestValueFactory<QMetaType::QLineF> {
+    static QLineF *create() { return new QLineF(10, 20, 30, 40); }
+};
+template<> struct TestValueFactory<QMetaType::QPoint> {
+    static QPoint *create() { return new QPoint(10, 20); }
+};
+template<> struct TestValueFactory<QMetaType::QPointF> {
+    static QPointF *create() { return new QPointF(10, 20); }
+};
+template<> struct TestValueFactory<QMetaType::QEasingCurve> {
+    static QEasingCurve *create() { return new QEasingCurve(QEasingCurve::InOutElastic); }
+};
+template<> struct TestValueFactory<QMetaType::QUuid> {
+    static QUuid *create() { return new QUuid(); }
+};
+template<> struct TestValueFactory<QMetaType::QModelIndex> {
+    static QModelIndex *create() { return new QModelIndex(); }
+};
+template<> struct TestValueFactory<QMetaType::QPersistentModelIndex> {
+    static QPersistentModelIndex *create() { return new QPersistentModelIndex(); }
+};
+template<> struct TestValueFactory<QMetaType::Nullptr> {
+    static std::nullptr_t *create() { return new std::nullptr_t; }
+};
+template<> struct TestValueFactory<QMetaType::QRegExp> {
+    static QRegExp *create()
+    {
+#ifndef QT_NO_REGEXP
+        return new QRegExp("A*");
+#else
+        return 0;
+#endif
+    }
+};
+template<> struct TestValueFactory<QMetaType::QRegularExpression> {
+    static QRegularExpression *create()
+    {
+#ifndef QT_NO_REGEXP
+        return new QRegularExpression("abc.*def");
+#else
+        return 0;
+#endif
+    }
+};
+template<> struct TestValueFactory<QMetaType::QJsonValue> {
+    static QJsonValue *create() { return new QJsonValue(123.); }
+};
+template<> struct TestValueFactory<QMetaType::QJsonObject> {
+    static QJsonObject *create() {
+        QJsonObject *o = new QJsonObject();
+        o->insert("a", 123.);
+        o->insert("b", true);
+        o->insert("c", QJsonValue::Null);
+        o->insert("d", QLatin1String("ciao"));
+        return o;
+    }
+};
+template<> struct TestValueFactory<QMetaType::QJsonArray> {
+    static QJsonArray *create() {
+        QJsonArray *a = new QJsonArray();
+        a->append(123.);
+        a->append(true);
+        a->append(QJsonValue::Null);
+        a->append(QLatin1String("ciao"));
+        return a;
+    }
+};
+template<> struct TestValueFactory<QMetaType::QJsonDocument> {
+    static QJsonDocument *create() {
+        return new QJsonDocument(
+            QJsonDocument::fromJson("{ 'foo': 123, 'bar': [true, null, 'ciao'] }")
+        );
+    }
+};
+template<> struct TestValueFactory<QMetaType::QVariant> {
+    static QVariant *create() { return new QVariant(QStringList(QStringList() << "Q" << "t")); }
+};
+
+#endif // TST_QMETATYPE_H
diff --git a/tests/auto/corelib/tools/qdatetime/tst_qdatetime_mac.mm b/tests/auto/corelib/tools/qdatetime/tst_qdatetime_mac.mm
index fb49b8952e..f73c7b9d5d 100644
--- a/tests/auto/corelib/tools/qdatetime/tst_qdatetime_mac.mm
+++ b/tests/auto/corelib/tools/qdatetime/tst_qdatetime_mac.mm
@@ -36,8 +36,11 @@
 void tst_QDateTime_macTypes()
 {
     // QDateTime <-> CFDate
-    {
-        QDateTime qtDateTime = QDateTime::fromMSecsSinceEpoch(0);
+
+    static const int kMsPerSecond = 1000;
+
+    for (int i = 0; i < kMsPerSecond; ++i) {
+        QDateTime qtDateTime = QDateTime::fromMSecsSinceEpoch(i);
         const CFDateRef cfDate = qtDateTime.toCFDate();
         QCOMPARE(QDateTime::fromCFDate(cfDate), qtDateTime);
         CFRelease(cfDate);
@@ -50,9 +53,9 @@ void tst_QDateTime_macTypes()
         QCOMPARE(QDateTime::fromCFDate(cfDate), qtDateTimeCopy);
     }
     // QDateTime <-> NSDate
-    {
+    for (int i = 0; i < kMsPerSecond; ++i) {
         QMacAutoReleasePool pool;
-        QDateTime qtDateTime = QDateTime::fromMSecsSinceEpoch(0);
+        QDateTime qtDateTime = QDateTime::fromMSecsSinceEpoch(i);
         const NSDate *nsDate = qtDateTime.toNSDate();
         QCOMPARE(QDateTime::fromNSDate(nsDate), qtDateTime);
     }