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
   7 import sys
   8 sys.path.insert(0, "../")
   9 from sys import getrefcount
  10
  11 import cairo
  12
  13 from gi.repository import GObject
  14 from gi.repository import Regress as Everything
  15
  16 if sys.version_info < (3, 0):
  17     UNICHAR = "\xe2\x99\xa5"
  18     PY2_UNICODE_UNICHAR = unicode(UNICHAR, 'UTF-8')
  19 else:
  20     UNICHAR = "♥"
  21
  22
  23 class TestEverything(unittest.TestCase):
  24
  25     def test_cairo_context(self):
  26         context = Everything.test_cairo_context_full_return()
  27         self.assertTrue(isinstance(context, cairo.Context))
  28
  29         surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 10, 10)
  30         context = cairo.Context(surface)
  31         Everything.test_cairo_context_none_in(context)
  32
  33     def test_cairo_surface(self):
  34         surface = Everything.test_cairo_surface_none_return()
  35         self.assertTrue(isinstance(surface, cairo.ImageSurface))
  36         self.assertTrue(isinstance(surface, cairo.Surface))
  37         self.assertEquals(surface.get_format(), cairo.FORMAT_ARGB32)
  38         self.assertEquals(surface.get_width(), 10)
  39         self.assertEquals(surface.get_height(), 10)
  40
  41         surface = Everything.test_cairo_surface_full_return()
  42         self.assertTrue(isinstance(surface, cairo.ImageSurface))
  43         self.assertTrue(isinstance(surface, cairo.Surface))
  44         self.assertEquals(surface.get_format(), cairo.FORMAT_ARGB32)
  45         self.assertEquals(surface.get_width(), 10)
  46         self.assertEquals(surface.get_height(), 10)
  47
  48         surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 10, 10)
  49         Everything.test_cairo_surface_none_in(surface)
  50
  51         surface = Everything.test_cairo_surface_full_out()
  52         self.assertTrue(isinstance(surface, cairo.ImageSurface))
  53         self.assertTrue(isinstance(surface, cairo.Surface))
  54         self.assertEquals(surface.get_format(), cairo.FORMAT_ARGB32)
  55         self.assertEquals(surface.get_width(), 10)
  56         self.assertEquals(surface.get_height(), 10)
  57
  58     def test_unichar(self):
  59         self.assertEquals("c", Everything.test_unichar("c"))
  60
  61         if sys.version_info < (3, 0):
  62             self.assertEquals(UNICHAR, Everything.test_unichar(PY2_UNICODE_UNICHAR))
  63         self.assertEquals(UNICHAR, Everything.test_unichar(UNICHAR))
  64         self.assertRaises(TypeError, Everything.test_unichar, "")
  65         self.assertRaises(TypeError, Everything.test_unichar, "morethanonechar")
  66
  67
  68     def test_floating(self):
  69         e = Everything.TestFloating()
  70         self.assertEquals(e.__grefcount__, 1)
  71
  72         e = GObject.new(Everything.TestFloating)
  73         self.assertEquals(e.__grefcount__, 1)
  74
  75         e = Everything.TestFloating.new()
  76         self.assertEquals(e.__grefcount__, 1)
  77
  78     def test_caller_allocates(self):
  79         struct_a = Everything.TestStructA()
  80         struct_a.some_int = 10
  81         struct_a.some_int8 = 21
  82         struct_a.some_double = 3.14
  83         struct_a.some_enum = Everything.TestEnum.VALUE3
  84
  85         struct_a_clone = struct_a.clone()
  86         self.assertTrue(struct_a != struct_a_clone)
  87         self.assertEquals(struct_a.some_int, struct_a_clone.some_int)
  88         self.assertEquals(struct_a.some_int8, struct_a_clone.some_int8)
  89         self.assertEquals(struct_a.some_double, struct_a_clone.some_double)
  90         self.assertEquals(struct_a.some_enum, struct_a_clone.some_enum)
  91
  92         struct_b = Everything.TestStructB()
  93         struct_b.some_int8 = 8
  94         struct_b.nested_a.some_int = 20
  95         struct_b.nested_a.some_int8 = 12
  96         struct_b.nested_a.some_double = 333.3333
  97         struct_b.nested_a.some_enum = Everything.TestEnum.VALUE2
  98
  99         struct_b_clone = struct_b.clone()
 100         self.assertTrue(struct_b != struct_b_clone)
 101         self.assertEquals(struct_b.some_int8, struct_b_clone.some_int8)
 102         self.assertEquals(struct_b.nested_a.some_int, struct_b_clone.nested_a.some_int)
 103         self.assertEquals(struct_b.nested_a.some_int8, struct_b_clone.nested_a.some_int8)
 104         self.assertEquals(struct_b.nested_a.some_double, struct_b_clone.nested_a.some_double)
 105         self.assertEquals(struct_b.nested_a.some_enum, struct_b_clone.nested_a.some_enum)
 106
 107     def test_wrong_type_of_arguments(self):
 108         try:
 109             Everything.test_int8()
 110         except TypeError:
 111             (e_type, e) = sys.exc_info()[:2]
 112             self.assertEquals(e.args, ("test_int8() takes exactly 1 argument(s) (0 given)",))
 113
 114     def test_gtypes(self):
 115         gchararray_gtype = GObject.type_from_name('gchararray')
 116         gtype = Everything.test_gtype(str)
 117         self.assertEquals(gchararray_gtype, gtype)
 118         gtype = Everything.test_gtype('gchararray')
 119         self.assertEquals(gchararray_gtype, gtype)
 120         gobject_gtype = GObject.GObject.__gtype__
 121         gtype = Everything.test_gtype(GObject.GObject)
 122         self.assertEquals(gobject_gtype, gtype)
 123         gtype = Everything.test_gtype('GObject')
 124         self.assertEquals(gobject_gtype, gtype)
 125         self.assertRaises(TypeError, Everything.test_gtype, 'invalidgtype')
 126
 127         class NotARegisteredClass(object):
 128             pass
 129
 130         self.assertRaises(TypeError, Everything.test_gtype, NotARegisteredClass)
 131
 132         class ARegisteredClass(GObject.GObject):
 133             __gtype_name__ = 'EverythingTestsARegisteredClass'
 134
 135         gtype = Everything.test_gtype('EverythingTestsARegisteredClass')
 136         self.assertEquals(ARegisteredClass.__gtype__, gtype)
 137         gtype = Everything.test_gtype(ARegisteredClass)
 138         self.assertEquals(ARegisteredClass.__gtype__, gtype)
 139         self.assertRaises(TypeError, Everything.test_gtype, 'ARegisteredClass')
 140
 141     def test_dir(self):
 142         attr_list = dir(Everything)
 143
 144         # test that typelib attributes are listed
 145         self.assertTrue('TestStructA' in attr_list)
 146
 147         # test that class attributes and methods are listed
 148         self.assertTrue('__class__' in attr_list)
 149         self.assertTrue('__dir__' in attr_list)
 150         self.assertTrue('__repr__' in attr_list)
 151
 152         # test that instance members are listed
 153         self.assertTrue('_namespace' in attr_list)
 154         self.assertTrue('_version' in attr_list)
 155
 156         # test that there are no duplicates returned
 157         self.assertEqual(len(attr_list), len(set(attr_list)))
 158
 159 class TestNullableArgs(unittest.TestCase):
 160     def test_in_nullable_hash(self):
 161         Everything.test_ghash_null_in(None)
 162
 163     def test_in_nullable_list(self):
 164         Everything.test_gslist_null_in(None)
 165         Everything.test_glist_null_in(None)
 166         Everything.test_gslist_null_in([])
 167         Everything.test_glist_null_in([])
 168
 169     def test_in_nullable_array(self):
 170         Everything.test_array_int_null_in(None)
 171         Everything.test_array_int_null_in([])
 172
 173     def test_in_nullable_string(self):
 174         Everything.test_utf8_null_in(None)
 175
 176     def test_in_nullable_object(self):
 177         Everything.func_obj_null_in(None)
 178
 179     def test_out_nullable_hash(self):
 180         self.assertEqual(None, Everything.test_ghash_null_out())
 181
 182     def test_out_nullable_list(self):
 183         self.assertEqual([], Everything.test_gslist_null_out())
 184         self.assertEqual([], Everything.test_glist_null_out())
 185
 186     def test_out_nullable_array(self):
 187         self.assertEqual([], Everything.test_array_int_null_out())
 188
 189     def test_out_nullable_string(self):
 190         self.assertEqual(None, Everything.test_utf8_null_out())
 191
 192     def test_out_nullable_object(self):
 193         self.assertEqual(None, Everything.TestObj.null_out())
 194
 195
 196 class TestCallbacks(unittest.TestCase):
 197     called = False
 198     main_loop = GObject.MainLoop()
 199
 200     def testCallback(self):
 201         TestCallbacks.called = False
 202         def callback():
 203             TestCallbacks.called = True
 204
 205         Everything.test_simple_callback(callback)
 206         self.assertTrue(TestCallbacks.called)
 207
 208     def testCallbackException(self):
 209         """
 210         This test ensures that we get errors from callbacks correctly
 211         and in particular that we do not segv when callbacks fail
 212         """
 213         def callback():
 214             x = 1 / 0
 215
 216         try:
 217             Everything.test_simple_callback(callback)
 218         except ZeroDivisionError:
 219             pass
 220
 221     def testDoubleCallbackException(self):
 222         """
 223         This test ensures that we get errors from callbacks correctly
 224         and in particular that we do not segv when callbacks fail
 225         """
 226         def badcallback():
 227             x = 1 / 0
 228
 229         def callback():
 230             Everything.test_boolean(True)
 231             Everything.test_boolean(False)
 232             Everything.test_simple_callback(badcallback())
 233
 234         try:
 235             Everything.test_simple_callback(callback)
 236         except ZeroDivisionError:
 237             pass
 238
 239     def testReturnValueCallback(self):
 240         TestCallbacks.called = False
 241         def callback():
 242             TestCallbacks.called = True
 243             return 44
 244
 245         self.assertEquals(Everything.test_callback(callback), 44)
 246         self.assertTrue(TestCallbacks.called)
 247
 248     def testCallbackAsync(self):
 249         TestCallbacks.called = False
 250         def callback(foo):
 251             TestCallbacks.called = True
 252             return foo
 253
 254         Everything.test_callback_async(callback, 44);
 255         i = Everything.test_callback_thaw_async();
 256         self.assertEquals(44, i);
 257         self.assertTrue(TestCallbacks.called)
 258
 259     def testCallbackScopeCall(self):
 260         TestCallbacks.called = 0
 261         def callback():
 262             TestCallbacks.called += 1
 263             return 0
 264
 265         Everything.test_multi_callback(callback)
 266         self.assertEquals(TestCallbacks.called, 2)
 267
 268     def testCallbackUserdata(self):
 269         TestCallbacks.called = 0
 270         def callback(userdata):
 271             self.assertEquals(userdata, "Test%d" % TestCallbacks.called)
 272             TestCallbacks.called += 1
 273             return TestCallbacks.called
 274
 275         for i in range(100):
 276             val = Everything.test_callback_user_data(callback, "Test%d" % i)
 277             self.assertEquals(val, i+1)
 278
 279         self.assertEquals(TestCallbacks.called, 100)
 280
 281     def testCallbackUserdataRefCount(self):
 282         TestCallbacks.called = False
 283         def callback(userdata):
 284             TestCallbacks.called = True
 285             return 1
 286
 287         ud = "Test User Data"
 288
 289         start_ref_count = getrefcount(ud)
 290         for i in range(100):
 291             Everything.test_callback_destroy_notify(callback, ud)
 292
 293         Everything.test_callback_thaw_notifications()
 294         end_ref_count = getrefcount(ud)
 295
 296         self.assertEquals(start_ref_count, end_ref_count)
 297
 298     def testAsyncReadyCallback(self):
 299         TestCallbacks.called = False
 300         TestCallbacks.main_loop = GObject.MainLoop()
 301
 302         def callback(obj, result, user_data):
 303             TestCallbacks.main_loop.quit()
 304             TestCallbacks.called = True
 305
 306         Everything.test_async_ready_callback(callback)
 307
 308         TestCallbacks.main_loop.run()
 309
 310         self.assertTrue(TestCallbacks.called)
 311
 312     def testCallbackDestroyNotify(self):
 313         def callback(user_data):
 314             TestCallbacks.called = True
 315             return 42
 316
 317         TestCallbacks.called = False
 318         self.assertEquals(Everything.test_callback_destroy_notify(callback, 42), 42)
 319         self.assertTrue(TestCallbacks.called)
 320         self.assertEquals(Everything.test_callback_thaw_notifications(), 42)
 321
 322     def testCallbackInMethods(self):
 323         object_ = Everything.TestObj()
 324
 325         def callback():
 326             TestCallbacks.called = True
 327             return 42
 328
 329         TestCallbacks.called = False
 330         object_.instance_method_callback(callback)
 331         self.assertTrue(TestCallbacks.called)
 332
 333         TestCallbacks.called = False
 334         Everything.TestObj.static_method_callback(callback)
 335         self.assertTrue(TestCallbacks.called)
 336
 337         def callbackWithUserData(user_data):
 338             TestCallbacks.called = True
 339             return 42
 340
 341         TestCallbacks.called = False
 342         obj_ = Everything.TestObj.new_callback(callbackWithUserData, None)
 343         self.assertTrue(TestCallbacks.called)
 344
 345     def testCallbackNone(self):
 346         # make sure this doesn't assert or crash
 347         Everything.test_simple_callback(None)
 348
 349
 350 class TestProperties(unittest.TestCase):
 351
 352     def test_basic(self):
 353         object_ = Everything.TestObj()
 354
 355         self.assertEquals(object_.props.int, 0)
 356         object_.props.int = 42
 357         self.assertTrue(isinstance(object_.props.int, int))
 358         self.assertEquals(object_.props.int, 42)
 359
 360         self.assertEquals(object_.props.float, 0.0)
 361         object_.props.float = 42.42
 362         self.assertTrue(isinstance(object_.props.float, float))
 363         self.assertAlmostEquals(object_.props.float, 42.42, places=5)
 364
 365         self.assertEquals(object_.props.double, 0.0)
 366         object_.props.double = 42.42
 367         self.assertTrue(isinstance(object_.props.double, float))
 368         self.assertAlmostEquals(object_.props.double, 42.42, places=5)
 369
 370         self.assertEquals(object_.props.string, None)
 371         object_.props.string = 'mec'
 372         self.assertTrue(isinstance(object_.props.string, str))
 373         self.assertEquals(object_.props.string, 'mec')
 374
 375     def test_hash_table(self):
 376         object_ = Everything.TestObj()
 377         self.assertEquals(object_.props.hash_table, None)
 378
 379         object_.props.hash_table = {'mec': 56}
 380         self.assertTrue(isinstance(object_.props.hash_table, dict))
 381         self.assertEquals(list(object_.props.hash_table.items())[0], ('mec', 56))
 382
 383     def test_list(self):
 384         object_ = Everything.TestObj()
 385         self.assertEquals(object_.props.list, [])
 386
 387         object_.props.list = ['1', '2', '3']
 388         self.assertTrue(isinstance(object_.props.list, list))
 389         self.assertEquals(object_.props.list, ['1', '2', '3'])
 390
 391     def test_boxed(self):
 392         object_ = Everything.TestObj()
 393         self.assertEquals(object_.props.boxed, None)
 394
 395         boxed = Everything.TestBoxed()
 396         boxed.some_int8 = 42
 397         object_.props.boxed = boxed
 398
 399         self.assertTrue(isinstance(object_.props.boxed, Everything.TestBoxed))
 400         self.assertEquals(object_.props.boxed.some_int8, 42)
 401
 402 class TestTortureProfile(unittest.TestCase):
 403     def test_torture_profile(self):
 404         import time
 405         total_time = 0
 406         print("")
 407         object_ = Everything.TestObj()
 408         sys.stdout.write("\ttorture test 1 (10000 iterations): ")
 409
 410         start_time = time.clock()
 411         for i in range(10000):
 412             (y,z,q) = object_.torture_signature_0(5000,
 413                                                   "Torture Test 1",
 414                                                   12345)
 415
 416         end_time = time.clock()
 417         delta_time = end_time - start_time
 418         total_time += delta_time
 419         print("%f secs" % delta_time)
 420
 421         sys.stdout.write("\ttorture test 2 (10000 iterations): ")
 422
 423         start_time = time.clock()
 424         for i in range(10000):
 425             (y,z,q) = Everything.TestObj().torture_signature_0(5000,
 426                                                                "Torture Test 2",
 427                                                                12345)
 428
 429         end_time = time.clock()
 430         delta_time = end_time - start_time
 431         total_time += delta_time
 432         print("%f secs" % delta_time)
 433
 434
 435         sys.stdout.write("\ttorture test 3 (10000 iterations): ")
 436         start_time = time.clock()
 437         for i in range(10000):
 438             try:
 439                 (y,z,q) = object_.torture_signature_1(5000,
 440                                                       "Torture Test 3",
 441                                                       12345)
 442             except:
 443                 pass
 444         end_time = time.clock()
 445         delta_time = end_time - start_time
 446         total_time += delta_time
 447         print("%f secs" % delta_time)
 448
 449         sys.stdout.write("\ttorture test 4 (10000 iterations): ")
 450         def callback(userdata):
 451             pass
 452
 453         userdata = [1,2,3,4]
 454         start_time = time.clock()
 455         for i in range(10000):
 456             (y,z,q) = Everything.test_torture_signature_2(5000,
 457                                                           callback,
 458                                                           userdata,
 459                                                           "Torture Test 4",
 460                                                           12345)
 461         end_time = time.clock()
 462         delta_time = end_time - start_time
 463         total_time += delta_time
 464         print("%f secs" % delta_time)
 465         print("\t====")
 466         print("\tTotal: %f sec" % total_time)
 467