Add a flag that ensure that a connection is made only one

It is often desirable, when doing connection, to ensure that the same
connection is only made once. This can be done with the
Qt::UniqueConnection 'flag'

Also documented the order the slot are called

Reviewed-by: Brad

1 files changed, 77 insertions, 4 deletions

diff --git a/tests/auto/qobject/tst_qobject.cpp b/tests/auto/qobject/tst_qobject.cpp
index fb46073..399d021 100644
--- a/tests/auto/qobject/tst_qobject.cpp
+++ b/tests/auto/qobject/tst_qobject.cpp
@@ -116,6 +116,7 @@ private slots:
     void dumpObjectInfo();
     void connectToSender();
     void qobjectConstCast();
+    void uniqConnection();
 protected:
 };
 
@@ -204,12 +205,20 @@ public:
 	sequence_slot3 = 0;
 	sequence_slot2 = 0;
 	sequence_slot1 = 0;
+        count_slot1 = 0;
+        count_slot2 = 0;
+        count_slot3 = 0;
+        count_slot4 = 0;
     }
 
     int sequence_slot1;
     int sequence_slot2;
     int sequence_slot3;
     int sequence_slot4;
+    int count_slot1;
+    int count_slot2;
+    int count_slot3;
+    int count_slot4;
 
     bool called(int slot) {
         switch (slot) {
@@ -224,10 +233,10 @@ public:
     static int sequence;
 
 public slots:
-    void slot1() { sequence_slot1 = ++sequence; }
-    void slot2() { sequence_slot2 = ++sequence; }
-    void slot3() { sequence_slot3 = ++sequence; }
-    void slot4() { sequence_slot4 = ++sequence; }
+    void slot1() { sequence_slot1 = ++sequence; count_slot1++; }
+    void slot2() { sequence_slot2 = ++sequence; count_slot2++; }
+    void slot3() { sequence_slot3 = ++sequence; count_slot3++; }
+    void slot4() { sequence_slot4 = ++sequence; count_slot4++; }
 
 };
 
@@ -2783,5 +2792,69 @@ void tst_QObject::qobjectConstCast()
     QVERIFY(qobject_cast<const FooObject *>(cptr));
 }
 
+void tst_QObject::uniqConnection()
+{
+    SenderObject *s = new SenderObject;
+    ReceiverObject *r1 = new ReceiverObject;
+    ReceiverObject *r2 = new ReceiverObject;
+    r1->reset();
+    r2->reset();
+    ReceiverObject::sequence = 0;
+
+    QVERIFY( connect( s, SIGNAL( signal1() ), r1, SLOT( slot1() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal1() ), r2, SLOT( slot1() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal1() ), r1, SLOT( slot3() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal3() ), r1, SLOT( slot3() ) , Qt::UniqueConnection) );
+
+    s->emitSignal1();
+    s->emitSignal2();
+    s->emitSignal3();
+    s->emitSignal4();
+
+    QCOMPARE( r1->count_slot1, 1 );
+    QCOMPARE( r1->count_slot2, 0 );
+    QCOMPARE( r1->count_slot3, 2 );
+    QCOMPARE( r1->count_slot4, 0 );
+    QCOMPARE( r2->count_slot1, 1 );
+    QCOMPARE( r2->count_slot2, 0 );
+    QCOMPARE( r2->count_slot3, 0 );
+    QCOMPARE( r2->count_slot4, 0 );
+    QCOMPARE( r1->sequence_slot1, 1 );
+    QCOMPARE( r2->sequence_slot1, 2 );
+    QCOMPARE( r1->sequence_slot3, 4 );
+
+    r1->reset();
+    r2->reset();
+    ReceiverObject::sequence = 0;
+
+    QVERIFY( connect( s, SIGNAL( signal4() ), r1, SLOT( slot4() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal4() ), r2, SLOT( slot4() ) , Qt::UniqueConnection) );
+    QVERIFY(!connect( s, SIGNAL( signal4() ), r2, SLOT( slot4() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal1() ), r2, SLOT( slot4() ) , Qt::UniqueConnection) );
+    QVERIFY(!connect( s, SIGNAL( signal4() ), r1, SLOT( slot4() ) , Qt::UniqueConnection) );
+
+    s->emitSignal4();
+    QCOMPARE( r1->count_slot4, 1 );
+    QCOMPARE( r2->count_slot4, 1 );
+    QCOMPARE( r1->sequence_slot4, 1 );
+    QCOMPARE( r2->sequence_slot4, 2 );
+
+    r1->reset();
+    r2->reset();
+    ReceiverObject::sequence = 0;
+
+    connect( s, SIGNAL( signal4() ), r1, SLOT( slot4() ) );
+
+    s->emitSignal4();
+    QCOMPARE( r1->count_slot4, 2 );
+    QCOMPARE( r2->count_slot4, 1 );
+    QCOMPARE( r1->sequence_slot4, 3 );
+    QCOMPARE( r2->sequence_slot4, 2 );
+
+    delete s;
+    delete r1;
+    delete r2;
+}
+
 QTEST_MAIN(tst_QObject)
 #include "tst_qobject.moc"