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)))