Autopilot

Merge lp:~canonical-platform-qa/autopilot/fix1266601-Pointer-pressed-move-2 into lp:autopilot

fix1266601-Pointer-pressed-move-2
Merge into trunk

Proposed by Leo Arias on 2015-03-13

Status:

Merged

Approved by:

Christopher Lee on 2015-03-18

Approved revision:

555

Merged at revision:

546

Proposed branch:

lp:~canonical-platform-qa/autopilot/fix1266601-Pointer-pressed-move-2

Merge into:

lp:autopilot

Diff against target:

588 lines (+235/-105)

4 files modified

autopilot/input/__init__.py (+7/-22)
autopilot/input/_uinput.py (+69/-29)
autopilot/tests/functional/test_input_stack.py (+6/-4)
autopilot/tests/unit/test_input.py (+153/-50)

To merge this branch:

bzr merge lp:~canonical-platform-qa/autopilot/fix1266601-Pointer-pressed-move-2

High

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot	continuous-integration		Approve on 2015-03-18
Christopher Lee (community)		2015-03-13	Approve on 2015-03-18
Richard Huddie (community)			Approve on 2015-03-17
Review via email: mp+252932@code.launchpad.net

Commit Message

Fixed the pressed finger move on touch.
Moved the last position handling to the touch backend.
Moved the animated move from drag to move.

lp:~canonical-platform-qa/autopilot/fix1266601-Pointer-pressed-move-2 updated on 2015-03-13

550. By Leo Arias on 2015-03-13: Updated copyright, added docs, change the property name to be the same as x11.

PS Jenkins bot (ps-jenkins) wrote on 2015-03-13:

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

review: Needs Fixing (continuous-integration)

lp:~canonical-platform-qa/autopilot/fix1266601-Pointer-pressed-move-2 updated on 2015-03-13

551. By Leo Arias on 2015-03-13: Updated the fake touch in functional tests.
552. By Leo Arias on 2015-03-13: Updated the other functional test.

PS Jenkins bot (ps-jenkins) wrote on 2015-03-13:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-03-15:

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

review: Needs Fixing (continuous-integration)

Christopher Lee (veebers) wrote on 2015-03-15:

Functional tests are failing with an error re: X11 and protocol. Have pinged CI and will follow up.

Christopher Lee (veebers) wrote on 2015-03-16:

Looking good, a couple of queries needing clarification. Thanks :-)

review: Needs Information

lp:~canonical-platform-qa/autopilot/fix1266601-Pointer-pressed-move-2 updated on 2015-03-16

553. By Leo Arias on 2015-03-16: Fixed copyright year.

Leo Arias (elopio) wrote on 2015-03-16:

Thanks for the review veebers. Replied and pushed.

lp:~canonical-platform-qa/autopilot/fix1266601-Pointer-pressed-move-2 updated on 2015-03-16

554. By Leo Arias on 2015-03-16: Made animate default to True.
555. By Leo Arias on 2015-03-16: extracted the call scenario method.

PS Jenkins bot (ps-jenkins) wrote on 2015-03-16:

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

review: Needs Fixing (continuous-integration)

Richard Huddie (rhuddie) wrote on 2015-03-17:

The changes look good to me. New and modified tests pass and flake8 is clean, so approving.

review: Approve

PS Jenkins bot (ps-jenkins) wrote on 2015-03-18:

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

review: Approve (continuous-integration)

Christopher Lee (veebers) wrote on 2015-03-18:

LGTM.

review: Approve

PS Jenkins bot (ps-jenkins) wrote on 2015-03-18:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) on 2015-03-18:

review: Approve (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Autopilot Hackers

Canonical Platform QA Team

Chris Gagnon

 === modified file 'autopilot/input/__init__.py'
 --- autopilot/input/__init__.py	2014-10-24 19:35:45 +0000
 +++ autopilot/input/__init__.py	2015-03-16 15:18:07 +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, 2015 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
@@ -558,8 +558,6 @@
              raise TypeError(
                  "`device` must be either a Touch or a Mouse instance.")
          self._device = device
--        self._x = 0
--        self._y = 0
      @property
      def x(self):
@@ -569,10 +567,7 @@
          last known X coordinate, which may not be a sensible value.
          """
--        if isinstance(self._device, Mouse):
--            return self._device.x
--        else:
--            return self._x
++        return self._device.x
      @property
      def y(self):
@@ -582,10 +577,7 @@
          last known Y coordinate, which may not be a sensible value.
          """
--        if isinstance(self._device, Mouse):
--            return self._device.y
--        else:
--            return self._y
++        return self._device.y
      def press(self, button=1):
          """Press the pointer at it's current location.
@@ -637,8 +629,8 @@
                  raise ValueError(
                      "Touch devices do not have button %d" % (button))
              self._device.tap(
--                self._x,
--                self._y,
++                self.x,
++                self.y,
                  press_duration=press_duration,
                  time_between_events=time_between_events
+             )
@@ -652,11 +644,7 @@
          :meth:`click` will occur.
          """
--        if isinstance(self._device, Mouse):
--            self._device.move(x, y)
--        else:
--            self._x = x
--            self._y = y
++        self._device.move(x, y)
      def click_object(
              self,
@@ -714,7 +702,7 @@
          if isinstance(self._device, Mouse):
              return self._device.position()
          else:
--            return (self._x, self._y)
++            return (self.x, self.y)
      def drag(self, x1, y1, x2, y2, rate=10, time_between_events=0.01):
          """Perform a press, move and release.
@@ -740,6 +728,3 @@
          """
          self._device.drag(
              x1, y1, x2, y2, rate=rate, time_between_events=time_between_events)
--        if isinstance(self._device, Touch):
--            self._x = x2
--            self._y = y2
 === modified file 'autopilot/input/_uinput.py'
 --- autopilot/input/_uinput.py	2014-10-30 23:42:46 +0000
 +++ autopilot/input/_uinput.py	2015-03-16 15:18:07 +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, 2014 Canonical
++# Copyright (C) 2012, 2013, 2014, 2015 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
@@ -458,6 +458,18 @@
          super(Touch, self).__init__()
          self._device = device_class()
          self.event_delayer = EventDelay()
++        self._x = 0
++        self._y = 0
++
++    @property
++    def x(self):
++        """Finger position X coordinate."""
++        return self._x
++
++    @property
++    def y(self):
++        """Finger position Y coordinate."""
++        return self._y
      @property
      def pressed(self):
@@ -472,10 +484,15 @@
          """
          _logger.debug("Tapping at: %d,%d", x, y)
          self.event_delayer.delay(time_between_events)
--        self._device.finger_down(x, y)
++        self._finger_down(x, y)
          sleep(press_duration)
          self._device.finger_up()
++    def _finger_down(self, x, y):
++        self._device.finger_down(x, y)
++        self._x = x
++        self._y = y
++
      def tap_object(self, object_, press_duration=0.1, time_between_events=0.1):
          """Click (or 'tap') a given object.
@@ -504,7 +521,7 @@
          """
          _logger.debug("Pressing at: %d,%d", x, y)
--        self._device.finger_down(x, y)
++        self._finger_down(x, y)
      def release(self):
          """Release a previously pressed finger.
@@ -515,15 +532,58 @@
          _logger.debug("Releasing")
          self._device.finger_up()
--    def move(self, x, y):
++    def move(self, x, y, animate=True, rate=10, time_between_events=0.01):
          """Moves the pointing "finger" to pos(x,y).
          NOTE: The finger has to be down for this to have any effect.
++        :param x: The point on the x axis where the move will end at.
++        :param y: The point on the y axis where the move will end at.
++        :param animate: Indicates if the move should be immediate or it should
++            be animated moving the finger slowly accross the screen as a real
++            user would do. By default, when the finger is down the finger is
++            animated. When the finger is up, the parameter is ignored and the
++            move is always immediate.
++        :type animate: boolean.
++        :param rate: The number of pixels the finger will be moved per
++            iteration. Default is 10 pixels. A higher rate will make the drag
++            faster, and lower rate will make it slower.
++        :param time_between_events: The number of seconds that the drag will
++            wait between iterations.
          :raises RuntimeError: if the finger is not pressed.
          """
--        self._device.finger_move(x, y)
++        if self.pressed:
++            if animate:
++                self._move_with_animation(x, y, rate, time_between_events)
++            else:
++                self._device.finger_move(x, y)
++        self._x = x
++        self._y = y
++
++    def _move_with_animation(self, x, y, rate, time_between_events):
++        current_x, current_y = self.x, self.y
++        while current_x != x or current_y != y:
++            dx = abs(x - current_x)
++            dy = abs(y - 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 x < current_x:
++                step_x *= -1
++            if y < current_y:
++                step_y *= -1
++
++            current_x += step_x
++            current_y += step_y
++
++            self._device.finger_move(current_x, current_y)
++
++            sleep(time_between_events)
      def drag(self, x1, y1, x2, y2, rate=10, time_between_events=0.01):
          """Perform a drag gesture.
@@ -548,30 +608,10 @@
          """
          _logger.debug("Dragging from %d,%d to %d,%d", x1, y1, x2, y2)
--        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(time_between_events)
--
++        self._finger_down(x1, y1)
++        self.move(
++            x2, y2, animate=True, rate=rate,
++            time_between_events=time_between_events)
          self._device.finger_up()
 === modified file 'autopilot/tests/functional/test_input_stack.py'
 --- autopilot/tests/functional/test_input_stack.py	2014-11-06 22:32:53 +0000
 +++ autopilot/tests/functional/test_input_stack.py	2015-03-16 15:18:07 +0000
@@ -484,8 +484,8 @@
          device = Pointer(Touch.create())
          device.move(34, 56)
--        self.assertThat(device._x, Equals(34))
--        self.assertThat(device._y, Equals(56))
++        self.assertThat(device.x, Equals(34))
++        self.assertThat(device.y, Equals(56))
      def test_touch_drag_updates_coordinates(self):
          """The Pointer wrapper must update it's x and y properties when
@@ -494,11 +494,13 @@
          """
          class FakeTouch(Touch):
              def __init__(self):
--                pass
++                self.x = 0
++                self.y = 0
              def drag(self, x1, y1, x2, y2, rate='dummy',
                       time_between_events='dummy'):
--                pass
++                self.x = x2
++                self.y = y2
          p = Pointer(FakeTouch())
          p.drag(0, 0, 100, 123)
 === modified file 'autopilot/tests/unit/test_input.py'
 --- autopilot/tests/unit/test_input.py	2014-10-30 23:42:46 +0000
 +++ autopilot/tests/unit/test_input.py	2015-03-16 15:18:07 +0000
@@ -1,7 +1,7 @@
  # -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+ #
  # Autopilot Functional Test Tool
--# Copyright (C) 2013, 2014 Canonical
++# Copyright (C) 2013, 2014, 2015 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
@@ -661,19 +661,65 @@
          self.assertFalse(touch.pressed)
--class UInputTouchTestCase(TestCase):
++class UInputTouchBaseTestCase(TestCase):
++
++    def setUp(self):
++        super(UInputTouchBaseTestCase, 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)
++        return touch
++
++
++class UInputTouchFingerCoordinatesTestCase(
++        testscenarios.TestWithScenarios, UInputTouchBaseTestCase):
++
++    TEST_X_DESTINATION = 10
++    TEST_Y_DESTINATION = 10
++
++    scenarios = [
++        ('tap', {
++            'method': 'tap',
++            'args': (TEST_X_DESTINATION, TEST_Y_DESTINATION)
++        }),
++        ('press', {
++            'method': 'press',
++            'args': (TEST_X_DESTINATION, TEST_Y_DESTINATION)
++        }),
++        ('move', {
++            'method': 'move',
++            'args': (TEST_X_DESTINATION, TEST_Y_DESTINATION)
++        }),
++        ('drag', {
++            'method': 'drag',
++            'args': (0, 0, TEST_X_DESTINATION, TEST_Y_DESTINATION)
++        })
++    ]
++
++    def call_scenario_method(self, object_, method, *args):
++        getattr(object_, method)(*self.args)
++
++    def test_method_must_update_finger_coordinates(self):
++        touch = self.get_touch_with_mocked_backend()
++
++        self.call_scenario_method(touch, self.method, *self.args)
++
++        self.assertEqual(touch.x, self.TEST_X_DESTINATION)
++        self.assertEqual(touch.y, self.TEST_Y_DESTINATION)
++
++
++class UInputTouchTestCase(UInputTouchBaseTestCase):
      """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 test_initial_coordinates_must_be_zero(self):
++        touch = self.get_touch_with_mocked_backend()
--    def get_touch_with_mocked_backend(self):
--        touch = _uinput.Touch(device_class=Mock)
--        touch._device.mock_add_spec(_uinput._UInputTouchDevice)
--        return touch
++        self.assertEqual(touch.x, 0)
++        self.assertEqual(touch.y, 0)
      def test_tap_must_put_finger_down_then_sleep_and_then_put_finger_up(self):
          expected_calls = [
@@ -720,52 +766,47 @@
          touch.move(10, 10)
          self.assertEqual(expected_calls, touch._device.mock_calls)
--    def test_drag_must_call_finger_down_move_and_up(self):
--        expected_calls = [
--            call.finger_down(0, 0),
--            call.finger_move(10, 10),
--            call.finger_up()
--        ]
--
--        touch = self.get_touch_with_mocked_backend()
--        touch.drag(0, 0, 10, 10)
--        self.assertEqual(expected_calls, touch._device.mock_calls)
--
--    def test_drag_must_move_with_specified_rate(self):
--        expected_calls = [
--            call.finger_down(0, 0),
++    def test_move_must_move_with_specified_rate(self):
++        expected_calls = [
              call.finger_move(5, 5),
              call.finger_move(10, 10),
              call.finger_move(15, 15),
--            call.finger_up()]
++        ]
          touch = self.get_touch_with_mocked_backend()
--        touch.drag(0, 0, 15, 15, rate=5)
++        touch.move(15, 15, rate=5)
          self.assertEqual(
              expected_calls, touch._device.mock_calls)
--    def test_drag_without_rate_must_use_default(self):
++    def test_move_without_rate_must_use_default(self):
          expected_calls = [
--            call.finger_down(0, 0),
              call.finger_move(10, 10),
              call.finger_move(20, 20),
--            call.finger_up()]
++        ]
          touch = self.get_touch_with_mocked_backend()
--        touch.drag(0, 0, 20, 20)
++        touch.move(20, 20)
          self.assertEqual(
              expected_calls, touch._device.mock_calls)
--    def test_drag_to_same_place_must_not_move(self):
++    def test_move_to_same_place_must_not_move(self):
++        expected_calls = []
++
++        touch = self.get_touch_with_mocked_backend()
++        touch.move(0, 0)
++        self.assertEqual(expected_calls, touch._device.mock_calls)
++
++    def test_drag_must_call_finger_down_move_and_up(self):
          expected_calls = [
              call.finger_down(0, 0),
++            call.finger_move(10, 10),
              call.finger_up()
+         ]
          touch = self.get_touch_with_mocked_backend()
--        touch.drag(0, 0, 0, 0)
++        touch.drag(0, 0, 10, 10)
          self.assertEqual(expected_calls, touch._device.mock_calls)
      def test_tap_without_press_duration_must_sleep_default_time(self):
@@ -848,55 +889,56 @@
          self.assertFalse(finger2.pressed)
--class DragUInputTouchTestCase(testscenarios.TestWithScenarios, TestCase):
++class MoveWithAnimationUInputTouchTestCase(
++        testscenarios.TestWithScenarios, TestCase):
      scenarios = [
--        ('drag to top', dict(
++        ('move to top', dict(
              start_x=50, start_y=50, stop_x=50, stop_y=30,
              expected_moves=[call.finger_move(50, 40),
                              call.finger_move(50, 30)])),
--        ('drag to bottom', dict(
++        ('move to bottom', dict(
              start_x=50, start_y=50, stop_x=50, stop_y=70,
              expected_moves=[call.finger_move(50, 60),
                              call.finger_move(50, 70)])),
--        ('drag to left', dict(
++        ('move to left', dict(
              start_x=50, start_y=50, stop_x=30, stop_y=50,
              expected_moves=[call.finger_move(40, 50),
                              call.finger_move(30, 50)])),
--        ('drag to right', dict(
++        ('move to right', dict(
              start_x=50, start_y=50, stop_x=70, stop_y=50,
              expected_moves=[call.finger_move(60, 50),
                              call.finger_move(70, 50)])),
--        ('drag to top-left', dict(
++        ('move to top-left', dict(
              start_x=50, start_y=50, stop_x=30, stop_y=30,
              expected_moves=[call.finger_move(40, 40),
                              call.finger_move(30, 30)])),
--        ('drag to top-right', dict(
++        ('move to top-right', dict(
              start_x=50, start_y=50, stop_x=70, stop_y=30,
              expected_moves=[call.finger_move(60, 40),
                              call.finger_move(70, 30)])),
--        ('drag to bottom-left', dict(
++        ('move to bottom-left', dict(
              start_x=50, start_y=50, stop_x=30, stop_y=70,
              expected_moves=[call.finger_move(40, 60),
                              call.finger_move(30, 70)])),
--        ('drag to bottom-right', dict(
++        ('move to bottom-right', dict(
              start_x=50, start_y=50, stop_x=70, stop_y=70,
              expected_moves=[call.finger_move(60, 60),
                              call.finger_move(70, 70)])),
--        ('drag less than rate', dict(
++        ('move less than rate', dict(
              start_x=50, start_y=50, stop_x=55, stop_y=55,
              expected_moves=[call.finger_move(55, 55)])),
--        ('drag with last move less than rate', dict(
++        ('move with last move less than rate', dict(
              start_x=50, start_y=50, stop_x=65, stop_y=65,
              expected_moves=[call.finger_move(60, 60),
                              call.finger_move(65, 65)])),
+     ]
      def setUp(self):
--        super(DragUInputTouchTestCase, self).setUp()
++        super(MoveWithAnimationUInputTouchTestCase, 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()
@@ -910,12 +952,12 @@
      def test_drag_moves(self):
          touch = self.get_touch_with_mocked_backend()
--        touch.drag(
--            self.start_x, self.start_y, self.stop_x, self.stop_y)
++        touch.press(self.start_x, self.start_y)
++        touch.move(self.stop_x, self.stop_y)
--        # We don't check the finger down and finger up. They are already
--        # tested.
--        expected_calls = [ANY] + self.expected_moves + [ANY]
++        expected_calls = (
++            [call.finger_down(self.start_x, self.start_y)] +
++            self.expected_moves)
          self.assertEqual(
              expected_calls, touch._device.mock_calls)
@@ -929,6 +971,30 @@
          pointer = autopilot.input.Pointer(touch)
          return pointer
++    def test_initial_coordinates_must_be_zero(self):
++        pointer = self.get_pointer_with_touch_backend_with_mock_device()
++
++        self.assertEqual(pointer.x, 0)
++        self.assertEqual(pointer.y, 0)
++
++    def test_drag_must_call_move_with_animation(self):
++        test_rate = 2
++        test_time_between_events = 1
++        test_destination_x = 20
++        test_destination_y = 20
++
++        pointer = self.get_pointer_with_touch_backend_with_mock_device()
++        with patch.object(pointer._device, 'move') as mock_move:
++            pointer.drag(
++                0, 0,
++                test_destination_x, test_destination_y,
++                rate=test_rate, time_between_events=test_time_between_events)
++
++        mock_move.assert_called_once_with(
++            test_destination_x, test_destination_y,
++            animate=True,
++            rate=test_rate, time_between_events=test_time_between_events)
++
      def test_drag_with_rate(self):
          pointer = self.get_pointer_with_touch_backend_with_mock_device()
          with patch.object(pointer._device, 'drag') as mock_drag:
@@ -968,3 +1034,40 @@
          mock_tap.assert_called_once_with(
 , 0, press_duration=10, time_between_events=0.1)
++
++    def test_not_pressed_move_must_not_move_pointing_figer(self):
++        """Test for moving the finger when it is not pressed.
++
++        The move method on the pointer class must update the finger coordinates
++        but it must not execute a move on the device.
++
++        """
++        test_x_destination = 20
++        test_y_destination = 20
++        pointer = self.get_pointer_with_touch_backend_with_mock_device()
++
++        pointer.move(10, 10)
++        pointer._device._device.pressed = False
++
++        with patch.object(pointer._device._device, 'finger_move') as mock_move:
++            pointer.move(test_x_destination, test_y_destination)
++
++        self.assertFalse(mock_move.called)
++        self.assertEqual(pointer.x, test_x_destination)
++        self.assertEqual(pointer.y, test_y_destination)
++
++    def test_pressed_move_must_move_pointing_finger(self):
++        test_x_destination = 20
++        test_y_destination = 20
++
++        pointer = self.get_pointer_with_touch_backend_with_mock_device()
++
++        pointer.move(10, 10)
++        pointer._device._device.pressed = True
++
++        with patch.object(pointer._device._device, 'finger_move') as mock_move:
++            pointer.move(test_x_destination, test_y_destination)
++
++        mock_move.assert_called_once_with(20, 20)
++        self.assertEqual(pointer.x, test_x_destination)
++        self.assertEqual(pointer.y, test_y_destination)

Autopilot

Merge lp:~canonical-platform-qa/autopilot/fix1266601-Pointer-pressed-move-2 into lp:autopilot

Commit Message

Description of the Change

Preview Diff

Subscribers