test/test-standalone.py

   1 #!/usr/bin/env python
   2
   3 """Tests that don't need an active D-Bus connection to run, but can be
   4 run in isolation.
   5 """
   6
   7 # Copyright (C) 2006, 2007 Collabora Ltd. <http://www.collabora.co.uk/>
   8 #
   9 # Licensed under the Academic Free License version 2.1
  10 #
  11 # This program is free software; you can redistribute it and/or modify
  12 # it under the terms of the GNU General Public License as published by
  13 # This program is free software; you can redistribute it and/or modify
  14 # it under the terms of the GNU General Public License as published by
  15 # the Free Software Foundation; either version 2 of the License, or
  16 # (at your option) any later version.
  17 #
  18 # This program is distributed in the hope that it will be useful,
  19 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 # GNU General Public License for more details.
  22 #
  23 # You should have received a copy of the GNU General Public License
  24 # along with this program; if not, write to the Free Software
  25 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  26
  27 import sys
  28 import os
  29 import unittest
  30 import time
  31 from traceback import print_exc
  32
  33 builddir = os.path.normpath(os.environ["DBUS_TOP_BUILDDIR"])
  34 pydir = os.path.normpath(os.environ["DBUS_TOP_SRCDIR"])
  35
  36 import _dbus_bindings
  37 import dbus
  38 import dbus.types as types
  39
  40 # Check that we're using the right versions
  41 if not dbus.__file__.startswith(pydir):
  42     raise Exception("DBus modules (%s) are not being picked up from the package"%dbus.__file__)
  43 if not _dbus_bindings.__file__.startswith(builddir):
  44     raise Exception("DBus modules (%s) are not being picked up from the package"%_dbus_bindings.__file__)
  45 assert (_dbus_bindings._python_version & 0xffff0000
  46         == sys.hexversion & 0xffff0000), \
  47         '_dbus_bindings was compiled for Python %x but this is Python %x, '\
  48         'a different major version'\
  49         % (_dbus_bindings._python_version, sys.hexversion)
  50 assert _dbus_bindings.__version__ == os.environ['DBUS_PYTHON_VERSION'], \
  51         '_dbus_bindings was compiled as version %s but Automake says '\
  52         'we should be version %s' \
  53         % (_dbus_bindings.__version__, os.environ['DBUS_PYTHON_VERSION'])
  54
  55 class TestTypes(unittest.TestCase):
  56
  57     def test_Dictionary(self):
  58         self.assertEquals(types.Dictionary({'foo':'bar'}), {'foo':'bar'})
  59         self.assertEquals(types.Dictionary({}, variant_level=2), {})
  60         self.assertEquals(types.Dictionary({}, variant_level=2).variant_level, 2)
  61
  62     def test_Array(self):
  63         self.assertEquals(types.Array(['foo','bar']), ['foo','bar'])
  64         self.assertEquals(types.Array([], variant_level=2), [])
  65         self.assertEquals(types.Array([], variant_level=2).variant_level, 2)
  66
  67     def test_Double(self):
  68         self.assertEquals(types.Double(0.0), 0.0)
  69         self.assertEquals(types.Double(0.125, variant_level=2), 0.125)
  70         self.assertEquals(types.Double(0.125, variant_level=2).variant_level, 2)
  71
  72     def test_Struct(self):
  73         x = types.Struct(('',))
  74         self.assertEquals(x.variant_level, 0)
  75         self.assertEquals(x, ('',))
  76         x = types.Struct('abc', variant_level=42)
  77         self.assertEquals(x.variant_level, 42)
  78         self.assertEquals(x, ('a','b','c'))
  79
  80     def test_Byte(self):
  81         self.assertEquals(types.Byte('x', variant_level=2), types.Byte(ord('x')))
  82
  83     def test_object_path_attr(self):
  84         class MyObject(object):
  85             __dbus_object_path__ = '/foo'
  86         from _dbus_bindings import SignalMessage
  87         self.assertEquals(SignalMessage.guess_signature(MyObject()), 'o')
  88
  89     def test_integers(self):
  90         # This is an API guarantee. Note that exactly which of these types
  91         # are ints and which of them are longs is *not* guaranteed.
  92         for cls in (types.Int16, types.UInt16, types.Int32, types.UInt32,
  93             types.Int64, types.UInt64):
  94             self.assert_(issubclass(cls, (int, long)))
  95             self.assert_(isinstance(cls(0), (int, long)))
  96             self.assertEquals(cls(0), 0)
  97             self.assertEquals(cls(23, variant_level=1), 23)
  98             self.assertEquals(cls(23, variant_level=1).variant_level, 1)
  99
 100     def test_integer_limits_16(self):
 101         self.assertEquals(types.Int16(0x7fff), 0x7fff)
 102         self.assertEquals(types.Int16(-0x8000), -0x8000)
 103         self.assertEquals(types.UInt16(0xffff), 0xffff)
 104         self.assertRaises(Exception, types.Int16, 0x8000)
 105         self.assertRaises(Exception, types.Int16, -0x8001)
 106         self.assertRaises(Exception, types.UInt16, 0x10000)
 107
 108     def test_integer_limits_32(self):
 109         self.assertEquals(types.Int32(0x7fffffff), 0x7fffffff)
 110         self.assertEquals(types.Int32(-0x80000000L), -0x80000000L)
 111         self.assertEquals(types.UInt32(0xffffffffL), 0xffffffffL)
 112         self.assertRaises(Exception, types.Int32, 0x80000000L)
 113         self.assertRaises(Exception, types.Int32, -0x80000001L)
 114         self.assertRaises(Exception, types.UInt32, 0x100000000L)
 115
 116     def test_integer_limits_64(self):
 117         self.assertEquals(types.Int64(0x7fffffffffffffffL), 0x7fffffffffffffffL)
 118         self.assertEquals(types.Int64(-0x8000000000000000L), -0x8000000000000000L)
 119         self.assertEquals(types.UInt64(0xffffffffffffffffL), 0xffffffffffffffffL)
 120         self.assertRaises(Exception, types.Int16, 0x8000000000000000L)
 121         self.assertRaises(Exception, types.Int16, -0x8000000000000001L)
 122         self.assertRaises(Exception, types.UInt16, 0x10000000000000000L)
 123
 124     def test_Signature(self):
 125         self.assertRaises(Exception, types.Signature, 'a')
 126         self.assertEquals(types.Signature('ab', variant_level=23), 'ab')
 127         self.assert_(isinstance(types.Signature('ab'), str))
 128         self.assertEquals(tuple(types.Signature('ab(xt)a{sv}')),
 129                           ('ab', '(xt)', 'a{sv}'))
 130         self.assert_(isinstance(tuple(types.Signature('ab'))[0],
 131                                 types.Signature))
 132
 133
 134 class TestMessageMarshalling(unittest.TestCase):
 135
 136     def test_count(self):
 137         from _dbus_bindings import SignalMessage
 138         s = SignalMessage('/', 'foo.bar', 'baz')
 139         try:
 140             s.append('a', signature='ss')
 141         except TypeError:
 142             pass
 143         else:
 144             raise AssertionError('Appending too few things in a message '
 145                                  'should fail')
 146         s = SignalMessage('/', 'foo.bar', 'baz')
 147         try:
 148             s.append('a','b','c', signature='ss')
 149         except TypeError:
 150             pass
 151         else:
 152             raise AssertionError('Appending too many things in a message '
 153                                  'should fail')
 154
 155     def test_append(self):
 156         aeq = self.assertEquals
 157         from _dbus_bindings import SignalMessage
 158         s = SignalMessage('/', 'foo.bar', 'baz')
 159         s.append([types.Byte(1)], signature='ay')
 160         aeq(s.get_signature(), 'ay')
 161         aeq(s.get_args_list(), [[types.Byte(1)]])
 162
 163         s = SignalMessage('/', 'foo.bar', 'baz')
 164         s.append([], signature='ay')
 165         aeq(s.get_args_list(), [[]])
 166
 167     def test_append_ByteArray(self):
 168         aeq = self.assertEquals
 169         from _dbus_bindings import SignalMessage
 170         s = SignalMessage('/', 'foo.bar', 'baz')
 171         s.append(types.ByteArray('ab'), signature='ay')
 172         aeq(s.get_args_list(), [[types.Byte('a'), types.Byte('b')]])
 173         s = SignalMessage('/', 'foo.bar', 'baz')
 174         s.append(types.ByteArray('ab'), signature='av')
 175         aeq(s.get_args_list(), [[types.Byte('a'), types.Byte('b')]])
 176
 177     def test_append_Variant(self):
 178         a = self.assert_
 179         aeq = self.assertEquals
 180         from _dbus_bindings import SignalMessage
 181         s = SignalMessage('/', 'foo.bar', 'baz')
 182         s.append(types.Int32(1, variant_level=0),
 183                  types.String('a', variant_level=42),
 184                  types.Array([types.Byte('a', variant_level=1),
 185                               types.UInt32(123, variant_level=1)],
 186                              signature='v'),
 187                  signature='vvv')
 188         aeq(s.get_signature(), 'vvv')
 189         args = s.get_args_list()
 190         aeq(args[0].__class__, types.Int32)
 191         aeq(args[0].variant_level, 1)
 192         aeq(args[1].__class__, types.String)
 193         aeq(args[1].variant_level, 42)
 194         aeq(args[2].__class__, types.Array)
 195         aeq(args[2].variant_level, 1)
 196         aeq(args[2].signature, 'v')
 197
 198     def test_guess_signature(self):
 199         aeq = self.assertEquals
 200         from _dbus_bindings import Message
 201         aeq(Message.guess_signature(('a','b')), '(ss)')
 202         aeq(Message.guess_signature('a','b'), 'ss')
 203         aeq(Message.guess_signature(['a','b']), 'as')
 204         aeq(Message.guess_signature(('a',)), '(s)')
 205         aeq(Message.guess_signature('abc'), 's')
 206         aeq(Message.guess_signature(types.Int32(123)), 'i')
 207         aeq(Message.guess_signature(types.ByteArray('abc')), 'ay')
 208         aeq(Message.guess_signature(('a',)), '(s)')
 209         aeq(Message.guess_signature(['a']), 'as')
 210         aeq(Message.guess_signature({'a':'b'}), 'a{ss}')
 211
 212     def test_guess_signature_dbus_types(self):
 213         aeq = self.assertEquals
 214         from _dbus_bindings import Message
 215         gs = Message.guess_signature
 216         aeq(gs(types.Dictionary({'a':'b'})), 'a{ss}')
 217         aeq(gs(types.Dictionary({'a':'b'}, signature='sv')), 'a{sv}')
 218         aeq(gs(types.Dictionary({}, signature='iu')), 'a{iu}')
 219         aeq(gs(types.Array([types.Int32(1)])), 'ai')
 220         aeq(gs(types.Array([types.Int32(1)], signature='u')), 'au')
 221
 222     def test_get_args_options(self):
 223         aeq = self.assertEquals
 224         s = _dbus_bindings.SignalMessage('/', 'foo.bar', 'baz')
 225         s.append('b', 'bytes', -1, 1, 'str', 'var', signature='yayiusv')
 226         aeq(s.get_args_list(), [ord('b'),
 227                                 [ord('b'),ord('y'),ord('t'),ord('e'), ord('s')],
 228                                 -1, 1, u'str', u'var'])
 229         byte, bytes, int32, uint32, string, variant = s.get_args_list()
 230         aeq(byte.__class__, types.Byte)
 231         aeq(bytes.__class__, types.Array)
 232         aeq(bytes[0].__class__, types.Byte)
 233         aeq(int32.__class__, types.Int32)
 234         aeq(uint32.__class__, types.UInt32)
 235         aeq(string.__class__, types.String)
 236         aeq(string.variant_level, 0)
 237         aeq(variant.__class__, types.String)
 238         aeq(variant.variant_level, 1)
 239
 240         byte, bytes, int32, uint32, string, variant = s.get_args_list(
 241                 byte_arrays=True)
 242         aeq(byte.__class__, types.Byte)
 243         aeq(bytes.__class__, types.ByteArray)
 244         aeq(bytes, 'bytes')
 245         aeq(bytes[0].__class__, str)
 246         aeq(int32.__class__, types.Int32)
 247         aeq(uint32.__class__, types.UInt32)
 248         aeq(string.__class__, types.String)
 249         aeq(variant.__class__, types.String)
 250         aeq(variant.variant_level, 1)
 251
 252         byte, bytes, int32, uint32, string, variant = s.get_args_list(
 253             utf8_strings=True)
 254         aeq(byte.__class__, types.Byte)
 255         aeq(bytes.__class__, types.Array)
 256         aeq(bytes[0].__class__, types.Byte)
 257         aeq(int32.__class__, types.Int32)
 258         aeq(uint32.__class__, types.UInt32)
 259         aeq(string.__class__, types.UTF8String)
 260         aeq(string, 'str')
 261         aeq(variant.__class__, types.UTF8String)
 262         aeq(variant.variant_level, 1)
 263         aeq(variant, 'var')
 264
 265     def test_object_path_attr(self):
 266         from _dbus_bindings import SignalMessage
 267         class MyObject(object):
 268             __dbus_object_path__ = '/foo'
 269         s = SignalMessage('/', 'foo.bar', 'baz')
 270         s.append(MyObject(), signature='o')
 271         s.append(MyObject())
 272         self.assertEquals(s.get_args_list(), ['/foo', '/foo'])
 273
 274     def test_struct(self):
 275         from _dbus_bindings import SignalMessage
 276         s = SignalMessage('/', 'foo.bar', 'baz')
 277         try:
 278             s.append(('a',), signature='(ss)')
 279         except TypeError:
 280             pass
 281         else:
 282             raise AssertionError('Appending too few things in a struct '
 283                                  'should fail')
 284         s = SignalMessage('/', 'foo.bar', 'baz')
 285         try:
 286             s.append(('a','b','c'), signature='(ss)')
 287         except TypeError:
 288             pass
 289         else:
 290             raise AssertionError('Appending too many things in a struct '
 291                                  'should fail')
 292
 293
 294 if __name__ == '__main__':
 295     unittest.main()