def run_test_on_port(self, chameleon_port, test_mirrored):
"""Run the test on the given Chameleon port.
@param chameleon_port: a ChameleonPorts object.
@param test_mirrored: True if mirror mode
@raise error.TestFail if any display errors
"""
self.chameleon_port = chameleon_port
self.screen_test = chameleon_screen_test.ChameleonScreenTest(
self.host, chameleon_port, self.display_facade, self.outputdir)
# Get connector type used (HDMI,DP,...)
self.connector_used = self.display_facade.get_external_connector_name()
# Set main display mode for the test
logging.info("Setting Mirrored display mode")
self.display_facade.set_mirrored(test_mirrored)
self.logout()
utils.poll_for_condition(
self.is_logged_out,
exception=error.TestFail('User is not logged out'),
sleep_interval=1)
logging.info("Restarting the chrome again!")
self.browser_facade.start_default_chrome(restart=True)
logging.info("Checking the external display mode and image!")
self.check_external_display(test_mirrored)
if self.errors:
raise error.TestFail('; '.join(set(self.errors)))
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, 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, 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, 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, test_mirrored=False, testcase_spec=None,
repeat_count=3, suspend_time_range=(5,7)):
if test_mirrored and not host.get_board_type() == 'CHROMEBOOK':
raise error.TestNAError('DUT is not Chromebook. Test Skipped')
if testcase_spec is None:
testcase_spec = self.DEFAULT_TESTCASE_SPEC
test_name = "%s_%dx%d" % testcase_spec
_, width, height = testcase_spec
test_resolution = (width, height)
if not edid.is_edid_supported(host, testcase_spec[1], testcase_spec[2]):
raise error.TestFail('Error: EDID is not supported by the platform'
': %s', test_name)
edid_path = os.path.join(self.bindir, 'test_data', 'edids', test_name)
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('Use EDID: %s', test_name)
with chameleon_port.use_edid_file(edid_path):
# Keep the original connector name, for later comparison.
expected_connector = utils.wait_for_value_changed(
display_facade.get_external_connector_name,
old_value=False)
logging.info('See the display on DUT: %s', expected_connector)
if not expected_connector:
raise error.TestFail('Error: Failed to see external display'
' (chameleon) from DUT: %s', test_name)
logging.info('Set mirrored: %s', test_mirrored)
display_facade.set_mirrored(test_mirrored)
logging.info('Repeat %d times Suspend and resume', repeat_count)
count = repeat_count
while count > 0:
count -= 1
if test_mirrored:
# magic sleep to make nyan_big wake up in mirrored mode
# TODO: find root cause
time.sleep(6)
suspend_time = random.randint(*suspend_time_range)
logging.info('Going to suspend, for %d seconds...',
suspend_time)
display_facade.suspend_resume(suspend_time)
logging.info('Resumed back')
message = screen_test.check_external_display_connected(
expected_connector)
if not message:
message = screen_test.test_screen_with_image(
test_resolution, test_mirrored)
if message:
raise error.TestFail(message)
def run_once(self, host, test_mirrored=False, resolution_list=None):
if not host.get_board_type() == 'CHROMEBOOK':
raise error.TestNAError('DUT is not Chromebook. Test Skipped')
if resolution_list is None:
resolution_list = self.DEFAULT_RESOLUTION_LIST
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)
errors = []
for chameleon_port in finder.iterate_all_ports():
screen_test = chameleon_screen_test.ChameleonScreenTest(
chameleon_port, display_facade, self.outputdir)
chameleon_port_name = chameleon_port.get_connector_type()
logging.info('Detected %s chameleon port.', chameleon_port_name)
for interface, width, height in resolution_list:
if not chameleon_port_name.startswith(interface):
continue
test_resolution = (width, height)
test_name = "%s_%dx%d" % ((interface,) + test_resolution)
if not edid.is_edid_supported(host, interface, width, height):
logging.info('Skip unsupported EDID: %s', test_name)
continue
edid_path = os.path.join(self.bindir, 'test_data', 'edids',
test_name)
logging.info('Use EDID: %s', test_name)
with chameleon_port.use_edid_file(edid_path):
index = utils.wait_for_value_changed(
display_facade.get_first_external_display_index,
old_value=False)
if not index:
raise error.TestFail("No external display is found.")
# In mirror mode only display index is '0', as external
# is treated same as internal(single resolution applies)
if test_mirrored:
index = 0
logging.info('Set mirrored: %s', test_mirrored)
display_facade.set_mirrored(test_mirrored)
settings_resolution_list = (
display_facade.get_available_resolutions(index))
if len(settings_resolution_list) == 0:
raise error.TestFail("No resolution list is found.")
logging.info('External display %d: %d resolutions found.',
index, len(settings_resolution_list))
for r in settings_resolution_list:
# FIXME: send a keystroke to keep display on.
# This is to work around a problem where the display may be
# turned off if the test has run for a long time (e.g.,
# greater than 15 min). When the display is off,
# set_resolution() will fail.
display_facade.hide_cursor()
logging.info('Set resolution to %dx%d', *r)
display_facade.set_resolution(index, *r)
time.sleep(self.RESOLUTION_CHANGE_TIME)
chameleon_port.wait_video_input_stable()
screen_test.test_screen_with_image(r, test_mirrored, errors)
if errors:
raise error.TestFail('; '.join(set(errors)))
def run_once(self,
host,
test_mirrored=False,
test_suspend_resume=False,
test_reboot=False,
test_lid_close_open=False,
resolution_list=None):
# Check the servo object.
if test_lid_close_open and host.servo is None:
raise error.TestError('Invalid servo object found on the host.')
if test_lid_close_open and not host.get_board_type() == 'CHROMEBOOK':
raise error.TestNAError('DUT is not Chromebook. Test Skipped')
if test_mirrored and 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.')
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 = []
if resolution_list is None:
resolution_list = self.DEFAULT_RESOLUTION_LIST
chameleon_supported = True
for chameleon_port in finder.iterate_all_ports():
screen_test = chameleon_screen_test.ChameleonScreenTest(
host, chameleon_port, display_facade, self.outputdir)
chameleon_port_name = chameleon_port.get_connector_type()
logging.info('Detected %s chameleon port.', chameleon_port_name)
for label, width, height in resolution_list:
test_resolution = (width, height)
test_name = "%s_%dx%d" % ((label, ) + test_resolution)
# The chameleon DP RX doesn't support 4K resolution.
# The max supported resolution is 2560x1600.
# See crbug/585900
if (chameleon_port_name.startswith('DP') and test_resolution >
(2560, 1600)):
chameleon_supported = False
if not edid.is_edid_supported(host, width, height):
logging.info('Skip unsupported EDID: %s', test_name)
continue
if test_lid_close_open:
logging.info('Close lid...')
host.servo.lid_close()
time.sleep(self.WAIT_TIME_LID_TRANSITION)
if test_reboot:
# Unplug the monitor explicitly. Otherwise, the following
# use_edid_file() call would expect a valid video signal,
# which is not true during reboot.
chameleon_port.unplug()
logging.info('Reboot...')
boot_id = host.get_boot_id()
host.reboot(wait=False)
host.test_wait_for_shutdown(self.REBOOT_TIMEOUT)
path = os.path.join(self.bindir, 'test_data', 'edids',
test_name)
logging.info('Use EDID: %s', test_name)
with chameleon_port.use_edid_file(path):
if test_lid_close_open:
logging.info('Open lid...')
host.servo.lid_open()
time.sleep(self.WAIT_TIME_LID_TRANSITION)
if test_reboot:
host.test_wait_for_boot(boot_id)
chameleon_port.plug()
utils.wait_for_value_changed(
display_facade.get_external_connector_name,
old_value=False)
logging.info('Set mirrored: %s', test_mirrored)
display_facade.set_mirrored(test_mirrored)
if test_suspend_resume:
if test_mirrored:
# magic sleep to wake up nyan_big in mirrored mode
# TODO: find root cause
time.sleep(6)
logging.info('Going to suspend...')
display_facade.suspend_resume()
logging.info('Resumed back')
screen_test.test_screen_with_image(test_resolution,
test_mirrored, errors,
chameleon_supported)
if errors:
raise error.TestFail('; '.join(set(errors)))
def run_once(self, host, plug_status, test_mirrored=False):
if test_mirrored and not host.get_board_type() == 'CHROMEBOOK':
raise error.TestNAError('DUT is not Chromebook. Test Skipped')
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 = []
is_display_failure = False
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())
logging.info('Set mirrored: %s', test_mirrored)
display_facade.set_mirrored(test_mirrored)
# Keep the original connector name, for later comparison.
expected_connector = display_facade.get_external_connector_name()
resolution = display_facade.get_external_resolution()
logging.info('See the display on DUT: %s %r', expected_connector,
resolution)
for (plugged_before_suspend, plugged_after_suspend,
plugged_before_resume) in plug_status:
test_case = ('TEST CASE: %s > SUSPEND > %s > %s > RESUME' %
('PLUG' if plugged_before_suspend else 'UNPLUG',
'PLUG' if plugged_after_suspend else 'UNPLUG',
'PLUG' if plugged_before_resume else 'UNPLUG'))
logging.info(test_case)
boot_id = host.get_boot_id()
chameleon_port.set_plug(plugged_before_suspend)
if screen_test.check_external_display_connected(
expected_connector
if plugged_before_suspend else False, errors):
is_display_failure = True
# Skip the following test if an unexpected display detected.
continue
logging.info('GOING TO SUSPEND FOR %d SECONDS...',
self.SUSPEND_DURATION)
time_before_suspend = time.time()
display_facade.suspend_resume_bg(self.SUSPEND_DURATION)
# Confirm DUT suspended.
logging.info('WAITING FOR SUSPEND...')
try:
host.test_wait_for_sleep(self.SUSPEND_TIMEOUT)
except error.TestFail, ex:
errors.append("%s - %s" % (test_case, str(ex)))
if plugged_after_suspend is not plugged_before_suspend:
chameleon_port.set_plug(plugged_after_suspend)
current_time = time.time()
sleep_time = (self.SUSPEND_DURATION -
(current_time - time_before_suspend) -
self.TIME_MARGIN_BEFORE_RESUME)
if sleep_time > 0:
logging.info('- Sleep for %.2f seconds...', sleep_time)
time.sleep(sleep_time)
if plugged_before_resume is not plugged_after_suspend:
chameleon_port.set_plug(plugged_before_resume)
time.sleep(self.TIME_MARGIN_BEFORE_RESUME)
logging.info('WAITING FOR RESUME...')
try:
host.test_wait_for_resume(boot_id, self.RESUME_TIMEOUT)
except error.TestFail, ex:
errors.append("%s - %s" % (test_case, str(ex)))
logging.info('Resumed back')
if screen_test.check_external_display_connected(
expected_connector if plugged_before_resume else False,
errors):
# Skip the following test if an unexpected display detected.
continue
if plugged_before_resume:
if test_mirrored and (not utils.wait_for_value(
display_facade.is_mirrored_enabled,
True,
timeout_sec=self.TIMEOUT_WAITING_MIRRORED)):
error_message = 'Error: not resumed to mirrored mode'
errors.append("%s - %s" % (test_case, error_message))
logging.error(error_message)
logging.info('Set mirrored: %s', True)
display_facade.set_mirrored(True)
elif screen_test.test_screen_with_image(
resolution, test_mirrored, errors):
is_display_failure = True
def run_test_on_port(self, chameleon_port, display_facade, plug_status):
"""Run the test on the given Chameleon port.
@param chameleon_port: a ChameleonPorts object.
@param display_facade: a display facade object.
@param plug_status: the plugged status before_close, after_close,
and before_open
"""
self.chameleon_port = chameleon_port
self.display_facade = display_facade
self.screen_test = chameleon_screen_test.ChameleonScreenTest(
chameleon_port, display_facade, self.outputdir)
# Get connector type used (HDMI,DP,...)
self.connector_used = self.display_facade.get_external_connector_name()
# Set main display mode for the test
self.display_facade.set_mirrored(self.test_mirrored)
for (plugged_before_close, plugged_after_close,
plugged_before_open) in plug_status:
logging.info('TEST CASE: %s > CLOSE_LID > %s > %s > OPEN_LID',
'PLUG' if plugged_before_close else 'UNPLUG',
'PLUG' if plugged_after_close else 'UNPLUG',
'PLUG' if plugged_before_open else 'UNPLUG')
is_suspended = False
boot_id = self.host.get_boot_id()
# Plug before close
self.chameleon_port.set_plug(plugged_before_close)
self.chameleon_port.wait_video_input_stable(
timeout=self.WAIT_TIME_STABLE_VIDEO_INPUT)
# Close lid and check
self.close_lid()
if plugged_before_close:
self.check_docked()
else:
self.host.test_wait_for_sleep(self.TIMEOUT_SUSPEND_TRANSITION)
is_suspended = True
# Plug after close and check
if plugged_after_close is not plugged_before_close:
self.chameleon_port.set_plug(plugged_after_close)
self.chameleon_port.wait_video_input_stable(
timeout=self.WAIT_TIME_STABLE_VIDEO_INPUT)
if not plugged_before_close:
self.check_still_suspended()
else:
self.host.test_wait_for_sleep(
self.TIMEOUT_SUSPEND_TRANSITION)
is_suspended = True
# Plug before open and check
if plugged_before_open is not plugged_after_close:
self.chameleon_port.set_plug(plugged_before_open)
self.chameleon_port.wait_video_input_stable(
timeout=self.WAIT_TIME_STABLE_VIDEO_INPUT)
if not plugged_before_close or not plugged_after_close:
self.check_still_suspended()
else:
self.host.test_wait_for_sleep(
self.TIMEOUT_SUSPEND_TRANSITION)
is_suspended = True
# Open lid and check
self.open_lid()
if is_suspended:
self.host.test_wait_for_resume(boot_id,
self.TIMEOUT_RESUME_TRANSITION)
is_suspended = False
# Check internal screen switch to primary display
self.check_primary_display_on_internal_screen()
# Plug monitor if not plugged, such that we can test the screen.
if not plugged_before_open:
self.chameleon_port.set_plug(True)
self.chameleon_port.wait_video_input_stable(
timeout=self.WAIT_TIME_STABLE_VIDEO_INPUT)
# Check status
self.check_external_display()
if self.errors:
raise error.TestFail('; '.join(set(self.errors)))
def run_once(self, host, test_mirrored=False, plug_status=None):
if test_mirrored and not host.get_board_type() == 'CHROMEBOOK':
raise error.TestNAError('DUT is not Chromebook. Test Skipped')
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 = []
is_display_failure = False
for chameleon_port in finder.iterate_all_ports():
screen_test = chameleon_screen_test.ChameleonScreenTest(
host, 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())
logging.info('Set mirrored: %s', test_mirrored)
display_facade.set_mirrored(test_mirrored)
# Keep the original connector name, for later comparison.
expected_connector = display_facade.get_external_connector_name()
resolution = display_facade.get_external_resolution()
logging.info('See the display on DUT: %s %r', expected_connector,
resolution)
if plug_status is None:
plug_status = self.PLUG_DEFAULT_CONFIG
for (plugged_before_boot, plugged_after_boot) in plug_status:
logging.info('TESTING THE CASE: %s > reboot > %s',
'PLUG' if plugged_before_boot else 'UNPLUG',
'PLUG' if plugged_after_boot else 'UNPLUG')
boot_id = host.get_boot_id()
chameleon_port.set_plug(plugged_before_boot)
# Don't wait DUT up. Do plug/unplug while booting.
logging.info('Reboot...')
host.reboot(wait=False)
host.test_wait_for_shutdown(
shutdown_timeout=self.REBOOT_TIMEOUT)
chameleon_port.set_plug(plugged_after_boot)
host.test_wait_for_boot(boot_id)
if screen_test.check_external_display_connected(
expected_connector if plugged_after_boot else False,
errors):
is_display_failure = True
# Skip the following test if an unexpected display detected.
continue
if plugged_after_boot:
if test_mirrored and (
not display_facade.is_mirrored_enabled()):
error_message = 'Error: not rebooted to mirrored mode'
errors.append(error_message)
logging.error(error_message)
is_display_failure = True
# Sets mirrored status for next test
logging.info('Set mirrored: %s', True)
display_facade.set_mirrored(True)
continue
if screen_test.test_screen_with_image(
resolution, test_mirrored, errors):
is_display_failure = True
if errors:
if is_display_failure:
raise error.TestFail('; '.join(set(errors)))
else:
raise error.TestError('; '.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.reset()
finder = chameleon_port_finder.ChameleonVideoInputFinder(
chameleon_board, display_facade)
errors = []
warns = []
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())
logging.info('Set mirrored: %s', test_mirrored)
display_facade.set_mirrored(test_mirrored)
# Keep the original connector name, for later comparison.
expected_connector = display_facade.get_external_connector_name()
resolution = display_facade.get_external_resolution()
logging.info('See the display on DUT: %s %r',
expected_connector, resolution)
for (plugged_before_noise,
plugged_after_noise) in self.PLUG_CONFIGS:
logging.info('TESTING THE CASE: %s > noise > %s',
'plug' if plugged_before_noise else 'unplug',
'plug' if plugged_after_noise else 'unplug')
chameleon_port.set_plug(plugged_before_noise)
if screen_test.check_external_display_connected(
expected_connector if plugged_before_noise else False,
errors):
# Skip the following test if an unexpected display detected.
continue
chameleon_port.fire_mixed_hpd_pulses(
self.PULSES_PLUGGED if plugged_after_noise
else self.PULSES_UNPLUGGED)
if plugged_after_noise:
chameleon_port.wait_video_input_stable()
if test_mirrored:
# Wait for resolution change to make sure the resolution
# is stable before moving on. This is to deal with the
# case where DUT may respond slowly after the noise.
# If the resolution doesn't change, then we are
# confident that it is stable. Otherwise, a slow
# response is caught.
r = display_facade.get_internal_resolution()
utils.wait_for_value_changed(
display_facade.get_internal_resolution,
old_value=r)
err = screen_test.check_external_display_connected(
expected_connector)
if not err:
err = screen_test.test_screen_with_image(
resolution, test_mirrored)
if err:
# When something goes wrong after the noise, a normal
# user would try to re-plug the cable to recover.
# We emulate this behavior below and report error if
# the problem persists.
logging.warn('Possibly flaky: %s', err)
warns.append('Possibly flaky: %s' % err)
logging.info('Replug and retry the screen test...')
chameleon_port.unplug()
time.sleep(self.REPLUG_DELAY_SEC)
chameleon_port.plug()
chameleon_port.wait_video_input_stable()
screen_test.test_screen_with_image(
resolution, test_mirrored, errors)
else:
screen_test.check_external_display_connected(False, errors)
time.sleep(1)
if errors:
raise error.TestFail('; '.join(set(errors)))
elif warns:
raise error.TestWarn('; '.join(set(warns)))
def run_once(self, host, test_mirrored=False):
if host.get_architecture() != 'arm':
raise error.TestNAError('HDCP is not supported on a non-ARM device')
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(
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())
logging.info('Set mirrored: %s', test_mirrored)
display_facade.set_mirrored(test_mirrored)
resolution = display_facade.get_external_resolution()
logging.info('Detected resolution on CrOS: %r', resolution)
original_cros_state = display_facade.get_content_protection()
was_chameleon_enabled = (
chameleon_port.is_content_protection_enabled())
try:
for (enable_chameleon, request_cros, expected_cros_state,
expected_chameleon_state) in self.TEST_CONFIGS:
# Do unplug and plug to emulate switching to a different
# display with a different content protection state.
chameleon_port.unplug()
logging.info('Set Chameleon HDCP: %r', enable_chameleon)
chameleon_port.set_content_protection(enable_chameleon)
time.sleep(self.DURATION_UNPLUG_FOR_HDCP)
chameleon_port.plug()
chameleon_port.wait_video_input_stable()
logging.info('Request CrOS HDCP: %s', request_cros)
display_facade.set_content_protection(request_cros)
state = utils.wait_for_value(
display_facade.get_content_protection, 'Enabled',
timeout_sec=self.TIMEOUT_HDCP_SWITCH)
logging.info('Got CrOS state: %s', state)
if state != expected_cros_state:
error_message = ('Failed to enable HDCP, state: %r' %
state)
logging.error(error_message)
errors.append(error_message)
encrypted = chameleon_port.is_video_input_encrypted()
logging.info('Got Chameleon state: %r', encrypted)
if encrypted != expected_chameleon_state:
error_message = ('Chameleon found HDCP in wrong state: '
'expected %r but got %r' %
(expected_chameleon_state, encrypted))
logging.error(error_message)
errors.append(error_message)
logging.info('Test screen under HDCP %s...',
'enabled' if encrypted else 'disabled')
screen_test.test_screen_with_image(
resolution, test_mirrored, errors)
finally:
display_facade.set_content_protection(original_cros_state)
chameleon_port.set_content_protection(was_chameleon_enabled)
if errors:
raise error.TestFail('; '.join(set(errors)))
def run_once(self,
host,
test_mirrored=False,
test_suspend_resume=False,
test_reboot=False,
test_lid_close_open=False,
resolution_list=None):
# Check the servo object
if test_lid_close_open and host.servo is None:
raise error.TestError('Invalid servo object found on the host.')
if test_lid_close_open and not host.get_board_type() == 'CHROMEBOOK':
raise error.TestNAError('DUT is not Chromebook. Test Skipped')
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)
errors = []
if resolution_list is None:
resolution_list = self.DEFAULT_RESOLUTION_LIST
for chameleon_port in finder.iterate_all_ports():
screen_test = chameleon_screen_test.ChameleonScreenTest(
chameleon_port, display_facade, self.outputdir)
chameleon_port_name = chameleon_port.get_connector_type()
logging.info('Detected %s chameleon port.', chameleon_port_name)
for interface, width, height in resolution_list:
if not chameleon_port_name.startswith(interface):
continue
test_resolution = (width, height)
test_name = "%s_%dx%d" % ((interface, ) + test_resolution)
if not edid.is_edid_supported(host, interface, width, height):
logging.info('Skip unsupported EDID: %s', test_name)
continue
if test_lid_close_open:
logging.info('Close lid...')
host.servo.lid_close()
time.sleep(self.WAIT_TIME_LID_TRANSITION)
if test_reboot:
logging.info('Reboot...')
boot_id = host.get_boot_id()
host.reboot(wait=False)
host.test_wait_for_shutdown(self.REBOOT_TIMEOUT)
path = os.path.join(self.bindir, 'test_data', 'edids',
test_name)
logging.info('Use EDID: %s', test_name)
with chameleon_port.use_edid_file(path):
if test_lid_close_open:
logging.info('Open lid...')
host.servo.lid_open()
time.sleep(self.WAIT_TIME_LID_TRANSITION)
if test_reboot:
host.test_wait_for_boot(boot_id)
utils.wait_for_value_changed(
display_facade.get_external_connector_name,
old_value=False)
logging.info('Set mirrored: %s', test_mirrored)
display_facade.set_mirrored(test_mirrored)
if test_suspend_resume:
if test_mirrored:
# magic sleep to wake up nyan_big in mirrored mode
# TODO: find root cause
time.sleep(6)
logging.info('Going to suspend...')
display_facade.suspend_resume()
logging.info('Resumed back')
screen_test.test_screen_with_image(test_resolution,
test_mirrored, errors)
if errors:
raise error.TestFail('; '.join(set(errors)))
