• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
2# Use of this source code is governed by a BSD-style license that can be
3# found in the LICENSE file.
4#
5
6"""This module contains unit tests for the classes in the validators module."""
7
8import glob
9import os.path
10import unittest
11
12import common_unittest_utils
13import common_util
14import test_conf as conf
15import validators
16
17from common_unittest_utils import create_mocked_devices, parse_tests_data
18from firmware_constants import AXIS, GV, MTB, PLATFORM, VAL
19from firmware_log import MetricNameProps
20from geometry.elements import Point
21from touch_device import TouchDevice
22from validators import (CountPacketsValidator,
23                        CountTrackingIDValidator,
24                        DiscardInitialSecondsValidator,
25                        DrumrollValidator,
26                        HysteresisValidator,
27                        LinearityValidator,
28                        MtbSanityValidator,
29                        NoGapValidator,
30                        NoLevelJumpValidator,
31                        NoReversedMotionValidator,
32                        PhysicalClickValidator,
33                        PinchValidator,
34                        RangeValidator,
35                        ReportRateValidator,
36                        StationaryFingerValidator,
37                        StationaryTapValidator,
38)
39
40
41unittest_path_lumpy = os.path.join(os.getcwd(), 'tests/logs/lumpy')
42mocked_device = create_mocked_devices()
43
44# Make short aliases for supported platforms
45alex = mocked_device[PLATFORM.ALEX]
46lumpy = mocked_device[PLATFORM.LUMPY]
47link = mocked_device[PLATFORM.LINK]
48# Some tests do not care what device is used.
49dontcare = 'dontcare'
50
51
52class CountTrackingIDValidatorTest(unittest.TestCase):
53    """Unit tests for CountTrackingIDValidator class."""
54
55    def _test_count_tracking_id(self, filename, criteria, device):
56        packets = parse_tests_data(filename)
57        validator = CountTrackingIDValidator(criteria, device=device)
58        vlog = validator.check(packets)
59        return vlog.score
60
61    def test_two_finger_id_change(self):
62        """Two two fingers id change.
63
64        Issue 7867: Cyapa : Two finger scroll, tracking ids change
65        """
66        filename = 'two_finger_id_change.dat'
67        score = self._test_count_tracking_id(filename, '== 2', lumpy)
68        self.assertTrue(score == 0)
69
70    def test_one_finger_fast_swipe_id_split(self):
71        """One finger fast swipe resulting in IDs split.
72
73        Issue: 7869: Lumpy: Tracking ID reassigned during quick-2F-swipe
74        """
75        filename = 'one_finger_fast_swipe_id_split.dat'
76        score = self._test_count_tracking_id(filename, '== 1', lumpy)
77        self.assertTrue(score == 0)
78
79    def test_two_fingers_fast_flick_id_split(self):
80        """Two figners fast flick resulting in IDs split.
81
82        Issue: 7869: Lumpy: Tracking ID reassigned during quick-2F-swipe
83        """
84        filename = 'two_finger_fast_flick_id_split.dat'
85        score = self._test_count_tracking_id(filename, '== 2', lumpy)
86        self.assertTrue(score == 0)
87
88
89class DrumrollValidatorTest(unittest.TestCase):
90    """Unit tests for DrumrollValidator class."""
91
92    def setUp(self):
93        self.criteria = conf.drumroll_criteria
94
95    def _test_drumroll(self, filename, criteria, device):
96        packets = parse_tests_data(filename)
97        validator = DrumrollValidator(criteria, device=device)
98        vlog = validator.check(packets)
99        return vlog.score
100
101    def _get_drumroll_metrics(self, filename, criteria, device):
102        packets = parse_tests_data(filename, gesture_dir=unittest_path_lumpy)
103        validator = DrumrollValidator(criteria, device=device)
104        metrics = validator.check(packets).metrics
105        return metrics
106
107    def test_drumroll_lumpy(self):
108        """Should catch the drumroll on lumpy.
109
110        Issue 7809: Lumpy: Drumroll bug in firmware
111        Max distance: 52.02 px
112        """
113        filename = 'drumroll_lumpy.dat'
114        score = self._test_drumroll(filename, self.criteria, lumpy)
115        self.assertTrue(score == 0)
116
117    def test_drumroll_lumpy_1(self):
118        """Should catch the drumroll on lumpy.
119
120        Issue 7809: Lumpy: Drumroll bug in firmware
121        Max distance: 43.57 px
122        """
123        filename = 'drumroll_lumpy_1.dat'
124        score = self._test_drumroll(filename, self.criteria, lumpy)
125        self.assertTrue(score <= 0.15)
126
127    def test_no_drumroll_link(self):
128        """Should pass (score == 1) when there is no drumroll.
129
130        Issue 7809: Lumpy: Drumroll bug in firmware
131        Max distance: 2.92 px
132        """
133        filename = 'no_drumroll_link.dat'
134        score = self._test_drumroll(filename, self.criteria, link)
135        self.assertTrue(score == 1)
136
137    def test_drumroll_metrics(self):
138        """Test the drumroll metrics."""
139        expected_max_values = {
140            '20130506_030025-fw_11.27-robot_sim/'
141            'drumroll.fast-lumpy-fw_11.27-manual-20130528_044804.dat':
142            2.29402908535,
143
144            '20130506_030025-fw_11.27-robot_sim/'
145            'drumroll.fast-lumpy-fw_11.27-manual-20130528_044820.dat':
146            0.719567771497,
147
148            '20130506_031746-fw_11.27-robot_sim/'
149            'drumroll.fast-lumpy-fw_11.27-manual-20130528_044728.dat':
150            0.833491481592,
151
152            '20130506_032458-fw_11.23-robot_sim/'
153            'drumroll.fast-lumpy-fw_11.23-manual-20130528_044856.dat':
154            1.18368539364,
155
156            '20130506_032458-fw_11.23-robot_sim/'
157            'drumroll.fast-lumpy-fw_11.23-manual-20130528_044907.dat':
158            0.851161282019,
159
160            '20130506_032659-fw_11.23-robot_sim/'
161            'drumroll.fast-lumpy-fw_11.23-manual-20130528_044933.dat':
162            2.64245519251,
163
164            '20130506_032659-fw_11.23-robot_sim/'
165            'drumroll.fast-lumpy-fw_11.23-manual-20130528_044947.dat':
166            0.910624022916,
167        }
168        criteria = self.criteria
169        for filename, expected_max_value in expected_max_values.items():
170            metrics = self._get_drumroll_metrics(filename, criteria, lumpy)
171            actual_max_value = max([m.value for m in metrics])
172            self.assertAlmostEqual(expected_max_value, actual_max_value)
173
174
175class LinearityValidatorTest(unittest.TestCase):
176    """Unit tests for LinearityValidator class."""
177
178    def setUp(self):
179        self.validator = LinearityValidator(conf.linearity_criteria,
180                                            device=lumpy, finger=0)
181        self.validator.init_check()
182
183    def test_simple_linear_regression0(self):
184        """A perfect y-t line from bottom left to top right"""
185        list_y = [20, 40, 60, 80, 100, 120, 140, 160]
186        list_t = [i * 0.1 for i in range(len(list_y))]
187        (max_err_px, rms_err_px) = self.validator._calc_errors_single_axis(
188                list_t, list_y)
189        self.assertAlmostEqual(max_err_px, 0)
190        self.assertAlmostEqual(rms_err_px, 0)
191
192    def test_simple_linear_regression0b(self):
193        """An imperfect y-t line from bottom left to top right with
194        the first and the last entries as outliers.
195
196        In this test case:
197          begin segment = [1,]
198          end segment = [188, 190]
199          middle segment = [20, 40, 60, 80, 100, 120, 140, 160]
200
201          the simple linear regression line is calculated based on the
202          middle segment, and is
203            y = 20 * t
204          the error = [1, 0, 0, 0, 0, 0, 0, 0, 0, 8, 10]
205        """
206        list_y = [1, 20, 40, 60, 80, 100, 120, 140, 160, 188, 190]
207        list_t = range(len(list_y))
208
209        expected_errs_dict = {
210            VAL.WHOLE: [1, 0, 0, 0, 0, 0, 0, 0, 0, 8, 10],
211            VAL.BEGIN: [1, ],
212            VAL.END: [8, 10],
213            VAL.BOTH_ENDS: [1, 8, 10],
214        }
215
216        for segment_flag, expected_errs in expected_errs_dict.items():
217            self.validator._segments= segment_flag
218            (max_err, rms_err) = self.validator._calc_errors_single_axis(list_t,
219                                                                         list_y)
220            expected_max_err = max(expected_errs)
221            expected_rms_err = (sum([i ** 2 for i in expected_errs]) /
222                                len(expected_errs)) ** 0.5
223            self.assertAlmostEqual(max_err, expected_max_err)
224            self.assertAlmostEqual(rms_err, expected_rms_err)
225
226    def test_log_details_and_metrics(self):
227        """Test the axes in _log_details_and_metrics"""
228        # gesture_dir: tests/data/linearity
229        gesture_dir = 'linearity'
230        filenames_axes = {
231            'two_finger_tracking.right_to_left.slow-lumpy-fw_11.27-robot-'
232                '20130227_204458.dat': [AXIS.X],
233            'one_finger_to_edge.center_to_top.slow-lumpy-fw_11.27-robot-'
234                '20130227_203228.dat': [AXIS.Y],
235            'two_finger_tracking.bottom_left_to_top_right.normal-lumpy-'
236                'fw_11.27-robot-20130227_204902.dat': [AXIS.X, AXIS.Y],
237        }
238        for filename, expected_axes in filenames_axes.items():
239            packets = parse_tests_data(filename, gesture_dir=gesture_dir)
240            # get the direction of the gesture
241            direction = [filename.split('-')[0].split('.')[1]]
242            self.validator.check(packets, direction)
243            actual_axes = sorted(self.validator.list_coords.keys())
244            self.assertEqual(actual_axes, expected_axes)
245
246    def _test_simple_linear_regression1(self):
247        """A y-t line taken from a real example.
248
249        Refer to the "Numerical example" in the wiki page:
250            http://en.wikipedia.org/wiki/Simple_linear_regression
251        """
252        list_t = [1.47, 1.50, 1.52, 1.55, 1.57, 1.60, 1.63, 1.65, 1.68, 1.70,
253                  1.73, 1.75, 1.78, 1.80, 1.83]
254        list_y = [52.21, 53.12, 54.48, 55.84, 57.20, 58.57, 59.93, 61.29,
255                  63.11, 64.47, 66.28, 68.10, 69.92, 72.19, 74.46]
256        expected_max_err = 1.3938545467809007
257        expected_rms_err = 0.70666155991311708
258        (max_err, rms_err) = self.validator._calc_errors_single_axis(
259                list_t, list_y)
260        self.assertAlmostEqual(max_err, expected_max_err)
261        self.assertAlmostEqual(rms_err, expected_rms_err)
262
263
264class NoGapValidatorTest(unittest.TestCase):
265    """Unit tests for NoGapValidator class."""
266    GAPS_SUBDIR = 'gaps'
267
268    def setUp(self):
269        self.criteria = conf.no_gap_criteria
270
271    def _test_no_gap(self, filename, criteria, device, slot):
272        file_subpath = os.path.join(self.GAPS_SUBDIR, filename)
273        packets = parse_tests_data(file_subpath)
274        validator = NoGapValidator(criteria, device=device, slot=slot)
275        vlog = validator.check(packets)
276        return vlog.score
277
278    def test_two_finger_scroll_gaps(self):
279        """Test that there are gaps in the two finger scroll gesture.
280
281        Issue 7552: Cyapa : two finger scroll motion produces gaps in tracking
282        """
283        filename = 'two_finger_gaps.horizontal.dat'
284        score0 = self._test_no_gap(filename, self.criteria, lumpy, 0)
285        score1 = self._test_no_gap(filename, self.criteria, lumpy, 1)
286        self.assertTrue(score0 <= 0.1)
287        self.assertTrue(score1 <= 0.1)
288
289    def test_gap_new_finger_arriving_or_departing(self):
290        """Test gap when new finger arriving or departing.
291
292        Issue: 8005: Cyapa : gaps appear when new finger arrives or departs
293        """
294        filename = 'gap_new_finger_arriving_or_departing.dat'
295        score = self._test_no_gap(filename, self.criteria, lumpy, 0)
296        self.assertTrue(score <= 0.3)
297
298    def test_one_stationary_finger_2nd_finger_moving_gaps(self):
299        """Test one stationary finger resulting in 2nd finger moving gaps."""
300        filename = 'one_stationary_finger_2nd_finger_moving_gaps.dat'
301        score = self._test_no_gap(filename, self.criteria, lumpy, 1)
302        self.assertTrue(score <= 0.1)
303
304    def test_resting_finger_2nd_finger_moving_gaps(self):
305        """Test resting finger resulting in 2nd finger moving gaps.
306
307        Issue 7648: Cyapa : Resting finger plus one finger move generates a gap
308        """
309        filename = 'resting_finger_2nd_finger_moving_gaps.dat'
310        score = self._test_no_gap(filename, self.criteria, lumpy, 1)
311        self.assertTrue(score <= 0.3)
312
313
314class PhysicalClickValidatorTest(unittest.TestCase):
315    """Unit tests for PhysicalClickValidator class."""
316
317    def setUp(self):
318        self.device = lumpy
319        self.criteria = '== 1'
320        self.mnprops = MetricNameProps()
321
322    def _test_physical_clicks(self, gesture_dir, files, expected_score):
323        gesture_path = os.path.join(unittest_path_lumpy, gesture_dir)
324        for filename, fingers in files.items():
325            packets = parse_tests_data(os.path.join(gesture_path, filename))
326            validator = PhysicalClickValidator(self.criteria,
327                                               fingers=fingers,
328                                               device=self.device)
329            vlog = validator.check(packets)
330            actual_score = vlog.score
331            self.assertTrue(actual_score == expected_score)
332
333    def test_physical_clicks_success(self):
334        """All physcial click files in the gesture_dir should pass."""
335        gesture_dir = '20130506_030025-fw_11.27-robot_sim'
336        gesture_path = os.path.join(unittest_path_lumpy, gesture_dir)
337
338        # Get all 1f physical click files.
339        file_prefix = 'one_finger_physical_click'
340        fingers = 1
341        files1 = [(filepath, fingers) for filepath in glob.glob(
342            os.path.join(gesture_path, file_prefix + '*.dat'))]
343
344        # Get all 2f physical click files.
345        file_prefix = 'two_fingers_physical_click'
346        fingers = 2
347        files2 = [(filepath, fingers) for filepath in glob.glob(
348            os.path.join(gesture_path, file_prefix + '*.dat'))]
349
350        # files is a dictionary of {filename: fingers}
351        files = dict(files1 + files2)
352        expected_score = 1.0
353        self._test_physical_clicks(gesture_dir, files, expected_score)
354
355    def test_physical_clicks_failure(self):
356        """All physcial click files specified below should fail."""
357        gesture_dir = '20130506_032458-fw_11.23-robot_sim'
358        # files is a dictionary of {filename: fingers}
359        files = {
360            'one_finger_physical_click.bottom_side-lumpy-fw_11.23-complete-'
361                '20130614_065744.dat': 1,
362            'one_finger_physical_click.center-lumpy-fw_11.23-complete-'
363                '20130614_065727.dat': 1,
364            'two_fingers_physical_click-lumpy-fw_11.23-complete-'
365                '20130614_065757.dat': 2,
366        }
367        expected_score = 0.0
368        self._test_physical_clicks(gesture_dir, files, expected_score)
369
370    def test_physical_clicks_by_finger_IDs(self):
371        """Test that some physical clicks may come with or without correct
372        finger IDs.
373        """
374        # files is a dictionary of {
375        #     filename: (number_fingers, (actual clicks, expected clicks))}
376        files = {
377                # An incorrect case with 1 finger: the event sequence comprises
378                #   Event: ABS_MT_TRACKING_ID, value 284
379                #   Event: ABS_MT_TRACKING_ID, value -1
380                #   Event: BTN_LEFT, value 1
381                #   Event: BTN_LEFT, value 0
382                # In this case, the BTN_LEFT occurs when there is no finger.
383                '1f_click_incorrect_behind_tid.dat': (1, (0, 1)),
384
385                # A correct case with 1 finger: the event sequence comprises
386                #   Event: ABS_MT_TRACKING_ID, value 284
387                #   Event: BTN_LEFT, value 1
388                #   Event: ABS_MT_TRACKING_ID, value -1
389                #   Event: BTN_LEFT, value 0
390                # In this case, the BTN_LEFT occurs when there is no finger.
391                '1f_click.dat': (1, (1, 1)),
392
393                # An incorrect case with 2 fingers: the event sequence comprises
394                #   Event: ABS_MT_TRACKING_ID, value 18
395                #   Event: BTN_LEFT, value 1
396                #   Event: BTN_LEFT, value 0
397                #   Event: ABS_MT_TRACKING_ID, value 19
398                #   Event: ABS_MT_TRACKING_ID, value -1
399                #   Event: ABS_MT_TRACKING_ID, value -1
400                # In this case, the BTN_LEFT occurs when there is only 1 finger.
401                '2f_clicks_incorrect_before_2nd_tid.dat': (2, (0, 1)),
402
403                # An incorrect case with 2 fingers: the event sequence comprises
404                #   Event: ABS_MT_TRACKING_ID, value 18
405                #   Event: ABS_MT_TRACKING_ID, value 19
406                #   Event: ABS_MT_TRACKING_ID, value -1
407                #   Event: ABS_MT_TRACKING_ID, value -1
408                #   Event: BTN_LEFT, value 1
409                #   Event: BTN_LEFT, value 0
410                # In this case, the BTN_LEFT occurs when there is only 1 finger.
411                '2f_clicks_incorrect_behind_2_tids.dat': (2, (0, 1)),
412
413                # A correct case with 2 fingers: the event sequence comprises
414                #   Event: ABS_MT_TRACKING_ID, value 18
415                #   Event: ABS_MT_TRACKING_ID, value 19
416                #   Event: BTN_LEFT, value 1
417                #   Event: ABS_MT_TRACKING_ID, value -1
418                #   Event: ABS_MT_TRACKING_ID, value -1
419                #   Event: BTN_LEFT, value 0
420                # In this case, the BTN_LEFT occurs when there is only 1 finger.
421                '2f_clicks.dat': (2, (1, 1)),
422        }
423        for filename, (fingers, expected_value) in files.items():
424            packets = parse_tests_data(filename)
425            validator = PhysicalClickValidator(self.criteria, fingers=fingers,
426                                               device=dontcare)
427            vlog = validator.check(packets)
428            metric_name = self.mnprops.CLICK_CHECK_TIDS.format(fingers)
429            for metric in vlog.metrics:
430                if metric.name == metric_name:
431                    self.assertEqual(metric.value, expected_value)
432
433
434class RangeValidatorTest(unittest.TestCase):
435    """Unit tests for RangeValidator class."""
436
437    def setUp(self):
438        self.device = lumpy
439
440    def _test_range(self, filename, expected_short_of_range_px):
441        filepath = os.path.join(unittest_path_lumpy, filename)
442        packets = parse_tests_data(filepath)
443        validator = RangeValidator(conf.range_criteria, device=self.device)
444
445        # Extract the gesture variation from the filename
446        variation = (filename.split('/')[-1].split('.')[1],)
447
448        # Determine the axis based on the direction in the gesture variation
449        axis = (self.device.axis_x if validator.is_horizontal(variation)
450                else self.device.axis_y if validator.is_vertical(variation)
451                else None)
452        self.assertTrue(axis is not None)
453
454        # Convert from pixels to mms.
455        expected_short_of_range_mm = self.device.pixel_to_mm_single_axis(
456                expected_short_of_range_px, axis)
457
458        vlog = validator.check(packets, variation)
459
460        # There is only one metric in the metrics list.
461        self.assertEqual(len(vlog.metrics), 1)
462        actual_short_of_range_mm = vlog.metrics[0].value
463        self.assertEqual(actual_short_of_range_mm, expected_short_of_range_mm)
464
465    def test_range(self):
466        """All physical click files specified below should fail."""
467        # files_px is a dictionary of {filename: short_of_range_px}
468        files_px = {
469            '20130506_030025-fw_11.27-robot_sim/'
470            'one_finger_to_edge.center_to_left.slow-lumpy-fw_11.27-'
471                'robot_sim-20130506_031554.dat': 0,
472
473            '20130506_030025-fw_11.27-robot_sim/'
474            'one_finger_to_edge.center_to_left.slow-lumpy-fw_11.27-'
475                'robot_sim-20130506_031608.dat': 0,
476
477            '20130506_032458-fw_11.23-robot_sim/'
478            'one_finger_to_edge.center_to_left.slow-lumpy-fw_11.23-'
479                'robot_sim-20130506_032538.dat': 1,
480
481            '20130506_032458-fw_11.23-robot_sim/'
482            'one_finger_to_edge.center_to_left.slow-lumpy-fw_11.23-'
483                'robot_sim-20130506_032549.dat': 1,
484        }
485
486        for filename, short_of_range_px in files_px.items():
487            self._test_range(filename, short_of_range_px)
488
489
490class StationaryFingerValidatorTest(unittest.TestCase):
491    """Unit tests for StationaryFingerValidator class."""
492
493    def setUp(self):
494        self.criteria = conf.stationary_finger_criteria
495
496    def _get_max_distance(self, filename, criteria, device):
497        packets = parse_tests_data(filename)
498        validator = StationaryFingerValidator(criteria, device=device)
499        vlog = validator.check(packets)
500        return vlog.metrics[0].value
501
502    def test_stationary_finger_shift(self):
503        """Test that the stationary shift due to 2nd finger tapping.
504
505        Issue 7442: Cyapa : Second finger tap events influence stationary finger
506        position
507        """
508        filename = 'stationary_finger_shift_with_2nd_finger_tap.dat'
509        max_distance = self._get_max_distance(filename, self.criteria, lumpy)
510        self.assertAlmostEqual(max_distance, 5.464430436926)
511
512    def test_stationary_strongly_affected_by_2nd_moving_finger(self):
513        """Test stationary finger strongly affected by 2nd moving finger with
514        gaps.
515
516        Issue 5812: [Cypress] reported positions of stationary finger strongly
517        affected by nearby moving finger
518        """
519        filename = ('stationary_finger_strongly_affected_by_2nd_moving_finger_'
520                    'with_gaps.dat')
521        max_distance = self._get_max_distance(filename, self.criteria, lumpy)
522        self.assertAlmostEqual(max_distance, 4.670861210146)
523
524
525class StationaryTapValidatorTest(unittest.TestCase):
526    """Unit tests for StationaryTapValidator class."""
527
528    def setUp(self):
529        self.criteria = conf.stationary_tap_criteria
530
531    def test_stationary_tap(self):
532        filenames = {'1f_click.dat': 1.718284027744,
533                     '1f_clickb.dat': 0.577590781705}
534        for filename, expected_max_distance in filenames.items():
535            packets = parse_tests_data(filename)
536            validator = StationaryTapValidator(self.criteria, device=lumpy)
537            vlog = validator.check(packets)
538            actual_max_distance = vlog.metrics[0].value
539            self.assertAlmostEqual(actual_max_distance, expected_max_distance)
540
541
542class NoLevelJumpValidatorTest(unittest.TestCase):
543    """Unit tests for NoLevelJumpValidator class."""
544
545    def setUp(self):
546        self.criteria = conf.no_level_jump_criteria
547        self.gesture_dir = 'drag_edge_thumb'
548
549    def _get_score(self, filename, device):
550        validator = NoLevelJumpValidator(self.criteria, device=device,
551                                         slots=[0,])
552        packets = parse_tests_data(filename, gesture_dir=self.gesture_dir)
553        vlog = validator.check(packets)
554        score = vlog.score
555        return score
556
557    def test_level_jumps(self):
558        """Test files with level jumps."""
559        filenames = [
560            'drag_edge_thumb.horizontal.dat',
561            'drag_edge_thumb.horizontal_2.dat',
562            'drag_edge_thumb.horizontal_3.no_points.dat',
563            'drag_edge_thumb.vertical.dat',
564            'drag_edge_thumb.vertical_2.dat',
565            'drag_edge_thumb.diagonal.dat',
566        ]
567        for filename in filenames:
568            self.assertTrue(self._get_score(filename, lumpy) <= 0.6)
569
570    def test_no_level_jumps(self):
571        """Test files without level jumps."""
572        filenames = [
573            'drag_edge_thumb.horizontal.curvy.dat',
574            'drag_edge_thumb.horizontal_2.curvy.dat',
575            'drag_edge_thumb.vertical.curvy.dat',
576            'drag_edge_thumb.vertical_2.curvy.dat',
577        ]
578        for filename in filenames:
579            self.assertTrue(self._get_score(filename, lumpy) == 1.0)
580
581
582class ReportRateValidatorTest(unittest.TestCase):
583    """Unit tests for ReportRateValidator class."""
584    def setUp(self):
585        self.criteria = '>= 60'
586
587    def _get_score(self, filename, device):
588        validator = ReportRateValidator(self.criteria, device=device,
589                                        chop_off_pauses=False)
590        packets = parse_tests_data(filename)
591        vlog = validator.check(packets)
592        score = vlog.score
593        return score
594
595    def test_report_rate_scores(self):
596        """Test the score of the report rate."""
597        filename = '2f_scroll_diagonal.dat'
598        self.assertTrue(self._get_score(filename, device=lumpy) <= 0.5)
599
600        filename = 'one_finger_with_slot_0.dat'
601        self.assertTrue(self._get_score(filename, device=lumpy) >= 0.9)
602
603        filename = 'two_close_fingers_merging_changed_ids_gaps.dat'
604        self.assertTrue(self._get_score(filename, device=lumpy) <= 0.5)
605
606    def test_report_rate_without_slot(self):
607        """Test report rate without specifying any slot."""
608        filename_report_rate_pair = [
609            ('2f_scroll_diagonal.dat', 40.31),
610            ('one_finger_with_slot_0.dat', 148.65),
611            ('two_close_fingers_merging_changed_ids_gaps.dat', 53.12),
612        ]
613        for filename, expected_report_rate in filename_report_rate_pair:
614            validator = ReportRateValidator(self.criteria, device=dontcare,
615                                            chop_off_pauses=False)
616            validator.check(parse_tests_data(filename))
617            actual_report_rate = round(validator.report_rate, 2)
618            self.assertAlmostEqual(actual_report_rate, expected_report_rate)
619
620    def test_report_rate_with_slot(self):
621        """Test report rate with slot=1"""
622        # Compute actual_report_rate
623        filename = ('stationary_finger_strongly_affected_by_2nd_moving_finger_'
624                    'with_gaps.dat')
625        validator = ReportRateValidator(self.criteria, device=dontcare,
626                                        finger=1, chop_off_pauses=False)
627        validator.check(parse_tests_data(filename))
628        actual_report_rate = validator.report_rate
629        # Compute expected_report_rate
630        first_syn_time = 2597.682925
631        last_syn_time = 2604.543335
632        num_packets = 592 - 1
633        expected_report_rate = num_packets / (last_syn_time - first_syn_time)
634        self.assertAlmostEqual(actual_report_rate, expected_report_rate)
635
636    def _test_report_rate_metrics(self, filename, expected_values):
637        packets = parse_tests_data(filename)
638        validator = ReportRateValidator(self.criteria, device=lumpy,
639                                        chop_off_pauses=False)
640        vlog = validator.check(packets)
641
642        # Verify that there are 3 metrics
643        number_metrics = 3
644        self.assertEqual(len(vlog.metrics), number_metrics)
645
646        # Verify the values of the 3 metrics.
647        for i in range(number_metrics):
648            actual_value = vlog.metrics[i].value
649            if isinstance(actual_value, tuple):
650                self.assertEqual(actual_value, expected_values[i])
651            else:
652                self.assertAlmostEqual(actual_value, expected_values[i])
653
654    def test_report_rate_metrics(self):
655        """Test the metrics of the report rates."""
656        # files is a dictionary of
657        #       {filename: ((# long_intervals, # all intervals),
658        #                    ave_interval, max_interval)}
659        files = {
660            '2f_scroll_diagonal.dat':
661                ((33, 33), 24.8057272727954, 26.26600000075996),
662            'one_finger_with_slot_0.dat':
663                ((1, 12), 6.727166666678386, 20.411999998032115),
664            'two_close_fingers_merging_changed_ids_gaps.dat':
665                ((13, 58), 18.82680942272318, 40.936946868896484),
666        }
667
668        for filename, values in files.items():
669            self._test_report_rate_metrics(filename, values)
670
671    def _test_chop_off_both_ends(self, xy_pairs, distance, expected_middle):
672        """Verify if the actual middle is equal to the expected middle."""
673        points = [Point(*xy) for xy in xy_pairs]
674        validator = ReportRateValidator(self.criteria, device=dontcare)
675        actual_middle = validator._chop_off_both_ends(points, distance)
676        self.assertEqual(actual_middle, expected_middle)
677
678    def test_chop_off_both_ends0(self):
679        """Test chop_off_both_ends() with distinct distances."""
680        xy_pairs = [
681                # pauses
682                (100, 20), (100, 21), (101, 22), (102, 24), (103, 26),
683                # moving segment
684                (120, 30), (122, 29), (123, 32), (123, 33), (126, 35),
685                (126, 32), (142, 29), (148, 30), (159, 31), (162, 30),
686                (170, 32), (183, 32), (194, 32), (205, 32), (208, 32),
687                # pauses
688                (230, 30), (231, 31), (232, 30), (231, 30), (230, 30),
689        ]
690
691        distance = 20
692        expected_begin_index = 5
693        expected_end_index = 19
694        expected_middle = [expected_begin_index, expected_end_index]
695        self._test_chop_off_both_ends(xy_pairs, distance, expected_middle)
696
697        distance = 0
698        expected_begin_index = 0
699        expected_end_index = len(xy_pairs) - 1
700        expected_middle = [expected_begin_index, expected_end_index]
701        self._test_chop_off_both_ends(xy_pairs, distance, expected_middle)
702
703    def test_chop_off_both_ends1(self):
704        """Test chop_off_both_ends() with some corner cases"""
705        distance = 20
706        xy_pairs = [(120, 50), (120, 50)]
707        expected_middle = None
708        self._test_chop_off_both_ends(xy_pairs, distance, expected_middle)
709
710        xy_pairs = [(120, 50), (150, 52), (200, 51)]
711        expected_middle = [1, 1]
712        self._test_chop_off_both_ends(xy_pairs, distance, expected_middle)
713
714        xy_pairs = [(120, 50), (120, 51), (200, 52), (200, 51)]
715        expected_middle = None
716        self._test_chop_off_both_ends(xy_pairs, distance, expected_middle)
717
718
719class HysteresisValidatorTest(unittest.TestCase):
720    """Unit tests for HysteresisValidator class."""
721
722    def setUp(self):
723        self.criteria = conf.hysteresis_criteria
724
725    def test_hysteresis(self):
726        """Test that the hysteresis causes an initial jump."""
727        filenames = {'center_to_right_normal_link.dat': 4.6043458,
728                     'center_to_right_slow_link.dat': 16.8671278}
729
730        for filename, expected_value in filenames.items():
731            packets = parse_tests_data(filename)
732            validator = HysteresisValidator(self.criteria, device=link)
733            vlog = validator.check(packets)
734            self.assertAlmostEqual(vlog.metrics[0].value, expected_value)
735
736    def test_click_data(self):
737        """Test that the validator handles None distances well.
738
739        In this test, distance1 = None and distance2 = None.
740        This results in ratio = infinity. There should be no error incurred.
741        """
742        packets = parse_tests_data('2f_clicks_test_hysteresis.dat')
743        validator = HysteresisValidator(self.criteria, device=link)
744        vlog = validator.check(packets)
745        self.assertEqual(vlog.metrics[0].value, float('infinity'))
746
747
748class MtbSanityValidatorTest(unittest.TestCase):
749    """Unit tests for MtbSanityValidator class."""
750
751    def setUp(self):
752        import fake_input_device
753        self.fake_device_info = fake_input_device.FakeInputDevice()
754
755    def _get_number_errors(self, filename):
756        packets = parse_tests_data(filename)
757        validator = MtbSanityValidator(device=link,
758                                       device_info=self.fake_device_info)
759        vlog = validator.check(packets)
760        number_errors, _ = vlog.metrics[1].value
761        return number_errors
762
763    def test_sanity_found_errors(self):
764        """Test that the tracking id is set to -1 before being assigned a
765        positive value.
766        """
767        filenames = ['finger_crossing.top_right_to_bottom_left.slow.dat',
768                     'two_finger_tap.vertical.dat']
769        for filename in filenames:
770            number_errors = self._get_number_errors(filename)
771            self.assertTrue(number_errors > 0)
772
773    def test_sanity_pass(self):
774        """Test that the MTB format is correct."""
775        filenames = ['2f_scroll_diagonal.dat',
776                     'drumroll_lumpy.dat']
777        for filename in filenames:
778            number_errors = self._get_number_errors(filename)
779            self.assertTrue(number_errors == 0)
780
781
782class DiscardInitialSecondsValidatorTest(unittest.TestCase):
783    """Unit tests for DiscardInitialSecondsValidator class."""
784
785    def setUp(self):
786        import fake_input_device
787        self.fake_device_info = fake_input_device.FakeInputDevice()
788
789    def _get_score(self, filename, criteria_str):
790        packets = parse_tests_data(filename)
791        validator = DiscardInitialSecondsValidator(
792            validator=CountTrackingIDValidator(criteria_str, device=link),
793            device=link)
794        vlog = validator.check(packets)
795        return vlog.score
796
797    def test_single_finger_hold(self):
798        """Test that the state machine reads one finger if
799        only one finger was held for over a second."""
800
801        filename = 'one_finger_long_hold.dat'
802        score = self._get_score(filename, '== 1')
803        self.assertTrue(score == 1)
804
805    def test_double_finger_hold(self):
806        """Test that the state machine reads two fingers if
807        two fingers were held for over a second."""
808
809        filename = 'two_finger_long_hold.dat'
810        score = self._get_score(filename, '== 2')
811        self.assertTrue(score == 1)
812
813    def test_double_tap_single_hold(self):
814        """Test that the validator discards the initial double tap and only
815        validates on the single finger long hold at the end.
816        """
817
818        filename = 'two_finger_tap_one_finger_hold.dat'
819        score = self._get_score(filename, '== 1')
820        self.assertTrue(score == 1)
821
822    def test_discard_initial_seconds(self):
823        """Test that discard_initial_seconds() cuts at the proper packet.
824
825        Note: to print the final_state_packet, use the following statements:
826            import mtb
827            print mtb.make_pretty_packet(final_state_packet)
828        """
829        packets = parse_tests_data('noise_stationary_extended.dat')
830        validator = DiscardInitialSecondsValidator(
831            validator=CountTrackingIDValidator('== 1', device=link),
832            device=link)
833        validator.init_check(packets)
834        packets = validator._discard_initial_seconds(packets, 1)
835        final_state_packet = packets[0]
836
837        self.assertTrue(len(final_state_packet) == 11)
838        # Assert the correctness of the 1st finger data in the order of
839        #     SLOT, TRACKING_ID, POSITION_X, POSITION_Y, PRESSURE
840        self.assertTrue(final_state_packet[0][MTB.EV_VALUE] == 2)
841        self.assertTrue(final_state_packet[1][MTB.EV_VALUE] == 2427)
842        self.assertTrue(final_state_packet[2][MTB.EV_VALUE] == 670)
843        self.assertTrue(final_state_packet[3][MTB.EV_VALUE] == 361)
844        self.assertTrue(final_state_packet[4][MTB.EV_VALUE] == 26)
845        # Assert the correctness of the 2nd finger data in the order of
846        #     SLOT, TRACKING_ID, POSITION_X, POSITION_Y, PRESSURE
847        self.assertTrue(final_state_packet[5][MTB.EV_VALUE] == 3)
848        self.assertTrue(final_state_packet[6][MTB.EV_VALUE] == 2426)
849        self.assertTrue(final_state_packet[7][MTB.EV_VALUE] == 670)
850        self.assertTrue(final_state_packet[8][MTB.EV_VALUE] == 368)
851        self.assertTrue(final_state_packet[9][MTB.EV_VALUE] == 21)
852        # EVENT TIME
853        self.assertTrue(final_state_packet[0][MTB.EV_TIME] == 1412021965.723953)
854
855    def test_get_snapshot_after_discarding_init_packets(self):
856        """Test that get_snapshot() handles non-ready packet properly
857        after discard_initial_seconds(). A non-ready packet is one that
858        the attributes such as X, Y, and Z are not all ready.
859        """
860        packets = parse_tests_data('non_ready_events_in_final_state_packet.dat')
861        validator = DiscardInitialSecondsValidator(
862            validator=CountTrackingIDValidator('== 1', device=link),
863            device=link)
864        validator.init_check(packets)
865        packets = validator._discard_initial_seconds(packets, 1)
866        final_state_packet = packets[0]
867
868        self.assertTrue(len(final_state_packet) == 4)
869        # Assert the correctness of the finger data in the order of
870        #     SLOT, TRACKING_ID, and POSITION_Y
871        self.assertTrue(final_state_packet[0][MTB.EV_VALUE] == 0)
872        self.assertTrue(final_state_packet[1][MTB.EV_VALUE] == 102)
873        self.assertTrue(final_state_packet[2][MTB.EV_VALUE] == 1316)
874        # EVENT TIME
875        self.assertTrue(final_state_packet[0][MTB.EV_TIME] == 1412888977.716634)
876
877    def test_noise_line_with_all_fingers_left(self):
878        """In this test case, all fingers left. The final_state_packet is []."""
879        packets=parse_tests_data('noise_line.dat')
880        validator = DiscardInitialSecondsValidator(ReportRateValidator('>= 60'))
881        validator.init_check(packets)
882        packets = validator._discard_initial_seconds(packets, 1)
883        validator.validator.init_check(packets)
884        list_syn_time = validator.validator.packets.get_list_syn_time([])
885        self.assertEqual(len(packets), 84)
886        self.assertEqual(len(list_syn_time), 84)
887
888
889if __name__ == '__main__':
890  unittest.main()
891