def get_content_protection(output_name): """ Gets the state of the content protection. @param output_name: The output name as a string. @return: A string of the state, like 'Undesired', 'Desired', or 'Enabled'. False if not supported. """ if utils.is_freon(): raise error.TestFail('freon: get_content_protection not implemented') output = call_xrandr('--verbose').split('\n') current_output_name = '' # Parse output of xrandr, line by line. for line in output: # If the line contains 'connected', it is a connected display. if line.find(' connected') != -1: current_output_name = line.split()[0] continue if current_output_name != output_name: continue # Search the line like: 'Content Protection: Undesired' match = re.search(r'Content Protection:\t(\w+)', line) if match: return match.group(1) return False
def run_once(self, videos, use_cr_source_dir=True): """ Runs video_decode_accelerator_unittest on the videos. @param videos: The test videos for video_decode_accelerator_unittest. @param use_cr_source_dir: Videos are under chrome source directory. @param gtest_filter: gtest_filter parameter for the unittest. @raises: error.TestFail for video_decode_accelerator_unittest failures. """ logging.debug('Starting video_VideoDecodeAccelerator: %s', videos) if use_cr_source_dir: path = os.path.join(self.cr_source_dir, 'media', 'test', 'data', '') else: path = '' last_test_failure = None for video in videos: cmd_line = ('--test_video_data="%s%s"' % (path, video)) if utils.is_freon(): cmd_line += ' --ozone-platform=gbm' try: self.run_chrome_test_binary(self.binary, cmd_line) except error.TestFail as test_failure: # Continue to run the remaining test videos and raise # the last failure after finishing all videos. logging.error('%s: %s', video, test_failure.message) last_test_failure = test_failure if last_test_failure: raise last_test_failure
def hide_typing_cursor(): """Hides typing cursor.""" # Press the tab key to move outside the typing bar. if utils.is_freon(): press_keys(['KEY_TAB']) else: press_key_X('Tab')
def run_chrome_test_binary(self, binary_to_run, extra_params='', prefix='', as_chronos=True): """ Run chrome test binary. @param binary_to_run: The name of the browser test binary. @param extra_params: Arguments for the browser test binary. @param prefix: Prefix to the command that invokes the test binary. @param as_chronos: Boolean indicating if the tests should run in a chronos shell. @raises: error.TestFail if there is error running the command. """ binary = self.get_chrome_binary_path(binary_to_run) cmd = '%s/%s %s' % (self.test_binary_dir, binary_to_run, extra_params) env_vars = 'HOME=%s CR_SOURCE_ROOT=%s CHROME_DEVEL_SANDBOX=%s' % ( self.home_dir, self.cr_source_dir, self.CHROME_SANDBOX) cmd = '%s %s' % (env_vars, prefix + cmd) try: if utils.is_freon(): if as_chronos: utils.system('su %s -c \'%s\'' % ('chronos', cmd)) else: utils.system(cmd) else: if as_chronos: graphics_utils.xsystem(cmd, user='******') else: graphics_utils.xsystem(cmd) except error.CmdError as e: raise error.TestFail('%s failed! %s' % (binary_to_run, e))
def hide_cursor(): """Hides mouse cursor.""" # Send a keystroke to hide the cursor. if utils.is_freon(): press_keys(['KEY_UP']) else: press_key_X('Up')
def screen_disable_blanking(): """ Called from power_Backlight to disable screen blanking. """ if utils.is_freon(): # We don't have to worry about unexpected screensavers or DPMS here. return xsystem(XSET + ' s off') xsystem(XSET + ' dpms 0 0 0') xsystem(XSET + ' -dpms')
def press_key_X(key_str): """Presses the given keys as one combination. @param key: A string of keys, e.g. 'ctrl+F4'. """ if utils.is_freon(): raise error.TestFail('freon: press_key_X not implemented') command = 'xdotool key %s' % key_str xsystem(command)
def screen_wakeup(): """Wake up the screen if it is dark.""" # Move the mouse a little bit to wake up the screen. if utils.is_freon(): device = _get_uinput_device_mouse_rel() _uinput_emit(device, 'REL_X', 1) _uinput_emit(device, 'REL_X', -1) else: xsystem('xdotool mousemove_relative 1 1')
def run_in_parallel(self, *commands): env = os.environ.copy() # To clear the temparory files created by vea_unittest. env['TMPDIR'] = self.tmpdir if not utils.is_freon(): env['DISPLAY'] = ':0' env['XAUTHORITY'] = '/home/chronos/.Xauthority' return map(lambda c: cmd_utils.popen(c, env=env), commands)
def get_display_output_state(): """ Retrieves output status of connected display(s). Return value: dictionary of connected display states. """ if utils.is_freon(): return get_modetest_output_state() else: return get_xrandr_output_state()
def run_once(self): # TODO(ihf): Remove this once GLES2ConformChrome works on freon. if utils.is_freon(): raise error.TestNAError( 'Test needs work on Freon. See crbug.com/484463.') if not os.path.exists(self.get_chrome_binary_path(self.BINARY)): raise error.TestFail('%s not found. Use internal Chrome sources!' % self.BINARY) self.run_chrome_test_binary(self.BINARY)
def get_internal_resolution(): if utils.is_freon(): if has_internal_display(): crtcs = get_modetest_crtcs() if len(crtcs) > 0: return crtcs[0].size return (-1, -1) else: connector = get_internal_connector_name() width, height, _, _ = get_output_rect_x(connector) return (width, height)
def set_content_protection(output_name, state): """ Sets the content protection to the given state. @param output_name: The output name as a string. @param state: One of the states 'Undesired', 'Desired', or 'Enabled' """ if utils.is_freon(): raise error.TestFail('freon: set_content_protection not implemented') call_xrandr('--output %s --set "Content Protection" %s' % (output_name, state))
def take_external_screenshot(self, path): """Takes external screenshot. @param path: path to image file. """ if utils.is_freon(): self.take_screenshot_crtc(path, self.get_external_crtc()) else: output = self.get_external_connector_name() box = self.get_output_rect(output) graphics_utils.take_screenshot_crop_x(path, box) return output, box # for logging/debugging
def cleanup(self): if utils.is_freon() and self._services: self._services.restore_services() if self.GSC: keyvals = self.GSC.get_memory_keyvals() for key, val in keyvals.iteritems(): self.output_perf_value(description=key, value=val, units='bytes', higher_is_better=False) self.GSC.finalize() self.write_perf_keyval(keyvals)
def run_once(self): if utils.is_freon(): if not self.__check_wflinfo(): raise error.TestFail('Failed: GLES API insufficient:' + self.error_message) return # TODO(ihf): Remove this once all boards are switched to freon. cmd_gl = os.path.join(self.bindir, 'gl_APICheck') cmd_gles = os.path.join(self.bindir, 'gles_APICheck') exist_gl = os.path.isfile(cmd_gl) exist_gles = os.path.isfile(cmd_gles) if not exist_gl and not exist_gles: raise error.TestFail( 'Failed: Found neither gl_APICheck nor gles_APICheck. ' 'Test setup error.') elif exist_gl and exist_gles: raise error.TestFail( 'Failed: Found both gl_APICheck and gles_APICheck. ' 'Test setup error.') elif exist_gl: self.error_message = '' result = self.__run_x_cmd(cmd_gl) errors = re.findall(r'ERROR: ', result) run_through = re.findall(r'SUCCEED: run to the end', result) if not errors and run_through: check_result = self.__check_gl(result) if not check_result: raise error.TestFail('Failed: GL API insufficient:' + self.error_message) else: raise error.TestFail('Failed: gl_APICheck error: ' + result) else: self.error_message = '' # TODO(zmo@): smarter mechanism with GLES & EGL library names. result = self.__run_x_cmd(cmd_gles + ' libGLESv2.so libEGL.so') errors = re.findall(r'ERROR: ', result) run_through = re.findall(r'SUCCEED: run to the end', result) if not errors and run_through: check_result = self.__check_gles(result) if not check_result: raise error.TestFail('Failed: GLES API insufficient:' + self.error_message) else: raise error.TestFail('Failed: gles_APICheck error: ' + result) # Check X11 extensions. self.error_message = '' check_result = self.__check_x_extensions(result) if not check_result: raise error.TestFail('Failed: X extensions insufficient:' + self.error_message)
def get_display_resolution(): """ Parses output of modetest to determine the display resolution of the dut. @return: tuple, (w,h) resolution of device under test. """ if not utils.is_freon(): return _get_display_resolution_x() connectors = get_modetest_connectors() for connector in connectors: if connector.connected: return connector.size return None
def run_once(self): # TODO(ihf): Remove this once KhronosGLCTSChrome works on freon. if utils.is_freon(): raise error.TestNAError( 'Test needs work on Freon. See crbug.com/484467.') if not os.path.exists(self.get_chrome_binary_path(self.BINARY)): raise error.TestFail('%s not found. Use internal Chrome sources!' % self.BINARY) log_file = os.path.join(self.resultsdir, self.BINARY + ".xml") bin_args = '--gtest_output=xml:%s %s' % (log_file, self.resultsdir) self.run_chrome_test_binary(self.BINARY, bin_args)
def screen_disable_energy_saving(): """ Called from power_Consumption to immediately disable energy saving. """ if utils.is_freon(): # All we need to do here is enable displays via Chrome. power_utils.set_display_power(power_utils.DISPLAY_POWER_ALL_ON) return # Disable X screen saver xsystem(XSET + ' s 0 0') # Disable DPMS Standby/Suspend/Off xsystem(XSET + ' dpms 0 0 0') # Force monitor on screen_switch_on(on=1) # Save off X settings xsystem(XSET + ' q')
def xcommand(cmd, user=None): """ Add the necessary X setup to a shell command that needs to connect to the X server. @param cmd: the command line string @param user: if not None su command to desired user. @return a modified command line string with necessary X setup """ logging.warning('xcommand will be deprecated under freon!') #traceback.print_stack() if user is not None: cmd = 'su %s -c \'%s\'' % (user, cmd) if not utils.is_freon(): cmd = 'DISPLAY=:0 XAUTHORITY=/home/chronos/.Xauthority ' + cmd return cmd
def take_screenshot_crop(fullpath, box=None, crtc_id=None): """ Take a screenshot using import tool, crop according to dim given by the box. @param fullpath: path, full path to save the image to. @param box: 4-tuple giving the upper left and lower right pixel coordinates. """ if not utils.is_freon(): return take_screenshot_crop_x(fullpath, box) if crtc_id is not None: image = drm.crtcScreenshot(crtc_id) else: image = drm.crtcScreenshot(get_internal_crtc()) if box: image = image.crop(box) image.save(fullpath) return fullpath
def get_external_resolution(): """Gets the resolution of the external display. @return A tuple of (width, height) or None if no external display is connected. """ if utils.is_freon(): offset = 1 if has_internal_display() else 0 crtcs = get_modetest_crtcs() if len(crtcs) > offset and crtcs[offset].size != (0, 0): return crtcs[offset].size return None else: connector = get_external_connector_name() width, height, _, _ = get_output_rect_x(connector) if width == 0 and height == 0: return None return (width, height)
def run_once(self, process_path=None, crash_extensions=None): if process_path: self._test_process(process_path, crash_extensions) return with chrome.Chrome(): if not utils.is_freon(): process_path = '/usr/bin/X' crash_extensions = ['.core', '.dmp', '.meta'] self.job.run_test("logging_CrashServices", process_path=process_path, crash_extensions=crash_extensions, tag=os.path.basename(process_path)) for process_path in self.process_list.keys(): self.job.run_test( "logging_CrashServices", process_path=process_path, crash_extensions=self.process_list.get(process_path), tag=os.path.basename(process_path))
def check_file(self, basename): match_func = getattr(self, 'match_%s' % basename) success = True expected_entries = self.load_path( os.path.join(self.bindir, 'baseline.%s' % basename)) # TODO(spang): Remove this once per-board baselines are supported # (crbug.com/406013). if utils.is_freon(): extra_baseline = 'baseline.%s.freon' % basename else: extra_baseline = 'baseline.%s.x11' % basename expected_entries += self.load_path( os.path.join(self.bindir, extra_baseline)) actual_entries = self.load_path('/etc/%s' % basename) if len(actual_entries) > len(expected_entries): success = False logging.error('%s baseline mismatch: expected %d entries, got %d.', basename, len(expected_entries), len(actual_entries)) for actual in actual_entries: expected = [x for x in expected_entries if x[0] == actual[0]] if not expected: success = False logging.error("Unexpected %s entry for '%s'.", basename, actual[0]) continue expected = expected[0] match_res = match_func(expected, actual) success = success and match_res for expected in expected_entries: actual = [x for x in actual_entries if x[0] == expected[0]] if not actual: logging.info("Ignoring missing %s entry for '%s'.", basename, expected[0]) return success
def run_once_vaapi(self): sys.path.append(self.bindir) import vaapi if not utils.is_freon(): # Set the XAUTHORITY for connecting to the X server utils.assert_has_X_server() os.environ.setdefault('XAUTHORITY', '/home/chronos/.Xauthority') display = vaapi.create_display(':0.0') else: display = vaapi.create_display('/dev/dri/card0') supported_profiles = vaapi.query_profiles(display) logging.info('Vaapi Profiles: %s', supported_profiles) for profile in self.REQUESTED_VAAPI_PROFILES: self.assertTrue(profile in supported_profiles, 'Profile:%s is not supported', profile) self.verifyProfile(vaapi, display, profile)
def get_vda_unittest_cmd_line(self, decode_videos): test_video_data = [] for v in decode_videos: assert len(v) == 6 # Convert to strings, also make a copy of the list. v = map(str, v) v[0] = self._downloads.get_path(v[0]) v[-1:-1] = ['0', '0'] # no fps requirements test_video_data.append(':'.join(v)) cmd_line = [ self.get_chrome_binary_path(VDA_BINARY), '--gtest_filter=DecodeVariations/*/0', '--test_video_data=%s' % ';'.join(test_video_data), '--rendering_warm_up=%d' % RENDERING_WARM_UP, '--rendering_fps=%f' % RENDERING_FPS, '--num_play_throughs=%d' % MAX_INT ] if utils.is_freon(): cmd_line.append('--ozone-platform=gbm') return cmd_line
def run_once(self, in_cloud, streams, profile): """Runs video_encode_accelerator_unittest on the streams. @param in_cloud: Input file needs to be downloaded first. @param streams: The test streams for video_encode_accelerator_unittest. @param profile: The profile to encode into. @raises error.TestFail for video_encode_accelerator_unittest failures. """ last_test_failure = None for path, width, height, bit_rate in streams: if in_cloud: input_path = os.path.join(self.tmpdir, path.split('/')[-1]) _download_video(path, input_path) else: input_path = os.path.join(self.cr_source_dir, path) output_path = os.path.join(self.tmpdir, '%s.out' % input_path.split('/')[-1]) cmd_line = '--test_stream_data="%s:%s:%s:%s:%s:%s"' % ( input_path, width, height, profile, output_path, bit_rate) if utils.is_freon(): cmd_line += ' --ozone-platform=gbm' cmd_line += self.get_filter_option() try: self.run_chrome_test_binary(BINARY, cmd_line, as_chronos=False) except error.TestFail as test_failure: # Continue to run the remaining test streams and raise # the last failure after finishing all streams. logging.exception('error while encoding %s', input_path) last_test_failure = test_failure finally: # Remove the downloaded video if in_cloud: _remove_if_exists(input_path) _remove_if_exists(output_path) if last_test_failure: raise last_test_failure
def get_vea_unittest_cmd_line(self, encode_videos): test_stream_data = [] for v in encode_videos: assert len(v) == 5 # Convert to strings, also make a copy of the list. v = map(str, v) v[0] = self._downloads.get_path(v[0]) # The output destination, ignore the output. v.insert(4, '/dev/null') # Insert the FPS requirement v.append(str(INPUT_FPS)) test_stream_data.append(':'.join(v)) cmd_line = [ self.get_chrome_binary_path(VEA_BINARY), '--gtest_filter=SimpleEncode/*/0', '--test_stream_data=%s' % ';'.join(test_stream_data), '--run_at_fps', '--num_frames_to_encode=%d' % MAX_INT ] if utils.is_freon(): cmd_line.append('--ozone-platform=gbm') return cmd_line
def run_once(self, test_slice): # TODO(ihf): Remove this once Piglit works on freon. if utils.is_freon(): return gpu_family = utils.get_gpu_family() family = gpu_family logging.info('Detected gpu family %s.', gpu_family) # TODO(ihf): Delete this once we have a piglit that runs on ARM. if gpu_family in ['mali', 'tegra']: logging.info('Not running any tests, passing by default.') return scripts_dir = os.path.join(self.bindir, self.test_scripts) family_dir = os.path.join(scripts_dir, family) # We don't want to introduce too many combinations, so fall back. if not os.path.isdir(family_dir): family = 'other' family_dir = os.path.join(scripts_dir, family) logging.info('Using scripts for gpu family %s.', family) scripts_dir = os.path.join(self.bindir, self.test_scripts) # Mark scripts executable if they are not. utils.system('chmod +x ' + scripts_dir + '*/graphics_PiglitBVT_*.sh') # Kick off test script. cmd = ( 'source ' + os.path.join(family_dir, 'graphics_PiglitBVT_%d.sh' % test_slice)) logging.info('Executing cmd = %s', cmd) result = utils.run(cmd, stdout_tee=utils.TEE_TO_LOGS, stderr_tee=utils.TEE_TO_LOGS, ignore_status=True) tests_failed = result.exit_status if tests_failed: reason = '%d tests failed on "%s" in slice %d' % ( tests_failed, gpu_family, test_slice) raise error.TestError(reason)
def _append_freon_switch_if_needed(self, cmd_line): if utils.is_freon(): cmd_line.append('--ozone-platform=gbm')