Merge lp:~elopio/autopilot/no_uinput_side-effects2 into lp:~elopio/autopilot/no_uinput_side-effects

[Leo Arias]

Not yet ready, just teasing jenkins.

[lp:~elopio/autopilot/no_uinput_side-effects2]

425. By Leo Arias on 2014-01-21

Added coverate for uinput.Touch.

426. By Leo Arias on 2014-01-21

Create the Touch device with a dummy resolution.

427. By Leo Arias on 2014-01-21

Fixed pep8.

428. By Leo Arias on 2014-01-21

Make sure that the keyboard mock will be used.

429. By Leo Arias on 2014-01-21

updated the pressed keys list.

430. By Leo Arias on 2014-01-21

Typo.

431. By Leo Arias on 2014-01-21

    updated the pressed keys list.

432. By Leo Arias on 2014-01-21

Fixed the release all.

433. By Leo Arias on 2014-01-21

Added a unit test for the previous bug.

434. By Leo Arias on 2014-01-21

Added the failing test case.

435. By Leo Arias on 2014-01-21

Fixed the test with multiple fingers.

Unmerged revisions

=== modified file 'autopilot/input/_uinput.py'
--- autopilot/input/_uinput.py	2014-01-21 04:44:16 +0000
+++ autopilot/input/_uinput.py	2014-01-21 09:50:21 +0000
@@ -20,10 +20,10 @@
 
 """UInput device drivers."""
 
+from autopilot import utilities
 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
 
 import logging
@@ -135,7 +135,7 @@
         for key in self._sanitise_keys(keys):
             for key_button in self._get_key_buttons(key):
                 self._device.press(key_button)
-                sleep(delay)
+                utilities.sleep(delay)
 
     def release(self, keys, delay=0.1):
         """Send key release events only.
@@ -156,7 +156,7 @@
         for key in reversed(self._sanitise_keys(keys)):
             for key_button in reversed(self._get_key_buttons(key)):
                 self._device.release(key_button)
-                sleep(delay)
+                utilities.sleep(delay)
 
     def press_and_release(self, keys, delay=0.1):
         """Press and release all items in 'keys'.
@@ -214,67 +214,16 @@
         return key_buttons
 
 
-last_tracking_id = 0
-
-
-def get_next_tracking_id():
-    global last_tracking_id
-    last_tracking_id += 1
-    return last_tracking_id
-
-
[e-mail]('Touch')
 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(), name='autopilot-finger',
+                  version=0x2, devnode=_get_devnode_path())
+
 
 # Multiouch notes:
 # ----------------
@@ -319,58 +268,177 @@
 # 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, res_y):
+    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.
+
+    If res_x and res_y are not specified, they will be queried from the system.
+
+    """
+
+    _touch_fingers_in_use = []
+    _max_number_of_fingers = 9
+    _last_tracking_id = 0
+
+    def __init__(self, res_x=None, res_y=None, device_class=UInput):
+        super(_UInputTouchDevice, self).__init__()
+        self._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.
+
+        """
+        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 fingers are available.
+
+        """
+        for i in range(_UInputTouchDevice._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.
+
+        """
+        if not self.pressed:
+            raise RuntimeError('Attempting to move without finger being down.')
+        else:
+            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"""
+        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."""
+        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
+        Touch._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."""
         logger.debug("Tapping at: %d,%d", x, y)
-        self._finger_down(x, y)
-        sleep(0.1)
-        self._finger_up()
+        self._device.finger_down(x, y)
+        utilities.sleep(0.1)
+        self._device.finger_up()
 
     def tap_object(self, object):
         """Click (or 'tap') a given object"""
@@ -382,12 +450,12 @@
         """Press and hold a given object or at the given coordinates
         Call release() when the object has been pressed long enough"""
         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"""
         logger.debug("Releasing")
-        self._finger_up()
+        self._device.finger_up()
 
     def move(self, x, y):
         """Moves the pointing "finger" to pos(x,y).
@@ -395,14 +463,12 @@
         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)
+        self._device.finger_move(x, y)
 
     def drag(self, x1, y1, x2, y2):
         """Perform a drag gesture from (x1,y1) to (x2,y2)"""
         logger.debug("Dragging from %d,%d to %d,%d", x1, y1, x2, y2)
-        self._finger_down(x1, y1)
+        self._device.finger_down(x1, y1)
 
         # Let's drag in 100 steps for now...
         dx = 1.0 * (x2 - x1) / 100
@@ -410,52 +476,13 @@
         cur_x = x1 + dx
         cur_y = y1 + dy
         for i in range(0, 100):
-            self._finger_move(int(cur_x), int(cur_y))
-            sleep(0.002)
+            self._device.finger_move(int(cur_x), int(cur_y))
+            utilities.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_move(x2, y2)
+        self._device.finger_up()
 
 
 # veebers: there should be a better way to handle this.
 
=== modified file 'autopilot/tests/unit/test_input.py'
--- autopilot/tests/unit/test_input.py	2014-01-21 04:52:16 +0000
+++ autopilot/tests/unit/test_input.py	2014-01-21 09:50:21 +0000
@@ -317,3 +317,264 @@
         self.assertEqual(
             expected_press_calls + expected_release_calls,
             self.keyboard._device.mock_calls)
+
+
+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 fingers after the test.
+        self.addCleanup(
+            self._set_fingers_in_use,
+            _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_fingers_in_use(self, touch_fingers_in_use, last_tracking_id):
+        _uinput._UInputTouchDevice._touch_fingers_in_use = touch_fingers_in_use
+        _uinput._UInputTouchDevice._last_tracking_id = last_tracking_id
+
+    def test_finger_down_should_use_free_slot(self):
+        for slot in range(self._number_of_slots):
+            touch = self._get_touch_device()
+
+            touch.finger_down(0, 0)
+
+            self._assert_finger_down_emitted_write_and_syn(
+                touch, slot=slot, tracking_id=mock.ANY, x=0, y=0)
+
+    def _get_touch_device(self):
+        touch = _uinput._UInputTouchDevice(device_class=mock.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 = [
+            mock.call.write(ecodes.EV_ABS, ecodes.ABS_MT_SLOT, slot),
+            mock.call.write(
+                ecodes.EV_ABS, ecodes.ABS_MT_TRACKING_ID, tracking_id),
+            mock.call.write(
+                ecodes.EV_KEY, ecodes.BTN_TOOL_FINGER, press_value),
+            mock.call.write(ecodes.EV_ABS, ecodes.ABS_MT_POSITION_X, x),
+            mock.call.write(ecodes.EV_ABS, ecodes.ABS_MT_POSITION_Y, y),
+            mock.call.write(ecodes.EV_ABS, ecodes.ABS_MT_PRESSURE, 400),
+            mock.call.syn()
+        ]
+        self.assertEqual(expected_calls, touch._device.mock_calls)
+
+    def test_finger_down_without_free_slots_should_raise_error(self):
+        # Claim all the available slots.
+        for slot in range(self._number_of_slots):
+            touch = self._get_touch_device()
+            touch.finger_down(0, 0)
+
+        touch = self._get_touch_device()
+
+        # 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_should_use_unique_tracking_id(self):
+        for number in range(self._number_of_slots):
+            touch = self._get_touch_device()
+            touch.finger_down(0, 0)
+
+            self._assert_finger_down_emitted_write_and_syn(
+                touch, slot=mock.ANY, tracking_id=number + 1, x=0, y=0)
+
+    def test_finger_down_should_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_device()
+            touch.finger_down(0, 0)
+            touch.finger_up()
+
+        touch = self._get_touch_device()
+
+        touch.finger_down(12, 12)
+        self._assert_finger_down_emitted_write_and_syn(
+            touch, slot=mock.ANY, tracking_id=number + 2, x=12, y=12)
+
+    def test_finger_down_with_finger_pressed_should_raise_error(self):
+        touch = self._get_touch_device()
+        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_should_raise_error(self):
+        touch = self._get_touch_device()
+
+        error = self.assertRaises(RuntimeError, touch.finger_move, 10, 10)
+        self.assertEqual(
+            'Attempting to move without finger being down.', str(error))
+
+    def test_finger_move_should_use_assigned_slot(self):
+        for slot in range(self._number_of_slots):
+            touch = self._get_touch_device()
+            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 _assert_finger_move_emitted_write_and_syn(self, touch, slot, x, y):
+        expected_calls = [
+            mock.call.write(ecodes.EV_ABS, ecodes.ABS_MT_SLOT, slot),
+            mock.call.write(ecodes.EV_ABS, ecodes.ABS_MT_POSITION_X, x),
+            mock.call.write(ecodes.EV_ABS, ecodes.ABS_MT_POSITION_Y, y),
+            mock.call.syn()
+        ]
+        self.assertEqual(expected_calls, touch._device.mock_calls)
+
+    def test_finger_move_should_reuse_assigned_slot(self):
+        first_slot = 0
+        touch = self._get_touch_device()
+        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_should_raise_error(self):
+        touch = self._get_touch_device()
+
+        error = self.assertRaises(RuntimeError, touch.finger_up)
+        self.assertEqual(
+            "Cannot release finger: it's not pressed.", str(error))
+
+    def test_finger_up_should_use_assigned_slot(self):
+        fingers = []
+        for slot in range(self._number_of_slots):
+            touch = self._get_touch_device()
+            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)
+
+    def _assert_finger_up_emitted_write_and_syn(self, touch, slot):
+        lift_tracking_id = -1
+        release_value = 0
+        expected_calls = [
+            mock.call.write(ecodes.EV_ABS, ecodes.ABS_MT_SLOT, slot),
+            mock.call.write(
+                ecodes.EV_ABS, ecodes.ABS_MT_TRACKING_ID, lift_tracking_id),
+            mock.call.write(
+                ecodes.EV_KEY, ecodes.BTN_TOOL_FINGER, release_value),
+            mock.call.syn()
+        ]
+        self.assertEqual(expected_calls, touch._device.mock_calls)
+
+    def test_finger_up_should_release_slot(self):
+        fingers = []
+        # Claim all the available slots.
+        for slot in range(self._number_of_slots):
+            touch = self._get_touch_device()
+            touch.finger_down(0, 0)
+            fingers.append(touch)
+
+        slot_to_reuse = 3
+        fingers[slot_to_reuse].finger_up()
+
+        touch = self._get_touch_device()
+
+        # 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=mock.ANY, x=15, y=15)
+
+    def test_pressed_with_finger_down(self):
+        touch = self._get_touch_device()
+        touch.finger_down(0, 0)
+
+        self.assertTrue(touch.pressed)
+
+    def test_pressed_without_finger_down(self):
+        touch = self._get_touch_device()
+        self.assertFalse(touch.pressed)
+
+    def test_pressed_after_finger_up(self):
+        touch = self._get_touch_device()
+        touch.finger_down(0, 0)
+        touch.finger_up()
+
+        self.assertFalse(touch.pressed)
+
+    def test_pressed_with_other_finger_down(self):
+        other_touch = self._get_touch_device()
+        other_touch.finger_down(0, 0)
+
+        touch = self._get_touch_device()
+        self.assertFalse(touch.pressed)
+
+
+class UInputTouchTestCase(TestCase):
+    """Test UInput Touch helper for autopilot tests."""
+
+    def setUp(self):
+        super(UInputTouchTestCase, self).setUp()
+        self.touch = _uinput.Touch(device_class=mock.Mock)
+        self.touch._device.mock_add_spec(
+            _uinput._UInputTouchDevice, spec_set=True)
+        # Mock the sleeps so we don't have to spend time actually sleeping.
+        self.addCleanup(utilities.sleep.disable_mock)
+        utilities.sleep.enable_mock()
+
+    def test_tap(self):
+        expected_calls = [
+            mock.call.finger_down(0, 0),
+            mock.call.finger_up()
+        ]
+
+        self.touch.tap(0, 0)
+        self.assertEqual(expected_calls, self.touch._device.mock_calls)
+
+    def test_tap_object(self):
+        object_ = type('Dummy', (object,), {'globalRect': (0, 0, 10, 10)})
+        expected_calls = [
+            mock.call.finger_down(5, 5),
+            mock.call.finger_up()
+        ]
+
+        self.touch.tap_object(object_)
+        self.assertEqual(expected_calls, self.touch._device.mock_calls)
+
+    def test_press(self):
+        expected_calls = [mock.call.finger_down(0, 0)]
+
+        self.touch.press(0, 0)
+        self.assertEqual(expected_calls, self.touch._device.mock_calls)
+
+    def test_release(self):
+        expected_calls = [mock.call.finger_up()]
+
+        self.touch.release()
+        self.assertEqual(expected_calls, self.touch._device.mock_calls)
+
+    def test_move(self):
+        expected_calls = [mock.call.finger_move(10, 10)]
+
+        self.touch.move(10, 10)
+        self.assertEqual(expected_calls, self.touch._device.mock_calls)