test: port dbus tests to python3

10 files changed, 357 insertions, 357 deletions

diff --git a/test/dbus/blacklist-test.py b/test/dbus/blacklist-test.py
index edbdb219..5a216d2a 100644
--- a/test/dbus/blacklist-test.py
+++ b/test/dbus/blacklist-test.py
@@ -1,4 +1,4 @@
-#! /usr/bin/env python
+#! /usr/bin/env python3
 # -.- coding: utf-8 -.-
 
 # remote-test.py
@@ -59,10 +59,10 @@ class BlacklistTest(RemoteTestCase):
 		
 		# Now remove all existing templates...
 		allTemplates = self.blacklist.GetTemplates()
-		[self.blacklist.RemoveTemplate(key) for key in allTemplates.iterkeys()]
+		[self.blacklist.RemoveTemplate(key) for key in list(allTemplates.keys())]
 		
 		# And ensure that they are indeed gone.
-		self.assertEquals(len(self.blacklist.GetTemplates()), 0)
+		self.assertEqual(len(self.blacklist.GetTemplates()), 0)
 
 	def _add_template(self, name, template):
 		self.blacklist.AddTemplate(name, template)
@@ -71,18 +71,18 @@ class BlacklistTest(RemoteTestCase):
 		self.assertEventsEqual(template, Event(res[name]))
 
 	def _assert_template_count(self, num):
-		self.assertEquals(len(self.blacklist.GetTemplates()), num)
+		self.assertEqual(len(self.blacklist.GetTemplates()), num)
 
 	def _assert_insert_blocked(self, *events):
-		inserted_ids = map(int, self.insertEventsAndWait(events))
-		zeros = filter(lambda x: x == 0, inserted_ids)
-		self.assertEquals(len(events), len(inserted_ids))
-		self.assertEquals(len(events), len(zeros))
+		inserted_ids = list(map(int, self.insertEventsAndWait(events)))
+		zeros = [x for x in inserted_ids if x == 0]
+		self.assertEqual(len(events), len(inserted_ids))
+		self.assertEqual(len(events), len(zeros))
 	
 	def _assert_insert_allowed(self, *events):
-		inserted_ids = map(int, self.insertEventsAndWait(events))
-		self.assertEquals(len(events), len(inserted_ids))
-		self.assertEquals([], filter(lambda x: x == 0, inserted_ids))
+		inserted_ids = list(map(int, self.insertEventsAndWait(events)))
+		self.assertEqual(len(events), len(inserted_ids))
+		self.assertEqual([], [x for x in inserted_ids if x == 0])
 
 	def testSetOne(self):
 		orig = Event.new_for_values(
@@ -187,28 +187,28 @@ class BlacklistTest(RemoteTestCase):
 	def testApplyBlacklistWithAccentsInURI(self):
 		# We blacklist some particular URIs
 		self._add_template("weirdo", Event.new_for_values(
-			subject_uri=u"çàrßá€"))
+			subject_uri="çàrßá€"))
 		self._add_template("normalo", Event.new_for_values(
-			subject_uri=u"hello"))
+			subject_uri="hello"))
 		self._assert_template_count(2)
 
 		# And check that the blacklisting works
 		self._assert_insert_blocked(Event.new_for_values(
 			interpretation="a", manifestation="b", actor="c",
-			subject_uri=u"çàrßá€"))
+			subject_uri="çàrßá€"))
 		self._assert_insert_blocked(Event.new_for_values(
 			interpretation="a", manifestation="b", actor="c",
-			subject_uri=u"hello"))
+			subject_uri="hello"))
 		self._assert_insert_allowed(Event.new_for_values(
 			interpretation="a", manifestation="b", actor="c",
-			subject_uri=u"hola"))
+			subject_uri="hola"))
 		self._assert_insert_allowed(Event.new_for_values(
 			interpretation="a", manifestation="b", actor="c",
-			subject_uri=u"çàrßá"))
+			subject_uri="çàrßá"))
 
 	def testApplyBlacklistForEventWithEmptyCurrentURI(self):
 		# We blacklist some particular current URI
-		self._add_template("t", Event.new_for_values(subject_current_uri=u"t"))
+		self._add_template("t", Event.new_for_values(subject_current_uri="t"))
 		self._assert_template_count(1)
 
 		# Blocking the current_uri works
@@ -228,28 +228,28 @@ class BlacklistTest(RemoteTestCase):
 	def testApplyBlacklistWithWildcardInURI(self):
 		# We blacklist some particular URIs
 		self._add_template("wild", Event.new_for_values(
-			subject_uri=u"block me*"))
+			subject_uri="block me*"))
 		self._assert_template_count(1)
 
 		# And check that the blacklisting works
 		self._assert_insert_blocked(Event.new_for_values(
 			interpretation="a", manifestation="b", actor="c",
-			subject_uri=u"block me"))
+			subject_uri="block me"))
 		self._assert_insert_blocked(Event.new_for_values(
 			interpretation="a", manifestation="b", actor="c",
-			subject_uri=u"block me*"))
+			subject_uri="block me*"))
 		self._assert_insert_blocked(Event.new_for_values(
 			interpretation="a", manifestation="b", actor="c",
-			subject_uri=u"block me now"))
+			subject_uri="block me now"))
 		self._assert_insert_blocked(Event.new_for_values(
 			interpretation="a", manifestation="b", actor="c",
-			subject_uri=u"block meß :)"))
+			subject_uri="block meß :)"))
 		self._assert_insert_allowed(Event.new_for_values(
 			interpretation="a", manifestation="b", actor="c",
-			subject_uri=u"block mNOT"))
+			subject_uri="block mNOT"))
 		self._assert_insert_allowed(Event.new_for_values(
 			interpretation="a", manifestation="b", actor="c",
-			subject_uri=u"nblock me"))
+			subject_uri="nblock me"))
 
 	def _get_blacklist_iface(self):
 		"""
@@ -267,9 +267,9 @@ class BlacklistTest(RemoteTestCase):
 		"""
 		blacklist = self._get_blacklist_iface()
 		allTemplates = blacklist.GetTemplates()
-		[blacklist.RemoveTemplate(key) for key in allTemplates.iterkeys()]
+		[blacklist.RemoveTemplate(key) for key in list(allTemplates.keys())]
 		newAllTemplates = blacklist.GetTemplates()
-		self.assertEquals(len(newAllTemplates), 0)
+		self.assertEqual(len(newAllTemplates), 0)
 
 	def testBlacklistSignals(self, mainloop=None, connect_signals=True):
 		self.blacklist = self._get_blacklist_iface()
@@ -287,17 +287,17 @@ class BlacklistTest(RemoteTestCase):
 		@asyncTestMethod(mainloop)
 		def cb_added(template_id, event_template):
 			global hit
-			self.assertEquals(hit, 0)
+			self.assertEqual(hit, 0)
 			hit = 1
-			self.assertEquals(template_id, "TestTemplate")
+			self.assertEqual(template_id, "TestTemplate")
 			self.assertEventsEqual(template1, event_template)
 
 		@asyncTestMethod(mainloop)
 		def cb_removed(template_id, event_template):
 			global hit
-			self.assertEquals(hit, 1)
+			self.assertEqual(hit, 1)
 			hit = 2
-			self.assertEquals(template_id, "TestTemplate")
+			self.assertEqual(template_id, "TestTemplate")
 			self.assertEventsEqual(template1, event_template)
 			mainloop.quit()
 
diff --git a/test/dbus/dsr-test.py b/test/dbus/dsr-test.py
index 9baed85e..96f96b78 100644
--- a/test/dbus/dsr-test.py
+++ b/test/dbus/dsr-test.py
@@ -1,4 +1,4 @@
-#! /usr/bin/env python
+#! /usr/bin/env python3
 # -.- coding: utf-8 -.-
 
 # remote-test.py
@@ -62,15 +62,15 @@ class ZeitgeistRemoteDataSourceRegistryTest(testutils.RemoteTestCase):
 
 	_ds2 = [
 		"www.example.org/bar",
-		u"© mwhahaha çàéü",
-		u"ThŊ§ ıs teĦ ün↓çØÐe¡",
+		"© mwhahaha çàéü",
+		"ThŊ§ ıs teĦ ün↓çØÐe¡",
 		[]
 	]
 
 	_ds2b = [
 		"www.example.org/bar", # same unique ID as _ds2
-		u"This string has been translated into the ASCII language",
-		u"Now the unicode is gone :(",
+		"This string has been translated into the ASCII language",
+		"Now the unicode is gone :(",
 		[
 			Event.new_for_values(subject_manifestation = "nah"),
 		],
@@ -86,21 +86,21 @@ class ZeitgeistRemoteDataSourceRegistryTest(testutils.RemoteTestCase):
 		"""
 		popo = []
 		ev[0][0] = ""
-		popo.append(map(unicode, ev[0]))
-		popo.append([map(unicode, subj) for subj in ev[1]])
+		popo.append(list(map(str, ev[0])))
+		popo.append([list(map(str, subj)) for subj in ev[1]])
 		# We need the check here so that if D-Bus gives us an empty
 		# byte array we don't serialize the text "dbus.Array(...)".
-		popo.append(str(ev[2]) if ev[2] else u'')
+		popo.append(str(ev[2]) if ev[2] else '')
 		return popo
 	
 	def _assertDataSourceEquals(self, dsdbus, dsref):
-		self.assertEquals(dsdbus[DataSource.UniqueId], dsref[0])
-		self.assertEquals(dsdbus[DataSource.Name], dsref[1])
-		self.assertEquals(dsdbus[DataSource.Description], dsref[2])
-		self.assertEquals(len(dsdbus[DataSource.EventTemplates]), len(dsref[3]))
+		self.assertEqual(dsdbus[DataSource.UniqueId], dsref[0])
+		self.assertEqual(dsdbus[DataSource.Name], dsref[1])
+		self.assertEqual(dsdbus[DataSource.Description], dsref[2])
+		self.assertEqual(len(dsdbus[DataSource.EventTemplates]), len(dsref[3]))
 		for i, template in enumerate(dsref[3]):
 			tmpl = dsdbus[DataSource.EventTemplates][i]
-			self.assertEquals(self.get_plain(tmpl), self.get_plain(template))
+			self.assertEqual(self.get_plain(tmpl), self.get_plain(template))
 	
 	def testPresence(self):
 		""" Ensure that the DataSourceRegistry extension is there """
@@ -109,18 +109,18 @@ class ZeitgeistRemoteDataSourceRegistryTest(testutils.RemoteTestCase):
 		registry.GetDataSources()
 	
 	def testGetDataSourcesEmpty(self):
-		self.assertEquals(self.client._registry.GetDataSources(), [])
+		self.assertEqual(self.client._registry.GetDataSources(), [])
 	
 	def testRegisterDataSource(self):
 		self.client.register_data_source(*self._ds1)
 		datasources = list(self.client._registry.GetDataSources())
-		self.assertEquals(len(datasources), 1)
+		self.assertEqual(len(datasources), 1)
 		self._assertDataSourceEquals(datasources[0], self._ds1)
 	
 	def testRegisterDataSourceUnicode(self):
 		self.client.register_data_source(*self._ds2)
 		datasources = list(self.client._registry.GetDataSources())
-		self.assertEquals(len(datasources), 1)
+		self.assertEqual(len(datasources), 1)
 		self._assertDataSourceEquals(datasources[0], self._ds2)
 	
 	def testRegisterDataSourceWithCallback(self):
@@ -133,7 +133,7 @@ class ZeitgeistRemoteDataSourceRegistryTest(testutils.RemoteTestCase):
 		
 		# Verify that they have been inserted correctly
 		datasources = list(self.client._registry.GetDataSources())
-		self.assertEquals(len(datasources), 2)
+		self.assertEqual(len(datasources), 2)
 		datasources.sort(key=lambda x: x[DataSource.UniqueId])
 		self._assertDataSourceEquals(datasources[0], self._ds1)
 		self._assertDataSourceEquals(datasources[1], self._ds2)
@@ -143,7 +143,7 @@ class ZeitgeistRemoteDataSourceRegistryTest(testutils.RemoteTestCase):
 		
 		# Verify that it changed correctly
 		datasources = list(self.client._registry.GetDataSources())
-		self.assertEquals(len(datasources), 2)
+		self.assertEqual(len(datasources), 2)
 		datasources.sort(key=lambda x: x[DataSource.UniqueId])
 		self._assertDataSourceEquals(datasources[0], self._ds1)
 		self._assertDataSourceEquals(datasources[1], self._ds2b)
@@ -152,28 +152,28 @@ class ZeitgeistRemoteDataSourceRegistryTest(testutils.RemoteTestCase):
 		# Insert a data-source -- it should be enabled by default
 		self.client._registry.RegisterDataSource(*self._ds1)
 		ds = list(self.client._registry.GetDataSources())[0]
-		self.assertEquals(ds[DataSource.Enabled], True)
+		self.assertEqual(ds[DataSource.Enabled], True)
 		
 		# Now we can choose to disable it...
 		self.client._registry.SetDataSourceEnabled(self._ds1[0], False)
 		ds = list(self.client._registry.GetDataSources())[0]
-		self.assertEquals(ds[DataSource.Enabled], False)
+		self.assertEqual(ds[DataSource.Enabled], False)
 		
 		# And enable it again!
 		self.client._registry.SetDataSourceEnabled(self._ds1[0], True)
 		ds = list(self.client._registry.GetDataSources())[0]
-		self.assertEquals(ds[DataSource.Enabled], True)
+		self.assertEqual(ds[DataSource.Enabled], True)
 
 	def testSetDataSourceDisabled(self):
 		# Insert a data-source -- it should be enabled by default
 		self.client._registry.RegisterDataSource(*self._ds1)
 		ds = list(self.client._registry.GetDataSources())[0]
-		self.assertEquals(ds[DataSource.Enabled], True)
+		self.assertEqual(ds[DataSource.Enabled], True)
 
 		# Now we can choose to disable it...
 		self.client._registry.SetDataSourceEnabled(self._ds1[0], False)
 		ds = list(self.client._registry.GetDataSources())[0]
-		self.assertEquals(ds[DataSource.Enabled], False)
+		self.assertEqual(ds[DataSource.Enabled], False)
 
 		event = Event.new_for_values(
 			interpretation="interpretation",
@@ -184,15 +184,15 @@ class ZeitgeistRemoteDataSourceRegistryTest(testutils.RemoteTestCase):
 
 		# ... which will block its events from being inserted
 		ids = self.insertEventsAndWait([event])
-		self.assertEquals(ids[0], 0)
+		self.assertEqual(ids[0], 0)
 
 		# And enable it again!
 		self.client._registry.SetDataSourceEnabled(self._ds1[0], True)
 		ds = list(self.client._registry.GetDataSources())[0]
-		self.assertEquals(ds[DataSource.Enabled], True)
+		self.assertEqual(ds[DataSource.Enabled], True)
 
 		ids = self.insertEventsAndWait([event])
-		self.assertEquals(ids[0], 1)
+		self.assertEqual(ids[0], 1)
 
 	def testGetDataSourceFromId(self):
 		# Insert a data-source -- and then retrieve it by id
@@ -214,17 +214,17 @@ class ZeitgeistRemoteDataSourceRegistryTest(testutils.RemoteTestCase):
 		@asyncTestMethod(mainloop)
 		def cb_registered(datasource):
 			global hit
-			self.assertEquals(hit, 0)
+			self.assertEqual(hit, 0)
 			hit = 1
 		
 		@asyncTestMethod(mainloop)
 		def cb_enabled(unique_id, enabled):
 			global hit
 			if hit == 1:
-				self.assertEquals(enabled, False)
+				self.assertEqual(enabled, False)
 				hit = 2
 			elif hit == 2:
-				self.assertEquals(enabled, True)
+				self.assertEqual(enabled, True)
 				hit = 3
 				# We're done -- change this if we figure out how to force a
 				# disconnection from the bus, so we can also check the
diff --git a/test/dbus/engine-test.py b/test/dbus/engine-test.py
index d550a12f..81b085a7 100644
--- a/test/dbus/engine-test.py
+++ b/test/dbus/engine-test.py
@@ -1,4 +1,4 @@
-#! /usr/bin/env python
+#! /usr/bin/env python3
 # -.- coding: utf-8 -.-
 
 # engine-test.py
@@ -36,11 +36,11 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 		test_event_1 = parse_events("test/data/one_event.js")[0]
 		# Insert item and event
 		ids = self.insertEventsAndWait([test_event_1])
-		self.assertEquals(1, len(ids))
+		self.assertEqual(1, len(ids))
 
 		result = self.getEventsAndWait(ids)
 		resulting_event = result.pop()
-		self.assertEquals(len(resulting_event), len(test_event_1))
+		self.assertEqual(len(resulting_event), len(test_event_1))
 
 		# fixing id, the initial event does not have any id set
 		test_event_1[0][0] = ids[0]
@@ -68,9 +68,9 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 		ids = self.insertEventsAndWait([ev])
 		result = self.getEventsAndWait(ids)
 
-		self.assertEquals(1, len(result))
+		self.assertEqual(1, len(result))
 		resulting_event = Event(result.pop())
-		self.assertEquals("foo://bar", resulting_event.interpretation)
+		self.assertEqual("foo://bar", resulting_event.interpretation)
 		self.assertTrue(resulting_event.timestamp) # We should have a timestamp again
 
 	def testDuplicateEventInsertion(self):
@@ -82,14 +82,14 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 
 		# Find all events, and make sure that this is exactly one event
 		result = self.findEventIdsAndWait([])
-		self.assertEquals(1, len(result))
-		self.assertEquals(1, result[0]) # The single event must have id 1
+		self.assertEqual(1, len(result))
+		self.assertEqual(1, result[0]) # The single event must have id 1
 
 	def testDeleteSingle(self):
 		self.testSingleInsertGet()
 		self.deleteEventsAndWait([1])
 		result = self.getEventsAndWait([1])
-		self.assertEquals(0, len(filter(None, result)))
+		self.assertEqual(0, len([_f for _f in result if _f]))
 
 	def testIllegalPredefinedEventId(self):
 		event = parse_events("test/data/single_event.js")[0]
@@ -97,44 +97,44 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 
 		# Try inserting the event
 		ids = self.insertEventsAndWait([event,])
-		self.assertEquals(len(ids), 1)
+		self.assertEqual(len(ids), 1)
 
 		# Event is not inserted, id == 0 means error
-		self.assertEquals(ids[0], 0)
+		self.assertEqual(ids[0], 0)
 
 		# Ensure that it really wasn't inserted
 		ids = self.findEventIdsAndWait([])
-		self.assertEquals(len(ids), 0)
+		self.assertEqual(len(ids), 0)
 
 	def testGetNonExisting(self):
 		events = self.getEventsAndWait([23,45,65])
-		self.assertEquals(3, len(events))
-		for ev in events: self.assertEquals(None, ev)
+		self.assertEqual(3, len(events))
+		for ev in events: self.assertEqual(None, ev)
 
 	def testGetDuplicateEventIds(self):
 		ids = import_events("test/data/five_events.js", self)
-		self.assertEquals(5, len(ids))
+		self.assertEqual(5, len(ids))
 
 		events = self.getEventsAndWait([1, 1])
 		self.assertEqual(2, len(events))
-		self.assertEqual(2, len(filter(None, events)))
+		self.assertEqual(2, len([_f for _f in events if _f]))
 		self.assertTrue(events[0].id == events[1].id == 1)
 
 	def testFindEventsId(self):
 		test_event_1 = parse_events("test/data/one_event.js")[0]
 		self.testSingleInsertGet()
 		result = self.findEventIdsAndWait([])
-		self.assertEquals(1, len(result))
+		self.assertEqual(1, len(result))
 		test_event_1[0][0] = 1
 		self.assertEqual(result[0], test_event_1.id)
 
 	def testFindNothing(self):
 		result = self.findEventIdsAndWait([])
-		self.assertEquals(0, len(result))
+		self.assertEqual(0, len(result))
 
 	def testFindNothingBackwards(self):
 		result = self.findEventIdsAndWait([], timerange=(1000000,1))
-		self.assertEquals(0, len(result))
+		self.assertEqual(0, len(result))
 
 	def testFindFilteredByEventButNotSubject(self):
 		# revision rainct@ubuntu.com-20091128164327-j8ez3fsifd1gygkr (1185)
@@ -142,38 +142,38 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 		self.testSingleInsertGet()
 		result = self.findEventIdsAndWait([Event.new_for_values(
 			interpretation=Interpretation.LEAVE_EVENT)])
-		self.assertEquals(0, len(result))
+		self.assertEqual(0, len(result))
 
 	def testFindFive(self):
 		import_events("test/data/five_events.js", self)
 		result = self.findEventIdsAndWait([])
-		self.assertEquals(5, len(result))
+		self.assertEqual(5, len(result))
 
 	def testFindFiveWithStorageState(self):
 		import_events("test/data/five_events.js", self)
 		# The event's storage is unknown, so we get them back always.
 		result = self.findEventIdsAndWait([], storage_state=1)
-		self.assertEquals(5, len(result))
+		self.assertEqual(5, len(result))
 		result = self.findEventIdsAndWait([], storage_state=0)
-		self.assertEquals(5, len(result))
+		self.assertEqual(5, len(result))
 
 	def testFindWithNonExistantActor(self):
 		# Bug 496109: filtering by timerange and a non-existing actor gave an
 		# incorrect result.
 		import_events("test/data/twenty_events.js", self)
 		result = self.findEventIdsAndWait([Event.new_for_values(actor="fake://foobar")])
-		self.assertEquals(0, len(result))
+		self.assertEqual(0, len(result))
 
 	def testFindWithSubjectText(self):
 		import_events("test/data/five_events.js", self)
 		result = self.findEventIdsAndWait([Event.new_for_values(subject_text='this is not real')])
-		self.assertEquals(0, len(result))
+		self.assertEqual(0, len(result))
 		result = self.findEventIdsAndWait([Event.new_for_values(subject_text='some text')])
-		self.assertEquals(1, len(result))
+		self.assertEqual(1, len(result))
 		result = self.findEventIdsAndWait([Event.new_for_values(subject_text='this *')])
-		self.assertEquals(0, len(result)) # We don't support wildcards for text
+		self.assertEqual(0, len(result)) # We don't support wildcards for text
 		result = self.findEventIdsAndWait([Event.new_for_values(subject_text='this item *')])
-		self.assertEquals(1, len(result))
+		self.assertEqual(1, len(result))
 
 	def testSortFindByTimeAsc(self):
 		import_events("test/data/twenty_events.js", self)
@@ -181,7 +181,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			result_type=ResultType.LeastRecentEvents)
 		event1 = self.getEventsAndWait([result[0]])[0]
 		event2 = self.getEventsAndWait([result[1]])[0]
-		self.assertEquals(True, event1.timestamp < event2.timestamp)
+		self.assertEqual(True, event1.timestamp < event2.timestamp)
 
 	def testSortFindByTimeDesc(self):
 		import_events("test/data/twenty_events.js", self)
@@ -189,7 +189,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			result_type=ResultType.MostRecentEvents)
 		event1 = self.getEventsAndWait([result[0]])[0]
 		event2 = self.getEventsAndWait([result[1]])[0]
-		self.assertEquals(True, event1.timestamp > event2.timestamp)
+		self.assertEqual(True, event1.timestamp > event2.timestamp)
 
 	def testFindWithActor(self):
 		test_event_1 = parse_events("test/data/one_event.js")[0]
@@ -199,7 +199,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			actor="application://gnome-about.desktop",
 			subjects=[subj,])
 		result = self.findEventIdsAndWait([event_template], num_events=0, result_type=1)
-		self.assertEquals(1, len(result))
+		self.assertEqual(1, len(result))
 		test_event_1[0][0] = 1
 		self.assertEqual(result[0], test_event_1.id)
 
@@ -208,7 +208,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 		subj = Subject()
 		event_template = Event.new_for_values(interpretation="stfu:OpenEvent", subjects=[subj])
 		result = self.findEventIdsAndWait([event_template], num_events=0, result_type=1)
-		self.assertEquals(2, len(result))
+		self.assertEqual(2, len(result))
 		events = self.getEventsAndWait(result)
 		for event in events:
 			self.assertEqual(event.interpretation, "stfu:OpenEvent")
@@ -219,13 +219,13 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			Event.new_for_values(interpretation="stfu:OpenEvent"),
 			Event.new_for_values(interpretation="stfu:EvilEvent")],
 			timerange = (102, 117), num_events=0, result_type=0)
-		self.assertEquals(15, len(result))
+		self.assertEqual(15, len(result))
 
 	def testFindWithFakeInterpretation(self):
 		import_events("test/data/twenty_events.js", self)
 		result = self.findEventIdsAndWait([Event.new_for_values(
 			interpretation="this-is-not-an-interpretation")])
-		self.assertEquals(0, len(result))
+		self.assertEqual(0, len(result))
 
 	def testFindWithManifestation(self):
 		import_events("test/data/five_events.js", self)
@@ -234,7 +234,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 
 		result = self.findEventIdsAndWait([event_template],
 			num_events=0, result_type=1)
-		self.assertEquals(1, len(result))
+		self.assertEqual(1, len(result))
 		events = self.getEventsAndWait(result)
 		for event in events:
 			self.assertEqual(event.manifestation, "stfu:EpicFailActivity")
@@ -276,7 +276,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 		subj2 = Subject.new_for_values(uri="file:///tmp/foo.txt")
 		event_template2 = Event.new_for_values(subjects=[subj2])
 		result = self.findEventIdsAndWait([event_template1, event_template2], num_events=0, result_type=4)
-		self.assertEquals(2, len(result))
+		self.assertEqual(2, len(result))
 		events = self.getEventsAndWait(result)
 
 	def testGetWithMultipleSubjects(self):
@@ -285,9 +285,9 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 		event = new_event(subjects=[subj1, subj2])
 		result = self.insertEventsAndWait([event])
 		events = self.getEventsAndWait(result)
-		self.assertEquals(2, len(events[0].subjects))
-		self.assertEquals("file:///tmp/foo.txt", events[0].subjects[0].uri)
-		self.assertEquals("file:///tmp/loo.txt", events[0].subjects[1].uri)
+		self.assertEqual(2, len(events[0].subjects))
+		self.assertEqual("file:///tmp/foo.txt", events[0].subjects[0].uri)
+		self.assertEqual("file:///tmp/loo.txt", events[0].subjects[1].uri)
 
 	def testFindEventIdsWithMultipleSubjects(self):
 		subj1 = Subject.new_for_values(uri="file:///tmp/foo.txt")
@@ -296,7 +296,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 		orig_ids = self.insertEventsAndWait([event])
 		result_ids = self.findEventIdsAndWait([Event()], num_events=0,
 			result_type=ResultType.LeastRecentEvents)
-		self.assertEquals(orig_ids, list(result_ids))
+		self.assertEqual(orig_ids, list(result_ids))
 
 	def testFindEventsEventTemplate(self):
 		import_events("test/data/five_events.js", self)
@@ -308,7 +308,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			timerange = (0, 200),
 			num_events=100,
 			result_type=0)
-		self.assertEquals(0, len(result)) # no subject with two different
+		self.assertEqual(0, len(result)) # no subject with two different
 										  # interpretations at the same time
 		subj = Subject.new_for_values(uri="file:///tmp/foo.txt")
 		subj1 = Subject.new_for_values(interpretation="stfu:Image")
@@ -318,27 +318,27 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			timerange = (0, 200),
 			num_events=100,
 			result_type=0)
-		self.assertEquals(1, len(result))
+		self.assertEqual(1, len(result))
 
 	def testJsonImport(self):
 		import_events("test/data/single_event.js", self)
 		results = self.getEventsAndWait([1])
-		self.assertEquals(1, len(results))
+		self.assertEqual(1, len(results))
 		ev = results[0]
-		self.assertEquals(1, ev.id)
-		self.assertEquals("123", ev.timestamp)
-		self.assertEquals("stfu:OpenEvent", ev.interpretation)
-		self.assertEquals("stfu:UserActivity", ev.manifestation)
-		self.assertEquals("firefox", ev.actor)
-		self.assertEquals(1, len(ev.subjects))
+		self.assertEqual(1, ev.id)
+		self.assertEqual("123", ev.timestamp)
+		self.assertEqual("stfu:OpenEvent", ev.interpretation)
+		self.assertEqual("stfu:UserActivity", ev.manifestation)
+		self.assertEqual("firefox", ev.actor)
+		self.assertEqual(1, len(ev.subjects))
 
 		subj = ev.subjects[0]
-		self.assertEquals("file:///tmp/foo.txt", subj.uri)
-		self.assertEquals("stfu:Document", subj.interpretation)
-		self.assertEquals("stfu:File", subj.manifestation)
-		self.assertEquals("text/plain", subj.mimetype)
-		self.assertEquals("this item has no text... rly!", subj.text)
-		self.assertEquals("368c991f-8b59-4018-8130-3ce0ec944157", subj.storage)
+		self.assertEqual("file:///tmp/foo.txt", subj.uri)
+		self.assertEqual("stfu:Document", subj.interpretation)
+		self.assertEqual("stfu:File", subj.manifestation)
+		self.assertEqual("text/plain", subj.mimetype)
+		self.assertEqual("this item has no text... rly!", subj.text)
+		self.assertEqual("368c991f-8b59-4018-8130-3ce0ec944157", subj.storage)
 
 	def testInsertSubjectOptionalAttributes(self):
 		ev = Event.new_for_values(
@@ -356,7 +356,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 
 		ids = self.insertEventsAndWait([ev,])
 		result = self.getEventsAndWait(ids)
-		self.assertEquals(len(ids), len(result))
+		self.assertEqual(len(ids), len(result))
 
 	def testEventWithoutSubject(self):
 		ev = Event.new_for_values(timestamp=123,
@@ -364,25 +364,25 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 					manifestation=Manifestation.USER_ACTIVITY,
 					actor="Freak Mamma")
 		ids = self.insertEventsAndWait([ev,])
-		self.assertEquals(len(ids), 1)
+		self.assertEqual(len(ids), 1)
 		# event is not inserted, id == 0 means error
-		self.assertEquals(ids[0], 0)
+		self.assertEqual(ids[0], 0)
 		# check if really not events were inserted
 		ids = self.findEventIdsAndWait([ev],
 			num_events=0,
 			result_type= ResultType.MostRecentEvents)
-		self.assertEquals(len(ids), 0)
+		self.assertEqual(len(ids), 0)
 
 	def testUnicodeEventInsert(self):
 		# Insert and get a unicode event
 		ids = import_events("test/data/unicode_event.js", self)
-		self.assertEquals(len(ids), 1)
+		self.assertEqual(len(ids), 1)
 		result = self.getEventsAndWait(ids)
-		self.assertEquals(1, len(result))
+		self.assertEqual(1, len(result))
 		event = result[0]
-		self.assertEquals(1, len(event.subjects))
-		self.assertEquals(u"hällö, I'm gürmen - åge drikker øl - ☠", event.subjects[0].text)
-		self.assertEquals(u"http://live.gnome.org/☠", event.subjects[0].uri)
+		self.assertEqual(1, len(event.subjects))
+		self.assertEqual("hällö, I'm gürmen - åge drikker øl - ☠", event.subjects[0].text)
+		self.assertEqual("http://live.gnome.org/☠", event.subjects[0].uri)
 
 		# Update the event we got from the DB's timestamp and insert
 		# it again, we want to to test some ping-pong back and forth
@@ -390,20 +390,20 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 		event.timestamp = "243"
 		ids = self.insertEventsAndWait([event])
 		result = self.getEventsAndWait(ids)
-		self.assertEquals(1, len(result))
+		self.assertEqual(1, len(result))
 		event = result[0]
-		self.assertEquals(1, len(event.subjects))
-		self.assertEquals(u"hällö, I'm gürmen - åge drikker øl - ☠", event.subjects[0].text)
-		self.assertEquals(u"http://live.gnome.org/☠", event.subjects[0].uri)
+		self.assertEqual(1, len(event.subjects))
+		self.assertEqual("hällö, I'm gürmen - åge drikker øl - ☠", event.subjects[0].text)
+		self.assertEqual("http://live.gnome.org/☠", event.subjects[0].uri)
 
 		# Try and find a unicode event
 		subj = Subject.new_for_values(text="hällö, I'm gürmen - åge drikker øl - ☠",
-			origin="file:///åges_øl í", uri=u"http://live.gnome.org/☠")
+			origin="file:///åges_øl í", uri="http://live.gnome.org/☠")
 		event_template = Event.new_for_values(subjects=[subj,])
 
 		result = self.findEventIdsAndWait([event_template],
 			timerange=(0,200), num_events=100, result_type=0)
-		self.assertEquals(len(result), 1)
+		self.assertEqual(len(result), 1)
 
 	def testEventWithBinaryPayload(self):
 		event = parse_events("test/data/single_event.js")[0]
@@ -421,8 +421,8 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 
 		ids = self.insertEventsAndWait([event])
 		result = self.getEventsAndWait(ids)[0]
-		result.payload = u"".join(unicode(x) for x in result.payload)
-		self.assertEquals(event.payload, result.payload)
+		result.payload = "".join(str(x) for x in result.payload)
+		self.assertEqual(event.payload, result.payload)
 		self.assertEventsEqual(event, result)
 
 	def testQueryByParent(self):
@@ -434,8 +434,8 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents)
 
-		self.assertEquals(1, len(ids))
-		self.assertEquals(_ids, list(ids))
+		self.assertEqual(1, len(ids))
+		self.assertEqual(_ids, list(ids))
 
 	def testNegation(self):
 		import_events("test/data/five_events.js", self)
@@ -447,7 +447,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(3, len(ids))
+		self.assertEqual(3, len(ids))
 		
 		template = Event.new_for_values(
 			manifestation = "!stfu:YourActivity"
@@ -456,7 +456,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(4, len(ids))
+		self.assertEqual(4, len(ids))
 		
 		template = Event.new_for_values(
 			actor = "!firefox"
@@ -465,7 +465,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(2, len(ids))
+		self.assertEqual(2, len(ids))
 
 		template = Event.new_for_values(
 			subject_uri = "!file:///tmp/foo.txt"
@@ -474,7 +474,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(3, len(ids))
+		self.assertEqual(3, len(ids))
 
 		template = Event.new_for_values(
 			subject_interpretation = "!stfu:Document"
@@ -483,7 +483,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(4, len(ids))
+		self.assertEqual(4, len(ids))
 
 		template = Event.new_for_values(
 			subject_manifestation = "!stfu:File"
@@ -492,7 +492,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(1, len(ids))
+		self.assertEqual(1, len(ids))
 
 		template = Event.new_for_values(
 			subject_origin = "!file:///tmp"
@@ -501,7 +501,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(2, len(ids))
+		self.assertEqual(2, len(ids))
 
 		template = Event.new_for_values(
 			subject_mimetype = "!text/plain"
@@ -510,7 +510,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(2, len(ids))
+		self.assertEqual(2, len(ids))
 
 		# the next two fields do not support negation, '!' is treated as
 		# content
@@ -522,7 +522,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(0, len(ids))
+		self.assertEqual(0, len(ids))
 
 	def testNegationCombination(self):
 		import_events("test/data/five_events.js", self)
@@ -535,7 +535,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(2, len(ids))
+		self.assertEqual(2, len(ids))
 
 		template = Event.new_for_values(
 			interpretation = "!stfu:OpenEvent",
@@ -545,7 +545,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(3, len(ids))
+		self.assertEqual(3, len(ids))
 
 	def testFindStorageNotExistant(self):
 		events = [
@@ -558,7 +558,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(0, len(results))
+		self.assertEqual(0, len(results))
 
 	def testFindStorage(self):
 		events = [
@@ -571,7 +571,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(1, len(results))
+		self.assertEqual(1, len(results))
 
 	def testMoving(self):
 		import_events("test/data/five_events.js", self)
@@ -581,23 +581,23 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 		ids = self.findEventIdsAndWait([template],
 			num_events = 0,
 			result_type = ResultType.MostRecentCurrentUri)
-		self.assertEquals(2, len(ids))
+		self.assertEqual(2, len(ids))
 
 		ids = self.findEventIdsAndWait([template],
 			num_events = 0,
 			result_type = ResultType.MostRecentCurrentUri)
-		self.assertEquals(2, len(ids))
+		self.assertEqual(2, len(ids))
 
 		ids = self.findEventIdsAndWait([template],
 			num_events = 0,
 			result_type = ResultType.MostRecentEvents)
-		self.assertEquals(5, len(ids))
+		self.assertEqual(5, len(ids))
 
 		template = Event.new_for_values(subject_current_origin='file:///*')
 		ids = self.findEventIdsAndWait([template],
 			num_events = 0,
 			result_type = ResultType.MostRecentEvents)
-		self.assertEquals(4, len(ids))
+		self.assertEqual(4, len(ids))
 
 	def testWildcard(self):
 		import_events("test/data/five_events.js", self)
@@ -609,7 +609,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(2, len(ids))
+		self.assertEqual(2, len(ids))
 
 		template = Event.new_for_values(
 			actor = "!ge*"
@@ -618,7 +618,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(3, len(ids))
+		self.assertEqual(3, len(ids))
 
 		template = Event.new_for_values(
 			subject_mimetype = "text/*"
@@ -627,7 +627,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(3, len(ids))
+		self.assertEqual(3, len(ids))
 
 		template = Event.new_for_values(
 			subject_uri = "http://*"
@@ -636,7 +636,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(1, len(ids))
+		self.assertEqual(1, len(ids))
 
 		template = Event.new_for_values(
 			subject_current_uri = "http://*"
@@ -645,7 +645,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(1, len(ids))
+		self.assertEqual(1, len(ids))
 
 		template = Event.new_for_values(
 			subject_origin = "file://*"
@@ -654,7 +654,7 @@ class ZeitgeistEngineTest(testutils.RemoteTestCase):
 			num_events=10,
 			result_type=ResultType.MostRecentEvents
 		)
-		self.assertEquals(3, len(ids))
+		self.assertEqual(3, len(ids))
 
 if __name__ == "__main__":
 	testutils.run()
diff --git a/test/dbus/histogram-test.py b/test/dbus/histogram-test.py
index bd303f41..c31b06bb 100644
--- a/test/dbus/histogram-test.py
+++ b/test/dbus/histogram-test.py
@@ -1,4 +1,4 @@
-#! /usr/bin/env python
+#! /usr/bin/env python3
 # -.- coding: utf-8 -.-
 
 # histogram-test.py
@@ -91,17 +91,17 @@ class HistogramTest(RemoteTestCase):
 		ev, ev_timestamp = self._createEventOne();
 		
 		inserted_ids = self.insertEventsAndWait([ev])
-		self.assertEquals(1, len(inserted_ids))
+		self.assertEqual(1, len(inserted_ids))
 		
 		h_data = self.histogram.GetHistogramData()
-		self.assertEquals(1, len(h_data))
+		self.assertEqual(1, len(h_data))
 		
 		h_day_timestamp = h_data[0][0]
 		
 		#Check if the inserted event belong to the right day!
 		day_ev = datetime.date.fromtimestamp(ev_timestamp)
 		start_day = datetime.date.fromtimestamp(h_day_timestamp)
-		self.assertEquals(day_ev.day , start_day.day)
+		self.assertEqual(day_ev.day , start_day.day)
 
 if __name__ == "__main__":
 	unittest.main()
diff --git a/test/dbus/monitor-test.py b/test/dbus/monitor-test.py
index f931b293..de0babef 100644
--- a/test/dbus/monitor-test.py
+++ b/test/dbus/monitor-test.py
@@ -1,4 +1,4 @@
-#! /usr/bin/env python
+#! /usr/bin/env python3
 # -.- coding: utf-8 -.-
 
 # remote-test.py
@@ -71,7 +71,7 @@ class ZeitgeistMonitorTest(testutils.RemoteTestCase):
 		self.client.insert_events(events)
 		mainloop.run()
 		
-		self.assertEquals(2, len(result))
+		self.assertEqual(2, len(result))
 		
 	def testMonitorInsertEventsWithSubjectTemplate(self):
 		result = []
@@ -95,7 +95,7 @@ class ZeitgeistMonitorTest(testutils.RemoteTestCase):
 		self.client.insert_events(events)
 		mainloop.run()
 		
-		self.assertEquals(1, len(result))
+		self.assertEqual(1, len(result))
 		
 	def testMonitorInsertEventsOutOfTimeRange(self):
 		result = []
@@ -119,7 +119,7 @@ class ZeitgeistMonitorTest(testutils.RemoteTestCase):
 		self.client.insert_events(events)
 		mainloop.run()
 		
-		self.assertEquals(3, len(result))
+		self.assertEqual(3, len(result))
 	
 	def testMonitorInsertEventsWithWildcardSubjectTemplate(self):
 		result = []
@@ -143,7 +143,7 @@ class ZeitgeistMonitorTest(testutils.RemoteTestCase):
 		self.client.insert_events(events)
 		mainloop.run()
 		
-		self.assertEquals(2, len(result))
+		self.assertEqual(2, len(result))
 	
 	def testMonitorInsertEventsWithNegatedSubjectTemplate(self):
 		result = []
@@ -167,7 +167,7 @@ class ZeitgeistMonitorTest(testutils.RemoteTestCase):
 		self.client.insert_events(events)
 		mainloop.run()
 		
-		self.assertEquals(4, len(result))
+		self.assertEqual(4, len(result))
 	
 	def testMonitorDeleteEvents(self):
 		result = []
@@ -176,7 +176,7 @@ class ZeitgeistMonitorTest(testutils.RemoteTestCase):
 		
 		@asyncTestMethod(mainloop)
 		def notify_insert_handler(time_range, events):
-			event_ids = map(lambda ev : ev.id, events)
+			event_ids = [ev.id for ev in events]
 			self.client.delete_events(event_ids)
 		
 		@asyncTestMethod(mainloop)
@@ -190,7 +190,7 @@ class ZeitgeistMonitorTest(testutils.RemoteTestCase):
 		self.client.insert_events(events)
 		mainloop.run()
 		
-		self.assertEquals(2, len(result))
+		self.assertEqual(2, len(result))
 	
 	def testMonitorDeleteNonExistingEvent(self):
 		result = []
@@ -206,7 +206,7 @@ class ZeitgeistMonitorTest(testutils.RemoteTestCase):
 
 		@asyncTestMethod(mainloop)
 		def notify_insert_handler(time_range, events):
-			event_ids = map(lambda ev : ev.id, events)
+			event_ids = [ev.id for ev in events]
 			self.client.delete_events([9999999])
 		
 		@asyncTestMethod(mainloop)
@@ -234,7 +234,7 @@ class ZeitgeistMonitorTest(testutils.RemoteTestCase):
 
 		@asyncTestMethod(mainloop)
 		def notify_insert_handler1(time_range, events):
-			event_ids = map(lambda ev : ev.id, events)
+			event_ids = [ev.id for ev in events]
 			self.client.delete_events(event_ids)
 		
 		@asyncTestMethod(mainloop)
@@ -256,8 +256,8 @@ class ZeitgeistMonitorTest(testutils.RemoteTestCase):
 		self.client.insert_events(events)
 		mainloop.run()
 		
-		self.assertEquals(2, len(result1))
-		self.assertEquals(2, len(result2))
+		self.assertEqual(2, len(result1))
+		self.assertEqual(2, len(result2))
 
 	def testMonitorInstallRemoval(self):
 		result = []
@@ -283,8 +283,8 @@ class ZeitgeistMonitorTest(testutils.RemoteTestCase):
 		
 		self.client.remove_monitor(mon, removed_handler)
 		mainloop.run()
-		self.assertEquals(1, len(result))
-		self.assertEquals(1, result.pop())
+		self.assertEqual(1, len(result))
+		self.assertEqual(1, result.pop())
 
 	def testMonitorReconnection(self):
 		result = []
@@ -313,7 +313,7 @@ class ZeitgeistMonitorTest(testutils.RemoteTestCase):
 
 		mainloop.run()
 		
-		self.assertEquals(3, len(result))
+		self.assertEqual(3, len(result))
 
 if __name__ == "__main__":
 	unittest.main()
diff --git a/test/dbus/remote-test.py b/test/dbus/remote-test.py
index 4b2d1632..fdfdc5ab 100644
--- a/test/dbus/remote-test.py
+++ b/test/dbus/remote-test.py
@@ -1,4 +1,4 @@
-#! /usr/bin/env python
+#! /usr/bin/env python3
 # -.- coding: utf-8 -.-
 
 # remote-test.py
@@ -38,26 +38,26 @@ class ZeitgeistRemoteAPITest(testutils.RemoteTestCase):
 		# Insert an event
 		events = parse_events("test/data/single_event.js")
 		ids = self.insertEventsAndWait(events)
-		self.assertEquals(1, len(ids))
+		self.assertEqual(1, len(ids))
 
 		# Now get it back and check it hasn't changed
 		retrieved_events = self.getEventsAndWait(ids)
-		self.assertEquals(1, len(retrieved_events))
+		self.assertEqual(1, len(retrieved_events))
 		self.assertEventsEqual(retrieved_events[0], events[0])
 
 	def testUnicodeInsert(self):
 		events = parse_events("test/data/unicode_event.js")
 		ids = self.insertEventsAndWait(events)
-		self.assertEquals(len(ids), len(events))
+		self.assertEqual(len(ids), len(events))
 		result_events = self.getEventsAndWait(ids)
-		self.assertEquals(len(ids), len(result_events))
+		self.assertEqual(len(ids), len(result_events))
 
 	def testGetEvents(self):
 		events = parse_events("test/data/five_events.js")
 		ids = self.insertEventsAndWait(events) + [1000, 2000]
 		result = self.getEventsAndWait(ids)
-		self.assertEquals(len(filter(None, result)), len(events))
-		self.assertEquals(len(filter(lambda event: event is None, result)), 2)
+		self.assertEqual(len([_f for _f in result if _f]), len(events))
+		self.assertEqual(len([event for event in result if event is None]), 2)
 
 	def testInsertAndDeleteEvent(self):
 		# Insert an event
@@ -66,12 +66,12 @@ class ZeitgeistRemoteAPITest(testutils.RemoteTestCase):
 
 		# Delete it, make sure the returned time range is correct
 		time_range = self.deleteEventsAndWait(ids)
-		self.assertEquals(time_range[0], time_range[1])
-		self.assertEquals(time_range[0], int(events[0].timestamp))
+		self.assertEqual(time_range[0], time_range[1])
+		self.assertEqual(time_range[0], int(events[0].timestamp))
 
 		# Make sure the event is gone
 		retrieved_events = self.getEventsAndWait(ids)
-		self.assertEquals(retrieved_events[0], None)
+		self.assertEqual(retrieved_events[0], None)
 
 	def testDeleteNonExistantEvent(self):
 		# Insert an event (populate the database so it isn't empty)
@@ -81,12 +81,12 @@ class ZeitgeistRemoteAPITest(testutils.RemoteTestCase):
 		# Try deleting a non-existant event
 		events = parse_events("test/data/single_event.js")
 		time_range = self.deleteEventsAndWait([int(ids[0]) + 1000])
-		self.assertEquals(time_range[0], time_range[1])
-		self.assertEquals(time_range[0], -1)
+		self.assertEqual(time_range[0], time_range[1])
+		self.assertEqual(time_range[0], -1)
 
 		# Make sure the inserted event is still there
 		retrieved_events = self.getEventsAndWait(ids)
-		self.assertEquals(1, len(retrieved_events))
+		self.assertEqual(1, len(retrieved_events))
 		self.assertEventsEqual(retrieved_events[0], events[0])
 
 	def testDeleteTwoSimilarEvents(self):
@@ -101,7 +101,7 @@ class ZeitgeistRemoteAPITest(testutils.RemoteTestCase):
 
 		# Make sure it's gone, but the second one is still there
 		retrieved_events = self.getEventsAndWait(ids)
-		self.assertEquals(retrieved_events[0], None)
+		self.assertEqual(retrieved_events[0], None)
 		self.assertEventsEqual(retrieved_events[1], event2)
 
 class ZeitgeistRemoteAPITestAdvanced(testutils.RemoteTestCase):
@@ -109,18 +109,18 @@ class ZeitgeistRemoteAPITestAdvanced(testutils.RemoteTestCase):
 	def testFindTwoOfThreeEvents(self):
 		events = parse_events("test/data/three_events.js")
 		ids = self.insertEventsAndWait(events)
-		self.assertEquals(3, len(ids))
+		self.assertEqual(3, len(ids))
 		
 		events = self.getEventsAndWait(ids)
-		self.assertEquals(3, len(events))		
+		self.assertEqual(3, len(events))
 		for event in events:
 			self.assertTrue(isinstance(event, Event))
-			self.assertEquals(Manifestation.USER_ACTIVITY, event.manifestation)
+			self.assertEqual(Manifestation.USER_ACTIVITY, event.manifestation)
 			self.assertTrue(event.actor.startswith("Boogaloo"))
 		
 		# Search for everything
 		ids = self.findEventIdsAndWait([], num_events=3)
-		self.assertEquals(3, len(ids))
+		self.assertEqual(3, len(ids))
 		
 		# Search for some specific templates
 		subj_templ1 = Subject.new_for_values(manifestation=Manifestation.FILE_DATA_OBJECT)
@@ -131,23 +131,23 @@ class ZeitgeistRemoteAPITestAdvanced(testutils.RemoteTestCase):
 					subjects=[subj_templ1, subj_templ2])
 		ids = self.findEventIdsAndWait([event_template],
 						num_events=10)
-		self.assertEquals(1, len(ids))
+		self.assertEqual(1, len(ids))
 
 	def testFindOneOfThreeEvents(self):
 		events = parse_events("test/data/three_events.js")
 		ids = self.insertEventsAndWait(events)
-		self.assertEquals(3, len(ids))
+		self.assertEqual(3, len(ids))
 		
 		events = self.getEventsAndWait(ids)
-		self.assertEquals(3, len(events))
+		self.assertEqual(3, len(events))
 		for event in events:
 			self.assertTrue(isinstance(event, Event))
-			self.assertEquals(Manifestation.USER_ACTIVITY, event.manifestation)
+			self.assertEqual(Manifestation.USER_ACTIVITY, event.manifestation)
 			self.assertTrue(event.actor.startswith("Boogaloo"))
 		
 		# Search for everything
 		ids = self.findEventIdsAndWait([], num_events=3)
-		self.assertEquals(3, len(ids))
+		self.assertEqual(3, len(ids))
 		
 		# Search for some specific templates
 		subj_templ1 = Subject.new_for_values(interpretation="!"+Interpretation.AUDIO)
@@ -158,21 +158,21 @@ class ZeitgeistRemoteAPITestAdvanced(testutils.RemoteTestCase):
 					subjects=[subj_templ1, subj_templ2])
 		ids = self.findEventIdsAndWait([event_template],
 						num_events=10)
-		self.assertEquals(1, len(ids))
+		self.assertEqual(1, len(ids))
 		events = self.getEventsAndWait(ids)
 		event = events[0]
-		self.assertEquals(event.subjects[0].interpretation, Interpretation.DOCUMENT)
+		self.assertEqual(event.subjects[0].interpretation, Interpretation.DOCUMENT)
 
 	def testFindEventsWithMultipleSubjects(self):
 		events = parse_events("test/data/three_events.js")
 		ids = self.insertEventsAndWait(events)
 
 		results = self.findEventsForTemplatesAndWait([], num_events=5)
-		self.assertEquals(3, len(results))
+		self.assertEqual(3, len(results))
 
-		self.assertEquals(len(results[2].get_subjects()), 2)
-		self.assertEquals(len(results[1].get_subjects()), 1)
-		self.assertEquals(len(results[0].get_subjects()), 1)
+		self.assertEqual(len(results[2].get_subjects()), 2)
+		self.assertEqual(len(results[1].get_subjects()), 1)
+		self.assertEqual(len(results[0].get_subjects()), 1)
 
 	def testFindEventsWithNoexpandOperator(self):
 		events = parse_events("test/data/three_events.js")
@@ -182,20 +182,20 @@ class ZeitgeistRemoteAPITestAdvanced(testutils.RemoteTestCase):
 			subject_interpretation=Interpretation.MEDIA)
 		results = self.findEventsForTemplatesAndWait([template],
 			num_events=5)
-		self.assertEquals(3, len(results))
+		self.assertEqual(3, len(results))
 
 		template = Event.new_for_values(
 			subject_interpretation='+%s' % Interpretation.MEDIA)
 		results = self.findEventsForTemplatesAndWait([template],
 			num_events=5)
-		self.assertEquals(0, len(results))
+		self.assertEqual(0, len(results))
 
 		template = Event.new_for_values(
 			subject_interpretation='+%s' % Interpretation.AUDIO)
 		results = self.findEventsForTemplatesAndWait([template],
 			num_events=5)
-		self.assertEquals(1, len(results))
-		self.assertEquals(results[0].get_subjects()[0].interpretation,
+		self.assertEqual(1, len(results))
+		self.assertEqual(results[0].get_subjects()[0].interpretation,
 			Interpretation.AUDIO)
 
 	def testFindEventsLimitWhenDuplicates(self):
@@ -206,66 +206,66 @@ class ZeitgeistRemoteAPITestAdvanced(testutils.RemoteTestCase):
 		# when some of them have multiple subjects (so more than one row
 		# with the same event id).
 		results = self.findEventsForTemplatesAndWait([], num_events=3)
-		self.assertEquals(3, len(results))
+		self.assertEqual(3, len(results))
 
 	def testInsertWithEmptySubjectInterpretationManifestation(self):
 		events = parse_events("test/data/incomplete_events.js")
 		ids = self.insertEventsAndWait(events[:3])
-		self.assertEquals(3, len(ids))
+		self.assertEqual(3, len(ids))
 
 		event = self.getEventsAndWait([ids[0]])[0]
-		self.assertEquals("Hi", event.subjects[0].manifestation)
-		self.assertEquals("", event.subjects[0].interpretation)
-		self.assertEquals("Something", event.subjects[1].manifestation)
-		self.assertEquals("", event.subjects[1].interpretation)
+		self.assertEqual("Hi", event.subjects[0].manifestation)
+		self.assertEqual("", event.subjects[0].interpretation)
+		self.assertEqual("Something", event.subjects[1].manifestation)
+		self.assertEqual("", event.subjects[1].interpretation)
 
 		event = self.getEventsAndWait([ids[1]])[0]
-		self.assertEquals(Manifestation.FILE_DATA_OBJECT, event.subjects[0].manifestation)
-		self.assertEquals(Interpretation.SOURCE_CODE, event.subjects[0].interpretation)
-		self.assertEquals(Manifestation.FILE_DATA_OBJECT, event.subjects[1].manifestation)
-		self.assertEquals("a", event.subjects[1].interpretation)
-		self.assertEquals("b", event.subjects[2].manifestation)
-		self.assertEquals(Interpretation.SOURCE_CODE, event.subjects[2].interpretation)
+		self.assertEqual(Manifestation.FILE_DATA_OBJECT, event.subjects[0].manifestation)
+		self.assertEqual(Interpretation.SOURCE_CODE, event.subjects[0].interpretation)
+		self.assertEqual(Manifestation.FILE_DATA_OBJECT, event.subjects[1].manifestation)
+		self.assertEqual("a", event.subjects[1].interpretation)
+		self.assertEqual("b", event.subjects[2].manifestation)
+		self.assertEqual(Interpretation.SOURCE_CODE, event.subjects[2].interpretation)
 		
 		event = self.getEventsAndWait([ids[2]])[0]
-		self.assertEquals("something else", event.subjects[0].manifestation)
-		self.assertEquals("#Audio", event.subjects[0].interpretation)
+		self.assertEqual("something else", event.subjects[0].manifestation)
+		self.assertEqual("#Audio", event.subjects[0].interpretation)
 
 	def testInsertWithEmptySubjectMimeType(self):
 		events = parse_events("test/data/incomplete_events.js")
 		ids = self.insertEventsAndWait([events[7]])
-		self.assertEquals(1, len(ids))
+		self.assertEqual(1, len(ids))
 		
 		event = self.getEventsAndWait([ids[0]])[0]
-		self.assertEquals(1, len(event.subjects))
+		self.assertEqual(1, len(event.subjects))
 
 		subject = event.subjects[0]
-		self.assertEquals("file:///unknown-mimetype-file", subject.uri)
-		self.assertEquals("", subject.mimetype)
-		self.assertEquals(Manifestation.FILE_DATA_OBJECT, subject.manifestation)  # FIXME
-		self.assertEquals("", subject.interpretation) # FIXME
+		self.assertEqual("file:///unknown-mimetype-file", subject.uri)
+		self.assertEqual("", subject.mimetype)
+		self.assertEqual(Manifestation.FILE_DATA_OBJECT, subject.manifestation)  # FIXME
+		self.assertEqual("", subject.interpretation) # FIXME
 
 	def testInsertIncompleteEvent(self):
 		events = parse_events("test/data/incomplete_events.js")
 
 		# Missing interpretation
 		ids = self.insertEventsAndWait([events[3]])
-		self.assertEquals(0, len(ids))
+		self.assertEqual(0, len(ids))
 
 		# Missing manifestation
 		ids = self.insertEventsAndWait([events[4]])
-		self.assertEquals(0, len(ids))
+		self.assertEqual(0, len(ids))
 
 		# Missing actor
 		ids = self.insertEventsAndWait([events[5]])
-		self.assertEquals(0, len(ids))
+		self.assertEqual(0, len(ids))
 
 	def testInsertIncompleteSubject(self):
 		events = parse_events("test/data/incomplete_events.js")
 
 		# Missing one subject URI
 		ids = self.insertEventsAndWait([events[6]])
-		self.assertEquals(0, len(ids))
+		self.assertEqual(0, len(ids))
 
 class ZeitgeistRemoteFindEventIdsTest(testutils.RemoteTestCase):
 	"""
@@ -286,172 +286,172 @@ class ZeitgeistRemoteFindEventIdsTest(testutils.RemoteTestCase):
 	def testFindEventIds(self):
 		# Retrieve all existing event IDs, make sure they are correct
 		retrieved_ids = self.findEventIdsAndWait([])
-		self.assertEquals(set(retrieved_ids), set(self.ids))
+		self.assertEqual(set(retrieved_ids), set(self.ids))
 
 	def testFindEventIdsForId(self):
 		# Retrieve events for a particular event ID 
 		template = Event([["3", "", "", "", "", ""], [], ""])
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(ids, [3])
+		self.assertEqual(ids, [3])
 
 	def testFindEventIdsForTimeRange(self):
 		# Make sure that filtering by time range we get the right ones
 		retrieved_ids = self.findEventIdsAndWait([],
 			timerange=TimeRange(133, 153))
-		self.assertEquals(retrieved_ids, [4, 2, 3]) # TS: [133, 143, 153]
+		self.assertEqual(retrieved_ids, [4, 2, 3]) # TS: [133, 143, 153]
 
 		retrieved_ids = self.findEventIdsAndWait([],
 			timerange=TimeRange(163, 163))
-		self.assertEquals(retrieved_ids, [5]) # Timestamps: [163]
+		self.assertEqual(retrieved_ids, [5]) # Timestamps: [163]
 
 	def testFindEventIdsForInterpretation(self):
 		# Retrieve events for a particular interpretation
 		template = Event.new_for_values(interpretation='stfu:OpenEvent')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(ids, [5, 1])
+		self.assertEqual(ids, [5, 1])
 
 		# Retrieve events excluding a particular interpretation
 		template = Event.new_for_values(interpretation='!stfu:OpenEvent')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(map(int, ids), [4, 2, 3])
+		self.assertEqual(list(map(int, ids)), [4, 2, 3])
 
 	def testFindEventIdsForManifestation(self):
 		# Retrieve events for a particular manifestation
 		template = Event.new_for_values(manifestation='stfu:BooActivity')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(ids, [2])
+		self.assertEqual(ids, [2])
 
 		# Retrieve events excluding a particular manifestation
 		template = Event.new_for_values(manifestation='!stfu:BooActivity')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(map(int, ids), [5, 4, 3, 1])
+		self.assertEqual(list(map(int, ids)), [5, 4, 3, 1])
 
 	def testFindEventIdsForActor(self):
 		# Retrieve events for a particular actor
 		template = Event.new_for_values(actor='gedit')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(ids, [3])
+		self.assertEqual(ids, [3])
 
 		# Retrieve events excluding a particular actor
 		template = Event.new_for_values(actor='!gedit')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(map(int, ids), [5, 4, 2, 1])
+		self.assertEqual(list(map(int, ids)), [5, 4, 2, 1])
 
 		# Retrieve events with actor matching a prefix
 		template = Event.new_for_values(actor='g*')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(map(int, ids), [2, 3])
+		self.assertEqual(list(map(int, ids)), [2, 3])
 
 	def testFindEventIdsForEventOrigin(self):
 		# Retrieve events for a particular actor
 		template = Event.new_for_values(origin='big bang')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(ids, [5, 3])
+		self.assertEqual(ids, [5, 3])
 
 		# Now let's try with wildcard and negation
 		template = Event.new_for_values(origin='!big *')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(map(int, ids), [4, 2, 1])
+		self.assertEqual(list(map(int, ids)), [4, 2, 1])
 
 	def testFindEventIdsForSubjectInterpretation(self):
 		# Retrieve events for a particular subject interpretation
 		template = Event.new_for_values(subject_interpretation='stfu:Document')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(ids, [1])
+		self.assertEqual(ids, [1])
 
 		# Retrieve events excluding a particular subject interpretation
 		template = Event.new_for_values(subject_interpretation='!stfu:Document')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(map(int, ids), [5, 4, 2, 3])
+		self.assertEqual(list(map(int, ids)), [5, 4, 2, 3])
 
 	def testFindEventIdsForSubjectManifestation(self):
 		# Retrieve events for a particular subject manifestation
 		template = Event.new_for_values(subject_manifestation='stfu:File')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(ids, [5, 4, 3, 1])
+		self.assertEqual(ids, [5, 4, 3, 1])
 
 		# Retrieve events excluding a particular subject interpretation
 		template = Event.new_for_values(subject_manifestation='!stfu:File')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(map(int, ids), [2])
+		self.assertEqual(list(map(int, ids)), [2])
 
 	def testFindEventIdsForSubjectMimeType(self):
 		# Retrieve events for a particular mime-type
 		template = Event.new_for_values(subject_mimetype='text/plain')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(ids, [4, 2, 3])
+		self.assertEqual(ids, [4, 2, 3])
 
 		# Now let's try with wildcard and negation
 		template = Event.new_for_values(subject_mimetype='!meat/*')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(map(int, ids), [5, 4, 2, 3])
+		self.assertEqual(list(map(int, ids)), [5, 4, 2, 3])
 
 	def testFindEventIdsForSubjectUri(self):
 		# Retrieve events for a particular URI
 		template = Event.new_for_values(subject_uri='file:///tmp/foo.txt')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(ids, [2, 3])
+		self.assertEqual(ids, [2, 3])
 
 		# Now let's try with wildcard...
 		template = Event.new_for_values(subject_uri='http://*')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(map(int, ids), [1])
+		self.assertEqual(list(map(int, ids)), [1])
 
 		# ... and negation
 		template = Event.new_for_values(subject_uri='!file:///tmp/foo.txt')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(map(int, ids), [5, 4, 1])
+		self.assertEqual(list(map(int, ids)), [5, 4, 1])
 
 	def testFindEventIdsForSubjectOrigin(self):
 		# Retrieve events for a particular origin
 		template = Event.new_for_values(subject_origin='file:///tmp')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(ids, [4, 2, 3])
+		self.assertEqual(ids, [4, 2, 3])
 
 		# Now let's try with wildcard and negation
 		template = Event.new_for_values(subject_origin='!file:*')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(map(int, ids), [5, 1])
+		self.assertEqual(list(map(int, ids)), [5, 1])
 
 	def testFindEventIdsForSubjectText(self):
 		# Retrieve events with a particular text
 		template = Event.new_for_values(subject_text='this item *')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(ids, [4])
+		self.assertEqual(ids, [4])
 
 	def testFindEventIdsForSubjectCurrentUri(self):
 		# Retrieve events for a particular current URI
 		template = Event.new_for_values(subject_current_uri='http://www.google.de')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(ids, [1])
+		self.assertEqual(ids, [1])
 
 		# Now let's try with wildcard and negation
 		template = Event.new_for_values(subject_current_uri='!http:*')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(map(int, ids), [5, 4, 2, 3])
+		self.assertEqual(list(map(int, ids)), [5, 4, 2, 3])
 
 	def testFindEventIdsForSubjectCurrentOrigin(self):
 		# Retrieve events for a particular current origin
 		template = Event.new_for_values(subject_current_origin='file:///tmp')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(ids, [4, 2, 3])
+		self.assertEqual(ids, [4, 2, 3])
 
 		# Now let's try with wildcard and negation
 		template = Event.new_for_values(subject_current_origin='!file:*')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(map(int, ids), [5, 1])
+		self.assertEqual(list(map(int, ids)), [5, 1])
 
 		# Now let's try with wildcard and negation
 		template = Event.new_for_values(subject_current_origin='!http:*')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(map(int, ids), [4, 2, 3])
+		self.assertEqual(list(map(int, ids)), [4, 2, 3])
 
 	def testFindEventIdsForSubjectStorage(self):
 		# Retrieve events for a particular subject storage
 		template = Event.new_for_values(subject_storage=
 			'368c991f-8b59-4018-8130-3ce0ec944157')
 		ids = self.findEventIdsAndWait([template])
-		self.assertEquals(ids, [4, 2, 3, 1])
+		self.assertEqual(ids, [4, 2, 3, 1])
 
 	def testFindEventIdsWithStorageState(self):
 		"""
@@ -463,16 +463,16 @@ class ZeitgeistRemoteFindEventIdsTest(testutils.RemoteTestCase):
 		
 		# Retrieve events with storage state "any"
 		ids = self.findEventIdsAndWait([], storage_state=StorageState.Any)
-		self.assertEquals(ids, [5, 4, 2, 3, 1])
+		self.assertEqual(ids, [5, 4, 2, 3, 1])
 		
 		# Retrieve events with storage state "available"
 		ids = self.findEventIdsAndWait([], storage_state=StorageState.Available)
-		self.assertEquals(ids, [5, 4, 2, 3, 1])
+		self.assertEqual(ids, [5, 4, 2, 3, 1])
 		
 		# Retrieve events with storage state "not available"
 		ids = self.findEventIdsAndWait([],
 			storage_state=StorageState.NotAvailable)
-		self.assertEquals(ids, [5, 4, 2, 3, 1])
+		self.assertEqual(ids, [5, 4, 2, 3, 1])
 
 	def testFindEventIdsWithUnknownStorageState(self):
 		"""
@@ -488,7 +488,7 @@ class ZeitgeistRemoteFindEventIdsTest(testutils.RemoteTestCase):
 
 		tmpl = Event.new_for_values(subject_uri='file:///i-am-unknown')
 		ids = self.findEventIdsAndWait([tmpl], storage_state=StorageState.Available)
-		self.assertEquals(ids, [6])
+		self.assertEqual(ids, [6])
 
 class ZeitgeistRemoteInterfaceTest(testutils.RemoteTestCase):
 
diff --git a/test/dbus/result-types-test.py b/test/dbus/result-types-test.py
index dbae9fe0..22fc30f9 100644
--- a/test/dbus/result-types-test.py
+++ b/test/dbus/result-types-test.py
@@ -1,4 +1,4 @@
-#! /usr/bin/env python
+#! /usr/bin/env python3
 # -.- coding: utf-8 -.-
 
 # result-types-test.py
@@ -43,7 +43,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 				reverse=True
 			)
 		]
-		self.assertEquals(list(ids), sorted_event_ids)
+		self.assertEqual(list(ids), sorted_event_ids)
 
 	def testResultTypesLeastRecentEvents(self):
 		import_events("test/data/five_events.js", self)
@@ -57,7 +57,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			event.id for event in sorted(events,
 				cmp=lambda x, y: cmp(int(x.timestamp), int(y.timestamp)))
 		]
-		self.assertEquals(list(ids), sorted_event_ids)
+		self.assertEqual(list(ids), sorted_event_ids)
 
 	def testResultTypesMostPopularActor(self):
 		import_events("test/data/twenty_events.js", self)
@@ -66,9 +66,9 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			num_events = 0,
 			result_type = ResultType.MostPopularActor)
 		events = self.getEventsAndWait(ids)
-		self.assertEquals([e[0][4] for e in events], ["firefox", "icedove",
+		self.assertEqual([e[0][4] for e in events], ["firefox", "icedove",
 			"frobnicator"])
-		self.assertEquals([e.timestamp for e in events], ["119", "114", "105"])
+		self.assertEqual([e.timestamp for e in events], ["119", "114", "105"])
 
 	def testResultTypesMostPopularActor2(self):
 		import_events("test/data/twenty_events.js", self)
@@ -78,9 +78,9 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			num_events = 0,
 			result_type = ResultType.MostPopularActor)
 		events = self.getEventsAndWait(ids)
-		self.assertEquals(len(events), 2)
-		self.assertEquals([e[0][4] for e in events], ["firefox", "frobnicator"])
-		self.assertEquals([e.timestamp for e in events], ["107", "105"])
+		self.assertEqual(len(events), 2)
+		self.assertEqual([e[0][4] for e in events], ["firefox", "frobnicator"])
+		self.assertEqual([e.timestamp for e in events], ["107", "105"])
 
 	def testResultTypesLeastPopularActor(self):
 		import_events("test/data/twenty_events.js", self)
@@ -90,9 +90,9 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.LeastPopularActor)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e[0][4] for e in events], ["frobnicator", "icedove",
+		self.assertEqual([e[0][4] for e in events], ["frobnicator", "icedove",
 			"firefox"])
-		self.assertEquals([e.timestamp for e in events], ["105", "114", "119"])
+		self.assertEqual([e.timestamp for e in events], ["105", "114", "119"])
 
 	def testResultTypesLeastPopularActor2(self):
 		import_events("test/data/twenty_events.js", self)
@@ -103,9 +103,9 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.LeastPopularActor)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals(len(events), 2)
-		self.assertEquals([e[0][4] for e in events], ["frobnicator", "firefox"])
-		self.assertEquals([e.timestamp for e in events], ["105", "107"])
+		self.assertEqual(len(events), 2)
+		self.assertEqual([e[0][4] for e in events], ["frobnicator", "firefox"])
+		self.assertEqual([e.timestamp for e in events], ["105", "107"])
 
 	def testResultTypesMostRecentSubject(self):
 		import_events("test/data/five_events.js", self)
@@ -115,7 +115,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.MostRecentSubjects)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events],
+		self.assertEqual([e.timestamp for e in events],
 			["163", "153", "143", "123"])
 
 	def testResultTypesLeastRecentSubject(self):
@@ -125,7 +125,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			num_events = 0,
 			result_type = ResultType.LeastRecentSubjects)
 		events = self.getEventsAndWait(ids)
-		self.assertEquals([e.timestamp for e in events],
+		self.assertEqual([e.timestamp for e in events],
 			["123", "143", "153", "163"])
 
 	def testResultTypesMostPopularSubject(self):
@@ -135,7 +135,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			num_events = 0,
 			result_type = ResultType.MostPopularSubjects)
 		events = self.getEventsAndWait(ids)
-		self.assertEquals([e.timestamp for e in events],
+		self.assertEqual([e.timestamp for e in events],
 			["143", "163", "153", "123"])
 
 	def testResultTypesLeastPopularSubject(self):
@@ -146,7 +146,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.LeastPopularSubjects)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events],
+		self.assertEqual([e.timestamp for e in events],
 			["123", "153", "163", "143"])
 
 	def testResultTypesMostRecentCurrentUri(self):
@@ -158,7 +158,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.MostRecentCurrentUri)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events],
+		self.assertEqual([e.timestamp for e in events],
 			["200", "153", "123"])
 
 	def testResultTypesLeastRecentCurrentUri(self):
@@ -169,7 +169,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			num_events = 0,
 			result_type = ResultType.LeastRecentCurrentUri)
 		events = self.getEventsAndWait(ids)
-		self.assertEquals([e.timestamp for e in events],
+		self.assertEqual([e.timestamp for e in events],
 			["123", "153", "200"])
 
 	def testResultTypesMostPopularCurrentUri(self):
@@ -180,7 +180,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			num_events = 0,
 			result_type = ResultType.MostPopularCurrentUri)
 		events = self.getEventsAndWait(ids)
-		self.assertEquals([e.timestamp for e in events],
+		self.assertEqual([e.timestamp for e in events],
 			["200", "123", "153"])
 
 	def testResultTypesLeastPopularCurrentUri(self):
@@ -191,7 +191,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			num_events = 0,
 			result_type = ResultType.LeastPopularCurrentUri)
 		events = self.getEventsAndWait(ids)
-		self.assertEquals([e.timestamp for e in events],
+		self.assertEqual([e.timestamp for e in events],
 			["153", "123", "200"])
 
 	def testResultTypesMostRecentCurrentOrigin(self):
@@ -203,7 +203,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type=ResultType.MostRecentCurrentOrigin)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events],
+		self.assertEqual([e.timestamp for e in events],
 			["200", "163", "153", "123"])
 
 	def testResultTypesLeastRecentCurrentOrigin(self):
@@ -214,7 +214,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			num_events=0,
 			result_type=ResultType.LeastRecentCurrentOrigin)
 		events = self.getEventsAndWait(ids)
-		self.assertEquals([e.timestamp for e in events],
+		self.assertEqual([e.timestamp for e in events],
 			["123", "153", "163", "200"])
 
 	def testResultTypesMostPopularCurrentOrigin(self):
@@ -225,7 +225,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			num_events=0,
 			result_type=ResultType.MostPopularCurrentOrigin)
 		events = self.getEventsAndWait(ids)
-		self.assertEquals([e.timestamp for e in events],
+		self.assertEqual([e.timestamp for e in events],
 			["200", "123", "163", "153"])
 
 	def testResultTypesLeastPopularCurrentOrigin(self):
@@ -236,7 +236,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			num_events=0,
 			result_type=ResultType.LeastPopularCurrentOrigin)
 		events = self.getEventsAndWait(ids)
-		self.assertEquals([e.timestamp for e in events],
+		self.assertEqual([e.timestamp for e in events],
 			["153", "163", "123", "200"])
 
 	def testResultTypesMostRecentActor(self):
@@ -247,7 +247,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.MostRecentActor)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ["119", "114", "105"])
+		self.assertEqual([e.timestamp for e in events], ["119", "114", "105"])
 
 	def testResultTypesMostRecentActor2(self):
 		import_events("test/data/twenty_events.js", self)
@@ -258,7 +258,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.MostRecentActor)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ["107", "105"])
+		self.assertEqual([e.timestamp for e in events], ["107", "105"])
 
 	def testResultTypesOldestActorBug641968(self):
 		events = [
@@ -274,14 +274,14 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			num_events = 0,
 			result_type = ResultType.OldestActor)
 		events = self.getEventsAndWait(ids)
-		self.assertEquals(list(ids), [1, 3, 4])
+		self.assertEqual(list(ids), [1, 3, 4])
 
 		# Get the least recent actors for "home/boo"
 		template = Event.new_for_values(subject_uri="home/boo")
 		ids = self.findEventIdsAndWait([template],
 			num_events = 0,
 			result_type = ResultType.OldestActor)
-		self.assertEquals(list(ids), [2])
+		self.assertEqual(list(ids), [2])
 
 		# Let's also try the same with MostRecentActor... Although there
 		# should be no problem here.
@@ -289,7 +289,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 		ids = self.findEventIdsAndWait([template],
 			num_events = 0,
 			result_type = ResultType.OldestActor)
-		self.assertEquals(list(ids), [2])
+		self.assertEqual(list(ids), [2])
 
 	def testResultTypesOldestActor(self):
 		import_events("test/data/twenty_events.js", self)
@@ -299,7 +299,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			num_events = 0,
 			result_type = ResultType.OldestActor)
 		events = self.getEventsAndWait(ids)
-		self.assertEquals([e.timestamp for e in events], ["100", "101", "105"])
+		self.assertEqual([e.timestamp for e in events], ["100", "101", "105"])
 
 	def testResultTypesLeastRecentActor(self):
 		import_events("test/data/twenty_events.js", self)
@@ -310,7 +310,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.LeastRecentActor)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ['105', '114', '119'])
+		self.assertEqual([e.timestamp for e in events], ['105', '114', '119'])
 
 	def testResultTypesLeastRecentActor2(self):
 		# The same test as before, but this time with fewer events so that
@@ -327,7 +327,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			num_events = 0,
 			result_type = ResultType.LeastRecentActor)
 		recv_events = self.getEventsAndWait(ids)
-		self.assertEquals([e.timestamp for e in recv_events], ['3', '4'])
+		self.assertEqual([e.timestamp for e in recv_events], ['3', '4'])
 
 	def testResultTypesMostPopularEventOrigin(self):
 		import_events("test/data/twenty_events.js", self)
@@ -337,9 +337,9 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.MostPopularEventOrigin)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e[0][5] for e in events],
+		self.assertEqual([e[0][5] for e in events],
 			["origin1", "origin3", "origin2"])
-		self.assertEquals([e.timestamp for e in events], ["102", "103", "100"])
+		self.assertEqual([e.timestamp for e in events], ["102", "103", "100"])
 
 	def testResultTypesLeastPopularEventOrigin(self):
 		import_events("test/data/twenty_events.js", self)
@@ -349,9 +349,9 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.LeastPopularEventOrigin)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e[0][5] for e in events],
+		self.assertEqual([e[0][5] for e in events],
 			["origin2", "origin3", "origin1"])
-		self.assertEquals([e.timestamp for e in events], ["100", "103", "102"])
+		self.assertEqual([e.timestamp for e in events], ["100", "103", "102"])
 
 	def testResultTypesMostRecentEventOrigin(self):
 		import_events("test/data/twenty_events.js", self)
@@ -361,7 +361,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.MostRecentEventOrigin)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ["103", "102", "100"])
+		self.assertEqual([e.timestamp for e in events], ["103", "102", "100"])
 
 	def testResultTypesLeastRecentEventOrigin(self):
 		import_events("test/data/twenty_events.js", self)
@@ -371,7 +371,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.LeastRecentEventOrigin)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ["100", "102", "103"])
+		self.assertEqual([e.timestamp for e in events], ["100", "102", "103"])
 
 	def testResultTypesMostPopularSubjectOrigin(self):
 		import_events("test/data/twenty_events.js", self)
@@ -381,9 +381,9 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.MostPopularOrigin)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e[1][0][3] for e in events], ["file:///tmp", "file:///home",
+		self.assertEqual([e[1][0][3] for e in events], ["file:///tmp", "file:///home",
 			"file:///etc"])
-		self.assertEquals([e.timestamp for e in events], ["116", "118", "119"])
+		self.assertEqual([e.timestamp for e in events], ["116", "118", "119"])
 
 	def testResultTypesLeastPopularSubjectOrigin(self):
 		import_events("test/data/twenty_events.js", self)
@@ -393,9 +393,9 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.LeastPopularOrigin)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e[1][0][3] for e in events], ["file:///etc", "file:///home",
+		self.assertEqual([e[1][0][3] for e in events], ["file:///etc", "file:///home",
 			"file:///tmp"])
-		self.assertEquals([e.timestamp for e in events], ["119", "118", "116"])
+		self.assertEqual([e.timestamp for e in events], ["119", "118", "116"])
 
 	def testResultTypesMostRecentSubjectOrigin(self):
 		import_events("test/data/twenty_events.js", self)
@@ -405,7 +405,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.MostRecentOrigin)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ["119", "118", "116"])
+		self.assertEqual([e.timestamp for e in events], ["119", "118", "116"])
 
 	def testResultTypesLeastRecentSubjectOrigin(self):
 		import_events("test/data/twenty_events.js", self)
@@ -415,7 +415,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.LeastRecentOrigin)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ["116", "118", "119"])
+		self.assertEqual([e.timestamp for e in events], ["116", "118", "119"])
 
 	def testResultTypesMostRecentMimeType(self):
 		import_events("test/data/twenty_events.js", self)
@@ -425,7 +425,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.MostRecentMimeType)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ['119', '114', '110', '107'])
+		self.assertEqual([e.timestamp for e in events], ['119', '114', '110', '107'])
 
 	def testResultTypesLeastRecentMimeType(self):
 		import_events("test/data/twenty_events.js", self)
@@ -435,7 +435,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.LeastRecentMimeType)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ['107', '110', '114', '119'])
+		self.assertEqual([e.timestamp for e in events], ['107', '110', '114', '119'])
 
 	def testResultTypesMostPopularMimeType(self):
 		import_events("test/data/twenty_events.js", self)
@@ -445,7 +445,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.MostPopularMimeType)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ['119', '110', '107', '114'])
+		self.assertEqual([e.timestamp for e in events], ['119', '110', '107', '114'])
 
 	def testResultTypesLeastPopularMimeType(self):
 		import_events("test/data/twenty_events.js", self)
@@ -455,7 +455,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.LeastPopularMimeType)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ['114', '107', '110', '119'])
+		self.assertEqual([e.timestamp for e in events], ['114', '107', '110', '119'])
 
 	def testResultTypesMostRecentSubjectInterpretation(self):
 		import_events("test/data/twenty_events.js", self)
@@ -465,7 +465,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.MostRecentSubjectInterpretation)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ['119', '118', '116', '106'])
+		self.assertEqual([e.timestamp for e in events], ['119', '118', '116', '106'])
 
 	def testResultTypesLeastRecentSubjectInterpretation(self):
 		import_events("test/data/twenty_events.js", self)
@@ -475,7 +475,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.LeastRecentSubjectInterpretation)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ['106', '116', '118', '119'])
+		self.assertEqual([e.timestamp for e in events], ['106', '116', '118', '119'])
 
 	def testResultTypesMostPopularSubjectInterpretation(self):
 		import_events("test/data/twenty_events.js", self)
@@ -485,7 +485,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.MostPopularSubjectInterpretation)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ['119', '116', '106', '118'])
+		self.assertEqual([e.timestamp for e in events], ['119', '116', '106', '118'])
 
 	def testResultTypesLeastPopularSubjectInterpretation(self):
 		import_events("test/data/twenty_events.js", self)
@@ -495,7 +495,7 @@ class ResultTypeTest(testutils.RemoteTestCase):
 			result_type = ResultType.LeastPopularSubjectInterpretation)
 		events = self.getEventsAndWait(ids)
 
-		self.assertEquals([e.timestamp for e in events], ['118', '106', '116', '119'])
+		self.assertEqual([e.timestamp for e in events], ['118', '106', '116', '119'])
 
 if __name__ == "__main__":
 	testutils.run()
diff --git a/test/dbus/run-all-tests.py b/test/dbus/run-all-tests.py
index 386a9f97..5ee86eb4 100755
--- a/test/dbus/run-all-tests.py
+++ b/test/dbus/run-all-tests.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -.- coding: utf-8 -.-
 
 # Zeitgeist
@@ -29,15 +29,15 @@ import sys
 from optparse import OptionParser
 
 if not os.path.isfile("NEWS"):
-    print >> sys.stderr, "*** Please run from root directory."
+    print("*** Please run from root directory.", file=sys.stderr)
     raise SystemExit
 
 # Load the updated Zeitgeist Python module
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../.."))
 
 if not os.path.isdir("zeitgeist"):
-	print >> sys.stderr, "*** If you get unexpected failures, " \
-		"you may want to run: `ln -s python zeitgeist`"
+	print("*** If you get unexpected failures, " \
+		"you may want to run: `ln -s python zeitgeist`", file=sys.stderr)
 
 from testutils import RemoteTestCase
 
@@ -98,13 +98,13 @@ if __name__ == "__main__":
 	bus = DBusPrivateMessageBus()
 	err = bus.run(ignore_errors=True)
 	if err:
-		print >> sys.stderr, "*** Failed to setup private bus, error was: %s" %err
+		print("*** Failed to setup private bus, error was: %s" %err, file=sys.stderr)
 		raise SystemExit
 	else:
-		print >> sys.stderr, "*** Testsuite is running using a private dbus bus"
+		print("*** Testsuite is running using a private dbus bus", file=sys.stderr)
 		config = bus.dbus_config.copy()
 		config.update({"DISPLAY": bus.DISPLAY, "pid.Xvfb": bus.display.pid})
-		print >> sys.stderr, "*** Configuration: %s" %config
+		print("*** Configuration: %s" %config, file=sys.stderr)
 	try:
 		os.environ["ZEITGEIST_DEFAULT_EXTENSIONS"] = \
 			"_zeitgeist.engine.extensions.blacklist.Blacklist," \
diff --git a/test/dbus/testutils.py b/test/dbus/testutils.py
index f2e3a903..8d48db3b 100644
--- a/test/dbus/testutils.py
+++ b/test/dbus/testutils.py
@@ -77,7 +77,7 @@ def dict2event(d):
 	
 def parse_events(path):
 	data = json.load(file(path))
-	events = map(dict2event, data)
+	events = list(map(dict2event, data))
 	return events
 
 def import_events(path, engine):
@@ -108,7 +108,7 @@ def complete_event(event):
 	return event
 
 def complete_events(events):
-	return map(complete_event, events)
+	return list(map(complete_event, events))
 
 def new_event(*args, **kwargs):
 	"""
@@ -125,9 +125,9 @@ def asyncTestMethod(mainloop):
 		def new_f(*args, **kwargs):
 			try:
 				f(*args, **kwargs)
-			except AssertionError, e:
+			except AssertionError as e:
 				mainloop.fail("Assertion failed: %s" % e)
-			except Exception, e:
+			except Exception as e:
 				mainloop.fail("Unexpected exception: %s" % e)
 		return new_f
 	return wrap
@@ -220,8 +220,8 @@ class RemoteTestCase (unittest.TestCase):
 		get_bus().close()
 		self.kill_daemon()
 		if 'ZEITGEIST_TESTS_KEEP_TMP' in os.environ:
-			print '\n\nAll temporary files have been preserved in %s\n' \
-				% self.datapath
+			print('\n\nAll temporary files have been preserved in %s\n' \
+				% self.datapath)
 		else:
 			shutil.rmtree(self.datapath)
 	
@@ -385,7 +385,7 @@ class RemoteTestCase (unittest.TestCase):
 				assert self.failed is False
 				self._mainloop.run()
 				if self.failed:
-					raise AssertionError, self.failure_message
+					raise AssertionError(self.failure_message)
 		
 		mainloop = MainLoopWithFailure()
 		if timeout is not None:
@@ -413,11 +413,11 @@ class RemoteTestCase (unittest.TestCase):
 			if not subject.current_origin:
 				subject.current_origin = subject.origin
 		popo = []
-		popo.append(map(unicode, ev[0]))
-		popo.append([map(unicode, subj) for subj in ev[1]])
+		popo.append(list(map(str, ev[0])))
+		popo.append([list(map(str, subj)) for subj in ev[1]])
 		# We need the check here so that if D-Bus gives us an empty
 		# byte array we don't serialize the text "dbus.Array(...)".
-		popo.append(str(ev[2]) if ev[2] else u'')
+		popo.append(str(ev[2]) if ev[2] else '')
 		return popo
 	
 	def assertEventsEqual(self, ev1, ev2):
@@ -453,7 +453,7 @@ class DBusPrivateMessageBus(object):
 	def run(self, ignore_errors=False):
 		try:
 			return self._run()
-		except Exception, e:
+		except Exception as e:
 			if ignore_errors:
 				return e
 			raise
@@ -471,7 +471,7 @@ class DBusPrivateMessageBus(object):
 	def quit(self, ignore_errors=False):
 		try:
 			return self._quit()
-		except Exception, e:
+		except Exception as e:
 			if ignore_errors:
 				return e
 			raise
diff --git a/test/dbus/upgrade-test.py b/test/dbus/upgrade-test.py
index 1c16d026..6e9a7b3c 100644
--- a/test/dbus/upgrade-test.py
+++ b/test/dbus/upgrade-test.py
@@ -1,4 +1,4 @@
-#! /usr/bin/env python
+#! /usr/bin/env python3
 # -.- coding: utf-8 -.-
 
 # upgrade-test.py
@@ -54,53 +54,53 @@ class ZeitgeistUpgradeTest(testutils.RemoteTestCase):
         original_events = parse_events("test/data/upgrade_test.js")
 
         # Ensure no events got lost (or duplicated)
-        self.assertEquals(len(events), len(original_events))
+        self.assertEqual(len(events), len(original_events))
 
         # Ensure no subjects got lost
         for i in range(len(events)):
-            self.assertEquals(len(events[i].subjects),
+            self.assertEqual(len(events[i].subjects),
                               len(original_events[i].subjects))
 
         # Ensure data didn't change (unless it should)
         for i in range(len(events)):
             a = events[i]
             b = original_events[i]
-            self.assertEquals(a.timestamp, b.timestamp)
-            self.assertEquals(a.interpretation, b.interpretation)
-            self.assertEquals(a.manifestation, b.manifestation)
-            self.assertEquals(a.actor, b.actor)
+            self.assertEqual(a.timestamp, b.timestamp)
+            self.assertEqual(a.interpretation, b.interpretation)
+            self.assertEqual(a.manifestation, b.manifestation)
+            self.assertEqual(a.actor, b.actor)
             for j in range(len(a.subjects)):
                 sa = a.subjects[j]
                 sb = b.subjects[j]
-                self.assertEquals(sa.uri, sb.uri)
-                self.assertEquals(sa.interpretation, sb.interpretation)
+                self.assertEqual(sa.uri, sb.uri)
+                self.assertEqual(sa.interpretation, sb.interpretation)
                 if not sa.uri.startswith("http://"):
-                    self.assertEquals(sa.manifestation, sb.manifestation)
-                self.assertEquals(sa.origin, sb.origin)
-                self.assertEquals(sa.mimetype, sb.mimetype)
-                self.assertEquals(sa.text, sb.text)
-                self.assertEquals(sa.storage, sb.storage)
+                    self.assertEqual(sa.manifestation, sb.manifestation)
+                self.assertEqual(sa.origin, sb.origin)
+                self.assertEqual(sa.mimetype, sb.mimetype)
+                self.assertEqual(sa.text, sb.text)
+                self.assertEqual(sa.storage, sb.storage)
 
         # Introduced in Zeitgeist 0.8.0:
         #  - event.origin
         #  - subject.current_uri
         for event in events:
-            self.assertEquals(event.origin, "")
+            self.assertEqual(event.origin, "")
             for subject in event.subjects:
-                self.assertEquals(subject.current_uri, subject.uri)
+                self.assertEqual(subject.current_uri, subject.uri)
 
         # Introduced in Bluebird Alpha 2:
         #  - WebDataObject
         for event in events:
             for subject in event.subjects:
                 if subject.uri.startswith("http://"):
-                    self.assertEquals(subject.manifestation, Manifestation.WEB_DATA_OBJECT)
+                    self.assertEqual(subject.manifestation, Manifestation.WEB_DATA_OBJECT)
 
         # Introduced in Zeitgeist 1.0 Beta 1
         #  - subject.current_origin
         for event in events:
             for subject in event.subjects:
-                self.assertEquals(subject.current_origin, subject.origin)
+                self.assertEqual(subject.current_origin, subject.origin)
 
     def testUpgradeFrom071(self):
         self.prepare("071")