Merge "Merge remote-tracking branch 'origin/api_changes'" into refs/staging/master

14 files changed, 518 insertions, 410 deletions

diff --git a/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp b/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp
index f4aefb2726..e8f6c29a94 100644
--- a/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp
+++ b/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp
@@ -617,6 +617,7 @@ public:
     bool unregisterTimer(int ) { return false; }
     bool unregisterTimers(QObject *) { return false; }
     QList<TimerInfo> registeredTimers(QObject *) const { return QList<TimerInfo>(); }
+    int remainingTime(int) { return 0; }
     void wakeUp() {}
     void interrupt() {}
     void flush() {}
diff --git a/tests/auto/corelib/kernel/qmetamethod/tst_qmetamethod.cpp b/tests/auto/corelib/kernel/qmetamethod/tst_qmetamethod.cpp
index 1651d00738..55997a3ca0 100644
--- a/tests/auto/corelib/kernel/qmetamethod/tst_qmetamethod.cpp
+++ b/tests/auto/corelib/kernel/qmetamethod/tst_qmetamethod.cpp
@@ -114,6 +114,7 @@ public slots:
     void voidSlotNoParameterNames(bool, int);
 signals:
     void voidSignal();
+    void voidSignalVoid(void);
     void voidSignalInt(int voidSignalIntArg);
     void voidSignalQReal(qreal voidSignalQRealArg);
     void voidSignalQString(const QString &voidSignalQStringArg);
@@ -196,7 +197,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidSignal")
             << QByteArray("voidSignal()")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>())
             << (QList<QByteArray>())
             << (QList<QByteArray>())
@@ -205,7 +206,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidInvokable")
             << QByteArray("voidInvokable()")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>())
             << (QList<QByteArray>())
             << (QList<QByteArray>())
@@ -214,7 +215,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidSlot")
             << QByteArray("voidSlot()")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>())
             << (QList<QByteArray>())
             << (QList<QByteArray>())
@@ -223,16 +224,25 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("MethodTestObject()")
             << QByteArray("MethodTestObject()")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::UnknownType) << QByteArray("")
             << (QList<int>())
             << (QList<QByteArray>())
             << (QList<QByteArray>())
             << QMetaMethod::Public
             << QMetaMethod::Constructor;
 
+    QTest::newRow("voidSignalVoid")
+            << QByteArray("voidSignalVoid()")
+            << int(QMetaType::Void) << QByteArray("void")
+            << QList<int>()
+            << QList<QByteArray>()
+            << QList<QByteArray>()
+            << QMetaMethod::Protected
+            << QMetaMethod::Signal;
+
     QTest::newRow("voidSignalInt")
             << QByteArray("voidSignalInt(int)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << int(QMetaType::Int))
             << (QList<QByteArray>() << QByteArray("int"))
             << (QList<QByteArray>() << QByteArray("voidSignalIntArg"))
@@ -241,7 +251,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidInvokableInt")
             << QByteArray("voidInvokableInt(int)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << int(QMetaType::Int))
             << (QList<QByteArray>() << QByteArray("int"))
             << (QList<QByteArray>() << QByteArray("voidInvokableIntArg"))
@@ -250,7 +260,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidSlotInt")
             << QByteArray("voidSlotInt(int)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << int(QMetaType::Int))
             << (QList<QByteArray>() << QByteArray("int"))
             << (QList<QByteArray>() << QByteArray("voidSlotIntArg"))
@@ -259,7 +269,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("MethodTestObject(int)")
             << QByteArray("MethodTestObject(int)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::UnknownType) << QByteArray("")
             << (QList<int>() << int(QMetaType::Int))
             << (QList<QByteArray>() << QByteArray("int"))
             << (QList<QByteArray>() << QByteArray("constructorIntArg"))
@@ -268,7 +278,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidSignalQReal")
             << QByteArray("voidSignalQReal(qreal)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << qMetaTypeId<qreal>())
             << (QList<QByteArray>() << QByteArray("qreal"))
             << (QList<QByteArray>() << QByteArray("voidSignalQRealArg"))
@@ -277,7 +287,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidInvokableQReal")
             << QByteArray("voidInvokableQReal(qreal)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << qMetaTypeId<qreal>())
             << (QList<QByteArray>() << QByteArray("qreal"))
             << (QList<QByteArray>() << QByteArray("voidInvokableQRealArg"))
@@ -286,7 +296,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidSlotQReal")
             << QByteArray("voidSlotQReal(qreal)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << qMetaTypeId<qreal>())
             << (QList<QByteArray>() << QByteArray("qreal"))
             << (QList<QByteArray>() << QByteArray("voidSlotQRealArg"))
@@ -295,7 +305,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("MethodTestObject(qreal)")
             << QByteArray("MethodTestObject(qreal)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::UnknownType) << QByteArray("")
             << (QList<int>() << qMetaTypeId<qreal>())
             << (QList<QByteArray>() << QByteArray("qreal"))
             << (QList<QByteArray>() << QByteArray("constructorQRealArg"))
@@ -304,7 +314,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidSignalQString")
             << QByteArray("voidSignalQString(QString)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << int(QMetaType::QString))
             << (QList<QByteArray>() << QByteArray("QString"))
             << (QList<QByteArray>() << QByteArray("voidSignalQStringArg"))
@@ -313,7 +323,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidInvokableQString")
             << QByteArray("voidInvokableQString(QString)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << int(QMetaType::QString))
             << (QList<QByteArray>() << QByteArray("QString"))
             << (QList<QByteArray>() << QByteArray("voidInvokableQStringArg"))
@@ -322,7 +332,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidSlotQString")
             << QByteArray("voidSlotQString(QString)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << int(QMetaType::QString))
             << (QList<QByteArray>() << QByteArray("QString"))
             << (QList<QByteArray>() << QByteArray("voidSlotQStringArg"))
@@ -331,7 +341,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("MethodTestObject(QString)")
             << QByteArray("MethodTestObject(QString)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::UnknownType) << QByteArray("")
             << (QList<int>() << int(QMetaType::QString))
             << (QList<QByteArray>() << QByteArray("QString"))
             << (QList<QByteArray>() << QByteArray("constructorQStringArg"))
@@ -340,7 +350,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidSignalCustomType")
             << QByteArray("voidSignalCustomType(CustomType)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << qMetaTypeId<CustomType>())
             << (QList<QByteArray>() << QByteArray("CustomType"))
             << (QList<QByteArray>() << QByteArray("voidSignalCustomTypeArg"))
@@ -349,7 +359,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidInvokableCustomType")
             << QByteArray("voidInvokableCustomType(CustomType)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << qMetaTypeId<CustomType>())
             << (QList<QByteArray>() << QByteArray("CustomType"))
             << (QList<QByteArray>() << QByteArray("voidInvokableCustomTypeArg"))
@@ -358,7 +368,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidSlotCustomType")
             << QByteArray("voidSlotCustomType(CustomType)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << qMetaTypeId<CustomType>())
             << (QList<QByteArray>() << QByteArray("CustomType"))
             << (QList<QByteArray>() << QByteArray("voidSlotCustomTypeArg"))
@@ -367,7 +377,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("MethodTestObject(CustomType)")
             << QByteArray("MethodTestObject(CustomType)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::UnknownType) << QByteArray("")
             << (QList<int>() << qMetaTypeId<CustomType>())
             << (QList<QByteArray>() << QByteArray("CustomType"))
             << (QList<QByteArray>() << QByteArray("constructorCustomTypeArg"))
@@ -376,7 +386,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidSignalCustomUnregisteredType")
             << QByteArray("voidSignalCustomUnregisteredType(CustomUnregisteredType)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << 0)
             << (QList<QByteArray>() << QByteArray("CustomUnregisteredType"))
             << (QList<QByteArray>() << QByteArray("voidSignalCustomUnregisteredTypeArg"))
@@ -385,7 +395,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidInvokableCustomUnregisteredType")
             << QByteArray("voidInvokableCustomUnregisteredType(CustomUnregisteredType)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << 0)
             << (QList<QByteArray>() << QByteArray("CustomUnregisteredType"))
             << (QList<QByteArray>() << QByteArray("voidInvokableCustomUnregisteredTypeArg"))
@@ -394,7 +404,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidSlotCustomUnregisteredType")
             << QByteArray("voidSlotCustomUnregisteredType(CustomUnregisteredType)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << 0)
             << (QList<QByteArray>() << QByteArray("CustomUnregisteredType"))
             << (QList<QByteArray>() << QByteArray("voidSlotCustomUnregisteredTypeArg"))
@@ -403,7 +413,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("MethodTestObject(CustomUnregisteredType)")
             << QByteArray("MethodTestObject(CustomUnregisteredType)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::UnknownType) << QByteArray("")
             << (QList<int>() << 0)
             << (QList<QByteArray>() << QByteArray("CustomUnregisteredType"))
             << (QList<QByteArray>() << QByteArray("constructorCustomUnregisteredTypeArg"))
@@ -536,7 +546,7 @@ void tst_QMetaMethod::method_data()
 
         QTest::newRow("MethodTestObject(bool,int,uint,qlonglong,qulonglong,double,long,short,char,ulong,ushort,uchar,float)")
                 << QByteArray("MethodTestObject(bool,int,uint,qlonglong,qulonglong,double,long,short,char,ulong,ushort,uchar,float)")
-                << int(QMetaType::Void) << QByteArray("")
+                << int(QMetaType::UnknownType) << QByteArray("")
                 << parameterTypes << parameterTypeNames << parameterNames
                 << QMetaMethod::Public
                 << QMetaMethod::Constructor;
@@ -544,7 +554,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidSignalNoParameterNames")
             << QByteArray("voidSignalNoParameterNames(bool,int)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << int(QMetaType::Bool) << int(QMetaType::Int))
             << (QList<QByteArray>() << QByteArray("bool") << QByteArray("int"))
             << (QList<QByteArray>() << QByteArray("") << QByteArray(""))
@@ -553,7 +563,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidInvokableNoParameterNames")
             << QByteArray("voidInvokableNoParameterNames(bool,int)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << int(QMetaType::Bool) << int(QMetaType::Int))
             << (QList<QByteArray>() << QByteArray("bool") << QByteArray("int"))
             << (QList<QByteArray>() << QByteArray("") << QByteArray(""))
@@ -562,7 +572,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("voidSlotNoParameterNames")
             << QByteArray("voidSlotNoParameterNames(bool,int)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::Void) << QByteArray("void")
             << (QList<int>() << int(QMetaType::Bool) << int(QMetaType::Int))
             << (QList<QByteArray>() << QByteArray("bool") << QByteArray("int"))
             << (QList<QByteArray>() << QByteArray("") << QByteArray(""))
@@ -571,7 +581,7 @@ void tst_QMetaMethod::method_data()
 
     QTest::newRow("MethodTestObject(bool,int)")
             << QByteArray("MethodTestObject(bool,int)")
-            << int(QMetaType::Void) << QByteArray("")
+            << int(QMetaType::UnknownType) << QByteArray("")
             << (QList<int>() << int(QMetaType::Bool) << int(QMetaType::Int))
             << (QList<QByteArray>() << QByteArray("bool") << QByteArray("int"))
             << (QList<QByteArray>() << QByteArray("") << QByteArray(""))
@@ -603,15 +613,51 @@ void tst_QMetaMethod::method()
     QCOMPARE(method.methodType(), methodType);
     QCOMPARE(method.access(), access);
 
-    QCOMPARE(method.signature(), signature.constData());
+    QVERIFY(!method.methodSignature().isEmpty());
+    if (method.methodSignature() != signature) {
+        // QMetaMethod should always produce a semantically equivalent signature
+        int signatureIndex = (methodType == QMetaMethod::Constructor)
+                ? mo->indexOfConstructor(method.methodSignature())
+                : mo->indexOfMethod(method.methodSignature());
+        QCOMPARE(signatureIndex, index);
+    }
 
-    QCOMPARE(method.tag(), "");
+    QByteArray computedName = signature.left(signature.indexOf('('));
+    QCOMPARE(method.name(), computedName);
 
-    QCOMPARE(method.typeName(), returnTypeName.constData());
-    QCOMPARE(QMetaType::type(method.typeName()), returnType);
+    QCOMPARE(method.tag(), "");
+    QCOMPARE(method.returnType(), returnType);
+    QVERIFY(method.typeName() != 0);
+    if (QByteArray(method.typeName()) != returnTypeName) {
+        // QMetaMethod should always produce a semantically equivalent typename
+        QCOMPARE(QMetaType::type(method.typeName()), QMetaType::type(returnTypeName));
+    }
 
-    QCOMPARE(method.parameterTypes(), parameterTypeNames);
+    if (method.parameterTypes() != parameterTypeNames) {
+        // QMetaMethod should always produce semantically equivalent typenames
+        QList<QByteArray> actualTypeNames = method.parameterTypes();
+        QCOMPARE(actualTypeNames.size(), parameterTypeNames.size());
+        for (int i = 0; i < parameterTypeNames.size(); ++i) {
+            QCOMPARE(QMetaType::type(actualTypeNames.at(i)),
+                     QMetaType::type(parameterTypeNames.at(i)));
+        }
+    }
     QCOMPARE(method.parameterNames(), parameterNames);
+
+    QCOMPARE(method.parameterCount(), parameterTypes.size());
+    for (int i = 0; i < parameterTypes.size(); ++i)
+        QCOMPARE(method.parameterType(i), parameterTypes.at(i));
+
+    {
+        QVector<int> actualParameterTypes(parameterTypes.size());
+        method.getParameterTypes(actualParameterTypes.data());
+        for (int i = 0; i < parameterTypes.size(); ++i)
+            QCOMPARE(actualParameterTypes.at(i), parameterTypes.at(i));
+    }
+
+    // Bogus indexes
+    QCOMPARE(method.parameterType(-1), 0);
+    QCOMPARE(method.parameterType(parameterTypes.size()), 0);
 }
 
 void tst_QMetaMethod::invalidMethod()
diff --git a/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp b/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
index 09fd0a7adb..5cf28b5141 100644
--- a/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
+++ b/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
@@ -816,9 +816,22 @@ void tst_QMetaObject::normalizedSignature_data()
 
     QTest::newRow("function") << "void foo()" << "void foo()";
     QTest::newRow("spaces") << " void  foo( ) " << "void foo()";
+    QTest::newRow("void") << "void foo(void)" << "void foo()";
+    QTest::newRow("void spaces") << "void foo( void )" << "void foo()";
+    QTest::newRow("void*") << "void foo(void*)" << "void foo(void*)";
+    QTest::newRow("void* spaces") << "void foo( void * )" << "void foo(void*)";
+    QTest::newRow("function ptr") << "void foo(void(*)(void))" << "void foo(void(*)())";
+    QTest::newRow("function ptr spaces") << "void foo( void ( * ) ( void ))" << "void foo(void(*)())";
+    QTest::newRow("function ptr void*") << "void foo(void(*)(void*))" << "void foo(void(*)(void*))";
+    QTest::newRow("function ptr void* spaces") << "void foo( void ( * ) ( void * ))" << "void foo(void(*)(void*))";
     QTest::newRow("template args") << " void  foo( QMap<a, a>, QList<b>) "
                                    << "void foo(QMap<a,a>,QList<b>)";
+    QTest::newRow("void template args") << " void  foo( Foo<void>, Bar<void> ) "
+                                   << "void foo(Foo<void>,Bar<void>)";
+    QTest::newRow("void* template args") << " void  foo( Foo<void*>, Bar<void *> ) "
+                                   << "void foo(Foo<void*>,Bar<void*>)";
     QTest::newRow("rettype") << "QList<int, int> foo()" << "QList<int,int>foo()";
+    QTest::newRow("rettype void template") << "Foo<void> foo()" << "Foo<void>foo()";
     QTest::newRow("const rettype") << "const QString *foo()" << "const QString*foo()";
     QTest::newRow("const ref") << "const QString &foo()" << "const QString&foo()";
     QTest::newRow("reference") << "QString &foo()" << "QString&foo()";
@@ -877,6 +890,7 @@ void tst_QMetaObject::normalizedType_data()
     QTest::newRow("struct") << "const struct foo*" << "const foo*";
     QTest::newRow("struct2") << "struct foo const*" << "const foo*";
     QTest::newRow("enum") << "enum foo" << "foo";
+    QTest::newRow("void") << "void" << "void";
 }
 
 void tst_QMetaObject::normalizedType()
@@ -978,25 +992,25 @@ void tst_QMetaObject::propertyNotify()
     QVERIFY(prop.isValid());
     QVERIFY(prop.hasNotifySignal());
     QMetaMethod signal = prop.notifySignal();
-    QCOMPARE(signal.signature(), "value6Changed()");
+    QCOMPARE(signal.methodSignature(), QByteArray("value6Changed()"));
 
     prop = mo->property(mo->indexOfProperty("value7"));
     QVERIFY(prop.isValid());
     QVERIFY(prop.hasNotifySignal());
     signal = prop.notifySignal();
-    QCOMPARE(signal.signature(), "value7Changed(QString)");
+    QCOMPARE(signal.methodSignature(), QByteArray("value7Changed(QString)"));
 
     prop = mo->property(mo->indexOfProperty("value8"));
     QVERIFY(prop.isValid());
     QVERIFY(!prop.hasNotifySignal());
     signal = prop.notifySignal();
-    QCOMPARE(signal.signature(), (const char *)0);
+    QCOMPARE(signal.methodSignature(), QByteArray());
 
     prop = mo->property(mo->indexOfProperty("value"));
     QVERIFY(prop.isValid());
     QVERIFY(!prop.hasNotifySignal());
     signal = prop.notifySignal();
-    QCOMPARE(signal.signature(), (const char *)0);
+    QCOMPARE(signal.methodSignature(), QByteArray());
 }
 
 void tst_QMetaObject::propertyConstant()
@@ -1114,7 +1128,7 @@ void tst_QMetaObject::indexOfMethod()
     QFETCH(bool, isSignal);
     int idx = object->metaObject()->indexOfMethod(name);
     QVERIFY(idx >= 0);
-    QCOMPARE(object->metaObject()->method(idx).signature(), name.constData());
+    QCOMPARE(object->metaObject()->method(idx).methodSignature(), name);
     QCOMPARE(object->metaObject()->indexOfSlot(name), isSignal ? -1 : idx);
     QCOMPARE(object->metaObject()->indexOfSignal(name), !isSignal ? -1 : idx);
 }
diff --git a/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp b/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp
index 97b14a374e..4b0a64ab54 100644
--- a/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp
+++ b/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp
@@ -217,6 +217,7 @@ void tst_QMetaObjectBuilder::method()
     QCOMPARE(nullMethod.signature(), QByteArray());
     QVERIFY(nullMethod.methodType() == QMetaMethod::Method);
     QVERIFY(nullMethod.returnType().isEmpty());
+    QVERIFY(nullMethod.parameterTypes().isEmpty());
     QVERIFY(nullMethod.parameterNames().isEmpty());
     QVERIFY(nullMethod.tag().isEmpty());
     QVERIFY(nullMethod.access() == QMetaMethod::Public);
@@ -228,7 +229,8 @@ void tst_QMetaObjectBuilder::method()
     QMetaMethodBuilder method1 = builder.addMethod("foo(const QString&, int)");
     QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
     QVERIFY(method1.methodType() == QMetaMethod::Method);
-    QVERIFY(method1.returnType().isEmpty());
+    QCOMPARE(method1.returnType(), QByteArray("void"));
+    QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QVERIFY(method1.parameterNames().isEmpty());
     QVERIFY(method1.tag().isEmpty());
     QVERIFY(method1.access() == QMetaMethod::Public);
@@ -242,6 +244,7 @@ void tst_QMetaObjectBuilder::method()
     QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
     QVERIFY(method2.methodType() == QMetaMethod::Method);
     QCOMPARE(method2.returnType(), QByteArray("int"));
+    QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
     QVERIFY(method2.parameterNames().isEmpty());
     QVERIFY(method2.tag().isEmpty());
     QVERIFY(method2.access() == QMetaMethod::Public);
@@ -267,6 +270,7 @@ void tst_QMetaObjectBuilder::method()
     QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
     QVERIFY(method1.methodType() == QMetaMethod::Method);
     QCOMPARE(method1.returnType(), QByteArray("int"));
+    QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QCOMPARE(method1.parameterNames(), QList<QByteArray>() << "a" << "b");
     QCOMPARE(method1.tag(), QByteArray("tag"));
     QVERIFY(method1.access() == QMetaMethod::Private);
@@ -276,6 +280,7 @@ void tst_QMetaObjectBuilder::method()
     QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
     QVERIFY(method2.methodType() == QMetaMethod::Method);
     QCOMPARE(method2.returnType(), QByteArray("int"));
+    QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
     QVERIFY(method2.parameterNames().isEmpty());
     QVERIFY(method2.tag().isEmpty());
     QVERIFY(method2.access() == QMetaMethod::Public);
@@ -296,6 +301,7 @@ void tst_QMetaObjectBuilder::method()
     QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
     QVERIFY(method1.methodType() == QMetaMethod::Method);
     QCOMPARE(method1.returnType(), QByteArray("int"));
+    QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QCOMPARE(method1.parameterNames(), QList<QByteArray>() << "a" << "b");
     QCOMPARE(method1.tag(), QByteArray("tag"));
     QVERIFY(method1.access() == QMetaMethod::Private);
@@ -305,6 +311,7 @@ void tst_QMetaObjectBuilder::method()
     QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
     QVERIFY(method2.methodType() == QMetaMethod::Method);
     QCOMPARE(method2.returnType(), QByteArray("QString"));
+    QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
     QCOMPARE(method2.parameterNames(), QList<QByteArray>() << "c");
     QCOMPARE(method2.tag(), QByteArray("Q_FOO"));
     QVERIFY(method2.access() == QMetaMethod::Protected);
@@ -320,6 +327,7 @@ void tst_QMetaObjectBuilder::method()
     QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
     QVERIFY(method2.methodType() == QMetaMethod::Method);
     QCOMPARE(method2.returnType(), QByteArray("QString"));
+    QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
     QCOMPARE(method2.parameterNames(), QList<QByteArray>() << "c");
     QCOMPARE(method2.tag(), QByteArray("Q_FOO"));
     QVERIFY(method2.access() == QMetaMethod::Protected);
@@ -346,7 +354,8 @@ void tst_QMetaObjectBuilder::slot()
     QMetaMethodBuilder method1 = builder.addSlot("foo(const QString&, int)");
     QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
     QVERIFY(method1.methodType() == QMetaMethod::Slot);
-    QVERIFY(method1.returnType().isEmpty());
+    QCOMPARE(method1.returnType(), QByteArray("void"));
+    QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QVERIFY(method1.parameterNames().isEmpty());
     QVERIFY(method1.tag().isEmpty());
     QVERIFY(method1.access() == QMetaMethod::Public);
@@ -358,7 +367,8 @@ void tst_QMetaObjectBuilder::slot()
     QMetaMethodBuilder method2 = builder.addSlot("bar(QString)");
     QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
     QVERIFY(method2.methodType() == QMetaMethod::Slot);
-    QVERIFY(method2.returnType().isEmpty());
+    QCOMPARE(method2.returnType(), QByteArray("void"));
+    QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
     QVERIFY(method2.parameterNames().isEmpty());
     QVERIFY(method2.tag().isEmpty());
     QVERIFY(method2.access() == QMetaMethod::Public);
@@ -383,7 +393,8 @@ void tst_QMetaObjectBuilder::signal()
     QMetaMethodBuilder method1 = builder.addSignal("foo(const QString&, int)");
     QCOMPARE(method1.signature(), QByteArray("foo(QString,int)"));
     QVERIFY(method1.methodType() == QMetaMethod::Signal);
-    QVERIFY(method1.returnType().isEmpty());
+    QCOMPARE(method1.returnType(), QByteArray("void"));
+    QCOMPARE(method1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QVERIFY(method1.parameterNames().isEmpty());
     QVERIFY(method1.tag().isEmpty());
     QVERIFY(method1.access() == QMetaMethod::Protected);
@@ -395,7 +406,8 @@ void tst_QMetaObjectBuilder::signal()
     QMetaMethodBuilder method2 = builder.addSignal("bar(QString)");
     QCOMPARE(method2.signature(), QByteArray("bar(QString)"));
     QVERIFY(method2.methodType() == QMetaMethod::Signal);
-    QVERIFY(method2.returnType().isEmpty());
+    QCOMPARE(method2.returnType(), QByteArray("void"));
+    QCOMPARE(method2.parameterTypes(), QList<QByteArray>() << "QString");
     QVERIFY(method2.parameterNames().isEmpty());
     QVERIFY(method2.tag().isEmpty());
     QVERIFY(method2.access() == QMetaMethod::Protected);
@@ -421,6 +433,7 @@ void tst_QMetaObjectBuilder::constructor()
     QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)"));
     QVERIFY(ctor1.methodType() == QMetaMethod::Constructor);
     QVERIFY(ctor1.returnType().isEmpty());
+    QCOMPARE(ctor1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QVERIFY(ctor1.parameterNames().isEmpty());
     QVERIFY(ctor1.tag().isEmpty());
     QVERIFY(ctor1.access() == QMetaMethod::Public);
@@ -433,6 +446,7 @@ void tst_QMetaObjectBuilder::constructor()
     QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));
     QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);
     QVERIFY(ctor2.returnType().isEmpty());
+    QCOMPARE(ctor2.parameterTypes(), QList<QByteArray>() << "QString");
     QVERIFY(ctor2.parameterNames().isEmpty());
     QVERIFY(ctor2.tag().isEmpty());
     QVERIFY(ctor2.access() == QMetaMethod::Public);
@@ -458,6 +472,7 @@ void tst_QMetaObjectBuilder::constructor()
     QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)"));
     QVERIFY(ctor1.methodType() == QMetaMethod::Constructor);
     QCOMPARE(ctor1.returnType(), QByteArray("int"));
+    QCOMPARE(ctor1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QCOMPARE(ctor1.parameterNames(), QList<QByteArray>() << "a" << "b");
     QCOMPARE(ctor1.tag(), QByteArray("tag"));
     QVERIFY(ctor1.access() == QMetaMethod::Private);
@@ -466,6 +481,7 @@ void tst_QMetaObjectBuilder::constructor()
     QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));
     QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);
     QVERIFY(ctor2.returnType().isEmpty());
+    QCOMPARE(ctor2.parameterTypes(), QList<QByteArray>() << "QString");
     QVERIFY(ctor2.parameterNames().isEmpty());
     QVERIFY(ctor2.tag().isEmpty());
     QVERIFY(ctor2.access() == QMetaMethod::Public);
@@ -484,6 +500,7 @@ void tst_QMetaObjectBuilder::constructor()
     QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)"));
     QVERIFY(ctor1.methodType() == QMetaMethod::Constructor);
     QCOMPARE(ctor1.returnType(), QByteArray("int"));
+    QCOMPARE(ctor1.parameterTypes(), QList<QByteArray>() << "QString" << "int");
     QCOMPARE(ctor1.parameterNames(), QList<QByteArray>() << "a" << "b");
     QCOMPARE(ctor1.tag(), QByteArray("tag"));
     QVERIFY(ctor1.access() == QMetaMethod::Private);
@@ -492,6 +509,7 @@ void tst_QMetaObjectBuilder::constructor()
     QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));
     QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);
     QCOMPARE(ctor2.returnType(), QByteArray("QString"));
+    QCOMPARE(ctor2.parameterTypes(), QList<QByteArray>() << "QString");
     QCOMPARE(ctor2.parameterNames(), QList<QByteArray>() << "c");
     QCOMPARE(ctor2.tag(), QByteArray("Q_FOO"));
     QVERIFY(ctor2.access() == QMetaMethod::Protected);
@@ -506,6 +524,7 @@ void tst_QMetaObjectBuilder::constructor()
     QCOMPARE(ctor2.signature(), QByteArray("bar(QString)"));
     QVERIFY(ctor2.methodType() == QMetaMethod::Constructor);
     QCOMPARE(ctor2.returnType(), QByteArray("QString"));
+    QCOMPARE(ctor2.parameterTypes(), QList<QByteArray>() << "QString");
     QCOMPARE(ctor2.parameterNames(), QList<QByteArray>() << "c");
     QCOMPARE(ctor2.tag(), QByteArray("Q_FOO"));
     QVERIFY(ctor2.access() == QMetaMethod::Protected);
@@ -525,6 +544,7 @@ void tst_QMetaObjectBuilder::constructor()
     QCOMPARE(prototypeConstructor.signature(), QByteArray("SomethingOfEverything()"));
     QVERIFY(prototypeConstructor.methodType() == QMetaMethod::Constructor);
     QCOMPARE(prototypeConstructor.returnType(), QByteArray());
+    QVERIFY(prototypeConstructor.parameterTypes().isEmpty());
     QVERIFY(prototypeConstructor.access() == QMetaMethod::Public);
     QCOMPARE(prototypeConstructor.index(), 1);
 
@@ -754,7 +774,7 @@ void tst_QMetaObjectBuilder::variantProperty()
     QCOMPARE(QMetaType::Type(prop.userType()), QMetaType::QVariant);
     QCOMPARE(QByteArray(prop.typeName()), QByteArray("QVariant"));
 
-    qFree(meta);
+    free(meta);
 }
 
 void tst_QMetaObjectBuilder::notifySignal()
@@ -1161,12 +1181,15 @@ bool tst_QMetaObjectBuilder::checkForSideEffects
 
 static bool sameMethod(const QMetaMethod& method1, const QMetaMethod& method2)
 {
-    if (QByteArray(method1.signature()) != QByteArray(method2.signature()))
+    if (method1.methodSignature() != method2.methodSignature())
         return false;
 
     if (QByteArray(method1.typeName()) != QByteArray(method2.typeName()))
         return false;
 
+    if (method1.parameterTypes() != method2.parameterTypes())
+        return false;
+
     if (method1.parameterNames() != method2.parameterNames())
         return false;
 
@@ -1391,7 +1414,7 @@ TestObject::TestObject(QObject *parent)
 
 TestObject::~TestObject()
 {
-    qFree(m_metaObject);
+    free(m_metaObject);
 }
 
 QMetaObject *TestObject::buildMetaObject()
@@ -1466,7 +1489,7 @@ void TestObject::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id,
             if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
         default: {
             QMetaMethod ctor = _o->metaObject()->constructor(_id);
-            qFatal("You forgot to add a case for CreateInstance %s", ctor.signature());
+            qFatal("You forgot to add a case for CreateInstance %s", ctor.methodSignature().constData());
           }
         }
     } else if (_c == QMetaObject::InvokeMetaMethod) {
@@ -1478,7 +1501,7 @@ void TestObject::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id,
         case 2: *reinterpret_cast<QVariantList(*)>(_a[0]) = _t->listInvokableQRealQString(*reinterpret_cast<qreal(*)>(_a[1]), *reinterpret_cast<QString(*)>(_a[2])); break;
         default: {
             QMetaMethod method = _o->metaObject()->method(_o->metaObject()->methodOffset() + _id);
-            qFatal("You forgot to add a case for InvokeMetaMethod %s", method.signature());
+            qFatal("You forgot to add a case for InvokeMetaMethod %s", method.methodSignature().constData());
           }
         }
     } else if (_c == QMetaObject::IndexOfMethod) {
diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
index 09bd9fe445..4eb26928ac 100644
--- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
+++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
@@ -97,16 +97,36 @@ private slots:
     void isEnum();
     void registerStreamBuiltin();
     void automaticTemplateRegistration();
+    void saveAndLoadBuiltin_data();
+    void saveAndLoadBuiltin();
+    void saveAndLoadCustom();
 };
 
 struct Foo { int i; };
 
+
+class CustomQObject : public QObject
+{
+    Q_OBJECT
+public:
+    CustomQObject(QObject *parent = 0)
+      : QObject(parent)
+    {
+    }
+};
+
+class CustomNonQObject {};
+
 void tst_QMetaType::defined()
 {
     QCOMPARE(int(QMetaTypeId2<QString>::Defined), 1);
     QCOMPARE(int(QMetaTypeId2<Foo>::Defined), 0);
     QCOMPARE(int(QMetaTypeId2<void*>::Defined), 1);
     QCOMPARE(int(QMetaTypeId2<int*>::Defined), 0);
+    QVERIFY(QMetaTypeId2<CustomQObject*>::Defined);
+    QVERIFY(!QMetaTypeId2<CustomQObject>::Defined);
+    QVERIFY(!QMetaTypeId2<CustomNonQObject>::Defined);
+    QVERIFY(!QMetaTypeId2<CustomNonQObject*>::Defined);
 }
 
 struct Bar
@@ -312,6 +332,7 @@ void tst_QMetaType::typeName_data()
     QTest::addColumn<QString>("aTypeName");
 
     QT_FOR_EACH_STATIC_TYPE(TYPENAME_DATA)
+    QTest::newRow("QMetaType::UnknownType") << QMetaType::UnknownType << static_cast<const char*>(0);
 
     QTest::newRow("Whity<double>") << static_cast<QMetaType::Type>(::qMetaTypeId<Whity<double> >()) << QString::fromLatin1("Whity<double>");
     QTest::newRow("Whity<int>") << static_cast<QMetaType::Type>(::qMetaTypeId<Whity<int> >()) << QString::fromLatin1("Whity<int>");
@@ -510,6 +531,46 @@ template<> struct TestValueFactory<QMetaType::QRegExp> {
 #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")); }
 };
@@ -630,6 +691,8 @@ void tst_QMetaType::sizeOf_data()
 {
     QTest::addColumn<QMetaType::Type>("type");
     QTest::addColumn<size_t>("size");
+
+    QTest::newRow("QMetaType::UnknownType") << QMetaType::UnknownType << size_t(0);
 #define ADD_METATYPE_TEST_ROW(MetaTypeName, MetaTypeId, RealType) \
     QTest::newRow(#RealType) << QMetaType::MetaTypeName << size_t(QTypeInfo<RealType>::sizeOf);
 FOR_EACH_CORE_METATYPE(ADD_METATYPE_TEST_ROW)
@@ -805,41 +868,15 @@ void tst_QMetaType::construct_data()
     create_data();
 }
 
-#ifndef Q_ALIGNOF
-template<uint N>
-struct RoundToNextHighestPowerOfTwo
-{
-private:
-    enum { V1 = N-1 };
-    enum { V2 = V1 | (V1 >> 1) };
-    enum { V3 = V2 | (V2 >> 2) };
-    enum { V4 = V3 | (V3 >> 4) };
-    enum { V5 = V4 | (V4 >> 8) };
-    enum { V6 = V5 | (V5 >> 16) };
-public:
-    enum { Value = V6 + 1 };
-};
-#endif
-
-template<class T>
-struct TypeAlignment
-{
-#ifdef Q_ALIGNOF
-    enum { Value = Q_ALIGNOF(T) };
-#else
-    enum { Value = RoundToNextHighestPowerOfTwo<sizeof(T)>::Value };
-#endif
-};
-
 template<int ID>
 static void testConstructHelper()
 {
     typedef typename MetaEnumToType<ID>::Type Type;
     QMetaType info(ID);
     int size = info.sizeOf();
-    void *storage1 = qMallocAligned(size, TypeAlignment<Type>::Value);
+    void *storage1 = qMallocAligned(size, Q_ALIGNOF(Type));
     void *actual1 = QMetaType::construct(ID, storage1, /*copy=*/0);
-    void *storage2 = qMallocAligned(size, TypeAlignment<Type>::Value);
+    void *storage2 = qMallocAligned(size, Q_ALIGNOF(Type));
     void *actual2 = info.construct(storage2, /*copy=*/0);
     QCOMPARE(actual1, storage1);
     QCOMPARE(actual2, storage2);
@@ -908,9 +945,9 @@ static void testConstructCopyHelper()
     QMetaType info(ID);
     int size = QMetaType::sizeOf(ID);
     QCOMPARE(info.sizeOf(), size);
-    void *storage1 = qMallocAligned(size, TypeAlignment<Type>::Value);
+    void *storage1 = qMallocAligned(size, Q_ALIGNOF(Type));
     void *actual1 = QMetaType::construct(ID, storage1, expected);
-    void *storage2 = qMallocAligned(size, TypeAlignment<Type>::Value);
+    void *storage2 = qMallocAligned(size, Q_ALIGNOF(Type));
     void *actual2 = info.construct(storage2, expected);
     QCOMPARE(actual1, storage1);
     QCOMPARE(actual2, storage2);
@@ -1052,6 +1089,7 @@ void tst_QMetaType::isRegistered_data()
     QTest::newRow("-1") << -1 << false;
     QTest::newRow("-42") << -42 << false;
     QTest::newRow("IsRegisteredDummyType + 1") << (dummyTypeId + 1) << false;
+    QTest::newRow("QMetaType::UnknownType") << int(QMetaType::UnknownType) << false;
 }
 
 void tst_QMetaType::isRegistered()
@@ -1291,6 +1329,133 @@ void tst_QMetaType::automaticTemplateRegistration()
   }
 }
 
+template <typename T>
+struct StreamingTraits
+{
+    enum { isStreamable = 1 }; // Streamable by default
+};
+
+// Non-streamable types
+
+#define DECLARE_NONSTREAMABLE(Type) \
+    template<> struct StreamingTraits<Type> { enum { isStreamable = 0 }; };
+
+DECLARE_NONSTREAMABLE(void)
+DECLARE_NONSTREAMABLE(void*)
+DECLARE_NONSTREAMABLE(QModelIndex)
+DECLARE_NONSTREAMABLE(QJsonValue)
+DECLARE_NONSTREAMABLE(QJsonObject)
+DECLARE_NONSTREAMABLE(QJsonArray)
+DECLARE_NONSTREAMABLE(QJsonDocument)
+DECLARE_NONSTREAMABLE(QObject*)
+DECLARE_NONSTREAMABLE(QWidget*)
+
+#define DECLARE_GUI_CLASS_NONSTREAMABLE(MetaTypeName, MetaTypeId, RealType) \
+    DECLARE_NONSTREAMABLE(RealType)
+QT_FOR_EACH_STATIC_GUI_CLASS(DECLARE_GUI_CLASS_NONSTREAMABLE)
+#undef DECLARE_GUI_CLASS_NONSTREAMABLE
+
+#define DECLARE_WIDGETS_CLASS_NONSTREAMABLE(MetaTypeName, MetaTypeId, RealType) \
+    DECLARE_NONSTREAMABLE(RealType)
+QT_FOR_EACH_STATIC_WIDGETS_CLASS(DECLARE_WIDGETS_CLASS_NONSTREAMABLE)
+#undef DECLARE_WIDGETS_CLASS_NONSTREAMABLE
+
+#undef DECLARE_NONSTREAMABLE
+
+void tst_QMetaType::saveAndLoadBuiltin_data()
+{
+    QTest::addColumn<int>("type");
+    QTest::addColumn<bool>("isStreamable");
+
+#define ADD_METATYPE_TEST_ROW(MetaTypeName, MetaTypeId, RealType) \
+    QTest::newRow(#RealType) << MetaTypeId << bool(StreamingTraits<RealType>::isStreamable);
+    QT_FOR_EACH_STATIC_TYPE(ADD_METATYPE_TEST_ROW)
+#undef ADD_METATYPE_TEST_ROW
+}
+
+void tst_QMetaType::saveAndLoadBuiltin()
+{
+    QFETCH(int, type);
+    QFETCH(bool, isStreamable);
+
+    void *value = QMetaType::create(type);
+
+    QByteArray ba;
+    QDataStream stream(&ba, QIODevice::ReadWrite);
+    QCOMPARE(QMetaType::save(stream, type, value), isStreamable);
+    QCOMPARE(stream.status(), QDataStream::Ok);
+
+    if (isStreamable) {
+        QVERIFY(QMetaType::load(stream, type, value)); // Hmmm, shouldn't it return false?
+        QCOMPARE(stream.status(), QDataStream::ReadPastEnd);
+    }
+
+    stream.device()->seek(0);
+    stream.resetStatus();
+    QCOMPARE(QMetaType::load(stream, type, value), isStreamable);
+    QCOMPARE(stream.status(), QDataStream::Ok);
+
+    if (isStreamable) {
+        QVERIFY(QMetaType::load(stream, type, value)); // Hmmm, shouldn't it return false?
+        QCOMPARE(stream.status(), QDataStream::ReadPastEnd);
+    }
+
+    QMetaType::destroy(type, value);
+}
+
+struct CustomStreamableType
+{
+    int a;
+};
+Q_DECLARE_METATYPE(CustomStreamableType)
+
+QDataStream &operator<<(QDataStream &out, const CustomStreamableType &t)
+{
+    out << t.a; return out;
+}
+
+QDataStream &operator>>(QDataStream &in, CustomStreamableType &t)
+{
+    int a;
+    in >> a;
+    if (in.status() == QDataStream::Ok)
+        t.a = a;
+    return in;
+}
+
+void tst_QMetaType::saveAndLoadCustom()
+{
+    CustomStreamableType t;
+    t.a = 123;
+
+    int id = ::qMetaTypeId<CustomStreamableType>();
+    QByteArray ba;
+    QDataStream stream(&ba, QIODevice::ReadWrite);
+    QVERIFY(!QMetaType::save(stream, id, &t));
+    QCOMPARE(stream.status(), QDataStream::Ok);
+    QVERIFY(!QMetaType::load(stream, id, &t));
+    QCOMPARE(stream.status(), QDataStream::Ok);
+
+    qRegisterMetaTypeStreamOperators<CustomStreamableType>("CustomStreamableType");
+    QVERIFY(QMetaType::save(stream, id, &t));
+    QCOMPARE(stream.status(), QDataStream::Ok);
+
+    CustomStreamableType t2;
+    t2.a = -1;
+    QVERIFY(QMetaType::load(stream, id, &t2)); // Hmmm, shouldn't it return false?
+    QCOMPARE(stream.status(), QDataStream::ReadPastEnd);
+    QCOMPARE(t2.a, -1);
+
+    stream.device()->seek(0);
+    stream.resetStatus();
+    QVERIFY(QMetaType::load(stream, id, &t2));
+    QCOMPARE(stream.status(), QDataStream::Ok);
+    QCOMPARE(t2.a, t.a);
+
+    QVERIFY(QMetaType::load(stream, id, &t2)); // Hmmm, shouldn't it return false?
+    QCOMPARE(stream.status(), QDataStream::ReadPastEnd);
+}
+
 // Compile-time test, it should be possible to register function pointer types
 class Undefined;
 
diff --git a/tests/auto/corelib/kernel/qobject/moc_oldnormalizeobject.cpp b/tests/auto/corelib/kernel/qobject/moc_oldnormalizeobject.cpp
deleted file mode 100644
index 2d180b88ea..0000000000
--- a/tests/auto/corelib/kernel/qobject/moc_oldnormalizeobject.cpp
+++ /dev/null
@@ -1,154 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/
-**
-** This file is part of the test suite of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** GNU Lesser General Public License Usage
-** This file may be used under the terms of the GNU Lesser General Public
-** License version 2.1 as published by the Free Software Foundation and
-** appearing in the file LICENSE.LGPL included in the packaging of this
-** file. Please review the following information to ensure the GNU Lesser
-** General Public License version 2.1 requirements will be met:
-** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU General
-** Public License version 3.0 as published by the Free Software Foundation
-** and appearing in the file LICENSE.GPL included in the packaging of this
-** file. Please review the following information to ensure the GNU General
-** Public License version 3.0 requirements will be met:
-** http://www.gnu.org/copyleft/gpl.html.
-**
-** Other Usage
-** Alternatively, this file may be used in accordance with the terms and
-** conditions contained in a signed written agreement between you and Nokia.
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-/****************************************************************************
-** Meta object code from reading C++ file 'oldnormalizeobject.h'
-**
-** Created: Wed Nov 18 11:43:05 2009
-**      by: The Qt Meta Object Compiler version 62 (Qt 4.6.0)
-**
-*****************************************************************************/
-
-// Yhis file was generated from moc version 4.6 to test binary compatibility
-// It should *not* be generated by the current moc
-
-#include "oldnormalizeobject.h"
-
-QT_BEGIN_MOC_NAMESPACE
-static const uint qt_meta_data_OldNormalizeObject[] = {
-
- // content:
-       4,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       6,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       3,       // signalCount
-
- // signals: signature, parameters, type, tag, flags
-      24,   20,   19,   19, 0x05,
-      57,   20,   19,   19, 0x05,
-     100,   20,   19,   19, 0x05,
-
- // slots: signature, parameters, type, tag, flags
-     149,   20,   19,   19, 0x0a,
-     180,   20,   19,   19, 0x0a,
-     221,   20,   19,   19, 0x0a,
-
-       0        // eod
-};
-
-static const char qt_meta_stringdata_OldNormalizeObject[] = {
-    "OldNormalizeObject\0\0ref\0"
-    "typeRefSignal(Template<Class&>&)\0"
-    "constTypeRefSignal(Template<const Class&>)\0"
-    "typeConstRefSignal(Template<const Class&>const&)\0"
-    "typeRefSlot(Template<Class&>&)\0"
-    "constTypeRefSlot(Template<const Class&>)\0"
-    "typeConstRefSlot(Template<const Class&>const&)\0"
-};
-
-const QMetaObject OldNormalizeObject::staticMetaObject = {
-    { &QObject::staticMetaObject, qt_meta_stringdata_OldNormalizeObject,
-      qt_meta_data_OldNormalizeObject, 0 }
-};
-
-#ifdef Q_NO_DATA_RELOCATION
-const QMetaObject &OldNormalizeObject::getStaticMetaObject() { return staticMetaObject; }
-#endif //Q_NO_DATA_RELOCATION
-
-const QMetaObject *OldNormalizeObject::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
-}
-
-void *OldNormalizeObject::qt_metacast(const char *_clname)
-{
-    if (!_clname) return 0;
-    if (!strcmp(_clname, qt_meta_stringdata_OldNormalizeObject))
-        return static_cast<void*>(const_cast< OldNormalizeObject*>(this));
-    return QObject::qt_metacast(_clname);
-}
-
-int OldNormalizeObject::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QObject::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        switch (_id) {
-        case 0: typeRefSignal((*reinterpret_cast< Template<Class&>(*)>(_a[1]))); break;
-        case 1: constTypeRefSignal((*reinterpret_cast< const Template<const Class&>(*)>(_a[1]))); break;
-        case 2: typeConstRefSignal((*reinterpret_cast< Template<const Class&>const(*)>(_a[1]))); break;
-        case 3: typeRefSlot((*reinterpret_cast< Template<Class&>(*)>(_a[1]))); break;
-        case 4: constTypeRefSlot((*reinterpret_cast< const Template<const Class&>(*)>(_a[1]))); break;
-        case 5: typeConstRefSlot((*reinterpret_cast< Template<const Class&>const(*)>(_a[1]))); break;
-        default: ;
-        }
-        _id -= 6;
-    }
-    return _id;
-}
-
-// SIGNAL 0
-void OldNormalizeObject::typeRefSignal(Template<Class&> & _t1)
-{
-    void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
-    QMetaObject::activate(this, &staticMetaObject, 0, _a);
-}
-
-// SIGNAL 1
-void OldNormalizeObject::constTypeRefSignal(const Template<const Class&> & _t1)
-{
-    void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
-    QMetaObject::activate(this, &staticMetaObject, 1, _a);
-}
-
-// SIGNAL 2
-void OldNormalizeObject::typeConstRefSignal(Template<Class const&> const & _t1)
-{
-    void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
-    QMetaObject::activate(this, &staticMetaObject, 2, _a);
-}
-QT_END_MOC_NAMESPACE
diff --git a/tests/auto/corelib/kernel/qobject/oldnormalizeobject.h b/tests/auto/corelib/kernel/qobject/oldnormalizeobject.h
deleted file mode 100644
index f73027707a..0000000000
--- a/tests/auto/corelib/kernel/qobject/oldnormalizeobject.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/
-**
-** This file is part of the QtTest module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** GNU Lesser General Public License Usage
-** This file may be used under the terms of the GNU Lesser General Public
-** License version 2.1 as published by the Free Software Foundation and
-** appearing in the file LICENSE.LGPL included in the packaging of this
-** file. Please review the following information to ensure the GNU Lesser
-** General Public License version 2.1 requirements will be met:
-** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU General
-** Public License version 3.0 as published by the Free Software Foundation
-** and appearing in the file LICENSE.GPL included in the packaging of this
-** file. Please review the following information to ensure the GNU General
-** Public License version 3.0 requirements will be met:
-** http://www.gnu.org/copyleft/gpl.html.
-**
-** Other Usage
-** Alternatively, this file may be used in accordance with the terms and
-** conditions contained in a signed written agreement between you and Nokia.
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef OLDNORMALIZEOBJECT_H
-#define OLDNORMALIZEOBJECT_H
-
-#include <QObject>
-
-struct Struct;
-class Class;
-template <typename T> class Template;
-
-// An object with old moc output that incorrectly normalizes 'T<C> const &' in the function
-// signatures
-class OldNormalizeObject : public QObject
-{
-    /* tmake ignore Q_OBJECT */
-    Q_OBJECT
-
-signals:
-    void typeRefSignal(Template<Class &> &ref);
-    void constTypeRefSignal(const Template<const Class &> &ref);
-    void typeConstRefSignal(Template<Class const &> const &ref);
-
-public slots:
-    void typeRefSlot(Template<Class &> &) {}
-    void constTypeRefSlot(const Template<const Class &> &) {}
-    void typeConstRefSlot(Template<Class const &> const &) {}
-};
-
-#endif // OLDNORMALIZEOBJECT_H
diff --git a/tests/auto/corelib/kernel/qobject/test/test.pro b/tests/auto/corelib/kernel/qobject/test/test.pro
index c08f910f8f..824223db15 100644
--- a/tests/auto/corelib/kernel/qobject/test/test.pro
+++ b/tests/auto/corelib/kernel/qobject/test/test.pro
@@ -3,9 +3,5 @@ TARGET = ../tst_qobject
 QT = core-private network testlib
 SOURCES = ../tst_qobject.cpp
 
-# this is here for a reason, moc_oldnormalizedobject.cpp is not auto-generated, it was generated by
-# moc from Qt 4.6, and should *not* be generated by the current moc
-SOURCES += ../moc_oldnormalizeobject.cpp
-
 load(testcase) # for target.path and installTestHelperApp()
 installTestHelperApp("../signalbug/signalbug",signalbug,signalbug)
diff --git a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
index f7f13e65ea..f429af7ce2 100644
--- a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
+++ b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
@@ -45,6 +45,7 @@
 #include <qpointer.h>
 #include <qtimer.h>
 #include <qregexp.h>
+#include <qregularexpression.h>
 #include <qmetaobject.h>
 #include <qvariant.h>
 #include <QTcpServer>
@@ -164,6 +165,7 @@ signals:
     void signal3();
     void signal4();
     QT_MOC_COMPAT void signal5();
+    void signal6(void);
 
 public slots:
     void aPublicSlot() { aPublicSlotCalled++; }
@@ -656,6 +658,26 @@ void tst_QObject::findChildren()
     l = qFindChildren<QObject*>(&o, QRegExp("harry"));
     QCOMPARE(l.size(), 0);
 
+    l = o.findChildren<QObject*>(QRegularExpression("o.*"));
+    QCOMPARE(l.size(), 5);
+    QVERIFY(l.contains(&o1));
+    QVERIFY(l.contains(&o2));
+    QVERIFY(l.contains(&o11));
+    QVERIFY(l.contains(&o12));
+    QVERIFY(l.contains(&o111));
+    l = o.findChildren<QObject*>(QRegularExpression("t.*"));
+    QCOMPARE(l.size(), 2);
+    QVERIFY(l.contains(&t1));
+    QVERIFY(l.contains(&t121));
+    tl = o.findChildren<QTimer*>(QRegularExpression(".*"));
+    QCOMPARE(tl.size(), 3);
+    QVERIFY(tl.contains(&t1));
+    QVERIFY(tl.contains(&t121));
+    tl = o.findChildren<QTimer*>(QRegularExpression("o.*"));
+    QCOMPARE(tl.size(), 0);
+    l = o.findChildren<QObject*>(QRegularExpression("harry"));
+    QCOMPARE(l.size(), 0);
+
     // empty and null string check
     op = qFindChild<QObject*>(&o);
     QCOMPARE(op, &o1);
@@ -803,6 +825,8 @@ void tst_QObject::connectDisconnectNotify_data()
     QTest::newRow("combo2") << SIGNAL( signal2(void) )    << SLOT( slot2(  ) );
     QTest::newRow("combo3") << SIGNAL( signal3(  ) )      << SLOT( slot3(void) );
     QTest::newRow("combo4") << SIGNAL(  signal4( void )  )<< SLOT(  slot4( void )  );
+    QTest::newRow("combo5") << SIGNAL( signal6( void ) )  << SLOT( slot4() );
+    QTest::newRow("combo6") << SIGNAL( signal6() )        << SLOT( slot4() );
 }
 
 void tst_QObject::connectDisconnectNotify()
@@ -1793,56 +1817,56 @@ void tst_QObject::metamethod()
     QMetaMethod m;
 
     m = mobj->method(mobj->indexOfMethod("invoke1()"));
-    QVERIFY(QByteArray(m.signature()) == "invoke1()");
+    QVERIFY(m.methodSignature() == "invoke1()");
     QVERIFY(m.methodType() == QMetaMethod::Method);
     QVERIFY(m.access() == QMetaMethod::Public);
     QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
     QVERIFY(!(m.attributes() & QMetaMethod::Compatibility));
 
     m = mobj->method(mobj->indexOfMethod("sinvoke1()"));
-    QVERIFY(QByteArray(m.signature()) == "sinvoke1()");
+    QVERIFY(m.methodSignature() == "sinvoke1()");
     QVERIFY(m.methodType() == QMetaMethod::Method);
     QVERIFY(m.access() == QMetaMethod::Public);
     QVERIFY((m.attributes() & QMetaMethod::Scriptable));
     QVERIFY(!(m.attributes() & QMetaMethod::Compatibility));
 
     m = mobj->method(mobj->indexOfMethod("invoke2()"));
-    QVERIFY(QByteArray(m.signature()) == "invoke2()");
+    QVERIFY(m.methodSignature() == "invoke2()");
     QVERIFY(m.methodType() == QMetaMethod::Method);
     QVERIFY(m.access() == QMetaMethod::Protected);
     QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
     QVERIFY((m.attributes() & QMetaMethod::Compatibility));
 
     m = mobj->method(mobj->indexOfMethod("sinvoke2()"));
-    QVERIFY(QByteArray(m.signature()) == "sinvoke2()");
+    QVERIFY(m.methodSignature() == "sinvoke2()");
     QVERIFY(m.methodType() == QMetaMethod::Method);
     QVERIFY(m.access() == QMetaMethod::Protected);
     QVERIFY((m.attributes() & QMetaMethod::Scriptable));
     QVERIFY((m.attributes() & QMetaMethod::Compatibility));
 
     m = mobj->method(mobj->indexOfMethod("invoke3()"));
-    QVERIFY(QByteArray(m.signature()) == "invoke3()");
+    QVERIFY(m.methodSignature() == "invoke3()");
     QVERIFY(m.methodType() == QMetaMethod::Method);
     QVERIFY(m.access() == QMetaMethod::Private);
     QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
     QVERIFY(!(m.attributes() & QMetaMethod::Compatibility));
 
     m = mobj->method(mobj->indexOfMethod("sinvoke3()"));
-    QVERIFY(QByteArray(m.signature()) == "sinvoke3()");
+    QVERIFY(m.methodSignature() == "sinvoke3()");
     QVERIFY(m.methodType() == QMetaMethod::Method);
     QVERIFY(m.access() == QMetaMethod::Private);
     QVERIFY((m.attributes() & QMetaMethod::Scriptable));
     QVERIFY(!(m.attributes() & QMetaMethod::Compatibility));
 
     m = mobj->method(mobj->indexOfMethod("signal5()"));
-    QVERIFY(QByteArray(m.signature()) == "signal5()");
+    QVERIFY(m.methodSignature() == "signal5()");
     QVERIFY(m.methodType() == QMetaMethod::Signal);
     QVERIFY(m.access() == QMetaMethod::Protected);
     QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
     QVERIFY((m.attributes() & QMetaMethod::Compatibility));
 
     m = mobj->method(mobj->indexOfMethod("aPublicSlot()"));
-    QVERIFY(QByteArray(m.signature()) == "aPublicSlot()");
+    QVERIFY(m.methodSignature() == "aPublicSlot()");
     QVERIFY(m.methodType() == QMetaMethod::Slot);
     QVERIFY(m.access() == QMetaMethod::Public);
     QVERIFY(!(m.attributes() & QMetaMethod::Scriptable));
@@ -2291,8 +2315,6 @@ public slots:
     void constTemplateSlot3(const Template< const int >) {}
 };
 
-#include "oldnormalizeobject.h"
-
 void tst_QObject::normalize()
 {
     NormalizeObject object;
@@ -2603,82 +2625,6 @@ void tst_QObject::normalize()
                            SIGNAL(typeConstRefSignal(Template<Class const &> const &)),
                            SLOT(typeConstRefSlot(Template<Class const &> const &))));
 
-    // same test again, this time with an object compiled with old moc output... we know that
-    // it is not possible to connect everything, whic is the purpose for this test
-    OldNormalizeObject oldobject;
-
-    QVERIFY(oldobject.connect(&oldobject,
-                              SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
-                              SLOT(constTypeRefSlot(const Template<const Class &> &))));
-    QVERIFY(oldobject.connect(&oldobject,
-                              SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
-                              SLOT(constTypeRefSlot(const Template<Class const &> &))));
-    // this fails in older versions, but passes now due to proper normalizing
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
-                               SLOT(constTypeRefSlot(Template<Class const &> const &))));
-    // this fails in older versions, but passes now due to proper normalizing
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(constTypeRefSignal(Template<const Class &> const &)),
-                               SLOT(constTypeRefSlot(Template<Class const &> const &))));
-    // this fails in older versions, but passes now due to proper normalizing
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(constTypeRefSignal(Template<Class const &> const &)),
-                               SLOT(constTypeRefSlot(Template<Class const &> const &))));
-
-    // these fail in older Qt versions, but pass now due to proper normalizing
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
-                               SLOT(typeConstRefSlot(const Template<const Class &> &))));
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
-                               SLOT(typeConstRefSlot(const Template<Class const &> &))));
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
-                               SLOT(typeConstRefSlot(Template<Class const &> const &))));
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(constTypeRefSignal(Template<const Class &> const &)),
-                               SLOT(typeConstRefSlot(Template<Class const &> const &))));
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(constTypeRefSignal(Template<Class const &> const &)),
-                               SLOT(typeConstRefSlot(Template<Class const &> const &))));
-
-    // these also fail in older Qt versions, but pass now due to proper normalizing
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
-                               SLOT(constTypeRefSlot(const Template<const Class &> &))));
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
-                               SLOT(constTypeRefSlot(const Template<Class const &> &))));
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
-                               SLOT(constTypeRefSlot(Template<Class const &> const &))));
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(typeConstRefSignal(Template<const Class &> const &)),
-                               SLOT(constTypeRefSlot(Template<Class const &> const &))));
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(typeConstRefSignal(Template<Class const &> const &)),
-                               SLOT(constTypeRefSlot(Template<Class const &> const &))));
-
-    // this fails in older versions, but passes now due to proper normalizing
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
-                               SLOT(typeConstRefSlot(const Template<const Class &> &))));
-    // this fails in older versions, but passes now due to proper normalizing
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
-                               SLOT(typeConstRefSlot(const Template<Class const &> &))));
-    // this fails in older versions, but passes now due to proper normalizing
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
-                               SLOT(typeConstRefSlot(Template<Class const &> const &))));
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(typeConstRefSignal(Template<const Class &> const &)),
-                               SLOT(typeConstRefSlot(Template<Class const &> const &))));
-    QVERIFY(oldobject.connect(&oldobject,
-                               SIGNAL(typeConstRefSignal(Template<Class const &> const &)),
-                               SLOT(typeConstRefSlot(Template<Class const &> const &))));
-
     QVERIFY(object.connect(&object,
                            SIGNAL(typePointerConstRefSignal(Class*const&)),
                            SLOT(typePointerConstRefSlot(Class*const&))));
diff --git a/tests/auto/corelib/kernel/qtimer/tst_qtimer.cpp b/tests/auto/corelib/kernel/qtimer/tst_qtimer.cpp
index 1149155726..0e42572b03 100644
--- a/tests/auto/corelib/kernel/qtimer/tst_qtimer.cpp
+++ b/tests/auto/corelib/kernel/qtimer/tst_qtimer.cpp
@@ -61,6 +61,7 @@ private slots:
     void zeroTimer();
     void singleShotTimeout();
     void timeout();
+    void remainingTime();
     void livelock_data();
     void livelock();
     void timerInfiniteRecursion_data();
@@ -149,6 +150,22 @@ void tst_QTimer::timeout()
     QVERIFY(helper.count > oldCount);
 }
 
+void tst_QTimer::remainingTime()
+{
+    TimerHelper helper;
+    QTimer timer;
+
+    connect(&timer, SIGNAL(timeout()), &helper, SLOT(timeout()));
+    timer.start(200);
+
+    QCOMPARE(helper.count, 0);
+
+    QTest::qWait(50);
+    QCOMPARE(helper.count, 0);
+
+    int remainingTime = timer.remainingTime();
+    QVERIFY2(qAbs(remainingTime - 150) < 50, qPrintable(QString::number(remainingTime)));
+}
 
 void tst_QTimer::livelock_data()
 {
diff --git a/tests/auto/corelib/kernel/qtranslator/qtranslator.pro b/tests/auto/corelib/kernel/qtranslator/qtranslator.pro
index c644f83a22..41c3dea924 100644
--- a/tests/auto/corelib/kernel/qtranslator/qtranslator.pro
+++ b/tests/auto/corelib/kernel/qtranslator/qtranslator.pro
@@ -1,6 +1,6 @@
-CONFIG += testcase
+CONFIG += testcase parallel_test
 TARGET = tst_qtranslator
-QT += widgets testlib
+QT = core testlib
 SOURCES = tst_qtranslator.cpp
 RESOURCES += qtranslator.qrc
 
diff --git a/tests/auto/corelib/kernel/qtranslator/tst_qtranslator.cpp b/tests/auto/corelib/kernel/qtranslator/tst_qtranslator.cpp
index 033d10001f..4689fc432a 100644
--- a/tests/auto/corelib/kernel/qtranslator/tst_qtranslator.cpp
+++ b/tests/auto/corelib/kernel/qtranslator/tst_qtranslator.cpp
@@ -40,18 +40,17 @@
 ****************************************************************************/
 
 #include <QtTest/QtTest>
-#include <QWidget>
 #include <qtranslator.h>
 #include <qfile.h>
 
-class tst_QTranslator : public QWidget
+class tst_QTranslator : public QObject
 {
     Q_OBJECT
 
 public:
     tst_QTranslator();
 protected:
-    bool event(QEvent *event);
+    bool eventFilter(QObject *obj, QEvent *event);
 private slots:
     void initTestCase();
 
@@ -71,8 +70,7 @@ private:
 tst_QTranslator::tst_QTranslator()
     : languageChangeEventCounter(0)
 {
-    show();
-    hide();
+    qApp->installEventFilter(this);
 }
 
 void tst_QTranslator::initTestCase()
@@ -83,11 +81,11 @@ void tst_QTranslator::initTestCase()
     QVERIFY2(QDir::setCurrent(testdata_dir), qPrintable("Could not chdir to " + testdata_dir));
 }
 
-bool tst_QTranslator::event(QEvent *event)
+bool tst_QTranslator::eventFilter(QObject *, QEvent *event)
 {
     if (event->type() == QEvent::LanguageChange)
         ++languageChangeEventCounter;
-    return QWidget::event(event);
+    return false;
 }
 
 void tst_QTranslator::load()
diff --git a/tests/auto/corelib/kernel/qvariant/stream/qt5.0/qregularexpression.bin b/tests/auto/corelib/kernel/qvariant/stream/qt5.0/qregularexpression.bin
new file mode 100644
index 0000000000..eaa50f7310
--- /dev/null
+++ b/tests/auto/corelib/kernel/qvariant/stream/qt5.0/qregularexpression.bin
diff --git a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
index 655c714322..6a6460d17b 100644
--- a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
+++ b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
@@ -58,6 +58,7 @@
 #include <qmatrix4x4.h>
 #include <qpen.h>
 #include <qpolygon.h>
+#include <qpalette.h>
 #include <qtransform.h>
 #include <qvector2d.h>
 #include <qvector3d.h>
@@ -192,6 +193,7 @@ private slots:
     void toLocale();
 
     void toRegExp();
+    void toRegularExpression();
 
     void matrix();
 
@@ -274,6 +276,8 @@ private slots:
     void forwardDeclare();
     void debugStream_data();
     void debugStream();
+    void debugStreamType_data();
+    void debugStreamType();
 
     void loadQt4Stream_data();
     void loadQt4Stream();
@@ -283,6 +287,9 @@ private slots:
     void loadQt5Stream();
     void saveQt5Stream_data();
     void saveQt5Stream();
+
+    void guiVariantAtExit();
+    void widgetsVariantAtExit();
 private:
     void dataStream_data(QDataStream::Version version);
     void loadQVariantFromDataStream(QDataStream::Version version);
@@ -1319,6 +1326,21 @@ void tst_QVariant::toRegExp()
     rx = variant.toRegExp();
 }
 
+void tst_QVariant::toRegularExpression()
+{
+    QVariant variant;
+    QRegularExpression re = variant.toRegularExpression();
+    QCOMPARE(re, QRegularExpression());
+
+    variant = QRegularExpression("abc.*def");
+    re = variant.toRegularExpression();
+    QCOMPARE(re, QRegularExpression("abc.*def"));
+
+    variant = QVariant::fromValue(QRegularExpression("[ab]\\w+"));
+    re = variant.value<QRegularExpression>();
+    QCOMPARE(re, QRegularExpression("[ab]\\w+"));
+}
+
 void tst_QVariant::matrix()
 {
     QVariant variant;
@@ -1519,6 +1541,8 @@ void tst_QVariant::writeToReadFromDataStream_data()
     QTest::newRow( "qchar_null" ) << QVariant(QChar(0)) << true;
     QTest::newRow( "regexp" ) << QVariant(QRegExp("foo", Qt::CaseInsensitive)) << false;
     QTest::newRow( "regexp_empty" ) << QVariant(QRegExp()) << false;
+    QTest::newRow( "regularexpression" ) << QVariant(QRegularExpression("abc.*def")) << false;
+    QTest::newRow( "regularexpression_empty" ) << QVariant(QRegularExpression()) << false;
 
     // types known to QMetaType, but not part of QVariant::Type
     QTest::newRow("QMetaType::Long invalid") << QVariant(QMetaType::Long, (void *) 0) << false;
@@ -1625,8 +1649,8 @@ void tst_QVariant::writeToReadFromOldDataStream()
 
 void tst_QVariant::checkDataStream()
 {
-    QTest::ignoreMessage(QtWarningMsg, "Trying to construct an instance of an invalid type, type id: 46");
-    const QByteArray settingsHex("0000002effffffffff");
+    QTest::ignoreMessage(QtWarningMsg, "Trying to construct an instance of an invalid type, type id: 49");
+    const QByteArray settingsHex("00000031ffffffffff");
     const QByteArray settings = QByteArray::fromHex(settingsHex);
     QDataStream in(settings);
     QVariant v;
@@ -1944,6 +1968,7 @@ void tst_QVariant::typeName_data()
     QTest::newRow("48") << int(QVariant::Vector3D) << QByteArray("QVector3D");
     QTest::newRow("49") << int(QVariant::Vector4D) << QByteArray("QVector4D");
     QTest::newRow("50") << int(QVariant::Quaternion) << QByteArray("QQuaternion");
+    QTest::newRow("51") << int(QVariant::RegularExpression) << QByteArray("QRegularExpression");
 }
 
 void tst_QVariant::typeName()
@@ -2547,9 +2572,24 @@ public:
 };
 Q_DECLARE_METATYPE(CustomQObjectDerived*)
 
+class CustomQObjectDerivedNoMetaType : public CustomQObject {
+    Q_OBJECT
+public:
+    CustomQObjectDerivedNoMetaType(QObject *parent = 0) : CustomQObject(parent) {}
+};
+
 void tst_QVariant::qvariant_cast_QObject_derived()
 {
     {
+        CustomQObjectDerivedNoMetaType *object = new CustomQObjectDerivedNoMetaType(this);
+        QVariant data = QVariant::fromValue(object);
+        QVERIFY(data.userType() == qMetaTypeId<CustomQObjectDerivedNoMetaType*>());
+        QCOMPARE(data.value<QObject *>(), object);
+        QCOMPARE(data.value<CustomQObjectDerivedNoMetaType *>(), object);
+        QCOMPARE(data.value<CustomQObject *>(), object);
+        QVERIFY(data.value<CustomQWidget*>() == 0);
+    }
+    {
         CustomQObjectDerived *object = new CustomQObjectDerived(this);
         QVariant data = QVariant::fromValue(object);
 
@@ -2787,7 +2827,7 @@ Q_DECLARE_METATYPE( MyClass )
 void tst_QVariant::loadUnknownUserType()
 {
     qRegisterMetaType<MyClass>("MyClass");
-    char data[] = {0, 0, 1, 0, 0, 0, 0, 0, 8, 77, 121, 67, 108, 97, 115, 115, 0};
+    char data[] = {0, 0, QMetaType::User >> 8 , char(QMetaType::User), 0, 0, 0, 0, 8, 'M', 'y', 'C', 'l', 'a', 's', 's', 0};
 
     QByteArray ba(data, sizeof(data));
     QDataStream ds(&ba, QIODevice::ReadOnly);
@@ -3548,6 +3588,10 @@ void tst_QVariant::loadQVariantFromDataStream(QDataStream::Version version)
     stream >> typeName >> loadedVariant;
 
     const int id = QMetaType::type(typeName.toLatin1());
+    if (id == QMetaType::Void) {
+        // Void type is not supported by QVariant
+        return;
+    }
 
     QVariant constructedVariant(static_cast<QVariant::Type>(id));
     QCOMPARE(constructedVariant.userType(), id);
@@ -3567,6 +3611,10 @@ void tst_QVariant::saveQVariantFromDataStream(QDataStream::Version version)
     dataFileStream >> typeName;
     QByteArray data = file.readAll();
     const int id = QMetaType::type(typeName.toLatin1());
+    if (id == QMetaType::Void) {
+        // Void type is not supported by QVariant
+        return;
+    }
 
     QBuffer buffer;
     buffer.open(QIODevice::ReadWrite);
@@ -3588,8 +3636,8 @@ void tst_QVariant::saveQVariantFromDataStream(QDataStream::Version version)
 
 class MessageHandler {
 public:
-    MessageHandler(const int typeId)
-        : oldMsgHandler(qInstallMsgHandler(handler))
+    MessageHandler(const int typeId, QtMsgHandler msgHandler = handler)
+        : oldMsgHandler(qInstallMsgHandler(msgHandler))
     {
         currentId = typeId;
     }
@@ -3603,13 +3651,29 @@ public:
     {
         return ok;
     }
-private:
+protected:
     static void handler(QtMsgType, const char *txt)
     {
         QString msg = QString::fromLatin1(txt);
         // Format itself is not important, but basic data as a type name should be included in the output
-        ok = msg.startsWith("QVariant(") + QMetaType::typeName(currentId);
-        QVERIFY2(ok, (QString::fromLatin1("Message is not valid: '") + msg + '\'').toLatin1().constData());
+        ok = msg.startsWith("QVariant(");
+        QVERIFY2(ok, (QString::fromLatin1("Message is not started correctly: '") + msg + '\'').toLatin1().constData());
+        ok &= (currentId == QMetaType::UnknownType
+             ? msg.contains("Invalid")
+             : msg.contains(QMetaType::typeName(currentId)));
+        QVERIFY2(ok, (QString::fromLatin1("Message doesn't contain type name: '") + msg + '\'').toLatin1().constData());
+        if (currentId == QMetaType::Char || currentId == QMetaType::QChar) {
+            // Chars insert '\0' into the qdebug stream, it is not possible to find a real string length
+            return;
+        }
+        if (QMetaType::typeFlags(currentId) & QMetaType::PointerToQObject) {
+            QByteArray currentName = QMetaType::typeName(currentId);
+            currentName.chop(1);
+            ok &= (msg.contains(", " + currentName) || msg.contains(", 0x0"));
+        }
+        ok &= msg.endsWith(") ");
+        QVERIFY2(ok, (QString::fromLatin1("Message is not correctly finished: '") + msg + '\'').toLatin1().constData());
+
     }
 
     QtMsgHandler oldMsgHandler;
@@ -3627,11 +3691,15 @@ void tst_QVariant::debugStream_data()
         const char *tagName = QMetaType::typeName(id);
         if (!tagName)
             continue;
-        QTest::newRow(tagName) << QVariant(static_cast<QVariant::Type>(id)) << id;
+        if (id != QMetaType::Void) {
+            QTest::newRow(tagName) << QVariant(static_cast<QVariant::Type>(id)) << id;
+        }
     }
     QTest::newRow("QBitArray(111)") << QVariant(QBitArray(3, true)) << qMetaTypeId<QBitArray>();
     QTest::newRow("CustomStreamableClass") << QVariant(qMetaTypeId<CustomStreamableClass>(), 0) << qMetaTypeId<CustomStreamableClass>();
     QTest::newRow("MyClass") << QVariant(qMetaTypeId<MyClass>(), 0) << qMetaTypeId<MyClass>();
+    QTest::newRow("InvalidVariant") << QVariant() << int(QMetaType::UnknownType);
+    QTest::newRow("CustomQObject") << QVariant::fromValue(this) << qMetaTypeId<tst_QVariant*>();
 }
 
 void tst_QVariant::debugStream()
@@ -3644,5 +3712,62 @@ void tst_QVariant::debugStream()
     QVERIFY(msgHandler.testPassed());
 }
 
+struct MessageHandlerType : public MessageHandler
+{
+    MessageHandlerType(const int typeId)
+        : MessageHandler(typeId, handler)
+    {}
+    static void handler(QtMsgType, const char *txt)
+    {
+        QString msg = QString::fromLatin1(txt);
+        // Format itself is not important, but basic data as a type name should be included in the output
+        ok = msg.startsWith("QVariant::");
+        QVERIFY2(ok, (QString::fromLatin1("Message is not started correctly: '") + msg + '\'').toLatin1().constData());
+        ok &= (currentId == QMetaType::UnknownType
+                ? msg.contains("Invalid")
+                : msg.contains(QMetaType::typeName(currentId)));
+        QVERIFY2(ok, (QString::fromLatin1("Message doesn't contain type name: '") + msg + '\'').toLatin1().constData());
+    }
+};
+
+void tst_QVariant::debugStreamType_data()
+{
+    debugStream_data();
+}
+
+void tst_QVariant::debugStreamType()
+{
+    QFETCH(QVariant, variant);
+    QFETCH(int, typeId);
+
+    MessageHandlerType msgHandler(typeId);
+    qDebug() << QVariant::Type(typeId);
+    QVERIFY(msgHandler.testPassed());
+}
+
+void tst_QVariant::guiVariantAtExit()
+{
+    // crash test, it should not crash at QGuiApplication exit
+    static QVariant cursor = QCursor();
+    static QVariant point = QPoint();
+    static QVariant image = QImage();
+    static QVariant pallete = QPalette();
+    Q_UNUSED(cursor);
+    Q_UNUSED(point);
+    Q_UNUSED(image);
+    Q_UNUSED(pallete);
+    QVERIFY(true);
+}
+
+void tst_QVariant::widgetsVariantAtExit()
+{
+    // crash test, it should not crash at QGuiApplication exit
+    static QVariant icon= QIcon();
+    static QVariant sizePolicy = QSizePolicy();
+    Q_UNUSED(icon);
+    Q_UNUSED(sizePolicy);
+    QVERIFY(true);
+}
+
 QTEST_MAIN(tst_QVariant)
 #include "tst_qvariant.moc"