def run_once(self, idle_time=120, sleep=10):
with chrome.Chrome():
self._backlight = power_utils.Backlight()
self._backlight.set_default()
t0 = time.time()
self._start_time = t0
self._psr = power_utils.DisplayPanelSelfRefresh(init_time=t0)
self.status = power_status.get_status()
self._stats = power_status.StatoMatic()
measurements = []
if not self.status.on_ac():
measurements.append(
power_status.SystemPower(self.status.battery_path))
if power_utils.has_rapl_support():
measurements += power_rapl.create_rapl()
self._plog = power_status.PowerLogger(measurements,
seconds_period=sleep)
self._tlog = power_status.TempLogger([], seconds_period=sleep)
self._plog.start()
self._tlog.start()
for _ in xrange(0, idle_time, sleep):
time.sleep(sleep)
self.status.refresh()
self.status.refresh()
self._plog.checkpoint('', self._start_time)
self._tlog.checkpoint('', self._start_time)
self._psr.refresh()
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):
if not self._check_cpu_type():
raise error.TestNAError('Unsupported CPU')
status = power_status.get_status()
if status.on_ac():
logging.info('AC Power is online')
self._on_ac = True
else:
logging.info('AC Power is offline')
self._on_ac = False
failures = ''
fail_count = self._verify_wifi_power_settings()
if fail_count:
failures += 'wifi_failures(%d) ' % fail_count
fail_count = self._verify_usb_power_settings()
if fail_count:
failures += 'usb_failures(%d) ' % fail_count
fail_count = self._verify_filesystem_power_settings()
if fail_count:
failures += 'filesystem_failures(%d) ' % fail_count
if failures:
raise error.TestFail(failures)
def run_once(self):
cpu_arch = power_utils.get_x86_cpu_arch()
if not cpu_arch:
raise error.TestNAError('Unsupported CPU')
self._cpu_type = 'Atom'
if cpu_arch is not 'Atom':
self._cpu_type = 'Non-Atom'
self._registers = power_utils.Registers()
status = power_status.get_status()
if status.on_ac():
logging.info('AC Power is online')
self._on_ac = True
else:
logging.info('AC Power is offline')
self._on_ac = False
failures = ''
for testname in SUBTESTS:
logging.info("SUBTEST = %s", testname)
func = getattr(self, "_verify_%s_power_settings" % testname)
fail_count = func()
if fail_count:
failures += '%s_failures(%d) ' % (testname, fail_count)
if failures:
raise error.TestFail(failures)
def initialize(self):
super(hardware_MultiReaderPowerConsumption, self).initialize()
# Make sure we're not on AC power
self.status = power_status.get_status()
if self.status.on_ac():
raise error.TestNAError(
'This test needs to be run with the AC power offline')
def initialize(self, **kwargs):
"""Set up local variables and ensure device is on AC power."""
self._initialize_test_constants()
self._power_status = power_status.get_status()
if not self._power_status.on_ac():
raise error.TestNAError('Test must be run with DUT on AC power.')
self._backlight = power_utils.Backlight()
super(policy_PowerManagementIdleSettings, self).initialize(**kwargs)
def initialize(self, **kwargs):
"""Set up local variables and ensure sufficient battery charge."""
self._power_status = power_status.get_status()
if not self._power_status.on_ac():
# Ensure that the battery has sufficient minimum charge.
self._power_status.assert_battery_state(self.PERCENT_CHARGE_MIN)
logging.info('Device power type is "%s"', self._power_type)
super(policy_ChromeOsLockOnIdleSuspend, self).initialize(**kwargs)
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 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 __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 run_once(self, seconds=200, sleep=10):
status = power_status.get_status()
if status.on_ac():
logging.warning('AC power is online -- '
'unable to monitor energy consumption')
return
# If powerd is running, stop it, so that it cannot interfere with the
# backlight adjustments in this test.
if utils.system_output('status powerd').find('start/running') != -1:
powerd_running = True
utils.system_output('stop powerd')
else:
powerd_running = False
start_energy = status.battery[0].energy
self._tlog = power_status.TempLogger([], seconds_period=sleep)
self._tlog.start()
# Let the test run
for i in range(0, seconds, sleep):
time.sleep(sleep)
status.refresh()
status.refresh()
end_energy = status.battery[0].energy
consumed_energy = start_energy - end_energy
energy_rate = consumed_energy * 60 * 60 / seconds
keyvals = self._tlog.calc()
keyvals['wh_energy_full'] = status.battery[0].energy_full
keyvals['wh_start_energy'] = start_energy
keyvals['wh_end_energy'] = end_energy
keyvals['wh_consumed_energy'] = consumed_energy
keyvals['w_average_energy_rate'] = energy_rate
keyvals['w_end_energy_rate'] = status.battery[0].energy_rate
self.write_perf_keyval(keyvals)
# Restore powerd if it was originally running.
if powerd_running:
utils.system_output('start powerd')
def run_power_test(self, audio_type):
"""
Captures power usage and reports it to the perf dashboard.
@param audio_type: audio format label to attach with perf keyval.
"""
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():
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']
energy_rate = get_power()
perf_keyval = {}
perf_keyval[POWER_DESCRIPTION + audio_type] = energy_rate
self.output_perf_value(description=POWER_DESCRIPTION + audio_type,
value=energy_rate,
units='W',
higher_is_better=False)
self.write_perf_keyval(perf_keyval)
def run_once(self):
status = power_status.get_status()
statomatic = power_status.StatoMatic()
meas = [power_status.SystemPower(status.battery_path)]
plog = power_status.PowerLogger(meas, seconds_period=1)
tlog = power_status.TempLogger(None, seconds_period=1)
plog.start()
tlog.start()
time.sleep(2)
logging.info("battery_energy: %f" % status.battery[0].energy)
logging.info("linepower_online: %s" % status.on_ac())
keyvals = plog.calc()
keyvals.update(tlog.calc())
keyvals.update(statomatic.publish())
for k in sorted(keyvals.keys()):
logging.info("%s: %s" , k, keyvals[k])
plog.save_results(self.resultsdir)
tlog.save_results(self.resultsdir)
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)]
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, delay=60, seconds=10, tries=20):
self._backlight = power_utils.Backlight()
# disable screen blanking. Stopping screen-locker isn't
# synchronous :(. Add a sleep for now, till powerd comes around
# and fixes all this for us.
# TODO(davidjames): Power manager should support this feature directly
time.sleep(5)
graphics_utils.screen_disable_blanking()
status = power_status.get_status()
status.assert_battery_state(5)
max_brightness = self._backlight.get_max_level()
if max_brightness < 4:
raise error.TestFail('Must have at least 5 backlight levels')
sysfs_max = self._get_highest_sysfs_max_brightness()
if max_brightness != sysfs_max:
raise error.TestFail(('Max brightness %d is not the highest ' +
'possible |max_brightness|, which is %d') %
(max_brightness, sysfs_max))
keyvals = {}
rates = []
levels = [0, 50, 100]
for i in levels:
self._backlight.set_percent(i)
time.sleep(delay)
this_rate = []
for _ in range(tries):
time.sleep(seconds)
status.refresh()
this_rate.append(status.battery[0].energy_rate)
rate = min(this_rate)
keyvals['w_bl_%d_rate' % i] = rate
rates.append(rate)
self.write_perf_keyval(keyvals)
for i in range(1, len(levels)):
if rates[i] <= rates[i - 1]:
raise error.TestFail('Turning up the backlight ' \
'should increase energy consumption')
def initialize(self, percent_initial_charge_min=10):
"""
Setup local variables and init the fake DM server
@param percent_initial_charge_min: Minimum percentage of battery
required for the test to run.
"""
# Username and password for the fake dm server can be anything
# they are not used to authenticate against GAIA.
self.username = '******'
self.password = '******'
self._power_status = power_status.get_status()
if not self._power_status.on_ac():
# Ensure that the battery has some charge.
self._power_status.assert_battery_state(percent_initial_charge_min)
logging.info("Device power type is %s", self._power_type)
self.fake_dm_server = enterprise_fake_dmserver.FakeDMServer(
self.srcdir)
self.fake_dm_server.start(self.tmpdir, self.debugdir)
def run_once(self, power_on=True):
status = power_status.get_status()
if power_on and not status.on_ac():
raise error.TestError('AC line status is not on but should be')
elif not power_on and status.on_ac():
raise error.TestError('AC line status is on but should not be')
def initialize(self,
percent_initial_charge_min=None,
check_network=True,
loop_time=3600,
loop_count=1,
should_scroll='true',
should_scroll_up='true',
scroll_loop='false',
scroll_interval_ms='10000',
scroll_by_pixels='600',
test_low_batt_p=3,
verbose=True,
force_wifi=False,
wifi_ap='',
wifi_sec='none',
wifi_pw='',
wifi_timeout=60,
tasks='',
volume_level=10,
mic_gain=10,
low_batt_margin_p=2,
ac_ok=False,
log_mem_bandwidth=False,
gaia_login=True):
"""
percent_initial_charge_min: min battery charge at start of test
check_network: check that Ethernet interface is not running
loop_time: length of time to run the test for in each loop
loop_count: number of times to loop the test for
should_scroll: should the extension scroll pages
should_scroll_up: should scroll in up direction
scroll_loop: continue scrolling indefinitely
scroll_interval_ms: how often to scoll
scroll_by_pixels: number of pixels to scroll each time
test_low_batt_p: percent battery at which test should stop
verbose: add more logging information
force_wifi: should we force to test to run on wifi
wifi_ap: the name (ssid) of the wifi access point
wifi_sec: the type of security for the wifi ap
wifi_pw: password for the wifi ap
wifi_timeout: The timeout for wifi configuration
volume_level: percent audio volume level
mic_gain: percent audio microphone gain level
low_batt_margin_p: percent low battery margin to be added to
sys_low_batt_p to guarantee test completes prior to powerd shutdown
ac_ok: boolean to allow running on AC
log_mem_bandwidth: boolean to log memory bandwidth during the test
gaia_login: boolean of whether real GAIA login should be attempted.
"""
self._backlight = None
self._services = None
self._browser = None
self._loop_time = loop_time
self._loop_count = loop_count
self._mseconds = self._loop_time * 1000
self._verbose = verbose
self._sys_low_batt_p = 0.
self._sys_low_batt_s = 0.
self._test_low_batt_p = test_low_batt_p
self._should_scroll = should_scroll
self._should_scroll_up = should_scroll_up
self._scroll_loop = scroll_loop
self._scroll_interval_ms = scroll_interval_ms
self._scroll_by_pixels = scroll_by_pixels
self._tmp_keyvals = {}
self._power_status = None
self._force_wifi = force_wifi
self._testServer = None
self._tasks = tasks.replace(' ', '')
self._backchannel = None
self._shill_proxy = None
self._volume_level = volume_level
self._mic_gain = mic_gain
self._ac_ok = ac_ok
self._log_mem_bandwidth = log_mem_bandwidth
self._wait_time = 60
self._stats = collections.defaultdict(list)
self._gaia_login = gaia_login
if not power_utils.has_battery():
rsp = "Device designed without battery. Skipping test."
raise error.TestNAError(rsp)
self._power_status = power_status.get_status()
self._tmp_keyvals['b_on_ac'] = self._power_status.on_ac()
with tempfile.NamedTemporaryFile() as pltp:
file_utils.download_file(self._pltp_url, pltp.name)
self._password = pltp.read().rstrip()
if not ac_ok:
self._power_status.assert_battery_state(percent_initial_charge_min)
# If force wifi enabled, convert eth0 to backchannel and connect to the
# specified WiFi AP.
if self._force_wifi:
sec_config = None
# TODO(dbasehore): Fix this when we get a better way of figuring out
# the wifi security configuration.
if wifi_sec == 'rsn' or wifi_sec == 'wpa':
sec_config = xmlrpc_security_types.WPAConfig(
psk=wifi_pw,
wpa_mode=xmlrpc_security_types.WPAConfig.MODE_PURE_WPA2,
wpa2_ciphers=[xmlrpc_security_types.WPAConfig.CIPHER_CCMP])
wifi_config = xmlrpc_datatypes.AssociationParameters(
ssid=wifi_ap,
security_config=sec_config,
configuration_timeout=wifi_timeout)
# If backchannel is already running, don't run it again.
self._backchannel = backchannel.Backchannel()
if not self._backchannel.setup():
raise error.TestError('Could not setup Backchannel network.')
self._shill_proxy = wifi_proxy.WifiProxy()
self._shill_proxy.remove_all_wifi_entries()
for i in xrange(1, 4):
raw_output = self._shill_proxy.connect_to_wifi_network(
wifi_config.ssid,
wifi_config.security,
wifi_config.security_parameters,
wifi_config.save_credentials,
station_type=wifi_config.station_type,
hidden_network=wifi_config.is_hidden,
discovery_timeout_seconds=wifi_config.discovery_timeout,
association_timeout_seconds=wifi_config.
association_timeout,
configuration_timeout_seconds=wifi_config.
configuration_timeout * i)
result = xmlrpc_datatypes.AssociationResult. \
from_dbus_proxy_output(raw_output)
if result.success:
break
logging.warn(
'wifi connect: disc:%d assoc:%d config:%d fail:%s',
result.discovery_time, result.association_time,
result.configuration_time, result.failure_reason)
else:
raise error.TestError('Could not connect to WiFi network.')
else:
# Find all wired ethernet interfaces.
# TODO: combine this with code in network_DisableInterface, in a
# common library somewhere.
ifaces = [
nic.strip() for nic in os.listdir('/sys/class/net/')
if ((not os.path.exists('/sys/class/net/' + nic + '/phy80211'))
and nic.find('eth') != -1)
]
logging.debug(str(ifaces))
for iface in ifaces:
if check_network and self._is_network_iface_running(iface):
raise error.TestError('Ethernet interface is active. ' +
'Please remove Ethernet cable')
# record the max backlight level
self._backlight = power_utils.Backlight()
self._tmp_keyvals['level_backlight_max'] = \
self._backlight.get_max_level()
self._services = service_stopper.ServiceStopper(
service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
self._services.stop_services()
# fix up file perms for the power test extension so that chrome
# can access it
os.system('chmod -R 755 %s' % self.bindir)
# setup a HTTP Server to listen for status updates from the power
# test extension
self._testServer = httpd.HTTPListener(8001, docroot=self.bindir)
self._testServer.run()
# initialize various interesting power related stats
self._statomatic = power_status.StatoMatic()
self._power_status.refresh()
help_output = utils.system_output('check_powerd_config --help')
if 'low_battery_shutdown' in help_output:
logging.info('Have low_battery_shutdown option')
self._sys_low_batt_p = float(
utils.system_output(
'check_powerd_config --low_battery_shutdown_percent'))
self._sys_low_batt_s = int(
utils.system_output(
'check_powerd_config --low_battery_shutdown_time'))
else:
# TODO(dchan) Once M57 in stable, remove this option and function.
logging.info('No low_battery_shutdown option')
(self._sys_low_batt_p, self._sys_low_batt_s) = \
self._get_sys_low_batt_values_from_log()
if self._sys_low_batt_p and self._sys_low_batt_s:
raise error.TestError(
"Low battery percent and seconds are non-zero.")
min_low_batt_p = min(self._sys_low_batt_p + low_batt_margin_p, 100)
if self._sys_low_batt_p and (min_low_batt_p > self._test_low_batt_p):
logging.warning(
"test low battery threshold is below system " +
"low battery requirement. Setting to %f", min_low_batt_p)
self._test_low_batt_p = min_low_batt_p
self._ah_charge_start = self._power_status.battery[0].charge_now
self._wh_energy_start = self._power_status.battery[0].energy
def _get_current_energy_rate(self):
return power_status.get_status().battery[0].energy_rate
def run_once(self):
# Require that this test be run on battery with at least 5% charge
status = power_status.get_status()
status.assert_battery_state(5)
prefs = {
'has_ambient_light_sensor': 0,
'ignore_external_policy': 1,
'plugged_dim_ms': 7200000,
'plugged_off_ms': 9000000,
'plugged_suspend_ms': 18000000,
'unplugged_dim_ms': 7200000,
'unplugged_off_ms': 9000000,
'unplugged_suspend_ms': 18000000
}
self._pref_change = power_utils.PowerPrefChanger(prefs)
keyvals = {}
num_errors = 0
# These are the expected ratios of energy rate between max, min, and off
# (zero) brightness levels. e.g. when changing from max to min, the
# energy rate must become <= (max_energy_rate * max_to_min_factor).
max_to_min_factor = \
1.0 - self._energy_rate_change_threshold_percent / 100.0
min_to_off_factor = \
1.0 - self._energy_rate_change_threshold_percent / 100.0
off_to_max_factor = 1.0 / (max_to_min_factor * min_to_off_factor)
# Determine the number of outputs that are on.
starting_num_outputs_on = get_num_outputs_on()
if starting_num_outputs_on == 0:
raise error.TestFail('At least one display output must be on.')
keyvals['starting_num_outputs_on'] = starting_num_outputs_on
self._backlight = power_utils.Backlight()
keyvals['max_brightness'] = self._backlight.get_max_level()
if keyvals['max_brightness'] <= self._min_num_steps:
raise error.TestFail('Must have at least %d backlight levels' %
(self._min_num_steps + 1))
keyvals['initial_brightness'] = self._backlight.get_level()
self._wait_for_stable_energy_rate()
keyvals['initial_power_w'] = self._get_current_energy_rate()
self._backlight_controller = power_utils.BacklightController()
self._backlight_controller.set_brightness_to_max()
current_brightness = \
utils.wait_for_value(self._backlight.get_level,
max_threshold=keyvals['max_brightness'])
if current_brightness != keyvals['max_brightness']:
num_errors += 1
logging.error(('Failed to increase brightness to max, ' + \
'brightness is %d.') % current_brightness)
else:
self._wait_for_stable_energy_rate()
keyvals['max_brightness_power_w'] = self._get_current_energy_rate()
# Set brightness to minimum without going to zero.
# Note that we don't know what the minimum brightness is, so just set
# min_threshold=0 to use the timeout to wait for the brightness to
# settle.
self._backlight_controller.set_brightness_to_min()
current_brightness = utils.wait_for_value(
self._backlight.get_level,
min_threshold=(keyvals['max_brightness'] / 2 - 1))
if current_brightness >= keyvals['max_brightness'] / 2 or \
current_brightness == 0:
num_errors += 1
logging.error('Brightness is not at minimum non-zero level: %d' %
current_brightness)
else:
self._wait_for_stable_energy_rate()
keyvals['min_brightness_power_w'] = self._get_current_energy_rate()
# Turn off the screen by decreasing brightness one more time with
# allow_off=True.
self._backlight_controller.decrease_brightness(True)
current_brightness = utils.wait_for_value(self._backlight.get_level,
min_threshold=0)
if current_brightness != 0:
num_errors += 1
logging.error('Brightness is %d, expecting 0.' %
current_brightness)
# Wait for screen to turn off.
num_outputs_on = utils.wait_for_value(
get_num_outputs_on, min_threshold=(starting_num_outputs_on - 1))
keyvals['outputs_on_after_screen_off'] = num_outputs_on
if num_outputs_on >= starting_num_outputs_on:
num_errors += 1
logging.error('At least one display must have been turned off. ' + \
'Number of displays on: %s' % num_outputs_on)
else:
self._wait_for_stable_energy_rate()
keyvals['screen_off_power_w'] = self._get_current_energy_rate()
# Set brightness to max.
self._backlight_controller.set_brightness_to_max()
current_brightness = utils.wait_for_value(
self._backlight.get_level, max_threshold=keyvals['max_brightness'])
if current_brightness != keyvals['max_brightness']:
num_errors += 1
logging.error(('Failed to increase brightness to max, ' + \
'brightness is %d.') % current_brightness)
# Verify that the same number of outputs are on as before.
num_outputs_on = get_num_outputs_on()
keyvals['outputs_on_at_end'] = num_outputs_on
if num_outputs_on != starting_num_outputs_on:
num_errors += 1
logging.error(('Number of displays turned on should be same as ' + \
'at start. Number of displays on: %s') %
num_outputs_on)
self._wait_for_stable_energy_rate()
keyvals['final_power_w'] = self._get_current_energy_rate()
# Energy rate must have changed significantly between transitions.
if 'max_brightness_power_w' in keyvals and \
'min_brightness_power_w' in keyvals and \
keyvals['min_brightness_power_w'] >= \
keyvals['max_brightness_power_w'] * max_to_min_factor:
num_errors += 1
logging.error('Power draw did not decrease enough when ' + \
'brightness was decreased from max to min.')
if 'screen_off_power_w' in keyvals and \
'min_brightness_power_w' in keyvals and \
keyvals['screen_off_power_w'] >= \
keyvals['min_brightness_power_w'] * min_to_off_factor:
num_errors += 1
logging.error('Power draw did not decrease enough when screen ' + \
'was turned off.')
if num_outputs_on == starting_num_outputs_on and \
'screen_off_power_w' in keyvals and \
keyvals['final_power_w'] <= \
keyvals['screen_off_power_w'] * off_to_max_factor:
num_errors += 1
logging.error('Power draw did not increase enough after ' + \
'turning screen on.')
self.write_perf_keyval(keyvals)
if num_errors > 0:
raise error.TestFail('Test failed with %d errors' % num_errors)
def run_once(self, power_on=True):
utils.poll_for_condition(
lambda: power_status.get_status().on_ac() == power_on,
timeout=10, exception=error.TestError('AC power not %d' % power_on))
def run_once(self,
test_hours=None,
sample_hours=None,
percent_initial_charge_min=0.2,
max_milliwatts_standby=None):
if test_hours <= sample_hours:
raise error.TestFail(
"Test hours must be greater than sample hours")
# If we're measuring <= 6min of S3 then the S0 time is not negligible.
# Note, reasonable rule of thumb is S0 idle is ~10-20 times S3 power.
if sample_hours < self._min_sample_hours:
raise error.TestFail("Must suspend more than %.2f hours" % \
sample_hours)
# Query initial power status
power_stats = power_status.get_status()
power_stats.assert_battery_state(percent_initial_charge_min)
charge_start = power_stats.battery[0].charge_now
voltage_start = power_stats.battery[0].voltage_now
max_hours = charge_start * voltage_start / \
(max_milliwatts_standby / 1000)
if max_hours < test_hours:
raise error.TestFail('Battery not charged adequately for test')
elapsed_hours = 0
while elapsed_hours < test_hours:
charge_before = power_stats.battery[0].charge_now
before_suspend_secs = rtc.get_seconds()
sys_power.do_suspend(sample_hours * 3600)
after_suspend_secs = rtc.get_seconds()
power_stats.refresh()
if power_stats.percent_current_charge() < self._percent_min_charge:
logging.warning(
"Battery percent = %.2f%%. Too low to continue")
break
# check that the RTC slept the correct amount of time as there could
# potentially be another wake source that would spoil the test.
actual_hours = (after_suspend_secs - before_suspend_secs) / 3600.0
logging.debug("actual_hours = %.4f", actual_hours)
percent_diff = math.fabs((actual_hours - sample_hours) /
((actual_hours + sample_hours) / 2) * 100)
if percent_diff > 2:
err_str = "Requested S3 time and actual varied by %.2f%%." \
% percent_diff
raise error.TestFail(err_str)
# Check resulting charge consumption
charge_used = charge_before - power_stats.battery[0].charge_now
logging.debug("charge_used = %.6f", charge_used)
elapsed_hours += actual_hours
logging.debug("elapsed_hours = %.4f", elapsed_hours)
charge_end = power_stats.battery[0].charge_now
voltage_end = power_stats.battery[0].voltage_now
standby_hours = power_stats.battery[0].charge_full_design / \
(charge_start - charge_end) * elapsed_hours
energy_used = charge_start * voltage_start - charge_end * voltage_end
if energy_used <= 0:
raise error.TestError("Energy used reading is suspect.")
standby_milliwatts = energy_used / elapsed_hours * 1000
results = {}
results['milliwatts_standby_power'] = standby_milliwatts
results['hours_standby_time'] = standby_hours
self.write_perf_keyval(results)
# need to sleep for some time to allow network connection to return
time.sleep(10)
