| #!/usr/bin/env python3 |
| # |
| # Copyright (C) 2018 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 the |
| # License for the specific language governing permissions and limitations under |
| # the License. |
| |
| import time |
| |
| from acts_contrib.test_utils.bt import BtEnum |
| from acts_contrib.test_utils.bt.bt_test_utils import clear_bonded_devices |
| from acts_contrib.test_utils.coex.CoexBaseTest import CoexBaseTest |
| from acts_contrib.test_utils.coex.coex_test_utils import connect_dev_to_headset |
| from acts_contrib.test_utils.coex.coex_test_utils import disconnect_headset_from_dev |
| from acts_contrib.test_utils.coex.coex_test_utils import initiate_disconnect_from_hf |
| from acts_contrib.test_utils.coex.coex_test_utils import pair_and_connect_headset |
| from acts_contrib.test_utils.tel.tel_defines import AUDIO_ROUTE_BLUETOOTH |
| from acts_contrib.test_utils.tel.tel_defines import AUDIO_ROUTE_SPEAKER |
| |
| from acts_contrib.test_utils.tel.tel_voice_utils import hangup_call |
| from acts_contrib.test_utils.tel.tel_voice_utils import set_audio_route |
| |
| |
| class CoexHfpStressTest(CoexBaseTest): |
| |
| def setup_class(self): |
| CoexBaseTest.setup_class(self) |
| |
| req_params = ["iterations"] |
| self.unpack_userparams(req_params) |
| |
| def setup_test(self): |
| CoexBaseTest.setup_test(self) |
| self.audio_receiver.enter_pairing_mode() |
| if not pair_and_connect_headset( |
| self.pri_ad, self.audio_receiver.mac_address, |
| set([BtEnum.BluetoothProfile.HEADSET.value])): |
| self.log.error("Failed to pair and connect to headset") |
| return False |
| |
| def teardown_test(self): |
| clear_bonded_devices(self.pri_ad) |
| CoexBaseTest.teardown_test(self) |
| self.audio_receiver.clean_up() |
| |
| def connect_disconnect_hfp_headset(self): |
| """Connect and disconnect hfp profile on headset for multiple |
| iterations. |
| |
| Steps: |
| 1.Connect hfp profile on headset. |
| 2.Disconnect hfp profile on headset. |
| 3.Repeat step 1 and 2 for N iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| """ |
| for i in range(self.iterations): |
| if not connect_dev_to_headset( |
| self.pri_ad, self.audio_receiver.mac_address, |
| {BtEnum.BluetoothProfile.HEADSET.value}): |
| self.log.error("Failure to connect HFP headset.") |
| return False |
| |
| if not disconnect_headset_from_dev( |
| self.pri_ad, self.audio_receiver.mac_address, |
| {BtEnum.BluetoothProfile.HEADSET.value}): |
| self.log.error("Could not disconnect {}".format( |
| self.audio_receiver.mac_address)) |
| return False |
| return True |
| |
| def initiate_call_from_hf_disconnect_from_ag(self): |
| """Initiates call from HF and disconnect call from ag for multiple |
| iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| """ |
| for i in range(self.iterations): |
| if not self.audio_receiver.press_initiate_call(): |
| self.log.error("Failed to initiate call.") |
| return False |
| time.sleep(5) #Wait time for intiating call. |
| if not hangup_call(self.log, self.pri_ad): |
| self.log.error("Failed to hang up the call.") |
| return False |
| return True |
| |
| def route_audio_from_hf_to_speaker(self): |
| """Route audio from HF to primary device inbuilt speakers and |
| vice_versa. |
| |
| Steps: |
| 1. Initiate call from HF. |
| 2. Toggle audio from HF to speaker and vice-versa from N iterations. |
| 3. Hangup call from primary device. |
| |
| Returns: |
| True if successful, False otherwise. |
| """ |
| if not self.audio_receiver.press_initiate_call(): |
| self.log.error("Failed to initiate call.") |
| return False |
| for i in range(self.iterations): |
| self.log.info("DUT speaker iteration = {}".format(i)) |
| if not set_audio_route(self.log, self.pri_ad, AUDIO_ROUTE_SPEAKER): |
| self.log.error("Failed switching to primary device speaker.") |
| hangup_call(self.log, self.pri_ad) |
| return False |
| time.sleep(2) |
| if not set_audio_route(self.log, self.pri_ad, |
| AUDIO_ROUTE_BLUETOOTH): |
| self.log.error("Failed switching to bluetooth headset.") |
| hangup_call(self.log, self.pri_ad) |
| return False |
| if not hangup_call(self.log, self.pri_ad): |
| self.log.error("Failed to hang up the call.") |
| return False |
| return True |
| |
| def connect_disconnect_hfp_headset_with_iperf(self): |
| """Wrapper function to start iperf traffic and connect/disconnect |
| to a2dp headset for N iterations. |
| """ |
| self.run_iperf_and_get_result() |
| if not self.connect_disconnect_hfp_headset(): |
| return False |
| return self.teardown_result() |
| |
| def hfp_long_duration_with_iperf(self): |
| """Wrapper function to start iperf traffic and initiate hfp call.""" |
| self.run_iperf_and_get_result() |
| if not initiate_disconnect_from_hf( |
| self.audio_receiver, self.pri_ad, self.sec_ad, |
| self.iperf["duration"]): |
| return False |
| return self.teardown_result() |
| |
| def initiate_call_multiple_times_with_iperf(self): |
| """Wrapper function to start iperf traffic and initiate call and |
| disconnect call simultaneously. |
| """ |
| self.run_iperf_and_get_result() |
| if not self.initiate_call_from_hf_disconnect_from_ag(): |
| return False |
| return self.teardown_result() |
| |
| def route_audio_from_hf_to_speaker_with_iperf(self): |
| """Wrapper function to start iperf traffic and route audio from |
| headset to speaker. |
| """ |
| self.run_iperf_and_get_result() |
| if not self.route_audio_from_hf_to_speaker(): |
| return False |
| return self.teardown_result() |
| |
| def test_stress_hfp_long_duration_with_tcp_ul(self): |
| """Stress test on hfp call continuously for 12 hours. |
| |
| This test is to start TCP-uplink traffic between host machine and |
| android device and test the integrity of hfp connection for 12 hours. |
| |
| Steps: |
| 1. Start TCP-uplink traffic. |
| 2. Initiate call. |
| 3. Verify call status. |
| 4. Disconnect call. |
| 5. Repeat steps 2 to 4 for N iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_021 |
| """ |
| if not self.hfp_long_duration_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_hfp_long_duration_with_tcp_dl(self): |
| """Stress test on hfp call continuously for 12 hours. |
| |
| This test is to start TCP-downlink traffic between host machine and |
| android device and test the integrity of hfp connection for 12 hours. |
| |
| Steps: |
| 1. Start TCP-downlink traffic. |
| 2. Initiate call. |
| 3. Verify call status. |
| 4. Disconnect call. |
| 5. Repeat steps 2 to 4 for N iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_022 |
| """ |
| if not self.hfp_long_duration_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_hfp_long_duration_with_udp_ul(self): |
| """Stress test on hfp call continuously for 12 hours. |
| |
| This test is to start UDP-uplink traffic between host machine and |
| android device and test the integrity of hfp connection for 12 hours. |
| |
| Steps: |
| 1. Start UDP-uplink traffic. |
| 2. Initiate call. |
| 3. Verify call status. |
| 4. Disconnect call. |
| 5. Repeat steps 2 to 4 for N iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_023 |
| """ |
| if not self.hfp_long_duration_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_hfp_long_duration_with_udp_dl(self): |
| """Stress test on hfp call continuously for 12 hours. |
| |
| This test is to start UDP-downlink traffic between host machine and |
| android device and test the integrity of hfp connection for 12 hours. |
| |
| Steps: |
| 1. Start UDP-downlink traffic. |
| 2. Initiate call. |
| 3. Verify call status. |
| 4. Disconnect call. |
| 5. Repeat steps 2 to 4 for N iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_024 |
| """ |
| if not self.hfp_long_duration_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_hfp_call_multiple_times_with_tcp_ul(self): |
| """Stress test for initiate and disconnect hfp call. |
| |
| This test is to start TCP-uplink traffic between host machine and |
| android device and test the integrity of hfp call. |
| |
| Steps: |
| 1. Start TCP-uplink traffic. |
| 2. Initiate call from HF |
| 3. Verify status of call |
| 4. Disconnect from AG. |
| 5. Repeat steps 2 to 4 for N iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_025 |
| """ |
| if not self.initiate_call_multiple_times_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_hfp_call_multiple_times_with_tcp_dl(self): |
| """Stress test for initiate and disconnect hfp call. |
| |
| This test is to start TCP-downlink traffic between host machine and |
| android device and test the integrity of hfp call. |
| |
| Steps: |
| 1. Start TCP-downlink traffic. |
| 2. Initiate call from HF |
| 3. Verify status of call |
| 4. Disconnect from AG. |
| 5. Repeat steps 2 to 4 for N iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_026 |
| """ |
| if not self.initiate_call_multiple_times_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_hfp_call_multiple_times_with_udp_ul(self): |
| """Stress test for initiate and disconnect hfp call. |
| |
| This test is to start UDP-uplink traffic between host machine and |
| android device and test the integrity of hfp call. |
| |
| Steps: |
| 1. Start UDP-uplink traffic. |
| 2. Initiate call from HF |
| 3. Verify status of call |
| 4. Disconnect from AG. |
| 5. Repeat steps 2 to 4 for N iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_027 |
| """ |
| if not self.initiate_call_multiple_times_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_hfp_call_multiple_times_with_udp_dl(self): |
| """Stress test for initiate and disconnect hfp call. |
| |
| This test is to start UDP-downlink traffic between host machine and |
| android device and test the integrity of hfp call. |
| |
| Steps: |
| 1. Start UDP-downlink traffic. |
| 2. Initiate call from HF |
| 3. Verify status of call |
| 4. Disconnect from AG. |
| 5. Repeat steps 2 to 4 for N iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_028 |
| """ |
| if not self.initiate_call_multiple_times_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_connect_disconnect_hfp_profile_with_tcp_ul(self): |
| """Stress test for connect/disconnect hfp headset. |
| |
| This test is to start TCP-uplink traffic between host machine and |
| android device and test the integrity of connection and disconnection |
| to headset with hfp profile. |
| |
| Steps: |
| 1. Run TCP-uplink traffic. |
| 2. Connect and disconnect headset with hfp profile. |
| 3. Repeat step 2 for N iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_033 |
| """ |
| if not self.connect_disconnect_hfp_headset(): |
| return False |
| return True |
| |
| def test_stress_connect_disconnect_hfp_profile_with_tcp_dl(self): |
| """Stress test for connect/disconnect hfp headset. |
| |
| This test is to start TCP-downlink traffic between host machine and |
| android device and test the integrity of connection and disconnection |
| to headset with hfp profile. |
| |
| Steps: |
| 1. Run TCP-downlink traffic. |
| 2. Connect and disconnect headset with hfp profile. |
| 3. Repeat step 2 for N iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_034 |
| """ |
| if not self.connect_disconnect_hfp_headset(): |
| return False |
| return True |
| |
| def test_stress_connect_disconnect_hfp_profile_with_udp_ul(self): |
| """Stress test for connect/disconnect hfp headset. |
| |
| This test is to start UDP-uplink traffic between host machine and |
| android device and test the integrity of connection and disconnection |
| to headset with hfp profile. |
| |
| Steps: |
| 1. Run UDP-uplink traffic. |
| 2. Connect and disconnect headset with hfp profile. |
| 3. Repeat step 2 for N iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_035 |
| """ |
| if not self.connect_disconnect_hfp_headset(): |
| return False |
| return True |
| |
| def test_stress_connect_disconnect_hfp_profile_with_udp_dl(self): |
| """Stress test for connect/disconnect hfp headset. |
| |
| This test is to start UDP-downlink traffic between host machine and |
| android device and test the integrity of connection and disconnection |
| to headset with hfp profile. |
| |
| Steps: |
| 1. Run UDP-downlink traffic. |
| 2. Connect and disconnect headset with hfp profile. |
| 3. Repeat step 2 for N iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_036 |
| """ |
| if not self.connect_disconnect_hfp_headset(): |
| return False |
| return True |
| |
| def test_stress_audio_routing_with_tcp_ul(self): |
| """Stress to route audio from HF to primary device speaker. |
| |
| This test is to start TCP-uplink traffic between host machine and |
| android device and test the integrity of audio routing between |
| bluetooth headset and android device inbuilt speaker. |
| |
| Steps: |
| 1. Starts TCP-uplink traffic. |
| 2. Route audio from hf to speaker and vice-versa. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_037 |
| """ |
| if not self.route_audio_from_hf_to_speaker_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_audio_routing_with_tcp_dl(self): |
| """Stress to route audio from HF to primary device speaker. |
| |
| This test is to start TCP-downlink traffic between host machine and |
| android device and test the integrity of audio routing between |
| bluetooth headset and android device inbuilt speaker. |
| |
| Steps: |
| 1. Starts TCP-downlink traffic. |
| 2. Route audio from hf to speaker and vice-versa. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_038 |
| """ |
| if not self.route_audio_from_hf_to_speaker_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_audio_routing_with_udp_ul(self): |
| """Stress to route audio from HF to primary device speaker. |
| |
| This test is to start UDP-uplink traffic between host machine and |
| android device and test the integrity of audio routing between |
| bluetooth headset and android device inbuilt speaker. |
| |
| Steps: |
| 1. Starts UDP-uplink traffic. |
| 2. Route audio from hf to speaker and vice-versa. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_039 |
| """ |
| if not self.route_audio_from_hf_to_speaker_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_audio_routing_with_udp_dl(self): |
| """Stress to route audio from HF to primary device speaker. |
| |
| This test is to start UDP-downlink traffic between host machine and |
| android device and test the integrity of audio routing between |
| bluetooth headset and android device inbuilt speaker. |
| |
| Steps: |
| 1. Starts UDP-downlink traffic. |
| 2. Route audio from hf to speaker and vice-versa. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_040 |
| """ |
| if not self.route_audio_from_hf_to_speaker_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_connect_disconnect_hfp_with_tcp_bidirectional(self): |
| """Stress test for connect/disconnect headset. |
| |
| This test is to start TCP-bidirectional traffic between host machine and |
| android device and test the integrity of connection and disconnection |
| to headset with hfp profile. |
| |
| Steps: |
| 1. Run TCP-bidirectional traffic. |
| 2. Connect and disconnect headset with hfp profile. |
| 3. Repeat step 2 for N iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_067 |
| """ |
| if not self.connect_disconnect_hfp_headset(): |
| return False |
| return True |
| |
| def test_stress_connect_disconnect_hfp_with_udp_bidirectional(self): |
| """Stress test for connect/disconnect headset. |
| |
| This test is to start UDP-bidirectional traffic between host machine and |
| android device and test the integrity of connection and disconnection |
| to headset with hfp profile. |
| |
| Steps: |
| 1. Run UDP-bidirectional traffic. |
| 2. Connect and disconnect headset with hfp profile. |
| 3. Repeat step 2 for N iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_068 |
| """ |
| if not self.connect_disconnect_hfp_headset(): |
| return False |
| return True |
| |
| def test_stress_hfp_long_duration_with_tcp_bidirectional(self): |
| """Stress test on hfp call continuously for 12 hours. |
| |
| This test is to start TCP-bidirectional traffic between host machine and |
| android device and test the integrity of hfp connection for 12 hours. |
| |
| Steps: |
| 1. Start TCP-bidirectional traffic. |
| 2. Initiate call. |
| 3. Verify call status. |
| 4. Disconnect call. |
| 5. Repeat steps 2 to 4 for N iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_069 |
| """ |
| if not self.hfp_long_duration_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_hfp_long_duration_with_udp_bidirectional(self): |
| """Stress test on hfp call continuously for 12 hours. |
| |
| This test is to start UDP-bidirectional traffic between host machine and |
| android device and test the integrity of hfp connection for 12 hours. |
| |
| Steps: |
| 1. Start UDP-bidirectional traffic. |
| 2. Initiate call. |
| 3. Verify call status. |
| 4. Disconnect call. |
| 5. Repeat steps 2 to 4 for N iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_070 |
| """ |
| if not self.hfp_long_duration_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_hfp_call_multiple_times_with_tcp_bidirectional(self): |
| """Stress test for initiate and disconnect hfp call. |
| |
| This test is to start TCP-bidirectional traffic between host machine and |
| android device and test the integrity of hfp call. |
| |
| Steps: |
| 1. Start TCP-bidirectional traffic. |
| 2. Initiate call from HF |
| 3. Verify status of call |
| 4. Disconnect from AG. |
| 5. Repeat steps 2 to 4 for N iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_071 |
| """ |
| if not self.initiate_call_multiple_times_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_hfp_call_multiple_times_with_udp_bidirectional(self): |
| """Stress test for initiate and disconnect hfp call. |
| |
| This test is to start UDP-bidirectional traffic between host machine and |
| android device and test the integrity of hfp call. |
| |
| Steps: |
| 1. Start UDP-bidirectional traffic. |
| 2. Initiate call from HF |
| 3. Verify status of call |
| 4. Disconnect from AG. |
| 5. Repeat steps 2 to 4 for N iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_072 |
| """ |
| if not self.initiate_call_multiple_times_with_iperf(): |
| return False |
| return True |