def __init__(self,
use_backchannel=True,
shutdown_other_devices=True,
modem_pattern=''):
"""
@param use_backchannel: Set up the backchannel that can be used to
communicate with the DUT.
@param shutdown_other_devices: If True, shutdown all devices except
cellular.
@param modem_pattern: Search string used when looking for the modem.
"""
# Tests should use this main loop instead of creating their own.
self.mainloop = dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
self.bus = dbus.SystemBus(mainloop=self.mainloop)
self.shill = None
self.modem_manager = None
self.modem = None
self.modem_path = None
self._backchannel = None
self._modem_pattern = modem_pattern
self._nested = None
self._context_managers = []
if use_backchannel:
self._backchannel = backchannel.Backchannel()
self._context_managers.append(self._backchannel)
if shutdown_other_devices:
self._context_managers.append(
shill_context.AllowedTechnologiesContext(
[shill_proxy.ShillProxy.TECHNOLOGY_CELLULAR]))
def run_once(self, **kwargs):
# Number of connectivity test runs.
self._connect_count = kwargs.get('connect_count', 5)
# Number of seconds to sleep between connect and disconnect operations.
self._sleep_kludge = kwargs.get('sleep_kludge', 5)
# URL pattern to fetch data from during each connectivity test run.
self._fetch_url_pattern = \
kwargs.get('fetch_url_pattern', network.FETCH_URL_PATTERN_FOR_TEST)
# Timeout in seconds for connect and disconnect operations, and
# fetching data from a URL.
self._connect_timeout = kwargs.get('connect_timeout', 10)
self._disconnect_timeout = kwargs.get('disconnect_timeout', 10)
self._fetch_timeout = kwargs.get('fetch_timeout', 120)
# Number of bytes to fetch during each connectivity test run.
self._bytes_to_fetch = kwargs.get('bytes_to_fetch', 64 * 1024)
with backchannel.Backchannel():
with cell_tools.OtherDeviceShutdownContext('wimax'):
# TODO(benchan): Replace FlimFlam with ShillProxy.
self._flim = flimflam.FlimFlam()
self._flim.SetDebugTags(SHILL_LOG_SCOPES)
self._service = self._flim.FindWimaxService()
if not self._service:
raise error.TestError('Could not find a WiMAX service.')
with shill_context.ServiceAutoConnectContext(
self._flim.FindWimaxService, False):
self._disconnect_service()
for _ in xrange(self._connect_count):
self._test_connectivity()
def _run_group_backchannel(self):
"""WiFi sub-tests."""
wifi_ap = 'GoogleGuest'
wifi_sec = 'none'
wifi_pw = ''
flim = flimflam.FlimFlam()
conn = flim.ConnectService(retries=3,
retry=True,
service_type='wifi',
ssid=wifi_ap,
security=wifi_sec,
passphrase=wifi_pw,
mode='managed')
if not conn[0]:
logging.error("Could not connect to WiFi")
return
logging.info('Starting Backchannel')
with backchannel.Backchannel():
# Wifi needs some time to recover after backchanel is activated
# TODO (kamrik) remove this sleep, once backchannel handles this
time.sleep(15)
cmd = 'ping -c %s www.google.com' % (self._duration_secs)
self._run_cmd('ping_wifi', cmd)
# This URL must be visible from WiFi network used for test
big_file_url = ('http://googleappengine.googlecode.com'
'/files/GoogleAppEngine-1.6.2.msi')
cmd = 'curl %s > /dev/null' % big_file_url
self._run_cmd('download_wifi', cmd, repeat=self._repeats)
def __init__(self,
use_backchannel=True,
shutdown_other_devices=True,
modem_pattern=''):
"""
@param use_backchannel: Set up the backchannel that can be used to
communicate with the DUT.
@param shutdown_other_devices: If True, shutdown all devices except
cellular.
@param modem_pattern: Search string used when looking for the modem.
"""
# Tests should use this main loop instead of creating their own.
self.mainloop = dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
self.bus = dbus.SystemBus(mainloop=self.mainloop)
self.shill = None
self.flim = None # Only use this for legacy tests.
self.modem_manager = None
self.modem = None
self.modem_path = None
self._backchannel = None
self._modem_pattern = modem_pattern
self._nested = None
self._context_managers = []
if use_backchannel:
self._backchannel = backchannel.Backchannel()
self._context_managers.append(self._backchannel)
if shutdown_other_devices:
self._context_managers.append(
cell_tools.OtherDeviceShutdownContext('cellular'))
def __init__(self, config):
self._nested = contextlib.nested(
backchannel.Backchannel(),
cell_tools.OtherDeviceShutdownContext('cellular'),
Environment(config))
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
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='',
kblight_percent=10,
volume_level=10,
mic_gain=10,
low_batt_margin_p=2,
ac_ok=False,
log_mem_bandwidth=False):
"""
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
kblight_percent: percent brightness of keyboard backlight
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
"""
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 = power_status.get_status()
self._tmp_keyvals['b_on_ac'] = self._power_status.on_ac()
self._force_wifi = force_wifi
self._testServer = None
self._tasks = tasks.replace(' ', '')
self._backchannel = None
self._shill_proxy = None
self._kblight_percent = kblight_percent
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)
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()
(self._sys_low_batt_p, self._sys_low_batt_s) = \
self._get_sys_low_batt_values()
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
