test_everything.py 21.6 KB
Newer Older
Tomeu Vizoso's avatar
Tomeu Vizoso committed
1
# -*- Mode: Python; py-indent-offset: 4 -*-
2
# coding=utf-8
Tomeu Vizoso's avatar
Tomeu Vizoso committed
3
4
5
6
7
8
# vim: tabstop=4 shiftwidth=4 expandtab

import unittest

import sys
sys.path.insert(0, "../")
9
from sys import getrefcount
Tomeu Vizoso's avatar
Tomeu Vizoso committed
10

11
import copy
Tomeu Vizoso's avatar
Tomeu Vizoso committed
12
13
import cairo

14
from gi.repository import GObject
15
from gi.repository import GLib
16
from gi.repository import Gio
17
from gi.repository import Regress as Everything
Tomeu Vizoso's avatar
Tomeu Vizoso committed
18

19
20
21
22
23
24
25
if sys.version_info < (3, 0):
    UNICHAR = "\xe2\x99\xa5"
    PY2_UNICODE_UNICHAR = unicode(UNICHAR, 'UTF-8')
else:
    UNICHAR = "鈾"


Tomeu Vizoso's avatar
Tomeu Vizoso committed
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
class TestEverything(unittest.TestCase):

    def test_cairo_context(self):
        context = Everything.test_cairo_context_full_return()
        self.assertTrue(isinstance(context, cairo.Context))

        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 10, 10)
        context = cairo.Context(surface)
        Everything.test_cairo_context_none_in(context)

    def test_cairo_surface(self):
        surface = Everything.test_cairo_surface_none_return()
        self.assertTrue(isinstance(surface, cairo.ImageSurface))
        self.assertTrue(isinstance(surface, cairo.Surface))
        self.assertEquals(surface.get_format(), cairo.FORMAT_ARGB32)
        self.assertEquals(surface.get_width(), 10)
        self.assertEquals(surface.get_height(), 10)

        surface = Everything.test_cairo_surface_full_return()
        self.assertTrue(isinstance(surface, cairo.ImageSurface))
        self.assertTrue(isinstance(surface, cairo.Surface))
        self.assertEquals(surface.get_format(), cairo.FORMAT_ARGB32)
        self.assertEquals(surface.get_width(), 10)
        self.assertEquals(surface.get_height(), 10)

        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 10, 10)
        Everything.test_cairo_surface_none_in(surface)

        surface = Everything.test_cairo_surface_full_out()
        self.assertTrue(isinstance(surface, cairo.ImageSurface))
        self.assertTrue(isinstance(surface, cairo.Surface))
        self.assertEquals(surface.get_format(), cairo.FORMAT_ARGB32)
        self.assertEquals(surface.get_width(), 10)
        self.assertEquals(surface.get_height(), 10)

Paolo Borelli's avatar
Paolo Borelli committed
61
62
    def test_unichar(self):
        self.assertEquals("c", Everything.test_unichar("c"))
63
64
65
66
67
68

        if sys.version_info < (3, 0):
            self.assertEquals(UNICHAR, Everything.test_unichar(PY2_UNICODE_UNICHAR))
        self.assertEquals(UNICHAR, Everything.test_unichar(UNICHAR))
        self.assertRaises(TypeError, Everything.test_unichar, "")
        self.assertRaises(TypeError, Everything.test_unichar, "morethanonechar")
69

70
    def test_floating(self):
71
72
73
74
75
76
77
78
        e = Everything.TestFloating()
        self.assertEquals(e.__grefcount__, 1)

        e = GObject.new(Everything.TestFloating)
        self.assertEquals(e.__grefcount__, 1)

        e = Everything.TestFloating.new()
        self.assertEquals(e.__grefcount__, 1)
79

80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
    def test_caller_allocates(self):
        struct_a = Everything.TestStructA()
        struct_a.some_int = 10
        struct_a.some_int8 = 21
        struct_a.some_double = 3.14
        struct_a.some_enum = Everything.TestEnum.VALUE3

        struct_a_clone = struct_a.clone()
        self.assertTrue(struct_a != struct_a_clone)
        self.assertEquals(struct_a.some_int, struct_a_clone.some_int)
        self.assertEquals(struct_a.some_int8, struct_a_clone.some_int8)
        self.assertEquals(struct_a.some_double, struct_a_clone.some_double)
        self.assertEquals(struct_a.some_enum, struct_a_clone.some_enum)

        struct_b = Everything.TestStructB()
        struct_b.some_int8 = 8
        struct_b.nested_a.some_int = 20
        struct_b.nested_a.some_int8 = 12
        struct_b.nested_a.some_double = 333.3333
        struct_b.nested_a.some_enum = Everything.TestEnum.VALUE2

        struct_b_clone = struct_b.clone()
        self.assertTrue(struct_b != struct_b_clone)
        self.assertEquals(struct_b.some_int8, struct_b_clone.some_int8)
        self.assertEquals(struct_b.nested_a.some_int, struct_b_clone.nested_a.some_int)
        self.assertEquals(struct_b.nested_a.some_int8, struct_b_clone.nested_a.some_int8)
        self.assertEquals(struct_b.nested_a.some_double, struct_b_clone.nested_a.some_double)
        self.assertEquals(struct_b.nested_a.some_enum, struct_b_clone.nested_a.some_enum)
108

109
110
111
    def test_wrong_type_of_arguments(self):
        try:
            Everything.test_int8()
112
113
        except TypeError:
            (e_type, e) = sys.exc_info()[:2]
114
            self.assertEquals(e.args, ("test_int8() takes exactly 1 argument (0 given)",))
115

116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
    def test_gtypes(self):
        gchararray_gtype = GObject.type_from_name('gchararray')
        gtype = Everything.test_gtype(str)
        self.assertEquals(gchararray_gtype, gtype)
        gtype = Everything.test_gtype('gchararray')
        self.assertEquals(gchararray_gtype, gtype)
        gobject_gtype = GObject.GObject.__gtype__
        gtype = Everything.test_gtype(GObject.GObject)
        self.assertEquals(gobject_gtype, gtype)
        gtype = Everything.test_gtype('GObject')
        self.assertEquals(gobject_gtype, gtype)
        self.assertRaises(TypeError, Everything.test_gtype, 'invalidgtype')

        class NotARegisteredClass(object):
            pass

        self.assertRaises(TypeError, Everything.test_gtype, NotARegisteredClass)

        class ARegisteredClass(GObject.GObject):
            __gtype_name__ = 'EverythingTestsARegisteredClass'

        gtype = Everything.test_gtype('EverythingTestsARegisteredClass')
        self.assertEquals(ARegisteredClass.__gtype__, gtype)
        gtype = Everything.test_gtype(ARegisteredClass)
        self.assertEquals(ARegisteredClass.__gtype__, gtype)
        self.assertRaises(TypeError, Everything.test_gtype, 'ARegisteredClass')
142

143
144
    def test_dir(self):
        attr_list = dir(Everything)
145

146
147
        # test that typelib attributes are listed
        self.assertTrue('TestStructA' in attr_list)
148

149
150
151
152
        # test that class attributes and methods are listed
        self.assertTrue('__class__' in attr_list)
        self.assertTrue('__dir__' in attr_list)
        self.assertTrue('__repr__' in attr_list)
153

154
155
        # test that instance members are listed
        self.assertTrue('_namespace' in attr_list)
156
        self.assertTrue('_version' in attr_list)
157

158
159
        # test that there are no duplicates returned
        self.assertEqual(len(attr_list), len(set(attr_list)))
160

Xavier Claessens's avatar
Xavier Claessens committed
161
    def test_ptrarray(self):
162
163
        # transfer container
        result = Everything.test_garray_container_return()
164
        self.assertEquals(result, ['regress'])
165
166
167
168
        result = None

        # transfer full
        result = Everything.test_garray_full_return()
169
        self.assertEquals(result, ['regress'])
170
        result = None
Xavier Claessens's avatar
Xavier Claessens committed
171

172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
    def test_hash_return(self):
        result = Everything.test_ghash_gvalue_return()
        self.assertEquals(result['integer'], 12)
        self.assertEquals(result['boolean'], True)
        self.assertEquals(result['string'], 'some text')
        strings = result['strings']
        self.assertTrue('first' in strings)
        self.assertTrue('second' in strings)
        self.assertTrue('third' in strings)
        result = None

    @unittest.skip('marshalling of GStrv in GValue not working')
    def test_hash_in_out(self):
        result = Everything.test_ghash_gvalue_return()
        # The following line will cause a failure, because we don't support
        # marshalling GStrv in GValue.
        Everything.test_ghash_gvalue_in(result)
        result = None

191
192
193
194
195
196
197
198
199
200
    def test_struct_gpointer(self):
        l1 = GLib.List()
        self.assertEqual(l1.data, None)
        init_refcount = getrefcount(l1)

        l1.data = 'foo'
        self.assertEqual(l1.data, 'foo')

        l2 = l1
        self.assertEqual(l1.data, l2.data)
201
        self.assertEquals(getrefcount(l1), init_refcount + 1)
202
203
204
205
206
207

        l3 = copy.copy(l1)
        l3.data = 'bar'
        self.assertEqual(l1.data, 'foo')
        self.assertEqual(l2.data, 'foo')
        self.assertEqual(l3.data, 'bar')
208
        self.assertEquals(getrefcount(l1), init_refcount + 1)
209
210
        self.assertEquals(getrefcount(l3), init_refcount)

211

212
213
214
215
216
217
218
class TestNullableArgs(unittest.TestCase):
    def test_in_nullable_hash(self):
        Everything.test_ghash_null_in(None)

    def test_in_nullable_list(self):
        Everything.test_gslist_null_in(None)
        Everything.test_glist_null_in(None)
219
220
        Everything.test_gslist_null_in([])
        Everything.test_glist_null_in([])
221
222

    def test_in_nullable_array(self):
223
        Everything.test_array_int_null_in(None)
224
        Everything.test_array_int_null_in([])
225
226
227
228

    def test_in_nullable_string(self):
        Everything.test_utf8_null_in(None)

229
    def test_in_nullable_object(self):
230
        Everything.func_obj_null_in(None)
231

232
233
234
235
    def test_out_nullable_hash(self):
        self.assertEqual(None, Everything.test_ghash_null_out())

    def test_out_nullable_list(self):
236
237
        self.assertEqual([], Everything.test_gslist_null_out())
        self.assertEqual([], Everything.test_glist_null_out())
238
239

    def test_out_nullable_array(self):
240
        self.assertEqual([], Everything.test_array_int_null_out())
241
242
243
244

    def test_out_nullable_string(self):
        self.assertEqual(None, Everything.test_utf8_null_out())

245
    def test_out_nullable_object(self):
246
        self.assertEqual(None, Everything.TestObj.null_out())
247

248

249
250
class TestCallbacks(unittest.TestCase):
    called = False
251
    main_loop = GObject.MainLoop()
Tomeu Vizoso's avatar
Tomeu Vizoso committed
252

253
    def test_callback(self):
254
        TestCallbacks.called = False
255

256
257
        def callback():
            TestCallbacks.called = True
258

259
260
261
        Everything.test_simple_callback(callback)
        self.assertTrue(TestCallbacks.called)

262
    def test_callback_exception(self):
263
264
265
266
267
268
        """
        This test ensures that we get errors from callbacks correctly
        and in particular that we do not segv when callbacks fail
        """
        def callback():
            x = 1 / 0
269
            self.fail('unexpected surviving zero divsion:' + str(x))
270

271
272
273
274
        # note that we do NOT expect the ZeroDivisionError to be propagated
        # through from the callback, as it crosses the Python<->C boundary
        # twice. (See GNOME #616279)
        Everything.test_simple_callback(callback)
275

276
    def test_double_callback_exception(self):
277
278
279
280
281
282
        """
        This test ensures that we get errors from callbacks correctly
        and in particular that we do not segv when callbacks fail
        """
        def badcallback():
            x = 1 / 0
283
            self.fail('unexpected surviving zero divsion:' + str(x))
284
285
286
287
288
289

        def callback():
            Everything.test_boolean(True)
            Everything.test_boolean(False)
            Everything.test_simple_callback(badcallback())

290
291
292
293
        # note that we do NOT expect the ZeroDivisionError to be propagated
        # through from the callback, as it crosses the Python<->C boundary
        # twice. (See GNOME #616279)
        Everything.test_simple_callback(callback)
294

295
    def test_return_value_callback(self):
296
        TestCallbacks.called = False
297

298
299
300
301
302
303
        def callback():
            TestCallbacks.called = True
            return 44

        self.assertEquals(Everything.test_callback(callback), 44)
        self.assertTrue(TestCallbacks.called)
304

305
    def test_callback_async(self):
306
        TestCallbacks.called = False
307

308
309
310
311
        def callback(foo):
            TestCallbacks.called = True
            return foo

Johan Dahlin's avatar
Johan Dahlin committed
312
313
314
        Everything.test_callback_async(callback, 44)
        i = Everything.test_callback_thaw_async()
        self.assertEquals(44, i)
315
        self.assertTrue(TestCallbacks.called)
316

317
    def test_callback_scope_call(self):
318
        TestCallbacks.called = 0
319

320
321
322
323
324
325
        def callback():
            TestCallbacks.called += 1
            return 0

        Everything.test_multi_callback(callback)
        self.assertEquals(TestCallbacks.called, 2)
326

327
    def test_callback_userdata(self):
328
        TestCallbacks.called = 0
329

330
331
332
333
        def callback(userdata):
            self.assertEquals(userdata, "Test%d" % TestCallbacks.called)
            TestCallbacks.called += 1
            return TestCallbacks.called
334

335
336
        for i in range(100):
            val = Everything.test_callback_user_data(callback, "Test%d" % i)
337
            self.assertEquals(val, i + 1)
338

339
        self.assertEquals(TestCallbacks.called, 100)
Tomeu Vizoso's avatar
Tomeu Vizoso committed
340

341
    def test_callback_userdata_refcount(self):
342
        TestCallbacks.called = False
343

344
345
346
347
348
349
350
351
352
        def callback(userdata):
            TestCallbacks.called = True
            return 1

        ud = "Test User Data"

        start_ref_count = getrefcount(ud)
        for i in range(100):
            Everything.test_callback_destroy_notify(callback, ud)
353

354
355
356
357
358
        Everything.test_callback_thaw_notifications()
        end_ref_count = getrefcount(ud)

        self.assertEquals(start_ref_count, end_ref_count)

359
    def test_async_ready_callback(self):
Tomeu Vizoso's avatar
Tomeu Vizoso committed
360
        TestCallbacks.called = False
361
        TestCallbacks.main_loop = GObject.MainLoop()
Tomeu Vizoso's avatar
Tomeu Vizoso committed
362
363
364
365
366
367
368
369
370
371

        def callback(obj, result, user_data):
            TestCallbacks.main_loop.quit()
            TestCallbacks.called = True

        Everything.test_async_ready_callback(callback)

        TestCallbacks.main_loop.run()

        self.assertTrue(TestCallbacks.called)
Tomeu Vizoso's avatar
Tomeu Vizoso committed
372

373
    def test_callback_destroy_notify(self):
Tomeu Vizoso's avatar
Tomeu Vizoso committed
374
375
376
377
378
379
380
381
        def callback(user_data):
            TestCallbacks.called = True
            return 42

        TestCallbacks.called = False
        self.assertEquals(Everything.test_callback_destroy_notify(callback, 42), 42)
        self.assertTrue(TestCallbacks.called)
        self.assertEquals(Everything.test_callback_thaw_notifications(), 42)
382

383
    def test_callback_in_methods(self):
384
385
386
387
        object_ = Everything.TestObj()

        def callback():
            TestCallbacks.called = True
388
            return 42
389
390
391
392
393
394
395
396
397
398
399

        TestCallbacks.called = False
        object_.instance_method_callback(callback)
        self.assertTrue(TestCallbacks.called)

        TestCallbacks.called = False
        Everything.TestObj.static_method_callback(callback)
        self.assertTrue(TestCallbacks.called)

        def callbackWithUserData(user_data):
            TestCallbacks.called = True
400
            return 42
401
402

        TestCallbacks.called = False
403
        Everything.TestObj.new_callback(callbackWithUserData, None)
404
        self.assertTrue(TestCallbacks.called)
405

406
    def test_callback_none(self):
407
        # make sure this doesn't assert or crash
408
        Everything.test_simple_callback(None)
409

410
    def test_callback_gerror(self):
411
412
413
414
415
416
417
418
419
420
        def callback(error):
            self.assertEqual(error.message, 'regression test error')
            self.assertTrue('g-io' in error.domain)
            self.assertEqual(error.code, Gio.IOErrorEnum.NOT_SUPPORTED)
            TestCallbacks.called = True

        TestCallbacks.called = False
        Everything.test_gerror_callback(callback)
        self.assertTrue(TestCallbacks.called)

421
422
423
424
425
426
427
428
429
    def test_callback_null_gerror(self):
        def callback(error):
            self.assertEqual(error, None)
            TestCallbacks.called = True

        TestCallbacks.called = False
        Everything.test_null_gerror_callback(callback)
        self.assertTrue(TestCallbacks.called)

430
    def test_callback_owned_gerror(self):
431
432
433
434
435
436
437
438
439
440
        def callback(error):
            self.assertEqual(error.message, 'regression test owned error')
            self.assertTrue('g-io' in error.domain)
            self.assertEqual(error.code, Gio.IOErrorEnum.PERMISSION_DENIED)
            TestCallbacks.called = True

        TestCallbacks.called = False
        Everything.test_owned_gerror_callback(callback)
        self.assertTrue(TestCallbacks.called)

441
    def test_callback_hashtable(self):
442
443
444
445
446
        def callback(data):
            self.assertEqual(data, mydict)
            mydict['new'] = 42
            TestCallbacks.called = True

447
        mydict = {'foo': 1, 'bar': 2}
448
449
450
        TestCallbacks.called = False
        Everything.test_hash_table_callback(mydict, callback)
        self.assertTrue(TestCallbacks.called)
451
452
        self.assertEqual(mydict, {'foo': 1, 'bar': 2, 'new': 42})

453

Martin Pitt's avatar
Martin Pitt committed
454
455
456
457
class TestClosures(unittest.TestCase):
    def test_int_arg(self):
        def callback(num):
            self.called = True
458
            return num + 1
Martin Pitt's avatar
Martin Pitt committed
459
460
461
462
463
464
465

        self.called = False
        result = Everything.test_closure_one_arg(callback, 42)
        self.assertTrue(self.called)
        self.assertEqual(result, 43)

    # https://bugzilla.gnome.org/show_bug.cgi?id=656554
466

Martin Pitt's avatar
Martin Pitt committed
467
468
469
470
471
472
473
474
475
476
477
478
    @unittest.expectedFailure
    def test_variant(self):
        def callback(variant):
            self.assertEqual(variant.get_type_string(), 'i')
            self.called = True
            return GLib.Variant('i', variant.get_int32() + 1)

        self.called = False
        result = Everything.test_closure_variant(callback, GLib.Variant('i', 42))
        self.assertTrue(self.called)
        self.assertEqual(result.get_type_string(), 'i')
        self.assertEqual(result.get_int32(), 43)
479

480

481
482
class TestProperties(unittest.TestCase):

483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
    def test_basic(self):
        object_ = Everything.TestObj()

        self.assertEquals(object_.props.int, 0)
        object_.props.int = 42
        self.assertTrue(isinstance(object_.props.int, int))
        self.assertEquals(object_.props.int, 42)

        self.assertEquals(object_.props.float, 0.0)
        object_.props.float = 42.42
        self.assertTrue(isinstance(object_.props.float, float))
        self.assertAlmostEquals(object_.props.float, 42.42, places=5)

        self.assertEquals(object_.props.double, 0.0)
        object_.props.double = 42.42
        self.assertTrue(isinstance(object_.props.double, float))
        self.assertAlmostEquals(object_.props.double, 42.42, places=5)

        self.assertEquals(object_.props.string, None)
        object_.props.string = 'mec'
        self.assertTrue(isinstance(object_.props.string, str))
        self.assertEquals(object_.props.string, 'mec')

506
507
508
509
510
511
    def test_hash_table(self):
        object_ = Everything.TestObj()
        self.assertEquals(object_.props.hash_table, None)

        object_.props.hash_table = {'mec': 56}
        self.assertTrue(isinstance(object_.props.hash_table, dict))
512
        self.assertEquals(list(object_.props.hash_table.items())[0], ('mec', 56))
513
514
515
516
517
518
519
520

    def test_list(self):
        object_ = Everything.TestObj()
        self.assertEquals(object_.props.list, [])

        object_.props.list = ['1', '2', '3']
        self.assertTrue(isinstance(object_.props.list, list))
        self.assertEquals(object_.props.list, ['1', '2', '3'])
521
522
523
524
525
526
527
528
529
530
531

    def test_boxed(self):
        object_ = Everything.TestObj()
        self.assertEquals(object_.props.boxed, None)

        boxed = Everything.TestBoxed()
        boxed.some_int8 = 42
        object_.props.boxed = boxed

        self.assertTrue(isinstance(object_.props.boxed, Everything.TestBoxed))
        self.assertEquals(object_.props.boxed.some_int8, 42)
532

533

534
535
536
537
538
539
540
541
542
543
class TestTortureProfile(unittest.TestCase):
    def test_torture_profile(self):
        import time
        total_time = 0
        print("")
        object_ = Everything.TestObj()
        sys.stdout.write("\ttorture test 1 (10000 iterations): ")

        start_time = time.clock()
        for i in range(10000):
544
545
546
            (y, z, q) = object_.torture_signature_0(5000,
                                                    "Torture Test 1",
                                                    12345)
547
548
549
550
551
552
553
554
555
556

        end_time = time.clock()
        delta_time = end_time - start_time
        total_time += delta_time
        print("%f secs" % delta_time)

        sys.stdout.write("\ttorture test 2 (10000 iterations): ")

        start_time = time.clock()
        for i in range(10000):
557
558
            (y, z, q) = Everything.TestObj().torture_signature_0(
                5000, "Torture Test 2", 12345)
559
560
561
562
563
564
565
566
567
568

        end_time = time.clock()
        delta_time = end_time - start_time
        total_time += delta_time
        print("%f secs" % delta_time)

        sys.stdout.write("\ttorture test 3 (10000 iterations): ")
        start_time = time.clock()
        for i in range(10000):
            try:
569
570
                (y, z, q) = object_.torture_signature_1(
                    5000, "Torture Test 3", 12345)
571
572
573
574
575
576
577
578
            except:
                pass
        end_time = time.clock()
        delta_time = end_time - start_time
        total_time += delta_time
        print("%f secs" % delta_time)

        sys.stdout.write("\ttorture test 4 (10000 iterations): ")
579

580
581
582
        def callback(userdata):
            pass

583
        userdata = [1, 2, 3, 4]
584
585
        start_time = time.clock()
        for i in range(10000):
586
587
            (y, z, q) = Everything.test_torture_signature_2(
                5000, callback, userdata, "Torture Test 4", 12345)
588
589
590
591
592
593
594
        end_time = time.clock()
        delta_time = end_time - start_time
        total_time += delta_time
        print("%f secs" % delta_time)
        print("\t====")
        print("\tTotal: %f sec" % total_time)

595

596
597
598
599
600
601
class TestAdvancedInterfaces(unittest.TestCase):
    def test_array_objs(self):
        obj1, obj2 = Everything.test_array_fixed_out_objects()
        self.assertTrue(isinstance(obj1, Everything.TestObj))
        self.assertTrue(isinstance(obj2, Everything.TestObj))
        self.assertNotEqual(obj1, obj2)
602
603

    def test_obj_skip_return_val(self):
Johan Dahlin's avatar
Johan Dahlin committed
604
605
606
607
608
609
        obj = Everything.TestObj()
        ret = obj.skip_return_val(50, 42.0, 60, 2, 3)
        self.assertEquals(len(ret), 3)
        self.assertEquals(ret[0], 51)
        self.assertEquals(ret[1], 61)
        self.assertEquals(ret[2], 32)
610

611
    def test_obj_skip_return_val_no_out(self):
Johan Dahlin's avatar
Johan Dahlin committed
612
        obj = Everything.TestObj()
613
614
615
616
617
618
        # raises an error for 0, succeeds for any other value
        self.assertRaises(GLib.GError, obj.skip_return_val_no_out, 0)

        ret = obj.skip_return_val_no_out(1)
        self.assertEquals(ret, None)

619

620
621
class TestSignals(unittest.TestCase):
    def test_object_param_signal(self):
Johan Dahlin's avatar
Johan Dahlin committed
622
        obj = Everything.TestObj()
623

624
        def callback(obj, obj_param):
625
            self.assertEquals(obj_param.props.int, 3)
626
            self.assertGreater(obj_param.__grefcount__, 1)
627
628
629

        obj.connect('sig-with-obj', callback)
        obj.emit_sig_with_obj()