libpyside: Refactor the signal-lambda-test

Introduce Sender/Receiver classes for clarity. Prepend tests for the
new Signal.connect() syntax before the old string-based connect() tests.

Join the 2 tests using QProcess to save one execution.

Pick-to: 6.5
Task-number: PYSIDE-2646
Change-Id: I41db1be3cf5772df2ed7a89aecf4d9b3ff5b8a51
Reviewed-by: Cristian Maureira-Fredes <cristian.maureira-fredes@qt.io>
(cherry picked from commit c174421fabf189aa877deac7d1b8d5503ec54991)
Reviewed-by: Qt Cherry-pick Bot <cherrypick_bot@qt-project.org>
(cherry picked from commit 24cca3617beeba2a31ea09f210576cce5d9da1c4)

1 files changed, 56 insertions, 28 deletions

diff --git a/sources/pyside6/tests/signals/lambda_test.py b/sources/pyside6/tests/signals/lambda_test.py
index a91a97959..c3198c305 100644
--- a/sources/pyside6/tests/signals/lambda_test.py
+++ b/sources/pyside6/tests/signals/lambda_test.py
@@ -13,12 +13,27 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL, QProcess
+from PySide6.QtCore import QObject, Signal, SIGNAL, QProcess
 
 from helper.usesqapplication import UsesQApplication
 
 
-class Dummy(QObject):
+class Sender(QObject):
+    void_signal = Signal()
+    int_signal = Signal(int)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._delayed_int = 0
+
+    def emit_void(self):
+        self.void_signal.emit()
+
+    def emit_int(self, v):
+        self.int_signal.emit(v)
+
+
+class Receiver(QObject):
 
     def __init__(self, *args):
         super().__init__(*args)
@@ -28,45 +43,58 @@ class BasicCase(unittest.TestCase):
 
     def testSimplePythonSignalNoArgs(self):
         # Connecting a lambda to a simple python signal without arguments
-        obj = Dummy()
-        QObject.connect(obj, SIGNAL('foo()'),
-                        lambda: setattr(obj, 'called', True))
-        obj.emit(SIGNAL('foo()'))
-        self.assertTrue(obj.called)
+        receiver = Receiver()
+        sender = Sender()
+        sender.void_signal.connect(lambda: setattr(receiver, 'called', True))
+        sender.emit_void()
+        self.assertTrue(receiver.called)
 
     def testSimplePythonSignal(self):
         # Connecting a lambda to a simple python signal witharguments
-        obj = Dummy()
+        receiver = Receiver()
+        sender = Sender()
+        arg = 42
+        sender.int_signal.connect(lambda x: setattr(receiver, 'arg', arg))
+        sender.emit_int(arg)
+        self.assertEqual(receiver.arg, arg)
+
+    def testSimplePythonSignalNoArgsString(self):
+        # Connecting a lambda to a simple python signal without arguments
+        receiver = Receiver()
+        sender = Sender()
+        QObject.connect(sender, SIGNAL('void_signal()'),
+                        lambda: setattr(receiver, 'called', True))
+        sender.emit_void()
+        self.assertTrue(receiver.called)
+
+    def testSimplePythonSignalString(self):
+        # Connecting a lambda to a simple python signal witharguments
+        receiver = Receiver()
+        sender = Sender()
         arg = 42
-        QObject.connect(obj, SIGNAL('foo(int)'),
-                        lambda x: setattr(obj, 'arg', 42))
-        obj.emit(SIGNAL('foo(int)'), arg)
-        self.assertEqual(obj.arg, arg)
+        QObject.connect(sender, SIGNAL('int_signal(int)'),
+                        lambda x: setattr(receiver, 'arg', arg))
+        sender.emit_int(arg)
+        self.assertEqual(receiver.arg, arg)
 
 
 class QtSigLambda(UsesQApplication):
 
     qapplication = True
 
-    def testNoArgs(self):
-        '''Connecting a lambda to a signal without arguments'''
-        proc = QProcess()
-        dummy = Dummy()
-        QObject.connect(proc, SIGNAL('started()'),
-                        lambda: setattr(dummy, 'called', True))
-        proc.start(sys.executable, ['-c', '""'])
-        proc.waitForFinished()
-        self.assertTrue(dummy.called)
-
     def testWithArgs(self):
-        '''Connecting a lambda to a signal with arguments'''
+        '''Connecting a lambda to a signal with and without arguments'''
         proc = QProcess()
-        dummy = Dummy()
-        QObject.connect(proc, SIGNAL('finished(int)'),
-                        lambda x: setattr(dummy, 'called', x))
+        dummy = Receiver()
+        proc.started.connect(lambda: setattr(dummy, 'called', True))
+        proc.finished.connect(lambda x: setattr(dummy, 'exit_code', x))
+
         proc.start(sys.executable, ['-c', '""'])
-        proc.waitForFinished()
-        self.assertEqual(dummy.called, proc.exitCode())
+        self.assertTrue(proc.waitForStarted())
+        self.assertTrue(proc.waitForFinished())
+
+        self.assertTrue(dummy.called)
+        self.assertEqual(dummy.exit_code, proc.exitCode())
 
 
 if __name__ == '__main__':