def restart_test(self):
""" Restart UI, excercises X server startup and shutdown and related
kernel paths. """
# Ui respawn will reboot us if we restart ui too many times, so stop
# it for the duration of the test.
stopped_services = service_stopper.ServiceStopper(['ui-respawn'])
stopped_services.stop_services()
while time.time() - self._start_time < self._test_duration_secs:
stopped_ui = service_stopper.ServiceStopper(['ui'])
stopped_ui.stop_services()
time.sleep(1)
stopped_ui.restore_services()
stopped_services.restore_services()
def setup(self, dumpdir=None):
"""Initializes avahi daemon on a new tap interface.
@param dumpdir: Directory where the traffic on the new tap interface
is recorded. A value of None disables traffic dumping.
"""
try:
from lansim import tuntap
except ImportError:
logging.exception('Failed to import lansim.')
raise error.TestError('Error importing lansim. Did you setup_dep '
'and install_pkg lansim on your test?')
# Ensure p2p and avahi aren't running.
self._services = service_stopper.ServiceStopper(['p2p', 'avahi'])
self._services.stop_services()
# Backup p2p files.
p2p_backup_files()
# Initialize the TAP interface.
self.tap = tuntap.TunTap(tuntap.IFF_TAP, name=self._tap_name)
self.tap.set_addr(self._tap_ip, self._tap_mask)
self.tap.up()
# Enable traffic dump.
if not dumpdir is None:
dumpfile = os.path.join(dumpdir, 'dump-%s.pcap' % self.tap.name)
self._tcpdump = tcpdump.Tcpdump(self.tap.name, dumpfile)
# Re-launch avahi-daemon on the TAP interface only.
avahi_utils.avahi_start_on_iface(self.tap.name)
utils.system("start p2p")
def test_cpu_usage(self, local_path):
"""
Runs the video cpu usage test.
@param local_path: the path to the video file.
@return a dictionary that contains the test result.
"""
def get_cpu_usage(cr):
time.sleep(STABILIZATION_DURATION)
cpu_usage_start = site_utils.get_cpu_usage()
time.sleep(MEASUREMENT_DURATION)
cpu_usage_end = site_utils.get_cpu_usage()
return site_utils.compute_active_cpu_time(cpu_usage_start,
cpu_usage_end) * 100
if not utils.wait_for_idle_cpu(WAIT_FOR_IDLE_CPU_TIMEOUT,
CPU_IDLE_USAGE):
raise error.TestError('Could not get idle CPU.')
if not utils.wait_for_cool_machine():
raise error.TestError('Could not get cool machine.')
# Stop the thermal service that may change the cpu frequency.
services = service_stopper.ServiceStopper(THERMAL_SERVICES)
services.stop_services()
# Set the scaling governor to performance mode to set the cpu to the
# highest frequency available.
original_governors = utils.set_high_performance_mode()
try:
return self.test_webrtc(local_path, get_cpu_usage)
finally:
services.restore_services()
utils.restore_scaling_governor_states(original_governors)
def run_once(self):
"""
Entry point of this test.
"""
self.job.install_pkg(self.dep, 'dep', self.dep_dir)
binary_path = os.path.join(self.dep_dir, 'bin', self.test_binary)
test_log_file = os.path.join(
self.resultsdir, '%s_%s' % (self.test_name, self.test_log_suffix))
with service_stopper.ServiceStopper([self.cros_camera_service]):
for hal in camera_utils.get_camera_hal_paths_for_test():
cmd = [
binary_path,
'--camera_hal_path=%s' % hal,
('--gtest_filter=Camera3StillCaptureTest/'
'Camera3SimpleStillCaptureTest.PerformanceTest/*'),
'--output_log=%s' % test_log_file
]
cmd = ' '.join(map(utils.sh_quote_word, cmd))
ret = utils.system(cmd,
timeout=self.timeout,
ignore_status=True)
self._analyze_log(test_log_file)
if ret != 0:
raise error.TestFail('Failed to execute command: %s' % cmd)
def initialize(self):
super(hardware_MemoryThroughput, self).initialize()
self._results = {}
stop = [ 'ui' ]
stop.extend(service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
self._services = service_stopper.ServiceStopper(stop)
self._services.stop_services()
def initialize(self):
# Must stop the TCSD process to be able to collect TPM status,
# then restart TCSD process to leave system in a known good state.
# Must also stop services which depend on tcsd.
self._services = service_stopper.ServiceStopper(
['cryptohomed', 'chapsd', 'tcsd'])
self._services.stop_services()
def test_power(self, local_path):
"""
Runs the video power consumption test.
@param local_path: the path to the video file.
@return a dictionary that contains the test result.
"""
self._backlight = power_utils.Backlight()
self._backlight.set_default()
self._service_stopper = service_stopper.ServiceStopper(
service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
self._service_stopper.stop_services()
self._power_status = power_status.get_status()
# Verify that we are running on battery and the battery is sufficiently
# charged.
self._power_status.assert_battery_state(BATTERY_INITIAL_CHARGED_MIN)
measurements = [power_status.SystemPower(
self._power_status.battery_path)]
def get_power(cr):
power_logger = power_status.PowerLogger(measurements)
power_logger.start()
time.sleep(STABILIZATION_DURATION)
start_time = time.time()
time.sleep(MEASUREMENT_DURATION)
power_logger.checkpoint('result', start_time)
keyval = power_logger.calc()
return keyval['result_' + measurements[0].domain + '_pwr']
return self.test_playback(local_path, get_power)
def run_once(self):
"""
Entry point of this test.
"""
self.job.install_pkg(self.dep, 'dep', self.dep_dir)
with service_stopper.ServiceStopper([self.adapter_service]):
cmd = [os.path.join(self.dep_dir, 'bin', self.test_binary)]
xml_content = utils.system_output(' '.join(
['android-sh', '-c', '\"cat',
self.media_profiles_path + '\"']))
root = xml.etree.ElementTree.fromstring(xml_content)
recording_params = Set()
for camcorder_profiles in root.findall('CamcorderProfiles'):
for encoder_profile in camcorder_profiles.findall(
'EncoderProfile'):
video = encoder_profile.find('Video')
recording_params.add(
'%s:%s:%s:%s' %
(camcorder_profiles.get('cameraId'),
video.get('width'), video.get('height'),
video.get('frameRate')))
if recording_params:
cmd.append('--recording_params=' + ','.join(recording_params))
if utils.get_current_board() in self.tablet_board_list:
cmd.append('--gtest_filter=-*SensorOrientationTest/*')
utils.system(' '.join(cmd), timeout=self.timeout)
def test_cpu_usage(self, local_path):
"""
Runs the video cpu usage test.
@param local_path: the path to the video file.
@return a dictionary that contains the test result.
"""
def get_cpu_usage(cr):
time.sleep(STABILIZATION_DURATION)
cpu_usage_start = utils.get_cpu_usage()
time.sleep(MEASUREMENT_DURATION)
cpu_usage_end = utils.get_cpu_usage()
return utils.compute_active_cpu_time(cpu_usage_start,
cpu_usage_end) * 100
# crbug/753292 - APNG login pictures increase CPU usage. Move the more
# strict idle checks after the login phase.
utils.wait_for_idle_cpu(WAIT_FOR_IDLE_CPU_TIMEOUT, CPU_IDLE_USAGE)
utils.wait_for_cool_machine()
if not utils.wait_for_idle_cpu(WAIT_FOR_IDLE_CPU_TIMEOUT,
CPU_IDLE_USAGE):
logging.warning('Could not get idle CPU pre login.')
if not utils.wait_for_cool_machine():
logging.warning('Could not get cold machine pre login.')
# Stop the thermal service that may change the cpu frequency.
self._service_stopper = service_stopper.ServiceStopper(
THERMAL_SERVICES)
self._service_stopper.stop_services()
# Set the scaling governor to performance mode to set the cpu to the
# highest frequency available.
self._original_governors = utils.set_high_performance_mode()
return self.test_webrtc(local_path, get_cpu_usage)
def initialize(self, seconds_period=20., pdash_note=''):
"""Perform necessary initialization prior to power test run.
@param seconds_period: float of probing interval in seconds.
@param pdash_note: note of the current run to send to power dashboard.
@var backlight: power_utils.Backlight object.
@var keyvals: dictionary of result keyvals.
@var status: power_status.SysStat object.
@var _checkpoint_logger: power_status.CheckpointLogger to track
checkpoint data.
@var _plog: power_status.PowerLogger object to monitor power.
@var _psr: power_utils.DisplayPanelSelfRefresh object to monitor PSR.
@var _services: service_stopper.ServiceStopper object.
@var _start_time: float of time in seconds since Epoch test started.
@var _stats: power_status.StatoMatic object.
@var _tlog: power_status.TempLogger object to monitor temperatures.
@var _clog: power_status.CPUStatsLogger object to monitor CPU(s)
frequencies and c-states.
@var _meas_logs: list of power_status.MeasurementLoggers
"""
super(power_Test, self).initialize()
self.backlight = power_utils.Backlight()
self.backlight.set_default()
self.keyvals = dict()
self.status = power_status.get_status()
self._checkpoint_logger = power_status.CheckpointLogger()
measurements = []
if not self.status.on_ac():
measurements.append(
power_status.SystemPower(self.status.battery_path))
if power_utils.has_powercap_support():
measurements += power_rapl.create_powercap()
elif power_utils.has_rapl_support():
measurements += power_rapl.create_rapl()
self._plog = power_status.PowerLogger(
measurements,
seconds_period=seconds_period,
checkpoint_logger=self._checkpoint_logger)
self._psr = power_utils.DisplayPanelSelfRefresh()
self._services = service_stopper.ServiceStopper(
service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
self._services.stop_services()
self._stats = power_status.StatoMatic()
self._tlog = power_status.TempLogger(
[],
seconds_period=seconds_period,
checkpoint_logger=self._checkpoint_logger)
self._clog = power_status.CPUStatsLogger(
seconds_period=seconds_period,
checkpoint_logger=self._checkpoint_logger)
self._meas_logs = [self._plog, self._tlog, self._clog]
self._pdash_note = pdash_note
def _stop_thermal_throttling(self):
"""
If exist on the platform/machine it stops the different thermal
throttling scripts from running.
Warning: this risks abnormal behavior if machine runs in high load.
"""
self._service_stopper = service_stopper.ServiceStopper(
_THERMAL_SERVICES)
def initialize(self):
"""Perform necessary initialization prior to test run.
Private Attributes:
_services: service_stopper.ServiceStopper object
"""
# Do not switch off screen for screenshot utility.
self._services = service_stopper.ServiceStopper(['powerd'])
self._services.stop_services()
def initialize(self):
smogcheck_util.enableI2C()
self.ttci_obj = None
self.tpm_obj = None
self.attr_dict = dict() # Attributes to output
self.perf_dict = dict() # Performance measures to output
self._services = service_stopper.ServiceStopper(
['cryptohomed', 'chapsd', 'tcsd'])
self._services.stop_services()
def initialize(self):
self.__take_tpm_ownership()
# Stop services that access to the TPM, to be able to use tpmc.
# Note: for TPM2 the order of re-starting services (they are started
# in the reversed listed order) is important: e.g. tpm_managerd must
# start after trunksd, and cryptohomed after attestationd.
self._services = service_stopper.ServiceStopper([
'cryptohomed', 'chapsd', 'attestationd', 'tpm_managerd', 'tcsd',
'trunksd'
])
self._services.stop_services()
def initialize(self):
super(graphics_VideoRenderingPower, self).initialize()
self._backlight = power_utils.Backlight()
self._backlight.set_default()
self._service_stopper = service_stopper.ServiceStopper(
service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
self._service_stopper.stop_services()
self._power_status = power_status.get_status()
def initialize(self):
"""Perform necessary initialization prior to test run.
Private Attributes:
_backlight: power_utils.Backlight object
_services: service_stopper.ServiceStopper object
"""
super(hardware_Backlight, self).initialize()
self._backlight = None
# Stop powerd to avoid it adjusting backlight levels
self._services = service_stopper.ServiceStopper(['powerd'])
self._services.stop_services()
def initialize(self):
# Must stop the TCSD process to be able to collect TPM status,
# then restart TCSD process to leave system in a known good state.
# Must also stop services which depend on tcsd.
# Note: for TPM2 the order of re-starting services (they are started
# in the reversed listed order) is important: e.g. tpm_managerd must
# start after trunksd, and cryptohomed after attestationd.
self._services = service_stopper.ServiceStopper([
'cryptohomed', 'chapsd', 'attestationd', 'tpm_managerd', 'tcsd',
'trunksd'
])
self._services.stop_services()
def initialize(self):
"""Perform necessary initialization prior to test run.
Private Attributes:
_backlight: power_utils.Backlight object
_services: service_stopper.ServiceStopper object
"""
super(power_Idle, self).initialize()
self._backlight = None
self._services = service_stopper.ServiceStopper(
service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
self._services.stop_services()
def get_dictionary_attack_counter():
"""Returns the current dictionary attack counter."""
tpm_command_info = {
'0x49465800': { # Infineon
'command': ('00 c1 ' # Tag = TPM_TAG_RQU_COMMAND
'00 00 00 16 ' # Size = 22
'00 00 00 65 ' # Ordinal = TPM_ORD_GetCapability
'00 00 00 10 ' # Capability Area = TPM_CAP_MFR
'00 00 00 04 ' # Size = 4
'00 00 08 02'), # Vendor-specific
'response_offset': 23}, # Vendor-specific
'0x57454300': { # Nuvoton
'command': ('00 c1 ' # Tag = TPM_TAG_RQU_COMMAND
'00 00 00 14 ' # Size = 20
'00 00 00 65 ' # Ordinal = TPM_ORD_GetCapability
'00 00 00 19 ' # Capability Area = TPM_CAP_DA_LOGIC
'00 00 00 02 ' # Size = 2
'00 04'), # Entity Type = TPM_ET_SRK
'response_offset': 18}, # TPM_DA_INFO.currentCount LSB
'0x53544d20': { # STMicro
'command': ('00 c1 ' # Tag = TPM_TAG_RQU_COMMAND
'00 00 00 14 ' # Size = 20
'00 00 00 65 ' # Ordinal = TPM_ORD_GetCapability
'00 00 00 19 ' # Capability Area = TPM_CAP_DA_LOGIC
'00 00 00 02 ' # Size = 2
'00 04'), # Entity Type = TPM_ET_SRK
'response_offset': 18}} # TPM_DA_INFO.currentCount LSB
caps_file='/sys/class/misc/tpm0/device/caps'
if not os.path.exists(caps_file):
caps_file='/sys/class/tpm/tpm0/device/caps'
try:
with open(caps_file, 'r') as fp:
caps = fp.read()
except IOError:
return 'Could not read TPM device caps.'
match = re.search(r'Manufacturer: (0x[0-9A-Fa-f]*)', caps)
if not match:
return 'Could not find TPM manufacturer.'
manufacturer = match.group(1)
if manufacturer not in tpm_command_info:
return 'TPM manufacturer not supported.'
with service_stopper.ServiceStopper(['cryptohomed',
'chapsd',
'tcsd']):
# The output of 'tpmc raw' is a series of bytes in the form
# '0x00 0x01 0x02 ...'.
tpm_response = utils.system_output(
'tpmc raw %s' % tpm_command_info[manufacturer]['command'],
ignore_status=True).split()
offset = tpm_command_info[manufacturer]['response_offset']
if (len(tpm_response) <= offset):
return 'Unexpected TPM response (length = %d).' % len(tpm_response)
return int(tpm_response[offset], base=16)
def initialize(self, ac_ok=False):
"""Initialize test.
Args:
ac_ok: boolean to allow running on AC
"""
# Objects that need to be taken care of in cleanup() are initialized
# here to None. Otherwise we run the risk of AttributeError raised in
# cleanup() masking a real error that caused the test to fail during
# initialize() before those variables were assigned.
self._backlight = None
self._tmp_keyvals = {}
self._services = service_stopper.ServiceStopper(
service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
self._services.stop_services()
# Time to exclude from calculation after firing a task [seconds]
self._stabilization_seconds = 5
self._power_status = power_status.get_status()
self._tmp_keyvals['b_on_ac'] = self._power_status.on_ac()
if not ac_ok:
# Verify that we are running on battery and the battery is
# sufficiently charged
self._power_status.assert_battery_state(30)
# Find the battery capacity to report expected battery life in hours
batinfo = self._power_status.battery[0]
self.energy_full_design = batinfo.energy_full_design
logging.info("energy_full_design = %0.3f Wh", self.energy_full_design)
# Local data and web server settings. Tarballs with traditional names
# like *.tgz don't get copied to the image by ebuilds (see
# AUTOTEST_FILE_MASK in autotest-chrome ebuild).
self._static_sub_dir = 'static_sites'
utils.extract_tarball_to_dir(
'static_sites.tgz.keep',
os.path.join(self.bindir, self._static_sub_dir))
self._media_dir = '/home/chronos/user/Downloads/'
self._httpd_port = 8000
self._url_base = 'http://localhost:%s/' % self._httpd_port
self._test_server = httpd.HTTPListener(self._httpd_port,
docroot=self.bindir)
# initialize various interesting power related stats
self._statomatic = power_status.StatoMatic()
self._test_server.run()
logging.info('initialize() finished')
def test_power(self, local_path):
"""
Runs the video power consumption test.
@param local_path: the path to the video file.
@return a dictionary that contains the test result.
"""
self._backlight = power_utils.Backlight()
self._backlight.set_default()
self._service_stopper = service_stopper.ServiceStopper(
service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
self._service_stopper.stop_services()
current_power_status = power_status.get_status()
# We expect the DUT is powered by battery now. But this is not always
# true due to other bugs. Disable this test temporarily as workaround.
# TODO(kcwu): remove this workaround after AC control is stable
# crbug.com/723968
if current_power_status.on_ac():
logging.warning('Still powered by AC. Skip this test')
return {}
# Verify that the battery is sufficiently charged.
current_power_status.assert_battery_state(BATTERY_INITIAL_CHARGED_MIN)
measurements = [power_status.SystemPower(
current_power_status.battery_path)]
def get_power(cr):
power_logger = power_status.PowerLogger(measurements)
power_logger.start()
time.sleep(STABILIZATION_DURATION)
start_time = time.time()
time.sleep(MEASUREMENT_DURATION)
power_logger.checkpoint('result', start_time)
keyval = power_logger.calc()
# save_results() will save <fname_prefix>_raw.txt and
# <fname_prefix>_summary.txt, where the former contains raw data.
fname_prefix = 'result_%.0f' % time.time()
power_logger.save_results(self.resultsdir, fname_prefix)
metric_name = 'result_' + measurements[0].domain
with open(os.path.join(
self.resultsdir, fname_prefix + '_raw.txt')) as f:
for line in f.readlines():
if line.startswith(metric_name):
split_data = line.split('\t')
# split_data[0] is metric_name, [1:] are raw data.
return [float(data) for data in split_data[1:]]
# Return a list contains the average power only for fallback.
return [keyval[metric_name + '_pwr_avg']]
return self.test_webrtc(local_path, get_power)
def initialize(self):
if not power_utils.has_battery():
raise error.TestNAError('DUT has no battery. Test Skipped')
self.status = power_status.get_status()
if not self.status.on_ac():
raise error.TestNAError(
'This test needs to be run with the AC power online')
self._services = service_stopper.ServiceStopper(
service_stopper.ServiceStopper.POWER_DRAW_SERVICES + ['ui'])
self._services.stop_services()
def initialize(self):
"""Perform necessary initialization prior to test run.
Private Attributes:
_results: dict containing keyvals with latency measurements
_services: service_stopper.ServiceStopper object
"""
super(hardware_MemoryLatency, self).initialize()
self._results = {}
stop = ['ui']
stop.extend(service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
self._services = service_stopper.ServiceStopper(stop)
self._services.stop_services()
def run_once(self):
"""Test body."""
with service_stopper.ServiceStopper(
services_to_stop=self.RELATED_SERVICES):
# AP configuration parameters, only configuring SSID.
ap_config = {apmanager_constants.CONFIG_SSID: 'testap'}
manager = apmanager_proxy.ApmanagerProxy()
service = manager.start_service(ap_config)
self._verify_process('hostapd', True)
self._verify_process('dnsmasq', True)
manager.terminate_service(service)
self._verify_process('hostapd', False)
self._verify_process('dnsmasq', False)
def __enter__(self):
# Stop the thermal service that may change the cpu frequency.
self._service_stopper = service_stopper.ServiceStopper(THERMAL_SERVICES)
self._service_stopper.stop_services()
if not utils.wait_for_idle_cpu(
WAIT_FOR_IDLE_CPU_TIMEOUT, CPU_IDLE_USAGE):
raise error.TestError('Could not get idle CPU.')
if not utils.wait_for_cool_machine():
raise error.TestError('Could not get cold machine.')
# Set the scaling governor to performance mode to set the cpu to the
# highest frequency available.
self._original_governors = utils.set_high_performance_mode()
return self
def test_generated_screenshots_match_expectation(self):
"""Draws a texture with a soft ellipse twice and captures each image.
Compares the output fuzzily against reference images.
"""
self._services = service_stopper.ServiceStopper(['ui'])
self._services.stop_services()
screenshot1_reference = os.path.join(self.bindir,
'screenshot1_reference.png')
screenshot1_generated = os.path.join(self.resultsdir,
'screenshot1_generated.png')
screenshot1_resized = os.path.join(
self.resultsdir, 'screenshot1_generated_resized.png')
screenshot2_reference = os.path.join(self.bindir,
'screenshot2_reference.png')
screenshot2_generated = os.path.join(self.resultsdir,
'screenshot2_generated.png')
screenshot2_resized = os.path.join(
self.resultsdir, 'screenshot2_generated_resized.png')
exefile = os.path.join(self.autodir, 'deps/glbench/windowmanagertest')
# Delay before screenshot: 1 second has caused failures.
options = ' --screenshot1_sec 2'
options += ' --screenshot2_sec 1'
options += ' --cooldown_sec 1'
# perceptualdiff can handle only 8 bit images.
screenshot_cmd = ' "/usr/local/autotest/bin/screenshot.py %s"'
options += ' --screenshot1_cmd' + screenshot_cmd % screenshot1_generated
options += ' --screenshot2_cmd' + screenshot_cmd % screenshot2_generated
cmd = exefile + ' ' + options
utils.run(cmd,
stdout_tee=utils.TEE_TO_LOGS,
stderr_tee=utils.TEE_TO_LOGS)
convert_cmd = ('convert -channel RGB -colorspace RGB -depth 8'
" -resize '100x100!' %s %s")
utils.system(convert_cmd %
(screenshot1_generated, screenshot1_resized))
utils.system(convert_cmd %
(screenshot2_generated, screenshot2_resized))
os.remove(screenshot1_generated)
os.remove(screenshot2_generated)
diff_cmd = 'perceptualdiff -verbose %s %s'
utils.system(diff_cmd % (screenshot1_reference, screenshot1_resized))
utils.system(diff_cmd % (screenshot2_reference, screenshot2_resized))
def test_power(self, local_path):
"""
Runs the video power consumption test.
@param local_path: the path to the video file.
@return a dictionary that contains the test result.
"""
self._backlight = power_utils.Backlight()
self._backlight.set_default()
self._service_stopper = service_stopper.ServiceStopper(
service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
self._service_stopper.stop_services()
self._power_status = power_status.get_status()
# We expect the DUT is powered by battery now. But this is not always
# true due to other bugs. Disable this test temporarily as workaround.
# TODO(kcwu): remove this workaround after AC control is stable
# crbug.com/723968
if self._power_status.on_ac():
logging.warning('Still powered by AC. Skip this test')
return {}
# Verify that the battery is sufficiently charged.
self._power_status.assert_battery_state(BATTERY_INITIAL_CHARGED_MIN)
measurements = [
power_status.SystemPower(self._power_status.battery_path)
]
if power_utils.has_rapl_support():
measurements += power_rapl.create_rapl()
def get_power(cr):
power_logger = power_status.PowerLogger(measurements)
power_logger.start()
time.sleep(STABILIZATION_DURATION)
start_time = time.time()
time.sleep(MEASUREMENT_DURATION)
power_logger.checkpoint('result', start_time)
keyval = power_logger.calc()
keyval = {
key: keyval[key]
for key in keyval if key.endswith('_pwr')
}
return keyval
return self.test_playback(local_path, get_power)
def __enter__(self):
self._backlight = power_utils.Backlight()
self._backlight.set_default()
self._service_stopper = service_stopper.ServiceStopper(
service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
self._service_stopper.stop_services()
status = power_status.get_status()
# Verify that we are running on battery and the battery is sufficiently
# charged.
status.assert_battery_state(BATTERY_INITIAL_CHARGED_MIN)
self._system_power = power_status.SystemPower(status.battery_path)
self._power_logger = power_status.PowerLogger([self._system_power])
return self
def run_power_test(self, browser, test_url, ac_ok):
"""Runs the webgl power consumption test and reports the perf results.
@param browser: The Browser object to run the test with.
@param test_url: The URL to the aquarium test site.
@param ac_ok: Boolean on whether its ok to have AC power supplied.
"""
self._backlight = power_utils.Backlight()
self._backlight.set_default()
self._service_stopper = service_stopper.ServiceStopper(
service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
self._service_stopper.stop_services()
if not ac_ok:
self._power_status = power_status.get_status()
# Verify that we are running on battery and the battery is
# sufficiently charged.
self._power_status.assert_battery_state(
BATTERY_INITIAL_CHARGED_MIN)
measurements = [
power_status.SystemPower(self._power_status.battery_path)
]
def get_power():
power_logger = power_status.PowerLogger(measurements)
power_logger.start()
time.sleep(STABILIZATION_DURATION)
start_time = time.time()
time.sleep(MEASUREMENT_DURATION)
power_logger.checkpoint('result', start_time)
keyval = power_logger.calc()
logging.info('Power output %s', keyval)
return keyval['result_' + measurements[0].domain + '_pwr']
self.run_fish_test(browser, test_url, 1000, perf_log=False)
if not ac_ok:
energy_rate = get_power()
# This is a power specific test so we are not capturing
# avg_fps and avg_render_time in this test.
self.perf_keyval[POWER_DESCRIPTION] = energy_rate
self.output_perf_value(description=POWER_DESCRIPTION,
value=energy_rate,
units='W',
higher_is_better=False)
def _setup_avahi(self):
"""Initializes avahi daemon on a new tap interface."""
from lansim import tuntap
# Ensure p2p and avahi aren't running.
self._services = service_stopper.ServiceStopper(['p2p', 'avahi'])
self._services.stop_services()
# Initialize avahi-daemon listenning only on the fake TAP interface.
self._tap = tuntap.TunTap(tuntap.IFF_TAP, name='faketap')
# The network 169.254/16 shouldn't clash with other real services. We
# use a /24 subnet of it here.
self._tap.set_addr('169.254.10.1', mask=24)
self._tap.up()
# Re-launch avahi-daemon on the tap interface.
avahi_utils.avahi_start_on_iface(self._tap.name)
