def _download_remote_test_file(self, filename, input_type):
"""Download a file from the remote touch playback folder.
@param filename: string of filename
@param input_type: device type, e.g. 'touchpad'
@returns: Path to local file or None if file is not found.
"""
REMOTE_STORAGE_URL = ('https://storage.googleapis.com/'
'chromiumos-test-assets-public/touch_playback')
filename = urllib.quote(filename)
if input_type in ['touchpad', 'touchscreen', 'stylus']:
url = '%s/%s/%s' % (REMOTE_STORAGE_URL, self._platform, filename)
else:
url = '%s/TYPE-%s/%s' % (REMOTE_STORAGE_URL, input_type, filename)
local_file = os.path.join(self.bindir, filename)
logging.info('Looking for %s', url)
try:
file_utils.download_file(url, local_file)
except urllib2.URLError as e:
logging.info('File download failed!')
logging.debug(e.msg)
return None
return local_file
def run_once(self, test_cases):
"""
Runs JpegEncodeAcceleratorTest.SimpleEncode on the device and reports
latency values for HW and SW.
"""
for (image_path, width, height) in test_cases:
url = DOWNLOAD_BASE + image_path
file_name = os.path.basename(image_path)
input_path = os.path.join(self.bindir, file_name)
file_utils.download_file(url, input_path)
test_name = ('%s_%dx%d' % (file_name, width, height))
output_path = os.path.join(self.tmpdir, TEST_LOG)
cmd_line_list = [helper_logger.chrome_vmodule_flag()] + [
'--gtest_filter=JpegEncodeAcceleratorTest.SimpleEncode',
('--output_log=%s' % output_path),
('--repeat=%d' % REPEAT_TIMES),
('--yuv_filenames="%s:%dx%d"' % (input_path, width, height))
]
cmd_line = ' '.join(cmd_line_list)
try:
self.run_chrome_test_binary(self.binary, cmd_line)
self.report_perf_results(test_name, output_path)
except Exception as last_error:
# Log the error and continue to the next test case.
logging.exception(last_error)
finally:
self.remove_if_exists(input_path)
self.remove_if_exists(output_path)
def run_once(self, args={}):
self._parse_args(args)
logging.info("Running crouton test:")
logging.info(" - repo: %s", self._repo)
logging.info(" - branch: %s", self._branch)
logging.info(" - runargs: %s", self._runargs)
logging.info(" - env:%s", self._env)
logging.debug(" - resultsdir: %s", self.resultsdir)
logging.debug(' - tmpdir: %s', self.tmpdir)
crouton_temp_file = os.path.join(self.tmpdir, "archive.tar.gz")
crouton_url = 'https://github.com/%s/archive/%s.tar.gz' \
% (self._repo, self._branch)
logging.info('Downloading crouton tarball: "%s".', crouton_url)
file_utils.download_file(crouton_url, crouton_temp_file)
os.chdir(self.tmpdir)
utils.system('tar xvf %s --strip-components 1' % crouton_temp_file)
# Set environment. Only allow setting CROUTON_MIRROR_* variables
for env_pair in self._env.split(";"):
keyval = env_pair.split("=")
if len(keyval) == 2 and keyval[0].find("CROUTON_MIRROR_") == 0:
logging.debug('Setting env %s=%s', keyval[0], keyval[1])
os.environ[keyval[0]] = keyval[1]
# Pass arguments separately to avoid problems with Little Bobby Tables.
args = ['test/run.sh', '-l', self.resultsdir] + self._runargs.split()
utils.run('sh',
args=args,
timeout=None,
ignore_status=False,
stderr_tee=logging_manager.LoggingFile(level=logging.INFO))
def run_once(self, video_name, histogram_name, histogram_bucket_val,
capability):
if self.is_skipping_test():
raise error.TestNAError('Skipping test run on this board.')
if not device_capability.DeviceCapability().have_capability(
capability):
logging.warning("Missing Capability: %s" % capability)
return
# Download test video.
url = DOWNLOAD_BASE + video_name
local_path = os.path.join(self.bindir, video_name)
file_utils.download_file(url, local_path)
# Start chrome with test flags.
EXTRA_BROWSER_ARGS.append(FAKE_FILE_ARG % local_path)
EXTRA_BROWSER_ARGS.append(helper_logger.chrome_vmodule_flag())
with chrome.Chrome(extra_browser_args=EXTRA_BROWSER_ARGS,
init_network_controller=True) as cr:
histogram_differ = histogram_verifier.HistogramDiffer(
cr, histogram_name)
# Open WebRTC loopback page.
cr.browser.platform.SetHTTPServerDirectories(self.bindir)
self.start_loopback(cr)
# Make sure decode is hardware accelerated.
histogram_verifier.expect_sole_bucket(histogram_differ,
histogram_bucket_val,
histogram_bucket_val)
def initialize(self, ppd_file):
"""
Args:
@param ppd_file: ppd file name
"""
# Instantiate Chrome browser.
with tempfile.NamedTemporaryFile() as cap:
file_utils.download_file(chrome.CAP_URL, cap.name)
password = cap.read().rstrip()
extra_flags = ['--enable-features=CrOSComponent']
self.browser = chrome.Chrome(gaia_login=False,
username=chrome.CAP_USERNAME,
password=password,
extra_browser_args=extra_flags)
self.tab = self.browser.browser.tabs[0]
# Set file path.
current_dir = os.path.dirname(os.path.realpath(__file__))
self.pdf_path = os.path.join(current_dir, 'to_print.pdf')
self.printing_log_path = '/tmp/printing_request.log'
# Download ppd files
self.ppd_file = '/tmp/%s' % ppd_file
file_utils.download_file(
'https://storage.googleapis.com/chromiumos-test-assets-public'
'/platform_AddPrinter/%s' % ppd_file, self.ppd_file)
# Start fake printer.
printer = FakePrinter()
self.server_thread = Thread(target=printer.start,
args=(self.printing_log_path, ))
self.server_thread.start()
def run_once(self):
with tempfile.NamedTemporaryFile() as pltp:
file_utils.download_file(self._PLTP_URL, pltp.name)
self._password = pltp.read().rstrip()
with chrome.Chrome(gaia_login=True,
username=self._USERNAME,
password=self._password) as cr:
if not cryptohome.is_vault_mounted(user=self._USERNAME):
raise error.TestFail(
'Expected to find a mounted vault for %s' % self._USERNAME)
tab = cr.browser.tabs.New()
# TODO(achuith): Use a better signal of being logged in, instead of
# parsing accounts.google.com.
tab.Navigate('http://accounts.google.com')
tab.WaitForDocumentReadyStateToBeComplete()
res = tab.EvaluateJavaScript('''
var res = '',
divs = document.getElementsByTagName('div');
for (var i = 0; i < divs.length; i++) {
res = divs[i].textContent;
if (res.search('%s') > 1) {
break;
}
}
res;
''' % self._USERNAME_DISPLAY)
if not res:
raise error.TestFail('No references to %s on accounts page.' %
self._USERNAME_DISPLAY)
tab.Close()
def run_once(self, codec, fps, video_file):
""" Report cpu usage and frame processing time with HW and SW encode.
Use MediaRecorder to record a videos with HW encode and SW encode, and
report the frame processing time and CPU usage of both.
@param codec: a string indicating the codec used to encode video stream,
ex. 'h264'.
@param fps: an integer specifying FPS of the fake input video stream.
@param video_file: a string specifying the name of the video file to be
used as fake input video stream.
"""
# Download test video.
url = DOWNLOAD_BASE + video_file
local_path = os.path.join(self.bindir, video_file)
file_utils.download_file(url, local_path)
fake_file_arg = (FAKE_FILE_ARG % local_path)
fake_stream_arg = (FAKE_STREAM_ARG % fps)
processing_time_sw = 0
processing_time_hw = 0
cpu_usage_sw = 0
cpu_usage_hw = 0
with chrome.Chrome(extra_browser_args=EXTRA_BROWSER_ARGS +
[fake_file_arg, fake_stream_arg] +
DISABLE_HW_ENCODE_ARGS +
[helper_logger.chrome_vmodule_flag()],
init_network_controller=True) as cr:
(processing_time_sw,
cpu_usage_sw) = self.get_record_performance(cr, codec, False)
self.output_perf_value(description=(SW_PREFIX +
FRAME_PROCESSING_TIME),
value=processing_time_sw,
units=TIME_UNIT,
higher_is_better=False)
self.output_perf_value(description=(SW_PREFIX + CPU_USAGE),
value=cpu_usage_sw,
units=PERCENT,
higher_is_better=False)
with chrome.Chrome(extra_browser_args=EXTRA_BROWSER_ARGS +
[fake_file_arg, fake_stream_arg] +
[helper_logger.chrome_vmodule_flag()],
init_network_controller=True) as cr:
(processing_time_hw,
cpu_usage_hw) = self.get_record_performance(cr, codec, True)
self.output_perf_value(description=(HW_PREFIX +
FRAME_PROCESSING_TIME),
value=processing_time_hw,
units=TIME_UNIT,
higher_is_better=False)
self.output_perf_value(description=(HW_PREFIX + CPU_USAGE),
value=cpu_usage_hw,
units=PERCENT,
higher_is_better=False)
log = 'sw processing_time=%f cpu=%d hw processing_time=%f cpu=%d' % (
processing_time_sw, cpu_usage_sw, processing_time_hw, cpu_usage_hw)
logging.info(log)
def _download_video(self, download_path, local_file):
url = '%s%s' % (DOWNLOAD_BASE, download_path)
logging.info('download "%s" to "%s"', url, local_file)
file_utils.download_file(url, local_file)
with open(local_file, 'r') as r:
md5sum = hashlib.md5(r.read()).hexdigest()
if md5sum not in download_path:
raise error.TestError('unmatched md5 sum: %s' % md5sum)
def _get_content(url):
"""Reads the content of the file at the given |URL|.
Args:
url: URL to be fetched.
Return:
The content of the fetched file.
"""
with tempfile.NamedTemporaryFile() as named_file:
file_utils.download_file(url, named_file.name)
return named_file.read().rstrip()
def run_once(self,
videos=None,
secs_per_video=_MEASUREMENT_DURATION,
use_hw_decode=True):
"""run_once method.
@param videos: list of tuple of tagname and video url to test.
@param secs_per_video: time in seconds to play video and measure power.
@param use_hw_decode: if False, disable hw video decoding.
"""
videos_local = []
loop = 0
if not videos:
videos = self._VIDEOS
# Download video to ramdisk
for name, url in videos:
local_path = os.path.join(self._RAMDISK, os.path.basename(url))
logging.info('Downloading %s to %s', url, local_path)
file_utils.download_file(url, local_path)
videos_local.append((name, local_path))
extra_browser_args = []
if not use_hw_decode:
extra_browser_args.append(self._DISABLE_HW_VIDEO_DECODE_ARGS)
with chrome.Chrome(extra_browser_args=extra_browser_args,
init_network_controller=True) as self.cr:
self.cr.browser.platform.SetHTTPServerDirectories(self._RAMDISK)
tab = self.cr.browser.tabs.New()
tab.Activate()
# Just measure power in full-screen.
fullscreen = tab.EvaluateJavaScript('document.webkitIsFullScreen')
if not fullscreen:
with keyboard.Keyboard() as keys:
keys.press_key('f4')
time.sleep(self._WAIT_FOR_IDLE)
self.start_measurements()
for name, url in videos_local:
logging.info('Playing video: %s', name)
self._play_video(self.cr, url)
tagname = '%s_%s' % (self.tagged_testname, name)
loop_start = time.time()
self.loop_sleep(loop, secs_per_video)
self.keyvals[name + '_dropped_frame_percent'] = \
self._calculate_dropped_frame_percent(tab)
self.checkpoint_measurements(tagname, loop_start)
loop += 1
def set_browser_options_for_opt_in(b_options):
"""
Setup Chrome for gaia login and opt_in.
@param b_options: browser options object used by chrome.Chrome.
"""
b_options.username = _USERNAME
with tempfile.NamedTemporaryFile() as pltp:
file_utils.download_file(_ARCP_URL, pltp.name)
b_options.password = pltp.read().rstrip()
b_options.disable_default_apps = False
b_options.disable_component_extensions_with_background_pages = False
b_options.gaia_login = True
def run_once(self, test_file, checksum):
local_path = os.path.join(self.bindir, '%s' % test_file)
file_utils.download_file(_DOWNLOAD_BASE + test_file, local_path)
logging.info('Downloaded file: %s. Expected checksum: %s', local_path,
checksum)
with open(local_path, 'r') as r:
md5sum = hashlib.md5(r.read()).hexdigest()
if md5sum != checksum:
raise error.TestError('unmatched md5 sum: %s' % md5sum)
with chrome.Chrome(init_network_controller=True) as cr:
cr.browser.platform.SetHTTPServerDirectories(self.bindir)
url = cr.browser.platform.http_server.UrlOf(local_path)
self.play_audio(cr.browser.tabs[0], url)
self.run_power_test(url.split('.')[-1])
def _download_extension_crx(self, output_file):
"""Download Cast (Beta) extension from Chrome Web Store to a file.
@param output_file: The output file of the extension.
"""
update_check_url = UPDATE_CHECK_URL % EXTENSION_ID_BETA
response = urllib2.urlopen(update_check_url).read()
logging.info('Response: %s', response)
pattern = r'codebase="(.*crx)"'
regex = re.compile(pattern)
match = regex.search(response)
extension_download_url = match.groups()[0]
logging.info('Extension download link: %s', extension_download_url)
file_utils.download_file(extension_download_url, output_file)
def initialize(self):
self.keyboard = keyboard.Keyboard()
self.username, password = arc_util.get_test_account_info()
# Login a user session.
if utils.is_arc_available():
super(platform_LogoutPerf,
self).initialize(gaia_login=True, disable_arc_opt_in=False)
self.cr = self._chrome
else:
with tempfile.NamedTemporaryFile() as cap:
file_utils.download_file(arc_util._ARCP_URL, cap.name)
password = cap.read().rstrip()
self.cr = chrome.Chrome(gaia_login=True,
username=self.username,
password=password)
def run_once(self, video_name, histogram_name, histogram_bucket_val):
# Download test video.
url = DOWNLOAD_BASE + video_name
local_path = os.path.join(self.bindir, video_name)
file_utils.download_file(url, local_path)
# Start chrome with test flags.
EXTRA_BROWSER_ARGS.append(FAKE_FILE_ARG % local_path)
with chrome.Chrome(extra_browser_args=EXTRA_BROWSER_ARGS) as cr:
# Open WebRTC loopback page.
cr.browser.platform.SetHTTPServerDirectories(self.bindir)
self.start_loopback(cr)
# Make sure decode is hardware accelerated.
histogram_verifier.verify(cr, histogram_name, histogram_bucket_val)
def run_once(self):
# Download test video.
url = DOWNLOAD_BASE + VIDEO_NAME
local_path = os.path.join(self.bindir, VIDEO_NAME)
file_utils.download_file(url, local_path)
# Start chrome with test flags.
EXTRA_BROWSER_ARGS.append(FAKE_FILE_ARG % local_path)
with chrome.Chrome(extra_browser_args=EXTRA_BROWSER_ARGS) as cr:
# Open WebRTC loopback page.
cr.browser.platform.SetHTTPServerDirectories(self.bindir)
self.start_loopback(cr)
# Make sure decode is hardware accelerated.
self.assert_hardware_accelerated(cr)
def play_and_record(self, recorder_widget):
"""Plays and records audio
@param recorder_widget: widget to do the recording
"""
audio_test_utils.dump_cros_audio_logs(
self.host, self.audio_facade, self.resultsdir,
'before_playback')
self.check_correct_audio_node_selected()
browser_facade = self.factory.create_browser_facade()
host_file = os.path.join('/tmp',
os.path.basename(self.test_playback_file))
with tempfile.NamedTemporaryFile() as tmpfile:
file_utils.download_file(self.test_playback_file, tmpfile.name)
os.chmod(tmpfile.name, 0444)
self.host.send_file(tmpfile.name, host_file)
logging.debug('Copied the file on the DUT at %s', host_file)
# Play, wait for some time, and then start recording.
# This is to avoid artifact caused by codec initialization.
browser_facade.new_tab('file://' + host_file)
logging.info('Start playing %s on Cros device', host_file)
time.sleep(self.SHORT_WAIT)
logging.debug('Suspend.')
self.suspend_resume()
logging.debug('Resume.')
time.sleep(self.SHORT_WAIT)
logging.debug('Start recording.')
recorder_widget.start_recording()
time.sleep(self.RECORD_SECONDS)
recorder_widget.stop_recording()
logging.debug('Stopped recording.')
audio_test_utils.dump_cros_audio_logs(
self.host, self.audio_facade, self.resultsdir,
'after_recording')
recorder_widget.read_recorded_binary()
def run_once(self,
decode_time_test=False,
cpu_test=False,
power_test=False,
arc_mode=None):
"""
Runs the video_WebRtcPerf test.
@param decode_time_test: Pass True to run decode time test.
@param cpu_test: Pass True to run CPU usage test.
@param power_test: Pass True to run power consumption test.
@param arc_mode: if 'enabled', run the test with Android enabled.
"""
# Download test video.
url = DOWNLOAD_BASE + VIDEO_NAME
local_path = os.path.join(self.bindir, VIDEO_NAME)
file_utils.download_file(url, local_path)
self.arc_mode = arc_mode
if decode_time_test:
keyvals = self.test_decode_time(local_path)
# The first value is max decode time. The second value is median
# decode time. Construct a dictionary containing one value to log
# the result.
max_decode_time = {
key: value[0]
for (key, value) in keyvals.items()
}
self.log_result(max_decode_time, MAX_DECODE_TIME_DESCRIPTION,
'milliseconds')
median_decode_time = {
key: value[1]
for (key, value) in keyvals.items()
}
self.log_result(median_decode_time, MEDIAN_DECODE_TIME_DESCRIPTION,
'milliseconds')
if cpu_test:
keyvals = self.test_cpu_usage(local_path)
self.log_result(keyvals, CPU_USAGE_DESCRIPTION, 'percent')
if power_test:
keyvals = self.test_power(local_path)
self.log_result(keyvals, POWER_DESCRIPTION, 'W')
def run_once(self, video_name, histogram_name, histogram_bucket_val):
if self.is_skipping_test():
raise error.TestNAError('Skipping test run on this board.')
# Download test video.
url = DOWNLOAD_BASE + video_name
local_path = os.path.join(self.bindir, video_name)
file_utils.download_file(url, local_path)
# Start chrome with test flags.
EXTRA_BROWSER_ARGS.append(FAKE_FILE_ARG % local_path)
with chrome.Chrome(extra_browser_args=EXTRA_BROWSER_ARGS,
init_network_controller=True) as cr:
# Open WebRTC loopback page.
cr.browser.platform.SetHTTPServerDirectories(self.bindir)
self.start_loopback(cr)
# Make sure decode is hardware accelerated.
histogram_verifier.verify(cr, histogram_name, histogram_bucket_val)
def _download_single_file(self, remote_path):
url = DOWNLOAD_BASE + remote_path
tmp = tempfile.NamedTemporaryFile(delete=False, dir=self._tmpdir)
logging.info('download "%s" to "%s"', url, tmp.name)
file_utils.download_file(url, tmp.name)
md5 = hashlib.md5()
with open(tmp.name, 'r') as r:
md5.update(r.read())
filename = os.path.basename(remote_path)
m = RE_VERSIONING_FILE.match(filename)
if m:
prefix, md5sum, suffix = m.groups()
if md5.hexdigest() != md5sum:
raise error.TestError('unmatched md5 sum: %s' %
md5.hexdigest())
filename = prefix + (suffix or '')
self._download_map[filename] = tmp.name
def run_once(self, video_name, video_description, power_test=False,
arc_mode=None):
"""
Runs the video_PlaybackPerf test.
@param video_name: the name of video to play in the DOWNLOAD_BASE
@param video_description: a string describes the video to play which
will be part of entry name in dashboard.
@param power_test: True if this is a power test and it would only run
the power test. If False, it would run the cpu usage test and
the dropped frame count test.
@param arc_mode: if 'enabled', run the test with Android enabled.
"""
# Download test video.
url = DOWNLOAD_BASE + video_name
local_path = os.path.join(self.bindir, os.path.basename(video_name))
logging.info("Downloading %s to %s", url, local_path);
file_utils.download_file(url, local_path)
self.arc_mode = arc_mode
if not power_test:
# Run the video playback dropped frame tests.
keyvals = self.test_dropped_frames(local_path)
# Every dictionary value is a tuple. The first element of the tuple
# is dropped frames. The second is dropped frames percent.
keyvals_dropped_frames = {k: v[0] for k, v in keyvals.iteritems()}
keyvals_dropped_frames_percent = {
k: v[1] for k, v in keyvals.iteritems()}
self.log_result(keyvals_dropped_frames, DROPPED_FRAMES_DESCRIPTION +
video_description, 'frames')
self.log_result(keyvals_dropped_frames_percent,
DROPPED_FRAMES_PERCENT_DESCRIPTION +
video_description, 'percent')
# Run the video playback cpu usage tests.
keyvals = self.test_cpu_usage(local_path)
self.log_result(keyvals, CPU_USAGE_DESCRIPTION + video_description,
'percent')
else:
keyvals = self.test_power(local_path)
self.log_result(keyvals, POWER_DESCRIPTION + video_description, 'W')
def run_once(self, gtest_filter=None):
"""
Runs jpeg_encode_accelerator_unittest on the device.
@param gtest_filter: test case filter.
@raises: error.TestFail for jpeg_encode_accelerator_unittest failures.
"""
url = DOWNLOAD_BASE + TEST_IMAGE_PATH
local_path = os.path.join(self.bindir,
os.path.basename(TEST_IMAGE_PATH))
file_utils.download_file(url, local_path)
cmd_line_list = [helper_logger.chrome_vmodule_flag()]
if gtest_filter:
cmd_line_list.append('--gtest_filter="%s"' % gtest_filter)
cmd_line = ' '.join(cmd_line_list)
self.run_chrome_test_binary(self.binary, cmd_line)
def _download_test_video(self):
"""
Downloads the test video to a temporary directory on host.
@return the remote path of the downloaded video.
"""
url = _DOWNLOAD_BASE + _VIDEO_NAME
local_path = os.path.join(self.tmpdir, _VIDEO_NAME)
logging.info('Downloading %s to %s', url, local_path)
file_utils.download_file(url, local_path)
# The directory returned by get_tmp_dir() is automatically deleted.
tmp_dir = self._host.get_tmp_dir()
remote_path = os.path.join(tmp_dir, _VIDEO_NAME)
# The temporary directory has mode 700 by default. Chrome runs with a
# different user so cannot access it unless we change the permissions.
logging.info('chmodding tmpdir %s to 755', tmp_dir)
self._host.run('chmod 755 %s' % tmp_dir)
logging.info('Sending %s to %s on DUT', local_path, remote_path)
self._host.send_file(local_path, remote_path)
os.remove(local_path)
return remote_path
def initialize(self, ppd_file):
"""
Args:
@param ppd_file: ppd file name
"""
# Set file path.
current_dir = os.path.dirname(os.path.realpath(__file__))
self.pdf_path = os.path.join(current_dir, 'to_print.pdf')
self.printing_log_path = '/tmp/printing_request.log'
# Download ppd files
self.ppd_file = '/tmp/%s' % ppd_file
file_utils.download_file(
'https://storage.googleapis.com/chromiumos-test-assets-public'
'/platform_AddPrinter/%s' % ppd_file, self.ppd_file)
# Start fake printer.
printer = FakePrinter()
self.server_thread = Thread(target=printer.start,
args=(self.printing_log_path, ))
self.server_thread.start()
def run_once(self, capability, arc_mode=None):
if not device_capability.DeviceCapability().have_capability(
capability):
logging.warning("Missing Capability: %s" % capability)
return
# Download test video.
url = DOWNLOAD_BASE + VIDEO_NAME
local_path = os.path.join(self.bindir, VIDEO_NAME)
file_utils.download_file(url, local_path)
# Start chrome with test flags.
EXTRA_BROWSER_ARGS.append(FAKE_FILE_ARG % local_path)
EXTRA_BROWSER_ARGS.append(helper_logger.chrome_vmodule_flag())
with chrome.Chrome(extra_browser_args=EXTRA_BROWSER_ARGS,
arc_mode=arc_mode,
init_network_controller=True) as cr:
# Open WebRTC loopback page.
cr.browser.platform.SetHTTPServerDirectories(self.bindir)
self.start_loopback(cr)
# Make sure decode is hardware accelerated.
self.assert_hardware_accelerated(cr)
def initialize(self):
# Create a virtual keyboard device for key event playback.
device_node = input_device.get_device_node(input_device.KEYBOARD_TYPES)
if not device_node:
raise error.TestFail('Could not find keyboard device node')
self.keyboard = input_device.InputDevice(device_node)
# Instantiate Chrome browser.
with tempfile.NamedTemporaryFile() as cap:
file_utils.download_file(chrome.CAP_URL, cap.name)
password = cap.read().rstrip()
self.browser = chrome.Chrome(gaia_login=True,
username=chrome.CAP_USERNAME,
password=password)
self.tab = self.browser.browser.tabs[0]
# Setup Chrome Tracing.
config = tracing_config.TracingConfig()
category_filter = config.chrome_trace_config.category_filter
category_filter.AddFilterString(_TARGET_TRACING_CATEGORIES)
config.enable_chrome_trace = True
self.target_tracing_config = config
def download_and_install_gsutil():
"""Download and install gsutil package."""
if not os.path.isdir(GSUTIL_PATH):
print 'Installing %s ...' % GSUTIL
# Download the gsutil tarball to a temporary directory
temp_dir = tempfile.mkdtemp()
gsutil_temp_file = os.path.join(temp_dir, GSUTIL_TAR_NAME)
print ' Downloading gsutil tarball: "%s".' % GSUTIL_URI
file_utils.download_file(GSUTIL_URI, gsutil_temp_file)
# Untar the gsutil tarball
untar_cmd_str = 'tar xf %s -C %s'
untar_cmd = untar_cmd_str % (gsutil_temp_file, GSUTIL_INSTALL_DIR)
print ' Untarring the gsutil tarball.'
simple_system(untar_cmd)
# Remove the tarball and the temp directory
shutil.rmtree(temp_dir)
# Set the PATH environment variable for gsutil
PATH = os.environ['PATH']
os.environ['PATH'] = ':'.join([GSUTIL_PATH, PATH])
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_screenshot_comparison_test(self):
"""
Template method to run screenshot comparison tests for ui pieces.
1. Set up test dirs.
2. Create folder name
3. Download golden image.
4. Capture test image.
5. Compare images locally, if FAIL upload to remote for analysis later.
6. Clean up test dirs.
"""
img_comp_conf_path = os.path.join(ui_TestBase.AUTOTEST_CROS_UI_DIR,
ui_TestBase.IMG_COMP_CONF_FILE)
img_comp_factory = image_comparison_factory.ImageComparisonFactory(
img_comp_conf_path)
golden_image_local_dir = os.path.join(ui_TestBase.WORKING_DIR,
'golden_images')
file_utils.make_leaf_dir(golden_image_local_dir)
filename = '%s.png' % self.tagged_testname
golden_image_remote_path = os.path.join(
ui_TestBase.REMOTE_DIR, 'ui',
lsbrelease_utils.get_chrome_milestone(), self.folder_name,
filename)
golden_image_local_path = os.path.join(golden_image_local_dir,
filename)
test_image_filepath = os.path.join(ui_TestBase.WORKING_DIR, filename)
try:
file_utils.download_file(golden_image_remote_path,
golden_image_local_path)
except urllib2.HTTPError as e:
warn = "No screenshot found for {0} on milestone {1}. ".format(
self.tagged_testname, lsbrelease_utils.get_chrome_milestone())
warn += e.msg
raise error.TestWarn(warn)
self.capture_screenshot(test_image_filepath)
comparer = img_comp_factory.make_pdiff_comparer()
comp_res = comparer.compare(golden_image_local_path,
test_image_filepath)
if comp_res.diff_pixel_count > img_comp_factory.pixel_thres:
publisher = img_comp_factory.make_imagediff_publisher(
self.resultsdir)
# get chrome version
version_string = utils.system_output(
constants.CHROME_VERSION_COMMAND, ignore_status=True)
version_string = utils.parse_chrome_version(version_string)[0]
# tags for publishing
tags = {
'testname': self.tagged_testname,
'chromeos_version': utils.get_chromeos_release_version(),
'chrome_version': version_string,
'board': utils.get_board(),
'date': datetime.date.today().strftime("%m/%d/%y"),
'diff_pixels': comp_res.diff_pixel_count
}
publisher.publish(golden_image_local_path, test_image_filepath,
comp_res.pdiff_image_path, tags)
raise error.TestFail('Test Failed. Please see image comparison '
'result by opening index.html from the '
'results directory.')
file_utils.rm_dir_if_exists(ui_TestBase.WORKING_DIR)
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)
