Merge lp:~elopio/autopilot/fix1257055-slow_drag into lp:autopilot

[Leo Arias]

Added Mouse, Touch and Pointer drags with rate.

[lp:~elopio/autopilot/fix1257055-slow_drag]

421. By Leo Arias on 2014-01-19

Updated the copyright years.

422. By Leo Arias on 2014-01-19

Added the rate to the Pointer drag.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:421
http://jenkins.qa.ubuntu.com/job/autopilot-ci/406/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-amd64-ci/132/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-armhf-ci/132/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty/2453/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/2455/console

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

review: Needs Fixing (continuous-integration)

[lp:~elopio/autopilot/fix1257055-slow_drag]

423. By Leo Arias on 2014-01-19

Renamed MockTouch to MockUinputTouch.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:423
http://jenkins.qa.ubuntu.com/job/autopilot-ci/407/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-amd64-ci/133/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-armhf-ci/133/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty/2454/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/2456/console

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

review: Needs Fixing (continuous-integration)

[lp:~elopio/autopilot/fix1257055-slow_drag]

424. By Leo Arias on 2014-01-20

Merged with trunk.

425. By Leo Arias on 2014-01-20

Added python-evdev as a build-dep.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:425
http://jenkins.qa.ubuntu.com/job/autopilot-ci/413/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-amd64-ci/139/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-armhf-ci/139/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty/2480/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/2482/console

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

review: Needs Fixing (continuous-integration)

[Thomi Richards (thomir-deactivatedaccount)]

Hi,

I'm not sure if this MP is still relevant. If it's not, please delete the proposal to merge. If it is, then:

39 - def drag(self, x1, y1, x2, y2):
40 + def drag(self, x1, y1, x2, y2, rate=10):

If you're adding (or removing, or changing) a parameter to a public method, please document it in the docstrings. What exactly is 'rate' measured in anyway?

82 - def drag(self, x1, y1, x2, y2):
83 + def drag(self, x1, y1, x2, y2, rate=10):

You introduce a new parameter, and then don't use it at all in the method.

In general this MP makes me feel rather uneasy. You're introducing a new parameter, and some code changes, and I can't see any justification for it.

If this is really needed, I think it might be worth moving the algorithm to a common location, and making both the X11 and uinput backends be able to use it. That way, you can test it without needing to mock out anything.

Anyway, please talk to me on IRC about this. We need to either clean it up and merge it, or remove it from the review queue.

review: Needs Fixing

[Thomi Richards (thomir-deactivatedaccount)]

Hi,

In order to make our review queue a little more sane, I'm setting this to WIP. If/when you need a new review, please set it back to 'Needs Review', and (optionally) ping someone on the AP team.

Thanks.

[lp:~elopio/autopilot/fix1257055-slow_drag]

426. By Leo Arias on 2014-02-11

Merged with prerequisite branch.

427. By Leo Arias on 2014-02-11

Fixed the imports.

428. By Leo Arias on 2014-02-11

Added comments for the rate parameter.

429. By Leo Arias on 2014-02-11

Updated the tests.

430. By Leo Arias on 2014-02-11

Removed unused import.

431. By Leo Arias on 2014-02-11

Removed extra line.

432. By Leo Arias on 2014-02-11

s/should/must

433. By Leo Arias on 2014-02-11

Added a test with time_between_events.

434. By Leo Arias on 2014-02-11

We can't use the real Mouse, so switch to touch backend for now.

435. By Leo Arias on 2014-02-11

Updated the fake.

Unmerged revisions

=== modified file 'autopilot/input/_X11.py'
--- autopilot/input/_X11.py	2013-11-07 05:53:36 +0000
+++ autopilot/input/_X11.py	2014-02-11 06:39:03 +0000
@@ -1,7 +1,7 @@
 # -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
 #
 # Autopilot Functional Test Tool
-# Copyright (C) 2012-2013 Canonical
+# Copyright (C) 2012, 2013, 2014 Canonical
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -455,7 +455,7 @@
         x, y = coord["root_x"], coord["root_y"]
         return x, y
 
-    def drag(self, x1, y1, x2, y2):
+    def drag(self, x1, y1, x2, y2, rate=10):
         """Performs a press, move and release.
 
         This is to keep a common API between Mouse and Finger as long as
@@ -464,7 +464,7 @@
         """
         self.move(x1, y1)
         self.press()
-        self.move(x2, y2)
+        self.move(x2, y2, rate=rate)
         self.release()
 
     @classmethod

=== modified file 'autopilot/input/__init__.py'
--- autopilot/input/__init__.py	2013-09-20 19:01:27 +0000
+++ autopilot/input/__init__.py	2014-02-11 06:39:03 +0000
@@ -369,7 +369,7 @@
         """
         raise NotImplementedError("You cannot use this class directly.")
 
-    def drag(self, x1, y1, x2, y2):
+    def drag(self, x1, y1, x2, y2, rate=10):
         """Performs a press, move and release.
 
         This is to keep a common API between Mouse and Finger as long as
@@ -466,7 +466,7 @@
         """Release a previously pressed finger"""
         raise NotImplementedError("You cannot use this class directly.")
 
-    def drag(self, x1, y1, x2, y2):
+    def drag(self, x1, y1, x2, y2, rate=10):
         """Perform a drag gesture from (x1,y1) to (x2,y2)"""
         raise NotImplementedError("You cannot use this class directly.")
 
@@ -641,9 +641,9 @@
         else:
             return (self._x, self._y)
 
-    def drag(self, x1, y1, x2, y2):
+    def drag(self, x1, y1, x2, y2, rate=10):
         """Performs a press, move and release."""
-        self._device.drag(x1, y1, x2, y2)
+        self._device.drag(x1, y1, x2, y2, rate=rate)
         if isinstance(self._device, Touch):
             self._x = x2
             self._y = y2

=== modified file 'autopilot/input/_common.py'
--- autopilot/input/_common.py	2013-12-10 03:10:11 +0000
+++ autopilot/input/_common.py	2014-02-11 06:39:03 +0000
@@ -26,8 +26,18 @@
 
 
 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.
+    """Get the center point of an object.
+
+    It searches for several different ways of determining exactly where the
+    center is.
+
+    :raises ValueError: if `object_proxy` has the globalRect attribute but it
+        is not of the correct type.
+    :raises ValueError: if `object_proxy` doesn't have the globalRect
+        attribute, it has the x and y attributes instead, but they are not of
+        the correct type.
+    :raises ValueError: if `object_proxy` doesn't have any recognised position
+        attributes.
 
     """
     try:

=== modified file 'autopilot/input/_uinput.py'
--- autopilot/input/_uinput.py	2013-11-07 05:53:36 +0000
+++ autopilot/input/_uinput.py	2014-02-11 06:39:03 +0000
@@ -1,7 +1,7 @@
 # -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
 #
 # Autopilot Functional Test Tool
-# Copyright (C) 2012-2013 Canonical
+# Copyright (C) 2012, 2013, 2014 Canonical
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -17,27 +17,23 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-
 """UInput device drivers."""
 
+import logging
+import os.path
+
+import six
+from evdev import UInput, ecodes as e
+
+import autopilot.platform
 from autopilot.input import Keyboard as KeyboardBase
 from autopilot.input import Touch as TouchBase
 from autopilot.input._common import get_center_point
-from autopilot.utilities import sleep
-import autopilot.platform
+from autopilot.utilities import deprecated, sleep
 
-import logging
-from evdev import UInput, ecodes as e
-import os.path
-import six
 
 logger = logging.getLogger(__name__)
 
-PRESS = 1
-RELEASE = 0
-
-_PRESSED_KEYS = []
-
 
 def _get_devnode_path():
     """Provide a fallback uinput node for devices which don't support udev"""
@@ -47,13 +43,78 @@
     return devnode
 
 
+class _UInputKeyboardDevice(object):
+    """Wrapper for the UInput Keyboard to execute its primitives."""
+
+    def __init__(self, device_class=UInput):
+        super(_UInputKeyboardDevice, self).__init__()
+        self._device = device_class(devnode=_get_devnode_path())
+        self._pressed_keys_ecodes = []
+
+    def press(self, key):
+        """Press one key button.
+
+        It ignores case, so, for example, 'a' and 'A' are mapped to the same
+        key.
+
+        """
+        ecode = self._get_ecode_for_key(key)
+        logger.debug('Pressing %s (%r).', key, ecode)
+        self._emit_press_event(ecode)
+        self._pressed_keys_ecodes.append(ecode)
+
+    def _get_ecode_for_key(self, key):
+        key_name = key if key.startswith('KEY_') else 'KEY_' + key
+        key_name = key_name.upper()
+        ecode = e.ecodes.get(key_name, None)
+        if ecode is None:
+            raise ValueError('Unknown key name: %s.' % key)
+        return ecode
+
+    def _emit_press_event(self, ecode):
+        press_value = 1
+        self._emit(ecode, press_value)
+
+    def _emit(self, ecode, value):
+        self._device.write(e.EV_KEY, ecode, value)
+        self._device.syn()
+
+    def release(self, key):
+        """Release one key button.
+
+        It ignores case, so, for example, 'a' and 'A' are mapped to the same
+        key.
+
+        :raises ValueError: if ``key`` is not pressed.
+
+        """
+        ecode = self._get_ecode_for_key(key)
+        if ecode in self._pressed_keys_ecodes:
+            logger.debug('Releasing %s (%r).', key, ecode)
+            self._emit_release_event(ecode)
+            self._pressed_keys_ecodes.remove(ecode)
+        else:
+            raise ValueError('Key %r not pressed.' % key)
+
+    def _emit_release_event(self, ecode):
+        release_value = 0
+        self._emit(ecode, release_value)
+
+    def release_pressed_keys(self):
+        """Release all the keys that are currently pressed."""
+        for ecode in self._pressed_keys_ecodes:
+            self._emit_release_event(ecode)
+        self._pressed_keys_ecodes = []
+
+
 class Keyboard(KeyboardBase):
 
-    _device = UInput(devnode=_get_devnode_path())
+    _device = None
 
-    def _emit(self, event, value):
-        Keyboard._device.write(e.EV_KEY, event, value)
-        Keyboard._device.syn()
+    def __init__(self, device_class=_UInputKeyboardDevice):
+        super(Keyboard, self).__init__()
+        if Keyboard._device is None:
+            Keyboard._device = device_class()
 
     def _sanitise_keys(self, keys):
         if keys == '+':
@@ -71,15 +132,15 @@
 
         presses the 'Alt' and 'F2' keys.
 
+        :raises TypeError: if ``keys`` is not a string.
+
         """
         if not isinstance(keys, six.string_types):
             raise TypeError("'keys' argument must be a string.")
 
         for key in self._sanitise_keys(keys):
-            for event in Keyboard._get_events_for_key(key):
-                logger.debug("Pressing %s (%r)", key, event)
-                _PRESSED_KEYS.append(event)
-                self._emit(event, PRESS)
+            for key_button in self._get_key_buttons(key):
+                self._device.press(key_button)
                 sleep(delay)
 
     def release(self, keys, delay=0.1):
@@ -94,16 +155,16 @@
 
         Keys are released in the reverse order in which they are specified.
 
+        :raises TypeError: if ``keys`` is not a string.
+        :raises ValueError: if one of the keys to be released is not pressed.
+
         """
         if not isinstance(keys, six.string_types):
             raise TypeError("'keys' argument must be a string.")
 
         for key in reversed(self._sanitise_keys(keys)):
-            for event in Keyboard._get_events_for_key(key):
-                logger.debug("Releasing %s (%r)", key, event)
-                if event in _PRESSED_KEYS:
-                    _PRESSED_KEYS.remove(event)
-                self._emit(event, RELEASE)
+            for key_button in reversed(self._get_key_buttons(key)):
+                self._device.release(key_button)
                 sleep(delay)
 
     def press_and_release(self, keys, delay=0.1):
@@ -118,6 +179,8 @@
 
         presses both the 'Alt' and 'F2' keys, and then releases both keys.
 
+        :raises TypeError: if ``keys`` is not a string.
+
         """
         logger.debug("Pressing and Releasing: %s", keys)
         self.press(keys, delay)
@@ -129,6 +192,8 @@
         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').
 
+        :raises TypeError: if ``keys`` is not a string.
+
         """
         if not isinstance(string, six.string_types):
             raise TypeError("'keys' argument must be a string.")
@@ -145,98 +210,35 @@
         any keys that were pressed and not released.
 
         """
-        global _PRESSED_KEYS
-        if len(_PRESSED_KEYS) == 0:
-            return
-
-        def _release(event):
-            Keyboard._device.write(e.EV_KEY, event, RELEASE)
-            Keyboard._device.syn()
-        for event in _PRESSED_KEYS:
-            logger.warning("Releasing key %r as part of cleanup call.", event)
-            _release(event)
-        _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
+        if cls._device is not None:
+            cls._device.release_pressed_keys()
+
+    def _get_key_buttons(self, key):
+        """Return a list of the key buttons required to press.
+
+        Multiple buttons will be returned when the key specified requires more
         than one keypress to generate (for example, upper-case letters).
 
         """
-        events = []
+        key_buttons = []
         if key.isupper() or key in _SHIFTED_KEYS:
-            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
-
-
+            key_buttons.append('KEY_LEFTSHIFT')
+        key_name = _UINPUT_CODE_TRANSLATIONS.get(key.upper(), key)
+        key_buttons.append(key_name)
+        return key_buttons
+
+
+@deprecated('the Touch class to instantiate a device object')
 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 the system.
 
     """
-
-    if res_x is None or res_y is None:
-        from autopilot.display import Display
-        display = Display.create()
-        # TODO: This calculation needs to become part of the display module:
-        l = r = t = b = 0
-        for screen in range(display.get_num_screens()):
-            geometry = display.get_screen_geometry(screen)
-            if geometry[0] < l:
-                l = geometry[0]
-            if geometry[1] < t:
-                t = geometry[1]
-            if geometry[0] + geometry[2] > r:
-                r = geometry[0] + geometry[2]
-            if geometry[1] + geometry[3] > b:
-                b = geometry[1] + geometry[3]
-        res_x = r - l
-        res_y = b - t
-
-    # 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, (0, res_x, 0, 0)),
-            (e.ABS_Y, (0, res_y, 0, 0)),
-            (e.ABS_PRESSURE, (0, 65535, 0, 0)),
-            (e.ABS_MT_POSITION_X, (0, res_x, 0, 0)),
-            (e.ABS_MT_POSITION_Y, (0, res_y, 0, 0)),
-            (e.ABS_MT_TOUCH_MAJOR, (0, 30, 0, 0)),
-            (e.ABS_MT_TRACKING_ID, (0, 65535, 0, 0)),
-            (e.ABS_MT_PRESSURE, (0, 255, 0, 0)),
-            (e.ABS_MT_SLOT, (0, 9, 0, 0)),
-        ],
-        e.EV_KEY: [
-            touch_tool,
-        ]
-    }
-
-    return UInput(cap_mt, name='autopilot-finger', version=0x2,
-                  devnode=_get_devnode_path())
-
-_touch_device = create_touch_device()
+    return UInput(events=_get_touch_events(res_x, res_y),
+                  name='autopilot-finger',
+                  version=0x2, devnode=_get_devnode_path())
+
 
 # Multiouch notes:
 # ----------------
@@ -281,143 +283,277 @@
 # 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)
+
+def _get_touch_events(res_x=None, res_y=None):
+    if res_x is None or res_y is None:
+        res_x, res_y = _get_system_resolution()
+
+    touch_tool = _get_touch_tool()
+
+    events = {
+        e.EV_ABS: [
+            (e.ABS_X, (0, res_x, 0, 0)),
+            (e.ABS_Y, (0, res_y, 0, 0)),
+            (e.ABS_PRESSURE, (0, 65535, 0, 0)),
+            (e.ABS_MT_POSITION_X, (0, res_x, 0, 0)),
+            (e.ABS_MT_POSITION_Y, (0, res_y, 0, 0)),
+            (e.ABS_MT_TOUCH_MAJOR, (0, 30, 0, 0)),
+            (e.ABS_MT_TRACKING_ID, (0, 65535, 0, 0)),
+            (e.ABS_MT_PRESSURE, (0, 255, 0, 0)),
+            (e.ABS_MT_SLOT, (0, 9, 0, 0)),
+        ],
+        e.EV_KEY: [
+            touch_tool,
+        ]
+    }
+    return events
+
+
+def _get_system_resolution():
+    from autopilot.display import Display
+    display = Display.create()
+    # TODO: This calculation needs to become part of the display module:
+    l = r = t = b = 0
+    for screen in range(display.get_num_screens()):
+        geometry = display.get_screen_geometry(screen)
+        if geometry[0] < l:
+            l = geometry[0]
+        if geometry[1] < t:
+            t = geometry[1]
+        if geometry[0] + geometry[2] > r:
+            r = geometry[0] + geometry[2]
+        if geometry[1] + geometry[3] > b:
+            b = geometry[1] + geometry[3]
+    res_x = r - l
+    res_y = b - t
+    return res_x, res_y
+
+
+def _get_touch_tool():
+    # android uses BTN_TOOL_FINGER, whereas desktop uses BTN_TOUCH. I have
+    # no idea why...
+    if autopilot.platform.model() == 'Desktop':
+        touch_tool = e.BTN_TOUCH
+    else:
+        touch_tool = e.BTN_TOOL_FINGER
+    return touch_tool
+
+
+class _UInputTouchDevice(object):
+    """Wrapper for the UInput Touch to execute its primitives."""
+
+    _device = None
+    _touch_fingers_in_use = []
+    _last_tracking_id = 0
+
+    def __init__(self, res_x=None, res_y=None, device_class=UInput):
+        """Class constructor.
+
+        If res_x and res_y are not specified, they will be queried from the
+        system.
+
+        """
+        super(_UInputTouchDevice, self).__init__()
+        if _UInputTouchDevice._device is None:
+            _UInputTouchDevice._device = device_class(
+                events=_get_touch_events(res_x, res_y),
+                name='autopilot-finger',
+                version=0x2, devnode=_get_devnode_path())
+        self._touch_finger_slot = None
+
+    @property
+    def pressed(self):
+        return self._touch_finger_slot is not None
+
+    def finger_down(self, x, y):
+        """Internal: moves finger "finger" down on the touchscreen.
+
+        :param x: The finger will be moved to this x coordinate.
+        :param y: The finger will be moved to this y coordinate.
+
+        :raises RuntimeError: if the finger is already pressed.
+        :raises RuntimeError: if no more touch slots are available.
+
+        """
+        if self.pressed:
+            raise RuntimeError("Cannot press finger: it's already pressed.")
+        self._touch_finger_slot = self._get_free_touch_finger_slot()
+
+        self._device.write(e.EV_ABS, e.ABS_MT_SLOT, self._touch_finger_slot)
+        self._device.write(
+            e.EV_ABS, e.ABS_MT_TRACKING_ID, self._get_next_tracking_id())
+        press_value = 1
+        self._device.write(e.EV_KEY, e.BTN_TOOL_FINGER, press_value)
+        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.write(e.EV_ABS, e.ABS_MT_PRESSURE, 400)
+        self._device.syn()
+
+    def _get_free_touch_finger_slot(self):
+        """Return the id of a free touch finger.
+
+        :raises RuntimeError: if no more touch slots are available.
+
+        """
+        max_number_of_fingers = 9
+        for i in range(max_number_of_fingers):
+            if i not in _UInputTouchDevice._touch_fingers_in_use:
+                _UInputTouchDevice._touch_fingers_in_use.append(i)
+                return i
+        raise RuntimeError('All available fingers have been used already.')
+
+    def _get_next_tracking_id(self):
+        _UInputTouchDevice._last_tracking_id += 1
+        return _UInputTouchDevice._last_tracking_id
+
+    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.
+
+        :raises RuntimeError: if the finger is not pressed.
+
+        """
+        if not self.pressed:
+            raise RuntimeError('Attempting to move without finger being down.')
+        self._device.write(e.EV_ABS, e.ABS_MT_SLOT, self._touch_finger_slot)
+        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):
+        """Internal: moves finger "finger" up from the touchscreen
+
+        :raises RuntimeError: if the finger is not pressed.
+
+        """
+        if not self.pressed:
+            raise RuntimeError("Cannot release finger: it's not pressed.")
+        self._device.write(e.EV_ABS, e.ABS_MT_SLOT, self._touch_finger_slot)
+        lift_tracking_id = -1
+        self._device.write(e.EV_ABS, e.ABS_MT_TRACKING_ID, lift_tracking_id)
+        release_value = 0
+        self._device.write(e.EV_KEY, e.BTN_TOOL_FINGER, release_value)
+        self._device.syn()
+        self._release_touch_finger()
+
+    def _release_touch_finger(self):
+        """Release the touch finger.
+
+        :raises RuntimeError: if the finger was not claimed before or was
+            already released.
+
+        """
+        if (self._touch_finger_slot not in
+                _UInputTouchDevice._touch_fingers_in_use):
+            raise RuntimeError(
+                "Finger %d was never claimed, or has already been released." %
+                self._touch_finger_slot)
+        _UInputTouchDevice._touch_fingers_in_use.remove(
+            self._touch_finger_slot)
+        self._touch_finger_slot = None
 
 
 class Touch(TouchBase):
     """Low level interface to generate single finger touch events."""
 
-    def __init__(self):
+    def __init__(self, device_class=_UInputTouchDevice):
         super(Touch, self).__init__()
-        self._touch_finger = None
+        self._device = device_class()
 
     @property
     def pressed(self):
-        return self._touch_finger is not None
+        return self._device.pressed
 
     def tap(self, x, y):
-        """Click (or 'tap') at given x and y coordinates."""
+        """Click (or 'tap') at given x and y coordinates.
+
+        :raises RuntimeError: if the finger is already pressed.
+        :raises RuntimeError: if no more finger slots are available.
+
+        """
         logger.debug("Tapping at: %d,%d", x, y)
-        self._finger_down(x, y)
+        self._device.finger_down(x, y)
         sleep(0.1)
-        self._finger_up()
-
-    def tap_object(self, object):
-        """Click (or 'tap') a given object"""
+        self._device.finger_up()
+
+    def tap_object(self, object_):
+        """Click (or 'tap') a given object.
+
+        :raises RuntimeError: if the finger is already pressed.
+        :raises RuntimeError: if no more finger slots are available.
+        :raises ValueError: if `object_` doesn't have any recognised position
+            attributes or if they are not of the correct type.
+
+        """
         logger.debug("Tapping object: %r", object)
-        x, y = get_center_point(object)
+        x, y = get_center_point(object_)
         self.tap(x, y)
 
     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"""
+        """Press and hold a given object or at the given coordinates.
+
+        Call release() when the object has been pressed long enough.
+
+        :raises RuntimeError: if the finger is already pressed.
+        :raises RuntimeError: if no more finger slots are available.
+
+        """
         logger.debug("Pressing at: %d,%d", x, y)
-        self._finger_down(x, y)
+        self._device.finger_down(x, y)
 
     def release(self):
-        """Release a previously pressed finger"""
+        """Release a previously pressed finger.
+
+        :raises RuntimeError: if the touch is not pressed.
+
+        """
         logger.debug("Releasing")
-        self._finger_up()
+        self._device.finger_up()
 
     def move(self, x, y):
         """Moves the pointing "finger" to pos(x,y).
 
         NOTE: The finger has to be down for this to have any effect.
 
-        """
-        if self._touch_finger is None:
-            raise RuntimeError("Attempting to move without finger being down.")
-        self._finger_move(x, y)
-
-    def drag(self, x1, y1, x2, y2):
-        """Perform a drag gesture from (x1,y1) to (x2,y2)"""
+        :raises RuntimeError: if the finger is not pressed.
+
+        """
+        self._device.finger_move(x, y)
+
+    def drag(self, x1, y1, x2, y2, rate=10):
+        """Perform a drag gesture from (x1,y1) to (x2,y2).
+
+        :raises RuntimeError: if the finger is already pressed.
+        :raises RuntimeError: if no more finger slots are available.
+
+        """
         logger.debug("Dragging from %d,%d to %d,%d", x1, y1, x2, y2)
-        self._finger_down(x1, y1)
-
-        # Let's drag in 100 steps for now...
-        dx = 1.0 * (x2 - x1) / 100
-        dy = 1.0 * (y2 - y1) / 100
-        cur_x = x1 + dx
-        cur_y = y1 + dy
-        for i in range(0, 100):
-            self._finger_move(int(cur_x), int(cur_y))
+        self._device.finger_down(x1, y1)
+
+        current_x, current_y = x1, y1
+        while current_x != x2 or current_y != y2:
+            dx = abs(x2 - current_x)
+            dy = abs(y2 - current_y)
+
+            intx = float(dx) / max(dx, dy)
+            inty = float(dy) / max(dx, dy)
+
+            step_x = min(rate * intx, dx)
+            step_y = min(rate * inty, dy)
+
+            if x2 < current_x:
+                step_x *= -1
+            if y2 < current_y:
+                step_y *= -1
+
+            current_x += step_x
+            current_y += step_y
+            self.device._finger_move(current_x, current_y)
+
             sleep(0.002)
-            cur_x += dx
-            cur_y += dy
-        # Make sure we actually end up at target
-        self._finger_move(x2, y2)
-        self._finger_up()
-
-    def _finger_down(self, x, y):
-        """Internal: moves finger "finger" down on the touchscreen.
-
-        :param x: The finger will be moved to this x coordinate.
-        :param y: The finger will be moved to this y coordinate.
-
-        """
-        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."""
-        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"""
-        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()
-        self._touch_finger = _release_touch_finger(self._touch_finger)
+
+        self.device._finger_up()
 
 
 # veebers: there should be a better way to handle this.

=== modified file 'autopilot/tests/functional/test_input_stack.py'
--- autopilot/tests/functional/test_input_stack.py	2013-12-16 00:20:40 +0000
+++ autopilot/tests/functional/test_input_stack.py	2014-02-11 06:39:03 +0000
@@ -1,7 +1,7 @@
 # -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
 #
 # Autopilot Functional Test Tool
-# Copyright (C) 2012-2013 Canonical
+# Copyright (C) 2012, 2013, 2014 Canonical
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -150,8 +150,8 @@
             from autopilot.input._X11 import _PRESSED_KEYS
             return _PRESSED_KEYS
         elif self.backend == 'UInput':
-            from autopilot.input._uinput import _PRESSED_KEYS
-            return _PRESSED_KEYS
+            from autopilot.input import _uinput
+            return _uinput.Keyboard._device._pressed_keys_ecodes
         else:
             self.fail("Don't know how to get pressed keys list for backend "
                       + self.backend
@@ -551,8 +551,9 @@
         test_result = FakeTestCase("test_press_key").run()
 
         self.assertThat(test_result.wasSuccessful(), Equals(True))
-        from autopilot.input._uinput import _PRESSED_KEYS
-        self.assertThat(_PRESSED_KEYS, Equals([]))
+        from autopilot.input import _uinput
+        self.assertThat(
+            _uinput.Keyboard._device._pressed_keys_ecodes, Equals([]))
 
     @patch('autopilot.input._X11.fake_input', new=lambda *args: None, )
     def test_mouse_button_released(self):

=== modified file 'autopilot/tests/unit/test_input.py'
--- autopilot/tests/unit/test_input.py	2013-12-10 03:10:11 +0000
+++ autopilot/tests/unit/test_input.py	2014-02-11 06:39:03 +0000
@@ -1,7 +1,7 @@
 # -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
 #
 # Autopilot Functional Test Tool
-# Copyright (C) 2013 Canonical
+# Copyright (C) 2013, 2014 Canonical
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -17,10 +17,18 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-from mock import patch
+import testscenarios
+
+from mock import call, Mock, patch
+from evdev import ecodes, uinput
+from mock import ANY, call, patch, Mock
+from six import StringIO
 from testtools import TestCase
-from testtools.matchers import raises
+from testtools.matchers import Contains, raises
 
+import autopilot.input
+from autopilot import utilities
+from autopilot.input import _uinput, _X11
 from autopilot.input._common import get_center_point
 
 
@@ -151,3 +159,774 @@
 
         self.assertEqual(123, x)
         self.assertEqual(345, y)
+
+
+class PartialMock(object):
+    """Mock some of the methods of an object, and record their calls."""
+
+    def __init__(self, real_object, *args):
+        super(PartialMock, self).__init__()
+        self._mock_manager = Mock()
+        self._real_object = real_object
+        self.patched_attributes = args
+
+    def __getattr__(self, name):
+        """Forward all the calls to the real object."""
+        return self._real_object.__getattribute__(name)
+
+    @property
+    def mock_calls(self):
+        """Return the calls recorded for the mocked attributes."""
+        return self._mock_manager.mock_calls
+
+    def __enter__(self):
+        self._start_patchers()
+        return self
+
+    def _start_patchers(self):
+        self._patchers = []
+        for attribute in self.patched_attributes:
+            patcher = patch.object(self._real_object, attribute)
+            self._patchers.append(patcher)
+
+            self._mock_manager.attach_mock(patcher.start(), attribute)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._stop_patchers()
+
+    def _stop_patchers(self):
+        for patcher in self._patchers:
+            patcher.stop()
+
+
+class MockX11Mouse(PartialMock):
+    """Mock for the X11 Mouse Touch.
+
+    It records the calls to press, release and move, but doesn't perform them.
+
+    """
+
+    def __init__(self):
+        super(MockX11Mouse, self).__init__(
+            _X11.Mouse(), 'press', 'release', 'move')
+
+    def get_move_call_args_list(self):
+        return self._mock_manager.move.call_args_list
+
+
+class X11MouseTestCase(TestCase):
+
+    def test_drag_should_call_move_with_rate(self):
+        expected_first_move_call = call(0, 0)
+        expected_second_move_call = call(100, 100, rate=1)
+        with MockX11Mouse() as mock_mouse:
+            mock_mouse.drag(0, 0, 100, 100, rate=1)
+
+        self.assertEqual(
+            [expected_first_move_call, expected_second_move_call],
+            mock_mouse.get_move_call_args_list())
+
+    def test_drag_with_default_rate(self):
+        expected_first_move_call = call(0, 0)
+        expected_second_move_call = call(100, 100, rate=10)
+        with MockX11Mouse() as mock_mouse:
+            mock_mouse.drag(0, 0, 100, 100)
+
+        self.assertEqual(
+            [expected_first_move_call, expected_second_move_call],
+            mock_mouse.get_move_call_args_list())
+
+
+class MockUinputTouch(PartialMock):
+    """Mock for the uinput Touch.
+
+    It records the calls to _finger_down, _finger_up and _finger_move, but
+    doesn't perform them.
+
+    """
+
+    def __init__(self):
+        super(MockUinputTouch, self).__init__(
+            _uinput.Touch(), '_finger_down', '_finger_up', '_finger_move')
+
+    def get_finger_move_call_args_list(self):
+        return self._mock_manager._finger_move.call_args_list
+
+
+class UinputTouchTestCase(TestCase):
+
+    def test_drag_finger_actions(self):
+        expected_finger_calls = [
+            call._finger_down(0, 0),
+            call._finger_move(10, 10),
+            call._finger_up()
+        ]
+        with MockUinputTouch() as mock_touch:
+            mock_touch.drag(0, 0, 10, 10)
+        self.assertEqual(mock_touch.mock_calls, expected_finger_calls)
+
+    def test_drag_should_call_move_with_rate(self):
+        expected_move_calls = [call(5, 5), call(10, 10), call(15, 15)]
+        with MockUinputTouch() as mock_touch:
+            mock_touch.drag(0, 0, 15, 15, rate=5)
+
+        self.assertEqual(
+            expected_move_calls, mock_touch.get_finger_move_call_args_list())
+
+    def test_drag_with_default_rate(self):
+        expected_move_calls = [call(10, 10), call(20, 20)]
+        with MockUinputTouch() as mock_touch:
+            mock_touch.drag(0, 0, 20, 20)
+
+        self.assertEqual(
+            expected_move_calls, mock_touch.get_finger_move_call_args_list())
+
+    def test_drag_to_same_place_should_not_move(self):
+        expected_finger_calls = [
+            call._finger_down(0, 0),
+            call._finger_up()
+        ]
+        with MockUinputTouch() as mock_touch:
+            mock_touch.drag(0, 0, 0, 0)
+        self.assertEqual(mock_touch.mock_calls, expected_finger_calls)
+
+
+class UInputTestCase(TestCase):
+    """Tests for the global methods of the uinput module."""
+
+    def test_create_touch_device_must_print_deprecation_message(self):
+        with patch('sys.stderr', new=StringIO()) as stderr:
+            with patch('autopilot.input._uinput.UInput'):
+                _uinput.create_touch_device('dummy', 'dummy')
+        self.assertThat(
+            stderr.getvalue(),
+            Contains(
+                "This function is deprecated. Please use 'the Touch class to "
+                "instantiate a device object' instead."
+            )
+        )
+
+
+class UInputKeyboardDeviceTestCase(TestCase):
+    """Test the integration with evdev.UInput for the keyboard."""
+
+    _PRESS_VALUE = 1
+    _RELEASE_VALUE = 0
+
+    def get_keyboard_with_mocked_backend(self):
+        keyboard = _uinput._UInputKeyboardDevice(device_class=Mock)
+        keyboard._device.mock_add_spec(uinput.UInput, spec_set=True)
+        return keyboard
+
+    def assert_key_press_emitted_write_and_syn(self, keyboard, key):
+        self.assert_emitted_write_and_syn(keyboard, key, self._PRESS_VALUE)
+
+    def assert_key_release_emitted_write_and_syn(self, keyboard, key):
+        self.assert_emitted_write_and_syn(keyboard, key, self._RELEASE_VALUE)
+
+    def assert_emitted_write_and_syn(self, keyboard, key, value):
+        key_ecode = ecodes.ecodes.get(key)
+        expected_calls = [
+            call.write(ecodes.EV_KEY, key_ecode, value),
+            call.syn()
+        ]
+
+        self.assertEqual(expected_calls, keyboard._device.mock_calls)
+
+    def press_key_and_reset_mock(self, keyboard, key):
+        keyboard.press(key)
+        keyboard._device.reset_mock()
+
+    def test_press_key_must_emit_write_and_syn(self):
+        keyboard = self.get_keyboard_with_mocked_backend()
+        keyboard.press('KEY_A')
+        self.assert_key_press_emitted_write_and_syn(keyboard, 'KEY_A')
+
+    def test_press_key_must_append_leading_string(self):
+        keyboard = self.get_keyboard_with_mocked_backend()
+        keyboard.press('A')
+        self.assert_key_press_emitted_write_and_syn(keyboard, 'KEY_A')
+
+    def test_press_key_must_ignore_case(self):
+        keyboard = self.get_keyboard_with_mocked_backend()
+        keyboard.press('a')
+        self.assert_key_press_emitted_write_and_syn(keyboard, 'KEY_A')
+
+    def test_press_unexisting_key_must_raise_error(self):
+        keyboard = self.get_keyboard_with_mocked_backend()
+        error = self.assertRaises(
+            ValueError, keyboard.press, 'unexisting')
+
+        self.assertEqual('Unknown key name: unexisting.', str(error))
+
+    def test_release_not_pressed_key_must_raise_error(self):
+        keyboard = self.get_keyboard_with_mocked_backend()
+        error = self.assertRaises(
+            ValueError, keyboard.release, 'A')
+
+        self.assertEqual("Key 'A' not pressed.", str(error))
+
+    def test_release_key_must_emit_write_and_syn(self):
+        keyboard = self.get_keyboard_with_mocked_backend()
+        self.press_key_and_reset_mock(keyboard, 'KEY_A')
+
+        keyboard.release('KEY_A')
+        self.assert_key_release_emitted_write_and_syn(keyboard, 'KEY_A')
+
+    def test_release_key_must_append_leading_string(self):
+        keyboard = self.get_keyboard_with_mocked_backend()
+        self.press_key_and_reset_mock(keyboard, 'KEY_A')
+
+        keyboard.release('A')
+        self.assert_key_release_emitted_write_and_syn(keyboard, 'KEY_A')
+
+    def test_release_key_must_ignore_case(self):
+        keyboard = self.get_keyboard_with_mocked_backend()
+        self.press_key_and_reset_mock(keyboard, 'KEY_A')
+
+        keyboard.release('a')
+        self.assert_key_release_emitted_write_and_syn(keyboard, 'KEY_A')
+
+    def test_release_unexisting_key_must_raise_error(self):
+        keyboard = self.get_keyboard_with_mocked_backend()
+        error = self.assertRaises(
+            ValueError, keyboard.release, 'unexisting')
+
+        self.assertEqual('Unknown key name: unexisting.', str(error))
+
+    def test_release_pressed_keys_without_pressed_keys_must_do_nothing(self):
+        keyboard = self.get_keyboard_with_mocked_backend()
+        keyboard.release_pressed_keys()
+        self.assertEqual([], keyboard._device.mock_calls)
+
+    def test_release_pressed_keys_with_pressed_keys(self):
+        expected_calls = [
+            call.write(
+                ecodes.EV_KEY, ecodes.ecodes.get('KEY_A'),
+                self._RELEASE_VALUE),
+            call.syn(),
+            call.write(
+                ecodes.EV_KEY, ecodes.ecodes.get('KEY_B'),
+                self._RELEASE_VALUE),
+            call.syn()
+        ]
+
+        keyboard = self.get_keyboard_with_mocked_backend()
+        self.press_key_and_reset_mock(keyboard, 'KEY_A')
+        self.press_key_and_reset_mock(keyboard, 'KEY_B')
+
+        keyboard.release_pressed_keys()
+
+        self.assertEqual(expected_calls, keyboard._device.mock_calls)
+
+    def test_release_pressed_keys_already_released(self):
+        expected_calls = []
+        keyboard = self.get_keyboard_with_mocked_backend()
+        keyboard.press('KEY_A')
+        keyboard.release_pressed_keys()
+        keyboard._device.reset_mock()
+
+        keyboard.release_pressed_keys()
+        self.assertEqual(expected_calls, keyboard._device.mock_calls)
+
+
+class UInputKeyboardTestCase(testscenarios.TestWithScenarios, TestCase):
+    """Test UInput Keyboard helper for autopilot tests."""
+
+    scenarios = [
+        ('single key', dict(keys='a', expected_calls_args=['a'])),
+        ('upper-case letter', dict(
+            keys='A', expected_calls_args=['KEY_LEFTSHIFT', 'A'])),
+        ('key combination', dict(
+            keys='a+b', expected_calls_args=['a', 'b']))
+    ]
+
+    def setUp(self):
+        super(UInputKeyboardTestCase, self).setUp()
+        # Return to the original device after the test.
+        self.addCleanup(self.set_keyboard_device, _uinput.Keyboard._device)
+        # Mock the sleeps so we don't have to spend time actually sleeping.
+        self.addCleanup(utilities.sleep.disable_mock)
+        utilities.sleep.enable_mock()
+
+    def set_keyboard_device(self, device):
+        _uinput.Keyboard._device = device
+
+    def get_keyboard_with_mocked_backend(self):
+        _uinput.Keyboard._device = None
+        keyboard = _uinput.Keyboard(device_class=Mock)
+        keyboard._device.mock_add_spec(
+            _uinput._UInputKeyboardDevice, spec_set=True)
+        return keyboard
+
+    def test_press_must_put_press_device_keys(self):
+        expected_calls = [
+            call.press(arg) for arg in self.expected_calls_args]
+        keyboard = self.get_keyboard_with_mocked_backend()
+        keyboard.press(self.keys)
+
+        self.assertEqual(expected_calls, keyboard._device.mock_calls)
+
+    def test_release_must_release_device_keys(self):
+        keyboard = self.get_keyboard_with_mocked_backend()
+        keyboard.press(self.keys)
+        keyboard._device.reset_mock()
+
+        expected_calls = [
+            call.release(arg) for arg in
+            reversed(self.expected_calls_args)]
+        keyboard.release(self.keys)
+
+        self.assertEqual(
+            expected_calls, keyboard._device.mock_calls)
+
+    def test_press_and_release_must_press_device_keys(self):
+        expected_press_calls = [
+            call.press(arg) for arg in self.expected_calls_args]
+        ignored_calls = [
+            ANY for arg in self.expected_calls_args]
+
+        keyboard = self.get_keyboard_with_mocked_backend()
+        keyboard.press_and_release(self.keys)
+
+        self.assertEqual(
+            expected_press_calls + ignored_calls,
+            keyboard._device.mock_calls)
+
+    def test_press_and_release_must_release_device_keys_in_reverse_order(
+            self):
+        ignored_calls = [
+            ANY for arg in self.expected_calls_args]
+        expected_release_calls = [
+            call.release(arg) for arg in
+            reversed(self.expected_calls_args)]
+
+        keyboard = self.get_keyboard_with_mocked_backend()
+        keyboard.press_and_release(self.keys)
+
+        self.assertEqual(
+            ignored_calls + expected_release_calls,
+            keyboard._device.mock_calls)
+
+    def test_on_test_end_without_device_must_do_nothing(self):
+        _uinput.Keyboard._device = None
+        # This will fail if it calls anything from the device, as it's None.
+        _uinput.Keyboard.on_test_end(self)
+
+    def test_on_test_end_with_device_must_release_pressed_keys(self):
+        keyboard = self.get_keyboard_with_mocked_backend()
+        _uinput.Keyboard.on_test_end(self)
+        self.assertEqual(
+            [call.release_pressed_keys()], keyboard._device.mock_calls)
+
+
+class TouchEventsTestCase(TestCase):
+
+    def assert_expected_ev_abs(self, res_x, res_y, actual_ev_abs):
+        expected_ev_abs = [
+            (ecodes.ABS_X, (0, res_x, 0, 0)),
+            (ecodes.ABS_Y, (0, res_y, 0, 0)),
+            (ecodes.ABS_PRESSURE, (0, 65535, 0, 0)),
+            (ecodes.ABS_MT_POSITION_X, (0, res_x, 0, 0)),
+            (ecodes.ABS_MT_POSITION_Y, (0, res_y, 0, 0)),
+            (ecodes.ABS_MT_TOUCH_MAJOR, (0, 30, 0, 0)),
+            (ecodes.ABS_MT_TRACKING_ID, (0, 65535, 0, 0)),
+            (ecodes.ABS_MT_PRESSURE, (0, 255, 0, 0)),
+            (ecodes.ABS_MT_SLOT, (0, 9, 0, 0))
+        ]
+        self.assertEqual(expected_ev_abs, actual_ev_abs)
+
+    def test_get_touch_events_without_args_must_use_system_resolution(self):
+        with patch.object(
+                _uinput, '_get_system_resolution', spec_set=True,
+                autospec=True) as mock_system_resolution:
+            mock_system_resolution.return_value = (
+                'system_res_x', 'system_res_y')
+            events = _uinput._get_touch_events()
+
+        ev_abs = events.get(ecodes.EV_ABS)
+        self.assert_expected_ev_abs('system_res_x', 'system_res_y', ev_abs)
+
+    def test_get_touch_events_with_args_must_use_given_resulution(self):
+        events = _uinput._get_touch_events('given_res_x', 'given_res_y')
+        ev_abs = events.get(ecodes.EV_ABS)
+        self.assert_expected_ev_abs('given_res_x', 'given_res_y', ev_abs)
+
+
+class UInputTouchDeviceTestCase(TestCase):
+    """Test the integration with evdev.UInput for the touch device."""
+
+    def setUp(self):
+        super(UInputTouchDeviceTestCase, self).setUp()
+        self._number_of_slots = 9
+
+        # Return to the original device after the test.
+        self.addCleanup(
+            self.set_mouse_device,
+            _uinput._UInputTouchDevice._device,
+            _uinput._UInputTouchDevice._touch_fingers_in_use,
+            _uinput._UInputTouchDevice._last_tracking_id)
+
+        # Always start the tests without fingers in use.
+        _uinput._UInputTouchDevice._touch_fingers_in_use = []
+        _uinput._UInputTouchDevice._last_tracking_id = 0
+
+    def set_mouse_device(
+            self, device, touch_fingers_in_use, last_tracking_id):
+        _uinput._UInputTouchDevice._device = device
+        _uinput._UInputTouchDevice._touch_fingers_in_use = touch_fingers_in_use
+        _uinput._UInputTouchDevice._last_tracking_id = last_tracking_id
+
+    def get_touch_with_mocked_backend(self):
+        dummy_x_resolution = 100
+        dummy_y_resolution = 100
+
+        _uinput._UInputTouchDevice._device = None
+        touch = _uinput._UInputTouchDevice(
+            res_x=dummy_x_resolution, res_y=dummy_y_resolution,
+            device_class=Mock)
+        touch._device.mock_add_spec(uinput.UInput, spec_set=True)
+        return touch
+
+    def assert_finger_down_emitted_write_and_syn(
+            self, touch, slot, tracking_id, x, y):
+        press_value = 1
+        expected_calls = [
+            call.write(ecodes.EV_ABS, ecodes.ABS_MT_SLOT, slot),
+            call.write(
+                ecodes.EV_ABS, ecodes.ABS_MT_TRACKING_ID, tracking_id),
+            call.write(
+                ecodes.EV_KEY, ecodes.BTN_TOOL_FINGER, press_value),
+            call.write(ecodes.EV_ABS, ecodes.ABS_MT_POSITION_X, x),
+            call.write(ecodes.EV_ABS, ecodes.ABS_MT_POSITION_Y, y),
+            call.write(ecodes.EV_ABS, ecodes.ABS_MT_PRESSURE, 400),
+            call.syn()
+        ]
+        self.assertEqual(expected_calls, touch._device.mock_calls)
+
+    def assert_finger_move_emitted_write_and_syn(self, touch, slot, x, y):
+        expected_calls = [
+            call.write(ecodes.EV_ABS, ecodes.ABS_MT_SLOT, slot),
+            call.write(ecodes.EV_ABS, ecodes.ABS_MT_POSITION_X, x),
+            call.write(ecodes.EV_ABS, ecodes.ABS_MT_POSITION_Y, y),
+            call.syn()
+        ]
+        self.assertEqual(expected_calls, touch._device.mock_calls)
+
+    def assert_finger_up_emitted_write_and_syn(self, touch, slot):
+        lift_tracking_id = -1
+        release_value = 0
+        expected_calls = [
+            call.write(ecodes.EV_ABS, ecodes.ABS_MT_SLOT, slot),
+            call.write(
+                ecodes.EV_ABS, ecodes.ABS_MT_TRACKING_ID, lift_tracking_id),
+            call.write(
+                ecodes.EV_KEY, ecodes.BTN_TOOL_FINGER, release_value),
+            call.syn()
+        ]
+        self.assertEqual(expected_calls, touch._device.mock_calls)
+
+    def test_finger_down_must_use_free_slot(self):
+        for slot in range(self._number_of_slots):
+            touch = self.get_touch_with_mocked_backend()
+
+            touch.finger_down(0, 0)
+
+            self.assert_finger_down_emitted_write_and_syn(
+                touch, slot=slot, tracking_id=ANY, x=0, y=0)
+
+    def test_finger_down_without_free_slots_must_raise_error(self):
+        # Claim all the available slots.
+        for slot in range(self._number_of_slots):
+            touch = self.get_touch_with_mocked_backend()
+            touch.finger_down(0, 0)
+
+        touch = self.get_touch_with_mocked_backend()
+
+        # Try to use one more.
+        error = self.assertRaises(RuntimeError, touch.finger_down, 11, 11)
+        self.assertEqual(
+            'All available fingers have been used already.', str(error))
+
+    def test_finger_down_must_use_unique_tracking_id(self):
+        for number in range(self._number_of_slots):
+            touch = self.get_touch_with_mocked_backend()
+            touch.finger_down(0, 0)
+
+            self.assert_finger_down_emitted_write_and_syn(
+                touch, slot=ANY, tracking_id=number + 1, x=0, y=0)
+
+    def test_finger_down_must_not_reuse_tracking_ids(self):
+        # Claim and release all the available slots once.
+        for number in range(self._number_of_slots):
+            touch = self.get_touch_with_mocked_backend()
+            touch.finger_down(0, 0)
+            touch.finger_up()
+
+        touch = self.get_touch_with_mocked_backend()
+
+        touch.finger_down(12, 12)
+        self.assert_finger_down_emitted_write_and_syn(
+            touch, slot=ANY, tracking_id=number + 2, x=12, y=12)
+
+    def test_finger_down_with_finger_pressed_must_raise_error(self):
+        touch = self.get_touch_with_mocked_backend()
+        touch.finger_down(0, 0)
+
+        error = self.assertRaises(RuntimeError, touch.finger_down, 0, 0)
+        self.assertEqual(
+            "Cannot press finger: it's already pressed.", str(error))
+
+    def test_finger_move_without_finger_pressed_must_raise_error(self):
+        touch = self.get_touch_with_mocked_backend()
+
+        error = self.assertRaises(RuntimeError, touch.finger_move, 10, 10)
+        self.assertEqual(
+            'Attempting to move without finger being down.', str(error))
+
+    def test_finger_move_must_use_assigned_slot(self):
+        for slot in range(self._number_of_slots):
+            touch = self.get_touch_with_mocked_backend()
+            touch.finger_down(0, 0)
+            touch._device.reset_mock()
+
+            touch.finger_move(10, 10)
+
+            self.assert_finger_move_emitted_write_and_syn(
+                touch, slot=slot, x=10, y=10)
+
+    def test_finger_move_must_reuse_assigned_slot(self):
+        first_slot = 0
+        touch = self.get_touch_with_mocked_backend()
+        touch.finger_down(1, 1)
+        touch._device.reset_mock()
+
+        touch.finger_move(13, 13)
+        self.assert_finger_move_emitted_write_and_syn(
+            touch, slot=first_slot, x=13, y=13)
+        touch._device.reset_mock()
+
+        touch.finger_move(14, 14)
+        self.assert_finger_move_emitted_write_and_syn(
+            touch, slot=first_slot, x=14, y=14)
+
+    def test_finger_up_without_finger_pressed_must_raise_error(self):
+        touch = self.get_touch_with_mocked_backend()
+
+        error = self.assertRaises(RuntimeError, touch.finger_up)
+        self.assertEqual(
+            "Cannot release finger: it's not pressed.", str(error))
+
+    def test_finger_up_must_use_assigned_slot(self):
+        fingers = []
+        for slot in range(self._number_of_slots):
+            touch = self.get_touch_with_mocked_backend()
+            touch.finger_down(0, 0)
+            touch._device.reset_mock()
+            fingers.append(touch)
+
+        for slot, touch in enumerate(fingers):
+            touch.finger_up()
+
+            self.assert_finger_up_emitted_write_and_syn(touch, slot=slot)
+            touch._device.reset_mock()
+
+    def test_finger_up_must_release_slot(self):
+        fingers = []
+        # Claim all the available slots.
+        for slot in range(self._number_of_slots):
+            touch = self.get_touch_with_mocked_backend()
+            touch.finger_down(0, 0)
+            fingers.append(touch)
+
+        slot_to_reuse = 3
+        fingers[slot_to_reuse].finger_up()
+
+        touch = self.get_touch_with_mocked_backend()
+
+        # Try to use one more.
+        touch.finger_down(15, 15)
+        self.assert_finger_down_emitted_write_and_syn(
+            touch, slot=slot_to_reuse, tracking_id=ANY, x=15, y=15)
+
+    def test_device_with_finger_down_must_be_pressed(self):
+        touch = self.get_touch_with_mocked_backend()
+        touch.finger_down(0, 0)
+
+        self.assertTrue(touch.pressed)
+
+    def test_device_without_finger_down_must_not_be_pressed(self):
+        touch = self.get_touch_with_mocked_backend()
+        self.assertFalse(touch.pressed)
+
+    def test_device_after_finger_up_must_not_be_pressed(self):
+        touch = self.get_touch_with_mocked_backend()
+        touch.finger_down(0, 0)
+        touch.finger_up()
+
+        self.assertFalse(touch.pressed)
+
+    def test_press_other_device_must_not_press_all_of_them(self):
+        other_touch = self.get_touch_with_mocked_backend()
+        other_touch.finger_down(0, 0)
+
+        touch = self.get_touch_with_mocked_backend()
+        self.assertFalse(touch.pressed)
+
+
+class UInputTouchTestCase(TestCase):
+    """Test UInput Touch helper for autopilot tests."""
+
+    def setUp(self):
+        super(UInputTouchTestCase, self).setUp()
+        # Mock the sleeps so we don't have to spend time actually sleeping.
+        self.addCleanup(utilities.sleep.disable_mock)
+        utilities.sleep.enable_mock()
+
+    def get_touch_with_mocked_backend(self):
+        touch = _uinput.Touch(device_class=Mock)
+        touch._device.mock_add_spec(
+            _uinput._UInputTouchDevice, spec_set=True)
+        return touch
+
+    def test_tap_must_put_finger_down_and_then_up(self):
+        expected_calls = [
+            call.finger_down(0, 0),
+            call.finger_up()
+        ]
+
+        touch = self.get_touch_with_mocked_backend()
+        touch.tap(0, 0)
+        self.assertEqual(expected_calls, touch._device.mock_calls)
+
+    def test_tap_object_must_put_finger_down_and_then_up_on_the_center(self):
+        object_ = type('Dummy', (object,), {'globalRect': (0, 0, 10, 10)})
+        expected_calls = [
+            call.finger_down(5, 5),
+            call.finger_up()
+        ]
+
+        touch = self.get_touch_with_mocked_backend()
+        touch.tap_object(object_)
+        self.assertEqual(expected_calls, touch._device.mock_calls)
+
+    def test_press_must_put_finger_down(self):
+        expected_calls = [call.finger_down(0, 0)]
+
+        touch = self.get_touch_with_mocked_backend()
+        touch.press(0, 0)
+        self.assertEqual(expected_calls, touch._device.mock_calls)
+
+    def test_release_must_put_finger_up(self):
+        expected_calls = [call.finger_up()]
+
+        touch = self.get_touch_with_mocked_backend()
+        touch.release()
+        self.assertEqual(expected_calls, touch._device.mock_calls)
+
+    def test_move_must_move_finger(self):
+        expected_calls = [call.finger_move(10, 10)]
+
+        touch = self.get_touch_with_mocked_backend()
+        touch.move(10, 10)
+        self.assertEqual(expected_calls, touch._device.mock_calls)
+
+
+class MultipleUInputTouchBackend(_uinput._UInputTouchDevice):
+
+    def __init__(self, res_x=100, res_y=100, device_class=Mock):
+        super(MultipleUInputTouchBackend, self).__init__(
+            res_x, res_y, device_class)
+
+
+class MultipleUInputTouchTestCase(TestCase):
+
+    def setUp(self):
+        super(MultipleUInputTouchTestCase, self).setUp()
+        # Return to the original device after the test.
+        self.addCleanup(
+            self.set_mouse_device,
+            _uinput._UInputTouchDevice._device,
+            _uinput._UInputTouchDevice._touch_fingers_in_use,
+            _uinput._UInputTouchDevice._last_tracking_id)
+
+    def set_mouse_device(
+            self, device, touch_fingers_in_use, last_tracking_id):
+        _uinput._UInputTouchDevice._device = device
+        _uinput._UInputTouchDevice._touch_fingers_in_use = touch_fingers_in_use
+        _uinput._UInputTouchDevice._last_tracking_id = last_tracking_id
+
+    def test_press_other_device_must_not_press_all_of_them(self):
+        finger1 = _uinput.Touch(device_class=MultipleUInputTouchBackend)
+        finger2 = _uinput.Touch(device_class=MultipleUInputTouchBackend)
+
+        finger1.press(0, 0)
+        self.addCleanup(finger1.release)
+
+        self.assertFalse(finger2.pressed)
+
+
+class DragUinputTouchTestCase(testscenarios.TestWithScenarios, TestCase):
+
+    scenarios = [
+        ('drag to top', dict(
+            start_x=50, start_y=50, stop_x=50, stop_y=30,
+            expected_moves=[call(50, 40), call(50, 30)])),
+        ('drag to bottom', dict(
+            start_x=50, start_y=50, stop_x=50, stop_y=70,
+            expected_moves=[call(50, 60), call(50, 70)])),
+        ('drag to left', dict(
+            start_x=50, start_y=50, stop_x=30, stop_y=50,
+            expected_moves=[call(40, 50), call(30, 50)])),
+        ('drag to right', dict(
+            start_x=50, start_y=50, stop_x=70, stop_y=50,
+            expected_moves=[call(60, 50), call(70, 50)])),
+
+        ('drag to top-left', dict(
+            start_x=50, start_y=50, stop_x=30, stop_y=30,
+            expected_moves=[call(40, 40), call(30, 30)])),
+        ('drag to top-right', dict(
+            start_x=50, start_y=50, stop_x=70, stop_y=30,
+            expected_moves=[call(60, 40), call(70, 30)])),
+        ('drag to bottom-left', dict(
+            start_x=50, start_y=50, stop_x=30, stop_y=70,
+            expected_moves=[call(40, 60), call(30, 70)])),
+        ('drag to bottom-right', dict(
+            start_x=50, start_y=50, stop_x=70, stop_y=70,
+            expected_moves=[call(60, 60), call(70, 70)])),
+
+        ('drag less than rate', dict(
+            start_x=50, start_y=50, stop_x=55, stop_y=55,
+            expected_moves=[call(55, 55)])),
+
+        ('drag with last move less than rate', dict(
+            start_x=50, start_y=50, stop_x=65, stop_y=65,
+            expected_moves=[call(60, 60), call(65, 65)])),
+    ]
+
+    def test_drag_moves(self):
+        with MockUinputTouch() as mock_touch:
+            mock_touch.drag(
+                self.start_x, self.start_y, self.stop_x, self.stop_y)
+
+        self.assertEqual(
+            self.expected_moves, mock_touch.get_finger_move_call_args_list())
+
+
+class PointerTestCase(TestCase):
+
+    def setUp(self):
+        super(PointerTestCase, self).setUp()
+        self.pointer = autopilot.input.Pointer(autopilot.input.Mouse.create())
+
+    def test_drag_with_rate(self):
+        with patch.object(self.pointer._device, 'drag') as mock_drag:
+            self.pointer.drag(0, 0, 20, 20, rate=5)
+
+        mock_drag.assert_called_once_with(0, 0, 20, 20, rate=5)
+
+    def test_drag_with_default_rate(self):
+        with patch.object(self.pointer._device, 'drag') as mock_drag:
+            self.pointer.drag(0, 0, 20, 20)
+
+        mock_drag.assert_called_once_with(0, 0, 20, 20, rate=10)

=== modified file 'debian/control'
--- debian/control	2014-01-29 20:48:43 +0000
+++ debian/control	2014-02-11 06:39:03 +0000
@@ -16,6 +16,7 @@
                python-dbus,
                python-debian,
                python-dev,
+               python-evdev,
                python-fixtures,
                python-gi,
                python-junitxml,
@@ -30,6 +31,7 @@
                python-xlib,
                python3-all-dev (>= 3.3),
                python3-dbus,
+               python3-evdev,
                python3-fixtures,
                python3-gi,
                python3-junitxml,