| #!/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. |
| """ |
| Test to check Basic Stress with Wlan. |
| |
| Test Setup: |
| |
| One Android device. |
| """ |
| import time |
| |
| from acts.test_utils.coex.CoexBaseTest import CoexBaseTest |
| from acts.test_utils.coex.coex_test_utils import toggle_bluetooth |
| from acts.test_utils.coex.coex_test_utils import device_discoverable |
| |
| |
| class CoexBasicStressTest(CoexBaseTest): |
| |
| def setup_class(self): |
| super().setup_class() |
| |
| req_params = ["iterations"] |
| self.unpack_userparams(req_params) |
| |
| def start_stop_classic_discovery_with_iperf(self): |
| """Starts and stop bluetooth discovery for 1000 iterations. |
| |
| Steps: |
| 1. Start Discovery on Primary device. |
| 2. Stop Discovery on Secondary device. |
| 3. Repeat step 1 and 2. |
| |
| Returns: |
| True if successful, False otherwise. |
| """ |
| self.run_iperf_and_get_result() |
| for i in range(self.iterations): |
| self.log.info("Discovery iteration {}".format(i)) |
| if not self.pri_ad.droid.bluetoothStartDiscovery(): |
| self.log.error("Bluetooth discovery failed.") |
| return False |
| time.sleep(2) |
| if not self.pri_ad.droid.bluetoothCancelDiscovery(): |
| self.log.error("Bluetooth cancel discovery failed.") |
| return False |
| return self.teardown_result() |
| |
| def check_device_discoverability_with_iperf(self): |
| """Checks if primary device is visible from secondary device. |
| |
| Steps: |
| 1. Start discovery on primary device. |
| 2. Discover primary device from Secondary device. |
| 3. Repeat step 1 and 2. |
| |
| Returns: |
| True if successful, False otherwise. |
| """ |
| self.run_iperf_and_get_result() |
| for i in range(self.iterations): |
| self.log.info("Discovery iteration = {}".format(i)) |
| if not device_discoverable(self.pri_ad, self.sec_ad): |
| self.log.error("Primary device could not be discovered.") |
| return False |
| return self.teardown_result() |
| |
| def toogle_bluetooth_with_iperf(self): |
| """Wrapper function to start iperf traffic and toggling bluetooth.""" |
| self.run_iperf_and_get_result() |
| if not toggle_bluetooth(self.pri_ad, self.iperf["duration"]): |
| return False |
| return self.teardown_result() |
| |
| def test_stress_toggle_bluetooth_with_tcp_ul(self): |
| """Stress test toggling bluetooth on and off. |
| |
| This test is to start TCP-uplink traffic between host machine |
| and android device and test the integrity of toggling bluetooth |
| on and off. |
| |
| Steps: |
| 1. Starts TCP-uplink traffic. |
| 2. Toggle bluetooth state on and off for N iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_001 |
| """ |
| if not self.toogle_bluetooth_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_toggle_bluetooth_with_tcp_dl(self): |
| """Stress test toggling bluetooth on and off. |
| |
| This test is to start TCP-downlink traffic between host machine |
| and android device and test the integrity of toggling bluetooth |
| on and off. |
| |
| Steps: |
| 1. Starts TCP-downlink traffic. |
| 2. Toggle bluetooth state on and off for N iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_002 |
| """ |
| if not self.toogle_bluetooth_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_toggle_bluetooth_with_udp_ul(self): |
| """Stress test toggling bluetooth on and off. |
| |
| This test is to start UDP-uplink traffic between host machine |
| and android device and test the integrity of toggling bluetooth |
| on and off. |
| |
| Steps: |
| 1. Starts UDP-uplink traffic. |
| 2. Toggle bluetooth state on and off for N iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_003 |
| """ |
| if not self.toogle_bluetooth_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_toggle_bluetooth_with_udp_dl(self): |
| """Stress test toggling bluetooth on and off. |
| |
| This test is to start UDP-downlink traffic between host machine |
| and android device and test the integrity of toggling bluetooth |
| on and off. |
| |
| Steps: |
| 1. Starts UDP-downlink traffic. |
| 2. Toggle bluetooth state on and off for N iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_004 |
| """ |
| if not self.toogle_bluetooth_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_bluetooth_discovery_with_tcp_ul(self): |
| """Stress test on bluetooth discovery. |
| |
| This test is to start TCP-uplink traffic between host machine |
| and android device and test the integrity of start and stop discovery. |
| |
| Steps: |
| 1. Starts TCP-uplink traffic. |
| 2. Performs start and stop discovery in quick succession. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_005 |
| """ |
| if not self.start_stop_classic_discovery_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_bluetooth_discovery_with_tcp_dl(self): |
| """Stress test on bluetooth discovery. |
| |
| This test is to start TCP-downlink traffic between host machine |
| and android device and test the integrity of start and stop discovery. |
| |
| Steps: |
| 1. Starts TCP-downlink traffic. |
| 2. Performs start and stop discovery in quick succession. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_006 |
| """ |
| if not self.start_stop_classic_discovery_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_bluetooth_discovery_with_udp_ul(self): |
| """Stress test on bluetooth discovery. |
| |
| This test is to start UDP-uplink traffic between host machine |
| and android device and test the integrity of start and stop discovery. |
| |
| Steps: |
| 1. Starts UDP-uplink traffic. |
| 2. Performs start and stop discovery in quick succession. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_007 |
| """ |
| if not self.start_stop_classic_discovery_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_bluetooth_discovery_with_udp_dl(self): |
| """Stress test on bluetooth discovery. |
| |
| This test is to start UDP-downlink traffic between host machine |
| and android device and test the integrity of start and stop discovery. |
| |
| Steps: |
| 1. Starts UDP-downlink traffic. |
| 2. Performs start and stop discovery in quick succession. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_008 |
| """ |
| if not self.start_stop_classic_discovery_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_primary_device_visibility_with_tcp_ul(self): |
| """Stress test on device visibility from secondary device. |
| |
| This test is to start TCP-uplink traffic between host machine |
| and android device and stress test on device discoverability from |
| secondary device |
| |
| Steps: |
| 1. Start TCP-uplink traffic. |
| 2. Make primary device visible. |
| 3. Check if primary device name is visible from secondary device. |
| 4. Repeat step 2 and 3 for n iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_009 |
| """ |
| if not self.check_device_discoverability_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_primary_device_visibility_with_tcp_dl(self): |
| """Stress test on device visibility from secondary device. |
| |
| This test is to start TCP-downlink traffic between host machine |
| and android device and stress test on device discoverability from |
| secondary device |
| |
| Steps: |
| 1. Start TCP-downlink traffic. |
| 2. Make primary device visible. |
| 3. Check if primary device name is visible from secondary device. |
| 4. Repeat step 2 and 3 for n iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_010 |
| """ |
| if not self.check_device_discoverability_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_primary_device_visibility_with_udp_ul(self): |
| """Stress test on device visibility from secondary device. |
| |
| This test is to start UDP-uplink traffic between host machine |
| and android device and stress test on device discoverability from |
| secondary device |
| |
| Steps: |
| 1. Start UDP-uplink traffic. |
| 2. Make primary device visible. |
| 3. Check if primary device name is visible from secondary device. |
| 4. Repeat step 2 and 3 for n iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_011 |
| """ |
| if not self.check_device_discoverability_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_primary_device_visibility_with_udp_dl(self): |
| """Stress test on device visibility from secondary device. |
| |
| This test is to start UDP-downlink traffic between host machine |
| and android device and stress test on device discoverability from |
| secondary device |
| |
| Steps: |
| 1. Start UDP-downlink traffic. |
| 2. Make primary device visible. |
| 3. Check if primary device name is visible from secondary device. |
| 4. Repeat step 2 and 3 for n iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_012 |
| """ |
| if not self.check_device_discoverability_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_toggle_bluetooth_with_tcp_bidirectional(self): |
| """Stress test toggling bluetooth on and off. |
| |
| This test is to start TCP-bidirectional traffic between host machine |
| and android device and test the integrity of toggling bluetooth |
| on and off. |
| |
| Steps: |
| 1. Starts TCP-bidirectional traffic. |
| 2. Toggle bluetooth state on and off for N iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_051 |
| """ |
| if not self.toogle_bluetooth_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_toggle_bluetooth_with_udp_bidirectional(self): |
| """Stress test toggling bluetooth on and off. |
| |
| This test is to start UDP-bidirectional traffic between host machine |
| and android device and test the integrity of toggling bluetooth |
| on and off. |
| |
| Steps: |
| 1. Starts TCP-bidirectional traffic. |
| 2. Toggle bluetooth state on and off for N iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_052 |
| """ |
| if not self.toogle_bluetooth_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_bluetooth_discovery_with_tcp_bidirectional(self): |
| """Stress test on bluetooth discovery. |
| |
| This test is to start TCP-bidirectional traffic between host machine |
| and android device and test the integrity of start and stop discovery. |
| |
| Steps: |
| 1. Starts TCP-bidirectional traffic. |
| 2. Performs start and stop discovery in quick succession. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_053 |
| """ |
| if not self.start_stop_classic_discovery_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_bluetooth_discovery_with_udp_bidirectional(self): |
| """Stress test on bluetooth discovery. |
| |
| This test is to start UDP-bidirectional traffic between host machine |
| and android device and test the integrity of start and stop discovery. |
| |
| Steps: |
| 1. Start wlan traffic with UDP-bidirectional. |
| 2. Start bluetooth discovery for N iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_054 |
| """ |
| if not self.start_stop_classic_discovery_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_primary_device_visiblity_tcp_bidirectional(self): |
| """Stress test on device visibility from secondary device. |
| |
| This test is to start TCP-bidirectional traffic between host machine |
| and android device and stress test on device discoverability from |
| secondary device |
| |
| Steps: |
| 1. Start TCP-bidirectional traffic. |
| 2. Make primary device visible. |
| 3. Check if primary device name is visible from secondary device. |
| 4. Repeat step 2 and 3 for n iterations |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_055 |
| """ |
| if not self.check_device_discoverability_with_iperf(): |
| return False |
| return True |
| |
| def test_stress_primary_device_visiblity_udp_bidirectional(self): |
| """Stress test on device visibility from secondary device. |
| |
| This test is to start UDP-bidirectional traffic between host machine |
| and android device and stress test on device discoverability from |
| secondary device |
| |
| Steps: |
| 1. Start UDP-bidirectional traffic. |
| 2. Make primary device visible. |
| 3. Check if primary device name is visible from secondary device. |
| 4. Repeat step 2 and 3 for n iterations. |
| |
| Returns: |
| True if successful, False otherwise. |
| |
| Test Id: Bt_CoEx_Stress_056 |
| """ |
| if not self.check_device_discoverability_with_iperf(): |
| return False |
| return True |