test_everything.py 22.1 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
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))
40
41
42
        self.assertEqual(surface.get_format(), cairo.FORMAT_ARGB32)
        self.assertEqual(surface.get_width(), 10)
        self.assertEqual(surface.get_height(), 10)
Tomeu Vizoso's avatar
Tomeu Vizoso committed
43
44
45
46

        surface = Everything.test_cairo_surface_full_return()
        self.assertTrue(isinstance(surface, cairo.ImageSurface))
        self.assertTrue(isinstance(surface, cairo.Surface))
47
48
49
        self.assertEqual(surface.get_format(), cairo.FORMAT_ARGB32)
        self.assertEqual(surface.get_width(), 10)
        self.assertEqual(surface.get_height(), 10)
Tomeu Vizoso's avatar
Tomeu Vizoso committed
50
51
52
53
54
55
56

        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))
57
58
59
        self.assertEqual(surface.get_format(), cairo.FORMAT_ARGB32)
        self.assertEqual(surface.get_width(), 10)
        self.assertEqual(surface.get_height(), 10)
Tomeu Vizoso's avatar
Tomeu Vizoso committed
60

Paolo Borelli's avatar
Paolo Borelli committed
61
    def test_unichar(self):
62
        self.assertEqual("c", Everything.test_unichar("c"))
63
64

        if sys.version_info < (3, 0):
65
66
            self.assertEqual(UNICHAR, Everything.test_unichar(PY2_UNICODE_UNICHAR))
        self.assertEqual(UNICHAR, Everything.test_unichar(UNICHAR))
67
68
        self.assertRaises(TypeError, Everything.test_unichar, "")
        self.assertRaises(TypeError, Everything.test_unichar, "morethanonechar")
69

70
    def test_floating(self):
71
        e = Everything.TestFloating()
72
        self.assertEqual(e.__grefcount__, 1)
73
74

        e = GObject.new(Everything.TestFloating)
75
        self.assertEqual(e.__grefcount__, 1)
76
77

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

80
81
82
83
84
85
86
87
88
    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)
89
90
91
92
        self.assertEqual(struct_a.some_int, struct_a_clone.some_int)
        self.assertEqual(struct_a.some_int8, struct_a_clone.some_int8)
        self.assertEqual(struct_a.some_double, struct_a_clone.some_double)
        self.assertEqual(struct_a.some_enum, struct_a_clone.some_enum)
93
94
95
96
97
98
99
100
101
102

        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)
103
104
105
106
107
        self.assertEqual(struct_b.some_int8, struct_b_clone.some_int8)
        self.assertEqual(struct_b.nested_a.some_int, struct_b_clone.nested_a.some_int)
        self.assertEqual(struct_b.nested_a.some_int8, struct_b_clone.nested_a.some_int8)
        self.assertEqual(struct_b.nested_a.some_double, struct_b_clone.nested_a.some_double)
        self.assertEqual(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.assertEqual(e.args, ("test_int8() takes exactly 1 argument (0 given)",))
115

116
117
118
    def test_gtypes(self):
        gchararray_gtype = GObject.type_from_name('gchararray')
        gtype = Everything.test_gtype(str)
119
        self.assertEqual(gchararray_gtype, gtype)
120
        gtype = Everything.test_gtype('gchararray')
121
        self.assertEqual(gchararray_gtype, gtype)
122
123
        gobject_gtype = GObject.GObject.__gtype__
        gtype = Everything.test_gtype(GObject.GObject)
124
        self.assertEqual(gobject_gtype, gtype)
125
        gtype = Everything.test_gtype('GObject')
126
        self.assertEqual(gobject_gtype, gtype)
127
128
129
130
131
132
133
134
135
136
137
        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')
138
        self.assertEqual(ARegisteredClass.__gtype__, gtype)
139
        gtype = Everything.test_gtype(ARegisteredClass)
140
        self.assertEqual(ARegisteredClass.__gtype__, gtype)
141
        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.assertEqual(result, ['regress'])
165
166
167
168
        result = None

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

172
173
    def test_hash_return(self):
        result = Everything.test_ghash_gvalue_return()
174
175
176
        self.assertEqual(result['integer'], 12)
        self.assertEqual(result['boolean'], True)
        self.assertEqual(result['string'], 'some text')
177
178
179
180
181
182
183
184
185
186
187
188
189
190
        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.assertEqual(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
209
        self.assertEqual(getrefcount(l1), init_refcount + 1)
        self.assertEqual(getrefcount(l3), init_refcount)
210

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
        def callback():
            TestCallbacks.called = True
            return 44

302
        self.assertEqual(Everything.test_callback(callback), 44)
303
        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
        Everything.test_callback_async(callback, 44)
        i = Everything.test_callback_thaw_async()
314
        self.assertEqual(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
        def callback():
            TestCallbacks.called += 1
            return 0

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

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

330
        def callback(userdata):
331
            self.assertEqual(userdata, "Test%d" % TestCallbacks.called)
332
333
            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.assertEqual(val, i + 1)
338

339
        self.assertEqual(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
        Everything.test_callback_thaw_notifications()
        end_ref_count = getrefcount(ud)

357
        self.assertEqual(start_ref_count, end_ref_count)
358

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
        def callback(user_data):
            TestCallbacks.called = True
            return 42

        TestCallbacks.called = False
379
        self.assertEqual(Everything.test_callback_destroy_notify(callback, 42), 42)
Tomeu Vizoso's avatar
Tomeu Vizoso committed
380
        self.assertTrue(TestCallbacks.called)
381
        self.assertEqual(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
    def test_basic(self):
        object_ = Everything.TestObj()

486
        self.assertEqual(object_.props.int, 0)
487
488
        object_.props.int = 42
        self.assertTrue(isinstance(object_.props.int, int))
489
        self.assertEqual(object_.props.int, 42)
490

491
        self.assertEqual(object_.props.float, 0.0)
492
493
494
495
        object_.props.float = 42.42
        self.assertTrue(isinstance(object_.props.float, float))
        self.assertAlmostEquals(object_.props.float, 42.42, places=5)

496
        self.assertEqual(object_.props.double, 0.0)
497
498
499
500
        object_.props.double = 42.42
        self.assertTrue(isinstance(object_.props.double, float))
        self.assertAlmostEquals(object_.props.double, 42.42, places=5)

501
        self.assertEqual(object_.props.string, None)
502
503
        object_.props.string = 'mec'
        self.assertTrue(isinstance(object_.props.string, str))
504
        self.assertEqual(object_.props.string, 'mec')
505

506
        self.assertEqual(object_.props.gtype, GObject.TYPE_INVALID)
507
        object_.props.gtype = int
508
        self.assertEqual(object_.props.gtype, GObject.TYPE_INT)
509

510
511
    def test_hash_table(self):
        object_ = Everything.TestObj()
512
        self.assertEqual(object_.props.hash_table, None)
513
514
515

        object_.props.hash_table = {'mec': 56}
        self.assertTrue(isinstance(object_.props.hash_table, dict))
516
        self.assertEqual(list(object_.props.hash_table.items())[0], ('mec', 56))
517
518
519

    def test_list(self):
        object_ = Everything.TestObj()
520
        self.assertEqual(object_.props.list, [])
521
522
523

        object_.props.list = ['1', '2', '3']
        self.assertTrue(isinstance(object_.props.list, list))
524
        self.assertEqual(object_.props.list, ['1', '2', '3'])
525
526
527

    def test_boxed(self):
        object_ = Everything.TestObj()
528
        self.assertEqual(object_.props.boxed, None)
529
530
531
532
533
534

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

        self.assertTrue(isinstance(object_.props.boxed, Everything.TestBoxed))
535
        self.assertEqual(object_.props.boxed.some_int8, 42)
536

537
538
    def test_gtype(self):
        object_ = Everything.TestObj()
539
        self.assertEqual(object_.props.gtype, GObject.TYPE_INVALID)
540
        object_.props.gtype = int
541
        self.assertEqual(object_.props.gtype, GObject.TYPE_INT)
542

Martin Pitt's avatar
Martin Pitt committed
543
        object_ = Everything.TestObj(gtype=int)
544
        self.assertEqual(object_.props.gtype, GObject.TYPE_INT)
545
        object_.props.gtype = str
546
        self.assertEqual(object_.props.gtype, GObject.TYPE_STRING)
547

548

549
550
551
552
553
554
555
556
557
558
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):
559
560
561
            (y, z, q) = object_.torture_signature_0(5000,
                                                    "Torture Test 1",
                                                    12345)
562
563
564
565
566
567
568
569
570
571

        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):
572
573
            (y, z, q) = Everything.TestObj().torture_signature_0(
                5000, "Torture Test 2", 12345)
574
575
576
577
578
579
580
581
582
583

        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:
584
585
                (y, z, q) = object_.torture_signature_1(
                    5000, "Torture Test 3", 12345)
586
587
588
589
590
591
592
593
            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): ")
594

595
596
597
        def callback(userdata):
            pass

598
        userdata = [1, 2, 3, 4]
599
600
        start_time = time.clock()
        for i in range(10000):
601
602
            (y, z, q) = Everything.test_torture_signature_2(
                5000, callback, userdata, "Torture Test 4", 12345)
603
604
605
606
607
608
609
        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)

610

611
612
613
614
615
616
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)
617
618

    def test_obj_skip_return_val(self):
Johan Dahlin's avatar
Johan Dahlin committed
619
620
        obj = Everything.TestObj()
        ret = obj.skip_return_val(50, 42.0, 60, 2, 3)
621
622
623
624
        self.assertEqual(len(ret), 3)
        self.assertEqual(ret[0], 51)
        self.assertEqual(ret[1], 61)
        self.assertEqual(ret[2], 32)
625

626
    def test_obj_skip_return_val_no_out(self):
Johan Dahlin's avatar
Johan Dahlin committed
627
        obj = Everything.TestObj()
628
629
630
631
        # 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)
632
        self.assertEqual(ret, None)
633

634

635
636
class TestSignals(unittest.TestCase):
    def test_object_param_signal(self):
Johan Dahlin's avatar
Johan Dahlin committed
637
        obj = Everything.TestObj()
638

639
        def callback(obj, obj_param):
640
            self.assertEqual(obj_param.props.int, 3)
641
            self.assertGreater(obj_param.__grefcount__, 1)
642
643
644

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