Merge lp:~thomir-deactivatedaccount/autopilot/merge-private-code into lp:autopilot

[Thomi Richards]

Merge in large changes for version 1.3.

This branch contains the 'new hotness' - large scale changes for autopilot 1.3.

[Michael Zanetti (mzanetti)]

just scrolled quickly through it (no real review yet) but stumbled across this:

3442 + ... a Qt4 Qml application might be launched like this::
3443 +
3444 + app_proxy = self.launch_test_application('qmlscene', 'my_scene.qml')

There is no qmlscene in Qt4. It was the QWidget based "qmlviewer" back then. qmlscene is the new Qt5 version which directly paints qml on a openGL scenegraph.

[Olivier Tilloy (osomon)]

I built a package from this MR, installed on my raring desktop, and tried to run the autopilot tests for lp:webbrowser-app.

Listing the tests fails with the following error:

    ImportError: cannot import name QtIntrospectionTestMixin

but can be easily fixed by simply removing this import, and not inheriting from QtIntrospectionTestMixin.

Running the tests fails with the following error:

_StringException: Traceback (most recent call last):
  File "/tmp/webbrowser-app/tests/autopilot/webbrowser_app/tests/test_mainwindow.py", line 263, in setUp
    super(TestMainWindowStartOpenRemotePageBase, self).setUp()
  File "/tmp/webbrowser-app/tests/autopilot/webbrowser_app/tests/__init__.py", line 161, in setUp
    super(BrowserTestCaseBaseWithHTTPServer, self).setUp()
  File "/tmp/webbrowser-app/tests/autopilot/webbrowser_app/tests/__init__.py", line 45, in setUp
    self.launch_test_local()
  File "/tmp/webbrowser-app/tests/autopilot/webbrowser_app/tests/__init__.py", line 62, in launch_test_local
    *self.ARGS)
  File "/usr/lib/python2.7/dist-packages/autopilot/testcase.py", line 450, in launch_test_application
    process = launch_application(launcher, application, *arguments, **kwargs)
  File "/usr/lib/python2.7/dist-packages/autopilot/introspection/__init__.py", line 80, in launch_application
    path, args = launcher.prepare_environment(application, list(arguments))
AttributeError: 'NoneType' object has no attribute 'prepare_environment'

Looks like a problem in autopilot itself.

[Michael Zanetti (mzanetti)]

I'd like to see some section in the docs that describe how to upgrade tests to be compatible with this version.

review: Needs Fixing

[Sergio Schvezov (sergiusens)]

Packaging/docs need fixing

$ bzr bd
...
/home/sergiusens/projects/autopilot/build-area/autopilot-1.2daily13.03.26/docs/api/autopilot.rst:: WARNING: document isn't included in any toctree

make[1]: *** [override_dh_auto_build] Error 1
make[1]: Leaving directory `/home/sergiusens/projects/autopilot/build-area/autopilot-1.2daily13.03.26'
make: *** [build] Error 2

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:184
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~thomir/autopilot/merge-private-code/+merge/156425/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/autopilot-ci/10/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-raring-amd64-ci/10/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-raring-armhf-ci/9/console

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

review: Needs Fixing (continuous-integration)

[lp:~thomir-deactivatedaccount/autopilot/merge-private-code]

185. By Thomi Richards on 2013-04-14

Bump current version to v1.3.

[Thomi Richards (thomir-deactivatedaccount)]

Hi Michael,

> There is no qmlscene in Qt4. It was the QWidget based "qmlviewer" back then.
> qmlscene is the new Qt5 version which directly paints qml on a openGL
> scenegraph.

Fixed. I'll add a second example that uses 'wmlscene' and specifies that it's for Qt5 as well. Note that the tutorial section of the documentation is unfinished - once that's complete this should become clearer.

[Thomi Richards (thomir-deactivatedaccount)]

Hi Oliver

> I built a package from this MR, installed on my raring desktop, and tried to
> run the autopilot tests for lp:webbrowser-app.
>

Autopilot 1.3 (the version number has now been updated) contains API breaks from 1.2, you won't be able to run your old tests without changing them. However, see my comments below:

> Listing the tests fails with the following error:
>
> ImportError: cannot import name QtIntrospectionTestMixin
>
> but can be easily fixed by simply removing this import, and not inheriting
> from QtIntrospectionTestMixin.

Yes - these Mixin Classes were rather nasty, and were the cause of many errors.

>
> Running the tests fails with the following error:
>
> _StringException: Traceback (most recent call last):
> File "/tmp/webbrowser-
> app/tests/autopilot/webbrowser_app/tests/test_mainwindow.py", line 263, in
> setUp
> super(TestMainWindowStartOpenRemotePageBase, self).setUp()
> File "/tmp/webbrowser-app/tests/autopilot/webbrowser_app/tests/__init__.py",
> line 161, in setUp
> super(BrowserTestCaseBaseWithHTTPServer, self).setUp()
> File "/tmp/webbrowser-app/tests/autopilot/webbrowser_app/tests/__init__.py",
> line 45, in setUp
> self.launch_test_local()
> File "/tmp/webbrowser-app/tests/autopilot/webbrowser_app/tests/__init__.py",
> line 62, in launch_test_local
> *self.ARGS)
> File "/usr/lib/python2.7/dist-packages/autopilot/testcase.py", line 450, in
> launch_test_application
> process = launch_application(launcher, application, *arguments, **kwargs)
> File "/usr/lib/python2.7/dist-packages/autopilot/introspection/__init__.py",
> line 80, in launch_application
> path, args = launcher.prepare_environment(application, list(arguments))
> AttributeError: 'NoneType' object has no attribute 'prepare_environment'
>
> Looks like a problem in autopilot itself.

Kind of :)

We should raise a better exception in this case, which I have just comitted to this branch:

        if launcher is None:
            raise RuntimeError("Autopilot could not determine the correct \
                introspection type to use. You can specify one by overriding \
                the AutopilotTestCase.pick_app_launcher method.")

What's happening is that autopilot is trying to guess what kind of introspection support to load - Gtk or Qt. Currently it simply does 'ldd <app_path>' and looks for 'qtcore' or 'gtk' - clearly this isn't going to work for python/Qt or python/Gtk apps. I have plans to extend that auto-detection routine, so it works for python scripts automatically. However, you can specify the introspection type manually, by overriding the pick_app_launcher method. In fact, there' san autopilot test that does exactly that, in autopilot/tests/test_ap_apps.py - I've pasted the relevant sections below:

class QtTests(ApplicationTests):

    def pick_app_launcher(self, app_path):
        # force Qt app introspection:
        from autopilot.introspection.qt import QtApplicationLauncher
        return QtApplicationLauncher()

    def test_can_launch_qt_script(self):
        path = self.write_script(dedent("""\
            #!/usr/bin/python
            from PyQt4.QtGui import QMainWindow, QAppli...

[Thomi Richards (thomir-deactivatedaccount)]

> I'd like to see some section in the docs that describe how to upgrade tests to
> be compatible with this version.

Agreed:

https://bugs.launchpad.net/autopilot/+bug/1168975

[lp:~thomir-deactivatedaccount/autopilot/merge-private-code]

186. By Thomi Richards on 2013-04-14

Fix problem with Qml launch example in documentation.

187. By Thomi Richards on 2013-04-14

Better error when autopilot cannot auto-detect the introspection type.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:185
http://jenkins.qa.ubuntu.com/job/autopilot-ci/11/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-raring-amd64-ci/11/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-raring-armhf-ci/10/console

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

review: Needs Fixing (continuous-integration)

[lp:~thomir-deactivatedaccount/autopilot/merge-private-code]

188. By Thomi Richards on 2013-04-14

Marked top-level pages as :orphan: sphinx docs, since we have our own custom html page, instead of an index toctree element.

[Thomi Richards (thomir-deactivatedaccount)]

Hi Sergio,

> Packaging/docs need fixing
>
> $ bzr bd
> ...
> /home/sergiusens/projects/autopilot/build-
> area/autopilot-1.2daily13.03.26/docs/api/autopilot.rst:: WARNING: document
> isn't included in any toctree
>

Fixed - this is because we have our own custom index page now.

Thanks,

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:188
http://jenkins.qa.ubuntu.com/job/autopilot-ci/12/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-raring-amd64-ci/12
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-raring-armhf-ci/11

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

review: Approve (continuous-integration)

[lp:~thomir-deactivatedaccount/autopilot/merge-private-code]

189. By Thomi Richards on 2013-04-14

Merged chris's work with the process managaer.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:189
http://jenkins.qa.ubuntu.com/job/autopilot-ci/13/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-raring-amd64-ci/13/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-raring-armhf-ci/12/console

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

review: Needs Fixing (continuous-integration)

[lp:~thomir-deactivatedaccount/autopilot/merge-private-code]

190. By Thomi Richards on 2013-04-15

Made a good start on new, better, introductory tutorial page.

191. By Thomi Richards on 2013-04-15

Documentation and setup.py now get version numbers from debian/changelog, rather than maintaining separate strings.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:191
http://jenkins.qa.ubuntu.com/job/autopilot-ci/14/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-raring-amd64-ci/14/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-raring-armhf-ci/13/console

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

review: Needs Fixing (continuous-integration)

[lp:~thomir-deactivatedaccount/autopilot/merge-private-code]

192. By Thomi Richards on 2013-04-15

Merged trunk, resolved conflicts.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:192
http://jenkins.qa.ubuntu.com/job/autopilot-ci/15/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-raring-amd64-ci/15
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-raring-armhf-ci/14

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

review: Approve (continuous-integration)

[lp:~thomir-deactivatedaccount/autopilot/merge-private-code]

193. By Thomi Richards on 2013-04-15

More docs.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:193
http://jenkins.qa.ubuntu.com/job/autopilot-ci/16/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-raring-amd64-ci/16/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-raring-armhf-ci/15/console

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

review: Needs Fixing (continuous-integration)

[lp:~thomir-deactivatedaccount/autopilot/merge-private-code]

194. By Thomi Richards on 2013-04-15

Added the start of a porting document.

195. By Thomi Richards on 2013-04-15

Merge in process test fixes.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:195
http://jenkins.qa.ubuntu.com/job/autopilot-ci/17/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-raring-amd64-ci/17/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-raring-armhf-ci/16/console

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

review: Needs Fixing (continuous-integration)

[lp:~thomir-deactivatedaccount/autopilot/merge-private-code]

196. By Thomi Richards on 2013-04-15

Turn off intersphinx support since we can't build it anyway, and testtools doesn't use sphinx for it's API docs.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:196
http://jenkins.qa.ubuntu.com/job/autopilot-ci/18/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-raring-amd64-ci/18/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-raring-armhf-ci/17/console

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

review: Needs Fixing (continuous-integration)

[lp:~thomir-deactivatedaccount/autopilot/merge-private-code]

197. By Thomi Richards on 2013-04-15

Fix bullet list in porting document.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:197
http://jenkins.qa.ubuntu.com/job/autopilot-ci/19/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-raring-amd64-ci/19
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-raring-armhf-ci/18

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

review: Approve (continuous-integration)

=== renamed file 'autopilot/emulators/clipboard.py' => 'autopilot/clipboard.py'
=== removed file 'autopilot/compizconfig.py'
--- autopilot/compizconfig.py	2012-08-27 21:26:45 +0000
+++ autopilot/compizconfig.py	1970-01-01 00:00:00 +0000
@@ -1,57 +0,0 @@
-# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-# Copyright 2012 Canonical
-# Author: Thomi Richards
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This script is designed to run unity in a test drive manner. It will drive
-# X and test the GL calls that Unity makes, so that we can easily find out if
-# we are triggering graphics driver/X bugs.
-
-"""Functions that wrap compizconfig to avoid some unpleasantness in that module."""
-
-from __future__ import absolute_import
-
-
-from autopilot.utilities import Silence
-
-_global_context = None
-
-def get_global_context():
-    """Get the compizconfig global context object."""
-    global _global_context
-    if _global_context is None:
-        with Silence():
-            from compizconfig import Context
-            _global_context = Context()
-    return _global_context
-
-
-def get_plugin(plugin_name):
-    """Get a compizconfig plugin with the specified name.
-
-    Raises KeyError of the plugin named does not exist.
-
-    """
-    ctx = get_global_context()
-    with Silence():
-        try:
-            return ctx.Plugins[plugin_name]
-        except KeyError:
-            raise KeyError("Compiz plugin '%s' does not exist." % (plugin_name))
-
-
-def get_setting(plugin_name, setting_name):
-    """Get a compizconfig setting object, given a plugin name and setting name.
-
-    Raises KeyError if the plugin or setting is not found.
-
-    """
-    plugin = get_plugin(plugin_name)
-    with Silence():
-        try:
-            return plugin.Screen[setting_name]
-        except KeyError:
-            raise KeyError("Compiz setting '%s' does not exist in plugin '%s'." % (setting_name, plugin_name))

=== renamed file 'autopilot/emulators/dbus_handler.py' => 'autopilot/dbus_handler.py'
=== added directory 'autopilot/display'
=== added file 'autopilot/display/_X11.py'
--- autopilot/display/_X11.py	1970-01-01 00:00:00 +0000
+++ autopilot/display/_X11.py	2013-04-15 21:43:32 +0000
@@ -0,0 +1,50 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2013 Canonical
+# Author: Christopher Lee
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+import logging
+
+from autopilot.display import Display as DisplayBase
+
+logger = logging.getLogger(__name__)
+
+class Display(DisplayBase):
+    def __init__(self):
+        # Note: MUST import these here, rather than at the top of the file. Why?
+        # Because sphinx imports these modules to build the API documentation,
+        # which in turn tries to import Gdk, which in turn fails because there's
+        # no DISPlAY environment set in the package builder.
+        from gi.repository import Gdk
+        self._default_screen = Gdk.Screen.get_default()
+        self._blacklisted_drivers = ["NVIDIA"]
+
+    def get_num_screens(self):
+        """Get the number of screens attached to the PC."""
+        return self._default_screen.get_n_monitors()
+
+    def get_primary_screen(self):
+        """Returns an integer of which screen is considered the primary"""
+        return self._default_screen.get_primary_monitor()
+
+    def get_screen_width(self, screen_number=0):
+        # return self._default_screen.get_width()
+        return self.get_screen_geometry(screen_number)[2]
+
+    def get_screen_height(self, screen_number=0):
+        #return self._default_screen.get_height()
+        return self.get_screen_geometry(screen_number)[3]
+
+    def get_screen_geometry(self, screen_number):
+        """Get the geometry for a particular screen.
+
+        :return: Tuple containing (x, y, width, height).
+
+        """
+        if screen_number < 0 or screen_number >= self.get_num_screens():
+            raise ValueError('Specified screen number is out of range.')
+        rect = self._default_screen.get_monitor_geometry(screen_number)
+        return (rect.x, rect.y, rect.width, rect.height)

=== added file 'autopilot/display/__init__.py'
--- autopilot/display/__init__.py	1970-01-01 00:00:00 +0000
+++ autopilot/display/__init__.py	2013-04-15 21:43:32 +0000
@@ -0,0 +1,136 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2013 Canonical
+# Author: Christopher Lee
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+"""The display module contaions support for getting screen information."""
+
+from collections import OrderedDict
+from autopilot.utilities import _pick_variant
+from autopilot.input import Mouse
+
+
+def is_rect_on_screen(screen_number, rect):
+    """Returns True if *rect* is **entirely** on the specified screen, with no overlap."""
+    (x, y, w, h) = rect
+    (mx, my, mw, mh) = Display.create().get_screen_geometry(screen_number)
+    return (x >= mx and x + w <= mx + mw and y >= my and y + h <= my + mh)
+
+
+def is_point_on_screen(screen_number, point):
+    """Returns True if *point* is on the specified screen.
+
+    *point* must be an iterable type with two elements: (x, y)
+
+    """
+    x, y = point
+    (mx, my, mw, mh) = Display.create().get_screen_geometry(screen_number)
+    return (x >= mx and x < mx + mw and y >= my and y < my + mh)
+
+
+def is_point_on_any_screen(point):
+    """Returns true if *point* is on any currently configured screen."""
+    return any([is_point_on_screen(m, point) for m in range(Display.create().get_num_screens())])
+
+
+def move_mouse_to_screen(screen_number):
+    """Move the mouse to the center of the specified screen."""
+    geo = Display.create().get_screen_geometry(screen_number)
+    x = geo[0] + (geo[2] / 2)
+    y = geo[1] + (geo[3] / 2)
+    #dont animate this or it might not get there due to barriers
+    Mouse.create().move(x, y, False)
+
+
+# veebers TODO: Write this so it's usable.
+# def drag_window_to_screen(self, window, screen):
+#     """Drags *window* to *screen*
+
+#     :param BamfWindow window: The window to drag
+#     :param integer screen: The screen to drag the *window* to
+#     :raises: **TypeError** if *window* is not a BamfWindow
+
+#     """
+#     if not isinstance(window, BamfWindow):
+#         raise TypeError("Window must be a BamfWindow")
+
+#     if window.monitor == screen:
+#         logger.debug("Window %r is already on screen %d." % (window.x_id, screen))
+#         return
+
+#     assert(not window.is_maximized)
+#     (win_x, win_y, win_w, win_h) = window.geometry
+#     (mx, my, mw, mh) = self.get_screen_geometry(screen)
+
+#     logger.debug("Dragging window %r to screen %d." % (window.x_id, screen))
+
+#     mouse = Mouse()
+#     keyboard = Keyboard()
+#     mouse.move(win_x + win_w/2, win_y + win_h/2)
+#     keyboard.press("Alt")
+#     mouse.press()
+#     keyboard.release("Alt")
+
+#     # We do the movements in two steps, to reduce the risk of being
+#     # blocked by the pointer barrier
+#     target_x = mx + mw/2
+#     target_y = my + mh/2
+#     mouse.move(win_x, target_y, rate=20, time_between_events=0.005)
+#     mouse.move(target_x, target_y, rate=20, time_between_events=0.005)
+#     mouse.release()
+
+
+class Display:
+    """The base class/inteface for the display devices"""
+
+    @staticmethod
+    def create(preferred_variant=''):
+        """Get an instance of the Display class.
+
+        If variant is specified, it should be a string that specifies a backend to
+        use. However, this hint can be ignored - autopilot will prefer to return a
+        variant other than the one requested, rather than fail to return anything at
+        all.
+
+        If autopilot cannot instantate any of the possible backends, a RuntimeError
+        will be raised.
+        """
+        def get_x11_display():
+            from autopilot.display._X11 import Display
+            return Display()
+
+        def get_upa_display():
+            from autopilot.display._upa import Display
+            return Display()
+
+        variants = OrderedDict()
+        variants['X11'] = get_x11_display
+        variants['UPA'] = get_upa_display
+        return _pick_variant(variants, preferred_variant)
+
+    class BlacklistedDriverError(RuntimeError):
+        """Cannot set primary monitor when running drivers listed in the driver blacklist."""
+
+    def get_num_screens(self):
+        """Get the number of screens attached to the PC."""
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def get_primary_screen(self):
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def get_screen_width(self, screen_number=0):
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def get_screen_height(self, screen_number=0):
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def get_screen_geometry(self, monitor_number):
+        """Get the geometry for a particular monitor.
+
+        :return: Tuple containing (x, y, width, height).
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")

=== added file 'autopilot/display/_upa.py'
--- autopilot/display/_upa.py	1970-01-01 00:00:00 +0000
+++ autopilot/display/_upa.py	2013-04-15 21:43:32 +0000
@@ -0,0 +1,40 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2013 Canonical
+# Author: Christopher Lee
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+import logging
+
+from autopilot.display import Display as DisplayBase
+from upa import get_resolution
+
+logger = logging.getLogger(__name__)
+
+class Display(DisplayBase):
+    """The base class/inteface for the display devices"""
+
+    def get_num_screens(self):
+        """Get the number of screens attached to the PC."""
+        return 1
+
+    def get_primary_screen(self):
+        """Returns an integer of which screen is considered the primary"""
+        return 0
+
+    def get_screen_width(self):
+        return get_resolution()[0]
+
+    def get_screen_height(self):
+        return get_resolution()[1]
+
+    def get_screen_geometry(self, screen_number):
+        """Get the geometry for a particular screen.
+
+        :return: Tuple containing (x, y, width, height).
+
+        """
+        res = get_resolution()
+        return (0, 0, res[0], res[1])

=== removed directory 'autopilot/emulators'
=== added file 'autopilot/emulators.py'
--- autopilot/emulators.py	1970-01-01 00:00:00 +0000
+++ autopilot/emulators.py	2013-04-15 21:43:32 +0000
@@ -0,0 +1,21 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2013 Canonical
+# Author: Thomi Richards
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This script is designed to run unity in a test drive manner. It will drive
+# X and test the GL calls that Unity makes, so that we can easily find out if
+# we are triggering graphics driver/X bugs.
+
+import autopilot.display as display
+import autopilot.clipboard as clipboard
+import autopilot.dbus_handler as dbus_handler
+import autopilot.ibus as ibus
+import autopilot.input as input
+
+
+"""
+"""

=== removed file 'autopilot/emulators/X11.py'
--- autopilot/emulators/X11.py	2013-03-03 21:21:08 +0000
+++ autopilot/emulators/X11.py	1970-01-01 00:00:00 +0000
@@ -1,187 +0,0 @@
-# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-# Copyright 2010 Canonical
-# Author: Alex Launi
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This script is designed to run unity in a test drive manner. It will drive
-# X and test the GL calls that Unity makes, so that we can easily find out if
-# we are triggering graphics driver/X bugs.
-
-"""A collection of emulators for X11 - namely keyboards and mice.
-
-In the future we may also need other devices.
-
-"""
-
-from __future__ import absolute_import
-
-import logging
-import os
-import subprocess
-
-from autopilot.emulators.bamf import BamfWindow
-from autopilot.emulators.input import get_keyboard, get_mouse
-from autopilot.utilities import deprecated
-
-
-logger = logging.getLogger(__name__)
-
-
-def reset_display():
-    from autopilot.emulators.input._X11 import reset_display
-    reset_display()
-
-
-# Keyboard and Mouse are no longer here. This is for backwards compatibility,
-# but will eventually dissapear.
-@deprecated('autopilot.emulators.input.get_keyboard')
-def Keyboard():
-    return get_keyboard()
-
-
-@deprecated('autopilot.emulators.input.get_mouse')
-def Mouse():
-    return get_mouse()
-
-
-class ScreenGeometry:
-    """Get details about screen geometry."""
-
-    class BlacklistedDriverError(RuntimeError):
-        """Cannot set primary monitor when running drivers listed in the driver blacklist."""
-
-    def __init__(self):
-        # Note: MUST import these here, rather than at the top of the file. Why?
-        # Because sphinx imports these modules to build the API documentation,
-        # which in turn tries to import Gdk, which in turn fails because there's
-        # no DISPlAY environment set in the package builder.
-        from gi.repository import Gdk
-        self._default_screen = Gdk.Screen.get_default()
-        self._blacklisted_drivers = ["NVIDIA"]
-
-    def get_num_monitors(self):
-        """Get the number of monitors attached to the PC."""
-        return self._default_screen.get_n_monitors()
-
-    def get_primary_monitor(self):
-        return self._default_screen.get_primary_monitor()
-
-    def set_primary_monitor(self, monitor):
-        """Set *monitor* to be the primary monitor.
-
-        :param int monitor: Must be between 0 and the number of configured
-         monitors.
-        :raises: **ValueError** if an invalid monitor is specified.
-        :raises: **BlacklistedDriverError** if your video driver does not
-         support this.
-
-        """
-        try:
-            glxinfo_out = subprocess.check_output("glxinfo")
-        except OSError, e:
-            raise OSError("Failed to run glxinfo: %s. (do you have mesa-utils installed?)" % e)
-
-        for dri in self._blacklisted_drivers:
-            if dri in glxinfo_out:
-                raise ScreenGeometry.BlacklistedDriverError('Impossible change the primary monitor for the given driver')
-
-        if monitor < 0 or monitor >= self.get_num_monitors():
-            raise ValueError('Monitor %d is not in valid range of 0 <= monitor < %d.' % (self.get_num_monitors()))
-
-        monitor_name = self._default_screen.get_monitor_plug_name(monitor)
-
-        if not monitor_name:
-            raise ValueError('Could not get monitor name from monitor number %d.' % (monitor))
-
-        ret = os.spawnlp(os.P_WAIT, "xrandr", "xrandr", "--output", monitor_name, "--primary")
-
-        if ret != 0:
-            raise RuntimeError('Xrandr can\'t set the primary monitor. error code: %d' % (ret))
-
-    def get_screen_width(self):
-        return self._default_screen.get_width()
-
-    def get_screen_height(self):
-        return self._default_screen.get_height()
-
-    def get_monitor_geometry(self, monitor_number):
-        """Get the geometry for a particular monitor.
-
-        :return: Tuple containing (x, y, width, height).
-
-        """
-        if monitor_number < 0 or monitor_number >= self.get_num_monitors():
-            raise ValueError('Specified monitor number is out of range.')
-        rect = self._default_screen.get_monitor_geometry(monitor_number)
-        return (rect.x, rect.y, rect.width, rect.height)
-
-    def is_rect_on_monitor(self, monitor_number, rect):
-        """Returns True if *rect* is **entirely** on the specified monitor, with no overlap."""
-
-        if type(rect) is not tuple or len(rect) != 4:
-            raise TypeError("rect must be a tuple of 4 int elements.")
-
-        (x, y, w, h) = rect
-        (mx, my, mw, mh) = self.get_monitor_geometry(monitor_number)
-        return (x >= mx and x + w <= mx + mw and y >= my and y + h <= my + mh)
-
-    def is_point_on_monitor(self, monitor_number, point):
-        """Returns True if *point* is on the specified monitor.
-
-        *point* must be an iterable type with two elements: (x, y)
-
-        """
-        x,y = point
-        (mx, my, mw, mh) = self.get_monitor_geometry(monitor_number)
-        return (x >= mx and x < mx + mw and y >= my and y < my + mh)
-
-    def is_point_on_any_monitor(self, point):
-        """Returns true if *point* is on any currently configured monitor."""
-        return any([self.is_point_on_monitor(m, point) for m in range(self.get_num_monitors())])
-
-    def move_mouse_to_monitor(self, monitor_number):
-        """Move the mouse to the center of the specified monitor."""
-        geo = self.get_monitor_geometry(monitor_number)
-        x = geo[0] + (geo[2] / 2)
-        y = geo[1] + (geo[3] / 2)
-        #dont animate this or it might not get there due to barriers
-        Mouse().move(x, y, False)
-
-    def drag_window_to_monitor(self, window, monitor):
-        """Drags *window* to *monitor*
-
-        :param BamfWindow window: The window to drag
-        :param integer monitor: The monitor to drag the *window* to
-        :raises: **TypeError** if *window* is not a BamfWindow
-
-        """
-        if not isinstance(window, BamfWindow):
-            raise TypeError("Window must be a BamfWindow")
-
-        if window.monitor == monitor:
-            logger.debug("Window %r is already on monitor %d." % (window.x_id, monitor))
-            return
-
-        assert(not window.is_maximized)
-        (win_x, win_y, win_w, win_h) = window.geometry
-        (mx, my, mw, mh) = self.get_monitor_geometry(monitor)
-
-        logger.debug("Dragging window %r to monitor %d." % (window.x_id, monitor))
-
-        mouse = Mouse()
-        keyboard = Keyboard()
-        mouse.move(win_x + win_w/2, win_y + win_h/2)
-        keyboard.press("Alt")
-        mouse.press()
-        keyboard.release("Alt")
-
-        # We do the movements in two steps, to reduce the risk of being
-        # blocked by the pointer barrier
-        target_x = mx + mw/2
-        target_y = my + mh/2
-        mouse.move(win_x, target_y, rate=20, time_between_events=0.005)
-        mouse.move(target_x, target_y, rate=20, time_between_events=0.005)
-        mouse.release()

=== removed file 'autopilot/emulators/__init__.py'
--- autopilot/emulators/__init__.py	2012-08-20 23:57:20 +0000
+++ autopilot/emulators/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,11 +0,0 @@
-# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-# Copyright 2012 Canonical
-# Author: Thomi Richards
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-
-"""
-A collection of emulators that make it easier to interact with X11 and Unity.
-"""

=== removed file 'autopilot/emulators/processmanager.py'
--- autopilot/emulators/processmanager.py	2012-06-07 04:52:04 +0000
+++ autopilot/emulators/processmanager.py	1970-01-01 00:00:00 +0000
@@ -1,66 +0,0 @@
-# Copyright 2012 Canonical
-# Author: Thomi Richards
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-
-"""The processmanager module contains utilities for starting, stopping, and
-generally managing processes during a test."""
-
-from __future__ import absolute_import
-import logging
-from time import sleep
-
-from autopilot.emulators.bamf import Bamf
-
-
-logger = logging.getLogger(__name__)
-
-class ProcessManager(object):
-    """Manage Processes during a test cycle."""
-
-    def __init__(self):
-        self._bamf = Bamf()
-        self.snapshot = None
-
-    def snapshot_running_apps(self):
-        """Make a list of all the running applications, and store it.
-
-        The stored list can later be used to detect any applications that have
-        been launched during a test and not shut down.
-
-        You may only call this method once before calling
-        compare_system_with_snapshot. Calling this method multiple times will
-        cause a RuntimeError to be raised.
-        """
-
-        if self.snapshot:
-            raise RuntimeError("You may only call snapshot_running_apps once \
-before calling compare_system_with_snapshot.")
-
-        self.snapshot = self._bamf.get_running_applications()
-
-    def compare_system_with_snapshot(self):
-        """Compare the currently running application with the last snapshot.
-
-        This method will raise an AssertionError if there are any new applications
-        currently running that were not running when the snapshot was taken.
-
-        This method should typically be called at the every end of a test.
-        """
-        if self.snapshot is None:
-            raise RuntimeError("No snapshot to match against.")
-
-        new_apps = []
-        for i in range(10):
-            current_apps = self._bamf.get_running_applications()
-            new_apps = filter(lambda i: i not in self.snapshot, current_apps)
-            if not new_apps:
-                self.snapshot = None
-                return
-            sleep(1)
-        self.snapshot = None
-        raise AssertionError("The following apps were started during the test and not closed: %r", new_apps)
-
-

=== removed file 'autopilot/emulators/zeitgeist.py'
--- autopilot/emulators/zeitgeist.py	2012-10-26 14:15:43 +0000
+++ autopilot/emulators/zeitgeist.py	1970-01-01 00:00:00 +0000
@@ -1,66 +0,0 @@
-# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-# Copyright 2012 Canonical
-# Author: Brandon Schaefer
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-
-"""Provide ability to register text files with the file lens."""
-
-from __future__ import absolute_import
-
-import logging
-import os.path
-from zeitgeist.client import ZeitgeistClient
-from zeitgeist.datamodel import Event, Interpretation, Manifestation, ResultType
-
-
-class Zeitgeist(object):
-    """Provide access zeitgeist."""
-
-    def __init__(self):
-        self.zg = ZeitgeistClient()
-        self.logger = logging.getLogger(__name__)
-
-    def add_existing_file(self, path):
-        """Registers *file* with zeitgeist.
-
-        :param string file: full path to an existing text file to register.
-        :raises: **RuntimeError** if *file* does not exist.
-
-        """
-        if os.path.exists(path):
-            self.__add_text_file(path)
-        else:
-          raise RuntimeError("File not found on path: %s." % (path))
-
-    def __add_text_file(self, path):
-        """Takes a path to a file and creates an event for it then querys it."""
-        file_lens = "file://"
-        dir_path = os.path.dirname(path)
-        name = os.path.basename(path)
-
-        event = Event.new_for_values (interpretation=Interpretation.ACCESS_EVENT,
-                                      manifestation=Manifestation.USER_ACTIVITY,
-                                      subject_uri=file_lens + path,
-                                      subject_interpretation=Interpretation.TEXT_DOCUMENT,
-                                      subject_manifestation=Manifestation.FILE_DATA_OBJECT,
-                                      subject_origin=file_lens + dir_path,
-                                      subject_text=name)
-        self.zg.insert_event(event)
-
-        template = Event.new_for_values (interpretation=Interpretation.ACCESS_EVENT,
-                                         manifestation=Manifestation.USER_ACTIVITY)
-
-        self.zg.find_events_for_template (template,
-                                     self.__log_events_cb,
-                                     num_events=1,
-                                     result_type=ResultType.MostRecentSubjects)
-
-    def __log_events_cb(self, events):
-        """Callback to recive events, we are just using it to log each event."""
-        self.logger.info("Found Events")
-        for event in events:
-            for subject in event.subjects:
-                self.logger.info(" * %s" % (subject.uri))

=== added file 'autopilot/gestures.py'
--- autopilot/gestures.py	1970-01-01 00:00:00 +0000
+++ autopilot/gestures.py	2013-04-15 21:43:32 +0000
@@ -0,0 +1,62 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2013 Canonical
+# Author: Thomi Richards
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+"""Gestural support for autopilot.
+
+This module contains functions that can generate touch and multi-tuch gestures
+for you. This is a convenience for the test author - there is nothing to prevent
+you from generating your own gestures!
+
+"""
+
+from autopilot.input import Touch
+from time import sleep
+
+
+def pinch(center, vector_start, vector_end):
+    """Perform a two finger pinch (zoom) gesture.
+
+    :param center: The coordinates (x,y) of the center of the pinch gesture.
+    :param vector_start: The (x,y) values to move away from the center for the start.
+    :param vector_end: The (x,y) values to move away from the center for the end.
+
+    The fingers will move in 100 steps between the start and the end points.
+    If start is smaller than end, the gesture will zoom in, otherwise it
+    will zoom out.
+
+    """
+
+    finger_1_start = [center[0] - vector_start[0], center[1] - vector_start[1]]
+    finger_2_start = [center[0] + vector_start[0], center[1] + vector_start[1]]
+    finger_1_end = [center[0] - vector_end[0], center[1] - vector_end[1]]
+    finger_2_end = [center[0] + vector_end[0], center[1] + vector_end[1]]
+
+    dx = 1.0 * (finger_1_end[0] - finger_1_start[0]) / 100
+    dy = 1.0 * (finger_1_end[1] - finger_1_start[1]) / 100
+
+    finger_1 = Touch.create()
+    finger_2 = Touch.create()
+
+    finger_1.press(*finger_1_start)
+    finger_2.press(*finger_2_start)
+
+    finger_1_cur = [finger_1_start[0] + dx, finger_1_start[1] + dy]
+    finger_2_cur = [finger_2_start[0] - dx, finger_2_start[1] - dy]
+
+    for i in range(0, 100):
+        finger_1.move(*finger_1_cur)
+        finger_2.move(*finger_2_cur)
+        sleep(0.005)
+
+        finger_1_cur = [finger_1_cur[0] + dx, finger_1_cur[1] + dy]
+        finger_2_cur = [finger_2_cur[0] - dx, finger_2_cur[1] - dy]
+
+    finger_1.move(*finger_1_end)
+    finger_2.move(*finger_2_end)
+    finger_1.release()
+    finger_2.release()

=== removed file 'autopilot/glibrunner.py'
--- autopilot/glibrunner.py	2012-09-26 23:21:20 +0000
+++ autopilot/glibrunner.py	1970-01-01 00:00:00 +0000
@@ -1,26 +0,0 @@
-# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-# Copyright 2012 Canonical
-# Author: Thomi Richards
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-
-from __future__ import absolute_import
-
-import testtools
-
-try:
-    import faulthandler
-    faulthandler.enable()
-except:
-    pass
-
-
-__all__ = [
-    'AutopilotTestRunner',
-    ]
-
-class AutopilotTestRunner(testtools.RunTest):
-    pass
-

=== modified file 'autopilot/globals.py'
--- autopilot/globals.py	2012-09-19 23:31:57 +0000
+++ autopilot/globals.py	2013-04-15 21:43:32 +0000
@@ -7,12 +7,16 @@
 # by the Free Software Foundation.
 
 from __future__ import absolute_import
-
-# this can be set to True, in which case tests will be recorded.
-__video_recording_enabled = False
-
-# this is where videos will be put after being encoded.
-__video_record_directory = "/tmp/autopilot"
+from StringIO import StringIO
+from autopilot.utilities import LogFormatter
+from testtools.content import text_content
+import subprocess
+import os.path
+import logging
+from autopilot.utilities import addCleanup
+
+logger = logging.getLogger(__name__)
+
 
 # if set to true, autopilot will output all pythong logging to stderr
 __log_verbose = False
@@ -23,12 +27,114 @@
     return __log_verbose
 
 
+class _TestLogger(object):
+    """A class that handles adding test logs as test result content."""
+
+    def __call__(self, test_instance):
+        self._setUpTestLogging(test_instance)
+        if get_log_verbose():
+            global logger
+            logger.info("*" * 60)
+            logger.info("Starting test %s", test_instance.shortDescription())
+
+    def _setUpTestLogging(self, test_instance):
+        self._log_buffer = StringIO()
+        root_logger = logging.getLogger()
+        root_logger.setLevel(logging.DEBUG)
+        formatter = LogFormatter()
+        self._log_handler = logging.StreamHandler(stream=self._log_buffer)
+        self._log_handler.setFormatter(formatter)
+        root_logger.addHandler(self._log_handler)
+        test_instance.addCleanup(self._tearDownLogging, test_instance)
+
+    def _tearDownLogging(self, test_instance):
+        root_logger = logging.getLogger()
+        self._log_handler.flush()
+        self._log_buffer.seek(0)
+        test_instance.addDetail('test-log', text_content(self._log_buffer.getvalue()))
+        root_logger.removeHandler(self._log_handler)
+        # Calling del to remove the handler and flush the buffer.  We are
+        # abusing the log handlers here a little.
+        del self._log_buffer
+
+
 def set_log_verbose(verbose):
     """Set whether or not we should log verbosely."""
+
     if type(verbose) is not bool:
         raise TypeError("Verbose flag must be a boolean.")
     global __log_verbose
     __log_verbose = verbose
+    if verbose:
+        logger = _TestLogger()
+        _on_test_started_call.append(logger)
+
+
+class _VideoCaptureTestCase(object):
+    """Video capture autopilot tests, saving the results if the test failed."""
+
+    _recording_app = '/usr/bin/recordmydesktop'
+    _recording_opts = ['--no-sound', '--no-frame', '-o',]
+
+    def __init__(self, recording_directory):
+        self.recording_directory = recording_directory
+
+    def __call__(self, test_instance):
+        if not self._have_recording_app():
+            logger.warning("Disabling video capture since '%s' is not present", self._recording_app)
+
+        self._test_passed = True
+        test_instance.addOnException(self._on_test_failed)
+        test_instance.addCleanup(self._stop_video_capture, test_instance)
+        self._start_video_capture(test_instance.shortDescription())
+
+    def _have_recording_app(self):
+        return os.path.exists(self._recording_app)
+
+    def _start_video_capture(self, test_id):
+        args = self._get_capture_command_line()
+        self._capture_file = os.path.join(
+            self.recording_directory,
+            '%s.ogv' % (test_id)
+            )
+        self._ensure_directory_exists_but_not_file(self._capture_file)
+        args.append(self._capture_file)
+        logger.debug("Starting: %r", args)
+        self._capture_process = subprocess.Popen(
+            args,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT
+            )
+
+    def _stop_video_capture(self, test_instance):
+        """Stop the video capture. If the test failed, save the resulting file."""
+
+        if self._test_passed:
+            # We use kill here because we don't want the recording app to start
+            # encoding the video file (since we're removing it anyway.)
+            self._capture_process.kill()
+            self._capture_process.wait()
+        else:
+            self._capture_process.terminate()
+            self._capture_process.wait()
+            if self._capture_process.returncode != 0:
+                test_instance.addDetail('video capture log', text_content(self._capture_process.stdout.read()))
+        self._capture_process = None
+
+    def _get_capture_command_line(self):
+        return [self._recording_app] + self._recording_opts
+
+    def _ensure_directory_exists_but_not_file(self, file_path):
+        dirpath = os.path.dirname(file_path)
+        if not os.path.exists(dirpath):
+            os.makedirs(dirpath)
+        elif os.path.exists(file_path):
+            logger.warning("Video capture file '%s' already exists, deleting.", file_path)
+            os.remove(file_path)
+
+    def _on_test_failed(self, ex_info):
+        """Called when a test fails."""
+        self._test_passed = False
 
 
 def configure_video_recording(enable_recording, record_dir):
@@ -43,18 +149,14 @@
     if not isinstance(record_dir, basestring):
         raise TypeError("record_dir must be a string.")
 
-    global __video_recording_enabled
-    global __video_record_directory
-
-    __video_recording_enabled = enable_recording
-    __video_record_directory = record_dir
-
-
-def get_video_recording_enabled():
-    global __video_recording_enabled
-    return __video_recording_enabled
-
-
-def get_video_record_directory():
-    global __video_record_directory
-    return __video_record_directory
+    if enable_recording:
+        recorder = _VideoCaptureTestCase(record_dir)
+        _on_test_started_call.append(recorder)
+
+
+_on_test_started_call = [addCleanup.set_test_instance]
+
+def on_test_started(test_case_instance):
+    global _on_test_started_call
+    for fun in _on_test_started_call:
+        fun(test_case_instance)

=== renamed file 'autopilot/emulators/ibus.py' => 'autopilot/ibus.py'
=== renamed directory 'autopilot/emulators/input' => 'autopilot/input'
=== modified file 'autopilot/input/_X11.py'
--- autopilot/emulators/input/_X11.py	2013-02-28 03:18:15 +0000
+++ autopilot/input/_X11.py	2013-04-15 21:43:32 +0000
@@ -19,13 +19,11 @@
 from __future__ import absolute_import
 
 import logging
-import os
-import subprocess
 from time import sleep
 
-from autopilot.emulators.bamf import BamfWindow
+from autopilot.display import is_point_on_any_screen, move_mouse_to_screen
 from autopilot.utilities import Silence
-from autopilot.emulators.input import (
+from autopilot.input import (
     Keyboard as KeyboardBase,
     Mouse as MouseBase,
     )
@@ -321,7 +319,7 @@
 
         dest_x, dest_y = x, y
         curr_x, curr_y = self.position()
-        coordinate_valid = ScreenGeometry().is_point_on_any_monitor((x,y))
+        coordinate_valid = is_point_on_any_screen((x,y))
 
         while curr_x != dest_x or curr_y != dest_y:
             dx = abs(dest_x - curr_x)
@@ -416,145 +414,4 @@
             logger.debug("Releasing mouse button %d as part of cleanup", btn)
             fake_input(get_display(), X.ButtonRelease, btn)
         _PRESSED_MOUSE_BUTTONS = []
-        sg = ScreenGeometry()
-        sg.move_mouse_to_monitor(0)
-
-
-class ScreenGeometry:
-    """Get details about screen geometry."""
-
-    class BlacklistedDriverError(RuntimeError):
-        """Cannot set primary monitor when running drivers listed in the driver blacklist."""
-
-    def __init__(self):
-        # Note: MUST import these here, rather than at the top of the file. Why?
-        # Because sphinx imports these modules to build the API documentation,
-        # which in turn tries to import Gdk, which in turn fails because there's
-        # no DISPlAY environment set in the package builder.
-        from gi.repository import Gdk
-        self._default_screen = Gdk.Screen.get_default()
-        self._blacklisted_drivers = ["NVIDIA"]
-
-    def get_num_monitors(self):
-        """Get the number of monitors attached to the PC."""
-        return self._default_screen.get_n_monitors()
-
-    def get_primary_monitor(self):
-        return self._default_screen.get_primary_monitor()
-
-    def set_primary_monitor(self, monitor):
-        """Set *monitor* to be the primary monitor.
-
-        :param int monitor: Must be between 0 and the number of configured
-         monitors.
-        :raises: **ValueError** if an invalid monitor is specified.
-        :raises: **BlacklistedDriverError** if your video driver does not
-         support this.
-
-        """
-        try:
-            glxinfo_out = subprocess.check_output("glxinfo")
-        except OSError, e:
-            raise OSError("Failed to run glxinfo: %s. (do you have mesa-utils installed?)" % e)
-
-        for dri in self._blacklisted_drivers:
-            if dri in glxinfo_out:
-                raise ScreenGeometry.BlacklistedDriverError('Impossible change the primary monitor for the given driver')
-
-        if monitor < 0 or monitor >= self.get_num_monitors():
-            raise ValueError('Monitor %d is not in valid range of 0 <= monitor < %d.' % (self.get_num_monitors()))
-
-        monitor_name = self._default_screen.get_monitor_plug_name(monitor)
-
-        if not monitor_name:
-            raise ValueError('Could not get monitor name from monitor number %d.' % (monitor))
-
-        ret = os.spawnlp(os.P_WAIT, "xrandr", "xrandr", "--output", monitor_name, "--primary")
-
-        if ret != 0:
-            raise RuntimeError('Xrandr can\'t set the primary monitor. error code: %d' % (ret))
-
-    def get_screen_width(self):
-        return self._default_screen.get_width()
-
-    def get_screen_height(self):
-        return self._default_screen.get_height()
-
-    def get_monitor_geometry(self, monitor_number):
-        """Get the geometry for a particular monitor.
-
-        :return: Tuple containing (x, y, width, height).
-
-        """
-        if monitor_number < 0 or monitor_number >= self.get_num_monitors():
-            raise ValueError('Specified monitor number is out of range.')
-        rect = self._default_screen.get_monitor_geometry(monitor_number)
-        return (rect.x, rect.y, rect.width, rect.height)
-
-    def is_rect_on_monitor(self, monitor_number, rect):
-        """Returns True if *rect* is **entirely** on the specified monitor, with no overlap."""
-
-        if type(rect) is not tuple or len(rect) != 4:
-            raise TypeError("rect must be a tuple of 4 int elements.")
-
-        (x, y, w, h) = rect
-        (mx, my, mw, mh) = self.get_monitor_geometry(monitor_number)
-        return (x >= mx and x + w <= mx + mw and y >= my and y + h <= my + mh)
-
-    def is_point_on_monitor(self, monitor_number, point):
-        """Returns True if *point* is on the specified monitor.
-
-        *point* must be an iterable type with two elements: (x, y)
-
-        """
-        x,y = point
-        (mx, my, mw, mh) = self.get_monitor_geometry(monitor_number)
-        return (x >= mx and x < mx + mw and y >= my and y < my + mh)
-
-    def is_point_on_any_monitor(self, point):
-        """Returns true if *point* is on any currently configured monitor."""
-        return any([self.is_point_on_monitor(m, point) for m in range(self.get_num_monitors())])
-
-    def move_mouse_to_monitor(self, monitor_number):
-        """Move the mouse to the center of the specified monitor."""
-        geo = self.get_monitor_geometry(monitor_number)
-        x = geo[0] + (geo[2] / 2)
-        y = geo[1] + (geo[3] / 2)
-        #dont animate this or it might not get there due to barriers
-        Mouse().move(x, y, False)
-
-    def drag_window_to_monitor(self, window, monitor):
-        """Drags *window* to *monitor*
-
-        :param BamfWindow window: The window to drag
-        :param integer monitor: The monitor to drag the *window* to
-        :raises: **TypeError** if *window* is not a BamfWindow
-
-        """
-        if not isinstance(window, BamfWindow):
-            raise TypeError("Window must be a BamfWindow")
-
-        if window.monitor == monitor:
-            logger.debug("Window %r is already on monitor %d." % (window.x_id, monitor))
-            return
-
-        assert(not window.is_maximized)
-        (win_x, win_y, win_w, win_h) = window.geometry
-        (mx, my, mw, mh) = self.get_monitor_geometry(monitor)
-
-        logger.debug("Dragging window %r to monitor %d." % (window.x_id, monitor))
-
-        mouse = Mouse()
-        keyboard = Keyboard()
-        mouse.move(win_x + win_w/2, win_y + win_h/2)
-        keyboard.press("Alt")
-        mouse.press()
-        keyboard.release("Alt")
-
-        # We do the movements in two steps, to reduce the risk of being
-        # blocked by the pointer barrier
-        target_x = mx + mw/2
-        target_y = my + mh/2
-        mouse.move(win_x, target_y, rate=20, time_between_events=0.005)
-        mouse.move(target_x, target_y, rate=20, time_between_events=0.005)
-        mouse.release()
+        move_mouse_to_screen(0)

=== modified file 'autopilot/input/__init__.py'
--- autopilot/emulators/input/__init__.py	2013-02-28 03:18:15 +0000
+++ autopilot/input/__init__.py	2013-04-15 21:43:32 +0000
@@ -6,99 +6,81 @@
 # under the terms of the GNU General Public License version 3, as published
 # by the Free Software Foundation.
 
-from collections import OrderedDict
-from autopilot.utilities import get_debug_logger
-
-"""Autopilot unified input system.
+"""
+Autopilot unified input system.
+===============================
 
 This package provides input methods for various platforms. Autopilot aims to
 provide an appropriate implementation for the currently running system. For
 example, not all systems have an X11 stack running: on those systems, autopilot
-will instantiate a Keyboard class that uses something other than X11 to generate
-key events (possibly UInput).
-
-Test authors are encouraged to instantiate the input devices they need for their
-tests using the get_keyboard and get_mouse methods directly. In the case where
-these methods don't do the right thing, authors may access the underlying input
-systems directly. However, these are not documented, and are liable to change
-without notice.
+will instantiate input classes class that use something other than X11 to generate
+events (possibly UInput).
+
+Test authors should instantiate the appropriate class using the ``create`` method
+on each class. Tests can provide a hint to this method to suggest that a particular
+subsystem be used. However, autopilot will prefer to return a subsystem other than
+the one specified, if the requested subsystem is unavailable.
+
+There are three basic input types available:
+
+ * :class:`Keyboard` - traditional keyboard devices.
+ * :class:`Mouse` - traditional mouse devices.
+ * :class:`Touch` - single point-of-contact touch device.
+ * For multitouch capabilities, see the :mod:`autopilot.gestures` module.
 
 """
 
-
-def get_keyboard(preferred_variant=""):
-    """Get an instance of the Keyboard class.
-
-    If variant is specified, it should be a string that specifies a backend to
-    use. However, this hint can be ignored - autopilot will prefer to return a
-    keyboard variant other than the one requested, rather than fail to return
-    anything at all.
-
-    If autopilot cannot instantate any of the possible backends, a RuntimeError
-    will be raised.
-    """
-    def get_x11_kb():
-        from autopilot.emulators.input._X11 import Keyboard
-        return Keyboard()
-    def get_uinput_kb():
-        from autopilot.emulators.input._uinput import Keyboard
-        return Keyboard()
-
-    variants = OrderedDict()
-    variants['X11'] = get_x11_kb
-    variants['UInput'] = get_uinput_kb
-    return _pick_variant(variants, preferred_variant)
-
-
-def get_mouse(preferred_variant=""):
-    """Get an instance of the Mouse class.
-
-    If variant is specified, it should be a string that specifies a backend to
-    use. However, this hint can be ignored - autopilot will prefer to return a
-    mouse variant other than the one requested, rather than fail to return
-    anything at all.
-
-    If autopilot cannot instantate any of the possible backends, a RuntimeError
-    will be raised.
-    """
-    def get_x11_mouse():
-        from autopilot.emulators.input._X11 import Mouse
-        return Mouse()
-
-    variants = OrderedDict()
-    variants['X11'] = get_x11_mouse
-    return _pick_variant(variants, preferred_variant)
-
-
-def _pick_variant(variants, preferred_variant):
-    possible_backends = variants.keys()
-    get_debug_logger().debug("Possible keyboard variants: %s", ','.join(possible_backends))
-    if preferred_variant in possible_backends:
-        possible_backends.sort(lambda a,b: -1 if a == preferred_variant else 0)
-    failure_reasons = []
-    for be in possible_backends:
-        try:
-            return variants[be]()
-        except Exception as e:
-            get_debug_logger().warning("Can't create keyboard variant %s: %r", be, e)
-            failure_reasons.append('%s: %r' % (be, e))
-    raise RuntimeError("Unable to instantiate any Keyboard backends\n%s" % '\n'.join(failure_reasons))
+from collections import OrderedDict
+from autopilot.utilities import _pick_variant
+
 
 
 class Keyboard(object):
 
-    """A base class for all keyboard-type devices."""
+    """A simple keyboard device class.
+
+    The keyboard class is used to generate key events while in an autopilot
+    test. This class should not be instantiated directly however. To get an
+    instance of the keyboard class, call :py:meth:`create` instead.
+
+    """
+
+    @staticmethod
+    def create(preferred_variant=''):
+        """Get an instance of the :py:class:`Keyboard` class.
+
+        :param preferred_variant: A string containing a hint as to which variant you
+            would like. However, this hint can be ignored - autopilot will prefer to
+            return a keyboard variant other than the one requested, rather than fail
+            to return anything at all.
+        :raises: a RuntimeError will be raised if autopilot cannot instantate any of
+            the possible backends.
+
+        """
+        def get_x11_kb():
+            from autopilot.input._X11 import Keyboard
+            return Keyboard()
+        def get_uinput_kb():
+            from autopilot.input._uinput import Keyboard
+            return Keyboard()
+
+        variants = OrderedDict()
+        variants['X11'] = get_x11_kb
+        variants['UInput'] = get_uinput_kb
+        return _pick_variant(variants, preferred_variant)
 
     def press(self, keys, delay=0.2):
         """Send key press events only.
 
-        :param string keys: Keys you want pressed.
+        :param keys: Keys you want pressed.
+        :param delay: The delay (in Seconds) after pressing the keys before
+            returning control to the caller.
 
         Example:
 
         >>> press('Alt+F2')
 
-        presses the 'Alt' and 'F2' keys.
+        presses the 'Alt' and 'F2' keys, but does not release them.
 
         """
         raise NotImplementedError("You cannot use this class directly.")
@@ -106,7 +88,9 @@
     def release(self, keys, delay=0.2):
         """Send key release events only.
 
-        :param string keys: Keys you want released.
+        :param keys: Keys you want released.
+        :param delay: The delay (in Seconds) after releasing the keys before
+            returning control to the caller.
 
         Example:
 
@@ -122,7 +106,9 @@
 
         This is the same as calling 'press(keys);release(keys)'.
 
-        :param string keys: Keys you want pressed and released.
+        :param keys: Keys you want pressed and released.
+        :param delay: The delay (in Seconds) after pressing and releasing each
+            key.
 
         Example:
 
@@ -137,6 +123,11 @@
     def type(self, string, delay=0.1):
         """Simulate a user typing a string of text.
 
+        :param string: The string to text to type.
+        :param delay: The delay (in Seconds) after pressing and releasing each
+            key. Note that the default value here is shorter than for the press,
+            release and press_and_release methods.
+
         .. note:: Only 'normal' keys can be typed with this method. Control
          characters (such as 'Alt' will be interpreted as an 'A', and 'l',
          and a 't').
@@ -156,7 +147,40 @@
 
 
 class Mouse(object):
-    """A base class for all mouse-type classes."""
+
+    """A simple mouse device class.
+
+    The mouse class is used to generate mouse events while in an autopilot
+    test. This class should not be instantiated directly however. To get an
+    instance of the mouse class, call :py:meth:`create` instead.
+
+    For example, to create a mouse object and click at (100,50):
+
+    >>> mouse = autopilot.input.Mouse.create()
+    >>> mouse.move(100, 50)
+    >>> mouse.click()
+
+    """
+
+    @staticmethod
+    def create(preferred_variant=''):
+        """Get an instance of the :py:class:`Mouse` class.
+
+        :param preferred_variant: A string containing a hint as to which variant you
+            would like. However, this hint can be ignored - autopilot will prefer to
+            return a mouse variant other than the one requested, rather than fail
+            to return anything at all.
+        :raises: a RuntimeError will be raised if autopilot cannot instantate any of
+            the possible backends.
+
+        """
+        def get_x11_mouse():
+            from autopilot.input._X11 import Mouse
+            return Mouse()
+
+        variants = OrderedDict()
+        variants['X11'] = get_x11_mouse
+        return _pick_variant(variants, preferred_variant)
 
     @property
     def x(self):
@@ -222,3 +246,73 @@
     def cleanup():
         """Put mouse in a known safe state."""
         raise NotImplementedError("You cannot use this class directly.")
+
+
+class Touch(object):
+    """A simple touch driver class.
+
+    This class can be used for any touch events that require a single active
+    touch at once. If you want to do complex gestures (including multi-touch
+    gestures), look at the :py:mod:`autopilot.gestures` module.
+
+    """
+
+    @staticmethod
+    def create(preferred_variant=''):
+        """Get an instance of the :py:class:`Touch` class.
+
+        :param preferred_variant: A string containing a hint as to which variant you
+            would like. However, this hint can be ignored - autopilot will prefer to
+            return a touch variant other than the one requested, rather than fail
+            to return anything at all.
+        :raises: a RuntimeError will be raised if autopilot cannot instantate any of
+            the possible backends.
+
+        """
+        def get_uinput_touch():
+            from autopilot.input._uinput import Touch
+            return Touch()
+
+        variants = OrderedDict()
+        variants['UInput'] = get_uinput_touch
+        return _pick_variant(variants, preferred_variant)
+
+    @property
+    def pressed(self):
+        """Return True if this touch is currently in use (i.e.- pressed on the
+            'screen').
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def tap(self, x, y):
+        """Click (or 'tap') at given x and y coordinates."""
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def tap_object(self, object):
+        """Tap the center point of a given object.
+
+        It does this by looking for several attributes, in order. The first
+        attribute found will be used. The attributes used are (in order):
+
+         * globalRect (x,y,w,h)
+         * center_x, center_y
+         * x, y, w, h
+
+        :raises: **ValueError** if none of these attributes are found, or if an
+         attribute is of an incorrect type.
+
+         """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def press(self, x, y):
+        """Press and hold."""
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def release(self):
+        """Release a previously pressed finger"""
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def drag(self, x1, y1, x2, y2):
+        """Perform a drag gesture from (x1,y1) to (x2,y2)"""
+        raise NotImplementedError("You cannot use this class directly.")

=== added file 'autopilot/input/_common.py'
--- autopilot/input/_common.py	1970-01-01 00:00:00 +0000
+++ autopilot/input/_common.py	2013-04-15 21:43:32 +0000
@@ -0,0 +1,46 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2013 Canonical
+# Author: Thomi Richards
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+"""Common, private utility code for input emulators."""
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def get_center_point(object_proxy):
+    """Get the center point of an object, searching for several different ways
+    of determining exactly where the center is.
+
+    """
+    try:
+        x,y,w,h = object_proxy.globalRect
+        logger.debug("Moving to object's globalRect coordinates.")
+        return x+w/2, y+h/2
+    except AttributeError:
+        pass
+    except (TypeError, ValueError):
+        raise ValueError("Object '%r' has globalRect attribute, but it is not of the correct type" % object_proxy)
+
+    try:
+        x,y = object_proxy.center_x, object_proxy.center_y
+        logger.debug("Moving to object's center_x, center_y coordinates.")
+        return x,y
+    except AttributeError:
+        pass
+    except (TypeError, ValueError):
+        raise ValueError("Object '%r' has center_x, center_y attributes, but they are not of the correct type" % object_proxy)
+
+    try:
+        x,y,w,h = object_proxy.x, object_proxy.y, object_proxy.w, object_proxy.h
+        logger.debug("Moving to object's center point calculated from x,y,w,h attributes.")
+        return x+w/2,y+h/2
+    except AttributeError:
+        raise ValueError("Object '%r' does not have any recognised position attributes" % object_proxy)
+    except (TypeError, ValueError):
+        raise ValueError("Object '%r' has x,y attribute, but they are not of the correct type" % object_proxy)

=== modified file 'autopilot/input/_uinput.py'
--- autopilot/emulators/input/_uinput.py	2013-02-28 01:00:50 +0000
+++ autopilot/input/_uinput.py	2013-04-15 21:43:32 +0000
@@ -9,11 +9,14 @@
 
 """UInput device drivers."""
 
-from autopilot.emulators.input import Keyboard as KeyboardBase
+from autopilot.input import Keyboard as KeyboardBase
+from autopilot.input import Touch as TouchBase
+from autopilot.input._common import get_center_point
+import autopilot.platform
+
 import logging
 from time import sleep
-from evdev import AbsData, InputDevice, UInput, ecodes as e
-import os.path
+from evdev import AbsData, UInput, ecodes as e
 
 logger = logging.getLogger(__name__)
 
@@ -22,6 +25,7 @@
 
 PRESSED_KEYS = []
 
+
 class Keyboard(KeyboardBase):
 
     def __init__(self):
@@ -46,7 +50,7 @@
             raise TypeError("'keys' argument must be a string.")
 
         for key in keys.split('+'):
-            for event in _get_events_for_key(key):
+            for event in Keyboard._get_events_for_key(key):
                 self._emit(event, PRESS)
                 sleep(delay)
 
@@ -69,7 +73,7 @@
         # # release keys in the reverse order they were pressed in.
         # keys = self.__translate_keys(keys)
         for key in reversed(keys.split('+')):
-            for event in _get_events_for_key(key):
+            for event in Keyboard._get_events_for_key(key):
                 self._emit(event, RELEASE)
                 sleep(delay)
 
@@ -118,78 +122,58 @@
         #     fake_input(get_display(), X.KeyRelease, keycode)
         # _PRESSED_KEYS = []
 
+    @staticmethod
+    def _get_events_for_key(key):
+        """Return a list of events required to generate 'key' as an input.
+
+        Multiple keys will be returned when the key specified requires more than one
+        keypress to generate (for example, upper-case letters).
+
+        """
+        events = []
+        if key.isupper():
+            events.append(e.KEY_LEFTSHIFT)
+        keyname = _UINPUT_CODE_TRANSLATIONS.get(key.upper(), key)
+        evt = getattr(e, 'KEY_' + keyname.upper(), None)
+        if evt is None:
+            raise ValueError("Unknown key name: '%s'" % key)
+        events.append(evt)
+        return events
+
+
 last_tracking_id = 0
 def get_next_tracking_id():
     global last_tracking_id
     last_tracking_id += 1
     return last_tracking_id
 
+
 def create_touch_device(res_x=None, res_y=None):
     """Create and return a UInput touch device.
 
-    If res_x and res_y are not specified, they will be queried from X11.
-
-    The following needs to go into /system/usr/idc/autopilot-finger.idc
-
-    # Copyright (C) 2011 The Android Open Source Project
-    #
-    # Licensed under the Apache License, Version 2.0 (the "License");
-    # you may not use this file except in compliance with the License.
-    # You may obtain a copy of the License at
-    #
-    #      http://www.apache.org/licenses/LICENSE-2.0
-    #
-    # Unless required by applicable law or agreed to in writing, software
-    # distributed under the License is distributed on an "AS IS" BASIS,
-    # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    # See the License for the specific language governing permissions and
-    # limitations under the License.
-
-    #
-    # Input Device Calibration File for the Tuna touch screen.
-    #
-
-    device.internal = 1
-
-    # Basic Parameters
-    touch.deviceType = touchScreen
-    touch.orientationAware = 1
-
-    # Size
-    touch.size.calibration = diameter
-    touch.size.scale = 10
-    touch.size.bias = 0
-    touch.size.isSummed = 0
-
-    # Pressure
-    # Driver reports signal strength as pressure.
-    #
-    # A normal thumb touch typically registers about 200 signal strength
-    # units although we don't expect these values to be accurate.
-    touch.pressure.calibration = amplitude
-    touch.pressure.scale = 0.005
-
-    # Orientation
-    touch.orientation.calibration = none
+    If res_x and res_y are not specified, they will be queried from the system.
+
     """
 
-    # FIXME: remove the harcoded values and determine ScreenGeometry without X11
-    res_x = 720
-    res_y = 1280
-
     if res_x is None or res_y is None:
-        from autopilot.emulators.X11 import ScreenGeometry
-        sg = ScreenGeometry()
-        res_x = sg.get_screen_width()
-        res_y = sg.get_screen_height()
+        from autopilot.display import Display
+        display = Display.create()
+        res_x = display.get_screen_width()
+        res_y = display.get_screen_height()
+
+    # android uses BTN_TOOL_FINGER, whereas desktop uses BTN_TOUCH. I have no
+    # idea why...
+    touch_tool = e.BTN_TOOL_FINGER
+    if autopilot.platform.model() == 'Desktop':
+        touch_tool = e.BTN_TOUCH
 
     cap_mt = {
         e.EV_ABS : [
             (e.ABS_X, AbsData(0, res_x, 0, 0)),
             (e.ABS_Y, AbsData(0, res_y, 0, 0)),
             (e.ABS_PRESSURE, AbsData(0, 65535, 0, 0)),
-            (e.ABS_DISTANCE, AbsData(0, 65535, 0, 0)),
-            (e.ABS_TOOL_WIDTH, AbsData(0, 65535, 0, 0)),
+            # (e.ABS_DISTANCE, AbsData(0, 65535, 0, 0)),
+            # (e.ABS_TOOL_WIDTH, AbsData(0, 65535, 0, 0)),
             (e.ABS_MT_POSITION_X, AbsData(0, res_x, 0, 0)),
             (e.ABS_MT_POSITION_Y, AbsData(0, res_y, 0, 0)),
             (e.ABS_MT_TOUCH_MAJOR, AbsData(0, 30, 0, 0)),
@@ -198,147 +182,122 @@
             (e.ABS_MT_SLOT, (0, 9, 0, 0)),
         ],
         e.EV_KEY: [
-            e.BTN_TOOL_FINGER,
+            touch_tool,
         ]
     }
 
-    try:
-        device = UInput(cap_mt, name='autopilot-finger', version=0x2)
-        return device
-    except:
-        logger.warning("Failed to open uinput device. Finger will not be available")
-        return None
-
-
-def find_touch_device():
-    """Return a list of touch devices found on the local machine.
-
-    :returns: A list of evdev.inputDevice objects, possibly an empty list.
-
-    """
-    def device_cmp(dev_a, dev_b):
-        def get_track_slot(dev):
-            capabilities = dev.capabilities()
-            for track_feature in capabilities[e.EV_ABS]:
-                if track_feature[0] == e.ABS_MT_SLOT:
-                    return track_feature[1][1]
-        return get_track_slot(dev_a) < get_track_slot(dev_b)
-
-    i = 0
-    touch_devices = []
-    while True:
-        path = '/dev/input/event%d' % (i)
-        if not os.path.exists(path):
-            break
-
-        dev = InputDevice(path)
-        capabilities = dev.capabilities()
-        if e.EV_ABS in capabilities:
-            touch_devices.append(dev)
-        i += 1
-    touch_devices.sort(device_cmp)
-    return touch_devices
-
-
-"""
-Multiouch notes:
-----------------
-
-We're simulating a class of device that can track multiple touches, and keep
-them separate. This is how most modern track devices work anyway. The device
-is created with a capability to track a certain number of distinct touches at
-once. This is the ABS_MT_SLOT capability. Since our target device can track 9
-separate touches, we'll do the same.
-
-Each finger contact starts by registering a slot number (0-8) with a tracking
-Id. The Id should be unique for this touch - this can be an auto-inctrementing
-integer. The very first packets to tell the kernel that we have a touch happening
-should look like this:
-
-   ABS_MT_SLOT 0
-   ABS_MT_TRACKING_ID 45
-   ABS_MT_POSITION_X x[0]
-   ABS_MT_POSITION_Y y[0]
-
-This associates Tracking id 45 (could be any number) with slot 0. Slot 0 can now
-not be use by any other touch until it is released.
-
-If we want to move this contact's coordinates, we do this:
-
-   ABS_MT_SLOT 0
-   ABS_MT_POSITION_X 123
-   ABS_MT_POSITION_Y 234
-
-Technically, the 'SLOT 0' part isn't needed, since we're already in slot 0, but
-it doesn't hurt to have it there.
-
-To lift the contact, we simply specify a tracking Id of -1:
-
-   ABS_MT_SLOT 0
-   ABS_MT_TRACKING_ID -1
-
-The initial association between slot and tracking Id is made when the 'finger'
-first makes contact with the device (well, not technically true, but close
-enough). Multiple touches can be active simultaniously, as long as they all have
-unique slots, and tracking Ids. The simplest way to think about this is that the
-SLOT refers to a finger number, and the TRACKING_ID identifies a unique touch
-for the duration of it's existance.
-
-"""
-
-class Finger(object):
+    return UInput(cap_mt, name='autopilot-finger', version=0x2)
+
+_touch_device = create_touch_device()
+
+# Multiouch notes:
+# ----------------
+
+# We're simulating a class of device that can track multiple touches, and keep
+# them separate. This is how most modern track devices work anyway. The device
+# is created with a capability to track a certain number of distinct touches at
+# once. This is the ABS_MT_SLOT capability. Since our target device can track 9
+# separate touches, we'll do the same.
+
+# Each finger contact starts by registering a slot number (0-8) with a tracking
+# Id. The Id should be unique for this touch - this can be an auto-inctrementing
+# integer. The very first packets to tell the kernel that we have a touch happening
+# should look like this:
+
+#    ABS_MT_SLOT 0
+#    ABS_MT_TRACKING_ID 45
+#    ABS_MT_POSITION_X x[0]
+#    ABS_MT_POSITION_Y y[0]
+
+# This associates Tracking id 45 (could be any number) with slot 0. Slot 0 can now
+# not be use by any other touch until it is released.
+
+# If we want to move this contact's coordinates, we do this:
+
+#    ABS_MT_SLOT 0
+#    ABS_MT_POSITION_X 123
+#    ABS_MT_POSITION_Y 234
+
+# Technically, the 'SLOT 0' part isn't needed, since we're already in slot 0, but
+# it doesn't hurt to have it there.
+
+# To lift the contact, we simply specify a tracking Id of -1:
+
+#    ABS_MT_SLOT 0
+#    ABS_MT_TRACKING_ID -1
+
+# The initial association between slot and tracking Id is made when the 'finger'
+# first makes contact with the device (well, not technically true, but close
+# enough). Multiple touches can be active simultaniously, as long as they all have
+# unique slots, and tracking Ids. The simplest way to think about this is that the
+# SLOT refers to a finger number, and the TRACKING_ID identifies a unique touch
+# for the duration of it's existance.
+
+_touch_fingers_in_use = []
+def _get_touch_finger():
+    """Claim a touch finger id for use.
+
+    :raises: RuntimeError if no more fingers are available.
+
+    """
+    global _touch_fingers_in_use
+
+    for i in range(9):
+        if i not in _touch_fingers_in_use:
+            _touch_fingers_in_use.append(i)
+            return i
+    raise RuntimeError("All available fingers have been used already.")
+
+def _release_touch_finger(finger_num):
+    """Relase a previously-claimed finger id.
+
+    :raises: RuntimeError if the finger given was never claimed, or was already
+    released.
+
+    """
+    global _touch_fingers_in_use
+
+    if finger_num not in _touch_fingers_in_use:
+        raise RuntimeError("Finger %d was never claimed, or has already been released." % (finger_num))
+    _touch_fingers_in_use.remove(finger_num)
+    assert(finger_num not in _touch_fingers_in_use)
+
+
+class Touch(TouchBase):
     """Low level interface to generate single finger touch events."""
 
     def __init__(self):
-        self.device = create_touch_device()
-        if self.device == None:
-            raise UInputError
-        self.current_x = 0
-        self.current_y = 0
-
-    def move(self, x, y):
-        """This is a convenience function to keep API compatibility with other pointer input methods"""
-        self.current_x = x
-        self.current_y = y
-
-    def move_to_object(self, object):
-        """This is a convenience function to keep API compatibility with other pointer input methods"""
-        self.current_x = object.globalRect[0] + object.globalRect[2] / 2
-        self.current_y = object.globalRect[1] + object.globalRect[3] / 2
-
-    def click(self):
-        self.tap(self.current_x, self.current_y)
+        super(TouchBase, self).__init__()
+        self._touch_finger = None
+
+    @property
+    def pressed(self):
+        return self._touch_finger is not None
 
     def tap(self, x, y):
         """Click (or 'tap') at given x and y coordinates."""
-        self._finger_down(0, x, y)
+        self._finger_down(x, y)
         sleep(0.1)
-        self._finger_up(0)
+        self._finger_up()
 
     def tap_object(self, object):
         """Click (or 'tap') a given object"""
-        self.tap(object.globalRect[0] + object.globalRect[2] / 2, object.globalRect[1] + object.globalRect[3] / 2)
+        x,y = get_center_point(object)
+        self.tap(x,y)
 
-    def press(self, *args):
+    def press(self, x, y):
         """Press and hold a given object or at the given coordinates
         Call release() when the object has been pressed long enough"""
-        if len(args) == 2:
-            self.current_x = args[0]
-            self.current_y = args[1]
-        elif len(args) == 0:
-            pass
-        else:
-            raise InvalidArgCount
-        self._finger_down(0, self.current_x, self.current_y)
+        self._finger_down(x, y)
 
     def release(self):
         """Release a previously pressed finger"""
-        self._finger_up(0)
+        self._finger_up()
 
 
     def drag(self, x1, y1, x2, y2):
         """Perform a drag gesture from (x1,y1) to (x2,y2)"""
-        self._finger_down(0, x1, y1)
+        self._finger_down(x1, y1)
 
         # Let's drag in 100 steps for now...
         dx = 1.0 * (x2 - x1) / 100
@@ -346,92 +305,49 @@
         cur_x = x1 + dx
         cur_y = y1 + dy
         for i in range(0, 100):
-            self._finger_move(0, int(cur_x), int(cur_y))
+            self._finger_move(int(cur_x), int(cur_y))
             sleep(0.002)
             cur_x += dx
             cur_y += dy
         # Make sure we actually end up at target
-        self._finger_move(0, x2, y2)
-        self._finger_up(0)
-
-    def pinch(self, center, distance_start, distance_end):
-        """Perform a two finger pinch (zoom) gesture
-        "center" gives the coordinates [x,y] of the center between the two fingers
-        "distance_start" [x,y] values to move away from the center for the start
-        "distance_end" [x,y] values to move away from the center for the end
-        The fingers will move in 100 steps between the start and the end points.
-        If start is smaller than end, the gesture will zoom in, otherwise it
-        will zoom out."""
-
-        finger_1_start = [center[0] - distance_start[0], center[1] - distance_start[1]]
-        finger_2_start = [center[0] + distance_start[0], center[1] + distance_start[1]]
-        finger_1_end = [center[0] - distance_end[0], center[1] - distance_end[1]]
-        finger_2_end = [center[0] + distance_end[0], center[1] + distance_end[1]]
-
-        dx = 1.0 * (finger_1_end[0] - finger_1_start[0]) / 100
-        dy = 1.0 * (finger_1_end[1] - finger_1_start[1]) / 100
-
-        self._finger_down(0, finger_1_start[0], finger_1_start[1])
-        self._finger_down(1, finger_2_start[0], finger_2_start[1])
-
-        finger_1_cur = [finger_1_start[0] + dx, finger_1_start[1] + dy]
-        finger_2_cur = [finger_2_start[0] - dx, finger_2_start[1] - dy]
-
-        for i in range(0, 100):
-            self._finger_move(0, finger_1_cur[0], finger_1_cur[1])
-            self._finger_move(1, finger_2_cur[0], finger_2_cur[1])
-            sleep(0.005)
-
-            finger_1_cur = [finger_1_cur[0] + dx, finger_1_cur[1] + dy]
-            finger_2_cur = [finger_2_cur[0] - dx, finger_2_cur[1] - dy]
-
-        self._finger_move(0, finger_1_end[0], finger_1_end[1])
-        self._finger_move(1, finger_2_end[0], finger_2_end[1])
-        self._finger_up(0)
-        self._finger_up(1)
-
-    def _finger_down(self, finger, x, y):
+        self._finger_move(x2, y2)
+        self._finger_up()
+
+
+
+    def _finger_down(self, x, y):
         """Internal: moves finger "finger" down to the touchscreen at pos (x,y)"""
-        self.device.write(e.EV_ABS, e.ABS_MT_SLOT, finger)
-        self.device.write(e.EV_ABS, e.ABS_MT_TRACKING_ID, get_next_tracking_id())
-        self.device.write(e.EV_KEY, e.BTN_TOOL_FINGER, 1)
-        self.device.write(e.EV_ABS, e.ABS_MT_POSITION_X, x)
-        self.device.write(e.EV_ABS, e.ABS_MT_POSITION_Y, y)
-        self.device.write(e.EV_ABS, e.ABS_MT_PRESSURE, 400)
-        self.device.syn()
-
-
-    def _finger_move(self, finger, x, y):
+        if self._touch_finger is not None:
+            raise RuntimeError("Cannot press finger: it's already pressed.")
+        self._touch_finger = _get_touch_finger()
+
+        _touch_device.write(e.EV_ABS, e.ABS_MT_SLOT, self._touch_finger)
+        _touch_device.write(e.EV_ABS, e.ABS_MT_TRACKING_ID, get_next_tracking_id())
+        _touch_device.write(e.EV_KEY, e.BTN_TOOL_FINGER, 1)
+        _touch_device.write(e.EV_ABS, e.ABS_MT_POSITION_X, int(x))
+        _touch_device.write(e.EV_ABS, e.ABS_MT_POSITION_Y, int(y))
+        _touch_device.write(e.EV_ABS, e.ABS_MT_PRESSURE, 400)
+        _touch_device.syn()
+
+
+    def _finger_move(self, x, y):
         """Internal: moves finger "finger" on the touchscreen to pos (x,y)
            NOTE: The finger has to be down for this to have any effect."""
-        self.device.write(e.EV_ABS, e.ABS_MT_SLOT, finger)
-        self.device.write(e.EV_ABS, e.ABS_MT_POSITION_X, int(x))
-        self.device.write(e.EV_ABS, e.ABS_MT_POSITION_Y, int(y))
-        self.device.syn()
-
-
-    def _finger_up(self, finger):
+        if self._touch_finger is not None:
+            _touch_device.write(e.EV_ABS, e.ABS_MT_SLOT, self._touch_finger)
+            _touch_device.write(e.EV_ABS, e.ABS_MT_POSITION_X, int(x))
+            _touch_device.write(e.EV_ABS, e.ABS_MT_POSITION_Y, int(y))
+            _touch_device.syn()
+
+
+    def _finger_up(self):
         """Internal: moves finger "finger" up from the touchscreen"""
-        self.device.write(e.EV_ABS, e.ABS_MT_SLOT, finger)
-        self.device.write(e.EV_ABS, e.ABS_MT_TRACKING_ID, -1)
-        self.device.write(e.EV_KEY, e.BTN_TOOL_FINGER, 0)
-        self.device.syn()
-
-
-class MultiTouch(object):
-    """High level interface to generate multi-touch events."""
-
-    # Need to work out a good interface for generating multitouch events...
-    # Possibly get users to specify each individual finger tracking path, or
-    # possibly specify a gesture by name, with parameters or so?
-    #
-    # Probably need to specify X & Y resolution as well. Think we can ignore
-    # pressure right now.
-    #
-    # Multi-touch protocol documentation is here:
-    #
-    # http://www.kernel.org/doc/Documentation/input/multi-touch-protocol.txt
-
+        if self._touch_finger is None:
+            raise RuntimeError("Cannot release finger: it's not pressed.")
+        _touch_device.write(e.EV_ABS, e.ABS_MT_SLOT, self._touch_finger)
+        _touch_device.write(e.EV_ABS, e.ABS_MT_TRACKING_ID, -1)
+        _touch_device.write(e.EV_KEY, e.BTN_TOOL_FINGER, 0)
+        _touch_device.syn()
 
 
 _UINPUT_CODE_TRANSLATIONS = {
@@ -441,23 +357,3 @@
     'ALT': 'LEFTALT',
     'SHIFT': 'LEFTSHIFT',
 }
-
-
-def _get_events_for_key(key):
-    """Return a list of events required to generate 'key' as an input.
-
-    Multiple keys will be returned when the key specified requires more than one
-    keypress to generate (for example, upper-case letters).
-
-    """
-    events = []
-    if key.isupper():
-        events.append(e.KEY_LEFTSHIFT)
-    keyname = _UINPUT_CODE_TRANSLATIONS.get(key.upper(), key)
-    evt = getattr(e, 'KEY_' + keyname.upper(), None)
-    if evt is None:
-        raise ValueError("Unknown key name: '%s'" % key)
-    events.append(evt)
-    return events
-
-

=== modified file 'autopilot/introspection/__init__.py'
--- autopilot/introspection/__init__.py	2013-02-22 03:31:40 +0000
+++ autopilot/introspection/__init__.py	2013-04-15 21:43:32 +0000
@@ -7,16 +7,18 @@
 # by the Free Software Foundation.
 #
 
-"""Package for introspection support."""
+"""Package for introspection support.
+
+This package contains the internal implementation of the autopilot introspection
+mechanism, and probably isn't useful to most test authors.
+
+"""
 
 import dbus
-from gi.repository import Gio
 import logging
 import subprocess
-from testtools.content import text_content
 from time import sleep
 import os
-import signal
 
 
 from autopilot.introspection.constants import (
@@ -31,62 +33,65 @@
     object_passes_filters,
     get_session_bus,
     )
-from autopilot.utilities import get_debug_logger
+from autopilot.utilities import get_debug_logger, addCleanup
 
 
 logger = logging.getLogger(__name__)
 
 
-class ApplicationIntrospectionTestMixin(object):
-    """A mix-in class to make launching applications for introsection easier.
-
-    .. important:: You should not instantiate this class directly. Instead, use
-     one of the derived classes.
-
-    """
-
-    def launch_test_application(self, application, *arguments, **kwargs):
-        """Launch *application* and retrieve a proxy object for the application.
-
-        Use this method to launch a supported application and start testing it.
-        The application can be specified as:
-
-         * A Desktop file, either with or without a path component.
-         * An executable file, either with a path, or one that is in the $PATH.
-
-        This method supports the following keyword arguments:
-
-         * *launch_dir*. If set to a directory that exists the process will be
-           launched from that directory.
-
-         * *capture_output*. If set to True (the default), the process output
-           will be captured and attached to the test as test detail.
-
-        :raises: **ValueError** if unknown keyword arguments are passed.
-        :return: A proxy object that represents the application. Introspection
-         data is retrievable via this object.
-
-         """
-        if not isinstance(application, basestring):
-            raise TypeError("'application' parameter must be a string.")
-        cwd = kwargs.pop('launch_dir', None)
-        capture_output = kwargs.pop('capture_output', True)
-        if kwargs:
-            raise ValueError("Unknown keyword arguments: %s." %
-                (', '.join( repr(k) for k in kwargs.keys())))
-
-        if application.endswith('.desktop'):
-            proc = Gio.DesktopAppInfo.new(application)
-            application = proc.get_executable()
-
-        path, args = self.prepare_environment(application, list(arguments))
-
-        process = launch_autopilot_enabled_process(path,
-                                                    args,
-                                                    capture_output,
-                                                    cwd=cwd)
-        self.addCleanup(self._kill_process_and_attach_logs, process)
-        return get_autopilot_proxy_object_for_process(process)
+def get_application_launcher(app_path):
+    """Return an instance of :class:`ApplicationLauncher` that knows how to launch
+    the application at 'app_path'.
+    """
+    # TODO: this is a teeny bit hacky - we call ldd to check whether this application
+    # links to certain library. We're assuming that linking to libQt* or libGtk*
+    # means the application is introspectable. This excludes 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()
+    except subprocess.CalledProcessError:
+        print "Error: Cannot auto-detect introspection plugin to load."
+        print "Use the '-i' argument to specify an interface."
+        exit(1) # TODO - don't exit, raise an exception, and handle it appropriately in parent code.
+    if 'libqtcore' in ldd_output:
+        from autopilot.introspection.qt import QtApplicationLauncher
+        return QtApplicationLauncher()
+    elif 'libgtk' in ldd_output:
+        from autopilot.introspection.gtk import GtkApplicationLauncher
+        return GtkApplicationLauncher()
+    return None
+
+
+def launch_application(launcher, application, *arguments, **kwargs):
+    """Launch an application, and return a process object.
+
+    :param launcher: An instance of the :class:`ApplicationLauncher` class to
+        prepare the environment before launching the application itself.
+    """
+
+    if not isinstance(application, basestring):
+        raise TypeError("'application' parameter must be a string.")
+    cwd = kwargs.pop('launch_dir', None)
+    capture_output = kwargs.pop('capture_output', True)
+    if kwargs:
+        raise ValueError("Unknown keyword arguments: %s." %
+            (', '.join( repr(k) for k in kwargs.keys())))
+
+    path, args = launcher.prepare_environment(application, list(arguments))
+
+    process = launch_process(path,
+        args,
+        capture_output,
+        cwd=cwd
+        )
+    return process
+
+
+class ApplicationLauncher(object):
+    """A class that knows how to launch an application with a certain type of
+    introspection enabled.
+
+    """
 
     def prepare_environment(self, app_path, arguments):
         """Prepare the application, or environment to launch with autopilot-support.
@@ -99,22 +104,9 @@
         """
         raise NotImplementedError("Sub-classes must implement this method.")
 
-    def _kill_process_and_attach_logs(self, process):
-        process.kill()
-        logger.info("waiting for process to exit.")
-        for i in range(10):
-            if process.returncode is not None:
-                break
-            if i == 9:
-                logger.info("Terminating process group, since it hasn't exited after 10 seconds.")
-                os.killpg(process.pid, signal.SIGTERM)
-            sleep(1)
-        stdout, stderr = process.communicate()
-        self.addDetail('process-stdout', text_content(stdout))
-        self.addDetail('process-stderr', text_content(stderr))
-
-
-def launch_autopilot_enabled_process(application, args, capture_output, **kwargs):
+
+
+def launch_process(application, args, capture_output, **kwargs):
     """Launch an autopilot-enabled process and return the proxy object."""
     commandline = [application]
     commandline.extend(args)
@@ -132,28 +124,6 @@
     return process
 
 
-def get_child_pids(pid):
-    """Get a list of all child process Ids, for the given parent.
-
-    """
-    def get_children(pid):
-        command = ['ps', '-o', 'pid', '--ppid', str(pid), '--noheaders']
-        try:
-            raw_output = subprocess.check_output(command)
-        except subprocess.CalledProcessError:
-            return []
-        return [int(p) for p in raw_output.split()]
-
-    result = [pid]
-    data = get_children(pid)
-    while data:
-        pid = data.pop(0)
-        result.append(pid)
-        data.extend(get_children(pid))
-
-    return result
-
-
 def get_autopilot_proxy_object_for_process(process):
     """Return the autopilot proxy object for the given *process*.
 
@@ -199,6 +169,28 @@
     raise RuntimeError("Unable to find Autopilot interface.")
 
 
+def get_child_pids(pid):
+    """Get a list of all child process Ids, for the given parent.
+
+    """
+    def get_children(pid):
+        command = ['ps', '-o', 'pid', '--ppid', str(pid), '--noheaders']
+        try:
+            raw_output = subprocess.check_output(command)
+        except subprocess.CalledProcessError:
+            return []
+        return [int(p) for p in raw_output.split()]
+
+    result = [pid]
+    data = get_children(pid)
+    while data:
+        pid = data.pop(0)
+        result.append(pid)
+        data.extend(get_children(pid))
+
+    return result
+
+
 def make_proxy_object_from_service_name(service_name, obj_path):
     """Returns a root proxy object given a DBus service name."""
     # parameters can sometimes be dbus.String instances, sometimes QString instances.

=== modified file 'autopilot/introspection/dbus.py'
--- autopilot/introspection/dbus.py	2013-02-20 04:00:40 +0000
+++ autopilot/introspection/dbus.py	2013-04-15 21:43:32 +0000
@@ -23,7 +23,7 @@
 from time import sleep
 from textwrap import dedent
 
-from autopilot.emulators.dbus_handler import get_session_bus
+from autopilot.dbus_handler import get_session_bus
 from autopilot.introspection.constants import AP_INTROSPECTION_IFACE
 from autopilot.utilities import Timer
 

=== modified file 'autopilot/introspection/gtk.py'
--- autopilot/introspection/gtk.py	2013-01-25 01:47:48 +0000
+++ autopilot/introspection/gtk.py	2013-04-15 21:43:32 +0000
@@ -8,10 +8,10 @@
 
 import os
 
-from autopilot.introspection import ApplicationIntrospectionTestMixin
-
-
-class GtkIntrospectionTestMixin(ApplicationIntrospectionTestMixin):
+from autopilot.introspection import ApplicationLauncher
+
+
+class GtkApplicationLauncher(ApplicationLauncher):
     """A mix-in class to make Gtk application introspection easier."""
 
     def prepare_environment(self, app_path, arguments):

=== modified file 'autopilot/introspection/qt.py'
--- autopilot/introspection/qt.py	2013-03-14 21:37:17 +0000
+++ autopilot/introspection/qt.py	2013-04-15 21:43:32 +0000
@@ -10,14 +10,14 @@
 """Classes and tools to support Qt introspection."""
 
 
-__all__ = ['QtIntrospectionTestMixin']
+__all__ = ['QtApplicationLauncher']
 
 import dbus
 import functools
 
 import logging
 
-from autopilot.introspection import ApplicationIntrospectionTestMixin
+from autopilot.introspection import ApplicationLauncher
 from autopilot.introspection.constants import QT_AUTOPILOT_IFACE
 from autopilot.introspection.dbus import get_session_bus
 
@@ -25,7 +25,7 @@
 logger = logging.getLogger(__name__)
 
 
-class QtIntrospectionTestMixin(ApplicationIntrospectionTestMixin):
+class QtApplicationLauncher(ApplicationLauncher):
     """A mix-in class to make Qt application introspection easier.
 
     Inherit from this class if you want to launch and test Qt application with

=== modified file 'autopilot/keybindings.py'
--- autopilot/keybindings.py	2013-02-28 00:26:07 +0000
+++ autopilot/keybindings.py	2013-04-15 21:43:32 +0000
@@ -27,8 +27,8 @@
 from types import NoneType
 import re
 
-from autopilot.emulators.input import get_keyboard
-from autopilot.compizconfig import get_plugin, get_setting
+from autopilot.input import Keyboard
+from autopilot.utilities import Silence
 
 logger = logging.getLogger(__name__)
 
@@ -184,8 +184,8 @@
 
     """
     plugin_name, setting_name = compiz_tuple
-    plugin = get_plugin(plugin_name)
-    setting = get_setting(plugin_name, setting_name)
+    plugin = _get_compiz_plugin(plugin_name)
+    setting = _get_compiz_setting(plugin_name, setting_name)
     if setting.Type != 'Key':
         raise ValueError("Key binding maps to a compiz option that does not hold a keybinding.")
     if not plugin.Enabled:
@@ -232,7 +232,7 @@
 
     @property
     def _keyboard(self):
-        return get_keyboard()
+        return Keyboard.create()
 
     def keybinding(self, binding_name, delay=None):
         """Press and release the keybinding with the given name.
@@ -263,3 +263,48 @@
     def keybinding_hold_part_then_tap(self, binding_name):
         self.keybinding_hold(binding_name)
         self.keybinding_tap(binding_name)
+
+
+# Functions that wrap compizconfig to avoid some unpleasantness in that module.
+# Local to the this keybindings for now until their removal in the very near
+# future.
+_global_compiz_context = None
+
+def _get_global_compiz_context():
+    """Get the compizconfig global context object."""
+    global _global_compiz_context
+    if _global_compiz_context is None:
+        with Silence():
+            from compizconfig import Context
+            _global_compiz_context = Context()
+    return _global_compiz_context
+
+
+def _get_compiz_plugin(plugin_name):
+    """Get a compizconfig plugin with the specified name.
+
+    Raises KeyError of the plugin named does not exist.
+
+    """
+    ctx = _get_global_compiz_context()
+    with Silence():
+        try:
+            return ctx.Plugins[plugin_name]
+        except KeyError:
+            raise KeyError("Compiz plugin '%s' does not exist." % (plugin_name))
+
+
+def _get_compiz_setting(plugin_name, setting_name):
+    """Get a compizconfig setting object, given a plugin name and setting name.
+
+    Raises KeyError if the plugin or setting is not found.
+
+    """
+    plugin = _get_compiz_plugin(plugin_name)
+    with Silence():
+        try:
+            return plugin.Screen[setting_name]
+        except KeyError:
+            raise KeyError("Compiz setting '%s' does not exist in plugin '%s'." % (setting_name, plugin_name))
+
+

=== modified file 'autopilot/matchers/__init__.py'
--- autopilot/matchers/__init__.py	2012-12-05 02:15:45 +0000
+++ autopilot/matchers/__init__.py	2013-04-15 21:43:32 +0000
@@ -18,9 +18,54 @@
 class Eventually(Matcher):
     """Asserts that a value will eventually equal a given Matcher object.
 
-    This works on objects that *either* have a :meth:`wait_for(expected)`
-    function, *or* objects that are callable and return the most current value
-    (i.e.- they refresh the objects value).
+    This matcher wraps another testtools matcher object. It makes that other
+    matcher work with a timeout. This is necessary for several reasons:
+
+    1. Since most actions in a GUI applicaton take some time to complete, the
+       test may need to wait for the application to enter the expected state.
+
+    2. Since the test is running in a separate process to the application under
+       test, test authors cannot make any assumptions about when the application
+       under test will recieve CPU time to update to the expected state.
+
+    There are two main ways of using the Eventually matcher:
+
+    **Attributes from the application**::
+
+        self.assertThat(window.maximized, Eventually(Equals(True)))
+
+    Here, ``window`` is an object generated by autopilot from the applications
+    state. This pattern of usage will cover 90% (or more) of the assertions in
+    an autopilot test. Note that any matcher can be used - either from testtools
+    or any custom matcher that implements the matcher API::
+
+        self.assertThat(window.height, Eventually(GreaterThan(200)))
+
+    **Callable Objects**::
+
+        self.assertThat(autopilot.platform.model, Eventually(Equals("Galaxy Nexus")))
+
+    In this example we're using the :func:`autopilot.platform.model` function as
+    a callable. In this form, Eventually matches against the return value of the
+    callable.
+
+    This can also be used to use a regular python property inside an Eventually
+    matcher::
+
+        self.assertThat(lambda: self.mouse.x, Eventually(LessThan(10)))
+
+    .. note:: Using this form generally makes your tests less readabvle, and
+        should be used with great care. It also relies the test author to have
+        knowledge about the implementation of the object being matched against.
+        In this example, if ``self.mouse.x`` were ever to change to be a regular
+        python attribute, this test would likely break.
+
+    **Timeout**
+
+    By default timeout period is ten seconds. This can be altered by passing the
+    timeout keyword::
+
+        self.assertThat(foo.bar, Eventually(Equals(123), timeout=30))
 
     """
 

=== added file 'autopilot/platform.py'
--- autopilot/platform.py	1970-01-01 00:00:00 +0000
+++ autopilot/platform.py	2013-04-15 21:43:32 +0000
@@ -0,0 +1,105 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2013 Canonical
+# Author: Thomi Richards
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+"""
+Platform identification utilities for Autopilot.
+================================================
+
+This module provides functions that give test authors hints as to which platform
+their tests are currently running on. This is useful when tests should only run
+on certain platforms.
+
+"""
+
+from os.path import exists
+
+
+def model():
+    """Get the model name of the current platform.
+
+    For desktop / laptop installations, this will return "Desktop".
+    Otherwise, the current hardware model will be returned. For example:
+
+    >>> autopilot.platform.model()
+    ... "Galaxy Nexus"
+
+    """
+    return _PlatformDetector.create().model
+
+
+def image_codename():
+    """Get the image codename.
+
+    For desktop / laptop installations this will return "Desktop".
+    Otherwise, the codename of the image that was installed will be
+    returned. For example:
+
+    >>> autopilot.platform.image_codename()
+    ... "maguro"
+
+    """
+    return _PlatformDetector.create().image_codename
+
+
+class _PlatformDetector(object):
+
+    _cached_detector = None
+
+    @staticmethod
+    def create():
+        """Create a platform detector object, or return one we baked earlier."""
+        if _PlatformDetector._cached_detector is None:
+            _PlatformDetector._cached_detector = _PlatformDetector()
+        return _PlatformDetector._cached_detector
+
+    def __init__(self):
+        self.model = "Desktop"
+        self.image_codename = "Desktop"
+
+        property_file = _get_property_file()
+        if property_file is not None:
+            self.update_values_from_build_file(property_file)
+
+    def update_values_from_build_file(self, property_file):
+        """Read build.prop file and parse it."""
+        properties = _parse_build_properties_file(property_file)
+        self.model = properties.get('ro.product.model', "Desktop")
+        self.image_codename = properties.get('ro.product.name', "Desktop")
+
+
+def _get_property_file():
+    """Return a file-like object that contains the contents of the build properties
+    file, if it exists, or None.
+
+    """
+    if exists('/system/build.prop'):
+        return open('/system/build.prop')
+    return None
+
+
+def _parse_build_properties_file(property_file):
+    """Parse 'property_file', which must be a file-like object containing the
+    system build properties.
+
+    Returns a dictionary of key,value pairs.
+
+    """
+    properties = {}
+    for line in property_file:
+        line = line.strip()
+        if not line or line.startswith('#') or line.isspace():
+            continue
+        split_location = line.find('=')
+        if split_location == -1:
+            continue
+        key = line[:split_location]
+        value = line[split_location + 1:]
+
+        properties[key] = value
+    return properties
+

=== added directory 'autopilot/process'
=== added file 'autopilot/process/__init__.py'
--- autopilot/process/__init__.py	1970-01-01 00:00:00 +0000
+++ autopilot/process/__init__.py	2013-04-15 21:43:32 +0000
@@ -0,0 +1,403 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2013 Canonical
+# Author: Christopher Lee
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+from collections import OrderedDict
+
+from autopilot.utilities import _pick_variant
+
+
+class ProcessManager(object):
+
+    """A simple process manager class.
+
+    The process manager is used to handle processes, windows and applications.
+    This class should not be instantiated directly however. To get an instance
+    of the keyboard class, call :py:meth:`create` instead.
+
+    """
+
+    KNOWN_APPS = {
+        'Character Map' : {
+            'desktop-file': 'gucharmap.desktop',
+            'process-name': 'gucharmap',
+            },
+        'Calculator' : {
+            'desktop-file': 'gcalctool.desktop',
+            'process-name': 'gnome-calculator',
+            },
+        'Mahjongg' : {
+            'desktop-file': 'mahjongg.desktop',
+            'process-name': 'gnome-mahjongg',
+            },
+        'Remmina' : {
+            'desktop-file': 'remmina.desktop',
+            'process-name': 'remmina',
+            },
+        'System Settings' : {
+            'desktop-file': 'gnome-control-center.desktop',
+            'process-name': 'gnome-control-center',
+            },
+        'Text Editor' : {
+            'desktop-file': 'gedit.desktop',
+            'process-name': 'gedit',
+            },
+        'Terminal' : {
+            'desktop-file': 'gnome-terminal.desktop',
+            'process-name': 'gnome-terminal',
+            },
+        }
+
+
+    @staticmethod
+    def create(preferred_variant=""):
+        """Get an instance of the :py:class:`ProcessManager` class.
+
+        :param preferred_variant: A string containing a hint as to which variant you
+            would like. However, this hint can be ignored - autopilot will prefer to
+            return a keyboard variant other than the one requested, rather than fail
+            to return anything at all.
+        :raises: a RuntimeError will be raised if autopilot cannot instantate any of
+            the possible backends.
+        """
+        def get_bamf_pm():
+            from autopilot.process._bamf import ProcessManager
+            return ProcessManager()
+
+        def get_upa_pm():
+            from autopilot.process._upa import ProcessManager
+            return ProcessManager()
+
+        variants = OrderedDict()
+        variants['BAMF'] = get_bamf_pm
+        return _pick_variant(variants, preferred_variant)
+
+    @classmethod
+    def register_known_application(cls, name, desktop_file, process_name):
+        """Register an application with autopilot.
+
+        After calling this method, you may call :meth:`start_app` or
+        :meth:`start_app_window` with the `name` parameter to start this
+        application.
+        You need only call this once within a test run - the application will
+        remain registerred until the test run ends.
+
+        :param name: The name to be used when launching the application.
+        :param desktop_file: The filename (without path component) of the desktop file used to launch the application.
+        :param process_name: The name of the executable process that gets run.
+        :raises: **KeyError** if application has been registered already
+
+        """
+        if name in cls.KNOWN_APPS:
+            raise KeyError("Application has been registered already")
+        else:
+            cls.KNOWN_APPS[name] = {
+                                     "desktop-file" : desktop_file,
+                                     "process-name" : process_name
+                                   }
+
+    @classmethod
+    def unregister_known_application(cls, name):
+        """Unregister an application with the known_apps dictionary.
+
+        :param name: The name to be used when launching the application.
+        :raises: **KeyError** if the application has not been registered.
+
+        """
+        if name in cls.KNOWN_APPS:
+            del cls.KNOWN_APPS[name]
+        else:
+            raise KeyError("Application has not been registered")
+
+    def start_app(self, app_name, files=[], locale=None):
+        """Start one of the known applications, and kill it on tear down.
+
+        .. warning:: This method will clear all instances of this application on
+         tearDown, not just the one opened by this method! We recommend that
+         you use the :meth:`start_app_window` method instead, as it is generally
+         safer.
+
+        :param app_name: The application name. *This name must either already
+         be registered as one of the built-in applications that are supported
+         by autopilot, or must have been registered using*
+         :meth:`register_known_application` *beforehand.*
+        :param files: (Optional) A list of paths to open with the
+         given application. *Not all applications support opening files in this
+         way.*
+        :param locale: (Optional) The locale will to set when the application
+         is launched. *If you want to launch an application without any
+         localisation being applied, set this parameter to 'C'.*
+        :returns: A :class:`~autopilot.process.Application` instance.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def start_app_window(self, app_name, files=[], locale=None):
+        """Open a single window for one of the known applications, and close it
+        at the end of the test.
+
+        :param app_name: The application name. *This name must either already
+         be registered as one of the built-in applications that are supported
+         by autopilot, or must have been registered with*
+         :meth:`register_known_application` *beforehand.*
+        :param files: (Optional) Should be a list of paths to open with the
+         given application. *Not all applications support opening files in this
+         way.*
+        :param locale: (Optional) The locale will to set when the application
+         is launched. *If you want to launch an application without any
+         localisation being applied, set this parameter to 'C'.*
+        :raises: **AssertionError** if no window was opened, or more than one
+         window was opened.
+        :returns: A :class:`~autopilot.process.Window` instance.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def get_open_windows_by_application(self, app_name):
+        """Get a list of ~autopilot.process.Window` instances
+        for the given application name.
+
+        :param app_name: The name of one of the well-known applications.
+        :returns: A list of :class:`~autopilot.process.Window`
+         instances.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def close_all_app(self, app_name):
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def get_app_instances(self, app_name):
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def app_is_running(self, app_name):
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def get_running_applications(self, user_visible_only=True):
+        """Get a list of the currently running applications.
+
+        If user_visible_only is True (the default), only applications
+        visible to the user in the switcher will be returned.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def get_running_applications_by_desktop_file(self, desktop_file):
+        """Return a list of applications that have the desktop file *desktop_file*.
+
+        This method will return an empty list if no applications
+        are found with the specified desktop file.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def get_open_windows(self, user_visible_only=True):
+        """Get a list of currently open windows.
+
+        If *user_visible_only* is True (the default), only applications visible
+        to the user in the switcher will be returned.
+
+        The result is sorted to be in stacking order.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def wait_until_application_is_running(self, desktop_file, timeout):
+        """Wait until a given application is running.
+
+        :param string desktop_file: The name of the application desktop file.
+        :param integer timeout: The maximum time to wait, in seconds. *If set to
+         something less than 0, this method will wait forever.*
+
+        :return: true once the application is found, or false if the application
+         was not found until the timeout was reached.
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def launch_application(self, desktop_file, files=[], wait=True):
+        """Launch an application by specifying a desktop file.
+
+        :param files: List of files to pass to the application. *Not all
+         apps support this.*
+        :type files: List of strings
+
+        .. note:: If `wait` is True, this method will wait up to 10 seconds for
+         the application to appear.
+
+        :raises: **TypeError** on invalid *files* parameter.
+        :return: The Gobject process object.
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+
+class Application(object):
+    @property
+    def desktop_file(self):
+        """Get the application desktop file.
+
+        This returns just the filename, not the full path.
+        If the application no longer exists, this returns an empty string.
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def name(self):
+        """Get the application name.
+
+        .. note:: This may change according to the current locale. If you want a
+         unique string to match applications against, use desktop_file instead.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def icon(self):
+        """Get the application icon.
+
+        :return: The name of the icon.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def is_active(self):
+        """Is the application active (i.e. has keyboard focus)?"""
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def is_urgent(self):
+        """Is the application currently signalling urgency?"""
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def user_visible(self):
+        """Is this application visible to the user?
+
+        .. note:: Some applications (such as the panel) are hidden to the user
+         but may still be returned.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def get_windows(self):
+        """Get a list of the application windows."""
+        raise NotImplementedError("You cannot use this class directly.")
+
+
+
+class Window(object):
+    @property
+    def x_id(self):
+        """Get the X11 Window Id."""
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def x_win(self):
+        """Get the X11 window object of the underlying window."""
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def get_wm_state(self):
+        """Get the state of the underlying window."""
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def name(self):
+        """Get the window name.
+
+        .. note:: This may change according to the current locale. If you want a
+         unique string to match windows against, use the x_id instead.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def title(self):
+        """Get the window title.
+
+        This may be different from the application name.
+
+        .. note:: This may change depending on the current locale.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def geometry(self):
+        """Get the geometry for this window.
+
+        :return: Tuple containing (x, y, width, height).
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def is_maximized(self):
+        """Is the window maximized?
+
+        Maximized in this case means both maximized vertically and
+        horizontally. If a window is only maximized in one direction it is not
+        considered maximized.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def application(self):
+        """Get the application that owns this window.
+
+        This method may return None if the window does not have an associated
+        application. The 'desktop' window is one such example.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def user_visible(self):
+        """Is this window visible to the user in the switcher?"""
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def is_hidden(self):
+        """Is this window hidden?
+
+        Windows are hidden when the 'Show Desktop' mode is activated.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def is_focused(self):
+        """Is this window focused?"""
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def is_valid(self):
+        """Is this window object valid?
+
+        Invalid windows are caused by windows closing during the construction of
+        this object instance.
+
+        """
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def monitor(self):
+        """Returns the monitor to which the windows belongs to"""
+        raise NotImplementedError("You cannot use this class directly.")
+
+    @property
+    def closed(self):
+        """Returns True if the window has been closed"""
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def close(self):
+        """Close the window."""
+        raise NotImplementedError("You cannot use this class directly.")
+
+    def set_focus(self):
+        raise NotImplementedError("You cannot use this class directly.")

=== renamed file 'autopilot/emulators/bamf.py' => 'autopilot/process/_bamf.py'
--- autopilot/emulators/bamf.py	2013-01-06 21:51:56 +0000
+++ autopilot/process/_bamf.py	2013-04-15 21:43:32 +0000
@@ -5,7 +5,7 @@
 # under the terms of the GNU General Public License version 3, as published
 # by the Free Software Foundation.
 
-"""Various classes for interacting with BAMF."""
+"""BAMF implementation of the Process Management"""
 
 from __future__ import absolute_import
 
@@ -13,21 +13,25 @@
 import dbus.glib
 from gi.repository import Gio
 from gi.repository import GLib
+import logging
 import os
+from time import sleep
 from Xlib import display, X, protocol
 
-from autopilot.emulators.dbus_handler import get_session_bus
-from autopilot.utilities import Silence
-
-__all__ = [
-    "Bamf",
-    "BamfApplication",
-    "BamfWindow",
-    ]
+from autopilot.dbus_handler import get_session_bus
+from autopilot.utilities import addCleanup, Silence
+
+from autopilot.process import (
+    ProcessManager as ProcessManagerBase,
+    Application as ApplicationBase,
+    Window as WindowBase
+    )
+
 
 _BAMF_BUS_NAME = 'org.ayatana.bamf'
 _X_DISPLAY = None
 
+logger = logging.getLogger(__name__)
 
 def get_display():
     """Create an Xlib display object (silently) and return it."""
@@ -51,7 +55,7 @@
         return False
 
 
-class Bamf(object):
+class ProcessManager(ProcessManagerBase):
     """High-level class for interacting with Bamf from within a test.
 
     Use this class to inspect the state of running applications and open
@@ -65,6 +69,126 @@
         self.matcher_proxy = get_session_bus().get_object(_BAMF_BUS_NAME, matcher_path)
         self.matcher_interface = dbus.Interface(self.matcher_proxy, self.matcher_interface_name)
 
+    def start_app(self, app_name, files=[], locale=None):
+        """Start one of the known applications, and kill it on tear down.
+
+        .. warning:: This method will clear all instances of this application on
+         tearDown, not just the one opened by this method! We recommend that
+         you use the :meth:`start_app_window` method instead, as it is generally
+         safer.
+
+        :param app_name: The application name. *This name must either already
+         be registered as one of the built-in applications that are supported
+         by autopilot, or must have been registered using*
+         :meth:`register_known_application` *beforehand.*
+        :param files: (Optional) A list of paths to open with the
+         given application. *Not all applications support opening files in this
+         way.*
+        :param locale: (Optional) The locale will to set when the application
+         is launched. *If you want to launch an application without any
+         localisation being applied, set this parameter to 'C'.*
+        :returns: A :class:`~autopilot.process.Application` instance.
+
+        """
+        window = self._open_window(app_name, files, locale)
+        if window:
+            addCleanup(self.close_all_app, app_name)
+            return window.application
+
+        raise AssertionError("No new application window was opened.")
+
+    def start_app_window(self, app_name, files=[], locale=None):
+        """Open a single window for one of the known applications, and close it
+        at the end of the test.
+
+        :param app_name: The application name. *This name must either already
+         be registered as one of the built-in applications that are supported
+         by autopilot, or must have been registered with*
+         :meth:`register_known_application` *beforehand.*
+        :param files: (Optional) Should be a list of paths to open with the
+         given application. *Not all applications support opening files in this
+         way.*
+        :param locale: (Optional) The locale will to set when the application
+         is launched. *If you want to launch an application without any
+         localisation being applied, set this parameter to 'C'.*
+        :raises: **AssertionError** if no window was opened, or more than one
+         window was opened.
+        :returns: A :class:`~autopilot.process.Window` instance.
+
+        """
+        window = self._open_window(app_name, files, locale)
+        if window:
+            addCleanup(window.close)
+            return window
+        raise AssertionError("No window was opened.")
+
+    def _open_window(self, app_name, files, locale):
+        """Open a new 'app_name' window, returning the window instance or None.
+
+        Raises an AssertionError if this creates more than one window.
+
+        """
+        existing_windows = self.get_open_windows_by_application(app_name)
+
+        if locale:
+            os.putenv("LC_ALL", locale)
+            addCleanup(os.unsetenv, "LC_ALL")
+            logger.info("Starting application '%s' with files %r in locale %s", app_name, files, locale)
+        else:
+            logger.info("Starting application '%s' with files %r", app_name, files)
+
+
+        app = self.KNOWN_APPS[app_name]
+        self.launch_application(app['desktop-file'], files)
+        apps = self.get_running_applications_by_desktop_file(app['desktop-file'])
+
+        for i in range(10):
+            try:
+                new_windows = []
+                [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)
+                if new_wins:
+                    assert len(new_wins) == 1
+                    return new_wins[0]
+            except DBusException:
+                pass
+            sleep(1)
+        return None
+
+    def get_open_windows_by_application(self, app_name):
+        """Get a list of ~autopilot.process.Window` instances
+        for the given application name.
+
+        :param app_name: The name of one of the well-known applications.
+        :returns: A list of :class:`~autopilot.process.Window`
+         instances.
+
+        """
+        existing_windows = []
+        [existing_windows.extend(a.get_windows()) for a in self.get_app_instances(app_name)]
+        return existing_windows
+
+    def close_all_app(self, app_name):
+        """Close all instances of the application 'app_name'."""
+        app = self.KNOWN_APPS[app_name]
+        try:
+            pids = check_output(["pidof", app['process-name']]).split()
+            if len(pids):
+                call(["kill"] + pids)
+        except CalledProcessError:
+            logger.warning("Tried to close applicaton '%s' but it wasn't running.", app_name)
+
+    def get_app_instances(self, app_name):
+        """Get `~autopilot.process.Application` instances for app_name."""
+        desktop_file = self.KNOWN_APPS[app_name]['desktop-file']
+        return self.get_running_applications_by_desktop_file(desktop_file)
+
+    def app_is_running(self, app_name):
+        """Return true if an instance of the application is running."""
+        apps = self.get_app_instances(app_name)
+        return len(apps) > 0
+
     def get_running_applications(self, user_visible_only=True):
         """Get a list of the currently running applications.
 
@@ -72,7 +196,7 @@
         visible to the user in the switcher will be returned.
 
         """
-        apps = [BamfApplication(p) for p in self.matcher_interface.RunningApplications()]
+        apps = [Application(p) for p in self.matcher_interface.RunningApplications()]
         if user_visible_only:
             return filter(_filter_user_visible, apps)
         return apps
@@ -80,7 +204,7 @@
     def get_running_applications_by_desktop_file(self, desktop_file):
         """Return a list of applications that have the desktop file *desktop_file*.
 
-        This method may return an empty list, if no applications
+        This method will return an empty list if no applications
         are found with the specified desktop file.
 
         """
@@ -93,14 +217,6 @@
                 pass
         return apps
 
-    def get_application_by_xid(self, xid):
-        """Return the application that has a child with the requested xid or None."""
-
-        app_path = self.matcher_interface.ApplicationForXid(xid)
-        if len(app_path):
-            return BamfApplication(app_path)
-        return None
-
     def get_open_windows(self, user_visible_only=True):
         """Get a list of currently open windows.
 
@@ -111,7 +227,7 @@
 
         """
 
-        windows = [BamfWindow(w) for w in self.matcher_interface.WindowStackForMonitor(-1)]
+        windows = [Window(w) for w in self.matcher_interface.WindowStackForMonitor(-1)]
         if user_visible_only:
             windows = filter(_filter_user_visible, windows)
         # Now sort on stacking order.
@@ -119,11 +235,6 @@
         # try and use len() on return values from these methods.
         return list(reversed(windows))
 
-    def get_window_by_xid(self, xid):
-        """Get the BamfWindow that matches the provided *xid*."""
-        windows = [BamfWindow(w) for w in self.matcher_interface.WindowPaths() if BamfWindow(w).x_id == xid]
-        return windows[0] if windows else None
-
     def wait_until_application_is_running(self, desktop_file, timeout):
         """Wait until a given application is running.
 
@@ -147,7 +258,7 @@
             # No, so define a callback to watch the ViewOpened signal:
             def on_view_added(bamf_path, name):
                 if bamf_path.split('/')[-1].startswith('application'):
-                    app = BamfApplication(bamf_path)
+                    app = Application(bamf_path)
                     if desktop_file == os.path.split(app.desktop_file)[1]:
                         gobject_loop.quit()
 
@@ -192,7 +303,7 @@
         return proc
 
 
-class BamfApplication(object):
+class Application(ApplicationBase):
     """Represents an application, with information as returned by Bamf.
 
     .. important:: Don't instantiate this class yourself. instead, use the
@@ -265,20 +376,20 @@
 
     def get_windows(self):
         """Get a list of the application windows."""
-        return [BamfWindow(w) for w in self._view_iface.Children()]
+        return [Window(w) for w in self._view_iface.Children()]
 
     def __repr__(self):
-        return "<BamfApplication '%s'>" % (self.name)
+        return "<Application '%s'>" % (self.name)
 
     def __eq__(self, other):
         return self.desktop_file == other.desktop_file
 
 
-class BamfWindow(object):
+class Window(WindowBase):
     """Represents an application window, as returned by Bamf.
 
     .. important:: Don't instantiate this class yourself. Instead, use the
-     appropriate methods in BamfApplication.
+     appropriate methods in Application.
 
     """
     def __init__(self, window_path):
@@ -364,7 +475,7 @@
         # associated application. For these windows we return none.
         parents = self._view_iface.Parents()
         if parents:
-            return BamfApplication(parents[0])
+            return Application(parents[0])
         else:
             return None
 
@@ -423,7 +534,7 @@
         self._x_win.configure(stack_mode=X.Above)
 
     def __repr__(self):
-        return "<BamfWindow '%s' Xid: %d>" % (self.title if self._x_win else '', self.x_id)
+        return "<Window '%s' Xid: %d>" % (self.title if self._x_win else '', self.x_id)
 
     def _getProperty(self, _type):
         """Get an X11 property.

=== modified file 'autopilot/testcase.py'
--- autopilot/testcase.py	2013-04-05 14:02:59 +0000
+++ autopilot/testcase.py	2013-04-15 21:43:32 +0000
@@ -11,40 +11,35 @@
 from __future__ import absolute_import
 
 from dbus import DBusException
+from gi.repository import Gio
 import logging
 import os
-from StringIO import StringIO
+import signal
 from subprocess import (
     call,
     CalledProcessError,
     check_output,
-    Popen,
-    PIPE,
-    STDOUT,
     )
 
 from testscenarios import TestWithScenarios
 from testtools import TestCase
 from testtools.content import text_content
 from testtools.matchers import Equals
-import time
+from time import sleep
 
-from autopilot.compizconfig import get_global_context
-from autopilot.emulators.bamf import Bamf
-from autopilot.emulators.zeitgeist import Zeitgeist
-from autopilot.emulators.processmanager import ProcessManager
-from autopilot.emulators.X11 import ScreenGeometry, reset_display
-from autopilot.emulators.input import get_keyboard, get_mouse
-from autopilot.glibrunner import AutopilotTestRunner
-from autopilot.globals import (get_log_verbose,
-    get_video_recording_enabled,
-    get_video_record_directory,
+from autopilot.process import ProcessManager
+from autopilot.input import Keyboard, Mouse
+from autopilot.introspection import (
+    get_application_launcher,
+    get_autopilot_proxy_object_for_process,
+    launch_application,
+    launch_process,
     )
+from autopilot.display import Display
+from autopilot.globals import on_test_started
 from autopilot.keybindings import KeybindingsHelper
 from autopilot.matchers import Eventually
-from autopilot.utilities import (get_compiz_setting,
-    LogFormatter,
-    )
+
 
 logger = logging.getLogger(__name__)
 
@@ -74,108 +69,7 @@
         return result
 
 
-class LoggedTestCase(TestWithScenarios, TestCase):
-    """Initialize the logging for the test case."""
-
-    def setUp(self):
-        self._setUpTestLogging()
-        # The reason that the super setup is done here is due to making sure
-        # that the logging is properly set up prior to calling it.
-        super(LoggedTestCase, self).setUp()
-        if get_log_verbose():
-            logger.info("*" * 60)
-            logger.info("Starting test %s", self.shortDescription())
-
-    def _setUpTestLogging(self):
-        self._log_buffer = StringIO()
-        root_logger = logging.getLogger()
-        root_logger.setLevel(logging.DEBUG)
-        formatter = LogFormatter()
-        self._log_handler = logging.StreamHandler(stream=self._log_buffer)
-        self._log_handler.setFormatter(formatter)
-        root_logger.addHandler(self._log_handler)
-
-        #Tear down logging in a cleanUp handler, so it's done after all other
-        # tearDown() calls and cleanup handlers.
-        self.addCleanup(self._tearDownLogging)
-
-    def _tearDownLogging(self):
-        root_logger = logging.getLogger()
-        self._log_handler.flush()
-        self._log_buffer.seek(0)
-        self.addDetail('test-log', text_content(self._log_buffer.getvalue()))
-        root_logger.removeHandler(self._log_handler)
-        # Calling del to remove the handler and flush the buffer.  We are
-        # abusing the log handlers here a little.
-        del self._log_buffer
-
-
-
-class VideoCapturedTestCase(LoggedTestCase):
-    """Video capture autopilot tests, saving the results if the test failed."""
-
-    _recording_app = '/usr/bin/recordmydesktop'
-    _recording_opts = ['--no-sound', '--no-frame', '-o',]
-
-    def setUp(self):
-        super(VideoCapturedTestCase, self).setUp()
-        global video_recording_enabled
-        if get_video_recording_enabled() and not self._have_recording_app():
-            video_recording_enabled = False
-            logger.warning("Disabling video capture since '%s' is not present", self._recording_app)
-
-        if get_video_recording_enabled():
-            self._test_passed = True
-            self.addOnException(self._on_test_failed)
-            self.addCleanup(self._stop_video_capture)
-            self._start_video_capture()
-
-    def _have_recording_app(self):
-        return os.path.exists(self._recording_app)
-
-    def _start_video_capture(self):
-        args = self._get_capture_command_line()
-        self._capture_file = self._get_capture_output_file()
-        self._ensure_directory_exists_but_not_file(self._capture_file)
-        args.append(self._capture_file)
-        logger.debug("Starting: %r", args)
-        self._capture_process = Popen(args, stdout=PIPE, stderr=STDOUT)
-
-    def _stop_video_capture(self):
-        """Stop the video capture. If the test failed, save the resulting file."""
-
-        if self._test_passed:
-            # We use kill here because we don't want the recording app to start
-            # encoding the video file (since we're removing it anyway.)
-            self._capture_process.kill()
-            self._capture_process.wait()
-        else:
-            self._capture_process.terminate()
-            self._capture_process.wait()
-            if self._capture_process.returncode != 0:
-                self.addDetail('video capture log', text_content(self._capture_process.stdout.read()))
-        self._capture_process = None
-
-    def _get_capture_command_line(self):
-        return [self._recording_app] + self._recording_opts
-
-    def _get_capture_output_file(self):
-        return os.path.join(get_video_record_directory(), '%s.ogv' % (self.shortDescription()))
-
-    def _ensure_directory_exists_but_not_file(self, file_path):
-        dirpath = os.path.dirname(file_path)
-        if not os.path.exists(dirpath):
-            os.makedirs(dirpath)
-        elif os.path.exists(file_path):
-            logger.warning("Video capture file '%s' already exists, deleting.", file_path)
-            os.remove(file_path)
-
-    def _on_test_failed(self, ex_info):
-        """Called when a test fails."""
-        self._test_passed = False
-
-
-class AutopilotTestCase(VideoCapturedTestCase, KeybindingsHelper):
+class AutopilotTestCase(TestWithScenarios, TestCase, KeybindingsHelper):
     """Wrapper around testtools.TestCase that adds significant functionality.
 
     This class should be the base class for all autopilot test case classes. Not
@@ -190,19 +84,11 @@
     :meth:`~autopilot.testcase.AutopilotTestCase.start_app` and
     :meth:`~autopilot.testcase.AutopilotTestCase.start_app_window` which will
     launch one of the well-known applications and return a
-    :class:`~autopilot.emulators.bamf.BamfApplication` or
-    :class:`~autopilot.emulators.bamf.BamfWindow` instance to the launched
+    :class:`~autopilot.process.Application` or
+    :class:`~autopilot.process.Window` instance to the launched
     process respectively. All applications launched in this way will be closed
     when the test ends.
 
-    **Set Unity & Compiz Options**
-
-    The :meth:`~autopilot.testcase.AutopilotTestCase.set_unity_option` and
-    :meth:`~autopilot.testcase.AutopilotTestCase.set_compiz_option` methods set a
-    unity or compiz setting to a particular value for the duration of the
-    current test only. This is useful if you want the window manager to behave
-    in a particular fashion for a particular test, while being assured that any
-    chances are non-destructive.
 
     **Patch Process Environment**
 
@@ -213,269 +99,40 @@
 
     """
 
-    run_tests_with = AutopilotTestRunner
-
-    KNOWN_APPS = {
-        'Character Map' : {
-            'desktop-file': 'gucharmap.desktop',
-            'process-name': 'gucharmap',
-            },
-        'Calculator' : {
-            'desktop-file': 'gcalctool.desktop',
-            'process-name': 'gnome-calculator',
-            },
-        'Mahjongg' : {
-            'desktop-file': 'mahjongg.desktop',
-            'process-name': 'gnome-mahjongg',
-            },
-        'Remmina' : {
-            'desktop-file': 'remmina.desktop',
-            'process-name': 'remmina',
-            },
-        'System Settings' : {
-            'desktop-file': 'gnome-control-center.desktop',
-            'process-name': 'gnome-control-center',
-            },
-        'Text Editor' : {
-            'desktop-file': 'gedit.desktop',
-            'process-name': 'gedit',
-            },
-        'Terminal' : {
-            'desktop-file': 'gnome-terminal.desktop',
-            'process-name': 'gnome-terminal',
-            },
-        }
-
-
     def setUp(self):
         super(AutopilotTestCase, self).setUp()
-
-        self._process_manager = ProcessManager()
-        self._process_manager.snapshot_running_apps()
-        self.addCleanup(self._process_manager.compare_system_with_snapshot)
-
-        self.bamf = Bamf()
-        self.keyboard = get_keyboard()
-        self.mouse = get_mouse()
-        self.zeitgeist = Zeitgeist()
-
-        self.screen_geo = ScreenGeometry()
+        on_test_started(self)
+
+        self.process_manager = ProcessManager.create()
+        self._app_snapshot = self.process_manager.get_running_applications()
+        self.addCleanup(self._compare_system_with_app_snapshot)
+
+        self.keyboard = Keyboard.create()
+        self.mouse = Mouse.create()
+
+        self.screen_geo = Display.create()
         self.addCleanup(self.keyboard.cleanup)
         self.addCleanup(self.mouse.cleanup)
 
-    def call_gsettings_cmd(self, command, schema, *args):
-        """Set a desktop wide gsettings option
-
-        Using the gsettings command because there is a bug with importing
-        from gobject introspection and pygtk2 simultaneously, and the Xlib
-        keyboard layout bits are very unwieldy. This seems like the best
-        solution, even a little bit brutish.
-        """
-        cmd = ['gsettings', command, schema] + list(args)
-        # strip to remove the trailing \n.
-        ret = check_output(cmd).strip()
-        time.sleep(5)
-        reset_display()
-        return ret
-
-    def set_unity_option(self, option_name, option_value):
-        """Set an option in the unity compiz plugin options.
-
-        .. note:: The value will be set for the current test only, and
-         automatically undone when the test ends.
-
-        :param option_name: The name of the unity option.
-        :param option_value: The value you want to set.
-        :raises: **KeyError** if the option named does not exist.
-
-        """
-        self.set_compiz_option("unityshell", option_name, option_value)
-
-    def set_compiz_option(self, plugin_name, option_name, option_value):
-        """Set a compiz option for the duration of this test only.
-
-        .. note:: The value will be set for the current test only, and
-         automatically undone when the test ends.
-
-        :param plugin_name: The name of the compiz plugin where the option is
-         registered. If the option is not in a plugin, the string "core" should
-         be used as the plugin name.
-        :param option_name: The name of the unity option.
-        :param option_value: The value you want to set.
-        :raises: **KeyError** if the option named does not exist.
-
-        """
-        old_value = self._set_compiz_option(plugin_name, option_name, option_value)
-        # Cleanup is LIFO, during clean-up also allow unity to respond
-        self.addCleanup(time.sleep, 0.5)
-        self.addCleanup(self._set_compiz_option, plugin_name, option_name, old_value)
-        # Allow unity time to respond to the new setting.
-        time.sleep(0.5)
-
-    def _set_compiz_option(self, plugin_name, option_name, option_value):
-        logger.info("Setting compiz option '%s' in plugin '%s' to %r",
-            option_name, plugin_name, option_value)
-        setting = get_compiz_setting(plugin_name, option_name)
-        old_value = setting.Value
-        setting.Value = option_value
-        get_global_context().Write()
-        return old_value
-
-    @classmethod
-    def register_known_application(cls, name, desktop_file, process_name):
-        """Register an application with autopilot.
-
-        After calling this method, you may call :meth:`start_app` or
-        :meth:`start_app_window` with the `name` parameter to start this
-        application.
-        You need only call this once within a test run - the application will
-        remain registerred until the test run ends.
-
-        :param name: The name to be used when launching the application.
-        :param desktop_file: The filename (without path component) of the desktop file used to launch the application.
-        :param process_name: The name of the executable process that gets run.
-        :raises: **KeyError** if application has been registered already
-
-        """
-        if name in cls.KNOWN_APPS:
-            raise KeyError("Application has been registered already")
-        else:
-            cls.KNOWN_APPS[name] = {
-                                     "desktop-file" : desktop_file,
-                                     "process-name" : process_name
-                                   }
-
-    @classmethod
-    def unregister_known_application(cls, name):
-        """Unregister an application with the known_apps dictionary.
-
-        :param name: The name to be used when launching the application.
-        :raises: **KeyError** if the application has not been registered.
-
-        """
-        if name in cls.KNOWN_APPS:
-            del cls.KNOWN_APPS[name]
-        else:
-            raise KeyError("Application has not been registered")
-
-    def start_app(self, app_name, files=[], locale=None):
-        """Start one of the known applications, and kill it on tear down.
-
-        .. warning:: This method will clear all instances of this application on
-         tearDown, not just the one opened by this method! We recommend that
-         you use the :meth:`start_app_window` method instead, as it is generally
-         safer.
-
-        :param app_name: The application name. *This name must either already
-         be registered as one of the built-in applications that are supported
-         by autopilot, or must have been registered using*
-         :meth:`register_known_application` *beforehand.*
-        :param files: (Optional) A list of paths to open with the
-         given application. *Not all applications support opening files in this
-         way.*
-        :param locale: (Optional) The locale will to set when the application
-         is launched. *If you want to launch an application without any
-         localisation being applied, set this parameter to 'C'.*
-        :returns: A :class:`~autopilot.emulators.bamf.BamfApplication` instance.
-
-        """
-        window = self._open_window(app_name, files, locale)
-        if window:
-            self.addCleanup(self.close_all_app, app_name)
-            return window.application
-
-        raise AssertionError("No new application window was opened.")
-
-    def start_app_window(self, app_name, files=[], locale=None):
-        """Open a single window for one of the known applications, and close it
-        at the end of the test.
-
-        :param app_name: The application name. *This name must either already
-         be registered as one of the built-in applications that are supported
-         by autopilot, or must have been registered with*
-         :meth:`register_known_application` *beforehand.*
-        :param files: (Optional) Should be a list of paths to open with the
-         given application. *Not all applications support opening files in this
-         way.*
-        :param locale: (Optional) The locale will to set when the application
-         is launched. *If you want to launch an application without any
-         localisation being applied, set this parameter to 'C'.*
-        :raises: **AssertionError** if no window was opened, or more than one
-         window was opened.
-        :returns: A :class:`~autopilot.emulators.bamf.BamfWindow` instance.
-
-        """
-        window = self._open_window(app_name, files, locale)
-        if window:
-            self.addCleanup(window.close)
-            return window
-        raise AssertionError("No window was opened.")
-
-    def _open_window(self, app_name, files, locale):
-        """Open a new 'app_name' window, returning the window instance or None.
-
-        Raises an AssertionError if this creates more than one window.
-
-        """
-        existing_windows = self.get_open_windows_by_application(app_name)
-
-        if locale:
-            os.putenv("LC_ALL", locale)
-            self.addCleanup(os.unsetenv, "LC_ALL")
-            logger.info("Starting application '%s' with files %r in locale %s", app_name, files, locale)
-        else:
-            logger.info("Starting application '%s' with files %r", app_name, files)
-
-
-        app = self.KNOWN_APPS[app_name]
-        self.bamf.launch_application(app['desktop-file'], files)
-        apps = self.bamf.get_running_applications_by_desktop_file(app['desktop-file'])
-
+    def _compare_system_with_app_snapshot(self):
+        """Compare the currently running application with the last snapshot.
+
+        This method will raise an AssertionError if there are any new applications
+        currently running that were not running when the snapshot was taken.
+        """
+        if self._app_snapshot is None:
+            raise RuntimeError("No snapshot to match against.")
+
+        new_apps = []
         for i in range(10):
-            try:
-                new_windows = []
-                [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)
-                if new_wins:
-                    assert len(new_wins) == 1
-                    return new_wins[0]
-            except DBusException:
-                pass
-            time.sleep(1)
-        return None
-
-    def get_open_windows_by_application(self, app_name):
-        """Get a list of BamfWindow instances for the given application name.
-
-        :param app_name: The name of one of the well-known applications.
-        :returns: A list of :class:`~autopilot.emulators.bamf.BamfWindow`
-         instances.
-
-        """
-        existing_windows = []
-        [existing_windows.extend(a.get_windows()) for a in self.get_app_instances(app_name)]
-        return existing_windows
-
-    def close_all_app(self, app_name):
-        """Close all instances of the application 'app_name'."""
-        app = self.KNOWN_APPS[app_name]
-        try:
-            pids = check_output(["pidof", app['process-name']]).split()
-            if len(pids):
-                call(["kill"] + pids)
-        except CalledProcessError:
-            logger.warning("Tried to close applicaton '%s' but it wasn't running.", app_name)
-
-    def get_app_instances(self, app_name):
-        """Get BamfApplication instances for app_name."""
-        desktop_file = self.KNOWN_APPS[app_name]['desktop-file']
-        return self.bamf.get_running_applications_by_desktop_file(desktop_file)
-
-    def app_is_running(self, app_name):
-        """Return true if an instance of the application is running."""
-        apps = self.get_app_instances(app_name)
-        return len(apps) > 0
+            current_apps = self.process_manager.get_running_applications()
+            new_apps = filter(lambda i: i not in self._app_snapshot, current_apps)
+            if not new_apps:
+                self._app_snapshot = None
+                return
+            sleep(1)
+        self._app_snapshot = None
+        raise AssertionError("The following apps were started during the test and not closed: %r", new_apps)
 
     def patch_environment(self, key, value):
         """Patch the process environment, setting *key* with value *value*.
@@ -513,12 +170,13 @@
 
         .. note:: Minimised windows are skipped.
 
-        :param stack_start: An iterable of BamfWindow instances.
+        :param stack_start: An iterable of
+         `~autopilot.process.Window` instances.
         :raises: **AssertionError** if the top of the window stack does not
          match the contents of the stack_start parameter.
 
         """
-        stack = [win for win in self.bamf.get_open_windows() if not win.is_hidden]
+        stack = [win for win in self.process_manager.get_open_windows() if not win.is_hidden]
         for pos, win in enumerate(stack_start):
             self.assertThat(stack[pos].x_id, Equals(win.x_id),
                             "%r at %d does not equal %r" % (stack[pos], pos, win))
@@ -531,7 +189,7 @@
         the autopilot DBus interface).
 
         For example, from within a test, to assert certain properties on a
-        BamfWindow instance::
+        `~autopilot.process.Window` instance::
 
             self.assertProperty(my_window, is_maximized=True)
 
@@ -561,3 +219,83 @@
             self.assertThat(lambda: getattr(obj, prop_name), Eventually(Equals(desired_value)))
 
     assertProperties = assertProperty
+
+    def launch_test_application(self, application, *arguments, **kwargs):
+        """Launch ``application`` and return a proxy object for the application.
+
+        Use this method to launch an application and start testing it. The
+        positional arguments are used as arguments to the application to lanch.
+        Keyword arguments are used to control the manner in which the application
+        is launched.
+
+        This method is designed to be flexible enough to launch all supported
+        types of applications. For example, to launch a traditional Gtk application,
+        a test might start with::
+
+            app_proxy = self.launch_test_application('gedit')
+
+        ... a Qt4 Qml application might be launched like this::
+
+            app_proxy = self.launch_test_application('qmlviewer', 'my_scene.qml')
+
+        ... a Qt5 Qml application is launched in a similar fashion::
+
+            app_proxy = self.launch_test_application('qmlscene', 'my_scene.qml')
+
+        :param application: The application to launch. The application can be
+            specified as:
+
+             * A full, absolute path to an executable file. (``/usr/bin/gedit``)
+             * A relative path to an executable file. (``./build/my_app``)
+             * An app name, which will be searched for in $PATH (``my_app``)
+
+        :keyword launch_dir:  If set to a directory that exists the process will be
+            launched from that directory.
+
+        :keyword capture_output: If set to True (the default), the process output
+            will be captured and attached to the test as test detail.
+
+        :raises: **ValueError** if unknown keyword arguments are passed.
+        :return: A proxy object that represents the application. Introspection
+         data is retrievable via this object.
+
+        """
+        # first, we get a launcher. Tests can override this if they need:
+        launcher = self.pick_app_launcher(application)
+        if launcher is None:
+            raise RuntimeError("Autopilot could not determine the correct \
+                introspection type to use. You can specify one by overriding \
+                the AutopilotTestCase.pick_app_launcher method.")
+        process = launch_application(launcher, application, *arguments, **kwargs)
+        self.addCleanup(self._kill_process_and_attach_logs, process)
+        return get_autopilot_proxy_object_for_process(process)
+
+    def pick_app_launcher(self, app_path):
+        """Given an application path, return an object suitable for launching
+        the application.
+
+        This function attempts to guess what kind of application you are
+        launching. If, for some reason the default implementation returns the
+        wrong launcher, test authors may override this method to provide their
+        own implemetnation.
+
+        The default implementation calls
+        :py:func:`autopilot.introspection.get_application_launcher`
+
+        """
+        # default implementation is in autopilot.introspection:
+        return get_application_launcher(app_path)
+
+    def _kill_process_and_attach_logs(self, process):
+        process.kill()
+        logger.info("waiting for process to exit.")
+        for i in range(10):
+            if process.returncode is not None:
+                break
+            if i == 9:
+                logger.info("Terminating process group, since it hasn't exited after 10 seconds.")
+                os.killpg(process.pid, signal.SIGTERM)
+            sleep(1)
+        stdout, stderr = process.communicate()
+        self.addDetail('process-stdout', text_content(stdout))
+        self.addDetail('process-stderr', text_content(stderr))

=== modified file 'autopilot/tests/test_ap_apps.py'
--- autopilot/tests/test_ap_apps.py	2013-02-22 03:59:51 +0000
+++ autopilot/tests/test_ap_apps.py	2013-04-15 21:43:32 +0000
@@ -13,8 +13,7 @@
 from textwrap import dedent
 
 from autopilot.testcase import AutopilotTestCase
-from autopilot.introspection.gtk import GtkIntrospectionTestMixin
-from autopilot.introspection.qt import QtIntrospectionTestMixin
+from autopilot.introspection.gtk import GtkApplicationLauncher
 
 
 class ApplicationTests(AutopilotTestCase):
@@ -33,15 +32,20 @@
         return path
 
 
-class QtTests(ApplicationTests, QtIntrospectionTestMixin):
+class QtTests(ApplicationTests):
 
     def setUp(self):
         super(QtTests, self).setUp()
 
         try:
-            self.app_path = subprocess.check_output(['which','qmlviewer']).strip()
+            self.app_path = subprocess.check_output(['which','qmlscene']).strip()
         except subprocess.CalledProcessError:
-            self.skip("qmlviewer not found.")
+            self.skip("qmlscene not found.")
+
+    def pick_app_launcher(self, app_path):
+        # force Qt app introspection:
+        from autopilot.introspection.qt import QtApplicationLauncher
+        return QtApplicationLauncher()
 
     def test_can_launch_qt_app(self):
         app_proxy = self.launch_test_application(self.app_path)
@@ -83,7 +87,7 @@
         self.assertTrue(app_proxy is not None)
 
 
-class GtkTests(ApplicationTests, GtkIntrospectionTestMixin):
+class GtkTests(ApplicationTests):
 
     def setUp(self):
         super(GtkTests, self).setUp()

=== modified file 'autopilot/tests/test_application_mixin.py'
--- autopilot/tests/test_application_mixin.py	2012-09-13 02:28:04 +0000
+++ autopilot/tests/test_application_mixin.py	2013-04-15 21:43:32 +0000
@@ -8,45 +8,33 @@
 
 from __future__ import absolute_import
 
-from testtools import TestCase
-from testtools.matchers import Equals, Is, Not, raises
-from mock import patch
-
-from autopilot.introspection.qt import QtIntrospectionTestMixin
-
+from autopilot.testcase import AutopilotTestCase
+from testtools.matchers import Is, Not, raises
 
 def dummy_addCleanup(*args, **kwargs):
     pass
 
 
-class ApplicationSupportTests(TestCase):
-
-    def test_can_create(self):
-        mixin = QtIntrospectionTestMixin()
-        self.assertThat(mixin, Not(Is(None)))
+class ApplicationSupportTests(AutopilotTestCase):
 
     def test_launch_with_bad_types_raises_typeerror(self):
         """Calling launch_test_application with something other than a string must
         raise a TypeError"""
 
-        mixin = QtIntrospectionTestMixin()
-        mixin.addCleanup = dummy_addCleanup
-
-        self.assertThat(lambda: mixin.launch_test_application(1), raises(TypeError))
-        self.assertThat(lambda: mixin.launch_test_application(True), raises(TypeError))
-        self.assertThat(lambda: mixin.launch_test_application(1.0), raises(TypeError))
-        self.assertThat(lambda: mixin.launch_test_application(object()), raises(TypeError))
-        self.assertThat(lambda: mixin.launch_test_application(None), raises(TypeError))
-        self.assertThat(lambda: mixin.launch_test_application([]), raises(TypeError))
-        self.assertThat(lambda: mixin.launch_test_application((None,)), raises(TypeError))
+        self.assertThat(lambda: self.launch_test_application(1), raises(TypeError))
+        self.assertThat(lambda: self.launch_test_application(True), raises(TypeError))
+        self.assertThat(lambda: self.launch_test_application(1.0), raises(TypeError))
+        self.assertThat(lambda: self.launch_test_application(object()), raises(TypeError))
+        self.assertThat(lambda: self.launch_test_application(None), raises(TypeError))
+        self.assertThat(lambda: self.launch_test_application([]), raises(TypeError))
+        self.assertThat(lambda: self.launch_test_application((None,)), raises(TypeError))
 
     def test_launch_raises_ValueError_on_unknown_kwargs(self):
         """launch_test_application must raise ValueError when given unknown
         keyword arguments.
 
         """
-        mixin = QtIntrospectionTestMixin()
-        fn = lambda: mixin.launch_test_application('gedit', arg1=123, arg2='asd')
+        fn = lambda: self.launch_test_application('gedit', arg1=123, arg2='asd')
         self.assertThat(fn, raises(ValueError("Unknown keyword arguments: 'arg1', 'arg2'.")))
 
     def test_launch_raises_ValueError_on_unknown_kwargs_with_known(self):
@@ -54,6 +42,5 @@
         keyword arguments.
 
         """
-        mixin = QtIntrospectionTestMixin()
-        fn = lambda: mixin.launch_test_application('gedit', arg1=123, arg2='asd', launch_dir='/')
+        fn = lambda: self.launch_test_application('gedit', arg1=123, arg2='asd', launch_dir='/')
         self.assertThat(fn, raises(ValueError("Unknown keyword arguments: 'arg1', 'arg2'.")))

=== removed file 'autopilot/tests/test_application_registration.py'
--- autopilot/tests/test_application_registration.py	2012-09-30 22:39:30 +0000
+++ autopilot/tests/test_application_registration.py	1970-01-01 00:00:00 +0000
@@ -1,94 +0,0 @@
-# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-# Copyright 2012 Canonical
-# Author: Thomi Richards
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-
-from __future__ import absolute_import
-
-from testtools import TestCase
-from testtools.matchers import Equals, Is, Not, raises, Contains
-from mock import patch
-
-from autopilot.testcase import AutopilotTestCase
-
-
-def safe_unregister_application(test_case_class, app_name):
-    if app_name in test_case_class.KNOWN_APPS:
-        test_case_class.unregister_known_application(app_name)
-
-class ApplicationRegistrationTests(TestCase):
-
-    def test_can_register_new_application(self):
-        AutopilotTestCase.register_known_application(
-            "NewApplicationName",
-            "newapp.desktop",
-            "newapp")
-        self.addCleanup(safe_unregister_application,
-            AutopilotTestCase,
-            "NewApplicationName")
-
-        app_details = AutopilotTestCase.KNOWN_APPS['NewApplicationName']
-
-        self.assertThat(AutopilotTestCase.KNOWN_APPS, Contains("NewApplicationName"))
-        self.assertTrue(type(app_details) is dict)
-        self.assertThat(app_details, Contains('desktop-file'))
-        self.assertThat(app_details, Contains('process-name'))
-        self.assertThat(app_details['desktop-file'], Equals('newapp.desktop'))
-        self.assertThat(app_details['process-name'], Equals('newapp'))
-
-    def test_registering_app_twice_raises_KeyError(self):
-        """Registering an application with the same app name as one that's
-        already in the dictionary must raise KeyError and not change the
-        dictionary.
-
-        """
-        AutopilotTestCase.register_known_application(
-            "NewApplicationName",
-            "newapp.desktop",
-            "newapp")
-        self.addCleanup(safe_unregister_application,
-            AutopilotTestCase,
-            "NewApplicationName")
-
-        app_details = AutopilotTestCase.KNOWN_APPS['NewApplicationName']
-        register_fn = lambda: AutopilotTestCase.register_known_application(
-            "NewApplicationName",
-            "newapp2.desktop",
-            "newapp2")
-
-        self.assertThat(register_fn, raises(
-            KeyError("Application has been registered already")))
-        self.assertThat(AutopilotTestCase.KNOWN_APPS, Contains("NewApplicationName"))
-        self.assertTrue(type(app_details) is dict)
-        self.assertThat(app_details, Contains('desktop-file'))
-        self.assertThat(app_details, Contains('process-name'))
-        self.assertThat(app_details['desktop-file'], Equals('newapp.desktop'))
-        self.assertThat(app_details['process-name'], Equals('newapp'))
-
-    def test_can_unregister_application(self):
-        AutopilotTestCase.register_known_application(
-            "NewApplicationName",
-            "newapp.desktop",
-            "newapp")
-        self.addCleanup(safe_unregister_application,
-            AutopilotTestCase,
-            "NewApplicationName")
-
-        AutopilotTestCase.unregister_known_application("NewApplicationName")
-
-        self.assertThat(AutopilotTestCase.KNOWN_APPS,
-            Not(Contains("NewApplicationName")))
-
-    def test_unregistering_unknown_application_raises_KeyError(self):
-        """Trying to unregister an application that is not already registered
-        must raise a KeyError.
-
-        """
-
-        unregister_fn = lambda: AutopilotTestCase.unregister_known_application("FooBarBaz")
-
-        self.assertThat(unregister_fn, raises(KeyError("Application has not been registered")))
-

=== removed file 'autopilot/tests/test_compiz_key_translate.py'
--- autopilot/tests/test_compiz_key_translate.py	2012-05-08 16:14:53 +0000
+++ autopilot/tests/test_compiz_key_translate.py	1970-01-01 00:00:00 +0000
@@ -1,69 +0,0 @@
-# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-# Copyright 2012 Canonical
-# Author: Thomi Richards
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-
-from __future__ import absolute_import
-
-from testscenarios import TestWithScenarios
-from testtools import TestCase
-from testtools.matchers import raises, Equals
-
-from autopilot.keybindings import _translate_compiz_keystroke_string as translate_func
-
-class KeyTranslateArgumentTests(TestWithScenarios, TestCase):
-    """Tests that the compizconfig keycode translation routes work as advertised."""
-
-    scenarios = [
-        ('bool', {'input': True}),
-        ('int', {'input': 42}),
-        ('float', {'input': 0.321}),
-        ('none', {'input': None}),
-    ]
-
-    def test_requires_string_instance(self):
-        """Function must raise TypeError unless given an instance of basestring."""
-        self.assertThat(lambda: translate_func(self.input), raises(TypeError))
-
-
-class TranslationTests(TestWithScenarios, TestCase):
-    """Test that we get the result we expect, with the given input."""
-
-    scenarios = [
-        ('empty string', dict(input='', expected='')),
-        ('single simpe letter', dict(input='a', expected='a')),
-        ('trailing space', dict(input='d   ', expected='d')),
-        ('only whitespace', dict(input='\t\n   ', expected='')),
-        ('special key: Ctrl', dict(input='<Control>', expected='Ctrl')),
-        ('special key: Primary', dict(input='<Primary>', expected='Ctrl')),
-        ('special key: Alt', dict(input='<Alt>', expected='Alt')),
-        ('special key: Shift', dict(input='<Shift>', expected='Shift')),
-        ('direction key up', dict(input='Up', expected='Up')),
-        ('direction key down', dict(input='Down', expected='Down')),
-        ('direction key left', dict(input='Left', expected='Left')),
-        ('direction key right', dict(input='Right', expected='Right')),
-        ('Ctrl+a', dict(input='<Control>a', expected='Ctrl+a')),
-        ('Primary+a', dict(input='<Control>a', expected='Ctrl+a')),
-        ('Shift+s', dict(input='<Shift>s', expected='Shift+s')),
-        ('Alt+d', dict(input='<Alt>d', expected='Alt+d')),
-        ('Super+w', dict(input='<Super>w', expected='Super+w')),
-        ('Ctrl+Up', dict(input='<Control>Up', expected='Ctrl+Up')),
-        ('Primary+Down', dict(input='<Control>Down', expected='Ctrl+Down')),
-        ('Alt+Left', dict(input='<Alt>Left', expected='Alt+Left')),
-        ('Shift+F3', dict(input='<Shift>F3', expected='Shift+F3')),
-        ('duplicate keys Ctrl+Ctrl', dict(input='<Control><Control>', expected='Ctrl')),
-        ('duplicate keys Ctrl+Primary', dict(input='<Control><Primary>', expected='Ctrl')),
-        ('duplicate keys Ctrl+Primary', dict(input='<Primary><Control>', expected='Ctrl')),
-        ('duplicate keys Alt+Alt', dict(input='<Alt><Alt>', expected='Alt')),
-        ('duplicate keys Ctrl+Primary+left', dict(input='<Control><Primary>Left', expected='Ctrl+Left')),
-        ('first key wins', dict(input='<Control><Alt>Down<Alt>', expected='Ctrl+Alt+Down')),
-        ('Getting silly now', dict(input='<Control><Primary><Shift><Shift><Alt>Left', expected='Ctrl+Shift+Alt+Left')),
-    ]
-
-    def test_translation(self):
-        self.assertThat(translate_func(self.input), Equals(self.expected))
-
-

=== removed file 'autopilot/tests/test_compiz_option_support.py'
--- autopilot/tests/test_compiz_option_support.py	2012-08-20 03:59:45 +0000
+++ autopilot/tests/test_compiz_option_support.py	1970-01-01 00:00:00 +0000
@@ -1,31 +0,0 @@
-# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-# Copyright 2012 Canonical
-# Author: Thomi Richards
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-
-from __future__ import absolute_import
-
-from testtools.matchers import Equals, raises, Not
-
-from autopilot.testcase import AutopilotTestCase
-import logging
-logger = logging.getLogger(__name__)
-
-
-
-class CompizConfigOptionTests(AutopilotTestCase):
-
-    def test_set_option_raises_KeyError_on_bad_plugin_name(self):
-        """set_compiz_option must raise KeyError when given a bad plugin name."""
-        fn = lambda: self.set_compiz_option('rubbishpluginname', 'rubbishsettingname', 'settingvalue')
-        self.assertThat(fn, raises(KeyError("Compiz plugin 'rubbishpluginname' does not exist.")))
-
-    def test_set_option_raises_KeyError_on_bad_setting_name(self):
-        """set_compiz_option must raise KeyError when called with a bad setting name."""
-        fn = lambda: self.set_compiz_option('core', 'rubbishsettingname', 'settingvalue')
-        self.assertThat(fn, raises(KeyError("Compiz setting 'rubbishsettingname' does not exist in plugin 'core'.")))
-
-

=== modified file 'autopilot/tests/test_keyboard.py'
--- autopilot/tests/test_keyboard.py	2012-12-04 01:37:07 +0000
+++ autopilot/tests/test_keyboard.py	2013-04-15 21:43:32 +0000
@@ -30,7 +30,7 @@
 
     def test_keyboard_types_correct_characters(self):
         """Verify that the keyboard.type method types what we expect."""
-        self.start_app_window('Terminal')
+        self.process_manager.start_app_window('Terminal')
         filename = mktemp()
         self.keyboard.type('''python -c "open('%s','w').write(raw_input())"''' % filename)
         self.keyboard.press_and_release('Enter')
@@ -46,7 +46,7 @@
         expect.
 
         """
-        self.start_app_window('Terminal')
+        self.process_manager.start_app_window('Terminal')
         filename = mktemp()
         self.keyboard.type('''python -c "open('%s','w').write(raw_input())"''' % filename)
         self.keyboard.press_and_release('Enter')

=== modified file 'autopilot/tests/test_mouse_emulator.py'
--- autopilot/tests/test_mouse_emulator.py	2013-02-28 04:16:14 +0000
+++ autopilot/tests/test_mouse_emulator.py	2013-04-15 21:43:32 +0000
@@ -10,7 +10,7 @@
 from testtools.matchers import Equals, raises
 from mock import patch
 
-from autopilot.emulators.input import get_mouse
+from autopilot.input import Mouse
 
 class Empty(object):
     pass
@@ -31,7 +31,7 @@
 
     def setUp(self):
         super(MouseEmulatorTests, self).setUp()
-        self.mouse = get_mouse()
+        self.mouse = Mouse.create()
 
     def tearDown(self):
         super(MouseEmulatorTests, self).tearDown()

=== modified file 'autopilot/tests/test_open_window.py'
--- autopilot/tests/test_open_window.py	2012-07-08 23:29:30 +0000
+++ autopilot/tests/test_open_window.py	2013-04-15 21:43:32 +0000
@@ -11,23 +11,24 @@
 from testtools.matchers import Equals
 
 from autopilot.testcase import AutopilotTestCase
+from autopilot.process import ProcessManager
 import logging
 logger = logging.getLogger(__name__)
 
 
 class OpenWindowTests(AutopilotTestCase):
 
-    scenarios = [(k, {'app_name': k}) for k in AutopilotTestCase.KNOWN_APPS.iterkeys()]
+    scenarios = [(k, {'app_name': k}) for k in ProcessManager.KNOWN_APPS.iterkeys()]
 
     def test_open_window(self):
         """self.start_app_window must open a new window of the given app."""
-        existing_apps = self.get_app_instances(self.app_name)
+        existing_apps = self.process_manager.get_app_instances(self.app_name)
         old_wins = []
         for app in existing_apps:
             old_wins.extend(app.get_windows())
         logger.debug("Old windows: %r", old_wins)
 
-        win = self.start_app_window(self.app_name)
+        win = self.process_manager.start_app_window(self.app_name)
         logger.debug("New window: %r", win)
         is_new = win.x_id not in [w.x_id for w in old_wins]
         self.assertThat(is_new, Equals(True))

=== added file 'autopilot/tests/test_out_of_test_addcleanup.py'
--- autopilot/tests/test_out_of_test_addcleanup.py	1970-01-01 00:00:00 +0000
+++ autopilot/tests/test_out_of_test_addcleanup.py	2013-04-15 21:43:32 +0000
@@ -0,0 +1,34 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2013 Canonical
+# Author: Thomi Richards
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+from testtools import TestCase
+from testtools.matchers import Equals
+
+from autopilot.testcase import AutopilotTestCase
+from autopilot.utilities import addCleanup
+
+log = ''
+
+class AddCleanupTests(TestCase):
+
+    def test_addCleanup_called_with_args_and_kwargs(self):
+        """Test that out-of-test addClenaup works as expected, and is passed both
+        args and kwargs.
+
+        """
+        class InnerTest(AutopilotTestCase):
+            def write_to_log(self, *args, **kwargs):
+                global log
+                log = "Hello %r %r" % (args, kwargs)
+
+            def test_foo(self):
+                addCleanup(self.write_to_log, "arg1", 2, foo='bar')
+
+        InnerTest('test_foo').run()
+        self.assertThat(log, Equals("Hello ('arg1', 2) {'foo': 'bar'}"))
+

=== added file 'autopilot/tests/test_platform.py'
--- autopilot/tests/test_platform.py	1970-01-01 00:00:00 +0000
+++ autopilot/tests/test_platform.py	2013-04-15 21:43:32 +0000
@@ -0,0 +1,134 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2013 Canonical
+# Author: Thomi Richards
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+"Tests for the autopilot platform code."
+
+import autopilot.platform as platform
+
+from StringIO import StringIO
+from testtools import TestCase
+from testtools.matchers import Equals
+
+from mock import patch
+
+class PlatformDetectorTests(TestCase):
+
+    def tearDown(self):
+        super(PlatformDetectorTests, self).tearDown()
+        # platform detector is cached, so destroy the cache at the end of each
+        # test:
+        platform._PlatformDetector._cached_detector = None
+
+    def test_platform_detector_is_cached(self):
+        """Test that the platform detector is only created once."""
+        detector1 = platform._PlatformDetector.create()
+        detector2 = platform._PlatformDetector.create()
+        self.assertThat(id(detector1), Equals(id(detector2)))
+
+    @patch('autopilot.platform._get_property_file')
+    def test_default_model(self, mock_get_property_file):
+        """The default model name must be 'Desktop'."""
+        mock_get_property_file.return_value = None
+
+        detector = platform._PlatformDetector.create()
+        self.assertThat(detector.model, Equals('Desktop'))
+
+    @patch('autopilot.platform._get_property_file')
+    def test_default_image_codename(self, mock_get_property_file):
+        """The default image codename must be 'Desktop'."""
+        mock_get_property_file.return_value = None
+
+        detector = platform._PlatformDetector.create()
+        self.assertThat(detector.image_codename, Equals('Desktop'))
+
+    @patch('autopilot.platform._get_property_file')
+    def test_model_is_set_from_property_file(self, mock_get_property_file):
+        """Detector must read product model from android properties file."""
+        mock_get_property_file.return_value = StringIO("ro.product.model=test123")
+
+        detector = platform._PlatformDetector.create()
+        self.assertThat(detector.model, Equals('test123'))
+
+    @patch('autopilot.platform._get_property_file', new=lambda: StringIO(""))
+    def test_model_has_default_when_not_in_property_file(self):
+        """Detector must use 'Desktop' as a default value for the model name
+        when the property file exists, but does not contain a model description.
+
+        """
+        detector = platform._PlatformDetector.create()
+        self.assertThat(detector.model, Equals('Desktop'))
+
+    @patch('autopilot.platform._get_property_file')
+    def test_product_codename_is_set_from_property_file(self, mock_get_property_file):
+        """Detector must read product model from android properties file."""
+        mock_get_property_file.return_value = StringIO("ro.product.name=test123")
+
+        detector = platform._PlatformDetector.create()
+        self.assertThat(detector.image_codename, Equals('test123'))
+
+    @patch('autopilot.platform._get_property_file', new=lambda: StringIO(""))
+    def test_product_codename_has_default_when_not_in_property_file(self):
+        """Detector must use 'Desktop' as a default value for the product codename
+        when the property file exists, but does not contain a model description.
+
+        """
+        detector = platform._PlatformDetector.create()
+        self.assertThat(detector.image_codename, Equals('Desktop'))
+
+
+class BuildPropertyParserTests(TestCase):
+
+    """Tests for the android build properties file parser."""
+
+    def test_empty_file_returns_empty_dictionary(self):
+        """An empty file must result in an empty dictionary."""
+        prop_file = StringIO("")
+        properties = platform._parse_build_properties_file(prop_file)
+        self.assertThat(len(properties), Equals(0))
+
+    def test_whitespace_is_ignored(self):
+        """Whitespace in build file must be ignored."""
+        prop_file = StringIO("\n\n\n\n\n")
+        properties = platform._parse_build_properties_file(prop_file)
+        self.assertThat(len(properties), Equals(0))
+
+    def test_comments_are_ignored(self):
+        """Comments in build file must be ignored."""
+        prop_file = StringIO("# Hello World\n #Hello Again\n#####")
+        properties = platform._parse_build_properties_file(prop_file)
+        self.assertThat(len(properties), Equals(0))
+
+    def test_invalid_lines_are_ignored(self):
+        """lines without ana ssignment must be ignored."""
+        prop_file = StringIO("Hello")
+        properties = platform._parse_build_properties_file(prop_file)
+        self.assertThat(len(properties), Equals(0))
+
+    def test_simple_value(self):
+        """Test a simple a=b expression."""
+        prop_file = StringIO("a=b")
+        properties = platform._parse_build_properties_file(prop_file)
+        self.assertThat(properties, Equals(dict(a='b')))
+
+    def test_multiple_values(self):
+        """Test several expressions over multiple lines."""
+        prop_file = StringIO("a=b\nb=23")
+        properties = platform._parse_build_properties_file(prop_file)
+        self.assertThat(properties, Equals(dict(a='b',b='23')))
+
+    def test_values_with_equals_in_them(self):
+        """Test that we can parse values with a '=' in them."""
+        prop_file = StringIO("a=b=c")
+        properties = platform._parse_build_properties_file(prop_file)
+        self.assertThat(properties, Equals(dict(a='b=c')))
+
+    def test_dotted_values_work(self):
+        """Test that we can use dotted values as the keys."""
+        prop_file = StringIO("ro.product.model=maguro")
+        properties = platform._parse_build_properties_file(prop_file)
+        self.assertThat(properties, Equals({'ro.product.model':'maguro'}))

=== renamed file 'autopilot/tests/test_bamf_emulator.py' => 'autopilot/tests/test_process_emulator.py'
--- autopilot/tests/test_bamf_emulator.py	2013-01-06 21:39:32 +0000
+++ autopilot/tests/test_process_emulator.py	2013-04-15 21:43:32 +0000
@@ -15,11 +15,11 @@
 from time import sleep, time
 
 
-class BamfEmulatorTests(AutopilotTestCase):
+class ProcessEmulatorTests(AutopilotTestCase):
 
     def ensure_gedit_not_running(self):
         """Close any open gedit applications."""
-        apps = self.bamf.get_running_applications_by_desktop_file('gedit.desktop')
+        apps = self.process_manager.get_running_applications_by_desktop_file('gedit.desktop')
         if apps:
             # this is a bit brutal, but easier in this context than the alternative.
             call(['killall', 'gedit'])
@@ -34,7 +34,7 @@
         start = time()
         t = Thread(target=start_gedit())
         t.start()
-        ret = self.bamf.wait_until_application_is_running('gedit.desktop', 10)
+        ret = self.process_manager.wait_until_application_is_running('gedit.desktop', 10)
         end = time()
         t.join()
 
@@ -46,7 +46,7 @@
         self.ensure_gedit_not_running()
 
         start = time()
-        ret = self.bamf.wait_until_application_is_running('gedit.desktop', 5)
+        ret = self.process_manager.wait_until_application_is_running('gedit.desktop', 5)
         end = time()
 
         self.assertThat(abs(end - start - 5.0), LessThan(1))

=== modified file 'autopilot/utilities.py'
--- autopilot/utilities.py	2013-03-03 21:21:08 +0000
+++ autopilot/utilities.py	2013-04-15 21:43:32 +0000
@@ -14,103 +14,26 @@
 
 from __future__ import absolute_import
 
+import inspect
 import logging
 import os
-import sys
 import time
 from functools import wraps
-from Xlib import X, display, protocol
-
-_display = None
-
-def get_display():
-    """Get a Xlib display object. Creating the display prints garbage to stdout."""
-    global _display
-    if _display is None:
-        with Silence():
-            _display = display.Display()
-    return _display
-
-
-
-def make_window_skip_taskbar(window, set_flag=True):
-    """Set the skip-taskbar kint on an X11 window.
-
-    'window' should be an Xlib window object.
-    set_flag should be 'True' to set the flag, 'False' to clear it.
-
-    """
-    state = get_display().get_atom('_NET_WM_STATE_SKIP_TASKBAR', 1)
-    action = int(set_flag)
-    if action == 0:
-        print "Clearing flag"
-    elif action == 1:
-        print "Setting flag"
-    _setProperty('_NET_WM_STATE', [action, state, 0, 1], window)
-    get_display().sync()
-
-
-def get_desktop_viewport():
-    """Get the x,y coordinates for the current desktop viewport top-left corner."""
-    return _getProperty('_NET_DESKTOP_VIEWPORT')
-
-
-def get_desktop_geometry():
-    """Get the full width and height of the desktop, including all the viewports."""
-    return _getProperty('_NET_DESKTOP_GEOMETRY')
-
-
-def _setProperty(_type, data, win=None, mask=None):
-    """ Send a ClientMessage event to a window"""
-    if not win:
-        win = get_display().screen().root
-    if type(data) is str:
-        dataSize = 8
-    else:
-        # data length must be 5 - pad with 0's if it's short, truncate otherwise.
-        data = (data + [0] * (5 - len(data)))[:5]
-        dataSize = 32
-
-    ev = protocol.event.ClientMessage(window=win,
-        client_type=get_display().get_atom(_type),
-        data=(dataSize, data))
-
-    if not mask:
-        mask = (X.SubstructureRedirectMask | X.SubstructureNotifyMask)
-    get_display().screen().root.send_event(ev, event_mask=mask)
-
-
-def _getProperty(_type, win=None):
-    if not win:
-        win = get_display().screen().root
-    atom = win.get_full_property(get_display().get_atom(_type), X.AnyPropertyType)
-    if atom: return atom.value
-
-
-def get_compiz_setting(plugin_name, setting_name):
-    """Get a compiz setting object.
-
-    'plugin_name' is the name of the plugin (e.g. 'core' or 'unityshell')
-    'setting_name' is the name of the setting (e.g. 'alt_tab_timeout')
-
-    This function will raise KeyError if the plugin or setting named does not
-    exist.
-
-    """
-    # circular dependancy:
-    from autopilot.compizconfig import get_setting
-    return get_setting(plugin_name, setting_name)
-
-
-def get_compiz_option(plugin_name, setting_name):
-    """Get a compiz setting value.
-
-    This is the same as calling:
-
-    >>> get_compiz_setting(plugin_name, setting_name).Value
-
-    """
-    return get_compiz_setting(plugin_name, setting_name).Value
+
+
+def _pick_variant(variants, preferred_variant):
+    possible_backends = variants.keys()
+    get_debug_logger().debug("Possible variants: %s", ','.join(possible_backends))
+    if preferred_variant in possible_backends:
+        possible_backends.sort(lambda a,b: -1 if a == preferred_variant else 0)
+    failure_reasons = []
+    for be in possible_backends:
+        try:
+            return variants[be]()
+        except Exception as e:
+            get_debug_logger().warning("Can't create variant %s: %r", be, e)
+            failure_reasons.append('%s: %r' % (be, e))
+    raise RuntimeError("Unable to instantiate any backends\n%s" % '\n'.join(failure_reasons))
 
 
 # Taken from http://code.activestate.com/recipes/577564-context-manager-for-low-level-redirection-of-stdou/
@@ -226,7 +149,33 @@
     def fdec(fn):
         @wraps(fn)
         def wrapped(*args, **kwargs):
-            sys.stderr.write("WARNING: This function is deprecated. Please use '%s' instead.\n" % alternative)
+            import sys
+            outerframe_details = inspect.getouterframes(inspect.currentframe())[1]
+            filename, line_number, function_name = outerframe_details[1:4]
+            sys.stderr.write("WARNING: in file \"{0}\", line {1} in {2}\n".format(filename, line_number, function_name))
+            sys.stderr.write("This function is deprecated. Please use '%s' instead.\n" % alternative)
             return fn(*args, **kwargs)
         return wrapped
     return fdec
+
+
+class _CleanupWrapper(object):
+    """Support for calling 'addCleanup' outside the test case."""
+
+    def __init__(self):
+        self._test_instance = None
+
+    def __call__(self, callable, *args, **kwargs):
+        if self._test_instance is None:
+            raise RuntimeError("Out-of-test addCleanup can only be called while an autopilot test case is running!")
+        self._test_instance.addCleanup(callable, *args, **kwargs)
+
+    def set_test_instance(self, test_instance):
+        self._test_instance = test_instance
+        test_instance.addCleanup(self._on_test_ended)
+
+    def _on_test_ended(self):
+        self._test_instance = None
+
+
+addCleanup = _CleanupWrapper()

=== modified file 'bin/autopilot'
--- bin/autopilot	2013-02-21 02:37:04 +0000
+++ bin/autopilot	2013-04-15 21:43:32 +0000
@@ -27,13 +27,13 @@
 from argparse import ArgumentParser
 from unittest.loader import TestLoader
 from unittest import TestSuite
-from autopilot.introspection.gtk import GtkIntrospectionTestMixin
-from autopilot.introspection.qt import QtIntrospectionTestMixin
+from autopilot.introspection import launch_application
+from autopilot.introspection.gtk import GtkApplicationLauncher
+from autopilot.introspection.qt import QtApplicationLauncher
 
 # list autopilot depends here, with the form:
 # ('python module name', 'ubuntu package name'),
 DEPENDS = [
-    ('compizconfig', 'python-compizconfig'),
     ('dbus', 'python-dbus'),
     ('gi.repository.GConf', 'gir1.2-gconf-2.0'),
     ('gi.repository.IBus', 'gir1.2-ibus-1.0'),
@@ -345,27 +345,19 @@
             exit(1)
 
     # We now have a full path to the application.
-    IntrospectionBase = None
+    launcher = None
     if args.interface == 'Auto':
-        IntrospectionBase = get_application_introspection_base(app_name)
+        launcher = get_application_introspection_base(app_name)
     elif args.interface == 'Gtk':
-        IntrospectionBase = GtkIntrospectionTestMixin
+        launcher = GtkApplicationLauncher()
     elif args.interface == 'Qt':
-        IntrospectionBase = QtIntrospectionTestMixin
-    if IntrospectionBase is None:
+        launcher = QtApplicationLauncher()
+    if launcher is None:
         print "Error: Could not determine introspection type to use for application '%s'." % app_name
         exit(1)
 
-    # IntrospectionBase is supposed to be a mixin class with a TestCase, and makes
-    # use of addCleanup to shut down the app after the test has completed. We
-    # patch that function here so we don't error...
-    def fake_cleanup(self, *args, **kwargs):
-        pass
-    IntrospectionBase.addCleanup = fake_cleanup
-
-    b = IntrospectionBase()
     try:
-        b.launch_test_application(app_name, capture_output=False)
+        launch_application(launcher, app_name, capture_output=False)
     except RuntimeError as e:
         print "Error: " + e.message
         exit(1)
@@ -387,9 +379,9 @@
         print "Use the '-i' argument to specify an interface."
         exit(1)
     if 'libqtcore' in ldd_output:
-        return QtIntrospectionTestMixin
+        return QtApplicationLauncher
     elif 'libgtk' in ldd_output:
-        return GtkIntrospectionTestMixin
+        return GtkApplicationLauncher
     return None
 
 

=== modified file 'debian/changelog'
--- debian/changelog	2013-03-26 00:02:00 +0000
+++ debian/changelog	2013-04-15 21:43:32 +0000
@@ -1,3 +1,9 @@
+autopilot (1.3) UNRELEASED; urgency=low
+
+  * Create version 1.3 (LP: #1168971)
+
+ -- Thomi Richards <[e-mail]>  Mon, 15 Apr 2013 09:33:21 +1200
+
 autopilot (1.2daily13.03.26-0ubuntu1) raring; urgency=low
 
   * Automatic snapshot from revision 155

=== modified file 'debian/control'
--- debian/control	2012-12-04 11:43:20 +0000
+++ debian/control	2013-04-15 21:43:32 +0000
@@ -9,6 +9,7 @@
                gir1.2-gtk-2.0,
                python (>= 2.6),
                python-dbus,
+               python-debian,
                python-setuptools,
                python-sphinx,
                python-testtools,
@@ -28,7 +29,6 @@
          gir1.2-glib-2.0,
          gir1.2-gtk-2.0,
          gir1.2-ibus-1.0,
-         python-compizconfig,
          python-dbus,
          python-junitxml,
          python-qt4,

=== added file 'docs/_templates/indexcontent.html'
--- docs/_templates/indexcontent.html	1970-01-01 00:00:00 +0000
+++ docs/_templates/indexcontent.html	2013-04-15 21:43:32 +0000
@@ -0,0 +1,45 @@
+{% extends "defindex.html" %}
+{% block tables %}
+<p>Autopilot is a tool for writing <i>functional tests</i> for <i>GUI</i> applications. It works out-of-the-box for Several GUI toolkits, including Gtk2, Gtk3, Qt4, and Qt5/Qml.</p>
+  <p><strong>Parts of the documentation:</strong></p>
+  <table class="contentstable" align="center">
+    <tr>
+      <td width="50%">
+        <p class="biglink">
+          <a class="biglink" href="{{ pathto("tutorial/tutorial") }}">Getting started with Autopilot</a><br/>
+          <span class="linkdescr">How to write your first Autopilot test.</span>
+        </p>
+      </td>
+      <td width="50%">
+        <p class="biglink">
+          <a class="biglink" href="{{ pathto("api/autopilot") }}">API Reference</a><br/>
+          <span class="linkdescr">API reference documentation for Autopilot.</span>
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <p class="biglink">
+          <a class="biglink" href="{{ pathto("faq/faq") }}">Frequently Asked Questions</a><br/>
+          <span class="linkdescr">...with answers!</span>
+        </p>
+      </td>
+      <td>
+        <p class="biglink">
+          <a class="biglink" href="{{ pathto("porting/porting") }}">Porting Autopilot Tests</a><br/>
+          <span class="linkdescr">How to port your tests from earlier versions of Autopilot.</span>
+        </p>
+      </td>
+    </tr>
+  </table>
+
+  <p><strong>Indices and tables:</strong></p>
+  <table class="contentstable" align="center"><tr>
+    <td width="50%">
+      <p class="biglink"><a class="biglink" href="{{ pathto("py-modindex") }}">Module Index</a><br/>
+         <span class="linkdescr">quick access to all modules</span></p>
+{#      <p class="biglink"><a class="biglink" href="{{ pathto("contents") }}">Complete Table of Contents</a><br/>
+         <span class="linkdescr">lists all sections and subsections</span></p> #}
+    </td></tr>
+  </table>
+{% endblock %}

=== modified file 'docs/api/autopilot.rst'
--- docs/api/autopilot.rst	2013-02-28 01:01:11 +0000
+++ docs/api/autopilot.rst	2013-04-15 21:43:32 +0000
@@ -1,103 +1,10 @@
+:orphan:
+
 Autopilot API Documentation
 ===========================
 
-Autopilot Utility Modules
-+++++++++++++++++++++++++
-
-:mod:`testcase` Module
-----------------------
-
-.. autoclass:: autopilot.testcase.AutopilotTestCase
-    :members:
-
-.. autofunction:: autopilot.testcase.multiply_scenarios
-
-:mod:`keybindings` Module
--------------------------
-
-.. automodule:: autopilot.keybindings
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-Emulators Package
-+++++++++++++++++
-
-:mod:`input` Module
--------------------
-
-.. automodule:: autopilot.emulators.input
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-:mod:`bamf` Module
-------------------
-
-.. automodule:: autopilot.emulators.bamf
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-:mod:`ibus` Module
-------------------
-
-.. automodule:: autopilot.emulators.ibus
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-:mod:`zeitgeist` Module
------------------------
-
-.. automodule:: autopilot.emulators.zeitgeist
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-Introspection Package
-+++++++++++++++++++++
-
-:mod:`introspection` Package
-----------------------------
-
-.. automodule:: autopilot.introspection
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-:mod:`dbus` Module
--------------------
-
-.. automodule:: autopilot.introspection.dbus
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-:mod:`qt` Module
--------------------
-
-.. automodule:: autopilot.introspection.qt
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-:mod:`gtk` Module
--------------------
-
-.. automodule:: autopilot.introspection.gtk
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-Matchers Package
-++++++++++++++++
-
-:mod:`matchers` Package
------------------------
-
-.. automodule:: autopilot.matchers
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
+.. toctree::
+   :maxdepth: 1
+   :glob:
+
+   *

=== added file 'docs/api/display.rst'
--- docs/api/display.rst	1970-01-01 00:00:00 +0000
+++ docs/api/display.rst	2013-04-15 21:43:32 +0000
@@ -0,0 +1,7 @@
+``display`` - Get information about the current display(s)
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+
+.. automodule:: autopilot.display
+    :members:
+    :undoc-members:

=== added file 'docs/api/emulators.rst'
--- docs/api/emulators.rst	1970-01-01 00:00:00 +0000
+++ docs/api/emulators.rst	2013-04-15 21:43:32 +0000
@@ -0,0 +1,20 @@
+``emulators`` - Backwards compatibility for autopilot v1.2
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+
+.. module autopilot.emulators
+   :synopsis: Backwards compatibility module to provide the 'emulators' namespace.
+
+
+The emulators module exists for backwards compatibility only.
+
+This module exists to make it easier to upgrade from autopilot v1.2 to v1.3 by
+providing the old 'emulators' namespace. However, it's a bad idea to rely on this
+module continuing to exist. It contains several sub-modules:
+
+ * :mod:`autopilot.display`
+ * autopilot.clipboard (deprecated)
+ * autopilot.dbus_handler (for internal use only)
+ * autopilot.ibus (deprecated)
+ * :mod:`autopilot.input`
+

=== added file 'docs/api/gestures.rst'
--- docs/api/gestures.rst	1970-01-01 00:00:00 +0000
+++ docs/api/gestures.rst	2013-04-15 21:43:32 +0000
@@ -0,0 +1,6 @@
+``gestures`` - Gestural and multi-touch support
++++++++++++++++++++++++++++++++++++++++++++++++
+
+
+.. automodule:: autopilot.gestures
+    :members:

=== added file 'docs/api/input.rst'
--- docs/api/input.rst	1970-01-01 00:00:00 +0000
+++ docs/api/input.rst	2013-04-15 21:43:32 +0000
@@ -0,0 +1,7 @@
+``input`` - Generate keyboard, mouse, and touch input events
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+
+.. automodule:: autopilot.input
+    :members:
+    :undoc-members:

=== added file 'docs/api/introspection.rst'
--- docs/api/introspection.rst	1970-01-01 00:00:00 +0000
+++ docs/api/introspection.rst	2013-04-15 21:43:32 +0000
@@ -0,0 +1,6 @@
+``introspection`` - Autopilot introspection internals