tests/test_gi.py

   1 # -*- Mode: Python; py-indent-offset: 4 -*-
   2 # coding=utf-8
   3 # vim: tabstop=4 shiftwidth=4 expandtab
   4
   5 import sys
   6
   7 import unittest
   8 import tempfile
   9 import shutil
  10 import os
  11 import locale
  12 import subprocess
  13 from gi.repository import GObject, GLib
  14
  15 from gi.repository import GIMarshallingTests
  16
  17 from compathelper import _bytes
  18
  19 if sys.version_info < (3, 0):
  20     CONSTANT_UTF8 = "const \xe2\x99\xa5 utf8"
  21     PY2_UNICODE_UTF8 = unicode(CONSTANT_UTF8, 'UTF-8')
  22     CHAR_255='\xff'
  23 else:
  24     CONSTANT_UTF8 = "const ♥ utf8"
  25     CHAR_255=bytes([255])
  26
  27 CONSTANT_NUMBER = 42
  28
  29
  30 class Number(object):
  31
  32     def __init__(self, value):
  33         self.value = value
  34
  35     def __int__(self):
  36         return int(self.value)
  37
  38     def __float__(self):
  39         return float(self.value)
  40
  41
  42 class Sequence(object):
  43
  44     def __init__(self, sequence):
  45         self.sequence = sequence
  46
  47     def __len__(self):
  48         return len(self.sequence)
  49
  50     def __getitem__(self, key):
  51         return self.sequence[key]
  52
  53
  54 class TestConstant(unittest.TestCase):
  55
  56 # Blocked by https://bugzilla.gnome.org/show_bug.cgi?id=595773
  57 #    def test_constant_utf8(self):
  58 #        self.assertEquals(CONSTANT_UTF8, GIMarshallingTests.CONSTANT_UTF8)
  59
  60     def test_constant_number(self):
  61         self.assertEquals(CONSTANT_NUMBER, GIMarshallingTests.CONSTANT_NUMBER)
  62
  63
  64 class TestBoolean(unittest.TestCase):
  65
  66     def test_boolean_return(self):
  67         self.assertEquals(True, GIMarshallingTests.boolean_return_true())
  68         self.assertEquals(False, GIMarshallingTests.boolean_return_false())
  69
  70     def test_boolean_in(self):
  71         GIMarshallingTests.boolean_in_true(True)
  72         GIMarshallingTests.boolean_in_false(False)
  73
  74         GIMarshallingTests.boolean_in_true(1)
  75         GIMarshallingTests.boolean_in_false(0)
  76
  77     def test_boolean_out(self):
  78         self.assertEquals(True, GIMarshallingTests.boolean_out_true())
  79         self.assertEquals(False, GIMarshallingTests.boolean_out_false())
  80
  81     def test_boolean_inout(self):
  82         self.assertEquals(False, GIMarshallingTests.boolean_inout_true_false(True))
  83         self.assertEquals(True, GIMarshallingTests.boolean_inout_false_true(False))
  84
  85
  86 class TestInt8(unittest.TestCase):
  87
  88     MAX = GObject.G_MAXINT8
  89     MIN = GObject.G_MININT8
  90
  91     def test_int8_return(self):
  92         self.assertEquals(self.MAX, GIMarshallingTests.int8_return_max())
  93         self.assertEquals(self.MIN, GIMarshallingTests.int8_return_min())
  94
  95     def test_int8_in(self):
  96         max = Number(self.MAX)
  97         min = Number(self.MIN)
  98
  99         GIMarshallingTests.int8_in_max(max)
 100         GIMarshallingTests.int8_in_min(min)
 101
 102         max.value += 1
 103         min.value -= 1
 104
 105         self.assertRaises(ValueError, GIMarshallingTests.int8_in_max, max)
 106         self.assertRaises(ValueError, GIMarshallingTests.int8_in_min, min)
 107
 108         self.assertRaises(TypeError, GIMarshallingTests.int8_in_max, "self.MAX")
 109
 110     def test_int8_out(self):
 111         self.assertEquals(self.MAX, GIMarshallingTests.int8_out_max())
 112         self.assertEquals(self.MIN, GIMarshallingTests.int8_out_min())
 113
 114     def test_int8_inout(self):
 115         self.assertEquals(self.MIN, GIMarshallingTests.int8_inout_max_min(Number(self.MAX)))
 116         self.assertEquals(self.MAX, GIMarshallingTests.int8_inout_min_max(Number(self.MIN)))
 117
 118
 119 class TestUInt8(unittest.TestCase):
 120
 121     MAX = GObject.G_MAXUINT8
 122
 123     def test_uint8_return(self):
 124         self.assertEquals(self.MAX, GIMarshallingTests.uint8_return())
 125
 126     def test_uint8_in(self):
 127         number = Number(self.MAX)
 128
 129         GIMarshallingTests.uint8_in(number)
 130         GIMarshallingTests.uint8_in(CHAR_255)
 131
 132         number.value += 1
 133         self.assertRaises(ValueError, GIMarshallingTests.uint8_in, number)
 134         self.assertRaises(ValueError, GIMarshallingTests.uint8_in, Number(-1))
 135
 136         self.assertRaises(TypeError, GIMarshallingTests.uint8_in, "self.MAX")
 137
 138     def test_uint8_out(self):
 139         self.assertEquals(self.MAX, GIMarshallingTests.uint8_out())
 140
 141     def test_uint8_inout(self):
 142         self.assertEquals(0, GIMarshallingTests.uint8_inout(Number(self.MAX)))
 143
 144
 145 class TestInt16(unittest.TestCase):
 146
 147     MAX = GObject.G_MAXINT16
 148     MIN = GObject.G_MININT16
 149
 150     def test_int16_return(self):
 151         self.assertEquals(self.MAX, GIMarshallingTests.int16_return_max())
 152         self.assertEquals(self.MIN, GIMarshallingTests.int16_return_min())
 153
 154     def test_int16_in(self):
 155         max = Number(self.MAX)
 156         min = Number(self.MIN)
 157
 158         GIMarshallingTests.int16_in_max(max)
 159         GIMarshallingTests.int16_in_min(min)
 160
 161         max.value += 1
 162         min.value -= 1
 163
 164         self.assertRaises(ValueError, GIMarshallingTests.int16_in_max, max)
 165         self.assertRaises(ValueError, GIMarshallingTests.int16_in_min, min)
 166
 167         self.assertRaises(TypeError, GIMarshallingTests.int16_in_max, "self.MAX")
 168
 169     def test_int16_out(self):
 170         self.assertEquals(self.MAX, GIMarshallingTests.int16_out_max())
 171         self.assertEquals(self.MIN, GIMarshallingTests.int16_out_min())
 172
 173     def test_int16_inout(self):
 174         self.assertEquals(self.MIN, GIMarshallingTests.int16_inout_max_min(Number(self.MAX)))
 175         self.assertEquals(self.MAX, GIMarshallingTests.int16_inout_min_max(Number(self.MIN)))
 176
 177
 178 class TestUInt16(unittest.TestCase):
 179
 180     MAX = GObject.G_MAXUINT16
 181
 182     def test_uint16_return(self):
 183         self.assertEquals(self.MAX, GIMarshallingTests.uint16_return())
 184
 185     def test_uint16_in(self):
 186         number = Number(self.MAX)
 187
 188         GIMarshallingTests.uint16_in(number)
 189
 190         number.value += 1
 191
 192         self.assertRaises(ValueError, GIMarshallingTests.uint16_in, number)
 193         self.assertRaises(ValueError, GIMarshallingTests.uint16_in, Number(-1))
 194
 195         self.assertRaises(TypeError, GIMarshallingTests.uint16_in, "self.MAX")
 196
 197     def test_uint16_out(self):
 198         self.assertEquals(self.MAX, GIMarshallingTests.uint16_out())
 199
 200     def test_uint16_inout(self):
 201         self.assertEquals(0, GIMarshallingTests.uint16_inout(Number(self.MAX)))
 202
 203
 204 class TestInt32(unittest.TestCase):
 205
 206     MAX = GObject.G_MAXINT32
 207     MIN = GObject.G_MININT32
 208
 209     def test_int32_return(self):
 210         self.assertEquals(self.MAX, GIMarshallingTests.int32_return_max())
 211         self.assertEquals(self.MIN, GIMarshallingTests.int32_return_min())
 212
 213     def test_int32_in(self):
 214         max = Number(self.MAX)
 215         min = Number(self.MIN)
 216
 217         GIMarshallingTests.int32_in_max(max)
 218         GIMarshallingTests.int32_in_min(min)
 219
 220         max.value += 1
 221         min.value -= 1
 222
 223         self.assertRaises(ValueError, GIMarshallingTests.int32_in_max, max)
 224         self.assertRaises(ValueError, GIMarshallingTests.int32_in_min, min)
 225
 226         self.assertRaises(TypeError, GIMarshallingTests.int32_in_max, "self.MAX")
 227
 228     def test_int32_out(self):
 229         self.assertEquals(self.MAX, GIMarshallingTests.int32_out_max())
 230         self.assertEquals(self.MIN, GIMarshallingTests.int32_out_min())
 231
 232     def test_int32_inout(self):
 233         self.assertEquals(self.MIN, GIMarshallingTests.int32_inout_max_min(Number(self.MAX)))
 234         self.assertEquals(self.MAX, GIMarshallingTests.int32_inout_min_max(Number(self.MIN)))
 235
 236
 237 class TestUInt32(unittest.TestCase):
 238
 239     MAX = GObject.G_MAXUINT32
 240
 241     def test_uint32_return(self):
 242         self.assertEquals(self.MAX, GIMarshallingTests.uint32_return())
 243
 244     def test_uint32_in(self):
 245         number = Number(self.MAX)
 246
 247         GIMarshallingTests.uint32_in(number)
 248
 249         number.value += 1
 250
 251         self.assertRaises(ValueError, GIMarshallingTests.uint32_in, number)
 252         self.assertRaises(ValueError, GIMarshallingTests.uint32_in, Number(-1))
 253
 254         self.assertRaises(TypeError, GIMarshallingTests.uint32_in, "self.MAX")
 255
 256     def test_uint32_out(self):
 257         self.assertEquals(self.MAX, GIMarshallingTests.uint32_out())
 258
 259     def test_uint32_inout(self):
 260         self.assertEquals(0, GIMarshallingTests.uint32_inout(Number(self.MAX)))
 261
 262
 263 class TestInt64(unittest.TestCase):
 264
 265     MAX = 2 ** 63 - 1
 266     MIN = - (2 ** 63)
 267
 268     def test_int64_return(self):
 269         self.assertEquals(self.MAX, GIMarshallingTests.int64_return_max())
 270         self.assertEquals(self.MIN, GIMarshallingTests.int64_return_min())
 271
 272     def test_int64_in(self):
 273         max = Number(self.MAX)
 274         min = Number(self.MIN)
 275
 276         GIMarshallingTests.int64_in_max(max)
 277         GIMarshallingTests.int64_in_min(min)
 278
 279         max.value += 1
 280         min.value -= 1
 281
 282         self.assertRaises(ValueError, GIMarshallingTests.int64_in_max, max)
 283         self.assertRaises(ValueError, GIMarshallingTests.int64_in_min, min)
 284
 285         self.assertRaises(TypeError, GIMarshallingTests.int64_in_max, "self.MAX")
 286
 287     def test_int64_out(self):
 288         self.assertEquals(self.MAX, GIMarshallingTests.int64_out_max())
 289         self.assertEquals(self.MIN, GIMarshallingTests.int64_out_min())
 290
 291     def test_int64_inout(self):
 292         self.assertEquals(self.MIN, GIMarshallingTests.int64_inout_max_min(Number(self.MAX)))
 293         self.assertEquals(self.MAX, GIMarshallingTests.int64_inout_min_max(Number(self.MIN)))
 294
 295
 296 class TestUInt64(unittest.TestCase):
 297
 298     MAX = 2 ** 64 - 1
 299
 300     def test_uint64_return(self):
 301         self.assertEquals(self.MAX, GIMarshallingTests.uint64_return())
 302
 303     def test_uint64_in(self):
 304         number = Number(self.MAX)
 305
 306         GIMarshallingTests.uint64_in(number)
 307
 308         number.value += 1
 309
 310         self.assertRaises(ValueError, GIMarshallingTests.uint64_in, number)
 311         self.assertRaises(ValueError, GIMarshallingTests.uint64_in, Number(-1))
 312
 313         self.assertRaises(TypeError, GIMarshallingTests.uint64_in, "self.MAX")
 314
 315     def test_uint64_out(self):
 316         self.assertEquals(self.MAX, GIMarshallingTests.uint64_out())
 317
 318     def test_uint64_inout(self):
 319         self.assertEquals(0, GIMarshallingTests.uint64_inout(Number(self.MAX)))
 320
 321
 322 class TestShort(unittest.TestCase):
 323
 324     MAX = GObject.constants.G_MAXSHORT
 325     MIN = GObject.constants.G_MINSHORT
 326
 327     def test_short_return(self):
 328         self.assertEquals(self.MAX, GIMarshallingTests.short_return_max())
 329         self.assertEquals(self.MIN, GIMarshallingTests.short_return_min())
 330
 331     def test_short_in(self):
 332         max = Number(self.MAX)
 333         min = Number(self.MIN)
 334
 335         GIMarshallingTests.short_in_max(max)
 336         GIMarshallingTests.short_in_min(min)
 337
 338         max.value += 1
 339         min.value -= 1
 340
 341         self.assertRaises(ValueError, GIMarshallingTests.short_in_max, max)
 342         self.assertRaises(ValueError, GIMarshallingTests.short_in_min, min)
 343
 344         self.assertRaises(TypeError, GIMarshallingTests.short_in_max, "self.MAX")
 345
 346     def test_short_out(self):
 347         self.assertEquals(self.MAX, GIMarshallingTests.short_out_max())
 348         self.assertEquals(self.MIN, GIMarshallingTests.short_out_min())
 349
 350     def test_short_inout(self):
 351         self.assertEquals(self.MIN, GIMarshallingTests.short_inout_max_min(Number(self.MAX)))
 352         self.assertEquals(self.MAX, GIMarshallingTests.short_inout_min_max(Number(self.MIN)))
 353
 354
 355 class TestUShort(unittest.TestCase):
 356
 357     MAX = GObject.constants.G_MAXUSHORT
 358
 359     def test_ushort_return(self):
 360         self.assertEquals(self.MAX, GIMarshallingTests.ushort_return())
 361
 362     def test_ushort_in(self):
 363         number = Number(self.MAX)
 364
 365         GIMarshallingTests.ushort_in(number)
 366
 367         number.value += 1
 368
 369         self.assertRaises(ValueError, GIMarshallingTests.ushort_in, number)
 370         self.assertRaises(ValueError, GIMarshallingTests.ushort_in, Number(-1))
 371
 372         self.assertRaises(TypeError, GIMarshallingTests.ushort_in, "self.MAX")
 373
 374     def test_ushort_out(self):
 375         self.assertEquals(self.MAX, GIMarshallingTests.ushort_out())
 376
 377     def test_ushort_inout(self):
 378         self.assertEquals(0, GIMarshallingTests.ushort_inout(Number(self.MAX)))
 379
 380
 381 class TestInt(unittest.TestCase):
 382
 383     MAX = GObject.constants.G_MAXINT
 384     MIN = GObject.constants.G_MININT
 385
 386     def test_int_return(self):
 387         self.assertEquals(self.MAX, GIMarshallingTests.int_return_max())
 388         self.assertEquals(self.MIN, GIMarshallingTests.int_return_min())
 389
 390     def test_int_in(self):
 391         max = Number(self.MAX)
 392         min = Number(self.MIN)
 393
 394         GIMarshallingTests.int_in_max(max)
 395         GIMarshallingTests.int_in_min(min)
 396
 397         max.value += 1
 398         min.value -= 1
 399
 400         self.assertRaises(ValueError, GIMarshallingTests.int_in_max, max)
 401         self.assertRaises(ValueError, GIMarshallingTests.int_in_min, min)
 402
 403         self.assertRaises(TypeError, GIMarshallingTests.int_in_max, "self.MAX")
 404
 405     def test_int_out(self):
 406         self.assertEquals(self.MAX, GIMarshallingTests.int_out_max())
 407         self.assertEquals(self.MIN, GIMarshallingTests.int_out_min())
 408
 409     def test_int_inout(self):
 410         self.assertEquals(self.MIN, GIMarshallingTests.int_inout_max_min(Number(self.MAX)))
 411         self.assertEquals(self.MAX, GIMarshallingTests.int_inout_min_max(Number(self.MIN)))
 412         self.assertRaises(TypeError, GIMarshallingTests.int_inout_min_max, Number(self.MIN), CONSTANT_NUMBER)
 413
 414
 415 class TestUInt(unittest.TestCase):
 416
 417     MAX = GObject.constants.G_MAXUINT
 418
 419     def test_uint_return(self):
 420         self.assertEquals(self.MAX, GIMarshallingTests.uint_return())
 421
 422     def test_uint_in(self):
 423         number = Number(self.MAX)
 424
 425         GIMarshallingTests.uint_in(number)
 426
 427         number.value += 1
 428
 429         self.assertRaises(ValueError, GIMarshallingTests.uint_in, number)
 430         self.assertRaises(ValueError, GIMarshallingTests.uint_in, Number(-1))
 431
 432         self.assertRaises(TypeError, GIMarshallingTests.uint_in, "self.MAX")
 433
 434     def test_uint_out(self):
 435         self.assertEquals(self.MAX, GIMarshallingTests.uint_out())
 436
 437     def test_uint_inout(self):
 438         self.assertEquals(0, GIMarshallingTests.uint_inout(Number(self.MAX)))
 439
 440
 441 class TestLong(unittest.TestCase):
 442
 443     MAX = GObject.constants.G_MAXLONG
 444     MIN = GObject.constants.G_MINLONG
 445
 446     def test_long_return(self):
 447         self.assertEquals(self.MAX, GIMarshallingTests.long_return_max())
 448         self.assertEquals(self.MIN, GIMarshallingTests.long_return_min())
 449
 450     def test_long_in(self):
 451         max = Number(self.MAX)
 452         min = Number(self.MIN)
 453
 454         GIMarshallingTests.long_in_max(max)
 455         GIMarshallingTests.long_in_min(min)
 456
 457         max.value += 1
 458         min.value -= 1
 459
 460         self.assertRaises(ValueError, GIMarshallingTests.long_in_max, max)
 461         self.assertRaises(ValueError, GIMarshallingTests.long_in_min, min)
 462
 463         self.assertRaises(TypeError, GIMarshallingTests.long_in_max, "self.MAX")
 464
 465     def test_long_out(self):
 466         self.assertEquals(self.MAX, GIMarshallingTests.long_out_max())
 467         self.assertEquals(self.MIN, GIMarshallingTests.long_out_min())
 468
 469     def test_long_inout(self):
 470         self.assertEquals(self.MIN, GIMarshallingTests.long_inout_max_min(Number(self.MAX)))
 471         self.assertEquals(self.MAX, GIMarshallingTests.long_inout_min_max(Number(self.MIN)))
 472
 473
 474 class TestULong(unittest.TestCase):
 475
 476     MAX = GObject.constants.G_MAXULONG
 477
 478     def test_ulong_return(self):
 479         self.assertEquals(self.MAX, GIMarshallingTests.ulong_return())
 480
 481     def test_ulong_in(self):
 482         number = Number(self.MAX)
 483
 484         GIMarshallingTests.ulong_in(number)
 485
 486         number.value += 1
 487
 488         self.assertRaises(ValueError, GIMarshallingTests.ulong_in, number)
 489         self.assertRaises(ValueError, GIMarshallingTests.ulong_in, Number(-1))
 490
 491         self.assertRaises(TypeError, GIMarshallingTests.ulong_in, "self.MAX")
 492
 493     def test_ulong_out(self):
 494         self.assertEquals(self.MAX, GIMarshallingTests.ulong_out())
 495
 496     def test_ulong_inout(self):
 497         self.assertEquals(0, GIMarshallingTests.ulong_inout(Number(self.MAX)))
 498
 499
 500 class TestSSize(unittest.TestCase):
 501
 502     MAX = GObject.constants.G_MAXLONG
 503     MIN = GObject.constants.G_MINLONG
 504
 505     def test_ssize_return(self):
 506         self.assertEquals(self.MAX, GIMarshallingTests.ssize_return_max())
 507         self.assertEquals(self.MIN, GIMarshallingTests.ssize_return_min())
 508
 509     def test_ssize_in(self):
 510         max = Number(self.MAX)
 511         min = Number(self.MIN)
 512
 513         GIMarshallingTests.ssize_in_max(max)
 514         GIMarshallingTests.ssize_in_min(min)
 515
 516         max.value += 1
 517         min.value -= 1
 518
 519         self.assertRaises(ValueError, GIMarshallingTests.ssize_in_max, max)
 520         self.assertRaises(ValueError, GIMarshallingTests.ssize_in_min, min)
 521
 522         self.assertRaises(TypeError, GIMarshallingTests.ssize_in_max, "self.MAX")
 523
 524     def test_ssize_out(self):
 525         self.assertEquals(self.MAX, GIMarshallingTests.ssize_out_max())
 526         self.assertEquals(self.MIN, GIMarshallingTests.ssize_out_min())
 527
 528     def test_ssize_inout(self):
 529         self.assertEquals(self.MIN, GIMarshallingTests.ssize_inout_max_min(Number(self.MAX)))
 530         self.assertEquals(self.MAX, GIMarshallingTests.ssize_inout_min_max(Number(self.MIN)))
 531
 532
 533 class TestSize(unittest.TestCase):
 534
 535     MAX = GObject.constants.G_MAXULONG
 536
 537     def test_size_return(self):
 538         self.assertEquals(self.MAX, GIMarshallingTests.size_return())
 539
 540     def test_size_in(self):
 541         number = Number(self.MAX)
 542
 543         GIMarshallingTests.size_in(number)
 544
 545         number.value += 1
 546
 547         self.assertRaises(ValueError, GIMarshallingTests.size_in, number)
 548         self.assertRaises(ValueError, GIMarshallingTests.size_in, Number(-1))
 549
 550         self.assertRaises(TypeError, GIMarshallingTests.size_in, "self.MAX")
 551
 552     def test_size_out(self):
 553         self.assertEquals(self.MAX, GIMarshallingTests.size_out())
 554
 555     def test_size_inout(self):
 556         self.assertEquals(0, GIMarshallingTests.size_inout(Number(self.MAX)))
 557
 558
 559 class TestFloat(unittest.TestCase):
 560
 561     MAX = GObject.constants.G_MAXFLOAT
 562     MIN = GObject.constants.G_MINFLOAT
 563
 564     def test_float_return(self):
 565         self.assertAlmostEquals(self.MAX, GIMarshallingTests.float_return())
 566
 567     def test_float_in(self):
 568         GIMarshallingTests.float_in(Number(self.MAX))
 569
 570         self.assertRaises(TypeError, GIMarshallingTests.float_in, "self.MAX")
 571
 572     def test_float_out(self):
 573         self.assertAlmostEquals(self.MAX, GIMarshallingTests.float_out())
 574
 575     def test_float_inout(self):
 576         self.assertAlmostEquals(self.MIN, GIMarshallingTests.float_inout(Number(self.MAX)))
 577
 578
 579 class TestDouble(unittest.TestCase):
 580
 581     MAX = GObject.constants.G_MAXDOUBLE
 582     MIN = GObject.constants.G_MINDOUBLE
 583
 584     def test_double_return(self):
 585         self.assertAlmostEquals(self.MAX, GIMarshallingTests.double_return())
 586
 587     def test_double_in(self):
 588         GIMarshallingTests.double_in(Number(self.MAX))
 589
 590         self.assertRaises(TypeError, GIMarshallingTests.double_in, "self.MAX")
 591
 592     def test_double_out(self):
 593         self.assertAlmostEquals(self.MAX, GIMarshallingTests.double_out())
 594
 595     def test_double_inout(self):
 596         self.assertAlmostEquals(self.MIN, GIMarshallingTests.double_inout(Number(self.MAX)))
 597
 598
 599 class TestGType(unittest.TestCase):
 600
 601     def test_gtype_name(self):
 602         self.assertEquals("void", GObject.TYPE_NONE.name)
 603         self.assertEquals("gchararray", GObject.TYPE_STRING.name)
 604
 605         def check_readonly(gtype):
 606             gtype.name = "foo"
 607
 608         self.assertRaises(AttributeError, check_readonly, GObject.TYPE_NONE)
 609         self.assertRaises(AttributeError, check_readonly, GObject.TYPE_STRING)
 610
 611     def test_gtype_return(self):
 612         self.assertEquals(GObject.TYPE_NONE, GIMarshallingTests.gtype_return())
 613         self.assertEquals(GObject.TYPE_STRING, GIMarshallingTests.gtype_string_return())
 614
 615     def test_gtype_in(self):
 616         GIMarshallingTests.gtype_in(GObject.TYPE_NONE)
 617         GIMarshallingTests.gtype_string_in(GObject.TYPE_STRING)
 618         self.assertRaises(TypeError, GIMarshallingTests.gtype_in, "foo")
 619         self.assertRaises(TypeError, GIMarshallingTests.gtype_string_in, "foo")
 620
 621     def test_gtype_out(self):
 622         self.assertEquals(GObject.TYPE_NONE, GIMarshallingTests.gtype_out())
 623         self.assertEquals(GObject.TYPE_STRING, GIMarshallingTests.gtype_string_out())
 624
 625     def test_gtype_inout(self):
 626         self.assertEquals(GObject.TYPE_INT, GIMarshallingTests.gtype_inout(GObject.TYPE_NONE))
 627
 628
 629 class TestUtf8(unittest.TestCase):
 630
 631     def test_utf8_none_return(self):
 632         self.assertEquals(CONSTANT_UTF8, GIMarshallingTests.utf8_none_return())
 633
 634     def test_utf8_full_return(self):
 635         self.assertEquals(CONSTANT_UTF8, GIMarshallingTests.utf8_full_return())
 636
 637     def test_utf8_none_in(self):
 638         GIMarshallingTests.utf8_none_in(CONSTANT_UTF8)
 639         if sys.version_info < (3, 0):
 640             GIMarshallingTests.utf8_none_in(PY2_UNICODE_UTF8)
 641
 642         self.assertRaises(TypeError, GIMarshallingTests.utf8_none_in, CONSTANT_NUMBER)
 643         self.assertRaises(TypeError, GIMarshallingTests.utf8_none_in, None)
 644
 645     def test_utf8_none_out(self):
 646         self.assertEquals(CONSTANT_UTF8, GIMarshallingTests.utf8_none_out())
 647
 648     def test_utf8_full_out(self):
 649         self.assertEquals(CONSTANT_UTF8, GIMarshallingTests.utf8_full_out())
 650
 651     def test_utf8_dangling_out(self):
 652         GIMarshallingTests.utf8_dangling_out()
 653
 654     def test_utf8_none_inout(self):
 655         self.assertEquals("", GIMarshallingTests.utf8_none_inout(CONSTANT_UTF8))
 656
 657     def test_utf8_full_inout(self):
 658         self.assertEquals("", GIMarshallingTests.utf8_full_inout(CONSTANT_UTF8))
 659
 660
 661 class TestArray(unittest.TestCase):
 662
 663     def test_array_fixed_int_return(self):
 664         self.assertEquals([-1, 0, 1, 2], GIMarshallingTests.array_fixed_int_return())
 665
 666     def test_array_fixed_short_return(self):
 667         self.assertEquals([-1, 0, 1, 2], GIMarshallingTests.array_fixed_short_return())
 668
 669     def test_array_fixed_int_in(self):
 670         GIMarshallingTests.array_fixed_int_in(Sequence([-1, 0, 1, 2]))
 671
 672         self.assertRaises(TypeError, GIMarshallingTests.array_fixed_int_in, Sequence([-1, '0', 1, 2]))
 673
 674         self.assertRaises(TypeError, GIMarshallingTests.array_fixed_int_in, 42)
 675         self.assertRaises(TypeError, GIMarshallingTests.array_fixed_int_in, None)
 676
 677     def test_array_fixed_short_in(self):
 678         GIMarshallingTests.array_fixed_short_in(Sequence([-1, 0, 1, 2]))
 679
 680     def test_array_fixed_out(self):
 681         self.assertEquals([-1, 0, 1, 2], GIMarshallingTests.array_fixed_out())
 682
 683     def test_array_fixed_inout(self):
 684         self.assertEquals([2, 1, 0, -1], GIMarshallingTests.array_fixed_inout([-1, 0, 1, 2]))
 685
 686     def test_array_return(self):
 687         self.assertEquals([-1, 0, 1, 2], GIMarshallingTests.array_return())
 688
 689     def test_array_in(self):
 690         GIMarshallingTests.array_in(Sequence([-1, 0, 1, 2]))
 691
 692     def test_array_uint8_in(self):
 693         GIMarshallingTests.array_uint8_in(Sequence([97, 98, 99, 100]))
 694         GIMarshallingTests.array_uint8_in(_bytes("abcd"))
 695
 696     def test_array_out(self):
 697         self.assertEquals([-1, 0, 1, 2], GIMarshallingTests.array_out())
 698
 699     def test_array_inout(self):
 700         self.assertEquals([-2, -1, 0, 1, 2], GIMarshallingTests.array_inout(Sequence([-1, 0, 1, 2])))
 701
 702     def test_method_array_in(self):
 703         object_ = GIMarshallingTests.Object()
 704         object_.method_array_in(Sequence([-1, 0, 1, 2]))
 705
 706     def test_method_array_out(self):
 707         object_ = GIMarshallingTests.Object()
 708         self.assertEquals([-1, 0, 1, 2], object_.method_array_out())
 709
 710     def test_method_array_inout(self):
 711         object_ = GIMarshallingTests.Object()
 712         self.assertEquals([-2, -1, 0, 1, 2], object_.method_array_inout(Sequence([-1, 0, 1, 2])))
 713
 714     def test_method_array_return(self):
 715         object_ = GIMarshallingTests.Object()
 716         self.assertEquals([-1, 0, 1, 2], object_.method_array_return())
 717
 718     def test_array_enum_in(self):
 719          GIMarshallingTests.array_enum_in([GIMarshallingTests.Enum.VALUE1,
 720                                            GIMarshallingTests.Enum.VALUE2,
 721                                            GIMarshallingTests.Enum.VALUE3])
 722
 723     def test_array_boxed_struct_in(self):
 724          struct1 = GIMarshallingTests.BoxedStruct()
 725          struct1.long_ = 1
 726          struct2 = GIMarshallingTests.BoxedStruct()
 727          struct2.long_ = 2
 728          struct3 = GIMarshallingTests.BoxedStruct()
 729          struct3.long_ = 3
 730
 731          GIMarshallingTests.array_struct_in([struct1, struct2, struct3])
 732
 733     def test_array_simple_struct_in(self):
 734          struct1 = GIMarshallingTests.SimpleStruct()
 735          struct1.long_ = 1
 736          struct2 = GIMarshallingTests.SimpleStruct()
 737          struct2.long_ = 2
 738          struct3 = GIMarshallingTests.SimpleStruct()
 739          struct3.long_ = 3
 740
 741          GIMarshallingTests.array_simple_struct_in([struct1, struct2, struct3])
 742
 743     def test_array_multi_array_key_value_in(self):
 744          GIMarshallingTests.multi_array_key_value_in(["one", "two", "three"],
 745                                                      [1, 2, 3])
 746
 747     def test_array_fixed_out_struct(self):
 748         struct1, struct2 = GIMarshallingTests.array_fixed_out_struct()
 749
 750         self.assertEquals(7, struct1.long_)
 751         self.assertEquals(6, struct1.int8)
 752         self.assertEquals(6, struct2.long_)
 753         self.assertEquals(7, struct2.int8)
 754
 755     def test_array_zero_terminated_return(self):
 756         self.assertEquals(['0', '1', '2'], GIMarshallingTests.array_zero_terminated_return())
 757
 758     def test_array_zero_terminated_return_null(self):
 759         self.assertEquals([], GIMarshallingTests.array_zero_terminated_return_null())
 760
 761     def test_array_zero_terminated_in(self):
 762         GIMarshallingTests.array_zero_terminated_in(Sequence(['0', '1', '2']))
 763
 764     def test_array_zero_terminated_out(self):
 765         self.assertEquals(['0', '1', '2'], GIMarshallingTests.array_zero_terminated_out())
 766
 767     def test_array_zero_terminated_out(self):
 768         self.assertEquals(['0', '1', '2'], GIMarshallingTests.array_zero_terminated_out())
 769
 770     def test_array_zero_terminated_inout(self):
 771         self.assertEquals(['-1', '0', '1', '2'], GIMarshallingTests.array_zero_terminated_inout(['0', '1', '2']))
 772
 773
 774 class TestGStrv(unittest.TestCase):
 775
 776     def test_gstrv_return(self):
 777         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gstrv_return())
 778
 779     def test_gstrv_in(self):
 780         GIMarshallingTests.gstrv_in(Sequence(['0', '1', '2']))
 781
 782     def test_gstrv_out(self):
 783         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gstrv_out())
 784
 785     def test_gstrv_out(self):
 786         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gstrv_out())
 787
 788     def test_gstrv_inout(self):
 789         self.assertEquals(['-1', '0', '1', '2'], GIMarshallingTests.gstrv_inout(['0', '1', '2']))
 790
 791
 792 class TestArrayGVariant(unittest.TestCase):
 793
 794     def test_array_gvariant_none_in(self):
 795         v = [GLib.Variant("i", 27), GLib.Variant("s", "Hello")]
 796         returned = [GLib.Variant.unpack(r) for r in GIMarshallingTests.array_gvariant_none_in(v)]
 797         self.assertEquals([27, "Hello"], returned)
 798
 799     def test_array_gvariant_container_in(self):
 800         v = [GLib.Variant("i", 27), GLib.Variant("s", "Hello")]
 801         returned = [GLib.Variant.unpack(r) for r in GIMarshallingTests.array_gvariant_none_in(v)]
 802         self.assertEquals([27, "Hello"], returned)
 803
 804     def test_array_gvariant_full_in(self):
 805         v = [GLib.Variant("i", 27), GLib.Variant("s", "Hello")]
 806         returned = [GLib.Variant.unpack(r) for r in GIMarshallingTests.array_gvariant_none_in(v)]
 807         self.assertEquals([27, "Hello"], returned)
 808
 809     def test_bytearray_gvariant(self):
 810         v = GLib.Variant.new_bytestring(b"foo")
 811         self.assertEquals(v.get_bytestring(), b"foo")
 812
 813
 814 class TestGArray(unittest.TestCase):
 815
 816     def test_garray_int_none_return(self):
 817         self.assertEquals([-1, 0, 1, 2], GIMarshallingTests.garray_int_none_return())
 818
 819     def test_garray_utf8_none_return(self):
 820         self.assertEquals(['0', '1', '2'], GIMarshallingTests.garray_utf8_none_return())
 821
 822     def test_garray_utf8_container_return(self):
 823         self.assertEquals(['0', '1', '2'], GIMarshallingTests.garray_utf8_container_return())
 824
 825     def test_garray_utf8_full_return(self):
 826         self.assertEquals(['0', '1', '2'], GIMarshallingTests.garray_utf8_full_return())
 827
 828     def test_garray_int_none_in(self):
 829         GIMarshallingTests.garray_int_none_in(Sequence([-1, 0, 1, 2]))
 830
 831         self.assertRaises(TypeError, GIMarshallingTests.garray_int_none_in, Sequence([-1, '0', 1, 2]))
 832
 833         self.assertRaises(TypeError, GIMarshallingTests.garray_int_none_in, 42)
 834         self.assertRaises(TypeError, GIMarshallingTests.garray_int_none_in, None)
 835
 836     def test_garray_utf8_none_in(self):
 837         GIMarshallingTests.garray_utf8_none_in(Sequence(['0', '1', '2']))
 838
 839     def test_garray_utf8_none_out(self):
 840         self.assertEquals(['0', '1', '2'], GIMarshallingTests.garray_utf8_none_out())
 841
 842     def test_garray_utf8_container_out(self):
 843         self.assertEquals(['0', '1', '2'], GIMarshallingTests.garray_utf8_container_out())
 844
 845     def test_garray_utf8_full_out(self):
 846         self.assertEquals(['0', '1', '2'], GIMarshallingTests.garray_utf8_full_out())
 847
 848     def test_garray_utf8_none_inout(self):
 849         self.assertEquals(['-2', '-1', '0', '1'], GIMarshallingTests.garray_utf8_none_inout(Sequence(('0', '1', '2'))))
 850
 851     def test_garray_utf8_container_inout(self):
 852         self.assertEquals(['-2', '-1','0', '1'], GIMarshallingTests.garray_utf8_container_inout(['0', '1', '2']))
 853
 854     def test_garray_utf8_full_inout(self):
 855         self.assertEquals(['-2', '-1','0', '1'], GIMarshallingTests.garray_utf8_full_inout(['0', '1', '2']))
 856
 857
 858 class TestGPtrArray(unittest.TestCase):
 859
 860     def test_gptrarray_utf8_none_return(self):
 861         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gptrarray_utf8_none_return())
 862
 863     def test_gptrarray_utf8_container_return(self):
 864         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gptrarray_utf8_container_return())
 865
 866     def test_gptrarray_utf8_full_return(self):
 867         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gptrarray_utf8_full_return())
 868
 869     def test_gptrarray_utf8_none_in(self):
 870         GIMarshallingTests.gptrarray_utf8_none_in(Sequence(['0', '1', '2']))
 871
 872     def test_gptrarray_utf8_none_out(self):
 873         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gptrarray_utf8_none_out())
 874
 875     def test_gptrarray_utf8_container_out(self):
 876         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gptrarray_utf8_container_out())
 877
 878     def test_gptrarray_utf8_full_out(self):
 879         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gptrarray_utf8_full_out())
 880
 881     def test_gptrarray_utf8_none_inout(self):
 882         self.assertEquals(['-2', '-1', '0', '1'], GIMarshallingTests.gptrarray_utf8_none_inout(Sequence(('0', '1', '2'))))
 883
 884     def test_gptrarray_utf8_container_inout(self):
 885         self.assertEquals(['-2', '-1','0', '1'], GIMarshallingTests.gptrarray_utf8_container_inout(['0', '1', '2']))
 886
 887     def test_gptrarray_utf8_full_inout(self):
 888         self.assertEquals(['-2', '-1','0', '1'], GIMarshallingTests.gptrarray_utf8_full_inout(['0', '1', '2']))
 889
 890
 891 class TestGList(unittest.TestCase):
 892
 893     def test_glist_int_none_return(self):
 894         self.assertEquals([-1, 0, 1, 2], GIMarshallingTests.glist_int_none_return())
 895
 896     def test_glist_utf8_none_return(self):
 897         self.assertEquals(['0', '1', '2'], GIMarshallingTests.glist_utf8_none_return())
 898
 899     def test_glist_utf8_container_return(self):
 900         self.assertEquals(['0', '1', '2'], GIMarshallingTests.glist_utf8_container_return())
 901
 902     def test_glist_utf8_full_return(self):
 903         self.assertEquals(['0', '1', '2'], GIMarshallingTests.glist_utf8_full_return())
 904
 905     def test_glist_int_none_in(self):
 906         GIMarshallingTests.glist_int_none_in(Sequence((-1, 0, 1, 2)))
 907
 908         self.assertRaises(TypeError, GIMarshallingTests.glist_int_none_in, Sequence((-1, '0', 1, 2)))
 909
 910         self.assertRaises(TypeError, GIMarshallingTests.glist_int_none_in, 42)
 911         self.assertRaises(TypeError, GIMarshallingTests.glist_int_none_in, None)
 912
 913     def test_glist_utf8_none_in(self):
 914         GIMarshallingTests.glist_utf8_none_in(Sequence(('0', '1', '2')))
 915
 916     def test_glist_utf8_none_out(self):
 917         self.assertEquals(['0', '1', '2'], GIMarshallingTests.glist_utf8_none_out())
 918
 919     def test_glist_utf8_container_out(self):
 920         self.assertEquals(['0', '1', '2'], GIMarshallingTests.glist_utf8_container_out())
 921
 922     def test_glist_utf8_full_out(self):
 923         self.assertEquals(['0', '1', '2'], GIMarshallingTests.glist_utf8_full_out())
 924
 925     def test_glist_utf8_none_inout(self):
 926         self.assertEquals(['-2', '-1', '0', '1'], GIMarshallingTests.glist_utf8_none_inout(Sequence(('0', '1', '2'))))
 927
 928     def test_glist_utf8_container_inout(self):
 929         self.assertEquals(['-2', '-1','0', '1'], GIMarshallingTests.glist_utf8_container_inout(('0', '1', '2')))
 930
 931     def test_glist_utf8_full_inout(self):
 932         self.assertEquals(['-2', '-1','0', '1'], GIMarshallingTests.glist_utf8_full_inout(('0', '1', '2')))
 933
 934
 935 class TestGSList(unittest.TestCase):
 936
 937     def test_gslist_int_none_return(self):
 938         self.assertEquals([-1, 0, 1, 2], GIMarshallingTests.gslist_int_none_return())
 939
 940     def test_gslist_utf8_none_return(self):
 941         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gslist_utf8_none_return())
 942
 943     def test_gslist_utf8_container_return(self):
 944         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gslist_utf8_container_return())
 945
 946     def test_gslist_utf8_full_return(self):
 947         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gslist_utf8_full_return())
 948
 949     def test_gslist_int_none_in(self):
 950         GIMarshallingTests.gslist_int_none_in(Sequence((-1, 0, 1, 2)))
 951
 952         self.assertRaises(TypeError, GIMarshallingTests.gslist_int_none_in, Sequence((-1, '0', 1, 2)))
 953
 954         self.assertRaises(TypeError, GIMarshallingTests.gslist_int_none_in, 42)
 955         self.assertRaises(TypeError, GIMarshallingTests.gslist_int_none_in, None)
 956
 957     def test_gslist_utf8_none_in(self):
 958         GIMarshallingTests.gslist_utf8_none_in(Sequence(('0', '1', '2')))
 959
 960     def test_gslist_utf8_none_out(self):
 961         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gslist_utf8_none_out())
 962
 963     def test_gslist_utf8_container_out(self):
 964         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gslist_utf8_container_out())
 965
 966     def test_gslist_utf8_full_out(self):
 967         self.assertEquals(['0', '1', '2'], GIMarshallingTests.gslist_utf8_full_out())
 968
 969     def test_gslist_utf8_none_inout(self):
 970         self.assertEquals(['-2', '-1', '0', '1'], GIMarshallingTests.gslist_utf8_none_inout(Sequence(('0', '1', '2'))))
 971
 972     def test_gslist_utf8_container_inout(self):
 973         self.assertEquals(['-2', '-1','0', '1'], GIMarshallingTests.gslist_utf8_container_inout(('0', '1', '2')))
 974
 975     def test_gslist_utf8_full_inout(self):
 976         self.assertEquals(['-2', '-1','0', '1'], GIMarshallingTests.gslist_utf8_full_inout(('0', '1', '2')))
 977
 978
 979 class TestGHashTable(unittest.TestCase):
 980
 981     def test_ghashtable_int_none_return(self):
 982         self.assertEquals({-1: 1, 0: 0, 1: -1, 2: -2}, GIMarshallingTests.ghashtable_int_none_return())
 983
 984     def test_ghashtable_int_none_return(self):
 985         self.assertEquals({'-1': '1', '0': '0', '1': '-1', '2': '-2'}, GIMarshallingTests.ghashtable_utf8_none_return())
 986
 987     def test_ghashtable_int_container_return(self):
 988         self.assertEquals({'-1': '1', '0': '0', '1': '-1', '2': '-2'}, GIMarshallingTests.ghashtable_utf8_container_return())
 989
 990     def test_ghashtable_int_full_return(self):
 991         self.assertEquals({'-1': '1', '0': '0', '1': '-1', '2': '-2'}, GIMarshallingTests.ghashtable_utf8_full_return())
 992
 993     def test_ghashtable_int_none_in(self):
 994         GIMarshallingTests.ghashtable_int_none_in({-1: 1, 0: 0, 1: -1, 2: -2})
 995
 996         self.assertRaises(TypeError, GIMarshallingTests.ghashtable_int_none_in, {-1: 1, '0': 0, 1: -1, 2: -2})
 997         self.assertRaises(TypeError, GIMarshallingTests.ghashtable_int_none_in, {-1: 1, 0: '0', 1: -1, 2: -2})
 998
 999         self.assertRaises(TypeError, GIMarshallingTests.ghashtable_int_none_in, '{-1: 1, 0: 0, 1: -1, 2: -2}')
1000         self.assertRaises(TypeError, GIMarshallingTests.ghashtable_int_none_in, None)
1001
1002     def test_ghashtable_utf8_none_in(self):
1003         GIMarshallingTests.ghashtable_utf8_none_in({'-1': '1', '0': '0', '1': '-1', '2': '-2'})
1004
1005     def test_ghashtable_utf8_none_out(self):
1006         self.assertEquals({'-1': '1', '0': '0', '1': '-1', '2': '-2'}, GIMarshallingTests.ghashtable_utf8_none_out())
1007
1008     def test_ghashtable_utf8_container_out(self):
1009         self.assertEquals({'-1': '1', '0': '0', '1': '-1', '2': '-2'}, GIMarshallingTests.ghashtable_utf8_container_out())
1010
1011     def test_ghashtable_utf8_full_out(self):
1012         self.assertEquals({'-1': '1', '0': '0', '1': '-1', '2': '-2'}, GIMarshallingTests.ghashtable_utf8_full_out())
1013
1014     def test_ghashtable_utf8_none_inout(self):
1015         self.assertEquals({'-1': '1', '0': '0', '1': '1'},
1016             GIMarshallingTests.ghashtable_utf8_none_inout({'-1': '1', '0': '0', '1': '-1', '2': '-2'}))
1017
1018     def test_ghashtable_utf8_container_inout(self):
1019         self.assertEquals({'-1': '1', '0': '0', '1': '1'},
1020             GIMarshallingTests.ghashtable_utf8_container_inout({'-1': '1', '0': '0', '1': '-1', '2': '-2'}))
1021
1022     def test_ghashtable_utf8_full_inout(self):
1023         self.assertEquals({'-1': '1', '0': '0', '1': '1'},
1024             GIMarshallingTests.ghashtable_utf8_full_inout({'-1': '1', '0': '0', '1': '-1', '2': '-2'}))
1025
1026
1027 class TestGValue(unittest.TestCase):
1028
1029     def test_gvalue_return(self):
1030         self.assertEquals(42, GIMarshallingTests.gvalue_return())
1031
1032     def test_gvalue_in(self):
1033         GIMarshallingTests.gvalue_in(42)
1034         value = GObject.Value()
1035         value.init(GObject.TYPE_INT)
1036         value.set_int(42)
1037         GIMarshallingTests.gvalue_in(value)
1038
1039     def test_gvalue_out(self):
1040         self.assertEquals(42, GIMarshallingTests.gvalue_out())
1041
1042     def test_gvalue_inout(self):
1043         self.assertEquals('42', GIMarshallingTests.gvalue_inout(42))
1044         value = GObject.Value()
1045         value.init(GObject.TYPE_INT)
1046         value.set_int(42)
1047         self.assertEquals('42', GIMarshallingTests.gvalue_inout(value))
1048
1049     def test_gvalue_flat_array_in(self):
1050         # the function already asserts the correct values
1051         GIMarshallingTests.gvalue_flat_array([42, "42", True])
1052
1053     def test_gvalue_flat_array_out(self):
1054         values = GIMarshallingTests.return_gvalue_flat_array()
1055         self.assertEqual(values, [42, '42', True])
1056
1057
1058 class TestGClosure(unittest.TestCase):
1059
1060     def test_gclosure_in(self):
1061         GIMarshallingTests.gclosure_in(lambda: 42)
1062
1063         # test passing a closure between two C calls
1064         closure = GIMarshallingTests.gclosure_return()
1065         GIMarshallingTests.gclosure_in(closure)
1066
1067         self.assertRaises(TypeError, GIMarshallingTests.gclosure_in, 42)
1068         self.assertRaises(TypeError, GIMarshallingTests.gclosure_in, None)
1069
1070
1071 class TestPointer(unittest.TestCase):
1072     def test_pointer_in_return(self):
1073         self.assertEquals(GIMarshallingTests.pointer_in_return(42), 42)
1074
1075
1076 class TestEnum(unittest.TestCase):
1077
1078     @classmethod
1079     def setUpClass(cls):
1080         '''Run tests under a test locale.
1081
1082         Upper case conversion of member names should not be locale specific;
1083         e.  g. in Turkish, "i".upper() == "i", which gives results like "iNVALiD"
1084
1085         Run test under a locale which defines toupper('a') == 'a'
1086         '''
1087         cls.locale_dir = tempfile.mkdtemp()
1088         subprocess.check_call(['localedef', '-i',
1089             os.path.join(os.path.dirname(os.path.realpath(__file__)), 'te_ST@nouppera'),
1090             '-c', '-f', 'UTF-8', os.path.join(cls.locale_dir, 'te_ST.UTF-8@nouppera')])
1091         os.environ['LOCPATH'] = cls.locale_dir
1092         locale.setlocale(locale.LC_ALL, 'te_ST.UTF-8@nouppera')
1093
1094     @classmethod
1095     def tearDownClass(cls):
1096         locale.setlocale(locale.LC_ALL, 'C')
1097         shutil.rmtree(cls.locale_dir)
1098         try:
1099             del os.environ['LOCPATH']
1100         except KeyError:
1101             pass
1102
1103     def test_enum(self):
1104         self.assertTrue(issubclass(GIMarshallingTests.Enum, int))
1105         self.assertTrue(isinstance(GIMarshallingTests.Enum.VALUE1, GIMarshallingTests.Enum))
1106         self.assertTrue(isinstance(GIMarshallingTests.Enum.VALUE2, GIMarshallingTests.Enum))
1107         self.assertTrue(isinstance(GIMarshallingTests.Enum.VALUE3, GIMarshallingTests.Enum))
1108         self.assertEquals(42, GIMarshallingTests.Enum.VALUE3)
1109
1110     def test_value_nick_and_name(self):
1111         self.assertEqual(GIMarshallingTests.Enum.VALUE1.value_nick, 'value1')
1112         self.assertEqual(GIMarshallingTests.Enum.VALUE2.value_nick, 'value2')
1113         self.assertEqual(GIMarshallingTests.Enum.VALUE3.value_nick, 'value3')
1114
1115         self.assertEqual(GIMarshallingTests.Enum.VALUE1.value_name, 'GI_MARSHALLING_TESTS_ENUM_VALUE1')
1116         self.assertEqual(GIMarshallingTests.Enum.VALUE2.value_name, 'GI_MARSHALLING_TESTS_ENUM_VALUE2')
1117         self.assertEqual(GIMarshallingTests.Enum.VALUE3.value_name, 'GI_MARSHALLING_TESTS_ENUM_VALUE3')
1118
1119     def test_enum_in(self):
1120         GIMarshallingTests.enum_in(GIMarshallingTests.Enum.VALUE3)
1121         GIMarshallingTests.enum_in(42)
1122
1123         self.assertRaises(TypeError, GIMarshallingTests.enum_in, 43)
1124         self.assertRaises(TypeError, GIMarshallingTests.enum_in, 'GIMarshallingTests.Enum.VALUE3')
1125
1126     def test_enum_out(self):
1127         enum = GIMarshallingTests.enum_out()
1128         self.assertTrue(isinstance(enum, GIMarshallingTests.Enum))
1129         self.assertEquals(enum, GIMarshallingTests.Enum.VALUE3)
1130
1131     def test_enum_inout(self):
1132         enum = GIMarshallingTests.enum_inout(GIMarshallingTests.Enum.VALUE3)
1133         self.assertTrue(isinstance(enum, GIMarshallingTests.Enum))
1134         self.assertEquals(enum, GIMarshallingTests.Enum.VALUE1)
1135
1136     def test_enum_second(self):
1137         # check for the bug where different non-gtype enums share the same class
1138         self.assertNotEqual(GIMarshallingTests.Enum, GIMarshallingTests.SecondEnum)
1139
1140         # check that values are not being shared between different enums
1141         self.assertTrue(hasattr(GIMarshallingTests.SecondEnum, "SECONDVALUE1"))
1142         self.assertRaises(AttributeError, getattr, GIMarshallingTests.Enum, "SECONDVALUE1")
1143         self.assertTrue(hasattr(GIMarshallingTests.Enum, "VALUE1"))
1144         self.assertRaises(AttributeError, getattr, GIMarshallingTests.SecondEnum, "VALUE1")
1145
1146
1147 class TestGEnum(unittest.TestCase):
1148
1149     def test_genum(self):
1150         self.assertTrue(issubclass(GIMarshallingTests.GEnum, GObject.GEnum))
1151         self.assertTrue(isinstance(GIMarshallingTests.GEnum.VALUE1, GIMarshallingTests.GEnum))
1152         self.assertTrue(isinstance(GIMarshallingTests.GEnum.VALUE2, GIMarshallingTests.GEnum))
1153         self.assertTrue(isinstance(GIMarshallingTests.GEnum.VALUE3, GIMarshallingTests.GEnum))
1154         self.assertEquals(42, GIMarshallingTests.GEnum.VALUE3)
1155
1156     def test_value_nick_and_name(self):
1157         self.assertEqual(GIMarshallingTests.GEnum.VALUE1.value_nick, 'value1')
1158         self.assertEqual(GIMarshallingTests.GEnum.VALUE2.value_nick, 'value2')
1159         self.assertEqual(GIMarshallingTests.GEnum.VALUE3.value_nick, 'value3')
1160
1161         self.assertEqual(GIMarshallingTests.GEnum.VALUE1.value_name, 'GI_MARSHALLING_TESTS_GENUM_VALUE1')
1162         self.assertEqual(GIMarshallingTests.GEnum.VALUE2.value_name, 'GI_MARSHALLING_TESTS_GENUM_VALUE2')
1163         self.assertEqual(GIMarshallingTests.GEnum.VALUE3.value_name, 'GI_MARSHALLING_TESTS_GENUM_VALUE3')
1164
1165     def test_genum_in(self):
1166         GIMarshallingTests.genum_in(GIMarshallingTests.GEnum.VALUE3)
1167         GIMarshallingTests.genum_in(42)
1168
1169         self.assertRaises(TypeError, GIMarshallingTests.genum_in, 43)
1170         self.assertRaises(TypeError, GIMarshallingTests.genum_in, 'GIMarshallingTests.GEnum.VALUE3')
1171
1172     def test_genum_out(self):
1173         genum = GIMarshallingTests.genum_out()
1174         self.assertTrue(isinstance(genum, GIMarshallingTests.GEnum))
1175         self.assertEquals(genum, GIMarshallingTests.GEnum.VALUE3)
1176
1177     def test_genum_inout(self):
1178         genum = GIMarshallingTests.genum_inout(GIMarshallingTests.GEnum.VALUE3)
1179         self.assertTrue(isinstance(genum, GIMarshallingTests.GEnum))
1180         self.assertEquals(genum, GIMarshallingTests.GEnum.VALUE1)
1181
1182
1183 class TestGFlags(unittest.TestCase):
1184
1185     def test_flags(self):
1186         self.assertTrue(issubclass(GIMarshallingTests.Flags, GObject.GFlags))
1187         self.assertTrue(isinstance(GIMarshallingTests.Flags.VALUE1, GIMarshallingTests.Flags))
1188         self.assertTrue(isinstance(GIMarshallingTests.Flags.VALUE2, GIMarshallingTests.Flags))
1189         self.assertTrue(isinstance(GIMarshallingTests.Flags.VALUE3, GIMarshallingTests.Flags))
1190         # __or__() operation should still return an instance, not an int.
1191         self.assertTrue(isinstance(GIMarshallingTests.Flags.VALUE1 | GIMarshallingTests.Flags.VALUE2,
1192                                    GIMarshallingTests.Flags))
1193         self.assertEquals(1 << 1, GIMarshallingTests.Flags.VALUE2)
1194
1195     def test_value_nick_and_name(self):
1196         self.assertEqual(GIMarshallingTests.Flags.VALUE1.first_value_nick, 'value1')
1197         self.assertEqual(GIMarshallingTests.Flags.VALUE2.first_value_nick, 'value2')
1198         self.assertEqual(GIMarshallingTests.Flags.VALUE3.first_value_nick, 'value3')
1199
1200         self.assertEqual(GIMarshallingTests.Flags.VALUE1.first_value_name, 'GI_MARSHALLING_TESTS_FLAGS_VALUE1')
1201         self.assertEqual(GIMarshallingTests.Flags.VALUE2.first_value_name, 'GI_MARSHALLING_TESTS_FLAGS_VALUE2')
1202         self.assertEqual(GIMarshallingTests.Flags.VALUE3.first_value_name, 'GI_MARSHALLING_TESTS_FLAGS_VALUE3')
1203
1204     def test_flags_in(self):
1205         GIMarshallingTests.flags_in(GIMarshallingTests.Flags.VALUE2)
1206         # result of __or__() operation should still be valid instance, not an int.
1207         GIMarshallingTests.flags_in(GIMarshallingTests.Flags.VALUE2 | GIMarshallingTests.Flags.VALUE2)
1208         GIMarshallingTests.flags_in_zero(Number(0))
1209
1210         self.assertRaises(TypeError, GIMarshallingTests.flags_in, 1 << 1)
1211         self.assertRaises(TypeError, GIMarshallingTests.flags_in, 'GIMarshallingTests.Flags.VALUE2')
1212
1213     def test_flags_out(self):
1214         flags = GIMarshallingTests.flags_out()
1215         self.assertTrue(isinstance(flags, GIMarshallingTests.Flags))
1216         self.assertEquals(flags, GIMarshallingTests.Flags.VALUE2)
1217
1218     def test_flags_inout(self):
1219         flags = GIMarshallingTests.flags_inout(GIMarshallingTests.Flags.VALUE2)
1220         self.assertTrue(isinstance(flags, GIMarshallingTests.Flags))
1221         self.assertEquals(flags, GIMarshallingTests.Flags.VALUE1)
1222
1223
1224 class TestNoTypeFlags(unittest.TestCase):
1225
1226     def test_flags(self):
1227         self.assertTrue(issubclass(GIMarshallingTests.NoTypeFlags, GObject.GFlags))
1228         self.assertTrue(isinstance(GIMarshallingTests.NoTypeFlags.VALUE1, GIMarshallingTests.NoTypeFlags))
1229         self.assertTrue(isinstance(GIMarshallingTests.NoTypeFlags.VALUE2, GIMarshallingTests.NoTypeFlags))
1230         self.assertTrue(isinstance(GIMarshallingTests.NoTypeFlags.VALUE3, GIMarshallingTests.NoTypeFlags))
1231         # __or__() operation should still return an instance, not an int.
1232         self.assertTrue(isinstance(GIMarshallingTests.NoTypeFlags.VALUE1 | GIMarshallingTests.NoTypeFlags.VALUE2,
1233                                    GIMarshallingTests.NoTypeFlags))
1234         self.assertEquals(1 << 1, GIMarshallingTests.NoTypeFlags.VALUE2)
1235
1236     def test_value_nick_and_name(self):
1237         self.assertEqual(GIMarshallingTests.NoTypeFlags.VALUE1.first_value_nick, 'value1')
1238         self.assertEqual(GIMarshallingTests.NoTypeFlags.VALUE2.first_value_nick, 'value2')
1239         self.assertEqual(GIMarshallingTests.NoTypeFlags.VALUE3.first_value_nick, 'value3')
1240
1241         self.assertEqual(GIMarshallingTests.NoTypeFlags.VALUE1.first_value_name, 'GI_MARSHALLING_TESTS_NO_TYPE_FLAGS_VALUE1')
1242         self.assertEqual(GIMarshallingTests.NoTypeFlags.VALUE2.first_value_name, 'GI_MARSHALLING_TESTS_NO_TYPE_FLAGS_VALUE2')
1243         self.assertEqual(GIMarshallingTests.NoTypeFlags.VALUE3.first_value_name, 'GI_MARSHALLING_TESTS_NO_TYPE_FLAGS_VALUE3')
1244
1245     def test_flags_in(self):
1246         GIMarshallingTests.no_type_flags_in(GIMarshallingTests.NoTypeFlags.VALUE2)
1247         GIMarshallingTests.no_type_flags_in(GIMarshallingTests.NoTypeFlags.VALUE2 | GIMarshallingTests.NoTypeFlags.VALUE2)
1248         GIMarshallingTests.no_type_flags_in_zero(Number(0))
1249
1250         self.assertRaises(TypeError, GIMarshallingTests.no_type_flags_in, 1 << 1)
1251         self.assertRaises(TypeError, GIMarshallingTests.no_type_flags_in, 'GIMarshallingTests.NoTypeFlags.VALUE2')
1252
1253     def test_flags_out(self):
1254         flags = GIMarshallingTests.no_type_flags_out()
1255         self.assertTrue(isinstance(flags, GIMarshallingTests.NoTypeFlags))
1256         self.assertEquals(flags, GIMarshallingTests.NoTypeFlags.VALUE2)
1257
1258     def test_flags_inout(self):
1259         flags = GIMarshallingTests.no_type_flags_inout(GIMarshallingTests.NoTypeFlags.VALUE2)
1260         self.assertTrue(isinstance(flags, GIMarshallingTests.NoTypeFlags))
1261         self.assertEquals(flags, GIMarshallingTests.NoTypeFlags.VALUE1)
1262
1263
1264 class TestStructure(unittest.TestCase):
1265
1266     def test_simple_struct(self):
1267         self.assertTrue(issubclass(GIMarshallingTests.SimpleStruct, GObject.GPointer))
1268
1269         struct = GIMarshallingTests.SimpleStruct()
1270         self.assertTrue(isinstance(struct, GIMarshallingTests.SimpleStruct))
1271
1272         self.assertEquals(0, struct.long_)
1273         self.assertEquals(0, struct.int8)
1274
1275         struct.long_ = 6
1276         struct.int8 = 7
1277
1278         self.assertEquals(6, struct.long_)
1279         self.assertEquals(7, struct.int8)
1280
1281         del struct
1282
1283     def test_nested_struct(self):
1284         struct = GIMarshallingTests.NestedStruct()
1285
1286         self.assertTrue(isinstance(struct.simple_struct, GIMarshallingTests.SimpleStruct))
1287
1288         struct.simple_struct.long_ = 42
1289         self.assertEquals(42, struct.simple_struct.long_)
1290
1291         del struct
1292
1293     def test_not_simple_struct(self):
1294         struct = GIMarshallingTests.NotSimpleStruct()
1295         self.assertEquals(None, struct.pointer)
1296
1297     def test_simple_struct_return(self):
1298         struct = GIMarshallingTests.simple_struct_returnv()
1299
1300         self.assertTrue(isinstance(struct, GIMarshallingTests.SimpleStruct))
1301         self.assertEquals(6, struct.long_)
1302         self.assertEquals(7, struct.int8)
1303
1304         del struct
1305
1306     def test_simple_struct_in(self):
1307         struct = GIMarshallingTests.SimpleStruct()
1308         struct.long_ = 6
1309         struct.int8 = 7
1310
1311         GIMarshallingTests.SimpleStruct.inv(struct)
1312
1313         del struct
1314
1315         struct = GIMarshallingTests.NestedStruct()
1316
1317         self.assertRaises(TypeError, GIMarshallingTests.SimpleStruct.inv, struct)
1318
1319         del struct
1320
1321         self.assertRaises(TypeError, GIMarshallingTests.SimpleStruct.inv, None)
1322
1323     def test_simple_struct_method(self):
1324         struct = GIMarshallingTests.SimpleStruct()
1325         struct.long_ = 6
1326         struct.int8 = 7
1327
1328         struct.method()
1329
1330         del struct
1331
1332         self.assertRaises(TypeError, GIMarshallingTests.SimpleStruct.method)
1333
1334     def test_pointer_struct(self):
1335         self.assertTrue(issubclass(GIMarshallingTests.PointerStruct, GObject.GPointer))
1336
1337         struct = GIMarshallingTests.PointerStruct()
1338         self.assertTrue(isinstance(struct, GIMarshallingTests.PointerStruct))
1339
1340         del struct
1341
1342     def test_pointer_struct_return(self):
1343         struct = GIMarshallingTests.pointer_struct_returnv()
1344
1345         self.assertTrue(isinstance(struct, GIMarshallingTests.PointerStruct))
1346         self.assertEquals(42, struct.long_)
1347
1348         del struct
1349
1350     def test_pointer_struct_in(self):
1351         struct = GIMarshallingTests.PointerStruct()
1352         struct.long_ = 42
1353
1354         struct.inv()
1355
1356         del struct
1357
1358     def test_boxed_struct(self):
1359         self.assertTrue(issubclass(GIMarshallingTests.BoxedStruct, GObject.GBoxed))
1360
1361         struct = GIMarshallingTests.BoxedStruct()
1362         self.assertTrue(isinstance(struct, GIMarshallingTests.BoxedStruct))
1363
1364         self.assertEquals(0, struct.long_)
1365         self.assertEquals([], struct.g_strv)
1366
1367         del struct
1368
1369     def test_boxed_struct_new(self):
1370         struct = GIMarshallingTests.BoxedStruct.new()
1371         self.assertTrue(isinstance(struct, GIMarshallingTests.BoxedStruct))
1372
1373         del struct
1374
1375     def test_boxed_struct_copy(self):
1376         struct = GIMarshallingTests.BoxedStruct()
1377
1378         new_struct = struct.copy()
1379         self.assertTrue(isinstance(new_struct, GIMarshallingTests.BoxedStruct))
1380
1381         del new_struct
1382         del struct
1383
1384     def test_boxed_struct_return(self):
1385         struct = GIMarshallingTests.boxed_struct_returnv()
1386
1387         self.assertTrue(isinstance(struct, GIMarshallingTests.BoxedStruct))
1388         self.assertEquals(42, struct.long_)
1389         self.assertEquals(['0', '1', '2'], struct.g_strv)
1390
1391         del struct
1392
1393     def test_boxed_struct_in(self):
1394         struct = GIMarshallingTests.BoxedStruct()
1395         struct.long_ = 42
1396
1397         struct.inv()
1398
1399         del struct
1400
1401     def test_boxed_struct_out(self):
1402         struct = GIMarshallingTests.boxed_struct_out()
1403
1404         self.assertTrue(isinstance(struct, GIMarshallingTests.BoxedStruct))
1405         self.assertEquals(42, struct.long_)
1406
1407         del struct
1408
1409     def test_boxed_struct_inout(self):
1410         in_struct = GIMarshallingTests.BoxedStruct()
1411         in_struct.long_ = 42
1412
1413         out_struct = GIMarshallingTests.boxed_struct_inout(in_struct)
1414
1415         self.assertTrue(isinstance(out_struct, GIMarshallingTests.BoxedStruct))
1416         self.assertEquals(0, out_struct.long_)
1417
1418         del in_struct
1419         del out_struct
1420
1421     def test_union(self):
1422         union = GIMarshallingTests.Union()
1423
1424         self.assertTrue(isinstance(union, GIMarshallingTests.Union))
1425
1426         new_union = union.copy()
1427         self.assertTrue(isinstance(new_union, GIMarshallingTests.Union))
1428
1429         del union
1430         del new_union
1431
1432     def test_union_return(self):
1433         union = GIMarshallingTests.union_returnv()
1434
1435         self.assertTrue(isinstance(union, GIMarshallingTests.Union))
1436         self.assertEquals(42, union.long_)
1437
1438         del union
1439
1440     def test_union_in(self):
1441         union = GIMarshallingTests.Union()
1442         union.long_ = 42
1443
1444         union.inv()
1445
1446         del union
1447
1448     def test_union_method(self):
1449         union = GIMarshallingTests.Union()
1450         union.long_ = 42
1451
1452         union.method()
1453
1454         del union
1455
1456         self.assertRaises(TypeError, GIMarshallingTests.Union.method)
1457
1458
1459 class TestGObject(unittest.TestCase):
1460
1461     def test_object(self):
1462         self.assertTrue(issubclass(GIMarshallingTests.Object, GObject.GObject))
1463
1464         object_ = GIMarshallingTests.Object()
1465         self.assertTrue(isinstance(object_, GIMarshallingTests.Object))
1466         self.assertEquals(object_.__grefcount__, 1)
1467
1468     def test_object_new(self):
1469         object_ = GIMarshallingTests.Object.new(42)
1470         self.assertTrue(isinstance(object_, GIMarshallingTests.Object))
1471         self.assertEquals(object_.__grefcount__, 1)
1472
1473     def test_object_int(self):
1474         object_ = GIMarshallingTests.Object(int = 42)
1475         self.assertEquals(object_.int_, 42)
1476 # FIXME: Don't work yet.
1477 #        object_.int_ = 0
1478 #        self.assertEquals(object_.int_, 0)
1479
1480     def test_object_static_method(self):
1481         GIMarshallingTests.Object.static_method()
1482
1483     def test_object_method(self):
1484         GIMarshallingTests.Object(int = 42).method()
1485         self.assertRaises(TypeError, GIMarshallingTests.Object.method, GObject.GObject())
1486         self.assertRaises(TypeError, GIMarshallingTests.Object.method)
1487
1488     def test_sub_object(self):
1489         self.assertTrue(issubclass(GIMarshallingTests.SubObject, GIMarshallingTests.Object))
1490
1491         object_ = GIMarshallingTests.SubObject()
1492         self.assertTrue(isinstance(object_, GIMarshallingTests.SubObject))
1493
1494     def test_sub_object_new(self):
1495         self.assertRaises(TypeError, GIMarshallingTests.SubObject.new, 42)
1496
1497     def test_sub_object_static_method(self):
1498         object_ = GIMarshallingTests.SubObject()
1499         object_.static_method()
1500
1501     def test_sub_object_method(self):
1502         object_ = GIMarshallingTests.SubObject(int = 42)
1503         object_.method()
1504
1505     def test_sub_object_sub_method(self):
1506         object_ = GIMarshallingTests.SubObject()
1507         object_.sub_method()
1508
1509     def test_sub_object_overwritten_method(self):
1510         object_ = GIMarshallingTests.SubObject()
1511         object_.overwritten_method()
1512
1513         self.assertRaises(TypeError, GIMarshallingTests.SubObject.overwritten_method, GIMarshallingTests.Object())
1514
1515     def test_sub_object_int(self):
1516         object_ = GIMarshallingTests.SubObject()
1517         self.assertEquals(object_.int_, 0)
1518 # FIXME: Don't work yet.
1519 #        object_.int_ = 42
1520 #        self.assertEquals(object_.int_, 42)
1521
1522     def test_object_none_return(self):
1523         object_ = GIMarshallingTests.Object.none_return()
1524         self.assertTrue(isinstance(object_, GIMarshallingTests.Object))
1525         self.assertEquals(object_.__grefcount__, 2)
1526
1527     def test_object_full_return(self):
1528         object_ = GIMarshallingTests.Object.full_return()
1529         self.assertTrue(isinstance(object_, GIMarshallingTests.Object))
1530         self.assertEquals(object_.__grefcount__, 1)
1531
1532     def test_object_none_in(self):
1533         object_ = GIMarshallingTests.Object(int = 42)
1534         GIMarshallingTests.Object.none_in(object_)
1535         self.assertEquals(object_.__grefcount__, 1)
1536
1537         object_ = GIMarshallingTests.SubObject(int = 42)
1538         GIMarshallingTests.Object.none_in(object_)
1539
1540         object_ = GObject.GObject()
1541         self.assertRaises(TypeError, GIMarshallingTests.Object.none_in, object_)
1542
1543         self.assertRaises(TypeError, GIMarshallingTests.Object.none_in, None)
1544
1545     def test_object_none_out(self):
1546         object_ = GIMarshallingTests.Object.none_out()
1547         self.assertTrue(isinstance(object_, GIMarshallingTests.Object))
1548         self.assertEquals(object_.__grefcount__, 2)
1549
1550         new_object = GIMarshallingTests.Object.none_out()
1551         self.assertTrue(new_object is object_)
1552
1553     def test_object_full_out(self):
1554         object_ = GIMarshallingTests.Object.full_out()
1555         self.assertTrue(isinstance(object_, GIMarshallingTests.Object))
1556         self.assertEquals(object_.__grefcount__, 1)
1557
1558     def test_object_none_inout(self):
1559         object_ = GIMarshallingTests.Object(int = 42)
1560         new_object = GIMarshallingTests.Object.none_inout(object_)
1561
1562         self.assertTrue(isinstance(new_object, GIMarshallingTests.Object))
1563
1564         self.assertFalse(object_ is new_object)
1565
1566         self.assertEquals(object_.__grefcount__, 1)
1567         self.assertEquals(new_object.__grefcount__, 2)
1568
1569         new_new_object = GIMarshallingTests.Object.none_inout(object_)
1570         self.assertTrue(new_new_object is new_object)
1571
1572         GIMarshallingTests.Object.none_inout(GIMarshallingTests.SubObject(int = 42))
1573
1574     def test_object_full_inout(self):
1575         object_ = GIMarshallingTests.Object(int = 42)
1576         new_object = GIMarshallingTests.Object.full_inout(object_)
1577
1578         self.assertTrue(isinstance(new_object, GIMarshallingTests.Object))
1579
1580         self.assertFalse(object_ is new_object)
1581
1582         self.assertEquals(object_.__grefcount__, 2)
1583         self.assertEquals(new_object.__grefcount__, 1)
1584
1585 # FIXME: Doesn't actually return the same object.
1586 #    def test_object_inout_same(self):
1587 #        object_ = GIMarshallingTests.Object()
1588 #        new_object = GIMarshallingTests.object_full_inout(object_)
1589 #        self.assertTrue(object_ is new_object)
1590 #        self.assertEquals(object_.__grefcount__, 1)
1591
1592
1593 class TestPythonGObject(unittest.TestCase):
1594
1595     class Object(GIMarshallingTests.Object):
1596         def __init__(self, int):
1597             GIMarshallingTests.Object.__init__(self)
1598             self.val = None
1599
1600         def method(self):
1601             # Don't call super, which asserts that self.int == 42.
1602             pass
1603
1604         def do_method_int8_in(self, int8):
1605             self.val = int8
1606
1607         def do_method_int8_out(self):
1608             return 42
1609
1610         def do_method_with_default_implementation(self, int8):
1611             GIMarshallingTests.Object.do_method_with_default_implementation(self, int8)
1612             self.props.int += int8
1613
1614     class SubObject(GIMarshallingTests.SubObject):
1615         def __init__(self, int):
1616             GIMarshallingTests.SubObject.__init__(self)
1617             self.val = None
1618
1619         def do_method_with_default_implementation(self, int8):
1620             self.val = int8
1621
1622     def test_object(self):
1623         self.assertTrue(issubclass(self.Object, GIMarshallingTests.Object))
1624
1625         object_ = self.Object(int = 42)
1626         self.assertTrue(isinstance(object_, self.Object))
1627
1628     def test_object_method(self):
1629         self.Object(int = 0).method()
1630
1631     def test_object_vfuncs(self):
1632         object_ = self.Object(int = 42)
1633         object_.method_int8_in(84)
1634         self.assertEqual(object_.val, 84)
1635         self.assertEqual(object_.method_int8_out(), 42)
1636
1637         object_.method_with_default_implementation(42)
1638         self.assertEqual(object_.props.int, 84)
1639
1640         class ObjectWithoutVFunc(GIMarshallingTests.Object):
1641             def __init__(self, int):
1642                 GIMarshallingTests.Object.__init__(self)
1643
1644         object_ = ObjectWithoutVFunc(int = 42)
1645         object_.method_with_default_implementation(84)
1646         self.assertEqual(object_.props.int, 84)
1647
1648     def test_subobject_parent_vfunc(self):
1649         object_ = self.SubObject(int = 81)
1650         object_.method_with_default_implementation(87)
1651         self.assertEquals(object_.val, 87)
1652
1653     def test_dynamic_module(self):
1654         from gi.module import DynamicGObjectModule
1655         self.assertTrue(isinstance(GObject, DynamicGObjectModule))
1656         # compare the same enum from both the pygobject attrs and gi GObject attrs
1657         self.assertEquals(GObject.SIGNAL_ACTION, GObject.SignalFlags.ACTION)
1658         # compare a static gobject attr with a dynamic GObject attr
1659         import gi._gobject
1660         self.assertEquals(GObject.GObject, gi._gobject.GObject)
1661
1662     def test_subobject_non_vfunc_do_method(self):
1663         class PythonObjectWithNonVFuncDoMethod:
1664             def do_not_a_vfunc(self):
1665                 return 5
1666
1667         class ObjectOverrideNonVFuncDoMethod(GIMarshallingTests.Object, PythonObjectWithNonVFuncDoMethod):
1668             def do_not_a_vfunc(self):
1669                 value = super(ObjectOverrideNonVFuncDoMethod, self).do_not_a_vfunc()
1670                 return 13 + value
1671
1672         object_ = ObjectOverrideNonVFuncDoMethod()
1673         self.assertEquals(18, object_.do_not_a_vfunc())
1674
1675     def test_native_function_not_set_in_subclass_dict(self):
1676         # Previously, GI was setting virtual functions on the class as well
1677         # as any *native* class that subclasses it. Here we check that it is only
1678         # set on the class that the method is originally from.
1679         self.assertTrue('do_method_with_default_implementation' in GIMarshallingTests.Object.__dict__)
1680         self.assertTrue('do_method_with_default_implementation' not in GIMarshallingTests.SubObject.__dict__)
1681
1682     def test_subobject_with_interface_and_non_vfunc_do_method(self):
1683         # There was a bug for searching for vfuncs in interfaces. It was
1684         # triggered by having a do_* method that wasn't overriding
1685         # a native vfunc, as well as inheriting from an interface.
1686         class GObjectSubclassWithInterface(GObject.GObject, GIMarshallingTests.Interface):
1687             def do_method_not_a_vfunc(self):
1688                 pass
1689
1690     def test_subsubobject(self):
1691         class SubSubSubObject(GIMarshallingTests.SubSubObject):
1692             def do_method_deep_hierarchy(self, num):
1693                 self.props.int = num * 2
1694
1695         sub_sub_sub_object = SubSubSubObject()
1696         GIMarshallingTests.SubSubObject.do_method_deep_hierarchy(sub_sub_sub_object, 5)
1697         self.assertEqual(sub_sub_sub_object.props.int, 5)
1698
1699
1700 class TestMultiOutputArgs(unittest.TestCase):
1701
1702     def test_int_out_out(self):
1703         self.assertEquals((6, 7), GIMarshallingTests.int_out_out())
1704
1705     def test_int_return_out(self):
1706         self.assertEquals((6, 7), GIMarshallingTests.int_return_out())
1707
1708 class TestGErrorException(unittest.TestCase):
1709     def test_gerror_exception(self):
1710         self.assertRaises(GObject.GError, GIMarshallingTests.gerror)
1711         try:
1712             GIMarshallingTests.gerror()
1713         except Exception:
1714             etype, e = sys.exc_info()[:2]
1715             self.assertEquals(e.domain, GIMarshallingTests.CONSTANT_GERROR_DOMAIN)
1716             self.assertEquals(e.code, GIMarshallingTests.CONSTANT_GERROR_CODE)
1717             self.assertEquals(e.message, GIMarshallingTests.CONSTANT_GERROR_MESSAGE)
1718
1719
1720 # Interface
1721
1722 class TestInterfaces(unittest.TestCase):
1723
1724     class TestInterfaceImpl(GObject.GObject, GIMarshallingTests.Interface):
1725         def __init__(self):
1726             GObject.GObject.__init__(self)
1727             self.val = None
1728
1729         def do_test_int8_in(self, int8):
1730             self.val = int8
1731
1732     def setUp(self):
1733         self.instance = self.TestInterfaceImpl()
1734
1735     def test_wrapper(self):
1736         self.assertTrue(issubclass(GIMarshallingTests.Interface, GObject.GInterface))
1737         self.assertEquals(GIMarshallingTests.Interface.__gtype__.name, 'GIMarshallingTestsInterface')
1738         self.assertRaises(NotImplementedError, GIMarshallingTests.Interface)
1739
1740     def test_implementation(self):
1741         self.assertTrue(issubclass(self.TestInterfaceImpl, GIMarshallingTests.Interface))
1742         self.assertTrue(isinstance(self.instance, GIMarshallingTests.Interface))
1743
1744     def test_int8_int(self):
1745         GIMarshallingTests.test_interface_test_int8_in(self.instance, 42)
1746         self.assertEquals(self.instance.val, 42)
1747
1748     def test_subclass(self):
1749         class TestInterfaceImplA(self.TestInterfaceImpl):
1750             pass
1751
1752         class TestInterfaceImplB(TestInterfaceImplA):
1753             pass
1754
1755         instance = TestInterfaceImplA()
1756         GIMarshallingTests.test_interface_test_int8_in(instance, 42)
1757         self.assertEquals(instance.val, 42)
1758
1759     def test_mro(self):
1760         # there was a problem with Python bailing out because of
1761         # http://en.wikipedia.org/wiki/Diamond_problem with interfaces,
1762         # which shouldn't really be a problem.
1763
1764         class TestInterfaceImpl(GObject.GObject, GIMarshallingTests.Interface):
1765             pass
1766
1767         class TestInterfaceImpl2(GIMarshallingTests.Interface,
1768                                  TestInterfaceImpl):
1769             pass
1770
1771         class TestInterfaceImpl3(self.TestInterfaceImpl,
1772                                  GIMarshallingTests.Interface2):
1773             pass
1774
1775
1776 class TestInterfaceClash(unittest.TestCase):
1777
1778     def test_clash(self):
1779         def create_clash():
1780             class TestClash(GObject.GObject, GIMarshallingTests.Interface, GIMarshallingTests.Interface2):
1781                 def do_test_int8_in(self, int8):
1782                     pass
1783             TestClash()
1784
1785         self.assertRaises(TypeError, create_clash)
1786
1787
1788 class TestOverrides(unittest.TestCase):
1789
1790     def test_constant(self):
1791         self.assertEquals(GIMarshallingTests.OVERRIDES_CONSTANT, 7)
1792
1793     def test_struct(self):
1794         # Test that the constructor has been overridden.
1795         struct = GIMarshallingTests.OverridesStruct(42)
1796
1797         self.assertTrue(isinstance(struct, GIMarshallingTests.OverridesStruct))
1798
1799         # Test that the method has been overridden.
1800         self.assertEquals(6, struct.method())
1801
1802         del struct
1803
1804         # Test that the overrides wrapper has been registered.
1805         struct = GIMarshallingTests.overrides_struct_returnv()
1806
1807         self.assertTrue(isinstance(struct, GIMarshallingTests.OverridesStruct))
1808
1809         del struct
1810
1811     def test_object(self):
1812         # Test that the constructor has been overridden.
1813         object_ = GIMarshallingTests.OverridesObject(42)
1814
1815         self.assertTrue(isinstance(object_, GIMarshallingTests.OverridesObject))
1816
1817         # Test that the alternate constructor has been overridden.
1818         object_ = GIMarshallingTests.OverridesObject.new(42)
1819
1820         self.assertTrue(isinstance(object_, GIMarshallingTests.OverridesObject))
1821
1822         # Test that the method has been overridden.
1823         self.assertEquals(6, object_.method())
1824
1825         # Test that the overrides wrapper has been registered.
1826         object_ = GIMarshallingTests.OverridesObject.returnv()
1827
1828         self.assertTrue(isinstance(object_, GIMarshallingTests.OverridesObject))
1829
1830     def test_module_name(self):
1831         self.assertEquals(GIMarshallingTests.OverridesStruct.__module__, 'gi.overrides.GIMarshallingTests')
1832         self.assertEquals(GObject.InitiallyUnowned.__module__, 'gi.repository.GObject')
1833
1834
1835 class TestDir(unittest.TestCase):
1836     def test_members_list(self):
1837         list = dir(GIMarshallingTests)
1838         self.assertTrue('OverridesStruct' in list)
1839         self.assertTrue('BoxedStruct' in list)
1840         self.assertTrue('OVERRIDES_CONSTANT' in list)
1841         self.assertTrue('GEnum' in list)
1842         self.assertTrue('int32_return_max' in list)
1843
1844     def test_modules_list(self):
1845         import gi.repository
1846         list = dir(gi.repository)
1847         self.assertTrue('GIMarshallingTests' in list)
1848
1849         # FIXME: test to see if a module which was not imported is in the list
1850         #        we should be listing every typelib we find, not just the ones
1851         #        which are imported
1852         #
1853         #        to test this I recommend we compile a fake module which
1854         #        our tests would never import and check to see if it is
1855         #        in the list:
1856         #
1857         # self.assertTrue('DoNotImportDummyTests' in list)
1858
1859
1860 class TestGErrorArrayInCrash(unittest.TestCase):
1861     # Previously there was a bug in invoke, in which C arrays were unwrapped
1862     # from inside GArrays to be passed to the C function. But when a GError was
1863     # set, invoke would attempt to free the C array as if it were a GArray.
1864     # This crash is only for C arrays. It does not happen for C functions which
1865     # take in GArrays. See https://bugzilla.gnome.org/show_bug.cgi?id=642708
1866     def test_gerror_array_in_crash(self):
1867         self.assertRaises(GObject.GError, GIMarshallingTests.gerror_array_in, [1, 2, 3])
1868
1869
1870 class TestGErrorOut(unittest.TestCase):
1871     # See https://bugzilla.gnome.org/show_bug.cgi?id=666098
1872     def test_gerror_out(self):
1873         error, debug = GIMarshallingTests.gerror_out()
1874
1875         self.assertIsInstance(error, GObject.GError)
1876         self.assertEquals(error.domain, GIMarshallingTests.CONSTANT_GERROR_DOMAIN)
1877         self.assertEquals(error.code, GIMarshallingTests.CONSTANT_GERROR_CODE)
1878         self.assertEquals(error.message, GIMarshallingTests.CONSTANT_GERROR_MESSAGE)
1879         self.assertEquals(debug, GIMarshallingTests.CONSTANT_GERROR_DEBUG_MESSAGE)
1880
1881
1882 class TestGErrorOutTransferNone(unittest.TestCase):
1883     # See https://bugzilla.gnome.org/show_bug.cgi?id=666098
1884     def test_gerror_out_transfer_none(self):
1885         error, debug = GIMarshallingTests.gerror_out_transfer_none()
1886
1887         self.assertIsInstance(error, GObject.GError)
1888         self.assertEquals(error.domain, GIMarshallingTests.CONSTANT_GERROR_DOMAIN)
1889         self.assertEquals(error.code, GIMarshallingTests.CONSTANT_GERROR_CODE)
1890         self.assertEquals(error.message, GIMarshallingTests.CONSTANT_GERROR_MESSAGE)
1891         self.assertEquals(GIMarshallingTests.CONSTANT_GERROR_DEBUG_MESSAGE, debug)
1892
1893
1894 class TestGErrorReturn(unittest.TestCase):
1895     # See https://bugzilla.gnome.org/show_bug.cgi?id=666098
1896     def test_return_gerror(self):
1897         error = GIMarshallingTests.gerror_return()
1898
1899         self.assertIsInstance(error, GObject.GError)
1900         self.assertEquals(error.domain, GIMarshallingTests.CONSTANT_GERROR_DOMAIN)
1901         self.assertEquals(error.code, GIMarshallingTests.CONSTANT_GERROR_CODE)
1902         self.assertEquals(error.message, GIMarshallingTests.CONSTANT_GERROR_MESSAGE)
1903
1904
1905 class TestKeywordArgs(unittest.TestCase):
1906
1907     def test_calling(self):
1908         kw_func = GIMarshallingTests.int_three_in_three_out
1909
1910         self.assertEquals(kw_func(1, 2, 3),                 (1, 2, 3))
1911         self.assertEquals(kw_func(**{'a':4, 'b':5, 'c':6}), (4, 5, 6))
1912         self.assertEquals(kw_func(1, **{'b':7, 'c':8}),     (1, 7, 8))
1913         self.assertEquals(kw_func(1, 7, **{'c':8}),         (1, 7, 8))
1914         self.assertEquals(kw_func(1, c=8, **{'b':7}),       (1, 7, 8))
1915         self.assertEquals(kw_func(2, c=4, b=3),             (2, 3, 4))
1916         self.assertEquals(kw_func(a=2, c=4, b=3),           (2, 3, 4))
1917
1918     def assertRaisesMessage(self, exception, message, func, *args, **kwargs):
1919         try:
1920             func(*args, **kwargs)
1921         except exception:
1922             (e_type, e) = sys.exc_info()[:2]
1923             if message is not None:
1924                 self.assertEqual(str(e), message)
1925         except:
1926             raise
1927         else:
1928             msg = "%s() did not raise %s" % (func.__name__, exception.__name__)
1929             raise AssertionError(msg)
1930
1931     def test_type_errors(self):
1932         # test too few args
1933         self.assertRaisesMessage(TypeError, "int_three_in_three_out() takes exactly 3 arguments (0 given)",
1934                                  GIMarshallingTests.int_three_in_three_out)
1935         self.assertRaisesMessage(TypeError, "int_three_in_three_out() takes exactly 3 arguments (1 given)",
1936                                  GIMarshallingTests.int_three_in_three_out, 1)
1937         self.assertRaisesMessage(TypeError, "int_three_in_three_out() takes exactly 3 arguments (0 given)",
1938                                  GIMarshallingTests.int_three_in_three_out, *())
1939         self.assertRaisesMessage(TypeError, "int_three_in_three_out() takes exactly 3 arguments (0 given)",
1940                                  GIMarshallingTests.int_three_in_three_out, *(), **{})
1941         self.assertRaisesMessage(TypeError, "int_three_in_three_out() takes exactly 3 non-keyword arguments (0 given)",
1942                                  GIMarshallingTests.int_three_in_three_out, *(), **{'c':4})
1943
1944         # test too many args
1945         self.assertRaisesMessage(TypeError, "int_three_in_three_out() takes exactly 3 arguments (4 given)",
1946                                  GIMarshallingTests.int_three_in_three_out, *(1, 2, 3, 4))
1947         self.assertRaisesMessage(TypeError, "int_three_in_three_out() takes exactly 3 non-keyword arguments (4 given)",
1948                                  GIMarshallingTests.int_three_in_three_out, *(1, 2, 3, 4), c=6)
1949
1950         # test too many keyword args
1951         self.assertRaisesMessage(TypeError, "int_three_in_three_out() got multiple values for keyword argument 'a'",
1952                                  GIMarshallingTests.int_three_in_three_out, 1, 2, 3, **{'a': 4, 'b': 5})
1953         self.assertRaisesMessage(TypeError, "int_three_in_three_out() got an unexpected keyword argument 'd'",
1954                                  GIMarshallingTests.int_three_in_three_out, d=4)
1955         self.assertRaisesMessage(TypeError, "int_three_in_three_out() got an unexpected keyword argument 'e'",
1956                                  GIMarshallingTests.int_three_in_three_out, **{'e': 2})
1957
1958     def test_kwargs_are_not_modified(self):
1959         d = {'b': 2}
1960         d2 = d.copy()
1961         GIMarshallingTests.int_three_in_three_out(1, c=4, **d)
1962         self.assertEqual(d, d2)
1963
1964
1965 class TestPropertiesObject(unittest.TestCase):
1966
1967     def setUp(self):
1968         self.obj = GIMarshallingTests.PropertiesObject()
1969
1970     def test_boolean(self):
1971         self.assertEqual(self.obj.props.some_boolean, False)
1972         self.obj.props.some_boolean = True
1973         self.assertEqual(self.obj.props.some_boolean, True)
1974
1975     @unittest.expectedFailure
1976     def test_char(self):
1977         # gobject-introspection thinks it has a guint8 type tag, which is wrong
1978         self.assertEqual(self.obj.props.some_char, 0)
1979         self.obj.props.some_char = GObject.G_MAXINT8
1980         self.assertEqual(self.obj.props.some_char, GObject.G_MAXINT8)
1981
1982     def test_uchar(self):
1983         self.assertEqual(self.obj.props.some_uchar, 0)
1984         self.obj.props.some_uchar = GObject.G_MAXUINT8
1985         self.assertEqual(self.obj.props.some_uchar, GObject.G_MAXUINT8)
1986
1987     def test_int(self):
1988         self.assertEqual(self.obj.props.some_int, 0)
1989         self.obj.props.some_int = GObject.G_MAXINT
1990         self.assertEqual(self.obj.props.some_int, GObject.G_MAXINT)
1991
1992     def test_uint(self):
1993         self.assertEqual(self.obj.props.some_uint, 0)
1994         self.obj.props.some_uint = GObject.G_MAXUINT
1995         self.assertEqual(self.obj.props.some_uint, GObject.G_MAXUINT)
1996
1997     def test_long(self):
1998         self.assertEqual(self.obj.props.some_long, 0)
1999         self.obj.props.some_long = GObject.G_MAXLONG
2000         self.assertEqual(self.obj.props.some_long, GObject.G_MAXLONG)
2001
2002     def test_ulong(self):
2003         self.assertEqual(self.obj.props.some_ulong, 0)
2004         self.obj.props.some_ulong = GObject.G_MAXULONG
2005         self.assertEqual(self.obj.props.some_ulong, GObject.G_MAXULONG)
2006
2007     def test_int64(self):
2008         self.assertEqual(self.obj.props.some_int64, 0)
2009         self.obj.props.some_int64 = GObject.G_MAXINT64
2010         self.assertEqual(self.obj.props.some_int64, GObject.G_MAXINT64)
2011
2012     def test_uint64(self):
2013         self.assertEqual(self.obj.props.some_uint64, 0)
2014         self.obj.props.some_uint64 = GObject.G_MAXUINT64
2015         self.assertEqual(self.obj.props.some_uint64, GObject.G_MAXUINT64)
2016
2017     def test_float(self):
2018         self.assertEqual(self.obj.props.some_float, 0)
2019         self.obj.props.some_float = GObject.G_MAXFLOAT
2020         self.assertEqual(self.obj.props.some_float, GObject.G_MAXFLOAT)
2021
2022     def test_double(self):
2023         self.assertEqual(self.obj.props.some_double, 0)
2024         self.obj.props.some_double = GObject.G_MAXDOUBLE
2025         self.assertEqual(self.obj.props.some_double, GObject.G_MAXDOUBLE)