def set_attenuation_and_run_iperf(self, called_func=None):
"""Sets attenuation and runs iperf for Attenuation max value.
Args:
called_func : Function object to run.
Returns:
True if Pass
False if Fail
"""
self.attenuators[self.num_atten - 1].set_atten(0)
self.rvr["bt_attenuation"] = []
self.rvr["test_name"] = self.current_test_name
self.rvr["bt_gap_analysis"] = {}
self.rvr["bt_range"] = []
status_flag = True
for bt_atten in self.bt_atten_range:
self.rvr[bt_atten] = {}
self.rvr[bt_atten]["fixed_attenuation"] = (
self.test_params["fixed_attenuation"][str(
self.network["channel"])])
self.log.info('Setting bt attenuation to: {} dB'.format(bt_atten))
self.attenuators[self.num_atten - 1].set_atten(bt_atten)
for i in range(self.num_atten - 1):
self.attenuators[i].set_atten(0)
if not wifi_connection_check(self.pri_ad, self.network["SSID"]):
wifi_test_device_init(self.pri_ad)
wifi_connect(self.pri_ad, self.network, num_of_tries=5)
adb_rssi_results = self.pri_ad.search_logcat(RSSI_RESULTS)
if adb_rssi_results:
self.log.debug(adb_rssi_results[-1])
self.log.info('Android device: {}'.format(
(adb_rssi_results[-1]['log_message']).split(',')[5]))
(self.rvr[bt_atten]["throughput_received"],
self.rvr[bt_atten]["a2dp_packet_drop"],
status_flag) = self.rvr_throughput(bt_atten, called_func)
self.wifi_max_atten_metric.metric_value = max(
self.rvr[bt_atten]["attenuation"])
self.wifi_min_atten_metric.metric_value = min(
self.rvr[bt_atten]["attenuation"])
if self.rvr[bt_atten]["throughput_received"]:
for i, atten in enumerate(self.rvr[bt_atten]["attenuation"]):
if self.rvr[bt_atten]["throughput_received"][i] < 1.0:
self.wifi_range_metric.metric_value = (
self.rvr[bt_atten]["attenuation"][i - 1])
break
else:
self.wifi_range_metric.metric_value = max(
self.rvr[bt_atten]["attenuation"])
else:
self.wifi_range_metric.metric_value = max(
self.rvr[bt_atten]["attenuation"])
if self.a2dp_streaming:
if not any(x > 0 for x in self.a2dp_dropped_list):
self.rvr[bt_atten]["a2dp_packet_drop"] = []
if not self.rvr["bt_range"]:
self.rvr["bt_range"].append(0)
return status_flag
def setup_test(self):
if ('a2dp_streaming' in self.current_test_name
and hasattr(self, 'audio_params')):
self.audio = get_audio_capture_device(self.sec_ad,
self.audio_params)
self.a2dp_streaming = True
for i in range(self.num_atten):
self.attenuators[i].set_atten(0)
if not wifi_connection_check(self.pri_ad, self.network["SSID"]):
wifi_connect(self.pri_ad, self.network, num_of_tries=5)
super().setup_test()
def setup_test(self):
self.result = {}
self.received = []
for a in self.android_devices:
a.ed.clear_all_events()
self.json_file = "{}/{}.json".format(self.pri_ad.log_path,
self.current_test_name)
if not wifi_connection_check(self.pri_ad, self.network["SSID"]):
self.log.error("Wifi connection does not exist")
return False
if not enable_bluetooth(self.pri_ad.droid, self.pri_ad.ed):
self.log.error("Failed to enable bluetooth")
return False
def set_attenuation_and_run_iperf(self, called_func=None):
"""Sets attenuation and runs iperf for Attenuation max value.
Args:
called_func : Function object to run.
Returns:
True if Pass
False if Fail
"""
self.iperf_received = []
for atten in self.attenuation_range:
self.log.info("Setting attenuation = {}".format(atten))
for i in range(self.num_atten):
self.attenuators[i].set_atten(atten)
if not wifi_connection_check(self.pri_ad, self.network["SSID"]):
return False
time.sleep(5) # Time for attenuation to set.
if called_func:
if not multithread_func(self.log, called_func):
return False
else:
self.run_iperf_and_get_result()
if "a2dp_streaming" in self.current_test_name:
if not collect_bluetooth_manager_dumpsys_logs(
self.pri_ad, self.current_test_name):
return False
self.teardown_result()
for i in range(self.num_atten):
self.attenuators[i].set_atten(0)
for received in self.received:
iperf_value = str(received).strip("Mb/s")
if iperf_value == "Iperf Failed":
self.iperf_received.append(0)
else:
self.iperf_received.append(float(iperf_value))
self.rvr["test_name"] = self.current_test_name
self.rvr["attenuation"] = list(self.attenuation_range)
self.rvr["throughput_received"] = self.iperf_received
self.rvr["fixed_attenuation"] = (
self.test_params["fixed_attenuation"][str(self.network["channel"])])
return True
def setup_test(self):
self.tag = 0
self.result = {}
self.dev_list = {}
self.iperf_variables = self.IperfVariables(self.current_test_name)
self.a2dp_dumpsys = A2dpDumpsysParser()
self.log_path = os.path.join(self.pri_ad.log_path,
self.current_test_name)
os.makedirs(self.log_path, exist_ok=True)
self.json_file = os.path.join(self.log_path, 'test_results.json')
for a in self.android_devices:
a.ed.clear_all_events()
if not wifi_connection_check(self.pri_ad, self.network['SSID']):
self.log.error('Wifi connection does not exist')
return False
if not enable_bluetooth(self.pri_ad.droid, self.pri_ad.ed):
self.log.error('Failed to enable bluetooth')
return False
if hasattr(self, 'required_devices'):
if ('discovery' in self.current_test_name or
'ble' in self.current_test_name):
self.create_android_relay_object()
else:
self.log.warning('required_devices is not given in config file')
def setup_test(self):
if not wifi_connection_check(self.pri_ad, self.network["SSID"]):
reset_wifi(self.pri_ad)
wifi_connect(self.pri_ad, self.network, num_of_tries=5)
super().setup_test()
def rvr_throughput(self, bt_atten, called_func=None):
"""Sets attenuation and runs the function passed.
Args:
bt_atten: Bluetooth attenuation.
called_func: Functions object to run parallely.
Returns:
Throughput, a2dp_drops and True/False.
"""
self.iperf_received = []
self.iperf_variables.received = []
self.a2dp_dropped_list = []
self.rvr["bt_attenuation"].append(bt_atten)
self.rvr[bt_atten]["audio_artifacts"] = {}
self.rvr[bt_atten]["attenuation"] = []
self.rvr["bt_gap_analysis"][bt_atten] = {}
for atten in self.wifi_atten_range:
tag = '{}_{}'.format(bt_atten, atten)
self.rvr[bt_atten]["attenuation"].append(
atten + self.rvr[bt_atten]["fixed_attenuation"])
self.log.info('Setting wifi attenuation to: {} dB'.format(atten))
for i in range(self.num_atten - 1):
self.attenuators[i].set_atten(atten)
if not wifi_connection_check(self.pri_ad, self.network["SSID"]):
self.iperf_received.append(0)
return self.iperf_received, self.a2dp_dropped_list, False
time.sleep(5) # Time for attenuation to set.
begin_time = get_current_epoch_time()
if self.a2dp_streaming:
self.audio.start()
if called_func:
if not multithread_func(self.log, called_func):
self.iperf_received.append(
float(
str(self.iperf_variables.received[-1]).strip(
"Mb/s")))
return self.iperf_received, self.a2dp_dropped_list, False
else:
self.run_iperf_and_get_result()
adb_rssi_poll_results = self.pri_ad.search_logcat(
RSSI_POLL_RESULTS, begin_time)
adb_rssi_results = self.pri_ad.search_logcat(
RSSI_RESULTS, begin_time)
if adb_rssi_results:
self.log.debug(adb_rssi_poll_results)
self.log.debug(adb_rssi_results[-1])
self.log.info('Android device: {}'.format(
(adb_rssi_results[-1]['log_message']).split(',')[5]))
if self.a2dp_streaming:
self.path = self.audio.stop()
analysis_path = AudioCaptureResult(
self.path).audio_quality_analysis(self.audio_params)
with open(analysis_path) as f:
self.rvr[bt_atten]["audio_artifacts"][atten] = f.readline()
content = json.loads(
self.rvr[bt_atten]["audio_artifacts"][atten])
self.rvr["bt_gap_analysis"][bt_atten][atten] = {}
for idx, data in enumerate(content["quality_result"]):
if data['artifacts']['delay_during_playback']:
self.rvr["bt_gap_analysis"][bt_atten][atten][idx] = (
data['artifacts']['delay_during_playback'])
self.rvr["bt_range"].append(bt_atten)
else:
self.rvr["bt_gap_analysis"][bt_atten][atten][idx] = 0
file_path = collect_bluetooth_manager_dumpsys_logs(
self.pri_ad, self.current_test_name)
self.a2dp_dropped_list.append(
self.a2dp_dumpsys.parse(file_path))
self.iperf_received.append(
float(str(self.iperf_variables.throughput[-1]).strip("Mb/s")))
for i in range(self.num_atten - 1):
self.attenuators[i].set_atten(0)
return self.iperf_received, self.a2dp_dropped_list, True