tests/test_everything.py

   1 # -*- Mode: Python; py-indent-offset: 4 -*-
   2 # coding=utf-8
   3 # vim: tabstop=4 shiftwidth=4 expandtab
   4
   5 import unittest
   6 import traceback
   7
   8 import sys
   9 from sys import getrefcount
  10
  11 import copy
  12 try:
  13     import cairo
  14     has_cairo = True
  15 except ImportError:
  16     has_cairo = False
  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
  23
  24 try:
  25     from gi.repository import Gtk
  26     Gtk  # pyflakes
  27 except:
  28     Gtk = None
  29
  30 if sys.version_info < (3, 0):
  31     UNICHAR = "\xe2\x99\xa5"
  32     PY2_UNICODE_UNICHAR = unicode(UNICHAR, 'UTF-8')
  33 else:
  34     UNICHAR = "♥"
  35
  36
  37 class TestEverything(unittest.TestCase):
  38
  39     @unittest.skipUnless(has_cairo, 'built without cairo support')
  40     def test_cairo_context(self):
  41         context = Everything.test_cairo_context_full_return()
  42         self.assertTrue(isinstance(context, cairo.Context))
  43
  44         surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 10, 10)
  45         context = cairo.Context(surface)
  46         Everything.test_cairo_context_none_in(context)
  47
  48     @unittest.skipUnless(has_cairo, 'built without cairo support')
  49     def test_cairo_surface(self):
  50         surface = Everything.test_cairo_surface_none_return()
  51         self.assertTrue(isinstance(surface, cairo.ImageSurface))
  52         self.assertTrue(isinstance(surface, cairo.Surface))
  53         self.assertEqual(surface.get_format(), cairo.FORMAT_ARGB32)
  54         self.assertEqual(surface.get_width(), 10)
  55         self.assertEqual(surface.get_height(), 10)
  56
  57         surface = Everything.test_cairo_surface_full_return()
  58         self.assertTrue(isinstance(surface, cairo.ImageSurface))
  59         self.assertTrue(isinstance(surface, cairo.Surface))
  60         self.assertEqual(surface.get_format(), cairo.FORMAT_ARGB32)
  61         self.assertEqual(surface.get_width(), 10)
  62         self.assertEqual(surface.get_height(), 10)
  63
  64         surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 10, 10)
  65         Everything.test_cairo_surface_none_in(surface)
  66
  67         surface = Everything.test_cairo_surface_full_out()
  68         self.assertTrue(isinstance(surface, cairo.ImageSurface))
  69         self.assertTrue(isinstance(surface, cairo.Surface))
  70         self.assertEqual(surface.get_format(), cairo.FORMAT_ARGB32)
  71         self.assertEqual(surface.get_width(), 10)
  72         self.assertEqual(surface.get_height(), 10)
  73
  74     def test_unichar(self):
  75         self.assertEqual("c", Everything.test_unichar("c"))
  76
  77         if sys.version_info < (3, 0):
  78             self.assertEqual(UNICHAR, Everything.test_unichar(PY2_UNICODE_UNICHAR))
  79         self.assertEqual(UNICHAR, Everything.test_unichar(UNICHAR))
  80         self.assertRaises(TypeError, Everything.test_unichar, "")
  81         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     def test_caller_allocates(self):
  94         struct_a = Everything.TestStructA()
  95         struct_a.some_int = 10
  96         struct_a.some_int8 = 21
  97         struct_a.some_double = 3.14
  98         struct_a.some_enum = Everything.TestEnum.VALUE3
  99
 100         struct_a_clone = struct_a.clone()
 101         self.assertTrue(struct_a != struct_a_clone)
 102         self.assertEqual(struct_a.some_int, struct_a_clone.some_int)
 103         self.assertEqual(struct_a.some_int8, struct_a_clone.some_int8)
 104         self.assertEqual(struct_a.some_double, struct_a_clone.some_double)
 105         self.assertEqual(struct_a.some_enum, struct_a_clone.some_enum)
 106
 107         struct_b = Everything.TestStructB()
 108         struct_b.some_int8 = 8
 109         struct_b.nested_a.some_int = 20
 110         struct_b.nested_a.some_int8 = 12
 111         struct_b.nested_a.some_double = 333.3333
 112         struct_b.nested_a.some_enum = Everything.TestEnum.VALUE2
 113
 114         struct_b_clone = struct_b.clone()
 115         self.assertTrue(struct_b != struct_b_clone)
 116         self.assertEqual(struct_b.some_int8, struct_b_clone.some_int8)
 117         self.assertEqual(struct_b.nested_a.some_int, struct_b_clone.nested_a.some_int)
 118         self.assertEqual(struct_b.nested_a.some_int8, struct_b_clone.nested_a.some_int8)
 119         self.assertEqual(struct_b.nested_a.some_double, struct_b_clone.nested_a.some_double)
 120         self.assertEqual(struct_b.nested_a.some_enum, struct_b_clone.nested_a.some_enum)
 121
 122     def test_wrong_type_of_arguments(self):
 123         try:
 124             Everything.test_int8()
 125         except TypeError:
 126             (e_type, e) = sys.exc_info()[:2]
 127             self.assertEqual(e.args, ("test_int8() takes exactly 1 argument (0 given)",))
 128
 129     def test_gtypes(self):
 130         gchararray_gtype = GObject.type_from_name('gchararray')
 131         gtype = Everything.test_gtype(str)
 132         self.assertEqual(gchararray_gtype, gtype)
 133         gtype = Everything.test_gtype('gchararray')
 134         self.assertEqual(gchararray_gtype, gtype)
 135         gobject_gtype = GObject.GObject.__gtype__
 136         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         self.assertRaises(TypeError, Everything.test_gtype, 'invalidgtype')
 141
 142         class NotARegisteredClass(object):
 143             pass
 144
 145         self.assertRaises(TypeError, Everything.test_gtype, NotARegisteredClass)
 146
 147         class ARegisteredClass(GObject.GObject):
 148             __gtype_name__ = 'EverythingTestsARegisteredClass'
 149
 150         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     def test_dir(self):
 157         attr_list = dir(Everything)
 158
 159         # test that typelib attributes are listed
 160         self.assertTrue('TestStructA' in attr_list)
 161
 162         # test that class attributes and methods are listed
 163         self.assertTrue('__class__' in attr_list)
 164         self.assertTrue('__dir__' in attr_list)
 165         self.assertTrue('__repr__' in attr_list)
 166
 167         # test that instance members are listed
 168         self.assertTrue('_namespace' in attr_list)
 169         self.assertTrue('_version' in attr_list)
 170
 171         # test that there are no duplicates returned
 172         self.assertEqual(len(attr_list), len(set(attr_list)))
 173
 174     def test_ptrarray(self):
 175         # transfer container
 176         result = Everything.test_garray_container_return()
 177         self.assertEqual(result, ['regress'])
 178         result = None
 179
 180         # transfer full
 181         result = Everything.test_garray_full_return()
 182         self.assertEqual(result, ['regress'])
 183         result = None
 184
 185     def test_hash_return(self):
 186         result = Everything.test_ghash_gvalue_return()
 187         self.assertEqual(result['integer'], 12)
 188         self.assertEqual(result['boolean'], True)
 189         self.assertEqual(result['string'], 'some text')
 190         self.assertEqual(result['strings'], ['first', 'second', 'third'])
 191         self.assertEqual(result['flags'], Everything.TestFlags.FLAG1 | Everything.TestFlags.FLAG3)
 192         self.assertEqual(result['enum'], Everything.TestEnum.VALUE2)
 193         result = None
 194
 195     def test_hash_in(self):
 196         # specifying a simple string array for "strings" does not work due to
 197         # https://bugzilla.gnome.org/show_bug.cgi?id=666636
 198         # workaround by explicitly building a GStrv object
 199         class GStrv(list):
 200             __gtype__ = GObject.TYPE_STRV
 201
 202         data = {'integer': 12,
 203                 'boolean': True,
 204                 'string': 'some text',
 205                 'strings': GStrv(['first', 'second', 'third']),
 206                 'flags': Everything.TestFlags.FLAG1 | Everything.TestFlags.FLAG3,
 207                 'enum': Everything.TestEnum.VALUE2,
 208                }
 209         Everything.test_ghash_gvalue_in(data)
 210         data = None
 211
 212     def test_struct_gpointer(self):
 213         l1 = GLib.List()
 214         self.assertEqual(l1.data, None)
 215         init_refcount = getrefcount(l1)
 216
 217         l1.data = 'foo'
 218         self.assertEqual(l1.data, 'foo')
 219
 220         l2 = l1
 221         self.assertEqual(l1.data, l2.data)
 222         self.assertEqual(getrefcount(l1), init_refcount + 1)
 223
 224         l3 = copy.copy(l1)
 225         l3.data = 'bar'
 226         self.assertEqual(l1.data, 'foo')
 227         self.assertEqual(l2.data, 'foo')
 228         self.assertEqual(l3.data, 'bar')
 229         self.assertEqual(getrefcount(l1), init_refcount + 1)
 230         self.assertEqual(getrefcount(l3), init_refcount)
 231
 232     def test_struct_opaque(self):
 233         # we should get a sensible error message
 234         try:
 235             Everything.TestBoxedPrivate()
 236             self.fail('allocating disguised struct without default constructor unexpectedly succeeded')
 237         except TypeError:
 238             (e_type, e_value, e_tb) = sys.exc_info()
 239             self.assertEqual(e_type, TypeError)
 240             self.assertTrue('TestBoxedPrivate' in str(e_value), str(e_value))
 241             self.assertTrue('override' in str(e_value), str(e_value))
 242             self.assertTrue('constructor' in str(e_value), str(e_value))
 243             tb = ''.join(traceback.format_exception(e_type, e_value, e_tb))
 244             self.assertTrue('tests/test_everything.py", line' in tb, tb)
 245
 246
 247 class TestNullableArgs(unittest.TestCase):
 248     def test_in_nullable_hash(self):
 249         Everything.test_ghash_null_in(None)
 250
 251     def test_in_nullable_list(self):
 252         Everything.test_gslist_null_in(None)
 253         Everything.test_glist_null_in(None)
 254         Everything.test_gslist_null_in([])
 255         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     def test_in_nullable_string(self):
 262         Everything.test_utf8_null_in(None)
 263
 264     def test_in_nullable_object(self):
 265         Everything.func_obj_null_in(None)
 266
 267     def test_out_nullable_hash(self):
 268         self.assertEqual(None, Everything.test_ghash_null_out())
 269
 270     def test_out_nullable_list(self):
 271         self.assertEqual([], Everything.test_gslist_null_out())
 272         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     def test_out_nullable_string(self):
 278         self.assertEqual(None, Everything.test_utf8_null_out())
 279
 280     def test_out_nullable_object(self):
 281         self.assertEqual(None, Everything.TestObj.null_out())
 282
 283
 284 class TestCallbacks(unittest.TestCase):
 285     called = False
 286     main_loop = GObject.MainLoop()
 287
 288     def test_callback(self):
 289         TestCallbacks.called = False
 290
 291         def callback():
 292             TestCallbacks.called = True
 293
 294         Everything.test_simple_callback(callback)
 295         self.assertTrue(TestCallbacks.called)
 296
 297     def test_callback_exception(self):
 298         """
 299         This test ensures that we get errors from callbacks correctly
 300         and in particular that we do not segv when callbacks fail
 301         """
 302         def callback():
 303             x = 1 / 0
 304             self.fail('unexpected surviving zero divsion:' + str(x))
 305
 306         # note that we do NOT expect the ZeroDivisionError to be propagated
 307         # through from the callback, as it crosses the Python<->C boundary
 308         # twice. (See GNOME #616279)
 309         Everything.test_simple_callback(callback)
 310
 311     def test_double_callback_exception(self):
 312         """
 313         This test ensures that we get errors from callbacks correctly
 314         and in particular that we do not segv when callbacks fail
 315         """
 316         def badcallback():
 317             x = 1 / 0
 318             self.fail('unexpected surviving zero divsion:' + str(x))
 319
 320         def callback():
 321             Everything.test_boolean(True)
 322             Everything.test_boolean(False)
 323             Everything.test_simple_callback(badcallback())
 324
 325         # note that we do NOT expect the ZeroDivisionError to be propagated
 326         # through from the callback, as it crosses the Python<->C boundary
 327         # twice. (See GNOME #616279)
 328         Everything.test_simple_callback(callback)
 329
 330     def test_return_value_callback(self):
 331         TestCallbacks.called = False
 332
 333         def callback():
 334             TestCallbacks.called = True
 335             return 44
 336
 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         def callback(foo):
 344             TestCallbacks.called = True
 345             return foo
 346
 347         Everything.test_callback_async(callback, 44)
 348         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         def callback():
 356             TestCallbacks.called += 1
 357             return 0
 358
 359         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             TestCallbacks.called += 1
 368             return TestCallbacks.called
 369
 370         for i in range(100):
 371             val = Everything.test_callback_user_data(callback, "Test%d" % i)
 372             self.assertEqual(val, i + 1)
 373
 374         self.assertEqual(TestCallbacks.called, 100)
 375
 376     def test_callback_userdata_refcount(self):
 377         TestCallbacks.called = False
 378
 379         def callback(userdata):
 380             TestCallbacks.called = True
 381             return 1
 382
 383         ud = "Test User Data"
 384
 385         start_ref_count = getrefcount(ud)
 386         for i in range(100):
 387             Everything.test_callback_destroy_notify(callback, ud)
 388
 389         Everything.test_callback_thaw_notifications()
 390         end_ref_count = getrefcount(ud)
 391
 392         self.assertEqual(start_ref_count, end_ref_count)
 393
 394     def test_async_ready_callback(self):
 395         TestCallbacks.called = False
 396         TestCallbacks.main_loop = GObject.MainLoop()
 397
 398         def callback(obj, result, user_data):
 399             TestCallbacks.main_loop.quit()
 400             TestCallbacks.called = True
 401
 402         Everything.test_async_ready_callback(callback)
 403
 404         TestCallbacks.main_loop.run()
 405
 406         self.assertTrue(TestCallbacks.called)
 407
 408     def test_callback_destroy_notify(self):
 409         def callback(user_data):
 410             TestCallbacks.called = True
 411             return 42
 412
 413         TestCallbacks.called = False
 414         self.assertEqual(Everything.test_callback_destroy_notify(callback, 42), 42)
 415         self.assertTrue(TestCallbacks.called)
 416         self.assertEqual(Everything.test_callback_thaw_notifications(), 42)
 417
 418     def test_callback_in_methods(self):
 419         object_ = Everything.TestObj()
 420
 421         def callback():
 422             TestCallbacks.called = True
 423             return 42
 424
 425         TestCallbacks.called = False
 426         object_.instance_method_callback(callback)
 427         self.assertTrue(TestCallbacks.called)
 428
 429         TestCallbacks.called = False
 430         Everything.TestObj.static_method_callback(callback)
 431         self.assertTrue(TestCallbacks.called)
 432
 433         def callbackWithUserData(user_data):
 434             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         def callback(error):
 447             self.assertEqual(error.message, 'regression test error')
 448             self.assertTrue('g-io' in error.domain)
 449             self.assertEqual(error.code, Gio.IOErrorEnum.NOT_SUPPORTED)
 450             TestCallbacks.called = True
 451
 452         TestCallbacks.called = False
 453         Everything.test_gerror_callback(callback)
 454         self.assertTrue(TestCallbacks.called)
 455
 456     def test_callback_null_gerror(self):
 457         def callback(error):
 458             self.assertEqual(error, None)
 459             TestCallbacks.called = True
 460
 461         TestCallbacks.called = False
 462         Everything.test_null_gerror_callback(callback)
 463         self.assertTrue(TestCallbacks.called)
 464
 465     def test_callback_owned_gerror(self):
 466         def callback(error):
 467             self.assertEqual(error.message, 'regression test owned error')
 468             self.assertTrue('g-io' in error.domain)
 469             self.assertEqual(error.code, Gio.IOErrorEnum.PERMISSION_DENIED)
 470             TestCallbacks.called = True
 471
 472         TestCallbacks.called = False
 473         Everything.test_owned_gerror_callback(callback)
 474         self.assertTrue(TestCallbacks.called)
 475
 476     def test_callback_hashtable(self):
 477         def callback(data):
 478             self.assertEqual(data, mydict)
 479             mydict['new'] = 42
 480             TestCallbacks.called = True
 481
 482         mydict = {'foo': 1, 'bar': 2}
 483         TestCallbacks.called = False
 484         Everything.test_hash_table_callback(mydict, callback)
 485         self.assertTrue(TestCallbacks.called)
 486         self.assertEqual(mydict, {'foo': 1, 'bar': 2, 'new': 42})
 487
 488
 489 class TestClosures(unittest.TestCase):
 490     def test_int_arg(self):
 491         def callback(num):
 492             self.called = True
 493             return num + 1
 494
 495         self.called = False
 496         result = Everything.test_closure_one_arg(callback, 42)
 497         self.assertTrue(self.called)
 498         self.assertEqual(result, 43)
 499
 500     def test_variant(self):
 501         def callback(variant):
 502             self.called = True
 503             if variant is None:
 504                 return None
 505             self.assertEqual(variant.get_type_string(), 'i')
 506             return GLib.Variant('i', variant.get_int32() + 1)
 507
 508         self.called = False
 509         result = Everything.test_closure_variant(callback, GLib.Variant('i', 42))
 510         self.assertTrue(self.called)
 511         self.assertEqual(result.get_type_string(), 'i')
 512         self.assertEqual(result.get_int32(), 43)
 513
 514         self.called = False
 515         result = Everything.test_closure_variant(callback, None)
 516         self.assertTrue(self.called)
 517         self.assertEqual(result, None)
 518
 519         self.called = False
 520         self.assertRaises(TypeError, Everything.test_closure_variant, callback, 'foo')
 521         self.assertFalse(self.called)
 522
 523
 524 class TestProperties(unittest.TestCase):
 525
 526     def test_basic(self):
 527         object_ = Everything.TestObj()
 528
 529         self.assertEqual(object_.props.int, 0)
 530         object_.props.int = 42
 531         self.assertTrue(isinstance(object_.props.int, int))
 532         self.assertEqual(object_.props.int, 42)
 533
 534         self.assertEqual(object_.props.float, 0.0)
 535         object_.props.float = 42.42
 536         self.assertTrue(isinstance(object_.props.float, float))
 537         self.assertAlmostEqual(object_.props.float, 42.42, places=5)
 538
 539         self.assertEqual(object_.props.double, 0.0)
 540         object_.props.double = 42.42
 541         self.assertTrue(isinstance(object_.props.double, float))
 542         self.assertAlmostEqual(object_.props.double, 42.42, places=5)
 543
 544         self.assertEqual(object_.props.string, None)
 545         object_.props.string = 'mec'
 546         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     def test_hash_table(self):
 554         object_ = Everything.TestObj()
 555         self.assertEqual(object_.props.hash_table, None)
 556
 557         object_.props.hash_table = {'mec': 56}
 558         self.assertTrue(isinstance(object_.props.hash_table, dict))
 559         self.assertEqual(list(object_.props.hash_table.items())[0], ('mec', 56))
 560
 561     def test_list(self):
 562         object_ = Everything.TestObj()
 563         self.assertEqual(object_.props.list, [])
 564
 565         object_.props.list = ['1', '2', '3']
 566         self.assertTrue(isinstance(object_.props.list, list))
 567         self.assertEqual(object_.props.list, ['1', '2', '3'])
 568
 569     def test_boxed(self):
 570         object_ = Everything.TestObj()
 571         self.assertEqual(object_.props.boxed, None)
 572
 573         boxed = Everything.TestBoxed()
 574         boxed.some_int8 = 42
 575         object_.props.boxed = boxed
 576
 577         self.assertTrue(isinstance(object_.props.boxed, Everything.TestBoxed))
 578         self.assertEqual(object_.props.boxed.some_int8, 42)
 579
 580     def test_boxed_equality(self):
 581         boxed = Everything.TestBoxedC()
 582         # TestBoxedC uses refcounting, so we know that
 583         # the pointer is the same when copied
 584         copy = boxed.copy()
 585         self.assertEqual(boxed, copy)
 586         self.assertNotEqual(id(boxed), id(copy))
 587
 588     def test_gtype(self):
 589         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
 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 class TestTortureProfile(unittest.TestCase):
 601     def test_torture_profile(self):
 602         import time
 603         total_time = 0
 604         print("")
 605         object_ = Everything.TestObj()
 606         sys.stdout.write("\ttorture test 1 (10000 iterations): ")
 607
 608         start_time = time.clock()
 609         for i in range(10000):
 610             (y, z, q) = object_.torture_signature_0(5000,
 611                                                     "Torture Test 1",
 612                                                     12345)
 613
 614         end_time = time.clock()
 615         delta_time = end_time - start_time
 616         total_time += delta_time
 617         print("%f secs" % delta_time)
 618
 619         sys.stdout.write("\ttorture test 2 (10000 iterations): ")
 620
 621         start_time = time.clock()
 622         for i in range(10000):
 623             (y, z, q) = Everything.TestObj().torture_signature_0(
 624                 5000, "Torture Test 2", 12345)
 625
 626         end_time = time.clock()
 627         delta_time = end_time - start_time
 628         total_time += delta_time
 629         print("%f secs" % delta_time)
 630
 631         sys.stdout.write("\ttorture test 3 (10000 iterations): ")
 632         start_time = time.clock()
 633         for i in range(10000):
 634             try:
 635                 (y, z, q) = object_.torture_signature_1(
 636                     5000, "Torture Test 3", 12345)
 637             except:
 638                 pass
 639         end_time = time.clock()
 640         delta_time = end_time - start_time
 641         total_time += delta_time
 642         print("%f secs" % delta_time)
 643
 644         sys.stdout.write("\ttorture test 4 (10000 iterations): ")
 645
 646         def callback(userdata):
 647             pass
 648
 649         userdata = [1, 2, 3, 4]
 650         start_time = time.clock()
 651         for i in range(10000):
 652             (y, z, q) = Everything.test_torture_signature_2(
 653                 5000, callback, userdata, "Torture Test 4", 12345)
 654         end_time = time.clock()
 655         delta_time = end_time - start_time
 656         total_time += delta_time
 657         print("%f secs" % delta_time)
 658         print("\t====")
 659         print("\tTotal: %f sec" % total_time)
 660
 661
 662 class TestAdvancedInterfaces(unittest.TestCase):
 663     def test_array_objs(self):
 664         obj1, obj2 = Everything.test_array_fixed_out_objects()
 665         self.assertTrue(isinstance(obj1, Everything.TestObj))
 666         self.assertTrue(isinstance(obj2, Everything.TestObj))
 667         self.assertNotEqual(obj1, obj2)
 668
 669     def test_obj_skip_return_val(self):
 670         obj = Everything.TestObj()
 671         ret = obj.skip_return_val(50, 42.0, 60, 2, 3)
 672         self.assertEqual(len(ret), 3)
 673         self.assertEqual(ret[0], 51)
 674         self.assertEqual(ret[1], 61)
 675         self.assertEqual(ret[2], 32)
 676
 677     def test_obj_skip_return_val_no_out(self):
 678         obj = Everything.TestObj()
 679         # raises an error for 0, succeeds for any other value
 680         self.assertRaises(GLib.GError, obj.skip_return_val_no_out, 0)
 681
 682         ret = obj.skip_return_val_no_out(1)
 683         self.assertEqual(ret, None)
 684
 685
 686 class TestSignals(unittest.TestCase):
 687     def test_object_param_signal(self):
 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         obj.connect('sig-with-obj', callback)
 697         obj.emit_sig_with_obj()
 698         self.assertTrue(obj.called)
 699
 700     def test_int64_param_from_py(self):
 701         obj = Everything.TestObj()
 702
 703         def callback(obj, i):
 704             obj.callback_i = i
 705             return i
 706
 707         obj.callback_i = None
 708         obj.connect('sig-with-int64-prop', callback)
 709         rv = obj.emit('sig-with-int64-prop', GObject.G_MAXINT64)
 710         self.assertEqual(rv, GObject.G_MAXINT64)
 711         self.assertEqual(obj.callback_i, GObject.G_MAXINT64)
 712
 713     def test_uint64_param_from_py(self):
 714         obj = Everything.TestObj()
 715
 716         def callback(obj, i):
 717             obj.callback_i = i
 718             return i
 719
 720         obj.callback_i = None
 721         obj.connect('sig-with-uint64-prop', callback)
 722         rv = obj.emit('sig-with-uint64-prop', GObject.G_MAXUINT64)
 723         self.assertEqual(rv, GObject.G_MAXUINT64)
 724         self.assertEqual(obj.callback_i, GObject.G_MAXUINT64)
 725
 726     def test_int64_param_from_c(self):
 727         obj = Everything.TestObj()
 728
 729         def callback(obj, i):
 730             obj.callback_i = i
 731             return i
 732
 733         obj.callback_i = None
 734
 735         obj.connect('sig-with-int64-prop', callback)
 736         obj.emit_sig_with_int64()
 737         self.assertEqual(obj.callback_i, GObject.G_MAXINT64)
 738
 739     def test_uint64_param_from_c(self):
 740         obj = Everything.TestObj()
 741
 742         def callback(obj, i):
 743             obj.callback_i = i
 744             return i
 745
 746         obj.callback_i = None
 747
 748         obj.connect('sig-with-uint64-prop', callback)
 749         obj.emit_sig_with_uint64()
 750         self.assertEqual(obj.callback_i, GObject.G_MAXUINT64)
 751
 752
 753 class TestPango(unittest.TestCase):
 754     @unittest.skipUnless(Gtk, 'Gtk not available')
 755     def test_cairo_font_options(self):
 756         screen = Gtk.Window().get_screen()
 757         font_opts = screen.get_font_options()
 758         self.assertEqual(type(font_opts.get_subpixel_order()), int)