Merge branch 'dev' into stable

This starts Qt 5.1 release cycle

Conflicts:
	src/gui/text/qfontdatabase.cpp
	src/gui/text/qharfbuzz_copy_p.h
	src/widgets/kernel/qapplication.cpp
	src/widgets/kernel/qcoreapplication.cpp

Change-Id: I72fbf83ab3c2206aeea1b089428b0fc2a89bd62b

9 files changed, 392 insertions, 124 deletions

diff --git a/tests/auto/corelib/kernel/kernel.pro b/tests/auto/corelib/kernel/kernel.pro
index 57d52117c7..a283f5343d 100644
--- a/tests/auto/corelib/kernel/kernel.pro
+++ b/tests/auto/corelib/kernel/kernel.pro
@@ -21,6 +21,11 @@ SUBDIRS=\
     qvariant \
     qwineventnotifier
 
+!qtHaveModule(network): SUBDIRS -= \
+    qeventloop \
+    qobject \
+    qsocketnotifier
+
 !contains(QT_CONFIG, private_tests): SUBDIRS -= \
     qsocketnotifier \
     qsharedmemory
@@ -28,4 +33,4 @@ SUBDIRS=\
 # This test is only applicable on Windows
 !win32*:SUBDIRS -= qwineventnotifier
 
-qnx: SUBDIRS -= qsharedmemory qsystemsemaphore
+android|qnx: SUBDIRS -= qsharedmemory qsystemsemaphore
diff --git a/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp b/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp
index 42bf9eeca3..10c00e2a67 100644
--- a/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp
+++ b/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp
@@ -769,6 +769,18 @@ void tst_QCoreApplication::testQuitLock()
     app.exec();
 }
 
+static void createQObjectOnDestruction()
+{
+    // Make sure that we can create a QObject after the last QObject has been
+    // destroyed (especially after QCoreApplication has).
+    //
+    // Before the fixes, this would cause a dangling pointer dereference. If
+    // the problem comes back, it's possible that the following causes no
+    // effect.
+    QObject obj;
+    obj.thread()->setProperty("testing", 1);
+}
+Q_DESTRUCTOR_FUNCTION(createQObjectOnDestruction)
 
 QTEST_APPLESS_MAIN(tst_QCoreApplication)
 #include "tst_qcoreapplication.moc"
diff --git a/tests/auto/corelib/kernel/qmath/tst_qmath.cpp b/tests/auto/corelib/kernel/qmath/tst_qmath.cpp
index 0d977317ca..24934ac138 100644
--- a/tests/auto/corelib/kernel/qmath/tst_qmath.cpp
+++ b/tests/auto/corelib/kernel/qmath/tst_qmath.cpp
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Copyright (C) 2013 Laszlo Papp <lpapp@kde.org>
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the test suite of the Qt Toolkit.
@@ -42,13 +43,17 @@
 #include <QtTest/QtTest>
 #include <qmath.h>
 
-static const qreal PI = 3.14159265358979323846264338327950288;
+static const double PI = 3.14159265358979323846264338327950288;
 
 class tst_QMath : public QObject
 {
     Q_OBJECT
 private slots:
     void fastSinCos();
+    void degreesToRadians_data();
+    void degreesToRadians();
+    void radiansToDegrees_data();
+    void radiansToDegrees();
 };
 
 void tst_QMath::fastSinCos()
@@ -62,6 +67,76 @@ void tst_QMath::fastSinCos()
     }
 }
 
+void tst_QMath::degreesToRadians_data()
+{
+    QTest::addColumn<float>("degreesFloat");
+    QTest::addColumn<float>("radiansFloat");
+    QTest::addColumn<double>("degreesDouble");
+    QTest::addColumn<double>("radiansDouble");
+
+    QTest::newRow( "pi" ) << 180.0f << float(M_PI) << 180.0 << PI;
+    QTest::newRow( "doublepi" ) << 360.0f << float(2*M_PI) << 360.0 << 2*PI;
+    QTest::newRow( "halfpi" ) << 90.0f << float(M_PI_2) << 90.0 << PI/2;
+
+    QTest::newRow( "random" ) << 123.1234567f << 2.1489097058516724f << 123.123456789123456789 << 2.148909707407169856192285627;
+    QTest::newRow( "bigrandom" ) << 987654321.9876543f << 17237819.79023679f << 987654321987654321.987654321987654321 << 17237819790236794.0;
+
+    QTest::newRow( "zero" ) << 0.0f << 0.0f << 0.0 << 0.0;
+
+    QTest::newRow( "minuspi" ) << -180.0f << float(-M_PI) << 180.0 << PI;
+    QTest::newRow( "minusdoublepi" ) << -360.0f << float(-2*M_PI) << -360.0 << -2*PI;
+    QTest::newRow( "minushalfpi" ) << -90.0f << float(-M_PI_2) << -90.0 << -PI/2;
+
+    QTest::newRow( "minusrandom" ) << -123.1234567f << -2.1489097058516724f << -123.123456789123456789 << -2.148909707407169856192285627;
+    QTest::newRow( "minusbigrandom" ) << -987654321.9876543f << -17237819.79023679f << -987654321987654321.987654321987654321 << -17237819790236794.0;
+}
+
+void tst_QMath::degreesToRadians()
+{
+    QFETCH(float, degreesFloat);
+    QFETCH(float, radiansFloat);
+    QFETCH(double, degreesDouble);
+    QFETCH(double, radiansDouble);
+
+    QCOMPARE(qDegreesToRadians(degreesFloat), radiansFloat);
+    QCOMPARE(qDegreesToRadians(degreesDouble), radiansDouble);
+}
+
+void tst_QMath::radiansToDegrees_data()
+{
+    QTest::addColumn<float>("radiansFloat");
+    QTest::addColumn<float>("degreesFloat");
+    QTest::addColumn<double>("radiansDouble");
+    QTest::addColumn<double>("degreesDouble");
+
+    QTest::newRow( "pi" ) << float(M_PI) << 180.0f << PI << 180.0;
+    QTest::newRow( "doublepi" ) << float(2*M_PI) << 360.0f << 2*PI << 360.0;
+    QTest::newRow( "halfpi" ) << float(M_PI_2) << 90.0f<< PI/2 << 90.0;
+
+    QTest::newRow( "random" ) << 123.1234567f << 7054.454427971739f << 123.123456789123456789 << 7054.4544330781363896676339209079742431640625;
+    QTest::newRow( "bigrandom" ) << 987654321.9876543f << 56588424267.74745f << 987654321987654321.987654321987654321 << 56588424267747450880.0;
+
+    QTest::newRow( "zero" ) << 0.0f << 0.0f << 0.0 << 0.0;
+
+    QTest::newRow( "minuspi" ) << float(-M_PI) << -180.0f << -PI << -180.0;
+    QTest::newRow( "minusdoublepi" ) << float(-2*M_PI) << -360.0f << -2*PI << -360.0;
+    QTest::newRow( "minushalfpi" ) << float(-M_PI_2) << -90.0f << -PI/2 << -90.0;
+
+    QTest::newRow( "minusrandom" ) << -123.1234567f << -7054.454427971739f << -123.123456789123456789 << -7054.4544330781363896676339209079742431640625;
+    QTest::newRow( "minusbigrandom" ) << -987654321.9876543f << -56588424267.74745f << -987654321987654321.987654321987654321 << -56588424267747450880.0;
+}
+
+void tst_QMath::radiansToDegrees()
+{
+    QFETCH(float, radiansFloat);
+    QFETCH(float, degreesFloat);
+    QFETCH(double, radiansDouble);
+    QFETCH(double, degreesDouble);
+
+    QCOMPARE(qRadiansToDegrees(radiansFloat), degreesFloat);
+    QCOMPARE(qRadiansToDegrees(radiansDouble), degreesDouble);
+}
+
 QTEST_APPLESS_MAIN(tst_QMath)
 
 #include "tst_qmath.moc"
diff --git a/tests/auto/corelib/kernel/qmetamethod/qmetamethod.pro b/tests/auto/corelib/kernel/qmetamethod/qmetamethod.pro
index e253702d56..8340bc06e3 100644
--- a/tests/auto/corelib/kernel/qmetamethod/qmetamethod.pro
+++ b/tests/auto/corelib/kernel/qmetamethod/qmetamethod.pro
@@ -3,5 +3,5 @@ CONFIG += parallel_test
 TARGET = tst_qmetamethod
 QT = core testlib
 SOURCES = tst_qmetamethod.cpp
-macx:CONFIG -= app_bundle
+mac:CONFIG -= app_bundle
 DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0
diff --git a/tests/auto/corelib/kernel/qmetaobjectbuilder/qmetaobjectbuilder.pro b/tests/auto/corelib/kernel/qmetaobjectbuilder/qmetaobjectbuilder.pro
index 008b596b72..9e2d3519e6 100644
--- a/tests/auto/corelib/kernel/qmetaobjectbuilder/qmetaobjectbuilder.pro
+++ b/tests/auto/corelib/kernel/qmetaobjectbuilder/qmetaobjectbuilder.pro
@@ -2,5 +2,5 @@ CONFIG += testcase parallel_test
 TARGET = tst_qmetaobjectbuilder
 QT = core-private gui-private testlib
 SOURCES = tst_qmetaobjectbuilder.cpp
-macx:CONFIG -= app_bundle
+mac:CONFIG -= app_bundle
 DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0
diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
index 7f7486ef4b..77ea39da53 100644
--- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
+++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
@@ -110,6 +110,7 @@ private slots:
     void saveAndLoadCustom();
     void metaObject();
     void constexprMetaTypeIds();
+    void constRefs();
 };
 
 struct Foo { int i; };
@@ -169,7 +170,7 @@ protected:
             const QByteArray name = QString("Bar%1_%2").arg(i).arg((size_t)QThread::currentThreadId()).toLatin1();
             const char *nm = name.constData();
             int tp = qRegisterMetaType<Bar>(nm);
-#ifdef Q_OS_LINUX
+#if defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID)
             pthread_yield();
 #endif
             QMetaType info(tp);
@@ -1762,6 +1763,17 @@ void tst_QMetaType::constexprMetaTypeIds()
 #endif
 }
 
+void tst_QMetaType::constRefs()
+{
+    QCOMPARE(::qMetaTypeId<const int &>(), ::qMetaTypeId<int>());
+    QCOMPARE(::qMetaTypeId<const QString &>(), ::qMetaTypeId<QString>());
+    QCOMPARE(::qMetaTypeId<const CustomMovable &>(), ::qMetaTypeId<CustomMovable>());
+    QCOMPARE(::qMetaTypeId<const QList<CustomMovable> &>(), ::qMetaTypeId<QList<CustomMovable> >());
+#if defined(Q_COMPILER_CONSTEXPR)
+    Q_STATIC_ASSERT(::qMetaTypeId<const int &>() == ::qMetaTypeId<int>());
+#endif
+}
+
 // Compile-time test, it should be possible to register function pointer types
 class Undefined;
 
diff --git a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
index 865264c43a..06fc89f657 100644
--- a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
+++ b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Copyright (C) 2013 Olivier Goffart <ogoffart@woboq.com>
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the test suite of the Qt Toolkit.
@@ -68,7 +69,7 @@ class tst_QObject : public QObject
 private slots:
     void initTestCase();
     void disconnect();
-    void connectByName();
+    void connectSlotsByName();
     void connectSignalsToSignalsWithDefaultArguments();
     void receivers();
     void normalize();
@@ -140,10 +141,22 @@ private slots:
     void returnValue2_data();
     void returnValue2();
     void connectVirtualSlots();
+    void connectPrivateSlots();
     void connectFunctorArgDifference();
+    void connectFunctorOverloads();
     void disconnectDoesNotLeakFunctor();
 };
 
+struct QObjectCreatedOnShutdown
+{
+    QObjectCreatedOnShutdown() {}
+    ~QObjectCreatedOnShutdown()
+    {
+        QObject();
+    }
+};
+static QObjectCreatedOnShutdown s_qobjectCreatedOnShutdown;
+
 class SenderObject : public QObject
 {
     Q_OBJECT
@@ -368,6 +381,7 @@ public:
     void emitSignalWithParams(int i) { emit signalWithParams(i); }
     void emitSignalWithParams(int i, QString string) { emit signalWithParams(i, string); }
     void emitSignalManyParams(int i1, int i2, int i3, QString string, bool onoff) { emit signalManyParams(i1, i2, i3, string, onoff); }
+    void emitSignalManyParams(int i1, int i2, int i3, QString string, bool onoff, bool dummy) { emit signalManyParams(i1, i2, i3, string, onoff, dummy); }
     void emitSignalManyParams2(int i1, int i2, int i3, QString string, bool onoff) { emit signalManyParams2(i1, i2, i3, string, onoff); }
     void emitSignalLoopBack() { emit signalLoopBack(); }
 
@@ -386,158 +400,89 @@ class AutoConnectReceiver : public QObject
     Q_OBJECT
 
 public:
+    QList<int> called_slots;
+
     AutoConnectReceiver()
     {
-        reset();
-
         connect(this, SIGNAL(on_Sender_signalLoopBack()), this, SLOT(slotLoopBack()));
     }
 
-    void reset() {
-        called_slot10 = 0;
-        called_slot9 = 0;
-        called_slot8 = 0;
-        called_slot7 = 0;
-        called_slot6 = 0;
-        called_slot5 = 0;
-        called_slot4 = 0;
-        called_slot3 = 0;
-        called_slot2 = 0;
-        called_slot1 = 0;
-    }
-
-    int called_slot1;
-    int called_slot2;
-    int called_slot3;
-    int called_slot4;
-    int called_slot5;
-    int called_slot6;
-    int called_slot7;
-    int called_slot8;
-    int called_slot9;
-    int called_slot10;
-
-    bool called(int slot) {
-        switch (slot) {
-        case 1: return called_slot1;
-        case 2: return called_slot2;
-        case 3: return called_slot3;
-        case 4: return called_slot4;
-        case 5: return called_slot5;
-        case 6: return called_slot6;
-        case 7: return called_slot7;
-        case 8: return called_slot8;
-        case 9: return called_slot9;
-        case 10: return called_slot10;
-        default: return false;
-        }
-    }
+    void emitSignalNoParams() { emit signalNoParams(); }
+    void emit_signal_with_underscore() { emit signal_with_underscore(); }
 
 public slots:
-    void on_Sender_signalNoParams() { ++called_slot1; }
-    void on_Sender_signalWithParams(int i = 0) { ++called_slot2; Q_UNUSED(i); }
-    void on_Sender_signalWithParams(int i, QString string) { ++called_slot3; Q_UNUSED(i);Q_UNUSED(string); }
-    void on_Sender_signalManyParams() { ++called_slot4; }
-    void on_Sender_signalManyParams(int i1, int i2, int i3, QString string, bool onoff) { ++called_slot5; Q_UNUSED(i1);Q_UNUSED(i2);Q_UNUSED(i3);Q_UNUSED(string);Q_UNUSED(onoff); }
+    void on_Sender_signalNoParams() { called_slots << 1; }
+    void on_Sender_signalWithParams(int i = 0) { called_slots << 2; Q_UNUSED(i); }
+    void on_Sender_signalWithParams(int i, QString string) { called_slots << 3; Q_UNUSED(i);Q_UNUSED(string); }
+    void on_Sender_signalManyParams() { called_slots << 4; }
+    void on_Sender_signalManyParams(int i1, int i2, int i3, QString string, bool onoff)
+    { called_slots << 5; Q_UNUSED(i1);Q_UNUSED(i2);Q_UNUSED(i3);Q_UNUSED(string);Q_UNUSED(onoff); }
     void on_Sender_signalManyParams(int i1, int i2, int i3, QString string, bool onoff, bool dummy)
-    { ++called_slot6; Q_UNUSED(i1);Q_UNUSED(i2);Q_UNUSED(i3);Q_UNUSED(string);Q_UNUSED(onoff); Q_UNUSED(dummy);}
+    { called_slots << 6; Q_UNUSED(i1);Q_UNUSED(i2);Q_UNUSED(i3);Q_UNUSED(string);Q_UNUSED(onoff); Q_UNUSED(dummy);}
     void on_Sender_signalManyParams2(int i1, int i2, int i3, QString string, bool onoff)
-    { ++called_slot7; Q_UNUSED(i1);Q_UNUSED(i2);Q_UNUSED(i3);Q_UNUSED(string);Q_UNUSED(onoff); }
-    void slotLoopBack() { ++called_slot8; }
+    { called_slots << 7; Q_UNUSED(i1);Q_UNUSED(i2);Q_UNUSED(i3);Q_UNUSED(string);Q_UNUSED(onoff); }
+    void slotLoopBack() { called_slots << 8; }
+    void on_Receiver_signalNoParams() { called_slots << 9; }
+    void on_Receiver_signal_with_underscore() { called_slots << 10; }
 
 protected slots:
-    void o() { ++called_slot9; }
-    void on() { ++called_slot10; }
+    void o() { called_slots << -1; }
+    void on() { called_slots << -1; }
+    void on_() { called_slots << -1; }
+    void on_something() { called_slots << -1; }
+    void on_child_signal() { called_slots << -1; }
 
 signals:
     void on_Sender_signalLoopBack();
+    void signalNoParams();
+    void signal_with_underscore();
 };
 
-void tst_QObject::connectByName()
+void tst_QObject::connectSlotsByName()
 {
     AutoConnectReceiver receiver;
+    receiver.setObjectName("Receiver");
     AutoConnectSender sender(&receiver);
     sender.setObjectName("Sender");
 
+    QTest::ignoreMessage(QtWarningMsg, "QMetaObject::connectSlotsByName: No matching signal for on_child_signal()");
+    QTest::ignoreMessage(QtWarningMsg, "QMetaObject::connectSlotsByName: Connecting slot on_Sender_signalManyParams() with the first of the following compatible signals: (\"signalManyParams(int,int,int,QString,bool)\", \"signalManyParams(int,int,int,QString,bool,bool)\") ");
     QMetaObject::connectSlotsByName(&receiver);
 
+    receiver.called_slots.clear();
     sender.emitSignalNoParams();
-    QCOMPARE(receiver.called(1), true);
-    QCOMPARE(receiver.called(2), false);
-    QCOMPARE(receiver.called(3), false);
-    QCOMPARE(receiver.called(4), false);
-    QCOMPARE(receiver.called(5), false);
-    QCOMPARE(receiver.called(6), false);
-    QCOMPARE(receiver.called(7), false);
-    QCOMPARE(receiver.called(8), false);
-    QCOMPARE(receiver.called(9), false);
-    QCOMPARE(receiver.called(10), false);
-    receiver.reset();
+    QCOMPARE(receiver.called_slots, QList<int>() << 1);
 
+    receiver.called_slots.clear();
     sender.emitSignalWithParams(0);
-    QCOMPARE(receiver.called(1), false);
-    QCOMPARE(receiver.called(2), true);
-    QCOMPARE(receiver.called(3), false);
-    QCOMPARE(receiver.called(4), false);
-    QCOMPARE(receiver.called(5), false);
-    QCOMPARE(receiver.called(6), false);
-    QCOMPARE(receiver.called(7), false);
-    QCOMPARE(receiver.called(8), false);
-    QCOMPARE(receiver.called(9), false);
-    QCOMPARE(receiver.called(10), false);
-    receiver.reset();
+    QCOMPARE(receiver.called_slots, QList<int>() << 2);
 
+    receiver.called_slots.clear();
     sender.emitSignalWithParams(0, "string");
-    QCOMPARE(receiver.called(1), false);
-    QCOMPARE(receiver.called(2), false);
-    QCOMPARE(receiver.called(3), true);
-    QCOMPARE(receiver.called(4), false);
-    QCOMPARE(receiver.called(5), false);
-    QCOMPARE(receiver.called(6), false);
-    QCOMPARE(receiver.called(7), false);
-    QCOMPARE(receiver.called(8), false);
-    QCOMPARE(receiver.called(9), false);
-    QCOMPARE(receiver.called(10), false);
-    receiver.reset();
+    QCOMPARE(receiver.called_slots, QList<int>() << 3);
 
+    receiver.called_slots.clear();
     sender.emitSignalManyParams(1, 2, 3, "string", true);
-    QCOMPARE(receiver.called(1), false);
-    QCOMPARE(receiver.called(2), false);
-    QCOMPARE(receiver.called(3), false);
-    QCOMPARE(receiver.called(4), true);
-    QCOMPARE(receiver.called(5), true);
-    QCOMPARE(receiver.called(6), false);
-    QCOMPARE(receiver.called(7), false);
-    QCOMPARE(receiver.called(8), false);
-    QCOMPARE(receiver.called(9), false);
-    QCOMPARE(receiver.called(10), false);
-    receiver.reset();
+    sender.emitSignalManyParams(1, 2, 3, "string", true, false);
+    // the slot '4' (signalManyParams()) will get connected
+    // to either of the two signalManyParams(...) overloads
+    QCOMPARE(receiver.called_slots, QList<int>() << 4 << 5 << 6);
 
+    receiver.called_slots.clear();
     sender.emitSignalManyParams2(1, 2, 3, "string", true);
-    QCOMPARE(receiver.called(1), false);
-    QCOMPARE(receiver.called(2), false);
-    QCOMPARE(receiver.called(3), false);
-    QCOMPARE(receiver.called(4), false);
-    QCOMPARE(receiver.called(5), false);
-    QCOMPARE(receiver.called(6), false);
-    QCOMPARE(receiver.called(7), true);
-    QCOMPARE(receiver.called(8), false);
-    QCOMPARE(receiver.called(9), false);
-    QCOMPARE(receiver.called(10), false);
-    receiver.reset();
+    QCOMPARE(receiver.called_slots, QList<int>() << 7);
 
+    receiver.called_slots.clear();
     sender.emitSignalLoopBack();
-    QCOMPARE(receiver.called(1), false);
-    QCOMPARE(receiver.called(2), false);
-    QCOMPARE(receiver.called(3), false);
-    QCOMPARE(receiver.called(4), false);
-    QCOMPARE(receiver.called(5), false);
-    QCOMPARE(receiver.called(6), false);
-    QCOMPARE(receiver.called(7), false);
-    QCOMPARE(receiver.called(8), true);
-    QCOMPARE(receiver.called(9), false);
-    QCOMPARE(receiver.called(10), false);
-    receiver.reset();
+    QCOMPARE(receiver.called_slots, QList<int>() << 8);
+
+    receiver.called_slots.clear();
+    receiver.emitSignalNoParams();
+    QCOMPARE(receiver.called_slots, QList<int>() << 9);
+
+    receiver.called_slots.clear();
+    receiver.emit_signal_with_underscore();
+    QCOMPARE(receiver.called_slots, QList<int>() << 10);
 }
 
 void tst_QObject::qobject_castTemplate()
@@ -1436,9 +1381,11 @@ public:
 
 public slots:
     void slot1(CustomType ct);
+    void slot2(const QList<CustomType> &ct);
 
 signals:
     void signal1(CustomType ct);
+    void signal2(const QList<CustomType> &ct);
 
 public:
     CustomType received;
@@ -1447,6 +1394,8 @@ public:
 void QCustomTypeChecker::slot1(CustomType ct)
 { received = ct; }
 
+void QCustomTypeChecker::slot2(const QList< CustomType >& ct)
+{ received = ct[0]; }
 
 void tst_QObject::customTypes()
 {
@@ -4657,6 +4606,21 @@ void tst_QObject::customTypesPointer()
         QCOMPARE(qRegisterMetaType<CustomType>("CustomType"), idx);
         QCOMPARE(QMetaType::type("CustomType"), idx);
         QVERIFY(QMetaType::isRegistered(idx));
+
+        // Test auto registered type  (QList<CustomType>)
+        QList<CustomType> list;
+        QCOMPARE(instanceCount, 4);
+        list.append(t1);
+        QCOMPARE(instanceCount, 5);
+        QVERIFY(connect(&checker, &QCustomTypeChecker::signal2,
+                        &checker, &QCustomTypeChecker::slot2, Qt::QueuedConnection));
+        emit checker.signal2(list);
+        QCOMPARE(instanceCount, 5); //because the list is implicitly shared.
+        list.clear();
+        QCOMPARE(instanceCount, 5);
+        QCoreApplication::processEvents();
+        QCOMPARE(checker.received.value(), t1.value());
+        QCOMPARE(instanceCount, 4);
     }
     QCOMPARE(instanceCount, 3);
 }
@@ -5535,6 +5499,72 @@ void tst_QObject::connectVirtualSlots()
     */
 }
 
+#ifndef QT_BUILD_INTERNAL
+void tst_QObject::connectPrivateSlots()
+{QSKIP("Needs QT_BUILD_INTERNAL");}
+#else
+class ConnectToPrivateSlotPrivate;
+
+class ConnectToPrivateSlot :public QObject {
+    Q_OBJECT
+public:
+    ConnectToPrivateSlot();
+    void test(SenderObject *obj1) ;
+    Q_DECLARE_PRIVATE(ConnectToPrivateSlot)
+};
+
+class ConnectToPrivateSlotPrivate : public QObjectPrivate {
+public:
+    Q_DECLARE_PUBLIC(ConnectToPrivateSlot)
+    int receivedCount;
+    QVariant receivedValue;
+
+    void thisIsAPrivateSlot() {
+        receivedCount++;
+    };
+
+    void thisIsAPrivateSlotWithArg(const QVariant &v) {
+        receivedCount++;
+        receivedValue = v;
+    };
+};
+
+ConnectToPrivateSlot::ConnectToPrivateSlot(): QObject(*new ConnectToPrivateSlotPrivate) {}
+
+void ConnectToPrivateSlot::test(SenderObject* obj1) {
+    Q_D(ConnectToPrivateSlot);
+    d->receivedCount = 0;
+    QVERIFY(QObjectPrivate::connect(obj1, &SenderObject::signal1, d, &ConnectToPrivateSlotPrivate::thisIsAPrivateSlot));
+    QVERIFY(QObjectPrivate::connect(obj1, &SenderObject::signal7, d, &ConnectToPrivateSlotPrivate::thisIsAPrivateSlotWithArg));
+    QCOMPARE(d->receivedCount, 0);
+    obj1->signal1();
+    QCOMPARE(d->receivedCount, 1);
+    QCOMPARE(d->receivedValue, QVariant());
+    obj1->signal7(666, QLatin1Literal("_"));
+    QCOMPARE(d->receivedCount, 2);
+    QCOMPARE(d->receivedValue, QVariant(666));
+    QVERIFY(QObjectPrivate::connect(obj1, &SenderObject::signal2, d, &ConnectToPrivateSlotPrivate::thisIsAPrivateSlot, Qt::UniqueConnection));
+    QVERIFY(!QObjectPrivate::connect(obj1, &SenderObject::signal2, d, &ConnectToPrivateSlotPrivate::thisIsAPrivateSlot, Qt::UniqueConnection));
+    obj1->signal2();
+    QCOMPARE(d->receivedCount, 3);
+    QVERIFY(QObjectPrivate::disconnect(obj1, &SenderObject::signal2, d, &ConnectToPrivateSlotPrivate::thisIsAPrivateSlot));
+    obj1->signal2();
+    QCOMPARE(d->receivedCount, 3);
+    QVERIFY(!QObjectPrivate::disconnect(obj1, &SenderObject::signal2, d, &ConnectToPrivateSlotPrivate::thisIsAPrivateSlot));
+}
+
+void tst_QObject::connectPrivateSlots()
+{
+    SenderObject sender;
+    {
+        ConnectToPrivateSlot o;
+        o.test(&sender);
+    }
+    sender.signal7(777, QLatin1String("check that deleting the object properly disconnected"));
+    sender.signal1();
+}
+#endif
+
 struct SlotFunctor
 {
     void operator()() {}
@@ -5570,6 +5600,131 @@ void tst_QObject::connectFunctorArgDifference()
     QVERIFY(true);
 }
 
+struct ComplexFunctor {
+    ComplexFunctor(int &overload, QList<QVariant> &result) : overload(overload), result(result) {}
+    void operator()(int a, int b) {
+        overload = 1;
+        result << a << b;
+    }
+    void operator()(double a, double b) {
+        overload = 2;
+        result << a << b;
+    }
+    void operator()(const QString &s) {
+        overload = 3;
+        result << s;
+    }
+    void operator()(const QString &) const {
+        Q_ASSERT(!"Should not be called because the non-const one should");
+        overload = -1;
+    }
+    template<typename T1, typename T2, typename T3, typename T4>
+    void operator()(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4) {
+        overload = 4;
+        result << QVariant::fromValue(t1) << QVariant::fromValue(t2) << QVariant::fromValue(t3) << QVariant::fromValue(t4);
+    }
+    int &overload;
+    QList<QVariant> &result;
+protected:
+    void operator()() const {
+        Q_ASSERT(!"Should not be called because it is protected");
+        overload = -1;
+    }
+};
+
+struct ComplexFunctorDeriv : ComplexFunctor {
+    ComplexFunctorDeriv(int &overload, QList<QVariant> &result) : ComplexFunctor(overload, result) {}
+
+    void operator()() const {
+        overload = 10;
+    }
+    void operator()(int a, int b) {
+        overload = 11;
+        result << a << b;
+    }
+    using ComplexFunctor::operator();
+private:
+    void operator()(int) {
+        Q_ASSERT(!"Should not be called because it is private");
+        overload = -1;
+    }
+};
+
+class FunctorArgDifferenceObject : public QObject
+{
+    Q_OBJECT
+signals:
+    void signal_ii(int,int);
+    void signal_iiS(int,int, const QString &);
+    void signal_dd(double,double);
+    void signal_ddS(double,double, const QString &);
+    void signal_S(const QString &);
+    void signal_SSSS(const QString &, const QString &, const QString &, const QString &);
+    void signal_iiSS(int, int, const QString &, const QString &);
+    void signal_VV(const QVariant &, const QVariant &);
+};
+
+template<typename Functor, typename Signal>
+void connectFunctorOverload_impl(Signal signal, int expOverload, QList<QVariant> expResult)
+{
+    FunctorArgDifferenceObject obj;
+    int overload;
+    QList<QVariant> result;
+    QVERIFY(QObject::connect(&obj, signal, Functor(overload, result)));
+
+    obj.signal_ii(1,2);
+    obj.signal_iiS(3,4,"5");
+    obj.signal_dd(6.6,7.7);
+    obj.signal_ddS(8.8,9.9,"10");
+    obj.signal_S("11");
+    obj.signal_SSSS("12", "13", "14", "15");
+    obj.signal_iiSS(16, 17, "18", "19");
+    obj.signal_VV(20,21);
+
+    QCOMPARE(overload, expOverload);
+    QCOMPARE(result, expResult);
+}
+
+void tst_QObject::connectFunctorOverloads()
+{
+#if defined (Q_COMPILER_DECLTYPE) && defined (Q_COMPILER_VARIADIC_TEMPLATES)
+    connectFunctorOverload_impl<ComplexFunctor>(&FunctorArgDifferenceObject::signal_ii, 1,
+                                (QList<QVariant>() << 1 << 2));
+    connectFunctorOverload_impl<ComplexFunctor>(&FunctorArgDifferenceObject::signal_iiS, 1,
+                                (QList<QVariant>() << 3 << 4));
+    connectFunctorOverload_impl<ComplexFunctor>(&FunctorArgDifferenceObject::signal_dd, 2,
+                                (QList<QVariant>() << 6.6 << 7.7));
+    connectFunctorOverload_impl<ComplexFunctor>(&FunctorArgDifferenceObject::signal_ddS, 2,
+                                (QList<QVariant>() << 8.8 << 9.9));
+    connectFunctorOverload_impl<ComplexFunctor>(&FunctorArgDifferenceObject::signal_S, 3,
+                                (QList<QVariant>() << QString("11")));
+    connectFunctorOverload_impl<ComplexFunctor>(&FunctorArgDifferenceObject::signal_SSSS, 4,
+                                (QList<QVariant>() << QString("12") << QString("13") << QString("14") << QString("15")));
+    connectFunctorOverload_impl<ComplexFunctor>(&FunctorArgDifferenceObject::signal_iiSS, 4,
+                                (QList<QVariant>() << 16 << 17 << QString("18") << QString("19")));
+    connectFunctorOverload_impl<ComplexFunctorDeriv>(&FunctorArgDifferenceObject::signal_ii, 11,
+                                (QList<QVariant>() << 1 << 2));
+    connectFunctorOverload_impl<ComplexFunctorDeriv>(&FunctorArgDifferenceObject::signal_iiS, 11,
+                                (QList<QVariant>() << 3 << 4));
+    connectFunctorOverload_impl<ComplexFunctorDeriv>(&FunctorArgDifferenceObject::signal_dd, 2,
+                                (QList<QVariant>() << 6.6 << 7.7));
+    connectFunctorOverload_impl<ComplexFunctorDeriv>(&FunctorArgDifferenceObject::signal_ddS, 2,
+                                (QList<QVariant>() << 8.8 << 9.9));
+    connectFunctorOverload_impl<ComplexFunctorDeriv>(&FunctorArgDifferenceObject::signal_S, 3,
+                                (QList<QVariant>() << QString("11")));
+    connectFunctorOverload_impl<ComplexFunctorDeriv>(&FunctorArgDifferenceObject::signal_SSSS, 4,
+                                (QList<QVariant>() << QString("12") << QString("13") << QString("14") << QString("15")));
+    connectFunctorOverload_impl<ComplexFunctorDeriv>(&FunctorArgDifferenceObject::signal_iiSS, 4,
+                                (QList<QVariant>() << 16 << 17 << QString("18") << QString("19")));
+    connectFunctorOverload_impl<ComplexFunctorDeriv>(&FunctorArgDifferenceObject::signal_VV, 10,
+                                (QList<QVariant>()));
+
+
+#else
+    QSKIP("Does not compile without C++11 variadic template");
+#endif
+}
+
 static int countedStructObjectsCount = 0;
 struct CountedStruct
 {
diff --git a/tests/auto/corelib/kernel/qpointer/tst_qpointer.cpp b/tests/auto/corelib/kernel/qpointer/tst_qpointer.cpp
index 7c6549364f..609b4b7dce 100644
--- a/tests/auto/corelib/kernel/qpointer/tst_qpointer.cpp
+++ b/tests/auto/corelib/kernel/qpointer/tst_qpointer.cpp
@@ -65,6 +65,7 @@ private slots:
     void threadSafety();
 
     void qvariantCast();
+    void constPointer();
 };
 
 void tst_QPointer::constructors()
@@ -384,6 +385,12 @@ void tst_QPointer::qvariantCast()
 //     QPointer<int> sop = qPointerFromVariant<int>(v);
 }
 
+void tst_QPointer::constPointer()
+{
+    // Compile-time test that QPointer<const T> works.
+    QPointer<const QFile> fp = new QFile;
+    delete fp.data();
+}
 
 
 QTEST_MAIN(tst_QPointer)
diff --git a/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp b/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp
index 3583c1cab3..ce5e83288f 100644
--- a/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp
+++ b/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp
@@ -748,6 +748,8 @@ void tst_QSharedMemory::simpleProcessProducerConsumer()
 {
     QFETCH(int, processes);
 
+    QSKIP("This test is unstable: QTBUG-25655");
+
     rememberKey("market");
 
     QProcess producer;