def check_normal_call(self):
result = True
if "wfc" not in self.test_name:
toggle_airplane_mode_by_adb(self.log, self.dut, False)
self.dut.ensure_screen_on()
self.dut.exit_setup_wizard()
reset_device_password(self.dut, None)
begin_time = get_current_epoch_time()
if not call_setup_teardown(
self.log,
self.android_devices[1],
self.dut,
ad_hangup=self.android_devices[1]):
self.dut.log.error("Regular MT phone call fails")
self.dut.log.info("call_info = %s", dumpsys_last_call_info(
self.dut))
result = False
if not call_setup_teardown(
self.log, self.dut, self.android_devices[1],
ad_hangup=self.dut):
self.dut.log.error("Regular MO phone call fails")
self.dut.log.info("call_info = %s", dumpsys_last_call_info(
self.dut))
result = False
return result
def check_call(self):
result = True
if not call_setup_teardown(self.log, self.android_devices[1], self.dut,
self.dut):
if not call_setup_teardown(self.log, self.android_devices[1],
self.dut, self.dut):
self.dut.log.error("MT call failed")
result = False
if not call_setup_teardown(self.log, self.dut, self.android_devices[1],
self.dut):
self.dut.log.error("MO call failed")
result = False
return result
def check_call_in_volte(self):
result = True
if not call_setup_teardown(self.log, self.android_devices[1], self.dut,
self.dut, None, is_phone_in_call_volte):
if not call_setup_teardown(self.log, self.android_devices[1],
self.dut, self.dut, None,
is_phone_in_call_volte):
self.dut.log.error("MT VoLTE call failed")
result = False
if not call_setup_teardown(self.log, self.dut, self.android_devices[1],
self.dut, is_phone_in_call_volte):
self.dut.log.error("MO VoLTE call failed")
result = False
return result
def check_call_in_wfc(self):
result = True
if not call_setup_teardown(self.log, self.android_devices[1], self.dut,
self.dut, None, is_phone_in_call_iwlan):
if not call_setup_teardown(self.log, self.android_devices[1],
self.dut, self.dut, None,
is_phone_in_call_iwlan):
self.dut.log.error("MT WFC call failed")
result = False
if not call_setup_teardown(self.log, self.dut, self.android_devices[1],
self.dut, is_phone_in_call_iwlan):
self.dut.log.error("MO WFC call failed")
result = False
return result
def _setup_phone_call(self):
if not call_setup_teardown(
self.log, self.caller, self.callee, ad_hangup=None):
self.log.error("Setup Call failed.")
return False
self.log.info("Setup call successfully.")
return True
def _setup_phone_active_call_wfc(self,
ad,
ssid,
password,
airplane_mode,
wfc_mode,
setup_volte=False):
if setup_volte and (not phone_setup_volte(self.log, ad)):
self.log.error("Phone failed to setup VoLTE.")
return False
if not phone_setup_iwlan(self.log, ad, airplane_mode, wfc_mode, ssid,
password):
self.log.error("DUT Failed to Set Up WiFi Calling")
return False
ensure_phones_idle(self.log, [ad, self.android_devices[1]])
if not phone_idle_iwlan(self.log, ad):
self.log.error("DUT not in WFC enabled state.")
return False
if not call_setup_teardown(self.log,
ad,
self.android_devices[1],
ad_hangup=None,
verify_caller_func=is_phone_in_call_iwlan):
self.log.error("Setup Call failed.")
return False
ad.droid.goToSleepNow()
return True
def test_sms_mt_in_call_volte(self):
""" Test MT SMS during a MO VoLTE call.
Make Sure PhoneA is in LTE mode (with VoLTE).
Make Sure PhoneB is able to make/receive call.
Call from PhoneA to PhoneB, accept on PhoneB, receive SMS on PhoneA.
Returns:
True if pass; False if fail.
"""
ads = self.android_devices
tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_volte,
(self.log, ads[1]))]
if not multithread_func(self.log, tasks):
self.log.error("Phone Failed to Set Up Properly.")
return False
self.log.info("Begin In Call SMS Test.")
if not call_setup_teardown(self.log,
ads[0],
ads[1],
ad_hangup=None,
verify_caller_func=is_phone_in_call_volte,
verify_callee_func=None):
return False
if not self._sms_test_mt(ads):
self.log.error("SMS test fail.")
return False
return True
def test_sms_mt_in_call_iwlan(self):
""" Test MT SMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
Make Sure PhoneA APM, WiFi connected, WFC WiFi preferred mode.
Make sure PhoneA report iwlan as data rat.
Make Sure PhoneB is able to make/receive call/sms.
Call from PhoneA to PhoneB, accept on PhoneB.
Receive SMS on PhoneA.
Returns:
True if pass; False if fail.
"""
ads = self.android_devices
tasks = [(phone_setup_iwlan,
(self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED,
self.wifi_network_ssid, self.wifi_network_pass)),
(phone_setup_voice_general, (self.log, ads[1]))]
if not multithread_func(self.log, tasks):
self.log.error("Phone Failed to Set Up Properly.")
return False
self.log.info("Begin In Call SMS Test.")
if not call_setup_teardown(self.log,
ads[0],
ads[1],
ad_hangup=None,
verify_caller_func=is_phone_in_call_iwlan,
verify_callee_func=None):
return False
return self._sms_test_mt(ads)
def _setup_phone_active_call(self):
if not call_setup_teardown(
self.log, self.ad, self.android_devices[1], ad_hangup=None):
self.log.error("Setup Call failed.")
return False
self.log.info("Setup active call successfully.")
return True
def test_smoke_wfc_call_sms(self):
ads = self.android_devices
sms_idle_result = False
sms_incall_result = False
call_result = False
self.log.info("--------start test_smoke_wfc_call_sms--------")
for ad in [ads[0], ads[1]]:
if not ad.droid.imsIsWfcEnabledByPlatform():
self.log.info("WFC not supported by platform.")
return True
try:
ensure_phones_default_state(self.log, ads)
tasks = [(phone_setup_iwlan,
(self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED,
self.wifi_network_ssid, self.wifi_network_pass)),
(phone_setup_iwlan,
(self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED,
self.wifi_network_ssid, self.wifi_network_pass))]
if not multithread_func(self.log, tasks):
self.log.error("Phone Failed to Set Up WiFI Calling.")
return False
self.log.info("1. Verify SMS in idle.")
if sms_send_receive_verify(self.log, ads[0], ads[1],
[rand_ascii_str(50)]):
sms_idle_result = True
self.log.info("2. Setup WiFi Call.")
if not call_setup_teardown(
self.log,
ads[0],
ads[1],
ad_hangup=None,
verify_caller_func=is_phone_in_call_iwlan,
verify_callee_func=is_phone_in_call_iwlan):
self.log.error("Setup WiFi Call Failed.")
self.log.info("sms_idle_result:{}".format(sms_idle_result))
return False
self.log.info("3. Verify SMS in call.")
if sms_send_receive_verify(self.log, ads[0], ads[1],
[rand_ascii_str(51)]):
sms_incall_result = True
self.log.info("4. Verify Call not drop and hangup.")
if (is_phone_in_call_iwlan(self.log, ads[0])
and is_phone_in_call_iwlan(self.log, ads[1])
and hangup_call(self.log, ads[0])):
call_result = True
return (call_result and sms_idle_result and sms_incall_result)
finally:
self.log.info(
"Summary for test run. Testbed:<{}>. <WFC> SMS idle: {}, "
"SMS in call: {}, Voice Call: {}".format(
getattr(self, Config.ikey_testbed_name.value),
sms_idle_result, sms_incall_result, call_result))
def _check_volte_enabled(self):
if phone_idle_volte(self.log, self.dut):
self.dut.log.info("VoLTE is enabled")
else:
self.dut.log.error("VoLTE is not enabled")
return False
if not call_setup_teardown(self.log, self.dut, self.ad_reference,
self.dut, is_phone_in_call_volte):
self.log.error("VoLTE Call Failed.")
return False
if not self._check_lte_data():
return False
return True
def _check_csfb_enabled(self):
if not call_setup_teardown(self.log, self.dut, self.ad_reference,
self.dut, is_phone_in_call_csfb):
self.log.error("CSFB Call Failed.")
return False
if not wait_for_network_generation(
self.log, self.dut, GEN_4G,
voice_or_data=NETWORK_SERVICE_DATA):
self.dut.log.error("Data service failed to camp to 4G")
return False
if not verify_internet_connection(self.log, self.dut):
self.log.error("Data not available on cell.")
return False
return True
def _make_phone_call(self, ads):
self.result_info["Total Calls"] += 1
if not call_setup_teardown(self.log,
ads[0],
ads[1],
ad_hangup=ads[random.randrange(0, 2)],
wait_time_in_call=random.randrange(
self.min_phone_call_duration,
self.max_phone_call_duration)):
self.log.error("Call setup and teardown failed.")
self.result_info["Call Failure"] += 1
return False
self.log.info("Call setup and teardown succeed.")
return True
def _mo_sms_in_3g_call(self, ads):
self.log.info("Begin In Call SMS Test.")
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=None):
return False
if not self._sms_test_mo(ads):
self.log.error("SMS test fail.")
return False
return True
def _check_wfc_apm(self):
if CAPABILITY_WFC in self.dut_capabilities:
self.log.info("Check WFC in APM")
if not phone_setup_iwlan(
self.log, self.dut, True, WFC_MODE_CELLULAR_PREFERRED,
self.wifi_network_ssid, self.wifi_network_pass):
self.log.error("Failed to setup WFC.")
return False
if not call_setup_teardown(self.log, self.dut, self.ad_reference,
self.dut, is_phone_in_call_iwlan):
self.log.error("WFC Call Failed.")
return False
else:
return True
return False
def _setup_phone_call(self, test_video):
if test_video:
if not video_call_setup(
self.log,
self.android_devices[0],
self.android_devices[1],
):
self.log.error("Failed to setup Video call")
return False
else:
if not call_setup_teardown(
self.log, self.caller, self.callee, ad_hangup=None):
self.log.error("Setup Call failed.")
return False
self.log.info("Setup call successfully.")
return True
def _setup_phone_call(self, test_video, phone_call_duration=WAIT_TIME_IN_CALL):
if test_video:
if not video_call_setup(
self.log,
self.android_devices[0],
self.android_devices[1],
):
self.log.error("Failed to setup Video call")
return False
else:
if not call_setup_teardown(
self.log, self.caller, self.callee, ad_hangup=None, wait_time_in_call=phone_call_duration):
self.log.error("Setup Call failed.")
return False
self.log.info("Setup call successfully.")
return True
def _check_volte(self, ad, ad_reference):
if (CAPABILITY_VOLTE in device_capabilities[self.dut_model] and
CAPABILITY_VOLTE in operator_capabilities[self.dut_operator]):
self.log.info("Check VoLTE")
if not phone_setup_volte(self.log, ad):
self.log.error("Failed to setup VoLTE.")
return False
if not call_setup_teardown(self.log, ad, ad_reference, ad,
is_phone_in_call_volte):
self.log.error("VoLTE Call Failed.")
return False
if not sms_send_receive_verify(self.log, ad, ad_reference,
[rand_ascii_str(50)]):
self.log.error("SMS failed")
return False
return True
def _check_3g(self):
self.log.info("Check 3G data and CS call")
if not phone_setup_voice_3g(self.log, self.dut):
self.log.error("Failed to setup 3G")
return False
if not verify_http_connection(self.log, self.dut):
self.log.error("Data not available on cell.")
return False
if not call_setup_teardown(self.log, self.dut, self.ad_reference,
self.dut, is_phone_in_call_3g):
self.log.error("WFC Call Failed.")
return False
if not sms_send_receive_verify(self.log, self.dut, self.ad_reference,
[rand_ascii_str(50)]):
self.log.error("SMS failed")
return False
return True
def _check_wfc(self, ad, ad_reference):
if (CAPABILITY_WFC in device_capabilities[self.dut_model] and
CAPABILITY_WFC in operator_capabilities[self.dut_operator]):
self.log.info("Check WFC")
if not phone_setup_iwlan(self.log, ad, True, WFC_MODE_WIFI_PREFERRED,
self.wifi_network_ssid, self.wifi_network_pass):
self.log.error("Failed to setup WFC.")
return False
if not call_setup_teardown(self.log, ad, ad_reference, ad,
is_phone_in_call_iwlan):
self.log.error("WFC Call Failed.")
return False
if not sms_send_receive_verify(self.log, ad, ad_reference,
[rand_ascii_str(50)]):
self.log.error("SMS failed")
return False
return True
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 _check_wfc_enabled(self):
if not wait_for_wifi_data_connection(self.log, self.dut, True):
self.dut.log.error("Failed to connect to WIFI")
return False
if not wait_for_wfc_enabled(self.log, self.dut):
self.dut.log.error("WFC is not enabled")
return False
if not wait_for_network_rat(self.log,
self.dut,
RAT_FAMILY_WLAN,
voice_or_data=NETWORK_SERVICE_DATA):
ad.log.info("Data rat can not go to iwlan mode successfully")
return False
if not call_setup_teardown(self.log, self.dut, self.ad_reference,
self.dut, is_phone_in_call_iwlan):
self.log.error("WFC Call Failed.")
return False
return True
def _make_phone_call(self, ads):
self.result_info["Total Calls"] += 1
begin_time = get_current_epoch_time()
start_qxdm_loggers(self.log, self.android_devices)
if not call_setup_teardown(
self.log,
ads[0],
ads[1],
ad_hangup=ads[random.randrange(0, 2)],
wait_time_in_call=random.randrange(
self.min_phone_call_duration,
self.max_phone_call_duration)):
self.log.error("Call setup and teardown failed.")
self.result_info["Call Failure"] += 1
self._take_bug_report("%s_call_failure" % self.test_name,
begin_time)
return False
self.log.info("Call setup and teardown succeed.")
return True
def test_ota_upgrade(self):
ota_package = self.user_params.get("ota_package")
if isinstance(ota_package, list):
ota_package = ota_package[0]
if ota_package and "dev/null" not in ota_package:
self.log.info("Upgrade with ota_package %s", ota_package)
self.log.info("Before OTA upgrade: %s",
get_info(self.android_devices))
else:
raise signals.TestSkip("No ota_package is defined")
ota_util = self.user_params.get("ota_util")
if isinstance(ota_util, list):
ota_util = ota_util[0]
if ota_util:
if "update_engine_client.zip" in ota_util:
self.user_params["UpdateDeviceOtaTool"] = ota_util
self.user_params["ota_tool"] = "UpdateDeviceOtaTool"
else:
self.user_params["AdbSideloadOtaTool"] = ota_util
self.user_params["ota_tool"] = "AdbSideloadOtaTool"
self.log.info("OTA upgrade with %s by %s", ota_package,
self.user_params["ota_tool"])
ota_updater.initialize(self.user_params, self.android_devices)
tasks = [(self._ota_upgrade, [ad]) for ad in self.android_devices]
try:
result = multithread_func(self.log, tasks)
except Exception as err:
abort_all_tests(self.log, "Unable to do ota upgrade: %s" % err)
device_info = get_info(self.android_devices)
self.log.info("After OTA upgrade: %s", device_info)
self.results.add_controller_info("AndroidDevice", device_info)
if len(self.android_devices) > 1:
caller = self.android_devices[0]
callee = self.android_devices[1]
return call_setup_teardown(
self.log, caller, callee, caller,
self._get_call_verification_function(caller),
self._get_call_verification_function(callee)) and result
return result
def call_drop_by_modem_crash(self,
call_verification_function=None,
vt=False):
if vt:
if not video_call_setup_teardown(
self.log,
self.dut,
self.ad_reference,
None,
video_state=VT_STATE_BIDIRECTIONAL,
verify_caller_func=is_phone_in_call_video_bidirectional,
verify_callee_func=is_phone_in_call_video_bidirectional):
self.dut.log.error("VT Call Failed.")
return False
else:
if not call_setup_teardown(
self.log,
self.dut,
self.ad_reference,
ad_hangup=None,
verify_caller_func=call_verification_function,
wait_time_in_call=10):
self.log.error("Call setup failed")
return False
# Modem SSR
self.modem_crash()
try:
if self.dut.droid.telecomIsInCall():
self.dut.log.info("Still in call after trigger modem crash")
return False
else:
reasons = self.dut.search_logcat(
"qcril_qmi_voice_map_qmi_to_ril_last_call_failure_cause")
if reasons:
self.dut.log.info(reasons[-1]["log_message"])
except Exception as e:
self.dut.log.error(e)
def _setup_phone_active_call(self, ad, phone_setup_func,
phone_idle_check_func,
phone_in_call_check_func):
if not phone_setup_func(self.log, ad):
self.log.error("DUT Failed to Set Up Properly: {}".format(
phone_setup_func.__name__))
return False
ensure_phones_idle(self.log, [ad, self.android_devices[1]])
if not phone_idle_check_func(self.log, ad):
self.log.error("DUT not in correct idle state: {}".format(
phone_idle_check_func.__name__))
return False
if not call_setup_teardown(
self.log,
ad,
self.android_devices[1],
ad_hangup=None,
verify_caller_func=phone_in_call_check_func):
self.log.error("Setup Call failed.")
return False
ad.droid.goToSleepNow()
return True
def test_sms_mo_in_call_csfb_1x(self):
""" Test MO SMS during a MO csfb 1x call.
Make Sure PhoneA is in LTE mode (no VoLTE).
Make Sure PhoneB is able to make/receive call.
Call from PhoneA to PhoneB, accept on PhoneB, send SMS on PhoneA.
Returns:
True if pass; False if fail.
"""
ads = self.android_devices
# make sure PhoneA is CDMA phone before proceed.
if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA):
self.log.error("Not CDMA phone, abort this csfb 1x SMS test.")
return False
tasks = [(phone_setup_csfb, (self.log, ads[0])),
(phone_setup_voice_general, (self.log, ads[1]))]
if not multithread_func(self.log, tasks):
self.log.error("Phone Failed to Set Up Properly.")
return False
self.log.info("Begin In Call SMS Test.")
if not call_setup_teardown(self.log,
ads[0],
ads[1],
ad_hangup=None,
verify_caller_func=is_phone_in_call_1x,
verify_callee_func=None):
return False
if not self._sms_test_mo(ads):
self.log.error("SMS test fail.")
return False
return True
def test_sms_mt_in_call_gsm(self):
""" Test MT SMS during a MO gsm call.
Make Sure PhoneA is in gsm mode.
Make Sure PhoneB is able to make/receive call.
Call from PhoneA to PhoneB, accept on PhoneB, receive SMS on PhoneA.
Returns:
True if pass; False if fail.
"""
ads = self.android_devices
# make sure PhoneA is GSM phone before proceed.
if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM):
self.log.error("Not GSM phone, abort this gsm SMS test.")
return False
tasks = [(phone_setup_voice_2g, (self.log, ads[0])),
(phone_setup_voice_general, (self.log, ads[1]))]
if not multithread_func(self.log, tasks):
self.log.error("Phone Failed to Set Up Properly.")
return False
self.log.info("Begin In Call SMS Test.")
if not call_setup_teardown(self.log,
ads[0],
ads[1],
ad_hangup=None,
verify_caller_func=is_phone_in_call_2g,
verify_callee_func=None):
return False
if not self._sms_test_mt(ads):
self.log.error("SMS test fail.")
return False
return True
def _check_volte(self):
if CAPABILITY_VOLTE in self.dut_capabilities:
self._set_volte_provisioning()
if not self._check_volte_provisioning():
return False
self.log.info("Check VoLTE")
if not wait_for_state(self.dut.droid.imsIsVolteProvisionedOnDevice,
True):
self.dut.log.error("VoLTE provisioning is disabled.")
return False
if not phone_setup_volte(self.log, self.dut):
self.log.error("Failed to setup VoLTE.")
return False
time.sleep(5)
if not call_setup_teardown(self.log, self.dut, self.ad_reference,
self.dut, is_phone_in_call_volte):
self.log.error("VoLTE Call Failed.")
return False
if not self._check_lte_data():
return False
else:
self.dut.log.info("VoLTE is not supported")
return False
return True
def two_phone_call_long_seq(log,
phone_a,
phone_a_idle_func,
phone_a_in_call_check_func,
phone_b,
phone_b_idle_func,
phone_b_in_call_check_func,
call_sequence_func=None,
wait_time_in_call=WAIT_TIME_IN_CALL):
"""Call process long sequence.
1. Ensure phone idle and in idle_func check return True.
2. Call from PhoneA to PhoneB, accept on PhoneB.
3. Check phone state, hangup on PhoneA.
4. Ensure phone idle and in idle_func check return True.
5. Call from PhoneA to PhoneB, accept on PhoneB.
6. Check phone state, hangup on PhoneB.
7. Ensure phone idle and in idle_func check return True.
8. Call from PhoneB to PhoneA, accept on PhoneA.
9. Check phone state, hangup on PhoneA.
10. Ensure phone idle and in idle_func check return True.
11. Call from PhoneB to PhoneA, accept on PhoneA.
12. Check phone state, hangup on PhoneB.
Args:
phone_a: PhoneA's android device object.
phone_a_idle_func: function to check PhoneA's idle state.
phone_a_in_call_check_func: function to check PhoneA's in-call state.
phone_b: PhoneB's android device object.
phone_b_idle_func: function to check PhoneB's idle state.
phone_b_in_call_check_func: function to check PhoneB's in-call state.
call_sequence_func: default parameter, not implemented.
wait_time_in_call: time to wait in call.
This is optional, default is WAIT_TIME_IN_CALL
Returns:
True: if call sequence succeed.
False: for errors
"""
ads = [phone_a, phone_b]
call_params = [
(ads[0], ads[1], ads[0], phone_a_in_call_check_func,
phone_b_in_call_check_func),
(ads[0], ads[1], ads[1], phone_a_in_call_check_func,
phone_b_in_call_check_func),
(ads[1], ads[0], ads[0], phone_b_in_call_check_func,
phone_a_in_call_check_func),
(ads[1], ads[0], ads[1], phone_b_in_call_check_func,
phone_a_in_call_check_func),
]
for param in call_params:
# Make sure phones are idle.
ensure_phones_idle(log, ads)
if phone_a_idle_func and not phone_a_idle_func(log, phone_a):
log.error("Phone A Failed to Reselect")
return False
if phone_b_idle_func and not phone_b_idle_func(log, phone_b):
log.error("Phone B Failed to Reselect")
return False
# TODO: b/26337871 Need to use proper API to check phone registered.
time.sleep(WAIT_TIME_BETWEEN_REG_AND_CALL)
# Make call.
log.info("---> Call test: {} to {} <---".format(
param[0].serial, param[1].serial))
if not call_setup_teardown(
log, *param, wait_time_in_call=wait_time_in_call):
log.error("Call Iteration Failed")
return False
return True
