def postprocess_iteration(self):
keyvals = self._stats.publish()
# record the current and max backlight levels
self._backlight = power_utils.Backlight()
keyvals['level_backlight_max'] = self._backlight.get_max_level()
keyvals['level_backlight_current'] = self._backlight.get_level()
# record battery stats if not on AC
if self.status.on_ac():
keyvals['b_on_ac'] = 1
else:
keyvals['b_on_ac'] = 0
keyvals['ah_charge_full'] = self.status.battery[0].charge_full
keyvals['ah_charge_full_design'] = \
self.status.battery[0].charge_full_design
keyvals['ah_charge_now'] = self.status.battery[0].charge_now
keyvals['a_current_now'] = self.status.battery[0].current_now
keyvals['wh_energy'] = self.status.battery[0].energy
keyvals['w_energy_rate'] = self.status.battery[0].energy_rate
keyvals['h_remaining_time'] = self.status.battery[0].remaining_time
keyvals['v_voltage_min_design'] = \
self.status.battery[0].voltage_min_design
keyvals['v_voltage_now'] = self.status.battery[0].voltage_now
keyvals.update(self._plog.calc())
keyvals.update(self._tlog.calc())
keyvals.update(self._psr.get_keyvals())
logging.debug("keyvals = %s", keyvals)
self.write_perf_keyval(keyvals)
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, 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 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 run_once(self, run_time_sec=60):
"""
@param run_time_sec: time to run the test
"""
if run_time_sec < 30:
raise error.TestError('Must run for at least 30 seconds')
with chrome.Chrome(init_network_controller=True) as cr:
# Start powerd if not started. Set timeouts for quick idle events.
run_time_ms = run_time_sec * 1000
# At the time of writing this test, the video detector gets a status
# update from Chrome every ten seconds.
dim_ms = 10000
off_ms = max(3600000, run_time_ms * 10)
prefs = {
'has_ambient_light_sensor': 0,
'ignore_external_policy': 1,
'plugged_dim_ms': dim_ms,
'plugged_off_ms': off_ms,
'unplugged_dim_ms': dim_ms,
'unplugged_off_ms': off_ms,
}
self._pref_change = power_utils.PowerPrefChanger(prefs)
keyvals = {}
# Start with max brightness, so we can easily detect dimming.
power_utils.BacklightController().set_brightness_to_max()
backlight = power_utils.Backlight()
initial_brightness = \
base_utils.wait_for_value(backlight.get_max_level)
# Open a tab to play video.
cr.browser.platform.SetHTTPServerDirectories(self.bindir)
tab = cr.browser.tabs[0]
tab.Navigate(
cr.browser.platform.http_server.UrlOf(
os.path.join(self.bindir, 'fade.html')))
tab.WaitForDocumentReadyStateToBeComplete()
# Sleep until the runtime is up.
time.sleep(run_time_sec)
# Stop powerd to avoid dimming when the video stops.
utils.system_output('stop powerd')
final_brightness = backlight.get_level()
# Check that the backlight stayed the same.
if initial_brightness != final_brightness:
raise error.TestFail(
('Backlight level changed from %d to %d when it should ' + \
'have stayed the same.') %
(initial_brightness, final_brightness))
keyvals['initial_brightness'] = initial_brightness
keyvals['final_brightness'] = final_brightness
self.write_perf_keyval(keyvals)
def run_once(self):
# optionally test keyboard backlight
kblight = None
kblight_errs = 0
try:
kblight = power_utils.KbdBacklight()
except power_utils.KbdBacklightException as e:
logging.info("Assuming no keyboard backlight due to %s", str(e))
if kblight:
init_percent = kblight.get_percent()
try:
for i in xrange(100, -1, -1):
kblight.set_percent(i)
result = int(kblight.get_percent())
if i != result:
logging.error('keyboard backlight set %d != %d get', i,
result)
kblight_errs += 1
finally:
kblight.set_percent(init_percent)
if kblight_errs:
raise error.TestFail("%d errors testing keyboard backlight." % \
kblight_errs)
self._backlight = power_utils.Backlight()
backlight_errs = 0
backlight_max = self._backlight.get_max_level()
for i in xrange(backlight_max + 1):
self._backlight.set_level(i)
result = self._backlight.get_level()
if i != result:
# The kernel Documentation/ABI/stable/sysfs-class-backlight
# states that the requested brightness may not be the
# actual_brightness.
# Although not specified in the docs, let's allow the difference
# between requested brightness and actual_brightness percent be
# within a tolerance of 1 of each other.
actual_percent = self._backlight.get_percent()
expected_percent = float(i) / float(backlight_max) * 100.0
diff_percent = abs(actual_percent - expected_percent)
log_level_func = logging.warn
if diff_percent > 1:
backlight_errs += 1
log_level_func = logging.error
log_level_func(
'backlight expected vs. actual exceeds error'
'tolerance')
log_level_func('backlight set %d != %d get', i, result)
log_level_func('backlight percent difference is %f%%',
diff_percent)
if backlight_errs:
raise error.TestFail("%d errors testing backlight." % \
backlight_errs)
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_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 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 run_once(self, resume_percent=70):
results = {}
backlight = power_utils.Backlight()
results['initial_brightness'] = backlight.get_level()
max_level = backlight.get_max_level()
resume_level = int(round(max_level * resume_percent / 100))
# If the current brightness is the same as the requested brightness,
# request 100 - |resume_brightness| instead.
if resume_level == results['initial_brightness']:
resume_level = max_level - resume_level
backlight.set_resume_level(resume_level)
sys_power.kernel_suspend(seconds=5)
final_level = backlight.get_level()
if final_level != resume_level:
raise error.TestFail(
('Brightness level after resume did not match requested ' + \
'brightness: %d vs %d') % (final_level, resume_level))
results['resume_brightness'] = resume_level
self.write_perf_keyval(results)
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, short=False, test_groups=None, reps=1):
# Some sub-tests have duration specified directly, _base_secs * reps
# is used in this case. Others complete whenever the underlying task
# completes, those are manually tuned to be roughly around
# reps * 30 seconds. Don't change _base_secs unless you also
# change the manual tuning in sub-tests
self._base_secs = 30
self._repeats = reps
self._duration_secs = self._base_secs * reps
# Lists of default tests to run
UI_TESTS = ['backlight', 'download', 'webpages', 'video', 'v8']
NONUI_TESTS = ['backchannel', 'sound', 'lowlevel']
DEFAULT_TESTS = UI_TESTS + NONUI_TESTS
DEFAULT_SHORT_TESTS = ['download', 'webpages', 'video']
self.short = short
if test_groups is None:
if self.short:
test_groups = DEFAULT_SHORT_TESTS
else:
test_groups = DEFAULT_TESTS
logging.info('Test groups to run: %s', ', '.join(test_groups))
self._backlight = power_utils.Backlight()
self._backlight.set_default()
measurements = \
[power_status.SystemPower(self._power_status.battery_path)]
if power_utils.has_rapl_support():
measurements += power_rapl.create_rapl()
self._plog = power_status.PowerLogger(measurements)
self._plog.start()
# Log in.
with chrome.Chrome() as cr:
self._browser = cr.browser
graphics_utils.screen_disable_energy_saving()
# Most of the tests will be running in this tab.
self._tab = cr.browser.tabs[0]
# Verify that we have a functioning browser and local web server.
self._tab.Activate()
self._web_echo("Sanity_test")
self._tab.WaitForDocumentReadyStateToBeComplete()
# Video test must have the data from download test
if ('video' in test_groups):
iv = test_groups.index('video')
if 'download' not in test_groups[:iv]:
msg = '"download" test must run before "video".'
raise error.TestError(msg)
# Run all the test groups
self._run_test_groups(test_groups)
# Wrap up
keyvals = self._plog.calc()
keyvals.update(self._tmp_keyvals)
# Calculate expected battery life time with ChromeVer power draw
idle_name = 'ChromeVer_system_pwr'
if idle_name in keyvals:
hours_life = self.energy_full_design / keyvals[idle_name]
keyvals['hours_battery_ChromeVer'] = hours_life
# Calculate a weighted power draw and battery life time. The weights
# are intended to represent "typical" usage. Some video, some Flash ...
# and most of the time idle.
# see http://www.chromium.org/chromium-os/testing/power-testing
weights = {
'vid400p_h264_system_pwr': 0.1,
# TODO(chromium:309403) re-enable BallsFlex once Flash in
# test-lab understood and re-distribute back to 60/20/10/10.
# 'BallsFlex_system_pwr':0.1,
'BallsDHTML_system_pwr': 0.3,
}
weights[idle_name] = 1 - sum(weights.values())
if set(weights).issubset(set(keyvals)):
p = sum(w * keyvals[k] for (k, w) in weights.items())
keyvals['w_Weighted_system_pwr'] = p
keyvals['hours_battery_Weighted'] = self.energy_full_design / p
self.write_perf_keyval(keyvals)
self._plog.save_results(self.resultsdir)
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 run_once(self, max_run_time=180, percent_charge_to_add=1,
percent_initial_charge_max=None,
percent_target_charge=None,
use_design_charge_capacity=True):
"""
max_run_time: maximum time the test will run for
percent_charge_to_add: percentage of the charge capacity charge to
add. The target charge will be capped at the charge capacity.
percent_initial_charge_max: maxium allowed initial charge.
use_design_charge_capacity: If set, use charge_full_design rather than
charge_full for calculations. charge_full represents
wear-state of battery, vs charge_full_design representing
ideal design state.
"""
time_to_sleep = 60
self._backlight = power_utils.Backlight()
self._backlight.set_percent(0)
self.remaining_time = self.max_run_time = max_run_time
self.charge_full_design = self.status.battery[0].charge_full_design
self.charge_full = self.status.battery[0].charge_full
if use_design_charge_capacity:
self.charge_capacity = self.charge_full_design
else:
self.charge_capacity = self.charge_full
if self.charge_capacity == 0:
raise error.TestError('Failed to determine charge capacity')
self.initial_charge = self.status.battery[0].charge_now
percent_initial_charge = self.initial_charge * 100 / \
self.charge_capacity
if percent_initial_charge_max and percent_initial_charge > \
percent_initial_charge_max:
raise error.TestError('Initial charge (%f) higher than max (%f)'
% (percent_initial_charge, percent_initial_charge_max))
current_charge = self.initial_charge
if percent_target_charge is None:
charge_to_add = self.charge_capacity * \
float(percent_charge_to_add) / 100
target_charge = current_charge + charge_to_add
else:
target_charge = self.charge_capacity * \
float(percent_target_charge) / 100
# trim target_charge if it exceeds charge capacity
if target_charge > self.charge_capacity:
target_charge = self.charge_capacity
logging.info('max_run_time: %d', self.max_run_time)
logging.info('initial_charge: %f', self.initial_charge)
logging.info('target_charge: %f', target_charge)
while self.remaining_time and current_charge < target_charge:
if time_to_sleep > self.remaining_time:
time_to_sleep = self.remaining_time
self.remaining_time -= time_to_sleep
time.sleep(time_to_sleep)
self.status.refresh()
if not self.status.on_ac():
raise error.TestError(
'This test needs to be run with the AC power online')
new_charge = self.status.battery[0].charge_now
logging.info('time_to_sleep: %d', time_to_sleep)
logging.info('charge_added: %f', (new_charge - current_charge))
current_charge = new_charge
logging.info('current_charge: %f', current_charge)
if self.status.battery[0].status == 'Full':
logging.info('Battery full, aborting!')
break
