tests/test_overrides.py

   1 # -*- Mode: Python; py-indent-offset: 4 -*-
   2 # vim: tabstop=4 shiftwidth=4 expandtab
   3
   4 import pygtk
   5 pygtk.require("2.0")
   6
   7 import unittest
   8
   9 import sys
  10 sys.path.insert(0, "../")
  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 import gi.overrides as overrides
  17 import gi.types
  18
  19 class TestGLib(unittest.TestCase):
  20
  21     def test_gvariant(self):
  22         variant = GLib.Variant('i', 42)
  23         self.assertTrue(isinstance(variant, GLib.Variant))
  24         self.assertEquals(variant.get_int32(), 42)
  25
  26         variant = GLib.Variant('(ss)', 'mec', 'mac')
  27         self.assertTrue(isinstance(variant, GLib.Variant))
  28         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
  29         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
  30         self.assertEquals(variant.get_child_value(0).get_string(), 'mec')
  31         self.assertEquals(variant.get_child_value(1).get_string(), 'mac')
  32
  33         variant = GLib.Variant('a{si}', {'key1': 1, 'key2': 2})
  34         self.assertTrue(isinstance(variant, GLib.Variant))
  35         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
  36         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
  37         # Looks like order is not preserved
  38         self.assertEquals(variant.get_child_value(1).get_child_value(0).get_string(), 'key1')
  39         self.assertEquals(variant.get_child_value(1).get_child_value(1).get_int32(), 1)
  40         self.assertEquals(variant.get_child_value(0).get_child_value(0).get_string(), 'key2')
  41         self.assertEquals(variant.get_child_value(0).get_child_value(1).get_int32(), 2)
  42
  43 class TestGdk(unittest.TestCase):
  44
  45     def test_color(self):
  46         color = Gdk.Color(100, 200, 300)
  47         self.assertEquals(color.red, 100)
  48         self.assertEquals(color.green, 200)
  49         self.assertEquals(color.blue, 300)
  50
  51     def test_event(self):
  52         event = Gdk.Event.new(Gdk.EventType.CONFIGURE)
  53         self.assertEquals(event.type, Gdk.EventType.CONFIGURE)
  54         self.assertEquals(event.send_event, 0)
  55
  56         event = Gdk.Event.new(Gdk.EventType.DRAG_MOTION)
  57         event.x_root, event.y_root = 0, 5
  58         self.assertEquals(event.x_root, 0)
  59         self.assertEquals(event.y_root, 5)
  60
  61 class TestGtk(unittest.TestCase):
  62     def test_uimanager(self):
  63         self.assertEquals(Gtk.UIManager, overrides.Gtk.UIManager)
  64         ui = Gtk.UIManager()
  65         ui.add_ui_from_string(
  66 """
  67 <ui>
  68     <menubar name="menubar1"></menubar>
  69 </ui>
  70 """
  71 )
  72         menubar = ui.get_widget("/menubar1")
  73         self.assertEquals(type(menubar), Gtk.MenuBar)
  74
  75     def test_actiongroup(self):
  76         self.assertEquals(Gtk.ActionGroup, overrides.Gtk.ActionGroup)
  77         action_group = Gtk.ActionGroup (name = 'TestActionGroup')
  78         callback_data = "callback data"
  79
  80         def test_action_callback_data(action, user_data):
  81             self.assertEquals(user_data, callback_data);
  82
  83         def test_radio_action_callback_data(action, current, user_data):
  84             self.assertEquals(user_data, callback_data);
  85
  86         action_group.add_actions ([
  87             ('test-action1', None, 'Test Action 1',
  88              None, None, test_action_callback_data),
  89             ('test-action2', Gtk.STOCK_COPY, 'Test Action 2',
  90               None, None, test_action_callback_data)], callback_data)
  91         action_group.add_toggle_actions([
  92             ('test-toggle-action1', None, 'Test Toggle Action 1',
  93              None, None, test_action_callback_data, False),
  94             ('test-toggle-action2', Gtk.STOCK_COPY, 'Test Toggle Action 2',
  95               None, None, test_action_callback_data, True)], callback_data)
  96         action_group.add_radio_actions([
  97             ('test-radio-action1', None, 'Test Radio Action 1'),
  98             ('test-radio-action2', Gtk.STOCK_COPY, 'Test Radio Action 2')], 1,
  99             test_radio_action_callback_data,
 100             callback_data)
 101
 102         expected_results = (('test-action1', Gtk.Action),
 103                             ('test-action2', Gtk.Action),
 104                             ('test-toggle-action1', Gtk.ToggleAction),
 105                             ('test-toggle-action2', Gtk.ToggleAction),
 106                             ('test-radio-action1', Gtk.RadioAction),
 107                             ('test-radio-action2', Gtk.RadioAction))
 108
 109         for action, cmp in zip(action_group.list_actions(), expected_results):
 110             a = (action.get_name(), type(action))
 111             self.assertEquals(a,cmp)
 112             action.activate()
 113
 114     def test_builder(self):
 115         self.assertEquals(Gtk.Builder, overrides.Gtk.Builder)
 116
 117         class SignalTest(GObject.GObject):
 118             __gtype_name__ = "GIOverrideSignalTest"
 119             __gsignals__ = {
 120                 "test-signal": (GObject.SIGNAL_RUN_FIRST,
 121                                 GObject.TYPE_NONE,
 122                                 []),
 123             }
 124
 125
 126         class SignalCheck:
 127             def __init__(self):
 128                 self.sentinel = 0
 129
 130             def on_signal_1(self, *args):
 131                 self.sentinel += 1
 132
 133             def on_signal_3(self, *args):
 134                 self.sentinel += 3
 135
 136         signal_checker = SignalCheck()
 137         builder = Gtk.Builder()
 138
 139         # add object1 to the builder
 140         builder.add_from_string(
 141 """
 142 <interface>
 143   <object class="GIOverrideSignalTest" id="object1">
 144       <signal name="test-signal" handler="on_signal_1" />
 145   </object>
 146 </interface>
 147 """)
 148
 149         # only add object3 to the builder
 150         builder.add_objects_from_string(
 151 """
 152 <interface>
 153   <object class="GIOverrideSignalTest" id="object2">
 154       <signal name="test-signal" handler="on_signal_2" />
 155   </object>
 156   <object class="GIOverrideSignalTest" id="object3">
 157       <signal name="test-signal" handler="on_signal_3" />
 158   </object>
 159   <object class="GIOverrideSignalTest" id="object4">
 160       <signal name="test-signal" handler="on_signal_4" />
 161   </object>
 162 </interface>
 163
 164 """,
 165             ['object3'])
 166
 167         # hook up signals
 168         builder.connect_signals(signal_checker)
 169
 170         # call their notify signals and check sentinel
 171         objects = builder.get_objects()
 172         self.assertEquals(len(objects), 2)
 173         for obj in objects:
 174             obj.emit('test-signal')
 175
 176         self.assertEquals(signal_checker.sentinel, 4)
 177
 178     def test_dialogs(self):
 179         self.assertEquals(Gtk.Dialog, overrides.Gtk.Dialog)
 180         self.assertEquals(Gtk.AboutDialog, overrides.Gtk.AboutDialog)
 181         self.assertEquals(Gtk.MessageDialog, overrides.Gtk.MessageDialog)
 182         self.assertEquals(Gtk.ColorSelectionDialog, overrides.Gtk.ColorSelectionDialog)
 183         self.assertEquals(Gtk.FileChooserDialog, overrides.Gtk.FileChooserDialog)
 184         self.assertEquals(Gtk.FontSelectionDialog, overrides.Gtk.FontSelectionDialog)
 185         self.assertEquals(Gtk.RecentChooserDialog, overrides.Gtk.RecentChooserDialog)
 186
 187         # Gtk.Dialog
 188         dialog = Gtk.Dialog (title='Foo',
 189                              flags=Gtk.DialogFlags.MODAL,
 190                              buttons=('test-button1', 1))
 191
 192         dialog.add_buttons ('test-button2', 2, Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE)
 193
 194         self.assertEquals('Foo', dialog.get_title())
 195         self.assertTrue(dialog.get_modal())
 196         button = dialog.get_widget_for_response (1)
 197         self.assertEquals('test-button1', button.get_label())
 198         button = dialog.get_widget_for_response (2)
 199         self.assertEquals('test-button2', button.get_label())
 200         button = dialog.get_widget_for_response (Gtk.ResponseType.CLOSE)
 201         self.assertEquals(Gtk.STOCK_CLOSE, button.get_label())
 202
 203         # Gtk.AboutDialog
 204         dialog = Gtk.AboutDialog()
 205
 206         # Gtk.MessageDialog
 207         dialog = Gtk.MessageDialog (title='message dialog test',
 208                                     flags=Gtk.DialogFlags.MODAL,
 209                                     buttons=Gtk.ButtonsType.OK,
 210                                     message_format='dude!')
 211
 212         self.assertEquals('message dialog test', dialog.get_title())
 213         self.assertTrue(dialog.get_modal())
 214         text = dialog.get_property('text')
 215         self.assertEquals('dude!', text)
 216
 217         # Gtk.ColorSelectionDialog
 218         dialog = Gtk.ColorSelectionDialog("color selection dialog test")
 219         self.assertEquals('color selection dialog test', dialog.get_title())
 220
 221         # Gtk.FileChooserDialog
 222         dialog = Gtk.FileChooserDialog (title='file chooser dialog test',
 223                                         buttons=('test-button1', 1),
 224                                         action=Gtk.FileChooserAction.SAVE)
 225
 226         dialog.add_buttons ('test-button2', 2, Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE)
 227         self.assertEquals('file chooser dialog test', dialog.get_title())
 228         button = dialog.get_widget_for_response (1)
 229         self.assertEquals('test-button1', button.get_label())
 230         button = dialog.get_widget_for_response (2)
 231         self.assertEquals('test-button2', button.get_label())
 232         button = dialog.get_widget_for_response (Gtk.ResponseType.CLOSE)
 233         self.assertEquals(Gtk.STOCK_CLOSE, button.get_label())
 234         action = dialog.get_property('action')
 235         self.assertEquals(Gtk.FileChooserAction.SAVE, action)
 236
 237
 238         # Gtk.FontSelectionDialog
 239         dialog = Gtk.ColorSelectionDialog("font selection dialog test")
 240         self.assertEquals('font selection dialog test', dialog.get_title())
 241
 242         # Gtk.RecentChooserDialog
 243         test_manager = Gtk.RecentManager()
 244         dialog = Gtk.RecentChooserDialog (title='recent chooser dialog test',
 245                                           buttons=('test-button1', 1),
 246                                           manager=test_manager)
 247
 248         dialog.add_buttons ('test-button2', 2, Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE)
 249         self.assertEquals('recent chooser dialog test', dialog.get_title())
 250         button = dialog.get_widget_for_response (1)
 251         self.assertEquals('test-button1', button.get_label())
 252         button = dialog.get_widget_for_response (2)
 253         self.assertEquals('test-button2', button.get_label())
 254         button = dialog.get_widget_for_response (Gtk.ResponseType.CLOSE)
 255         self.assertEquals(Gtk.STOCK_CLOSE, button.get_label())
 256
 257     class TestClass(GObject.GObject):
 258         __gtype_name__ = "GIOverrideTreeAPITest"
 259
 260         def __init__(self, tester, int_value, string_value):
 261             super(TestGtk.TestClass, self).__init__()
 262             self.tester = tester
 263             self.int_value = int_value
 264             self.string_value = string_value
 265
 266         def check(self, int_value, string_value):
 267             self.tester.assertEquals(int_value, self.int_value)
 268             self.tester.assertEquals(string_value, self.string_value)
 269
 270     def test_tree_store(self):
 271         self.assertEquals(Gtk.TreeStore, overrides.Gtk.TreeStore)
 272         self.assertEquals(Gtk.ListStore, overrides.Gtk.ListStore)
 273         self.assertEquals(Gtk.TreeModel, overrides.Gtk.TreeModel)
 274         self.assertEquals(Gtk.TreeViewColumn, overrides.Gtk.TreeViewColumn)
 275
 276         class TestPyObject(object):
 277             pass
 278
 279         test_pyobj = TestPyObject()
 280         test_pydict = {1:1, "2":2, "3":"3"}
 281         test_pylist = [1,"2", "3"]
 282         tree_store = Gtk.TreeStore(int, 'gchararray', TestGtk.TestClass, object, object, object)
 283
 284         parent = None
 285         for i in range(100):
 286             label = 'this is child #%d' % i
 287             testobj = TestGtk.TestClass(self, i, label)
 288             parent = tree_store.append(parent, (i,
 289                                                 label,
 290                                                 testobj,
 291                                                 test_pyobj,
 292                                                 test_pydict,
 293                                                 test_pylist))
 294
 295         # len gets the number of children in the root node
 296         # since we kept appending to the previous node
 297         # there should only be one child of the root
 298         self.assertEquals(len(tree_store), 1)
 299
 300         # walk the tree to see if the values were stored correctly
 301         parent = None
 302         i = 0
 303
 304         treeiter = tree_store.iter_children(parent)
 305         while treeiter:
 306            i = tree_store.get_value(treeiter, 0)
 307            s = tree_store.get_value(treeiter, 1)
 308            obj = tree_store.get_value(treeiter, 2)
 309            i = tree_store.get_value(treeiter, 0)
 310            s = tree_store.get_value(treeiter, 1)
 311            obj = tree_store.get_value(treeiter, 2)
 312            obj.check(i, s)
 313
 314            pyobj = tree_store.get_value(treeiter, 3)
 315            self.assertEquals(pyobj, test_pyobj)
 316            pydict = tree_store.get_value(treeiter, 4)
 317            self.assertEquals(pydict, test_pydict)
 318            pylist = tree_store.get_value(treeiter, 5)
 319            self.assertEquals(pylist, test_pylist)
 320
 321            parent = treeiter
 322            treeiter = tree_store.iter_children(parent)
 323
 324         self.assertEquals(i, 99)
 325
 326     def test_list_store(self):
 327         class TestPyObject(object):
 328             pass
 329
 330         test_pyobj = TestPyObject()
 331         test_pydict = {1:1, "2":2, "3":"3"}
 332         test_pylist = [1,"2", "3"]
 333
 334         list_store = Gtk.ListStore(int, str, 'GIOverrideTreeAPITest', object, object, object)
 335         for i in range(95):
 336             label = 'this is row #%d' % i
 337             testobj = TestGtk.TestClass(self, i, label)
 338             parent = list_store.append((i,
 339                                         label,
 340                                         testobj,
 341                                         test_pyobj,
 342                                         test_pydict,
 343                                         test_pylist))
 344
 345         # add sorted items out of order to test insert* apis
 346         i = 97
 347         label = 'this is row #97'
 348         treeiter = list_store.append((i,
 349                                       label,
 350                                       TestGtk.TestClass(self, i, label),
 351                                       test_pyobj,
 352                                       test_pydict,
 353                                       test_pylist))
 354         # this should append
 355         i = 99
 356         label = 'this is row #99'
 357         list_store.insert(9999, (i,
 358                                  label,
 359                                  TestGtk.TestClass(self, i, label),
 360                                  test_pyobj,
 361                                  test_pydict,
 362                                  test_pylist))
 363
 364         i = 96
 365         label = 'this is row #96'
 366         list_store.insert_before(treeiter, (i,
 367                                             label,
 368                                             TestGtk.TestClass(self, i, label),
 369                                             test_pyobj,
 370                                             test_pydict,
 371                                             test_pylist))
 372
 373         i = 98
 374         label = 'this is row #98'
 375         list_store.insert_after(treeiter, (i,
 376                                            label,
 377                                            TestGtk.TestClass(self, i, label),
 378                                            test_pyobj,
 379                                            test_pydict,
 380                                            test_pylist))
 381
 382
 383         i = 95
 384         label = 'this is row #95'
 385         list_store.insert(95, (i,
 386                                label,
 387                                TestGtk.TestClass(self, i, label),
 388                                test_pyobj,
 389                                test_pydict,
 390                                test_pylist))
 391
 392         self.assertEquals(len(list_store), 100)
 393
 394         # walk the list to see if the values were stored correctly
 395         i = 0
 396         treeiter = list_store.get_iter_first()
 397
 398         counter = 0
 399         while treeiter:
 400             i = list_store.get_value(treeiter, 0)
 401             self.assertEquals(i, counter)
 402             s = list_store.get_value(treeiter, 1)
 403             obj = list_store.get_value(treeiter, 2)
 404             obj.check(i, s)
 405
 406             pyobj = list_store.get_value(treeiter, 3)
 407             self.assertEquals(pyobj, test_pyobj)
 408             pydict = list_store.get_value(treeiter, 4)
 409             self.assertEquals(pydict, test_pydict)
 410             pylist = list_store.get_value(treeiter, 5)
 411             self.assertEquals(pylist, test_pylist)
 412             treeiter = list_store.iter_next(treeiter)
 413
 414             counter += 1
 415
 416         self.assertEquals(i, 99)
 417
 418     def test_tree_model(self):
 419         tree_store = Gtk.TreeStore(int, str)
 420
 421         self.assertTrue(tree_store)
 422         self.assertEqual(len(tree_store), 0)
 423         self.assertEqual(tree_store.get_iter_first(), None)
 424
 425         def get_by_index(row, col=None):
 426             if col:
 427                 return tree_store[row][col]
 428             else:
 429                 return tree_store[row]
 430
 431         self.assertRaises(TypeError, get_by_index, None)
 432         self.assertRaises(TypeError, get_by_index, "")
 433         self.assertRaises(TypeError, get_by_index, ())
 434
 435         self.assertRaises(IndexError, get_by_index, "0")
 436         self.assertRaises(IndexError, get_by_index, 0)
 437         self.assertRaises(IndexError, get_by_index, (0,))
 438
 439         self.assertRaises(ValueError, tree_store.get_iter, "0")
 440         self.assertRaises(ValueError, tree_store.get_iter, 0)
 441         self.assertRaises(ValueError, tree_store.get_iter, (0,))
 442
 443         self.assertRaises(ValueError, tree_store.get_iter_from_string, "0")
 444
 445         for row in tree_store:
 446             self.fail("Should not be reached")
 447
 448         for i in range(100):
 449             label = 'this is row #%d' % i
 450             parent = tree_store.append(None, (i, label,))
 451             self.assertNotEquals(parent, None)
 452             for j in range(20):
 453                 label = 'this is child #%d of node #%d' % (j, i)
 454                 child = tree_store.append(parent, (j, label,))
 455                 self.assertNotEqual(child, None)
 456
 457         self.assertTrue(tree_store)
 458         self.assertEqual(len(tree_store), 100)
 459
 460         for i,row in enumerate(tree_store):
 461             self.assertEqual(row.model, tree_store)
 462             self.assertEqual(row.parent, None)
 463
 464             self.assertEqual(tree_store[i].path, row.path)
 465             self.assertEqual(tree_store[str(i)].path, row.path)
 466             self.assertEqual(tree_store[(i,)].path, row.path)
 467
 468             self.assertEqual(tree_store[i][0], i)
 469             self.assertEqual(tree_store[i][1], "this is row #%d" % i)
 470
 471             aiter = tree_store.get_iter(i)
 472             self.assertEqual(tree_store.get_path(aiter), row.path)
 473
 474             aiter = tree_store.get_iter(str(i))
 475             self.assertEqual(tree_store.get_path(aiter), row.path)
 476
 477             aiter = tree_store.get_iter((i,))
 478             self.assertEqual(tree_store.get_path(aiter), row.path)
 479
 480             self.assertEqual(tree_store.iter_parent(aiter), row.parent)
 481
 482             next = tree_store.iter_next(aiter)
 483             if i < len(tree_store) - 1:
 484                 self.assertEqual(tree_store.get_path(next), row.next.path)
 485             else:
 486                 self.assertEqual(next, None)
 487
 488             self.assertEqual(tree_store.iter_n_children(row.iter), 20)
 489
 490             child = tree_store.iter_children(row.iter)
 491             for j,childrow in enumerate(row.iterchildren()):
 492                 child_path = tree_store.get_path(child)
 493                 self.assertEqual(childrow.path, child_path)
 494                 self.assertEqual(childrow.parent.path, row.path)
 495                 self.assertEqual(childrow.path, tree_store[child].path)
 496                 self.assertEqual(childrow.path, tree_store[child_path].path)
 497
 498                 self.assertEqual(childrow[0], tree_store[child][0])
 499                 self.assertEqual(childrow[0], j)
 500                 self.assertEqual(childrow[1], tree_store[child][1])
 501                 self.assertEqual(childrow[1], 'this is child #%d of node #%d' % (j, i))
 502
 503                 self.assertRaises(IndexError, get_by_index, child, 2)
 504
 505                 tree_store[child][1] = 'this was child #%d of node #%d' % (j, i)
 506                 self.assertEqual(childrow[1], 'this was child #%d of node #%d' % (j, i))
 507
 508                 nth_child = tree_store.iter_nth_child(row.iter, j)
 509                 self.assertEqual(childrow.path, tree_store.get_path(nth_child))
 510
 511                 childrow2 = tree_store["%d:%d" % (i, j)]
 512                 self.assertEqual(childrow.path, childrow2.path)
 513
 514                 childrow2 = tree_store[(i, j,)]
 515                 self.assertEqual(childrow.path, childrow2.path)
 516
 517                 child = tree_store.iter_next(child)
 518                 if j < 19:
 519                     self.assertEqual(childrow.next.path, tree_store.get_path(child))
 520                 else:
 521                     self.assertEqual(child, childrow.next)
 522                     self.assertEqual(child, None)
 523
 524             self.assertEqual(j, 19)
 525
 526         self.assertEqual(i, 99)
 527
 528         # negative indices
 529         for i in range(-1,-100,-1):
 530             i_real = i + 100
 531             self.assertEqual(tree_store[i][0], i_real)
 532
 533             row = tree_store[i]
 534             for j in range(-1, -20, -1):
 535                 j_real = j + 20
 536                 path = (i_real, j_real,)
 537
 538                 self.assertEqual(tree_store[path][-2], j_real)
 539
 540                 label = 'this was child #%d of node #%d' % (j_real, i_real)
 541                 self.assertEqual(tree_store[path][-1], label)
 542
 543                 new_label = 'this still is child #%d of node #%d' % (j_real, i_real)
 544                 tree_store[path][-1] = new_label
 545                 self.assertEqual(tree_store[path][-1], new_label)
 546
 547                 self.assertRaises(IndexError, get_by_index, path, -3)
 548
 549         self.assertRaises(IndexError, get_by_index, -101)
 550
 551         last_row = tree_store[99]
 552         self.assertNotEqual(last_row, None)
 553
 554         for i,childrow in enumerate(last_row.iterchildren()):
 555             if i < 19:
 556                 self.assertTrue(tree_store.remove(childrow.iter))
 557             else:
 558                 self.assertFalse(tree_store.remove(childrow.iter))
 559
 560         self.assertEqual(i, 19)
 561
 562         self.assertEqual(tree_store.iter_n_children(last_row.iter), 0)
 563         for childrow in last_row.iterchildren():
 564             self.fail("Should not be reached")
 565
 566     def test_tree_view_column(self):
 567         cell = Gtk.CellRendererText()
 568         column = Gtk.TreeViewColumn(title='This is just a test',
 569                                     cell_renderer=cell,
 570                                     text=0,
 571                                     style=2)
 572
 573     def test_text_buffer(self):
 574         self.assertEquals(Gtk.TextBuffer, overrides.Gtk.TextBuffer)
 575         buffer = Gtk.TextBuffer()
 576         tag = buffer.create_tag ('title', font = 'Sans 18')
 577
 578         self.assertEquals(tag.props.name, 'title')
 579         self.assertEquals(tag.props.font, 'Sans 18')
 580
 581         (start, end) = buffer.get_bounds()
 582
 583         buffer.insert(end, 'HelloHello')
 584         buffer.insert(end, ' Bob')
 585
 586         cursor_iter = end.copy()
 587         cursor_iter.backward_chars(9)
 588         buffer.place_cursor(cursor_iter)
 589         buffer.insert_at_cursor(' Jane ')
 590
 591         (start, end) = buffer.get_bounds()
 592         text = buffer.get_text(start, end, False)
 593
 594         self.assertEquals(text, 'Hello Jane Hello Bob')
 595
 596     def test_buttons(self):
 597         self.assertEquals(Gtk.Button, overrides.Gtk.Button)
 598
 599         # test Gtk.Button
 600         button = Gtk.Button()
 601         button = Gtk.Button(stock=Gtk.STOCK_CLOSE)
 602         self.assertEquals(Gtk.STOCK_CLOSE, button.get_label())
 603         self.assertTrue(button.get_use_stock())
 604         self.assertTrue(button.get_use_underline())
 605
 606     def test_inheritance(self):
 607         for name in overrides.Gtk.__all__:
 608             over = getattr(overrides.Gtk, name)
 609             for element in dir(Gtk):
 610                 try:
 611                     klass = getattr(Gtk, element)
 612                     info = klass.__info__
 613                 except (NotImplementedError, AttributeError):
 614                     continue
 615
 616                 # Get all parent classes and interfaces klass inherits from
 617                 if isinstance(info, gi.types.ObjectInfo):
 618                     classes = list(info.get_interfaces())
 619                     parent = info.get_parent()
 620                     while parent.get_name() != "Object":
 621                         classes.append(parent)
 622                         parent = parent.get_parent()
 623                     classes = [kl for kl in classes if kl.get_namespace() == "Gtk"]
 624                 else:
 625                     continue
 626
 627                 for kl in classes:
 628                     if kl.get_name() == name:
 629                         self.assertTrue(issubclass(klass, over,),
 630                             "%r does not inherit from override %r" % (klass, over,))
 631
 632     def test_editable(self):
 633         self.assertEquals(Gtk.Editable, overrides.Gtk.Editable)
 634
 635         # need to use Gtk.Entry because Editable is an interface
 636         entry=Gtk.Entry()
 637         pos = entry.insert_text('HeWorld', 0)
 638         self.assertEquals(pos, 7)
 639         pos = entry.insert_text('llo ', 2)
 640         self.assertEquals(pos, 6)
 641         text = entry.get_chars(0, 11)
 642         self.assertEquals('Hello World', text)