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