def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) self._trigger_dfs() return Global.SUCCESS, "No errors"
def run_test(self): """ Run test """ LabWifiBase.run_test(self) LabWifiKPIBase.run_test(self) self._networking_api.set_wifi_power("off") time.sleep(self._wait_btwn_cmd) # Start log monitoring self._networking_api.start_wifi_connection_log() self._networking_api.set_wifi_power("on") # Get the log and trigger it ! time_to_reconnect = self.__check_logs_and_compute_time() if time_to_reconnect > self._time_target: msg = "Reconnection time too long : %ss. Expected : %ss" % ( time_to_reconnect, self._time_target) self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) return_msg = "No errors - Time to connect : %ss - Target : %ss" % ( time_to_reconnect, self._time_target) return Global.SUCCESS, return_msg
def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) # Start log monitoring self._networking_api.start_wifi_connection_log() # Try to connect to the WiFi network self._networking_api.wifi_connect(self._ssid, self._connection_expected) # Control the connection status connection_status = self._networking_api.\ get_wifi_connection_status_log(self._ssid) self._logger.info("Connection log read: %s" % connection_status) if self._connection_expected and connection_status != "SUCCESS": msg = "Unable to connect to channel %s while DUT CRDA is %s" \ % (str(self._channel), self._dut_crda) self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) if not self._connection_expected and connection_status == "SUCCESS": # disconnect self._networking_api.wifi_disconnect(self._ssid) # Raise an Error msg = "Successfully connected to channel %s while DUT CRDA is %s" \ % (str(self._channel), self._dut_crda) self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) # Specific case for channel 14 in Japan if int(self._channel) == 14 and self._dut_crda == "JP" \ and self._standard.lower() != "b": # Check connection rate corresponds to B standard (11 MByte/s) connection_rate = self._networking_api.\ get_wifi_connection_rate(self._dut_wlan_iface) self._logger.info("Connection rate: %d MB/s" % connection_rate) if connection_rate != self.__CONNECTION_RATE_FOR_B_STANDARD: msg = "Channel 14 in Japan connection rate test failed." msg += " connection_rate read: " + str(connection_rate) self._logger.error(msg) # Disconnect WiFi self._networking_api.wifi_disconnect(self._ssid) raise DeviceException(DeviceException.OPERATION_FAILED, msg) # Disconnect WiFi if self._connection_expected: self._networking_api.wifi_disconnect(self._ssid) return Global.SUCCESS, "no_error"
def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) # Open the browser and load the url before timeout self._test_web_browsing(self._website_url, self._browser_type, self._webpage_loading_timeout) return Global.SUCCESS, "No error"
def run_test(self): """ Execute the test """ # Call LAB_WIFI_BASE Run function LabWifiBase.run_test(self) time.sleep(self._wait_btwn_cmd) # Run Iperf command throughput = self._networking_api.iperf(self._iperf_settings) # Compute verdict depending on throughputs return compute_iperf_verdict(throughput, self._throughput_targets, self._direction)
def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) # Wifi disconnection self._networking_api.wifi_remove_config(self._ssid) self._logger.info("Waiting %s seconds" % str(self._time2wait)) time.sleep(self._time2wait) # Start log monitoring self._networking_api.start_wifi_connection_log() # Try to connect with the wrong passphrase self._networking_api.set_wificonfiguration( self._ssid, self._wrong_passphrase, self._security, self._ip_setting, self._ip_address, self._netmask, self._gateway, self._dns1, self._dns2) self._networking_api.wifi_connect(self._ssid, False) # Control the connection status connection_status = self._networking_api.\ get_wifi_connection_status_log(self._ssid) self._logger.info("Connection log read: %s" % connection_status) if connection_status != "FAILURE": msg = "Unable to retrieve connection failure information from log" raise DeviceException(DeviceException.OPERATION_FAILED, msg) # Wifi disconnection self._networking_api.wifi_remove_config(self._ssid) self._logger.info("Waiting %s seconds" % str(self._time2wait)) time.sleep(self._time2wait) # Now try to connect with the real passphrase # Start log monitoring self._networking_api.start_wifi_connection_log() self._networking_api.set_wificonfiguration( self._ssid, self._passphrase, self._security, self._ip_setting, self._ip_address, self._netmask, self._gateway, self._dns1, self._dns2) self._networking_api.wifi_connect(self._ssid, True) # Control the connection status connection_status = self._networking_api.\ get_wifi_connection_status_log(self._ssid) self._logger.info("Connection log read: %s" % connection_status) return Global.SUCCESS, "no_error"
def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) # Wait for the Wifi to sleep self._logger.info("Waiting %s sec for Wifi to sleep" % self._time_before_wifi_sleep) time.sleep(self._time_before_wifi_sleep) self._logger.info("Wifi should have gone to sleep") # Checks that Wifi is well entered into sleep mode try: packet_loss = self._networking_api.ping(self._wifirouter_ip, self._packetsize, self._count) except AcsBaseException as e: if "Network is unreachable" in e.get_error_message(): # Then the Exception has been raised # because of a ping connection failure packet_loss = Measure() packet_loss.value = 100 packet_loss.units = "%" else: raise e if packet_loss.value < self._lossrate_disconnected: msg = "Wifi did not manage to enter sleep mode: %s packet loss" \ % str(packet_loss.value) self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) # Wake up the screen self._phone_system_api.display_on() time.sleep(6 * self._wait_btwn_cmd) self._phone_system_api.display_off() # Check WIFI connection by pinging Wifi AP packet_loss = self._networking_api.ping(self._wifirouter_ip, self._packetsize, self._count) if packet_loss.value > self._lossrate_connection_ok: msg = "Wifi did not manage to wakes up: %s packet loss" \ % str(packet_loss.value) self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) return Global.SUCCESS, "No errors"
def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) # Reconnect only if needed (B2B continuous mode = True) if self._is_wifi_already_connected is not True: self._networking_api.set_wificonfiguration( self._ssid, self._passphrase, self._security, self._ip_setting, self._ip_address, self._netmask, self._gateway, self._dns1, self._dns2) self._networking_api.wifi_connect(self._ssid) # Check connection to the SSID self._networking_api.check_connection_state(self._ssid) # Check Wifi connection is available packetloss = self._networking_api.ping(self._wifirouter_ip, self._packetsize, self._packnb) if packetloss.value > self._lossrate: msg = "Fail to recover Wifi connection after enabling WiFi interface " + \ "(ping NOK: %s%% packet loss)" % str(packetloss.value) self._logger.error(msg) raise DeviceException(DeviceException.PROHIBITIVE_MEASURE, msg) # Forget AP SSID self._networking_api.wifi_remove_config(self._ssid) self._is_wifi_already_connected = False time.sleep(self.WAITING_TIME) # Check if SSID is remembered connected_wifi_list = self._networking_api.list_connected_wifi() if self._ssid in connected_wifi_list: msg = "WiFi is connected to %s network and it shouldn't!" % self._ssid self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) # Confirm connection is still possible self._networking_api.set_wificonfiguration( self._ssid, self._passphrase, self._security, self._ip_setting, self._ip_address, self._netmask, self._gateway, self._dns1, self._dns2) self._networking_api.wifi_connect(self._ssid, True) self._is_wifi_already_connected = True return Global.SUCCESS, "No errors"
def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) # Enable Wifi self._networking_api.set_wifi_power("on") time.sleep(self._registration_waiting_time) # Ping Wifi server self.__ping_server(self._wifirouter_ip, "Wifi network") # Disable Wifi self._networking_api.set_wifi_power("off") time.sleep(self._registration_waiting_time) # Ping Live server self.__ping_server(self._live_server, "Cellular network") return Global.SUCCESS, "No errors"
def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) # Ensure the AP configuration is correct and connect the DUT to the AP if not self.__1st_iteration: if self._bandwidth == "40": # Restore the Bandwidth to 40 MHz self._set_ap_bandwidth('40', False) if self._wifi_mimo: # Restore MIMO activation on AP self._set_ap_mimo(True, False) else: self.__1st_iteration = False # Connect the DUT to AP with connection check if specific feature(s) is(are) enabled (40MHz, MIMO) self._wifi_connect_dut() # Run the FTP tranfer with the parameters extracted from the XML TC file ftp_result = self._launch_ftp_transfer() # Retrieve the FTP throughput throughput = re.findall(self._FTP_THROUGHTPUT_PARSING_PATTERN, ftp_result[1]) if len(throughput) > 0: throughput = int(throughput[0]) else: throughput = -1 # If enhanced features (like 40MHz and/or MIMO) are activated, # we need to compare throughput without these features self._check_enhanced_features(throughput) # Disconnect DUT from AP self._networking_api.wifi_disconnect(self._ssid) return ftp_result
def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) # Disable SSID self._ns.init() try: self._ns.disable_wireless() finally: self._ns.release() # Check Wifi is lost try: packetloss = self._networking_api.ping(self._wifirouter_ip, self._packetsize, self._packnb, source_address=self.__dut_ip_adr) except AcsBaseException as e: if "Network is unreachable" in e.get_error_message(): # Then the Exception has been raised # because of a ping connection failure packetloss = Measure() packetloss.value = 100 packetloss.units = "%" else: self._logger.error("Ping command fails: " + e.get_error_message()) raise e if packetloss.value < self._lossrate_disconnected: msg = "Wifi connection still established (ping OK)" self._logger.error(msg) raise DeviceException(DeviceException.PROHIBITIVE_MEASURE, msg) # Enable SSID self._ns.init() try: self._ns.enable_wireless() finally: self._ns.release() init_timer = time.time() ping_continue = True while ping_continue: self._logger.debug("Wait " + str(self._wifi_reconnection_time) + "s to reconnect before ping") time.sleep(self._wifi_reconnection_time) # Check Wifi connection is back try: packetloss = self._networking_api.ping(self._wifirouter_ip, self._packetsize, self._packnb) except AcsBaseException as e: if "Network is unreachable" in e.get_error_message(): packetloss = Measure() packetloss.value = 100 packetloss.units = "%" else: self._logger.error("Ping command fails: " + e.get_error_message()) raise e if packetloss.value > self._lossrate: msg = "Fail to recover Wifi connection after loss of coverage " \ + "(ping NOK: %s%% packet loss)" % str(packetloss.value) self._logger.warning(msg) if (time.time() - init_timer) > 180: self._logger.error("Reconnection time > 3min") raise DeviceException(DeviceException.PROHIBITIVE_MEASURE, msg) else: ping_continue = False return Global.SUCCESS, "No errors"
def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) # Put display on and off to avoid scan failure. self._phone_system_api.display_on() time.sleep(self._wait_btwn_cmd) self._phone_system_api.display_off() self._logger.info("Ping direction : " + self._direction) for ip_to_ping in self._all_ip_to_ping: if self._direction == "UL": # ping from DUT to Server self._logger.info("Ping address " + str(ip_to_ping) + " with " + str(self._count) + " packets of " + str(self._packetsize) + " bytes...") packet_loss = self._networking_api.ping( ip_to_ping, self._packetsize, self._count, source_address=self._dut_ip) elif self._direction == "DL": # ping from Server to DUT self._logger.info("Ping address " + str(ip_to_ping) + " with " + str(self._count) + " packets of " + str(self._packetsize) + " bytes...") packet_loss = self._computer.ping(ip_to_ping, self._packetsize, self._count) else: msg = "%s is not a valid xfer direction" % self._direction self._logger.error(msg) raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg) msg = "Measured Packet Loss: %.0f%s (Target: %.0f%s)" \ % (packet_loss.value, packet_loss.units, self._target_ping_packet_loss_rate, packet_loss.units) self._logger.info(msg) # Compute verdict depending on % of packet loss if not self._key_exchange_should_fail: if packet_loss.value > self._target_ping_packet_loss_rate: msg = "Ping packet loss is not acceptable [%s]" \ % str(packet_loss.value) self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) else: if ip_to_ping != '0.0.0.0': if packet_loss.value < 100: msg = "Ping packet loss is too low [%s]" \ % str(packet_loss.value) self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) if self._waiting_time > 0: self._logger.info("Waiting for %s sec" % str(self._waiting_time)) time.sleep(self._waiting_time) return Global.SUCCESS, "No errors"
def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) # push a script that will run the test in adb disconnected mode self._networking_api.usb_tether(self._wifi_off, self._unplug_usb, self._use_flight_mode) # Disconnect ADB self._device.disconnect_board() self._disconnected = True time.sleep(10) start_time = time.time() # Tethering should have now started on DUT, wait for USB interface to come up # pylint: disable=W0612 ip, self._hotspot_ip = self._computer.dhclient( self._computer.get_usb_interface()) # USB is now tethered # remove temporarily existing route for the same network self._destination, self._netmask, self._iface = \ self._computer.change_route(self._network, self._hotspot_ip) self._changedroute = True # Ping the Access Point behind the tethered USB hotspot packet_loss = self._computer.ping(self._wifirouter_ip, self._packetsize, self._count) self._logger.info("Packet loss: %s%s" % (packet_loss.value, packet_loss.units)) if packet_loss.value > self._target_ping_packet_loss_rate: msg = "Could not ping AP through interface usb0" self._logger.error(msg) time.sleep(90) # need to wait for the DUT script to end raise DeviceException(DeviceException.OPERATION_FAILED, msg) # wait for up to 60 seconds after starting DUT script sleep_time = 60 - (time.time() - start_time) if sleep_time > 0: time.sleep(sleep_time) if self._unplug_usb: self._io_card.usb_host_pc_connector(False) self._unplugged = True time.sleep(10) start_time = time.time() # try to ping again, this should fail packet_loss = self._computer.ping(self._wifirouter_ip, self._packetsize, self._count) self._logger.info("Packet loss: %s%s" % (packet_loss.value, packet_loss.units)) if packet_loss.value != 100: msg = "Ping AP through interface usb0 successful after USB unplugged" self._logger.error(msg) time.sleep(60) # need to wait for the DUT script to end raise DeviceException(DeviceException.OPERATION_FAILED, msg) # plug USB self._io_card.usb_host_pc_connector(True) self._unplugged = False # wait x seconds time.sleep(self._device.get_usb_sleep_duration()) # wait for DUT to complete script... sleep_time = 30 - (time.time() - start_time) if sleep_time > 0: time.sleep(sleep_time) # wait for USB interface to come up, this should fail ! try: self._computer.dhclient(self._computer.get_usb_interface()) msg = "Interface usb0 incorrectly still tethered" self._logger.error(msg) time.sleep(30) # need to wait for the DUT script to end raise DeviceException(DeviceException.OPERATION_FAILED, msg) except TestEquipmentException as e: if not "Could not get IP address" in str(e): raise elif not self._use_flight_mode or self._wifi_off: # wait for DUT to activate flight_mode/turn off wifi... start_time = time.time() # try to ping again, this should fail packet_loss = self._computer.ping(self._wifirouter_ip, self._packetsize, self._count) self._logger.info("Packet loss: %s%s" % (packet_loss.value, packet_loss.units)) if packet_loss.value != 100: msg = "Ping AP through interface usb0 successful" if self._wifi_off: msg += " after turning wifi off" else: msg += " after enabling flight mode" self._logger.error(msg) time.sleep(60) # need to wait for the DUT script to end raise DeviceException(DeviceException.OPERATION_FAILED, msg) # wait for DUT to deactivate flight_mode/turn on wifi... sleep_time = 30 - (time.time() - start_time) if sleep_time > 0: time.sleep(sleep_time) # Ping the Access Point packet_loss = self._computer.ping(self._wifirouter_ip, self._packetsize, self._count) self._logger.info("Packet loss: %s%s" % (packet_loss.value, packet_loss.units)) if packet_loss.value > self._target_ping_packet_loss_rate: msg = "Could not ping AP through interface usb0" self._logger.error(msg) time.sleep(30) # need to wait for the DUT script to end raise DeviceException(DeviceException.OPERATION_FAILED, msg) # wait 30 seconds more for DUT to deactivate tethering time.sleep(30) self._device.connect_board() self._disconnected = False if self._changedroute: # restore original route self._computer.restore_route(self._network, self._hotspot_ip, self._destination, self._netmask, self._iface) self._changedroute = False return Global.SUCCESS, "No error"
def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) self._networking_api.check_connection_state(self._ssid) if self._direction == "DL": msg = "FTP transfer " + str(self._direction) + " for " + str( self._dlfilename) + "..." filename = self._dlfilename elif self._direction == "UL": msg = "FTP transfer " + str(self._direction) + " for " + str( self._ulfilename) + "..." filename = self._ulfilename else: msg = "%s is not a known xfer direction" % self._direction raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg) self._logger.info(msg) task_id = self._networking_api.start_ftp_xfer( self._direction, self._ftp_ip_address, self._ftp_username, self._ftp_password, filename, self._device.get_ftpdir_path()) start = time.time() # trigger DFS on AP while FTP Transfer is being done. self._trigger_dfs() # check that DUT was able to connect after DFS trigger self._networking_api.check_connection_state(self._ssid) # Check FTP transfer is still ongoing ftp_status = self._networking_api.get_ftp_xfer_status() if ftp_status != self._networking_api.FTP_TRANSFERRING: if self._networking_api.is_ftp_xfer_success( filename, self._direction, task_id): msg = "File has already been transferred. Please use a bigger file for this test!" # End the transfer self._networking_api.stop_ftp_xfer(task_id) self._logger.error(msg) raise AcsConfigException(AcsConfigException.OPERATION_FAILED, msg) else: msg = "FTP transfer STOPS while switching channel, ftp status=%s. " % str( ftp_status) # End the transfer self._networking_api.stop_ftp_xfer(task_id) self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) # Wait for the FTP transfer to end. while start + self._xfer_timeout > time.time( ) and ftp_status == self._networking_api.FTP_TRANSFERRING: time.sleep(5) ftp_status = self._networking_api.get_ftp_xfer_status() # Does Timeout occur? if ftp_status == self._networking_api.FTP_TRANSFERRING: # End the transfer self._networking_api.stop_ftp_xfer(task_id) msg = "FTP Transfer timeout. Please use a smaller file or increase the timeout value" self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) # Control that the FTP transfer was success if not self._networking_api.is_ftp_xfer_success( self._dlfilename, self._direction, task_id): # End the transfer self._networking_api.stop_ftp_xfer(task_id) msg = "FTP transfer FAILS" self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) return Global.SUCCESS, "No errors"
def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) # Reconnect only if needed (B2B continuous mode = True) if self._is_wifi_already_connected is not True: self._networking_api.set_wificonfiguration(self._ssid, self._passphrase, self._security, self._ip_setting, self._ip_address, self._netmask, self._gateway, self._dns1, self._dns2) self._networking_api.wifi_connect(self._ssid) # Check Wifi connection is available packetloss = self._networking_api.ping(self._wifirouter_ip, self._packetsize, self._packnb) if packetloss.value > self._lossrate: msg = "Fail to recover Wifi connection after enabling wifi interface " + \ "(ping NOK: %s%% packet loss)" % str(packetloss.value) self._logger.error(msg) raise DeviceException(DeviceException.PROHIBITIVE_MEASURE, msg) # Disable Wifi interface self.__set_wifi_off() time.sleep(self._wifi_switchoff_time) # Enable Wifi interface self.__set_wifi_on() time.sleep(self._wifi_switchon_time) # Check connection to the SSID self._networking_api.check_connection_state(self._ssid) # Check Wifi connection is back packetloss = self._networking_api.ping(self._wifirouter_ip, self._packetsize, self._packnb) if packetloss.value > self._lossrate: msg = "Fail to recover Wifi connection after enabling wifi interface " \ + "(ping NOK: %s%% packet loss)" % str(packetloss.value) self._logger.error(msg) raise DeviceException(DeviceException.PROHIBITIVE_MEASURE, msg) # Forget AP SSID self._networking_api.wifi_remove_config(self._ssid) if self._hidden: # SSID not broadcasted. Check that the SSID disappears from the list. self._logger.info("Waiting %d seconds for SSID to disappear from scan list" % self._waiting_check_time) time.sleep(self._waiting_check_time) # Check AP is well forgotten and no connection is made on it all_network_list = self._networking_api.list_ssids() if self._ssid in all_network_list: msg = "SSID %s is unexpectedly present in the list" % str(self._ssid) self._logger.error(msg) raise DeviceException(DeviceException.PROHIBITIVE_MEASURE, msg) else: # SSID broadcasted. Check that the Connection is not established. connected_network_list = self._networking_api.list_connected_wifi() if self._ssid in connected_network_list: msg = "DUT is unexpectedly connected to %s " % str(self._ssid) self._logger.error(msg) raise DeviceException(DeviceException.PROHIBITIVE_MEASURE, msg) self._is_wifi_already_connected = False return Global.SUCCESS, "No errors"
def run_test(self): """ Execute the test """ # pylint: disable=E1101 LabWifiBase.run_test(self) # monitor wifi connection time if requested mean = -1 if self._monitor_connection_time and self.get_b2b_iteration( ) == self._current_iteration_num: # This is the last iteration of back to back test # compute standard deviation, mean and verdict mean = float(numpy.mean(self._connection_time_list)) std_deviation = float(numpy.std(self._connection_time_list)) compute_verdict(self._expected_connection_time, self._tolerance, mean, std_deviation, self._logger) # Switch OFF the AP if the TC associated parameter is enabled if self._restart_ap_radio: # Forget the SSID self._networking_api.wifi_remove_config(self._ssid) # Disable radio self._ns.init() self._ns.disable_wireless() # Restart the DUT wifi interface self._networking_api.set_wifi_power("off") time.sleep(self._wait_btwn_cmd) self._networking_api.set_wifi_power("on") time.sleep(self._wait_btwn_cmd) # Register to the "out of range" network if str(self._wrong_passphrase).lower() == 'none': self._networking_api.set_wificonfiguration( self._ssid, self._passphrase, self._security, self._ip_setting, self._ip_address, self._netmask, self._gateway, self._dns1, self._dns2) else: self._networking_api.set_wificonfiguration( self._ssid, self._wrong_passphrase, self._security, self._ip_setting, self._ip_address, self._netmask, self._gateway, self._dns1, self._dns2) self._networking_api.set_autoconnect_mode(self._ssid, AUTO_CONNECT_STATE.on) # Restart the Wifi interface if required if self._restart_dut == "INTERFACE": # Power cycle the Wifi interface self._networking_api.set_wifi_power("off") time.sleep(self._wait_btwn_cmd) self._networking_api.set_wifi_power("on") time.sleep(self._wait_btwn_cmd) elif self._restart_dut == "PHONE": # Power cycle the phone self._device.reboot() # Switch ON the AP if the TC associated parameter is enabled if self._restart_ap_radio: # enable_wireless includes a time sleep self._ns.enable_wireless() self._ns.release() if self._restart_dut == "INTERFACE" \ or self._restart_dut == "PHONE" \ or self._restart_ap_radio \ or self._mac_filter != "OFF" \ or str(self._wrong_passphrase).lower() != 'none': if str(self._wrong_passphrase).lower() == 'none' and \ not self._key_exchange_should_fail: # Wait for the connection to establish self._networking_api.check_connection_state(self._ssid) else: # Wait for the connection to try to establish self._logger.debug( "Waiting for the connection list to be updated") self._phone_system_api.display_on() time.sleep(30) self._phone_system_api.display_off() # MAC address filter management if self._mac_filter != "OFF": if self._mac_filter_parameter != "OFF": self._networking_api.wifi_disconnect(self._ssid) self._add_mac_filter_to_ap() # Try to reconnect DUT self._networking_api.wifi_connect(self._ssid, False) try: self._networking_api.check_connection_state(self._ssid, 20) except AcsBaseException as e: if not self._dut_in_mac_filter or \ e.get_generic_error_message() != DeviceException.TIMEOUT_REACHED: raise # List connected SSIDs to check if the right ssid is connected connected_wifi_list = self._networking_api.list_connected_wifi() if str(self._wrong_passphrase).lower() == 'none' and \ not self._key_exchange_should_fail and \ not self._dut_in_mac_filter: if self._ssid in connected_wifi_list: result = "Wifi connected to network %s with correct password." % str( self._ssid) if mean > 0: result += " Mean connection time is %2.2f sec" % mean if self._ip_setting_enable: if (self._ip_address == self._networking_api.get_wifi_ip_address()): result += "Static ip successfully set." else: msg = "obtained ip address is different from the " + \ "static ip address" self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) else: msg = "Wifi did not connect to network " \ + "[%s] with correct password. " % str(self._ssid) self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) else: if self._ssid not in connected_wifi_list: result = "Wifi not connected to network " \ + "%s" % str(self._ssid) if str(self._wrong_passphrase).lower() != 'none' or \ self._key_exchange_should_fail: result += ", with wrong password" if self._dut_in_mac_filter: result += ", MAC add filtered" else: msg = "Wifi connected to network " \ + "[%s]" % str(self._ssid) if str(self._wrong_passphrase).lower() != 'none' or \ self._key_exchange_should_fail: msg += ", with wrong password" if self._dut_in_mac_filter: msg += ", MAC add filtered" self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) if self._mac_filter != "OFF": if self._mac_filter_parameter != "OFF": self._networking_api.wifi_disconnect(self._ssid) # Remove MAC filter self._remove_mac_filter_on_ap() # Connect DUT self._networking_api.wifi_connect(self._ssid) return Global.SUCCESS, result
def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) if self._wifi_off > 0: # WiFi interface OFF setup self.__compute_test_duration("WIFI_OFF") self._networking_api.\ measure_wifi_turns_off_duration("async_init", self._wifi_interface, duration=self._tduration) # Unplug the USB cable if necessary if self._usb_pluggedin.lower() == "false": # We have to disable S3 in order to keep DUT active when unplugged self._sleep_mode_api.init("s0i3") self._device.disconnect_board() self._usb_connected_status = False self._io_card.usb_host_pc_connector(False) if self._scan > 0: # WiFi scan test self.__run_scan_test(False) elif self._scan == -1: # PERIODIC scan (every 40s for the first 5min then is every 5min) self.__run_periodic_scan_test() elif self._wifi_off > 0: # Wifi OFF test self._logger.info("Sleep %d sec" % self._tduration) time.sleep(self._tduration) elif self._scan == 0 and self._wifi_off == 0 and self._tduration > 0: # No scan test self.__run_scan_test(True) else: msg = "Unhandled test scenario" self._logger.error(msg) raise AcsConfigException(AcsConfigException.PROHIBITIVE_BEHAVIOR, msg) # Plug the USB cable back if necessary if self._usb_pluggedin.lower() == "false": self._io_card.usb_host_pc_connector(True) self._device.connect_board() self._usb_connected_status = True # Enable S3 self._sleep_mode_api.clear() if self._wifi_off > 0: # WiFi interface OFF teardown self._networking_api.\ measure_wifi_turns_off_duration("async_result", self._wifi_interface, expected_duration=self._wifi_off * 60, tolerance=self._tolerance) return Global.SUCCESS, "No errors"
def run_test(self): """ Execute the test """ LabWifiBase.run_test(self) # Change AP security type # Initiate connection to the equipment self._ns.init() try: # Configure the equipment self._ns.set_wifi_config(self._ssid, self._hidden, self._standard, self._security_2, self._passphrase_2, self._channel, self._dtim, self._beacon, self._wmm, self._bandwidth, self._wifi_mimo, self._radiusip, self._radiusport, self._radiussecret) finally: # Close the connection to AP self._ns.release() self._logger.debug("Wait %ss for automatic disconnection" % self.WAIT_FOR_DISCONNECTION) time.sleep(self.WAIT_FOR_DISCONNECTION) # Ping to validate DUT is not connected packet_loss = self._networking_api.ping(self._wifi_server_ip_address, self.PING_PACKET_SIZE, self.PING_PACKET_COUNT, blocking=False) if packet_loss.value < 100 and packet_loss.value != -1: msg = "Ping packet loss is not acceptable [%s] - DUT should be disconnected" % str(packet_loss.value) self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) # Connect with good credentials self._networking_api.clean_all_data_connections() time.sleep(self._wait_btwn_cmd) self._networking_api.set_wificonfiguration(self._ssid, self._passphrase_2, self._security_2, self._ip_setting, self._ip_address, self._netmask, self._gateway, self._dns1, self._dns2) time.sleep(self._wait_btwn_cmd) self._networking_api.wifi_connect(self._ssid) # Ping to validate DUT is connected time.sleep(self._wait_btwn_cmd) packet_loss = self._networking_api.ping(self._wifi_server_ip_address, self.PING_PACKET_SIZE, self.PING_PACKET_COUNT) if packet_loss.value > 0: msg = "Ping packet loss is not acceptable [%s] - DUT should be connected" % str(packet_loss.value) self._logger.error(msg) raise DeviceException(DeviceException.OPERATION_FAILED, msg) return Global.SUCCESS, "no_error"