def test_stress_toggle_wifi_state_bluetooth_on(self): """Toggle WiFi state ON and OFF for N times when bluetooth ON.""" enable_bluetooth(self.dut.droid, self.dut.ed) for count in range(self.stress_count): """Test toggling wifi""" try: self.log.debug("Going from on to off.") wutils.wifi_toggle_state(self.dut, False) self.log.debug("Going from off to on.") startTime = time.time() wutils.wifi_toggle_state(self.dut, True) startup_time = time.time() - startTime self.log.debug("WiFi was enabled on the device in %s s." % startup_time) except: signals.TestFailure(details="", extras={ "Iterations": "%d" % self.stress_count, "Pass": "******" % count }) disable_bluetooth(self.dut.droid) raise signals.TestPass(details="", extras={ "Iterations": "%d" % self.stress_count, "Pass": "******" % (count + 1) })
def teardown_class(self): """Clean up the test class after tests finish running """ super().teardown_class() self.dut.droid.bluetoothFactoryReset() self.dut.adb.shell(BLE_LOCATION_SCAN_DISABLE) self.bt_device.reset() self.bt_device.power_off() btutils.disable_bluetooth(self.dut.droid)
def teardown_class(self): super().teardown_class() self.dut.droid.bluetoothFactoryReset() # Stopping BT on slave self.bt_device.reset() self.bt_device.power_off() #Stopping BT on master bt_utils.disable_bluetooth(self.dut.droid)
def teardown_class(self): super().teardown_class() if hasattr(self, 'media'): self.media.stop() if hasattr(self, 'attenuator'): self.attenuator.set_atten(INIT_ATTEN) self.dut.droid.bluetoothFactoryReset() self.bt_device.reset() self.bt_device.power_off() btutils.disable_bluetooth(self.dut.droid)
def teardown_test(self): super().teardown_test() self.dut.droid.bluetoothFactoryReset() self.media.stop() # Set Attenuator to the initial attenuation if hasattr(self, 'attenuator'): self.attenuator.set_atten(INIT_ATTEN) self.bt_device.reset() self.bt_device.power_off() btutils.disable_bluetooth(self.dut.droid)
def teardown_test(self): # Deleting the table self.dut.adb.shell('rm {}'.format(self.power_file_paths[1])) self.attenuator.set_atten(self.atten_min) self.log.info('Attenuation set to {} dB'.format(self.atten_min)) ble_gatt_disconnection(self.bt_device, self.bluetooth_gatt, self.gatt_callback) self.bt_device.droid.bluetoothSocketConnStop() self.dut.droid.bluetoothSocketConnStop() time.sleep(l2cap_max_inactivity_delay_after_disconnect) self.dut.droid.bluetoothFactoryReset() bt_utils.disable_bluetooth(self.dut.droid)
def setup_class(self): super(BleScanPowerTest, self).setup_class() # Get power test device serial number power_test_device_serial = self.user_params["PowerTestDevice"] # If there are multiple devices in the shield box turn off # all of them except the one for the power testing if len(self.android_devices) > 1: for ad in self.android_devices: if ad.serial != power_test_device_serial[0]: self.ad.log.info("Disable BT for %s != %s", ad.serial, power_test_device_serial[0]) disable_bluetooth(ad.droid)
def test_reboot_wifi_and_bluetooth_on(self): """Toggle WiFi and bluetooth ON then reboot """ wutils.wifi_toggle_state(self.dut, True) enable_bluetooth(self.dut.droid, self.dut.ed) self.dut.reboot() time.sleep(DEFAULT_TIMEOUT) asserts.assert_true(self.dut.droid.bluetoothCheckState(), "bluetooth state changed after reboot") asserts.assert_true(self.dut.droid.wifiCheckState(), "wifi state changed after reboot") disable_bluetooth(self.dut.droid)
def teardown_test(self): #Stopping Music if hasattr(self, 'media'): self.media.stop() # Stopping BT on slave self.bt_device.reset() self.bt_device.power_off() #Stopping BT on master bt_utils.disable_bluetooth(self.dut.droid) #Resetting the atten to initial levels self.attenuator.set_atten(self.atten_min) self.log.info('Attenuation set to {} dB'.format(self.atten_min))
def setup_test(self): super().setup_test() self.attenuator = self.attenuators[0] btutils.enable_bqr(self.dut) time.sleep(2) btutils.disable_bluetooth(self.dut.droid) time.sleep(2) btutils.enable_bluetooth(self.dut.droid, self.dut.ed) btutils.connect_phone_to_headset(self.dut, self.bt_device, 60) vol = self.dut.droid.getMaxMediaVolume() * self.volume self.dut.droid.setMediaVolume(int(vol)) self.cal_data_path = os.path.join(self.log_path, 'Calibration') self.log_file = os.path.join(self.cal_data_path, 'Cal_data.csv') os.makedirs(os.path.dirname(self.log_file), exist_ok=True)
def test_power_baseline_play_music_but_disable_bluetooth(self): """Test power usage baseline of playing music but Bluetooth is off. Test power usage baseline of playing music but Bluetooth is off speaker volume is set to 0. Steps: 1. Disable Bluetooth 2. The same steps described in _main_power_test_function_for_codec() 3. Enable Bluetooth Expected Result: Power consumption results TAGS: Bluetooth, A2DP, Power, Codec Priority: 3 """ self.ad.log.info("Disable BT") if not disable_bluetooth(self.ad.droid): self.log.error("Failed to disable Bluetooth on DUT") return False self._main_power_test_function_for_codec( self.CODEC_SBC, self.SAMPLE_RATE_44100, self.BITS_PER_SAMPLE_16, self.cd_quality_music_file, self.LDACBT_NONE, False, True) self.ad.log.info("Enable BT") if not bluetooth_enabled_check(self.ad): self.log.error("Failed to turn Bluetooth on DUT")
def teardown_test(self): self.parsing_results() with open(self.json_file, 'a') as results_file: json.dump(self.result, results_file, indent=4, sort_keys=True) if not disable_bluetooth(self.pri_ad.droid): self.log.info('Failed to disable bluetooth') return False self.destroy_android_and_relay_object()
def teardown_test(self): """Tear down necessary objects after test case is finished. Bring down the AP interface, delete the bridge interface, stop the packet sender, and reset the ethernet interface for the packet sender """ super().teardown_test() self.dut.droid.bluetoothFactoryReset() self.dut.adb.shell(BLE_LOCATION_SCAN_DISABLE) if hasattr(self, 'media'): self.media.stop() # Set Attenuator to the initial attenuation if hasattr(self, 'attenuators'): self.set_attenuation(INIT_ATTEN) self.bt_device.reset() self.bt_device.power_off() btutils.disable_bluetooth(self.dut.droid)
def phone_setup_for_BT(dut, bt_on, ble_on, screen_status): """Sets the phone and Bluetooth in the desired state Args: dut: object of the android device under test bt_on: Enable/Disable BT ble_on: Enable/Disable BLE screen_status: screen ON or OFF """ # Initialize the dut to rock-bottom state wputils.dut_rockbottom(dut) time.sleep(2) # Check if we are enabling a background scan # TODO: Turn OFF cellular wihtout having to turn ON airplane mode if bt_on == 'OFF' and ble_on == 'ON': dut.adb.shell(BLE_LOCATION_SCAN_ENABLE) dut.droid.connectivityToggleAirplaneMode(False) time.sleep(2) # Turn ON/OFF BT if bt_on == 'ON': enable_bluetooth(dut.droid, dut.ed) dut.log.info('BT is ON') else: disable_bluetooth(dut.droid) dut.droid.bluetoothDisableBLE() dut.log.info('BT is OFF') time.sleep(2) # Turn ON/OFF BLE if ble_on == 'ON': dut.droid.bluetoothEnableBLE() dut.log.info('BLE is ON') else: dut.droid.bluetoothDisableBLE() dut.log.info('BLE is OFF') time.sleep(2) # Set the desired screen status if screen_status == 'OFF': dut.droid.goToSleepNow() dut.log.info('Screen is OFF') time.sleep(2)
def teardown_test(self): 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.result["a2dp_packet_drop"] = a2dp_dumpsys_parser() with open(self.json_file, 'w+') as results_file: json.dump(self.result, results_file, indent=4) if not disable_bluetooth(self.pri_ad.droid): self.log.info("Failed to disable bluetooth") return False self.teardown_thread()
def phone_setup_for_BT(self, bt_on, ble_on, screen_status): """Sets the phone and Bluetooth in the desired state Args: bt_on: Enable/Disable BT ble_on: Enable/Disable BLE screen_status: screen ON or OFF """ # Check if we are enabling a background scan # TODO: Turn OFF cellular wihtout having to turn ON airplane mode if bt_on == 'OFF' and ble_on == 'ON': self.dut.adb.shell(BLE_LOCATION_SCAN_ENABLE) self.dut.droid.connectivityToggleAirplaneMode(False) time.sleep(2) # Turn ON/OFF BT if bt_on == 'ON': enable_bluetooth(self.dut.droid, self.dut.ed) self.dut.log.info('BT is ON') else: disable_bluetooth(self.dut.droid) self.dut.droid.bluetoothDisableBLE() self.dut.log.info('BT is OFF') time.sleep(2) # Turn ON/OFF BLE if ble_on == 'ON': self.dut.droid.bluetoothEnableBLE() self.dut.log.info('BLE is ON') else: self.dut.droid.bluetoothDisableBLE() self.dut.log.info('BLE is OFF') time.sleep(2) # Set the desired screen status if screen_status == 'OFF': self.dut.droid.goToSleepNow() self.dut.log.info('Screen is OFF') time.sleep(2)
def teardown_test(self): self.performance_baseline_check() for i in range(self.num_atten): self.attenuators[i].set_atten(0) current_atten = int(self.attenuators[i].get_atten()) self.log.debug( "Setting attenuation to zero : Current atten {} : {}".format( self.attenuators[i], current_atten)) self.a2dp_streaming = False if not disable_bluetooth(self.pri_ad.droid): self.log.info("Failed to disable bluetooth") return False self.destroy_android_and_relay_object() self.rvr = {}
def destroy_android_and_relay_object(self): """Destroys android device object and relay device object if required devices has android device and relay device.""" if hasattr(self, 'required_devices'): if ('discovery' in self.current_test_name or 'ble' in self.current_test_name): if hasattr(self, 'inquiry_devices'): for device in range(len(self.inquiry_devices)): inquiry_device = self.inquiry_devices[device] if not disable_bluetooth(inquiry_device.droid): self.log.info('Failed to disable bluetooth') android_device.destroy(self.inquiry_devices) if hasattr(self, 'relay'): relay_device_controller.destroy(self.relay)
def toggle_bluetooth(pri_ad, duration): """Toggles bluetooth on/off for N iterations. Args: pri_ad: An android device object. duration: Iperf duration of the test. Returns: True if successful, False otherwise. """ start_time = time.time() while time.time() < start_time + duration: if not enable_bluetooth(pri_ad.droid, pri_ad.ed): pri_ad.log.error("Failed to enable bluetooth") return False time.sleep(BLUETOOTH_WAIT_TIME) if not disable_bluetooth(pri_ad.droid): pri_ad.log.error("Failed to turn off bluetooth") return False time.sleep(BLUETOOTH_WAIT_TIME) return True
def teardown_test(self): self.performance_baseline_check() if not disable_bluetooth(self.pri_ad.droid): self.log.error("Failed to disable bluetooth") return False self.teardown_thread()
def setup_class(self): super().setup_class() if not disable_bluetooth(self.pri_ad.droid): self.log.info('Failed to disable bluetooth') return False
def teardown_class(self): bt_utils.disable_bluetooth(self.dut.droid)
def setup_test(self): CoexPerformanceBaseTest.setup_test(self) if not disable_bluetooth(self.pri_ad.droid): self.log.info("Failed to disable bluetooth") return False
def test_call_transfer_off_on(self): """ Tests that after we turn adapter on when an active call is in progress, we show the call. Precondition: 1. AG & HF are disconnected but paired. 2. HF's adapter is OFF Steps: 1. Make a call from AG role (since disconnected) 2. Accept from RE role and transition the call to Active 3. Turn HF's adapter ON 4. HF should transition into Active call state. Returns: Pass if True Fail if False Priority: 1 """ # Connect HF & AG if not bt_test_utils.connect_pri_to_sec( self.hf, self.ag, set([BtEnum.BluetoothProfile.HEADSET_CLIENT.value])): self.log.error("Could not connect HF and AG {} {}".format( self.hf.serial, self.ag.serial)) return False # make a call on AG if not initiate_call(self.log, self.ag, self.re_phone_number): self.ag.log.error("Failed to initiate call from ag.") return False # Wait for all HF if not car_telecom_utils.wait_for_dialing(self.log, self.hf): self.hf.log.error("HF not in ringing state.") return False # Accept the call on RE if not wait_and_answer_call(self.log, self.re): self.re.log.error("Failed to accept call on re.") return False # Wait for all HF, AG, RE to go into an Active state. if not car_telecom_utils.wait_for_active(self.log, self.hf): self.hf.log.error("HF not in Active state.") return False if not car_telecom_utils.wait_for_active(self.log, self.ag): self.ag.log.error("AG not in Active state.") return False if not car_telecom_utils.wait_for_active(self.log, self.re): self.re.log.error("RE not in Active state.") return False # Turn the adapter OFF on HF if not bt_test_utils.disable_bluetooth(self.hf.droid): self.hf.log.error("Failed to turn BT off on HF.") return False # Turn adapter ON on HF if not bt_test_utils.enable_bluetooth(self.hf.droid, self.hf.ed): self.hf.log.error("Failed to turn BT ON after call on HF.") return False # Check that HF is in active state if not car_telecom_utils.wait_for_active(self.log, self.hf): self.hf.log.error("HF not in Active state.") return False # Hangup the call and check all devices are clean self.hf.droid.telecomEndCall() ret = True ret &= car_telecom_utils.wait_for_not_in_call(self.log, self.hf) ret &= car_telecom_utils.wait_for_not_in_call(self.log, self.ag) ret &= car_telecom_utils.wait_for_not_in_call(self.log, self.re) return ret