| # Copyright (c) 2011 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| ''' Autotest program for verifying trackpad X level driver ''' |
| |
| import glob |
| import logging |
| import os |
| import time |
| |
| from autotest_lib.client.bin import test, utils |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.cros import cros_ui |
| |
| from trackpad_device import TrackpadDevice |
| from trackpad_util import read_trackpad_test_conf, get_prefix |
| from Xcapture import Xcapture |
| from Xcheck import Xcheck |
| |
| |
| class TrackpadData: |
| ''' An empty class to hold global trackpad test data for communication |
| between threads |
| ''' |
| pass |
| |
| ''' tdata: trackpad data as a global variable used between threads |
| (1) The main thread runs in the hardware_Trackpad class will derive the test |
| result through Xcheck class. The test result is stored in tdata. |
| It requires read/write access to tdata. |
| (2) A second thread will launch a HTTP server that communicates with a |
| chrome extension on the target machine to display the test result |
| on the fly during the test procedure. When the result of a gesture file |
| test has been derived, it is sent to the browser for display. |
| |
| Note: it is not required to use mutex to protect the global tdata for two |
| reasons: |
| - tdata will be accessed sequentially between the two threads. |
| - The main thread is a writer, and the HTTP server thread is a reader. |
| No lock is needed in this case. |
| ''' |
| tdata = TrackpadData() |
| |
| |
| class hardware_Trackpad(test.test): |
| ''' Play back device packets through the trackpad device. Capture the |
| resultant X events. Analyze whether the X events meet the criteria |
| of the functionality. |
| ''' |
| version = 1 |
| |
| def run_once(self): |
| global tdata |
| tdata.file_basename = None |
| tdata.chrome_request = 0 |
| tdata.report_finished = False |
| |
| # Get functionality_list, and gesture_files_path from config file |
| local_path = self.autodir + '/tests/hardware_Trackpad' |
| functionality_list = read_trackpad_test_conf('functionality_list', |
| local_path) |
| gesture_files_path_conf = read_trackpad_test_conf('gesture_files_path', |
| local_path) |
| gesture_files_path = os.path.join(local_path, gesture_files_path_conf) |
| logging.info('Path of trackpad gesture files: %s' % gesture_files_path) |
| |
| # Initialization of statistics |
| tdata.num_wrong_file_name = 0 |
| tdata.num_files_tested = {} |
| tdata.tot_fail_count = 0 |
| tdata.tot_num_files_tested = 0 |
| tdata.fail_count = dict([(tp_func.name, 0) |
| for tp_func in functionality_list]) |
| logging.info('') |
| logging.info('*** hardware_Trackpad autotest is started ***') |
| |
| # Start Trackpad Input Device |
| self.tp_device = TrackpadDevice(local_path) |
| |
| # Get an instance of AutoX to handle X related issues |
| autox = cros_ui.get_autox() |
| |
| # Start X events capture |
| self.xcapture = Xcapture(error, local_path, autox) |
| |
| # Initialize X events Check |
| self.xcheck = Xcheck(self.tp_device, local_path) |
| |
| # Processing every functionality in functionality_list |
| # An example functionality is 'any_finger_click' |
| for tdata.func in functionality_list: |
| # If this function is not enabled in configuration file, skip it. |
| if not tdata.func.enabled: |
| continue; |
| |
| logging.info('\n') |
| logging.info('Functionality: %s (Area: %s)' % |
| (tdata.func.name, tdata.func.area[1])) |
| tdata.num_files_tested[tdata.func.name] = 0 |
| |
| # Some cases of specifying gesture files in the configuration file: |
| # Case 1: |
| # If gesture files are set to None in this functionality, skip it. |
| # It looks as: |
| # files=None, or |
| # files=(None,), |
| # |
| # Case 2: |
| # '*' means all files starting with the functionality name |
| # Its setting in the configuration file looks as |
| # files='*', or |
| # files=('*',), |
| # |
| # Case 3: |
| # In other case, gesture files could be set as: |
| # ('any_finger_click.l1-*', 'any_finger_click.r*') |
| if tdata.func.files is None or tdata.func.files.count(None) > 0: |
| logging.info(' Gesture files is set to None. Skipped.') |
| continue |
| elif tdata.func.files == '*' or tdata.func.files.count('*') > 0: |
| group_name_list = ('*',) |
| else: |
| group_name_list = tdata.func.files |
| |
| # A group name can be '*', or something looks like |
| # 'any_finger_click.l1-*', or |
| # 'any_finger_click.r*'), etc. |
| for group_name in group_name_list: |
| # prefix is the area name as default |
| tdata.prefix = get_prefix(tdata.func) |
| if tdata.prefix is not None: |
| # E.g., prefix = 'click-' |
| prefix = tdata.prefix + '-' |
| group_path = os.path.join(gesture_files_path, prefix) |
| |
| if group_name == '*': |
| # E.g., group_path = '.../click-any_finger_click' |
| group_path = group_path + tdata.func.name |
| # Two possibilities of the gesture_file_group: |
| # 1. '.../click-any_finger_click.*': |
| # variations exists (subname is not None) |
| # 2. '.../click-any_finger_click-*': no variations |
| # no variations (subname is None) |
| # Note: attributes are separated by dash ('-') |
| # variations are separated by dot ('.') |
| gesture_file_group = (glob.glob(group_path + '.*') + |
| glob.glob(group_path + '-*')) |
| else: |
| group_path = group_path + group_name |
| gesture_file_group = glob.glob(group_path) |
| |
| # Process each specific gesture_file now. |
| for gesture_file in gesture_file_group: |
| # Every gesture file name should start with the correct |
| # functionality name, because we use the functionality to |
| # determine the test criteria for the file. Otherwise, |
| # a warning message is shown. |
| tdata.file_basename = os.path.basename(gesture_file) |
| start_flag0 = tdata.file_basename.startswith( |
| tdata.func.name) |
| start_flag1 = tdata.file_basename.split('-')[1].startswith( |
| tdata.func.name) |
| if (tdata.prefix is None and not start_flag0) or \ |
| (tdata.prefix is not None and not start_flag1): |
| warn_msg = 'The gesture file does not start with ' + \ |
| 'correct functionality: %s' |
| logging.warning(warn_msg % gesture_file) |
| tdata.num_wrong_file_name += 1 |
| |
| gesture_file_path = os.path.join(gesture_files_path, |
| gesture_file) |
| logging.info('') |
| logging.info(' gesture file: %s' % tdata.file_basename) |
| |
| # Start X events capture |
| self.xcapture.start(tdata.file_basename) |
| |
| # Play back the gesture file |
| self.tp_device.playback(gesture_file_path) |
| |
| # Wait until there are no more incoming X events. |
| normal_timeout_flag = self.xcapture.wait() |
| |
| # Stop X events capture |
| self.xcapture.stop() |
| |
| # Check X events |
| tdata.result = self.xcheck.run(tdata.func, tdata, |
| self.xcapture.read()) and \ |
| normal_timeout_flag |
| |
| # Update statistics |
| tdata.num_files_tested[tdata.func.name] += 1 |
| tdata.tot_num_files_tested += 1 |
| if not tdata.result: |
| tdata.fail_count[tdata.func.name] += 1 |
| tdata.tot_fail_count += 1 |
| |
| # Terminate X event capture process |
| self.xcapture.terminate() |
| |
| # Logging test summary |
| logging.info('\n') |
| tot_pass_count = tdata.tot_num_files_tested - tdata.tot_fail_count |
| logging.info('*** Total number of (passed / tested) files: (%d / %d) ' |
| '***' % (tot_pass_count, tdata.tot_num_files_tested)) |
| area_name = None |
| for tp_func in functionality_list: |
| func_name = tp_func.name |
| if tp_func.area[0] != area_name: |
| area_name = tp_func.area[0] |
| logging.info(' Area: %s' % area_name) |
| test_count = tdata.num_files_tested[func_name] |
| fail_count = tdata.fail_count[func_name] |
| pass_count = test_count - fail_count |
| if test_count > 0: |
| pass_rate_str = '%3.0f%%' % (100.0 * pass_count / test_count) |
| count_str = '(%d / %d)' % (pass_count, test_count) |
| else: |
| pass_rate_str = ' ' |
| count_str = ' ' |
| func_msg = ' {0:<25}: {1:4s} {2:9s} passed.' |
| logging.info(func_msg.format(func_name, pass_rate_str, count_str)) |
| logging.info('\n') |
| |
| # Raise error.TestFail if there is any test failed. |
| if tdata.tot_fail_count > 0: |
| fail_str = 'Total number of failed files: %d' |
| raise error.TestFail(fail_str % tdata.tot_fail_count) |
