Merge lp:~autopilot/autopilot/experimental into lp:autopilot

[Thomi Richards]

New Hotness for autopilot 1.4.

This branch contains the 'new hotness' for autopilot 1.4. Specifically:

 - better introspection type support.
 - python 3 support!

[lp:~autopilot/autopilot/experimental]

347. By Thomi Richards on 2013-09-16

Merged trunk, resolved conflicts.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:346
http://jenkins.qa.ubuntu.com/job/autopilot-ci/221/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-saucy-amd64-ci/149/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-saucy-armhf-ci/149/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/autopilot-ci/221/rebuild

review: Needs Fixing (continuous-integration)

[Martin Pitt (pitti)]

Big Plus for documenting the wire protocol and porting instructions!

review: Approve

[lp:~autopilot/autopilot/experimental]

348. By Thomi Richards on 2013-09-16

PEP8 fixes.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:347
http://jenkins.qa.ubuntu.com/job/autopilot-ci/222/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-saucy-amd64-ci/150/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-saucy-armhf-ci/150/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/autopilot-ci/222/rebuild

review: Needs Fixing (continuous-integration)

[Martin Pitt (pitti)]

Strictly speaking this would need to grow "Breaks: libautopilot-gtk (<< 1.4), libautopilot-qt (<< 1.4)" to both p-ap and p3-ap, as these are only recommends and not depends:.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:348
http://jenkins.qa.ubuntu.com/job/autopilot-ci/224/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-saucy-amd64-ci/151
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-saucy-armhf-ci/151

Click here to trigger a rebuild:
http://s-jenkins:8080/job/autopilot-ci/224/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:347
http://jenkins.qa.ubuntu.com/job/autopilot-ci/225/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-saucy-amd64-ci/153
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-saucy-armhf-ci/153

Click here to trigger a rebuild:
http://s-jenkins:8080/job/autopilot-ci/225/rebuild

review: Approve (continuous-integration)

=== modified file 'autopilot/__init__.py'
--- autopilot/__init__.py	2013-07-22 04:42:45 +0000
+++ autopilot/__init__.py	2013-09-16 17:17:50 +0000
@@ -20,7 +20,7 @@
 from argparse import ArgumentParser, REMAINDER, Action
 import subprocess
 
-version = '1.3.1'
+version = '1.4.0'
 
 
 class BackendException(RuntimeError):
@@ -30,7 +30,7 @@
     def __init__(self, original_exception):
         super(BackendException, self).__init__(
             "Error while initialising backend. Original exception was: " +
-            original_exception.message)
+            str(original_exception))
         self.original_exception = original_exception
 
 
@@ -179,7 +179,8 @@
                 "${Version}",
                 "--show",
                 "python-autopilot",
-            ]
+            ],
+            universal_newlines=True
         ).strip()
     except subprocess.CalledProcessError:
         return None
 
=== modified file 'autopilot/globals.py'
--- autopilot/globals.py	2013-07-22 04:14:41 +0000
+++ autopilot/globals.py	2013-09-16 17:17:50 +0000
@@ -19,7 +19,14 @@
 
 
 from __future__ import absolute_import
-from StringIO import StringIO
+
+try:
+    # Python 2
+    from StringIO import StringIO
+except ImportError:
+    # Python 3
+    from io import StringIO
+
 from autopilot.utilities import LogFormatter, CleanupRegistered
 from testtools.content import text_content
 import subprocess
@@ -203,7 +210,7 @@
     """
     if type(enable_recording) is not bool:
         raise TypeError("enable_recording must be a boolean.")
-    if not isinstance(record_dir, basestring):
+    if not isinstance(record_dir, str):
         raise TypeError("record_dir must be a string.")
 
     _video_logger.enable_recording(enable_recording)
 
=== modified file 'autopilot/ibus.py'
--- autopilot/ibus.py	2013-07-30 00:16:11 +0000
+++ autopilot/ibus.py	2013-09-16 17:17:50 +0000
@@ -94,7 +94,7 @@
         raise TypeError("engine_list must be a list of valid engine names.")
     available_engines = get_available_input_engines()
     for engine in engine_list:
-        if not isinstance(engine, basestring):
+        if not isinstance(engine, str):
             raise TypeError("Engines in engine_list must all be strings.")
         if engine not in available_engines:
             raise ValueError(
 
=== modified file 'autopilot/input/_X11.py'
--- autopilot/input/_X11.py	2013-09-04 03:44:07 +0000
+++ autopilot/input/_X11.py	2013-09-16 17:17:50 +0000
@@ -27,6 +27,7 @@
 from __future__ import absolute_import
 
 import logging
+import sys
 from time import sleep
 
 from autopilot.display import is_point_on_any_screen, move_mouse_to_screen
@@ -45,6 +46,10 @@
 _DISPLAY = None
 logger = logging.getLogger(__name__)
 
+# py2 compatible alias for py3
+if sys.version >= '3':
+    basestring = str
+
 
 def get_display():
     """Return the Xlib display object.
@@ -333,8 +338,8 @@
                 sync,
                 X.CurrentTime,
                 X.NONE,
-                x=x,
-                y=y)
+                x=int(x),
+                y=int(y))
             get_display().sync()
             sleep(time_between_events)
 
 
=== modified file 'autopilot/input/_osk.py'
--- autopilot/input/_osk.py	2013-08-23 00:23:40 +0000
+++ autopilot/input/_osk.py	2013-09-16 17:17:50 +0000
@@ -18,6 +18,7 @@
 #
 
 import logging
+import sys
 from time import sleep
 from contextlib import contextmanager
 
@@ -31,6 +32,10 @@
 
 logger = logging.getLogger(__name__)
 
+# py2 compatible alias for py3
+if sys.version >= '3':
+    basestring = str
+
 
 class Keyboard(KeyboardBase):
 
 
=== modified file 'autopilot/input/_uinput.py'
--- autopilot/input/_uinput.py	2013-07-24 08:26:10 +0000
+++ autopilot/input/_uinput.py	2013-09-16 17:17:50 +0000
@@ -29,6 +29,7 @@
 from time import sleep
 from evdev import UInput, ecodes as e
 import os.path
+import sys
 
 logger = logging.getLogger(__name__)
 
@@ -37,6 +38,10 @@
 
 _PRESSED_KEYS = []
 
+# py2 compatible alias for py3
+if sys.version >= '3':
+    basestring = str
+
 
 def _get_devnode_path():
     """Provide a fallback uinput node for devices which don't support udev"""
 
=== modified file 'autopilot/introspection/__init__.py'
--- autopilot/introspection/__init__.py	2013-07-30 15:08:30 +0000
+++ autopilot/introspection/__init__.py	2013-09-16 17:17:50 +0000
@@ -33,6 +33,7 @@
 from time import sleep
 from functools import partial
 import os
+import sys
 
 from autopilot.introspection.backends import DBusAddress
 from autopilot.introspection.constants import (
@@ -62,6 +63,10 @@
 # Keep track of known connections during search
 connection_list = []
 
+# py2 compatible alias for py3
+if sys.version >= '3':
+    basestring = str
+
 
 class ProcessSearchError(RuntimeError):
     pass
@@ -77,7 +82,10 @@
     # any non-dynamically linked executables, which we may need to fix further
     # down the line.
     try:
-        ldd_output = subprocess.check_output(["ldd", app_path]).strip().lower()
+        ldd_output = subprocess.check_output(
+            ["ldd", app_path],
+            universal_newlines=True
+        ).strip().lower()
     except subprocess.CalledProcessError as e:
         raise RuntimeError(e)
     if 'libqtcore' in ldd_output or 'libqt5core' in ldd_output:
@@ -115,9 +123,11 @@
     cwd = kwargs.pop('launch_dir', None)
     capture_output = kwargs.pop('capture_output', True)
     if kwargs:
+        arglist = [repr(k) for k in kwargs.keys()]
+        arglist.sort()
         raise ValueError(
             "Unknown keyword arguments: %s." %
-            (', '.join(repr(k) for k in kwargs.keys())))
+            (', '.join(arglist)))
 
     path, args = launcher.prepare_environment(application, list(arguments))
 
@@ -164,6 +174,7 @@
         stderr=cap_mode,
         close_fds=True,
         preexec_fn=os.setsid,
+        universal_newlines=True,
         **kwargs
     )
     return process
@@ -263,7 +274,7 @@
     if application_name:
         app_name_check_fn = lambda i: get_classname_from_path(
             i.introspection_iface.GetState('/')[0][0]) == application_name
-        dbus_addresses = filter(app_name_check_fn, dbus_addresses)
+        dbus_addresses = list(filter(app_name_check_fn, dbus_addresses))
 
     if dbus_addresses is None or len(dbus_addresses) == 0:
         raise ProcessSearchError("Search criteria returned no results")
 
=== modified file 'autopilot/introspection/backends.py'
--- autopilot/introspection/backends.py	2013-07-30 17:31:50 +0000
+++ autopilot/introspection/backends.py	2013-09-16 17:17:50 +0000
@@ -91,9 +91,9 @@
 
     @property
     def introspection_iface(self):
-        if not isinstance(self._addr_tuple.connection, basestring):
+        if not isinstance(self._addr_tuple.connection, str):
             raise TypeError("Service name must be a string.")
-        if not isinstance(self._addr_tuple.object_path, basestring):
+        if not isinstance(self._addr_tuple.object_path, str):
             raise TypeError("Object name must be a string")
 
         if not self._check_pid_running():
 
=== modified file 'autopilot/introspection/constants.py'
--- autopilot/introspection/constants.py	2013-05-13 22:47:50 +0000
+++ autopilot/introspection/constants.py	2013-09-16 17:17:50 +0000
@@ -25,4 +25,4 @@
 AP_INTROSPECTION_IFACE = 'com.canonical.Autopilot.Introspection'
 DBUS_INTROSPECTION_IFACE = 'org.freedesktop.DBus.Introspectable'
 
-CURRENT_WIRE_PROTOCOL_VERSION = "1.3"
+CURRENT_WIRE_PROTOCOL_VERSION = "1.4"
 
=== modified file 'autopilot/introspection/dbus.py'
--- autopilot/introspection/dbus.py	2013-08-09 01:29:23 +0000
+++ autopilot/introspection/dbus.py	2013-09-16 17:17:50 +0000
@@ -30,10 +30,11 @@
 from contextlib import contextmanager
 import logging
 import re
-from testtools.matchers import Equals
-from time import sleep
+import sys
 from uuid import uuid4
 
+from autopilot.introspection.types import create_value_instance
+from autopilot.introspection.utilities import translate_state_keys
 from autopilot.utilities import Timer, get_debug_logger
 
 
@@ -41,8 +42,16 @@
 logger = logging.getLogger(__name__)
 
 
+# py2 compatible alias for py3
+if sys.version >= '3':
+    _PY3 = True
+    basestring = str
+else:
+    _PY3 = False
+
+
 class StateNotFoundError(RuntimeError):
-    """Raised when a piece of state information from unity is not found."""
+    """Raised when a piece of state information is not found."""
 
     message = "State not found for class with name '{}' and id '{}'."
 
@@ -81,17 +90,11 @@
 
     """
     global _object_registry
-    for cls in _object_registry[proxy_object._id].itervalues():
+    for cls in _object_registry[proxy_object._id].values():
         if type(proxy_object) is not cls:
             cls._Backend = None
 
 
-def translate_state_keys(state_dict):
-    """Translates the *state_dict* passed in so the keys are usable as python
-    attributes."""
-    return {k.replace('-', '_'): v for k, v in state_dict.iteritems()}
-
-
 def get_classname_from_path(object_path):
     return object_path.split("/")[-1]
 
@@ -100,7 +103,7 @@
     """Return true if *instance* satisifies all the filters present in
     kwargs."""
     with instance.no_automatic_refreshing():
-        for attr, val in kwargs.iteritems():
+        for attr, val in kwargs.items():
             if not hasattr(instance, attr) or getattr(instance, attr) != val:
                 # Either attribute is not present, or is present but with
                 # the wrong value - don't add this instance to the results
@@ -108,8 +111,14 @@
                 return False
     return True
 
-
-class DBusIntrospectionObject(object):
+DBusIntrospectionObjectBase = IntrospectableObjectMetaclass(
+    'DBusIntrospectionObjectBase',
+    (object,),
+    {}
+)
+
+
+class DBusIntrospectionObject(DBusIntrospectionObjectBase):
     """A class that supports transparent data retrieval from the application
     under test.
 
@@ -120,8 +129,6 @@
 
     """
 
-    __metaclass__ = IntrospectableObjectMetaclass
-
     _Backend = None
 
     def __init__(self, state_dict, path):
@@ -139,91 +146,20 @@
 
         """
         self.__state = {}
-        for key, value in translate_state_keys(state_dict).iteritems():
+        for key, value in translate_state_keys(state_dict).items():
             # don't store id in state dictionary -make it a proper instance
             # attribute
             if key == 'id':
-                self.id = value
-            self.__state[key] = self._make_attribute(key, value)
-
-    def _make_attribute(self, name, value):
-        """Make an attribute for *value*, patched with the wait_for
-        function."""
-
-        def wait_for(self, expected_value, timeout=10):
-            """Wait up to 10 seconds for our value to change to
-            *expected_value*.
-
-            *expected_value* can be a testtools.matcher. Matcher subclass (like
-            LessThan, for example), or an ordinary value.
-
-            This works by refreshing the value using repeated dbus calls.
-
-            :raises: **RuntimeError** if the attribute was not equal to the
-             expected value after 10 seconds.
-
-            """
-            # It's guaranteed that our value is up to date, since __getattr__
-            # calls refresh_state. This if statement stops us waiting if the
-            # value is already what we expect:
-            if self == expected_value:
-                return
-
-            def make_unicode(value):
-                if isinstance(value, str):
-                    return unicode(value.decode('utf8'))
-                return value
-
-            if hasattr(expected_value, 'expected'):
-                expected_value.expected = make_unicode(expected_value.expected)
-
-            # unfortunately not all testtools matchers derive from the Matcher
-            # class, so we can't use issubclass, isinstance for this:
-            match_fun = getattr(expected_value, 'match', None)
-            is_matcher = match_fun and callable(match_fun)
-            if not is_matcher:
-                expected_value = Equals(expected_value)
-
-            time_left = timeout
-            while True:
-                _, new_state = self.parent.get_new_state()
-                new_state = translate_state_keys(new_state)
-                new_value = make_unicode(new_state[self.name])
-                # Support for testtools.matcher classes:
-                mismatch = expected_value.match(new_value)
-                if mismatch:
-                    failure_msg = mismatch.describe()
-                else:
-                    self.parent._set_properties(new_state)
-                    return
-
-                if time_left >= 1:
-                    sleep(1)
-                    time_left -= 1
-                else:
-                    sleep(time_left)
-                    break
-
-            raise AssertionError(
-                "After %.1f seconds test on %s.%s failed: %s" % (
-                    timeout, self.parent.__class__.__name__, self.name,
-                    failure_msg))
-
-        # This looks like magic, but it's really not. We're creating a new type
-        # on the fly that derives from the type of 'value' with a couple of
-        # extra attributes: wait_for is the wait_for method above. 'parent' and
-        # 'name' are needed by the wait_for method.
-        #
-        # We can't use traditional meta-classes here, since the type we're
-        # deriving from is only known at call time, not at parse time (we could
-        # override __call__ in the meta class, but that doesn't buy us anything
-        # extra).
-        #
-        # A better way to do this would be with functools.partial, which I
-        # tried initially, but doesn't work well with bound methods.
-        t = type(value)
-        attrs = {'wait_for': wait_for, 'parent': self, 'name': name}
-        return type(t.__name__, (t,), attrs)(value)
+                self.id = int(value[1])
+            try:
+                self.__state[key] = create_value_instance(value, self, key)
+            except ValueError as e:
+                logger.warning(
+                    "While constructing attribute '%s.%s': %s",
+                    self.__class__.__name__,
+                    key,
+                    str(e)
+                )
 
     def get_children_by_type(self, desired_type, **kwargs):
         """Get a list of children of the specified type.
@@ -302,6 +238,19 @@
         children = [self.make_introspection_object(i) for i in state_dicts]
         return children
 
+    def get_parent(self):
+        """Returns the parent of this object.
+
+        If this object has no parent (i.e.- it is the root of the introspection
+        tree). Then it returns itself.
+
+        """
+        query = self.get_class_query_string() + "/.."
+        parent_state_dicts = self.get_state_by_path(query)
+
+        parent = self.make_introspection_object(parent_state_dicts[0])
+        return parent
+
     def select_single(self, type_name='*', **kwargs):
         """Get a single node from the introspection tree, with type equal to
         *type_name* and (optionally) matching the keyword filters present in
@@ -390,8 +339,9 @@
             "Selecting objects of %s with attributes: %r",
             'any type' if type_name == '*' else 'type ' + type_name, kwargs)
 
-        first_param = ''
-        for k, v in kwargs.iteritems():
+        server_side_filters = []
+        client_side_filters = {}
+        for k, v in kwargs.items():
             # LP Bug 1209029: The XPathSelect protocol does not allow all valid
             # node names or values. We need to decide here whether the filter
             # parameters are going to work on the backend or not. If not, we
@@ -399,25 +349,33 @@
             # _is_valid_server_side_filter_param function (below) for the
             # specific requirements.
             if _is_valid_server_side_filter_param(k, v):
-                first_param = '[{}={}]'.format(k, v)
-                kwargs.pop(k)
-                break
-        query_path = "%s//%s%s" % (self.get_class_query_string(),
-                                   type_name,
-                                   first_param)
+                server_side_filters.append(
+                    _get_filter_string_for_key_value_pair(k, v)
+                )
+            else:
+                client_side_filters[k] = v
+        filter_str = '[{}]'.format(','.join(server_side_filters)) \
+            if server_side_filters else ""
+        query_path = "%s//%s%s" % (
+            self.get_class_query_string(),
+            type_name,
+            filter_str
+        )
 
         state_dicts = self.get_state_by_path(query_path)
         instances = [self.make_introspection_object(i) for i in state_dicts]
-        return filter(lambda i: object_passes_filters(i, **kwargs), instances)
+        return [i for i in instances
+                if object_passes_filters(i, **client_side_filters)]
 
     def refresh_state(self):
-        """Refreshes the object's state from unity.
+        """Refreshes the object's state.
 
         You should probably never have to call this directly. Autopilot
         automatically retrieves new state every time this object's attributes
         are read.
 
-        :raises: **StateNotFound** if the object in unity has been destroyed.
+        :raises: **StateNotFound** if the object in the application under test
+            has been destroyed.
 
         """
         _, new_state = self.get_new_state()
@@ -563,9 +521,32 @@
 
     """
     return (
-        isinstance(value, str) and
+        type(value) in (str, int, bool) and
         re.match(r'^[a-zA-Z0-9_\-]+( [a-zA-Z0-9_\-])*$', key) is not None and
-        re.match(r'^[a-zA-Z0-9_\-]+( [a-zA-Z0-9_\-])*$', value) is not None)
+        (type(value) != int or -2**31 <= value <= 2**31 - 1))
+
+
+def _get_filter_string_for_key_value_pair(key, value):
+    """Return a string representing the filter query for this key/value pair.
+
+    The value must be suitable for server-side filtering. Raises ValueError if
+    this is not the case.
+
+    """
+    if isinstance(value, str):
+        if _PY3:
+            escaped_value = value.encode("unicode_escape")\
+                .decode('ASCII')\
+                .replace("'", "\\'")
+        else:
+            escaped_value = value.encode("string_escape")
+            # note: string_escape codec escapes "'" but not '"'...
+            escaped_value = escaped_value.replace('"', r'\"')
+        return '{}="{}"'.format(key, escaped_value)
+    elif isinstance(value, int) or isinstance(value, bool):
+        return "{}={}".format(key, repr(value))
+    else:
+        raise ValueError("Unsupported value type: {}".format(type(value)))
 
 
 class _CustomEmulatorMeta(IntrospectableObjectMetaclass):
@@ -583,9 +564,10 @@
                 d['_id'] = uuid4()
         return super(_CustomEmulatorMeta, cls).__new__(cls, name, bases, d)
 
-
-class CustomEmulatorBase(DBusIntrospectionObject):
-
+CustomEmulatorBase = _CustomEmulatorMeta('CustomEmulatorBase',
+                                         (DBusIntrospectionObject, ),
+                                         {})
+CustomEmulatorBase.__doc__ = \
     """This class must be used as a base class for any custom emulators defined
     within a test case.
 
@@ -593,5 +575,3 @@
         Tutorial Section :ref:`custom_emulators`
             Information on how to write custom emulators.
     """
-
-    __metaclass__ = _CustomEmulatorMeta
 
=== added file 'autopilot/introspection/types.py'
--- autopilot/introspection/types.py	1970-01-01 00:00:00 +0000
+++ autopilot/introspection/types.py	2013-09-16 17:17:50 +0000
@@ -0,0 +1,619 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Autopilot Functional Test Tool
+# Copyright (C) 2013 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+"""
+Autopilot proxy type support.
+=============================
+
+This module defines the classes that are used for all attributes on proxy
+objects. All proxy objects contain attributes that transparently mirror the
+values present in the application under test. Autopilot takes care of keeping
+these values up to date.
+
+Object attributes fall into two categories. Attributes that are a single
+string, boolean, or integer property are sent directly across DBus. These are
+called "plain" types, and are stored in autopilot as instnaces of the
+:class:`PlainType` class. Attributes that are more complex (a rectangle, for
+example) are called "complex" types, and are split into several component
+values, sent across dbus, and are then reconstituted in autopilot into useful
+objects.
+
+"""
+
+from __future__ import absolute_import
+
+from datetime import datetime, time
+import dbus
+import logging
+from testtools.matchers import Equals
+from time import sleep
+
+from autopilot.introspection.utilities import translate_state_keys
+
+
+logger = logging.getLogger(__name__)
+
+
+class ValueType(object):
+
+    """Store constants for different special types that autopilot understands.
+
+    DO NOT add items here unless you have documented them correctly in
+    docs/appendix/protocol.rst.
+
+    """
+    PLAIN = 0
+    RECTANGLE = 1
+    POINT = 2
+    SIZE = 3
+    COLOR = 4
+    DATETIME = 5
+    TIME = 6
+    UNKNOWN = -1
+
+
+def create_value_instance(value, parent, name):
+    """Create an object that exposes the interesing part of the value
+    specified, given the value_type_id.
+
+    :param parent: The object this attribute belongs to.
+    :param name: The name of this attribute.
+    :param value: The value array from DBus.
+
+    """
+    type_dict = {
+        ValueType.PLAIN: _make_plain_type,
+        ValueType.RECTANGLE: Rectangle,
+        ValueType.POINT: Point,
+        ValueType.SIZE: Size,
+        ValueType.DATETIME: DateTime,
+        ValueType.TIME: Time,
+        ValueType.UNKNOWN: _make_plain_type,
+    }
+    type_id = value[0]
+    value = value[1:]
+
+    if type_id not in type_dict:
+        logger.warning("Unknown type id %d", type_id)
+        type_id = ValueType.UNKNOWN
+
+    type_class = type_dict.get(type_id, None)
+    if type_id == ValueType.UNKNOWN:
+        value = [dbus.Array(value)]
+    if len(value) == 0:
+        raise ValueError("Cannot create attribute, no data supplied")
+    return type_class(*value, parent=parent, name=name)
+
+
+class TypeBase(object):
+
+    def wait_for(self, expected_value, timeout=10):
+        """Wait up to 10 seconds for our value to change to
+        *expected_value*.
+
+        *expected_value* can be a testtools.matcher. Matcher subclass (like
+        LessThan, for example), or an ordinary value.
+
+        This works by refreshing the value using repeated dbus calls.
+
+        :raises AssertionError: if the attribute was not equal to the
+         expected value after 10 seconds.
+
+        :raises RuntimeError: if the attribute you called this on was not
+         constructed as part of an object.
+
+        """
+        # It's guaranteed that our value is up to date, since __getattr__
+        # calls refresh_state. This if statement stops us waiting if the
+        # value is already what we expect:
+        if self == expected_value:
+            return
+
+        if self.name is None or self.parent is None:
+            raise RuntimeError(
+                "This variable was not constructed as part of "
+                "an object. The wait_for method cannot be used."
+            )
+
+        def make_unicode(value):
+            if isinstance(value, bytes):
+                return value.decode('utf8')
+            return value
+
+        if hasattr(expected_value, 'expected'):
+            expected_value.expected = make_unicode(expected_value.expected)
+
+        # unfortunately not all testtools matchers derive from the Matcher
+        # class, so we can't use issubclass, isinstance for this:
+        match_fun = getattr(expected_value, 'match', None)
+        is_matcher = match_fun and callable(match_fun)
+        if not is_matcher:
+            expected_value = Equals(expected_value)
+
+        time_left = timeout
+        while True:
+            # TODO: These next three lines are duplicated from the parent...
+            # can we just have this code once somewhere?
+            _, new_state = self.parent.get_new_state()
+            new_state = translate_state_keys(new_state)
+            new_value = make_unicode(new_state[self.name][1])  # [1] is the val
+            # Support for testtools.matcher classes:
+            mismatch = expected_value.match(new_value)
+            if mismatch:
+                failure_msg = mismatch.describe()
+            else:
+                self.parent._set_properties(new_state)
+                return
+
+            if time_left >= 1:
+                sleep(1)
+                time_left -= 1
+            else:
+                sleep(time_left)
+                break
+
+        raise AssertionError(
+            "After %.1f seconds test on %s.%s failed: %s" % (
+                timeout, self.parent.__class__.__name__, self.name,
+                failure_msg))
+
+
+class PlainType(TypeBase):
+
+    """Plain type support in autopilot proxy objects.
+
+    Instances of this class will be used for all plain attrubites. The word
+    "plain" in this context means anything that's marshalled as a string,
+    boolean or integer type across dbus.
+
+    Instances of these classes can be used just like the underlying type. For
+    example, given an object property called 'length' that is marshalled over
+    dbus as an integer value, the following will be true::
+
+        >>> isinstance(object.length, PlainType)
+        True
+        >>> isinstance(object.length, int)
+        True
+        >>> print(object.length)
+        123
+        >>> print(object.length + 32)
+        155
+
+    However, a special case exists for boolean values: because you cannot
+    subclass from the 'bool' type, the following check will fail (
+    ``object.visible`` is a boolean property)::
+
+        >>> isinstance(object.visible, bool)
+        False
+
+    However boolean values will behave exactly as you expect them to.
+
+    """
+
+    def __new__(cls, value, parent=None, name=None):
+        return _make_plain_type(value, parent=parent, name=name)
+
+
+def _make_plain_type(value, parent=None, name=None):
+        new_type_name = type(value).__name__
+        new_type_bases = (type(value), PlainType)
+        new_type_dict = dict(parent=parent, name=name)
+        new_type = type(new_type_name, new_type_bases, new_type_dict)
+        return new_type(value)
+
+
+def _array_packed_type(num_args):
+    """Return a base class that accepts 'num_args' and is packed into a dbus
+    Array type.
+
+    """
+    class _ArrayPackedType(dbus.Array, TypeBase):
+
+        def __init__(self, *args, **kwargs):
+            if len(args) != self._required_arg_count:
+                raise ValueError(
+                    "%s must be constructed with %d arguments, not %d"
+                    % (
+                        self.__class__.__name__,
+                        self._required_arg_count,
+                        len(args)
+                    )
+                )
+            super(_ArrayPackedType, self).__init__(args)
+            # TODO: pop instead of get, and raise on unknown kwarg
+            self.parent = kwargs.get("parent", None)
+            self.name = kwargs.get("name", None)
+    return type(
+        "_ArrayPackedType_{}".format(num_args),
+        (_ArrayPackedType,),
+        dict(_required_arg_count=num_args)
+    )
+
+
+class Rectangle(_array_packed_type(4)):
+
+    """The RectangleType class represents a rectangle in cartesian space.
+
+    To construct a rectangle, pass the x, y, width and height parameters in to
+    the class constructor::
+
+        my_rect = Rectangle(12,13,100,150)
+
+    These attributes can be accessed either using named attributes, or via
+    sequence indexes::
+
+        >>> my_rect.x == my_rect[0] == 12
+        True
+        >>> my_rect.y == my_rect[1] == 13
+        True
+        >>> my_rect.w == my_rect[2] == 100
+        True
+        >>> my_rect.h == my_rect[3] == 150
+        True
+
+    You may also access the width and height values using the ``width`` and
+    ``height`` properties::
+
+        >>> my_rect.width == my_rect.w
+        True
+        >>> my_rect.height == my_rect.h
+        True
+
+    Rectangles can be compared using ``==`` and ``!=``, either to another
+    Rectangle instance, or to any mutable sequence type::
+
+        >>> my_rect == [12, 13, 100, 150]
+        True
+        >>> my_rect != Rectangle(1,2,3,4)
+        True
+
+    """
+
+    @property
+    def x(self):
+        return self[0]
+
+    @property
+    def y(self):
+        return self[1]
+
+    @property
+    def w(self):
+        return self[2]
+
+    @property
+    def width(self):
+        return self[2]
+
+    @property
+    def h(self):
+        return self[3]
+
+    @property
+    def height(self):
+        return self[3]
+
+
+class Point(_array_packed_type(2)):
+
+    """The Point class represents a 2D point in cartesian space.
+
+    To construct a Point, pass in the x, y parameters to the class
+    constructor::
+
+        >>> my_point = Point(50,100)
+
+    These attributes can be accessed either using named attributes, or via
+    sequence indexes::
+
+        >>> my_point.x == my_point[0] == 50
+        True
+        >>> my_point.y == my_point[1] == 100
+        True
+
+    Point instances can be compared using ``==`` and ``!=``, either to another
+    Point instance, or to any mutable sequence type with the correct number of
+    items::
+
+        >>> my_point == [50, 100]
+        True
+        >>> my_point != Point(5, 10)
+        True
+
+    """
+
+    @property
+    def x(self):
+        return self[0]
+
+    @property
+    def y(self):
+        return self[1]
+
+
+class Size(_array_packed_type(2)):
+
+    """The Size class represents a 2D size in cartesian space.
+
+    To construct a Size, pass in the width, height parameters to the class
+    constructor::
+
+        >>> my_size = Size(50,100)
+
+    These attributes can be accessed either using named attributes, or via
+    sequence indexes::
+
+        >>> my_size.width == my_size.w == my_size[0] == 50
+        True
+        >>> my_size.height == my_size.h == my_size[1] == 100
+        True
+
+    Size instances can be compared using ``==`` and ``!=``, either to another
+    Size instance, or to any mutable sequence type with the correct number of
+    items::
+
+        >>> my_size == [50, 100]
+        True
+        >>> my_size != Size(5, 10)
+        True
+
+    """
+
+    @property
+    def w(self):
+        return self[0]
+
+    @property
+    def width(self):
+        return self[0]
+
+    @property
+    def h(self):
+        return self[1]
+
+    @property
+    def height(self):
+        return self[1]
+
+
+class Color(_array_packed_type(4)):
+
+    """The Color class represents an RGBA Color.
+
+    To construct a Color, pass in the red, green, blue and alpha parameters to
+    the class constructor::
+
+        >>> my_color = Color(50, 100, 200, 255)
+
+    These attributes can be accessed either using named attributes, or via
+    sequence indexes::
+
+        >>> my_color.red == my_color[0] == 50
+        True
+        >>> my_color.green == my_color[1] == 100
+        True
+        >>> my_color.blue == my_color[2] == 200
+        True
+        >>> my_color.alpha == my_color[3] == 255
+        True
+
+    Color instances can be compared using ``==`` and ``!=``, either to another
+    Color instance, or to any mutable sequence type with the correct number of
+    items::
+
+        >>> my_color == [50, 100, 200, 255]
+        True
+        >>> my_color != Color(5, 10, 0, 0)
+        True
+
+    """
+
+    @property
+    def red(self):
+        return self[0]
+
+    @property
+    def green(self):
+        return self[1]
+
+    @property
+    def blue(self):
+        return self[2]
+
+    @property
+    def alpha(self):
+        return self[3]
+
+
+class DateTime(_array_packed_type(1)):
+
+    """The DateTime class represents a date and time in the UTC timezone.
+
+    DateTime is constructed by passing a unix timestamp in to the constructor.
+    Timestamps are expressed as the number of seconds since 1970-01-01T00:00:00
+    in the UTC timezone::
+
+        >>> my_dt = DateTime(1377209927)
+
+    This timestamp can always be accessed either using index access or via a
+    named property::
+
+        >>> my_dt[0] == my_dt.timestamp == 1377209927
+        True
+
+    DateTime objects also expose the usual named properties you would expect on
+    a date/time object::
+
+        >>> my_dt.year
+        2013
+        >>> my_dt.month
+        8
+        >>> my_dt.day
+        22
+        >>> my_dt.hour
+        22
+        >>> my_dt.minute
+        18
+        >>> my_dt.second
+        47
+
+    Two DateTime objects can be compared for equality::
+
+        >>> my_dt == DateTime(1377209927)
+        True
+
+    You can also compare a DateTime with any mutable sequence type containing
+    the timestamp (although this probably isn't very useful for test authors)::
+
+        >>> my_dt == [1377209927]
+        True
+
+    Finally, you can also compare a DateTime instance with a python datetime
+    instance::
+
+        >>> my_datetime = datetime.datetime.fromutctimestamp(1377209927)
+        True
+
+    DateTime instances can be converted to datetime instances:
+
+        >>> isinstance(my_dt.datetime, datetime.datetime)
+        True
+
+    """
+    def __init__(self, *args, **kwargs):
+        super(DateTime, self).__init__(*args, **kwargs)
+        self._cached_dt = datetime.utcfromtimestamp(self[0])
+
+    @property
+    def year(self):
+        return self._cached_dt.year
+
+    @property
+    def month(self):
+        return self._cached_dt.month
+
+    @property
+    def day(self):
+        return self._cached_dt.day
+
+    @property
+    def hour(self):
+        return self._cached_dt.hour
+
+    @property
+    def minute(self):
+        return self._cached_dt.minute
+
+    @property
+    def second(self):
+        return self._cached_dt.second
+
+    @property
+    def timestamp(self):
+        return self[0]
+
+    @property
+    def datetime(self):
+        return self._cached_dt
+
+    def __eq__(self, other):
+        if isinstance(other, datetime):
+            return other == self._cached_dt
+        return super(DateTime, self).__eq__(other)
+
+
+class Time(_array_packed_type(4)):
+
+    """The Time class represents a time, without a date component.
+
+    You can construct a Time instnace by passing the hours, minutes, seconds,
+    and milliseconds to the class constructor::
+
+        >>> my_time = Time(12, 34, 01, 23)
+
+    The values passed in must be valid for their positions (ie..- 0-23 for
+    hours, 0-59 for minutes and seconds, and 0-999 for milliseconds). Passing
+    invalid values will cause a ValueError to be raised.
+
+    The hours, minutes, seconds, and milliseconds can be accessed using either
+    index access or named properties::
+
+        >>> my_time.hours == my_time[0] == 12
+        True
+        >>> my_time.minutes == my_time[1] == 34
+        True
+        >>> my_time.seconds == my_time[2] == 01
+        True
+        >>> my_time.milliseconds == my_time[3] == 23
+        True
+
+    Time instances can be compared to other time instances, any mutable
+    sequence containing four integers, or datetime.time instances::
+
+        >>> my_time == Time(12, 34, 01, 23)
+        True
+        >>> my_time == Time(1,2,3,4)
+        False
+
+        >>> my_time == [12, 34, 01, 23]
+        True
+
+        >>> my_time == datetime.time(12, 34, 01, 23000)
+        True
+
+    Note that the Time class stores milliseconds, while the ``datettime.time``
+    class stores microseconds.
+
+    Finally, you can get a ``datetime.time`` instance from a Time instance::
+
+        >>> isinstance(my_time.time, datetime.time)
+        True
+
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(Time, self).__init__(*args, **kwargs)
+        # datetime.time uses microseconds, instead of mulliseconds:
+        self._cached_time = time(self[0], self[1], self[2], self[3] * 1000)
+
+    @property
+    def hour(self):
+        return self._cached_time.hour
+
+    @property
+    def minute(self):
+        return self._cached_time.minute
+
+    @property
+    def second(self):
+        return self._cached_time.second
+
+    @property
+    def millisecond(self):
+        return self._cached_time.microsecond / 1000
+
+    @property
+    def time(self):
+        return self._cached_time
+
+    def __eq__(self, other):
+        if isinstance(other, time):
+            return other == self._cached_time
+        return super(DateTime, self).__eq__(other)
 
=== modified file 'autopilot/introspection/utilities.py'
--- autopilot/introspection/utilities.py	2013-07-30 15:08:30 +0000
+++ autopilot/introspection/utilities.py	2013-09-16 17:17:50 +0000
@@ -39,3 +39,9 @@
     bus_obj = bus.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus')
     bus_iface = Interface(bus_obj, 'org.freedesktop.DBus')
     return bus_iface.GetConnectionUnixProcessID(connection_name)
+
+
+def translate_state_keys(state_dict):
+    """Translates the *state_dict* passed in so the keys are usable as python
+    attributes."""
+    return {k.replace('-', '_'): v for k, v in state_dict.items()}
 
=== modified file 'autopilot/keybindings.py'
--- autopilot/keybindings.py	2013-09-16 14:37:29 +0000
+++ autopilot/keybindings.py	2013-09-16 17:17:50 +0000
@@ -36,8 +36,8 @@
 from __future__ import absolute_import
 
 import logging
-from types import NoneType
 import re
+import sys
 
 from autopilot.input import Keyboard
 from autopilot.utilities import Silence
@@ -45,6 +45,10 @@
 logger = logging.getLogger(__name__)
 
 
+# py2 compatible alias for py3
+if sys.version >= '3':
+    basestring = str
+
 #
 # Fill this dictionary with keybindings we want to store.
 #
@@ -262,7 +266,7 @@
         keyboard emulator.
 
         """
-        if type(delay) not in (float, NoneType):
+        if delay is not None and type(delay) != float:
             raise TypeError(
                 "delay parameter must be a float if it is defined.")
         if delay:
 
=== modified file 'autopilot/matchers/__init__.py'
--- autopilot/matchers/__init__.py	2013-08-06 20:15:11 +0000
+++ autopilot/matchers/__init__.py	2013-09-16 17:17:50 +0000
@@ -108,7 +108,7 @@
         try:
             wait_fun(self.matcher, self.timeout)
         except AssertionError as e:
-            return Mismatch(unicode(e))
+            return Mismatch(str(e))
         return None
 
     def __str__(self):
 
=== modified file 'autopilot/process/_bamf.py'
--- autopilot/process/_bamf.py	2013-08-12 16:11:03 +0000
+++ autopilot/process/_bamf.py	2013-09-16 17:17:50 +0000
@@ -168,11 +168,11 @@
                 [new_windows.extend(a.get_windows()) for a in apps]
                 filter_fn = lambda w: w.x_id not in [
                     c.x_id for c in existing_windows]
-                new_wins = filter(filter_fn, new_windows)
+                new_wins = list(filter(filter_fn, new_windows))
                 if new_wins:
                     assert len(new_wins) == 1
                     return new_wins[0]
-            except DBusException:
+            except dbus.DBusException:
                 pass
             sleep(1)
         return None
@@ -223,7 +223,7 @@
         apps = [Application(p) for p in
                 self.matcher_interface.RunningApplications()]
         if user_visible_only:
-            return filter(_filter_user_visible, apps)
+            return list(filter(_filter_user_visible, apps))
         return apps
 
     def get_running_applications_by_desktop_file(self, desktop_file):
@@ -255,7 +255,7 @@
         windows = [Window(w) for w in
                    self.matcher_interface.WindowStackForMonitor(-1)]
         if user_visible_only:
-            windows = filter(_filter_user_visible, windows)
+            windows = list(filter(_filter_user_visible, windows))
         # Now sort on stacking order.
         # We explicitly convert to a list from an iterator since tests
         # frequently try and use len() on return values from these methods.
@@ -349,8 +349,8 @@
                 self._app_proxy, 'org.ayatana.bamf.view')
             self._app_iface = dbus.Interface(
                 self._app_proxy, 'org.ayatana.bamf.application')
-        except dbus.DBusException, e:
-            e.message += 'bamf_app_path=%r' % (bamf_app_path)
+        except dbus.DBusException as e:
+            e.args += ('bamf_app_path=%r' % (bamf_app_path),)
             raise
 
     @property
@@ -413,6 +413,8 @@
         return "<Application '%s'>" % (self.name)
 
     def __eq__(self, other):
+        if other is None:
+            return False
         return self.desktop_file == other.desktop_file
 
 
@@ -611,5 +613,5 @@
         """Return a list of strings representing the current window state."""
 
         get_display().sync()
-        return map(get_display().get_atom_name, self._getProperty(
-            '_NET_WM_STATE'))
+        return [get_display().get_atom_name(p)
+                for p in self._getProperty('_NET_WM_STATE')]
 
=== modified file 'autopilot/testcase.py'
--- autopilot/testcase.py	2013-07-29 10:29:37 +0000
+++ autopilot/testcase.py	2013-09-16 17:17:50 +0000
@@ -251,7 +251,8 @@
          data is retrievable via this object.
 
         """
-        app_path = subprocess.check_output(['which', application]).strip()
+        app_path = subprocess.check_output(['which', application],
+                                           universal_newlines=True).strip()
         # Get a launcher, tests can override this if they need:
         launcher_hint = kwargs.pop('app_type', '')
         launcher = None
@@ -294,8 +295,8 @@
         new_apps = []
         for i in range(10):
             current_apps = self.process_manager.get_running_applications()
-            new_apps = filter(
-                lambda i: i not in self._app_snapshot, current_apps)
+            new_apps = list(filter(
+                lambda i: i not in self._app_snapshot, current_apps))
             if not new_apps:
                 self._app_snapshot = None
                 return
@@ -399,7 +400,7 @@
         if not kwargs:
             raise ValueError("At least one keyword argument must be present.")
 
-        for prop_name, desired_value in kwargs.iteritems():
+        for prop_name, desired_value in kwargs.items():
             none_val = object()
             attr = getattr(obj, prop_name, none_val)
             if attr == none_val:
 
=== modified file 'autopilot/tests/functional/test_ap_apps.py'
--- autopilot/tests/functional/test_ap_apps.py	2013-07-30 15:08:30 +0000
+++ autopilot/tests/functional/test_ap_apps.py	2013-09-16 17:17:50 +0000
@@ -23,9 +23,10 @@
 import stat
 import subprocess
 import logging
+import sys
 from mock import patch
 from tempfile import mktemp
-from testtools.matchers import raises, LessThan, Equals
+from testtools.matchers import raises, LessThan
 from textwrap import dedent
 from time import sleep
 
@@ -37,6 +38,10 @@
 )
 
 
+# backwards compatible alias for Python 3
+if sys.version > '3':
+    xrange = range
+
 logger = logging.getLogger(__name__)
 
 
@@ -90,14 +95,14 @@
 
         """
         path = self.write_script(dedent("""\
-            #!/usr/bin/python
+            #!%s
 
             from time import sleep
 
             while True:
-                print "Still running"
+                print("Still running")
                 sleep(1)
-        """))
+        """ % sys.executable))
 
         expected_error = "Search criteria returned no results"
         self.assertThat(
@@ -123,14 +128,14 @@
 
         """
         path = self.write_script(dedent("""\
-            #!/usr/bin/python
+            #!%s
 
             from time import sleep
             import sys
 
             sleep(5)
             sys.exit(1)
-        """))
+        """ % sys.executable))
 
         expected_error = "Process exited with exit code: 1"
         self.assertThat(
@@ -148,14 +153,14 @@
 
         """
         path = self.write_script(dedent("""\
-            #!/usr/bin/python
+            #!%s
 
             from time import sleep
             import sys
 
             sleep(1)
             sys.exit(1)
-        """))
+        """ % sys.executable))
         start = datetime.datetime.now()
 
         try:
@@ -177,7 +182,7 @@
 
         """
         path = self.write_script(dedent("""\
-            #!/usr/bin/python
+            #!%s
             from PyQt4.QtGui import QMainWindow, QApplication
             from PyQt4.QtCore import QTimer
 
@@ -188,7 +193,7 @@
             win.show()
             QTimer.singleShot(8000, app.exit)
             app.exec_()
-            """))
+            """ % sys.executable))
         app_proxy = self.launch_test_application(path, app_type='qt')
         self.assertTrue(app_proxy is not None)
 
@@ -214,7 +219,8 @@
         # We cannot use 'which', as qtchooser installs wrappers - we need to
         # check in the actual library paths
         env = subprocess.check_output(
-            ['qtchooser', '-qt=' + version, '-print-env']).split('\n')
+            ['qtchooser', '-qt=' + version, '-print-env'],
+            universal_newlines=True).split('\n')
         for i in env:
             if i.find('QTTOOLDIR') >= 0:
                 path = i.lstrip("QTTOOLDIR=").strip('"') + "/" + name
@@ -226,7 +232,8 @@
     def _find_qt_binary_old(self, version, name):
         # Check for the existence of the binary the old way
         try:
-            path = subprocess.check_output(['which', 'qmlviewer']).strip()
+            path = subprocess.check_output(['which', 'qmlviewer'],
+                                           universal_newlines=True).strip()
         except subprocess.CalledProcessError:
             path = None
         return path
@@ -236,7 +243,9 @@
 
         try:
             qtversions = subprocess.check_output(
-                ['qtchooser', '-list-versions']).split('\n')
+                ['qtchooser', '-list-versions'],
+                universal_newlines=True
+            ).split('\n')
             check_func = self._find_qt_binary_chooser
         except OSError:
             # This means no qtchooser is installed, so let's check for
@@ -268,7 +277,7 @@
 
     def test_can_launch_qt_script(self):
         path = self.write_script(dedent("""\
-            #!/usr/bin/python
+            #!%s
             from PyQt4.QtGui import QMainWindow, QApplication
             from sys import argv
 
@@ -276,13 +285,13 @@
             win = QMainWindow()
             win.show()
             app.exec_()
-            """))
+            """ % sys.executable))
         app_proxy = self.launch_test_application(path, app_type='qt')
         self.assertTrue(app_proxy is not None)
 
     def test_can_launch_wrapper_script(self):
         path = self.write_script(dedent("""\
-            #!/usr/bin/python
+            #!%s
             from PyQt4.QtGui import QMainWindow, QApplication
             from sys import argv
 
@@ -290,7 +299,7 @@
             win = QMainWindow()
             win.show()
             app.exec_()
-            """))
+            """ % sys.executable))
         wrapper_path = self.write_script(dedent("""\
             #!/bin/sh
 
@@ -309,7 +318,7 @@
 
         try:
             self.app_path = subprocess.check_output(
-                ['which', 'gnome-mahjongg']).strip()
+                ['which', 'gnome-mahjongg'], universal_newlines=True).strip()
         except subprocess.CalledProcessError:
             self.skip("gnome-mahjongg not found.")
 
@@ -319,27 +328,27 @@
 
     def test_can_launch_gtk_script(self):
         path = self.write_script(dedent("""\
-            #!/usr/bin/python
+            #!%s
             from gi.repository import Gtk
 
             win = Gtk.Window()
             win.connect("delete-event", Gtk.main_quit)
             win.show_all()
             Gtk.main()
-            """))
+            """ % sys.executable))
         app_proxy = self.launch_test_application(path, app_type='gtk')
         self.assertTrue(app_proxy is not None)
 
     def test_can_launch_wrapper_script(self):
         path = self.write_script(dedent("""\
-            #!/usr/bin/python
+            #!%s
             from gi.repository import Gtk
 
             win = Gtk.Window()
             win.connect("delete-event", Gtk.main_quit)
             win.show_all()
             Gtk.main()
-            """))
+            """ % sys.executable))
         wrapper_path = self.write_script(dedent("""\
             #!/bin/sh
 
 
=== modified file 'autopilot/tests/functional/test_autopilot_functional.py'
--- autopilot/tests/functional/test_autopilot_functional.py	2013-08-29 06:46:41 +0000
+++ autopilot/tests/functional/test_autopilot_functional.py	2013-09-16 17:17:50 +0000
@@ -99,7 +99,8 @@
             environment_patch['PYTHONPATH'] = ap_base_path
         bin_path = os.path.join(ap_base_path, 'bin', 'autopilot')
         if not os.path.exists(bin_path):
-            bin_path = subprocess.check_output(['which', 'autopilot']).strip()
+            bin_path = subprocess.check_output(['which', 'autopilot'],
+                                               universal_newlines=True).strip()
             logger.info(
                 "Not running from source, setting bin_path to %s", bin_path)
 
@@ -119,6 +120,7 @@
             env=environ,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            universal_newlines=True,
         )
 
         stdout, stderr = process.communicate()
@@ -173,7 +175,7 @@
 
         if type(tests) is not list:
             raise TypeError("tests must be a list, not %r" % type(tests))
-        if not isinstance(output, basestring):
+        if not isinstance(output, str):
             raise TypeError("output must be a string, not %r" % type(output))
 
         test_names = ''.join(['    %s\n' % t for t in sorted(tests)])
@@ -738,7 +740,7 @@
 
         self.assertThat(code, Equals(1))
         self.assertTrue(os.path.exists(output_file_path))
-        log_contents = unicode(open(output_file_path, encoding='utf-8').read())
+        log_contents = open(output_file_path, encoding='utf-8').read()
         self.assertThat(
             log_contents,
             Contains(u'\xa1pl\u0279oM \u01ddpo\u0254\u0131u\u2229 oll\u01ddH'))
@@ -773,7 +775,7 @@
 
         self.assertThat(code, Equals(1))
         self.assertTrue(os.path.exists(output_file_path))
-        log_contents = unicode(open(output_file_path, encoding='utf-8').read())
+        log_contents = open(output_file_path, encoding='utf-8').read()
         self.assertThat(
             log_contents,
             Contains(u'\xa1pl\u0279oM \u01ddpo\u0254\u0131u\u2229 oll\u01ddH'))
 
=== modified file 'autopilot/tests/functional/test_dbus_query.py'
--- autopilot/tests/functional/test_dbus_query.py	2013-07-29 10:29:37 +0000
+++ autopilot/tests/functional/test_dbus_query.py	2013-09-16 17:17:50 +0000
@@ -73,6 +73,18 @@
         main_window = app.select_single('QMainWindow')
         self.assertThat(main_window, NotEquals(None))
 
+    def test_can_select_parent_of_root(self):
+        """Must be able to select the parent of the root object."""
+        root = self.start_fully_featured_app()
+        root_parent = root.get_parent()
+        self.assertThat(root.id, Equals(root_parent.id))
+
+    def test_can_select_parent_of_normal_node(self):
+        root = self.start_fully_featured_app()
+        main_window = root.select_single('QMainWindow')
+        window_parent = main_window.get_parent()
+        self.assertThat(window_parent.id, Equals(root.id))
+
     def test_single_select_on_object(self):
         """Must be able to select a single unique child of an object."""
         app = self.start_fully_featured_app()
@@ -156,7 +168,7 @@
     def test_select_many_only_using_parameters(self):
         app = self.start_fully_featured_app()
         many_help_menus = app.select_many(title='Help')
-        self.assertThat(len(many_help_menus), Equals(2))
+        self.assertThat(len(many_help_menus), Equals(1))
 
     def test_select_many_with_no_parameter_matches_returns_empty_list(self):
         app = self.start_fully_featured_app()
@@ -172,7 +184,8 @@
         super(DbusCustomBusTests, self).setUp()
 
     def _enable_custom_dbus_bus(self):
-        p = subprocess.Popen(['dbus-launch'], stdout=subprocess.PIPE)
+        p = subprocess.Popen(['dbus-launch'], stdout=subprocess.PIPE,
+                             universal_newlines=True)
         output = p.communicate()
         results = output[0].split("\n")
         dbus_pid = int(results[1].split("=")[1])
 
=== modified file 'autopilot/tests/functional/test_input_stack.py'
--- autopilot/tests/functional/test_input_stack.py	2013-09-04 03:44:07 +0000
+++ autopilot/tests/functional/test_input_stack.py	2013-09-16 17:17:50 +0000
@@ -27,11 +27,13 @@
 from unittest import SkipTest
 from mock import patch
 
+from autopilot.display import Display
 from autopilot import platform
 from autopilot.testcase import AutopilotTestCase, multiply_scenarios
 from autopilot.input import Keyboard, Mouse, Pointer, Touch
 from autopilot.input._common import get_center_point
 from autopilot.matchers import Eventually
+from autopilot.testcase import AutopilotTestCase, multiply_scenarios
 from autopilot.utilities import on_test_started
 
 
@@ -274,9 +276,12 @@
         LP bug #1195499.
 
         """
+        screen_geometry = Display.create().get_screen_geometry(0)
         device = Mouse.create()
-        device.move(10, 10.6)
-        self.assertEqual(device.position(), (10, 10))
+        target_x = screen_geometry[0] + 10
+        target_y = screen_geometry[1] + 10.6
+        device.move(target_x, target_y)
+        self.assertEqual(device.position(), (target_x, int(target_y)))
 
     @patch('autopilot.platform.model', new=lambda *args: "Not Desktop", )
     def test_mouse_creation_on_device_raises_useful_error(self):
 
=== modified file 'autopilot/tests/functional/test_introspection_features.py'
--- autopilot/tests/functional/test_introspection_features.py	2013-07-14 09:22:48 +0000
+++ autopilot/tests/functional/test_introspection_features.py	2013-09-16 17:17:50 +0000
@@ -104,7 +104,8 @@
 
             def launch_test_qml(self):
                 arch = subprocess.check_output(
-                    ["dpkg-architecture", "-qDEB_HOST_MULTIARCH"]).strip()
+                    ["dpkg-architecture", "-qDEB_HOST_MULTIARCH"],
+                    universal_newlines=True).strip()
                 qml_path = tempfile.mktemp(suffix='.qml')
                 open(qml_path, 'w').write(self.test_qml)
                 self.addCleanup(os.remove, qml_path)
 
=== modified file 'autopilot/tests/functional/test_open_window.py'
--- autopilot/tests/functional/test_open_window.py	2013-07-14 09:17:37 +0000
+++ autopilot/tests/functional/test_open_window.py	2013-09-16 17:17:50 +0000
@@ -31,7 +31,7 @@
 class OpenWindowTests(AutopilotTestCase):
 
     scenarios = [
-        (k, {'app_name': k}) for k in ProcessManager.KNOWN_APPS.iterkeys()]
+        (k, {'app_name': k}) for k in ProcessManager.KNOWN_APPS.keys()]
 
     def test_open_window(self):
         """self.start_app_window must open a new window of the given app."""
 
=== modified file 'autopilot/tests/functional/test_process_emulator.py'
--- autopilot/tests/functional/test_process_emulator.py	2013-07-24 04:45:13 +0000
+++ autopilot/tests/functional/test_process_emulator.py	2013-09-16 17:17:50 +0000
@@ -96,7 +96,7 @@
         try:
             process_manager = ProcessManager.create(preferred_backend="BAMF")
         except BackendException as e:
-            self.skip("Test is only for BAMF backend ({}).".format(e.message))
+            self.skip("Test is only for BAMF backend ({}).".format(str(e)))
 
         process_manager.start_app('Calculator')
 
 
=== modified file 'autopilot/tests/unit/test_command_line_args.py'
--- autopilot/tests/unit/test_command_line_args.py	2013-07-22 03:40:32 +0000
+++ autopilot/tests/unit/test_command_line_args.py	2013-09-16 17:17:50 +0000
@@ -23,7 +23,14 @@
 
 
 from mock import patch
-from StringIO import StringIO
+
+try:
+    # Python 2
+    from StringIO import StringIO
+except ImportError:
+    # Python 3
+    from io import StringIO
+
 from testtools import TestCase
 from testtools.matchers import Equals
 from unittest import expectedFailure
@@ -34,7 +41,7 @@
 class CommandLineArgsTests(TestCase):
 
     def parse_args(self, args):
-        if isinstance(args, basestring):
+        if isinstance(args, str):
             args = args.split()
         try:
             return parse_arguments(args)
 
=== modified file 'autopilot/tests/unit/test_custom_exceptions.py'
--- autopilot/tests/unit/test_custom_exceptions.py	2013-07-22 03:39:30 +0000
+++ autopilot/tests/unit/test_custom_exceptions.py	2013-09-16 17:17:50 +0000
@@ -30,7 +30,7 @@
         """BackendException must be able to wrap another exception instance."""
         err = BackendException(RuntimeError("Hello World"))
         self.assertThat(err.original_exception, IsInstance(RuntimeError))
-        self.assertThat(err.original_exception.message, Equals("Hello World"))
+        self.assertThat(str(err.original_exception), Equals("Hello World"))
 
     def test_dunder_str(self):
         err = BackendException(RuntimeError("Hello World"))
 
=== modified file 'autopilot/tests/unit/test_introspection_features.py'
--- autopilot/tests/unit/test_introspection_features.py	2013-08-08 20:33:14 +0000
+++ autopilot/tests/unit/test_introspection_features.py	2013-09-16 17:17:50 +0000
@@ -24,8 +24,9 @@
 
 
 from autopilot.introspection.dbus import (
+    _get_filter_string_for_key_value_pair,
+    _is_valid_server_side_filter_param,
     CustomEmulatorBase,
-    _is_valid_server_side_filter_param,
 )
 
 
@@ -69,10 +70,19 @@
     scenarios = [
         ('should work', dict(key='keyname', value='value', result=True)),
         ('invalid key', dict(key='k  e', value='value', result=False)),
-        ('invalid value', dict(key='key', value='v  e', result=False)),
-        ('invalid value2', dict(key='key', value='v?e', result=False)),
-        ('invalid value3', dict(key='key', value='1/2', result=False)),
-        ('invalid value type', dict(key='key', value=False, result=False)),
+        ('string value', dict(key='key', value='v  e', result=True)),
+        ('string value2', dict(key='key', value='v?e', result=True)),
+        ('string value3', dict(key='key', value='1/2."!@#*&^%', result=True)),
+        ('bool value', dict(key='key', value=False, result=True)),
+        ('int value', dict(key='key', value=123, result=True)),
+        ('int value2', dict(key='key', value=-123, result=True)),
+        ('float value', dict(key='key', value=1.0, result=False)),
+        ('dict value', dict(key='key', value={}, result=False)),
+        ('obj value', dict(key='key', value=TestCase, result=False)),
+        ('int overflow 1', dict(key='key', value=-2147483648, result=True)),
+        ('int overflow 2', dict(key='key', value=-2147483649, result=False)),
+        ('int overflow 3', dict(key='key', value=2147483647, result=True)),
+        ('int overflow 4', dict(key='key', value=2147483648, result=False)),
     ]
 
     def test_valid_server_side_param(self):
@@ -80,3 +90,24 @@
             _is_valid_server_side_filter_param(self.key, self.value),
             Equals(self.result)
         )
+
+
+class ServerSideParameterFilterStringTests(TestWithScenarios, TestCase):
+
+    scenarios = [
+        ('bool true', dict(k='visible', v=True, r="visible=True")),
+        ('bool false', dict(k='visible', v=False, r="visible=False")),
+        ('int +ve', dict(k='size', v=123, r="size=123")),
+        ('int -ve', dict(k='prio', v=-12, r="prio=-12")),
+        ('simple string', dict(k='Name', v="btn1", r="Name=\"btn1\"")),
+        ('string space', dict(k='Name', v="a b  c ", r="Name=\"a b  c \"")),
+        ('str escapes', dict(
+            k='a',
+            v="\a\b\f\n\r\t\v\\",
+            r=r'a="\x07\x08\x0c\n\r\t\x0b\\"')),
+        ('escape quotes', dict(k='b', v="'", r='b="\\' + "'" + '"')),
+    ]
+
+    def test_query_string(self):
+        s = _get_filter_string_for_key_value_pair(self.k, self.v)
+        self.assertThat(s, Equals(self.r))
 
=== modified file 'autopilot/tests/unit/test_matchers.py'
--- autopilot/tests/unit/test_matchers.py	2013-08-07 03:18:32 +0000
+++ autopilot/tests/unit/test_matchers.py	2013-09-16 17:17:50 +0000
@@ -20,9 +20,12 @@
 
 from __future__ import absolute_import
 
+import sys
+
 from autopilot.introspection.dbus import DBusIntrospectionObject
 from autopilot.matchers import Eventually
 
+from contextlib import contextmanager
 import dbus
 from testscenarios import TestWithScenarios
 from testtools import TestCase
@@ -30,7 +33,6 @@
     Contains,
     Equals,
     IsInstance,
-    LessThan,
     MatchesException,
     Mismatch,
     Raises,
@@ -38,6 +40,23 @@
 from time import time
 
 
+if sys.version >= '3':
+    unicode = str
+
+
+@contextmanager
+def expected_runtime(tmin, tmax):
+    start = time()
+    try:
+        yield
+    finally:
+        elapsed_time = abs(time() - start)
+        if not tmin < elapsed_time < tmax:
+            raise AssertionError(
+                "Runtime of %f is not between %f and %f"
+                % (elapsed_time, tmin, tmax))
+
+
 def make_fake_attribute_with_result(result, attribute_type='wait_for'):
     """Make a fake attribute with the given result.
 
@@ -58,13 +77,15 @@
         return lambda: result
     elif attribute_type == 'wait_for':
         if isinstance(result, unicode):
-            obj = FakeObject(dict(id=123, attr=dbus.String(result)))
+            obj = FakeObject(dict(id=[0, 123], attr=[0, dbus.String(result)]))
             return obj.attr
-        elif isinstance(result, str):
-            obj = FakeObject(dict(id=123, attr=dbus.UTF8String(result)))
+        elif isinstance(result, bytes):
+            obj = FakeObject(
+                dict(id=[0, 123], attr=[0, dbus.UTF8String(result)])
+            )
             return obj.attr
         else:
-            obj = FakeObject(dict(id=123, attr=dbus.Boolean(result)))
+            obj = FakeObject(dict(id=[0, 123], attr=[0, dbus.Boolean(result)]))
             return obj.attr
 
 
@@ -84,37 +105,31 @@
         ('wait_for', dict(attribute_type='wait_for')),
     ]
 
-    def test_eventually_matcher_returns_Mismatch(self):
+    def test_eventually_matcher_returns_mismatch(self):
         """Eventually matcher must return a Mismatch."""
         attr = make_fake_attribute_with_result(False, self.attribute_type)
-        e = Eventually(Equals(True)).match(lambda: attr)
+        e = Eventually(Equals(True)).match(attr)
 
         self.assertThat(e, IsInstance(Mismatch))
 
     def test_eventually_default_timeout(self):
         """Eventually matcher must default to 10 second timeout."""
         attr = make_fake_attribute_with_result(False, self.attribute_type)
-        start = time()
-        Eventually(Equals(True)).match(attr)
-        # max error of 1 second seems reasonable:
-        self.assertThat(abs(time() - start - 10.0), LessThan(1))
+        with expected_runtime(9.5, 11.0):
+            Eventually(Equals(True)).match(attr)
 
     def test_eventually_passes_immeadiately(self):
         """Eventually matcher must not wait if the assertion passes
         initially."""
-        start = time()
         attr = make_fake_attribute_with_result(True, self.attribute_type)
-        Eventually(Equals(True)).match(attr)
-        # max error of 1 second seems reasonable:
-        self.assertThat(abs(time() - start), LessThan(1))
+        with expected_runtime(0.0, 1.0):
+            Eventually(Equals(True)).match(attr)
 
     def test_eventually_matcher_allows_non_default_timeout(self):
         """Eventually matcher must allow a non-default timeout value."""
-        start = time()
         attr = make_fake_attribute_with_result(False, self.attribute_type)
-        Eventually(Equals(True), timeout=5).match(attr)
-        # max error of 1 second seems reasonable:
-        self.assertThat(abs(time() - start - 5.0), LessThan(1))
+        with expected_runtime(4.5, 6.0):
+            Eventually(Equals(True), timeout=5).match(attr)
 
     def test_mismatch_message_has_correct_timeout_value(self):
         """The mismatch value must have the correct timeout value in it."""
@@ -134,20 +149,16 @@
 
     def test_match_with_expected_value_unicode(self):
         """The expected unicode value matches new value string."""
-        start = time()
         attr = make_fake_attribute_with_result(
-            unicode(u'\u963f\u5e03\u4ece'), 'wait_for')
-        Eventually(Equals(str("阿布从"))).match(attr)
-        #this should not take more than 1 second
-        self.assertThat(abs(time() - start), LessThan(1))
+            u'\u963f\u5e03\u4ece', 'wait_for')
+        with expected_runtime(0.0, 1.0):
+            Eventually(Equals("阿布从")).match(attr)
 
     def test_match_with_new_value_unicode(self):
         """new value with unicode must match expected value string."""
-        start = time()
         attr = make_fake_attribute_with_result(str("阿布从"), 'wait_for')
-        Eventually(Equals(unicode(u'\u963f\u5e03\u4ece'))).match(attr)
-        # this should not take more than 1 second
-        self.assertThat(abs(time() - start), LessThan(1))
+        with expected_runtime(0.0, 1.0):
+            Eventually(Equals(u'\u963f\u5e03\u4ece')).match(attr)
 
     def test_mismatch_with_bool(self):
         """The mismatch value must fail boolean values."""
@@ -160,7 +171,7 @@
         """The mismatch value must fail with str and unicode mix."""
         attr = make_fake_attribute_with_result(str("阿布从1"), 'wait_for')
         mismatch = Eventually(Equals(
-            unicode(u'\u963f\u5e03\u4ece')), timeout=.5).match(attr)
+            u'\u963f\u5e03\u4ece'), timeout=.5).match(attr)
         self.assertThat(
             mismatch.describe(), Contains('failed'))
 
@@ -169,6 +180,6 @@
         self.skip("mismatch Contains returns ascii error")
         attr = make_fake_attribute_with_result(str("阿布从1"), 'wait_for')
         mismatch = Eventually(Equals(
-            unicode(u'\u963f\u5e03\u4ece')), timeout=.5).match(attr)
+            u'\u963f\u5e03\u4ece'), timeout=.5).match(attr)
         self.assertThat(
             mismatch.describe(), Contains("阿布从11"))
 
=== modified file 'autopilot/tests/unit/test_pick_backend.py'
--- autopilot/tests/unit/test_pick_backend.py	2013-07-22 03:30:31 +0000
+++ autopilot/tests/unit/test_pick_backend.py	2013-09-16 17:17:50 +0000
@@ -107,7 +107,7 @@
             raised = True
             self.assertTrue(hasattr(e, 'original_exception'))
             self.assertThat(e.original_exception, IsInstance(ValueError))
-            self.assertThat(e.original_exception.message, Equals("Foo"))
+            self.assertThat(str(e.original_exception), Equals("Foo"))
         self.assertTrue(raised)
 
     def test_failure_of_all_backends(self):
 
=== modified file 'autopilot/tests/unit/test_platform.py'
--- autopilot/tests/unit/test_platform.py	2013-07-24 00:07:54 +0000
+++ autopilot/tests/unit/test_platform.py	2013-09-16 17:17:50 +0000
@@ -21,7 +21,13 @@
 
 import autopilot.platform as platform
 
-from StringIO import StringIO
+try:
+    # Python 2
+    from StringIO import StringIO
+except ImportError:
+    # Python 3
+    from io import StringIO
+
 from testtools import TestCase
 from testtools.matchers import Equals
 
 
=== added file 'autopilot/tests/unit/test_types.py'
--- autopilot/tests/unit/test_types.py	1970-01-01 00:00:00 +0000
+++ autopilot/tests/unit/test_types.py	2013-09-16 17:17:50 +0000
@@ -0,0 +1,579 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Autopilot Functional Test Tool
+# Copyright (C) 2013 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from __future__ import absolute_import
+
+from datetime import datetime, time
+from mock import patch
+from testscenarios import TestWithScenarios
+from testtools import TestCase
+from testtools.matchers import Equals, IsInstance, NotEquals, raises
+import dbus
+
+from autopilot.introspection.types import (
+    Color,
+    create_value_instance,
+    DateTime,
+    PlainType,
+    Point,
+    Rectangle,
+    Size,
+    Time,
+    ValueType,
+)
+from autopilot.introspection.dbus import DBusIntrospectionObject
+
+
+class FakeObject(object):
+
+    def __init__(self):
+        self.get_new_state_called = False
+        self.set_properties_called = False
+
+    def get_new_state(self):
+        self.get_new_state_called = True
+
+    def _set_properties(self, state):
+        self.set_properties_called = True
+
+
+class PlainTypeTests(TestWithScenarios, TestCase):
+
+    scenarios = [
+        ('bool true', dict(t=dbus.Boolean, v=True)),
+        ('bool false', dict(t=dbus.Boolean, v=False)),
+        ('int16 +ve', dict(t=dbus.Int16, v=123)),
+        ('int16 -ve', dict(t=dbus.Int16, v=-23000)),
+        ('int32 +ve', dict(t=dbus.Int32, v=30000000)),
+        ('int32 -ve', dict(t=dbus.Int32, v=-3002050)),
+        ('int64 +ve', dict(t=dbus.Int64, v=234234002050)),
+        ('int64 -ve', dict(t=dbus.Int64, v=-234234002050)),
+        ('string', dict(t=dbus.String, v="Hello World")),
+    ]
+
+    def test_can_construct(self):
+        p = PlainType(self.t(self.v))
+
+        self.assertThat(p, Equals(self.v))
+        self.assertThat(hasattr(p, 'wait_for'), Equals(True))
+        self.assertThat(p, IsInstance(self.t))
+
+
+class RectangleTypeTests(TestCase):
+
+    def test_can_construct_rectangle(self):
+        r = Rectangle(1, 2, 3, 4)
+        self.assertThat(r, IsInstance(dbus.Array))
+
+    def test_rectangle_has_xywh_properties(self):
+        r = Rectangle(1, 2, 3, 4)
+
+        self.assertThat(r.x, Equals(1))
+        self.assertThat(r.y, Equals(2))
+        self.assertThat(r.w, Equals(3))
+        self.assertThat(r.width, Equals(3))
+        self.assertThat(r.h, Equals(4))
+        self.assertThat(r.height, Equals(4))
+
+    def test_rectangle_has_slice_access(self):
+        r = Rectangle(1, 2, 3, 4)
+
+        self.assertThat(r[0], Equals(1))
+        self.assertThat(r[1], Equals(2))
+        self.assertThat(r[2], Equals(3))
+        self.assertThat(r[3], Equals(4))
+
+    def test_equality_with_rectangle(self):
+        r1 = Rectangle(1, 2, 3, 4)
+        r2 = Rectangle(1, 2, 3, 4)
+
+        self.assertThat(r1, Equals(r2))
+
+    def test_equality_with_list(self):
+        r1 = Rectangle(1, 2, 3, 4)
+        r2 = [1, 2, 3, 4]
+
+        self.assertThat(r1, Equals(r2))
+
+
+class PointTypeTests(TestCase):
+
+    def test_can_construct_point(self):
+        r = Point(1, 2)
+        self.assertThat(r, IsInstance(dbus.Array))
+
+    def test_point_has_xy_properties(self):
+        r = Point(1, 2)
+
+        self.assertThat(r.x, Equals(1))
+        self.assertThat(r.y, Equals(2))
+
+    def test_point_has_slice_access(self):
+        r = Point(1, 2)
+
+        self.assertThat(r[0], Equals(1))
+        self.assertThat(r[1], Equals(2))
+
+    def test_equality_with_point(self):
+        p1 = Point(1, 2)
+        p2 = Point(1, 2)
+
+        self.assertThat(p1, Equals(p2))
+
+    def test_equality_with_list(self):
+        p1 = Point(1, 2)
+        p2 = [1, 2]
+
+        self.assertThat(p1, Equals(p2))
+
+
+class SizeTypeTests(TestCase):
+
+    def test_can_construct_size(self):
+        r = Size(1, 2)
+        self.assertThat(r, IsInstance(dbus.Array))
+
+    def test_size_has_wh_properties(self):
+        r = Size(1, 2)
+
+        self.assertThat(r.w, Equals(1))
+        self.assertThat(r.width, Equals(1))
+        self.assertThat(r.h, Equals(2))
+        self.assertThat(r.height, Equals(2))
+
+    def test_size_has_slice_access(self):
+        r = Size(1, 2)
+
+        self.assertThat(r[0], Equals(1))
+        self.assertThat(r[1], Equals(2))
+
+    def test_equality_with_size(self):
+        s1 = Size(50, 100)
+        s2 = Size(50, 100)
+
+        self.assertThat(s1, Equals(s2))
+
+    def test_equality_with_list(self):
+        s1 = Size(50, 100)
+        s2 = [50, 100]
+
+        self.assertThat(s1, Equals(s2))
+
+
+class ColorTypeTests(TestCase):
+
+    def test_can_construct_color(self):
+        r = Color(123, 234, 55, 255)
+        self.assertThat(r, IsInstance(dbus.Array))
+
+    def test_color_has_rgba_properties(self):
+        r = Color(123, 234, 55, 255)
+
+        self.assertThat(r.red, Equals(123))
+        self.assertThat(r.green, Equals(234))
+        self.assertThat(r.blue, Equals(55))
+        self.assertThat(r.alpha, Equals(255))
+
+    def test_color_has_slice_access(self):
+        r = Color(123, 234, 55, 255)
+
+        self.assertThat(r[0], Equals(123))
+        self.assertThat(r[1], Equals(234))
+        self.assertThat(r[2], Equals(55))
+        self.assertThat(r[3], Equals(255))
+
+    def test_eqiality_with_color(self):
+        c1 = Color(123, 234, 55, 255)
+        c2 = Color(123, 234, 55, 255)
+
+        self.assertThat(c1, Equals(c2))
+
+    def test_eqiality_with_list(self):
+        c1 = Color(123, 234, 55, 255)
+        c2 = [123, 234, 55, 255]
+
+        self.assertThat(c1, Equals(c2))
+
+
+class DateTimeTests(TestCase):
+
+    def test_can_construct_datetime(self):
+        dt = DateTime(1377209927)
+        self.assertThat(dt, IsInstance(dbus.Array))
+
+    def test_datetime_has_slice_access(self):
+        dt = DateTime(1377209927)
+
+        self.assertThat(dt[0], Equals(1377209927))
+
+    def test_datetime_has_properties(self):
+        dt = DateTime(1377209927)
+
+        self.assertThat(dt.timestamp, Equals(1377209927))
+        self.assertThat(dt.year, Equals(2013))
+        self.assertThat(dt.month, Equals(8))
+        self.assertThat(dt.day, Equals(22))
+        self.assertThat(dt.hour, Equals(22))
+        self.assertThat(dt.minute, Equals(18))
+        self.assertThat(dt.second, Equals(47))
+
+    def test_equality_with_datetime(self):
+        dt1 = DateTime(1377209927)
+        dt2 = DateTime(1377209927)
+
+        self.assertThat(dt1, Equals(dt2))
+
+    def test_equality_with_list(self):
+        dt1 = DateTime(1377209927)
+        dt2 = [1377209927]
+
+        self.assertThat(dt1, Equals(dt2))
+
+    def test_equality_with_datetime(self):
+        dt1 = DateTime(1377209927)
+        dt2 = datetime.utcfromtimestamp(1377209927)
+        dt3 = datetime.utcfromtimestamp(1377209928)
+
+        self.assertThat(dt1, Equals(dt2))
+        self.assertThat(dt1, NotEquals(dt3))
+
+    def test_can_convert_to_datetime(self):
+        dt1 = DateTime(1377209927)
+
+        self.assertThat(dt1.datetime, IsInstance(datetime))
+
+
+class TimeTests(TestCase):
+
+    def test_can_construct_time(self):
+        dt = Time(0, 0, 0, 0)
+        self.assertThat(dt, IsInstance(dbus.Array))
+
+    def test_time_has_slice_access(self):
+        dt = Time(0, 1, 2, 3)
+
+        self.assertThat(dt[0], Equals(0))
+        self.assertThat(dt[1], Equals(1))
+        self.assertThat(dt[2], Equals(2))
+        self.assertThat(dt[3], Equals(3))
+
+    def test_time_has_properties(self):
+        dt = Time(0, 1, 2, 3)
+
+        self.assertThat(dt.hour, Equals(0))
+        self.assertThat(dt.minute, Equals(1))
+        self.assertThat(dt.second, Equals(2))
+        self.assertThat(dt.millisecond, Equals(3))
+
+    def test_equality_with_time(self):
+        dt1 = Time(0, 1, 2, 3)
+        dt2 = Time(0, 1, 2, 3)
+        dt3 = Time(4, 1, 2, 3)
+
+        self.assertThat(dt1, Equals(dt2))
+        self.assertThat(dt1, NotEquals(dt3))
+
+    def test_equality_with_time(self):
+        dt1 = Time(0, 1, 2, 3)
+        dt2 = [0, 1, 2, 3]
+        dt3 = [4, 1, 2, 3]
+
+        self.assertThat(dt1, Equals(dt2))
+        self.assertThat(dt1, NotEquals(dt3))
+
+    def test_equality_with_time(self):
+        dt1 = Time(2, 3, 4, 5)
+        dt2 = time(2, 3, 4, 5000)
+        dt3 = time(5, 4, 3, 2000)
+
+        self.assertThat(dt1, Equals(dt2))
+        self.assertThat(dt1, NotEquals(dt3))
+
+    def test_can_convert_to_time(self):
+        dt1 = Time(1, 2, 3, 4)
+
+        self.assertThat(dt1.time, IsInstance(time))
+
+
+class CreateValueInstanceTests(TestCase):
+
+    """Tests to check that create_value_instance does the right thing."""
+
+    def test_plain_string(self):
+        data = dbus.Array([dbus.Int32(ValueType.PLAIN), dbus.String("Hello")])
+        attr = create_value_instance(data, None, None)
+
+        self.assertThat(attr, Equals("Hello"))
+        self.assertThat(attr, IsInstance(PlainType))
+
+    def test_plain_boolean(self):
+        data = dbus.Array([dbus.Int32(ValueType.PLAIN), dbus.Boolean(False)])
+        attr = create_value_instance(data, None, None)
+
+        self.assertThat(attr, Equals(False))
+        self.assertThat(attr, IsInstance(PlainType))
+
+    def test_plain_int16(self):
+        data = dbus.Array([dbus.Int32(ValueType.PLAIN), dbus.Int16(-2**14)])
+        attr = create_value_instance(data, None, None)
+
+        self.assertThat(attr, Equals(-2**14))
+        self.assertThat(attr, IsInstance(PlainType))
+
+    def test_plain_int32(self):
+        data = dbus.Array([dbus.Int32(ValueType.PLAIN), dbus.Int32(-2**30)])
+        attr = create_value_instance(data, None, None)
+
+        self.assertThat(attr, Equals(-2**30))
+        self.assertThat(attr, IsInstance(PlainType))
+
+    def test_plain_int64(self):
+        data = dbus.Array([dbus.Int32(ValueType.PLAIN), dbus.Int64(-2**40)])
+        attr = create_value_instance(data, None, None)
+
+        self.assertThat(attr, Equals(-2**40))
+        self.assertThat(attr, IsInstance(PlainType))
+
+    def test_plain_uint16(self):
+        data = dbus.Array([dbus.Int32(ValueType.PLAIN), dbus.UInt16(2**14)])
+        attr = create_value_instance(data, None, None)
+
+        self.assertThat(attr, Equals(2**14))
+        self.assertThat(attr, IsInstance(PlainType))
+
+    def test_plain_uint32(self):
+        data = dbus.Array([dbus.Int32(ValueType.PLAIN), dbus.UInt32(2**30)])
+        attr = create_value_instance(data, None, None)
+
+        self.assertThat(attr, Equals(2**30))
+        self.assertThat(attr, IsInstance(PlainType))
+
+    def test_plain_uint64(self):
+        data = dbus.Array([dbus.Int32(ValueType.PLAIN), dbus.UInt64(2**40)])
+        attr = create_value_instance(data, None, None)
+
+        self.assertThat(attr, Equals(2**40))
+        self.assertThat(attr, IsInstance(PlainType))
+
+    def test_plain_array(self):
+        data = dbus.Array([
+            dbus.Int32(ValueType.PLAIN),
+            dbus.Array([
+                dbus.String("Hello"),
+                dbus.String("World")
+            ])
+        ])
+        attr = create_value_instance(data, None, None)
+        self.assertThat(attr, Equals(["Hello", "World"]))
+        self.assertThat(attr, IsInstance(PlainType))
+
+    def test_rectangle(self):
+        data = dbus.Array(
+            [
+                dbus.Int32(ValueType.RECTANGLE),
+                dbus.Int32(0),
+                dbus.Int32(10),
+                dbus.Int32(20),
+                dbus.Int32(30),
+            ]
+        )
+
+        attr = create_value_instance(data, None, None)
+
+        self.assertThat(attr, IsInstance(Rectangle))
+
+    def test_invalid_rectanlge(self):
+        data = dbus.Array(
+            [
+                dbus.Int32(ValueType.RECTANGLE),
+                dbus.Int32(0),
+            ]
+        )
+
+        fn = lambda: create_value_instance(data, None, None)
+
+        self.assertThat(fn, raises(
+            ValueError("Rectangle must be constructed with 4 arguments, not 1")
+        ))
+
+    def test_point(self):
+        data = dbus.Array(
+            [
+                dbus.Int32(ValueType.POINT),
+                dbus.Int32(0),
+                dbus.Int32(10),
+            ]
+        )
+
+        attr = create_value_instance(data, None, None)
+
+        self.assertThat(attr, IsInstance(Point))
+
+    def test_invalid_point(self):
+        data = dbus.Array(
+            [
+                dbus.Int32(ValueType.POINT),
+                dbus.Int32(0),
+                dbus.Int32(0),
+                dbus.Int32(0),
+            ]
+        )
+
+        fn = lambda: create_value_instance(data, None, None)
+
+        self.assertThat(fn, raises(
+            ValueError("Point must be constructed with 2 arguments, not 3")
+        ))
+
+    def test_size(self):
+        data = dbus.Array(
+            [
+                dbus.Int32(ValueType.SIZE),
+                dbus.Int32(0),
+                dbus.Int32(10),
+            ]
+        )
+
+        attr = create_value_instance(data, None, None)
+
+        self.assertThat(attr, IsInstance(Size))
+
+    def test_invalid_size(self):
+        data = dbus.Array(
+            [
+                dbus.Int32(ValueType.SIZE),
+                dbus.Int32(0),
+            ]
+        )
+
+        fn = lambda: create_value_instance(data, None, None)
+
+        self.assertThat(fn, raises(
+            ValueError("Size must be constructed with 2 arguments, not 1")
+        ))
+
+    def test_date_time(self):
+        data = dbus.Array(
+            [
+                dbus.Int32(ValueType.DATETIME),
+                dbus.Int32(0),
+            ]
+        )
+
+        attr = create_value_instance(data, None, None)
+
+        self.assertThat(attr, IsInstance(DateTime))
+
+    def test_invalid_date_time(self):
+        data = dbus.Array(
+            [
+                dbus.Int32(ValueType.DATETIME),
+                dbus.Int32(0),
+                dbus.Int32(0),
+                dbus.Int32(0),
+            ]
+        )
+
+        fn = lambda: create_value_instance(data, None, None)
+
+        self.assertThat(fn, raises(
+            ValueError("DateTime must be constructed with 1 arguments, not 3")
+        ))
+
+    def test_time(self):
+        data = dbus.Array(
+            [
+                dbus.Int32(ValueType.TIME),
+                dbus.Int32(0),
+                dbus.Int32(0),
+                dbus.Int32(0),
+                dbus.Int32(0),
+            ]
+        )
+
+        attr = create_value_instance(data, None, None)
+
+        self.assertThat(attr, IsInstance(Time))
+
+    def test_invalid_time(self):
+        data = dbus.Array(
+            [
+                dbus.Int32(ValueType.TIME),
+                dbus.Int32(0),
+                dbus.Int32(0),
+                dbus.Int32(0),
+            ]
+        )
+
+        fn = lambda: create_value_instance(data, None, None)
+
+        self.assertThat(fn, raises(
+            ValueError("Time must be constructed with 4 arguments, not 3")
+        ))
+
+    def test_unknown_type_id(self):
+        """Unknown type Ids should result in a plain type, along with a log
+        message.
+
+        """
+
+        data = dbus.Array(
+            [
+                dbus.Int32(543),
+                dbus.Int32(0),
+                dbus.Boolean(False),
+                dbus.String("Hello World")
+            ]
+        )
+        attr = create_value_instance(data, None, None)
+        self.assertThat(attr, IsInstance(PlainType))
+        self.assertThat(attr, IsInstance(dbus.Array))
+        self.assertThat(attr, Equals([0, False, "Hello World"]))
+
+    def test_invalid_no_data(self):
+        data = dbus.Array(
+            [
+                dbus.Int32(0),
+            ]
+        )
+        fn = lambda: create_value_instance(data, None, None)
+
+        self.assertThat(fn, raises(
+            ValueError("Cannot create attribute, no data supplied")
+        ))
+
+
+class DBusIntrospectionObjectTests(TestCase):
+
+    @patch('autopilot.introspection.dbus.logger.warning')
+    def test_dbus_introspection_object_logs_bad_data(self, error_logger):
+        """The DBusIntrospectionObject class must log an error when it gets
+        bad data from the autopilot backend.
+
+        """
+        my_obj = DBusIntrospectionObject(
+            dict(foo=[0]),
+            '/some/dummy/path'
+        )
+        error_logger.assert_called_once_with(
+            "While constructing attribute '%s.%s': %s",
+            "DBusIntrospectionObject",
+            "foo",
+            "Cannot create attribute, no data supplied"
+        )
 
=== modified file 'autopilot/tests/unit/test_version_utility_fns.py'
--- autopilot/tests/unit/test_version_utility_fns.py	2013-07-22 03:14:42 +0000
+++ autopilot/tests/unit/test_version_utility_fns.py	2013-09-16 17:17:50 +0000
@@ -43,7 +43,7 @@
         """The _get_package_installed_version function must return None when
         subprocess raises an error while calling dpkg-query.
         """
-        def raise_error(*args):
+        def raise_error(*args, **kwargs):
             raise subprocess.CalledProcessError(1, "dpkg-query")
         with patch('subprocess.check_output', new=raise_error):
             self.assertThat(_get_package_installed_version(), Equals(None))
@@ -54,7 +54,7 @@
 
         """
         with patch('subprocess.check_output',
-                   new=lambda *a: "1.3daily13.05.22\n"):
+                   new=lambda *a, **kwargs: "1.3daily13.05.22\n"):
             self.assertThat(
                 _get_package_installed_version(), Equals("1.3daily13.05.22"))
 
 
=== modified file 'autopilot/utilities.py'
--- autopilot/utilities.py	2013-09-04 04:53:40 +0000
+++ autopilot/utilities.py	2013-09-16 17:17:50 +0000
@@ -34,13 +34,14 @@
 
 def _pick_backend(backends, preferred_backend):
     """Pick a backend and return an instance of it."""
-    possible_backends = backends.keys()
+    possible_backends = list(backends.keys())
     get_debug_logger().debug(
         "Possible backends: %s", ','.join(possible_backends))
     if preferred_backend:
         if preferred_backend in possible_backends:
-            possible_backends.sort(
-                lambda a, b: -1 if a == preferred_backend else 0)
+            # make preferred_backend the first list item
+            possible_backends.remove(preferred_backend)
+            possible_backends.insert(0, preferred_backend)
         else:
             raise RuntimeError("Unknown backend '%s'" % (preferred_backend))
     failure_reasons = []
@@ -67,7 +68,7 @@
     ...
 
     """
-    def __init__(self, stdout=os.devnull, stderr=os.devnull, mode='w'):
+    def __init__(self, stdout=os.devnull, stderr=os.devnull, mode='wb'):
         self.outfiles = stdout, stderr
         self.combine = (stdout == stderr)
         self.mode = mode
@@ -309,9 +310,7 @@
         return class_object
 
 
-class CleanupRegistered(object):
-
-    __metaclass__ = _TestCleanupMeta
+CleanupRegistered = _TestCleanupMeta('CleanupRegistered', (object,), {})
 
 
 def action_on_test_start(test_instance):
 
=== modified file 'autopilot/vis/bus_enumerator.py'
--- autopilot/vis/bus_enumerator.py	2013-07-14 08:17:17 +0000
+++ autopilot/vis/bus_enumerator.py	2013-09-16 17:17:50 +0000
@@ -79,7 +79,7 @@
 
     def get_found_connections(self):
         """Get a list of found connection names. This may not be up to date."""
-        return self._data.keys()
+        return list(self._data.keys())
 
     def get_found_objects(self, connection_string):
         """Get a list of found objects for a particular connection name.
@@ -87,9 +87,9 @@
         This may be out of date.
 
         """
-        if connection_string not in self._data.keys():
+        if connection_string not in self._data:
             raise KeyError("%s not in results" % connection_string)
-        return self._data[connection_string].keys()
+        return list(self._data[connection_string].keys())
 
     def get_found_interfaces(self, connection_string, object_path):
         """Get a list of found interfaces for a particular connection name and
@@ -98,9 +98,9 @@
         This may be out of date.
 
         """
-        if connection_string not in self._data.keys():
+        if connection_string not in self._data:
             raise KeyError("connection %s not in results" % connection_string)
-        if object_path not in self._data[connection_string].keys():
+        if object_path not in self._data[connection_string]:
             raise KeyError(
                 "object %s not in results for connection %s" %
                 (object_path, connection_string))
 
=== modified file 'autopilot/vis/main_window.py'
--- autopilot/vis/main_window.py	2013-07-14 08:13:25 +0000
+++ autopilot/vis/main_window.py	2013-09-16 17:17:50 +0000
@@ -20,6 +20,7 @@
 
 from __future__ import absolute_import
 
+import sys
 import dbus
 from PyQt4 import QtGui, QtCore
 
@@ -33,6 +34,8 @@
 from autopilot.vis.objectproperties import TreeNodeDetailWidget
 from autopilot.vis.resources import get_qt_icon
 
+_PY3 = sys.version >= '3'
+
 
 class MainWindow(QtGui.QMainWindow):
     def __init__(self, dbus_bus):
@@ -44,8 +47,12 @@
 
     def readSettings(self):
         settings = QtCore.QSettings()
-        self.restoreGeometry(settings.value("geometry").toByteArray())
-        self.restoreState(settings.value("windowState").toByteArray())
+        if _PY3:
+            self.restoreGeometry(settings.value("geometry").data())
+            self.restoreState(settings.value("windowState").data())
+        else:
+            self.restoreGeometry(settings.value("geometry").toByteArray())
+            self.restoreState(settings.value("windowState").toByteArray())
 
     def closeEvent(self, event):
         settings = QtCore.QSettings()
@@ -90,17 +97,16 @@
     def update_selectable_interfaces(self):
         selected_text = self.connection_list.currentText()
         self.connection_list.clear()
-        self.connection_list.addItem("Please select a connection",
-                                     QtCore.QVariant(None))
-        for name, proxy_obj in self.selectable_interfaces.iteritems():
+        self.connection_list.addItem("Please select a connection", None)
+        for name, proxy_obj in self.selectable_interfaces.items():
             if isinstance(proxy_obj, QtObjectProxyMixin):
                 self.connection_list.addItem(
                     get_qt_icon(),
                     name,
-                    QtCore.QVariant(proxy_obj)
+                    proxy_obj
                 )
             else:
-                self.connection_list.addItem(name, QtCore.QVariant(proxy_obj))
+                self.connection_list.addItem(name, proxy_obj)
 
         prev_selected = self.connection_list.findText(selected_text,
                                                       QtCore.Qt.MatchExactly)
@@ -109,7 +115,9 @@
         self.connection_list.setCurrentIndex(prev_selected)
 
     def conn_list_activated(self, index):
-        dbus_details = self.connection_list.itemData(index).toPyObject()
+        dbus_details = self.connection_list.itemData(index)
+        if not _PY3:
+            dbus_details = dbus_details.toPyObject()
         if dbus_details:
             self.tree_model = VisTreeModel(dbus_details)
             self.tree_view.setModel(self.tree_model)
@@ -211,16 +219,16 @@
 
     def data(self, index, role):
         if not index.isValid():
-            return QtCore.QVariant()
+            return None
         if role == QtCore.Qt.DisplayRole:
-            return QtCore.QVariant(index.internalPointer().name)
+            return index.internalPointer().name
 
     def headerData(self, column, orientation, role):
         if (orientation == QtCore.Qt.Horizontal and
                 role == QtCore.Qt.DisplayRole):
             try:
-                return QtCore.QVariant("Tree Node")
+                return "Tree Node"
             except IndexError:
                 pass
 
-        return QtCore.QVariant()
+        return None
 
=== modified file 'autopilot/vis/objectproperties.py'
--- autopilot/vis/objectproperties.py	2013-07-14 08:10:50 +0000
+++ autopilot/vis/objectproperties.py	2013-09-16 17:17:50 +0000
@@ -20,8 +20,11 @@
 
 """Code for introspection tree object properties."""
 
+import sys
+
 from PyQt4 import QtGui, QtCore
 
+
 from autopilot.vis.resources import get_qt_icon, dbus_string_rep
 from autopilot.introspection.qt import QtObjectProxyMixin
 
@@ -94,7 +97,10 @@
     def __init__(self, *args, **kwargs):
         super(PropertyView, self).__init__(*args, **kwargs)
 
-        header_titles = QtCore.QStringList(["Name", "Value"])
+        if sys.version >= '3':
+            header_titles = ["Name", "Value"]
+        else:
+            header_titles = QtCore.QStringList(["Name", "Value"])
         self.details_layout = QtGui.QVBoxLayout(self)
 
         self.table_view = QtGui.QTableWidget()
@@ -122,7 +128,7 @@
             details_string = dbus_string_rep(object_details[key])
             item_name = QtGui.QTableWidgetItem(key)
             item_details = QtGui.QTableWidgetItem(
-                details_string.decode('utf-8'))
+                details_string)
             self.table_view.setItem(i, 0, item_name)
             self.table_view.setItem(i, 1, item_details)
         self.table_view.setSortingEnabled(True)
 
=== modified file 'autopilot/vis/resources.py'
--- autopilot/vis/resources.py	2013-07-14 08:05:09 +0000
+++ autopilot/vis/resources.py	2013-09-16 17:17:50 +0000
@@ -32,7 +32,7 @@
     if isinstance(dbus_type, dbus.Boolean):
         return repr(bool(dbus_type))
     if isinstance(dbus_type, dbus.String):
-        return dbus_type.encode('utf-8', errors='ignore')
+        return dbus_type.encode('utf-8', errors='ignore').decode('utf-8')
     if (isinstance(dbus_type, dbus.Int16) or
             isinstance(dbus_type, dbus.UInt16) or
             isinstance(dbus_type, dbus.Int32) or
 
=== modified file 'bin/autopilot'
--- bin/autopilot	2013-08-01 15:33:53 +0000
+++ bin/autopilot	2013-09-16 17:17:50 +0000
@@ -66,21 +66,21 @@
 
         suite_names = ["%s.%s" % (t.__module__, t.__class__.__name__)
                        for t in test_list_fn()]
-        unique_suite_names = OrderedDict.fromkeys(suite_names).keys()
+        unique_suite_names = list(OrderedDict.fromkeys(suite_names).keys())
         num_tests = len(unique_suite_names)
         total_title = "suites"
-        print "    %s" % ("\n    ".join(unique_suite_names))
+        print("    %s" % ("\n    ".join(unique_suite_names)))
     else:
         for test in test_list_fn():
             has_scenarios = (hasattr(test, "scenarios")
                              and type(test.scenarios) is list)
             if has_scenarios:
                 num_tests += len(test.scenarios)
-                print " *%d %s" % (len(test.scenarios), test.id())
+                print(" *%d %s" % (len(test.scenarios), test.id()))
             else:
                 num_tests += 1
-                print "   ", test.id()
-    print "\n\n %d total %s." % (num_tests, total_title)
+                print("    " + test.id())
+    print("\n\n %d total %s." % (num_tests, total_title))
 
 
 def run_tests(args):
@@ -89,7 +89,7 @@
 
     if args.random_order:
         shuffle(test_suite._tests)
-        print "Running tests in random order"
+        print("Running tests in random order")
 
     import autopilot.globals
 
@@ -104,8 +104,8 @@
             stdout=subprocess.PIPE
         )
         if call_ret_code != 0:
-            print "ERROR: The application 'recordmydesktop' needs to be " \
-                  "installed to record failing jobs."
+            print("ERROR: The application 'recordmydesktop' needs to be "
+                  "installed to record failing jobs.")
             exit(1)
         autopilot.globals.configure_video_recording(True,
                                                     args.record_directory,
@@ -181,7 +181,7 @@
                     datetime.now().strftime("%d.%m.%y-%H%M%S")
                 )
                 log_file = os.path.join(log_file, default_log)
-                print "Using default log filename: %s " % default_log
+                print("Using default log filename: %s " % default_log)
             if args.format == 'xml':
                 _output_stream = open(log_file, 'w')
             else:
@@ -216,7 +216,7 @@
 def load_test_suite_from_name(test_names):
     """Returns a test suite object given a dotted test names."""
     loader = TestLoader()
-    if isinstance(test_names, basestring):
+    if isinstance(test_names, str):
         test_names = list(test_names)
     elif not isinstance(test_names, list):
         raise TypeError("test_names must be either a string or list, not %r"
@@ -241,7 +241,7 @@
     all_tests = TestSuite(tests)
 
     test_dirs = ", ".join(sorted(test_package_locations))
-    print "Loading tests from: %s\n" % test_dirs
+    print("Loading tests from: %s\n" % test_dirs)
     sys.stdout.flush()
 
     requested_tests = {}
@@ -256,7 +256,7 @@
             try:
                 test.debug()
             except Exception as e:
-                print e
+                print(e)
         else:
             test_id = test.id()
         if any([test_id.startswith(name) for name in test_names]):
@@ -287,9 +287,10 @@
     app_name = args.application[0]
     if not isabs(app_name) or not exists(app_name):
         try:
-            app_name = subprocess.check_output(["which", app_name]).strip()
+            app_name = subprocess.check_output(["which", app_name],
+                                               universal_newlines=True).strip()
         except subprocess.CalledProcessError:
-            print "Error: cannot find application '%s'" % (app_name)
+            print("Error: cannot find application '%s'" % (app_name))
             exit(1)
 
     # We now have a full path to the application.
@@ -298,21 +299,21 @@
         try:
             launcher = get_application_launcher(app_name)
         except RuntimeError as e:
-            print "Error detecting launcher: %s" % e.message
-            print "(Perhaps use the '-i' argument to specify an interface.)"
+            print("Error detecting launcher: %s" % str(e))
+            print("(Perhaps use the '-i' argument to specify an interface.)")
             exit(1)
     else:
         launcher = get_application_launcher_from_string_hint(args.interface)
     if launcher is None:
-        print "Error: Could not determine introspection type to use for " \
-              "application '%s'." % app_name
-        print "(Perhaps use the '-i' argument to specify an interface.)"
+        print("Error: Could not determine introspection type to use for " \
+              "application '%s'." % app_name)
+        print("(Perhaps use the '-i' argument to specify an interface.)")
         exit(1)
 
     try:
         launch_application(launcher, *args.application, capture_output=False)
     except RuntimeError as e:
-        print "Error: " + e.message
+        print("Error: " + str(e))
         exit(1)
 
 
 
=== modified file 'debian/changelog'
--- debian/changelog	2013-09-06 10:03:58 +0000
+++ debian/changelog	2013-09-16 17:17:50 +0000
@@ -1,3 +1,10 @@
+autopilot (1.4-0ubuntu1) saucy; urgency=low
+
+  [ Thomi Richards ]
+  * Update to new DBus wire protocol, bump autopilot version number.
+
+ -- Thomi Richards <[e-mail]>  Fri, 16 Aug 2013 08:47:12 +1200
+
 autopilot (1.3.1+13.10.20130906.1-0ubuntu1) saucy; urgency=low
 
   [ Christopher Lee ]
 
=== modified file 'debian/control'
--- debian/control	2013-09-09 21:34:21 +0000
+++ debian/control	2013-09-16 17:17:50 +0000
@@ -4,24 +4,37 @@
 Maintainer: Ubuntu Developers <[e-mail]>
 XSBC-Original-Maintainer: Thomi Richards <[e-mail]>
 Build-Depends: debhelper (>= 9.0.0),
-               gir1.2-ibus-1.0,
+               dh-python,
+               dvipng,
                gir1.2-gconf-2.0,
                gir1.2-gtk-3.0,
-               python (>= 2.6),
+               gir1.2-ibus-1.0,
+               graphviz,
+               liblttng-ust-dev,
+               python-all-dev (>= 2.6),
+               python3-all-dev (>= 3.3),
                python-dbus,
-               python-dev,
                python-debian,
+               python-gi,
                python-mock,
                python-setuptools,
                python-sphinx,
+               python-testscenarios,
                python-testtools,
-               python-testscenarios,
                python-xlib,
-               python-gi,
-               liblttng-ust-dev,
+               python3-dbus,
+               python3-gi,
+               python3-mock,
+               python3-setuptools,
+               python3-testscenarios,
+               python3-testtools,
+               python3-xlib,
+               texlive-latex-extra,
 Standards-Version: 3.9.4
 Homepage: https://launchpad.net/autopilot
 Vcs-bzr: https://code.launchpad.net/+branch/ubuntu/autopilot
+X-Python-Version: >= 2.7
+X-Python3-Version: >= 3.3
 
 Package: python-autopilot
 Architecture: all
@@ -33,8 +46,8 @@
          python-testtools,
          udev,
 Recommends: autopilot-desktop | autopilot-touch,
-            libautopilot-gtk (>= 1.3),
-            libautopilot-qt (>= 1.3),
+            libautopilot-gtk (>= 1.4),
+            libautopilot-qt (>= 1.4),
             python-autopilot-trace,
             recordmydesktop,
 Description: Utility to write and run integration tests easily
@@ -43,6 +56,31 @@
  keyboard. It also provides a lot of utilities linked to the X server
  and detecting applications.
 
+Package: python3-autopilot
+Architecture: all
+Depends: ${misc:Depends},
+         ${python3:Depends},
+         python3-dbus,
+         python3-junitxml,
+         python3-testscenarios,
+         python3-testtools,
+         udev,
+Recommends: python3-xlib,
+            python3-evdev,
+            gir1.2-gconf-2.0,
+            gir1.2-glib-2.0,
+            gir1.2-gtk-3.0,
+            gir1.2-ibus-1.0,
+            libautopilot-gtk (>= 1.4),
+            libautopilot-qt (>= 1.4),
+            python3-autopilot-trace,
+            recordmydesktop,
+Description: Utility to write and run integration tests easily (Python 3)
+ The autopilot engine enables to ease the writing of python tests
+ for your application manipulating your inputs like the mouse and
+ keyboard. It also provides a lot of utilities linked to the X server
+ and detecting applications.
+
 Package: python-autopilot-trace
 Architecture: any
 Depends: ${misc:Depends},
@@ -53,12 +91,21 @@
  autopilot tests. This is useful when using autopilot to exercise
  an instrumented application.
 
+Package: python3-autopilot-trace
+Architecture: any
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+         python3-autopilot,
+Description: Support for tracing in autopilot (Python 3)
+ This package contains the binary lttng trace point for tracing
+ autopilot tests. This is useful when using autopilot to exercise
+ an instrumented application.
 
 Package: autopilot-touch
 Architecture: any
 Section: metapackages
 Depends: ${misc:Depends},
-         libautopilot-qt (>= 1.3) [!powerpc],
+         libautopilot-qt (>= 1.4) [!powerpc],
          python-autopilot,
          python-evdev,
          python-ubuntu-platform-api [armhf],
@@ -91,7 +138,20 @@
          python-qt4,
          python-qt4-dbus,
 Description: The visualisation application for Autopilot.
- The Autopilot vis tool allows you to inspect an application introspectioin
+ The Autopilot vis tool allows you to inspect an application introspection
+ tree. It is a useful tool for test authors, but not required to run autopilot
+ tests.
+
+Package: python3-autopilot-vis
+Architecture: all
+Depends: ${misc:Depends},
+         ${python3:Depends},
+         python3-autopilot,
+         python3-dbus,
+         python3-pyqt4,
+         python3-dbus.mainloop.qt,
+Description: The visualisation application for Autopilot (Python 3)
+ The Autopilot vis tool allows you to inspect an application introspection
  tree. It is a useful tool for test authors, but not required to run autopilot
  tests.
 
@@ -99,8 +159,8 @@
 Architecture: all
 Depends: ${misc:Depends},
          ${python:Depends},
-         libautopilot-gtk,
-         libautopilot-qt,
+         libautopilot-gtk (>= 1.4),
+         libautopilot-qt (>= 1.4),
          python-autopilot,
          python-evdev,
          python-mock,
@@ -112,3 +172,21 @@
  You can use this package to verify that autopilot is functioning
  correctly, or to copy the techniques used in the autopilot tests
  themselves.
+
+Package: python3-autopilot-tests
+Architecture: all
+Depends: ${misc:Depends},
+         ${python3:Depends},
+         libautopilot-gtk (>= 1.4),
+         libautopilot-qt (>= 1.4),
+         python3-autopilot,
+         python3-evdev,
+         python3-mock,
+         python-windowmocker,
+         qmlscene,
+         recordmydesktop,
+Description: Tests for the autopilot functional test tool. (Python 3)
+ This package contains tests for the python3-autopilot package.
+ You can use this package to verify that autopilot is functioning
+ correctly, or to copy the techniques used in the autopilot tests
+ themselves.
 
=== added file 'debian/python-autopilot-tests.install'
--- debian/python-autopilot-tests.install	1970-01-01 00:00:00 +0000
+++ debian/python-autopilot-tests.install	2013-09-16 17:17:50 +0000
@@ -0,0 +1,3 @@
+usr/lib/python2*/*/autopilot/tests/*.py
+usr/lib/python2*/*/autopilot/tests/unit/*.py
+usr/lib/python2*/*/autopilot/tests/functional/*.py
 
=== removed file 'debian/python-autopilot-tests.pyinstall'
--- debian/python-autopilot-tests.pyinstall	2013-05-08 23:43:42 +0000
+++ debian/python-autopilot-tests.pyinstall	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-autopilot/tests/*.py
-autopilot/tests/unit/*.py
-autopilot/tests/functional/*.py
 
=== added file 'debian/python-autopilot-vis.install'
--- debian/python-autopilot-vis.install	1970-01-01 00:00:00 +0000
+++ debian/python-autopilot-vis.install	2013-09-16 17:17:50 +0000
@@ -0,0 +1,1 @@
+usr/lib/python2*/*/autopilot/vis/*.py
 
=== removed file 'debian/python-autopilot-vis.pyinstall'
--- debian/python-autopilot-vis.pyinstall	2013-04-30 16:49:02 +0000
+++ debian/python-autopilot-vis.pyinstall	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-autopilot/vis/*.py
 
=== modified file 'debian/python-autopilot.install'
--- debian/python-autopilot.install	2013-05-04 01:01:06 +0000
+++ debian/python-autopilot.install	2013-09-16 17:17:50 +0000
@@ -1,2 +1,8 @@
+usr/lib/python2*/*/autopilot/*.py
+usr/lib/python2*/*/autopilot/display/*.py
+usr/lib/python2*/*/autopilot/input/*.py
+usr/lib/python2*/*/autopilot/introspection/*.py
+usr/lib/python2*/*/autopilot/matchers/*.py
+usr/lib/python2*/*/autopilot/process/*.py
 usr/bin/autopilot /usr/bin/
 debian/61-autopilot-uinput.rules /lib/udev/rules.d
 
=== removed file 'debian/python-autopilot.pyinstall'
--- debian/python-autopilot.pyinstall	2013-04-30 16:49:02 +0000
+++ debian/python-autopilot.pyinstall	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-autopilot/*.py
-autopilot/display/*.py
-autopilot/input/*.py
-autopilot/introspection/*.py
-autopilot/matchers/*.py
-autopilot/process/*.py
 
=== added file 'debian/python3-autopilot-tests.install'
--- debian/python3-autopilot-tests.install	1970-01-01 00:00:00 +0000
+++ debian/python3-autopilot-tests.install	2013-09-16 17:17:50 +0000
@@ -0,0 +1,3 @@
+usr/lib/python3*/*/autopilot/tests/*.py
+usr/lib/python3*/*/autopilot/tests/unit/*.py
+usr/lib/python3*/*/autopilot/tests/functional/*.py
 
=== added file 'debian/python3-autopilot-trace.install'
--- debian/python3-autopilot-trace.install	1970-01-01 00:00:00 +0000
+++ debian/python3-autopilot-trace.install	2013-09-16 17:17:50 +0000
@@ -0,0 +1,1 @@
+usr/lib/python3*/*/autopilot/tracepoint.*.so
 
=== added file 'debian/python3-autopilot-vis.install'
--- debian/python3-autopilot-vis.install	1970-01-01 00:00:00 +0000
+++ debian/python3-autopilot-vis.install	2013-09-16 17:17:50 +0000
@@ -0,0 +1,1 @@
+usr/lib/python3*/*/autopilot/vis/*.py
 
=== added file 'debian/python3-autopilot.docs'
--- debian/python3-autopilot.docs	1970-01-01 00:00:00 +0000
+++ debian/python3-autopilot.docs	2013-09-16 17:17:50 +0000
@@ -0,0 +1,2 @@
+docs/_build/html/
+
 
=== added file 'debian/python3-autopilot.install'
--- debian/python3-autopilot.install	1970-01-01 00:00:00 +0000
+++ debian/python3-autopilot.install	2013-09-16 17:17:50 +0000
@@ -0,0 +1,9 @@
+usr/bin/autopilot /usr/bin/
+debian/61-autopilot-uinput.rules /lib/udev/rules.d
+usr/lib/python3*/*/autopilot/*.py
+usr/lib/python3*/*/autopilot/display/*.py
+usr/lib/python3*/*/autopilot/input/*.py
+usr/lib/python3*/*/autopilot/introspection/*.py
+usr/lib/python3*/*/autopilot/matchers/*.py
+usr/lib/python3*/*/autopilot/process/*.py
+
 
=== added file 'debian/python3-autopilot.postinst'
--- debian/python3-autopilot.postinst	1970-01-01 00:00:00 +0000
+++ debian/python3-autopilot.postinst	2013-09-16 17:17:50 +0000
@@ -0,0 +1,24 @@
+#!/bin/sh
+# postinst for autopilot
+
+set -e
+
+AUTOPILOT_GROUP=autopilot
+
+if [ "$1" = configure ]; then
+    # Add the autopilot group
+    addgroup --quiet \
+             --system \
+             --no-create-home \
+             "$AUTOPILOT_GROUP" || true
+
+    # Add each sudo user to the autopilot group
+    for u in $(getent group sudo | sed -e "s/^.*://" -e "s/,/ /g"); do
+        adduser --quiet "$u" "$AUTOPILOT_GROUP" > /dev/null || true
+    done
+
+    # udev rules were installed, trigger creation of the /dev node
+    udevadm trigger --action=change
+fi
+
+#DEBHELPER#
 
=== modified file 'debian/rules'
--- debian/rules	2013-05-30 12:00:24 +0000
+++ debian/rules	2013-09-16 17:17:50 +0000
@@ -5,14 +5,42 @@
 # export DH_VERBOSE=1
 
 %:
-	dh $@ --with python2
+	dh $@ --with python2,python3
+
+override_dh_auto_clean:
+	set -ex; for python in $(shell py3versions -r); do \
+	    $$python setup.py clean || true; \
+	done
+	dh_auto_clean
+	rm -rf build
 
 override_dh_auto_build:
 	sphinx-build -b html -W  docs/ docs/_build/html/
+	set -ex; for python in $(shell py3versions -r); do \
+	    $$python setup.py build; \
+	done
 	dh_auto_build
 
 override_dh_auto_test:
+ifeq (, $(findstring nocheck, $(DEB_BUILD_OPTIONS)))
 	python -m testtools.run discover autopilot.tests.unit
+	python3 -m testtools.run discover autopilot.tests.unit
+endif
+
+override_dh_auto_install:
+	set -ex; for python in $(shell py3versions -r); do \
+	    $$python setup.py install --root=$(CURDIR)/debian/tmp --install-layout=deb; \
+	done
+	dh_auto_install
 
 override_dh_install:
-	dh_install --list-missing
+	# note, egg-info isn't important unless we have entry_points or other
+	# things that runtime wants to inspect
+	dh_install -X.pyc -X.egg-info --fail-missing
+	# provide python3-ized runner and avoid file conflicts
+	set -e; if [ -d debian/python3-autopilot ]; then \
+	    cd debian/python3-autopilot; \
+	    mv usr/bin/autopilot usr/bin/autopilot-py3; \
+	    sed -i '1 s/python$$/python3/' usr/bin/autopilot-py3; \
+	    mv lib/udev/rules.d/61-autopilot-uinput.rules lib/udev/rules.d/61-autopilot-py3-uinput.rules; \
+	fi
 
=== modified file 'docs/_templates/indexcontent.html'
--- docs/_templates/indexcontent.html	2013-06-14 03:31:10 +0000
+++ docs/_templates/indexcontent.html	2013-09-16 17:17:50 +0000
@@ -38,6 +38,12 @@
           <span class="linkdescr">How to port your tests from earlier versions of Autopilot.</span>
         </p>
       </td>
+      <td>
+        <p class="biglink">
+          <a class="biglink" href="{{ pathto("appendix/appendix") }}">Appendices</a><br/>
+          <span class="linkdescr">Technical documentation that doesn't fit anywhere else.</span>
+        </p>
+      </td>
     </tr>
   </table>
 
 
=== modified file 'docs/api/introspection.rst'
--- docs/api/introspection.rst	2013-06-25 23:10:27 +0000
+++ docs/api/introspection.rst	2013-09-16 17:17:50 +0000
@@ -4,3 +4,6 @@
 .. automodule:: autopilot.introspection
     :members: CustomEmulatorBase, DBusIntrospectionObject, get_proxy_object_for_existing_process
 
+
+.. automodule:: autopilot.introspection.types
+	:members: PlainType, Rectangle, Point, Size, DateTime, Time
 
=== added directory 'docs/appendix'
=== added file 'docs/appendix/appendix.rst'
--- docs/appendix/appendix.rst	1970-01-01 00:00:00 +0000
+++ docs/appendix/appendix.rst	2013-09-16 17:17:50 +0000
@@ -0,0 +1,9 @@
+Appendices
+###########
+
+These technical documents describe features of the autopilot ecosystem that test authors probably don't need to know about, but may be useful to developers of autopilot itself.
+
+.. toctree::
+	:maxdepth: 2
+
+	protocol
 
=== added file 'docs/appendix/protocol.rst'
--- docs/appendix/protocol.rst	1970-01-01 00:00:00 +0000
+++ docs/appendix/protocol.rst	2013-09-16 17:17:50 +0000
@@ -0,0 +1,366 @@
+XPathSelect Query Protocol
+##########################
+
+
+This document defines the protocol used between autopilot and the application under test. In almost all cases, the application under test needs no knowledge of this protocol, since it is handled by one of the UI toolkit specific autopilot drivers (we support both Gtk and Qt). If you are a test author, you should be aware that this document likely contains no useful information for you!
+
+.. contents::
+
+**Who should read this document:**
+
+ * People wanting to hack on autopilot itself.
+ * People wanting to hack on xpathselect.
+ * People wanting to use autopilot to test an application not supported by the current autopilot UI toolkit drivers.
+ * People wanting to write a new UI toolkit driver.
+
+
+DBus Interface
+==============
+
+Every application under test must register itself on a DBus bus. Traditionally this is the DBus session bus, but autopilot supports any DBus bus that the user running autopilot has access to. Applications may choose to us ea well-known connection name, but it is not required.
+
+The only requirement for the DBus connection is that the ``com.canonical.Autopilot.Introspection`` interface is presented on exactly one exported object. The interface has two methods:
+
+ * ``GetVersion()``. The ``GetVersion`` method takes no parameters, and returns a string describing the DBus wire protocol version being used by the application under test. Autopilot will refuse to connect to DBus wire protocol versions that are different than the expected version. The current version string is described later in this document. The version string should be in the format "X.Y", where ``X``, ``Y`` are the major and minor version numbers, respectively.
+
+ * ``GetState(...)``. The ``GetState`` method takes a single string parameter, which is the "XPath Query". The format of that string parameter, and the return value, are the subject of the rest of this document.
+
+
+Object Trees
+============
+
+Autopilot assumes that the application under test is constructed of a tree of objects. This is true for both Gtk and Qt applications, where the tree usually starts with an "application" object, and roughly follows widget stacking order.
+
+The purpose of the XPathSelect protocol is to allow autopilot to select the parts of the application that it is interested in.
+
+Autopilot passes a query string to the ``GetState`` method, and the application replies with the objects selected (if any), and their internal state details.
+
+The object tree is a tree of objects. Objects have several properties that are worth mentioning:
+
+ * Each object *must* have a name that can be used as a python identifier. This is usually the class name or widget type (for example, ``QPushButton``, in a Qt GUI application).
+ * Each object *must* have an attribute named "id", whose value is an integer that is guaranteed to be unique for that object (note however that the same object may appear multiple times in the introspection tree in different places. In this case, the object id must remain consistent between each appearance).
+ * Objects *may* have more attributes. Each attribute name must be a string that can be represented as a python variable name. Attribute values can be any type that is representable over dbus.
+ * Objects *may* have zero or more child objects.
+
+This tree of objects is known as an "introspection tree" throughout the autopilot documentation.
+
+Selecting Objects
+=================
+
+Objects in a tree are selected in a very similar fashion to files in a filesystem. The ``/`` character is used to separate between levels of the tree.
+
+Selecting the Root Object
++++++++++++++++++++++++++
+
+A shortcut exists for selecting the root object in the introspection tree. A query of ``/`` will always return the root object. This is used when autopilot does not yet know the name of, the root object.
+
+Absolute Queries
+++++++++++++++++
+
+Absolute queries specify the entire path to the object, or objects autopilot is interested in. They must start with ``/`` and specify object names, separated by ``/`` characters. For example:
+
+.. list-table:: **XPathSelect Absolute Queries**
+	:header-rows: 1
+
+	* - Query:
+	  - Selects:
+	* - ``/``
+	  - The root object (see above).
+	* - ``/foo``
+	  - The root object, which must be named 'foo'.
+	* - ``/foo/bar``
+	  - Object 'bar', which is a direct child of the root object 'foo'.
+
+
+Using absolute queries, it is possible to select nodes in a tree of objects. However, there is no requirement for an absolute query path to match to exactly one object in the tree. For example, given a tree that looks like this:
+
+.. graphviz::
+
+   digraph foo {
+      node [shape=box];
+      a [label="foo"];
+      b [label="bar"];
+      c [label="bar"];
+      d [label="bar"];
+
+      a -> b;
+      a -> c;
+      a -> d;
+   }
+
+a query of ``/foo/bar`` will select two objects. This is allowed, but not always what we want. There are several ways to avoid this, they will be covered later in this document.
+
+Relative Queries
+++++++++++++++++
+
+Absolute queries are very fast for the application under test to process, and are used whenever autopilot knows where the object it wants to look at exists within the introspection tree. However, sometimes we need to be able to retrieve all the objects of a certain type within the tree. XPathSelect understands relative queries, which will select objects of a specified type anywhere in the tree. For example:
+
+.. list-table:: **XPathSelect Relative Queries**
+	:header-rows: 1
+
+	* - Query:
+	  - Selects:
+	* - ``//foo``
+	  - All objects named 'foo', anywhere in the tree.
+
+Relative queries are much slower for the application under test to process, since the entire introspection tree must be searched for the objects that match the search criteria. Additionally, relative queries can generate a large amount of data that has to be sent across DBus, which can slow things down further.
+
+Mixed Queries
++++++++++++++
+
+Absolute and relative queries can be mixed. All the relative queries in the above table will search the entire object tree. However, sometimes you only want to search part of the object tree, in which case you can use a mixed query:
+
+.. list-table:: **XPathSelect Mixed Queries**
+	:header-rows: 1
+
+	* - Query:
+	  - Selects:
+	* - ``/foo/bar//baz``
+	  - Select all objects named 'baz' which are in the tree beneath '/foo/bar'
+	* - ``/foo/far//bar/baz``
+	  - Select all 'baz' objects which are immeadiate children of a 'bar' object, which itself is in the subtree beneath '/foo/far'.
+
+As you can see, mixed queries can get reasonably complicated.
+
+Attribute Queries
++++++++++++++++++
+
+Sometimes we want to select an object whose attributes match certain values. For example, if the application under test is a Qt application, we may want to retrieve a list of 'QPushButton' objects whose 'active' attribute is set to ``True``.
+
+The XPathSelect query protocol supports three value types for attributes:
+
+ * Boolean attribute values are represented as ``True`` or ``False``.
+
+ * String attribute values are represented as strings inside double quote characters. The XPathSelect library understands the common character escape codes, as well as the ``\x__`` hexidecimal escape sequence (For exmaple: ``"\x41"`` would evaluate to a string with a single character 'A'.).
+
+ * Integer attribute values are supported. Integers may use a sign (either '+' or '-'). The sign may be omitted for positive numbers. The range for integer values is from :math:`-2^{32}` to :math:`2^{31}-1`.
+
+Attribute queries are done inside square brackets (``[...]``) next to the object they apply to. The following table lists a number of attribute queries, as examples of what can be achieved.
+
+.. list-table:: **XPathSelect Attribute Queries**
+	:header-rows: 1
+
+	* - Query:
+	  - Selects:
+	* - ``//QPushButton[active=True]``
+	  - Select all ``QPushbutton`` objects whose "active" attribute is set to True.
+	* - ``//QPushButton[label="Deploy Robots!"]``
+	  - Select all ``QPushButton`` objects whose labels are set to the string "Deploy Robots".
+	* - ``//QPushButton[label="Deploy Robots!",active=True]``
+	  - Select all ``QPushButton`` objects whose labels are set to the string "Deploy Robots", *and* whose "active" attribute is set to True.
+	* - ``//QSpinBox[value=-10]``
+	  - Select all ``QSpinBox`` objects whose value attribute is set to -10.
+
+.. note::
+	While the XPathSelect protocol has a fairly limited list of supported types for attribute matching queries, it is important to note that autopilot transparently supports matching object attributes of any type. Autopilot will send attribute filters to the application under test using the XPathSelect protocol only if the attribute filters are supported by XPathSelect. In all other cases, the filtering will be done within autopilot. At worst, the test author may notice that some queries take longer than others.
+
+Wildcard Nodes
+==============
+
+As well as selecting a node in the introspection tree by node name, one can also use ``*`` to select any node. However, there are a few restrictions on this feature, to stop the inadvertent selection of the entire tree.
+
+Selecting All Children
+++++++++++++++++++++++
+
+Wildcard nodes are often used to select all the children of a particular object. For example, if the query ``/path/to/object[id=123]`` returns the parent object you are interested in, then the query ``/path/to/object[id=123]/*`` will return all the immediate children of that object.
+
+Selecting Nodes based on Attributes
++++++++++++++++++++++++++++++++++++
+
+The second use of wildcard nodes is to select nodes based purely on their attributes, rather than their type. For example, to select every object with a 'visible' property set to 'True', the following query will work: ``//*[visible=True]``. However, care must be taken - this query will traverse the entire introspection tree, and may take a long time. Additionally, a large amount of data may be returned over DBus.
+
+Invalid Wildcard Queries
+++++++++++++++++++++++++
+
+The wildcard specifier may only be used after a search separator if you have also specified attribute filters. For example, all the following queries are invalid:
+
+**Invalid Queries**
+
+* ``//*``
+
+* ``/path/to/some/node//*``
+
+* ``//node//*``
+
+However, the following queries are all valid:
+
+**Valid Queries**
+
+* ``//node/*``
+
+* ``/node//*[key="value"]``
+
+* ``//node//*[key=True]``
+
+Returning State Data
+====================
+
+Once the application under test has parsed the XPathSleect query, and has a list (possibly empty!) of objects that match the given query, it must serialize those objects back across DBus as the return value from the ``GetState`` method. The data structure used is reasonably complex, and is described below:
+
+* At the top level, the return type must be an array of objects. Each item in the array represents an object that matched the supplied query. If no objects matched the supplied query, an empty array must be returned.
+
+ * Each object is a DBus structure that has two parts: a string, and a map. The string specifies the full tree path to the object being returned (for example "/path/to/object").
+
+   * The map represents the object state, and is a map of strings to arrays. The keys in this map are property names (for example "visible").
+
+    * The arrays represents the property value. It contains at least two parts, a value type id (see below for a list of these ids and what they mean), and one or more values. The values can be any type representable over dbus. Some values may actually be arrays of values, for example.
+
+.. graphviz::
+
+   digraph dbus_data {
+      node [shape=record];
+
+      objects [label="Object|<f1>Object|..."];
+      object2 [label="Object_name|<f1>Object_state"];
+      object_state [label="property|<f0>property|..."]
+      property [label="key|value_type|value|..."]
+
+      objects:f1 -> object2;
+      object2:f1 -> object_state;
+      object_state:f0 -> property;
+   }
+
+
+Valid IDs
++++++++++
+
+The following table lists the various type Ids, and their meaning.
+
+.. list-table:: **Autopilot Type IDs and their meaning**
+	:header-rows: 1
+	:widths: 5 90
+
+	* - Type ID:
+	  - Meaning:
+	* - 0
+	  - Simple Type. The value is a DBus integer, boolean, or string, and that is exactly how it should be represented to the user.
+	* - 1
+	  - Rectangle. The next four values are all integers, and represent a rectangle in cartesian space. The four numbers must represent the x, y, width and height of the rectangle, respectively. Autopilot will likely present the four values as 'x', 'y', 'w' and 'h' to test authors. Autopilot makes no assumptions about the coordinate space used.
+	* - 2
+	  - Point. The next two values are integers, and represent an X, Y, point in catesian space.
+	* - 3
+	  - Size. The next two value are integers, and represent a width,height pair, describing a size in catesian space.
+	* - 4
+	  - Color. The next four values are all integers, and represent the red, green, blue, and alpha components of the color, respectively. Each component is bounded between 0 and 255.
+	* - 5
+	  - Date or Date/Time. The next value is an integer representing the number of seconds since the unix epoch (1970-01-011 00:00:00), UTC time.
+	* - 6
+	  - Time. The next values are all integers, and represent hours, minutes, seconds, milliseconds.
+
+Special Attributes
+++++++++++++++++++
+
+Most attributes that are returned will be attributes of the UI toolkit class itself. However, there are two special attributes:
+
+* The ``id`` attribute *must* be present, and must contain an integer number. This number must be unique for this instance of the object. This number must also be within the range suitable for integer parameter matching.
+
+* The ``Children`` attribute *may* be present if the object being serialized has any children in the introspection tree. If it is present, it must be an array of strings, where each string is the class name of the immediate child object.
+
+* The ``globalRect`` property should be present for any components that have an on-screen presence. It should be a 4-element array containing the x,y,w,h values of the items on-screen coordinates. Note that these coordinates should be in screen-space, rather than local application space.
+
+Example GetState Return Values
+++++++++++++++++++++++++++++++
+
+All the examples in this section have had whitespace added to make them more readable.
+
+**Example 1: Unity Shell**
+
+Query: ``/``
+
+Return Value::
+
+	[
+		(
+			'/Unity',
+			{
+				'id': 0L,
+				'Children':
+				[
+					'DashController',
+					'HudController',
+					'LauncherController',
+					'PanelController',
+					'Screen'
+					'SessionController',
+					'ShortcutController',
+					'SwitcherController',
+					'WindowManager',
+				]
+			}
+		)
+	]
+
+
+**Example 2: Qt Creator Menu**
+
+This is a much larger object, and shows the ``globalRect`` attribute.
+
+Query: ``/QtCreator/QMenu[objectName="Project.Menu.Session"]``
+
+Return Value::
+
+	[
+		(
+			'/QtCreator/QMenu',
+			{
+				'_autopilot_id': 2L,
+				'acceptDrops': False,
+				'accessibleDescription': '',
+				'accessibleName': '',
+				'autoFillBackground': False,
+				'baseSize': [0, 0],
+				'Children': ['QAction'],
+				'childrenRect': [0, 0, 0, 0],
+				'contextMenuPolicy': 1,
+				'enabled': True,
+				'focus': False,
+				'focusPolicy': 0,
+				'frameGeometry': [0, 0, 100, 30],
+				'frameSize': [100, 30],
+				'fullScreen': False,
+				'geometry': [0, 0, 100, 30],
+				'globalRect': [0, 0, 100, 30],
+				'height': 30,
+				'id': 2L,
+				'inputMethodHints': 0,
+				'isActiveWindow': False,
+				'layoutDirection': 0,
+				'maximized': False,
+				'maximumHeight': 16777215,
+				'maximumSize': [16777215, 16777215]
+				'maximumWidth': 16777215,
+				'minimized': False,
+				'minimumHeight': 0,
+				'minimumSize': [0, 0],
+				'minimumSizeHint': [-1, -1],
+				'minimumWidth': 0,
+				'modal': False,
+				'mouseTracking': True,
+				'normalGeometry': [0, 0, 0, 0],
+				'objectName': 'Project.Menu.Session',
+				'pos': [0, 0],
+				'rect': [0, 0, 100, 30],
+				'separatorsCollapsible': True,
+				'size': [100, 30],
+				'sizeHint': [379, 205],
+				'sizeIncrement': [0, 0],
+				'statusTip': '',
+				'styleSheet': '',
+				'tearOffEnabled': False,
+				'title': '',
+				'toolTip': '',
+				'updatesEnabled': True,
+				'visible': False,
+				'whatsThis': '',
+				'width': 100,
+				'windowFilePath': '',
+				'windowIconText': '',
+				'windowModality': 0,
+				'windowModified': False,
+				'windowOpacity': 1.0,
+				'windowTitle': '',
+				'x': 0,
+				'y': 0,
+			}
+		)
+	]
 
=== modified file 'docs/conf.py'
--- docs/conf.py	2013-07-25 05:47:36 +0000
+++ docs/conf.py	2013-09-16 17:17:50 +0000
@@ -50,6 +50,8 @@
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 extensions = [
     'sphinx.ext.autodoc',
+    'sphinx.ext.graphviz',
+    'sphinx.ext.pngmath',
     'sphinx.ext.viewcode',
     'otto',
 ]
@@ -84,7 +86,7 @@
 except ImportError:
     # If we don't have python-debian installed, guess a coarse-grained version
     # string
-    version = '1.3'
+    version = '1.4'
 
 # The full version, including alpha/beta/rc tags.
 release = version
 
=== modified file 'docs/contents.rst'
--- docs/contents.rst	2013-06-14 02:05:36 +0000
+++ docs/contents.rst	2013-09-16 17:17:50 +0000
@@ -11,3 +11,4 @@
     porting/porting
     faq/faq
     faq/contribute
+    appendix/appendix
 
=== modified file 'docs/porting/porting.rst'
--- docs/porting/porting.rst	2013-04-27 02:59:44 +0000
+++ docs/porting/porting.rst	2013-09-16 17:17:50 +0000
@@ -12,6 +12,24 @@
 
 Autopilot versions earlier than 1.2 were not publicly announced, and were only used within Canonical. For that reason, this document assumes that version 1.2 is the lowest version of autopilot present `"in the wild"`.
 
+Porting to Autopilot v1.4.x
+===========================
+
+The 1.4 release contains several changes that required a break in the DBus wire protocol between autopilot and the applications under test. Most of these changes require no change to test code.
+
+Gtk Tests and Boolean Parameters
+++++++++++++++++++++++++++++++++
+
+Version 1.3 of the autopilot-gtk backend contained `a bug <https://bugs.launchpad.net/autopilot-gtk/+bug/1214249>`_ that caused all Boolean properties to be exported as integers instead of boolean values. This in turn meant that test code would fail to return the correct objects when using selection criteria such as::
+
+	visible_buttons = app.select_many("GtkPushButton", visible=True)
+
+and instead had to write something like this::
+
+	visible_buttons = app.select_many("GtkPushButton", visible=1)
+
+This bug has now been fixed, and using the integer selection will fail.
+
 Porting to Autopilot v1.3.x
 ===========================
 
 
=== modified file 'docs/tutorial/advanced_autopilot.rst'
--- docs/tutorial/advanced_autopilot.rst	2013-08-23 04:07:36 +0000
+++ docs/tutorial/advanced_autopilot.rst	2013-09-16 17:17:50 +0000
@@ -236,7 +236,7 @@
     >>> try:
     ...     kbd = Keyboard.create("uinput")
     ... except RuntimeError as e:
-    ...     print "Unable to create keyboard:", e
+    ...     print("Unable to create keyboard: " + str(e))
     ...
     Unable to create keyboard: Unknown backend 'uinput'
 
 
=== modified file 'setup.py'
--- setup.py	2013-07-24 05:56:06 +0000
+++ setup.py	2013-09-16 17:17:50 +0000
@@ -28,7 +28,7 @@
 except ImportError:
     # If we don't have python-debian installed, guess a coarse-grained version
     # string
-    version = '1.3.1'
+    version = '1.4.0'
 
 autopilot_tracepoint = Extension(
     'autopilot.tracepoint',