def setup_and_connect(self, ap_settings):
"""Generates a hostapd config, setups up the AP with that config, then
attempts to associate a DUT
Args:
ap_settings: A dictionary of hostapd constant n_capabilities.
"""
security_profile = None
password = None
temp_n_capabilities = list(ap_settings['n_capabilities'])
n_capabilities = []
for n_capability in temp_n_capabilities:
if n_capability in hostapd_constants.N_CAPABILITIES_MAPPING.keys():
n_capabilities.append(n_capability)
if ap_settings['chbw'] == 'HT20' or ap_settings['chbw'] == 'HT40+':
if ap_settings['frequency'] == '2.4GHz':
channel = 1
elif ap_settings['frequency'] == '5GHz':
channel = 36
else:
raise ValueError('Invalid frequence: %s' %
ap_settings['frequency'])
if ap_settings['chbw'] == 'HT40-':
if ap_settings['frequency'] == '2.4GHz':
channel = 11
elif ap_settings['frequency'] == '5GHz':
channel = 60
else:
raise ValueError('Invalid frequency: %s' %
ap_settings['frequency'])
if ap_settings['chbw'] == 'HT40-' or ap_settings['chbw'] == 'HT40+':
if hostapd_config.ht40_plus_allowed(channel):
extended_channel = hostapd_constants.N_CAPABILITY_HT40_PLUS
elif hostapd_config.ht40_minus_allowed(channel):
extended_channel = hostapd_constants.N_CAPABILITY_HT40_MINUS
else:
raise ValueError('Invalid channel: %s' % channel)
n_capabilities.append(extended_channel)
if ap_settings['security'] == 'wpa2':
security_profile = Security(security_mode=SECURITY_WPA2,
password=rand_ascii_str(20),
wpa_cipher='CCMP',
wpa2_cipher='CCMP')
password = security_profile.password
validate_setup_ap_and_associate(access_point=self.access_point,
client=self.dut,
profile_name='whirlwind',
mode=hostapd_constants.MODE_11N_MIXED,
channel=channel,
n_capabilities=n_capabilities,
ac_capabilities=[],
force_wmm=True,
ssid=utils.rand_ascii_str(20),
security=security_profile,
password=password)
def get_open_network(self,
ap_count=1,
ssid_length_2g=hostapd_constants.AP_SSID_LENGTH_2G,
ssid_length_5g=hostapd_constants.AP_SSID_LENGTH_5G):
"""Generates SSIDs for a open network using a random generator.
Args:
ap_count: Determines if we want to use one or both the APs for
for configuration. If set to '2', then both APs will
be configured with the same configuration.
ssid_length_2g: Int, number of characters to use for 2G SSID.
ssid_length_5g: Int, number of characters to use for 5G SSID.
Returns: A dict of 2G and 5G network lists for hostapd configuration.
"""
network_dict_2g = {}
network_dict_5g = {}
self.user_params["open_network"] = []
open_2g_ssid = '2g_%s' % utils.rand_ascii_str(ssid_length_2g)
open_5g_ssid = '5g_%s' % utils.rand_ascii_str(ssid_length_5g)
network_dict_2g = {"SSID": open_2g_ssid, "security": 'none'}
network_dict_5g = {"SSID": open_5g_ssid, "security": 'none'}
for ap in range(ap_count):
self.user_params["open_network"].append({
"2g": network_dict_2g,
"5g": network_dict_5g
})
self.open_network = self.user_params["open_network"]
return {"2g": network_dict_2g, "5g": network_dict_5g}
def setup_class(self):
super().setup_class()
if 'dut' in self.user_params:
if self.user_params['dut'] == 'fuchsia_devices':
self.dut = create_wlan_device(self.fuchsia_devices[0])
elif self.user_params['dut'] == 'android_devices':
self.dut = create_wlan_device(self.android_devices[0])
else:
raise ValueError('Invalid DUT specified in config. (%s)' %
self.user_params['dut'])
else:
# Default is an android device, just like the other tests
self.dut = create_wlan_device(self.android_devices[0])
self.access_point = self.access_points[0]
# Same for both 2g and 5g
self.ssid = utils.rand_ascii_str(hostapd_constants.AP_SSID_LENGTH_2G)
self.password = utils.rand_ascii_str(
hostapd_constants.AP_PASSPHRASE_LENGTH_2G)
self.security_profile_wpa2 = Security(
security_mode=hostapd_constants.WPA2_STRING,
password=self.password,
wpa2_cipher=hostapd_constants.WPA2_DEFAULT_CIPER)
self.access_point.stop_all_aps()
def create_softap_config(self):
"""Create a softap config with ssid and password."""
ap_ssid = "softap_" + utils.rand_ascii_str(8)
ap_password = utils.rand_ascii_str(8)
self.dut.log.info("softap setup: %s %s", ap_ssid, ap_password)
config = {wutils.WifiEnums.SSID_KEY: ap_ssid}
config[wutils.WifiEnums.PWD_KEY] = ap_password
return config
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 sms_send_outgoing_texts(self, pri_dut, sec_dut):
self.log.info("Test send sms of different sizes.")
input("Press enter to execute this testcase...")
msg = [rand_ascii_str(50), rand_ascii_str(1), rand_ascii_str(500)]
if not sms_send_receive_verify(self.log, pri_dut, sec_dut, msg):
return False
else:
self.log.info("Successfully sent sms. Please verify on carkit.")
return True
def get_open_network(self,
mirror_ap,
open_network,
hidden=False,
same_ssid=False,
ssid_length_2g=hostapd_constants.AP_SSID_LENGTH_2G,
ssid_length_5g=hostapd_constants.AP_SSID_LENGTH_5G,
security_mode='none'):
"""Generates SSIDs for a open network using a random generator.
Args:
mirror_ap: Boolean, determines if both APs use the same hostapd
config or different configs.
open_network: List of open networks.
same_ssid: Boolean, determines if both bands on AP use the same
SSID.
ssid_length_2g: Int, number of characters to use for 2G SSID.
ssid_length_5g: Int, number of characters to use for 5G SSID.
security_mode: 'none' for open and 'OWE' for WPA3 OWE.
Returns: A dict of 2G and 5G network lists for hostapd configuration.
"""
network_dict_2g = {}
network_dict_5g = {}
if same_ssid:
open_2g_ssid = 'xg_%s' % utils.rand_ascii_str(ssid_length_2g)
open_5g_ssid = open_2g_ssid
else:
open_2g_ssid = '2g_%s' % utils.rand_ascii_str(ssid_length_2g)
open_5g_ssid = '5g_%s' % utils.rand_ascii_str(ssid_length_5g)
network_dict_2g = {
"SSID": open_2g_ssid,
"security": security_mode,
"hiddenSSID": hidden
}
network_dict_5g = {
"SSID": open_5g_ssid,
"security": security_mode,
"hiddenSSID": hidden
}
ap = 0
for ap in range(MAX_AP_COUNT):
open_network.append({
"2g": copy.copy(network_dict_2g),
"5g": copy.copy(network_dict_5g)
})
if not mirror_ap:
break
return {"2g": network_dict_2g, "5g": network_dict_5g}
def get_wpa2_network(
self,
ap_count=1,
ssid_length_2g=hostapd_constants.AP_SSID_LENGTH_2G,
ssid_length_5g=hostapd_constants.AP_SSID_LENGTH_5G,
passphrase_length_2g=hostapd_constants.AP_PASSPHRASE_LENGTH_2G,
passphrase_length_5g=hostapd_constants.AP_PASSPHRASE_LENGTH_5G):
"""Generates SSID and passphrase for a WPA2 network using random
generator.
Args:
ap_count: Determines if we want to use one or both the APs
for configuration. If set to '2', then both APs will
be configured with the same configuration.
ssid_length_2g: Int, number of characters to use for 2G SSID.
ssid_length_5g: Int, number of characters to use for 5G SSID.
passphrase_length_2g: Int, length of password for 2G network.
passphrase_length_5g: Int, length of password for 5G network.
Returns: A dict of 2G and 5G network lists for hostapd configuration.
"""
network_dict_2g = {}
network_dict_5g = {}
ref_5g_security = hostapd_constants.WPA2_STRING
ref_2g_security = hostapd_constants.WPA2_STRING
self.user_params["reference_networks"] = []
ref_2g_ssid = '2g_%s' % utils.rand_ascii_str(ssid_length_2g)
ref_2g_passphrase = utils.rand_ascii_str(passphrase_length_2g)
ref_5g_ssid = '5g_%s' % utils.rand_ascii_str(ssid_length_5g)
ref_5g_passphrase = utils.rand_ascii_str(passphrase_length_5g)
network_dict_2g = {
"SSID": ref_2g_ssid,
"security": ref_2g_security,
"password": ref_2g_passphrase
}
network_dict_5g = {
"SSID": ref_5g_ssid,
"security": ref_5g_security,
"password": ref_5g_passphrase
}
for ap in range(ap_count):
self.user_params["reference_networks"].append({
"2g":
network_dict_2g,
"5g":
network_dict_5g
})
self.reference_networks = self.user_params["reference_networks"]
return {"2g": network_dict_2g, "5g": network_dict_5g}
def test_wrong_password_whirlwind_5g(self):
self.connect_disconnect(
{
'profile':
'whirlwind',
'channel':
self.channel_5G,
'security':
hostapd_security.Security(security_mode='wpa2',
password=rand_ascii_str(10))
},
password=rand_ascii_str(20),
negative_test=True)
def test_soft_ap_5g_wpa2_local(self):
self.verify_soft_ap_associate_and_pass_traffic(
self.primary_client, {
'ssid':
utils.rand_ascii_str(hostapd_constants.AP_SSID_LENGTH_5G),
'security_type':
SECURITY_WPA2,
'password':
utils.rand_ascii_str(hostapd_constants.MIN_WPA_PSK_LENGTH),
'connectivity_mode':
CONNECTIVITY_MODE_LOCAL,
'operating_band':
OPERATING_BAND_5G
})
def test_soft_ap_any_wpa3_unrestricted(self):
self.verify_soft_ap_associate_and_pass_traffic(
self.primary_client, {
'ssid':
utils.rand_ascii_str(hostapd_constants.AP_SSID_LENGTH_5G),
'security_type':
SECURITY_WPA3,
'password':
utils.rand_ascii_str(hostapd_constants.MIN_WPA_PSK_LENGTH),
'connectivity_mode':
CONNECTIVITY_MODE_UNRESTRICTED,
'operating_band':
OPERATING_BAND_ANY
})
def _send_message(self, 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)
text = rand_ascii_str(length)
message_content_map = {0: [text], 1: [("Mms Message", text, None)]}
message_func_map = {
0: sms_send_receive_verify,
1: mms_send_receive_verify
}
message_type = message_type_map[selection]
self.result_info["Total %s" % message_type] += 1
begin_time = get_current_epoch_time()
start_qxdm_loggers(self.log, self.android_devices)
if not message_func_map[selection](self.log, ads[0], ads[1],
message_content_map[selection]):
self.log.error("%s of length %s from %s to %s fails", message_type,
length, ads[0].serial, ads[1].serial)
self.result_info["%s failure" % message_type] += 1
if message_type == "SMS" or self.result_info["%s failure" %
message_type] == 1:
self._take_bug_report("%s_%s_failure" % (self.test_name,
message_type),
begin_time)
return False
else:
self.log.info("%s of length %s from %s to %s succeed",
message_type_map[selection], length, ads[0].serial,
ads[1].serial)
return True
def stress_test(self, setup_func=None, network_check_func=None, test_sms=False):
if setup_func and not setup_func():
self.log.error("Test setup %s failed", setup_func.__name__)
return False
fail_count = collections.defaultdict(int)
for i in range(1, self.phone_call_iteration + 1):
msg = "Stress Call Test %s Iteration: <%s> / <%s>" % (
self.test_name, i, self.phone_call_iteration)
self.log.info(msg)
iteration_result = True
ensure_phones_idle(self.log, self.android_devices)
if not self._setup_phone_call():
fail_count["dialing"] += 1
iteration_result = False
self.log.error("%s call dialing failure.", msg)
if network_check_func and not network_check_func(self.log,
self.caller):
fail_count["caller_network_check"] += 1
iteration_result = False
self.log.error("%s network check %s failure.", msg,
network_check_func.__name__)
if network_check_func and not network_check_func(self.log,
self.callee):
fail_count["callee_network_check"] += 1
iteration_result = False
self.log.error("%s network check failure.", msg)
time.sleep(self.phone_call_duration)
if not verify_incall_state(self.log, [self.caller, self.callee],
True):
self.log.error("%s call dropped.", msg)
iteration_result = False
fail_count["drop"] += 1
self._hangup_call()
if test_sms and not sms_send_receive_verify(
self.log, self.caller, self.callee, [rand_ascii_str(180)]):
fail_count["sms"] += 1
self.log.info("%s %s" % (msg, str(iteration_result)))
if not iteration_result:
self._take_bug_report("%s_%s" % (self.test_name, i), self.begin_time)
if self.sleep_time_between_test_iterations:
self.caller.droid.goToSleepNow()
self.callee.droid.goToSleepNow()
time.sleep(self.sleep_time_between_test_iterations)
test_result = True
for failure, count in fail_count.items():
if count:
self.log.error("%s: %s %s failures in %s iterations".format(
self.test_name, count, failure, self.phone_call_iteration))
test_result = False
return test_result
def setup_and_connect(self, ap_settings):
"""Uses ap_settings to set up ap and then attempts to associate a DUT.
Args:
ap_settings: a dict containing test case settings, including
bandwidth, security, n_capabilities, and ac_capabilities
"""
security = ap_settings['security']
chbw = ap_settings['chbw']
password = None
if security:
password = security.password
n_capabilities = ap_settings['n_capabilities']
ac_capabilities = ap_settings['ac_capabilities']
validate_setup_ap_and_associate(access_point=self.access_point,
client=self.dut,
profile_name='whirlwind',
mode=hostapd_constants.MODE_11AC_MIXED,
channel=36,
n_capabilities=n_capabilities,
ac_capabilities=ac_capabilities,
force_wmm=True,
ssid=utils.rand_ascii_str(20),
security=security,
vht_bandwidth=chbw,
password=password)
def _send_message(self, 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)
text = rand_ascii_str(length)
message_content_map = {0: [text], 1: [("Mms Message", text, None)]}
message_func_map = {
0: sms_send_receive_verify,
1: mms_send_receive_verify
}
self.result_info["Total %s" % message_type_map[selection]] += 1
if not message_func_map[selection](self.log, ads[0], ads[1],
message_content_map[selection]):
self.log.error("%s of length %s from %s to %s fails",
message_type_map[selection], length, ads[0].serial,
ads[1].serial)
self.result_info["%s failure" % message_type_map[selection]] += 1
return False
else:
self.log.info("%s of length %s from %s to %s succeed",
message_type_map[selection], length, ads[0].serial,
ads[1].serial)
return True
def _check_sms_mt(self):
if not sms_send_receive_verify(self.log, self.ad_reference, self.dut,
[rand_ascii_str(180)]):
self.log.error("SMS receive test failed")
return False
else:
self.log.info("SMS receive test passed")
return True
def setup_class(self):
""" Setup devices for tethering and unpack params """
self.hotspot_device = self.android_devices[0]
self.tethered_devices = self.android_devices[1:]
req_params = ("url", "open_network")
self.unpack_userparams(req_params)
self.network = {
"SSID": "hotspot_%s" % utils.rand_ascii_str(6),
"password": "******" % utils.rand_ascii_str(6)
}
self.new_ssid = "wifi_tethering_test2"
self.tcpdump_pid = []
nutils.verify_lte_data_and_tethering_supported(self.hotspot_device)
for ad in self.tethered_devices:
wutils.wifi_test_device_init(ad)
def test_wrong_ssid_whirlwind_5g(self):
self.connect_disconnect(
{
'profile': 'whirlwind',
'channel': self.channel_5G,
'security': None
},
ssid=rand_ascii_str(20),
negative_test=True)
def setup_class(self):
super().setup_class()
self.ssid = rand_ascii_str(10)
self.wlan_device = create_wlan_device(self.fuchsia_devices[0])
self.ap = self.access_points[0]
self.num_of_iterations = int(
self.user_params.get("beacon_loss_test_iterations",
self.num_of_iterations))
self.in_use_interface = None
def _check_mms_mt(self):
message_array = [("Test Message", rand_ascii_str(180), None)]
if not mms_send_receive_verify(self.log, self.ad_reference, self.dut,
message_array):
self.log.error("MMS receive test failed")
return False
else:
self.log.info("MMS receive test passed")
return True
def test_soft_ap_2g_open_unrestricted(self):
self.verify_soft_ap_associate_and_pass_traffic(
self.primary_client, {
'ssid': utils.rand_ascii_str(
hostapd_constants.AP_SSID_LENGTH_2G),
'security_type': SECURITY_OPEN,
'connectivity_mode': CONNECTIVITY_MODE_UNRESTRICTED,
'operating_band': OPERATING_BAND_2G
})
def test_stress_softAP_startup_and_stop_5g(self):
"""Test to bring up softAP and down for N times.
Steps:
1. Bring up softAP on 5G.
2. Check for softAP on teh client device.
3. Turn ON WiFi.
4. Verify softAP is turned down and WiFi is up.
"""
ap_ssid = "softap_" + utils.rand_ascii_str(8)
ap_password = utils.rand_ascii_str(8)
self.dut.log.info("softap setup: %s %s", ap_ssid, ap_password)
config = {wutils.WifiEnums.SSID_KEY: ap_ssid}
config[wutils.WifiEnums.PWD_KEY] = ap_password
# Set country code explicitly to "US".
wutils.set_wifi_country_code(self.dut, wutils.WifiEnums.CountryCode.US)
wutils.set_wifi_country_code(self.dut_client,
wutils.WifiEnums.CountryCode.US)
for count in range(self.stress_count):
initial_wifi_state = self.dut.droid.wifiCheckState()
wutils.start_wifi_tethering(self.dut, ap_ssid, ap_password,
WifiEnums.WIFI_CONFIG_APBAND_5G)
wutils.start_wifi_connection_scan_and_ensure_network_found(
self.dut_client, ap_ssid)
wutils.stop_wifi_tethering(self.dut)
asserts.assert_false(self.dut.droid.wifiIsApEnabled(),
"SoftAp failed to shutdown!")
# Give some time for WiFi to come back to previous state.
time.sleep(2)
cur_wifi_state = self.dut.droid.wifiCheckState()
if initial_wifi_state != cur_wifi_state:
raise signals.TestFailure(
"Wifi state was %d before softAP and %d now!" %
(initial_wifi_state, cur_wifi_state),
extras={
"Iterations": "%d" % self.stress_count,
"Pass": "******" % count
})
raise signals.TestPass(details="",
extras={
"Iterations": "%d" % self.stress_count,
"Pass": "******" % (count + 1)
})
def setup_class(self):
super().setup_class()
self.ssid = rand_ascii_str(10)
self.fd = self.fuchsia_devices[0]
self.dut = create_wlan_device(self.fd)
self.ap = self.access_points[0]
self.num_of_iterations = int(
self.user_params.get("connection_stress_test_iterations",
self.num_of_iterations))
self.log.info('iterations: %d' % self.num_of_iterations)
def create_and_save_wifi_network_config(self):
""" Create a config with random SSID and password.
Returns:
A tuple with the config and networkId for the newly created and saved network.
"""
config_ssid = self.TEST_SSID_PREFIX + utils.rand_ascii_str(8)
config_password = utils.rand_ascii_str(8)
self.dut.log.info("creating config: %s %s", config_ssid,
config_password)
config = {wutils.WifiEnums.SSID_KEY: config_ssid}
config[wutils.WifiEnums.PWD_KEY] = config_password
# Now save the config.
network_id = self.dut.droid.wifiAddNetwork(config)
self.dut.log.info("saved config: network_id = %s", network_id)
return {
self.NETWORK_ID_ELEMENT: network_id,
self.CONFIG_ELEMENT: config
}
def _sms_test(self, ads):
"""Test SMS between two phones.
Returns:
True if success.
False if failed.
"""
sms_params = [(ads[0], ads[1])]
message_arrays = [[rand_ascii_str(50)], [rand_ascii_str(160)],
[rand_ascii_str(180)]]
for outer_param in sms_params:
outer_param = (self.log, ) + outer_param
for message_array in message_arrays:
inner_param = outer_param + (message_array, )
if not sms_send_receive_verify(*inner_param):
return False
return True
def message_test(self):
failure = 0
total_count = 0
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}
message_func_map = {
0: sms_send_receive_verify,
1: mms_send_receive_verify
}
while time.time() < self.finishing_time:
try:
self.dut.log.info(dict(self.result_info))
total_count += 1
selection = random.randrange(0, 2)
message_type = message_type_map[selection]
self.result_info["Total %s" % message_type] += 1
length = random.randrange(min_length_map[selection],
max_length_map[selection] + 1)
text = rand_ascii_str(length)
message_content_map = {
0: [text],
1: [("Mms Message", text, None)]
}
if not message_func_map[selection](
self.log, self.dut, self.dut,
message_content_map[selection]):
self.log.error("%s of length %s from self to self fails",
message_type, length)
self.result_info["%s failure" % message_type] += 1
#self._take_bug_report("%s_messaging_failure" % self.test_name,
# time.strftime("%m-%d-%Y-%H-%M-%S"))
failure += 1
else:
self.dut.log.info(
"%s of length %s from self to self succeed",
message_type, length)
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
self.dut.log.info("Messaging test failure: %s/%s", failure,
total_count)
if failure / total_count > 0.1:
return "Messaging test failure: %s/%s" % (failure, total_count)
else:
return ""
def test_mt_sms_multipart_gsm(self):
""" Test MT SMS(more than 160 charcters) functionality on GSM
Make Sure Phone is in GSM mode
Send a SMS from Anritsu
Verify Phone receives the SMS
Returns:
True if pass; False if fail
"""
return self._setup_sms(set_system_model_gsm, RAT_GSM, self.phoneNumber,
rand_ascii_str(MULTI_PART_LEN),
DIRECTION_MOBILE_TERMINATED)
def sms_receive_multiple(self, pri_dut, sec_dut):
text_count = 10
self.log.info(
"Test sending {} sms messages to phone.".format(text_count))
input("Press enter to execute this testcase...")
for _ in range(text_count):
msg = [rand_ascii_str(50)]
if not sms_send_receive_verify(self.log, sec_dut, pri_dut, msg):
return False
else:
self.log.info(
"Successfully sent sms. Please verify on carkit.")
return True
def test_mo_sms_singlepart_gsm(self):
""" Test MO SMS(less than 160 charcters) functionality on GSM
Make Sure Phone is in GSM mode
Send a SMS from Phone
Verify Anritsu receives the SMS
Returns:
True if pass; False if fail
"""
return self._setup_sms(set_system_model_gsm, RAT_GSM, self.phoneNumber,
rand_ascii_str(SINGLE_PART_LEN),
DIRECTION_MOBILE_ORIGINATED)
def setup_class(self):
super().setup_class()
self.ssid = rand_ascii_str(10)
self.fd = self.fuchsia_devices[0]
self.wlan_device = create_wlan_device(self.fd)
self.ap = self.access_points[0]
setup_ap_and_associate(access_point=self.ap,
client=self.wlan_device,
profile_name='whirlwind',
channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
ssid=self.ssid,
setup_bridge=True)
