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 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 = \
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, idle_time=120, sleep=10, bt_warmup_time=20):
"""Collect power stats when bluetooth adapter is on or off.
"""
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_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=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('bluetooth_adapter_off', self._start_time)
self._tlog.checkpoint('', self._start_time)
self._psr.refresh()
# Turn on bluetooth adapter.
bt_device = bluetooth_device_xmlrpc_server \
.BluetoothDeviceXmlRpcDelegate()
# If we cannot start bluetoothd, fail gracefully and still write
# data with bluetooth adapter off to file, as we are interested in
# just that data too. start_bluetoothd() already logs the error so
# not logging any error here.
if not bt_device.start_bluetoothd():
return
if not bt_device.set_powered(True):
logging.warning("Cannot turn on bluetooth adapter.")
return
time.sleep(bt_warmup_time)
if not bt_device._is_powered_on():
logging.warning("Bluetooth adapter is off.")
return
t1 = time.time()
time.sleep(idle_time)
self._plog.checkpoint('bluetooth_adapter_on', t1)
bt_device.set_powered(False)
bt_device.stop_bluetoothd()
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 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 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 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 test_power(self):
"""
Runs the video power consumption test.
@return a dictionary that contains the test result.
"""
self._backlight = power_utils.Backlight()
self._backlight.set_level(0)
self._power_status = power_status.get_status()
self._use_ec = True
if not power_utils.charge_control_by_ectool(is_charge=False):
logging.warning('Can\'t stop charging')
return {}
if not self._power_status.battery:
raise error.TestFail('No valid battery')
# Verify that the battery is sufficiently charged.
percent_initial_charge = self._power_status.percent_current_charge()
if percent_initial_charge < BATTERY_INITIAL_CHARGED_MIN:
logging.warning(
'Initial charge (%f) less than min (%f)',
(percent_initial_charge, BATTERY_INITIAL_CHARGED_MIN))
return {}
measurements = [
power_status.SystemPower(self._power_status.battery_path)
]
def get_power():
power_logger = power_status.PowerLogger(measurements)
power_logger.start()
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_avg']
return self.test_decode(get_power)
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_backlight(self, backlight_level):
"""
Get the actual backlight percentage and compare it to the set policy.
Note: There is a slight difference between the computed on the reported
brightness. This is likely due floating point math differences between
the implemented formula on the DUT, and the one used here. Because
of this, a half percent tolerace is added.
@param backlight_level: int or float, UI brightness settings.
"""
self._backlight = power_utils.Backlight()
actual_percent = self._backlight.get_percent()
set_percent = self._convert_power_percent(backlight_level)
if abs(actual_percent - set_percent) > 0.5:
raise error.TestError(
"Screen brightness incorrect ({}) when it should be {}".format(
set_percent, actual_percent))
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 postprocess_iteration(self):
"""Write power stats to file.
"""
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
plog_keyvals = self._plog.calc()
self._publish_chromeperf_dashboard(plog_keyvals)
keyvals.update(plog_keyvals)
keyvals.update(self._tlog.calc())
keyvals.update(self._psr.get_keyvals())
logging.debug("keyvals = %s", keyvals)
self.write_perf_keyval(keyvals)
pdash = power_dashboard.PowerLoggerDashboard(self._plog,
self.tagged_testname,
self.resultsdir)
pdash.upload()
def __enter__(self):
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(johnylin): remove this workaround after AC control is stable
# crbug.com/914211
if status.on_ac():
logging.warning('Still powered by AC. Skip this test')
raise error.TestNAError('Unable to disable AC.')
# Verify that we are running on battery and the battery is sufficiently
# charged.
status.assert_battery_state(BATTERY_INITIAL_CHARGED_MIN)
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._system_power = power_status.SystemPower(status.battery_path)
self._power_logger = power_status.PowerLogger([self._system_power])
return self
def run_once(self, resume_percent=70, suspend_state='mem'):
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=10, state=suspend_state)
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,
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
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=None,
force_discharge=False, pdash_note=''):
"""
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: whether real GAIA login should be attempted. If 'None'
(default) then boolean is determined from URL.
force_discharge: boolean of whether to tell ec to discharge battery even
when the charger is plugged in.
pdash_note: note of the current run to send to power dashboard.
"""
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._force_discharge = force_discharge
self._pdash_note = pdash_note
if not power_utils.has_battery():
if ac_ok and (power_utils.has_powercap_support() or
power_utils.has_rapl_support()):
logging.info("Device has no battery but has powercap data.")
else:
rsp = "Skipping test for device without battery and powercap."
raise error.TestNAError(rsp)
self._power_status = power_status.get_status()
self._tmp_keyvals['b_on_ac'] = self._power_status.on_ac()
self._gaia_login = gaia_login
if gaia_login is None:
self._gaia_login = power_load_util.use_gaia_login()
self._username = power_load_util.get_username()
self._password = power_load_util.get_password()
if not ac_ok:
self._power_status.assert_battery_state(percent_initial_charge_min)
if force_discharge:
if not power_utils.charge_control_by_ectool(False):
raise error.TestError('Could not run battery force discharge.')
# 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.
ifaces = [ iface for iface in interface.get_interfaces()
if (not iface.is_wifi_device() and
iface.name.startswith('eth')) ]
logging.debug(str([iface.name for iface in ifaces]))
for iface in ifaces:
if check_network and iface.is_lower_up:
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()
self._detachable_handler = power_utils.BaseActivitySimulator()
# 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()
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'))
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
if self._power_status.battery:
self._ah_charge_start = self._power_status.battery[0].charge_now
self._wh_energy_start = self._power_status.battery[0].energy
