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)
