| # 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 shutil |
| |
| import trackpad_util |
| import trackpad_summary |
| |
| 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, KEY_LOG, KEY_SEQ |
| 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 initialize(self): |
| self.vlog = trackpad_util.VerificationLog() |
| self.local_path = self.bindir |
| self.model = trackpad_util.get_model() |
| self.regression_gestures = None |
| self.autotest_log_path = trackpad_util.get_logger_filename( |
| logging.getLogger(), logging.INFO) |
| |
| # Get some parameters from the config file |
| self.regression_subset_list = read_trackpad_test_conf( |
| 'regression_subset_list', self.local_path) |
| self.regression_default_subset = read_trackpad_test_conf( |
| 'regression_default_subset', self.local_path) |
| self.functionality_list = read_trackpad_test_conf( |
| 'functionality_list', self.local_path) |
| self.regression_gestures_dict = read_trackpad_test_conf( |
| 'regression_gestures_dict', self.local_path) |
| |
| # Get some file paths from the config file |
| self.gesture_files_path_results = self.read_gesture_files_path( |
| self.local_path, 'gesture_files_path_results') |
| self.gesture_files_subpath_regression = self.read_gesture_files_path( |
| self.local_path, 'gesture_files_subpath_regression') |
| self.regression_gesture_sets = self.read_gesture_files_path( |
| self.local_path, 'regression_gesture_sets') |
| self.gesture_files_path_autotest = self.read_gesture_files_path( |
| self.local_path, 'gesture_files_path_autotest') |
| self.gesture_files_path_latest = self.read_gesture_files_path( |
| self.local_path, 'gesture_files_path_latest') |
| |
| def read_gesture_files_path(self, local_path, name): |
| ''' Read gesture file path from config file. ''' |
| pathname = read_trackpad_test_conf(name, local_path) |
| logging.info('Path of %s: %s' % (name, pathname)) |
| return pathname |
| |
| def _is_in_regression_gestures(self, gesture_file): |
| ''' Determine if a gesture file is in the regression gestures list. |
| |
| For current settings, |
| - long regression test: self.regression_gestures is None, which means |
| all gesture files will be used for regression |
| test. |
| - short regression test: self.regression_gestures is read from the file |
| './data/gestures/regression_gestures_short' |
| Only gesture files listed in the file will be |
| used for regression test. |
| |
| A gesture file name looks like |
| 'click-no_cursor_wobble.tap-alex-user-20120430_114910.dat' |
| We want to extract the left half part of the file name which looks like |
| 'click-no_cursor_wobble.tap' |
| and check if this gesture exists in the regression_gestures. |
| ''' |
| result = gesture_file.split('-%s-' % self.model) |
| gesture = None if result is None else result[0] |
| return (self.regression_gestures is None or |
| gesture in self.regression_gestures) |
| |
| def _extract_tarball_to_work_dir(self, subset): |
| ''' Extract the gesture files tarball to working directory ''' |
| # Set up an empty work directory |
| gesture_files_path_work = self.read_gesture_files_path( |
| self.local_path, 'gesture_files_path_work') |
| if os.path.isdir(gesture_files_path_work): |
| shutil.rmtree(gesture_files_path_work, True) |
| if not os.path.isdir(gesture_files_path_work): |
| os.makedirs(gesture_files_path_work) |
| logging.info(' The work path "%s" is created successfully.' % |
| gesture_files_path_work) |
| |
| regression_tarball = 'regression_files_%s.tar' % subset |
| regression_tarball_path = os.path.join(self.local_path, |
| self.gesture_files_subpath_regression, regression_tarball) |
| |
| if not os.path.isfile(regression_tarball_path): |
| logging.warn(' The regression tarball does not exist: "%s"' % |
| regression_tarball_path) |
| return None |
| |
| # Extract files from the tarball |
| strip_level = 0 if subset == 'short' else 1 |
| untar_cmd = ('tar --strip-components %d -xvf %s -C %s' % |
| (strip_level, |
| regression_tarball_path, |
| gesture_files_path_work)) |
| rc = utils.system(untar_cmd) |
| if rc != 0: |
| logging.warn(' Failed in executing "%s".' % untar_cmd) |
| return None |
| logging.info(' Succeeded in executing "%s".' % untar_cmd) |
| return gesture_files_path_work |
| |
| def _set_regression_gestures(self, subset): |
| ''' Read regression_gestures based on the subset |
| |
| When self.regression_gestures is set to None, it means that all of the |
| gesture files in the specified gesture set will be used. |
| ''' |
| if subset is None or self.regression_gestures_dict[subset] is None: |
| self.regression_gestures = None |
| else: |
| gestures_path = os.path.join(self.local_path, |
| self.regression_gestures_dict[subset]) |
| execfile(gestures_path, globals()) |
| if self.model in regression_gestures: |
| self.regression_gestures = regression_gestures[self.model] |
| else: |
| self.regression_gestures = baseline_regression_gestures |
| |
| def _get_regression_gesture_set(self, subset): |
| ''' Get the regression gesture set. ''' |
| model = self.model |
| if subset not in self.regression_subset_list: |
| subset = self.regression_default_subset |
| |
| # Skip those models that are not specified the regression gesture sets. |
| # There are two possible reasons: |
| # (1) the gestures are not captured yet. |
| # (2) it is a model without built-in trackpad. |
| if model not in self.regression_gesture_sets[subset]: |
| return None |
| |
| regression_gesture_set = self.regression_gesture_sets[subset][model] |
| gesture_set_path = os.path.join(self.local_path, |
| self.gesture_files_subpath_regression, regression_gesture_set) |
| |
| # Make a symlink for autotest. |
| trackpad_util.write_symlink(gesture_set_path, |
| self.gesture_files_path_autotest) |
| |
| return subset |
| |
| def _setup_gesture_files_path(self, test_set, subset): |
| ''' Set up gesture files path |
| |
| If it is a tarball, extract files from the tarball and set up its path. |
| If it is an ordinary directory, just returns its path. |
| ''' |
| # If this is a regression test, let gesture_files_path_autotest |
| # point to the regression gesture set specified in conf. |
| if test_set == 'regression': |
| subset = self._get_regression_gesture_set(subset) |
| |
| # If this is a test on a gesture set captured in the local machine, |
| # let gesture_files_path_autotest point to the 'latest' symlink if it |
| # exists. Otherwise, let it point to the default regression gesture set. |
| elif test_set == 'localhost': |
| if os.path.exists(self.gesture_files_path_latest): |
| trackpad_util.write_symlink(self.gesture_files_path_latest, |
| self.gesture_files_path_autotest) |
| else: |
| subset = self._get_regression_gesture_set(subset) |
| |
| # Skip those models without the regression gesture sets. |
| if subset is None: |
| return None |
| |
| # Determine gestures to test |
| self._set_regression_gestures(subset) |
| |
| logging.info(' test_set: %s' % test_set) |
| logging.info(' subset: %s' % subset) |
| logging.info(' gesture_files_path_autotest: %s' % |
| os.path.realpath(self.gesture_files_path_autotest)) |
| |
| return self.gesture_files_path_autotest |
| |
| def run_once(self, test_set='localhost', subset=None): |
| ''' test_set determines the path of gesture files. |
| |
| The test_set could be |
| localhost: run locally from the client side |
| regression: run by control.regression |
| ''' |
| global tdata |
| tdata.file_basename = None |
| tdata.chrome_request = 0 |
| tdata.report_finished = False |
| local_path = self.local_path |
| functionality_list = self.functionality_list |
| gesture_files_path_results = self.gesture_files_path_results |
| |
| # Set up regression path |
| gesture_files_path_autotest = self._setup_gesture_files_path(test_set, |
| subset) |
| |
| # Skip those models without regression gesture sets. |
| if gesture_files_path_autotest is None: |
| logging.info('No gesture sets are specified for this model: %s' % |
| self.model) |
| return |
| |
| # Exit if the gesture files path for autotest does not exist. |
| if (gesture_files_path_autotest is None or |
| not os.path.exists(gesture_files_path_autotest)): |
| raise error.TestError(' The autotest path does not exist: %s.' % |
| str(os.path.realpath(gesture_files_path_autotest))) |
| |
| if not os.path.exists(gesture_files_path_results): |
| os.makedirs(gesture_files_path_results) |
| logging.info(' The result path "%s" is created successfully.' % |
| gesture_files_path_results) |
| self.ilog = trackpad_util.IterationLog(gesture_files_path_results, |
| gesture_files_path_autotest, |
| self.autotest_log_path) |
| |
| # Start tpcontrol log and get the gesture library version |
| self.tpcontrol_log = trackpad_util.TpcontrolLog() |
| gesture_version = self.tpcontrol_log.get_gesture_version() |
| logging.info('Gesture library version: %s' % gesture_version) |
| |
| # Initialization of statistics |
| tdata.num_wrong_file_name = 0 |
| tdata.num_files_tested = {} |
| tdata.num_files_tested_fullname = {} |
| tdata.subname_list = {} |
| 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]) |
| tdata.fail_count_fullname = {} |
| vlog_dict = {} |
| vlog_dict[KEY_LOG] = {} |
| vlog_dict[KEY_SEQ] = [] |
| logging.info('') |
| logging.info('*** hardware_Trackpad autotest is started ***') |
| |
| # Start Trackpad Input Device |
| self.tp_device = TrackpadDevice() |
| |
| # 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: |
| flag_logging_func_name = False |
| tdata.num_files_tested[tdata.func.name] = 0 |
| tdata.subname_list[tdata.func.name] = [] |
| |
| # 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_autotest, prefix) |
| |
| if group_name == '*': |
| # E.g., group_path = '.../click-any_finger_click' |
| 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_name |
| gesture_file_group = glob.glob(group_path) |
| |
| # Process each specific gesture_file now. |
| for gesture_file in gesture_file_group: |
| tdata.file_basename = os.path.basename(gesture_file) |
| # If regression_gestures have been specified, this file |
| # should be in the regression_gestures. |
| # Currently, the short regression test has been specified |
| # the regression_gestures. |
| if not self._is_in_regression_gestures(tdata.file_basename): |
| continue |
| |
| # 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. |
| 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_autotest, gesture_file) |
| |
| if not flag_logging_func_name: |
| flag_logging_func_name = True |
| logging.info('\nFunctionality: %s (Area: %s)' % |
| (tdata.func.name, tdata.func.area[1])) |
| logging.info('\n 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 |
| xevent_str = self.xcapture.read() |
| output = self.xcheck.run(tdata.func, tdata, xevent_str) |
| tdata.result = output['result'] and normal_timeout_flag |
| |
| # Insert the verification log into the vlog dictionary |
| self.vlog.insert_vlog_dict(vlog_dict, gesture_file, |
| output['result'], output['vlog']) |
| |
| logging.info('...................vlog.................') |
| logging.info(str(output['vlog'])) |
| |
| # Save tpcontrol log if this gesture file failed. |
| if not tdata.result: |
| self.tpcontrol_log.save_log(tdata.file_basename) |
| |
| # Initialization for this subname |
| fullname = trackpad_util.get_fullname(tdata.file_basename) |
| if not tdata.subname_list[tdata.func.name]: |
| tdata.subname_list[tdata.func.name] = [] |
| if fullname not in tdata.num_files_tested_fullname: |
| tdata.num_files_tested_fullname[fullname] = 0 |
| tdata.subname_list[tdata.func.name].append(fullname) |
| tdata.fail_count_fullname[fullname] = 0 |
| |
| # Update statistics |
| tdata.num_files_tested[tdata.func.name] += 1 |
| tdata.num_files_tested_fullname[fullname] += 1 |
| tdata.tot_num_files_tested += 1 |
| if not tdata.result: |
| tdata.fail_count[tdata.func.name] += 1 |
| tdata.fail_count_fullname[fullname] += 1 |
| tdata.tot_fail_count += 1 |
| |
| # Terminate X event capture process |
| self.xcapture.terminate() |
| |
| # Logging test summary |
| tot_pass_count = tdata.tot_num_files_tested - tdata.tot_fail_count |
| msg = trackpad_summary.format_result_header(self.ilog.result_file_name, |
| tot_pass_count, |
| tdata.tot_num_files_tested) |
| self.ilog.write_result_log(msg) |
| |
| area_name = None |
| for tp_func in functionality_list: |
| # if not tp_func.enabled: |
| # continue |
| func_name = tp_func.name |
| test_count = tdata.num_files_tested[func_name] |
| if test_count == 0: |
| continue |
| if tp_func.area[0] != area_name: |
| area_name = tp_func.area[0] |
| msg = trackpad_summary.format_result_area(area_name) |
| self.ilog.write_result_log(msg) |
| |
| for fullname in tdata.subname_list[func_name]: |
| test_count_fullname = tdata.num_files_tested_fullname[fullname] |
| fail_count_fullname = tdata.fail_count_fullname[fullname] |
| pass_count_fullname = test_count_fullname - fail_count_fullname |
| msg = trackpad_summary.format_result_pass_rate(fullname, |
| pass_count_fullname, test_count_fullname) |
| self.ilog.write_result_log(msg) |
| |
| msg = trackpad_summary.format_result_tail() |
| self.ilog.write_result_log(msg) |
| self.ilog.write_result_log('Verification Log = %s' % vlog_dict) |
| self.ilog.write_result_log('\n\n\n') |
| self.ilog.close_result_log() |
| self.ilog.append_detailed_log(self.autodir) |
| |
| # 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) |
