def setup_class(self):
# AVRCP roles
self.CT = self.android_devices[0]
self.TG = self.android_devices[1]
# A2DP roles for the same devices
self.SNK = self.CT
self.SRC = self.TG
# Setup devices
bt_test_utils.setup_multiple_devices_for_bt_test([self.CT, self.TG])
self.btAddrCT = self.CT.droid.bluetoothGetLocalAddress()
self.btAddrTG = self.TG.droid.bluetoothGetLocalAddress()
# Additional time from the stack reset in setup.
time.sleep(4)
# Pair the devices.
if not bt_test_utils.pair_pri_to_sec(
self.CT, self.TG, attempts=4, auto_confirm=False):
self.log.error("Failed to pair")
return False
# Disable all
car_bt_utils.set_car_profile_priorities_off(self.SNK, self.SRC)
# Enable A2DP
bt_test_utils.set_profile_priority(
self.SNK, self.SRC, [BtEnum.BluetoothProfile.A2DP_SINK],
BtEnum.BluetoothPriorityLevel.PRIORITY_ON)
def setup_class(self):
self.hf = self.android_devices[0]
self.ag = self.android_devices[1]
self.re = self.android_devices[2]
self.ag_phone_number = "tel:{}".format(
self.ag.droid.telephonyGetLine1Number())
self.re_phone_number = "tel:{}".format(
self.re.droid.telephonyGetLine1Number())
self.log.info("ag tel: {} re tel: {}".format(self.ag_phone_number,
self.re_phone_number))
# Setup includes pairing and connecting the devices.
bt_test_utils.setup_multiple_devices_for_bt_test([self.hf, self.ag])
bt_test_utils.reset_bluetooth([self.hf, self.ag])
# Pair and connect the devices.
if not bt_test_utils.pair_pri_to_sec(self.hf.droid, self.ag.droid):
self.log.error("Failed to pair")
return False
# Connect the devices now, try twice.
attempts = 2
connected = False
while attempts > 0 and not connected:
connected = bt_test_utils.connect_pri_to_sec(
self.log, self.hf, self.ag.droid,
set([BtEnum.BluetoothProfile.HEADSET_CLIENT.value]))
self.log.info("Connected {}".format(connected))
attempts -= 1
return connected
def setup_class(self):
if not super(BtCarPbapTest, self).setup_class():
return False
permissions_list = [
"android.permission.READ_CONTACTS",
"android.permission.WRITE_CONTACTS",
"android.permission.READ_EXTERNAL_STORAGE"
]
for permission in permissions_list:
self.pse.adb.shell(
"pm grant com.google.android.contacts {}".format(permission))
for permission in permissions_list:
self.pce.adb.shell(
"pm grant com.android.contacts {}".format(permission))
# Pair the devices.
# This call may block until some specified timeout in bt_test_utils.py.
# Grace time inbetween stack state changes
setup_multiple_devices_for_bt_test(self.android_devices)
if not bt_test_utils.pair_pri_to_sec(self.pce, self.pse):
self.log.error("Failed to pair.")
return False
time.sleep(3)
if not bt_test_utils.pair_pri_to_sec(self.pce, self.pse2):
self.log.error("Failed to pair.")
return False
# Disable the HFP and A2DP profiles. This will ensure only PBAP
# gets connected. Also, this will eliminate the auto-connect loop.
car_bt_utils.set_car_profile_priorities_off(self.pce, self.pse)
car_bt_utils.set_car_profile_priorities_off(self.pce, self.pse2)
# Enable PBAP on PSE & PCE.
self.pse.droid.bluetoothChangeProfileAccessPermission(
self.pce.droid.bluetoothGetLocalAddress(),
BtEnum.BluetoothProfile.PBAP_SERVER.value,
BtEnum.BluetoothAccessLevel.ACCESS_ALLOWED.value)
self.pse2.droid.bluetoothChangeProfileAccessPermission(
self.pce.droid.bluetoothGetLocalAddress(),
BtEnum.BluetoothProfile.PBAP_SERVER.value,
BtEnum.BluetoothAccessLevel.ACCESS_ALLOWED.value)
bt_test_utils.set_profile_priority(
self.pce, self.pse, [BtEnum.BluetoothProfile.PBAP_CLIENT],
BtEnum.BluetoothPriorityLevel.PRIORITY_ON)
bt_test_utils.set_profile_priority(
self.pce, self.pse2, [BtEnum.BluetoothProfile.PBAP_CLIENT],
BtEnum.BluetoothPriorityLevel.PRIORITY_ON)
return True
def setup_class(self):
self.tag = 0
self.iperf_result = {}
self.thread_list = []
self.log_files = []
if not setup_multiple_devices_for_bt_test(self.android_devices):
self.log.error("Failed to setup devices for bluetooth test")
return False
req_params = ["network", "iperf"]
opt_params = ["AccessPoint", "RetailAccessPoints", "RelayDevice"]
self.unpack_userparams(req_params, opt_params)
if hasattr(self, "RelayDevice"):
self.audio_receiver = self.relay_devices[0]
self.audio_receiver.power_on()
else:
self.log.warning("Missing Relay config file.")
self.path = self.pri_ad.log_path
if hasattr(self, "AccessPoint"):
self.ap = self.access_points[0]
configure_and_start_ap(self.ap, self.network)
elif hasattr(self, "RetailAccessPoints"):
self.access_points = retail_ap.create(self.RetailAccessPoints)
self.access_point = self.access_points[0]
band = self.access_point.band_lookup_by_channel(
self.network["channel"])
self.access_point.set_channel(band, self.network["channel"])
else:
self.log.warning("config file have no access point information")
wifi_test_device_init(self.pri_ad)
wifi_connect(self.pri_ad, self.network)
def setup_test(self):
# Reset the devices in a clean state.
bt_test_utils.setup_multiple_devices_for_bt_test(self.android_devices)
bt_test_utils.reset_bluetooth(self.android_devices)
for a in self.android_devices:
a.ed.clear_all_events()
# Pair the devices.
# This call may block until some specified timeout in bt_test_utils.py.
result = bt_test_utils.pair_pri_to_sec(self.car.droid, self.ph.droid)
asserts.assert_true(result, "pair_pri_to_sec returned false.");
# Check for successful setup of test.
devices = self.car.droid.bluetoothGetBondedDevices()
asserts.assert_equal(len(devices), 1, "pair_pri_to_sec succeeded but no bonded devices.")
def setup_class(self):
if "reboot_between_test_class" in self.user_params:
threads = []
for a in self.android_devices:
thread = threading.Thread(target=self._reboot_device,
args=([a]))
threads.append(thread)
thread.start()
for t in threads:
t.join()
return setup_multiple_devices_for_bt_test(self.android_devices)
def setup_class(self):
self.car = self.android_devices[0]
self.ph = self.android_devices[1]
self.car_bt_addr = self.car.droid.bluetoothGetLocalAddress()
self.ph_bt_addr = self.ph.droid.bluetoothGetLocalAddress()
bt_test_utils.setup_multiple_devices_for_bt_test([self.car, self.ph])
# Pair the devices.
# This call may block until some specified timeout in bt_test_utils.py.
result = bt_test_utils.pair_pri_to_sec(
self.car, self.ph, auto_confirm=False)
asserts.assert_true(result, "pair_pri_to_sec returned false.")
# Check for successful setup of test.
devices = self.car.droid.bluetoothGetBondedDevices()
asserts.assert_equal(
len(devices), 1,
"pair_pri_to_sec succeeded but no bonded devices.")
def setup_class(self):
super().setup_class()
self.client_ad = self.android_devices[0]
# The client which is scanning will need location to be enabled in order to
# start scan and get scan results.
utils.set_location_service(self.client_ad, True)
self.server_ad = self.android_devices[1]
# Note that some tests required a third device.
if len(self.android_devices) > 2:
self.server2_ad = self.android_devices[2]
return setup_multiple_devices_for_bt_test(self.android_devices)
def setup_class(self):
super().setup_class()
for ad in self.android_devices:
self._setup_bt_libs(ad)
if 'preferred_device_order' in self.user_params:
prefered_device_order = self.user_params['preferred_device_order']
for i, ad in enumerate(self.android_devices):
if ad.serial in prefered_device_order:
index = prefered_device_order.index(ad.serial)
self.android_devices[i], self.android_devices[index] = \
self.android_devices[index], self.android_devices[i]
if "reboot_between_test_class" in self.user_params:
threads = []
for a in self.android_devices:
thread = threading.Thread(
target=self._reboot_device, args=([a]))
threads.append(thread)
thread.start()
for t in threads:
t.join()
if not setup_multiple_devices_for_bt_test(self.android_devices):
return False
self.device_selector = get_device_selector_dictionary(
self.android_devices)
if "bluetooth_proto_path" in self.user_params:
from google import protobuf
self.bluetooth_proto_path = self.user_params[
"bluetooth_proto_path"][0]
if not os.path.isfile(self.bluetooth_proto_path):
try:
self.bluetooth_proto_path = "{}/bluetooth.proto".format(
os.path.dirname(os.path.realpath(__file__)))
except Exception:
self.log.error("File not found.")
if not os.path.isfile(self.bluetooth_proto_path):
self.log.error("Unable to find Bluetooth proto {}.".format(
self.bluetooth_proto_path))
return False
for ad in self.android_devices:
ad.metrics_path = os.path.join(ad.log_path, "BluetoothMetrics")
os.makedirs(ad.metrics_path, exist_ok=True)
ad.bluetooth_proto_module = \
compile_import_proto(ad.metrics_path, self.bluetooth_proto_path)
if not ad.bluetooth_proto_module:
self.log.error("Unable to compile bluetooth proto at " +
self.bluetooth_proto_path)
return False
# Clear metrics.
get_bluetooth_metrics(ad, ad.bluetooth_proto_module)
return True
def test_ble_sar_custom_table(self):
""" Test for BLE SAR custom table
BLE SAR custom table Test Iterates over BT SAR custom table and forces signal states, by
measuring ble RSSI and power level for each state and processes the results of
sweep_table and computes BLE TX power and parses the processed table with
computed BLE TX power values to return pass or fail
"""
self.push_table(self.dut, self.custom_sar_path)
setup_multiple_devices_for_bt_test(self.android_devices)
# Establish CoC BLE connection
self.status, self.gatt_callback, self.gatt_server, self.bluetooth_gatt, \
self.client_conn_id = ble_coc_connection(self.bt_device, self.dut)
sar_df = self.sweep_table(self.dut,
self.bt_device,
self.client_conn_id,
self.gatt_server,
self.gatt_callback,
isBLE=True)
sar_df = self.process_table(sar_df)
self.process_results(sar_df, type='BLE')
def setup_class(self):
super().setup_class()
self.pri_ad = self.android_devices[0]
if len(self.android_devices) == 2:
self.sec_ad = self.android_devices[1]
elif len(self.android_devices) == 3:
self.third_ad = self.android_devices[2]
self.ssh_config = None
self.counter = 0
self.thread_list = []
if not setup_multiple_devices_for_bt_test(self.android_devices):
self.log.error('Failed to setup devices for bluetooth test')
return False
req_params = ['network', 'iperf']
opt_params = [
'AccessPoint', 'RetailAccessPoints', 'RelayDevice',
'required_devices'
]
self.unpack_userparams(req_params, opt_params)
self.iperf_server = self.iperf_servers[0]
self.iperf_client = self.iperf_clients[0]
if hasattr(self, 'RelayDevice'):
self.audio_receiver = self.relay_devices[0]
self.audio_receiver.power_on()
self.headset_mac_address = self.audio_receiver.mac_address
else:
self.log.warning('Missing Relay config file.')
if hasattr(self, 'AccessPoint'):
self.ap = self.access_points[0]
configure_and_start_ap(self.ap, self.network)
elif hasattr(self, 'RetailAccessPoints'):
self.retail_access_points = retail_ap.create(
self.RetailAccessPoints)
self.retail_access_point = self.retail_access_points[0]
band = self.retail_access_point.band_lookup_by_channel(
self.network['channel'])
self.retail_access_point.set_channel(band, self.network['channel'])
else:
self.log.warning('config file have no access point information')
wifi_test_device_init(self.pri_ad)
wifi_connect(self.pri_ad, self.network, num_of_tries=5)
def setup_class(self):
if not setup_multiple_devices_for_bt_test(self.android_devices):
return False
return self._start_special_advertisements()
def setup_class(self):
return setup_multiple_devices_for_bt_test(self.android_devices)
def setup_test(self):
setup_multiple_devices_for_bt_test(self.android_devices)
self._connect_rfcomm()
def setup_class(self):
super().setup_class()
self.droid_ad = self.android_devices[0]
self.droid1_ad = self.android_devices[1]
return setup_multiple_devices_for_bt_test(self.android_devices)
def setup_class(self):
for a in self.android_devices:
sync_device_time(a)
return setup_multiple_devices_for_bt_test(self.android_devices)
def setup_test(self):
"""Setup devices for tethering before each test."""
setup_multiple_devices_for_bt_test(
[self.tmobile_device, self.verizon_device])
