test_everything.py 22.2 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
        self.assertEqual(result['strings'], ['first', 'second', 'third'])
178
179
        result = None

180
181
182
183
184
185
186
187
188
189
190
191
    def test_hash_in(self):
        #data = {'integer': 12, 'boolean': True, 'string': 'some text',
        #        'strings': ['first', 'second', 'third']}
        # above does not work due to https://bugzilla.gnome.org/show_bug.cgi?id=666636
        # so use workaround to explicitly build a GStrV object
        class GStrv(list):
            __gtype__ = GObject.type_from_name('GStrv')

        data = {'integer': 12, 'boolean': True, 'string': 'some text',
                'strings': GStrv(['first', 'second', 'third'])}
        Everything.test_ghash_gvalue_in(data)
        data = None
192

193
194
195
196
197
198
199
200
201
202
    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)
203
        self.assertEqual(getrefcount(l1), init_refcount + 1)
204
205
206
207
208
209

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

213

214
215
216
217
218
219
220
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)
221
222
        Everything.test_gslist_null_in([])
        Everything.test_glist_null_in([])
223
224

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

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

231
    def test_in_nullable_object(self):
232
        Everything.func_obj_null_in(None)
233

234
235
236
237
    def test_out_nullable_hash(self):
        self.assertEqual(None, Everything.test_ghash_null_out())

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

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

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

247
    def test_out_nullable_object(self):
248
        self.assertEqual(None, Everything.TestObj.null_out())
249

250

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

255
    def test_callback(self):
256
        TestCallbacks.called = False
257

258
259
        def callback():
            TestCallbacks.called = True
260

261
262
263
        Everything.test_simple_callback(callback)
        self.assertTrue(TestCallbacks.called)

264
    def test_callback_exception(self):
265
266
267
268
269
270
        """
        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
271
            self.fail('unexpected surviving zero divsion:' + str(x))
272

273
274
275
276
        # 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)
277

278
    def test_double_callback_exception(self):
279
280
281
282
283
284
        """
        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
285
            self.fail('unexpected surviving zero divsion:' + str(x))
286
287
288
289
290
291

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

292
293
294
295
        # 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)
296

297
    def test_return_value_callback(self):
298
        TestCallbacks.called = False
299

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

304
        self.assertEqual(Everything.test_callback(callback), 44)
305
        self.assertTrue(TestCallbacks.called)
306

307
    def test_callback_async(self):
308
        TestCallbacks.called = False
309

310
311
312
313
        def callback(foo):
            TestCallbacks.called = True
            return foo

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

319
    def test_callback_scope_call(self):
320
        TestCallbacks.called = 0
321

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

        Everything.test_multi_callback(callback)
327
        self.assertEqual(TestCallbacks.called, 2)
328

329
    def test_callback_userdata(self):
330
        TestCallbacks.called = 0
331

332
        def callback(userdata):
333
            self.assertEqual(userdata, "Test%d" % TestCallbacks.called)
334
335
            TestCallbacks.called += 1
            return TestCallbacks.called
336

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

341
        self.assertEqual(TestCallbacks.called, 100)
Tomeu Vizoso's avatar
Tomeu Vizoso committed
342

343
    def test_callback_userdata_refcount(self):
344
        TestCallbacks.called = False
345

346
347
348
349
350
351
352
353
354
        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)
355

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

359
        self.assertEqual(start_ref_count, end_ref_count)
360

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

        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
374

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

        TestCallbacks.called = False
381
        self.assertEqual(Everything.test_callback_destroy_notify(callback, 42), 42)
Tomeu Vizoso's avatar
Tomeu Vizoso committed
382
        self.assertTrue(TestCallbacks.called)
383
        self.assertEqual(Everything.test_callback_thaw_notifications(), 42)
384

385
    def test_callback_in_methods(self):
386
387
388
389
        object_ = Everything.TestObj()

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

        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
402
            return 42
403
404

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

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

412
    def test_callback_gerror(self):
413
414
415
416
417
418
419
420
421
422
        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)

423
424
425
426
427
428
429
430
431
    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)

432
    def test_callback_owned_gerror(self):
433
434
435
436
437
438
439
440
441
442
        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)

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

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

455

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

        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
468

Martin Pitt's avatar
Martin Pitt committed
469
470
471
472
473
474
475
476
477
478
479
480
    @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)
481

482

483
484
class TestProperties(unittest.TestCase):

485
486
487
    def test_basic(self):
        object_ = Everything.TestObj()

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

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

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

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

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

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

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

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

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

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

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

        self.assertTrue(isinstance(object_.props.boxed, Everything.TestBoxed))
537
        self.assertEqual(object_.props.boxed.some_int8, 42)
538

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

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

550

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

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

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

597
598
599
        def callback(userdata):
            pass

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

612

613
614
615
616
617
618
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)
619
620

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

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

636

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

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

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