Merge branch 'master' of ../../qt/master

Conflicts:
	examples/multimedia/audioinput/audioinput.cpp
	src/multimedia/audio/qaudiodeviceinfo.cpp
	src/multimedia/audio/qaudiodeviceinfo_win32_p.cpp
	src/multimedia/audio/qaudioformat.cpp
	src/multimedia/audio/qaudioinput_win32_p.cpp
	src/multimedia/audio/qaudiooutput_win32_p.cpp
	tests/auto/qaudioformat/tst_qaudioformat.cpp

6 files changed, 582 insertions, 12 deletions

diff --git a/tests/auto/qobject/moc_oldnormalizeobject.cpp b/tests/auto/qobject/moc_oldnormalizeobject.cpp
new file mode 100644
index 0000000..bde9c39
--- /dev/null
+++ b/tests/auto/qobject/moc_oldnormalizeobject.cpp
@@ -0,0 +1,113 @@
+/****************************************************************************
+** 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/qobject/oldnormalizeobject.h b/tests/auto/qobject/oldnormalizeobject.h
new file mode 100644
index 0000000..8420a3a
--- /dev/null
+++ b/tests/auto/qobject/oldnormalizeobject.h
@@ -0,0 +1,28 @@
+#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/qobject/signalbug.cpp b/tests/auto/qobject/signalbug.cpp
index d5a85d3..aa2078f 100644
--- a/tests/auto/qobject/signalbug.cpp
+++ b/tests/auto/qobject/signalbug.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/tests/auto/qobject/signalbug.h b/tests/auto/qobject/signalbug.h
index 427f83c..0563f16 100644
--- a/tests/auto/qobject/signalbug.h
+++ b/tests/auto/qobject/signalbug.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/tests/auto/qobject/tst_qobject.cpp b/tests/auto/qobject/tst_qobject.cpp
index 5035139..7c172ef 100644
--- a/tests/auto/qobject/tst_qobject.cpp
+++ b/tests/auto/qobject/tst_qobject.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
@@ -60,6 +60,10 @@
 #include <QProcess>
 
 #include "qobject.h"
+#ifdef QT_BUILD_INTERNAL
+#include <private/qobject_p.h>
+#endif
+
 
 #include <math.h>
 
@@ -121,6 +125,8 @@ private slots:
     void interfaceIid();
     void deleteQObjectWhenDeletingEvent();
     void overloads();
+    void isSignalConnected();
+    void qMetaObjectConnect();
 protected:
 };
 
@@ -2017,6 +2023,7 @@ enum Enum { };
 
 struct Struct { };
 class Class { };
+template <typename T> class Template { };
 
 class NormalizeObject : public QObject
 {
@@ -2054,6 +2061,12 @@ signals:
     void unsignedshortSignal(unsigned short);
     void unsignedcharSignal(unsigned char);
 
+    void typeRefSignal(Template<Class &> &ref);
+    void constTypeRefSignal(const Template<Class const &> &ref);
+    void typeConstRefSignal(Template<Class const &> const &ref);
+
+    void typePointerConstRefSignal(Class * const &);
+
 public slots:
     void uintPointerSlot(uint *) { }
     void ulongPointerSlot(ulong *) { }
@@ -2085,8 +2098,15 @@ public slots:
     void unsignedshortSlot(unsigned short) {};
     void unsignedcharSlot(unsigned char) {};
 
+    void typeRefSlot(Template<Class &> &) {}
+    void constTypeRefSlot(const Template<const Class &> &) {}
+    void typeConstRefSlot(Template<Class const &> const &) {}
+
+    void typePointerConstRefSlot(Class * const &) {}
 };
 
+#include "oldnormalizeobject.h"
+
 void tst_QObject::normalize()
 {
     NormalizeObject object;
@@ -2326,7 +2346,165 @@ void tst_QObject::normalize()
                            SIGNAL(unsignedcharSignal(unsigned char)),
                            SLOT(unsignedcharSlot(unsigned char))));
 
+    // connect when original template signature and mixed usage of 'T<C const &> const &',
+    // 'const T<const C &> &', and 'T<const C &>'
+
+    QVERIFY(object.connect(&object,
+                           SIGNAL(typeRefSignal(Template<Class &> &)),
+                           SLOT(typeRefSlot(Template<Class &> &))));
 
+    QVERIFY(object.connect(&object,
+                           SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
+                           SLOT(constTypeRefSlot(const Template<const Class &> &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
+                           SLOT(constTypeRefSlot(const Template<Class const &> &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
+                           SLOT(constTypeRefSlot(Template<Class const &> const &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(constTypeRefSignal(Template<const Class &> const &)),
+                           SLOT(constTypeRefSlot(Template<Class const &> const &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(constTypeRefSignal(Template<Class const &> const &)),
+                           SLOT(constTypeRefSlot(Template<Class const &> const &))));
+
+    QVERIFY(object.connect(&object,
+                           SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
+                           SLOT(typeConstRefSlot(const Template<const Class &> &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
+                           SLOT(typeConstRefSlot(const Template<Class const &> &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
+                           SLOT(typeConstRefSlot(Template<Class const &> const &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(constTypeRefSignal(Template<const Class &> const &)),
+                           SLOT(typeConstRefSlot(Template<Class const &> const &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(constTypeRefSignal(Template<Class const &> const &)),
+                           SLOT(typeConstRefSlot(Template<Class const &> const &))));
+
+    QVERIFY(object.connect(&object,
+                           SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
+                           SLOT(constTypeRefSlot(const Template<const Class &> &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
+                           SLOT(constTypeRefSlot(const Template<Class const &> &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
+                           SLOT(constTypeRefSlot(Template<Class const &> const &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(typeConstRefSignal(Template<const Class &> const &)),
+                           SLOT(constTypeRefSlot(Template<Class const &> const &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(typeConstRefSignal(Template<Class const &> const &)),
+                           SLOT(constTypeRefSlot(Template<Class const &> const &))));
+
+    QVERIFY(object.connect(&object,
+                           SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
+                           SLOT(typeConstRefSlot(const Template<const Class &> &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
+                           SLOT(typeConstRefSlot(const Template<Class const &> &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
+                           SLOT(typeConstRefSlot(Template<Class const &> const &))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(typeConstRefSignal(Template<const Class &> const &)),
+                           SLOT(typeConstRefSlot(Template<Class const &> const &))));
+    QVERIFY(object.connect(&object,
+                           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&))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(typePointerConstRefSignal(Class*const&)),
+                           SLOT(typePointerConstRefSlot(Class*))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(typePointerConstRefSignal(Class*)),
+                           SLOT(typePointerConstRefSlot(Class*const&))));
+    QVERIFY(object.connect(&object,
+                           SIGNAL(typePointerConstRefSignal(Class*)),
+                           SLOT(typePointerConstRefSlot(Class*))));
 }
 
 class SiblingDeleter : public QObject
@@ -3016,5 +3194,252 @@ void tst_QObject::overloads()
     QCOMPARE(obj2.o4_obj, qApp); //default arg of the slot
 }
 
+class ManySignals : public QObject
+{   Q_OBJECT
+    friend class tst_QObject;
+signals:
+    void sig00(); void sig01(); void sig02(); void sig03(); void sig04();
+    void sig05(); void sig06(); void sig07(); void sig08(); void sig09();
+    void sig10(); void sig11(); void sig12(); void sig13(); void sig14();
+    void sig15(); void sig16(); void sig17(); void sig18(); void sig19();
+    void sig20(); void sig21(); void sig22(); void sig23(); void sig24();
+    void sig25(); void sig26(); void sig27(); void sig28(); void sig29();
+    void sig30(); void sig31(); void sig32(); void sig33(); void sig34();
+    void sig35(); void sig36(); void sig37(); void sig38(); void sig39();
+    void sig40(); void sig41(); void sig42(); void sig43(); void sig44();
+    void sig45(); void sig46(); void sig47(); void sig48(); void sig49();
+    void sig50(); void sig51(); void sig52(); void sig53(); void sig54();
+    void sig55(); void sig56(); void sig57(); void sig58(); void sig59();
+    void sig60(); void sig61(); void sig62(); void sig63(); void sig64();
+    void sig65(); void sig66(); void sig67(); void sig68(); void sig69();
+
+public slots:
+    void received() { rec++; }
+public:
+    int rec;
+};
+
+
+void tst_QObject::isSignalConnected()
+{
+    ManySignals o;
+    o.rec = 0;
+#ifdef QT_BUILD_INTERNAL
+    QObjectPrivate *priv = QObjectPrivate::get(&o);
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("destroyed()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig00()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig05()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig15()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig29()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig60()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig61()")));
+#endif
+
+    QObject::connect(&o, SIGNAL(sig00()), &o, SIGNAL(sig69()));
+    QObject::connect(&o, SIGNAL(sig34()), &o, SIGNAL(sig03()));
+    QObject::connect(&o, SIGNAL(sig69()), &o, SIGNAL(sig34()));
+    QObject::connect(&o, SIGNAL(sig03()), &o, SIGNAL(sig18()));
+
+#ifdef QT_BUILD_INTERNAL
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("destroyed()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig05()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig15()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig29()")));
+
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig00()")));
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig03()")));
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig34()")));
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig69()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig18()")));
+#endif
+
+    QObject::connect(&o, SIGNAL(sig18()), &o, SIGNAL(sig29()));
+    QObject::connect(&o, SIGNAL(sig29()), &o, SIGNAL(sig62()));
+    QObject::connect(&o, SIGNAL(sig62()), &o, SIGNAL(sig28()));
+    QObject::connect(&o, SIGNAL(sig28()), &o, SIGNAL(sig27()));
+
+#ifdef QT_BUILD_INTERNAL
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig18()")));
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig62()")));
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig28()")));
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig69()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig27()")));
+#endif
+
+    QCOMPARE(o.rec, 0);
+    emit o.sig01();
+    emit o.sig34();
+    QCOMPARE(o.rec, 0);
+
+    QObject::connect(&o, SIGNAL(sig27()), &o, SLOT(received()));
+
+#ifdef QT_BUILD_INTERNAL
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig00()")));
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig03()")));
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig34()")));
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig18()")));
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig62()")));
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig28()")));
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig69()")));
+    QVERIFY(priv->isSignalConnected(priv->signalIndex("sig27()")));
+
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig04()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig21()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig25()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig55()")));
+    QVERIFY(!priv->isSignalConnected(priv->signalIndex("sig61()")));
+#endif
+
+    emit o.sig00();
+    QCOMPARE(o.rec, 1);
+    emit o.sig69();
+    QCOMPARE(o.rec, 2);
+    emit o.sig36();
+    QCOMPARE(o.rec, 2);
+}
+
+void tst_QObject::qMetaObjectConnect()
+{
+    SenderObject *s = new SenderObject;
+    ReceiverObject *r1 = new ReceiverObject;
+    ReceiverObject *r2 = new ReceiverObject;
+    r1->reset();
+    r2->reset();
+    ReceiverObject::sequence = 0;
+
+    int signal1Index = s->metaObject()->indexOfSignal("signal1()");
+    int signal3Index = s->metaObject()->indexOfSignal("signal3()");
+    int slot1Index = r1->metaObject()->indexOfSlot("slot1()");
+    int slot2Index = r1->metaObject()->indexOfSlot("slot2()");
+    int slot3Index = r1->metaObject()->indexOfSlot("slot3()");
+
+    QVERIFY(slot1Index > 0);
+    QVERIFY(slot2Index > 0);
+    QVERIFY(slot3Index > 0);
+
+    QVERIFY( QMetaObject::connect( s, signal1Index, r1, slot1Index) );
+    QVERIFY( QMetaObject::connect( s, signal3Index, r2, slot3Index) );
+    QVERIFY( QMetaObject::connect( s, -1, r2, slot2Index) );
+
+    QCOMPARE( r1->count_slot1, 0 );
+    QCOMPARE( r1->count_slot2, 0 );
+    QCOMPARE( r1->count_slot3, 0 );
+    QCOMPARE( r2->count_slot1, 0 );
+    QCOMPARE( r2->count_slot2, 0 );
+    QCOMPARE( r2->count_slot3, 0 );
+
+    s->emitSignal1();
+
+    QCOMPARE( r1->count_slot1, 1 );
+    QCOMPARE( r1->count_slot2, 0 );
+    QCOMPARE( r1->count_slot3, 0 );
+    QCOMPARE( r2->count_slot1, 0 );
+    QCOMPARE( r2->count_slot2, 1 );
+    QCOMPARE( r2->count_slot3, 0 );
+
+    s->emitSignal2();
+    s->emitSignal3();
+    s->emitSignal4();
+
+    QCOMPARE( r1->count_slot1, 1 );
+    QCOMPARE( r1->count_slot2, 0 );
+    QCOMPARE( r1->count_slot3, 0 );
+    QCOMPARE( r2->count_slot1, 0 );
+    QCOMPARE( r2->count_slot2, 4 );
+    QCOMPARE( r2->count_slot3, 1 );
+
+    QVERIFY( QMetaObject::disconnect( s, signal1Index, r1, slot1Index) );
+    QVERIFY( QMetaObject::disconnect( s, signal3Index, r2, slot3Index) );
+    QVERIFY( QMetaObject::disconnect( s, -1, r2, slot2Index) );
+
+    s->emitSignal1();
+    s->emitSignal2();
+    s->emitSignal3();
+    s->emitSignal4();
+
+    QCOMPARE( r1->count_slot1, 1 );
+    QCOMPARE( r1->count_slot2, 0 );
+    QCOMPARE( r1->count_slot3, 0 );
+    QCOMPARE( r2->count_slot1, 0 );
+    QCOMPARE( r2->count_slot2, 4 );
+    QCOMPARE( r2->count_slot3, 1 );
+
+    //some "dynamic" signal
+    QVERIFY( QMetaObject::connect( s, s->metaObject()->methodOffset() + 20, r1, slot3Index) );
+    QVERIFY( QMetaObject::connect( s, s->metaObject()->methodOffset() + 35, r2, slot1Index) );
+    QVERIFY( QMetaObject::connect( s, -1, r1, slot2Index) );
+
+    r1->reset();
+    r2->reset();
+
+    void *args[] = { 0 , 0 };
+    QMetaObject::activate(s, s->metaObject()->methodOffset() + 20, args);
+    QMetaObject::activate(s, s->metaObject()->methodOffset() + 48, args);
+    QCOMPARE( r1->count_slot1, 0 );
+    QCOMPARE( r1->count_slot2, 2 );
+    QCOMPARE( r1->count_slot3, 1 );
+    QCOMPARE( r2->count_slot1, 0 );
+    QCOMPARE( r2->count_slot2, 0 );
+    QCOMPARE( r2->count_slot3, 0 );
+
+    QMetaObject::activate(s, s->metaObject()->methodOffset() + 35, args);
+    s->emitSignal1();
+    s->emitSignal2();
+
+    QCOMPARE( r1->count_slot1, 0 );
+    QCOMPARE( r1->count_slot2, 5 );
+    QCOMPARE( r1->count_slot3, 1 );
+    QCOMPARE( r2->count_slot1, 1 );
+    QCOMPARE( r2->count_slot2, 0 );
+    QCOMPARE( r2->count_slot3, 0 );
+
+    delete s;
+    r1->reset();
+    r2->reset();
+
+#define SIGNAL_INDEX(S)  obj1.metaObject()->indexOfSignal(QMetaObject::normalizedSignature(#S))
+    OverloadObject obj1;
+    QObject obj2, obj3;
+
+    QMetaObject::connect(&obj1, SIGNAL_INDEX(sig(int)) , r1, slot1Index);
+    QMetaObject::connect(&obj1, SIGNAL_INDEX(sig(QObject *, QObject *, QObject *)) , r2, slot1Index);
+
+    QMetaObject::connect(&obj1, SIGNAL_INDEX(sig(QObject *, QObject *, QObject *, QObject *)) , r1, slot2Index);
+    QMetaObject::connect(&obj1, SIGNAL_INDEX(sig(QObject *)) , r2, slot2Index);
+    QMetaObject::connect(&obj1, SIGNAL_INDEX(sig(int, int)) , r1, slot3Index);
+
+    emit obj1.sig(0.5); //connected to nothing
+    emit obj1.sig(1, 'a'); //connected to nothing
+    QCOMPARE( r1->count_slot1, 0 );
+    QCOMPARE( r1->count_slot2, 0 );
+    QCOMPARE( r1->count_slot3, 0 );
+    QCOMPARE( r2->count_slot1, 0 );
+    QCOMPARE( r2->count_slot2, 0 );
+    QCOMPARE( r2->count_slot3, 0 );
+
+    emit obj1.sig(1); //this signal is connected
+    emit obj1.sig(&obj2);
+
+    QCOMPARE( r1->count_slot1, 1 );
+    QCOMPARE( r1->count_slot2, 0 );
+    QCOMPARE( r1->count_slot3, 1 );
+    QCOMPARE( r2->count_slot1, 0 );
+    QCOMPARE( r2->count_slot2, 1 );
+    QCOMPARE( r2->count_slot3, 0 );
+
+    emit obj1.sig(&obj2, &obj3); //this signal is connected
+
+    QCOMPARE( r1->count_slot1, 1 );
+    QCOMPARE( r1->count_slot2, 1 );
+    QCOMPARE( r1->count_slot3, 1 );
+    QCOMPARE( r2->count_slot1, 1 );
+    QCOMPARE( r2->count_slot2, 1 );
+    QCOMPARE( r2->count_slot3, 0 );
+
+    delete r1;
+    delete r2;
+
+}
+
 QTEST_MAIN(tst_QObject)
 #include "tst_qobject.moc"
diff --git a/tests/auto/qobject/tst_qobject.pro b/tests/auto/qobject/tst_qobject.pro
index 003ee98..0200f3e 100644
--- a/tests/auto/qobject/tst_qobject.pro
+++ b/tests/auto/qobject/tst_qobject.pro
@@ -1,16 +1,20 @@
 load(qttest_p4)
-SOURCES  += tst_qobject.cpp
+SOURCES += tst_qobject.cpp
 
-QT = core network gui
-contains(QT_CONFIG, qt3support):DEFINES+=QT_HAS_QT3SUPPORT
+# 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
 
-wince*: {
-   addFiles.sources = signalbug.exe
-   addFiles.path = .
-   DEPLOYMENT += addFiles
+QT = core \
+    network \
+    gui
+contains(QT_CONFIG, qt3support):DEFINES += QT_HAS_QT3SUPPORT
+wince*: { 
+    addFiles.sources = signalbug.exe
+    addFiles.path = .
+    DEPLOYMENT += addFiles
 }
-
-symbian: {
+symbian: { 
     addFiles.sources = signalbug.exe
     addFiles.path = \sys\bin
     DEPLOYMENT += addFiles