More Python 3 porting, this time primarily to get test-client.py working.

Changes include:

- DBusException.get_dbus_message(): In Python 3, the str of the exception will
  already be a unicode, so don't try to decode it unless it's a bytes object
  (a.k.a. 8-bit str in Python 2).
- gobject_service.py: Switch to pygi and rewrite the metaclass instantiation
  code to be portable between Python 2 and Python 3.
- run-test.sh: echo a few more useful environment variables
- test-client.py:
  - Globally replace deprecated assertEquals with assertEqual
  - Globally replace deprecated assert_ with assertTrue
  - Use bytes objects for both 'ay' signatured methods on the server
  - AcceptUnicodeString will return a native unicode, i.e. a str in Python 3
    and a unicode in Python 2.  Python 3 has no `unicode` built-in.
  - Reformat some long lines for debugging.
- test-service.py:
  - Open the log file in 'a' mode for easier tailing.
  - AcceptUnicodeString will return a native unicode, i.e. a str in Python 3
    and a unicode in Python 2.  Python 3 has no `unicode` built-in.
  - reformat some long lines for debugging.
  - Put module-scope code into a main() function and add a bunch of logger
    output for better debugging.  `session_bus` must still be global though.
    Wrap main() in a bit try/except to log all top-level exceptions.

5 files changed, 214 insertions, 157 deletions

diff --git a/dbus/exceptions.py b/dbus/exceptions.py
index 8d84a29..5283369 100644
--- a/dbus/exceptions.py
+++ b/dbus/exceptions.py
@@ -27,6 +27,7 @@ __all__ = ('DBusException', 'MissingErrorHandlerException',
            'IntrospectionParserException', 'UnknownMethodException',
            'NameExistsException')
 
+
 class DBusException(Exception):
 
     include_traceback = False
@@ -57,7 +58,9 @@ class DBusException(Exception):
 
     def get_dbus_message(self):
         s = Exception.__str__(self)
-        return s.decode('utf-8', 'replace')
+        if isinstance(s, bytes):
+            return s.decode('utf-8', 'replace')
+        return s
 
     def get_dbus_name(self):
         return self._dbus_error_name
diff --git a/dbus/gobject_service.py b/dbus/gobject_service.py
index 61a7749..47a2b5f 100644
--- a/dbus/gobject_service.py
+++ b/dbus/gobject_service.py
@@ -22,9 +22,21 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 # DEALINGS IN THE SOFTWARE.
 
-import gobject
+__all__ = ['ExportedGObject']
+
+from gi.repository import GObject as gobject
 import dbus.service
 
+# The odd syntax used here is required so that the code is compatible with
+# both Python 2 and Python 3.  It essentially creates a new class called
+# ExportedGObject with a metaclass of ExportGObjectType and an __init__()
+# function.
+#
+# Because GObject and `dbus.service.Object` both have custom metaclasses, the
+# naive approach using simple multiple inheritance won't work. This class has
+# `ExportedGObjectType` as its metaclass, which is sufficient to make it work
+# correctly.
+
 class ExportedGObjectType(gobject.GObjectMeta, dbus.service.InterfaceType):
     """A metaclass which inherits from both GObjectMeta and
     `dbus.service.InterfaceType`. Used as the metaclass for `ExportedGObject`.
@@ -33,39 +45,39 @@ class ExportedGObjectType(gobject.GObjectMeta, dbus.service.InterfaceType):
         gobject.GObjectMeta.__init__(cls, name, bases, dct)
         dbus.service.InterfaceType.__init__(cls, name, bases, dct)
 
-class ExportedGObject(gobject.GObject, dbus.service.Object):
-    """A GObject which is exported on the D-Bus.
 
-    Because GObject and `dbus.service.Object` both have custom metaclasses,
-    the naive approach using simple multiple inheritance won't work. This
-    class has `ExportedGObjectType` as its metaclass, which is sufficient
-    to make it work correctly.
-    """
-    __metaclass__ = ExportedGObjectType
+def ExportedGObject__init__(self, conn=None, object_path=None, **kwargs):
+    """Initialize an exported GObject.
+
+    :Parameters:
+        `conn` : dbus.connection.Connection
+            The D-Bus connection or bus
+        `object_path` : str
+            The object path at which to register this object.
+    :Keywords:
+        `bus_name` : dbus.service.BusName
+            A bus name to be held on behalf of this object, or None.
+        `gobject_properties` : dict
+            GObject properties to be set on the constructed object.
 
-    def __init__(self, conn=None, object_path=None, **kwargs):
-        """Initialize an exported GObject.
+            Any unrecognised keyword arguments will also be interpreted
+            as GObject properties.
+        """
+    bus_name = kwargs.pop('bus_name', None)
+    gobject_properties = kwargs.pop('gobject_properties', None)
 
-        :Parameters:
-            `conn` : dbus.connection.Connection
-                The D-Bus connection or bus
-            `object_path` : str
-                The object path at which to register this object.
-        :Keywords:
-            `bus_name` : dbus.service.BusName
-                A bus name to be held on behalf of this object, or None.
-            `gobject_properties` : dict
-                GObject properties to be set on the constructed object.
+    if gobject_properties is not None:
+        kwargs.update(gobject_properties)
+    gobject.GObject.__init__(self, **kwargs)
+    dbus.service.Object.__init__(self, conn=conn,
+                                 object_path=object_path,
+                                 bus_name=bus_name)
 
-                Any unrecognised keyword arguments will also be interpreted
-                as GObject properties.
-            """
-        bus_name = kwargs.pop('bus_name', None)
-        gobject_properties = kwargs.pop('gobject_properties', None)
+ExportedGObject__doc__ = 'A GObject which is exported on the D-Bus.'
 
-        if gobject_properties is not None:
-            kwargs.update(gobject_properties)
-        gobject.GObject.__init__(self, **kwargs)
-        dbus.service.Object.__init__(self, conn=conn,
-                                     object_path=object_path,
-                                     bus_name=bus_name)
+ExportedGObject = ExportedGObjectType(
+    'ExportedGObject',
+    (gobject.GObject, dbus.service.Object),
+    {'__init__': ExportedGObject__init__,
+     '__doc__': ExportedGObject__doc__,
+     })
diff --git a/test/run-test.sh b/test/run-test.sh
index e50dae5..79efaff 100755
--- a/test/run-test.sh
+++ b/test/run-test.sh
@@ -62,6 +62,8 @@ fi
 
 dbus-monitor > "$DBUS_TOP_BUILDDIR"/test/monitor.log &
 
+echo "DBUS_TOP_SRCDIR=$DBUS_TOP_SRCDIR"
+echo "DBUS_TOP_BUILDDIR=$DBUS_TOP_BUILDDIR"
 echo "PYTHONPATH=$PYTHONPATH"
 echo "PYTHON=$PYTHON"
 
diff --git a/test/test-client.py b/test/test-client.py
index d8dc387..dc2be4e 100755
--- a/test/test-client.py
+++ b/test/test-client.py
@@ -84,7 +84,7 @@ class TestDBusBindings(unittest.TestCase):
         print("introspection, ", end='')
         remote_gobject.Introspect(dbus_interface=dbus.INTROSPECTABLE_IFACE)
         print("method call, ", end='')
-        self.assertEquals(iface.Echo('123'), '123')
+        self.assertEqual(iface.Echo('123'), '123')
         print("... OK")
 
     def testWeakRefs(self):
@@ -92,9 +92,9 @@ class TestDBusBindings(unittest.TestCase):
         # wrong - pre-bugfix, this would segfault
         bus = dbus.SessionBus(private=True)
         ref = weakref.ref(bus)
-        self.assert_(ref() is bus)
+        self.assertTrue(ref() is bus)
         del bus
-        self.assert_(ref() is None)
+        self.assertTrue(ref() is None)
 
     def testInterfaceKeyword(self):
         #test dbus_interface parameter
@@ -102,25 +102,27 @@ class TestDBusBindings(unittest.TestCase):
                                       dbus_interface = IFACE))
         print(self.iface.Echo("dbus_interface on Interface test Passed", 
                               dbus_interface = IFACE))
-        self.assert_(True)
+        self.assertTrue(True)
 
     def testGetDBusMethod(self):
-        self.assertEquals(self.iface.get_dbus_method('AcceptListOfByte')('\1\2\3'), [1,2,3])
-        self.assertEquals(self.remote_object.get_dbus_method('AcceptListOfByte', dbus_interface=IFACE)('\1\2\3'), [1,2,3])
+        self.assertEqual(self.iface.get_dbus_method('AcceptListOfByte')(b'\1\2\3'), [1,2,3])
+        self.assertEqual(self.remote_object.get_dbus_method('AcceptListOfByte', dbus_interface=IFACE)(b'\1\2\3'), [1,2,3])
 
     def testCallingConventionOptions(self):
-        self.assertEquals(self.iface.AcceptListOfByte('\1\2\3'), [1,2,3])
-        self.assertEquals(self.iface.AcceptListOfByte('\1\2\3', byte_arrays=True), '\1\2\3')
-        self.assertEquals(self.iface.AcceptByteArray('\1\2\3'), [1,2,3])
-        self.assertEquals(self.iface.AcceptByteArray('\1\2\3', byte_arrays=True), '\1\2\3')
+        self.assertEqual(self.iface.AcceptListOfByte(b'\1\2\3'), [1,2,3])
+        self.assertEqual(self.iface.AcceptListOfByte(b'\1\2\3', byte_arrays=True), b'\1\2\3')
+        self.assertEqual(self.iface.AcceptByteArray(b'\1\2\3'), [1,2,3])
+        self.assertEqual(self.iface.AcceptByteArray(b'\1\2\3', byte_arrays=True), b'\1\2\3')
         if is_py2:
-            self.assert_(isinstance(self.iface.AcceptUTF8String('abc'), unicode))
-            self.assert_(isinstance(self.iface.AcceptUTF8String('abc', utf8_strings=True), str))
-        self.assert_(isinstance(self.iface.AcceptUnicodeString('abc'), unicode))
+            self.assertTrue(isinstance(self.iface.AcceptUTF8String('abc'), unicode))
+            self.assertTrue(isinstance(self.iface.AcceptUTF8String('abc', utf8_strings=True), str))
+        unicode_type = (str if is_py3 else unicode)
+        self.assertTrue(isinstance(self.iface.AcceptUnicodeString('abc'), 
+                                   unicode_type))
         kwargs = {}
         if is_py2:
             kwargs['utf8_strings'] = True
-        self.assert_(isinstance(self.iface.AcceptUnicodeString('abc', **kwargs), str))
+        self.assertTrue(isinstance(self.iface.AcceptUnicodeString('abc', **kwargs), str))
 
     def testIntrospection(self):
         #test introspection
@@ -128,7 +130,7 @@ class TestDBusBindings(unittest.TestCase):
         print(self.remote_object.Introspect(
             dbus_interface="org.freedesktop.DBus.Introspectable"))
         print("Introspection test passed")
-        self.assert_(True)
+        self.assertTrue(True)
 
     def testMultiPathIntrospection(self):
         # test introspection on an object exported in multiple places
@@ -139,7 +141,7 @@ class TestDBusBindings(unittest.TestCase):
         remote_object.Introspect(dbus_interface="org.freedesktop.DBus.Introspectable")
         remote_object = self.bus.get_object(NAME, OBJECT + '/Multi2/3')
         remote_object.Introspect(dbus_interface="org.freedesktop.DBus.Introspectable")
-        self.assert_(True)
+        self.assertTrue(True)
 
     def testPythonTypes(self):
         #test sending python types and getting them back
@@ -148,30 +150,30 @@ class TestDBusBindings(unittest.TestCase):
         for send_val in test_types_vals:
             print("Testing %s"% str(send_val))
             recv_val = self.iface.Echo(send_val)
-            self.assertEquals(send_val, recv_val)
-            self.assertEquals(recv_val.variant_level, 1)
+            self.assertEqual(send_val, recv_val)
+            self.assertEqual(recv_val.variant_level, 1)
 
     def testMethodExtraInfoKeywords(self):
         print("Testing MethodExtraInfoKeywords...")
         sender, path, destination, message_cls = self.iface.MethodExtraInfoKeywords()
-        self.assert_(sender.startswith(':'))
-        self.assertEquals(path, '/org/freedesktop/DBus/TestSuitePythonObject')
+        self.assertTrue(sender.startswith(':'))
+        self.assertEqual(path, '/org/freedesktop/DBus/TestSuitePythonObject')
         # we're using the "early binding" form of get_object (without
         # follow_name_owner_changes), so the destination we actually sent it
         # to will be the unique name
-        self.assert_(destination.startswith(':'))
-        self.assertEquals(message_cls, 'dbus.lowlevel.MethodCallMessage')
+        self.assertTrue(destination.startswith(':'))
+        self.assertEqual(message_cls, 'dbus.lowlevel.MethodCallMessage')
 
     def testUtf8StringsSync(self):
         if is_py3:
             return
         send_val = 'foo'
         recv_val = self.iface.Echo(send_val, utf8_strings=True)
-        self.assert_(isinstance(recv_val, str))
-        self.assert_(isinstance(recv_val, dbus.UTF8String))
+        self.assertTrue(isinstance(recv_val, str))
+        self.assertTrue(isinstance(recv_val, dbus.UTF8String))
         recv_val = self.iface.Echo(send_val, utf8_strings=False)
-        self.assert_(isinstance(recv_val, unicode))
-        self.assert_(isinstance(recv_val, dbus.String))
+        self.assertTrue(isinstance(recv_val, unicode))
+        self.assertTrue(isinstance(recv_val, dbus.String))
 
     def testBenchmarkIntrospect(self):
         print("\n********* Benchmark Introspect ************")
@@ -181,7 +183,7 @@ class TestDBusBindings(unittest.TestCase):
         b = time.time()
         print(b)
         print("Delta: %f" % (b - a))
-        self.assert_(True)
+        self.assertTrue(True)
 
     def testAsyncCalls(self):
         #test sending python types and getting them back async
@@ -205,8 +207,8 @@ class TestDBusBindings(unittest.TestCase):
                     if self.do_exit:
                         main_loop.quit()
 
-                    self.test_controler.assertEquals(val, self.expected_result)
-                    self.test_controler.assertEquals(val.variant_level, 1)
+                    self.test_controler.assertEqual(val, self.expected_result)
+                    self.test_controler.assertEqual(val.variant_level, 1)
                     if is_py2:
                         if self.utf8 and not isinstance(val, dbus.UTF8String):
                             failures.append('%r should have been utf8 but was not' % val)
@@ -240,7 +242,7 @@ class TestDBusBindings(unittest.TestCase):
                                        **kwargs)
         main_loop.run()
         if failures:
-            self.assert_(False, failures)
+            self.assertTrue(False, failures)
 
     def testStrictMarshalling(self):
         print("\n********* Testing strict return & signal marshalling ***********")
@@ -252,13 +254,14 @@ class TestDBusBindings(unittest.TestCase):
         # with a different number
         values = ["", ("",""), ("","",""), [], {}, ["",""], ["","",""]]
         methods = [
-                    (self.iface.ReturnOneString, 'SignalOneString', set([0]), set([0])),
-                    (self.iface.ReturnTwoStrings, 'SignalTwoStrings', set([1, 5]), set([1])),
-                    (self.iface.ReturnStruct, 'SignalStruct', set([1, 5]), set([1])),
-                    # all of our test values are sequences so will marshall correctly into an array :P
-                    (self.iface.ReturnArray, 'SignalArray', set(range(len(values))), set([3, 5, 6])),
-                    (self.iface.ReturnDict, 'SignalDict', set([0, 3, 4]), set([4]))
-                ]
+            (self.iface.ReturnOneString, 'SignalOneString', set([0]), set([0])),
+            (self.iface.ReturnTwoStrings, 'SignalTwoStrings', set([1, 5]), set([1])),
+            (self.iface.ReturnStruct, 'SignalStruct', set([1, 5]), set([1])),
+            # all of our test values are sequences so will marshall correctly
+            # into an array :P
+            (self.iface.ReturnArray, 'SignalArray', set(range(len(values))), set([3, 5, 6])),
+            (self.iface.ReturnDict, 'SignalDict', set([0, 3, 4]), set([4]))
+            ]
 
         for (method, signal, success_values, return_values) in methods:
             print("\nTrying correct behaviour of", method._method_name)
@@ -266,19 +269,31 @@ class TestDBusBindings(unittest.TestCase):
                 try:
                     ret = method(value)
                 except Exception as e:
-                    print("%s(%r) raised %s: %s" % (method._method_name, values[value], e.__class__, e))
+                    print("%s(%r) raised %s: %s" % 
+                          (method._method_name, values[value], e.__class__, e))
 
                     # should fail if it tried to marshal the wrong type
-                    self.assert_(value not in success_values, "%s should succeed when we ask it to return %r\n%s\n%s" % (method._method_name, values[value], e.__class__, e))
+                    self.assertTrue(value not in success_values, 
+                                    "%s should succeed when we ask it to "
+                                    "return %r\n%s\n%s" % (
+                                        method._method_name, values[value], 
+                                        e.__class__, e))
                 else:
-                    print("%s(%r) returned %r" % (method._method_name, values[value], ret))
+                    print("%s(%r) returned %r" % (
+                        method._method_name, values[value], ret))
 
                     # should only succeed if it's the right return type
-                    self.assert_(value in success_values, "%s should fail when we ask it to return %r" % (method._method_name, values[value]))
+                    self.assertTrue(value in success_values, 
+                                    "%s should fail when we ask it to "
+                                    "return %r" % (
+                                        method._method_name, values[value]))
 
                     # check the value is right too :D
                     returns = map(lambda n: values[n], return_values)
-                    self.assert_(ret in returns, "%s should return one of %r but it returned %r instead" % (method._method_name, returns, ret))
+                    self.assertTrue(ret in returns, 
+                                    "%s should return one of %r but it "
+                                    "returned %r instead" % (
+                                        method._method_name, returns, ret))
 
             print("\nTrying correct emission of", signal)
             for value in range(len(values)):
@@ -288,12 +303,12 @@ class TestDBusBindings(unittest.TestCase):
                     print("EmitSignal(%s, %r) raised %s" % (signal, values[value], e.__class__))
 
                     # should fail if it tried to marshal the wrong type
-                    self.assert_(value not in success_values, "EmitSignal(%s) should succeed when we ask it to return %r\n%s\n%s" % (signal, values[value], e.__class__, e))
+                    self.assertTrue(value not in success_values, "EmitSignal(%s) should succeed when we ask it to return %r\n%s\n%s" % (signal, values[value], e.__class__, e))
                 else:
                     print("EmitSignal(%s, %r) appeared to succeed" % (signal, values[value]))
 
                     # should only succeed if it's the right return type
-                    self.assert_(value in success_values, "EmitSignal(%s) should fail when we ask it to return %r" % (signal, values[value]))
+                    self.assertTrue(value in success_values, "EmitSignal(%s) should fail when we ask it to return %r" % (signal, values[value]))
 
                     # FIXME: wait for the signal here
 
@@ -303,7 +318,7 @@ class TestDBusBindings(unittest.TestCase):
         print("\n********* Testing inheritance from dbus.method.Interface ***********")
         ret = self.iface.CheckInheritance()
         print("CheckInheritance returned %s" % ret)
-        self.assert_(ret, "overriding CheckInheritance from TestInterface failed")
+        self.assertTrue(ret, "overriding CheckInheritance from TestInterface failed")
 
     def testAsyncMethods(self):
         print("\n********* Testing asynchronous method implementation *******")
@@ -314,12 +329,12 @@ class TestDBusBindings(unittest.TestCase):
                     print("calling AsynchronousMethod with %s %s %s" % (async, fail, val))
                     ret = self.iface.AsynchronousMethod(async, fail, val)
                 except Exception as e:
-                    self.assert_(fail, '%s: %s' % (e.__class__, e))
+                    self.assertTrue(fail, '%s: %s' % (e.__class__, e))
                     print("Expected failure: %s: %s" % (e.__class__, e))
                 else:
-                    self.assert_(not fail, 'Expected failure but succeeded?!')
-                    self.assertEquals(val, ret)
-                    self.assertEquals(1, ret.variant_level)
+                    self.assertTrue(not fail, 'Expected failure but succeeded?!')
+                    self.assertEqual(val, ret)
+                    self.assertEqual(1, ret.variant_level)
 
     def testBusInstanceCaching(self):
         print("\n********* Testing dbus.Bus instance sharing *********")
@@ -338,18 +353,18 @@ class TestDBusBindings(unittest.TestCase):
             private_func = func(private=True)
 
             print(" - checking shared instances are the same...")
-            self.assert_(share_cls == share_type, '%s should equal %s' % (share_cls, share_type))
-            self.assert_(share_type == share_func, '%s should equal %s' % (share_type, share_func))
+            self.assertTrue(share_cls == share_type, '%s should equal %s' % (share_cls, share_type))
+            self.assertTrue(share_type == share_func, '%s should equal %s' % (share_type, share_func))
 
             print(" - checking private instances are distinct from the shared instance...")
-            self.assert_(share_cls != private_cls, '%s should not equal %s' % (share_cls, private_cls))
-            self.assert_(share_type != private_type, '%s should not equal %s' % (share_type, private_type))
-            self.assert_(share_func != private_func, '%s should not equal %s' % (share_func, private_func))
+            self.assertTrue(share_cls != private_cls, '%s should not equal %s' % (share_cls, private_cls))
+            self.assertTrue(share_type != private_type, '%s should not equal %s' % (share_type, private_type))
+            self.assertTrue(share_func != private_func, '%s should not equal %s' % (share_func, private_func))
 
             print(" - checking private instances are distinct from each other...")
-            self.assert_(private_cls != private_type, '%s should not equal %s' % (private_cls, private_type))
-            self.assert_(private_type != private_func, '%s should not equal %s' % (private_type, private_func))
-            self.assert_(private_func != private_cls, '%s should not equal %s' % (private_func, private_cls))
+            self.assertTrue(private_cls != private_type, '%s should not equal %s' % (private_cls, private_type))
+            self.assertTrue(private_type != private_func, '%s should not equal %s' % (private_type, private_func))
+            self.assertTrue(private_func != private_cls, '%s should not equal %s' % (private_func, private_cls))
 
     def testSenderName(self):
         print('\n******** Testing sender name keyword ********')
@@ -358,19 +373,19 @@ class TestDBusBindings(unittest.TestCase):
 
     def testBusGetNameOwner(self):
         ret = self.bus.get_name_owner(NAME)
-        self.assert_(ret.startswith(':'), ret)
+        self.assertTrue(ret.startswith(':'), ret)
 
     def testBusListNames(self):
         ret = self.bus.list_names()
-        self.assert_(NAME in ret, ret)
+        self.assertTrue(NAME in ret, ret)
 
     def testBusListActivatableNames(self):
         ret = self.bus.list_activatable_names()
-        self.assert_(NAME in ret, ret)
+        self.assertTrue(NAME in ret, ret)
 
     def testBusNameHasOwner(self):
-        self.assert_(self.bus.name_has_owner(NAME))
-        self.assert_(not self.bus.name_has_owner('badger.mushroom.snake'))
+        self.assertTrue(self.bus.name_has_owner(NAME))
+        self.assertTrue(not self.bus.name_has_owner('badger.mushroom.snake'))
 
     def testBusNameCreation(self):
         print('\n******** Testing BusName creation ********')
@@ -392,12 +407,12 @@ class TestDBusBindings(unittest.TestCase):
                 busname = dbus.service.BusName(name, dbus.SessionBus())
             except Exception as e:
                 print("%s:\n%s" % (e.__class__, e))
-                self.assert_(not succeed, 'did not expect registering bus name %s to fail' % name)
+                self.assertTrue(not succeed, 'did not expect registering bus name %s to fail' % name)
             else:
                 print(busname)
-                self.assert_(succeed, 'expected registering bus name %s to fail'% name)
+                self.assertTrue(succeed, 'expected registering bus name %s to fail'% name)
                 if name in names:
-                    self.assert_(names[name] == busname, 'got a new instance for same name %s' % name)
+                    self.assertTrue(names[name] == busname, 'got a new instance for same name %s' % name)
                     print("instance of %s re-used, good!" % name)
                 else:
                     names[name] = busname
@@ -410,70 +425,70 @@ class TestDBusBindings(unittest.TestCase):
 
         bus = dbus.Bus()
         ret = bus.name_has_owner('org.freedesktop.DBus.Python.TestName')
-        self.assert_(not ret, 'deleting reference failed to release BusName org.freedesktop.DBus.Python.TestName')
+        self.assertTrue(not ret, 'deleting reference failed to release BusName org.freedesktop.DBus.Python.TestName')
 
     def testMultipleReturnWithoutSignature(self):
         # https://bugs.freedesktop.org/show_bug.cgi?id=10174
         ret = self.iface.MultipleReturnWithoutSignature()
-        self.assert_(not isinstance(ret, dbus.Struct), repr(ret))
-        self.assertEquals(ret, ('abc', 123))
+        self.assertTrue(not isinstance(ret, dbus.Struct), repr(ret))
+        self.assertEqual(ret, ('abc', 123))
 
     def testListExportedChildObjects(self):
-        self.assert_(self.iface.TestListExportedChildObjects())
+        self.assertTrue(self.iface.TestListExportedChildObjects())
 
     def testRemoveFromConnection(self):
         # https://bugs.freedesktop.org/show_bug.cgi?id=10457
-        self.assert_(not self.iface.HasRemovableObject())
-        self.assert_(self.iface.AddRemovableObject())
-        self.assert_(self.iface.HasRemovableObject())
+        self.assertTrue(not self.iface.HasRemovableObject())
+        self.assertTrue(self.iface.AddRemovableObject())
+        self.assertTrue(self.iface.HasRemovableObject())
 
         removable = self.bus.get_object(NAME, OBJECT + '/RemovableObject')
         iface = dbus.Interface(removable, IFACE)
-        self.assert_(iface.IsThere())
-        self.assert_(iface.RemoveSelf())
+        self.assertTrue(iface.IsThere())
+        self.assertTrue(iface.RemoveSelf())
 
-        self.assert_(not self.iface.HasRemovableObject())
+        self.assertTrue(not self.iface.HasRemovableObject())
 
         # and again...
-        self.assert_(self.iface.AddRemovableObject())
-        self.assert_(self.iface.HasRemovableObject())
-        self.assert_(iface.IsThere())
-        self.assert_(iface.RemoveSelf())
-        self.assert_(not self.iface.HasRemovableObject())
+        self.assertTrue(self.iface.AddRemovableObject())
+        self.assertTrue(self.iface.HasRemovableObject())
+        self.assertTrue(iface.IsThere())
+        self.assertTrue(iface.RemoveSelf())
+        self.assertTrue(not self.iface.HasRemovableObject())
 
     def testFallbackObjectTrivial(self):
         obj = self.bus.get_object(NAME, OBJECT + '/Fallback')
         iface = dbus.Interface(obj, IFACE)
         path, rel, unique_name = iface.TestPathAndConnKeywords()
-        self.assertEquals(path, OBJECT + '/Fallback')
-        self.assertEquals(rel, '/')
-        self.assertEquals(unique_name, obj.bus_name)
+        self.assertEqual(path, OBJECT + '/Fallback')
+        self.assertEqual(rel, '/')
+        self.assertEqual(unique_name, obj.bus_name)
 
     def testFallbackObjectNested(self):
         obj = self.bus.get_object(NAME, OBJECT + '/Fallback/Nested')
         iface = dbus.Interface(obj, IFACE)
         path, rel, unique_name = iface.TestPathAndConnKeywords()
-        self.assertEquals(path, OBJECT + '/Fallback/Nested')
-        self.assertEquals(rel, '/')
-        self.assertEquals(unique_name, obj.bus_name)
+        self.assertEqual(path, OBJECT + '/Fallback/Nested')
+        self.assertEqual(rel, '/')
+        self.assertEqual(unique_name, obj.bus_name)
 
         obj = self.bus.get_object(NAME, OBJECT + '/Fallback/Nested/Badger/Mushroom')
         iface = dbus.Interface(obj, IFACE)
         path, rel, unique_name = iface.TestPathAndConnKeywords()
-        self.assertEquals(path, OBJECT + '/Fallback/Nested/Badger/Mushroom')
-        self.assertEquals(rel, '/Badger/Mushroom')
-        self.assertEquals(unique_name, obj.bus_name)
+        self.assertEqual(path, OBJECT + '/Fallback/Nested/Badger/Mushroom')
+        self.assertEqual(rel, '/Badger/Mushroom')
+        self.assertEqual(unique_name, obj.bus_name)
 
     def testFallbackObject(self):
         obj = self.bus.get_object(NAME, OBJECT + '/Fallback/Badger/Mushroom')
         iface = dbus.Interface(obj, IFACE)
         path, rel, unique_name = iface.TestPathAndConnKeywords()
-        self.assertEquals(path, OBJECT + '/Fallback/Badger/Mushroom')
-        self.assertEquals(rel, '/Badger/Mushroom')
-        self.assertEquals(unique_name, obj.bus_name)
+        self.assertEqual(path, OBJECT + '/Fallback/Badger/Mushroom')
+        self.assertEqual(rel, '/Badger/Mushroom')
+        self.assertEqual(unique_name, obj.bus_name)
 
     def testTimeoutSync(self):
-        self.assert_(self.iface.BlockFor500ms(timeout=1.0) is None)
+        self.assertTrue(self.iface.BlockFor500ms(timeout=1.0) is None)
         self.assertRaises(dbus.DBusException,
                           lambda: self.iface.BlockFor500ms(timeout=0.25))
 
@@ -482,11 +497,11 @@ class TestDBusBindings(unittest.TestCase):
         try:
             self.iface.AsyncRaise()
         except dbus.DBusException as e:
-            self.assert_(e.get_dbus_name() ==
+            self.assertTrue(e.get_dbus_name() ==
                          'org.freedesktop.bugzilla.bug12403',
                          e.get_dbus_name())
         else:
-            self.assert_(False)
+            self.assertTrue(False)
 
     def testClosePrivateBus(self):
         # fd.o #12096
@@ -519,11 +534,11 @@ class TestDBusBindings(unittest.TestCase):
                                  reply_handler=incorrectly_returned,
                                  error_handler=correctly_failed)
         loop.run()
-        self.assertEquals(passes, ['250', '1000'])
-        self.assertEquals(fails, [])
+        self.assertEqual(passes, ['250', '1000'])
+        self.assertEqual(fails, [])
 
     def testTimeoutAsyncService(self):
-        self.assert_(self.iface.AsyncWait500ms(timeout=1.0) is None)
+        self.assertTrue(self.iface.AsyncWait500ms(timeout=1.0) is None)
         self.assertRaises(dbus.DBusException,
                           lambda: self.iface.AsyncWait500ms(timeout=0.25))
 
@@ -538,8 +553,8 @@ class TestDBusBindings(unittest.TestCase):
         try:
             self.iface.RaiseValueError()
         except Exception as e:
-            self.assert_(isinstance(e, dbus.DBusException), e.__class__)
-            self.assert_('.ValueError: Traceback ' in str(e),
+            self.assertTrue(isinstance(e, dbus.DBusException), e.__class__)
+            self.assertTrue('.ValueError: Traceback ' in str(e),
                          'Wanted a traceback but got:\n"""%s"""' % str(e))
         else:
             raise AssertionError('Wanted an exception')
@@ -547,8 +562,8 @@ class TestDBusBindings(unittest.TestCase):
         try:
             self.iface.RaiseDBusExceptionNoTraceback()
         except Exception as e:
-            self.assert_(isinstance(e, dbus.DBusException), e.__class__)
-            self.assertEquals(str(e),
+            self.assertTrue(isinstance(e, dbus.DBusException), e.__class__)
+            self.assertEqual(str(e),
                               'com.example.Networking.ServerError: '
                               'Server not responding')
         else:
@@ -557,8 +572,8 @@ class TestDBusBindings(unittest.TestCase):
         try:
             self.iface.RaiseDBusExceptionWithTraceback()
         except Exception as e:
-            self.assert_(isinstance(e, dbus.DBusException), e.__class__)
-            self.assert_(str(e).startswith('com.example.Misc.RealityFailure: '
+            self.assertTrue(isinstance(e, dbus.DBusException), e.__class__)
+            self.assertTrue(str(e).startswith('com.example.Misc.RealityFailure: '
                                            'Traceback '),
                          'Wanted a traceback but got:\n%s' % str(e))
         else:
@@ -576,20 +591,20 @@ class TestDBusPythonToGLibBindings(unittest.TestCase):
         print "\n********* Introspection Test ************"
         print self.remote_object.Introspect(dbus_interface="org.freedesktop.DBus.Introspectable")
         print "Introspection test passed"
-        self.assert_(True)
+        self.assertTrue(True)
 
     def testCalls(self):
         print "\n********* Call Test ************"
         result =  self.iface.ManyArgs(1000, 'Hello GLib', 2)
         print result
-        self.assert_(result == [2002.0, 'HELLO GLIB'])
+        self.assertTrue(result == [2002.0, 'HELLO GLIB'])
 
         arg0 = {"Dude": 1, "john": "palmieri", "python": 2.4}
         result = self.iface.ManyStringify(arg0)
         print result
        
         print "Call test passed"
-        self.assert_(True)
+        self.assertTrue(True)
 
     def testPythonTypes(self):
         print "\n********* Testing Python Types ***********"
@@ -597,7 +612,7 @@ class TestDBusPythonToGLibBindings(unittest.TestCase):
         for send_val in test_types_vals:
             print "Testing %s"% str(send_val)
             recv_val = self.iface.EchoVariant(send_val)
-            self.assertEquals(send_val, recv_val.object)
+            self.assertEqual(send_val, recv_val.object)
 """
 if __name__ == '__main__':
     gobject.threads_init()
diff --git a/test/test-service.py b/test/test-service.py
index 62c3fd8..a4448f6 100755
--- a/test/test-service.py
+++ b/test/test-service.py
@@ -41,14 +41,13 @@ import random
 
 from dbus.gobject_service import ExportedGObject
 from gi.repository import GObject as gobject
-from dbus._compat import is_py2
+from dbus._compat import is_py2, is_py3
 
 
-logging.basicConfig(filename=builddir + '/test/test-service.log', filemode='w')
+logging.basicConfig(filename=builddir + '/test/test-service.log', filemode='a')
 logging.getLogger().setLevel(1)
 logger = logging.getLogger('test-service')
 
-
 NAME = "org.freedesktop.DBus.TestSuitePythonService"
 IFACE = "org.freedesktop.DBus.TestSuiteInterface"
 OBJECT = "/org/freedesktop/DBus/TestSuitePythonObject"
@@ -137,7 +136,8 @@ class TestObject(dbus.service.Object, TestInterface):
 
     @dbus.service.method(IFACE, in_signature='s', out_signature='s')
     def AcceptUnicodeString(self, foo):
-        assert isinstance(foo, unicode), (foo, foo.__class__.__mro__)
+        unicode_type = (str if is_py3 else unicode)
+        assert isinstance(foo, unicode_type), (foo, foo.__class__.__mro__)
         return foo
 
     kwargs = {}
@@ -161,9 +161,10 @@ class TestObject(dbus.service.Object, TestInterface):
         assert isinstance(foo, list), (foo, foo.__class__.__mro__)
         return foo
 
-    @dbus.service.method(IFACE, in_signature='ay', out_signature='ay', byte_arrays=True)
+    @dbus.service.method(IFACE, in_signature='ay', out_signature='ay', 
+                         byte_arrays=True)
     def AcceptByteArray(self, foo):
-        assert isinstance(foo, str), (foo, foo.__class__.__mro__)
+        assert isinstance(foo, bytes), (foo, foo.__class__.__mro__)
         return foo
 
     @dbus.service.method(IFACE)
@@ -257,11 +258,13 @@ class TestObject(dbus.service.Object, TestInterface):
         assert objs_org == ['freedesktop'], objs_org
         return True
 
-    @dbus.service.method(IFACE, in_signature='bbv', out_signature='v', async_callbacks=('return_cb', 'error_cb'))
+    @dbus.service.method(IFACE, in_signature='bbv', out_signature='v', 
+                         async_callbacks=('return_cb', 'error_cb'))
     def AsynchronousMethod(self, async, fail, variant, return_cb, error_cb):
         try:
             if async:
-                gobject.timeout_add(500, self.AsynchronousMethod, False, fail, variant, return_cb, error_cb)
+                gobject.timeout_add(500, self.AsynchronousMethod, False, fail, 
+                                    variant, return_cb, error_cb)
                 return
             else:
                 if fail:
@@ -273,7 +276,8 @@ class TestObject(dbus.service.Object, TestInterface):
         except Exception as e:
             error_cb(e)
 
-    @dbus.service.method(IFACE, in_signature='', out_signature='s', sender_keyword='sender')
+    @dbus.service.method(IFACE, in_signature='', out_signature='s', 
+                         sender_keyword='sender')
     def WhoAmI(self, sender):
         return sender
 
@@ -338,10 +342,31 @@ class TestObject(dbus.service.Object, TestInterface):
 
         raise_cb(Fdo12403Error())
 
-session_bus = dbus.SessionBus()
-global_name = dbus.service.BusName(NAME, bus=session_bus)
-object = TestObject(global_name)
-g_object = TestGObject(global_name)
-fallback_object = Fallback(session_bus)
-loop = gobject.MainLoop()
-loop.run()
+
+def main():
+    global session_bus
+    logger.info('getting session bus')
+    session_bus = dbus.SessionBus()
+    logger.info('getting bus name %s', NAME)
+    global_name = dbus.service.BusName(NAME, bus=session_bus)
+    logger.info('making TestObject')
+    object = TestObject(global_name)
+    logger.info('making TestGObject')
+    g_object = TestGObject(global_name)
+    logger.info('making Fallback')
+    fallback_object = Fallback(session_bus)
+    logger.info('creating mainloop')
+    loop = gobject.MainLoop()
+    logger.info('running')
+    loop.run()
+    logger.info('done')
+
+
+if __name__ == '__main__':
+    session_bus = None
+    try:
+        logger.info('entering main')
+        main()
+    except:
+        logger.exception('test-service main failure')
+        raise