def test_CellularSmokeNoCallBoxSetup(self): self._reset_everything() logger.debug('making flimflam object..') self.flim = flimflam.FlimFlam() logger.debug('Find Cellular Device ...') self.device = self.flim.FindCellularDevice() logger.debug('Find Celluar Service..') self.service = self.flim.FindCellularService() logger.debug('Set Auto Connect to False ..') self.service.SetProperty('AutoConnect', dbus.Boolean(False)) logger.debug('Reset all modems ..') network.ResetAllModems(self.flim) logger.debug('Prepare Modem for LTE..') cell_tools.PrepareModemForTechnology('', 'Technology:LTE') logger.debug('Make another flimflam..') self.flim = flimflam.FlimFlam() logger.debug('Sleep for 5...') time.sleep(5) logger.debug('Connect to Cellular...') cell_tools.ConnectToCellular(self.flim, timeout=60) logger.debug('Clearing errors...') env.emulator.ClearErrors() logger.debug('Check connect to cellular ...') service = env.CheckedConnectToCellular()
def test_TurnOnPxtAndConnectToCellularWorks(self): self._reset_everything() self.flim = flimflam.FlimFlam() #self.device = self.flim.FindCellularDevice() self.service = self.flim.FindCellularService() self.service.SetProperty('AutoConnect', dbus.Boolean(False)) with environment.DefaultCellularTestContext(config) as c: env = c.env env.StartDefault(technology_lte) self.flim = flimflam.FlimFlam() # because the manger destroys it? cell_tools.ConnectToCellular(self.flim, timeout=60)
def run_once(self, config, technology): # The DefaultCellularTestContext builds: # * a backchannel ethernet context. This makes a virtual # device that connects the DUT to the test infrastructure. # It has restrictive routes and is outside of flimflam's # control. This makes the tests resilient to flimflam # restarts and helps to ensure that the test is actually # sending traffic on the cellular link # * an OtherDeviceShutdownContext, which shuts down other # network devices on the host. Again, this is to ensure # that test traffic goes over the modem # * A cellular test environment context, which lets us # interact with the cell network. with environment.DefaultCellularTestContext(config) as c: env = c.env flim = flimflam.FlimFlam() env.StartDefault(technology) network.ResetAllModems(flim) cell_tools.PrepareModemForTechnology('', technology) # TODO(rochberg) Need to figure out what isn't settling here. # Going to wait 'til after ResetAllModems changes land. time.sleep(10) # Clear all errors before we start. # Resetting the modem above may have caused some errors on the # 8960 (eg. lost connection, etc). env.emulator.ClearErrors() service = env.CheckedConnectToCellular() env.CheckHttpConnectivity() env.CheckedDisconnectFromCellular(service)
def init_flimflam(self): # Initialize flimflam and device type specific functions. self.flim = flimflam.FlimFlam(dbus.SystemBus()) self.flim.SetDebugTags(SHILL_LOG_SCOPES) self.flim.FindCellularService = self.flim.FindCellularService self.flim.FindCellularDevice = self.flim.FindCellularDevice
def run_once(self, name='wwan', loops=20, seed=None): dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) self.bus = dbus.SystemBus() main_loop = gobject.MainLoop() modem_path = self.FindModemPath() if not modem_path: raise error.TestFail('No Gobi modem found.') print 'Modem: %s' % (modem_path, ) self.RequestDormancyEvents(modem_path) flim = flimflam.FlimFlam() device = flim.FindElementByNameSubstring('Device', name) if not device: device = flim.FindElementByPropertySubstring( 'Device', 'Interface', name) self.bus.add_signal_receiver(self.PropertyChanged, signal_name='PropertyChanged') self.bus.add_signal_receiver(self.DormancyStatus, signal_name='DormancyStatus') self.tester = DormancyTester(main_loop=main_loop, loops=loops, flim=flim, device=device) self.tester.run()
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 run_once(self, config, technology): with environment.DefaultCellularTestContext(config) as c: env = c.env flim = flimflam.FlimFlam() env.StartDefault(technology) network.ResetAllModems(flim) cell_tools.PrepareModemForTechnology('', technology) # TODO(rochberg): Figure out why this is necessary time.sleep(10) # Clear all errors before we start. # Resetting the modem above may have caused some errors on the # 8960 (eg. lost connection, etc). env.emulator.ClearErrors() service = env.CheckedConnectToCellular() # TODO(rochberg): Factor this and the counts stuff out # so that individual tests don't have to care. env.emulator.LogStats() env.emulator.ResetDataCounters() perf = http_speed.HttpSpeed( env.config.cell['perfserver']['download_url_format_string'], env.config.cell['perfserver']['upload_url']) # TODO(rochberg): Can/should we these values into the # write_perf_keyval dictionary? Now we just log them. env.emulator.GetDataCounters() env.CheckedDisconnectFromCellular(service) self.write_perf_keyval(perf)
def __init__(self, logdir, method=sys_power.do_suspend, throw=False, device_times=False, suspend_state=''): """ Prepare environment for suspending. @param suspend_state: Suspend state to enter into. It can be 'mem' or 'freeze' or an empty string. If the suspend state is an empty string, system suspends to the default pref. """ self.disconnect_3G_time = 0 self.successes = [] self.failures = [] self._logdir = logdir self._suspend = method self._throw = throw self._reset_pm_print_times = False self._restart_tlsdated = False self._log_file = None self._suspend_state = suspend_state if device_times: self.device_times = [] # stop tlsdated, make sure we/hwclock have /dev/rtc for ourselves if utils.system_output('initctl status tlsdated').find('start') != -1: utils.system('initctl stop tlsdated') self._restart_tlsdated = True # give process's file descriptors time to asynchronously tear down time.sleep(0.1) # prime powerd_suspend RTC timestamp saving and make sure hwclock works utils.open_write_close(self.HWCLOCK_FILE, '') hwclock_output = utils.system_output('hwclock -r --debug --utc', ignore_status=True) if not re.search('Using.*/dev interface to.*clock', hwclock_output): raise error.TestError('hwclock cannot find rtc: ' + hwclock_output) # activate device suspend timing debug output if hasattr(self, 'device_times'): if not int(utils.read_one_line('/sys/power/pm_print_times')): self._set_pm_print_times(True) self._reset_pm_print_times = True # Shut down 3G to remove its variability from suspend time measurements flim = flimflam.FlimFlam() service = flim.FindCellularService(0) if service: logging.info('Found 3G interface, disconnecting.') start_time = time.time() (success, status) = flim.DisconnectService( service=service, wait_timeout=60) if success: logging.info('3G disconnected successfully.') self.disconnect_3G_time = time.time() - start_time else: logging.error('Could not disconnect: %s.', status) self.disconnect_3G_time = -1 self._configure_suspend_state()
def test_TurnOnPxtAndConnectToCellularWorksAddSmoke(self): self._reset_everything() self.flim = flimflam.FlimFlam() #self.device = self.flim.FindCellularDevice() self.service = self.flim.FindCellularService() self.service.SetProperty('AutoConnect', dbus.Boolean(False)) with environment.DefaultCellularTestContext(config) as c: env = c.env env.StartDefault(technology_lte) cell_tools.PrepareModemForTechnology('', technology_lte) self.flim = flimflam.FlimFlam() # because the manger destroys it? #network.ResetAllModems(self.flim) self.flim = flimflam.FlimFlam() # because the manger destroys it? cell_tools.ConnectToCellular(self.flim, timeout=60) env.emulator.ClearErrors() service = env.CheckedConnectToCellular() #env.CheckHttpConnectivity() env.CheckedDisconnectFromCellular(service)
def _initialize_shill(self): """Get access to shill.""" # CellularProxy.get_proxy() checks to see if shill is running and # responding to DBus requests. It returns None if that's not the case. self.shill = cellular_proxy.CellularProxy.get_proxy(self.bus) if self.shill is None: raise error.TestError('Cannot connect to shill, is shill running?') # Keep this around to support older tests that haven't migrated to # cellular_proxy. self.flim = flimflam.FlimFlam()
def init_flimflam(self, device_type): # Initialize flimflam and device type specific functions. self.flim = flimflam.FlimFlam(dbus.SystemBus()) self.flim.SetDebugTags(SHILL_LOG_SCOPES) logging.debug('Using device type: %s' % device_type) if device_type == flimflam.FlimFlam.DEVICE_WIMAX: self.FindMobileService = self.flim.FindWimaxService self.FindMobileDevice = self.flim.FindWimaxDevice self.modem_status = self._skip_modem_status self.connect_mobile_service = self.connect_wimax elif device_type == flimflam.FlimFlam.DEVICE_CELLULAR: self.FindMobileService = self.flim.FindCellularService self.FindMobileDevice = self.flim.FindCellularDevice self.modem_status = self._get_modem_status self.connect_mobile_service = self.flim.ConnectService else: raise error.TestError('Device type %s not supported yet.' % device_type)
def __enter__(self): self.device_manager = flimflam.DeviceManager(flimflam.FlimFlam()) self.device_manager.ShutdownAllExcept(self.device_type) return self
def __enter__(self): self.flim = flimflam.FlimFlam() return self
def run_once(self, config, technologies, wait_for_disc, verify_set_power): # This test only works if all the technologies are in the same # family. Check that before doing anything else. families = set( cellular.TechnologyToFamily[tech] for tech in technologies) if len(families) > 1: raise error.TestError('Specify only one family not: %s' % families) # choose a technology other than the one we plan to start with technology = technologies[-1] with environment.DefaultCellularTestContext(config) as c: env = c.env flim = flimflam.FlimFlam() flim.SetDebugTags('manager+device+modem') env.StartDefault(technology) network.ResetAllModems(flim) logging.info('Preparing for %s' % technology) cell_tools.PrepareModemForTechnology('', technology) # TODO(jglasgow) Need to figure out what isn't settling here. # Going to wait 'til after ResetAllModems changes land. time.sleep(10) # Clear all errors before we start. # Resetting the modem above may have caused some errors on the # 8960 (eg. lost connection, etc). env.emulator.ClearErrors() service = env.CheckedConnectToCellular(timeout=CELLULAR_TIMEOUT) # Step through all technologies, forcing a transition failed_technologies = [] manager, modem_path = mm.PickOneModem('') cell_modem = manager.GetModem(modem_path) for tech in technologies: tname = str(tech).replace('Technology:', '') if verify_set_power: logging.info('Powering off basestation') env.emulator.SetPower(cellular.Power.OFF) self.TimedPollForCondition( 'Power.OFF.%s.deregister_time' % tname, lambda: not cell_modem.ModemIsRegistered(), timeout=CELLULAR_TIMEOUT, exception=_STILL_REGISTERED_ERROR) logging.info('Powering on basestation') env.emulator.SetPower(cellular.Power.DEFAULT) self.TimedPollForCondition( 'Power.DEFAULT.%s.register_time' % tname, lambda: cell_modem.ModemIsRegistered(), timeout=CELLULAR_TIMEOUT, exception=_NOT_REGISTERED_ERROR) logging.info('Stopping basestation') env.emulator.Stop() if wait_for_disc: self.TimedPollForCondition( 'Stop.%s.deregister_time' % tname, lambda: not cell_modem.ModemIsRegistered(), timeout=CELLULAR_TIMEOUT, exception=_STILL_REGISTERED_ERROR) logging.info('Reconfiguring for %s' % tech) env.emulator.SetTechnology(tech) env.emulator.Start() try: self.TimedPollForCondition( 'Start.%s.register_time' % tname, lambda: cell_modem.ModemIsRegisteredUsing(tech), timeout=CELLULAR_TIMEOUT, exception=_WrongTech(tech)) except _WrongTech, wt: failed_technologies.append( (wt.technology, cell_modem.GetAccessTechnology()))