Update constants, namespaces, and servicetest from Gabble.

I tried to update gabbletest too, but it's changed in ways that break
haze. So I've left that for now.

3 files changed, 230 insertions, 57 deletions

diff --git a/tests/twisted/constants.py b/tests/twisted/constants.py
index 8528c47..1d2edf8 100644
--- a/tests/twisted/constants.py
+++ b/tests/twisted/constants.py
@@ -17,6 +17,7 @@ CHANNEL = "org.freedesktop.Telepathy.Channel"
 CHANNEL_IFACE_CALL_STATE = CHANNEL + ".Interface.CallState"
 CHANNEL_IFACE_CHAT_STATE = CHANNEL + '.Interface.ChatState'
 CHANNEL_IFACE_DESTROYABLE = CHANNEL + ".Interface.Destroyable"
+CHANNEL_IFACE_DTMF = CHANNEL + ".Interface.DTMF"
 CHANNEL_IFACE_GROUP = CHANNEL + ".Interface.Group"
 CHANNEL_IFACE_HOLD = CHANNEL + ".Interface.Hold"
 CHANNEL_IFACE_MEDIA_SIGNALLING = CHANNEL + ".Interface.MediaSignalling"
@@ -24,10 +25,11 @@ CHANNEL_IFACE_MESSAGES = CHANNEL + ".Interface.Messages"
 CHANNEL_IFACE_PASSWORD = CHANNEL + ".Interface.Password"
 CHANNEL_IFACE_TUBE = CHANNEL + ".Interface.Tube"
 CHANNEL_IFACE_SASL_AUTH = CHANNEL + ".Interface.SaslAuthentication.DRAFT"
+CHANNEL_IFACE_CONFERENCE = CHANNEL + '.Interface.Conference'
 
 CHANNEL_TYPE_CALL = CHANNEL + ".Type.Call.DRAFT"
 CHANNEL_TYPE_CONTACT_LIST = CHANNEL + ".Type.ContactList"
-CHANNEL_TYPE_CONTACT_SEARCH = CHANNEL + ".Type.ContactSearch.DRAFT2"
+CHANNEL_TYPE_CONTACT_SEARCH = CHANNEL + ".Type.ContactSearch"
 CHANNEL_TYPE_TEXT = CHANNEL + ".Type.Text"
 CHANNEL_TYPE_TUBES = CHANNEL + ".Type.Tubes"
 CHANNEL_TYPE_STREAM_TUBE = CHANNEL + ".Type.StreamTube"
@@ -37,6 +39,8 @@ CHANNEL_TYPE_TEXT = CHANNEL + ".Type.Text"
 CHANNEL_TYPE_FILE_TRANSFER = CHANNEL + ".Type.FileTransfer"
 CHANNEL_TYPE_SERVER_AUTHENTICATION = \
     CHANNEL + ".Type.ServerAuthentication.DRAFT"
+CHANNEL_TYPE_SERVER_TLS_CONNECTION = \
+    CHANNEL + ".Type.ServerTLSConnection"
 
 TP_AWKWARD_PROPERTIES = "org.freedesktop.Telepathy.Properties"
 PROPERTY_FLAG_READ = 1
@@ -97,17 +101,34 @@ CALL_SENDING_STATE_NONE = 0
 CALL_SENDING_STATE_PENDING_SEND = 1
 CALL_SENDING_STATE_SENDING = 2
 
+SUBSCRIPTION_STATE_UNKNOWN = 0
+SUBSCRIPTION_STATE_NO = 1
+SUBSCRIPTION_STATE_REMOVED_REMOTELY = 2
+SUBSCRIPTION_STATE_ASK = 3
+SUBSCRIPTION_STATE_YES = 4
+
+CONTACT_LIST_STATE_NONE = 0
+CONTACT_LIST_STATE_WAITING = 1
+CONTACT_LIST_STATE_FAILURE = 2
+CONTACT_LIST_STATE_SUCCESS = 3
+
 CONN = "org.freedesktop.Telepathy.Connection"
 CONN_IFACE_AVATARS = CONN + '.Interface.Avatars'
+CONN_IFACE_ALIASING = CONN + '.Interface.Aliasing'
 CONN_IFACE_CAPS = CONN + '.Interface.Capabilities'
 CONN_IFACE_CONTACTS = CONN + '.Interface.Contacts'
 CONN_IFACE_CONTACT_CAPS = CONN + '.Interface.ContactCapabilities'
 CONN_IFACE_CONTACT_INFO = CONN + ".Interface.ContactInfo"
+CONN_IFACE_PRESENCE = CONN + '.Interface.Presence'
 CONN_IFACE_SIMPLE_PRESENCE = CONN + '.Interface.SimplePresence'
 CONN_IFACE_REQUESTS = CONN + '.Interface.Requests'
 CONN_IFACE_LOCATION = CONN + '.Interface.Location'
 CONN_IFACE_GABBLE_DECLOAK = CONN + '.Interface.Gabble.Decloak'
-CONN_IFACE_MAIL_NOTIFICATION = CONN + '.Interface.MailNotification.DRAFT'
+CONN_IFACE_MAIL_NOTIFICATION = CONN + '.Interface.MailNotification'
+CONN_IFACE_CONTACT_LIST = CONN + '.Interface.ContactList'
+CONN_IFACE_CONTACT_GROUPS = CONN + '.Interface.ContactGroups'
+CONN_IFACE_CLIENT_TYPES = CONN + '.Interface.ClientTypes'
+CONN_IFACE_POWER_SAVING = CONN + '.Interface.PowerSaving'
 
 ATTR_CONTACT_CAPABILITIES = CONN_IFACE_CONTACT_CAPS + '/capabilities'
 
@@ -127,6 +148,13 @@ CANCELLED = ERROR + '.Cancelled'
 DISCONNECTED = ERROR + '.Disconnected'
 REGISTRATION_EXISTS = ERROR + '.RegistrationExists'
 AUTHENTICATION_FAILED = ERROR + '.AuthenticationFailed'
+CONNECTION_REPLACED = ERROR + '.ConnectionReplaced'
+ALREADY_CONNECTED = ERROR + '.AlreadyConnected'
+NETWORK_ERROR = ERROR + '.NetworkError'
+NOT_YET = ERROR + '.NotYet'
+INVALID_HANDLE = ERROR + '.InvalidHandle'
+CERT_UNTRUSTED = ERROR + '.Cert.Untrusted'
+SERVICE_BUSY = ERROR + '.ServiceBusy'
 
 UNKNOWN_METHOD = 'org.freedesktop.DBus.Error.UnknownMethod'
 
@@ -138,6 +166,10 @@ DBUS_TUBE_DBUS_NAMES = CHANNEL_TYPE_DBUS_TUBE + '.DBusNames'
 DBUS_TUBE_SUPPORTED_ACCESS_CONTROLS = CHANNEL_TYPE_DBUS_TUBE + '.SupportedAccessControls'
 STREAM_TUBE_SUPPORTED_SOCKET_TYPES = CHANNEL_TYPE_STREAM_TUBE + '.SupportedSocketTypes'
 
+CONFERENCE_INITIAL_CHANNELS = CHANNEL_IFACE_CONFERENCE + '.InitialChannels'
+CONFERENCE_INITIAL_INVITEE_HANDLES = CHANNEL_IFACE_CONFERENCE + '.InitialInviteeHandles'
+CONFERENCE_INITIAL_INVITEE_IDS = CHANNEL_IFACE_CONFERENCE + '.InitialInviteeIDs'
+
 CONTACT_SEARCH_ASK = CHANNEL_TYPE_CONTACT_SEARCH + '.AvailableSearchKeys'
 CONTACT_SEARCH_SERVER = CHANNEL_TYPE_CONTACT_SEARCH + '.Server'
 CONTACT_SEARCH_STATE = CHANNEL_TYPE_CONTACT_SEARCH + '.SearchState'
@@ -338,6 +370,10 @@ AUTH_METHOD = CHANNEL_TYPE_SERVER_AUTHENTICATION + ".AuthenticationMethod"
 AUTH_INFO = CHANNEL_TYPE_SERVER_AUTHENTICATION + ".AuthenticationInformation"
 SASL_AVAILABLE_MECHANISMS = CHANNEL_IFACE_SASL_AUTH + ".AvailableMechanisms"
 
+# Channel_Type_ServerTLSConnection
+TLS_CERT_PATH = CHANNEL_TYPE_SERVER_TLS_CONNECTION + ".ServerCertificate"
+TLS_HOSTNAME = CHANNEL_TYPE_SERVER_TLS_CONNECTION + ".Hostname"
+
 # Connection.Interface.Location
 
 LOCATION_FEATURE_CAN_SET = 1
@@ -356,3 +392,28 @@ PARAM_REGISTER = 2
 PARAM_HAS_DEFAULT = 4
 PARAM_SECRET = 8
 PARAM_DBUS_PROPERTY = 16
+
+AUTHENTICATION = 'org.freedesktop.Telepathy.Authentication'
+AUTH_TLS_CERT = AUTHENTICATION + ".TLSCertificate"
+
+TLS_CERT_STATE_PENDING = 0
+TLS_CERT_STATE_ACCEPTED = 1
+TLS_CERT_STATE_REJECTED = 2
+
+TLS_REJECT_REASON_UNKNOWN = 0
+TLS_REJECT_REASON_UNTRUSTED = 1
+
+# Channel.Interface.Messages
+
+MESSAGE_PART_SUPPORT_FLAGS = CHANNEL_IFACE_MESSAGES + '.MessagePartSupportFlags'
+DELIVERY_REPORTING_SUPPORT = CHANNEL_IFACE_MESSAGES + '.DeliveryReportingSupport'
+SUPPORTED_CONTENT_TYPES = CHANNEL_IFACE_MESSAGES + '.SupportedContentTypes'
+
+MSG_SENDING_FLAGS_REPORT_DELIVERY = 1
+MSG_SENDING_FLAGS_REPORT_READ = 2
+MSG_SENDING_FLAGS_REPORT_DELETED = 4
+
+DELIVERY_REPORTING_SUPPORT_FLAGS_RECEIVE_FAILURES = 1
+DELIVERY_REPORTING_SUPPORT_FLAGS_RECEIVE_SUCCESSES = 2
+DELIVERY_REPORTING_SUPPORT_FLAGS_RECEIVE_READ = 4
+DELIVERY_REPORTING_SUPPORT_FLAGS_RECEIVE_DELETED = 8
diff --git a/tests/twisted/ns.py b/tests/twisted/ns.py
index d9b290f..a483b27 100644
--- a/tests/twisted/ns.py
+++ b/tests/twisted/ns.py
@@ -37,6 +37,9 @@ MUC_BYTESTREAM = 'http://telepathy.freedesktop.org/xmpp/protocol/muc-bytestream'
 MUC_OWNER = '%s#owner' % MUC
 MUC_USER = '%s#user' % MUC
 NICK = "http://jabber.org/protocol/nick"
+NS_XMPP_SASL = 'urn:ietf:params:xml:ns:xmpp-sasl'
+NS_XMPP_BIND = 'urn:ietf:params:xml:ns:xmpp-bind'
+NS_XMPP_TLS  = 'urn:ietf:params:xml:ns:xmpp-tls'
 OLPC_ACTIVITIES = "http://laptop.org/xmpp/activities"
 OLPC_ACTIVITIES_NOTIFY = "%s+notify" % OLPC_ACTIVITIES
 OLPC_ACTIVITY = "http://laptop.org/xmpp/activity"
@@ -66,3 +69,7 @@ X_DELAY = 'jabber:x:delay'
 XML = 'http://www.w3.org/XML/1998/namespace'
 X_OOB = 'jabber:x:oob'
 GABBLE_CAPS="http://telepathy.freedesktop.org/caps"
+PRESENCE_INVISIBLE = 'presence-invisible'
+PRIVACY = 'jabber:iq:privacy'
+INVISIBLE = 'urn:xmpp:invisible:0'
+GOOGLE_SHARED_STATUS = 'google:shared-status'
diff --git a/tests/twisted/servicetest.py b/tests/twisted/servicetest.py
index bb00d7a..1832270 100644
--- a/tests/twisted/servicetest.py
+++ b/tests/twisted/servicetest.py
@@ -7,6 +7,7 @@ from twisted.internet import glib2reactor
 from twisted.internet.protocol import Protocol, Factory, ClientFactory
 glib2reactor.install()
 import sys
+import time
 
 import pprint
 import unittest
@@ -24,6 +25,7 @@ class Event:
     def __init__(self, type, **kw):
         self.__dict__.update(kw)
         self.type = type
+        (self.subqueue, self.subtype) = type.split ("-", 1)
 
 def format_event(event):
     ret = ['- type %s' % event.type]
@@ -46,6 +48,7 @@ class EventPattern:
             self.predicate = properties['predicate']
             del properties['predicate']
         self.properties = properties
+        (self.subqueue, self.subtype) = type.split ("-", 1)
 
     def __repr__(self):
         properties = dict(self.properties)
@@ -85,6 +88,7 @@ class BaseEventQueue:
     def __init__(self, timeout=None):
         self.verbose = False
         self.forbidden_events = set()
+        self.event_queues = {}
 
         if timeout is None:
             self.timeout = 5
@@ -95,12 +99,14 @@ class BaseEventQueue:
         if self.verbose:
             print s
 
+    def log_queues(self, queues):
+        self.log ("Waiting for event on: %s" % ", ".join(queues))
+
     def log_event(self, event):
-        if self.verbose:
-            self.log('got event:')
+        self.log('got event:')
 
-            if self.verbose:
-                map(self.log, format_event(event))
+        if self.verbose:
+            map(self.log, format_event(event))
 
     def forbid_events(self, patterns):
         """
@@ -127,15 +133,22 @@ class BaseEventQueue:
                 assert False
 
     def expect(self, type, **kw):
+        """
+        Waits for an event matching the supplied pattern to occur, and returns
+        it. For example, to await a D-Bus signal with particular arguments:
+
+            e = q.expect('dbus-signal', signal='Badgers', args=["foo", 42])
+        """
         pattern = EventPattern(type, **kw)
+        t = time.time()
 
         while True:
-            event = self.wait()
-            self.log_event(event)
+            event = self.wait([pattern.subqueue])
             self._check_forbidden(event)
 
             if pattern.match(event):
-                self.log('handled')
+                self.log('handled, took %0.3f ms'
+                    % ((time.time() - t) * 1000.0) )
                 self.log('')
                 return event
 
@@ -143,11 +156,44 @@ class BaseEventQueue:
             self.log('')
 
     def expect_many(self, *patterns):
+        """
+        Waits for events matching all of the supplied EventPattern instances to
+        return, and returns a list of events in the same order as the patterns
+        they matched. After a pattern is successfully matched, it is not
+        considered for future events; if more than one unsatisfied pattern
+        matches an event, the first "wins".
+
+        Note that the expected events may occur in any order. If you're
+        expecting a series of events in a particular order, use repeated calls
+        to expect() instead.
+
+        This method is useful when you're awaiting a number of events which may
+        happen in any order. For instance, in telepathy-gabble, calling a D-Bus
+        method often causes a value to be returned immediately, as well as a
+        query to be sent to the server. Since these events may reach the test
+        in either order, the following is incorrect and will fail if the IQ
+        happens to reach the test first:
+
+            ret = q.expect('dbus-return', method='Foo')
+            query = q.expect('stream-iq', query_ns=ns.FOO)
+
+        The following would be correct:
+
+            ret, query = q.expect_many(
+                EventPattern('dbus-return', method='Foo'),
+                EventPattern('stream-iq', query_ns=ns.FOO),
+            )
+        """
         ret = [None] * len(patterns)
+        t = time.time()
 
         while None in ret:
             try:
-                event = self.wait()
+                queues = set()
+                for i, pattern in enumerate(patterns):
+                    if ret[i] is None:
+                        queues.add(pattern.subqueue)
+                event = self.wait(queues)
             except TimeoutError:
                 self.log('timeout')
                 self.log('still expecting:')
@@ -155,12 +201,12 @@ class BaseEventQueue:
                     if ret[i] is None:
                         self.log(' - %r' % pattern)
                 raise
-            self.log_event(event)
             self._check_forbidden(event)
 
             for i, pattern in enumerate(patterns):
                 if ret[i] is None and pattern.match(event):
-                    self.log('handled')
+                    self.log('handled, took %0.3f ms'
+                        % ((time.time() - t) * 1000.0) )
                     self.log('')
                     ret[i] = event
                     break
@@ -173,8 +219,7 @@ class BaseEventQueue:
     def demand(self, type, **kw):
         pattern = EventPattern(type, **kw)
 
-        event = self.wait()
-        self.log_event(event)
+        event = self.wait([pattern.subqueue])
 
         if pattern.match(event):
             self.log('handled')
@@ -184,14 +229,34 @@ class BaseEventQueue:
         self.log('not handled')
         raise RuntimeError('expected %r, got %r' % (pattern, event))
 
+    def queues_available(self, queues):
+        if queues == None:
+            return self.event_queues.keys()
+        else:
+            available = self.event_queues.keys()
+            return filter(lambda x: x in available, queues)
+
+
+    def pop_next(self, queue):
+        events = self.event_queues[queue]
+        e = events.pop(0)
+        if not events:
+           self.event_queues.pop (queue)
+        return e
+
+    def append(self, event):
+        self.log ("Adding to queue")
+        self.log_event (event)
+        self.event_queues[event.subqueue] = \
+            self.event_queues.get(event.subqueue, []) + [event]
+
 class IteratingEventQueue(BaseEventQueue):
     """Event queue that works by iterating the Twisted reactor."""
 
     def __init__(self, timeout=None):
         BaseEventQueue.__init__(self, timeout)
-        self.events = []
 
-    def wait(self):
+    def wait(self, queues=None):
         stop = [False]
 
         def later():
@@ -199,68 +264,92 @@ class IteratingEventQueue(BaseEventQueue):
 
         delayed_call = reactor.callLater(self.timeout, later)
 
-        while (not self.events) and (not stop[0]):
-            reactor.iterate(0.1)
+        self.log_queues(queues)
 
-        if self.events:
+        qa = self.queues_available(queues)
+        while not qa and (not stop[0]):
+            reactor.iterate(0.01)
+            qa = self.queues_available(queues)
+
+        if qa:
             delayed_call.cancel()
-            return self.events.pop(0)
+            e = self.pop_next (qa[0])
+            self.log_event (e)
+            return e
         else:
             raise TimeoutError
 
-    def append(self, event):
-        self.events.append(event)
-
-    # compatibility
-    handle_event = append
-
 class TestEventQueue(BaseEventQueue):
     def __init__(self, events):
         BaseEventQueue.__init__(self)
-        self.events = events
+        for e in events:
+            self.append (e)
 
-    def wait(self):
-        if self.events:
-            return self.events.pop(0)
+    def wait(self, queues = None):
+        qa = self.queues_available(queues)
+
+        if qa:
+            return self.pop_next (qa[0])
         else:
             raise TimeoutError
 
 class EventQueueTest(unittest.TestCase):
     def test_expect(self):
-        queue = TestEventQueue([Event('foo'), Event('bar')])
-        assert queue.expect('foo').type == 'foo'
-        assert queue.expect('bar').type == 'bar'
+        queue = TestEventQueue([Event('test-foo'), Event('test-bar')])
+        assert queue.expect('test-foo').type == 'test-foo'
+        assert queue.expect('test-bar').type == 'test-bar'
 
     def test_expect_many(self):
-        queue = TestEventQueue([Event('foo'), Event('bar')])
+        queue = TestEventQueue([Event('test-foo'),
+            Event('test-bar')])
         bar, foo = queue.expect_many(
-            EventPattern('bar'),
-            EventPattern('foo'))
-        assert bar.type == 'bar'
-        assert foo.type == 'foo'
+            EventPattern('test-bar'),
+            EventPattern('test-foo'))
+        assert bar.type == 'test-bar'
+        assert foo.type == 'test-foo'
 
     def test_expect_many2(self):
         # Test that events are only matched against patterns that haven't yet
         # been matched. This tests a regression.
-        queue = TestEventQueue([Event('foo', x=1), Event('foo', x=2)])
+        queue = TestEventQueue([Event('test-foo', x=1), Event('test-foo', x=2)])
         foo1, foo2 = queue.expect_many(
-            EventPattern('foo'),
-            EventPattern('foo'))
-        assert foo1.type == 'foo' and foo1.x == 1
-        assert foo2.type == 'foo' and foo2.x == 2
+            EventPattern('test-foo'),
+            EventPattern('test-foo'))
+        assert foo1.type == 'test-foo' and foo1.x == 1
+        assert foo2.type == 'test-foo' and foo2.x == 2
+
+    def test_expect_queueing(self):
+        queue = TestEventQueue([Event('foo-test', x=1),
+            Event('foo-test', x=2)])
+
+        queue.append(Event('bar-test', x=1))
+        queue.append(Event('bar-test', x=2))
+
+        queue.append(Event('baz-test', x=1))
+        queue.append(Event('baz-test', x=2))
+
+        for x in xrange(1,2):
+            e = queue.expect ('baz-test')
+            assertEquals (x, e.x)
+
+            e = queue.expect ('bar-test')
+            assertEquals (x, e.x)
+
+            e = queue.expect ('foo-test')
+            assertEquals (x, e.x)
 
     def test_timeout(self):
         queue = TestEventQueue([])
-        self.assertRaises(TimeoutError, queue.expect, 'foo')
+        self.assertRaises(TimeoutError, queue.expect, 'test-foo')
 
     def test_demand(self):
-        queue = TestEventQueue([Event('foo'), Event('bar')])
-        foo = queue.demand('foo')
-        assert foo.type == 'foo'
+        queue = TestEventQueue([Event('test-foo'), Event('test-bar')])
+        foo = queue.demand('test-foo')
+        assert foo.type == 'test-foo'
 
     def test_demand_fail(self):
-        queue = TestEventQueue([Event('foo'), Event('bar')])
-        self.assertRaises(RuntimeError, queue.demand, 'bar')
+        queue = TestEventQueue([Event('test-foo'), Event('test-bar')])
+        self.assertRaises(RuntimeError, queue.demand, 'test-bar')
 
 def unwrap(x):
     """Hack to unwrap D-Bus values, so that they're easier to read when
@@ -289,11 +378,11 @@ def call_async(test, proxy, method, *args, **kw):
     resulting method return/error."""
 
     def reply_func(*ret):
-        test.handle_event(Event('dbus-return', method=method,
+        test.append(Event('dbus-return', method=method,
             value=unwrap(ret)))
 
     def error_func(err):
-        test.handle_event(Event('dbus-error', method=method, error=err,
+        test.append(Event('dbus-error', method=method, error=err,
             name=err.get_dbus_name(), message=str(err)))
 
     method_proxy = getattr(proxy, method)
@@ -341,6 +430,9 @@ def wrap_connection(conn):
          ('Location', cs.CONN_IFACE_LOCATION),
          ('Future', tp_name_prefix + '.Connection.FUTURE'),
          ('MailNotification', cs.CONN_IFACE_MAIL_NOTIFICATION),
+         ('ContactList', cs.CONN_IFACE_CONTACT_LIST),
+         ('ContactGroups', cs.CONN_IFACE_CONTACT_GROUPS),
+         ('PowerSaving', cs.CONN_IFACE_POWER_SAVING),
         ]))
 
 def wrap_channel(chan, type_, extra=None):
@@ -383,7 +475,7 @@ class EventProtocol(Protocol):
 
     def dataReceived(self, data):
         if self.queue is not None:
-            self.queue.handle_event(Event('socket-data', protocol=self,
+            self.queue.append(Event('socket-data', protocol=self,
                 data=data))
 
     def sendData(self, data):
@@ -395,7 +487,7 @@ class EventProtocol(Protocol):
 
     def connectionLost(self, reason=None):
         if self.queue is not None:
-            self.queue.handle_event(Event('socket-disconnected', protocol=self))
+            self.queue.append(Event('socket-disconnected', protocol=self))
 
 class EventProtocolFactory(Factory):
     def __init__(self, queue, block_reading=False):
@@ -407,7 +499,7 @@ class EventProtocolFactory(Factory):
 
     def buildProtocol(self, addr):
         proto = self._create_protocol()
-        self.queue.handle_event(Event('socket-connected', protocol=proto))
+        self.queue.append(Event('socket-connected', protocol=proto))
         return proto
 
 class EventProtocolClientFactory(EventProtocolFactory, ClientFactory):
@@ -415,7 +507,7 @@ class EventProtocolClientFactory(EventProtocolFactory, ClientFactory):
 
 def watch_tube_signals(q, tube):
     def got_signal_cb(*args, **kwargs):
-        q.handle_event(Event('tube-signal',
+        q.append(Event('tube-signal',
             path=kwargs['path'],
             signal=kwargs['member'],
             args=map(unwrap, args),
@@ -433,6 +525,15 @@ def assertEquals(expected, value):
         raise AssertionError(
             "expected:\n%s\ngot:\n%s" % (pretty(expected), pretty(value)))
 
+def assertSameSets(expected, value):
+    exp_set = set(expected)
+    val_set = set(value)
+
+    if exp_set != val_set:
+        raise AssertionError(
+            "expected contents:\n%s\ngot:\n%s" % (
+                pretty(exp_set), pretty(val_set)))
+
 def assertNotEquals(expected, value):
     if expected == value:
         raise AssertionError(
@@ -485,8 +586,12 @@ def install_colourer():
             self.patterns = patterns
 
         def write(self, s):
-            f = self.patterns.get(s, lambda x: x)
-            self.fh.write(f(s))
+            for p, f in self.patterns.items():
+                if s.startswith(p):
+                    self.fh.write(f(p) + s[len(p):])
+                    return
+
+            self.fh.write(s)
 
     sys.stdout = Colourer(sys.stdout, patterns)
     return sys.stdout