From 6f540691c4787746f5269447d518fe00ae17268d Mon Sep 17 00:00:00 2001
From: Stephen Kelly <stephen.kelly@kdab.com>
Date: Fri, 13 Jul 2012 11:48:09 +0200
Subject: [PATCH] Add some tests to note that private signals can't be
 overloads.

This is just for completeness of the understanding of the limitations
of private signals. There are no private signals in Qt which have
overloads.

Change-Id: Ic34c555aea360ee34beec796e597657888573da9
Reviewed-by: Olivier Goffart <ogoffart@woboq.com>
---
 tests/auto/tools/moc/tst_moc.cpp | 88 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)

diff --git a/tests/auto/tools/moc/tst_moc.cpp b/tests/auto/tools/moc/tst_moc.cpp
index a79a5f6..f030810 100644
--- a/tests/auto/tools/moc/tst_moc.cpp
+++ b/tests/auto/tools/moc/tst_moc.cpp
@@ -1813,12 +1813,25 @@ public:
         emit privateSignal1(QPrivateSignal());
         emit privateSignalWith1Arg(42, QPrivateSignal());
         emit privateSignalWith2Args(42, "Hello", QPrivateSignal());
+
+        emit privateOverloadedSignal(QPrivateSignal());
+        emit privateOverloadedSignal(42, QPrivateSignal());
+
+        emit overloadedMaybePrivate();
+        emit overloadedMaybePrivate(42, QPrivateSignal());
     }
 
 Q_SIGNALS:
     void privateSignal1(QPrivateSignal);
     void privateSignalWith1Arg(int arg1, QPrivateSignal);
     void privateSignalWith2Args(int arg1, const QString &arg2, QPrivateSignal);
+
+    void privateOverloadedSignal(QPrivateSignal);
+    void privateOverloadedSignal(int, QPrivateSignal);
+
+    void overloadedMaybePrivate();
+    void overloadedMaybePrivate(int, QPrivateSignal);
+
 };
 
 class SubClassFromPrivateSignals : public ClassWithPrivateSignals
@@ -1845,6 +1858,14 @@ public:
 //         emit privateSignal1(ClassWithPrivateSignals::QPrivateSignal());
 //         emit privateSignalWith1Arg(42, ClassWithPrivateSignals::QPrivateSignal());
 //         emit privateSignalWith2Args(42, "Hello", ClassWithPrivateSignals::QPrivateSignal());
+
+//         emit privateOverloadedSignal();
+//         emit privateOverloadedSignal(42);
+
+//         emit overloadedMaybePrivate();
+//         emit overloadedMaybePrivate(42);
+
+
     }
 };
 
@@ -2135,6 +2156,73 @@ void tst_Moc::privateSignalConnection()
 
         QVERIFY(tester.testPassed);
     }
+
+    // Overloaded private signals
+    {
+
+        ClassWithPrivateSignals classWithPrivateSignals;
+        SignalConnectionTester tester;
+        QObject::connect(&classWithPrivateSignals, SIGNAL(privateOverloadedSignal()), &tester, SLOT(testSlot()));
+        QVERIFY(!tester.testPassed);
+
+        classWithPrivateSignals.emitPrivateSignals();
+
+        QVERIFY(tester.testPassed);
+    }
+    {
+
+        ClassWithPrivateSignals classWithPrivateSignals;
+        SignalConnectionTester tester;
+        QObject::connect(&classWithPrivateSignals, SIGNAL(privateOverloadedSignal(int)), &tester, SLOT(testSlotWith1Arg(int)));
+        QVERIFY(!tester.testPassed);
+
+        classWithPrivateSignals.emitPrivateSignals();
+
+        QVERIFY(tester.testPassed);
+    }
+    // We can't use function pointer connections to private signals which are overloaded because we would have to cast in this case to:
+    //   static_cast<void (ClassWithPrivateSignals::*)(int, ClassWithPrivateSignals::QPrivateSignal)>(&ClassWithPrivateSignals::privateOverloadedSignal)
+    // Which doesn't work as ClassWithPrivateSignals::QPrivateSignal is private.
+
+    // Overload with either private or not private signals
+    {
+
+        ClassWithPrivateSignals classWithPrivateSignals;
+        SignalConnectionTester tester;
+        QObject::connect(&classWithPrivateSignals, SIGNAL(overloadedMaybePrivate()), &tester, SLOT(testSlot()));
+        QVERIFY(!tester.testPassed);
+
+        classWithPrivateSignals.emitPrivateSignals();
+
+        QVERIFY(tester.testPassed);
+    }
+    {
+
+        ClassWithPrivateSignals classWithPrivateSignals;
+        SignalConnectionTester tester;
+        QObject::connect(&classWithPrivateSignals, SIGNAL(privateOverloadedSignal(int)), &tester, SLOT(testSlotWith1Arg(int)));
+        QVERIFY(!tester.testPassed);
+
+        classWithPrivateSignals.emitPrivateSignals();
+
+        QVERIFY(tester.testPassed);
+    }
+    {
+
+        ClassWithPrivateSignals classWithPrivateSignals;
+        SignalConnectionTester tester;
+        QObject::connect(&classWithPrivateSignals,
+                         static_cast<void (ClassWithPrivateSignals::*)()>(&ClassWithPrivateSignals::overloadedMaybePrivate),
+                         &tester, &SignalConnectionTester::testSlot);
+        QVERIFY(!tester.testPassed);
+
+        classWithPrivateSignals.emitPrivateSignals();
+
+        QVERIFY(tester.testPassed);
+    }
+    // We can't use function pointer connections to private signals which are overloaded because we would have to cast in this case to:
+    //   static_cast<void (ClassWithPrivateSignals::*)(int, ClassWithPrivateSignals::QPrivateSignal)>(&ClassWithPrivateSignals::overloadedMaybePrivate)
+    // Which doesn't work as ClassWithPrivateSignals::QPrivateSignal is private.
 }
 
 
-- 
2.7.4