def _test_proxy(self): """ Test pac piroxy and manual proxy settings Steps: 1. Start tcpdump 2. Run http requests 3. Stop tcpdump 4. Verify the packets from tcpdump have valid queries """ # start tcpdump on the device self.tcpdump_pid = start_tcpdump(self.dut, self.test_name) # verify http requests self._verify_http_request(self.dut) # stop tcpdump on the device pcap_file = stop_tcpdump(self.dut, self.tcpdump_pid, self.test_name) # verify proxy server result = self._verify_proxy_server(pcap_file, True, self.bypass_host) asserts.assert_true(result, "Proxy failed for %s" % self.bypass_host) result = self._verify_proxy_server(pcap_file, False, self.non_bypass_host) asserts.assert_true(result, "Proxy failed for %s" % self.non_bypass_host)
def setup_test(self): self.dut.droid.wifiStartTrackingStateChange() self.dut.droid.wakeLockAcquireBright() self.dut.droid.wakeUpNow() wutils.reset_wifi(self.dut) self.dut.ed.clear_all_events() self.tcpdump_pid = start_tcpdump(self.dut, self.test_name)
def _start_tcp_dump(self, ad): """ Start tcpdump on the give dut Args: 1. ad: dut to run tcpdump on """ self.tcpdump_pid = start_tcpdump(ad, self.test_name)
def catch_log(self): """Capture logs include bugreport, ANR, mount,ps,vendor,tcpdump""" self.log.info("Get log for regular capture.") file_name = time.strftime("%Y-%m-%d_%H:%M:%S", time.localtime()) current_path = os.path.join(self.dut.log_path, file_name) os.makedirs(current_path, exist_ok=True) serial_number = self.dut.serial try: out = self.dut.adb.shell("bugreportz", timeout=240) if not out.startswith("OK"): raise AndroidDeviceError('Failed to take bugreport on %s: %s' % (serial_number, out), serial=serial_number) br_out_path = out.split(':')[1].strip().split()[0] self.dut.adb.pull("%s %s" % (br_out_path, self.dut.log_path)) self.dut.adb.pull("/data/anr {}".format(current_path), timeout=600) self.dut.adb._exec_adb_cmd( "shell", "mount > {}".format(os.path.join(current_path, "mount.txt"))) self.dut.adb._exec_adb_cmd( "shell", "ps > {}".format(os.path.join(current_path, "ps.txt"))) self.dut.adb.pull("/data/misc/logd {}".format(current_path)) self.dut.adb.pull("/data/vendor {}".format(current_path), timeout=800) stop_tcpdump(self.dut, self.tcpdump_pid, file_name, adb_pull_timeout=600) self.tcpdump_pid = start_tcpdump(self.dut, file_name) except TimeoutError as e: self.log.error(e)
def setup_test(self): asserts.skip_if( self.test_name.startswith("test_tcp") and \ self.kernel_version < SUPPORTED_KERNEL_VERSION, "TCP Keepalive is not supported on kernel %s. Need at least %s" % (self.kernel_version, SUPPORTED_KERNEL_VERSION)) if self.test_name.endswith("_lte"): wutils.wifi_toggle_state(self.dut, False) time.sleep(3) link_prop = self.dut.droid.connectivityGetActiveLinkProperties() iface = link_prop["InterfaceName"] self.log.info("Iface: %s" % iface) self.dut_ip = self.dut.droid.connectivityGetIPv4Addresses(iface)[0] self.tcpdump_pid = start_tcpdump(self.dut, self.test_name)
def test_multipath_preference_data_download(self): """ Verify multipath preference when large file is downloaded Steps: 1. DUT has WiFi and LTE data 2. WiFi is active network 3. Download large file over cell network 4. Verify multipath preference on cell network is 0 """ # set vars ad = self.android_devices[1] self.dut = ad self._clear_netstats(ad) utils.sync_device_time(ad) self.tcpdump_pid = nutils.start_tcpdump(ad, self.test_name) cell_network = ad.droid.connectivityGetActiveNetwork() self.log.info("cell network %s" % cell_network) wutils.wifi_connect(ad, self.wifi_network) wifi_network = ad.droid.connectivityGetActiveNetwork() self.log.info("wifi network %s" % wifi_network) # verify multipath preference for wifi and cell networks self._verify_multipath_preferences(ad, RELIABLE, RELIABLE, wifi_network, cell_network) # download file with cell network ad.droid.connectivityNetworkOpenConnection(cell_network, self.download_file) file_folder, file_name = _generate_file_directory_and_file_name( self.download_file, DOWNLOAD_PATH) file_path = os.path.join(file_folder, file_name) self.log.info("File path: %s" % file_path) if _check_file_existance(ad, file_path): self.log.info("File exists. Removing file %s" % file_name) ad.adb.shell("rm -rf %s%s" % (DOWNLOAD_PATH, file_name)) # verify multipath preference values curr_time = time.time() while time.time() < curr_time + TIMEOUT: try: self._verify_multipath_preferences(ad, RELIABLE, NONE, wifi_network, cell_network) return True except signals.TestFailure as e: self.log.debug("%s" % e) time.sleep(1) return False
def test_IPv6_RA_with_RTT(self): """Test if the device filters IPv6 RA packets with different re-trans time Steps: 1. Get the current RA count 2. Send 400 packets with different re-trans time 3. Verify that RA count increased by 400 4. Verify internet connectivity """ pkt_num = 400 rtt_list = random.sample(range(10, 10000), pkt_num) self.log.info("RTT List: %s" % rtt_list) # get mac address of the dut ap = self.access_points[0] wutils.connect_to_wifi_network(self.dut, self.wpapsk_5g) mac_addr = self.dut.droid.wifiGetConnectionInfo()['mac_address'] self.log.info("mac_addr %s" % mac_addr) time.sleep(30) # wait 30 sec before sending RAs # get the current ra count ra_count = self._get_icmp6intype134() # start tcpdump on the device tcpdump_pid = start_tcpdump(self.dut, self.test_name) # send RA with differnt re-trans time for rtt in rtt_list: ap.send_ra('wlan1', mac_addr, 0, 1, rtt=rtt) # stop tcpdump and pull file time.sleep(60) pcap_file = stop_tcpdump(self.dut, tcpdump_pid, self.test_name) # get the new RA count new_ra_count = self._get_icmp6intype134() asserts.assert_true(new_ra_count >= ra_count + pkt_num, "Device did not accept all RAs") # verify the RA pkts RTT match tcpdump_rtt_list = self._get_rtt_list_from_tcpdump(pcap_file) asserts.assert_true( set(rtt_list).issubset(set(tcpdump_rtt_list)), "RA packets didn't match with tcpdump") # verify if internet connectivity works after sending RA packets wutils.validate_connection(self.dut)
def test_multipath_preference_low_data_limit(self): """ Verify multipath preference when mobile data limit is low Steps: 1. DUT has WiFi and LTE data 2. Set mobile data usage limit to low value 3. Verify that multipath preference is 0 for cell network """ # set vars ad = self.android_devices[0] self.dut = ad self._clear_netstats(ad) utils.sync_device_time(ad) self.tcpdump_pid = nutils.start_tcpdump(ad, self.test_name) sub_id = str(ad.droid.telephonyGetSubscriberId()) cell_network = ad.droid.connectivityGetActiveNetwork() self.log.info("cell network %s" % cell_network) wutils.wifi_connect(ad, self.wifi_network) wifi_network = ad.droid.connectivityGetActiveNetwork() self.log.info("wifi network %s" % wifi_network) # verify mulipath preference values self._verify_multipath_preferences(ad, RELIABLE, RELIABLE, wifi_network, cell_network) # set low data limit on mobile data total_pre = self._get_total_data_usage_for_device(ad, 0, sub_id) self.log.info("Setting data usage limit to %sMB" % (total_pre + 5)) ad.droid.connectivitySetDataUsageLimit( sub_id, int((total_pre + 5) * 1000.0 * 1000.0)) self.log.info("Setting data warning limit to %sMB" % (total_pre + 5)) ad.droid.connectivitySetDataWarningLimit( sub_id, int((total_pre + 5) * 1000.0 * 1000.0)) # verify multipath preference values curr_time = time.time() while time.time() < curr_time + TIMEOUT: try: self._verify_multipath_preferences(ad, RELIABLE, NONE, wifi_network, cell_network) return True except signals.TestFailure as e: self.log.debug("%s" % e) time.sleep(1) return False
def browsing_test(self, stress_hour_time): """Continue stress http_request and capture log if any fail Args: stress_hour_time: hour of time to stress http_request """ t = threading.Thread(target=self.simulate_roaming) t.start() start_time = time.time() http_request_failed = False while time.time() < start_time + stress_hour_time * 3600: if not self.http_request(): http_request_failed = True self.simulation_thread_running = False t.join() if http_request_failed: self.catch_log() else: stop_standing_subprocess(self.tcpdump_pid) file_name = time.strftime("%Y-%m-%d_%H:%M:%S", time.localtime()) self.tcpdump_pid = start_tcpdump(self.dut, file_name)
def setup_test(self): self.tcpdump_pid_a = start_tcpdump(self.dut_a, self.test_name) self.tcpdump_pid_b = start_tcpdump(self.dut_b, self.test_name)
def setup_test(self): self.dut.droid.wakeLockAcquireBright() self.dut.droid.wakeUpNow() self.dut.unlock_screen() self.tcpdump_pid = start_tcpdump(self.dut, self.test_name)
def setup_test(self): for ad in self.android_devices: self.tcpdump_pid.append(nutils.start_tcpdump(ad, self.test_name))
def setup_test(self): if 'RTT' not in self.test_name: self.tcpdump_pid = start_tcpdump(self.dut, self.test_name)
def setup_test(self): for ad in self.android_devices: self.tcpdumps.append(start_tcpdump(ad, self.test_name)) ad.droid.wakeLockAcquireBright() ad.droid.wakeUpNow()