Imported Upstream version 3.3.2

[platform/upstream/pygobject2.git] / tests / test_signal.py

diff --git a/tests/test_signal.py b/tests/test_signal.py
index 8486adb..66a7427 100644 (file)
--- a/tests/test_signal.py
+++ b/tests/test_signal.py
@@ -8,17 +8,21 @@ from gi.repository import GObject
 import testhelper
 from compathelper import _long
 
+
 class C(GObject.GObject):
-    __gsignals__ = { 'my_signal': (GObject.SignalFlags.RUN_FIRST, None,
-                                   (GObject.TYPE_INT,)) }
+    __gsignals__ = {'my_signal': (GObject.SignalFlags.RUN_FIRST, None,
+                                  (GObject.TYPE_INT,))}
+
     def do_my_signal(self, arg):
         self.arg = arg
 
+
 class D(C):
     def do_my_signal(self, arg2):
         self.arg2 = arg2
         C.do_my_signal(self, arg2)
 
+
 class TestSignalCreation(unittest.TestCase):
     # Bug 540376.
     def test_illegals(self):
@@ -48,13 +52,15 @@ class TestChaining(unittest.TestCase):
         self.inst.emit("my_signal", 42)
         assert self.inst.arg == 42
 
-    def testChaining(self):
+    def testChaining2(self):
         inst2 = D()
         inst2.emit("my_signal", 44)
         assert inst2.arg == 44
         assert inst2.arg2 == 44
 
 # This is for bug 153718
+
+
 class TestGSignalsError(unittest.TestCase):
     def testInvalidType(self, *args):
         def foo():
@@ -66,10 +72,11 @@ class TestGSignalsError(unittest.TestCase):
     def testInvalidName(self, *args):
         def foo():
             class Foo(GObject.GObject):
-                __gsignals__ = {'not-exists' : 'override'}
+                __gsignals__ = {'not-exists': 'override'}
         self.assertRaises(TypeError, foo)
         gc.collect()
 
+
 class TestGPropertyError(unittest.TestCase):
     def testInvalidType(self, *args):
         def foo():
@@ -81,11 +88,12 @@ class TestGPropertyError(unittest.TestCase):
     def testInvalidName(self, *args):
         def foo():
             class Foo(GObject.GObject):
-                __gproperties__ = { None: None }
+                __gproperties__ = {None: None}
 
         self.assertRaises(TypeError, foo)
         gc.collect()
 
+
 class TestList(unittest.TestCase):
     def testListObject(self):
         self.assertEqual(GObject.signal_list_names(C), ('my-signal',))
@@ -99,6 +107,7 @@ def my_accumulator(ihint, return_accu, handler_return, user_data):
         return False, return_accu
     return True, return_accu + handler_return
 
+
 class Foo(GObject.GObject):
     __gsignals__ = {
         'my-acc-signal': (GObject.SignalFlags.RUN_LAST, GObject.TYPE_INT,
@@ -107,6 +116,7 @@ class Foo(GObject.GObject):
                                 (), GObject.signal_accumulator_true_handled)
         }
 
+
 class TestAccumulator(unittest.TestCase):
 
     def testAccumulator(self):
@@ -134,16 +144,20 @@ class TestAccumulator(unittest.TestCase):
     def _true_handler1(self, obj):
         self.__true_val = 1
         return False
+
     def _true_handler2(self, obj):
         self.__true_val = 2
         return True
+
     def _true_handler3(self, obj):
         self.__true_val = 3
         return False
 
+
 class E(GObject.GObject):
-    __gsignals__ = { 'signal': (GObject.SignalFlags.RUN_FIRST, None,
-                                ()) }
+    __gsignals__ = {'signal': (GObject.SignalFlags.RUN_FIRST, None,
+                               ())}
+
     def __init__(self):
         GObject.GObject.__init__(self)
         self.status = 0
@@ -152,9 +166,11 @@ class E(GObject.GObject):
         assert self.status == 0
         self.status = 1
 
+
 class F(GObject.GObject):
-    __gsignals__ = { 'signal': (GObject.SignalFlags.RUN_FIRST, None,
-                                ()) }
+    __gsignals__ = {'signal': (GObject.SignalFlags.RUN_FIRST, None,
+                               ())}
+
     def __init__(self):
         GObject.GObject.__init__(self)
         self.status = 0
@@ -162,6 +178,7 @@ class F(GObject.GObject):
     def do_signal(self):
         self.status += 1
 
+
 class TestEmissionHook(unittest.TestCase):
     def testAdd(self):
         self.hook = True
@@ -194,10 +211,11 @@ class TestEmissionHook(unittest.TestCase):
     def testCallbackReturnFalse(self):
         self.hook = False
         obj = F()
+
         def _emission_hook(obj):
             obj.status += 1
             return False
-        hook_id = GObject.add_emission_hook(obj, "signal", _emission_hook)
+        GObject.add_emission_hook(obj, "signal", _emission_hook)
         obj.emit('signal')
         obj.emit('signal')
         self.assertEqual(obj.status, 3)
@@ -205,6 +223,7 @@ class TestEmissionHook(unittest.TestCase):
     def testCallbackReturnTrue(self):
         self.hook = False
         obj = F()
+
         def _emission_hook(obj):
             obj.status += 1
             return True
@@ -217,6 +236,7 @@ class TestEmissionHook(unittest.TestCase):
     def testCallbackReturnTrueButRemove(self):
         self.hook = False
         obj = F()
+
         def _emission_hook(obj):
             obj.status += 1
             return True
@@ -226,6 +246,7 @@ class TestEmissionHook(unittest.TestCase):
         obj.emit('signal')
         self.assertEqual(obj.status, 3)
 
+
 class TestClosures(unittest.TestCase):
     def setUp(self):
         self.count = 0
@@ -274,11 +295,13 @@ class TestClosures(unittest.TestCase):
 
     def testGString(self):
         class C(GObject.GObject):
-            __gsignals__ = { 'my_signal': (GObject.SignalFlags.RUN_LAST, GObject.TYPE_GSTRING,
-                                           (GObject.TYPE_GSTRING,)) }
+            __gsignals__ = {'my_signal': (GObject.SignalFlags.RUN_LAST, GObject.TYPE_GSTRING,
+                                          (GObject.TYPE_GSTRING,))}
+
             def __init__(self, test):
                 GObject.GObject.__init__(self)
                 self.test = test
+
             def do_my_signal(self, data):
                 self.data = data
                 self.test.assertEqual(len(data), 3)
@@ -287,12 +310,13 @@ class TestClosures(unittest.TestCase):
         data = c.emit("my_signal", "\01\00\02")
         self.assertEqual(data, "\02\00\01")
 
+
 class SigPropClass(GObject.GObject):
-    __gsignals__ = { 'my_signal': (GObject.SignalFlags.RUN_FIRST, None,
-                                   (GObject.TYPE_INT,)) }
+    __gsignals__ = {'my_signal': (GObject.SignalFlags.RUN_FIRST, None,
+                                  (GObject.TYPE_INT,))}
 
     __gproperties__ = {
-        'foo': (str, None, None, '', GObject.PARAM_WRITABLE|GObject.PARAM_CONSTRUCT),
+        'foo': (str, None, None, '', GObject.PARAM_WRITABLE | GObject.PARAM_CONSTRUCT),
         }
 
     signal_emission_failed = False
@@ -314,7 +338,7 @@ class SigPropClass(GObject.GObject):
 class TestSigProp(unittest.TestCase):
     def testEmitInPropertySetter(self):
         obj = SigPropClass()
-        self.failIf(obj.signal_emission_failed)
+        self.assertFalse(obj.signal_emission_failed)
 
 f = GObject.SignalFlags.RUN_FIRST
 l = GObject.SignalFlags.RUN_LAST
@@ -323,6 +347,7 @@ double = GObject.TYPE_DOUBLE
 uint = GObject.TYPE_UINT
 ulong = GObject.TYPE_ULONG
 
+
 class CM(GObject.GObject):
     __gsignals__ = dict(
         test1=(f, None, ()),
@@ -335,6 +360,7 @@ class CM(GObject.GObject):
         test_object=(l, object, (object, )),
     )
 
+
 class _TestCMarshaller:
     def setUp(self):
         self.obj = CM()
@@ -355,7 +381,7 @@ class _TestCMarshaller:
 
     def testTestReturnFloat(self):
         rv = self.obj.emit("test-float", 1.234)
-        self.failUnless(rv >= 1.233999 and rv <= 1.2400001, rv)
+        self.assertTrue(rv >= 1.233999 and rv <= 1.2400001, rv)
 
     def testTestReturnDouble(self):
         rv = self.obj.emit("test-double", 1.234)
@@ -378,12 +404,14 @@ else:
     print()
 
 # Test for 374653
+
+
 class TestPyGValue(unittest.TestCase):
     def testNoneNULLBoxedConversion(self):
         class C(GObject.GObject):
             __gsignals__ = dict(my_boxed_signal=(
                 GObject.SignalFlags.RUN_LAST,
-                GObject.type_from_name('GStrv'), ()))
+                GObject.TYPE_STRV, ()))
 
         obj = C()
         obj.connect('my-boxed-signal', lambda obj: None)