def setup_test(self):
self.tcpdump_pid_a = start_adb_tcpdump(self.dut_a,
self.test_name,
mask='all')
self.tcpdump_pid_b = start_adb_tcpdump(self.dut_b,
self.test_name,
mask='all')
def setup_class(self):
super().setup_class()
self.ad = self.android_devices[0]
req_params = [
# A { SSID, password } dictionary. Password is optional.
'wifi_network',
# A [latitude, longitude] list to identify test location.
'test_location',
# Cold Start Criteria, a int to define the criteria.
'cs_criteria',
# Warm Start Criteria, a int to define the criteria.
'ws_criteria',
# Hot Start Criteria, a int to define the criteria.
'hs_criteria',
# NetworkLocationProvide Criteria, a int to define the criteria.
'nlp_criteria',
# A list to identify QXDM log path.
'qdsp6m_path'
]
self.unpack_userparams(req_param_names=req_params)
# Init test types Cold Start, Warm Start and Hot Start.
test_type = namedtuple('Type', ['command', 'criteria'])
self.test_types = {
'cs': test_type('Cold Start', self.cs_criteria),
'ws': test_type('Warm Start', self.ws_criteria),
'hs': test_type('Hot Start', self.hs_criteria)
}
gutils._init_device(self.ad)
self.begin_time = utils.get_current_epoch_time()
gutils.clear_logd_gnss_qxdm_log(self.ad)
tutils.start_qxdm_logger(self.ad, self.begin_time)
tutils.start_adb_tcpdump(self.ad)
def setup_class(self):
super(TelLiveStressTest, self).setup_class()
self.dut = self.android_devices[0]
self.single_phone_test = self.user_params.get("single_phone_test",
False)
# supported file download methods: chrome, sl4a, curl
self.file_download_method = self.user_params.get(
"file_download_method", "curl")
self.get_binder_logs = self.user_params.get("get_binder_logs", False)
if len(self.android_devices) == 1:
self.single_phone_test = True
if self.single_phone_test:
self.android_devices = self.android_devices[:1]
self.call_server_number = self.user_params.get(
"call_server_number", STORY_LINE)
if self.file_download_method == "sl4a":
# with single device, do not use sl4a file download
# due to stability issue
self.file_download_method = "curl"
else:
self.android_devices = self.android_devices[:2]
for ad in self.android_devices:
ad.adb.shell("setprop nfc.debug_enable 1")
if self.user_params.get("turn_on_tcpdump", True):
start_adb_tcpdump(ad, interface="any", mask="all")
self.user_params["telephony_auto_rerun"] = 0
self.phone_call_iteration = int(
self.user_params.get("phone_call_iteration", 500))
self.max_phone_call_duration = int(
self.user_params.get("max_phone_call_duration", 600))
self.min_sleep_time = int(self.user_params.get("min_sleep_time", 30))
self.max_sleep_time = int(self.user_params.get("max_sleep_time", 60))
self.max_run_time = int(self.user_params.get("max_run_time", 14400))
self.max_sms_length = int(self.user_params.get("max_sms_length", 1000))
self.max_mms_length = int(self.user_params.get("max_mms_length", 160))
self.min_sms_length = int(self.user_params.get("min_sms_length", 1))
self.min_mms_length = int(self.user_params.get("min_mms_length", 1))
self.min_phone_call_duration = int(
self.user_params.get("min_phone_call_duration", 10))
self.crash_check_interval = int(
self.user_params.get("crash_check_interval", 300))
self.dut_incall = False
self.dut_capabilities = self.dut.telephony.get("capabilities", [])
self.dut_wfc_modes = self.dut.telephony.get("wfc_modes", [])
self.gps_log_file = self.user_params.get("gps_log_file", None)
return True
def _start_tcp_dump(self, ad):
""" Start tcpdump on the give dut
Args:
1. ad: dut to run tcpdump on
"""
if self.tcpdump_pid:
stop_adb_tcpdump(ad, self.tcpdump_pid, pull_tcpdump=False)
self.tcpdump_pid = start_adb_tcpdump(ad, self.test_name, mask='all')
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_adb_tcpdump(self.dut,
self.test_name,
mask='all')
def data_test(self):
failure = 0
total_count = 0
tcpdump_pid = None
#file_names = ["5MB", "10MB", "20MB", "50MB", "200MB", "512MB", "1GB"]
file_names = ["5MB", "10MB", "20MB", "50MB", "200MB", "512MB"]
while time.time() < self.finishing_time:
total_count += 1
pull_tcpdump = False
try:
self.dut.log.info(dict(self.result_info))
self.result_info["Total file download"] += 1
selection = random.randrange(0, len(file_names))
file_name = file_names[selection]
(tcpdump_pid, tcpdump_file) = \
start_adb_tcpdump(self.dut, self.test_name, mask="all")
if not active_file_download_test(self.log, self.dut,
file_name):
self.result_info["%s file download failure" %
file_name] += 1
failure += 1
pull_tcpdump = True
self._take_bug_report("%s_download_failure" %
self.test_name,
time.strftime("%m-%d-%Y-%H-%M-%S"))
self.dut.droid.goToSleepNow()
time.sleep(random.randrange(0, self.max_sleep_time))
except IGNORE_EXCEPTIONS as e:
self.log.error("Exception error %s", str(e))
self.result_info["Exception Errors"] += 1
if self.result_info["Exception Errors"] > EXCEPTION_TOLERANCE:
self.finishing_time = time.time()
raise
except Exception as e:
self.finishing_time = time.time()
raise
finally:
if tcpdump_pid is not None:
stop_adb_tcpdump(self.dut, tcpdump_pid, tcpdump_file,
pull_tcpdump)
self.dut.log.info("File download test failure: %s/%s", failure,
total_count)
if failure / total_count > 0.1:
return "File download test failure: %s/%s" % (failure, total_count)
else:
return ""
def setup_test(self):
self.tcpdump_pid = start_adb_tcpdump(self.dut,
self.test_name,
mask='all')
def start_qxdm_and_tcpdump_log(self):
"""Start QXDM and adb tcpdump if collect_logs is True."""
if self.collect_logs:
start_qxdm_logger(self.ad, get_current_epoch_time())
start_adb_tcpdump(self.ad)
def _make_phone_call(self, call_verification_func=None):
ads = self.android_devices[:]
if not self.single_phone_test:
random.shuffle(ads)
the_number = self.result_info["Call Total"] + 1
duration = random.randrange(self.min_phone_call_duration,
self.max_phone_call_duration)
result = True
test_name = "%s_No_%s_phone_call" % (self.test_name, the_number)
log_msg = "[Test Case] %s" % test_name
self.log.info("%s for %s seconds begin", log_msg, duration)
begin_time = get_device_epoch_time(ads[0])
for ad in self.android_devices:
if self.user_params.get("turn_on_tcpdump", True):
start_adb_tcpdump(ad, interface="any", mask="all")
if not getattr(ad, "droid", None):
ad.droid, ad.ed = ad.get_droid()
ad.ed.start()
else:
try:
if not ad.droid.is_live:
ad.droid, ad.ed = ad.get_droid()
ad.ed.start()
else:
ad.ed.clear_all_events()
except Exception:
ad.log.info("Create new sl4a session for phone call")
ad.droid, ad.ed = ad.get_droid()
ad.ed.start()
ad.droid.logI("%s begin" % log_msg)
start_qxdm_loggers(self.log, self.android_devices, begin_time)
failure_reasons = set()
self.dut_incall = True
if self.single_phone_test:
call_setup_result = initiate_call(
self.log,
self.dut,
self.call_server_number,
incall_ui_display=INCALL_UI_DISPLAY_BACKGROUND
) and wait_for_in_call_active(self.dut, 60, 3)
else:
call_setup_result = call_setup_teardown(
self.log,
ads[0],
ads[1],
ad_hangup=None,
verify_caller_func=call_verification_func,
verify_callee_func=call_verification_func,
wait_time_in_call=0,
incall_ui_display=INCALL_UI_DISPLAY_BACKGROUND)
if not call_setup_result:
call_logs = ads[0].search_logcat(
"ActivityManager: START u0 {act=android.intent.action.CALL",
begin_time)
messaging_logs = ads[0].search_logcat(
"com.google.android.apps.messaging/.ui.conversation.ConversationActivity",
begin_time)
if call_logs and messaging_logs:
if messaging_logs[-1]["datetime_obj"] - call_logs[-1]["datetime_obj"] < 5:
ads[0].log.info(
"Call setup failure due to simultaneous activities")
self.result_info[
"Call Setup Failure With Simultaneous Activity"] += 1
return True
self.log.error("%s: Setup Call failed.", log_msg)
failure_reasons.add("Setup")
result = False
else:
elapsed_time = 0
check_interval = 5
while (elapsed_time < duration):
check_interval = min(check_interval, duration - elapsed_time)
time.sleep(check_interval)
elapsed_time += check_interval
time_message = "at <%s>/<%s> second." % (elapsed_time,
duration)
for ad in ads:
if not call_verification_func(self.log, ad):
ad.log.warning("Call is NOT in correct %s state at %s",
call_verification_func.__name__,
time_message)
if call_verification_func.__name__ == "is_phone_in_call_iwlan":
if is_phone_in_call(self.log, ad):
if getattr(ad, "data_rat_state_error_count",
0) < 1:
setattr(ad, "data_rat_state_error_count",
1)
continue
failure_reasons.add("Maintenance")
last_call_drop_reason(ad, begin_time)
hangup_call(self.log, ads[0])
result = False
else:
ad.log.info("Call is in correct %s state at %s",
call_verification_func.__name__,
time_message)
if not result:
break
if not hangup_call(self.log, ads[0]):
failure_reasons.add("Teardown")
result = False
for ad in ads:
if not wait_for_call_id_clearing(ad,
[]) or ad.droid.telecomIsInCall():
ad.log.error("Fail to hang up call")
failure_reasons.add("Teardown")
result = False
self.result_info["Call Total"] += 1
for ad in self.android_devices:
try:
ad.droid.logI("%s end" % log_msg)
except:
pass
self.log.info("%s end", log_msg)
self.dut_incall = False
if not result:
self.log.info("%s failed", log_msg)
if self.gps_log_file:
gps_info = job.run(
"tail %s" % self.gps_log_file, ignore_status=True)
if gps_info.stdout:
gps_log_path = os.path.join(self.log_path, test_name,
"gps_logs.txt")
utils.create_dir(gps_log_path)
job.run(
"tail %s > %s" % (self.gps_log_file, gps_log_path),
ignore_status=True)
self.log.info("gps log:\n%s", gps_info.stdout)
else:
self.log.warning("Fail to get gps log %s",
self.user_params["gps_log_file"])
for reason in failure_reasons:
self.result_info["Call %s Failure" % reason] += 1
for ad in ads:
log_path = os.path.join(self.log_path, test_name,
"%s_binder_logs" % ad.serial)
utils.create_dir(log_path)
ad.pull_files(BINDER_LOGS, log_path)
try:
self._take_bug_report(test_name, begin_time)
except Exception as e:
self.log.exception(e)
for ad in ads:
if ad.droid.telecomIsInCall():
hangup_call_by_adb(ad)
else:
self.log.info("%s test succeed", log_msg)
self.result_info["Call Success"] += 1
if self.result_info["Call Total"] % 50 == 0:
for ad in ads:
synchronize_device_time(ad)
if not check_is_wifi_connected(self.log, ad,
self.wifi_network_ssid):
ensure_wifi_connected(self.log, ad,
self.wifi_network_ssid,
self.wifi_network_pass)
force_connectivity_metrics_upload(ad)
time.sleep(300)
wifi_toggle_state(self.log, ad, False)
if self.get_binder_logs:
log_path = os.path.join(self.log_path,
"%s_binder_logs" % test_name,
"%s_binder_logs" % ad.serial)
utils.create_dir(log_path)
ad.pull_files(BINDER_LOGS, log_path)
return result
def _send_message(self, max_wait_time=2 * MAX_WAIT_TIME_SMS_RECEIVE):
if self.single_phone_test:
ads = [self.dut, self.dut]
else:
ads = self.android_devices[:]
random.shuffle(ads)
selection = random.randrange(0, 2)
message_type_map = {0: "SMS", 1: "MMS"}
max_length_map = {0: self.max_sms_length, 1: self.max_mms_length}
min_length_map = {0: self.min_sms_length, 1: self.min_mms_length}
length = random.randrange(min_length_map[selection],
max_length_map[selection] + 1)
message_func_map = {
0: sms_send_receive_verify,
1: mms_send_receive_verify
}
rat = self.dut.adb.getprop("gsm.network.type")
self.dut.log.info("Network in RAT %s", rat)
if self.dut_incall and not is_rat_svd_capable(rat.upper()):
self.dut.log.info("In call data not supported, test SMS only")
selection = 0
message_type = message_type_map[selection]
the_number = self.result_info["%s Total" % message_type] + 1
begin_time = get_device_epoch_time(self.dut)
test_name = "%s_No_%s_%s" % (self.test_name, the_number, message_type)
start_qxdm_loggers(self.log, self.android_devices)
log_msg = "[Test Case] %s" % test_name
self.log.info("%s begin", log_msg)
for ad in self.android_devices:
if self.user_params.get("turn_on_tcpdump", True):
start_adb_tcpdump(ad, interface="any", mask="all")
if not getattr(ad, "messaging_droid", None):
ad.messaging_droid, ad.messaging_ed = ad.get_droid()
ad.messaging_ed.start()
else:
try:
if not ad.messaging_droid.is_live:
ad.messaging_droid, ad.messaging_ed = ad.get_droid()
ad.messaging_ed.start()
else:
ad.messaging_ed.clear_all_events()
except Exception:
ad.log.info("Create new sl4a session for messaging")
ad.messaging_droid, ad.messaging_ed = ad.get_droid()
ad.messaging_ed.start()
ad.messaging_droid.logI("%s begin" % log_msg)
text = "%s: " % test_name
text_length = len(text)
if length < text_length:
text = text[:length]
else:
text += rand_ascii_str(length - text_length)
message_content_map = {0: [text], 1: [(test_name, text, None)]}
result = message_func_map[selection](self.log, ads[0], ads[1],
message_content_map[selection],
max_wait_time)
self.log.info("%s end", log_msg)
for ad in self.android_devices:
ad.messaging_droid.logI("%s end" % log_msg)
if not result:
self.result_info["%s Total" % message_type] += 1
if message_type == "SMS":
self.log.error("%s fails", log_msg)
self.result_info["%s Failure" % message_type] += 1
else:
rat = self.dut.adb.getprop("gsm.network.type")
self.dut.log.info("Network in RAT %s", rat)
if self.dut_incall and not is_rat_svd_capable(rat.upper()):
self.dut.log.info(
"In call data not supported, MMS failure expected")
self.result_info["Expected In-call MMS failure"] += 1
return True
else:
self.log.error("%s fails", log_msg)
self.result_info["MMS Failure"] += 1
try:
self._take_bug_report(test_name, begin_time)
except Exception as e:
self.log.exception(e)
return False
else:
self.result_info["%s Total" % message_type] += 1
self.log.info("%s succeed", log_msg)
self.result_info["%s Success" % message_type] += 1
return True