tests/test_overrides.py

   1 # -*- Mode: Python; py-indent-offset: 4 -*-
   2 # vim: tabstop=4 shiftwidth=4 expandtab
   3
   4 import unittest
   5
   6 import sys
   7 sys.path.insert(0, "../")
   8
   9 from compathelper import _long, _unicode, _bytes
  10
  11 from gi.repository import GLib
  12 from gi.repository import GObject
  13 from gi.repository import Gdk
  14 from gi.repository import Gtk
  15 from gi.repository import Gio
  16 from gi.repository import Pango
  17 from gi.repository import GdkPixbuf
  18 import gi.overrides as overrides
  19 import gi.types
  20
  21
  22 class TestRegistry(unittest.TestCase):
  23
  24     def test_non_gi(self):
  25         class MyClass:
  26             pass
  27
  28         try:
  29             overrides.override(MyClass)
  30             self.fail('unexpected success of overriding non-GI class')
  31         except TypeError as e:
  32             self.assertTrue('Can not override a type MyClass' in str(e))
  33
  34
  35 class TestGLib(unittest.TestCase):
  36
  37     def test_gvariant_create(self):
  38         # simple values
  39
  40         variant = GLib.Variant('i', 42)
  41         self.assertTrue(isinstance(variant, GLib.Variant))
  42         self.assertEqual(variant.get_int32(), 42)
  43
  44         variant = GLib.Variant('s', '')
  45         self.assertTrue(isinstance(variant, GLib.Variant))
  46         self.assertEqual(variant.get_string(), '')
  47
  48         variant = GLib.Variant('s', 'hello')
  49         self.assertTrue(isinstance(variant, GLib.Variant))
  50         self.assertEqual(variant.get_string(), 'hello')
  51
  52         # boxed variant
  53         variant = GLib.Variant('v', GLib.Variant('i', 42))
  54         self.assertTrue(isinstance(variant, GLib.Variant))
  55         self.assertTrue(isinstance(variant.get_variant(), GLib.Variant))
  56         self.assertEqual(variant.get_type_string(), 'v')
  57         self.assertEqual(variant.get_variant().get_type_string(), 'i')
  58         self.assertEqual(variant.get_variant().get_int32(), 42)
  59
  60         variant = GLib.Variant('v', GLib.Variant('v', GLib.Variant('i', 42)))
  61         self.assertEqual(variant.get_type_string(), 'v')
  62         self.assertEqual(variant.get_variant().get_type_string(), 'v')
  63         self.assertEqual(variant.get_variant().get_variant().get_type_string(), 'i')
  64         self.assertEqual(variant.get_variant().get_variant().get_int32(), 42)
  65
  66         # tuples
  67
  68         variant = GLib.Variant('()', ())
  69         self.assertEqual(variant.get_type_string(), '()')
  70         self.assertEqual(variant.n_children(), 0)
  71
  72         variant = GLib.Variant('(i)', (3,))
  73         self.assertEqual(variant.get_type_string(), '(i)')
  74         self.assertTrue(isinstance(variant, GLib.Variant))
  75         self.assertEqual(variant.n_children(), 1)
  76         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
  77         self.assertEqual(variant.get_child_value(0).get_int32(), 3)
  78
  79         variant = GLib.Variant('(ss)', ('mec', 'mac'))
  80         self.assertEqual(variant.get_type_string(), '(ss)')
  81         self.assertTrue(isinstance(variant, GLib.Variant))
  82         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
  83         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
  84         self.assertEqual(variant.get_child_value(0).get_string(), 'mec')
  85         self.assertEqual(variant.get_child_value(1).get_string(), 'mac')
  86
  87         # nested tuples
  88         variant = GLib.Variant('((si)(ub))', (('hello', -1), (42, True)))
  89         self.assertEqual(variant.get_type_string(), '((si)(ub))')
  90         self.assertEqual(variant.unpack(), (('hello', -1), (_long(42), True)))
  91
  92         # dictionaries
  93
  94         variant = GLib.Variant('a{si}', {})
  95         self.assertTrue(isinstance(variant, GLib.Variant))
  96         self.assertEqual(variant.get_type_string(), 'a{si}')
  97         self.assertEqual(variant.n_children(), 0)
  98
  99         variant = GLib.Variant('a{si}', {'': 1, 'key1': 2, 'key2': 3})
 100         self.assertEqual(variant.get_type_string(), 'a{si}')
 101         self.assertTrue(isinstance(variant, GLib.Variant))
 102         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
 103         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
 104         self.assertTrue(isinstance(variant.get_child_value(2), GLib.Variant))
 105         self.assertEqual(variant.unpack(), {'': 1, 'key1': 2, 'key2': 3})
 106
 107         # nested dictionaries
 108         variant = GLib.Variant('a{sa{si}}', {})
 109         self.assertTrue(isinstance(variant, GLib.Variant))
 110         self.assertEqual(variant.get_type_string(), 'a{sa{si}}')
 111         self.assertEqual(variant.n_children(), 0)
 112
 113         d = {'': {'': 1, 'keyn1': 2},
 114              'key1': {'key11': 11, 'key12': 12}}
 115         variant = GLib.Variant('a{sa{si}}', d)
 116         self.assertEqual(variant.get_type_string(), 'a{sa{si}}')
 117         self.assertTrue(isinstance(variant, GLib.Variant))
 118         self.assertEqual(variant.unpack(), d)
 119
 120         # arrays
 121
 122         variant = GLib.Variant('ai', [])
 123         self.assertEqual(variant.get_type_string(), 'ai')
 124         self.assertEqual(variant.n_children(), 0)
 125
 126         variant = GLib.Variant('ai', [1, 2])
 127         self.assertEqual(variant.get_type_string(), 'ai')
 128         self.assertTrue(isinstance(variant, GLib.Variant))
 129         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
 130         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
 131         self.assertEqual(variant.get_child_value(0).get_int32(), 1)
 132         self.assertEqual(variant.get_child_value(1).get_int32(), 2)
 133
 134         variant = GLib.Variant('as', [])
 135         self.assertEqual(variant.get_type_string(), 'as')
 136         self.assertEqual(variant.n_children(), 0)
 137
 138         variant = GLib.Variant('as', [''])
 139         self.assertEqual(variant.get_type_string(), 'as')
 140         self.assertTrue(isinstance(variant, GLib.Variant))
 141         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
 142         self.assertEqual(variant.get_child_value(0).get_string(), '')
 143
 144         variant = GLib.Variant('as', ['hello', 'world'])
 145         self.assertEqual(variant.get_type_string(), 'as')
 146         self.assertTrue(isinstance(variant, GLib.Variant))
 147         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
 148         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
 149         self.assertEqual(variant.get_child_value(0).get_string(), 'hello')
 150         self.assertEqual(variant.get_child_value(1).get_string(), 'world')
 151
 152         # nested arrays
 153         variant = GLib.Variant('aai', [])
 154         self.assertEqual(variant.get_type_string(), 'aai')
 155         self.assertEqual(variant.n_children(), 0)
 156
 157         variant = GLib.Variant('aai', [[]])
 158         self.assertEqual(variant.get_type_string(), 'aai')
 159         self.assertEqual(variant.n_children(), 1)
 160         self.assertEqual(variant.get_child_value(0).n_children(), 0)
 161
 162         variant = GLib.Variant('aai', [[1, 2], [3, 4, 5]])
 163         self.assertEqual(variant.get_type_string(), 'aai')
 164         self.assertEqual(variant.unpack(), [[1, 2], [3, 4, 5]])
 165
 166         #
 167         # complex types
 168         #
 169
 170         variant = GLib.Variant('(as)', ([],))
 171         self.assertEqual(variant.get_type_string(), '(as)')
 172         self.assertEqual(variant.n_children(), 1)
 173         self.assertEqual(variant.get_child_value(0).n_children(), 0)
 174
 175         variant = GLib.Variant('(as)', ([''],))
 176         self.assertEqual(variant.get_type_string(), '(as)')
 177         self.assertEqual(variant.n_children(), 1)
 178         self.assertEqual(variant.get_child_value(0).n_children(), 1)
 179         self.assertEqual(variant.get_child_value(0).get_child_value(0).get_string(), '')
 180
 181         variant = GLib.Variant('(as)', (['hello'],))
 182         self.assertEqual(variant.get_type_string(), '(as)')
 183         self.assertEqual(variant.n_children(), 1)
 184         self.assertEqual(variant.get_child_value(0).n_children(), 1)
 185         self.assertEqual(variant.get_child_value(0).get_child_value(0).get_string(), 'hello')
 186
 187         obj = {'a1': (1, True), 'a2': (2, False)}
 188         variant = GLib.Variant('a{s(ib)}', obj)
 189         self.assertEqual(variant.get_type_string(), 'a{s(ib)}')
 190         self.assertEqual(variant.unpack(), obj)
 191
 192         obj = {'a1': (1, GLib.Variant('b', True)), 'a2': (2, GLib.Variant('y', 255))}
 193         variant = GLib.Variant('a{s(iv)}', obj)
 194         self.assertEqual(variant.get_type_string(), 'a{s(iv)}')
 195         self.assertEqual(variant.unpack(), {'a1': (1, True), 'a2': (2, 255)})
 196
 197         obj = (1, {'a': {'a1': True, 'a2': False},
 198                    'b': {'b1': False},
 199                    'c': {}
 200                   },
 201                'foo')
 202         variant = GLib.Variant('(ia{sa{sb}}s)', obj)
 203         self.assertEqual(variant.get_type_string(), '(ia{sa{sb}}s)')
 204         self.assertEqual(variant.unpack(), obj)
 205
 206         obj = {"frequency": GLib.Variant('t', 738000000),
 207             "hierarchy": GLib.Variant('i', 0),
 208             "bandwidth": GLib.Variant('x', 8),
 209             "code-rate-hp": GLib.Variant('d', 2.0 / 3.0),
 210             "constellation": GLib.Variant('s', "QAM16"),
 211             "guard-interval": GLib.Variant('u', 4)}
 212         variant = GLib.Variant('a{sv}', obj)
 213         self.assertEqual(variant.get_type_string(), 'a{sv}')
 214         self.assertEqual(variant.unpack(), {"frequency": 738000000,
 215             "hierarchy": 0,
 216             "bandwidth": 8,
 217             "code-rate-hp": 2.0 / 3.0,
 218             "constellation": "QAM16",
 219             "guard-interval": 4})
 220
 221     def test_gvariant_create_errors(self):
 222         # excess arguments
 223         self.assertRaises(TypeError, GLib.Variant, 'i', 42, 3)
 224         self.assertRaises(TypeError, GLib.Variant, '(i)', (42, 3))
 225
 226         # not enough arguments
 227         self.assertRaises(TypeError, GLib.Variant, '(ii)', (42,))
 228
 229         # data type mismatch
 230         self.assertRaises(TypeError, GLib.Variant, 'i', 'hello')
 231         self.assertRaises(TypeError, GLib.Variant, 's', 42)
 232         self.assertRaises(TypeError, GLib.Variant, '(ss)', 'mec', 'mac')
 233
 234         # unimplemented data type
 235         self.assertRaises(NotImplementedError, GLib.Variant, 'Q', 1)
 236
 237     def test_gvariant_unpack(self):
 238         # simple values
 239         res = GLib.Variant.new_int32(-42).unpack()
 240         self.assertEqual(res, -42)
 241
 242         res = GLib.Variant.new_uint64(34359738368).unpack()
 243         self.assertEqual(res, 34359738368)
 244
 245         res = GLib.Variant.new_boolean(True).unpack()
 246         self.assertEqual(res, True)
 247
 248         res = GLib.Variant.new_object_path('/foo/Bar').unpack()
 249         self.assertEqual(res, '/foo/Bar')
 250
 251         # variant
 252         res = GLib.Variant('v', GLib.Variant.new_int32(-42)).unpack()
 253         self.assertEqual(res, -42)
 254
 255         GLib.Variant('v', GLib.Variant('v', GLib.Variant('i', 42)))
 256         self.assertEqual(res, -42)
 257
 258         # tuple
 259         res = GLib.Variant.new_tuple(GLib.Variant.new_int32(-1),
 260                 GLib.Variant.new_string('hello')).unpack()
 261         self.assertEqual(res, (-1, 'hello'))
 262
 263         # array
 264         vb = GLib.VariantBuilder.new(gi._gi.variant_type_from_string('ai'))
 265         vb.add_value(GLib.Variant.new_int32(-1))
 266         vb.add_value(GLib.Variant.new_int32(3))
 267         res = vb.end().unpack()
 268         self.assertEqual(res, [-1, 3])
 269
 270         # dictionary
 271         res = GLib.Variant('a{si}', {'key1': 1, 'key2': 2}).unpack()
 272         self.assertEqual(res, {'key1': 1, 'key2': 2})
 273
 274     def test_gvariant_iteration(self):
 275         # array index access
 276         vb = GLib.VariantBuilder.new(gi._gi.variant_type_from_string('ai'))
 277         vb.add_value(GLib.Variant.new_int32(-1))
 278         vb.add_value(GLib.Variant.new_int32(3))
 279         v = vb.end()
 280
 281         self.assertEqual(len(v), 2)
 282         self.assertEqual(v[0], -1)
 283         self.assertEqual(v[1], 3)
 284         self.assertEqual(v[-1], 3)
 285         self.assertEqual(v[-2], -1)
 286         self.assertRaises(IndexError, v.__getitem__, 2)
 287         self.assertRaises(IndexError, v.__getitem__, -3)
 288         self.assertRaises(ValueError, v.__getitem__, 'a')
 289
 290         # array iteration
 291         self.assertEqual([x for x in v], [-1, 3])
 292         self.assertEqual(list(v), [-1, 3])
 293
 294         # tuple index access
 295         v = GLib.Variant.new_tuple(GLib.Variant.new_int32(-1),
 296                 GLib.Variant.new_string('hello'))
 297         self.assertEqual(len(v), 2)
 298         self.assertEqual(v[0], -1)
 299         self.assertEqual(v[1], 'hello')
 300         self.assertEqual(v[-1], 'hello')
 301         self.assertEqual(v[-2], -1)
 302         self.assertRaises(IndexError, v.__getitem__, 2)
 303         self.assertRaises(IndexError, v.__getitem__, -3)
 304         self.assertRaises(ValueError, v.__getitem__, 'a')
 305
 306         # tuple iteration
 307         self.assertEqual([x for x in v], [-1, 'hello'])
 308         self.assertEqual(tuple(v), (-1, 'hello'))
 309
 310         # dictionary index access
 311         vsi = GLib.Variant('a{si}', {'key1': 1, 'key2': 2})
 312         vis = GLib.Variant('a{is}', {1: 'val1', 5: 'val2'})
 313
 314         self.assertEqual(len(vsi), 2)
 315         self.assertEqual(vsi['key1'], 1)
 316         self.assertEqual(vsi['key2'], 2)
 317         self.assertRaises(KeyError, vsi.__getitem__, 'unknown')
 318
 319         self.assertEqual(len(vis), 2)
 320         self.assertEqual(vis[1], 'val1')
 321         self.assertEqual(vis[5], 'val2')
 322         self.assertRaises(KeyError, vsi.__getitem__, 3)
 323
 324         # dictionary iteration
 325         self.assertEqual(set(vsi.keys()), set(['key1', 'key2']))
 326         self.assertEqual(set(vis.keys()), set([1, 5]))
 327
 328         # string index access
 329         v = GLib.Variant('s', 'hello')
 330         self.assertEqual(len(v), 5)
 331         self.assertEqual(v[0], 'h')
 332         self.assertEqual(v[4], 'o')
 333         self.assertEqual(v[-1], 'o')
 334         self.assertEqual(v[-5], 'h')
 335         self.assertRaises(IndexError, v.__getitem__, 5)
 336         self.assertRaises(IndexError, v.__getitem__, -6)
 337
 338         # string iteration
 339         self.assertEqual([x for x in v], ['h', 'e', 'l', 'l', 'o'])
 340
 341     def test_variant_split_signature(self):
 342         self.assertEqual(GLib.Variant.split_signature('()'), [])
 343
 344         self.assertEqual(GLib.Variant.split_signature('s'), ['s'])
 345
 346         self.assertEqual(GLib.Variant.split_signature('as'), ['as'])
 347
 348         self.assertEqual(GLib.Variant.split_signature('(s)'), ['s'])
 349
 350         self.assertEqual(GLib.Variant.split_signature('(iso)'), ['i', 's', 'o'])
 351
 352         self.assertEqual(GLib.Variant.split_signature('(s(ss)i(ii))'),
 353                 ['s', '(ss)', 'i', '(ii)'])
 354
 355         self.assertEqual(GLib.Variant.split_signature('(as)'), ['as'])
 356
 357         self.assertEqual(GLib.Variant.split_signature('(s(ss)iaiaasa(ii))'),
 358                 ['s', '(ss)', 'i', 'ai', 'aas', 'a(ii)'])
 359
 360         self.assertEqual(GLib.Variant.split_signature('(a{iv}(ii)((ss)a{s(ss)}))'),
 361                 ['a{iv}', '(ii)', '((ss)a{s(ss)})'])
 362
 363     def test_variant_hash(self):
 364         v1 = GLib.Variant('s', 'somestring')
 365         v2 = GLib.Variant('s', 'somestring')
 366         v3 = GLib.Variant('s', 'somestring2')
 367
 368         self.assertTrue(v2 in set([v1, v3]))
 369         self.assertTrue(v2 in frozenset([v1, v3]))
 370         self.assertTrue(v2 in {v1: '1', v3: '2'})
 371
 372     def test_variant_compare(self):
 373         # Check if identical GVariant are equal
 374
 375         def assert_equal(vtype, value):
 376             self.assertEqual(GLib.Variant(vtype, value), GLib.Variant(vtype, value))
 377
 378         def assert_not_equal(vtype1, value1, vtype2, value2):
 379             self.assertNotEqual(GLib.Variant(vtype1, value1), GLib.Variant(vtype2, value2))
 380
 381         numbers = ['y', 'n', 'q', 'i', 'u', 'x', 't', 'h', 'd']
 382         for num in numbers:
 383             assert_equal(num, 42)
 384             assert_not_equal(num, 42, num, 41)
 385             assert_not_equal(num, 42, 's', '42')
 386
 387         assert_equal('s', 'something')
 388         assert_not_equal('s', 'something', 's', 'somethingelse')
 389         assert_not_equal('s', 'something', 'i', 1234)
 390
 391         assert_equal('g', 'dustybinqhogx')
 392         assert_not_equal('g', 'dustybinqhogx', 'g', 'dustybin')
 393         assert_not_equal('g', 'dustybinqhogx', 'i', 1234)
 394
 395         assert_equal('o', '/dev/null')
 396         assert_not_equal('o', '/dev/null', 'o', '/dev/zero')
 397         assert_not_equal('o', '/dev/null', 'i', 1234)
 398
 399         assert_equal('(s)', ('strtuple',))
 400         assert_not_equal('(s)', ('strtuple',), '(s)', ('strtuple2',))
 401
 402         assert_equal('a{si}', {'str': 42})
 403         assert_not_equal('a{si}', {'str': 42}, 'a{si}', {'str': 43})
 404
 405         assert_equal('v', GLib.Variant('i', 42))
 406         assert_not_equal('v', GLib.Variant('i', 42), 'v', GLib.Variant('i', 43))
 407
 408     def test_variant_bool(self):
 409         # Check if the GVariant bool matches the unpacked Pythonic bool
 410
 411         def assert_equals_bool(vtype, value):
 412             self.assertEqual(bool(GLib.Variant(vtype, value)), bool(value))
 413
 414         # simple values
 415         assert_equals_bool('b', True)
 416         assert_equals_bool('b', False)
 417
 418         numbers = ['y', 'n', 'q', 'i', 'u', 'x', 't', 'h', 'd']
 419         for number in numbers:
 420             assert_equals_bool(number, 0)
 421             assert_equals_bool(number, 1)
 422
 423         assert_equals_bool('s', '')
 424         assert_equals_bool('g', '')
 425         assert_equals_bool('s', 'something')
 426         assert_equals_bool('o', '/dev/null')
 427         assert_equals_bool('g', 'dustybinqhogx')
 428
 429         # arrays
 430         assert_equals_bool('ab', [True])
 431         assert_equals_bool('ab', [False])
 432         for number in numbers:
 433             assert_equals_bool('a' + number, [])
 434             assert_equals_bool('a' + number, [0])
 435         assert_equals_bool('as', [])
 436         assert_equals_bool('as', [''])
 437         assert_equals_bool('ao', [])
 438         assert_equals_bool('ao', ['/'])
 439         assert_equals_bool('ag', [])
 440         assert_equals_bool('ag', [''])
 441         assert_equals_bool('aai', [[]])
 442
 443         # tuples
 444         assert_equals_bool('()', ())
 445         for number in numbers:
 446             assert_equals_bool('(' + number + ')', (0,))
 447         assert_equals_bool('(s)', ('',))
 448         assert_equals_bool('(o)', ('/',))
 449         assert_equals_bool('(g)', ('',))
 450         assert_equals_bool('(())', ((),))
 451
 452         # dictionaries
 453         assert_equals_bool('a{si}', {})
 454         assert_equals_bool('a{si}', {'': 0})
 455
 456         # complex types, always True
 457         assert_equals_bool('(as)', ([],))
 458         assert_equals_bool('a{s(i)}', {'': (0,)})
 459
 460         # variant types, recursive unpacking
 461         assert_equals_bool('v', GLib.Variant('i', 0))
 462         assert_equals_bool('v', GLib.Variant('i', 1))
 463
 464
 465 class TestPango(unittest.TestCase):
 466
 467     def test_default_font_description(self):
 468         desc = Pango.FontDescription()
 469         self.assertEqual(desc.get_variant(), Pango.Variant.NORMAL)
 470
 471     def test_font_description(self):
 472         desc = Pango.FontDescription('monospace')
 473         self.assertEqual(desc.get_family(), 'monospace')
 474         self.assertEqual(desc.get_variant(), Pango.Variant.NORMAL)
 475
 476     def test_layout(self):
 477         self.assertRaises(TypeError, Pango.Layout)
 478         context = Pango.Context()
 479         layout = Pango.Layout(context)
 480         self.assertEqual(layout.get_context(), context)
 481
 482         layout.set_markup("Foobar")
 483         self.assertEqual(layout.get_text(), "Foobar")
 484
 485
 486 class TestGdk(unittest.TestCase):
 487
 488     def test_constructor(self):
 489         attribute = Gdk.WindowAttr()
 490         attribute.window_type = Gdk.WindowType.CHILD
 491         attributes_mask = Gdk.WindowAttributesType.X | \
 492             Gdk.WindowAttributesType.Y
 493         window = Gdk.Window(None, attribute, attributes_mask)
 494         self.assertEqual(window.get_window_type(), Gdk.WindowType.CHILD)
 495
 496     def test_color(self):
 497         color = Gdk.Color(100, 200, 300)
 498         self.assertEqual(color.red, 100)
 499         self.assertEqual(color.green, 200)
 500         self.assertEqual(color.blue, 300)
 501         self.assertEqual(color, Gdk.Color(100, 200, 300))
 502         self.assertNotEqual(color, Gdk.Color(1, 2, 3))
 503
 504     def test_color_floats(self):
 505         self.assertEqual(Gdk.Color(13107, 21845, 65535),
 506                          Gdk.Color.from_floats(0.2, 1.0 / 3.0, 1.0))
 507
 508         self.assertEqual(Gdk.Color(13107, 21845, 65535).to_floats(),
 509                          (0.2, 1.0 / 3.0, 1.0))
 510
 511         self.assertEqual(Gdk.RGBA(0.2, 1.0 / 3.0, 1.0, 0.5).to_color(),
 512                          Gdk.Color.from_floats(0.2, 1.0 / 3.0, 1.0))
 513
 514         self.assertEqual(Gdk.RGBA.from_color(Gdk.Color(13107, 21845, 65535)),
 515                          Gdk.RGBA(0.2, 1.0 / 3.0, 1.0, 1.0))
 516
 517     def test_rgba(self):
 518         self.assertEqual(Gdk.RGBA, overrides.Gdk.RGBA)
 519         rgba = Gdk.RGBA(0.1, 0.2, 0.3, 0.4)
 520         self.assertEqual(rgba, Gdk.RGBA(0.1, 0.2, 0.3, 0.4))
 521         self.assertNotEqual(rgba, Gdk.RGBA(0.0, 0.2, 0.3, 0.4))
 522         self.assertEqual(rgba.red, 0.1)
 523         self.assertEqual(rgba.green, 0.2)
 524         self.assertEqual(rgba.blue, 0.3)
 525         self.assertEqual(rgba.alpha, 0.4)
 526         rgba.green = 0.9
 527         self.assertEqual(rgba.green, 0.9)
 528
 529         # Iterator/tuple convsersion
 530         self.assertEqual(tuple(Gdk.RGBA(0.1, 0.2, 0.3, 0.4)),
 531                          (0.1, 0.2, 0.3, 0.4))
 532
 533     def test_event(self):
 534         event = Gdk.Event.new(Gdk.EventType.CONFIGURE)
 535         self.assertEqual(event.type, Gdk.EventType.CONFIGURE)
 536         self.assertEqual(event.send_event, 0)
 537
 538         event = Gdk.Event.new(Gdk.EventType.DRAG_MOTION)
 539         event.x_root, event.y_root = 0, 5
 540         self.assertEqual(event.x_root, 0)
 541         self.assertEqual(event.y_root, 5)
 542
 543         event = Gdk.Event()
 544         event.type = Gdk.EventType.SCROLL
 545         self.assertRaises(AttributeError, lambda: getattr(event, 'foo_bar'))
 546
 547     def test_event_structures(self):
 548         def button_press_cb(button, event):
 549             self.assertTrue(isinstance(event, Gdk.EventButton))
 550             self.assertTrue(event.type == Gdk.EventType.BUTTON_PRESS)
 551             self.assertEqual(event.send_event, 0)
 552             self.assertEqual(event.get_state(), Gdk.ModifierType.CONTROL_MASK)
 553             self.assertEqual(event.get_root_coords(), (2, 5))
 554
 555             event.time = 12345
 556             self.assertEqual(event.get_time(), 12345)
 557
 558         w = Gtk.Window()
 559         b = Gtk.Button()
 560         b.connect('button-press-event', button_press_cb)
 561         w.add(b)
 562         w.show_all()
 563         Gdk.test_simulate_button(b.get_window(),
 564                                  2, 5,
 565                                  0,
 566                                  Gdk.ModifierType.CONTROL_MASK,
 567                                  Gdk.EventType.BUTTON_PRESS)
 568
 569     def test_cursor(self):
 570         self.assertEqual(Gdk.Cursor, overrides.Gdk.Cursor)
 571         c = Gdk.Cursor(Gdk.CursorType.WATCH)
 572         self.assertNotEqual(c, None)
 573         c = Gdk.Cursor(cursor_type=Gdk.CursorType.WATCH)
 574         self.assertNotEqual(c, None)
 575
 576         display_manager = Gdk.DisplayManager.get()
 577         display = display_manager.get_default_display()
 578
 579         test_pixbuf = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB,
 580                                            False,
 581                                            8,
 582                                            5,
 583                                            10)
 584
 585         c = Gdk.Cursor(display,
 586                        test_pixbuf,
 587                        y=0, x=0)
 588
 589         self.assertNotEqual(c, None)
 590         self.assertRaises(ValueError, Gdk.Cursor, 1, 2, 3)
 591
 592
 593 class TestGtk(unittest.TestCase):
 594
 595     def test_container(self):
 596         box = Gtk.Box()
 597         self.assertTrue(isinstance(box, Gtk.Box))
 598         self.assertTrue(isinstance(box, Gtk.Container))
 599         self.assertTrue(isinstance(box, Gtk.Widget))
 600         self.assertTrue(box)
 601         label = Gtk.Label()
 602         label2 = Gtk.Label()
 603         box.add(label)
 604         box.add(label2)
 605         self.assertTrue(label in box)
 606         self.assertTrue(label2 in box)
 607         self.assertEqual(len(box), 2)
 608         self.assertTrue(box)
 609         l = [x for x in box]
 610         self.assertEqual(l, [label, label2])
 611
 612     def test_actions(self):
 613         self.assertEqual(Gtk.Action, overrides.Gtk.Action)
 614         self.assertRaises(TypeError, Gtk.Action)
 615         action = Gtk.Action("test", "Test", "Test Action", Gtk.STOCK_COPY)
 616         self.assertEqual(action.get_name(), "test")
 617         self.assertEqual(action.get_label(), "Test")
 618         self.assertEqual(action.get_tooltip(), "Test Action")
 619         self.assertEqual(action.get_stock_id(), Gtk.STOCK_COPY)
 620
 621         self.assertEqual(Gtk.RadioAction, overrides.Gtk.RadioAction)
 622         self.assertRaises(TypeError, Gtk.RadioAction)
 623         action = Gtk.RadioAction("test", "Test", "Test Action", Gtk.STOCK_COPY, 1)
 624         self.assertEqual(action.get_name(), "test")
 625         self.assertEqual(action.get_label(), "Test")
 626         self.assertEqual(action.get_tooltip(), "Test Action")
 627         self.assertEqual(action.get_stock_id(), Gtk.STOCK_COPY)
 628         self.assertEqual(action.get_current_value(), 1)
 629
 630     def test_actiongroup(self):
 631         self.assertEqual(Gtk.ActionGroup, overrides.Gtk.ActionGroup)
 632         self.assertRaises(TypeError, Gtk.ActionGroup)
 633
 634         action_group = Gtk.ActionGroup(name='TestActionGroup')
 635         callback_data = "callback data"
 636
 637         def test_action_callback_data(action, user_data):
 638             self.assertEqual(user_data, callback_data)
 639
 640         def test_radio_action_callback_data(action, current, user_data):
 641             self.assertEqual(user_data, callback_data)
 642
 643         action_group.add_actions([
 644             ('test-action1', None, 'Test Action 1',
 645              None, None, test_action_callback_data),
 646             ('test-action2', Gtk.STOCK_COPY, 'Test Action 2',
 647               None, None, test_action_callback_data)], callback_data)
 648         action_group.add_toggle_actions([
 649             ('test-toggle-action1', None, 'Test Toggle Action 1',
 650              None, None, test_action_callback_data, False),
 651             ('test-toggle-action2', Gtk.STOCK_COPY, 'Test Toggle Action 2',
 652               None, None, test_action_callback_data, True)], callback_data)
 653         action_group.add_radio_actions([
 654             ('test-radio-action1', None, 'Test Radio Action 1'),
 655             ('test-radio-action2', Gtk.STOCK_COPY, 'Test Radio Action 2')], 1,
 656             test_radio_action_callback_data,
 657             callback_data)
 658
 659         expected_results = [('test-action1', Gtk.Action),
 660                             ('test-action2', Gtk.Action),
 661                             ('test-toggle-action1', Gtk.ToggleAction),
 662                             ('test-toggle-action2', Gtk.ToggleAction),
 663                             ('test-radio-action1', Gtk.RadioAction),
 664                             ('test-radio-action2', Gtk.RadioAction)]
 665
 666         for action in action_group.list_actions():
 667             a = (action.get_name(), type(action))
 668             self.assertTrue(a in expected_results)
 669             expected_results.remove(a)
 670             action.activate()
 671
 672     def test_uimanager(self):
 673         self.assertEqual(Gtk.UIManager, overrides.Gtk.UIManager)
 674         ui = Gtk.UIManager()
 675         ui.add_ui_from_string(
 676 """
 677 <ui>
 678     <menubar name="menubar1"></menubar>
 679 </ui>
 680 """
 681 )
 682         menubar = ui.get_widget("/menubar1")
 683         self.assertEqual(type(menubar), Gtk.MenuBar)
 684
 685         ag = Gtk.ActionGroup(name="ag1")
 686         ui.insert_action_group(ag)
 687         ag2 = Gtk.ActionGroup(name="ag2")
 688         ui.insert_action_group(ag2)
 689         groups = ui.get_action_groups()
 690         self.assertEqual(ag, groups[-2])
 691         self.assertEqual(ag2, groups[-1])
 692
 693     def test_builder(self):
 694         self.assertEqual(Gtk.Builder, overrides.Gtk.Builder)
 695
 696         class SignalTest(GObject.GObject):
 697             __gtype_name__ = "GIOverrideSignalTest"
 698             __gsignals__ = {
 699                 "test-signal": (GObject.SignalFlags.RUN_FIRST,
 700                                 None,
 701                                 []),
 702             }
 703
 704         class SignalCheck:
 705             def __init__(self):
 706                 self.sentinel = 0
 707                 self.after_sentinel = 0
 708
 709             def on_signal_1(self, *args):
 710                 self.sentinel += 1
 711                 self.after_sentinel += 1
 712
 713             def on_signal_3(self, *args):
 714                 self.sentinel += 3
 715
 716             def on_signal_after(self, *args):
 717                 if self.after_sentinel == 1:
 718                     self.after_sentinel += 1
 719
 720         signal_checker = SignalCheck()
 721         builder = Gtk.Builder()
 722
 723         # add object1 to the builder
 724         builder.add_from_string(
 725 """
 726 <interface>
 727   <object class="GIOverrideSignalTest" id="object1">
 728       <signal name="test-signal" after="yes" handler="on_signal_after" />
 729       <signal name="test-signal" handler="on_signal_1" />
 730   </object>
 731 </interface>
 732 """)
 733
 734         # only add object3 to the builder
 735         builder.add_objects_from_string(
 736 """
 737 <interface>
 738   <object class="GIOverrideSignalTest" id="object2">
 739       <signal name="test-signal" handler="on_signal_2" />
 740   </object>
 741   <object class="GIOverrideSignalTest" id="object3">
 742       <signal name="test-signal" handler="on_signal_3" />
 743   </object>
 744   <object class="GIOverrideSignalTest" id="object4">
 745       <signal name="test-signal" handler="on_signal_4" />
 746   </object>
 747 </interface>
 748
 749 """,
 750             ['object3'])
 751
 752         # hook up signals
 753         builder.connect_signals(signal_checker)
 754
 755         # call their notify signals and check sentinel
 756         objects = builder.get_objects()
 757         self.assertEqual(len(objects), 2)
 758         for obj in objects:
 759             obj.emit('test-signal')
 760
 761         self.assertEqual(signal_checker.sentinel, 4)
 762         self.assertEqual(signal_checker.after_sentinel, 2)
 763
 764     def test_dialogs(self):
 765         self.assertEqual(Gtk.Dialog, overrides.Gtk.Dialog)
 766         self.assertEqual(Gtk.AboutDialog, overrides.Gtk.AboutDialog)
 767         self.assertEqual(Gtk.MessageDialog, overrides.Gtk.MessageDialog)
 768         self.assertEqual(Gtk.ColorSelectionDialog, overrides.Gtk.ColorSelectionDialog)
 769         self.assertEqual(Gtk.FileChooserDialog, overrides.Gtk.FileChooserDialog)
 770         self.assertEqual(Gtk.FontSelectionDialog, overrides.Gtk.FontSelectionDialog)
 771         self.assertEqual(Gtk.RecentChooserDialog, overrides.Gtk.RecentChooserDialog)
 772
 773         # Gtk.Dialog
 774         dialog = Gtk.Dialog(title='Foo',
 775                             flags=Gtk.DialogFlags.MODAL,
 776                             buttons=('test-button1', 1))
 777         self.assertTrue(isinstance(dialog, Gtk.Dialog))
 778         self.assertTrue(isinstance(dialog, Gtk.Window))
 779
 780         dialog.add_buttons('test-button2', 2, Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE)
 781
 782         self.assertEqual('Foo', dialog.get_title())
 783         self.assertTrue(dialog.get_modal())
 784         button = dialog.get_widget_for_response(1)
 785         self.assertEqual('test-button1', button.get_label())
 786         button = dialog.get_widget_for_response(2)
 787         self.assertEqual('test-button2', button.get_label())
 788         button = dialog.get_widget_for_response(Gtk.ResponseType.CLOSE)
 789         self.assertEqual(Gtk.STOCK_CLOSE, button.get_label())
 790
 791         # Gtk.AboutDialog
 792         dialog = Gtk.AboutDialog()
 793         self.assertTrue(isinstance(dialog, Gtk.Dialog))
 794         self.assertTrue(isinstance(dialog, Gtk.Window))
 795
 796         # Gtk.MessageDialog
 797         dialog = Gtk.MessageDialog(title='message dialog test',
 798                                    flags=Gtk.DialogFlags.MODAL,
 799                                    buttons=Gtk.ButtonsType.OK,
 800                                    message_format='dude!')
 801         self.assertTrue(isinstance(dialog, Gtk.Dialog))
 802         self.assertTrue(isinstance(dialog, Gtk.Window))
 803
 804         self.assertEqual('message dialog test', dialog.get_title())
 805         self.assertTrue(dialog.get_modal())
 806         text = dialog.get_property('text')
 807         self.assertEqual('dude!', text)
 808
 809         dialog.format_secondary_text('2nd text')
 810         self.assertEqual(dialog.get_property('secondary-text'), '2nd text')
 811         self.assertFalse(dialog.get_property('secondary-use-markup'))
 812
 813         dialog.format_secondary_markup('2nd markup')
 814         self.assertEqual(dialog.get_property('secondary-text'), '2nd markup')
 815         self.assertTrue(dialog.get_property('secondary-use-markup'))
 816
 817         # Gtk.ColorSelectionDialog
 818         dialog = Gtk.ColorSelectionDialog("color selection dialog test")
 819         self.assertTrue(isinstance(dialog, Gtk.Dialog))
 820         self.assertTrue(isinstance(dialog, Gtk.Window))
 821         self.assertEqual('color selection dialog test', dialog.get_title())
 822
 823         # Gtk.FileChooserDialog
 824         dialog = Gtk.FileChooserDialog(title='file chooser dialog test',
 825                                        buttons=('test-button1', 1),
 826                                        action=Gtk.FileChooserAction.SAVE)
 827         self.assertTrue(isinstance(dialog, Gtk.Dialog))
 828         self.assertTrue(isinstance(dialog, Gtk.Window))
 829
 830         dialog.add_buttons('test-button2', 2, Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE)
 831         self.assertEqual('file chooser dialog test', dialog.get_title())
 832         button = dialog.get_widget_for_response(1)
 833         self.assertEqual('test-button1', button.get_label())
 834         button = dialog.get_widget_for_response(2)
 835         self.assertEqual('test-button2', button.get_label())
 836         button = dialog.get_widget_for_response(Gtk.ResponseType.CLOSE)
 837         self.assertEqual(Gtk.STOCK_CLOSE, button.get_label())
 838         action = dialog.get_property('action')
 839         self.assertEqual(Gtk.FileChooserAction.SAVE, action)
 840
 841         # Gtk.FontSelectionDialog
 842         dialog = Gtk.ColorSelectionDialog("font selection dialog test")
 843         self.assertTrue(isinstance(dialog, Gtk.Dialog))
 844         self.assertTrue(isinstance(dialog, Gtk.Window))
 845         self.assertEqual('font selection dialog test', dialog.get_title())
 846
 847         # Gtk.RecentChooserDialog
 848         test_manager = Gtk.RecentManager()
 849         dialog = Gtk.RecentChooserDialog(title='recent chooser dialog test',
 850                                          buttons=('test-button1', 1),
 851                                          manager=test_manager)
 852         self.assertTrue(isinstance(dialog, Gtk.Dialog))
 853         self.assertTrue(isinstance(dialog, Gtk.Window))
 854
 855         dialog.add_buttons('test-button2', 2, Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE)
 856         self.assertEqual('recent chooser dialog test', dialog.get_title())
 857         button = dialog.get_widget_for_response(1)
 858         self.assertEqual('test-button1', button.get_label())
 859         button = dialog.get_widget_for_response(2)
 860         self.assertEqual('test-button2', button.get_label())
 861         button = dialog.get_widget_for_response(Gtk.ResponseType.CLOSE)
 862         self.assertEqual(Gtk.STOCK_CLOSE, button.get_label())
 863
 864     class TestClass(GObject.GObject):
 865         __gtype_name__ = "GIOverrideTreeAPITest"
 866
 867         def __init__(self, tester, int_value, string_value):
 868             super(TestGtk.TestClass, self).__init__()
 869             self.tester = tester
 870             self.int_value = int_value
 871             self.string_value = string_value
 872
 873         def check(self, int_value, string_value):
 874             self.tester.assertEqual(int_value, self.int_value)
 875             self.tester.assertEqual(string_value, self.string_value)
 876
 877     def test_tree_store(self):
 878         self.assertEqual(Gtk.TreeStore, overrides.Gtk.TreeStore)
 879         self.assertEqual(Gtk.ListStore, overrides.Gtk.ListStore)
 880         self.assertEqual(Gtk.TreeModel, overrides.Gtk.TreeModel)
 881         self.assertEqual(Gtk.TreeViewColumn, overrides.Gtk.TreeViewColumn)
 882
 883         class TestPyObject(object):
 884             pass
 885
 886         test_pyobj = TestPyObject()
 887         test_pydict = {1: 1, "2": 2, "3": "3"}
 888         test_pylist = [1, "2", "3"]
 889         tree_store = Gtk.TreeStore(int,
 890                                    'gchararray',
 891                                    TestGtk.TestClass,
 892                                    GObject.TYPE_PYOBJECT,
 893                                    object,
 894                                    object,
 895                                    object,
 896                                    bool,
 897                                    bool,
 898                                    GObject.TYPE_UINT,
 899                                    GObject.TYPE_ULONG,
 900                                    GObject.TYPE_INT64,
 901                                    GObject.TYPE_UINT64,
 902                                    GObject.TYPE_UCHAR,
 903                                    GObject.TYPE_CHAR)
 904
 905         parent = None
 906         for i in range(97):
 907             label = 'this is child #%d' % i
 908             testobj = TestGtk.TestClass(self, i, label)
 909             parent = tree_store.append(parent, (i,
 910                                                 label,
 911                                                 testobj,
 912                                                 testobj,
 913                                                 test_pyobj,
 914                                                 test_pydict,
 915                                                 test_pylist,
 916                                                 i % 2,
 917                                                 bool(i % 2),
 918                                                 i,
 919                                                 GObject.G_MAXULONG,
 920                                                 GObject.G_MININT64,
 921                                                 0xffffffffffffffff,
 922                                                 254,
 923                                                 _bytes('a')
 924                                                 ))
 925         # test set
 926         parent = tree_store.append(parent)
 927         i = 97
 928         label = 'this is child #%d' % i
 929         testobj = TestGtk.TestClass(self, i, label)
 930         tree_store.set(parent, 0, i,
 931                                2, testobj,
 932                                1, label,
 933                                3, testobj,
 934                                4, test_pyobj,
 935                                5, test_pydict,
 936                                6, test_pylist,
 937                                7, i % 2,
 938                                8, bool(i % 2),
 939                                9, i,
 940                                10, GObject.G_MAXULONG,
 941                                11, GObject.G_MININT64,
 942                                12, 0xffffffffffffffff,
 943                                13, 254,
 944                                14, _bytes('a'))
 945
 946         parent = tree_store.append(parent)
 947         i = 98
 948         label = 'this is child #%d' % i
 949         testobj = TestGtk.TestClass(self, i, label)
 950         tree_store.set(parent, {0: i,
 951                                 2: testobj,
 952                                 1: label,
 953                                 3: testobj,
 954                                 4: test_pyobj,
 955                                 5: test_pydict,
 956                                 6: test_pylist,
 957                                 7: i % 2,
 958                                 8: bool(i % 2),
 959                                 9: i,
 960                                 10: GObject.G_MAXULONG,
 961                                 11: GObject.G_MININT64,
 962                                 12: 0xffffffffffffffff,
 963                                 13: 254,
 964                                 14: _bytes('a')})
 965
 966         parent = tree_store.append(parent)
 967         i = 99
 968         label = 'this is child #%d' % i
 969         testobj = TestGtk.TestClass(self, i, label)
 970         tree_store.set(parent, (0, 2, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14),
 971                                (i,
 972                                 testobj,
 973                                 label,
 974                                 testobj,
 975                                 test_pyobj,
 976                                 test_pydict,
 977                                 test_pylist,
 978                                 i % 2,
 979                                 bool(i % 2),
 980                                 i,
 981                                 GObject.G_MAXULONG,
 982                                 GObject.G_MININT64,
 983                                 0xffffffffffffffff,
 984                                 254,
 985                                 _bytes('a')))
 986
 987         # len gets the number of children in the root node
 988         # since we kept appending to the previous node
 989         # there should only be one child of the root
 990         self.assertEqual(len(tree_store), 1)
 991
 992         # walk the tree to see if the values were stored correctly
 993         parent = None
 994         i = 0
 995
 996         treeiter = tree_store.iter_children(parent)
 997         while treeiter:
 998             i = tree_store.get_value(treeiter, 0)
 999             s = tree_store.get_value(treeiter, 1)
1000             obj = tree_store.get_value(treeiter, 2)
1001             obj.check(i, s)
1002             obj2 = tree_store.get_value(treeiter, 3)
1003             self.assertEqual(obj, obj2)
1004
1005             pyobj = tree_store.get_value(treeiter, 4)
1006             self.assertEqual(pyobj, test_pyobj)
1007             pydict = tree_store.get_value(treeiter, 5)
1008             self.assertEqual(pydict, test_pydict)
1009             pylist = tree_store.get_value(treeiter, 6)
1010             self.assertEqual(pylist, test_pylist)
1011
1012             bool_1 = tree_store.get_value(treeiter, 7)
1013             bool_2 = tree_store.get_value(treeiter, 8)
1014             self.assertEqual(bool_1, bool_2)
1015             self.assertTrue(isinstance(bool_1, bool))
1016             self.assertTrue(isinstance(bool_2, bool))
1017
1018             uint_ = tree_store.get_value(treeiter, 9)
1019             self.assertEqual(uint_, i)
1020             ulong_ = tree_store.get_value(treeiter, 10)
1021             self.assertEqual(ulong_, GObject.G_MAXULONG)
1022             int64_ = tree_store.get_value(treeiter, 11)
1023             self.assertEqual(int64_, GObject.G_MININT64)
1024             uint64_ = tree_store.get_value(treeiter, 12)
1025             self.assertEqual(uint64_, 0xffffffffffffffff)
1026             uchar_ = tree_store.get_value(treeiter, 13)
1027             self.assertEqual(ord(uchar_), 254)
1028             char_ = tree_store.get_value(treeiter, 14)
1029             self.assertEqual(char_, 'a')
1030
1031             parent = treeiter
1032             treeiter = tree_store.iter_children(parent)
1033
1034         self.assertEqual(i, 99)
1035
1036     def test_tree_store_signals(self):
1037         tree_store = Gtk.TreeStore(int, bool)
1038
1039         def on_row_inserted(tree_store, tree_path, tree_iter, signal_list):
1040             signal_list.append('row-inserted')
1041
1042         def on_row_changed(tree_store, tree_path, tree_iter, signal_list):
1043             signal_list.append('row-changed')
1044
1045         signals = []
1046         tree_store.connect('row-inserted', on_row_inserted, signals)
1047         tree_store.connect('row-changed', on_row_changed, signals)
1048
1049         # adding rows with and without data should only call one signal
1050         tree_store.append(None, (0, False))
1051         self.assertEqual(signals, ['row-inserted'])
1052
1053         signals.pop()
1054         tree_store.append(None)
1055         self.assertEqual(signals, ['row-inserted'])
1056
1057         signals.pop()
1058         tree_store.prepend(None, (0, False))
1059         self.assertEqual(signals, ['row-inserted'])
1060
1061         signals.pop()
1062         tree_store.prepend(None)
1063         self.assertEqual(signals, ['row-inserted'])
1064
1065         signals.pop()
1066         tree_store.insert(None, 1, (0, False))
1067         self.assertEqual(signals, ['row-inserted'])
1068
1069         signals.pop()
1070         tree_store.insert(None, 1)
1071         self.assertEqual(signals, ['row-inserted'])
1072
1073     def test_list_store(self):
1074         class TestPyObject(object):
1075             pass
1076
1077         test_pyobj = TestPyObject()
1078         test_pydict = {1: 1, "2": 2, "3": "3"}
1079         test_pylist = [1, "2", "3"]
1080
1081         list_store = Gtk.ListStore(int, str, 'GIOverrideTreeAPITest', object, object, object, bool, bool)
1082         for i in range(1, 93):
1083             label = 'this is row #%d' % i
1084             testobj = TestGtk.TestClass(self, i, label)
1085             list_store.append((i,
1086                                label,
1087                                testobj,
1088                                test_pyobj,
1089                                test_pydict,
1090                                test_pylist,
1091                                i % 2,
1092                                bool(i % 2)))
1093
1094         i = 93
1095         label = _unicode('this is row #93')
1096         treeiter = list_store.append()
1097         list_store.set_value(treeiter, 0, i)
1098         list_store.set_value(treeiter, 1, label)
1099         list_store.set_value(treeiter, 2, TestGtk.TestClass(self, i, label))
1100         list_store.set_value(treeiter, 3, test_pyobj)
1101         list_store.set_value(treeiter, 4, test_pydict)
1102         list_store.set_value(treeiter, 5, test_pylist)
1103         list_store.set_value(treeiter, 6, 1)
1104         list_store.set_value(treeiter, 7, True)
1105
1106         # test prepend
1107         label = 'this is row #0'
1108         list_store.prepend((0,
1109                             label,
1110                             TestGtk.TestClass(self, 0, label),
1111                             test_pyobj,
1112                             test_pydict,
1113                             test_pylist,
1114                             0,
1115                             False))
1116
1117         # test automatic unicode->str conversion
1118         i = 94
1119         label = _unicode('this is row #94')
1120         treeiter = list_store.append((i,
1121                                       label,
1122                                       TestGtk.TestClass(self, i, label),
1123                                       test_pyobj,
1124                                       test_pydict,
1125                                       test_pylist,
1126                                       0,
1127                                       False))
1128
1129         # add sorted items out of order to test insert* apis
1130         # also test sending in None to not set a column
1131         i = 97
1132         label = 'this is row #97'
1133         treeiter = list_store.append((None,
1134                                       None,
1135                                       None,
1136                                       test_pyobj,
1137                                       None,
1138                                       test_pylist,
1139                                       1,
1140                                       None))
1141
1142         list_store.set_value(treeiter, 0, i)
1143         list_store.set_value(treeiter, 1, label)
1144         list_store.set_value(treeiter, 2, TestGtk.TestClass(self, i, label))
1145         list_store.set_value(treeiter, 4, test_pydict)
1146         list_store.set_value(treeiter, 7, True)
1147
1148         # this should append
1149         i = 99
1150         label = 'this is row #99'
1151         list_store.insert(9999, (i,
1152                                  label,
1153                                  TestGtk.TestClass(self, i, label),
1154                                  test_pyobj,
1155                                  test_pydict,
1156                                  test_pylist,
1157                                  1,
1158                                  True))
1159
1160         i = 96
1161         label = 'this is row #96'
1162         list_store.insert_before(treeiter, (i,
1163                                             label,
1164                                             TestGtk.TestClass(self, i, label),
1165                                             test_pyobj,
1166                                             test_pydict,
1167                                             test_pylist,
1168                                             0,
1169                                             False))
1170
1171         i = 98
1172         label = 'this is row #98'
1173         list_store.insert_after(treeiter, (i,
1174                                            label,
1175                                            TestGtk.TestClass(self, i, label),
1176                                            test_pyobj,
1177                                            test_pydict,
1178                                            test_pylist,
1179                                            0,
1180                                            False))
1181
1182         i = 95
1183         label = 'this is row #95'
1184         list_store.insert(95, (i,
1185                                label,
1186                                TestGtk.TestClass(self, i, label),
1187                                test_pyobj,
1188                                test_pydict,
1189                                test_pylist,
1190                                1,
1191                                True))
1192
1193         i = 100
1194         label = 'this is row #100'
1195         treeiter = list_store.append()
1196         list_store.set(treeiter, 1, label,
1197                                  0, i,
1198                                  2, TestGtk.TestClass(self, i, label),
1199                                  3, test_pyobj,
1200                                  4, test_pydict,
1201                                  5, test_pylist,
1202                                  6, 0,
1203                                  7, False)
1204         i = 101
1205         label = 'this is row #101'
1206         treeiter = list_store.append()
1207         list_store.set(treeiter, {1: label,
1208                                   0: i,
1209                                   2: TestGtk.TestClass(self, i, label),
1210                                   3: test_pyobj,
1211                                   4: test_pydict,
1212                                   5: test_pylist,
1213                                   6: 1,
1214                                   7: True})
1215         i = 102
1216         label = 'this is row #102'
1217         treeiter = list_store.append()
1218         list_store.set(treeiter, (1, 0, 2, 3, 4, 5, 6, 7),
1219                                   (label,
1220                                    i,
1221                                    TestGtk.TestClass(self, i, label),
1222                                    test_pyobj,
1223                                    test_pydict,
1224                                    test_pylist,
1225                                    0,
1226                                    False))
1227
1228         self.assertEqual(len(list_store), 103)
1229
1230         # walk the list to see if the values were stored correctly
1231         i = 0
1232         treeiter = list_store.get_iter_first()
1233
1234         counter = 0
1235         while treeiter:
1236             i = list_store.get_value(treeiter, 0)
1237             self.assertEqual(i, counter)
1238             s = list_store.get_value(treeiter, 1)
1239             obj = list_store.get_value(treeiter, 2)
1240             obj.check(i, s)
1241
1242             pyobj = list_store.get_value(treeiter, 3)
1243             self.assertEqual(pyobj, test_pyobj)
1244             pydict = list_store.get_value(treeiter, 4)
1245             self.assertEqual(pydict, test_pydict)
1246             pylist = list_store.get_value(treeiter, 5)
1247             self.assertEqual(pylist, test_pylist)
1248
1249             bool_1 = list_store.get_value(treeiter, 6)
1250             bool_2 = list_store.get_value(treeiter, 7)
1251             self.assertEqual(bool_1, bool_2)
1252             self.assertTrue(isinstance(bool_1, bool))
1253             self.assertTrue(isinstance(bool_2, bool))
1254
1255             treeiter = list_store.iter_next(treeiter)
1256
1257             counter += 1
1258
1259         self.assertEqual(i, 102)
1260
1261     def test_list_store_sort(self):
1262         def comp1(model, row1, row2, user_data):
1263             v1 = model[row1][1]
1264             v2 = model[row2][1]
1265
1266             # make "m" smaller than anything else
1267             if v1.startswith('m') and not v2.startswith('m'):
1268                 return -1
1269             if v2.startswith('m') and not v1.startswith('m'):
1270                 return 1
1271             return (v1 > v2) - (v1 < v2)
1272
1273         list_store = Gtk.ListStore(int, str)
1274         list_store.set_sort_func(2, comp1, None)
1275         list_store.append((1, 'apples'))
1276         list_store.append((3, 'oranges'))
1277         list_store.append((2, 'mango'))
1278
1279         # not sorted yet, should be original order
1280         self.assertEqual([list(i) for i in list_store],
1281                 [[1, 'apples'], [3, 'oranges'], [2, 'mango']])
1282
1283         # sort with our custom function
1284         list_store.set_sort_column_id(2, Gtk.SortType.ASCENDING)
1285         self.assertEqual([list(i) for i in list_store],
1286                 [[2, 'mango'], [1, 'apples'], [3, 'oranges']])
1287
1288         list_store.set_sort_column_id(2, Gtk.SortType.DESCENDING)
1289         self.assertEqual([list(i) for i in list_store],
1290                 [[3, 'oranges'], [1, 'apples'], [2, 'mango']])
1291
1292     def test_list_store_signals(self):
1293         list_store = Gtk.ListStore(int, bool)
1294
1295         def on_row_inserted(list_store, tree_path, tree_iter, signal_list):
1296             signal_list.append('row-inserted')
1297
1298         def on_row_changed(list_store, tree_path, tree_iter, signal_list):
1299             signal_list.append('row-changed')
1300
1301         signals = []
1302         list_store.connect('row-inserted', on_row_inserted, signals)
1303         list_store.connect('row-changed', on_row_changed, signals)
1304
1305         # adding rows with and without data should only call one signal
1306         list_store.append((0, False))
1307         self.assertEqual(signals, ['row-inserted'])
1308
1309         signals.pop()
1310         list_store.append()
1311         self.assertEqual(signals, ['row-inserted'])
1312
1313         signals.pop()
1314         list_store.prepend((0, False))
1315         self.assertEqual(signals, ['row-inserted'])
1316
1317         signals.pop()
1318         list_store.prepend()
1319         self.assertEqual(signals, ['row-inserted'])
1320
1321         signals.pop()
1322         list_store.insert(1, (0, False))
1323         self.assertEqual(signals, ['row-inserted'])
1324
1325         signals.pop()
1326         list_store.insert(1)
1327         self.assertEqual(signals, ['row-inserted'])
1328
1329     def test_tree_path(self):
1330         p1 = Gtk.TreePath()
1331         p2 = Gtk.TreePath.new_first()
1332         self.assertEqual(p1, p2)
1333         self.assertEqual(str(p1), '0')
1334         p1 = Gtk.TreePath(2)
1335         p2 = Gtk.TreePath.new_from_string('2')
1336         self.assertEqual(p1, p2)
1337         self.assertEqual(str(p1), '2')
1338         p1 = Gtk.TreePath('1:2:3')
1339         p2 = Gtk.TreePath.new_from_string('1:2:3')
1340         self.assertEqual(p1, p2)
1341         self.assertEqual(str(p1), '1:2:3')
1342         p1 = Gtk.TreePath((1, 2, 3))
1343         p2 = Gtk.TreePath.new_from_string('1:2:3')
1344         self.assertEqual(p1, p2)
1345         self.assertEqual(str(p1), '1:2:3')
1346         self.assertTrue(p1 != None)
1347         self.assertFalse(p1 == None)
1348         self.assertTrue(p1 > None)
1349         self.assertTrue(p1 >= None)
1350         self.assertFalse(p1 < None)
1351         self.assertFalse(p1 <= None)
1352
1353         self.assertEqual(tuple(p1), (1, 2, 3))
1354
1355     def test_tree_model(self):
1356         tree_store = Gtk.TreeStore(int, str)
1357
1358         self.assertTrue(tree_store)
1359         self.assertEqual(len(tree_store), 0)
1360         self.assertEqual(tree_store.get_iter_first(), None)
1361
1362         def get_by_index(row, col=None):
1363             if col:
1364                 return tree_store[row][col]
1365             else:
1366                 return tree_store[row]
1367
1368         self.assertRaises(TypeError, get_by_index, None)
1369         self.assertRaises(TypeError, get_by_index, "")
1370         self.assertRaises(TypeError, get_by_index, ())
1371
1372         self.assertRaises(IndexError, get_by_index, "0")
1373         self.assertRaises(IndexError, get_by_index, 0)
1374         self.assertRaises(IndexError, get_by_index, (0,))
1375
1376         self.assertRaises(ValueError, tree_store.get_iter, "0")
1377         self.assertRaises(ValueError, tree_store.get_iter, 0)
1378         self.assertRaises(ValueError, tree_store.get_iter, (0,))
1379
1380         self.assertRaises(ValueError, tree_store.get_iter_from_string, "0")
1381
1382         for row in tree_store:
1383             self.fail("Should not be reached")
1384
1385         class DerivedIntType(int):
1386             pass
1387
1388         class DerivedStrType(str):
1389             pass
1390
1391         for i in range(100):
1392             label = 'this is row #%d' % i
1393             parent = tree_store.append(None, (DerivedIntType(i), DerivedStrType(label),))
1394             self.assertNotEqual(parent, None)
1395             for j in range(20):
1396                 label = 'this is child #%d of node #%d' % (j, i)
1397                 child = tree_store.append(parent, (j, label,))
1398                 self.assertNotEqual(child, None)
1399
1400         self.assertTrue(tree_store)
1401         self.assertEqual(len(tree_store), 100)
1402
1403         self.assertEqual(tree_store.iter_previous(tree_store.get_iter(0)), None)
1404
1405         for i, row in enumerate(tree_store):
1406             self.assertEqual(row.model, tree_store)
1407             self.assertEqual(row.parent, None)
1408
1409             self.assertEqual(tree_store[i].path, row.path)
1410             self.assertEqual(tree_store[str(i)].path, row.path)
1411             self.assertEqual(tree_store[(i,)].path, row.path)
1412
1413             self.assertEqual(tree_store[i][0], i)
1414             self.assertEqual(tree_store[i][1], "this is row #%d" % i)
1415
1416             aiter = tree_store.get_iter(i)
1417             self.assertEqual(tree_store.get_path(aiter), row.path)
1418
1419             aiter = tree_store.get_iter(str(i))
1420             self.assertEqual(tree_store.get_path(aiter), row.path)
1421
1422             aiter = tree_store.get_iter((i,))
1423             self.assertEqual(tree_store.get_path(aiter), row.path)
1424
1425             self.assertEqual(tree_store.iter_parent(aiter), row.parent)
1426
1427             next = tree_store.iter_next(aiter)
1428             if i < len(tree_store) - 1:
1429                 self.assertEqual(tree_store.get_path(next), row.next.path)
1430                 self.assertEqual(tree_store.get_path(tree_store.iter_previous(next)),
1431                                  tree_store.get_path(aiter))
1432             else:
1433                 self.assertEqual(next, None)
1434
1435             self.assertEqual(tree_store.iter_n_children(row.iter), 20)
1436
1437             child = tree_store.iter_children(row.iter)
1438             for j, childrow in enumerate(row.iterchildren()):
1439                 child_path = tree_store.get_path(child)
1440                 self.assertEqual(childrow.path, child_path)
1441                 self.assertEqual(childrow.parent.path, row.path)
1442                 self.assertEqual(childrow.path, tree_store[child].path)
1443                 self.assertEqual(childrow.path, tree_store[child_path].path)
1444
1445                 self.assertEqual(childrow[0], tree_store[child][0])
1446                 self.assertEqual(childrow[0], j)
1447                 self.assertEqual(childrow[1], tree_store[child][1])
1448                 self.assertEqual(childrow[1], 'this is child #%d of node #%d' % (j, i))
1449
1450                 self.assertRaises(IndexError, get_by_index, child, 2)
1451
1452                 tree_store[child][1] = 'this was child #%d of node #%d' % (j, i)
1453                 self.assertEqual(childrow[1], 'this was child #%d of node #%d' % (j, i))
1454
1455                 nth_child = tree_store.iter_nth_child(row.iter, j)
1456                 self.assertEqual(childrow.path, tree_store.get_path(nth_child))
1457
1458                 childrow2 = tree_store["%d:%d" % (i, j)]
1459                 self.assertEqual(childrow.path, childrow2.path)
1460
1461                 childrow2 = tree_store[(i, j,)]
1462                 self.assertEqual(childrow.path, childrow2.path)
1463
1464                 child = tree_store.iter_next(child)
1465                 if j < 19:
1466                     self.assertEqual(childrow.next.path, tree_store.get_path(child))
1467                 else:
1468                     self.assertEqual(child, childrow.next)
1469                     self.assertEqual(child, None)
1470
1471             self.assertEqual(j, 19)
1472
1473         self.assertEqual(i, 99)
1474
1475         # negative indices
1476         for i in range(-1, -100, -1):
1477             i_real = i + 100
1478             self.assertEqual(tree_store[i][0], i_real)
1479
1480             row = tree_store[i]
1481             for j in range(-1, -20, -1):
1482                 j_real = j + 20
1483                 path = (i_real, j_real,)
1484
1485                 self.assertEqual(tree_store[path][-2], j_real)
1486
1487                 label = 'this was child #%d of node #%d' % (j_real, i_real)
1488                 self.assertEqual(tree_store[path][-1], label)
1489
1490                 new_label = 'this still is child #%d of node #%d' % (j_real, i_real)
1491                 tree_store[path][-1] = new_label
1492                 self.assertEqual(tree_store[path][-1], new_label)
1493
1494                 self.assertRaises(IndexError, get_by_index, path, -3)
1495
1496         self.assertRaises(IndexError, get_by_index, -101)
1497
1498         last_row = tree_store[99]
1499         self.assertNotEqual(last_row, None)
1500
1501         for i, childrow in enumerate(last_row.iterchildren()):
1502             if i < 19:
1503                 self.assertTrue(tree_store.remove(childrow.iter))
1504             else:
1505                 self.assertFalse(tree_store.remove(childrow.iter))
1506
1507         self.assertEqual(i, 19)
1508
1509         self.assertEqual(tree_store.iter_n_children(last_row.iter), 0)
1510         for childrow in last_row.iterchildren():
1511             self.fail("Should not be reached")
1512
1513         aiter = tree_store.get_iter(10)
1514         self.assertRaises(TypeError, tree_store.get, aiter, 1, 'a')
1515         self.assertRaises(ValueError, tree_store.get, aiter, 1, -1)
1516         self.assertRaises(ValueError, tree_store.get, aiter, 1, 100)
1517         self.assertEqual(tree_store.get(aiter, 0, 1), (10, 'this is row #10'))
1518
1519         # check __delitem__
1520         self.assertEqual(len(tree_store), 100)
1521         aiter = tree_store.get_iter(10)
1522         del tree_store[aiter]
1523         self.assertEqual(len(tree_store), 99)
1524         self.assertRaises(TypeError, tree_store.__delitem__, None)
1525         self.assertRaises(IndexError, tree_store.__delitem__, -101)
1526         self.assertRaises(IndexError, tree_store.__delitem__, 101)
1527
1528     def test_tree_model_edit(self):
1529         model = Gtk.ListStore(int, str, float)
1530         model.append([1, "one", -0.1])
1531         model.append([2, "two", -0.2])
1532
1533         def set_row(value):
1534             model[1] = value
1535
1536         self.assertRaises(TypeError, set_row, 3)
1537         self.assertRaises(TypeError, set_row, "three")
1538         self.assertRaises(ValueError, set_row, [])
1539         self.assertRaises(ValueError, set_row, [3, "three"])
1540
1541         model[0] = (3, "three", -0.3)
1542
1543     def test_tree_row_slice(self):
1544         model = Gtk.ListStore(int, str, float)
1545         model.append([1, "one", -0.1])
1546
1547         self.assertEqual([1, "one", -0.1], model[0][:])
1548         self.assertEqual([1, "one"], model[0][:2])
1549         self.assertEqual(["one", -0.1], model[0][1:])
1550         self.assertEqual(["one"], model[0][1:-1])
1551         self.assertEqual([1], model[0][:-2])
1552         self.assertEqual([], model[0][5:])
1553         self.assertEqual([1, -0.1], model[0][0:3:2])
1554
1555         model[0][:] = (2, "two", -0.2)
1556         self.assertEqual([2, "two", -0.2], model[0][:])
1557
1558         model[0][:2] = (3, "three")
1559         self.assertEqual([3, "three", -0.2], model[0][:])
1560
1561         model[0][1:] = ("four", -0.4)
1562         self.assertEqual([3, "four", -0.4], model[0][:])
1563
1564         model[0][1:-1] = ("five",)
1565         self.assertEqual([3, "five", -0.4], model[0][:])
1566
1567         model[0][0:3:2] = (6, -0.6)
1568         self.assertEqual([6, "five", -0.6], model[0][:])
1569
1570         def set_row1():
1571             model[0][5:] = ("doesn't", "matter",)
1572
1573         self.assertRaises(ValueError, set_row1)
1574
1575         def set_row2():
1576             model[0][:1] = (0, "zero", 0)
1577
1578         self.assertRaises(ValueError, set_row2)
1579
1580         def set_row3():
1581             model[0][:2] = ("0", 0)
1582
1583         self.assertRaises(ValueError, set_row3)
1584
1585     def test_tree_view(self):
1586         store = Gtk.ListStore(int, str)
1587         store.append((0, "foo"))
1588         store.append((1, "bar"))
1589         view = Gtk.TreeView()
1590         # FIXME: We can't easily call get_cursor() to make sure this works as
1591         # expected as we need to realize and focus the column; the following
1592         # will raise a Gtk-CRITICAL which we ignore for now
1593         old_mask = GLib.log_set_always_fatal(
1594             GLib.LogLevelFlags.LEVEL_WARNING | GLib.LogLevelFlags.LEVEL_ERROR)
1595         view.set_cursor(store[1].path)
1596         view.set_cursor(str(store[1].path))
1597
1598         view.get_cell_area(store[1].path)
1599         view.get_cell_area(str(store[1].path))
1600
1601         GLib.log_set_always_fatal(old_mask)
1602
1603     def test_tree_view_column(self):
1604         cell = Gtk.CellRendererText()
1605         Gtk.TreeViewColumn(title='This is just a test',
1606                            cell_renderer=cell,
1607                            text=0,
1608                            style=2)
1609
1610     def test_tree_selection(self):
1611         store = Gtk.ListStore(int, str)
1612         for i in range(10):
1613             store.append((i, "foo"))
1614         view = Gtk.TreeView()
1615         view.set_model(store)
1616         firstpath = store.get_path(store.get_iter_first())
1617         sel = view.get_selection()
1618
1619         sel.select_path(firstpath)
1620         (m, s) = sel.get_selected()
1621         self.assertEqual(m, store)
1622         self.assertEqual(store.get_path(s), firstpath)
1623
1624         sel.select_path(0)
1625         (m, s) = sel.get_selected()
1626         self.assertEqual(m, store)
1627         self.assertEqual(store.get_path(s), firstpath)
1628
1629         sel.select_path("0:0")
1630         (m, s) = sel.get_selected()
1631         self.assertEqual(m, store)
1632         self.assertEqual(store.get_path(s), firstpath)
1633
1634         sel.select_path((0, 0))
1635         (m, s) = sel.get_selected()
1636         self.assertEqual(m, store)
1637         self.assertEqual(store.get_path(s), firstpath)
1638
1639     def test_text_buffer(self):
1640         self.assertEqual(Gtk.TextBuffer, overrides.Gtk.TextBuffer)
1641         buffer = Gtk.TextBuffer()
1642         tag = buffer.create_tag('title', font='Sans 18')
1643
1644         self.assertEqual(tag.props.name, 'title')
1645         self.assertEqual(tag.props.font, 'Sans 18')
1646
1647         (start, end) = buffer.get_bounds()
1648
1649         mark = buffer.create_mark(None, start)
1650         self.assertFalse(mark.get_left_gravity())
1651
1652         buffer.set_text('Hello Jane Hello Bob')
1653         (start, end) = buffer.get_bounds()
1654         text = buffer.get_text(start, end, False)
1655         self.assertEqual(text, 'Hello Jane Hello Bob')
1656
1657         buffer.set_text('')
1658         (start, end) = buffer.get_bounds()
1659         text = buffer.get_text(start, end, False)
1660         self.assertEqual(text, '')
1661
1662         buffer.insert(end, 'HelloHello')
1663         buffer.insert(end, ' Bob')
1664
1665         cursor_iter = end.copy()
1666         cursor_iter.backward_chars(9)
1667         buffer.place_cursor(cursor_iter)
1668         buffer.insert_at_cursor(' Jane ')
1669
1670         (start, end) = buffer.get_bounds()
1671         text = buffer.get_text(start, end, False)
1672         self.assertEqual(text, 'Hello Jane Hello Bob')
1673
1674         sel = buffer.get_selection_bounds()
1675         self.assertEqual(sel, ())
1676         buffer.select_range(start, end)
1677         sel = buffer.get_selection_bounds()
1678         self.assertTrue(sel[0].equal(start))
1679         self.assertTrue(sel[1].equal(end))
1680
1681         buffer.set_text('')
1682         buffer.insert_with_tags(buffer.get_start_iter(), 'HelloHello', tag)
1683         (start, end) = buffer.get_bounds()
1684         self.assertTrue(start.begins_tag(tag))
1685         self.assertTrue(start.has_tag(tag))
1686
1687         buffer.set_text('')
1688         buffer.insert_with_tags_by_name(buffer.get_start_iter(), 'HelloHello', 'title')
1689         (start, end) = buffer.get_bounds()
1690         self.assertTrue(start.begins_tag(tag))
1691         self.assertTrue(start.has_tag(tag))
1692
1693         self.assertRaises(ValueError, buffer.insert_with_tags_by_name,
1694                 buffer.get_start_iter(), 'HelloHello', 'unknowntag')
1695
1696     def test_text_iter(self):
1697         self.assertEqual(Gtk.TextIter, overrides.Gtk.TextIter)
1698         buffer = Gtk.TextBuffer()
1699         buffer.set_text('Hello Jane Hello Bob')
1700         tag = buffer.create_tag('title', font='Sans 18')
1701         (start, end) = buffer.get_bounds()
1702         start.forward_chars(10)
1703         buffer.apply_tag(tag, start, end)
1704         self.assertTrue(start.begins_tag())
1705         self.assertTrue(end.ends_tag())
1706         self.assertTrue(start.toggles_tag())
1707         self.assertTrue(end.toggles_tag())
1708         start.backward_chars(1)
1709         self.assertFalse(start.begins_tag())
1710         self.assertFalse(start.ends_tag())
1711         self.assertFalse(start.toggles_tag())
1712
1713     def test_buttons(self):
1714         self.assertEqual(Gtk.Button, overrides.Gtk.Button)
1715
1716         # test Gtk.Button
1717         button = Gtk.Button()
1718         self.assertTrue(isinstance(button, Gtk.Button))
1719         self.assertTrue(isinstance(button, Gtk.Container))
1720         self.assertTrue(isinstance(button, Gtk.Widget))
1721         button = Gtk.Button(stock=Gtk.STOCK_CLOSE)
1722         self.assertEqual(Gtk.STOCK_CLOSE, button.get_label())
1723         self.assertTrue(button.get_use_stock())
1724         self.assertTrue(button.get_use_underline())
1725
1726         # test Gtk.Button use_stock
1727         button = Gtk.Button(label=Gtk.STOCK_CLOSE, use_stock=True, use_underline=True)
1728         self.assertEqual(Gtk.STOCK_CLOSE, button.get_label())
1729         self.assertTrue(button.get_use_stock())
1730         self.assertTrue(button.get_use_underline())
1731
1732         # test Gtk.LinkButton
1733         self.assertRaises(TypeError, Gtk.LinkButton)
1734         button = Gtk.LinkButton('http://www.Gtk.org', 'Gtk')
1735         self.assertTrue(isinstance(button, Gtk.Button))
1736         self.assertTrue(isinstance(button, Gtk.Container))
1737         self.assertTrue(isinstance(button, Gtk.Widget))
1738         self.assertEqual('http://www.Gtk.org', button.get_uri())
1739         self.assertEqual('Gtk', button.get_label())
1740
1741     def test_inheritance(self):
1742         for name in overrides.Gtk.__all__:
1743             over = getattr(overrides.Gtk, name)
1744             for element in dir(Gtk):
1745                 try:
1746                     klass = getattr(Gtk, element)
1747                     info = klass.__info__
1748                 except (NotImplementedError, AttributeError):
1749                     continue
1750
1751                 # Get all parent classes and interfaces klass inherits from
1752                 if isinstance(info, gi.types.ObjectInfo):
1753                     classes = list(info.get_interfaces())
1754                     parent = info.get_parent()
1755                     while parent.get_name() != "Object":
1756                         classes.append(parent)
1757                         parent = parent.get_parent()
1758                     classes = [kl for kl in classes if kl.get_namespace() == "Gtk"]
1759                 else:
1760                     continue
1761
1762                 for kl in classes:
1763                     if kl.get_name() == name:
1764                         self.assertTrue(issubclass(klass, over,),
1765                             "%r does not inherit from override %r" % (klass, over,))
1766
1767     def test_editable(self):
1768         self.assertEqual(Gtk.Editable, overrides.Gtk.Editable)
1769
1770         # need to use Gtk.Entry because Editable is an interface
1771         entry = Gtk.Entry()
1772         pos = entry.insert_text('HeWorld', 0)
1773         self.assertEqual(pos, 7)
1774         pos = entry.insert_text('llo ', 2)
1775         self.assertEqual(pos, 6)
1776         text = entry.get_chars(0, 11)
1777         self.assertEqual('Hello World', text)
1778
1779     def test_label(self):
1780         label = Gtk.Label(label='Hello')
1781         self.assertTrue(isinstance(label, Gtk.Widget))
1782         self.assertEqual(label.get_text(), 'Hello')
1783
1784     def adjustment_check(self, adjustment, value=0.0, lower=0.0, upper=0.0,
1785                          step_increment=0.0, page_increment=0.0, page_size=0.0):
1786         self.assertEqual(adjustment.get_value(), value)
1787         self.assertEqual(adjustment.get_lower(), lower)
1788         self.assertEqual(adjustment.get_upper(), upper)
1789         self.assertEqual(adjustment.get_step_increment(), step_increment)
1790         self.assertEqual(adjustment.get_page_increment(), page_increment)
1791         self.assertEqual(adjustment.get_page_size(), page_size)
1792
1793     def test_adjustment(self):
1794         adjustment = Gtk.Adjustment(1, 0, 6, 4, 5, 3)
1795         self.adjustment_check(adjustment, 1, 0, 6, 4, 5, 3)
1796
1797         adjustment = Gtk.Adjustment(1, 0, 6, 4, 5)
1798         self.adjustment_check(adjustment, 1, 0, 6, 4, 5)
1799
1800         adjustment = Gtk.Adjustment(1, 0, 6, 4)
1801         self.adjustment_check(adjustment, 1, 0, 6, 4)
1802
1803         adjustment = Gtk.Adjustment(1, 0, 6)
1804         self.adjustment_check(adjustment, 1, 0, 6)
1805
1806         adjustment = Gtk.Adjustment()
1807         self.adjustment_check(adjustment)
1808
1809         adjustment = Gtk.Adjustment(value=1, lower=0, upper=6,
1810                                     step_increment=4, page_increment=5, page_size=3)
1811         self.adjustment_check(adjustment, 1, 0, 6, 4, 5, 3)
1812
1813     def test_table(self):
1814         table = Gtk.Table()
1815         self.assertTrue(isinstance(table, Gtk.Table))
1816         self.assertTrue(isinstance(table, Gtk.Container))
1817         self.assertTrue(isinstance(table, Gtk.Widget))
1818         self.assertEqual(table.get_size(), (1, 1))
1819         self.assertEqual(table.get_homogeneous(), False)
1820         table = Gtk.Table(2, 3)
1821         self.assertEqual(table.get_size(), (2, 3))
1822         self.assertEqual(table.get_homogeneous(), False)
1823         table = Gtk.Table(2, 3, True)
1824         self.assertEqual(table.get_size(), (2, 3))
1825         self.assertEqual(table.get_homogeneous(), True)
1826
1827         # Test PyGTK interface
1828         table = Gtk.Table(rows=3, columns=2)
1829         self.assertEqual(table.get_size(), (3, 2))
1830         # Test using the actual property names
1831         table = Gtk.Table(n_rows=2, n_columns=3, homogeneous=True)
1832         self.assertEqual(table.get_size(), (2, 3))
1833         self.assertEqual(table.get_homogeneous(), True)
1834
1835         label = Gtk.Label(label='Hello')
1836         self.assertTrue(isinstance(label, Gtk.Widget))
1837         table.attach(label, 0, 1, 0, 1)
1838         self.assertEqual(label, table.get_children()[0])
1839
1840     def test_scrolledwindow(self):
1841         sw = Gtk.ScrolledWindow()
1842         self.assertTrue(isinstance(sw, Gtk.ScrolledWindow))
1843         self.assertTrue(isinstance(sw, Gtk.Container))
1844         self.assertTrue(isinstance(sw, Gtk.Widget))
1845         sb = sw.get_hscrollbar()
1846         self.assertEqual(sw.get_hadjustment(), sb.get_adjustment())
1847         sb = sw.get_vscrollbar()
1848         self.assertEqual(sw.get_vadjustment(), sb.get_adjustment())
1849
1850     def test_widget_drag_methods(self):
1851         widget = Gtk.Button()
1852
1853         # here we are not checking functionality, only that the methods exist
1854         # and except the right number of arguments
1855
1856         widget.drag_check_threshold(0, 0, 0, 0)
1857
1858         # drag_dest_ methods
1859         widget.drag_dest_set(Gtk.DestDefaults.DROP, None, Gdk.DragAction.COPY)
1860         widget.drag_dest_add_image_targets()
1861         widget.drag_dest_add_text_targets()
1862         widget.drag_dest_add_uri_targets()
1863         widget.drag_dest_get_track_motion()
1864         widget.drag_dest_set_track_motion(True)
1865         widget.drag_dest_get_target_list()
1866         widget.drag_dest_set_target_list(Gtk.TargetList.new([Gtk.TargetEntry.new('test', 0, 0)]))
1867         widget.drag_dest_unset()
1868
1869         widget.drag_highlight()
1870         widget.drag_unhighlight()
1871
1872         # drag_source_ methods
1873         widget.drag_source_set(Gdk.ModifierType.BUTTON1_MASK, None, Gdk.DragAction.MOVE)
1874         widget.drag_source_add_image_targets()
1875         widget.drag_source_add_text_targets()
1876         widget.drag_source_add_uri_targets()
1877         widget.drag_source_set_icon_name("")
1878         widget.drag_source_set_icon_pixbuf(GdkPixbuf.Pixbuf())
1879         widget.drag_source_set_icon_stock("")
1880         widget.drag_source_get_target_list()
1881         widget.drag_source_set_target_list(Gtk.TargetList.new([Gtk.TargetEntry.new('test', 0, 0)]))
1882         widget.drag_source_unset()
1883
1884         # these methods cannot be called because they require a valid drag on
1885         # a real GdkWindow. So we only check that they exist and are callable.
1886         self.assertTrue(hasattr(widget.drag_dest_set_proxy, '__call__'))
1887         self.assertTrue(hasattr(widget.drag_get_data, '__call__'))
1888
1889     def test_scrollbar(self):
1890         # PyGTK compat
1891         adjustment = Gtk.Adjustment()
1892
1893         hscrollbar = Gtk.HScrollbar()
1894         vscrollbar = Gtk.VScrollbar()
1895         self.assertNotEqual(hscrollbar.props.adjustment, adjustment)
1896         self.assertNotEqual(vscrollbar.props.adjustment, adjustment)
1897
1898         hscrollbar = Gtk.HScrollbar(adjustment)
1899         vscrollbar = Gtk.VScrollbar(adjustment)
1900         self.assertEqual(hscrollbar.props.adjustment, adjustment)
1901         self.assertEqual(vscrollbar.props.adjustment, adjustment)
1902
1903     def test_iconview(self):
1904         # PyGTK compat
1905         iconview = Gtk.IconView()
1906         self.assertEqual(iconview.props.model, None)
1907
1908         model = Gtk.ListStore(str)
1909         iconview = Gtk.IconView(model)
1910         self.assertEqual(iconview.props.model, model)
1911
1912     def test_toolbutton(self):
1913         # PyGTK compat
1914         button = Gtk.ToolButton()
1915         self.assertEqual(button.props.stock_id, None)
1916
1917         button = Gtk.ToolButton('gtk-new')
1918         self.assertEqual(button.props.stock_id, 'gtk-new')
1919
1920         icon = Gtk.Image.new_from_stock(Gtk.STOCK_OPEN, Gtk.IconSize.SMALL_TOOLBAR)
1921
1922         button = Gtk.ToolButton(label='mylabel', icon_widget=icon)
1923         self.assertEqual(button.props.label, 'mylabel')
1924         self.assertEqual(button.props.icon_widget, icon)
1925
1926     def test_iconset(self):
1927         # PyGTK compat
1928         Gtk.IconSet()
1929         pixbuf = GdkPixbuf.Pixbuf()
1930         Gtk.IconSet(pixbuf)
1931
1932     def test_viewport(self):
1933         # PyGTK compat
1934         vadjustment = Gtk.Adjustment()
1935         hadjustment = Gtk.Adjustment()
1936
1937         viewport = Gtk.Viewport(hadjustment=hadjustment,
1938                                 vadjustment=vadjustment)
1939
1940         self.assertEqual(viewport.props.vadjustment, vadjustment)
1941         self.assertEqual(viewport.props.hadjustment, hadjustment)
1942
1943
1944 class TestGio(unittest.TestCase):
1945     def setUp(self):
1946         self.settings = Gio.Settings('org.gnome.test')
1947         # we change the values in the tests, so set them to predictable start
1948         # value
1949         self.settings.reset('test-string')
1950         self.settings.reset('test-array')
1951
1952     def test_file_enumerator(self):
1953         self.assertEqual(Gio.FileEnumerator, overrides.Gio.FileEnumerator)
1954         f = Gio.file_new_for_path("./")
1955
1956         iter_info = []
1957         for info in f.enumerate_children("standard::*", 0, None):
1958             iter_info.append(info.get_name())
1959
1960         next_info = []
1961         enumerator = f.enumerate_children("standard::*", 0, None)
1962         while True:
1963             info = enumerator.next_file(None)
1964             if info is None:
1965                 break
1966             next_info.append(info.get_name())
1967
1968         self.assertEqual(iter_info, next_info)
1969
1970     def test_gsettings_native(self):
1971         self.assertTrue('test-array' in self.settings.list_keys())
1972
1973         # get various types
1974         v = self.settings.get_value('test-boolean')
1975         self.assertEqual(v.get_boolean(), True)
1976         self.assertEqual(self.settings.get_boolean('test-boolean'), True)
1977
1978         v = self.settings.get_value('test-string')
1979         self.assertEqual(v.get_string(), 'Hello')
1980         self.assertEqual(self.settings.get_string('test-string'), 'Hello')
1981
1982         v = self.settings.get_value('test-array')
1983         self.assertEqual(v.unpack(), [1, 2])
1984
1985         v = self.settings.get_value('test-tuple')
1986         self.assertEqual(v.unpack(), (1, 2))
1987
1988         # set a value
1989         self.settings.set_string('test-string', 'World')
1990         self.assertEqual(self.settings.get_string('test-string'), 'World')
1991
1992         self.settings.set_value('test-string', GLib.Variant('s', 'Goodbye'))
1993         self.assertEqual(self.settings.get_string('test-string'), 'Goodbye')
1994
1995     def test_gsettings_constructor(self):
1996         # default constructor uses path from schema
1997         self.assertEqual(self.settings.get_property('path'), '/tests/')
1998
1999         # optional constructor arguments
2000         with_path = Gio.Settings('org.gnome.nopathtest', path='/mypath/')
2001         self.assertEqual(with_path.get_property('path'), '/mypath/')
2002         self.assertEqual(with_path['np-int'], 42)
2003
2004     def test_gsettings_override(self):
2005         # dictionary interface
2006         self.assertEqual(len(self.settings), 4)
2007         self.assertTrue('test-array' in self.settings)
2008         self.assertTrue('test-array' in self.settings.keys())
2009         self.assertFalse('nonexisting' in self.settings)
2010         self.assertFalse(4 in self.settings)
2011         self.assertEqual(bool(self.settings), True)
2012
2013         # get various types
2014         self.assertEqual(self.settings['test-boolean'], True)
2015         self.assertEqual(self.settings['test-string'], 'Hello')
2016         self.assertEqual(self.settings['test-array'], [1, 2])
2017         self.assertEqual(self.settings['test-tuple'], (1, 2))
2018
2019         self.assertRaises(KeyError, self.settings.__getitem__, 'unknown')
2020         self.assertRaises(KeyError, self.settings.__getitem__, 2)
2021
2022         # set a value
2023         self.settings['test-string'] = 'Goodbye'
2024         self.assertEqual(self.settings['test-string'], 'Goodbye')
2025         self.settings['test-array'] = [3, 4, 5]
2026         self.assertEqual(self.settings['test-array'], [3, 4, 5])
2027
2028         self.assertRaises(TypeError, self.settings.__setitem__, 'test-string', 1)
2029         self.assertRaises(KeyError, self.settings.__setitem__, 'unknown', 'moo')
2030
2031     def test_gsettings_empty(self):
2032         empty = Gio.Settings('org.gnome.empty', path='/tests/')
2033         self.assertEqual(len(empty), 0)
2034         self.assertEqual(bool(empty), True)
2035         self.assertEqual(empty.keys(), [])