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
  18 class TestGLib(unittest.TestCase):
  19
  20     def test_gvariant(self):
  21         variant = GLib.Variant('i', 42)
  22         self.assertTrue(isinstance(variant, GLib.Variant))
  23         self.assertEquals(variant.get_int32(), 42)
  24
  25         variant = GLib.Variant('(ss)', 'mec', 'mac')
  26         self.assertTrue(isinstance(variant, GLib.Variant))
  27         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
  28         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
  29         self.assertEquals(variant.get_child_value(0).get_string(), 'mec')
  30         self.assertEquals(variant.get_child_value(1).get_string(), 'mac')
  31
  32         variant = GLib.Variant('a{si}', {'key1': 1, 'key2': 2})
  33         self.assertTrue(isinstance(variant, GLib.Variant))
  34         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
  35         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
  36         # Looks like order is not preserved
  37         self.assertEquals(variant.get_child_value(1).get_child_value(0).get_string(), 'key1')
  38         self.assertEquals(variant.get_child_value(1).get_child_value(1).get_int32(), 1)
  39         self.assertEquals(variant.get_child_value(0).get_child_value(0).get_string(), 'key2')
  40         self.assertEquals(variant.get_child_value(0).get_child_value(1).get_int32(), 2)
  41
  42 class TestGdk(unittest.TestCase):
  43
  44     def test_color(self):
  45         color = Gdk.Color(100, 200, 300)
  46         self.assertEquals(color.red, 100)
  47         self.assertEquals(color.green, 200)
  48         self.assertEquals(color.blue, 300)
  49
  50     def test_event(self):
  51         event = Gdk.Event.new(Gdk.EventType.CONFIGURE)
  52         self.assertEquals(event.type, Gdk.EventType.CONFIGURE)
  53         self.assertEquals(event.send_event, 0)
  54
  55         event = Gdk.Event.new(Gdk.EventType.DRAG_MOTION)
  56         event.x_root, event.y_root = 0, 5
  57         self.assertEquals(event.x_root, 0)
  58         self.assertEquals(event.y_root, 5)
  59
  60 class TestGtk(unittest.TestCase):
  61     def test_uimanager(self):
  62         self.assertEquals(Gtk.UIManager, overrides.Gtk.UIManager)
  63         ui = Gtk.UIManager()
  64         ui.add_ui_from_string(
  65 """
  66 <ui>
  67     <menubar name="menubar1"></menubar>
  68 </ui>
  69 """
  70 )
  71         menubar = ui.get_widget("/menubar1")
  72         self.assertEquals(type(menubar), Gtk.MenuBar)
  73
  74     def test_actiongroup(self):
  75         self.assertEquals(Gtk.ActionGroup, overrides.Gtk.ActionGroup)
  76         action_group = Gtk.ActionGroup (name = 'TestActionGroup')
  77         callback_data = "callback data"
  78
  79         def test_action_callback_data(action, user_data):
  80             self.assertEquals(user_data, callback_data);
  81
  82         def test_radio_action_callback_data(action, current, user_data):
  83             self.assertEquals(user_data, callback_data);
  84
  85         action_group.add_actions ([
  86             ('test-action1', None, 'Test Action 1',
  87              None, None, test_action_callback_data),
  88             ('test-action2', Gtk.STOCK_COPY, 'Test Action 2',
  89               None, None, test_action_callback_data)], callback_data)
  90         action_group.add_toggle_actions([
  91             ('test-toggle-action1', None, 'Test Toggle Action 1',
  92              None, None, test_action_callback_data, False),
  93             ('test-toggle-action2', Gtk.STOCK_COPY, 'Test Toggle Action 2',
  94               None, None, test_action_callback_data, True)], callback_data)
  95         action_group.add_radio_actions([
  96             ('test-radio-action1', None, 'Test Radio Action 1'),
  97             ('test-radio-action2', Gtk.STOCK_COPY, 'Test Radio Action 2')], 1,
  98             test_radio_action_callback_data,
  99             callback_data)
 100
 101         expected_results = (('test-action1', Gtk.Action),
 102                             ('test-action2', Gtk.Action),
 103                             ('test-toggle-action1', Gtk.ToggleAction),
 104                             ('test-toggle-action2', Gtk.ToggleAction),
 105                             ('test-radio-action1', Gtk.RadioAction),
 106                             ('test-radio-action2', Gtk.RadioAction))
 107
 108         for action, cmp in zip(action_group.list_actions(), expected_results):
 109             a = (action.get_name(), type(action))
 110             self.assertEquals(a,cmp)
 111             action.activate()
 112
 113     def test_builder(self):
 114         self.assertEquals(Gtk.Builder, overrides.Gtk.Builder)
 115
 116         class SignalTest(GObject.GObject):
 117             __gtype_name__ = "GIOverrideSignalTest"
 118             __gsignals__ = {
 119                 "test-signal": (GObject.SIGNAL_RUN_FIRST,
 120                                 GObject.TYPE_NONE,
 121                                 []),
 122             }
 123
 124
 125         class SignalCheck:
 126             def __init__(self):
 127                 self.sentinel = 0
 128
 129             def on_signal_1(self, *args):
 130                 self.sentinel += 1
 131
 132             def on_signal_3(self, *args):
 133                 self.sentinel += 3
 134
 135         signal_checker = SignalCheck()
 136         builder = Gtk.Builder()
 137
 138         # add object1 to the builder
 139         builder.add_from_string(
 140 """
 141 <interface>
 142   <object class="GIOverrideSignalTest" id="object1">
 143       <signal name="test-signal" handler="on_signal_1" />
 144   </object>
 145 </interface>
 146 """)
 147
 148         # only add object3 to the builder
 149         builder.add_objects_from_string(
 150 """
 151 <interface>
 152   <object class="GIOverrideSignalTest" id="object2">
 153       <signal name="test-signal" handler="on_signal_2" />
 154   </object>
 155   <object class="GIOverrideSignalTest" id="object3">
 156       <signal name="test-signal" handler="on_signal_3" />
 157   </object>
 158   <object class="GIOverrideSignalTest" id="object4">
 159       <signal name="test-signal" handler="on_signal_4" />
 160   </object>
 161 </interface>
 162
 163 """,
 164             ['object3'])
 165
 166         # hook up signals
 167         builder.connect_signals(signal_checker)
 168
 169         # call their notify signals and check sentinel
 170         objects = builder.get_objects()
 171         self.assertEquals(len(objects), 2)
 172         for obj in objects:
 173             obj.emit('test-signal')
 174
 175         self.assertEquals(signal_checker.sentinel, 4)
 176
 177     def test_dialog(self):
 178         self.assertEquals(Gtk.Dialog, overrides.Gtk.Dialog)
 179         dialog = Gtk.Dialog (title='Foo',
 180                              flags=Gtk.DialogFlags.MODAL,
 181                              buttons=('test-button1', 1))
 182
 183         dialog.add_buttons ('test-button2', 2, Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE)
 184
 185         self.assertEquals('Foo', dialog.get_title())
 186         self.assertTrue(dialog.get_modal())
 187         button = dialog.get_widget_for_response (1)
 188         self.assertEquals('test-button1', button.get_label())
 189         button = dialog.get_widget_for_response (2)
 190         self.assertEquals('test-button2', button.get_label())
 191         button = dialog.get_widget_for_response (Gtk.ResponseType.CLOSE)
 192         self.assertEquals(Gtk.STOCK_CLOSE, button.get_label())
 193
 194     class TestClass(GObject.GObject):
 195         __gtype_name__ = "GIOverrideTreeAPITest"
 196
 197         def __init__(self, tester, int_value, string_value):
 198             super(TestGtk.TestClass, self).__init__()
 199             self.tester = tester
 200             self.int_value = int_value
 201             self.string_value = string_value
 202
 203         def check(self, int_value, string_value):
 204             self.tester.assertEquals(int_value, self.int_value)
 205             self.tester.assertEquals(string_value, self.string_value)
 206
 207     def test_tree_store(self):
 208         self.assertEquals(Gtk.TreeStore, overrides.Gtk.TreeStore)
 209         self.assertEquals(Gtk.ListStore, overrides.Gtk.ListStore)
 210         self.assertEquals(Gtk.TreeModel, overrides.Gtk.TreeModel)
 211         self.assertEquals(Gtk.TreeViewColumn, overrides.Gtk.TreeViewColumn)
 212
 213         tree_store = Gtk.TreeStore(int, 'gchararray', TestGtk.TestClass)
 214         parent = None
 215         for i in range(100):
 216             label = 'this is child #%d' % i
 217             testobj = TestGtk.TestClass(self, i, label)
 218             parent = tree_store.append(parent, (i, label, testobj))
 219
 220         # len gets the number of children in the root node
 221         # since we kept appending to the previous node
 222         # there should only be one child of the root
 223         self.assertEquals(len(tree_store), 1)
 224
 225         # walk the tree to see if the values were stored correctly
 226         parent = None
 227         i = 0
 228
 229         (has_children, treeiter) = tree_store.iter_children(parent)
 230         while (has_children):
 231            i = tree_store.get_value(treeiter, 0)
 232            s = tree_store.get_value(treeiter, 1)
 233            obj = tree_store.get_value(treeiter, 2)
 234            obj.check(i, s)
 235            parent = treeiter
 236            (has_children, treeiter) = tree_store.iter_children(parent)
 237
 238         self.assertEquals(i, 99)
 239
 240     def test_list_store(self):
 241         list_store = Gtk.ListStore(int, str, 'GIOverrideTreeAPITest')
 242         for i in range(100):
 243             label = 'this is row #%d' % i
 244             testobj = TestGtk.TestClass(self, i, label)
 245             parent = list_store.append((i, label, testobj))
 246
 247         self.assertEquals(len(list_store), 100)
 248
 249         # walk the list to see if the values were stored correctly
 250         i = 0
 251         (has_more, treeiter) = list_store.get_iter_first()
 252
 253         while has_more:
 254             i = list_store.get_value(treeiter, 0)
 255             s = list_store.get_value(treeiter, 1)
 256             obj = list_store.get_value(treeiter, 2)
 257             obj.check(i, s)
 258             has_more = list_store.iter_next(treeiter)
 259
 260         self.assertEquals(i, 99)
 261
 262     def test_tree_view_column(self):
 263         cell = Gtk.CellRendererText()
 264         column = Gtk.TreeViewColumn(title='This is just a test',
 265                                     cell_renderer=cell,
 266                                     text=0,
 267                                     style=2)
 268
 269     def test_text_buffer(self):
 270         self.assertEquals(Gtk.TextBuffer, overrides.Gtk.TextBuffer)
 271         buffer = Gtk.TextBuffer()
 272         tag = buffer.create_tag ('title', font = 'Sans 18')
 273
 274         self.assertEquals(tag.props.name, 'title')
 275         self.assertEquals(tag.props.font, 'Sans 18')
 276
 277         (start, end) = buffer.get_bounds()
 278
 279         buffer.insert(end, 'HelloHello')
 280         buffer.insert(end, ' Bob')
 281
 282         cursor_iter = end.copy()
 283         cursor_iter.backward_chars(9)
 284         buffer.place_cursor(cursor_iter)
 285         buffer.insert_at_cursor(' Jane ')
 286
 287         (start, end) = buffer.get_bounds()
 288         text = buffer.get_text(start, end, False)
 289
 290         self.assertEquals(text, 'Hello Jane Hello Bob')
 291
 292     def test_buttons(self):
 293         self.assertEquals(Gtk.Button, overrides.Gtk.Button)
 294
 295         # test Gtk.Button
 296         button = Gtk.Button()
 297         button = Gtk.Button(stock=Gtk.STOCK_CLOSE)
 298         self.assertEquals(Gtk.STOCK_CLOSE, button.get_label())
 299         self.assertTrue(button.get_use_stock())
 300         self.assertTrue(button.get_use_underline())