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 _find_video_port(self): """Finds HDMI as a video port.""" finder = chameleon_port_finder.ChameleonVideoInputFinder( self._chameleon_board, self._display_facade) self._hdmi_video_port = finder.find_port(self.interface) if not self._hdmi_video_port: raise ChameleonHDMIInputWidgetHandlerError( 'Can not find HDMI port, perhaps HDMI is not connected?')
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 start_dock_mode_measurement(self): """Starts the dock mode to measure. It iterates the connection ports between DUT and Chameleon and uses the first port. Sets DUT into the dock mode. Then yields the connected ports. It is used via a with statement, like the following: measurer = LocalChameleonMeasurer(cros_host, args, chrome) with measurer.start_dock_mode_measurement() as chameleon_port: # chameleon_port is automatically plugged before this line # and lid is close to enter doc mode. do_some_test_on(chameleon_port) # chameleon_port is automatically unplugged after this line # and lid is open again. @yields the first connected ChameleonVideoInput which is ensured plugged before yielding. @raises TestFail if no connected video port or fail to enter dock mode. """ finder = chameleon_port_finder.ChameleonVideoInputFinder( self.chameleon, self.display_facade) try: with finder.use_first_port() as chameleon_port: logging.info('Used Chameleon port: %s', chameleon_port.get_connector_type()) logging.info('Close lid to switch into dock mode...') self.host.servo.lid_close() time.sleep(self._WAIT_TIME_LID_TRANSITION) # Hide the typing cursor. self.display_facade.hide_typing_cursor() # Sleep a while to wait the pop-up window faded-out. time.sleep(self._TIME_WAIT_FADE_OUT) # Get the resolution to make sure Chameleon in a good state. resolution = chameleon_port.get_resolution() logging.info('Detected the resolution: %dx%d', *resolution) # Check if it is dock mode, no internal screen. if self.display_facade.get_internal_resolution() is not None: raise error.TestError('Failed to enter dock mode: ' 'internal display still valid') yield chameleon_port finally: logging.info('Open lid again...') self.host.servo.lid_open()
def _find_connected_port(self): """ Gets a connected port of the pre-specified interface. @raises TestError if desired port was not detected. """ self.chameleon_board.reset() finder = chameleon_port_finder.ChameleonVideoInputFinder( self.chameleon_board, self.display_facade) connected_port = finder.find_port(self.interface) if connected_port is None: msg = 'No %s port found.\n' % self.interface raise error.TestError(msg + str(finder)) self.port = connected_port self.was_plugged = connected_port.plugged
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, args): ext_paths = [constants.DISPLAY_TEST_EXTENSION] with chrome.Chrome(extension_paths=ext_paths, autotest_ext=True) as cr: factory = local_facade_factory.LocalFacadeFactory(cr) display_facade = factory.create_display_facade() chameleon_board = chameleon.create_chameleon_board( host.hostname, args) 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, 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 start_mirrored_mode_measurement(self): """Starts the mirrored mode to measure. It iterates the connection ports between DUT and Chameleon and uses the first port. Sets DUT into the mirrored mode. Then yields the connected ports. It is used via a with statement, like the following: measurer = LocalChameleonMeasurer(cros_host, args, chrome) with measurer.start_mirrored_mode_measurement() as chameleon_port: # chameleon_port is automatically plugged before this line. do_some_test_on(chameleon_port) # chameleon_port is automatically unplugged after this line. @yields the first connected ChameleonVideoInput which is ensured plugged before yielding. @raises TestFail if no connected video port. """ finder = chameleon_port_finder.ChameleonVideoInputFinder( self.chameleon, self.display_facade) with finder.use_first_port() as chameleon_port: logging.info('Used Chameleon port: %s', chameleon_port.get_connector_type()) logging.info('Setting to mirrored mode') self.display_facade.set_mirrored(True) # Hide the typing cursor. self.display_facade.hide_typing_cursor() # Sleep a while to wait the pop-up window faded-out. time.sleep(self._TIME_WAIT_FADE_OUT) # Get the resolution to make sure Chameleon in a good state. resolution = chameleon_port.get_resolution() logging.info('Detected the resolution: %dx%d', *resolution) yield chameleon_port
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, 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, 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, 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_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, source_path, codec, resolution, host, args, collect_only=False): board = utils.get_current_board() file_utils.make_leaf_dir(constants.TEST_DIR) with chrome.Chrome( extension_paths=[cros_constants.MULTIMEDIA_TEST_EXTENSION], autotest_ext=True) as cr: cr.browser.platform.SetHTTPServerDirectories(self.bindir) html_fullpath = os.path.join(self.bindir, 'video.html') player = native_html5_player.NativeHtml5Player( tab=cr.browser.tabs[0], full_url=cr.browser.platform.http_server.UrlOf(html_fullpath), video_id='video', video_src_path=source_path, event_timeout=120) chameleon_board = chameleon.create_chameleon_board( host.hostname, args) display_facade = local_facade_factory.LocalFacadeFactory( cr).create_display_facade() finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, display_facade) capturer = chameleon_video_capturer.ChameleonVideoCapturer( finder.find_port(interface='hdmi'), display_facade) with capturer: player.load_video() player.verify_video_can_play() display_facade.move_to_display( display_facade.get_first_external_display_index()) display_facade.set_fullscreen(True) # HACK: Unset and reset fullscreen. There is a bug in Chrome # that fails to move the window to a correct position. # Resetting fullscren helps, check http://crbug.com/574284 display_facade.set_fullscreen(False) display_facade.set_fullscreen(True) time.sleep(5) box = (0, 0, constants.DESIRED_WIDTH, constants.DESIRED_HEIGHT) #TODO: mussa, Revisit once crbug/580736 is fixed for n in xrange(constants.NUM_CAPTURE_TRIES): logging.debug('Trying to capture frames. TRY #%d', n + 1) raw_test_checksums = capturer.capture_only( player, max_frame_count=constants.FCOUNT, box=box) raw_test_checksums = [ tuple(checksum) for checksum in raw_test_checksums ] overreach_counts = self.overreach_frame_counts( raw_test_checksums, constants.MAX_FRAME_REPEAT_COUNT) if not overreach_counts: # no checksums exceeded threshold break player.pause() player.seek_to(datetime.timedelta(seconds=0)) else: msg = ('Framecount overreach detected even after %d ' 'tries. Checksums: %s' % (constants.NUM_CAPTURE_TRIES, overreach_counts)) raise error.TestFail(msg) # produces unique checksums mapped to their occur. indices test_checksum_indices = frame_checksum_utils.checksum_indices( raw_test_checksums) test_checksums = test_checksum_indices.keys() test_indices = test_checksum_indices.values() golden_checksums_filepath = os.path.join( constants.TEST_DIR, constants.GOLDEN_CHECKSUMS_FILENAME) if collect_only: capturer.write_images(test_indices, constants.TEST_DIR, constants.IMAGE_FORMAT) logging.debug("Write golden checksum file to %s", golden_checksums_filepath) with open(golden_checksums_filepath, "w+") as f: for checksum in test_checksums: f.write(' '.join([str(i) for i in checksum]) + '\n') return golden_checksums_remote_filepath = os.path.join( constants.GOLDEN_CHECKSUM_REMOTE_BASE_DIR, board, codec + '_' + resolution, constants.GOLDEN_CHECKSUMS_FILENAME) file_utils.download_file(golden_checksums_remote_filepath, golden_checksums_filepath) golden_checksums = self.read_checksum_file( golden_checksums_filepath) golden_checksum_count = len(golden_checksums) test_checksum_count = len(test_checksums) eps = constants.MAX_DIFF_TOTAL_FCOUNT if golden_checksum_count - test_checksum_count > eps: msg = ('Expecting about %d checksums, received %d. ' 'Allowed delta is %d') % (golden_checksum_count, test_checksum_count, eps) raise error.TestFail(msg) # Some frames might be missing during either golden frame # collection or during a test run. Using LCS ensures we # ignore a few missing frames while comparing test vs golden lcs_len = sequence_utils.lcs_length(golden_checksums, test_checksums) missing_frames_count = len(golden_checksums) - lcs_len unknown_frames_count = len(test_checksums) - lcs_len msg = ('# of matching frames : %d. # of missing frames : %d. ' '# of unknown test frames : %d. Max allowed # of ' 'missing frames : %d. # of golden frames : %d. # of ' 'test_checksums : %d' % (lcs_len, missing_frames_count, unknown_frames_count, constants.MAX_NONMATCHING_FCOUNT, len(golden_checksums), len(test_checksums))) logging.debug(msg) if (missing_frames_count + unknown_frames_count > constants.MAX_NONMATCHING_FCOUNT): unknown_frames = set(test_checksums) - set( golden_checksums) store_indices = [ test_checksum_indices[c] for c in unknown_frames ] paths = capturer.write_images(store_indices, constants.TEST_DIR, constants.IMAGE_FORMAT) path_publish = publisher.ImageDiffPublisher( self.resultsdir) path_publish.publish_paths(paths, self.tagged_testname) raise error.TestFail("Too many non-matching frames")
def run_once(self, host): edid_path = os.path.join(self.bindir, 'test_data/edids/HDMI_DELL_U2410.txt') golden_file = audio_test_data.SWEEP_TEST_FILE # Dump audio diagnostics data for debugging. chameleon_board = host.chameleon factory = self.create_remote_facade_factory(host) self._system_facade = factory.create_system_facade() self.set_high_performance_mode() chameleon_board.reset() widget_factory = chameleon_audio_helper.AudioWidgetFactory( factory, host) source = widget_factory.create_widget(chameleon_audio_ids.CrosIds.HDMI) recorder = widget_factory.create_widget( chameleon_audio_ids.ChameleonIds.HDMI) binder = widget_factory.create_binder(source, recorder) display_facade = factory.create_display_facade() finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, display_facade) hdmi_port = finder.find_port('HDMI') if not hdmi_port: raise error.TestFail( 'Can not find HDMI port, perhaps HDMI is not connected?') with hdmi_port.use_edid_file(edid_path): # TODO(cychiang) remove this when issue crbug.com/450101 is fixed. audio_test_utils.correction_plug_unplug_for_audio(host, hdmi_port) with chameleon_audio_helper.bind_widgets(binder): audio_facade = factory.create_audio_facade() audio_test_utils.dump_cros_audio_logs(host, audio_facade, self.resultsdir, 'after_binding') output_nodes, _ = audio_facade.get_selected_node_types() if output_nodes != ['HDMI']: raise error.TestFail( '%s rather than HDMI is selected on Cros device' % output_nodes) # Transfer the data to Cros device first because it takes # several seconds. source.set_playback_data(golden_file) logging.info('Start recording from Chameleon.') recorder.start_recording() time.sleep(self.DELAY_BEFORE_PLAYBACK) logging.info('Start playing %s on Cros device', golden_file.path) source.start_playback(blocking=True) logging.info('Stopped playing %s on Cros device', golden_file.path) time.sleep(self.DELAY_AFTER_PLAYBACK) audio_test_utils.dump_cros_audio_logs(host, audio_facade, self.resultsdir, 'after_recording') recorder.stop_recording() logging.info('Stopped recording from Chameleon.') recorder.read_recorded_binary() recorded_file = os.path.join(self.resultsdir, "recorded.raw") logging.info('Saving recorded data to %s', recorded_file) recorder.save_file(recorded_file) if not chameleon_audio_helper.compare_recorded_result( golden_file, recorder, 'correlation'): raise error.TestFail( 'Recorded file does not match playback file')
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, 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, 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, video_hardware_acceleration=True, video_url=DEFAULT_VIDEO_URL, arc=False): """Running audio/video synchronization quality measurement @param host: A host object representing the DUT. @param video_hardware_acceleration: Enables the hardware acceleration for video decoding. @param video_url: The ULR of the test video. @param arc: Tests on ARC with an Android Video Player App. """ self.host = host factory = remote_facade_factory.RemoteFacadeFactory( host, results_dir=self.resultsdir, no_chrome=True) chrome_args = { 'extension_paths': [constants.AUDIO_TEST_EXTENSION, constants.DISPLAY_TEST_EXTENSION], 'extra_browser_args': [], 'arc_mode': arc_common.ARC_MODE_DISABLED, 'autotest_ext': True } if not video_hardware_acceleration: chrome_args['extra_browser_args'].append( '--disable-accelerated-video-decode') if arc: chrome_args['arc_mode'] = arc_common.ARC_MODE_ENABLED browser_facade = factory.create_browser_facade() browser_facade.start_custom_chrome(chrome_args) logging.info("created chrome") if arc: self.setup_video_app() chameleon_board = host.chameleon audio_facade = factory.create_audio_facade() display_facade = factory.create_display_facade() video_facade = factory.create_video_facade() audio_port_finder = chameleon_port_finder.ChameleonAudioInputFinder( chameleon_board) video_port_finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, display_facade) audio_port = audio_port_finder.find_port('HDMI') video_port = video_port_finder.find_port('HDMI') chameleon_board.setup_and_reset(self.outputdir) _, ext = os.path.splitext(video_url) with tempfile.NamedTemporaryFile(prefix='playback_', suffix=ext) as f: # The default permission is 0o600. os.chmod(f.name, 0o644) file_utils.download_file(video_url, f.name) if arc: video_facade.prepare_arc_playback(f.name) else: video_facade.prepare_playback(f.name) edid_path = os.path.join(self.bindir, 'test_data/edids/HDMI_DELL_U2410.txt') video_port.plug() with video_port.use_edid_file(edid_path): audio_facade.set_chrome_active_node_type('HDMI', None) audio_facade.set_chrome_active_volume(100) audio_test_utils.check_audio_nodes(audio_facade, (['HDMI'], None)) display_facade.set_mirrored(True) video_port.start_monitoring_audio_video_capturing_delay() time.sleep(self.DELAY_BEFORE_CAPTURING) video_port.start_capturing_video((64, 64, 16, 16)) audio_port.start_capturing_audio() time.sleep(self.DELAY_BEFORE_PLAYBACK) if arc: video_facade.start_arc_playback(blocking_secs=20) else: video_facade.start_playback(blocking=True) time.sleep(self.DELAY_AFTER_PLAYBACK) remote_path, _ = audio_port.stop_capturing_audio() video_port.stop_capturing_video() start_delay = video_port.get_audio_video_capturing_delay() local_path = os.path.join(self.resultsdir, 'recorded.raw') chameleon_board.host.get_file(remote_path, local_path) audio_data = open(local_path).read() video_data = video_port.get_captured_checksums() logging.info("audio capture %d bytes, %f seconds", len(audio_data), len(audio_data) / float(self.AUDIO_CAPTURE_RATE) / 32) logging.info("video capture %d frames, %f seconds", len(video_data), len(video_data) / float(self.VIDEO_CAPTURE_RATE)) key_audio = self.compute_audio_keypoint(audio_data) key_video = self.compute_video_keypoint(video_data) # Use the capturing delay to align A/V key_video = map(lambda x: x + start_delay, key_video) dropped_frame_count = None if not arc: video_facade.dropped_frame_count() prefix = '' if arc: prefix = 'arc_' elif video_hardware_acceleration: prefix = 'hw_' else: prefix = 'sw_' self.log_result(prefix, key_audio, key_video, dropped_frame_count)
def run_once(self, host, jack_node=False, hdmi_node=False, usb_node=False, play_audio=False): self.host = host chameleon_board = host.chameleon audio_board = chameleon_board.get_audio_board() factory = remote_facade_factory.RemoteFacadeFactory( host, results_dir=self.resultsdir) chameleon_board.setup_and_reset(self.outputdir) self.audio_facade = factory.create_audio_facade() self.display_facade = factory.create_display_facade() self.check_default_nodes() nodes = [] if audio_test_utils.has_internal_speaker(self.host): self.set_active_volume_to_node_volume('INTERNAL_SPEAKER') nodes.append('INTERNAL_SPEAKER') self.switch_nodes_and_check_volume(nodes) if play_audio: self.browser_facade = factory.create_browser_facade() self.browser_facade.new_tab(URL) time.sleep(self._WAIT_TO_LOAD_VIDEO) if hdmi_node: edid_path = os.path.join(self.bindir, 'test_data/edids/HDMI_DELL_U2410.txt') finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, self.display_facade) hdmi_port = finder.find_port('HDMI') hdmi_port.apply_edid(edid_lib.Edid.from_file(edid_path)) time.sleep(self._APPLY_EDID_DELAY) hdmi_port.set_plug(True) time.sleep(self._PLUG_DELAY * 2) audio_test_utils.check_audio_nodes(self.audio_facade, (['HDMI'], None)) if play_audio: self.audio_facade.check_audio_stream_at_selected_device() self.set_active_volume_to_node_volume('HDMI') nodes.append('HDMI') self.switch_nodes_and_check_volume(nodes) if jack_node: jack_plugger = audio_board.get_jack_plugger() jack_plugger.plug() time.sleep(self._PLUG_DELAY) audio_test_utils.dump_cros_audio_logs(host, self.audio_facade, self.resultsdir) # Checks whether line-out or headphone is detected. hp_jack_node_type = audio_test_utils.check_hp_or_lineout_plugged( self.audio_facade) audio_test_utils.check_audio_nodes(self.audio_facade, (None, ['MIC'])) self.set_active_volume_to_node_volume(hp_jack_node_type) nodes.append(hp_jack_node_type) self.switch_nodes_and_check_volume(nodes) if usb_node: widget_factory = chameleon_audio_helper.AudioWidgetFactory( factory, host) source = widget_factory.create_widget( chameleon_audio_ids.CrosIds.USBOUT) recorder = widget_factory.create_widget( chameleon_audio_ids.ChameleonIds.USBIN) binder = widget_factory.create_binder(source, recorder) with chameleon_audio_helper.bind_widgets(binder): time.sleep(self._PLUG_DELAY) audio_test_utils.check_audio_nodes(self.audio_facade, (['USB'], ['USB'])) self.set_active_volume_to_node_volume('USB') nodes.append('USB') self.switch_nodes_and_check_volume(nodes) time.sleep(self._PLUG_DELAY) nodes.remove('USB') self.switch_nodes_and_check_volume(nodes) if jack_node: if usb_node: audio_test_utils.check_audio_nodes( self.audio_facade, ([hp_jack_node_type], ['MIC'])) jack_plugger.unplug() time.sleep(self._PLUG_DELAY) nodes.remove(hp_jack_node_type) self.switch_nodes_and_check_volume(nodes) if hdmi_node: if usb_node or jack_node: audio_test_utils.check_audio_nodes(self.audio_facade, (['HDMI'], None)) hdmi_port.set_plug(False) time.sleep(self._PLUG_DELAY) nodes.remove('HDMI') self.switch_nodes_and_check_volume(nodes) self.check_default_nodes()
def run_once(self, host, jack_node=False, hdmi_node=False, usb_node=False): self.host = host chameleon_board = host.chameleon audio_board = chameleon_board.get_audio_board() factory = self.create_remote_facade_factory(host) chameleon_board.reset() self.audio_facade = factory.create_audio_facade() self.display_facade = factory.create_display_facade() self.check_default_nodes() nodes = [] if audio_test_utils.has_internal_speaker(self.host): self.set_active_volume_to_node_volume('INTERNAL_SPEAKER') nodes.append('INTERNAL_SPEAKER') self.switch_nodes_and_check_volume(nodes) if hdmi_node: edid_path = os.path.join(self.bindir, 'test_data/edids/HDMI_DELL_U2410.txt') finder = chameleon_port_finder.ChameleonVideoInputFinder( chameleon_board, self.display_facade) hdmi_port = finder.find_port('HDMI') hdmi_port.apply_edid(edid_lib.Edid.from_file(edid_path)) time.sleep(self._APPLY_EDID_DELAY) hdmi_port.set_plug(True) time.sleep(self._PLUG_DELAY) audio_test_utils.check_audio_nodes(self.audio_facade, (['HDMI'], None)) self.set_active_volume_to_node_volume('HDMI') nodes.append('HDMI') self.switch_nodes_and_check_volume(nodes) if jack_node: jack_plugger = audio_board.get_jack_plugger() jack_plugger.plug() time.sleep(self._PLUG_DELAY) audio_test_utils.dump_cros_audio_logs(host, self.audio_facade, self.resultsdir) audio_test_utils.check_audio_nodes(self.audio_facade, (['HEADPHONE'], ['MIC'])) self.set_active_volume_to_node_volume('HEADPHONE') nodes.append('HEADPHONE') self.switch_nodes_and_check_volume(nodes) if usb_node: widget_factory = chameleon_audio_helper.AudioWidgetFactory( factory, host) source = widget_factory.create_widget( chameleon_audio_ids.CrosIds.USBOUT) recorder = widget_factory.create_widget( chameleon_audio_ids.ChameleonIds.USBIN) binder = widget_factory.create_binder(source, recorder) with chameleon_audio_helper.bind_widgets(binder): time.sleep(self._PLUG_DELAY) audio_test_utils.check_audio_nodes(self.audio_facade, (['USB'], ['USB'])) self.set_active_volume_to_node_volume('USB') nodes.append('USB') self.switch_nodes_and_check_volume(nodes) time.sleep(self._PLUG_DELAY) nodes.remove('USB') self.switch_nodes_and_check_volume(nodes) if jack_node: if usb_node: audio_test_utils.check_audio_nodes(self.audio_facade, (['HEADPHONE'], ['MIC'])) jack_plugger.unplug() time.sleep(self._PLUG_DELAY) nodes.remove('HEADPHONE') self.switch_nodes_and_check_volume(nodes) if hdmi_node: if usb_node or jack_node : audio_test_utils.check_audio_nodes(self.audio_facade, (['HDMI'], None)) hdmi_port.set_plug(False) time.sleep(self._PLUG_DELAY) nodes.remove('HDMI') self.switch_nodes_and_check_volume(nodes) self.check_default_nodes()
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, 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)))