scottk/wlan-testing
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/wlan-testing.git synced 2025-11-03 04:18:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add/Modify: Description and Markers in Client Scale Tests.

Browse Source 
Signed-off-by: jitendracandela <jitendra.kushavah@candelatech.com>
This commit is contained in:
jitendracandela
2024-04-10 16:26:25 +05:30
parent 4419da58c1
commit 95d2ecd93b
6 changed files with 1002 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

169
tests/e2e/basic/performance_tests/client_scale_test/open/test_bridge_mode.py
View File

@@ -37,8 +37,17 @@ setup_params_general_2G = {
@pytest.mark.twog
@pytest.mark.twog_band
class TestWifiCapacityBRIDGEMode2G(object):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and open and twog"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and open and twog
"""
@allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-3648", name="WIFI-3648")
@@ -47,8 +56,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
@allure.title("Test for TCP Download 2.4 GHz")
def test_client_open_BRIDGE_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and open and twog and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and open and twog and tcp_download
"""
profile_data = {"ssid_name": "ssid_open_2g", "appliedRadios": ["2G"]}
ssid_name = profile_data["ssid_name"]
@@ -66,8 +84,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
@allure.title("Test for UDP Download 2.4 GHz")
def test_client_open_BRIDGE_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and open and twog and udp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and open and twog and udp_download
"""
profile_data = {"ssid_name": "ssid_open_2g", "appliedRadios": ["2G"]}
ssid_name = profile_data["ssid_name"]
@@ -86,8 +113,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
def test_client_open_BRIDGE_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and open and twog and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and open and twog and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_open_2g", "appliedRadios": ["2G"]}
ssid_name = profile_data["ssid_name"]
@@ -106,8 +142,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
def test_client_open_BRIDGE_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and open and twog and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and open and twog and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_open_2g", "appliedRadios": ["2G"]}
ssid_name = profile_data["ssid_name"]
@@ -125,8 +170,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
def test_client_open_bridge_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and open and twog and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and open and twog and tcp_upload
"""
profile_data = {"ssid_name": "ssid_open_2g", "appliedRadios": ["2G"]}
ssid_name = profile_data["ssid_name"]
@@ -144,8 +198,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
def test_client_open_bridge_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and open and twog and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and open and twog and udp_upload
"""
profile_data = {"ssid_name": "ssid_open_2g", "appliedRadios": ["2G"]}
ssid_name = profile_data["ssid_name"]
@@ -196,8 +259,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_open_BRIDGE_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and open and fiveg and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and open and fiveg and tcp_download
"""
profile_data = {"ssid_name": "ssid_open_5g", "appliedRadios": ["5G"]}
ssid_name = profile_data["ssid_name"]
@@ -217,8 +289,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_open_BRIDGE_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and open and fiveg and udp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and open and fiveg and udp_download
"""
profile_data = {"ssid_name": "ssid_open_5g", "appliedRadios": ["5G"]}
ssid_name = profile_data["ssid_name"]
@@ -237,8 +318,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_open_BRIDGE_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and open and fiveg and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and open and fiveg and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_open_5g", "appliedRadios": ["5G"]}
ssid_name = profile_data["ssid_name"]
@@ -257,8 +347,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_open_BRIDGE_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and open and fiveg and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and open and fiveg and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_open_5g", "appliedRadios": ["5G"]}
ssid_name = profile_data["ssid_name"]
@@ -276,8 +375,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_open_bridge_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and open and fiveg and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and open and fiveg and udp_upload
"""
profile_data = {"ssid_name": "ssid_open_5g", "appliedRadios": ["5G"]}
ssid_name = profile_data["ssid_name"]
@@ -295,8 +403,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_open_bridge_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and open and fiveg and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and open and fiveg and tcp_upload
"""
profile_data = {"ssid_name": "ssid_open_5g", "appliedRadios": ["5G"]}
ssid_name = profile_data["ssid_name"]

156
tests/e2e/basic/performance_tests/client_scale_test/open/test_nat_mode.py
View File

@@ -47,8 +47,17 @@ class TestWifiCapacityNATMode2G(object):
@allure.title("Test for TCP Download 2.4 GHz")
def test_client_open_NAT_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and open and twog and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and open and twog and tcp_download
"""
profile_data = {"ssid_name": "ssid_open_2g", "appliedRadios": ["2G"]}
ssid_name = profile_data["ssid_name"]
@@ -66,8 +75,17 @@ class TestWifiCapacityNATMode2G(object):
@allure.title("Test for UDP Download 2.4 GHz")
def test_client_open_NAT_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and open and twog and udp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and open and twog and udp_download
"""
profile_data = {"ssid_name": "ssid_open_2g", "appliedRadios": ["2G"]}
ssid_name = profile_data["ssid_name"]
@@ -86,8 +104,17 @@ class TestWifiCapacityNATMode2G(object):
def test_client_open_NAT_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and open and twog and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and open and twog and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_open_2g", "appliedRadios": ["2G"]}
ssid_name = profile_data["ssid_name"]
@@ -106,8 +133,17 @@ class TestWifiCapacityNATMode2G(object):
def test_client_open_NAT_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and open and twog and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and open and twog and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_open_2g", "appliedRadios": ["2G"]}
ssid_name = profile_data["ssid_name"]
@@ -125,8 +161,17 @@ class TestWifiCapacityNATMode2G(object):
def test_client_open_NAT_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and open and twog and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and open and twog and tcp_upload
"""
profile_data = {"ssid_name": "ssid_open_2g", "appliedRadios": ["2G"]}
ssid_name = profile_data["ssid_name"]
@@ -144,8 +189,17 @@ class TestWifiCapacityNATMode2G(object):
def test_client_open_NAT_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and open and twog and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and open and twog and udp_upload
"""
profile_data = {"ssid_name": "ssid_open_2g", "appliedRadios": ["2G"]}
ssid_name = profile_data["ssid_name"]
@@ -196,8 +250,17 @@ class TestWifiCapacityNATMode5G(object):
def test_client_open_NAT_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and open and fiveg and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and open and fiveg and tcp_download
"""
profile_data = {"ssid_name": "ssid_open_5g", "appliedRadios": ["5G"]}
ssid_name = profile_data["ssid_name"]
@@ -217,8 +280,17 @@ class TestWifiCapacityNATMode5G(object):
def test_client_open_NAT_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and open and fiveg and udp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and open and fiveg and udp_download
"""
profile_data = {"ssid_name": "ssid_open_5g", "appliedRadios": ["5G"]}
ssid_name = profile_data["ssid_name"]
@@ -237,8 +309,17 @@ class TestWifiCapacityNATMode5G(object):
def test_client_open_NAT_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and open and fiveg and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and open and fiveg and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_open_5g", "appliedRadios": ["5G"]}
ssid_name = profile_data["ssid_name"]
@@ -257,8 +338,17 @@ class TestWifiCapacityNATMode5G(object):
def test_client_open_NAT_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and open and fiveg and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and open and fiveg and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_open_5g", "appliedRadios": ["5G"]}
ssid_name = profile_data["ssid_name"]
@@ -276,8 +366,17 @@ class TestWifiCapacityNATMode5G(object):
def test_client_open_NAT_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and open and fiveg and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and open and fiveg and udp_upload
"""
profile_data = {"ssid_name": "ssid_open_5g", "appliedRadios": ["5G"]}
ssid_name = profile_data["ssid_name"]
@@ -295,8 +394,17 @@ class TestWifiCapacityNATMode5G(object):
def test_client_open_NAT_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and open and fiveg and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and open and fiveg and tcp_upload
"""
profile_data = {"ssid_name": "ssid_open_5g", "appliedRadios": ["5G"]}
ssid_name = profile_data["ssid_name"]

234
tests/e2e/basic/performance_tests/client_scale_test/wpa2_personal/test_bridge_mode.py
View File

@@ -47,8 +47,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
@allure.title("Test for TCP Download 2.4 GHz")
def test_client_wpa2_BRIDGE_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and twog and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and twog and tcp_download
"""
profile_data = {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -66,8 +75,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
@allure.title("Test for UDP Download 2.4 GHz")
def test_client_wpa2_BRIDGE_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and twog and udp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and twog and udp_download
"""
profile_data = {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -86,8 +104,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
def test_client_wpa2_BRIDGE_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and twog and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and twog and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -106,8 +133,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
def test_client_wpa2_BRIDGE_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and twog and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and twog and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -126,8 +162,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
def test_client_wpa2_bridge_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and twog and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and twog and tcp_upload
"""
profile_data = {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -146,8 +191,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
def test_client_wpa2_bridge_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and twog and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and twog and udp_upload
"""
profile_data = {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -198,8 +252,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_wpa2_BRIDGE_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and fiveg and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and fiveg and tcp_download
"""
profile_data = {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -219,8 +282,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_wpa2_BRIDGE_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and fiveg and udp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and fiveg and udp_download
"""
profile_data = {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -239,8 +311,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_wpa2_BRIDGE_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and fiveg and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and fiveg and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -259,8 +340,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_wpa2_BRIDGE_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and fiveg and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and fiveg and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -278,8 +368,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_wpa2_bridge_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and fiveg and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and fiveg and udp_upload
"""
profile_data = {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -297,8 +396,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_wpa2_bridge_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and fiveg and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and fiveg and tcp_upload
"""
profile_data = {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -350,8 +458,17 @@ class TestWifiCapacityBRIDGEModeDual(object):
@allure.title("Test for TCP Download 2.4 GHz and 5 GHz")
def test_client_wpa2_BRIDGE_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and dual_band and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and dual_band and tcp_download
"""
profile_data = {"ssid_name": "ssid_wpa2_dual_band", "appliedRadios": ["2G", "5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -369,8 +486,17 @@ class TestWifiCapacityBRIDGEModeDual(object):
@allure.title("Test for UDP Download 2.4 GHz and 5 GHz")
def test_client_wpa2_BRIDGE_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and dual_band and udp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and dual_band and udp_download
"""
profile_data = {"ssid_name": "ssid_wpa2_dual_band", "appliedRadios": ["2G", "5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -389,8 +515,17 @@ class TestWifiCapacityBRIDGEModeDual(object):
def test_client_wpa2_BRIDGE_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and dual_band and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and dual_band and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa2_dual_band", "appliedRadios": ["2G", "5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -409,8 +544,17 @@ class TestWifiCapacityBRIDGEModeDual(object):
def test_client_wpa2_BRIDGE_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and dual_band and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and dual_band and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa2_dual_band", "appliedRadios": ["2G", "5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -429,8 +573,17 @@ class TestWifiCapacityBRIDGEModeDual(object):
def test_client_wpa2_bridge_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and dual_band and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and dual_band and tcp_upload
"""
profile_data = {"ssid_name": "ssid_wpa2_dual_band", "appliedRadios": ["2G", "5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -449,8 +602,17 @@ class TestWifiCapacityBRIDGEModeDual(object):
def test_client_wpa2_bridge_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa2_personal and dual_band and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa2_personal and dual_band and udp_upload
"""
profile_data = {"ssid_name": "ssid_wpa2_dual_band", "appliedRadios": ["2G", "5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]

234
tests/e2e/basic/performance_tests/client_scale_test/wpa2_personal/test_nat_mode.py
View File

@@ -47,8 +47,17 @@ class TestWifiCapacityNATMode2G(object):
@allure.title("Test for TCP Download 2.4 GHz")
def test_client_wpa2_NAT_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and twog and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and twog and tcp_download
"""
profile_data = {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -66,8 +75,17 @@ class TestWifiCapacityNATMode2G(object):
@allure.title("Test for UDP Download 2.4 GHz")
def test_client_wpa2_NAT_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and twog and udp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and twog and udp_download
"""
profile_data = {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -86,8 +104,17 @@ class TestWifiCapacityNATMode2G(object):
def test_client_wpa2_NAT_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and twog and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and twog and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -106,8 +133,17 @@ class TestWifiCapacityNATMode2G(object):
def test_client_wpa2_NAT_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and twog and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and twog and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -126,8 +162,17 @@ class TestWifiCapacityNATMode2G(object):
def test_client_wpa2_NAT_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and twog and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and twog and tcp_upload
"""
profile_data = {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -146,8 +191,17 @@ class TestWifiCapacityNATMode2G(object):
def test_client_wpa2_NAT_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and twog and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and twog and udp_upload
"""
profile_data = {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -198,8 +252,17 @@ class TestWifiCapacityNATMode5G(object):
def test_client_wpa2_NAT_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and fiveg and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and fiveg and tcp_download
"""
profile_data = {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -219,8 +282,17 @@ class TestWifiCapacityNATMode5G(object):
def test_client_wpa2_NAT_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and fiveg and udp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and fiveg and udp_download
"""
profile_data = {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -239,8 +311,17 @@ class TestWifiCapacityNATMode5G(object):
def test_client_wpa2_NAT_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and fiveg and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and fiveg and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -259,8 +340,17 @@ class TestWifiCapacityNATMode5G(object):
def test_client_wpa2_NAT_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and fiveg and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and fiveg and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -278,8 +368,17 @@ class TestWifiCapacityNATMode5G(object):
def test_client_wpa2_NAT_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and fiveg and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and fiveg and udp_upload
"""
profile_data = {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -297,8 +396,17 @@ class TestWifiCapacityNATMode5G(object):
def test_client_wpa2_NAT_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and fiveg and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and fiveg and tcp_upload
"""
profile_data = {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -350,8 +458,17 @@ class TestWifiCapacityNATModeDual(object):
@allure.title("Test for TCP Download 2.4 GHz and 5 GHz")
def test_client_wpa2_NAT_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and dual_band and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and dual_band and tcp_download
"""
profile_data = {"ssid_name": "ssid_wpa2_dual_band", "appliedRadios": ["2G", "5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -369,8 +486,17 @@ class TestWifiCapacityNATModeDual(object):
@allure.title("Test for UDP Download 2.4 GHz and 5 GHz")
def test_client_wpa2_NAT_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and dual_band and udp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and dual_band and udp_download
"""
profile_data = {"ssid_name": "ssid_wpa2_dual_band", "appliedRadios": ["2G", "5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -389,8 +515,17 @@ class TestWifiCapacityNATModeDual(object):
def test_client_wpa2_NAT_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and dual_band and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and dual_band and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa2_dual_band", "appliedRadios": ["2G", "5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -409,8 +544,17 @@ class TestWifiCapacityNATModeDual(object):
def test_client_wpa2_NAT_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and dual_band and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and dual_band and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa2_dual_band", "appliedRadios": ["2G", "5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -429,8 +573,17 @@ class TestWifiCapacityNATModeDual(object):
def test_client_wpa2_NAT_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and dual_band and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and dual_band and tcp_upload
"""
profile_data = {"ssid_name": "ssid_wpa2_dual_band", "appliedRadios": ["2G", "5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -449,8 +602,17 @@ class TestWifiCapacityNATModeDual(object):
def test_client_wpa2_NAT_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test NAT mode
pytest -m "client_scale_tests and nat and wpa2_personal and dual_band and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and nat and wpa2_personal and dual_band and udp_upload
"""
profile_data = {"ssid_name": "ssid_wpa2_dual_band", "appliedRadios": ["2G", "5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]

236
tests/e2e/basic/performance_tests/client_scale_test/wpa3_personal/test_bridge_mode.py
View File

@@ -47,8 +47,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
@allure.title("Test for TCP Download 2.4 GHz")
def test_client_wpa3_bridge_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and twog and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and twog and tcp_download
"""
profile_data = {"ssid_name": "ssid_wpa3_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -65,8 +74,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
@allure.title("Test for TCP Upload 2.4 GHz")
def test_client_wpa3_bridge_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and twog and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and twog and tcp_upload
"""
profile_data = {"ssid_name": "ssid_wpa3_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -83,8 +101,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
@allure.title("Test for UDP Upload 2.4 GHz")
def test_client_wpa3_bridge_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and twog and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and twog and udp_upload
"""
profile_data = {"ssid_name": "ssid_wpa3_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -102,9 +129,18 @@ class TestWifiCapacityBRIDGEMode2G(object):
@allure.title("Test for UDP Download 2.4 GHz")
def test_client_wpa3_bridge_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and twog and udp_download"
"""
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and twog and udp_download
"""
profile_data = {"ssid_name": "ssid_wpa3_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
mode = "BRIDGE"
@@ -122,8 +158,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
def test_client_wpa3_bridge_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and twog and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and twog and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa3_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -142,8 +187,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
def test_client_wpa3_bridge_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and twog and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and twog and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa3_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -193,8 +247,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
@allure.title("Test for TCP Download 5 GHz")
def test_client_wpa3_bridge_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and fiveg and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and fiveg and tcp_download
"""
profile_data = {"ssid_name": "ssid_wpa3_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -212,8 +275,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
@allure.title("Test for UDP Download 5 GHz")
def test_client_wpa3_bridge_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and fiveg and udp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and fiveg and udp_download
"""
profile_data = {"ssid_name": "ssid_wpa3_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -232,8 +304,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_wpa3_bridge_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and fiveg and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and fiveg and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa3_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -252,8 +333,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_wpa3_bridge_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and fiveg and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and fiveg and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa3_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -270,8 +360,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
@allure.title("Test for TCP Upload 5 GHz")
def test_client_wpa3_bridge_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and fiveg and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and fiveg and tcp_upload
"""
profile_data = {"ssid_name": "ssid_wpa3_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -288,8 +387,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
@allure.title("Test for UDP Upload 5 GHz")
def test_client_wpa3_bridge_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and fiveg and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and fiveg and udp_upload
"""
profile_data = {"ssid_name": "ssid_wpa3_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -340,8 +448,17 @@ class TestWifiCapacityBRIDGEMode6G(object):
@allure.title("Test for TCP Download 6 GHz")
def test_client_wpa3_bridge_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and sixg and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and sixg and tcp_download
"""
profile_data = {"ssid_name": "ssid_wpa3_6g", "appliedRadios": ["6G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -360,8 +477,17 @@ class TestWifiCapacityBRIDGEMode6G(object):
@allure.title("Test for UDP Download 6 GHz")
def test_client_wpa3_bridge_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and sixg and udp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and sixg and udp_download
"""
profile_data = {"ssid_name": "ssid_wpa3_6g", "appliedRadios": ["6G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -381,8 +507,17 @@ class TestWifiCapacityBRIDGEMode6G(object):
def test_client_wpa3_bridge_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and sixg and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and sixg and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa3_6g", "appliedRadios": ["6G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -402,8 +537,17 @@ class TestWifiCapacityBRIDGEMode6G(object):
def test_client_wpa3_bridge_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and sixg and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and sixg and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa3_6g", "appliedRadios": ["6G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -421,8 +565,17 @@ class TestWifiCapacityBRIDGEMode6G(object):
@allure.title("Test for TCP Upload 6 GHz")
def test_client_wpa3_bridge_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and sixg and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and sixg and tcp_upload
"""
profile_data = {"ssid_name": "ssid_wpa3_6g", "appliedRadios": ["6G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -440,8 +593,17 @@ class TestWifiCapacityBRIDGEMode6G(object):
@allure.title("Test for UDP Upload 6 GHz")
def test_client_wpa3_bridge_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa3_personal and sixg and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa3_personal and sixg and udp_upload
"""
profile_data = {"ssid_name": "ssid_wpa3_6g", "appliedRadios": ["6G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]

156
tests/e2e/basic/performance_tests/client_scale_test/wpa_personal/test_bridge_mode.py
View File

@@ -47,8 +47,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
@allure.title("Test for TCP Download 2.4 GHz")
def test_client_wpa_BRIDGE_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa_personal and twog and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa_personal and twog and tcp_download
"""
profile_data = {"ssid_name": "ssid_wpa_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -66,8 +75,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
@allure.title("Test for UDP Download 2.4 GHz")
def test_client_wpa_BRIDGE_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration, max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa_personal and twog and udp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa_personal and twog and udp_download
"""
profile_data = {"ssid_name": "ssid_wpa_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -86,8 +104,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
def test_client_wpa_BRIDGE_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa_personal and twog and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa_personal and twog and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -106,8 +133,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
def test_client_wpa_BRIDGE_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa_personal and twog and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa_personal and twog and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -125,8 +161,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
def test_client_wpa_bridge_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa_personal and twog and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa_personal and twog and tcp_upload
"""
profile_data = {"ssid_name": "ssid_wpa_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -144,8 +189,17 @@ class TestWifiCapacityBRIDGEMode2G(object):
def test_client_wpa_bridge_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa_personal and twog and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa_personal and twog and udp_upload
"""
profile_data = {"ssid_name": "ssid_wpa_2g", "appliedRadios": ["2G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -196,8 +250,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_wpa_BRIDGE_tcp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa_personal and fiveg and tcp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa_personal and fiveg and tcp_download
"""
profile_data = {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -217,8 +280,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_wpa_BRIDGE_udp_dl(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa_personal and fiveg and udp_download"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa_personal and fiveg and udp_download
"""
profile_data = {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -237,8 +309,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_wpa_BRIDGE_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa_personal and fiveg and tcp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa_personal and fiveg and tcp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -257,8 +338,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_wpa_BRIDGE_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa_personal and fiveg and udp_bidirectional"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa_personal and fiveg and udp_bidirectional
"""
profile_data = {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -276,8 +366,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_wpa_bridge_udp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa_personal and fiveg and udp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa_personal and fiveg and udp_upload
"""
profile_data = {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]
@@ -295,8 +394,17 @@ class TestWifiCapacityBRIDGEMode5G(object):
def test_client_wpa_bridge_tcp_ul(self, get_test_library, get_dut_logs_per_test_case,
get_test_device_logs, num_stations, setup_configuration,
max_stations):
""" Client Scale Test BRIDGE mode
pytest -m "client_scale_tests and bridge and wpa_personal and fiveg and tcp_upload"
"""
The WiFi Capacity test is designed to measure the performance of an Access Point when handling different
amounts of WiFi Stations. The test allows the user to increase the number of stations in user-defined steps
for each test iteration and measure the per station and the overall throughput for each trial. Along with
throughput other measurements made are client connection times, Fairness, % packet loss, DHCP times, and more.
The expected behavior is for the AP to be able to handle several stations (within the limitations of the AP
specs) and make sure all stations get a fair amount of airtime both upstream and downstream. An AP that
scales well will not show a significant overall throughput decrease as more stations are added.
Unique Marker:
client_scale_tests and bridge and wpa_personal and fiveg and tcp_upload
"""
profile_data = {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["5G"], "security_key": "something"}
ssid_name = profile_data["ssid_name"]