def check_incall_data(self):
if verify_internet_connection_by_ping(self.log, self.dut):
self.internet_connection_check_method = verify_internet_connection_by_ping
elif verify_http_connection(self.log, self.dut):
self.internet_connection_check_method = verify_http_connection
else:
self.dut.log.error("Data test failed")
raise signals.TestFailure("Data check failed")
if self.single_phone_test:
if not initiate_call(
self.log, self.dut,
self.call_server_number) and wait_for_in_call_active(
self.dut, 60, 3):
self._take_bug_report(self.test_name, self.begin_time)
raise signals.TestFailure("Unable to make phone call")
else:
if not call_setup_teardown(
self.log, self.dut, self.android_devices[1],
ad_hangup=None):
self._take_bug_report(self.test_name, self.begin_time)
raise signals.TestFailure("Unable to make phone call")
voice_rat = self.dut.droid.telephonyGetCurrentVoiceNetworkType()
data_rat = self.dut.droid.telephonyGetCurrentDataNetworkType()
self.dut.log.info("Voice in RAT %s, Data in RAT %s", voice_rat,
data_rat)
try:
if is_rat_svd_capable(voice_rat.upper()) and is_rat_svd_capable(
data_rat.upper()):
self.dut.log.info("Capable for simultaneous voice and data")
if not self.internet_connection_check_method(
self.log, self.dut):
self.dut.log.error("Incall data check failed")
raise signals.TestFailure("Incall data check failed")
else:
return True
else:
self.dut.log.info(
"Not capable for simultaneous voice and data")
return False
hangup_call(self.log, self.dut)
finally:
for ad in self.android_devices:
if ad.droid.telecomIsInCall():
hangup_call(self.log, ad)
def _data_download(self, file_names=["5MB", "10MB", "20MB", "50MB"]):
begin_time = get_current_epoch_time()
start_qxdm_loggers(self.log, self.android_devices)
self.dut.log.info(dict(self.result_info))
selection = random.randrange(0, len(file_names))
file_name = file_names[selection]
self.result_info["Internet Connection Check Total"] += 1
if not self.internet_connection_check_method(self.log, self.dut):
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.result_info[
"Expected Incall Internet Connection Check Failure"] += 1
return True
else:
self.result_info["Internet Connection Check Failure"] += 1
test_name = "%s_internet_connection_No_%s_failure" % (
self.test_name,
self.result_info["Internet Connection Check Failure"])
try:
self._ad_take_extra_logs(self.dut, test_name, begin_time)
self._ad_take_bugreport(self.dut, test_name, begin_time)
except Exception as e:
self.log.exception(e)
return False
else:
self.result_info["Internet Connection Check Success"] += 1
self.result_info["File Download Total"] += 1
if not active_file_download_test(
self.log, self.dut, file_name,
method=self.file_download_method):
self.result_info["File Download Failure"] += 1
if self.result_info["File Download Failure"] == 1:
try:
self._ad_take_extra_logs(
self.dut, "%s_file_download_failure" % self.test_name,
begin_time)
self._ad_take_bugreport(
self.dut, "%s_file_download_failure" % self.test_name,
begin_time)
except Exception as e:
self.log.exception(e)
return False
else:
self.result_info["File Download Success"] += 1
return True
def test_smoke_3g_call_data_sms(self):
try:
ads = self.android_devices
sms_idle_result = False
sms_incall_result = False
data_idle_result = False
data_incall_result = False
call_result = False
self.log.info("--------start test_smoke_3g_call_data_sms--------")
ensure_phones_default_state(self.log, ads)
tasks = [(phone_setup_voice_3g, (self.log, ads[0])),
(phone_setup_voice_3g, (self.log, ads[1]))]
if not multithread_func(self.log, tasks):
self.log.error("Phone Failed to Set Up 3G.")
return False
self.log.info("1. SMS in 3G idle.")
sms_idle_result = sms_send_receive_verify(self.log, ads[0], ads[1],
[rand_ascii_str(50)])
self.log.info("2. Data in 3G idle.")
if (wait_for_cell_data_connection(self.log, ads[0], True)
and verify_http_connection(self.log, ads[0])):
data_idle_result = True
self.log.info("3. Setup 3G Call.")
if not call_setup_teardown(self.log,
ads[0],
ads[1],
ad_hangup=None,
verify_caller_func=is_phone_in_call_3g,
verify_callee_func=is_phone_in_call_3g):
self.log.error("Setup 3G Call Failed.")
return False
self.log.info("4. Verify SMS in call.")
sms_incall_result = sms_send_receive_verify(
self.log, ads[0], ads[1], [rand_ascii_str(51)])
self.log.info("5. Verify Data in call.")
if is_rat_svd_capable(
get_network_rat(self.log, ads[0], NETWORK_SERVICE_VOICE)):
if (wait_for_cell_data_connection(self.log, ads[0], True)
and verify_http_connection(self.log, ads[0])):
data_incall_result = True
else:
self.log.info("Data in call not supported on current RAT."
"Skip Data verification.")
data_incall_result = SKIP
self.log.info("6. Verify Call not drop and hangup.")
if (is_phone_in_call_3g(self.log, ads[0])
and is_phone_in_call_3g(self.log, ads[1])
and hangup_call(self.log, ads[0])):
call_result = True
return (sms_idle_result and data_idle_result and call_result
and sms_incall_result and ((data_incall_result is True) or
(data_incall_result == SKIP)))
finally:
self.log.info(
"Summary for test run. Testbed:<{}>. <3G> SMS idle: {}, "
"Data idle: {}, SMS in call: {}, Data in call: {}, "
"Voice Call: {}".format(
getattr(self, Config.ikey_testbed_name.value),
sms_idle_result, data_idle_result, sms_incall_result,
data_incall_result, call_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