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