Mercurial Mercurial > oss > FCL > sf > mw > qt / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
tests/auto/qobject/tst_qobject.cpp
changeset 30 5dc02b23752f
parent 19 fcece45ef507
equal deleted inserted replaced
29:b72c6db6890b 30:5dc02b23752f 
   126     void deleteQObjectWhenDeletingEvent();
 
   126     void deleteQObjectWhenDeletingEvent();
 
   127     void overloads();
 
   127     void overloads();
 
   128     void isSignalConnected();
 
   128     void isSignalConnected();
 
   129     void qMetaObjectConnect();
 
   129     void qMetaObjectConnect();
 
   130     void qMetaObjectDisconnectOne();
 
   130     void qMetaObjectDisconnectOne();
 
       
   131     void sameName();
 
   131 protected:
 
   132 protected:
 
   132 };
 
   133 };
 
   133 
   134 
   134 tst_QObject::tst_QObject()
 
   135 tst_QObject::tst_QObject()
 
   135 {
 
   136 {
 
   160 class SenderObject : public QObject
 
   161 class SenderObject : public QObject
 
   161 {
 
   162 {
 
   162     Q_OBJECT
 
   163     Q_OBJECT
 
   163 
   164 
   164 public:
 
   165 public:
 
   165     SenderObject() : recursionCount(0) {}
 
   166     SenderObject() : aPublicSlotCalled(0), recursionCount(0) {}
 
   166 
   167 
   167     void emitSignal1AfterRecursion()
 
   168     void emitSignal1AfterRecursion()
 
   168     {
 
   169     {
 
   169         if (recursionCount++ < 100)
 
   170         if (recursionCount++ < 100)
 
   170             emitSignal1AfterRecursion();
 
   171             emitSignal1AfterRecursion();
 
   183     void signal3();
 
   184     void signal3();
 
   184     void signal4();
 
   185     void signal4();
 
   185     QT_MOC_COMPAT void signal5();
 
   186     QT_MOC_COMPAT void signal5();
 
   186 
   187 
   187 public slots:
 
   188 public slots:
 
   188     void aPublicSlot(){}
 
   189     void aPublicSlot() { aPublicSlotCalled++; }
 
   189 
   190 
   190 public:
 
   191 public:
 
   191     Q_INVOKABLE void invoke1(){}
 
   192     Q_INVOKABLE void invoke1(){}
 
   192     Q_SCRIPTABLE void sinvoke1(){}
 
   193     Q_SCRIPTABLE void sinvoke1(){}
 
       
   194     int aPublicSlotCalled;
 
   193 protected:
 
   195 protected:
 
   194     Q_INVOKABLE QT_MOC_COMPAT void invoke2(){}
 
   196     Q_INVOKABLE QT_MOC_COMPAT void invoke2(){}
 
   195     Q_INVOKABLE QT_MOC_COMPAT void invoke2(int){}
 
   197     Q_INVOKABLE QT_MOC_COMPAT void invoke2(int){}
 
   196     Q_SCRIPTABLE QT_MOC_COMPAT void sinvoke2(){}
 
   198     Q_SCRIPTABLE QT_MOC_COMPAT void sinvoke2(){}
 
   197 private:
 
   199 private:
 
   427         }
 
   429         }
 
   428     }
 
   430     }
 
   429 
   431 
   430 public slots:
 
   432 public slots:
 
   431     void on_Sender_signalNoParams() { ++called_slot1; }
 
   433     void on_Sender_signalNoParams() { ++called_slot1; }
 
   432     void on_Sender_signalWithParams(int i = 0) { ++called_slot2; }
 
   434     void on_Sender_signalWithParams(int i = 0) { ++called_slot2; Q_UNUSED(i); }
 
   433     void on_Sender_signalWithParams(int i, QString string) { ++called_slot3; }
 
   435     void on_Sender_signalWithParams(int i, QString string) { ++called_slot3; Q_UNUSED(i);Q_UNUSED(string); }
 
   434     void on_Sender_signalManyParams() { ++called_slot4; }
 
   436     void on_Sender_signalManyParams() { ++called_slot4; }
 
   435     void on_Sender_signalManyParams(int i1, int i2, int i3, QString string, bool onoff) { ++called_slot5; }
 
   437     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); }
 
   436     void on_Sender_signalManyParams(int i1, int i2, int i3, QString string, bool onoff, bool dummy) { ++called_slot6; }
 
   438     void on_Sender_signalManyParams(int i1, int i2, int i3, QString string, bool onoff, bool dummy)
 
   437     void on_Sender_signalManyParams2(int i1, int i2, int i3, QString string, bool onoff) { ++called_slot7; }
 
   439     { ++called_slot6; Q_UNUSED(i1);Q_UNUSED(i2);Q_UNUSED(i3);Q_UNUSED(string);Q_UNUSED(onoff); Q_UNUSED(dummy);}
 
       
   440     void on_Sender_signalManyParams2(int i1, int i2, int i3, QString string, bool onoff)
 
       
   441     { ++called_slot7; Q_UNUSED(i1);Q_UNUSED(i2);Q_UNUSED(i3);Q_UNUSED(string);Q_UNUSED(onoff); }
 
   438     void slotLoopBack() { ++called_slot8; }
 
   442     void slotLoopBack() { ++called_slot8; }
 
   439 
   443 
   440 protected slots:
 
   444 protected slots:
 
   441     void o() { Q_ASSERT(0); }
 
   445     void o() { Q_ASSERT(0); }
 
   442     void on() { Q_ASSERT(0); }
 
   446     void on() { Q_ASSERT(0); }
 
  1110         QCOMPARE(t2.i3, 3);
 
  1114         QCOMPARE(t2.i3, 3);
 
  1111     }
 
  1115     }
 
  1112     QCOMPARE(instanceCount, 0);
 
  1116     QCOMPARE(instanceCount, 0);
 
  1113 }
 
  1117 }
 
  1114 
  1118 
       
  1119 typedef QString CustomString;
 
       
  1120 
  1115 class PropertyObject : public QObject
 
  1121 class PropertyObject : public QObject
 
  1116 {
 
  1122 {
 
  1117     Q_OBJECT
 
  1123     Q_OBJECT
 
  1118     Q_ENUMS(Alpha Priority)
 
  1124     Q_ENUMS(Alpha Priority)
 
  1119 
  1125 
  1123     Q_PROPERTY(QString string READ string WRITE setString)
 
  1129     Q_PROPERTY(QString string READ string WRITE setString)
 
  1124     Q_PROPERTY(QVariant variant READ variant WRITE setVariant)
 
  1130     Q_PROPERTY(QVariant variant READ variant WRITE setVariant)
 
  1125     Q_PROPERTY(CustomType* custom READ custom WRITE setCustom)
 
  1131     Q_PROPERTY(CustomType* custom READ custom WRITE setCustom)
 
  1126     Q_PROPERTY(float myFloat READ myFloat WRITE setMyFloat)
 
  1132     Q_PROPERTY(float myFloat READ myFloat WRITE setMyFloat)
 
  1127     Q_PROPERTY(qreal myQReal READ myQReal WRITE setMyQReal)
 
  1133     Q_PROPERTY(qreal myQReal READ myQReal WRITE setMyQReal)
 
       
  1134     Q_PROPERTY(CustomString customString READ customString WRITE setCustomString )
 
  1128 
  1135 
  1129 public:
 
  1136 public:
 
  1130     enum Alpha {
 
  1137     enum Alpha {
 
  1131         Alpha0,
 
  1138         Alpha0,
 
  1132         Alpha1,
 
  1139         Alpha1,
 
  1160     void setMyFloat(float value) { m_float = value; }
 
  1167     void setMyFloat(float value) { m_float = value; }
 
  1161     inline float myFloat() const { return m_float; }
 
  1168     inline float myFloat() const { return m_float; }
 
  1162 
  1169 
  1163     void setMyQReal(qreal value) { m_qreal = value; }
 
  1170     void setMyQReal(qreal value) { m_qreal = value; }
 
  1164     qreal myQReal() const { return m_qreal; }
 
  1171     qreal myQReal() const { return m_qreal; }
 
       
  1172 
       
  1173     CustomString customString() const { return m_customString; }
 
       
  1174     void setCustomString(const QString &string) { m_customString = string; }
 
  1165 
  1175 
  1166 private:
 
  1176 private:
 
  1167     Alpha m_alpha;
 
  1177     Alpha m_alpha;
 
  1168     Priority m_priority;
 
  1178     Priority m_priority;
 
  1169     int m_number;
 
  1179     int m_number;
 
  1170     QString m_string;
 
  1180     QString m_string;
 
  1171     QVariant m_variant;
 
  1181     QVariant m_variant;
 
  1172     CustomType *m_custom;
 
  1182     CustomType *m_custom;
 
  1173     float m_float;
 
  1183     float m_float;
 
  1174     qreal m_qreal;
 
  1184     qreal m_qreal;
 
       
  1185     CustomString m_customString;
 
  1175 };
 
  1186 };
 
  1176 
  1187 
  1177 Q_DECLARE_METATYPE(PropertyObject::Priority)
 
  1188 Q_DECLARE_METATYPE(PropertyObject::Priority)
 
  1178 
  1189 
  1179 void tst_QObject::threadSignalEmissionCrash()
 
  1190 void tst_QObject::threadSignalEmissionCrash()
 
  1624     QCOMPARE(qVariantValue<PropertyObject::Priority>(var), PropertyObject::High);
 
  1635     QCOMPARE(qVariantValue<PropertyObject::Priority>(var), PropertyObject::High);
 
  1625     object.setPriority(PropertyObject::Low);
 
  1636     object.setPriority(PropertyObject::Low);
 
  1626     QCOMPARE(qVariantValue<PropertyObject::Priority>(object.property("priority")), PropertyObject::Low);
 
  1637     QCOMPARE(qVariantValue<PropertyObject::Priority>(object.property("priority")), PropertyObject::Low);
 
  1627     object.setProperty("priority", var);
 
  1638     object.setProperty("priority", var);
 
  1628     QCOMPARE(qVariantValue<PropertyObject::Priority>(object.property("priority")), PropertyObject::High);
 
  1639     QCOMPARE(qVariantValue<PropertyObject::Priority>(object.property("priority")), PropertyObject::High);
 
       
  1640 
       
  1641     qRegisterMetaType<CustomString>("CustomString");
 
       
  1642     QVERIFY(mo->indexOfProperty("customString") != -1);
 
       
  1643     QCOMPARE(object.property("customString").toString(), QString());
 
       
  1644     object.setCustomString("String1");
 
       
  1645     QCOMPARE(object.property("customString"), QVariant("String1"));
 
       
  1646     QVERIFY(object.setProperty("customString", "String2"));
 
       
  1647     QCOMPARE(object.property("customString"), QVariant("String2"));
 
       
  1648     QVERIFY(!object.setProperty("customString", QVariant()));
 
  1629 }
 
  1649 }
 
  1630 
  1650 
  1631 void tst_QObject::metamethod()
 
  1651 void tst_QObject::metamethod()
 
  1632 {
 
  1652 {
 
  1633     SenderObject obj;
 
  1653     SenderObject obj;
 
  2022 
  2042 
  2023 enum Enum { };
 
  2043 enum Enum { };
 
  2024 
  2044 
  2025 struct Struct { };
 
  2045 struct Struct { };
 
  2026 class Class { };
 
  2046 class Class { };
 
       
  2047 template <typename T> class Template { };
 
  2027 
  2048 
  2028 class NormalizeObject : public QObject
 
  2049 class NormalizeObject : public QObject
 
  2029 {
 
  2050 {
 
  2030     Q_OBJECT
 
  2051     Q_OBJECT
 
  2031 
  2052 
  2059     void unsignedlonglongSignal(quint64);
 
  2080     void unsignedlonglongSignal(quint64);
 
  2060     void unsignedlongintSignal(unsigned long int);
 
  2081     void unsignedlongintSignal(unsigned long int);
 
  2061     void unsignedshortSignal(unsigned short);
 
  2082     void unsignedshortSignal(unsigned short);
 
  2062     void unsignedcharSignal(unsigned char);
 
  2083     void unsignedcharSignal(unsigned char);
 
  2063 
  2084 
       
  2085     void typeRefSignal(Template<Class &> &ref);
 
       
  2086     void constTypeRefSignal(const Template<Class const &> &ref);
 
       
  2087     void typeConstRefSignal(Template<Class const &> const &ref);
 
       
  2088 
       
  2089     void typePointerConstRefSignal(Class * const &);
 
       
  2090 
       
  2091     void constTemplateSignal1( Template<int > );
 
       
  2092     void constTemplateSignal2( Template< const int >);
 
       
  2093 
  2064 public slots:
 
  2094 public slots:
 
  2065     void uintPointerSlot(uint *) { }
 
  2095     void uintPointerSlot(uint *) { }
 
  2066     void ulongPointerSlot(ulong *) { }
 
  2096     void ulongPointerSlot(ulong *) { }
 
  2067     void constUintPointerSlot(const uint *) { }
 
  2097     void constUintPointerSlot(const uint *) { }
 
  2068     void constUlongPointerSlot(const ulong *) { }
 
  2098     void constUlongPointerSlot(const ulong *) { }
 
  2069 
  2099 
  2070     void structSlot(Struct s) { }
 
  2100     void structSlot(Struct s) { Q_UNUSED(s); }
 
  2071     void classSlot(Class c) { }
 
  2101     void classSlot(Class c) { Q_UNUSED(c); }
 
  2072     void enumSlot(Enum e) { }
 
  2102     void enumSlot(Enum e) { Q_UNUSED(e); }
 
  2073 
  2103 
  2074     void structPointerSlot(Struct *s) { }
 
  2104     void structPointerSlot(Struct *s) { Q_UNUSED(s); }
 
  2075     void classPointerSlot(Class *c) { }
 
  2105     void classPointerSlot(Class *c) { Q_UNUSED(c); }
 
  2076     void enumPointerSlot(Enum *e) { }
 
  2106     void enumPointerSlot(Enum *e) { Q_UNUSED(e); }
 
  2077 
  2107 
  2078     void constStructPointerSlot(const Struct *s) { }
 
  2108     void constStructPointerSlot(const Struct *s) { Q_UNUSED(s); }
 
  2079     void constClassPointerSlot(const Class *c) { }
 
  2109     void constClassPointerSlot(const Class *c) { Q_UNUSED(c); }
 
  2080     void constEnumPointerSlot(const Enum *e) { }
 
  2110     void constEnumPointerSlot(const Enum *e) { Q_UNUSED(e); }
 
  2081 
  2111 
  2082     void constStructPointerConstPointerSlot(const Struct * const *s) { }
 
  2112     void constStructPointerConstPointerSlot(const Struct * const *s) { Q_UNUSED(s); }
 
  2083     void constClassPointerConstPointerSlot(const Class * const *c) { }
 
  2113     void constClassPointerConstPointerSlot(const Class * const *c) { Q_UNUSED(c); }
 
  2084     void constEnumPointerConstPointerSlot(const Enum * const *e) { }
 
  2114     void constEnumPointerConstPointerSlot(const Enum * const *e) { Q_UNUSED(e); }
 
  2085 
  2115 
  2086     void uintSlot(uint) {};
 
  2116     void uintSlot(uint) {};
 
  2087     void unsignedintSlot(unsigned int) {};
 
  2117     void unsignedintSlot(unsigned int) {};
 
  2088     void unsignedSlot(unsigned) {};
 
  2118     void unsignedSlot(unsigned) {};
 
  2089     void unsignedlongSlot(unsigned long) {};
 
  2119     void unsignedlongSlot(unsigned long) {};
 
  2090     void unsignedlonglongSlot(quint64) {};
 
  2120     void unsignedlonglongSlot(quint64) {};
 
  2091     void unsignedlongintSlot(unsigned long int) {};
 
  2121     void unsignedlongintSlot(unsigned long int) {};
 
  2092     void unsignedshortSlot(unsigned short) {};
 
  2122     void unsignedshortSlot(unsigned short) {};
 
  2093     void unsignedcharSlot(unsigned char) {};
 
  2123     void unsignedcharSlot(unsigned char) {};
 
  2094 
  2124 
       
  2125     void typeRefSlot(Template<Class &> &) {}
 
       
  2126     void constTypeRefSlot(const Template<const Class &> &) {}
 
       
  2127     void typeConstRefSlot(Template<Class const &> const &) {}
 
       
  2128 
       
  2129     void typePointerConstRefSlot(Class * const &) {}
 
       
  2130 
       
  2131     void constTemplateSlot1(Template<int > const) {}
 
       
  2132     void constTemplateSlot2(const Template<int > ) {}
 
       
  2133     void constTemplateSlot3(const Template< const int >) {}
 
  2095 };
 
  2134 };
 
       
  2135 
       
  2136 #include "oldnormalizeobject.h"
 
  2096 
  2137 
  2097 void tst_QObject::normalize()
 
  2138 void tst_QObject::normalize()
 
  2098 {
 
  2139 {
 
  2099     NormalizeObject object;
 
  2140     NormalizeObject object;
 
  2100 
  2141 
  2331                            SLOT(unsignedshortSlot(unsigned short))));
 
  2372                            SLOT(unsignedshortSlot(unsigned short))));
 
  2332     QVERIFY(object.connect(&object,
 
  2373     QVERIFY(object.connect(&object,
 
  2333                            SIGNAL(unsignedcharSignal(unsigned char)),
 
  2374                            SIGNAL(unsignedcharSignal(unsigned char)),
 
  2334                            SLOT(unsignedcharSlot(unsigned char))));
 
  2375                            SLOT(unsignedcharSlot(unsigned char))));
 
  2335 
  2376 
  2336 
  2377     // connect when original template signature and mixed usage of 'T<C const &> const &',
 
       
  2378     // 'const T<const C &> &', and 'T<const C &>'
 
       
  2379 
       
  2380     QVERIFY(object.connect(&object,
 
       
  2381                            SIGNAL(typeRefSignal(Template<Class &> &)),
 
       
  2382                            SLOT(typeRefSlot(Template<Class &> &))));
 
       
  2383 
       
  2384     QVERIFY(object.connect(&object,
 
       
  2385                            SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
 
       
  2386                            SLOT(constTypeRefSlot(const Template<const Class &> &))));
 
       
  2387     QVERIFY(object.connect(&object,
 
       
  2388                            SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
 
       
  2389                            SLOT(constTypeRefSlot(const Template<Class const &> &))));
 
       
  2390     QVERIFY(object.connect(&object,
 
       
  2391                            SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
 
       
  2392                            SLOT(constTypeRefSlot(Template<Class const &> const &))));
 
       
  2393     QVERIFY(object.connect(&object,
 
       
  2394                            SIGNAL(constTypeRefSignal(Template<const Class &> const &)),
 
       
  2395                            SLOT(constTypeRefSlot(Template<Class const &> const &))));
 
       
  2396     QVERIFY(object.connect(&object,
 
       
  2397                            SIGNAL(constTypeRefSignal(Template<Class const &> const &)),
 
       
  2398                            SLOT(constTypeRefSlot(Template<Class const &> const &))));
 
       
  2399 
       
  2400     QVERIFY(object.connect(&object,
 
       
  2401                            SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
 
       
  2402                            SLOT(typeConstRefSlot(const Template<const Class &> &))));
 
       
  2403     QVERIFY(object.connect(&object,
 
       
  2404                            SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
 
       
  2405                            SLOT(typeConstRefSlot(const Template<Class const &> &))));
 
       
  2406     QVERIFY(object.connect(&object,
 
       
  2407                            SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
 
       
  2408                            SLOT(typeConstRefSlot(Template<Class const &> const &))));
 
       
  2409     QVERIFY(object.connect(&object,
 
       
  2410                            SIGNAL(constTypeRefSignal(Template<const Class &> const &)),
 
       
  2411                            SLOT(typeConstRefSlot(Template<Class const &> const &))));
 
       
  2412     QVERIFY(object.connect(&object,
 
       
  2413                            SIGNAL(constTypeRefSignal(Template<Class const &> const &)),
 
       
  2414                            SLOT(typeConstRefSlot(Template<Class const &> const &))));
 
       
  2415 
       
  2416     QVERIFY(object.connect(&object,
 
       
  2417                            SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
 
       
  2418                            SLOT(constTypeRefSlot(const Template<const Class &> &))));
 
       
  2419     QVERIFY(object.connect(&object,
 
       
  2420                            SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
 
       
  2421                            SLOT(constTypeRefSlot(const Template<Class const &> &))));
 
       
  2422     QVERIFY(object.connect(&object,
 
       
  2423                            SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
 
       
  2424                            SLOT(constTypeRefSlot(Template<Class const &> const &))));
 
       
  2425     QVERIFY(object.connect(&object,
 
       
  2426                            SIGNAL(typeConstRefSignal(Template<const Class &> const &)),
 
       
  2427                            SLOT(constTypeRefSlot(Template<Class const &> const &))));
 
       
  2428     QVERIFY(object.connect(&object,
 
       
  2429                            SIGNAL(typeConstRefSignal(Template<Class const &> const &)),
 
       
  2430                            SLOT(constTypeRefSlot(Template<Class const &> const &))));
 
       
  2431 
       
  2432     QVERIFY(object.connect(&object,
 
       
  2433                            SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
 
       
  2434                            SLOT(typeConstRefSlot(const Template<const Class &> &))));
 
       
  2435     QVERIFY(object.connect(&object,
 
       
  2436                            SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
 
       
  2437                            SLOT(typeConstRefSlot(const Template<Class const &> &))));
 
       
  2438     QVERIFY(object.connect(&object,
 
       
  2439                            SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
 
       
  2440                            SLOT(typeConstRefSlot(Template<Class const &> const &))));
 
       
  2441     QVERIFY(object.connect(&object,
 
       
  2442                            SIGNAL(typeConstRefSignal(Template<const Class &> const &)),
 
       
  2443                            SLOT(typeConstRefSlot(Template<Class const &> const &))));
 
       
  2444     QVERIFY(object.connect(&object,
 
       
  2445                            SIGNAL(typeConstRefSignal(Template<Class const &> const &)),
 
       
  2446                            SLOT(typeConstRefSlot(Template<Class const &> const &))));
 
       
  2447 
       
  2448     // same test again, this time with an object compiled with old moc output... we know that
 
       
  2449     // it is not possible to connect everything, whic is the purpose for this test
 
       
  2450     OldNormalizeObject oldobject;
 
       
  2451 
       
  2452     QVERIFY(oldobject.connect(&oldobject,
 
       
  2453                               SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
 
       
  2454                               SLOT(constTypeRefSlot(const Template<const Class &> &))));
 
       
  2455     QVERIFY(oldobject.connect(&oldobject,
 
       
  2456                               SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
 
       
  2457                               SLOT(constTypeRefSlot(const Template<Class const &> &))));
 
       
  2458     // this fails in older versions, but passes now due to proper normalizing
 
       
  2459     QVERIFY(oldobject.connect(&oldobject,
 
       
  2460                                SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
 
       
  2461                                SLOT(constTypeRefSlot(Template<Class const &> const &))));
 
       
  2462     // this fails in older versions, but passes now due to proper normalizing
 
       
  2463     QVERIFY(oldobject.connect(&oldobject,
 
       
  2464                                SIGNAL(constTypeRefSignal(Template<const Class &> const &)),
 
       
  2465                                SLOT(constTypeRefSlot(Template<Class const &> const &))));
 
       
  2466     // this fails in older versions, but passes now due to proper normalizing
 
       
  2467     QVERIFY(oldobject.connect(&oldobject,
 
       
  2468                                SIGNAL(constTypeRefSignal(Template<Class const &> const &)),
 
       
  2469                                SLOT(constTypeRefSlot(Template<Class const &> const &))));
 
       
  2470 
       
  2471     // these fail in older Qt versions, but pass now due to proper normalizing
 
       
  2472     QVERIFY(oldobject.connect(&oldobject,
 
       
  2473                                SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
 
       
  2474                                SLOT(typeConstRefSlot(const Template<const Class &> &))));
 
       
  2475     QVERIFY(oldobject.connect(&oldobject,
 
       
  2476                                SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
 
       
  2477                                SLOT(typeConstRefSlot(const Template<Class const &> &))));
 
       
  2478     QVERIFY(oldobject.connect(&oldobject,
 
       
  2479                                SIGNAL(constTypeRefSignal(const Template<const Class &> &)),
 
       
  2480                                SLOT(typeConstRefSlot(Template<Class const &> const &))));
 
       
  2481     QVERIFY(oldobject.connect(&oldobject,
 
       
  2482                                SIGNAL(constTypeRefSignal(Template<const Class &> const &)),
 
       
  2483                                SLOT(typeConstRefSlot(Template<Class const &> const &))));
 
       
  2484     QVERIFY(oldobject.connect(&oldobject,
 
       
  2485                                SIGNAL(constTypeRefSignal(Template<Class const &> const &)),
 
       
  2486                                SLOT(typeConstRefSlot(Template<Class const &> const &))));
 
       
  2487 
       
  2488     // these also fail in older Qt versions, but pass now due to proper normalizing
 
       
  2489     QVERIFY(oldobject.connect(&oldobject,
 
       
  2490                                SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
 
       
  2491                                SLOT(constTypeRefSlot(const Template<const Class &> &))));
 
       
  2492     QVERIFY(oldobject.connect(&oldobject,
 
       
  2493                                SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
 
       
  2494                                SLOT(constTypeRefSlot(const Template<Class const &> &))));
 
       
  2495     QVERIFY(oldobject.connect(&oldobject,
 
       
  2496                                SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
 
       
  2497                                SLOT(constTypeRefSlot(Template<Class const &> const &))));
 
       
  2498     QVERIFY(oldobject.connect(&oldobject,
 
       
  2499                                SIGNAL(typeConstRefSignal(Template<const Class &> const &)),
 
       
  2500                                SLOT(constTypeRefSlot(Template<Class const &> const &))));
 
       
  2501     QVERIFY(oldobject.connect(&oldobject,
 
       
  2502                                SIGNAL(typeConstRefSignal(Template<Class const &> const &)),
 
       
  2503                                SLOT(constTypeRefSlot(Template<Class const &> const &))));
 
       
  2504 
       
  2505     // this fails in older versions, but passes now due to proper normalizing
 
       
  2506     QVERIFY(oldobject.connect(&oldobject,
 
       
  2507                                SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
 
       
  2508                                SLOT(typeConstRefSlot(const Template<const Class &> &))));
 
       
  2509     // this fails in older versions, but passes now due to proper normalizing
 
       
  2510     QVERIFY(oldobject.connect(&oldobject,
 
       
  2511                                SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
 
       
  2512                                SLOT(typeConstRefSlot(const Template<Class const &> &))));
 
       
  2513     // this fails in older versions, but passes now due to proper normalizing
 
       
  2514     QVERIFY(oldobject.connect(&oldobject,
 
       
  2515                                SIGNAL(typeConstRefSignal(const Template<const Class &> &)),
 
       
  2516                                SLOT(typeConstRefSlot(Template<Class const &> const &))));
 
       
  2517     QVERIFY(oldobject.connect(&oldobject,
 
       
  2518                                SIGNAL(typeConstRefSignal(Template<const Class &> const &)),
 
       
  2519                                SLOT(typeConstRefSlot(Template<Class const &> const &))));
 
       
  2520     QVERIFY(oldobject.connect(&oldobject,
 
       
  2521                                SIGNAL(typeConstRefSignal(Template<Class const &> const &)),
 
       
  2522                                SLOT(typeConstRefSlot(Template<Class const &> const &))));
 
       
  2523 
       
  2524     QVERIFY(object.connect(&object,
 
       
  2525                            SIGNAL(typePointerConstRefSignal(Class*const&)),
 
       
  2526                            SLOT(typePointerConstRefSlot(Class*const&))));
 
       
  2527     QVERIFY(object.connect(&object,
 
       
  2528                            SIGNAL(typePointerConstRefSignal(Class*const&)),
 
       
  2529                            SLOT(typePointerConstRefSlot(Class*))));
 
       
  2530     QVERIFY(object.connect(&object,
 
       
  2531                            SIGNAL(typePointerConstRefSignal(Class*)),
 
       
  2532                            SLOT(typePointerConstRefSlot(Class*const&))));
 
       
  2533     QVERIFY(object.connect(&object,
 
       
  2534                            SIGNAL(typePointerConstRefSignal(Class*)),
 
       
  2535                            SLOT(typePointerConstRefSlot(Class*))));
 
       
  2536 
       
  2537     QVERIFY( connect(&object, SIGNAL(constTemplateSignal1(Template <int>)),
 
       
  2538                      &object , SLOT(constTemplateSlot1 (Template<int > )  ) ));
 
       
  2539     QVERIFY( connect(&object, SIGNAL(constTemplateSignal1(Template <int>)),
 
       
  2540                      &object , SLOT(constTemplateSlot2 (Template<int > )  ) ));
 
       
  2541     QVERIFY( connect(&object, SIGNAL(constTemplateSignal2(Template <const int>)),
 
       
  2542                      &object , SLOT(constTemplateSlot3(Template<int const > ) ) ));
 
       
  2543 
       
  2544     //type does not match
 
       
  2545     QTest::ignoreMessage(QtWarningMsg, "QObject::connect: Incompatible sender/receiver arguments\n"
 
       
  2546                     "        NormalizeObject::constTemplateSignal1(Template<int>) --> NormalizeObject::constTemplateSlot3(Template<const int>)");
 
       
  2547     QVERIFY(!connect(&object, SIGNAL(constTemplateSignal1(Template <int>)),
 
       
  2548                      &object , SLOT(constTemplateSlot3(Template<int const> ) ) ));
 
  2337 }
 
  2549 }
 
  2338 
  2550 
  2339 class SiblingDeleter : public QObject
 
  2551 class SiblingDeleter : public QObject
 
  2340 {
 
  2552 {
 
  2341 public:
 
  2553 public:
 
  3360 
  3572 
  3361     delete s;
 
  3573     delete s;
 
  3362     delete r1;
 
  3574     delete r1;
 
  3363 }
 
  3575 }
 
  3364 
  3576 
       
  3577 class ConfusingObject : public SenderObject
 
       
  3578 { Q_OBJECT
 
       
  3579 public slots:
 
       
  3580     void signal1() { s++; }
 
       
  3581 signals:
 
       
  3582     void aPublicSlot();
 
       
  3583 public:
 
       
  3584     int s;
 
       
  3585     ConfusingObject() : s(0) {}
 
       
  3586     friend class tst_QObject;
 
       
  3587 };
 
       
  3588 
       
  3589 void tst_QObject::sameName()
 
       
  3590 {
 
       
  3591     ConfusingObject c1, c2;
 
       
  3592     QVERIFY(connect(&c1, SIGNAL(signal1()), &c1, SLOT(signal1())));
 
       
  3593     c1.emitSignal1();
 
       
  3594     QCOMPARE(c1.s, 1);
 
       
  3595 
       
  3596     QVERIFY(connect(&c2, SIGNAL(signal1()), &c1, SIGNAL(signal1())));
 
       
  3597     c2.emitSignal1();
 
       
  3598     QCOMPARE(c1.s, 2);
 
       
  3599 
       
  3600     QVERIFY(connect(&c2, SIGNAL(aPublicSlot()), &c1, SLOT(signal1())));
 
       
  3601     c2.aPublicSlot();
 
       
  3602     QCOMPARE(c2.aPublicSlotCalled, 0);
 
       
  3603     QCOMPARE(c1.aPublicSlotCalled, 0);
 
       
  3604     QCOMPARE(c1.s, 3);
 
       
  3605 
       
  3606     QVERIFY(connect(&c2, SIGNAL(aPublicSlot()), &c1, SLOT(aPublicSlot())));
 
       
  3607     c2.aPublicSlot();
 
       
  3608     QCOMPARE(c2.aPublicSlotCalled, 0);
 
       
  3609     QCOMPARE(c1.aPublicSlotCalled, 1);
 
       
  3610     QCOMPARE(c1.s, 4);
 
       
  3611 }
 
       
  3612 
  3365 QTEST_MAIN(tst_QObject)
 
  3613 QTEST_MAIN(tst_QObject)
 
  3366 #include "tst_qobject.moc"
 
  3614 #include "tst_qobject.moc"
FCL/sf/mw/qt