test_everything.py 23.5 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
12
13
14
15
16
try:
    import cairo
    has_cairo = True
except ImportError:
    has_cairo = False
Tomeu Vizoso's avatar
Tomeu Vizoso committed
17

18
from gi.repository import GObject
19
from gi.repository import GLib
20
from gi.repository import Gio
21
from gi.repository import Gtk
22
from gi.repository import Regress as Everything
Tomeu Vizoso's avatar
Tomeu Vizoso committed
23

24
25
26
27
28
29
30
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
31
32
class TestEverything(unittest.TestCase):

33
    @unittest.skipUnless(has_cairo, 'built without cairo support')
Tomeu Vizoso's avatar
Tomeu Vizoso committed
34
35
36
37
38
39
40
41
    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)

42
    @unittest.skipUnless(has_cairo, 'built without cairo support')
Tomeu Vizoso's avatar
Tomeu Vizoso committed
43
44
45
46
    def test_cairo_surface(self):
        surface = Everything.test_cairo_surface_none_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

        surface = Everything.test_cairo_surface_full_return()
        self.assertTrue(isinstance(surface, cairo.ImageSurface))
        self.assertTrue(isinstance(surface, cairo.Surface))
54
55
56
        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
57
58
59
60
61
62
63

        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))
64
65
66
        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
67

Paolo Borelli's avatar
Paolo Borelli committed
68
    def test_unichar(self):
69
        self.assertEqual("c", Everything.test_unichar("c"))
70
71

        if sys.version_info < (3, 0):
72
73
            self.assertEqual(UNICHAR, Everything.test_unichar(PY2_UNICODE_UNICHAR))
        self.assertEqual(UNICHAR, Everything.test_unichar(UNICHAR))
74
75
        self.assertRaises(TypeError, Everything.test_unichar, "")
        self.assertRaises(TypeError, Everything.test_unichar, "morethanonechar")
76

77
    def test_floating(self):
78
        e = Everything.TestFloating()
79
        self.assertEqual(e.__grefcount__, 1)
80
81

        e = GObject.new(Everything.TestFloating)
82
        self.assertEqual(e.__grefcount__, 1)
83
84

        e = Everything.TestFloating.new()
85
        self.assertEqual(e.__grefcount__, 1)
86

87
88
89
90
91
92
93
94
95
    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)
96
97
98
99
        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)
100
101
102
103
104
105
106
107
108
109

        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)
110
111
112
113
114
        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)
115

116
117
118
    def test_wrong_type_of_arguments(self):
        try:
            Everything.test_int8()
119
120
        except TypeError:
            (e_type, e) = sys.exc_info()[:2]
121
            self.assertEqual(e.args, ("test_int8() takes exactly 1 argument (0 given)",))
122

123
124
125
    def test_gtypes(self):
        gchararray_gtype = GObject.type_from_name('gchararray')
        gtype = Everything.test_gtype(str)
126
        self.assertEqual(gchararray_gtype, gtype)
127
        gtype = Everything.test_gtype('gchararray')
128
        self.assertEqual(gchararray_gtype, gtype)
129
130
        gobject_gtype = GObject.GObject.__gtype__
        gtype = Everything.test_gtype(GObject.GObject)
131
        self.assertEqual(gobject_gtype, gtype)
132
        gtype = Everything.test_gtype('GObject')
133
        self.assertEqual(gobject_gtype, gtype)
134
135
136
137
138
139
140
141
142
143
144
        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')
145
        self.assertEqual(ARegisteredClass.__gtype__, gtype)
146
        gtype = Everything.test_gtype(ARegisteredClass)
147
        self.assertEqual(ARegisteredClass.__gtype__, gtype)
148
        self.assertRaises(TypeError, Everything.test_gtype, 'ARegisteredClass')
149

150
151
    def test_dir(self):
        attr_list = dir(Everything)
152

153
154
        # test that typelib attributes are listed
        self.assertTrue('TestStructA' in attr_list)
155

156
157
158
159
        # 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)
160

161
162
        # test that instance members are listed
        self.assertTrue('_namespace' in attr_list)
163
        self.assertTrue('_version' in attr_list)
164

165
166
        # test that there are no duplicates returned
        self.assertEqual(len(attr_list), len(set(attr_list)))
167

Xavier Claessens's avatar
Xavier Claessens committed
168
    def test_ptrarray(self):
169
170
        # transfer container
        result = Everything.test_garray_container_return()
171
        self.assertEqual(result, ['regress'])
172
173
174
175
        result = None

        # transfer full
        result = Everything.test_garray_full_return()
176
        self.assertEqual(result, ['regress'])
177
        result = None
Xavier Claessens's avatar
Xavier Claessens committed
178

179
180
    def test_hash_return(self):
        result = Everything.test_ghash_gvalue_return()
181
182
183
        self.assertEqual(result['integer'], 12)
        self.assertEqual(result['boolean'], True)
        self.assertEqual(result['string'], 'some text')
184
        self.assertEqual(result['strings'], ['first', 'second', 'third'])
185
186
        self.assertEqual(result['flags'], Everything.TestFlags.FLAG1 | Everything.TestFlags.FLAG3)
        self.assertEqual(result['enum'], Everything.TestEnum.VALUE2)
187
188
        result = None

189
    def test_hash_in(self):
190
191
192
        # specifying a simple string array for "strings" does not work due to
        # https://bugzilla.gnome.org/show_bug.cgi?id=666636
        # workaround by explicitly building a GStrv object
193
        class GStrv(list):
Martin Pitt's avatar
Martin Pitt committed
194
            __gtype__ = GObject.TYPE_STRV
195

196
197
198
199
200
201
202
        data = {'integer': 12,
                'boolean': True,
                'string': 'some text',
                'strings': GStrv(['first', 'second', 'third']),
                'flags': Everything.TestFlags.FLAG1 | Everything.TestFlags.FLAG3,
                'enum': Everything.TestEnum.VALUE2,
               }
203
204
        Everything.test_ghash_gvalue_in(data)
        data = None
205

206
207
208
209
210
211
212
213
214
215
    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)
216
        self.assertEqual(getrefcount(l1), init_refcount + 1)
217
218
219
220
221
222

        l3 = copy.copy(l1)
        l3.data = 'bar'
        self.assertEqual(l1.data, 'foo')
        self.assertEqual(l2.data, 'foo')
        self.assertEqual(l3.data, 'bar')
223
224
        self.assertEqual(getrefcount(l1), init_refcount + 1)
        self.assertEqual(getrefcount(l3), init_refcount)
225

226

227
228
229
230
231
232
233
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)
234
235
        Everything.test_gslist_null_in([])
        Everything.test_glist_null_in([])
236
237

    def test_in_nullable_array(self):
238
        Everything.test_array_int_null_in(None)
239
        Everything.test_array_int_null_in([])
240
241
242
243

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

244
    def test_in_nullable_object(self):
245
        Everything.func_obj_null_in(None)
246

247
248
249
250
    def test_out_nullable_hash(self):
        self.assertEqual(None, Everything.test_ghash_null_out())

    def test_out_nullable_list(self):
251
252
        self.assertEqual([], Everything.test_gslist_null_out())
        self.assertEqual([], Everything.test_glist_null_out())
253
254

    def test_out_nullable_array(self):
255
        self.assertEqual([], Everything.test_array_int_null_out())
256
257
258
259

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

260
    def test_out_nullable_object(self):
261
        self.assertEqual(None, Everything.TestObj.null_out())
262

263

264
265
class TestCallbacks(unittest.TestCase):
    called = False
266
    main_loop = GObject.MainLoop()
Tomeu Vizoso's avatar
Tomeu Vizoso committed
267

268
    def test_callback(self):
269
        TestCallbacks.called = False
270

271
272
        def callback():
            TestCallbacks.called = True
273

274
275
276
        Everything.test_simple_callback(callback)
        self.assertTrue(TestCallbacks.called)

277
    def test_callback_exception(self):
278
279
280
281
282
283
        """
        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
284
            self.fail('unexpected surviving zero divsion:' + str(x))
285

286
287
288
289
        # 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)
290

291
    def test_double_callback_exception(self):
292
293
294
295
296
297
        """
        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
298
            self.fail('unexpected surviving zero divsion:' + str(x))
299
300
301
302
303
304

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

305
306
307
308
        # 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)
309

310
    def test_return_value_callback(self):
311
        TestCallbacks.called = False
312

313
314
315
316
        def callback():
            TestCallbacks.called = True
            return 44

317
        self.assertEqual(Everything.test_callback(callback), 44)
318
        self.assertTrue(TestCallbacks.called)
319

320
    def test_callback_async(self):
321
        TestCallbacks.called = False
322

323
324
325
326
        def callback(foo):
            TestCallbacks.called = True
            return foo

Johan Dahlin's avatar
Johan Dahlin committed
327
328
        Everything.test_callback_async(callback, 44)
        i = Everything.test_callback_thaw_async()
329
        self.assertEqual(44, i)
330
        self.assertTrue(TestCallbacks.called)
331

332
    def test_callback_scope_call(self):
333
        TestCallbacks.called = 0
334

335
336
337
338
339
        def callback():
            TestCallbacks.called += 1
            return 0

        Everything.test_multi_callback(callback)
340
        self.assertEqual(TestCallbacks.called, 2)
341

342
    def test_callback_userdata(self):
343
        TestCallbacks.called = 0
344

345
        def callback(userdata):
346
            self.assertEqual(userdata, "Test%d" % TestCallbacks.called)
347
348
            TestCallbacks.called += 1
            return TestCallbacks.called
349

350
351
        for i in range(100):
            val = Everything.test_callback_user_data(callback, "Test%d" % i)
352
            self.assertEqual(val, i + 1)
353

354
        self.assertEqual(TestCallbacks.called, 100)
Tomeu Vizoso's avatar
Tomeu Vizoso committed
355

356
    def test_callback_userdata_refcount(self):
357
        TestCallbacks.called = False
358

359
360
361
362
363
364
365
366
367
        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)
368

369
370
371
        Everything.test_callback_thaw_notifications()
        end_ref_count = getrefcount(ud)

372
        self.assertEqual(start_ref_count, end_ref_count)
373

374
    def test_async_ready_callback(self):
Tomeu Vizoso's avatar
Tomeu Vizoso committed
375
        TestCallbacks.called = False
376
        TestCallbacks.main_loop = GObject.MainLoop()
Tomeu Vizoso's avatar
Tomeu Vizoso committed
377
378
379
380
381
382
383
384
385
386

        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
387

388
    def test_callback_destroy_notify(self):
Tomeu Vizoso's avatar
Tomeu Vizoso committed
389
390
391
392
393
        def callback(user_data):
            TestCallbacks.called = True
            return 42

        TestCallbacks.called = False
394
        self.assertEqual(Everything.test_callback_destroy_notify(callback, 42), 42)
Tomeu Vizoso's avatar
Tomeu Vizoso committed
395
        self.assertTrue(TestCallbacks.called)
396
        self.assertEqual(Everything.test_callback_thaw_notifications(), 42)
397

398
    def test_callback_in_methods(self):
399
400
401
402
        object_ = Everything.TestObj()

        def callback():
            TestCallbacks.called = True
403
            return 42
404
405
406
407
408
409
410
411
412
413
414

        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
415
            return 42
416
417

        TestCallbacks.called = False
418
        Everything.TestObj.new_callback(callbackWithUserData, None)
419
        self.assertTrue(TestCallbacks.called)
420

421
    def test_callback_none(self):
422
        # make sure this doesn't assert or crash
423
        Everything.test_simple_callback(None)
424

425
    def test_callback_gerror(self):
426
427
428
429
430
431
432
433
434
435
        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)

436
437
438
439
440
441
442
443
444
    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)

445
    def test_callback_owned_gerror(self):
446
447
448
449
450
451
452
453
454
455
        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)

456
    def test_callback_hashtable(self):
457
458
459
460
461
        def callback(data):
            self.assertEqual(data, mydict)
            mydict['new'] = 42
            TestCallbacks.called = True

462
        mydict = {'foo': 1, 'bar': 2}
463
464
465
        TestCallbacks.called = False
        Everything.test_hash_table_callback(mydict, callback)
        self.assertTrue(TestCallbacks.called)
466
467
        self.assertEqual(mydict, {'foo': 1, 'bar': 2, 'new': 42})

468

Martin Pitt's avatar
Martin Pitt committed
469
470
471
472
class TestClosures(unittest.TestCase):
    def test_int_arg(self):
        def callback(num):
            self.called = True
473
            return num + 1
Martin Pitt's avatar
Martin Pitt committed
474
475
476
477
478
479
480
481
482

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

    def test_variant(self):
        def callback(variant):
            self.called = True
483
484
485
            if variant is None:
                return None
            self.assertEqual(variant.get_type_string(), 'i')
Martin Pitt's avatar
Martin Pitt committed
486
487
488
489
490
491
492
            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)
493

494
495
496
497
498
499
500
501
502
        self.called = False
        result = Everything.test_closure_variant(callback, None)
        self.assertTrue(self.called)
        self.assertEqual(result, None)

        self.called = False
        self.assertRaises(TypeError, Everything.test_closure_variant, callback, 'foo')
        self.assertFalse(self.called)

503

504
505
class TestProperties(unittest.TestCase):

506
507
508
    def test_basic(self):
        object_ = Everything.TestObj()

509
        self.assertEqual(object_.props.int, 0)
510
511
        object_.props.int = 42
        self.assertTrue(isinstance(object_.props.int, int))
512
        self.assertEqual(object_.props.int, 42)
513

514
        self.assertEqual(object_.props.float, 0.0)
515
516
        object_.props.float = 42.42
        self.assertTrue(isinstance(object_.props.float, float))
Martin Pitt's avatar
Martin Pitt committed
517
        self.assertAlmostEqual(object_.props.float, 42.42, places=5)
518

519
        self.assertEqual(object_.props.double, 0.0)
520
521
        object_.props.double = 42.42
        self.assertTrue(isinstance(object_.props.double, float))
Martin Pitt's avatar
Martin Pitt committed
522
        self.assertAlmostEqual(object_.props.double, 42.42, places=5)
523

524
        self.assertEqual(object_.props.string, None)
525
526
        object_.props.string = 'mec'
        self.assertTrue(isinstance(object_.props.string, str))
527
        self.assertEqual(object_.props.string, 'mec')
528

529
        self.assertEqual(object_.props.gtype, GObject.TYPE_INVALID)
530
        object_.props.gtype = int
531
        self.assertEqual(object_.props.gtype, GObject.TYPE_INT)
532

533
534
    def test_hash_table(self):
        object_ = Everything.TestObj()
535
        self.assertEqual(object_.props.hash_table, None)
536
537
538

        object_.props.hash_table = {'mec': 56}
        self.assertTrue(isinstance(object_.props.hash_table, dict))
539
        self.assertEqual(list(object_.props.hash_table.items())[0], ('mec', 56))
540
541
542

    def test_list(self):
        object_ = Everything.TestObj()
543
        self.assertEqual(object_.props.list, [])
544
545
546

        object_.props.list = ['1', '2', '3']
        self.assertTrue(isinstance(object_.props.list, list))
547
        self.assertEqual(object_.props.list, ['1', '2', '3'])
548
549
550

    def test_boxed(self):
        object_ = Everything.TestObj()
551
        self.assertEqual(object_.props.boxed, None)
552
553
554
555
556
557

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

        self.assertTrue(isinstance(object_.props.boxed, Everything.TestBoxed))
558
        self.assertEqual(object_.props.boxed.some_int8, 42)
559

Jasper St. Pierre's avatar
Jasper St. Pierre committed
560
561
562
563
564
565
566
567
    def test_boxed_equality(self):
        boxed = Everything.TestBoxedC()
        # TestBoxedC uses refcounting, so we know that
        # the pointer is the same when copied
        copy = boxed.copy()
        self.assertEqual(boxed, copy)
        self.assertNotEqual(id(boxed), id(copy))

568
569
    def test_gtype(self):
        object_ = Everything.TestObj()
570
        self.assertEqual(object_.props.gtype, GObject.TYPE_INVALID)
571
        object_.props.gtype = int
572
        self.assertEqual(object_.props.gtype, GObject.TYPE_INT)
573

Martin Pitt's avatar
Martin Pitt committed
574
        object_ = Everything.TestObj(gtype=int)
575
        self.assertEqual(object_.props.gtype, GObject.TYPE_INT)
576
        object_.props.gtype = str
577
        self.assertEqual(object_.props.gtype, GObject.TYPE_STRING)
578

579

580
581
582
583
584
585
586
587
588
589
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):
590
591
592
            (y, z, q) = object_.torture_signature_0(5000,
                                                    "Torture Test 1",
                                                    12345)
593
594
595
596
597
598
599
600
601
602

        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):
603
604
            (y, z, q) = Everything.TestObj().torture_signature_0(
                5000, "Torture Test 2", 12345)
605
606
607
608
609
610
611
612
613
614

        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:
615
616
                (y, z, q) = object_.torture_signature_1(
                    5000, "Torture Test 3", 12345)
617
618
619
620
621
622
623
624
            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): ")
625

626
627
628
        def callback(userdata):
            pass

629
        userdata = [1, 2, 3, 4]
630
631
        start_time = time.clock()
        for i in range(10000):
632
633
            (y, z, q) = Everything.test_torture_signature_2(
                5000, callback, userdata, "Torture Test 4", 12345)
634
635
636
637
638
639
640
        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)

641

642
643
644
645
646
647
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)
648
649

    def test_obj_skip_return_val(self):
Johan Dahlin's avatar
Johan Dahlin committed
650
651
        obj = Everything.TestObj()
        ret = obj.skip_return_val(50, 42.0, 60, 2, 3)
652
653
654
655
        self.assertEqual(len(ret), 3)
        self.assertEqual(ret[0], 51)
        self.assertEqual(ret[1], 61)
        self.assertEqual(ret[2], 32)
656

657
    def test_obj_skip_return_val_no_out(self):
Johan Dahlin's avatar
Johan Dahlin committed
658
        obj = Everything.TestObj()
659
660
661
662
        # 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)
663
        self.assertEqual(ret, None)
664

665

666
667
class TestSignals(unittest.TestCase):
    def test_object_param_signal(self):
Johan Dahlin's avatar
Johan Dahlin committed
668
        obj = Everything.TestObj()
669

670
        def callback(obj, obj_param):
671
            self.assertEqual(obj_param.props.int, 3)
672
            self.assertGreater(obj_param.__grefcount__, 1)
673
674
675

        obj.connect('sig-with-obj', callback)
        obj.emit_sig_with_obj()
676
677
678
679
680
681
682


class TestPango(unittest.TestCase):
    def test_cairo_font_options(self):
        screen = Gtk.Window().get_screen()
        font_opts = screen.get_font_options()
        self.assertEqual(type(font_opts.get_subpixel_order()), int)