test_everything.py 25.9 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
# vim: tabstop=4 shiftwidth=4 expandtab

import unittest
6
import traceback
Tomeu Vizoso's avatar
Tomeu Vizoso committed
7
8

import sys
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
#import gi
19
from gi.repository import GObject
20
from gi.repository import GLib
21
from gi.repository import Gio
22
from gi.repository import Regress as Everything
Tomeu Vizoso's avatar
Tomeu Vizoso committed
23

24
25
26
27
28
29
try:
    from gi.repository import Gtk
    Gtk  # pyflakes
except:
    Gtk = None

30
31
32
33
34
35
36
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
37
38
class TestEverything(unittest.TestCase):

39
    @unittest.skipUnless(has_cairo, 'built without cairo support')
Tomeu Vizoso's avatar
Tomeu Vizoso committed
40
41
42
43
44
45
46
47
    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)

48
    @unittest.skipUnless(has_cairo, 'built without cairo support')
Tomeu Vizoso's avatar
Tomeu Vizoso committed
49
50
51
52
    def test_cairo_surface(self):
        surface = Everything.test_cairo_surface_none_return()
        self.assertTrue(isinstance(surface, cairo.ImageSurface))
        self.assertTrue(isinstance(surface, cairo.Surface))
53
54
55
        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
56
57
58
59

        surface = Everything.test_cairo_surface_full_return()
        self.assertTrue(isinstance(surface, cairo.ImageSurface))
        self.assertTrue(isinstance(surface, cairo.Surface))
60
61
62
        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
63
64
65
66
67
68
69

        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))
70
71
72
        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
73

Paolo Borelli's avatar
Paolo Borelli committed
74
    def test_unichar(self):
75
        self.assertEqual("c", Everything.test_unichar("c"))
76
77

        if sys.version_info < (3, 0):
78
79
            self.assertEqual(UNICHAR, Everything.test_unichar(PY2_UNICODE_UNICHAR))
        self.assertEqual(UNICHAR, Everything.test_unichar(UNICHAR))
80
81
        self.assertRaises(TypeError, Everything.test_unichar, "")
        self.assertRaises(TypeError, Everything.test_unichar, "morethanonechar")
82

83
    def test_floating(self):
84
        e = Everything.TestFloating()
85
        self.assertEqual(e.__grefcount__, 1)
86
87

        e = GObject.new(Everything.TestFloating)
88
        self.assertEqual(e.__grefcount__, 1)
89
90

        e = Everything.TestFloating.new()
91
        self.assertEqual(e.__grefcount__, 1)
92

93
94
95
96
97
98
99
100
101
    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)
102
103
104
105
        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)
106
107
108
109
110
111
112
113
114
115

        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)
116
117
118
119
120
        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)
121

122
123
124
    def test_wrong_type_of_arguments(self):
        try:
            Everything.test_int8()
125
126
        except TypeError:
            (e_type, e) = sys.exc_info()[:2]
127
            self.assertEqual(e.args, ("test_int8() takes exactly 1 argument (0 given)",))
128

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

156
157
    def test_dir(self):
        attr_list = dir(Everything)
158

159
160
        # test that typelib attributes are listed
        self.assertTrue('TestStructA' in attr_list)
161

162
163
164
165
        # 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)
166

167
168
        # test that instance members are listed
        self.assertTrue('_namespace' in attr_list)
169
        self.assertTrue('_version' in attr_list)
170

171
172
        # test that there are no duplicates returned
        self.assertEqual(len(attr_list), len(set(attr_list)))
173

Xavier Claessens's avatar
Xavier Claessens committed
174
    def test_ptrarray(self):
175
176
        # transfer container
        result = Everything.test_garray_container_return()
177
        self.assertEqual(result, ['regress'])
178
179
180
181
        result = None

        # transfer full
        result = Everything.test_garray_full_return()
182
        self.assertEqual(result, ['regress'])
183
        result = None
Xavier Claessens's avatar
Xavier Claessens committed
184

185
186
    def test_hash_return(self):
        result = Everything.test_ghash_gvalue_return()
187
188
189
        self.assertEqual(result['integer'], 12)
        self.assertEqual(result['boolean'], True)
        self.assertEqual(result['string'], 'some text')
190
        self.assertEqual(result['strings'], ['first', 'second', 'third'])
191
192
        self.assertEqual(result['flags'], Everything.TestFlags.FLAG1 | Everything.TestFlags.FLAG3)
        self.assertEqual(result['enum'], Everything.TestEnum.VALUE2)
193
194
        result = None

195
    def test_hash_in(self):
196
197
198
        # 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
199
        class GStrv(list):
Martin Pitt's avatar
Martin Pitt committed
200
            __gtype__ = GObject.TYPE_STRV
201

202
203
204
205
206
207
208
        data = {'integer': 12,
                'boolean': True,
                'string': 'some text',
                'strings': GStrv(['first', 'second', 'third']),
                'flags': Everything.TestFlags.FLAG1 | Everything.TestFlags.FLAG3,
                'enum': Everything.TestEnum.VALUE2,
               }
209
210
        Everything.test_ghash_gvalue_in(data)
        data = None
211

212
213
214
215
216
217
218
219
220
221
    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)
222
        self.assertEqual(getrefcount(l1), init_refcount + 1)
223
224
225
226
227
228

        l3 = copy.copy(l1)
        l3.data = 'bar'
        self.assertEqual(l1.data, 'foo')
        self.assertEqual(l2.data, 'foo')
        self.assertEqual(l3.data, 'bar')
229
230
        self.assertEqual(getrefcount(l1), init_refcount + 1)
        self.assertEqual(getrefcount(l3), init_refcount)
231

232
233
234
235
236
    def test_struct_opaque(self):
        # we should get a sensible error message
        try:
            Everything.TestBoxedPrivate()
            self.fail('allocating disguised struct without default constructor unexpectedly succeeded')
237
238
239
240
241
242
243
        except TypeError:
            (e_type, e_value, e_tb) = sys.exc_info()
            self.assertEqual(e_type, TypeError)
            self.assertTrue('TestBoxedPrivate' in str(e_value), str(e_value))
            self.assertTrue('override' in str(e_value), str(e_value))
            self.assertTrue('constructor' in str(e_value), str(e_value))
            tb = ''.join(traceback.format_exception(e_type, e_value, e_tb))
244
245
            self.assertTrue('tests/test_everything.py", line' in tb, tb)

246

247
248
249
250
251
252
253
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)
254
255
        Everything.test_gslist_null_in([])
        Everything.test_glist_null_in([])
256
257

    def test_in_nullable_array(self):
258
        Everything.test_array_int_null_in(None)
259
        Everything.test_array_int_null_in([])
260
261
262
263

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

264
    def test_in_nullable_object(self):
265
        Everything.func_obj_null_in(None)
266

267
268
269
270
    def test_out_nullable_hash(self):
        self.assertEqual(None, Everything.test_ghash_null_out())

    def test_out_nullable_list(self):
271
272
        self.assertEqual([], Everything.test_gslist_null_out())
        self.assertEqual([], Everything.test_glist_null_out())
273
274

    def test_out_nullable_array(self):
275
        self.assertEqual([], Everything.test_array_int_null_out())
276
277
278
279

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

280
    def test_out_nullable_object(self):
281
        self.assertEqual(None, Everything.TestObj.null_out())
282

283

284
285
class TestCallbacks(unittest.TestCase):
    called = False
286
    main_loop = GObject.MainLoop()
Tomeu Vizoso's avatar
Tomeu Vizoso committed
287

288
    def test_callback(self):
289
        TestCallbacks.called = False
290

291
292
        def callback():
            TestCallbacks.called = True
293

294
295
296
        Everything.test_simple_callback(callback)
        self.assertTrue(TestCallbacks.called)

297
    def test_callback_exception(self):
298
299
300
301
302
303
        """
        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
304
            self.fail('unexpected surviving zero divsion:' + str(x))
305

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

311
    def test_double_callback_exception(self):
312
313
314
315
316
317
        """
        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
318
            self.fail('unexpected surviving zero divsion:' + str(x))
319
320
321
322
323
324

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

325
326
327
328
        # 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)
329

330
    def test_return_value_callback(self):
331
        TestCallbacks.called = False
332

333
334
335
336
        def callback():
            TestCallbacks.called = True
            return 44

337
        self.assertEqual(Everything.test_callback(callback), 44)
338
        self.assertTrue(TestCallbacks.called)
339

340
    def test_callback_async(self):
341
        TestCallbacks.called = False
342

343
344
345
346
        def callback(foo):
            TestCallbacks.called = True
            return foo

Johan Dahlin's avatar
Johan Dahlin committed
347
348
        Everything.test_callback_async(callback, 44)
        i = Everything.test_callback_thaw_async()
349
        self.assertEqual(44, i)
350
        self.assertTrue(TestCallbacks.called)
351

352
    def test_callback_scope_call(self):
353
        TestCallbacks.called = 0
354

355
356
357
358
359
        def callback():
            TestCallbacks.called += 1
            return 0

        Everything.test_multi_callback(callback)
360
        self.assertEqual(TestCallbacks.called, 2)
361

362
    def test_callback_userdata(self):
363
        TestCallbacks.called = 0
364

365
        def callback(userdata):
366
            self.assertEqual(userdata, "Test%d" % TestCallbacks.called)
367
368
            TestCallbacks.called += 1
            return TestCallbacks.called
369

370
371
        for i in range(100):
            val = Everything.test_callback_user_data(callback, "Test%d" % i)
372
            self.assertEqual(val, i + 1)
373

374
        self.assertEqual(TestCallbacks.called, 100)
Tomeu Vizoso's avatar
Tomeu Vizoso committed
375

376
    def test_callback_userdata_refcount(self):
377
        TestCallbacks.called = False
378

379
380
381
382
383
384
385
386
387
        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)
388

389
390
391
        Everything.test_callback_thaw_notifications()
        end_ref_count = getrefcount(ud)

392
        self.assertEqual(start_ref_count, end_ref_count)
393

394
    def test_async_ready_callback(self):
Tomeu Vizoso's avatar
Tomeu Vizoso committed
395
        TestCallbacks.called = False
396
        TestCallbacks.main_loop = GObject.MainLoop()
Tomeu Vizoso's avatar
Tomeu Vizoso committed
397
398
399
400
401
402
403
404
405
406

        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
407

408
    def test_callback_destroy_notify(self):
Tomeu Vizoso's avatar
Tomeu Vizoso committed
409
410
411
412
413
        def callback(user_data):
            TestCallbacks.called = True
            return 42

        TestCallbacks.called = False
414
        self.assertEqual(Everything.test_callback_destroy_notify(callback, 42), 42)
Tomeu Vizoso's avatar
Tomeu Vizoso committed
415
        self.assertTrue(TestCallbacks.called)
416
        self.assertEqual(Everything.test_callback_thaw_notifications(), 42)
417

418
    def test_callback_in_methods(self):
419
420
421
422
        object_ = Everything.TestObj()

        def callback():
            TestCallbacks.called = True
423
            return 42
424
425
426
427
428
429
430
431
432
433
434

        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
435
            return 42
436
437

        TestCallbacks.called = False
438
        Everything.TestObj.new_callback(callbackWithUserData, None)
439
        self.assertTrue(TestCallbacks.called)
440

441
    def test_callback_none(self):
442
        # make sure this doesn't assert or crash
443
        Everything.test_simple_callback(None)
444

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

456
457
458
459
460
461
462
463
464
    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)

465
    def test_callback_owned_gerror(self):
466
467
468
469
470
471
472
473
474
475
        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)

476
    def test_callback_hashtable(self):
477
478
479
480
481
        def callback(data):
            self.assertEqual(data, mydict)
            mydict['new'] = 42
            TestCallbacks.called = True

482
        mydict = {'foo': 1, 'bar': 2}
483
484
485
        TestCallbacks.called = False
        Everything.test_hash_table_callback(mydict, callback)
        self.assertTrue(TestCallbacks.called)
486
487
        self.assertEqual(mydict, {'foo': 1, 'bar': 2, 'new': 42})

488

Martin Pitt's avatar
Martin Pitt committed
489
490
491
492
class TestClosures(unittest.TestCase):
    def test_int_arg(self):
        def callback(num):
            self.called = True
493
            return num + 1
Martin Pitt's avatar
Martin Pitt committed
494
495
496
497
498
499
500
501
502

        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
503
504
505
            if variant is None:
                return None
            self.assertEqual(variant.get_type_string(), 'i')
Martin Pitt's avatar
Martin Pitt committed
506
507
508
509
510
511
512
            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)
513

514
515
516
517
518
519
520
521
522
        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)

523

524
525
class TestProperties(unittest.TestCase):

526
527
528
    def test_basic(self):
        object_ = Everything.TestObj()

529
        self.assertEqual(object_.props.int, 0)
530
531
        object_.props.int = 42
        self.assertTrue(isinstance(object_.props.int, int))
532
        self.assertEqual(object_.props.int, 42)
533

534
        self.assertEqual(object_.props.float, 0.0)
535
536
        object_.props.float = 42.42
        self.assertTrue(isinstance(object_.props.float, float))
Martin Pitt's avatar
Martin Pitt committed
537
        self.assertAlmostEqual(object_.props.float, 42.42, places=5)
538

539
        self.assertEqual(object_.props.double, 0.0)
540
541
        object_.props.double = 42.42
        self.assertTrue(isinstance(object_.props.double, float))
Martin Pitt's avatar
Martin Pitt committed
542
        self.assertAlmostEqual(object_.props.double, 42.42, places=5)
543

544
        self.assertEqual(object_.props.string, None)
545
546
        object_.props.string = 'mec'
        self.assertTrue(isinstance(object_.props.string, str))
547
        self.assertEqual(object_.props.string, 'mec')
548

549
        self.assertEqual(object_.props.gtype, GObject.TYPE_INVALID)
550
        object_.props.gtype = int
551
        self.assertEqual(object_.props.gtype, GObject.TYPE_INT)
552

553
554
    def test_hash_table(self):
        object_ = Everything.TestObj()
555
        self.assertEqual(object_.props.hash_table, None)
556
557
558

        object_.props.hash_table = {'mec': 56}
        self.assertTrue(isinstance(object_.props.hash_table, dict))
559
        self.assertEqual(list(object_.props.hash_table.items())[0], ('mec', 56))
560
561
562

    def test_list(self):
        object_ = Everything.TestObj()
563
        self.assertEqual(object_.props.list, [])
564
565
566

        object_.props.list = ['1', '2', '3']
        self.assertTrue(isinstance(object_.props.list, list))
567
        self.assertEqual(object_.props.list, ['1', '2', '3'])
568
569
570

    def test_boxed(self):
        object_ = Everything.TestObj()
571
        self.assertEqual(object_.props.boxed, None)
572
573
574
575
576
577

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

        self.assertTrue(isinstance(object_.props.boxed, Everything.TestBoxed))
578
        self.assertEqual(object_.props.boxed.some_int8, 42)
579

Jasper St. Pierre's avatar
Jasper St. Pierre committed
580
581
582
583
584
585
586
587
    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))

588
589
    def test_gtype(self):
        object_ = Everything.TestObj()
590
        self.assertEqual(object_.props.gtype, GObject.TYPE_INVALID)
591
        object_.props.gtype = int
592
        self.assertEqual(object_.props.gtype, GObject.TYPE_INT)
593

Martin Pitt's avatar
Martin Pitt committed
594
        object_ = Everything.TestObj(gtype=int)
595
        self.assertEqual(object_.props.gtype, GObject.TYPE_INT)
596
        object_.props.gtype = str
597
        self.assertEqual(object_.props.gtype, GObject.TYPE_STRING)
598

599

600
601
602
603
604
605
606
607
608
609
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):
610
611
612
            (y, z, q) = object_.torture_signature_0(5000,
                                                    "Torture Test 1",
                                                    12345)
613
614
615
616
617
618
619
620
621
622

        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):
623
624
            (y, z, q) = Everything.TestObj().torture_signature_0(
                5000, "Torture Test 2", 12345)
625
626
627
628
629
630
631
632
633
634

        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:
635
636
                (y, z, q) = object_.torture_signature_1(
                    5000, "Torture Test 3", 12345)
637
638
639
640
641
642
643
644
            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): ")
645

646
647
648
        def callback(userdata):
            pass

649
        userdata = [1, 2, 3, 4]
650
651
        start_time = time.clock()
        for i in range(10000):
652
653
            (y, z, q) = Everything.test_torture_signature_2(
                5000, callback, userdata, "Torture Test 4", 12345)
654
655
656
657
658
659
660
        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)

661

662
663
664
665
666
667
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)
668
669

    def test_obj_skip_return_val(self):
Johan Dahlin's avatar
Johan Dahlin committed
670
671
        obj = Everything.TestObj()
        ret = obj.skip_return_val(50, 42.0, 60, 2, 3)
672
673
674
675
        self.assertEqual(len(ret), 3)
        self.assertEqual(ret[0], 51)
        self.assertEqual(ret[1], 61)
        self.assertEqual(ret[2], 32)
676

677
    def test_obj_skip_return_val_no_out(self):
Johan Dahlin's avatar
Johan Dahlin committed
678
        obj = Everything.TestObj()
679
680
681
682
        # 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)
683
        self.assertEqual(ret, None)
684

685

686
687
class TestSignals(unittest.TestCase):
    def test_object_param_signal(self):
Johan Dahlin's avatar
Johan Dahlin committed
688
        obj = Everything.TestObj()
689

690
        def callback(obj, obj_param):
691
            self.assertEqual(obj_param.props.int, 3)
692
            self.assertGreater(obj_param.__grefcount__, 1)
693
            obj.called = True
694

695
        obj.called = False
696
697
        obj.connect('sig-with-obj', callback)
        obj.emit_sig_with_obj()
698
        self.assertTrue(obj.called)
699

700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
    def test_int64_param_from_py(self):
        obj = Everything.TestObj()

        def callback(obj, i):
            obj.callback_i = i
            return i

        obj.callback_i = None
        obj.connect('sig-with-int64-prop', callback)
        rv = obj.emit('sig-with-int64-prop', GObject.G_MAXINT64)
        self.assertEqual(rv, GObject.G_MAXINT64)
        self.assertEqual(obj.callback_i, GObject.G_MAXINT64)

    def test_uint64_param_from_py(self):
        obj = Everything.TestObj()

        def callback(obj, i):
            obj.callback_i = i
            return i

        obj.callback_i = None
        obj.connect('sig-with-uint64-prop', callback)
        rv = obj.emit('sig-with-uint64-prop', GObject.G_MAXUINT64)
        self.assertEqual(rv, GObject.G_MAXUINT64)
        self.assertEqual(obj.callback_i, GObject.G_MAXUINT64)

    def test_int64_param_from_c(self):
        obj = Everything.TestObj()

        def callback(obj, i):
            obj.callback_i = i
            return i

        obj.callback_i = None

        obj.connect('sig-with-int64-prop', callback)
        obj.emit_sig_with_int64()
        self.assertEqual(obj.callback_i, GObject.G_MAXINT64)

    def test_uint64_param_from_c(self):
        obj = Everything.TestObj()

        def callback(obj, i):
            obj.callback_i = i
            return i

        obj.callback_i = None

        obj.connect('sig-with-uint64-prop', callback)
        obj.emit_sig_with_uint64()
        self.assertEqual(obj.callback_i, GObject.G_MAXUINT64)

752
753

class TestPango(unittest.TestCase):
754
    @unittest.skipUnless(Gtk, 'Gtk not available')
755
756
757
758
    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)