1
=== modified file 'autopilot/input/_X11.py'
2
--- autopilot/input/_X11.py	2013-11-07 05:53:36 +0000
3
+++ autopilot/input/_X11.py	2014-02-11 12:23:36 +0000
4
@@ -1,7 +1,7 @@
5
1
# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
1
# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
6
2
#
2
#
7
3
# Autopilot Functional Test Tool
3
# Autopilot Functional Test Tool
9
4
# Copyright (C) 2012-2013 Canonical
4
# Copyright (C) 2012, 2013, 2014 Canonical
10
5
#
5
#
11
6
# This program is free software: you can redistribute it and/or modify
6
# This program is free software: you can redistribute it and/or modify
12
7
# it under the terms of the GNU General Public License as published by
7
# it under the terms of the GNU General Public License as published by
13
@@ -455,16 +455,31 @@
14
455
        x, y = coord["root_x"], coord["root_y"]
455
        x, y = coord["root_x"], coord["root_y"]
15
456
        return x, y
456
        return x, y
16
457
457
19
458
    def drag(self, x1, y1, x2, y2):
458
    def drag(self, x1, y1, x2, y2, rate=10, time_between_events=0.01):
20
459
        """Performs a press, move and release.
459
        """Perform a press, move and release.
21
460
460
22
461
        This is to keep a common API between Mouse and Finger as long as
461
        This is to keep a common API between Mouse and Finger as long as
23
462
        possible.
462
        possible.
24
463
463
25
464
        The pointer will be dragged from the starting point to the ending point
26
465
        with multiple moves. The number of moves, and thus the time that it
27
466
        will take to complete the drag can be altered with the `rate`
28
467
        parameter.
29
468
30
469
        :param x1: The point on the x axis where the drag will start from.
31
470
        :param y1: The point on the y axis where the drag will starts from.
32
471
        :param x2: The point on the x axis where the drag will end at.
33
472
        :param y2: The point on the y axis where the drag will end at.
34
473
        :param rate: The number of pixels the mouse will be moved per
35
474
            iteration. Default is 10 pixels. A higher rate will make the drag
36
475
            faster, and lower rate will make it slower.
37
476
        :param time_between_events: The number of seconds that the drag will
38
477
            wait between iterations.
39
478
40
464
        """
479
        """
41
465
        self.move(x1, y1)
480
        self.move(x1, y1)
42
466
        self.press()
481
        self.press()
44
467
        self.move(x2, y2)
482
        self.move(x2, y2, rate=rate, time_between_events=time_between_events)
45
468
        self.release()
483
        self.release()
46
469
484
47
470
    @classmethod
485
    @classmethod
48
471
486
49
=== modified file 'autopilot/input/__init__.py'
50
--- autopilot/input/__init__.py	2013-09-20 19:01:27 +0000
51
+++ autopilot/input/__init__.py	2014-02-11 12:23:36 +0000
52
@@ -369,12 +369,27 @@
53
369
        """
369
        """
54
370
        raise NotImplementedError("You cannot use this class directly.")
370
        raise NotImplementedError("You cannot use this class directly.")
55
371
371
58
372
    def drag(self, x1, y1, x2, y2):
372
    def drag(self, x1, y1, x2, y2, rate=10, time_between_events=0.01):
59
373
        """Performs a press, move and release.
373
        """Perform a press, move and release.
60
374
374
61
375
        This is to keep a common API between Mouse and Finger as long as
375
        This is to keep a common API between Mouse and Finger as long as
62
376
        possible.
376
        possible.
63
377
377
64
378
        The pointer will be dragged from the starting point to the ending point
65
379
        with multiple moves. The number of moves, and thus the time that it
66
380
        will take to complete the drag can be altered with the `rate`
67
381
        parameter.
68
382
69
383
        :param x1: The point on the x axis where the drag will start from.
70
384
        :param y1: The point on the y axis where the drag will starts from.
71
385
        :param x2: The point on the x axis where the drag will end at.
72
386
        :param y2: The point on the y axis where the drag will end at.
73
387
        :param rate: The number of pixels the mouse will be moved per
74
388
            iteration. Default is 10 pixels. A higher rate will make the drag
75
389
            faster, and lower rate will make it slower.
76
390
        :param time_between_events: The number of seconds that the drag will
77
391
            wait between iterations.
78
392
79
378
        """
393
        """
80
379
        raise NotImplementedError("You cannot use this class directly.")
394
        raise NotImplementedError("You cannot use this class directly.")
81
380
395
82
@@ -466,8 +481,28 @@
83
466
        """Release a previously pressed finger"""
481
        """Release a previously pressed finger"""
84
467
        raise NotImplementedError("You cannot use this class directly.")
482
        raise NotImplementedError("You cannot use this class directly.")
85
468
483
88
469
    def drag(self, x1, y1, x2, y2):
484
    def drag(self, x1, y1, x2, y2, rate=10, time_between_events=0.01):
89
470
        """Perform a drag gesture from (x1,y1) to (x2,y2)"""
485
        """Perform a drag gesture.
90
486
91
487
        The finger will be dragged from the starting point to the ending point
92
488
        with multiple moves. The number of moves, and thus the time that it
93
489
        will take to complete the drag can be altered with the `rate`
94
490
        parameter.
95
491
96
492
        :param x1: The point on the x axis where the drag will start from.
97
493
        :param y1: The point on the y axis where the drag will starts from.
98
494
        :param x2: The point on the x axis where the drag will end at.
99
495
        :param y2: The point on the y axis where the drag will end at.
100
496
        :param rate: The number of pixels the finger will be moved per
101
497
            iteration. Default is 10 pixels. A higher rate will make the drag
102
498
            faster, and lower rate will make it slower.
103
499
        :param time_between_events: The number of seconds that the drag will
104
500
            wait between iterations.
105
501
106
502
        :raises RuntimeError: if the finger is already pressed.
107
503
        :raises RuntimeError: if no more finger slots are available.
108
504
109
505
        """
110
471
        raise NotImplementedError("You cannot use this class directly.")
506
        raise NotImplementedError("You cannot use this class directly.")
111
472
507
112
473
508
113
@@ -641,9 +676,30 @@
114
641
        else:
676
        else:
115
642
            return (self._x, self._y)
677
            return (self._x, self._y)
116
643
678
120
644
    def drag(self, x1, y1, x2, y2):
679
    def drag(self, x1, y1, x2, y2, rate=10, time_between_events=0.01):
121
645
        """Performs a press, move and release."""
680
        """Perform a press, move and release.
122
646
        self._device.drag(x1, y1, x2, y2)
681
123
682
        This is to keep a common API between Mouse and Finger as long as
124
683
        possible.
125
684
126
685
        The pointer will be dragged from the starting point to the ending point
127
686
        with multiple moves. The number of moves, and thus the time that it
128
687
        will take to complete the drag can be altered with the `rate`
129
688
        parameter.
130
689
131
690
        :param x1: The point on the x axis where the drag will start from.
132
691
        :param y1: The point on the y axis where the drag will starts from.
133
692
        :param x2: The point on the x axis where the drag will end at.
134
693
        :param y2: The point on the y axis where the drag will end at.
135
694
        :param rate: The number of pixels the mouse will be moved per
136
695
            iteration. Default is 10 pixels. A higher rate will make the drag
137
696
            faster, and lower rate will make it slower.
138
697
        :param time_between_events: The number of seconds that the drag will
139
698
            wait between iterations.
140
699
141
700
        """
142
701
        self._device.drag(
143
702
            x1, y1, x2, y2, rate=rate, time_between_events=time_between_events)
144
647
        if isinstance(self._device, Touch):
703
        if isinstance(self._device, Touch):
145
648
            self._x = x2
704
            self._x = x2
146
649
            self._y = y2
705
            self._y = y2
147
650
706
148
=== modified file 'autopilot/input/_uinput.py'
149
--- autopilot/input/_uinput.py	2014-02-11 12:23:36 +0000
150
+++ autopilot/input/_uinput.py	2014-02-11 12:23:36 +0000
151
@@ -521,8 +521,23 @@
152
521
        """
521
        """
153
522
        self._device.finger_move(x, y)
522
        self._device.finger_move(x, y)
154
523
523
157
524
    def drag(self, x1, y1, x2, y2):
524
    def drag(self, x1, y1, x2, y2, rate=10, time_between_events=0.01):
158
525
        """Perform a drag gesture from (x1,y1) to (x2,y2).
525
        """Perform a drag gesture.
159
526
160
527
        The finger will be dragged from the starting point to the ending point
161
528
        with multiple moves. The number of moves, and thus the time that it
162
529
        will take to complete the drag can be altered with the `rate`
163
530
        parameter.
164
531
165
532
        :param x1: The point on the x axis where the drag will start from.
166
533
        :param y1: The point on the y axis where the drag will starts from.
167
534
        :param x2: The point on the x axis where the drag will end at.
168
535
        :param y2: The point on the y axis where the drag will end at.
169
536
        :param rate: The number of pixels the finger will be moved per
170
537
            iteration. Default is 10 pixels. A higher rate will make the drag
171
538
            faster, and lower rate will make it slower.
172
539
        :param time_between_events: The number of seconds that the drag will
173
540
            wait between iterations.
174
526
541
175
527
        :raises RuntimeError: if the finger is already pressed.
542
        :raises RuntimeError: if the finger is already pressed.
176
528
        :raises RuntimeError: if no more finger slots are available.
543
        :raises RuntimeError: if no more finger slots are available.
177
@@ -531,18 +546,28 @@
178
531
        logger.debug("Dragging from %d,%d to %d,%d", x1, y1, x2, y2)
546
        logger.debug("Dragging from %d,%d to %d,%d", x1, y1, x2, y2)
179
532
        self._device.finger_down(x1, y1)
547
        self._device.finger_down(x1, y1)
180
533
548
193
534
        # Let's drag in 100 steps for now...
549
        current_x, current_y = x1, y1
194
535
        dx = 1.0 * (x2 - x1) / 100
550
        while current_x != x2 or current_y != y2:
195
536
        dy = 1.0 * (y2 - y1) / 100
551
            dx = abs(x2 - current_x)
196
537
        cur_x = x1 + dx
552
            dy = abs(y2 - current_y)
197
538
        cur_y = y1 + dy
553
198
539
        for i in range(0, 100):
554
            intx = float(dx) / max(dx, dy)
199
540
            self._device.finger_move(int(cur_x), int(cur_y))
555
            inty = float(dy) / max(dx, dy)
200
541
            sleep(0.002)
556
201
542
            cur_x += dx
557
            step_x = min(rate * intx, dx)
202
543
            cur_y += dy
558
            step_y = min(rate * inty, dy)
203
544
        # Make sure we actually end up at target
559
204
545
        self._device.finger_move(x2, y2)
560
            if x2 < current_x:
205
561
                step_x *= -1
206
562
            if y2 < current_y:
207
563
                step_y *= -1
208
564
209
565
            current_x += step_x
210
566
            current_y += step_y
211
567
            self._device.finger_move(current_x, current_y)
212
568
213
569
            sleep(time_between_events)
214
570
215
546
        self._device.finger_up()
571
        self._device.finger_up()
216
547
572
217
548
573
218
549
574
219
=== modified file 'autopilot/tests/functional/test_input_stack.py'
220
--- autopilot/tests/functional/test_input_stack.py	2014-02-11 12:23:36 +0000
221
+++ autopilot/tests/functional/test_input_stack.py	2014-02-11 12:23:36 +0000
222
@@ -487,7 +487,8 @@
223
487
            def __init__(self):
487
            def __init__(self):
224
488
                pass
488
                pass
225
489
489
227
490
            def drag(self, x1, y1, x2, y2):
490
            def drag(self, x1, y1, x2, y2, rate='dummy',
228
491
                     time_between_events='dummy'):
229
491
                pass
492
                pass
230
492
493
231
493
        p = Pointer(FakeTouch())
494
        p = Pointer(FakeTouch())
232
494
495
233
=== modified file 'autopilot/tests/unit/test_input.py'
234
--- autopilot/tests/unit/test_input.py	2014-02-11 12:23:36 +0000
235
+++ autopilot/tests/unit/test_input.py	2014-02-11 12:23:36 +0000
236
@@ -19,14 +19,15 @@
237
19
19
238
20
import testscenarios
20
import testscenarios
239
21
from evdev import ecodes, uinput
21
from evdev import ecodes, uinput
241
22
from mock import ANY, call, patch, Mock
22
from mock import ANY, call, Mock, patch
242
23
from six import StringIO
23
from six import StringIO
243
24
from testtools import TestCase
24
from testtools import TestCase
244
25
from testtools.matchers import Contains, raises
25
from testtools.matchers import Contains, raises
245
26
26
246
27
import autopilot.input
247
28
from autopilot import utilities
248
27
from autopilot.input import _uinput
29
from autopilot.input import _uinput
249
28
from autopilot.input._common import get_center_point
30
from autopilot.input._common import get_center_point
250
29
from autopilot import utilities
251
30
31
252
31
32
253
32
class Empty(object):
33
class Empty(object):
254
@@ -698,6 +699,54 @@
255
698
        touch.move(10, 10)
699
        touch.move(10, 10)
256
699
        self.assertEqual(expected_calls, touch._device.mock_calls)
700
        self.assertEqual(expected_calls, touch._device.mock_calls)
257
700
701
258
702
    def test_drag_must_call_finger_down_move_and_up(self):
259
703
        expected_calls = [
260
704
            call.finger_down(0, 0),
261
705
            call.finger_move(10, 10),
262
706
            call.finger_up()
263
707
        ]
264
708
265
709
        touch = self.get_touch_with_mocked_backend()
266
710
        touch.drag(0, 0, 10, 10)
267
711
        self.assertEqual(expected_calls, touch._device.mock_calls)
268
712
269
713
    def test_drag_must_move_with_specified_rate(self):
270
714
        expected_calls = [
271
715
            call.finger_down(0, 0),
272
716
            call.finger_move(5, 5),
273
717
            call.finger_move(10, 10),
274
718
            call.finger_move(15, 15),
275
719
            call.finger_up()]
276
720
277
721
        touch = self.get_touch_with_mocked_backend()
278
722
        touch.drag(0, 0, 15, 15, rate=5)
279
723
280
724
        self.assertEqual(
281
725
            expected_calls, touch._device.mock_calls)
282
726
283
727
    def test_drag_without_rate_must_use_default(self):
284
728
        expected_calls = [
285
729
            call.finger_down(0, 0),
286
730
            call.finger_move(10, 10),
287
731
            call.finger_move(20, 20),
288
732
            call.finger_up()]
289
733
290
734
        touch = self.get_touch_with_mocked_backend()
291
735
        touch.drag(0, 0, 20, 20)
292
736
293
737
        self.assertEqual(
294
738
            expected_calls, touch._device.mock_calls)
295
739
296
740
    def test_drag_to_same_place_must_not_move(self):
297
741
        expected_calls = [
298
742
            call.finger_down(0, 0),
299
743
            call.finger_up()
300
744
        ]
301
745
302
746
        touch = self.get_touch_with_mocked_backend()
303
747
        touch.drag(0, 0, 0, 0)
304
748
        self.assertEqual(expected_calls, touch._device.mock_calls)
305
749
306
701
750
307
702
class MultipleUInputTouchBackend(_uinput._UInputTouchDevice):
751
class MultipleUInputTouchBackend(_uinput._UInputTouchDevice):
308
703
752
309
@@ -731,3 +780,109 @@
310
731
        self.addCleanup(finger1.release)
780
        self.addCleanup(finger1.release)
311
732
781
312
733
        self.assertFalse(finger2.pressed)
782
        self.assertFalse(finger2.pressed)
313
783
314
784
315
785
class DragUInputTouchTestCase(testscenarios.TestWithScenarios, TestCase):
316
786
317
787
    scenarios = [
318
788
        ('drag to top', dict(
319
789
            start_x=50, start_y=50, stop_x=50, stop_y=30,
320
790
            expected_moves=[call.finger_move(50, 40),
321
791
                            call.finger_move(50, 30)])),
322
792
        ('drag to bottom', dict(
323
793
            start_x=50, start_y=50, stop_x=50, stop_y=70,
324
794
            expected_moves=[call.finger_move(50, 60),
325
795
                            call.finger_move(50, 70)])),
326
796
        ('drag to left', dict(
327
797
            start_x=50, start_y=50, stop_x=30, stop_y=50,
328
798
            expected_moves=[call.finger_move(40, 50),
329
799
                            call.finger_move(30, 50)])),
330
800
        ('drag to right', dict(
331
801
            start_x=50, start_y=50, stop_x=70, stop_y=50,
332
802
            expected_moves=[call.finger_move(60, 50),
333
803
                            call.finger_move(70, 50)])),
334
804
335
805
        ('drag to top-left', dict(
336
806
            start_x=50, start_y=50, stop_x=30, stop_y=30,
337
807
            expected_moves=[call.finger_move(40, 40),
338
808
                            call.finger_move(30, 30)])),
339
809
        ('drag to top-right', dict(
340
810
            start_x=50, start_y=50, stop_x=70, stop_y=30,
341
811
            expected_moves=[call.finger_move(60, 40),
342
812
                            call.finger_move(70, 30)])),
343
813
        ('drag to bottom-left', dict(
344
814
            start_x=50, start_y=50, stop_x=30, stop_y=70,
345
815
            expected_moves=[call.finger_move(40, 60),
346
816
                            call.finger_move(30, 70)])),
347
817
        ('drag to bottom-right', dict(
348
818
            start_x=50, start_y=50, stop_x=70, stop_y=70,
349
819
            expected_moves=[call.finger_move(60, 60),
350
820
                            call.finger_move(70, 70)])),
351
821
352
822
        ('drag less than rate', dict(
353
823
            start_x=50, start_y=50, stop_x=55, stop_y=55,
354
824
            expected_moves=[call.finger_move(55, 55)])),
355
825
356
826
        ('drag with last move less than rate', dict(
357
827
            start_x=50, start_y=50, stop_x=65, stop_y=65,
358
828
            expected_moves=[call.finger_move(60, 60),
359
829
                            call.finger_move(65, 65)])),
360
830
    ]
361
831
362
832
    def setUp(self):
363
833
        super(DragUInputTouchTestCase, self).setUp()
364
834
        # Mock the sleeps so we don't have to spend time actually sleeping.
365
835
        self.addCleanup(utilities.sleep.disable_mock)
366
836
        utilities.sleep.enable_mock()
367
837
368
838
    def get_touch_with_mocked_backend(self):
369
839
        touch = _uinput.Touch(device_class=Mock)
370
840
        touch._device.mock_add_spec(
371
841
            _uinput._UInputTouchDevice, spec_set=True)
372
842
        return touch
373
843
374
844
    def test_drag_moves(self):
375
845
        touch = self.get_touch_with_mocked_backend()
376
846
377
847
        touch.drag(
378
848
            self.start_x, self.start_y, self.stop_x, self.stop_y)
379
849
380
850
        # We don't check the finger down and finger up. They are already
381
851
        # tested.
382
852
        expected_calls = [ANY] + self.expected_moves + [ANY]
383
853
        self.assertEqual(
384
854
            expected_calls, touch._device.mock_calls)
385
855
386
856
387
857
class PointerWithTouchBackendTestCase(TestCase):
388
858
389
859
    def get_pointer_with_touch_backend_with_mock_device(self):
390
860
        touch = _uinput.Touch(device_class=Mock)
391
861
        touch._device.mock_add_spec(
392
862
            _uinput._UInputTouchDevice, spec_set=True)
393
863
        pointer = autopilot.input.Pointer(touch)
394
864
        return pointer
395
865
396
866
    def test_drag_with_rate(self):
397
867
        pointer = self.get_pointer_with_touch_backend_with_mock_device()
398
868
        with patch.object(pointer._device, 'drag') as mock_drag:
399
869
            pointer.drag(0, 0, 20, 20, rate='test')
400
870
401
871
        mock_drag.assert_called_once_with(
402
872
            0, 0, 20, 20, rate='test', time_between_events=0.01)
403
873
404
874
    def test_drag_with_time_between_events(self):
405
875
        pointer = self.get_pointer_with_touch_backend_with_mock_device()
406
876
        with patch.object(pointer._device, 'drag') as mock_drag:
407
877
            pointer.drag(0, 0, 20, 20, time_between_events='test')
408
878
409
879
        mock_drag.assert_called_once_with(
410
880
            0, 0, 20, 20, rate=10, time_between_events='test')
411
881
412
882
    def test_drag_with_default_parameters(self):
413
883
        pointer = self.get_pointer_with_touch_backend_with_mock_device()
414
884
        with patch.object(pointer._device, 'drag') as mock_drag:
415
885
            pointer.drag(0, 0, 20, 20)
416
886
417
887
        mock_drag.assert_called_once_with(
418
888
            0, 0, 20, 20, rate=10, time_between_events=0.01)
Reviewer	Review Type	Date Requested	Status
Thomi Richards (community)		2014-02-11	Approve on 2014-02-12
PS Jenkins bot	continuous-integration	2014-02-11	Approve on 2014-02-11
Leo Arias			Pending
Review via email: mp+205702@code.launchpad.net