tests/test_overrides_glib.py

   1 # -*- Mode: Python; py-indent-offset: 4 -*-
   2 # vim: tabstop=4 shiftwidth=4 expandtab
   3
   4 import unittest
   5
   6 import gi
   7 from gi.repository import GLib
   8 from compathelper import _long
   9
  10
  11 class TestGVariant(unittest.TestCase):
  12     def test_create(self):
  13         # simple values
  14
  15         variant = GLib.Variant('i', 42)
  16         self.assertTrue(isinstance(variant, GLib.Variant))
  17         self.assertEqual(variant.get_int32(), 42)
  18
  19         variant = GLib.Variant('s', '')
  20         self.assertTrue(isinstance(variant, GLib.Variant))
  21         self.assertEqual(variant.get_string(), '')
  22
  23         variant = GLib.Variant('s', 'hello')
  24         self.assertTrue(isinstance(variant, GLib.Variant))
  25         self.assertEqual(variant.get_string(), 'hello')
  26
  27         # boxed variant
  28         variant = GLib.Variant('v', GLib.Variant('i', 42))
  29         self.assertTrue(isinstance(variant, GLib.Variant))
  30         self.assertTrue(isinstance(variant.get_variant(), GLib.Variant))
  31         self.assertEqual(variant.get_type_string(), 'v')
  32         self.assertEqual(variant.get_variant().get_type_string(), 'i')
  33         self.assertEqual(variant.get_variant().get_int32(), 42)
  34
  35         variant = GLib.Variant('v', GLib.Variant('v', GLib.Variant('i', 42)))
  36         self.assertEqual(variant.get_type_string(), 'v')
  37         self.assertEqual(variant.get_variant().get_type_string(), 'v')
  38         self.assertEqual(variant.get_variant().get_variant().get_type_string(), 'i')
  39         self.assertEqual(variant.get_variant().get_variant().get_int32(), 42)
  40
  41         # tuples
  42
  43         variant = GLib.Variant('()', ())
  44         self.assertEqual(variant.get_type_string(), '()')
  45         self.assertEqual(variant.n_children(), 0)
  46
  47         variant = GLib.Variant('(i)', (3,))
  48         self.assertEqual(variant.get_type_string(), '(i)')
  49         self.assertTrue(isinstance(variant, GLib.Variant))
  50         self.assertEqual(variant.n_children(), 1)
  51         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
  52         self.assertEqual(variant.get_child_value(0).get_int32(), 3)
  53
  54         variant = GLib.Variant('(ss)', ('mec', 'mac'))
  55         self.assertEqual(variant.get_type_string(), '(ss)')
  56         self.assertTrue(isinstance(variant, GLib.Variant))
  57         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
  58         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
  59         self.assertEqual(variant.get_child_value(0).get_string(), 'mec')
  60         self.assertEqual(variant.get_child_value(1).get_string(), 'mac')
  61
  62         # nested tuples
  63         variant = GLib.Variant('((si)(ub))', (('hello', -1), (42, True)))
  64         self.assertEqual(variant.get_type_string(), '((si)(ub))')
  65         self.assertEqual(variant.unpack(), (('hello', -1), (_long(42), True)))
  66
  67         # dictionaries
  68
  69         variant = GLib.Variant('a{si}', {})
  70         self.assertTrue(isinstance(variant, GLib.Variant))
  71         self.assertEqual(variant.get_type_string(), 'a{si}')
  72         self.assertEqual(variant.n_children(), 0)
  73
  74         variant = GLib.Variant('a{si}', {'': 1, 'key1': 2, 'key2': 3})
  75         self.assertEqual(variant.get_type_string(), 'a{si}')
  76         self.assertTrue(isinstance(variant, GLib.Variant))
  77         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
  78         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
  79         self.assertTrue(isinstance(variant.get_child_value(2), GLib.Variant))
  80         self.assertEqual(variant.unpack(), {'': 1, 'key1': 2, 'key2': 3})
  81
  82         # nested dictionaries
  83         variant = GLib.Variant('a{sa{si}}', {})
  84         self.assertTrue(isinstance(variant, GLib.Variant))
  85         self.assertEqual(variant.get_type_string(), 'a{sa{si}}')
  86         self.assertEqual(variant.n_children(), 0)
  87
  88         d = {'': {'': 1, 'keyn1': 2},
  89              'key1': {'key11': 11, 'key12': 12}}
  90         variant = GLib.Variant('a{sa{si}}', d)
  91         self.assertEqual(variant.get_type_string(), 'a{sa{si}}')
  92         self.assertTrue(isinstance(variant, GLib.Variant))
  93         self.assertEqual(variant.unpack(), d)
  94
  95         # arrays
  96
  97         variant = GLib.Variant('ai', [])
  98         self.assertEqual(variant.get_type_string(), 'ai')
  99         self.assertEqual(variant.n_children(), 0)
 100
 101         variant = GLib.Variant('ai', [1, 2])
 102         self.assertEqual(variant.get_type_string(), 'ai')
 103         self.assertTrue(isinstance(variant, GLib.Variant))
 104         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
 105         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
 106         self.assertEqual(variant.get_child_value(0).get_int32(), 1)
 107         self.assertEqual(variant.get_child_value(1).get_int32(), 2)
 108
 109         variant = GLib.Variant('as', [])
 110         self.assertEqual(variant.get_type_string(), 'as')
 111         self.assertEqual(variant.n_children(), 0)
 112
 113         variant = GLib.Variant('as', [''])
 114         self.assertEqual(variant.get_type_string(), 'as')
 115         self.assertTrue(isinstance(variant, GLib.Variant))
 116         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
 117         self.assertEqual(variant.get_child_value(0).get_string(), '')
 118
 119         variant = GLib.Variant('as', ['hello', 'world'])
 120         self.assertEqual(variant.get_type_string(), 'as')
 121         self.assertTrue(isinstance(variant, GLib.Variant))
 122         self.assertTrue(isinstance(variant.get_child_value(0), GLib.Variant))
 123         self.assertTrue(isinstance(variant.get_child_value(1), GLib.Variant))
 124         self.assertEqual(variant.get_child_value(0).get_string(), 'hello')
 125         self.assertEqual(variant.get_child_value(1).get_string(), 'world')
 126
 127         # nested arrays
 128         variant = GLib.Variant('aai', [])
 129         self.assertEqual(variant.get_type_string(), 'aai')
 130         self.assertEqual(variant.n_children(), 0)
 131
 132         variant = GLib.Variant('aai', [[]])
 133         self.assertEqual(variant.get_type_string(), 'aai')
 134         self.assertEqual(variant.n_children(), 1)
 135         self.assertEqual(variant.get_child_value(0).n_children(), 0)
 136
 137         variant = GLib.Variant('aai', [[1, 2], [3, 4, 5]])
 138         self.assertEqual(variant.get_type_string(), 'aai')
 139         self.assertEqual(variant.unpack(), [[1, 2], [3, 4, 5]])
 140
 141         #
 142         # complex types
 143         #
 144
 145         variant = GLib.Variant('(as)', ([],))
 146         self.assertEqual(variant.get_type_string(), '(as)')
 147         self.assertEqual(variant.n_children(), 1)
 148         self.assertEqual(variant.get_child_value(0).n_children(), 0)
 149
 150         variant = GLib.Variant('(as)', ([''],))
 151         self.assertEqual(variant.get_type_string(), '(as)')
 152         self.assertEqual(variant.n_children(), 1)
 153         self.assertEqual(variant.get_child_value(0).n_children(), 1)
 154         self.assertEqual(variant.get_child_value(0).get_child_value(0).get_string(), '')
 155
 156         variant = GLib.Variant('(as)', (['hello'],))
 157         self.assertEqual(variant.get_type_string(), '(as)')
 158         self.assertEqual(variant.n_children(), 1)
 159         self.assertEqual(variant.get_child_value(0).n_children(), 1)
 160         self.assertEqual(variant.get_child_value(0).get_child_value(0).get_string(), 'hello')
 161
 162         obj = {'a1': (1, True), 'a2': (2, False)}
 163         variant = GLib.Variant('a{s(ib)}', obj)
 164         self.assertEqual(variant.get_type_string(), 'a{s(ib)}')
 165         self.assertEqual(variant.unpack(), obj)
 166
 167         obj = {'a1': (1, GLib.Variant('b', True)), 'a2': (2, GLib.Variant('y', 255))}
 168         variant = GLib.Variant('a{s(iv)}', obj)
 169         self.assertEqual(variant.get_type_string(), 'a{s(iv)}')
 170         self.assertEqual(variant.unpack(), {'a1': (1, True), 'a2': (2, 255)})
 171
 172         obj = (1, {'a': {'a1': True, 'a2': False},
 173                    'b': {'b1': False},
 174                    'c': {}
 175                   },
 176                'foo')
 177         variant = GLib.Variant('(ia{sa{sb}}s)', obj)
 178         self.assertEqual(variant.get_type_string(), '(ia{sa{sb}}s)')
 179         self.assertEqual(variant.unpack(), obj)
 180
 181         obj = {"frequency": GLib.Variant('t', 738000000),
 182                "hierarchy": GLib.Variant('i', 0),
 183                "bandwidth": GLib.Variant('x', 8),
 184                "code-rate-hp": GLib.Variant('d', 2.0 / 3.0),
 185                "constellation": GLib.Variant('s', "QAM16"),
 186                "guard-interval": GLib.Variant('u', 4)}
 187         variant = GLib.Variant('a{sv}', obj)
 188         self.assertEqual(variant.get_type_string(), 'a{sv}')
 189         self.assertEqual(variant.unpack(),
 190                          {"frequency": 738000000,
 191                           "hierarchy": 0,
 192                           "bandwidth": 8,
 193                           "code-rate-hp": 2.0 / 3.0,
 194                           "constellation": "QAM16",
 195                           "guard-interval": 4
 196                          })
 197
 198     def test_create_errors(self):
 199         # excess arguments
 200         self.assertRaises(TypeError, GLib.Variant, 'i', 42, 3)
 201         self.assertRaises(TypeError, GLib.Variant, '(i)', (42, 3))
 202
 203         # not enough arguments
 204         self.assertRaises(TypeError, GLib.Variant, '(ii)', (42,))
 205
 206         # data type mismatch
 207         self.assertRaises(TypeError, GLib.Variant, 'i', 'hello')
 208         self.assertRaises(TypeError, GLib.Variant, 's', 42)
 209         self.assertRaises(TypeError, GLib.Variant, '(ss)', 'mec', 'mac')
 210         self.assertRaises(TypeError, GLib.Variant, '(s)', 'hello')
 211
 212         # unimplemented data type
 213         self.assertRaises(NotImplementedError, GLib.Variant, 'Q', 1)
 214
 215     def test_unpack(self):
 216         # simple values
 217         res = GLib.Variant.new_int32(-42).unpack()
 218         self.assertEqual(res, -42)
 219
 220         res = GLib.Variant.new_uint64(34359738368).unpack()
 221         self.assertEqual(res, 34359738368)
 222
 223         res = GLib.Variant.new_boolean(True).unpack()
 224         self.assertEqual(res, True)
 225
 226         res = GLib.Variant.new_object_path('/foo/Bar').unpack()
 227         self.assertEqual(res, '/foo/Bar')
 228
 229         # variant
 230         res = GLib.Variant('v', GLib.Variant.new_int32(-42)).unpack()
 231         self.assertEqual(res, -42)
 232
 233         GLib.Variant('v', GLib.Variant('v', GLib.Variant('i', 42)))
 234         self.assertEqual(res, -42)
 235
 236         # tuple
 237         res = GLib.Variant.new_tuple(GLib.Variant.new_int32(-1),
 238                                      GLib.Variant.new_string('hello')).unpack()
 239         self.assertEqual(res, (-1, 'hello'))
 240
 241         # array
 242         vb = GLib.VariantBuilder.new(gi._gi.variant_type_from_string('ai'))
 243         vb.add_value(GLib.Variant.new_int32(-1))
 244         vb.add_value(GLib.Variant.new_int32(3))
 245         res = vb.end().unpack()
 246         self.assertEqual(res, [-1, 3])
 247
 248         # dictionary
 249         res = GLib.Variant('a{si}', {'key1': 1, 'key2': 2}).unpack()
 250         self.assertEqual(res, {'key1': 1, 'key2': 2})
 251
 252     def test_iteration(self):
 253         # array index access
 254         vb = GLib.VariantBuilder.new(gi._gi.variant_type_from_string('ai'))
 255         vb.add_value(GLib.Variant.new_int32(-1))
 256         vb.add_value(GLib.Variant.new_int32(3))
 257         v = vb.end()
 258
 259         self.assertEqual(len(v), 2)
 260         self.assertEqual(v[0], -1)
 261         self.assertEqual(v[1], 3)
 262         self.assertEqual(v[-1], 3)
 263         self.assertEqual(v[-2], -1)
 264         self.assertRaises(IndexError, v.__getitem__, 2)
 265         self.assertRaises(IndexError, v.__getitem__, -3)
 266         self.assertRaises(ValueError, v.__getitem__, 'a')
 267
 268         # array iteration
 269         self.assertEqual([x for x in v], [-1, 3])
 270         self.assertEqual(list(v), [-1, 3])
 271
 272         # tuple index access
 273         v = GLib.Variant.new_tuple(GLib.Variant.new_int32(-1),
 274                                    GLib.Variant.new_string('hello'))
 275         self.assertEqual(len(v), 2)
 276         self.assertEqual(v[0], -1)
 277         self.assertEqual(v[1], 'hello')
 278         self.assertEqual(v[-1], 'hello')
 279         self.assertEqual(v[-2], -1)
 280         self.assertRaises(IndexError, v.__getitem__, 2)
 281         self.assertRaises(IndexError, v.__getitem__, -3)
 282         self.assertRaises(ValueError, v.__getitem__, 'a')
 283
 284         # tuple iteration
 285         self.assertEqual([x for x in v], [-1, 'hello'])
 286         self.assertEqual(tuple(v), (-1, 'hello'))
 287
 288         # dictionary index access
 289         vsi = GLib.Variant('a{si}', {'key1': 1, 'key2': 2})
 290         vis = GLib.Variant('a{is}', {1: 'val1', 5: 'val2'})
 291
 292         self.assertEqual(len(vsi), 2)
 293         self.assertEqual(vsi['key1'], 1)
 294         self.assertEqual(vsi['key2'], 2)
 295         self.assertRaises(KeyError, vsi.__getitem__, 'unknown')
 296
 297         self.assertEqual(len(vis), 2)
 298         self.assertEqual(vis[1], 'val1')
 299         self.assertEqual(vis[5], 'val2')
 300         self.assertRaises(KeyError, vsi.__getitem__, 3)
 301
 302         # dictionary iteration
 303         self.assertEqual(set(vsi.keys()), set(['key1', 'key2']))
 304         self.assertEqual(set(vis.keys()), set([1, 5]))
 305
 306         # string index access
 307         v = GLib.Variant('s', 'hello')
 308         self.assertEqual(len(v), 5)
 309         self.assertEqual(v[0], 'h')
 310         self.assertEqual(v[4], 'o')
 311         self.assertEqual(v[-1], 'o')
 312         self.assertEqual(v[-5], 'h')
 313         self.assertRaises(IndexError, v.__getitem__, 5)
 314         self.assertRaises(IndexError, v.__getitem__, -6)
 315
 316         # string iteration
 317         self.assertEqual([x for x in v], ['h', 'e', 'l', 'l', 'o'])
 318
 319     def test_split_signature(self):
 320         self.assertEqual(GLib.Variant.split_signature('()'), [])
 321
 322         self.assertEqual(GLib.Variant.split_signature('s'), ['s'])
 323
 324         self.assertEqual(GLib.Variant.split_signature('as'), ['as'])
 325
 326         self.assertEqual(GLib.Variant.split_signature('(s)'), ['s'])
 327
 328         self.assertEqual(GLib.Variant.split_signature('(iso)'), ['i', 's', 'o'])
 329
 330         self.assertEqual(GLib.Variant.split_signature('(s(ss)i(ii))'),
 331                          ['s', '(ss)', 'i', '(ii)'])
 332
 333         self.assertEqual(GLib.Variant.split_signature('(as)'), ['as'])
 334
 335         self.assertEqual(GLib.Variant.split_signature('(s(ss)iaiaasa(ii))'),
 336                          ['s', '(ss)', 'i', 'ai', 'aas', 'a(ii)'])
 337
 338         self.assertEqual(GLib.Variant.split_signature('(a{iv}(ii)((ss)a{s(ss)}))'),
 339                          ['a{iv}', '(ii)', '((ss)a{s(ss)})'])
 340
 341     def test_hash(self):
 342         v1 = GLib.Variant('s', 'somestring')
 343         v2 = GLib.Variant('s', 'somestring')
 344         v3 = GLib.Variant('s', 'somestring2')
 345
 346         self.assertTrue(v2 in set([v1, v3]))
 347         self.assertTrue(v2 in frozenset([v1, v3]))
 348         self.assertTrue(v2 in {v1: '1', v3: '2'})
 349
 350     def test_compare(self):
 351         # Check if identical GVariant are equal
 352
 353         def assert_equal(vtype, value):
 354             self.assertEqual(GLib.Variant(vtype, value), GLib.Variant(vtype, value))
 355
 356         def assert_not_equal(vtype1, value1, vtype2, value2):
 357             self.assertNotEqual(GLib.Variant(vtype1, value1), GLib.Variant(vtype2, value2))
 358
 359         numbers = ['y', 'n', 'q', 'i', 'u', 'x', 't', 'h', 'd']
 360         for num in numbers:
 361             assert_equal(num, 42)
 362             assert_not_equal(num, 42, num, 41)
 363             assert_not_equal(num, 42, 's', '42')
 364
 365         assert_equal('s', 'something')
 366         assert_not_equal('s', 'something', 's', 'somethingelse')
 367         assert_not_equal('s', 'something', 'i', 1234)
 368
 369         assert_equal('g', 'dustybinqhogx')
 370         assert_not_equal('g', 'dustybinqhogx', 'g', 'dustybin')
 371         assert_not_equal('g', 'dustybinqhogx', 'i', 1234)
 372
 373         assert_equal('o', '/dev/null')
 374         assert_not_equal('o', '/dev/null', 'o', '/dev/zero')
 375         assert_not_equal('o', '/dev/null', 'i', 1234)
 376
 377         assert_equal('(s)', ('strtuple',))
 378         assert_not_equal('(s)', ('strtuple',), '(s)', ('strtuple2',))
 379
 380         assert_equal('a{si}', {'str': 42})
 381         assert_not_equal('a{si}', {'str': 42}, 'a{si}', {'str': 43})
 382
 383         assert_equal('v', GLib.Variant('i', 42))
 384         assert_not_equal('v', GLib.Variant('i', 42), 'v', GLib.Variant('i', 43))
 385
 386     def test_bool(self):
 387         # Check if the GVariant bool matches the unpacked Pythonic bool
 388
 389         def assert_equals_bool(vtype, value):
 390             self.assertEqual(bool(GLib.Variant(vtype, value)), bool(value))
 391
 392         # simple values
 393         assert_equals_bool('b', True)
 394         assert_equals_bool('b', False)
 395
 396         numbers = ['y', 'n', 'q', 'i', 'u', 'x', 't', 'h', 'd']
 397         for number in numbers:
 398             assert_equals_bool(number, 0)
 399             assert_equals_bool(number, 1)
 400
 401         assert_equals_bool('s', '')
 402         assert_equals_bool('g', '')
 403         assert_equals_bool('s', 'something')
 404         assert_equals_bool('o', '/dev/null')
 405         assert_equals_bool('g', 'dustybinqhogx')
 406
 407         # arrays
 408         assert_equals_bool('ab', [True])
 409         assert_equals_bool('ab', [False])
 410         for number in numbers:
 411             assert_equals_bool('a' + number, [])
 412             assert_equals_bool('a' + number, [0])
 413         assert_equals_bool('as', [])
 414         assert_equals_bool('as', [''])
 415         assert_equals_bool('ao', [])
 416         assert_equals_bool('ao', ['/'])
 417         assert_equals_bool('ag', [])
 418         assert_equals_bool('ag', [''])
 419         assert_equals_bool('aai', [[]])
 420
 421         # tuples
 422         assert_equals_bool('()', ())
 423         for number in numbers:
 424             assert_equals_bool('(' + number + ')', (0,))
 425         assert_equals_bool('(s)', ('',))
 426         assert_equals_bool('(o)', ('/',))
 427         assert_equals_bool('(g)', ('',))
 428         assert_equals_bool('(())', ((),))
 429
 430         # dictionaries
 431         assert_equals_bool('a{si}', {})
 432         assert_equals_bool('a{si}', {'': 0})
 433
 434         # complex types, always True
 435         assert_equals_bool('(as)', ([],))
 436         assert_equals_bool('a{s(i)}', {'': (0,)})
 437
 438         # variant types, recursive unpacking
 439         assert_equals_bool('v', GLib.Variant('i', 0))
 440         assert_equals_bool('v', GLib.Variant('i', 1))
 441
 442     def test_repr(self):
 443         v = GLib.Variant('(is)', (1, 'somestring'))
 444         self.assertEqual(str(v), "(1, 'somestring')")
 445         self.assertEqual(repr(v), "GLib.Variant('(is)', (1, 'somestring'))")