def run_once(self, host=None, kiosk_app_attributes=None): self.client = host self.kiosk_app_name = None factory = remote_facade_factory.RemoteFacadeFactory( host, no_chrome=True) self.system_facade = factory.create_system_facade() self.kiosk_facade = factory.create_kiosk_facade() self._setup_kiosk_app_on_dut(kiosk_app_attributes) time.sleep(STABILIZATION_DURATION) self._initialize_test_variables() self.perf_results = {'cpu': '0', 'mem': '0', 'temp': '0'} for iteration in range(PERF_CAPTURE_ITERATIONS): #TODO(krishnargv@): Add a method to verify that the Kiosk app is # active and is running on the DUT. logging.info("Running perf_capture Iteration: %d", iteration+1) self.perf_results = self._run_perf_capture_cycle() self._write_perf_keyvals(self.perf_results) self._write_perf_results(self.perf_results) # Post perf results directly to performance dashboard. You may view # uploaded data at https://chromeperf.appspot.com/new_points, # with test path pattern=ChromeOS_Enterprise/cros-*/longevity*/* chart_data = self._read_perf_results() data_obj = self._format_data_for_upload(chart_data) self._send_to_dashboard(data_obj) tpm_utils.ClearTPMOwnerRequest(self.client)
def setup(self, chart_host): # prepare chart device self.chart_dir = chart_host.get_tmp_dir() logging.debug('chart_dir=%s', self.chart_dir) self.display_facade = remote_facade_factory.RemoteFacadeFactory( chart_host).create_display_facade() # set chart display brightness self.init_display_level = chart_host.run( self.BRIGHTNESS_CMD).stdout.rstrip() chart_host.run(self.SET_BRIGHTNESS_CMD % self.DISPLAY_LEVEL) # keep display always on chart_host.run('stop powerd', ignore_status=True) # scp scene to chart_host chart_host.send_file( os.path.join(self.bindir, 'files', self.SCENE_NAME), self.chart_dir) chart_host.run('chmod', args=('-R', '755', self.chart_dir)) # display scene self.display_facade.load_url( 'file://' + os.path.join(self.chart_dir, self.SCENE_NAME)) self.display_facade.set_fullscreen(True)
def run_once(self, host, player): """ Entry point for test case. @param host: A reference to the DUT. @param player: A string representing what audio player to use. Could be 'native' or 'browser'. """ if not audio_test_utils.has_internal_speaker(host): return host.chameleon.setup_and_reset(self.outputdir) facade_factory = remote_facade_factory.RemoteFacadeFactory( host, results_dir=self.resultsdir) self.audio_facade = facade_factory.create_audio_facade() self.browser_facade = facade_factory.create_browser_facade() widget_factory = chameleon_audio_helper.AudioWidgetFactory( facade_factory, host) self.sound_source = widget_factory.create_widget( chameleon_audio_ids.CrosIds.SPEAKER) self.sound_recorder = widget_factory.create_widget( chameleon_audio_ids.ChameleonIds.MIC) self.play_and_record(host, player, 'left') self.process_and_save_data(channel='left') self.validate_recorded_data(channel='left') self.play_and_record(host, player, 'right') self.process_and_save_data(channel='right') self.validate_recorded_data(channel='right')
def run_once(self, host, num_iterations=12): """Running Bluetooth adapter tests for basic audio link @param host: the DUT, usually a chromebook @param num_iterations: the number of rounds to execute the test """ self.host = host self.check_chameleon() # Setup Bluetooth widgets and their binder, but do not yet connect. audio_test.audio_test_requirement() factory = remote_facade_factory.RemoteFacadeFactory( host, results_dir=self.resultsdir) chameleon_board = self.host.chameleon if chameleon_board is None: raise error.TestNAError("No chameleon device is present") chameleon_board.setup_and_reset(self.outputdir) widget_factory = chameleon_audio_helper.AudioWidgetFactory( factory, host) source = widget_factory.create_widget( chameleon_audio_ids.CrosIds.BLUETOOTH_HEADPHONE) bluetooth_widget = widget_factory.create_widget( chameleon_audio_ids.PeripheralIds.BLUETOOTH_DATA_RX) binder = widget_factory.create_binder(source, bluetooth_widget) # Test body self.play_audio(binder, factory, widget_factory, num_iterations)
def run_once(self, host=None): self.client = host factory = remote_facade_factory.RemoteFacadeFactory(host, no_chrome=True) self.system_facade = factory.create_system_facade() self.cfm_facade = factory.create_cfm_facade() tpm_utils.ClearTPMOwnerRequest(self.client) if self.client.servo: self.client.servo.switch_usbkey('dut') self.client.servo.set('usb_mux_sel3', 'dut_sees_usbkey') time.sleep(_SHORT_TIMEOUT) self.client.servo.set('dut_hub1_rst1', 'off') time.sleep(_SHORT_TIMEOUT) try: self.enroll_device_and_start_hangout() self.collect_perf_data() self.cfm_facade.end_hangout_session() self.upload_jmidata() except Exception as e: raise error.TestFail(str(e)) tpm_utils.ClearTPMOwnerRequest(self.client)
def run_once(self, host, repeat): factory = remote_facade_factory.RemoteFacadeFactory(host) self.display_facade = factory.create_display_facade() chameleon_board = host.chameleon chameleon_board.reset() finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, self.display_facade) self.errors = [] for chameleon_port in finder.iterate_all_ports(): self.chameleon_port = chameleon_port self.screen_test = chameleon_screen_test.ChameleonScreenTest( chameleon_port, self.display_facade, self.outputdir) logging.debug('See the display on Chameleon: port %d (%s)', self.chameleon_port.get_connector_id(), self.chameleon_port.get_connector_type()) # Keep the original connector name, for later comparison. self.connector_used = ( self.display_facade.get_external_connector_name()) for i in xrange(repeat): logging.info("Iteration %d", (i + 1)) self.set_mode_and_check(False) self.set_mode_and_check(True)
def run_once(self, host, repeat, no_check=False): if not host.get_board_type() == 'CHROMEBOOK': raise error.TestNAError('DUT is not Chromebook. Test Skipped') factory = remote_facade_factory.RemoteFacadeFactory(host) self.display_facade = factory.create_display_facade() chameleon_board = host.chameleon chameleon_board.setup_and_reset(self.outputdir) finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, self.display_facade) self.errors = [] for chameleon_port in finder.iterate_all_ports(): self.chameleon_port = chameleon_port self.screen_test = chameleon_screen_test.ChameleonScreenTest( chameleon_port, self.display_facade, self.outputdir) logging.debug('See the display on Chameleon: port %d (%s)', self.chameleon_port.get_connector_id(), self.chameleon_port.get_connector_type()) # Keep the original connector name, for later comparison. self.connector_used = ( self.display_facade.get_external_connector_name()) for i in xrange(repeat): logging.info("Iteration %d", (i + 1)) self.set_mode_and_check(True, no_check) self.set_mode_and_check(False, no_check)
def run_once(self, host, plug_status, test_mirrored=False): # Check for chromebook type devices if not host.get_board_type() == 'CHROMEBOOK': raise error.TestNAError('DUT is not Chromebook. Test Skipped') # Check for incompatible with servo chromebooks board_name = host.get_board().split(':')[1] if board_name in self.INCOMPATIBLE_SERVO_BOARDS: raise error.TestNAError( 'DUT is incompatible with servo. Skipping test.') self.host = host self.test_mirrored = test_mirrored self.errors = list() # Check the servo object if self.host.servo is None: raise error.TestError('Invalid servo object found on the host.') factory = remote_facade_factory.RemoteFacadeFactory(host) display_facade = factory.create_display_facade() chameleon_board = host.chameleon chameleon_board.setup_and_reset(self.outputdir) finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, display_facade) for chameleon_port in finder.iterate_all_ports(): self.run_test_on_port(chameleon_port, display_facade, plug_status)
def run_once(self, host, repeat_count=1): """Running Bluetooth adapter standalone tests. @param host: device under test host @param repeat_count: the number of times to repeat the tests. """ self.host = host factory = remote_facade_factory.RemoteFacadeFactory(host) self.bluetooth_facade = factory.create_bluetooth_hid_facade() for i in xrange(1, repeat_count + 1): logging.info('repeat count: %d / %d', i, repeat_count) # The bluetoothd must be running in the beginning. self.test_bluetoothd_running() # It is possible that the adapter is not powered on yet. # Power it on anyway and verify that it is actually powered on. self.test_power_on_adapter() # Verify that the adapter could be powered off and powered on, # and that it is in the correct working state. self.test_power_off_adapter() self.test_power_on_adapter() self.test_adapter_work_state() # Verify that the bluetoothd could be simply stopped and then # be started again, and that it is in the correct working state. self.test_stop_bluetoothd() self.test_start_bluetoothd() self.test_adapter_work_state() # Verify that the adapter could be reset off and on which includes # removing all cached information. self.test_reset_off_adapter() self.test_reset_on_adapter() self.test_adapter_work_state() # Verify that the adapter supports basic profiles. self.test_UUIDs() # Verify that the adapter could start and stop discovery. self.test_start_discovery() self.test_stop_discovery() self.test_start_discovery() # Verify that the adapter could set both discoverable and # non-discoverable successfully. self.test_discoverable() self.test_nondiscoverable() self.test_discoverable() # Verify that the adapter could set pairable and non-pairable. self.test_pairable() self.test_nonpairable() self.test_pairable() if self.fails: raise error.TestFail(self.fails)
def run_once(self, host=None): """Runs the test.""" self.client = host factory = remote_facade_factory.RemoteFacadeFactory(host, no_chrome=True) self.cfm_facade = factory.create_cfm_facade() tpm_utils.ClearTPMOwnerRequest(self.client) if self.client.servo: self.client.servo.switch_usbkey('dut') self.client.servo.set('usb_mux_sel3', 'dut_sees_usbkey') time.sleep(SHORT_TIMEOUT) self.client.servo.set('dut_hub1_rst1', 'off') time.sleep(SHORT_TIMEOUT) try: self.cfm_facade.enroll_device() self.cfm_facade.restart_chrome_for_cfm() self._hangouts_sanity_test() self._peripherals_sanity_test() self._diagnostics_sanity_test() except Exception as e: raise error.TestFail(str(e)) tpm_utils.ClearTPMOwnerRequest(self.client) if FAILED_TEST_LIST: raise error.TestFail( 'Test failed because of following reasons: %s' % ', '.join(map(str, FAILED_TEST_LIST)))
def run_once(self, host, repeat, cmd): """Runs the test.""" self.client = host factory = remote_facade_factory.RemoteFacadeFactory(host, no_chrome=True) self.cfm_facade = factory.create_cfm_facade() tpm_utils.ClearTPMOwnerRequest(self.client) if self.client.servo: self.client.servo.switch_usbkey('dut') self.client.servo.set('usb_mux_sel3', 'dut_sees_usbkey') time.sleep(_LONG_TIMEOUT) self.client.servo.set('dut_hub1_rst1', 'off') time.sleep(_LONG_TIMEOUT) try: self._enroll_device() self._start_hangout_session() self._change_volume(repeat, cmd) self._end_hangout_session() except Exception as e: raise error.TestFail(str(e)) tpm_utils.ClearTPMOwnerRequest(self.client)
def run_once(self, host, hangout, repeat): """Main function to run autotest. @param host: Host object representing the DUT. @hangout: Name of meeting that DUT will join/leave. @param repeat: Number of times CfM joins and leaves meeting. """ counter = 1 self.client = host factory = remote_facade_factory.RemoteFacadeFactory(host, no_chrome=True) self.cfm_facade = factory.create_cfm_facade() tpm_utils.ClearTPMOwnerRequest(self.client) if self.client.servo: self.client.servo.switch_usbkey('dut') self.client.servo.set('usb_mux_sel3', 'dut_sees_usbkey') time.sleep(SHORT_TIMEOUT) self.client.servo.set('dut_hub1_rst1', 'off') time.sleep(SHORT_TIMEOUT) try: self.cfm_facade.enroll_device() self.cfm_facade.restart_chrome_for_cfm() self.cfm_facade.wait_for_telemetry_commands() if not self.cfm_facade.is_oobe_start_page(): self.cfm_facade.wait_for_oobe_start_page() self.cfm_facade.skip_oobe_screen() except Exception as e: raise error.TestFail(str(e)) usb_original_output = host.run(CMD).stdout.rstrip() logging.info('The initial usb devices:\n %s', usb_original_output) usb_original_list = usb_original_output.splitlines() while repeat > 0: self.client.reboot() time.sleep(random.randrange(1, IDLE_TIME)) self.cfm_facade.restart_chrome_for_cfm() self.cfm_facade.wait_for_telemetry_commands() if not self._compare_cmd_output(usb_original_list): raise error.TestFail( "After reboot list of USB devices is not the same.") for test in range(random.randrange(1, MEETS_BETWEEN_REBOOT)): logging.info('Start meeting for loop: #%d', counter) counter += 1 self._run_hangout_session(hangout, usb_original_list) if FAILED_TEST_LIST: raise error.TestFail( 'Test failed because of following reasons: %s' % ', '.join(map(str, FAILED_TEST_LIST))) repeat -= 1 if repeat == 0: break tpm_utils.ClearTPMOwnerRequest(self.client)
def __init__(self, cros_host, outputdir=None, no_chrome=False): """Initializes the object.""" self.host = cros_host factory = remote_facade_factory.RemoteFacadeFactory( cros_host, no_chrome) self.display_facade = factory.create_display_facade() self.chameleon = cros_host.chameleon self.chameleon.setup_and_reset(outputdir)
def run_once(self, host, edid_set): def _get_edid_type(s): i = s.rfind('_') + 1 j = len(s) - len('.txt') return s[i:j].upper() edid_path = os.path.join(self.bindir, 'test_data', 'edids', edid_set, '*') factory = remote_facade_factory.RemoteFacadeFactory(host) display_facade = factory.create_display_facade() chameleon_board = host.chameleon chameleon_board.setup_and_reset(self.outputdir) finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, display_facade) for chameleon_port in finder.iterate_all_ports(): screen_test = chameleon_screen_test.ChameleonScreenTest( chameleon_port, display_facade, self.outputdir) logging.info('See the display on Chameleon: port %d (%s)', chameleon_port.get_connector_id(), chameleon_port.get_connector_type()) connector = chameleon_port.get_connector_type() supported_types = self._EDID_TYPES[connector] failed_edids = [] for filepath in glob.glob(edid_path): filename = os.path.basename(filepath) edid_type = _get_edid_type(filename) if edid_type not in supported_types: logging.info('Skip EDID: %s...', filename) continue logging.info('Use EDID: %s...', filename) try: with chameleon_port.use_edid( edid.Edid.from_file(filepath, skip_verify=True)): resolution = utils.wait_for_value_changed( display_facade.get_external_resolution, old_value=None) if resolution is None: raise error.TestFail('No external display detected on DUT') if screen_test.test_resolution(resolution): raise error.TestFail('Resolution test failed') except (error.TestFail, xmlrpclib.Fault) as e: logging.warning(e) logging.error('EDID not supported: %s', filename) failed_edids.append(filename) if failed_edids: message = ('Total %d EDIDs not supported: ' % len(failed_edids) + ', '.join(failed_edids)) logging.error(message) raise error.TestFail(message)
def run_once(self, suspends=5, integration=None): self._host = self.context.client.host for router_conf, client_conf in self._configurations: self.context.configure(configuration_parameters=router_conf) assoc_params = xmlrpc_datatypes.AssociationParameters( is_hidden=client_conf.is_hidden, security_config=client_conf.security_config, ssid=self.context.router.get_ssid()) self.context.assert_connect_wifi(assoc_params) self._timings = list() if integration: if not self._host.servo: raise error.TestNAError('Servo object returned None. ' 'Check if servo is missing or bad') # If the DUT is up and cold_reset is set to on, that means the # DUT does not support cold_reset. We can't run the test, # because it may get in a bad state and we won't be able # to recover. if self._host.servo.get('cold_reset') == 'on': raise error.TestNAError('This DUT does not support ' 'cold reset, exiting') self.factory = remote_facade_factory.RemoteFacadeFactory( self._host, no_chrome=True) logging.info('Running Wifi Suspend Stress Integration test.') browser_facade = self.factory.create_browser_facade() browser_facade.start_default_chrome() utils.poll_for_condition(condition=self.logged_in, timeout=_START_TIMEOUT_SECONDS, sleep_interval=1, desc='User not logged in.') self.check_servo_lid_open_support() stressor = stress.CountedStressor(self.stress_wifi_suspend) else: logging.info('Running Non integration Wifi Stress test.') stressor = stress.CountedStressor( self.powerd_non_servo_wifi_suspend) stressor.start(suspends) stressor.wait() perf_dict = { 'fastest': max(self._timings), 'slowest': min(self._timings), 'average': (float(sum(self._timings)) / len(self._timings)) } for key in perf_dict: self.output_perf_value( description=key, value=perf_dict[key], units='seconds', higher_is_better=False, graph=router_conf.perf_loggable_description)
def run_once(self, host, device_type, num_iterations=1, min_pass_count=1): """Running Bluetooth HID reports tests. @param host: the DUT, usually a chromebook @param device_type : the bluetooth HID device type, e.g., 'MOUSE' @param num_iterations: the number of rounds to execute the test @param min_pass_count: the minimal pass count to pass this test """ self.host = host factory = remote_facade_factory.RemoteFacadeFactory(host) self.bluetooth_facade = factory.create_bluetooth_hid_facade() self.input_facade = factory.create_input_facade() pass_count = 0 self.total_fails = {} for iteration in xrange(1, num_iterations + 1): self.fails = [] # Get the bluetooth device object. device = self.get_device(device_type) # Reset the adapter and set it pairable. self.test_reset_on_adapter() self.test_pairable() # Let the adapter pair, and connect to the target device. time.sleep(self.TEST_SLEEP_SECS) self.test_discover_device(device.address) time.sleep(self.TEST_SLEEP_SECS) self.test_pairing(device.address, device.pin, trusted=True) time.sleep(self.TEST_SLEEP_SECS) self.test_connection_by_adapter(device.address) # Run tests about mouse reports. if device_type == 'MOUSE': self._run_mouse_tests(device) # Disconnect the device, and remove the pairing. self.test_disconnection_by_adapter(device.address) self.test_remove_pairing(device.address) if bool(self.fails): self.total_fails['Round %d' % iteration] = self.fails else: pass_count += 1 fail_count = iteration - pass_count logging.info('=== (pass = %d, fail = %d) / total %d ===\n', pass_count, fail_count, num_iterations) if pass_count < min_pass_count: raise error.TestFail(self.total_fails)
def run_once(self, host, peripheral_whitelist_dict): """Main function to run autotest. @param host: Host object representing the DUT. """ self.client = host factory = remote_facade_factory.RemoteFacadeFactory(host, no_chrome=True) self.cfm_facade = factory.create_cfm_facade() tpm_utils.ClearTPMOwnerRequest(self.client) if self.client.servo: self.client.servo.switch_usbkey('dut') self.client.servo.set('usb_mux_sel3', 'dut_sees_usbkey') time.sleep(_WAIT_DELAY) self._set_hub_power(True) usb_list_dir_on = self._get_usb_device_dirs() cros_peripheral_dict = self._parse_device_dir_for_info( usb_list_dir_on, peripheral_whitelist_dict) logging.debug('Peripherals detected by CrOS: %s', cros_peripheral_dict) try: self._enroll_device_and_skip_oobe() self._set_preferred_peripherals(cros_peripheral_dict) cfm_peripheral_dict = self._peripheral_detection() logging.debug('Peripherals detected by hotrod: %s', cfm_peripheral_dict) except Exception as e: raise error.TestFail(str(e)) tpm_utils.ClearTPMOwnerRequest(self.client) cros_peripherals = set(cros_peripheral_dict.iteritems()) cfm_peripherals = set(cfm_peripheral_dict.iteritems()) peripheral_diff = cros_peripherals.difference(cfm_peripherals) if peripheral_diff: no_match_list = list() for item in peripheral_diff: no_match_list.append(item[0]) raise error.TestFail('Following peripherals do not match: %s' % ', '.join(no_match_list))
def create_remote_facade_factory(host, result_dir): """Creates a remote facade factory to access multimedia server. @param host: A CrosHost object to access Cros device. @param result_dir: A directory to store multimedia server init log. @returns: A RemoteFacadeFactory object to create different facade for different functionalities provided by multimedia server. """ try: factory = remote_facade_factory.RemoteFacadeFactory(host) finally: host.get_file( constants.MULTIMEDIA_XMLRPC_SERVER_LOG_FILE, os.path.join(result_dir, 'multimedia_xmlrpc_server.log.init')) return factory
def initialize(self, host, run_test_only=False, skip_enrollment=False): """ Initializes common test properties. @param host: a host object representing the DUT. @param run_test_only: Wheter to run only the test or to also perform deprovisioning, enrollment and system reboot. If set to 'True', the DUT must already be enrolled and past the OOB screen to be able to execute the test. @param skip_enrollment: Whether to skip the enrollment step. Cleanup at the end of the test is done regardless. """ super(CfmBaseTest, self).initialize() self._host = host self._run_test_only = run_test_only self._skip_enrollment = skip_enrollment self._facade_factory = remote_facade_factory.RemoteFacadeFactory( self._host, no_chrome=True) self.cfm_facade = self._facade_factory.create_cfm_facade()
def run_once(self, host, suspend=False, disable=False, disconnect=False): """Runs bluetooth audio connection test.""" self.host = host factory = remote_facade_factory.RemoteFacadeFactory( host, results_dir=self.resultsdir) self.audio_facade = factory.create_audio_facade() chameleon_board = host.chameleon chameleon_board.setup_and_reset(self.outputdir) widget_factory = chameleon_audio_helper.AudioWidgetFactory( factory, host) source = widget_factory.create_widget( chameleon_audio_ids.CrosIds.BLUETOOTH_HEADPHONE) bluetooth_widget = widget_factory.create_widget( chameleon_audio_ids.PeripheralIds.BLUETOOTH_DATA_RX) recorder = widget_factory.create_widget( chameleon_audio_ids.ChameleonIds.LINEIN) binder = widget_factory.create_binder(source, bluetooth_widget, recorder) with chameleon_audio_helper.bind_widgets(binder): audio_test_utils.dump_cros_audio_logs(host, self.audio_facade, self.resultsdir, 'after_binding') if audio_test_utils.has_internal_microphone(host): self.audio_facade.set_chrome_active_node_type( None, 'BLUETOOTH') audio_test_utils.check_audio_nodes(self.audio_facade, (['BLUETOOTH'], ['BLUETOOTH'])) # Monitors there is no node change in this time period. with audio_test_utils.monitor_no_nodes_changed( self.audio_facade, self.dump_logs_after_nodes_changed): logging.debug('Monitoring NodesChanged signal for %s seconds', self.CONNECTION_TEST_TIME_SECS) time.sleep(self.CONNECTION_TEST_TIME_SECS)
def run_once(self, host): factory = remote_facade_factory.RemoteFacadeFactory(host) display_facade = factory.create_display_facade() chameleon_board = host.chameleon chameleon_board.setup_and_reset(self.outputdir) finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, display_facade) ports = finder.find_all_ports() connected_ports = ports.connected dut_failed_ports = ports.failed msg = str(finder) logging.debug(msg) if dut_failed_ports or not connected_ports: raise error.TestFail(msg)
def run_once(self, host=None, perf_params=None): self.client = host self.kiosk_app_name = None self.perf_params = perf_params logging.info('Perf params: %r', self.perf_params) if not enterprise_longevity_helper.verify_perf_params( EXPECTED_PARAMS, self.perf_params): raise error.TestFail('Missing or incorrect perf_params in the' ' control file. Refer to the README.txt for' ' info on perf params.: %r' %(self.perf_params)) factory = remote_facade_factory.RemoteFacadeFactory( host, no_chrome=True) self.system_facade = factory.create_system_facade() self.kiosk_facade = factory.create_kiosk_facade() self._setup_kiosk_app_on_dut(self.perf_params['kiosk_app_attributes']) time.sleep(STABILIZATION_DURATION) self._initialize_test_variables() for iteration in range(self.perf_params['perf_capture_iterations']): #TODO(krishnargv@): Add a method to verify that the Kiosk app is # active and is running on the DUT. logging.info("Running perf_capture Iteration: %d", iteration+1) self.perf_results = self._run_perf_capture_cycle() self._write_perf_keyvals(self.perf_results) self._write_perf_results(self.perf_results) # Post perf results directly to performance dashboard. You may view # uploaded data at https://chromeperf.appspot.com/new_points, # with test path pattern=ChromeOS_Enterprise/cros-*/longevity*/* if perf_params['test_type'] == 'multiple_samples': chart_data = enterprise_longevity_helper.read_perf_results( self.resultsdir, 'results-chart.json') data_obj = self._format_data_for_upload(chart_data) self._send_to_dashboard(data_obj) tpm_utils.ClearTPMOwnerRequest(self.client)
def run_once(self, host, test_mirrored=True): """Checks the mode is preserved after logout @param host: DUT object @param test_mirrored: True if mirror mode """ self.host = host self.errors = list() chameleon_board = host.chameleon factory = remote_facade_factory.RemoteFacadeFactory( self.host, results_dir=self.resultsdir) self.display_facade = factory.create_display_facade() self.browser_facade = factory.create_browser_facade() self.input_facade = factory.create_input_facade() chameleon_board.setup_and_reset(self.outputdir) finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, self.display_facade) # Iterates all connected video ports and ensures every of them plugged for chameleon_port in finder.iterate_all_ports(): self.run_test_on_port(chameleon_port, test_mirrored)
def run_once(self, host, test_mirrored=False): factory = remote_facade_factory.RemoteFacadeFactory(host) self._display_facade = factory.create_display_facade() self._test_tab_descriptor = None chameleon_board = host.chameleon chameleon_board.reset() finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, self._display_facade) errors = [] for chameleon_port in finder.iterate_all_ports(): logging.info('Set mirrored: %s', test_mirrored) self._display_facade.set_mirrored(test_mirrored) self._test_screen_with_color_sequence(test_mirrored, chameleon_port, errors) if errors: raise error.TestFail('; '.join(set(errors)))
def run_once(self, host, test_mirrored=False): factory = remote_facade_factory.RemoteFacadeFactory(host) display_facade = factory.create_display_facade() chameleon_board = host.chameleon chameleon_board.setup_and_reset(self.outputdir) finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, display_facade) errors = [] for chameleon_port in finder.iterate_all_ports(): screen_test = chameleon_screen_test.ChameleonScreenTest( host, chameleon_port, display_facade, self.outputdir) with chameleon_port.use_edid(edid.NO_EDID): connector_name = utils.wait_for_value_changed( display_facade.get_external_connector_name, old_value=False) if not connector_name: error_message = 'Failed to detect display without an EDID' logging.error(error_message) errors.append(error_message) continue logging.info('Set mirrored: %s', test_mirrored) display_facade.set_mirrored(test_mirrored) resolution = display_facade.get_external_resolution() if resolution not in self.STANDARD_MODE_RESOLUTIONS: error_message = ('Switched to a non-standard mode: %r' % resolution) logging.error(error_message) errors.append(error_message) continue screen_test.test_screen_with_image(resolution, test_mirrored, errors) if errors: raise error.TestFail('; '.join(set(errors)))
def run_once(self, host=None): """Runs the test.""" self.client = host factory = remote_facade_factory.RemoteFacadeFactory(host, no_chrome=True) self.cfm_facade = factory.create_cfm_facade() tpm_utils.ClearTPMOwnerRequest(self.client) # Enable USB port on the servo so device can see and talk to the # attached peripheral. if self.client.servo: self.client.servo.switch_usbkey('dut') self.client.servo.set('usb_mux_sel3', 'dut_sees_usbkey') time.sleep(SHORT_TIMEOUT) self.client.servo.set('dut_hub1_rst1', 'off') time.sleep(SHORT_TIMEOUT) try: self.cfm_facade.enroll_device() # The following reboot and sleep are a hack around devtools crash # issue tracked in crbug.com/739474. self.client.reboot() time.sleep(SHORT_TIMEOUT) self.cfm_facade.skip_oobe_after_enrollment() # Following trigger new Thor/Meetings APIs. self.cfm_facade.wait_for_meetings_telemetry_commands() self.cfm_facade.start_meeting_session() time.sleep(LONG_TIMEOUT) self.cfm_facade.end_meeting_session() time.sleep(SHORT_TIMEOUT) except Exception as e: raise error.TestFail(str(e)) finally: tpm_utils.ClearTPMOwnerRequest(self.client)
def run_once(self, host, plug_status, test_mirrored=False): # Check for chromebook type devices if not host.get_board_type() == 'CHROMEBOOK': raise error.TestNAError('DUT is not Chromebook. Test Skipped') self.host = host self.test_mirrored = test_mirrored self.errors = list() # Check the servo object if self.host.servo is None: raise error.TestError('Invalid servo object found on the host.') factory = remote_facade_factory.RemoteFacadeFactory(host) display_facade = factory.create_display_facade() chameleon_board = host.chameleon chameleon_board.reset() finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, display_facade) for chameleon_port in finder.iterate_all_ports(): self.run_test_on_port(chameleon_port, display_facade, plug_status)
def run_once(self, host=None, is_meeting=False): self.client = host factory = remote_facade_factory.RemoteFacadeFactory(host, no_chrome=True) self.system_facade = factory.create_system_facade() self.cfm_facade = factory.create_cfm_facade() tpm_utils.ClearTPMOwnerRequest(self.client) if self.client.servo: self.client.servo.switch_usbkey('dut') self.client.servo.set('usb_mux_sel3', 'dut_sees_usbkey') time.sleep(_SHORT_TIMEOUT) self.client.servo.set('dut_hub1_rst1', 'off') time.sleep(_SHORT_TIMEOUT) try: if is_meeting: self.enroll_device_and_join_meeting() else: self.enroll_device_and_start_hangout() self.collect_perf_data() if is_meeting: self.cfm_facade.end_meeting_session() else: self.cfm_facade.end_hangout_session() self.upload_jmidata() except Exception as e: # Clear tpm to remove device ownership before exiting to ensure # device is not left in an enrolled state. tpm_utils.ClearTPMOwnerRequest(self.client) raise error.TestFail(str(e)) tpm_utils.ClearTPMOwnerRequest(self.client)
def run_once(self, host, subtest, test_duration=60): self._host = host self._subtest = subtest factory = remote_facade_factory.RemoteFacadeFactory(host) self._browser_facade = factory.create_browser_facade() self._browser_facade.start_custom_chrome(self.CHROME_KWARGS) self._display_facade = factory.create_display_facade() self._graphics_facade = factory.create_graphics_facade() logging.info('Preparing local WebGL test assets.') self._prepare_test_assets() chameleon_board = host.chameleon chameleon_board.setup_and_reset(self.outputdir) finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, self._display_facade) # Snapshot the DUT system logs for any prior GPU hangs self._graphics_facade.graphics_state_checker_initialize() for chameleon_port in finder.iterate_all_ports(): logging.info('Setting Chameleon screen to extended mode.') self._display_facade.set_mirrored(False) time.sleep(self.WAIT_AFTER_SWITCH) logging.info('Launching WebGL windows.') self._setup_windows() logging.info('Measuring the external display update rate.') self._measure_external_display_fps(chameleon_port) logging.info('Running test for {}s.'.format(test_duration)) time.sleep(test_duration) # Raise an error on new GPU hangs self._graphics_facade.graphics_state_checker_finalize()
def run_once(self, host, repeat, peripheral_whitelist_dict): """Main function to run autotest. @param host: Host object representing the DUT. @param repeat: Number of times peripheral should be hotplugged. @param peripheral_whitelist_dict: Dictionary of peripherals to test. """ self.client = host factory = remote_facade_factory.RemoteFacadeFactory(host, no_chrome=True) self.cfm_facade = factory.create_cfm_facade() tpm_utils.ClearTPMOwnerRequest(self.client) if self.client.servo: self.client.servo.switch_usbkey('dut') self.client.servo.set('usb_mux_sel3', 'dut_sees_usbkey') time.sleep(_SHORT_TIMEOUT) self._set_hub_power(True) try: self._enroll_device_and_skip_oobe() self._set_peripheral(peripheral_whitelist_dict) on_off_list = [True, False] on_off = itertools.cycle(on_off_list) while repeat: reset_ = on_off.next() self._set_hub_power(reset_) self._peripheral_detection(peripheral_whitelist_dict, reset_) repeat -= 1 except Exception as e: raise error.TestFail(str(e)) tpm_utils.ClearTPMOwnerRequest(self.client)