#!/usr/bin/env python3 # # Copyright (C) 2016 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); you may not # use this file except in compliance with the License. You may obtain a copy of # the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See thea # License for the specific language governing permissions and limitations under # the License. """ Test script to exercise Ble Advertisement Api's. This exercises all getters and setters. This is important since there is a builder object that is immutable after you set all attributes of each object. If this test suite doesn't pass, then other test suites utilising Ble Advertisements will also fail. """ import pprint from acts.controllers.sl4a_lib import rpc_client from acts.test_decorators import test_tracker_info from acts_contrib.test_utils.bt.BluetoothBaseTest import BluetoothBaseTest from acts_contrib.test_utils.bt.bt_test_utils import adv_fail, adv_succ, scan_result from acts_contrib.test_utils.bt.bt_test_utils import generate_ble_advertise_objects from acts_contrib.test_utils.bt.bt_constants import ble_advertise_settings_modes from acts_contrib.test_utils.bt.bt_constants import ble_advertise_settings_tx_powers # from acts_contrib.test_utils.bt.bt_constants import ble_advertise_settings_own_address_types from acts_contrib.test_utils.bt.bt_constants import java_integer class BleAdvertiseVerificationError(Exception): """Error in fetsching BleScanner Advertise result.""" class BleAdvertiseApiTest(BluetoothBaseTest): def setup_class(self): super().setup_class() self.ad_dut = self.android_devices[0] self.sc_dut = self.android_devices[1] @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='d6d8d0a6-7b3e-4e4b-a5d0-bcfd6e207474') def test_adv_settings_defaults(self): """Tests the default advertisement settings. This builder object should have a proper "get" expectation for each attribute of the builder object once it's built. Steps: 1. Build a new advertise settings object. 2. Get the attributes of the advertise settings object. 3. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 0 """ test_result = True droid = self.ad_dut.droid adv_settings = droid.bleBuildAdvertiseSettings() adv_mode = droid.bleGetAdvertiseSettingsMode(adv_settings) tx_power_level = droid.bleGetAdvertiseSettingsTxPowerLevel( adv_settings) is_connectable = droid.bleGetAdvertiseSettingsIsConnectable( adv_settings) exp_adv_mode = ble_advertise_settings_modes['low_power'] exp_tx_power_level = ble_advertise_settings_tx_powers['medium'] exp_is_connectable = True if adv_mode != exp_adv_mode: test_result = False self.log.debug("exp filtering mode: {}," " found filtering mode: {}".format( exp_adv_mode, adv_mode)) if tx_power_level != exp_tx_power_level: test_result = False self.log.debug("exp tx power level: {}," " found filtering tx power level: {}".format( exp_tx_power_level, tx_power_level)) if exp_is_connectable != is_connectable: test_result = False self.log.debug("exp is connectable: {}," " found filtering is connectable: {}".format( exp_is_connectable, is_connectable)) return test_result @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='f2a276ae-1436-43e4-aba7-1ede787200ee') def test_adv_data_defaults(self): """Tests the default advertisement data. This builder object should have a proper "get" expectation for each attribute of the builder object once it's built. Steps: 1. Build a new AdvertiseData object. 2. Get the attributes of the advertise settings object. 3. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 0 """ test_result = True droid = self.ad_dut.droid adv_data = droid.bleBuildAdvertiseData() service_uuids = droid.bleGetAdvertiseDataServiceUuids(adv_data) include_tx_power_level = droid.bleGetAdvertiseDataIncludeTxPowerLevel( adv_data) include_device_name = droid.bleGetAdvertiseDataIncludeDeviceName( adv_data) exp_service_uuids = [] exp_include_tx_power_level = False exp_include_device_name = False self.log.debug("Step 4: Verify all defaults match exp values.") if service_uuids != exp_service_uuids: test_result = False self.log.debug("exp filtering service uuids: {}," " found filtering service uuids: {}".format( exp_service_uuids, service_uuids)) if include_tx_power_level != exp_include_tx_power_level: test_result = False self.log.debug( "exp filtering include tx power level:: {}," " found filtering include tx power level: {}".format( exp_include_tx_power_level, include_tx_power_level)) if include_device_name != exp_include_device_name: test_result = False self.log.debug( "exp filtering include tx power level: {}," " found filtering include tx power level: {}".format( exp_include_device_name, include_device_name)) if not test_result: self.log.debug("Some values didn't match the defaults.") else: self.log.debug("All default values passed.") return test_result @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='8d462e60-6b4e-49f3-9ef4-5a8b612d285d') def test_adv_settings_set_adv_mode_balanced(self): """Tests advertise settings balanced mode. This advertisement settings from "set" advertisement mode should match the corresponding "get" function. Steps: 1. Build a new advertise settings object. 2. Set the advertise mode attribute to balanced. 3. Get the attributes of the advertise settings object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_adv_mode = ble_advertise_settings_modes['balanced'] self.log.debug( "Step 2: Set the filtering settings object's value to {}".format( exp_adv_mode)) return self.verify_adv_settings_adv_mode(droid, exp_adv_mode) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='334fefeb-365f-4ee3-9be0-42b1fabe3178') def test_adv_settings_set_adv_mode_low_power(self): """Tests advertise settings low power mode. This advertisement settings from "set" advertisement mode should match the corresponding "get" function. Steps: 1. Build a new advertise settings object. 2. Set the advertise mode attribute to low power mode. 3. Get the attributes of the advertise settings object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_adv_mode = ble_advertise_settings_modes['low_power'] self.log.debug( "Step 2: Set the filtering settings object's value to {}".format( exp_adv_mode)) return self.verify_adv_settings_adv_mode(droid, exp_adv_mode) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='ce087782-1535-4694-944a-e962c22638ed') def test_adv_settings_set_adv_mode_low_latency(self): """Tests advertise settings low latency mode. This advertisement settings from "set" advertisement mode should match the corresponding "get" function. Steps: 1. Build a new advertise settings object. 2. Set the advertise mode attribute to low latency mode. 3. Get the attributes of the advertise settings object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_adv_mode = ble_advertise_settings_modes['low_latency'] self.log.debug( "Step 2: Set the filtering settings object's value to {}".format( exp_adv_mode)) return self.verify_adv_settings_adv_mode(droid, exp_adv_mode) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='59b52be9-d38b-4814-af08-c68aa8910a16') def test_adv_settings_set_invalid_adv_mode(self): """Tests advertise settings invalid advertising mode. This advertisement settings from "set" advertisement mode should fail when setting an invalid advertisement. Steps: 1. Build a new advertise settings object. 2. Set the advertise mode attribute to -1. Expected Result: Building the advertise settings should fail. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 2 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_adv_mode = -1 self.log.debug("Step 2: Set the filtering mode to -1") return self.verify_invalid_adv_settings_adv_mode(droid, exp_adv_mode) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='d8292633-831f-41c4-974a-ad267e9795e9') def test_adv_settings_set_adv_tx_power_level_high(self): """Tests advertise settings tx power level high. This advertisement settings from "set" advertisement tx power level should match the corresponding "get" function. Steps: 1. Build a new advertise settings object. 2. Set the advertise mode attribute to tx power level high. 3. Get the attributes of the advertise settings object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_adv_tx_power = ble_advertise_settings_tx_powers['high'] self.log.debug( "Step 2: Set the filtering settings object's value to {}".format( exp_adv_tx_power)) return self.verify_adv_settings_tx_power_level(droid, exp_adv_tx_power) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='d577de1f-4fd9-43d5-beff-c0696c5e0ea1') def test_adv_settings_set_adv_tx_power_level_medium(self): """Tests advertise settings tx power level medium. This advertisement settings from "set" advertisement tx power level should match the corresponding "get" function. Steps: 1. Build a new advertise settings object. 2. Set the advertise mode attribute to tx power level medium. 3. Get the attributes of the advertise settings object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") test_result = True droid = self.ad_dut.droid exp_adv_tx_power = ble_advertise_settings_tx_powers['medium'] self.log.debug( "Step 2: Set the filtering settings object's value to {}".format( exp_adv_tx_power)) return self.verify_adv_settings_tx_power_level(droid, exp_adv_tx_power) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='e972f8b5-a3cf-4b3f-9223-a8a74c0fd855') def test_adv_settings_set_adv_tx_power_level_low(self): """Tests advertise settings tx power level low. This advertisement settings from "set" advertisement tx power level should match the corresponding "get" function. Steps: 1. Build a new advertise settings object. 2. Set the advertise mode attribute to tx power level low. 3. Get the attributes of the advertise settings object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_adv_tx_power = (ble_advertise_settings_tx_powers['low']) self.log.debug( "Step 2: Set the filtering settings object's value to ".format( exp_adv_tx_power)) return self.verify_adv_settings_tx_power_level(droid, exp_adv_tx_power) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='e972f8b5-a3cf-4b3f-9223-a8a74c0fd855') def test_adv_settings_set_adv_tx_power_level_ultra_low(self): """Tests advertise settings tx power level ultra low. This advertisement settings from "set" advertisement tx power level should match the corresponding "get" function. Steps: 1. Build a new advertise settings object. 2. Set the advertise mode attribute to tx power level ultra low. 3. Get the attributes of the advertise settings object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_adv_tx_power = ble_advertise_settings_tx_powers['ultra_low'] self.log.debug( "Step 2: Set the filtering settings object's value to ".format( exp_adv_tx_power)) return self.verify_adv_settings_tx_power_level(droid, exp_adv_tx_power) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='e972f8b5-a3cf-4b3f-9223-a8a74c0fd855') def test_adv_settings_set_invalid_adv_tx_power_level(self): """Tests advertise settings invalid advertising tx power level. This advertisement settings from "set" advertisement mode should fail when setting an invalid advertisement. Steps: 1. Build a new advertise settings object. 2. Set the advertise tx power level attribute to -1. Expected Result: Building the advertise settings should fail. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_adv_tx_power = -1 self.log.debug("Step 2: Set the filtering mode to -1") return self.verify_invalid_adv_settings_tx_power_level( droid, exp_adv_tx_power) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='1be71f77-64af-42b7-84cb-e06df0836966') def test_adv_settings_set_is_connectable_true(self): """Tests advertise settings is connectable true. This advertisement settings from "set" advertisement tx power level should match the corresponding "get" function. Steps: 1. Build a new advertise settings object. 2. Set the advertise is connectable to true. 3. Get the attributes of the advertise settings object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_is_connectable = True self.log.debug( "Step 2: Set the filtering settings object's value to {}".format( exp_is_connectable)) return self.verify_adv_settings_is_connectable(droid, exp_is_connectable) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='f9865333-9198-4385-938d-5fc641ee9968') def test_adv_settings_set_is_connectable_false(self): """Tests advertise settings is connectable false. This advertisement settings from "set" advertisement tx power level should match the corresponding "get" function. Steps: 1. Build a new advertise settings object. 2. Set the advertise is connectable to false. 3. Get the attributes of the advertise settings object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_is_connectable = False self.log.debug("Step 2: Set the filtering settings object's value to " + str(exp_is_connectable)) return self.verify_adv_settings_is_connectable(droid, exp_is_connectable) @BluetoothBaseTest.bt_test_wrap def test_adv_settings_set_adv_own_address_type_public(self): """Tests advertise settings own address type public. This advertisement settings from "set" advertisement own address type should match the corresponding "get" function. Steps: 1. Build a new advertise settings object. 2. Set the advertise mode attribute to own address type public. 3. Get the attributes of the advertise settings object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid # exp_adv_own_address_type = ble_advertise_settings_own_address_types['public'] exp_adv_own_address_type = 0 self.log.debug( "Step 2: Set the filtering settings object's value to {}".format( exp_adv_own_address_type)) return self.verify_adv_settings_own_address_type(droid, exp_adv_own_address_type) @BluetoothBaseTest.bt_test_wrap def test_adv_settings_set_adv_own_address_type_random(self): """Tests advertise settings own address type random. This advertisement settings from "set" advertisement own address type should match the corresponding "get" function. Steps: 1. Build a new advertise settings object. 2. Set the advertise mode attribute to own address type random. 3. Get the attributes of the advertise settings object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid # exp_adv_own_address_type = ble_advertise_settings_own_address_types['random'] exp_adv_own_address_type = 1 self.log.debug( "Step 2: Set the filtering settings object's value to {}".format( exp_adv_own_address_type)) return self.verify_adv_settings_own_address_type(droid, exp_adv_own_address_type) @BluetoothBaseTest.bt_test_wrap def test_adv_with_multiple_own_address_types(self): ad_droid = self.ad_dut.droid sc_droid = self.sc_dut.droid sc_ed = self.sc_dut.ed adv_count = 10 exp_adv_own_address_types = [0, 1, 1, 0, 0, 1, 1, 1, 0, 0] uuid = '01234567-89ab-cdef-0123-456789abcdef' service_data = [] for i in range(3): service_data.append(i) for own_add_type in exp_adv_own_address_types: result = self.verify_adv_set_address_type_start_adv(ad_droid, own_add_type, uuid, service_data) if result is False: return False mac_list = [] filter_list = sc_droid.bleGenFilterList() scan_settings = sc_droid.bleBuildScanSetting() scan_callback = sc_droid.bleGenScanCallback() sc_droid.bleStartBleScan(filter_list, scan_settings, scan_callback) event_name = scan_result.format(scan_callback) self.log.info("Scan onSuccess Event") for _ in range(1000): if len(mac_list) is adv_count: break try: event = sc_ed.pop_event(event_name, 10) result = event['data']['Result'] deviceInfo = result['deviceInfo'] serviceUuidList = result['serviceUuidList'] if uuid in serviceUuidList: mac_addr = deviceInfo['address'] if mac_addr not in mac_list: self.log.info("Found device. address: {}".format(mac_addr)) mac_list.append(mac_addr) except rpc_client.Sl4aApiError: self.log.info("{} event was not found.".format(event_name)) break return len(mac_list) is adv_count @BluetoothBaseTest.bt_test_wrap def test_adv_settings_set_invalid_adv_own_address_type(self): """Tests advertise settings invalid own address type. This advertisement settings from "set" advertisement own address type should match the corresponding "get" function. Steps: 1. Build a new advertise settings object. 2. Set the advertise mode attribute to invalid own address type. 3. Get the attributes of the advertise settings object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_adv_own_address_type = -100 self.log.debug("Step 2: Set the filtering settings own address type to -1") return self.verify_invalid_adv_settings_own_address_type(droid, exp_adv_own_address_type) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='a770ed7e-c6cd-4533-8876-e42e68f8b4fb') def test_adv_data_set_service_uuids_empty(self): """Tests advertisement data's service uuids to empty. This advertisement data from "set" advertisement service uuid should match the corresponding "get" function. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's service uuid to empty. 3. Get the attributes of the AdvertiseData object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_service_uuids = [] self.log.debug("Step 2: Set the filtering data object's value to " + str(exp_service_uuids)) return self.verify_adv_data_service_uuids(droid, exp_service_uuids) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='3da511db-d024-45c8-be3c-fe8e123129fa') def test_adv_data_set_service_uuids_single(self): """Tests advertisement data's service uuids to empty. This advertisement data from "set" advertisement service uuid should match the corresponding "get" function. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's service uuid to empty. 3. Get the attributes of the AdvertiseData object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_service_uuids = ["00000000-0000-1000-8000-00805f9b34fb"] self.log.debug("Step 2: Set the filtering data object's value to " + str(exp_service_uuids)) return self.verify_adv_data_service_uuids(droid, exp_service_uuids) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='15073359-d607-4a76-b60a-00a4b34f9a85') def test_adv_data_set_service_uuids_multiple(self): """Tests advertisement data's service uuids to multiple uuids. This advertisement data from "set" advertisement service uuid should match the corresponding "get" function. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's service uuid to multiple uuids. 3. Get the attributes of the AdvertiseData object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_service_uuids = [ "00000000-0000-1000-8000-00805f9b34fb", "00000000-0000-1000-8000-00805f9b34fb" ] self.log.debug("Step 2: Set the filtering data object's value to " + str(exp_service_uuids)) return self.verify_adv_data_service_uuids(droid, exp_service_uuids) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='af783a71-ef80-4974-a077-16a4ed8f0114') def test_adv_data_set_service_uuids_invalid_uuid(self): """Tests advertisement data's service uuids to an invalid uuid. This advertisement data from "set" advertisement service uuid should fail when there is an invalid service uuid. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's service uuid to an invalid uuid. Expected Result: Building the AdvertiseData should fail. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_service_uuids = ["0"] self.log.debug("Step 2: Set the filtering data service uuids to " + str(exp_service_uuids)) return self.verify_invalid_adv_data_service_uuids( droid, exp_service_uuids) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='51d634e7-6271-4cc0-a57b-3c1b632a7db6') def test_adv_data_set_service_data(self): """Tests advertisement data's service data. This advertisement data from "set" advertisement service data should match the corresponding "get" function. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's service data. 3. Get the attributes of the AdvertiseData object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_service_data_uuid = "00000000-0000-1000-8000-00805f9b34fb" exp_service_data = [1, 2, 3] self.log.debug( "Step 2: Set the filtering data object's service data uuid to: {}, " "service data: {}".format(exp_service_data_uuid, exp_service_data)) return self.verify_adv_data_service_data(droid, exp_service_data_uuid, exp_service_data) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='aa18b0af-2a41-4b2a-af64-ea639961d561') def test_adv_data_set_service_data_invalid_service_data(self): """Tests advertisement data's invalid service data. This advertisement data from "set" advertisement service data should fail on an invalid value. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's service data to an invalid value. 3. Get the attributes of the AdvertiseData object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_service_data_uuid = "00000000-0000-1000-8000-00805f9b34fb" exp_service_data = "helloworld" self.log.debug( "Step 2: Set the filtering data object's service data uuid to: {}, " "service data: {}".format(exp_service_data_uuid, exp_service_data)) return self.verify_invalid_adv_data_service_data( droid, exp_service_data_uuid, exp_service_data) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='13a75a47-eff4-429f-a436-d244bbfe4496') def test_adv_data_set_service_data_invalid_service_data_uuid(self): """Tests advertisement data's invalid service data and uuid. This advertisement data from "set" advertisement service data should fail on an invalid value. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's service data and uuid to an invalid value. 3. Get the attributes of the AdvertiseData object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_service_data_uuid = "0" exp_service_data = "1,2,3" self.log.debug( "Step 2: Set the filtering data object's service data uuid to: {}, " "service data: {}".format(exp_service_data_uuid, exp_service_data)) return self.verify_invalid_adv_data_service_data( droid, exp_service_data_uuid, exp_service_data) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='386024e2-212e-4eed-8ef3-43d0c0239ea5') def test_adv_data_set_manu_id(self): """Tests advertisement data's manufacturers data and id. This advertisement data from "set" advertisement manufacturers data should match the corresponding "get" function. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's manufacturers data and id. 3. Get the attributes of the AdvertiseData object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_manu_id = 0 exp_manu_specific_data = [1, 2, 3] self.log.debug( "Step 2: Set the filtering data object's service data manu id: {}" ", manu specific data: {}".format(exp_manu_id, exp_manu_specific_data)) return self.verify_adv_data_manu_id(droid, exp_manu_id, exp_manu_specific_data) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='650ceff2-2760-4a34-90fb-e637a2c5ebb5') def test_adv_data_set_manu_id_invalid_manu_id(self): """Tests advertisement data's manufacturers invalid id. This advertisement data from "set" advertisement manufacturers data should not be successful on an invalid id. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's manufacturers id to -1. 3. Build the advertisement data. Expected Result: Building the advertisement data should fail. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_manu_id = -1 exp_manu_specific_data = [1, 2, 3] self.log.debug( "Step 2: Set the filtering data object's service data manu id: {}" ", manu specific data: {}".format(exp_manu_id, exp_manu_specific_data)) return self.verify_invalid_adv_data_manu_id(droid, exp_manu_id, exp_manu_specific_data) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='27ccd7d7-9cd2-4e95-8198-ef6ca746d1cc') def test_adv_data_set_manu_id_invalid_manu_specific_data(self): """Tests advertisement data's manufacturers invalid specific data. This advertisement data from "set" advertisement manufacturers data should not be successful on an invalid specific data. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's manufacturers specific data to helloworld. 3. Build the advertisement data. Expected Result: Building the advertisement data should fail. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_manu_id = 0 exp_manu_specific_data = ['helloworld'] self.log.debug( "Step 2: Set the filtering data object's service data manu id: {}" ", manu specific data: {}".format(exp_manu_id, exp_manu_specific_data)) return self.verify_invalid_adv_data_manu_id(droid, exp_manu_id, exp_manu_specific_data) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='8e78d444-cd25-4c17-9532-53972a6f0ffe') def test_adv_data_set_manu_id_max(self): """Tests advertisement data's manufacturers id to the max size. This advertisement data from "set" advertisement manufacturers data should match the corresponding "get" function. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's manufacturers id to JavaInterger.MAX value. 3. Get the attributes of the AdvertiseData object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 3 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_manu_id = java_integer['max'] exp_manu_specific_data = [1, 2, 3] self.log.debug( "Step 2: Set the filtering data object's service data manu id: {}" ", manu specific data: {}".format(exp_manu_id, exp_manu_specific_data)) return self.verify_adv_data_manu_id(droid, exp_manu_id, exp_manu_specific_data) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='6c4866b7-ddf5-44ef-a231-0af683c6db80') def test_adv_data_set_include_tx_power_level_true(self): """Tests advertisement data's include tx power level to True. This advertisement data from "set" advertisement manufacturers data should match the corresponding "get" function. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's include tx power level to True. 3. Get the attributes of the AdvertiseData object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_include_tx_power_level = True self.log.debug( "Step 2: Set the filtering data object's include tx power level: " "{}".format(exp_include_tx_power_level)) return self.verify_adv_data_include_tx_power_level( droid, exp_include_tx_power_level) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='db06cc5f-60cf-4f04-b0fe-0c354f987541') def test_adv_data_set_include_tx_power_level_false(self): """Tests advertisement data's include tx power level to False. This advertisement data from "set" advertisement manufacturers data should match the corresponding "get" function. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's include tx power level to False. 3. Get the attributes of the AdvertiseData object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_include_tx_power_level = False self.log.debug( "Step 2: Set the filtering data object's include tx power level: {}" .format(exp_include_tx_power_level)) return self.verify_adv_data_include_tx_power_level( droid, exp_include_tx_power_level) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='e99480c4-fd37-4791-a8d0-7eb8f8f72d62') def test_adv_data_set_include_device_name_true(self): """Tests advertisement data's include device name to True. This advertisement data from "set" advertisement manufacturers data should match the corresponding "get" function. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's include device name to True. 3. Get the attributes of the AdvertiseData object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") droid = self.ad_dut.droid exp_include_device_name = True self.log.debug( "Step 2: Set the filtering data object's include device name: {}" .format(exp_include_device_name)) return self.verify_adv_data_include_device_name( droid, exp_include_device_name) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='b89ed642-c426-4777-8217-7bb8c2058592') def test_adv_data_set_include_device_name_false(self): """Tests advertisement data's include device name to False. This advertisement data from "set" advertisement manufacturers data should match the corresponding "get" function. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's include device name to False. 3. Get the attributes of the AdvertiseData object. 4. Compare the attributes found against the attributes exp. Expected Result: Found attributes should match expected attributes. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ self.log.debug("Step 1: Setup environment.") test_result = True droid = self.ad_dut.droid exp_include_device_name = False self.log.debug( "Step 2: Set the filtering data object's include device name: {}". format(exp_include_device_name)) return self.verify_adv_data_include_device_name( droid, exp_include_device_name) @BluetoothBaseTest.bt_test_wrap @test_tracker_info(uuid='5033bcf5-a841-4b8b-af35-92c7237c7b36') def test_advertisement_greater_than_31_bytes(self): """Tests advertisement data's size to be greater than 31 bytes. This advertisement data from "set" advertisement manufacturers data should match the corresponding "get" function. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's size to be greater than 31 bytes 3. Build the advertisement data. Expected Result: Api fails to build the AdvertiseData. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ test_result = True droid = self.ad_dut.droid ed = self.android_devices[0].ed service_data = [] for i in range(25): service_data.append(i) droid.bleAddAdvertiseDataServiceData( "0000110D-0000-1000-8000-00805F9B34FB", service_data) advcallback, adv_data, adv_settings = generate_ble_advertise_objects( droid) droid.bleStartBleAdvertising(advcallback, adv_data, adv_settings) try: ed.pop_event(adv_fail.format(advcallback)) except rpc_client.Sl4aApiError: self.log.info("{} event was not found.".format( adv_fail.format(advcallback))) return False return test_result def verify_adv_settings_adv_mode(self, droid, exp_adv_mode): try: droid.bleSetAdvertiseSettingsAdvertiseMode(exp_adv_mode) except BleAdvertiseVerificationError as error: self.log.debug(str(error)) return False self.log.debug("Step 3: Get a filtering settings object's index.") settings_index = droid.bleBuildAdvertiseSettings() self.log.debug("Step 4: Get the filtering setting's filtering mode.") adv_mode = droid.bleGetAdvertiseSettingsMode(settings_index) if exp_adv_mode is not adv_mode: self.log.debug("exp value: {}, Actual value: {}".format( exp_adv_mode, adv_mode)) return False self.log.debug("Advertise Setting's filtering mode {} value " "test Passed.".format(exp_adv_mode)) return True def verify_adv_settings_tx_power_level(self, droid, exp_adv_tx_power): try: droid.bleSetAdvertiseSettingsTxPowerLevel(exp_adv_tx_power) except BleAdvertiseVerificationError as error: self.log.debug(str(error)) return False self.log.debug("Step 3: Get a filtering settings object's index.") settings_index = droid.bleBuildAdvertiseSettings() self.log.debug("Step 4: Get the filtering setting's tx power level.") adv_tx_power_level = droid.bleGetAdvertiseSettingsTxPowerLevel( settings_index) if exp_adv_tx_power is not adv_tx_power_level: self.log.debug("exp value: {}, Actual value: {}".format( exp_adv_tx_power, adv_tx_power_level)) return False self.log.debug("Advertise Setting's tx power level {}" " value test Passed.".format(exp_adv_tx_power)) return True def verify_adv_settings_is_connectable(self, droid, exp_is_connectable): try: droid.bleSetAdvertiseSettingsIsConnectable(exp_is_connectable) except BleAdvertiseVerificationError as error: self.log.debug(str(error)) return False self.log.debug("Step 3: Get a filtering settings object's index.") settings_index = droid.bleBuildAdvertiseSettings() self.log.debug( "Step 4: Get the filtering setting's is connectable value.") is_connectable = droid.bleGetAdvertiseSettingsIsConnectable( settings_index) if exp_is_connectable is not is_connectable: self.log.debug("exp value: {}, Actual value: {}".format( exp_is_connectable, is_connectable)) return False self.log.debug("Advertise Setting's is connectable {}" " value test Passed.".format(exp_is_connectable)) return True def verify_adv_settings_own_address_type(self, droid, exp_adv_own_address_type): try: droid.bleSetAdvertiseSettingsOwnAddressType(exp_adv_own_address_type) except BleAdvertiseVerificationError as error: self.log.debug(str(error)) return False self.log.debug("Step 3: Get a filtering settings object's index.") settings_index = droid.bleBuildAdvertiseSettings() self.log.debug("Step 4: Get the filtering setting's own address type.") adv_own_address_type = droid.bleGetAdvertiseSettingsOwnAddressType( settings_index) if exp_adv_own_address_type is not adv_own_address_type: self.log.debug("exp value: {}, Actual value: {}".format( exp_adv_own_address_type, adv_own_address_type)) return False self.log.debug("Advertise Setting's own address type {}" " value test Passed.".format(exp_adv_own_address_type)) return True def verify_adv_set_address_type_start_adv(self, droid, own_address_type, uuid, service_data): try: droid.bleSetAdvertiseSettingsOwnAddressType(own_address_type) except BleAdvertiseVerificationError as error: self.log.debug(str(error)) return False droid.bleAddAdvertiseDataServiceData( uuid, service_data) advcallback, adv_data, adv_settings = generate_ble_advertise_objects( droid) droid.bleStartBleAdvertising(advcallback, adv_data, adv_settings) adv_own_address_type = droid.bleGetAdvertiseSettingsOwnAddressType( adv_settings) if own_address_type is not adv_own_address_type: self.log.debug("exp value: {}, Actual value: {}".format( own_address_type, adv_own_address_type)) return False try: event = self.android_devices[0].ed.pop_event(adv_succ.format(advcallback), 10) self.log.info("Ble Advertise Success Event: {}".format(event)) except rpc_client.Sl4aApiError: self.log.info("{} event was not found.".format( adv_succ.format(advcallback))) return False return True def verify_adv_data_service_uuids(self, droid, exp_service_uuids): try: droid.bleSetAdvertiseDataSetServiceUuids(exp_service_uuids) except BleAdvertiseVerificationError as error: self.log.debug(str(error)) return False self.log.debug("Step 3: Get a filtering data object's index.") data_index = droid.bleBuildAdvertiseData() self.log.debug("Step 4: Get the filtering data's service uuids.") service_uuids = droid.bleGetAdvertiseDataServiceUuids(data_index) if exp_service_uuids != service_uuids: self.log.debug("exp value: {}, Actual value: {}".format( exp_service_uuids, service_uuids)) return False self.log.debug( "Advertise Data's service uuids {}, value test Passed.".format( exp_service_uuids)) return True def verify_adv_data_service_data(self, droid, exp_service_data_uuid, exp_service_data): try: droid.bleAddAdvertiseDataServiceData(exp_service_data_uuid, exp_service_data) except BleAdvertiseVerificationError as error: self.log.debug(str(error)) return False self.log.debug("Step 3: Get a filtering data object's index.") data_index = droid.bleBuildAdvertiseData() self.log.debug("Step 4: Get the filtering data's service data.") service_data = droid.bleGetAdvertiseDataServiceData( data_index, exp_service_data_uuid) if exp_service_data != service_data: self.log.debug("exp value: {}, Actual value: {}".format( exp_service_data, service_data)) return False self.log.debug("Advertise Data's service data uuid: {}, service data: " "{}, value test Passed.".format(exp_service_data_uuid, exp_service_data)) return True def verify_adv_data_manu_id(self, droid, exp_manu_id, exp_manu_specific_data): try: droid.bleAddAdvertiseDataManufacturerId(exp_manu_id, exp_manu_specific_data) except BleAdvertiseVerificationError as error: self.log.debug(str(error)) return False self.log.debug("Step 3: Get a filtering data object's index.") data_index = droid.bleBuildAdvertiseData() self.log.debug("Step 5: Get the filtering data's manu specific data.") manu_specific_data = droid.bleGetAdvertiseDataManufacturerSpecificData( data_index, exp_manu_id) if exp_manu_specific_data != manu_specific_data: self.log.debug("exp value: " + str(exp_manu_specific_data) + ", Actual value: " + str(manu_specific_data)) return False self.log.debug("Advertise Data's manu id: " + str(exp_manu_id) + ", manu's specific data: " + str(exp_manu_specific_data) + " value test Passed.") return True def verify_adv_data_include_tx_power_level(self, droid, exp_include_tx_power_level): try: droid.bleSetAdvertiseDataIncludeTxPowerLevel( exp_include_tx_power_level) except BleAdvertiseVerificationError as error: self.log.debug(str(error)) return False self.log.debug("Step 3: Get a filtering settings object's index.") data_index = droid.bleBuildAdvertiseData() self.log.debug( "Step 4: Get the filtering data's include tx power level.") include_tx_power_level = droid.bleGetAdvertiseDataIncludeTxPowerLevel( data_index) if exp_include_tx_power_level is not include_tx_power_level: self.log.debug("exp value: " + str(exp_include_tx_power_level) + ", Actual value: " + str(include_tx_power_level)) return False self.log.debug("Advertise Setting's include tx power level " + str( exp_include_tx_power_level) + " value test Passed.") return True def verify_adv_data_include_device_name(self, droid, exp_include_device_name): try: droid.bleSetAdvertiseDataIncludeDeviceName(exp_include_device_name) except BleAdvertiseVerificationError as error: self.log.debug(str(error)) return False self.log.debug("Step 3: Get a filtering settings object's index.") data_index = droid.bleBuildAdvertiseData() self.log.debug("Step 4: Get the filtering data's include device name.") include_device_name = droid.bleGetAdvertiseDataIncludeDeviceName( data_index) if exp_include_device_name is not include_device_name: self.log.debug("exp value: {}, Actual value: {}".format( exp_include_device_name, include_device_name)) return False self.log.debug("Advertise Setting's include device name {}" " value test Passed.".format(exp_include_device_name)) return True def verify_invalid_adv_settings_adv_mode(self, droid, exp_adv_mode): try: droid.bleSetAdvertiseSettingsAdvertiseMode(exp_adv_mode) droid.bleBuildAdvertiseSettings() self.log.debug("Set Advertise settings invalid filtering mode " "passed with input as {}".format(exp_adv_mode)) return False except rpc_client.Sl4aApiError: self.log.debug( "Set Advertise settings invalid filtering mode " "failed successfully with input as {}".format(exp_adv_mode)) return True def verify_invalid_adv_settings_tx_power_level(self, droid, exp_adv_tx_power): try: droid.bleSetAdvertiseSettingsTxPowerLevel(exp_adv_tx_power) droid.bleBuildAdvertiseSettings() self.log.debug("Set Advertise settings invalid tx power level " + " with input as {}".format(exp_adv_tx_power)) return False except rpc_client.Sl4aApiError: self.log.debug( "Set Advertise settings invalid tx power level " "failed successfullywith input as {}".format(exp_adv_tx_power)) return True def verify_invalid_adv_settings_own_address_type(self, droid, exp_adv_own_address_type): try: droid.bleSetAdvertiseSettingsOwnAddressType(exp_adv_own_address_type) droid.bleBuildAdvertiseSettings() self.log.debug("Set Advertise settings invalid own address type " + " with input as {}".format(exp_adv_own_address_type)) return False except rpc_client.Sl4aApiError: self.log.debug( "Set Advertise settings invalid own address type " "failed successfully with input as {}".format(exp_adv_own_address_type)) return True def verify_invalid_adv_data_service_uuids(self, droid, exp_service_uuids): try: droid.bleSetAdvertiseDataSetServiceUuids(exp_service_uuids) droid.bleBuildAdvertiseData() self.log.debug("Set Advertise Data service uuids " + " with input as {}".format(exp_service_uuids)) return False except rpc_client.Sl4aApiError: self.log.debug( "Set Advertise Data invalid service uuids failed " "successfully with input as {}".format(exp_service_uuids)) return True def verify_invalid_adv_data_service_data( self, droid, exp_service_data_uuid, exp_service_data): try: droid.bleAddAdvertiseDataServiceData(exp_service_data_uuid, exp_service_data) droid.bleBuildAdvertiseData() self.log.debug("Set Advertise Data service data uuid: {}," ", service data: {}".format(exp_service_data_uuid, exp_service_data)) return False except rpc_client.Sl4aApiError: self.log.debug("Set Advertise Data service data uuid: " + str(exp_service_data_uuid) + ", service data: " + str(exp_service_data) + " failed successfully.") return True def verify_invalid_adv_data_manu_id(self, droid, exp_manu_id, exp_manu_specific_data): try: droid.bleAddAdvertiseDataManufacturerId(exp_manu_id, exp_manu_specific_data) droid.bleBuildAdvertiseData() self.log.debug( "Set Advertise Data manu id: " + str(exp_manu_id) + ", manu specific data: " + str(exp_manu_specific_data)) return False except rpc_client.Sl4aApiError: self.log.debug("Set Advertise Data manu id: {}," " manu specific data: {},".format( exp_manu_id, exp_manu_specific_data)) return True