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 import os
   8 sys.path.insert(0, "../")
   9
  10 from compathelper import _long, _unicode, _bytes
  11
  12 from gi.repository import GLib
  13 from gi.repository import GObject
  14 from gi.repository import Gdk
  15 from gi.repository import Gtk
  16 from gi.repository import Gio
  17 from gi.repository import Pango
  18 from gi.repository import GdkPixbuf
  19 import gi.overrides as overrides
  20 import gi.types
  21
  22 class TestGLib(unittest.TestCase):
  23
  24     def test_gvariant_create(self):
  25         # simple values
  26
  27         variant = GLib.Variant('i', 42)
  28         self.assertTrue(isinstance(variant, GLib.Variant))
  29         self.assertEquals(variant.get_int32(), 42)
  30
  31         variant = GLib.Variant('s', '')
  32         self.assertTrue(isinstance(variant, GLib.Variant))
  33         self.assertEquals(variant.get_string(), '')
  34
  35         variant = GLib.Variant('s', 'hello')
  36         self.assertTrue(isinstance(variant, GLib.Variant))
  37         self.assertEquals(variant.get_string(), 'hello')
  38
  39         # boxed variant
  40         variant = GLib.Variant('v', GLib.Variant('i', 42))
  41         self.assertTrue(isinstance(variant, GLib.Variant))
  42         self.assertTrue(isinstance(variant.get_variant(), GLib.Variant))
  43         self.assertEqual(variant.get_type_string(), 'v')
  44         self.assertEqual(variant.get_variant().get_type_string(), 'i')
  45         self.assertEquals(variant.get_variant().get_int32(), 42)
  46
  47         variant = GLib.Variant('v', GLib.Variant('v', GLib.Variant('i', 42)))
  48         self.assertEqual(variant.get_type_string(), 'v')
  49         self.assertEqual(variant.get_variant().get_type_string(), 'v')
  50         self.assertEqual(variant.get_variant().get_variant().get_type_string(), 'i')
  51         self.assertEquals(variant.get_variant().get_variant().get_int32(), 42)
  52
  53         # tuples
  54
  55         variant = GLib.Variant('()', ())
  56         self.assertEqual(variant.get_type_string(), '()')
  57         self.assertEquals(variant.n_children(), 0)
  58
  59         variant = GLib.Variant('(i)', (3,))
  60         self.assertEqual(variant.get_type_string(), '(i)')
  61         self.assertTrue(isinstance(variant, GLib.Variant))
  62         self.assertEquals(variant.n_children(), 1)
  63         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
  64         self.assertEquals(variant.get_child_value(0).get_int32(), 3)
  65
  66         variant = GLib.Variant('(ss)', ('mec', 'mac'))
  67         self.assertEqual(variant.get_type_string(), '(ss)')
  68         self.assertTrue(isinstance(variant, GLib.Variant))
  69         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
  70         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
  71         self.assertEquals(variant.get_child_value(0).get_string(), 'mec')
  72         self.assertEquals(variant.get_child_value(1).get_string(), 'mac')
  73
  74         # nested tuples
  75         variant = GLib.Variant('((si)(ub))', (('hello', -1), (42, True)))
  76         self.assertEqual(variant.get_type_string(), '((si)(ub))')
  77         self.assertEqual(variant.unpack(), (('hello', -1), (_long(42), True)))
  78
  79         # dictionaries
  80
  81         variant = GLib.Variant('a{si}', {})
  82         self.assertTrue(isinstance(variant, GLib.Variant))
  83         self.assertEqual(variant.get_type_string(), 'a{si}')
  84         self.assertEquals(variant.n_children(), 0)
  85
  86         variant = GLib.Variant('a{si}', {'': 1, 'key1': 2, 'key2': 3})
  87         self.assertEqual(variant.get_type_string(), 'a{si}')
  88         self.assertTrue(isinstance(variant, GLib.Variant))
  89         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
  90         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
  91         self.assertTrue(isinstance(variant.get_child_value(2), GLib.Variant))
  92         self.assertEqual(variant.unpack(), {'': 1, 'key1': 2, 'key2': 3})
  93
  94         # nested dictionaries
  95         variant = GLib.Variant('a{sa{si}}', {})
  96         self.assertTrue(isinstance(variant, GLib.Variant))
  97         self.assertEqual(variant.get_type_string(), 'a{sa{si}}')
  98         self.assertEquals(variant.n_children(), 0)
  99
 100         d = {'':     {'': 1, 'keyn1': 2},
 101              'key1': {'key11': 11, 'key12': 12}}
 102         variant = GLib.Variant('a{sa{si}}', d)
 103         self.assertEqual(variant.get_type_string(), 'a{sa{si}}')
 104         self.assertTrue(isinstance(variant, GLib.Variant))
 105         self.assertEqual(variant.unpack(), d)
 106
 107         # arrays
 108
 109         variant = GLib.Variant('ai', [])
 110         self.assertEqual(variant.get_type_string(), 'ai')
 111         self.assertEquals(variant.n_children(), 0)
 112
 113         variant = GLib.Variant('ai', [1, 2])
 114         self.assertEqual(variant.get_type_string(), 'ai')
 115         self.assertTrue(isinstance(variant, GLib.Variant))
 116         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
 117         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
 118         self.assertEquals(variant.get_child_value(0).get_int32(), 1)
 119         self.assertEquals(variant.get_child_value(1).get_int32(), 2)
 120
 121         variant = GLib.Variant('as', [])
 122         self.assertEqual(variant.get_type_string(), 'as')
 123         self.assertEquals(variant.n_children(), 0)
 124
 125         variant = GLib.Variant('as', [''])
 126         self.assertEqual(variant.get_type_string(), 'as')
 127         self.assertTrue(isinstance(variant, GLib.Variant))
 128         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
 129         self.assertEquals(variant.get_child_value(0).get_string(), '')
 130
 131         variant = GLib.Variant('as', ['hello', 'world'])
 132         self.assertEqual(variant.get_type_string(), 'as')
 133         self.assertTrue(isinstance(variant, GLib.Variant))
 134         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
 135         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
 136         self.assertEquals(variant.get_child_value(0).get_string(), 'hello')
 137         self.assertEquals(variant.get_child_value(1).get_string(), 'world')
 138
 139         # nested arrays
 140         variant = GLib.Variant('aai', [])
 141         self.assertEqual(variant.get_type_string(), 'aai')
 142         self.assertEquals(variant.n_children(), 0)
 143
 144         variant = GLib.Variant('aai', [[]])
 145         self.assertEqual(variant.get_type_string(), 'aai')
 146         self.assertEquals(variant.n_children(), 1)
 147         self.assertEquals(variant.get_child_value(0).n_children(), 0)
 148
 149         variant = GLib.Variant('aai', [[1, 2], [3, 4, 5]])
 150         self.assertEqual(variant.get_type_string(), 'aai')
 151         self.assertEquals(variant.unpack(), [[1, 2], [3, 4, 5]])
 152
 153         #
 154         # complex types
 155         #
 156
 157         variant = GLib.Variant('(as)', ([],))
 158         self.assertEqual(variant.get_type_string(), '(as)')
 159         self.assertEquals(variant.n_children(), 1)
 160         self.assertEquals(variant.get_child_value(0).n_children(), 0)
 161
 162         variant = GLib.Variant('(as)', ([''],))
 163         self.assertEqual(variant.get_type_string(), '(as)')
 164         self.assertEquals(variant.n_children(), 1)
 165         self.assertEquals(variant.get_child_value(0).n_children(), 1)
 166         self.assertEquals(variant.get_child_value(0).get_child_value(0).get_string(), '')
 167
 168         variant = GLib.Variant('(as)', (['hello'],))
 169         self.assertEqual(variant.get_type_string(), '(as)')
 170         self.assertEquals(variant.n_children(), 1)
 171         self.assertEquals(variant.get_child_value(0).n_children(), 1)
 172         self.assertEquals(variant.get_child_value(0).get_child_value(0).get_string(), 'hello')
 173
 174         obj = {'a1': (1, True), 'a2': (2, False)}
 175         variant = GLib.Variant('a{s(ib)}', obj)
 176         self.assertEqual(variant.get_type_string(), 'a{s(ib)}')
 177         self.assertEqual(variant.unpack(), obj)
 178
 179         obj = {'a1': (1, GLib.Variant('b', True)), 'a2': (2, GLib.Variant('y', 255))}
 180         variant = GLib.Variant('a{s(iv)}', obj)
 181         self.assertEqual(variant.get_type_string(), 'a{s(iv)}')
 182         self.assertEqual(variant.unpack(), {'a1': (1, True), 'a2': (2, 255)})
 183
 184         obj = (1, {'a': {'a1': True, 'a2': False},
 185                    'b': {'b1': False},
 186                    'c': {}
 187                   },
 188                'foo')
 189         variant = GLib.Variant('(ia{sa{sb}}s)', obj)
 190         self.assertEqual(variant.get_type_string(), '(ia{sa{sb}}s)')
 191         self.assertEqual(variant.unpack(), obj)
 192
 193         obj = {"frequency": GLib.Variant('t', 738000000),
 194             "hierarchy": GLib.Variant('i', 0),
 195             "bandwidth": GLib.Variant('x', 8),
 196             "code-rate-hp": GLib.Variant('d', 2.0/3.0),
 197             "constellation": GLib.Variant('s', "QAM16"),
 198             "guard-interval": GLib.Variant('u', 4),}
 199         variant = GLib.Variant('a{sv}', obj)
 200         self.assertEqual(variant.get_type_string(), 'a{sv}')
 201         self.assertEqual(variant.unpack(), {"frequency": 738000000,
 202             "hierarchy": 0,
 203             "bandwidth": 8,
 204             "code-rate-hp": 2.0/3.0,
 205             "constellation": "QAM16",
 206             "guard-interval": 4})
 207
 208     def test_gvariant_create_errors(self):
 209         # excess arguments
 210         self.assertRaises(TypeError, GLib.Variant, 'i', 42, 3)
 211         self.assertRaises(TypeError, GLib.Variant, '(i)', (42, 3))
 212
 213         # not enough arguments
 214         self.assertRaises(TypeError, GLib.Variant, '(ii)', (42,))
 215
 216         # data type mismatch
 217         self.assertRaises(TypeError, GLib.Variant, 'i', 'hello')
 218         self.assertRaises(TypeError, GLib.Variant, 's', 42)
 219         self.assertRaises(TypeError, GLib.Variant, '(ss)', 'mec', 'mac')
 220
 221         # unimplemented data type
 222         self.assertRaises(NotImplementedError, GLib.Variant, 'Q', 1)
 223
 224     def test_gvariant_unpack(self):
 225         # simple values
 226         res = GLib.Variant.new_int32(-42).unpack()
 227         self.assertEqual(res, -42)
 228
 229         res = GLib.Variant.new_uint64(34359738368).unpack()
 230         self.assertEqual(res, 34359738368)
 231
 232         res = GLib.Variant.new_boolean(True).unpack()
 233         self.assertEqual(res, True)
 234
 235         res = GLib.Variant.new_object_path('/foo/Bar').unpack()
 236         self.assertEqual(res, '/foo/Bar')
 237
 238         # variant
 239         res = GLib.Variant('v', GLib.Variant.new_int32(-42)).unpack()
 240         self.assertEqual(res, -42)
 241
 242         variant = GLib.Variant('v', GLib.Variant('v', GLib.Variant('i', 42)))
 243         self.assertEqual(res, -42)
 244
 245         # tuple
 246         res = GLib.Variant.new_tuple(GLib.Variant.new_int32(-1),
 247                 GLib.Variant.new_string('hello')).unpack()
 248         self.assertEqual(res, (-1, 'hello'))
 249
 250         # array
 251         vb = GLib.VariantBuilder.new(gi._gi.variant_type_from_string('ai'))
 252         vb.add_value(GLib.Variant.new_int32(-1))
 253         vb.add_value(GLib.Variant.new_int32(3))
 254         res = vb.end().unpack()
 255         self.assertEqual(res, [-1, 3])
 256
 257         # dictionary
 258         res = GLib.Variant('a{si}', {'key1': 1, 'key2': 2}).unpack()
 259         self.assertEqual(res, {'key1': 1, 'key2': 2})
 260
 261     def test_gvariant_iteration(self):
 262         # array index access
 263         vb = GLib.VariantBuilder.new(gi._gi.variant_type_from_string('ai'))
 264         vb.add_value(GLib.Variant.new_int32(-1))
 265         vb.add_value(GLib.Variant.new_int32(3))
 266         v = vb.end()
 267
 268         self.assertEqual(len(v), 2)
 269         self.assertEqual(v[0], -1)
 270         self.assertEqual(v[1], 3)
 271         self.assertEqual(v[-1], 3)
 272         self.assertEqual(v[-2], -1)
 273         self.assertRaises(IndexError, v.__getitem__, 2)
 274         self.assertRaises(IndexError, v.__getitem__, -3)
 275         self.assertRaises(ValueError, v.__getitem__, 'a')
 276
 277         # array iteration
 278         self.assertEqual([x for x in v], [-1, 3])
 279         self.assertEqual(list(v), [-1, 3])
 280
 281         # tuple index access
 282         v = GLib.Variant.new_tuple(GLib.Variant.new_int32(-1),
 283                 GLib.Variant.new_string('hello'))
 284         self.assertEqual(len(v), 2)
 285         self.assertEqual(v[0], -1)
 286         self.assertEqual(v[1], 'hello')
 287         self.assertEqual(v[-1], 'hello')
 288         self.assertEqual(v[-2], -1)
 289         self.assertRaises(IndexError, v.__getitem__, 2)
 290         self.assertRaises(IndexError, v.__getitem__, -3)
 291         self.assertRaises(ValueError, v.__getitem__, 'a')
 292
 293         # tuple iteration
 294         self.assertEqual([x for x in v], [-1, 'hello'])
 295         self.assertEqual(tuple(v), (-1, 'hello'))
 296
 297         # dictionary index access
 298         vsi = GLib.Variant('a{si}', {'key1': 1, 'key2': 2})
 299         vis = GLib.Variant('a{is}', {1: 'val1', 5: 'val2'})
 300
 301         self.assertEqual(len(vsi), 2)
 302         self.assertEqual(vsi['key1'], 1)
 303         self.assertEqual(vsi['key2'], 2)
 304         self.assertRaises(KeyError, vsi.__getitem__, 'unknown')
 305
 306         self.assertEqual(len(vis), 2)
 307         self.assertEqual(vis[1], 'val1')
 308         self.assertEqual(vis[5], 'val2')
 309         self.assertRaises(KeyError, vsi.__getitem__, 3)
 310
 311         # dictionary iteration
 312         self.assertEqual(set(vsi.keys()), set(['key1', 'key2']))
 313         self.assertEqual(set(vis.keys()), set([1, 5]))
 314
 315         # string index access
 316         v = GLib.Variant('s', 'hello')
 317         self.assertEqual(len(v), 5)
 318         self.assertEqual(v[0], 'h')
 319         self.assertEqual(v[4], 'o')
 320         self.assertEqual(v[-1], 'o')
 321         self.assertEqual(v[-5], 'h')
 322         self.assertRaises(IndexError, v.__getitem__, 5)
 323         self.assertRaises(IndexError, v.__getitem__, -6)
 324
 325         # string iteration
 326         self.assertEqual([x for x in v], ['h', 'e', 'l', 'l', 'o'])
 327
 328 class TestPango(unittest.TestCase):
 329
 330     def test_default_font_description(self):
 331         desc = Pango.FontDescription()
 332         self.assertEquals(desc.get_variant(), Pango.Variant.NORMAL)
 333
 334     def test_font_description(self):
 335         desc = Pango.FontDescription('monospace')
 336         self.assertEquals(desc.get_family(), 'monospace')
 337         self.assertEquals(desc.get_variant(), Pango.Variant.NORMAL)
 338
 339     def test_layout(self):
 340         self.assertRaises(TypeError, Pango.Layout)
 341         context = Pango.Context()
 342         layout = Pango.Layout(context)
 343         self.assertEquals(layout.get_context(), context)
 344
 345 class TestGdk(unittest.TestCase):
 346
 347     def test_constructor(self):
 348         attribute = Gdk.WindowAttr()
 349         attribute.window_type = Gdk.WindowType.CHILD
 350         attributes_mask = Gdk.WindowAttributesType.X | \
 351             Gdk.WindowAttributesType.Y
 352         window = Gdk.Window(None, attribute, attributes_mask)
 353         self.assertEquals(window.get_window_type(), Gdk.WindowType.CHILD)
 354
 355     def test_color(self):
 356         color = Gdk.Color(100, 200, 300)
 357         self.assertEquals(color.red, 100)
 358         self.assertEquals(color.green, 200)
 359         self.assertEquals(color.blue, 300)
 360         self.assertEquals(color, Gdk.Color(100, 200, 300))
 361         self.assertNotEquals(color, Gdk.Color(1, 2, 3))
 362
 363     def test_rgba(self):
 364         self.assertEquals(Gdk.RGBA, overrides.Gdk.RGBA)
 365         rgba = Gdk.RGBA(0.1, 0.2, 0.3, 0.4)
 366         self.assertEquals(rgba, Gdk.RGBA(0.1, 0.2, 0.3, 0.4))
 367         self.assertNotEquals(rgba, Gdk.RGBA(0.0, 0.2, 0.3, 0.4))
 368         self.assertEquals(rgba.red, 0.1)
 369         self.assertEquals(rgba.green, 0.2)
 370         self.assertEquals(rgba.blue, 0.3)
 371         self.assertEquals(rgba.alpha, 0.4)
 372         rgba.green = 0.9
 373         self.assertEquals(rgba.green, 0.9)
 374
 375     def test_event(self):
 376         event = Gdk.Event.new(Gdk.EventType.CONFIGURE)
 377         self.assertEquals(event.type, Gdk.EventType.CONFIGURE)
 378         self.assertEquals(event.send_event, 0)
 379
 380         event = Gdk.Event.new(Gdk.EventType.DRAG_MOTION)
 381         event.x_root, event.y_root = 0, 5
 382         self.assertEquals(event.x_root, 0)
 383         self.assertEquals(event.y_root, 5)
 384
 385         event = Gdk.Event()
 386         event.type = Gdk.EventType.SCROLL
 387         self.assertRaises(AttributeError, lambda: getattr(event, 'foo_bar'))
 388
 389     def test_event_structures(self):
 390         def button_press_cb(button, event):
 391             self.assertTrue(isinstance(event, Gdk.EventButton))
 392             self.assertTrue(event.type == Gdk.EventType.BUTTON_PRESS)
 393             self.assertEquals(event.send_event, 0)
 394             self.assertEquals(event.get_state(), Gdk.ModifierType.CONTROL_MASK)
 395             self.assertEquals(event.get_root_coords(), (2, 5))
 396
 397             event.time = 12345
 398             self.assertEquals(event.get_time(), 12345)
 399
 400         w = Gtk.Window()
 401         b = Gtk.Button()
 402         b.connect('button-press-event', button_press_cb)
 403         w.add(b)
 404         w.show_all()
 405         Gdk.test_simulate_button(b.get_window(),
 406                                  2, 5,
 407                                  0,
 408                                  Gdk.ModifierType.CONTROL_MASK,
 409                                  Gdk.EventType.BUTTON_PRESS)
 410
 411     def test_cursor(self):
 412         self.assertEquals(Gdk.Cursor, overrides.Gdk.Cursor)
 413         c = Gdk.Cursor(Gdk.CursorType.WATCH)
 414         self.assertNotEqual(c, None)
 415         c = Gdk.Cursor(cursor_type = Gdk.CursorType.WATCH)
 416         self.assertNotEqual(c, None)
 417
 418         display_manager = Gdk.DisplayManager.get()
 419         display = display_manager.get_default_display()
 420
 421         test_pixbuf = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB,
 422                                            False,
 423                                            8,
 424                                            5,
 425                                            10)
 426
 427         c = Gdk.Cursor(display,
 428                        test_pixbuf,
 429                        y=0, x=0)
 430
 431         self.assertNotEqual(c, None)
 432         self.assertRaises(ValueError, Gdk.Cursor, 1, 2, 3)
 433
 434 class TestGtk(unittest.TestCase):
 435
 436     def test_container(self):
 437         box = Gtk.Box()
 438         self.assertTrue(box)
 439         label = Gtk.Label()
 440         label2 = Gtk.Label()
 441         box.add(label)
 442         box.add(label2)
 443         self.assertTrue(label in box)
 444         self.assertTrue(label2 in box)
 445         self.assertEqual(len(box), 2)
 446         self.assertTrue(box)
 447         l = [x for x in box]
 448         self.assertEqual(l, [label, label2])
 449
 450     def test_actions(self):
 451         self.assertEquals(Gtk.Action, overrides.Gtk.Action)
 452         self.assertRaises(TypeError, Gtk.Action)
 453         action = Gtk.Action("test", "Test", "Test Action", Gtk.STOCK_COPY)
 454         self.assertEquals(action.get_name(), "test")
 455         self.assertEquals(action.get_label(), "Test")
 456         self.assertEquals(action.get_tooltip(), "Test Action")
 457         self.assertEquals(action.get_stock_id(), Gtk.STOCK_COPY)
 458
 459         self.assertEquals(Gtk.RadioAction, overrides.Gtk.RadioAction)
 460         self.assertRaises(TypeError, Gtk.RadioAction)
 461         action = Gtk.RadioAction("test", "Test", "Test Action", Gtk.STOCK_COPY, 1)
 462         self.assertEquals(action.get_name(), "test")
 463         self.assertEquals(action.get_label(), "Test")
 464         self.assertEquals(action.get_tooltip(), "Test Action")
 465         self.assertEquals(action.get_stock_id(), Gtk.STOCK_COPY)
 466         self.assertEquals(action.get_current_value(), 1)
 467
 468     def test_actiongroup(self):
 469         self.assertEquals(Gtk.ActionGroup, overrides.Gtk.ActionGroup)
 470         self.assertRaises(TypeError, Gtk.ActionGroup)
 471
 472         action_group = Gtk.ActionGroup (name = 'TestActionGroup')
 473         callback_data = "callback data"
 474
 475         def test_action_callback_data(action, user_data):
 476             self.assertEquals(user_data, callback_data);
 477
 478         def test_radio_action_callback_data(action, current, user_data):
 479             self.assertEquals(user_data, callback_data);
 480
 481         action_group.add_actions ([
 482             ('test-action1', None, 'Test Action 1',
 483              None, None, test_action_callback_data),
 484             ('test-action2', Gtk.STOCK_COPY, 'Test Action 2',
 485               None, None, test_action_callback_data)], callback_data)
 486         action_group.add_toggle_actions([
 487             ('test-toggle-action1', None, 'Test Toggle Action 1',
 488              None, None, test_action_callback_data, False),
 489             ('test-toggle-action2', Gtk.STOCK_COPY, 'Test Toggle Action 2',
 490               None, None, test_action_callback_data, True)], callback_data)
 491         action_group.add_radio_actions([
 492             ('test-radio-action1', None, 'Test Radio Action 1'),
 493             ('test-radio-action2', Gtk.STOCK_COPY, 'Test Radio Action 2')], 1,
 494             test_radio_action_callback_data,
 495             callback_data)
 496
 497         expected_results = [('test-action1', Gtk.Action),
 498                             ('test-action2', Gtk.Action),
 499                             ('test-toggle-action1', Gtk.ToggleAction),
 500                             ('test-toggle-action2', Gtk.ToggleAction),
 501                             ('test-radio-action1', Gtk.RadioAction),
 502                             ('test-radio-action2', Gtk.RadioAction)]
 503
 504         for action in action_group.list_actions():
 505             a = (action.get_name(), type(action))
 506             self.assertTrue(a in expected_results)
 507             expected_results.remove(a)
 508             action.activate()
 509
 510     def test_uimanager(self):
 511         self.assertEquals(Gtk.UIManager, overrides.Gtk.UIManager)
 512         ui = Gtk.UIManager()
 513         ui.add_ui_from_string(
 514 """
 515 <ui>
 516     <menubar name="menubar1"></menubar>
 517 </ui>
 518 """
 519 )
 520         menubar = ui.get_widget("/menubar1")
 521         self.assertEquals(type(menubar), Gtk.MenuBar)
 522
 523         ag = Gtk.ActionGroup (name="ag1")
 524         ui.insert_action_group(ag)
 525         ag2 = Gtk.ActionGroup (name="ag2")
 526         ui.insert_action_group(ag2)
 527         groups = ui.get_action_groups()
 528         self.assertEquals(ag, groups[-2])
 529         self.assertEquals(ag2, groups[-1])
 530
 531     def test_builder(self):
 532         self.assertEquals(Gtk.Builder, overrides.Gtk.Builder)
 533
 534         class SignalTest(GObject.GObject):
 535             __gtype_name__ = "GIOverrideSignalTest"
 536             __gsignals__ = {
 537                 "test-signal": (GObject.SignalFlags.RUN_FIRST,
 538                                 None,
 539                                 []),
 540             }
 541
 542
 543         class SignalCheck:
 544             def __init__(self):
 545                 self.sentinel = 0
 546
 547             def on_signal_1(self, *args):
 548                 self.sentinel += 1
 549
 550             def on_signal_3(self, *args):
 551                 self.sentinel += 3
 552
 553         signal_checker = SignalCheck()
 554         builder = Gtk.Builder()
 555
 556         # add object1 to the builder
 557         builder.add_from_string(
 558 """
 559 <interface>
 560   <object class="GIOverrideSignalTest" id="object1">
 561       <signal name="test-signal" handler="on_signal_1" />
 562   </object>
 563 </interface>
 564 """)
 565
 566         # only add object3 to the builder
 567         builder.add_objects_from_string(
 568 """
 569 <interface>
 570   <object class="GIOverrideSignalTest" id="object2">
 571       <signal name="test-signal" handler="on_signal_2" />
 572   </object>
 573   <object class="GIOverrideSignalTest" id="object3">
 574       <signal name="test-signal" handler="on_signal_3" />
 575   </object>
 576   <object class="GIOverrideSignalTest" id="object4">
 577       <signal name="test-signal" handler="on_signal_4" />
 578   </object>
 579 </interface>
 580
 581 """,
 582             ['object3'])
 583
 584         # hook up signals
 585         builder.connect_signals(signal_checker)
 586
 587         # call their notify signals and check sentinel
 588         objects = builder.get_objects()
 589         self.assertEquals(len(objects), 2)
 590         for obj in objects:
 591             obj.emit('test-signal')
 592
 593         self.assertEquals(signal_checker.sentinel, 4)
 594
 595     def test_dialogs(self):
 596         self.assertEquals(Gtk.Dialog, overrides.Gtk.Dialog)
 597         self.assertEquals(Gtk.AboutDialog, overrides.Gtk.AboutDialog)
 598         self.assertEquals(Gtk.MessageDialog, overrides.Gtk.MessageDialog)
 599         self.assertEquals(Gtk.ColorSelectionDialog, overrides.Gtk.ColorSelectionDialog)
 600         self.assertEquals(Gtk.FileChooserDialog, overrides.Gtk.FileChooserDialog)
 601         self.assertEquals(Gtk.FontSelectionDialog, overrides.Gtk.FontSelectionDialog)
 602         self.assertEquals(Gtk.RecentChooserDialog, overrides.Gtk.RecentChooserDialog)
 603
 604         # Gtk.Dialog
 605         dialog = Gtk.Dialog (title='Foo',
 606                              flags=Gtk.DialogFlags.MODAL,
 607                              buttons=('test-button1', 1))
 608
 609         dialog.add_buttons ('test-button2', 2, Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE)
 610
 611         self.assertEquals('Foo', dialog.get_title())
 612         self.assertTrue(dialog.get_modal())
 613         button = dialog.get_widget_for_response (1)
 614         self.assertEquals('test-button1', button.get_label())
 615         button = dialog.get_widget_for_response (2)
 616         self.assertEquals('test-button2', button.get_label())
 617         button = dialog.get_widget_for_response (Gtk.ResponseType.CLOSE)
 618         self.assertEquals(Gtk.STOCK_CLOSE, button.get_label())
 619
 620         # Gtk.AboutDialog
 621         dialog = Gtk.AboutDialog()
 622
 623         # Gtk.MessageDialog
 624         dialog = Gtk.MessageDialog (title='message dialog test',
 625                                     flags=Gtk.DialogFlags.MODAL,
 626                                     buttons=Gtk.ButtonsType.OK,
 627                                     message_format='dude!')
 628
 629         self.assertEquals('message dialog test', dialog.get_title())
 630         self.assertTrue(dialog.get_modal())
 631         text = dialog.get_property('text')
 632         self.assertEquals('dude!', text)
 633
 634         dialog.format_secondary_text('2nd text')
 635         self.assertEqual(dialog.get_property('secondary-text'), '2nd text')
 636         self.assertFalse(dialog.get_property('secondary-use-markup'))
 637
 638         dialog.format_secondary_markup('2nd markup')
 639         self.assertEqual(dialog.get_property('secondary-text'), '2nd markup')
 640         self.assertTrue(dialog.get_property('secondary-use-markup'))
 641
 642         # Gtk.ColorSelectionDialog
 643         dialog = Gtk.ColorSelectionDialog("color selection dialog test")
 644         self.assertEquals('color selection dialog test', dialog.get_title())
 645
 646         # Gtk.FileChooserDialog
 647         dialog = Gtk.FileChooserDialog (title='file chooser dialog test',
 648                                         buttons=('test-button1', 1),
 649                                         action=Gtk.FileChooserAction.SAVE)
 650
 651         dialog.add_buttons ('test-button2', 2, Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE)
 652         self.assertEquals('file chooser dialog test', dialog.get_title())
 653         button = dialog.get_widget_for_response (1)
 654         self.assertEquals('test-button1', button.get_label())
 655         button = dialog.get_widget_for_response (2)
 656         self.assertEquals('test-button2', button.get_label())
 657         button = dialog.get_widget_for_response (Gtk.ResponseType.CLOSE)
 658         self.assertEquals(Gtk.STOCK_CLOSE, button.get_label())
 659         action = dialog.get_property('action')
 660         self.assertEquals(Gtk.FileChooserAction.SAVE, action)
 661
 662
 663         # Gtk.FontSelectionDialog
 664         dialog = Gtk.ColorSelectionDialog("font selection dialog test")
 665         self.assertEquals('font selection dialog test', dialog.get_title())
 666
 667         # Gtk.RecentChooserDialog
 668         test_manager = Gtk.RecentManager()
 669         dialog = Gtk.RecentChooserDialog (title='recent chooser dialog test',
 670                                           buttons=('test-button1', 1),
 671                                           manager=test_manager)
 672
 673         dialog.add_buttons ('test-button2', 2, Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE)
 674         self.assertEquals('recent chooser dialog test', dialog.get_title())
 675         button = dialog.get_widget_for_response (1)
 676         self.assertEquals('test-button1', button.get_label())
 677         button = dialog.get_widget_for_response (2)
 678         self.assertEquals('test-button2', button.get_label())
 679         button = dialog.get_widget_for_response (Gtk.ResponseType.CLOSE)
 680         self.assertEquals(Gtk.STOCK_CLOSE, button.get_label())
 681
 682     class TestClass(GObject.GObject):
 683         __gtype_name__ = "GIOverrideTreeAPITest"
 684
 685         def __init__(self, tester, int_value, string_value):
 686             super(TestGtk.TestClass, self).__init__()
 687             self.tester = tester
 688             self.int_value = int_value
 689             self.string_value = string_value
 690
 691         def check(self, int_value, string_value):
 692             self.tester.assertEquals(int_value, self.int_value)
 693             self.tester.assertEquals(string_value, self.string_value)
 694
 695     def test_tree_store(self):
 696         self.assertEquals(Gtk.TreeStore, overrides.Gtk.TreeStore)
 697         self.assertEquals(Gtk.ListStore, overrides.Gtk.ListStore)
 698         self.assertEquals(Gtk.TreeModel, overrides.Gtk.TreeModel)
 699         self.assertEquals(Gtk.TreeViewColumn, overrides.Gtk.TreeViewColumn)
 700
 701         class TestPyObject(object):
 702             pass
 703
 704         test_pyobj = TestPyObject()
 705         test_pydict = {1:1, "2":2, "3":"3"}
 706         test_pylist = [1,"2", "3"]
 707         tree_store = Gtk.TreeStore(int,
 708                                    'gchararray',
 709                                    TestGtk.TestClass,
 710                                    GObject.TYPE_PYOBJECT,
 711                                    object,
 712                                    object,
 713                                    object,
 714                                    bool,
 715                                    bool,
 716                                    GObject.TYPE_UINT,
 717                                    GObject.TYPE_ULONG,
 718                                    GObject.TYPE_INT64,
 719                                    GObject.TYPE_UINT64,
 720                                    GObject.TYPE_UCHAR,
 721                                    GObject.TYPE_CHAR)
 722
 723         parent = None
 724         for i in range(97):
 725             label = 'this is child #%d' % i
 726             testobj = TestGtk.TestClass(self, i, label)
 727             parent = tree_store.append(parent, (i,
 728                                                 label,
 729                                                 testobj,
 730                                                 testobj,
 731                                                 test_pyobj,
 732                                                 test_pydict,
 733                                                 test_pylist,
 734                                                 i % 2,
 735                                                 bool(i % 2),
 736                                                 i,
 737                                                 GObject.G_MAXULONG,
 738                                                 GObject.G_MININT64,
 739                                                 0xffffffffffffffff,
 740                                                 254,
 741                                                 _bytes('a')
 742                                                 ))
 743         # test set
 744         parent = tree_store.append(parent)
 745         i = 97
 746         label = 'this is child #%d' % i
 747         testobj = TestGtk.TestClass(self, i, label)
 748         tree_store.set(parent, 0, i,
 749                                2, testobj,
 750                                1, label,
 751                                3, testobj,
 752                                4, test_pyobj,
 753                                5, test_pydict,
 754                                6, test_pylist,
 755                                7, i % 2,
 756                                8, bool(i % 2),
 757                                9, i,
 758                                10, GObject.G_MAXULONG,
 759                                11, GObject.G_MININT64,
 760                                12, 0xffffffffffffffff,
 761                                13, 254,
 762                                14, _bytes('a'))
 763
 764         parent = tree_store.append(parent)
 765         i = 98
 766         label = 'this is child #%d' % i
 767         testobj = TestGtk.TestClass(self, i, label)
 768         tree_store.set(parent, {0: i,
 769                                 2: testobj,
 770                                 1: label,
 771                                 3: testobj,
 772                                 4: test_pyobj,
 773                                 5: test_pydict,
 774                                 6: test_pylist,
 775                                 7: i % 2,
 776                                 8: bool(i % 2),
 777                                 9: i,
 778                                 10: GObject.G_MAXULONG,
 779                                 11: GObject.G_MININT64,
 780                                 12: 0xffffffffffffffff,
 781                                 13: 254,
 782                                 14: _bytes('a')})
 783
 784         parent = tree_store.append(parent)
 785         i = 99
 786         label = 'this is child #%d' % i
 787         testobj = TestGtk.TestClass(self, i, label)
 788         tree_store.set(parent, (0, 2, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14),
 789                                (i,
 790                                 testobj,
 791                                 label,
 792                                 testobj,
 793                                 test_pyobj,
 794                                 test_pydict,
 795                                 test_pylist,
 796                                 i % 2,
 797                                 bool(i % 2),
 798                                 i,
 799                                 GObject.G_MAXULONG,
 800                                 GObject.G_MININT64,
 801                                 0xffffffffffffffff,
 802                                 254,
 803                                 _bytes('a')))
 804
 805         # len gets the number of children in the root node
 806         # since we kept appending to the previous node
 807         # there should only be one child of the root
 808         self.assertEquals(len(tree_store), 1)
 809
 810         # walk the tree to see if the values were stored correctly
 811         parent = None
 812         i = 0
 813
 814         treeiter = tree_store.iter_children(parent)
 815         while treeiter:
 816            i = tree_store.get_value(treeiter, 0)
 817            s = tree_store.get_value(treeiter, 1)
 818            obj = tree_store.get_value(treeiter, 2)
 819            obj.check(i, s)
 820            obj2 = tree_store.get_value(treeiter, 3)
 821            self.assertEquals(obj, obj2);
 822
 823            pyobj = tree_store.get_value(treeiter, 4)
 824            self.assertEquals(pyobj, test_pyobj)
 825            pydict = tree_store.get_value(treeiter, 5)
 826            self.assertEquals(pydict, test_pydict)
 827            pylist = tree_store.get_value(treeiter, 6)
 828            self.assertEquals(pylist, test_pylist)
 829
 830            bool_1 = tree_store.get_value(treeiter, 7)
 831            bool_2 = tree_store.get_value(treeiter, 8)
 832            self.assertEquals(bool_1, bool_2)
 833            self.assertTrue(isinstance(bool_1, bool))
 834            self.assertTrue(isinstance(bool_2, bool))
 835
 836            uint_ = tree_store.get_value(treeiter, 9)
 837            self.assertEquals(uint_, i)
 838            ulong_ = tree_store.get_value(treeiter, 10)
 839            self.assertEquals(ulong_, GObject.G_MAXULONG)
 840            int64_ = tree_store.get_value(treeiter, 11)
 841            self.assertEquals(int64_, GObject.G_MININT64)
 842            uint64_ = tree_store.get_value(treeiter, 12)
 843            self.assertEquals(uint64_, 0xffffffffffffffff)
 844            uchar_ = tree_store.get_value(treeiter, 13)
 845            self.assertEquals(ord(uchar_), 254)
 846            char_ = tree_store.get_value(treeiter, 14)
 847            self.assertEquals(char_, 'a')
 848
 849            parent = treeiter
 850            treeiter = tree_store.iter_children(parent)
 851
 852         self.assertEquals(i, 99)
 853
 854     def test_list_store(self):
 855         class TestPyObject(object):
 856             pass
 857
 858         test_pyobj = TestPyObject()
 859         test_pydict = {1:1, "2":2, "3":"3"}
 860         test_pylist = [1,"2", "3"]
 861
 862         list_store = Gtk.ListStore(int, str, 'GIOverrideTreeAPITest', object, object, object, bool, bool)
 863         for i in range(1, 93):
 864             label = 'this is row #%d' % i
 865             testobj = TestGtk.TestClass(self, i, label)
 866             parent = list_store.append((i,
 867                                         label,
 868                                         testobj,
 869                                         test_pyobj,
 870                                         test_pydict,
 871                                         test_pylist,
 872                                         i % 2,
 873                                         bool(i % 2)))
 874
 875         i = 93
 876         label = _unicode('this is row #93')
 877         treeiter = list_store.append()
 878         list_store.set_value(treeiter, 0, i)
 879         list_store.set_value(treeiter, 1, label)
 880         list_store.set_value(treeiter, 2, TestGtk.TestClass(self, i, label))
 881         list_store.set_value(treeiter, 3, test_pyobj)
 882         list_store.set_value(treeiter, 4, test_pydict)
 883         list_store.set_value(treeiter, 5, test_pylist)
 884         list_store.set_value(treeiter, 6, 1)
 885         list_store.set_value(treeiter, 7, True)
 886
 887         # test prepend
 888         label = 'this is row #0'
 889         list_store.prepend((0,
 890                             label,
 891                             TestGtk.TestClass(self, 0, label),
 892                             test_pyobj,
 893                             test_pydict,
 894                             test_pylist,
 895                             0,
 896                             False))
 897
 898         # test automatic unicode->str conversion
 899         i = 94
 900         label = _unicode('this is row #94')
 901         treeiter = list_store.append((i,
 902                                       label,
 903                                       TestGtk.TestClass(self, i, label),
 904                                       test_pyobj,
 905                                       test_pydict,
 906                                       test_pylist,
 907                                       0,
 908                                       False))
 909
 910         # add sorted items out of order to test insert* apis
 911         # also test sending in None to not set a column
 912         i = 97
 913         label = 'this is row #97'
 914         treeiter = list_store.append((None,
 915                                       None,
 916                                       None,
 917                                       test_pyobj,
 918                                       None,
 919                                       test_pylist,
 920                                       1,
 921                                       None))
 922
 923         list_store.set_value(treeiter, 0, i)
 924         list_store.set_value(treeiter, 1, label)
 925         list_store.set_value(treeiter, 2, TestGtk.TestClass(self, i, label))
 926         list_store.set_value(treeiter, 4, test_pydict)
 927         list_store.set_value(treeiter, 7, True)
 928
 929         # this should append
 930         i = 99
 931         label = 'this is row #99'
 932         list_store.insert(9999, (i,
 933                                  label,
 934                                  TestGtk.TestClass(self, i, label),
 935                                  test_pyobj,
 936                                  test_pydict,
 937                                  test_pylist,
 938                                  1,
 939                                  True))
 940
 941         i = 96
 942         label = 'this is row #96'
 943         list_store.insert_before(treeiter, (i,
 944                                             label,
 945                                             TestGtk.TestClass(self, i, label),
 946                                             test_pyobj,
 947                                             test_pydict,
 948                                             test_pylist,
 949                                             0,
 950                                             False))
 951
 952         i = 98
 953         label = 'this is row #98'
 954         list_store.insert_after(treeiter, (i,
 955                                            label,
 956                                            TestGtk.TestClass(self, i, label),
 957                                            test_pyobj,
 958                                            test_pydict,
 959                                            test_pylist,
 960                                            0,
 961                                            False))
 962
 963
 964         i = 95
 965         label = 'this is row #95'
 966         list_store.insert(95, (i,
 967                                label,
 968                                TestGtk.TestClass(self, i, label),
 969                                test_pyobj,
 970                                test_pydict,
 971                                test_pylist,
 972                                1,
 973                                True))
 974
 975         i = 100
 976         label = 'this is row #100'
 977         treeiter = list_store.append()
 978         list_store.set(treeiter, 1, label,
 979                                  0, i,
 980                                  2, TestGtk.TestClass(self, i, label),
 981                                  3, test_pyobj,
 982                                  4, test_pydict,
 983                                  5, test_pylist,
 984                                  6, 0,
 985                                  7, False)
 986         i = 101
 987         label = 'this is row #101'
 988         treeiter = list_store.append()
 989         list_store.set(treeiter, {1: label,
 990                                   0: i,
 991                                   2: TestGtk.TestClass(self, i, label),
 992                                   3: test_pyobj,
 993                                   4: test_pydict,
 994                                   5: test_pylist,
 995                                   6: 1,
 996                                   7: True})
 997         i = 102
 998         label = 'this is row #102'
 999         treeiter = list_store.append()
1000         list_store.set(treeiter, (1, 0, 2, 3, 4, 5, 6, 7),
1001                                   (label,
1002                                    i,
1003                                    TestGtk.TestClass(self, i, label),
1004                                    test_pyobj,
1005                                    test_pydict,
1006                                    test_pylist,
1007                                    0,
1008                                    False))
1009
1010         self.assertEquals(len(list_store), 103)
1011
1012         # walk the list to see if the values were stored correctly
1013         i = 0
1014         treeiter = list_store.get_iter_first()
1015
1016         counter = 0
1017         while treeiter:
1018             i = list_store.get_value(treeiter, 0)
1019             self.assertEquals(i, counter)
1020             s = list_store.get_value(treeiter, 1)
1021             obj = list_store.get_value(treeiter, 2)
1022             obj.check(i, s)
1023
1024             pyobj = list_store.get_value(treeiter, 3)
1025             self.assertEquals(pyobj, test_pyobj)
1026             pydict = list_store.get_value(treeiter, 4)
1027             self.assertEquals(pydict, test_pydict)
1028             pylist = list_store.get_value(treeiter, 5)
1029             self.assertEquals(pylist, test_pylist)
1030
1031             bool_1 = list_store.get_value(treeiter, 6)
1032             bool_2 = list_store.get_value(treeiter, 7)
1033             self.assertEquals(bool_1, bool_2)
1034             self.assertTrue(isinstance(bool_1, bool))
1035             self.assertTrue(isinstance(bool_2, bool))
1036
1037             treeiter = list_store.iter_next(treeiter)
1038
1039             counter += 1
1040
1041         self.assertEquals(i, 102)
1042
1043     def test_tree_path(self):
1044         p1 = Gtk.TreePath()
1045         p2 = Gtk.TreePath.new_first()
1046         self.assertEqual(p1, p2)
1047         self.assertEqual(str(p1), '0')
1048         p1 = Gtk.TreePath(2)
1049         p2 = Gtk.TreePath.new_from_string('2')
1050         self.assertEqual(p1, p2)
1051         self.assertEqual(str(p1), '2')
1052         p1 = Gtk.TreePath('1:2:3')
1053         p2 = Gtk.TreePath.new_from_string('1:2:3')
1054         self.assertEqual(p1, p2)
1055         self.assertEqual(str(p1), '1:2:3')
1056         p1 = Gtk.TreePath((1,2,3))
1057         p2 = Gtk.TreePath.new_from_string('1:2:3')
1058         self.assertEqual(p1, p2)
1059         self.assertEqual(str(p1), '1:2:3')
1060         self.assertTrue(p1 != None)
1061         self.assertFalse(p1 == None)
1062         self.assertTrue(p1 > None)
1063         self.assertTrue(p1 >= None)
1064         self.assertFalse(p1 < None)
1065         self.assertFalse(p1 <= None)
1066
1067     def test_tree_model(self):
1068         tree_store = Gtk.TreeStore(int, str)
1069
1070         self.assertTrue(tree_store)
1071         self.assertEqual(len(tree_store), 0)
1072         self.assertEqual(tree_store.get_iter_first(), None)
1073
1074         def get_by_index(row, col=None):
1075             if col:
1076                 return tree_store[row][col]
1077             else:
1078                 return tree_store[row]
1079
1080         self.assertRaises(TypeError, get_by_index, None)
1081         self.assertRaises(TypeError, get_by_index, "")
1082         self.assertRaises(TypeError, get_by_index, ())
1083
1084         self.assertRaises(IndexError, get_by_index, "0")
1085         self.assertRaises(IndexError, get_by_index, 0)
1086         self.assertRaises(IndexError, get_by_index, (0,))
1087
1088         self.assertRaises(ValueError, tree_store.get_iter, "0")
1089         self.assertRaises(ValueError, tree_store.get_iter, 0)
1090         self.assertRaises(ValueError, tree_store.get_iter, (0,))
1091
1092         self.assertRaises(ValueError, tree_store.get_iter_from_string, "0")
1093
1094         for row in tree_store:
1095             self.fail("Should not be reached")
1096
1097         class DerivedIntType(int):
1098             pass
1099
1100         class DerivedStrType(str):
1101             pass
1102
1103         for i in range(100):
1104             label = 'this is row #%d' % i
1105             parent = tree_store.append(None, (DerivedIntType(i), DerivedStrType(label),))
1106             self.assertNotEquals(parent, None)
1107             for j in range(20):
1108                 label = 'this is child #%d of node #%d' % (j, i)
1109                 child = tree_store.append(parent, (j, label,))
1110                 self.assertNotEqual(child, None)
1111
1112         self.assertTrue(tree_store)
1113         self.assertEqual(len(tree_store), 100)
1114
1115         for i,row in enumerate(tree_store):
1116             self.assertEqual(row.model, tree_store)
1117             self.assertEqual(row.parent, None)
1118
1119             self.assertEqual(tree_store[i].path, row.path)
1120             self.assertEqual(tree_store[str(i)].path, row.path)
1121             self.assertEqual(tree_store[(i,)].path, row.path)
1122
1123             self.assertEqual(tree_store[i][0], i)
1124             self.assertEqual(tree_store[i][1], "this is row #%d" % i)
1125
1126             aiter = tree_store.get_iter(i)
1127             self.assertEqual(tree_store.get_path(aiter), row.path)
1128
1129             aiter = tree_store.get_iter(str(i))
1130             self.assertEqual(tree_store.get_path(aiter), row.path)
1131
1132             aiter = tree_store.get_iter((i,))
1133             self.assertEqual(tree_store.get_path(aiter), row.path)
1134
1135             self.assertEqual(tree_store.iter_parent(aiter), row.parent)
1136
1137             next = tree_store.iter_next(aiter)
1138             if i < len(tree_store) - 1:
1139                 self.assertEqual(tree_store.get_path(next), row.next.path)
1140             else:
1141                 self.assertEqual(next, None)
1142
1143             self.assertEqual(tree_store.iter_n_children(row.iter), 20)
1144
1145             child = tree_store.iter_children(row.iter)
1146             for j,childrow in enumerate(row.iterchildren()):
1147                 child_path = tree_store.get_path(child)
1148                 self.assertEqual(childrow.path, child_path)
1149                 self.assertEqual(childrow.parent.path, row.path)
1150                 self.assertEqual(childrow.path, tree_store[child].path)
1151                 self.assertEqual(childrow.path, tree_store[child_path].path)
1152
1153                 self.assertEqual(childrow[0], tree_store[child][0])
1154                 self.assertEqual(childrow[0], j)
1155                 self.assertEqual(childrow[1], tree_store[child][1])
1156                 self.assertEqual(childrow[1], 'this is child #%d of node #%d' % (j, i))
1157
1158                 self.assertRaises(IndexError, get_by_index, child, 2)
1159
1160                 tree_store[child][1] = 'this was child #%d of node #%d' % (j, i)
1161                 self.assertEqual(childrow[1], 'this was child #%d of node #%d' % (j, i))
1162
1163                 nth_child = tree_store.iter_nth_child(row.iter, j)
1164                 self.assertEqual(childrow.path, tree_store.get_path(nth_child))
1165
1166                 childrow2 = tree_store["%d:%d" % (i, j)]
1167                 self.assertEqual(childrow.path, childrow2.path)
1168
1169                 childrow2 = tree_store[(i, j,)]
1170                 self.assertEqual(childrow.path, childrow2.path)
1171
1172                 child = tree_store.iter_next(child)
1173                 if j < 19:
1174                     self.assertEqual(childrow.next.path, tree_store.get_path(child))
1175                 else:
1176                     self.assertEqual(child, childrow.next)
1177                     self.assertEqual(child, None)
1178
1179             self.assertEqual(j, 19)
1180
1181         self.assertEqual(i, 99)
1182
1183         # negative indices
1184         for i in range(-1,-100,-1):
1185             i_real = i + 100
1186             self.assertEqual(tree_store[i][0], i_real)
1187
1188             row = tree_store[i]
1189             for j in range(-1, -20, -1):
1190                 j_real = j + 20
1191                 path = (i_real, j_real,)
1192
1193                 self.assertEqual(tree_store[path][-2], j_real)
1194
1195                 label = 'this was child #%d of node #%d' % (j_real, i_real)
1196                 self.assertEqual(tree_store[path][-1], label)
1197
1198                 new_label = 'this still is child #%d of node #%d' % (j_real, i_real)
1199                 tree_store[path][-1] = new_label
1200                 self.assertEqual(tree_store[path][-1], new_label)
1201
1202                 self.assertRaises(IndexError, get_by_index, path, -3)
1203
1204         self.assertRaises(IndexError, get_by_index, -101)
1205
1206         last_row = tree_store[99]
1207         self.assertNotEqual(last_row, None)
1208
1209         for i,childrow in enumerate(last_row.iterchildren()):
1210             if i < 19:
1211                 self.assertTrue(tree_store.remove(childrow.iter))
1212             else:
1213                 self.assertFalse(tree_store.remove(childrow.iter))
1214
1215         self.assertEqual(i, 19)
1216
1217         self.assertEqual(tree_store.iter_n_children(last_row.iter), 0)
1218         for childrow in last_row.iterchildren():
1219             self.fail("Should not be reached")
1220
1221         aiter = tree_store.get_iter(10)
1222         self.assertRaises(TypeError, tree_store.get, aiter, 1, 'a')
1223         self.assertRaises(ValueError, tree_store.get, aiter, 1, -1)
1224         self.assertRaises(ValueError, tree_store.get, aiter, 1, 100)
1225         self.assertEqual(tree_store.get(aiter, 0, 1), (10, 'this is row #10'))
1226
1227     def test_tree_view_column(self):
1228         cell = Gtk.CellRendererText()
1229         column = Gtk.TreeViewColumn(title='This is just a test',
1230                                     cell_renderer=cell,
1231                                     text=0,
1232                                     style=2)
1233
1234     def test_tree_selection(self):
1235         store = Gtk.ListStore(int, str)
1236         for i in range(10):
1237             store.append((i, "foo"))
1238         view = Gtk.TreeView()
1239         view.set_model(store)
1240         firstpath = store.get_path(store.get_iter_first())
1241         sel = view.get_selection()
1242
1243         sel.select_path(firstpath)
1244         (m, s) = sel.get_selected()
1245         self.assertEqual(m, store)
1246         self.assertEqual(store.get_path(s), firstpath)
1247
1248         sel.select_path(0)
1249         (m, s) = sel.get_selected()
1250         self.assertEqual(m, store)
1251         self.assertEqual(store.get_path(s), firstpath)
1252
1253         sel.select_path("0:0")
1254         (m, s) = sel.get_selected()
1255         self.assertEqual(m, store)
1256         self.assertEqual(store.get_path(s), firstpath)
1257
1258         sel.select_path((0,0))
1259         (m, s) = sel.get_selected()
1260         self.assertEqual(m, store)
1261         self.assertEqual(store.get_path(s), firstpath)
1262
1263     def test_text_buffer(self):
1264         self.assertEquals(Gtk.TextBuffer, overrides.Gtk.TextBuffer)
1265         buffer = Gtk.TextBuffer()
1266         tag = buffer.create_tag ('title', font = 'Sans 18')
1267
1268         self.assertEquals(tag.props.name, 'title')
1269         self.assertEquals(tag.props.font, 'Sans 18')
1270
1271         (start, end) = buffer.get_bounds()
1272
1273         mark = buffer.create_mark(None, start)
1274         self.assertFalse(mark.get_left_gravity())
1275
1276         buffer.set_text('Hello Jane Hello Bob')
1277         (start, end) = buffer.get_bounds()
1278         text = buffer.get_text(start, end, False)
1279         self.assertEquals(text, 'Hello Jane Hello Bob')
1280
1281         buffer.set_text('')
1282         (start, end) = buffer.get_bounds()
1283         text = buffer.get_text(start, end, False)
1284         self.assertEquals(text, '')
1285
1286         buffer.insert(end, 'HelloHello')
1287         buffer.insert(end, ' Bob')
1288
1289         cursor_iter = end.copy()
1290         cursor_iter.backward_chars(9)
1291         buffer.place_cursor(cursor_iter)
1292         buffer.insert_at_cursor(' Jane ')
1293
1294         (start, end) = buffer.get_bounds()
1295         text = buffer.get_text(start, end, False)
1296         self.assertEquals(text, 'Hello Jane Hello Bob')
1297
1298         sel = buffer.get_selection_bounds()
1299         self.assertEquals(sel, ())
1300         buffer.select_range(start, end)
1301         sel = buffer.get_selection_bounds()
1302         self.assertTrue(sel[0].equal(start))
1303         self.assertTrue(sel[1].equal(end))
1304
1305         buffer.set_text('')
1306         buffer.insert_with_tags(buffer.get_start_iter(), 'HelloHello', tag)
1307         (start, end) = buffer.get_bounds()
1308         self.assertTrue(start.begins_tag(tag))
1309         self.assertTrue(start.has_tag(tag))
1310
1311         buffer.set_text('')
1312         buffer.insert_with_tags_by_name(buffer.get_start_iter(), 'HelloHello', 'title')
1313         (start, end) = buffer.get_bounds()
1314         self.assertTrue(start.begins_tag(tag))
1315         self.assertTrue(start.has_tag(tag))
1316
1317         self.assertRaises(ValueError, buffer.insert_with_tags_by_name,
1318                 buffer.get_start_iter(), 'HelloHello', 'unknowntag')
1319
1320     def test_text_iter(self):
1321         self.assertEquals(Gtk.TextIter, overrides.Gtk.TextIter)
1322         buffer = Gtk.TextBuffer()
1323         buffer.set_text('Hello Jane Hello Bob')
1324         tag = buffer.create_tag ('title', font = 'Sans 18')
1325         (start, end) = buffer.get_bounds()
1326         start.forward_chars(10)
1327         buffer.apply_tag(tag, start, end)
1328         self.assertTrue(start.begins_tag())
1329         self.assertTrue(end.ends_tag())
1330         self.assertTrue(start.toggles_tag())
1331         self.assertTrue(end.toggles_tag())
1332         start.backward_chars(1)
1333         self.assertFalse(start.begins_tag())
1334         self.assertFalse(start.ends_tag())
1335         self.assertFalse(start.toggles_tag())
1336
1337     def test_buttons(self):
1338         self.assertEquals(Gtk.Button, overrides.Gtk.Button)
1339
1340         # test Gtk.Button
1341         button = Gtk.Button()
1342         button = Gtk.Button(stock=Gtk.STOCK_CLOSE)
1343         self.assertEquals(Gtk.STOCK_CLOSE, button.get_label())
1344         self.assertTrue(button.get_use_stock())
1345         self.assertTrue(button.get_use_underline())
1346
1347         # test Gtk.LinkButton
1348         self.assertRaises(TypeError, Gtk.LinkButton)
1349         button = Gtk.LinkButton('http://www.gtk.org', 'Gtk')
1350         self.assertEquals('http://www.gtk.org', button.get_uri())
1351         self.assertEquals('Gtk', button.get_label())
1352
1353     def test_inheritance(self):
1354         for name in overrides.Gtk.__all__:
1355             over = getattr(overrides.Gtk, name)
1356             for element in dir(Gtk):
1357                 try:
1358                     klass = getattr(Gtk, element)
1359                     info = klass.__info__
1360                 except (NotImplementedError, AttributeError):
1361                     continue
1362
1363                 # Get all parent classes and interfaces klass inherits from
1364                 if isinstance(info, gi.types.ObjectInfo):
1365                     classes = list(info.get_interfaces())
1366                     parent = info.get_parent()
1367                     while parent.get_name() != "Object":
1368                         classes.append(parent)
1369                         parent = parent.get_parent()
1370                     classes = [kl for kl in classes if kl.get_namespace() == "Gtk"]
1371                 else:
1372                     continue
1373
1374                 for kl in classes:
1375                     if kl.get_name() == name:
1376                         self.assertTrue(issubclass(klass, over,),
1377                             "%r does not inherit from override %r" % (klass, over,))
1378
1379     def test_editable(self):
1380         self.assertEquals(Gtk.Editable, overrides.Gtk.Editable)
1381
1382         # need to use Gtk.Entry because Editable is an interface
1383         entry=Gtk.Entry()
1384         pos = entry.insert_text('HeWorld', 0)
1385         self.assertEquals(pos, 7)
1386         pos = entry.insert_text('llo ', 2)
1387         self.assertEquals(pos, 6)
1388         text = entry.get_chars(0, 11)
1389         self.assertEquals('Hello World', text)
1390
1391     def test_label(self):
1392         label = Gtk.Label(label='Hello')
1393         self.assertEquals(label.get_text(), 'Hello')
1394
1395     def adjustment_check(self, adjustment, value=0.0, lower=0.0, upper=0.0,
1396                          step_increment=0.0, page_increment=0.0, page_size=0.0):
1397         self.assertEquals(adjustment.get_value(), value)
1398         self.assertEquals(adjustment.get_lower(), lower)
1399         self.assertEquals(adjustment.get_upper(), upper)
1400         self.assertEquals(adjustment.get_step_increment(), step_increment)
1401         self.assertEquals(adjustment.get_page_increment(), page_increment)
1402         self.assertEquals(adjustment.get_page_size(), page_size)
1403
1404     def test_adjustment(self):
1405         adjustment =       Gtk.Adjustment(1, 0, 6, 4, 5, 3)
1406         self.adjustment_check(adjustment, 1, 0, 6, 4, 5, 3)
1407
1408         adjustment =       Gtk.Adjustment(1, 0, 6, 4, 5)
1409         self.adjustment_check(adjustment, 1, 0, 6, 4, 5)
1410
1411         adjustment =       Gtk.Adjustment(1, 0, 6, 4)
1412         self.adjustment_check(adjustment, 1, 0, 6, 4)
1413
1414         adjustment =       Gtk.Adjustment(1, 0, 6)
1415         self.adjustment_check(adjustment, 1, 0, 6)
1416
1417         adjustment = Gtk.Adjustment()
1418         self.adjustment_check(adjustment)
1419
1420         adjustment = Gtk.Adjustment(value=1, lower=0, upper=6,
1421                                     step_increment=4, page_increment=5, page_size=3)
1422         self.adjustment_check(adjustment, 1, 0, 6, 4, 5, 3)
1423
1424     def test_table(self):
1425         table = Gtk.Table()
1426         self.assertEquals(table.get_size(), (1,1))
1427         self.assertEquals(table.get_homogeneous(), False)
1428         table = Gtk.Table(2, 3)
1429         self.assertEquals(table.get_size(), (2,3))
1430         self.assertEquals(table.get_homogeneous(), False)
1431         table = Gtk.Table(2, 3, True)
1432         self.assertEquals(table.get_size(), (2,3))
1433         self.assertEquals(table.get_homogeneous(), True)
1434
1435         # Test PyGTK interface
1436         table = Gtk.Table(rows=3, columns=2)
1437         self.assertEquals(table.get_size(), (3,2))
1438         # Test using the actual property names
1439         table = Gtk.Table(n_rows=2, n_columns=3, homogeneous=True)
1440         self.assertEquals(table.get_size(), (2,3))
1441         self.assertEquals(table.get_homogeneous(), True)
1442
1443         label = Gtk.Label(label='Hello')
1444         table.attach(label, 0, 1, 0, 1)
1445         self.assertEquals(label, table.get_children()[0])
1446
1447     def test_scrolledwindow(self):
1448         sw = Gtk.ScrolledWindow()
1449         sb = sw.get_hscrollbar()
1450         self.assertEquals(sw.get_hadjustment(), sb.get_adjustment())
1451         sb = sw.get_vscrollbar()
1452         self.assertEquals(sw.get_vadjustment(), sb.get_adjustment())
1453
1454     def test_widget_drag_methods(self):
1455         widget = Gtk.Button()
1456
1457         # here we are not checking functionality, only that the methods exist
1458         # and except the right number of arguments
1459
1460         widget.drag_check_threshold(0, 0, 0, 0)
1461
1462         # drag_dest_ methods
1463         widget.drag_dest_set(Gtk.DestDefaults.DROP, None, Gdk.DragAction.COPY)
1464         widget.drag_dest_add_image_targets()
1465         widget.drag_dest_add_text_targets()
1466         widget.drag_dest_add_uri_targets()
1467         widget.drag_dest_get_track_motion()
1468         widget.drag_dest_set_track_motion(True)
1469         widget.drag_dest_get_target_list()
1470         widget.drag_dest_set_target_list(Gtk.TargetList.new([Gtk.TargetEntry()]))
1471         widget.drag_dest_unset()
1472
1473         widget.drag_highlight()
1474         widget.drag_unhighlight()
1475
1476         # drag_source_ methods
1477         widget.drag_source_set(Gdk.ModifierType.BUTTON1_MASK, None, Gdk.DragAction.MOVE)
1478         widget.drag_source_add_image_targets()
1479         widget.drag_source_add_text_targets()
1480         widget.drag_source_add_uri_targets()
1481         widget.drag_source_set_icon_name("")
1482         widget.drag_source_set_icon_pixbuf(GdkPixbuf.Pixbuf())
1483         widget.drag_source_set_icon_stock("")
1484         widget.drag_source_get_target_list()
1485         widget.drag_source_set_target_list(Gtk.TargetList.new([Gtk.TargetEntry()]))
1486         widget.drag_source_unset()
1487
1488         # these methods cannot be called because they require a valid drag on
1489         # a real GdkWindow. So we only check that they exist and are callable.
1490         self.assertTrue(hasattr(widget.drag_dest_set_proxy, '__call__'))
1491         self.assertTrue(hasattr(widget.drag_get_data, '__call__'))
1492
1493 class TestGio(unittest.TestCase):
1494     def setUp(self):
1495         os.environ['GSETTINGS_BACKEND'] = 'memory'
1496         # support a separate build tree, so look in build dir first
1497         os.environ['GSETTINGS_SCHEMA_DIR'] = os.environ.get('TESTS_BUILDDIR',
1498                 os.path.dirname(__file__))
1499         self.settings = Gio.Settings('org.gnome.test')
1500         # we change the values in the tests, so set them to predictable start
1501         # value
1502         self.settings.reset('test-string')
1503         self.settings.reset('test-array')
1504
1505     def test_file_enumerator(self):
1506         self.assertEquals(Gio.FileEnumerator, overrides.Gio.FileEnumerator)
1507         f = Gio.file_new_for_path("./")
1508
1509         iter_info = []
1510         for info in f.enumerate_children("standard::*", 0, None):
1511             iter_info.append(info.get_name())
1512
1513         next_info = []
1514         enumerator = f.enumerate_children("standard::*", 0, None)
1515         while True:
1516             info = enumerator.next_file(None)
1517             if info is None:
1518                 break
1519             next_info.append(info.get_name())
1520
1521         self.assertEquals(iter_info, next_info)
1522
1523     def test_gsettings_native(self):
1524         self.assertTrue('test-array' in self.settings.list_keys())
1525
1526         # get various types
1527         v = self.settings.get_value('test-boolean')
1528         self.assertEqual(v.get_boolean(), True)
1529         self.assertEqual(self.settings.get_boolean('test-boolean'), True)
1530
1531         v = self.settings.get_value('test-string')
1532         self.assertEqual(v.get_string(), 'Hello')
1533         self.assertEqual(self.settings.get_string('test-string'), 'Hello')
1534
1535         v = self.settings.get_value('test-array')
1536         self.assertEqual(v.unpack(), [1, 2])
1537
1538         v = self.settings.get_value('test-tuple')
1539         self.assertEqual(v.unpack(), (1, 2))
1540
1541         # set a value
1542         self.settings.set_string('test-string', 'World')
1543         self.assertEqual(self.settings.get_string('test-string'), 'World')
1544
1545         self.settings.set_value('test-string', GLib.Variant('s', 'Goodbye'))
1546         self.assertEqual(self.settings.get_string('test-string'), 'Goodbye')
1547
1548     def test_gsettings_constructor(self):
1549         # default constructor uses path from schema
1550         self.assertEqual(self.settings.get_property('path'), '/tests/')
1551
1552         # optional constructor arguments
1553         with_path = Gio.Settings('org.gnome.nopathtest', path='/mypath/')
1554         self.assertEqual(with_path.get_property('path'), '/mypath/')
1555         self.assertEqual(with_path['np-int'], 42)
1556
1557     def test_gsettings_override(self):
1558         # dictionary interface
1559         self.assertEqual(len(self.settings), 4)
1560         self.assertTrue('test-array' in self.settings)
1561         self.assertTrue('test-array' in self.settings.keys())
1562         self.failIf('nonexisting' in self.settings)
1563         self.failIf(4 in self.settings)
1564         self.assertEqual(bool(self.settings), True)
1565
1566         # get various types
1567         self.assertEqual(self.settings['test-boolean'], True)
1568         self.assertEqual(self.settings['test-string'], 'Hello')
1569         self.assertEqual(self.settings['test-array'], [1, 2])
1570         self.assertEqual(self.settings['test-tuple'], (1, 2))
1571
1572         self.assertRaises(KeyError, self.settings.__getitem__, 'unknown')
1573         self.assertRaises(KeyError, self.settings.__getitem__, 2)
1574
1575         # set a value
1576         self.settings['test-string'] = 'Goodbye'
1577         self.assertEqual(self.settings['test-string'], 'Goodbye')
1578         self.settings['test-array'] = [3, 4, 5]
1579         self.assertEqual(self.settings['test-array'], [3, 4, 5])
1580
1581         self.assertRaises(TypeError, self.settings.__setitem__, 'test-string', 1)
1582         self.assertRaises(KeyError, self.settings.__setitem__, 'unknown', 'moo')
1583
1584     def test_gsettings_empty(self):
1585         empty = Gio.Settings('org.gnome.empty', path='/tests/')
1586         self.assertEqual(len(empty), 0)
1587         self.assertEqual(bool(empty), True)
1588         self.assertEqual(empty.keys(), [])