def _take_bug_report(self, test_name, begin_time):
test_log_path = os.path.join(self.log_path, test_name)
utils.create_dir(test_log_path)
# Extract test_run_info.txt, test_run_detail.txt
for file_name in ("test_run_info.txt", "test_run_details.txt"):
extract_test_log(
self.log, os.path.join(self.log_path, file_name),
os.path.join(test_log_path, "%s_%s" % (test_name, file_name)),
"\[Test Case\] %s " % test_name)
if self._skip_bug_report():
return
dev_num = getattr(self, "number_of_devices", None) or len(
self.android_devices)
tasks = [(self._ad_take_bugreport, (ad, test_name, begin_time))
for ad in self.android_devices[:dev_num]]
tasks.extend([(self._ad_take_extra_logs, (ad, test_name, begin_time))
for ad in self.android_devices[:dev_num]])
run_multithread_func(self.log, tasks)
for ad in self.android_devices[:dev_num]:
if getattr(ad, "reboot_to_recover", False):
reboot_device(ad)
ad.reboot_to_recover = False
# Zip log folder
if not self.user_params.get("zip_log", False): return
src_dir = os.path.join(self.log_path, test_name)
file_name = "%s_%s" % (src_dir, begin_time)
self.log.info("Zip folder %s to %s.zip", src_dir, file_name)
shutil.make_archive(file_name, "zip", src_dir)
shutil.rmtree(src_dir)
def _take_bug_report(self, test_name, begin_time):
if "no_bug_report_on_fail" in self.user_params:
return
tasks = [(self._ad_take_reports, (ad, test_name, begin_time))
for ad in self.android_devices]
run_multithread_func(self.log, tasks)
def volte_modechange_volte_test(self):
sub_id = self.dut.droid.subscriptionGetDefaultSubId()
result = True
while time.time() < self.finishing_time:
try:
if self._prefnetwork_mode_change(sub_id):
run_multithread_func(
self.log,
[(self._data_download, [["5MB"]]),
(self._make_phone_call, [is_phone_in_call_volte]),
(self._send_message, [])])
else:
result = False
if self._mobile_data_toggling():
run_multithread_func(
self.log,
[(self._data_download, [["5MB"]]),
(self._make_phone_call, [is_phone_in_call_volte]),
(self._send_message, [])])
else:
result = False
except Exception as e:
self.log.error("Exception error %s", str(e))
self.result_info["Exception Errors"] += 1
self.log.info(dict(self.result_info))
if self.result_info["Exception Errors"] >= EXCEPTION_TOLERANCE:
self.log.error("Too many exception errors, quit test")
return False
return result
def parallel_tests(self, setup_func=None, call_verification_func=None):
self.log.info(self._get_result_message())
if setup_func and not setup_func():
msg = "%s setup %s failed" % (self.test_name, setup_func.__name__)
self.log.error(msg)
self._take_bug_report("%s%s" % (self.test_name,
setup_func.__name__),
self.begin_time)
return False
if not call_verification_func:
call_verification_func = is_phone_in_call
self.finishing_time = time.time() + self.max_run_time
if self.check_incall_data():
self.log.info(
"==== Start parallel voice/message/data stress test ====")
self.perf_data["testing method"] = "parallel"
results = run_multithread_func(
self.log, [(self.call_test, [call_verification_func]),
(self.message_test, []), (self.data_test, []),
(self.crash_check_test, [])])
else:
self.log.info(
"==== Start sequential voice/message/data stress test ====")
self.perf_data["testing method"] = "sequential"
results = run_multithread_func(
self.log, [(self.sequential_tests, [call_verification_func]),
(self.crash_check_test, [])])
result_message = self._get_result_message()
self.log.info(result_message)
self._update_perf_json()
self.result_detail = result_message
return all(results)
def test_data_call_stress(self):
""" Default state stress test"""
self.finishing_time = time.time() + self.max_run_time
results = run_multithread_func(self.log,
[(self.data_call_stress_test, []),
(self.crash_check_test, [])])
result_message = self._get_result_message()
self.log.info(result_message)
self._update_perf_json()
self.result_detail = result_message
return all(results)
def test_wifi_cell_irat_stress_ping_continuous(self):
"""Test for data switch between WiFi and Cell. DUT go in and out WiFi
coverage for multiple times.
Steps:
1. Set WiFi and Cellular signal to good (attenuation value to MIN).
2. Make sure DUT get Cell data coverage (LTE) and WiFi connected.
3. Set WiFi RSSI to MAX (WiFi attenuator value to MIN).
4. Verify DUT report WiFi connected and Internet access OK.
5. Set WiFi RSSI to MIN (WiFi attenuator value to MAX).
6. Verify DUT report Cellular Data connected and Internet access OK.
7. Repeat Step 3~6 for stress number.
Expected Results:
4. DUT report WiFi connected and Internet access OK.
6. DUT report Cellular Data connected and Internet access OK.
7. Stress test should pass.
Returns:
True if Pass. False if fail.
"""
if not self._basic_connectivity_check():
self.log.error("Basic Connectivity Check Failed")
return False
total_iteration = self.stress_test_number
ad = self.android_devices[0]
ping_task = (adb_shell_ping, (ad, DEFAULT_PING_DURATION,
"www.google.com", 200, 40))
irat_task = (self._wifi_cell_irat_task, (ad, DEFAULT_IRAT_DURATION))
current_iteration = 1
while (current_iteration <= total_iteration):
self.log.info(">----Current iteration = %d/%d----<",
current_iteration, total_iteration)
results = run_multithread_func(self.log, [ping_task, irat_task])
if not results[1]:
ad.log.error("Data IRAT failed in active ICMP transfer")
break
if results[0]:
ad.log.info("ICMP transfer succeeded with parallel IRAT")
else:
ad.log.error("ICMP transfer failed with parallel IRAT")
break
self.log.info(">----Iteration : %d/%d succeed.----<",
current_iteration, total_iteration)
current_iteration += 1
if current_iteration <= total_iteration:
self.log.info(">----Iteration : %d/%d failed.----<",
current_iteration, total_iteration)
return False
else:
return True
def parallel_with_network_change_tests(self, setup_func=None):
if setup_func and not setup_func():
self.log.error("Test setup %s failed", setup_func.__name__)
return False
self.finishing_time = time.time() + self.max_run_time
results = run_multithread_func(self.log,
[(self.volte_modechange_volte_test, []),
(self.crash_check_test, [])])
result_message = self._get_result_message()
self.log.info(result_message)
self._update_perf_json()
self.result_detail = result_message
return all(results)
def _take_bug_report(self, test_name, begin_time):
if self._skip_bug_report(test_name):
return
dev_num = getattr(self, "number_of_devices", None) or len(
self.android_devices)
tasks = [(self._ad_take_bugreport, (ad, test_name, begin_time))
for ad in self.android_devices[:dev_num]]
tasks.extend([(self._ad_take_extra_logs, (ad, test_name, begin_time))
for ad in self.android_devices[:dev_num]])
run_multithread_func(self.log, tasks)
for ad in self.android_devices[:dev_num]:
if getattr(ad, "reboot_to_recover", False):
reboot_device(ad)
ad.reboot_to_recover = False
# Zip log folder
if not self.user_params.get("zip_log", False): return
src_dir = os.path.join(self.log_path, test_name)
os.makedirs(src_dir, exist_ok=True)
file_name = "%s_%s" % (src_dir, begin_time)
self.log.info("Zip folder %s to %s.zip", src_dir, file_name)
shutil.make_archive(file_name, "zip", src_dir)
shutil.rmtree(src_dir)
def parallel_volte_tests(self, setup_func=None):
if setup_func and not setup_func():
self.log.error("Test setup %s failed", setup_func.__name__)
return False
self.result_info = collections.defaultdict(int)
self.finishing_time = time.time() + self.max_run_time
results = run_multithread_func(
self.log, [(self.volte_modechange_volte_test, []),
(self.message_test, []), (self.crash_check_test, [])])
self.log.info(dict(self.result_info))
error_message = " ".join(results).strip()
if error_message:
self.log.error(error_message)
fail(error_message)
return True
def multithread_func(log, tasks):
"""Multi-thread function wrapper.
Args:
log: log object.
tasks: tasks to be executed in parallel.
Returns:
List of results of tasks
"""
results = run_multithread_func(log, tasks)
for res in results:
if not res:
return False
return True
def parallel_tests(self, change_env_func, setup_func=None):
if setup_func and not setup_func():
self.log.error("Test setup %s failed", setup_func.__name__)
return False
self.result_info = collections.defaultdict(int)
self.finishing_time = time.time() + self.max_run_time
results = run_multithread_func(self.log, [(self.call_test, []), (
self.message_test, []), (self.data_test, []), (
self.crash_check_test, []), (change_env_func, [])])
result_message = "%s" % dict(self.result_info)
self.log.info(result_message)
if all(results):
explicit_pass(result_message)
else:
fail(result_message)
def active_handover(self,
set_simulation_func,
phone_setup_func,
phone_idle_func_after_registration=None,
volte=True,
iperf=True,
all_bands=False,
is_wait_for_registration=True,
voice_number=DEFAULT_CALL_NUMBER,
teardown_side=CALL_TEARDOWN_PHONE,
wait_time_in_call=WAIT_TIME_IN_CALL):
try:
bts = set_simulation_func(self.anritsu, self.user_params,
self.ad.sim_card)
set_usim_parameters(self.anritsu, self.ad.sim_card)
set_post_sim_params(self.anritsu, self.user_params,
self.ad.sim_card)
self.anritsu.start_simulation()
self.anritsu.send_command("IMSSTARTVN 1")
self.anritsu.send_command("IMSSTARTVN 2")
self.anritsu.send_command("IMSSTARTVN 3")
# turn off all other BTS to ensure UE registers on BTS1
simmodel = self.anritsu.get_simulation_model().split(',')
no_of_bts = len(simmodel)
for i in range(2, no_of_bts + 1):
self.anritsu.send_command("OUTOFSERVICE OUT,BTS{}".format(i))
if phone_setup_func is not None:
if not phone_setup_func(self.ad):
self.log.warning("phone_setup_func failed. Rebooting UE")
self.ad.reboot()
time.sleep(30)
if self.ad.sim_card == "VzW12349":
set_preferred_apn_by_adb(self.ad, "VZWINTERNET")
if not phone_setup_func(self.ad):
self.log.error("phone_setup_func failed.")
if is_wait_for_registration:
self.anritsu.wait_for_registration_state()
if phone_idle_func_after_registration:
if not phone_idle_func_after_registration(self.log, self.ad):
self.log.error("phone_idle_func failed.")
for i in range(2, no_of_bts + 1):
self.anritsu.send_command("OUTOFSERVICE IN,BTS{}".format(i))
time.sleep(WAIT_TIME_ANRITSU_REG_AND_CALL)
if iperf: # setup iPerf server
server_ip = self.iperf_setup()
if not server_ip:
self.log.error("iperf server can not be reached by ping")
return False
if volte: # make a VoLTE MO call
if not make_ims_call(self.log, self.ad, self.anritsu,
voice_number):
self.log.error(
"Phone {} Failed to make volte call to {}".format(
self.ad.serial, voice_number))
return False
if all_bands and (simmodel[1] == "WCDMA"):
band = []
for rat in simmodel[:2]:
band.append(self.anritsu.get_supported_bands(rat))
self.log.info("UE reported LTE bands are {}".format(band[0]))
self.log.info("UE reported WCDMA bands are {}".format(band[1]))
current_lte_band = bts[0].band
# move current LTE band to the last in the list
band[0].remove(current_lte_band)
band[0].append(current_lte_band)
n = max(len(band[0]), len(band[1]))
else:
n = 1 # n is the number of LTE->WCDMA->LTE handovers
for i in range(n):
if all_bands:
bts[1].band = band[1][i % len(band[1])]
if not iperf: # VoLTE only
result = handover_tc(self.log, self.anritsu,
WAITTIME_BEFORE_HANDOVER,
BtsNumber.BTS1, BtsNumber.BTS2)
time.sleep(WAITTIME_AFTER_HANDOVER)
else: # with iPerf
iperf_task = (self._iperf_task,
(server_ip, WAITTIME_BEFORE_HANDOVER +
WAITTIME_AFTER_HANDOVER - 10))
ho_task = (handover_tc, (self.log, self.anritsu,
WAITTIME_BEFORE_HANDOVER,
BtsNumber.BTS1, BtsNumber.BTS2))
result = run_multithread_func(self.log,
[ho_task, iperf_task])
if not result[1]:
self.log.error("iPerf failed.")
return False
self.log.info("handover test case result code {}.".format(
result[0]))
if volte:
# check if the phone stay in call
if not self.ad.droid.telecomIsInCall():
self.log.error("Call is already ended in the phone.")
return False
if not tear_down_call(self.log, self.ad, self.anritsu):
self.log.error("Phone {} Failed to tear down".format(
self.ad.serial, voice_number))
return False
if simmodel[1] == "WCDMA" and iperf:
if all_bands:
bts[0].band = band[0][i % len(band[0])]
iperf_task = (self._iperf_task,
(server_ip, WAITTIME_BEFORE_HANDOVER +
WAITTIME_AFTER_HANDOVER - 10))
ho_task = (handover_tc, (self.log, self.anritsu,
WAITTIME_BEFORE_HANDOVER,
BtsNumber.BTS2, BtsNumber.BTS1))
result = run_multithread_func(self.log,
[ho_task, iperf_task])
if not result[1]:
self.log.error("iPerf failed.")
return False
self.log.info("handover test case result code {}.".format(
result[0]))
except AnritsuError as e:
self.log.error("Error in connection with Anritsu Simulator: " +
str(e))
return False
except Exception as e:
self.log.error("Exception during voice call procedure: " + str(e))
return False
return True