From 9afec3c4f3eca9db2c2b0c1b2e2aa0539fcaa007 Mon Sep 17 00:00:00 2001
From: Chen Yudong <chenyudong@espressif.com>
Date: Fri, 6 Feb 2026 17:43:04 +0800
Subject: [PATCH] fix: use iperf-cmd for example esp_ble_mesh/wifi_coexist

---
 .../esp_ble_mesh/wifi_coexist/main/cmd_wifi.c | 155 +-----------------
 .../wifi_coexist/main/idf_component.yml       |   2 +-
 .../esp_ble_mesh/wifi_coexist/main/main.c     |   3 +
 ...E_Mesh_WiFi_Coexist_Example_Walkthrough.md |   2 +-
 examples/wifi/iperf/sdkconfig.ci.99           |   1 +
 examples/wifi/iperf/sdkconfig.defaults        |   1 -
 .../idf_iperf_test_util/IperfUtility.py       |  89 +++++-----
 7 files changed, 45 insertions(+), 208 deletions(-)

diff --git a/examples/bluetooth/esp_ble_mesh/wifi_coexist/main/cmd_wifi.c b/examples/bluetooth/esp_ble_mesh/wifi_coexist/main/cmd_wifi.c
index 42da684a3a..ff2e4f2d2a 100644
--- a/examples/bluetooth/esp_ble_mesh/wifi_coexist/main/cmd_wifi.c
+++ b/examples/bluetooth/esp_ble_mesh/wifi_coexist/main/cmd_wifi.c
@@ -1,7 +1,7 @@
 /*
  * Iperf example - wifi commands
  *
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2026 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
@@ -18,21 +18,6 @@
 #include "freertos/event_groups.h"
 #include "esp_wifi.h"
 #include "esp_netif.h"
-#include "iperf.h"
-
-typedef struct {
-    struct arg_str *ip;
-    struct arg_lit *server;
-    struct arg_lit *udp;
-    struct arg_lit *version;
-    struct arg_int *port;
-    struct arg_int *length;
-    struct arg_int *interval;
-    struct arg_int *time;
-    struct arg_lit *abort;
-    struct arg_end *end;
-} wifi_iperf_t;
-static wifi_iperf_t iperf_args;
 
 typedef struct {
     struct arg_str *ssid;
@@ -293,124 +278,6 @@ static int wifi_cmd_query(int argc, char **argv)
     return 0;
 }
 
-static uint32_t wifi_get_local_ip(void)
-{
-    int bits = xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT, 0, 1, 0);
-    esp_netif_t *ifx = ap_netif;
-    esp_netif_ip_info_t ip_info;
-    wifi_mode_t mode;
-
-    esp_wifi_get_mode(&mode);
-    if (WIFI_MODE_STA == mode) {
-        bits = xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT, 0, 1, 0);
-        if (bits & CONNECTED_BIT) {
-            ifx = sta_netif;
-        } else {
-            ESP_LOGE(TAG, "sta has no IP");
-            return 0;
-        }
-    }
-
-    esp_netif_get_ip_info(ifx, &ip_info);
-    return ip_info.ip.addr;
-}
-
-static int wifi_cmd_iperf(int argc, char **argv)
-{
-    int nerrors = arg_parse(argc, argv, (void **) &iperf_args);
-    iperf_cfg_t cfg;
-
-    if (nerrors != 0) {
-        arg_print_errors(stderr, iperf_args.end, argv[0]);
-        return 0;
-    }
-
-    memset(&cfg, 0, sizeof(cfg));
-
-    // wifi iperf only support IPV4 address
-    cfg.type = IPERF_IP_TYPE_IPV4;
-
-    if ( iperf_args.abort->count != 0) {
-        iperf_stop();
-        return 0;
-    }
-
-    if ( ((iperf_args.ip->count == 0) && (iperf_args.server->count == 0)) ||
-            ((iperf_args.ip->count != 0) && (iperf_args.server->count != 0)) ) {
-        ESP_LOGE(TAG, "should specific client/server mode");
-        return 0;
-    }
-
-    if (iperf_args.ip->count == 0) {
-        cfg.flag |= IPERF_FLAG_SERVER;
-    } else {
-        cfg.destination_ip4 = esp_ip4addr_aton(iperf_args.ip->sval[0]);
-        cfg.flag |= IPERF_FLAG_CLIENT;
-    }
-
-    cfg.source_ip4 = wifi_get_local_ip();
-    if (cfg.source_ip4 == 0) {
-        return 0;
-    }
-
-    if (iperf_args.length->count == 0) {
-        cfg.len_send_buf = 0;
-    } else {
-        cfg.len_send_buf = iperf_args.length->ival[0];
-    }
-
-    if (iperf_args.udp->count == 0) {
-        cfg.flag |= IPERF_FLAG_TCP;
-    } else {
-        cfg.flag |= IPERF_FLAG_UDP;
-    }
-
-    if (iperf_args.port->count == 0) {
-        cfg.sport = IPERF_DEFAULT_PORT;
-        cfg.dport = IPERF_DEFAULT_PORT;
-    } else {
-        if (cfg.flag & IPERF_FLAG_SERVER) {
-            cfg.sport = iperf_args.port->ival[0];
-            cfg.dport = IPERF_DEFAULT_PORT;
-        } else {
-            cfg.sport = IPERF_DEFAULT_PORT;
-            cfg.dport = iperf_args.port->ival[0];
-        }
-    }
-
-    if (iperf_args.interval->count == 0) {
-        cfg.interval = IPERF_DEFAULT_INTERVAL;
-    } else {
-        cfg.interval = iperf_args.interval->ival[0];
-        if (cfg.interval <= 0) {
-            cfg.interval = IPERF_DEFAULT_INTERVAL;
-        }
-    }
-
-    if (iperf_args.time->count == 0) {
-        cfg.time = IPERF_DEFAULT_TIME;
-    } else {
-        cfg.time = iperf_args.time->ival[0];
-        if (cfg.time <= cfg.interval) {
-            cfg.time = cfg.interval;
-        }
-    }
-
-    ESP_LOGI(TAG, "mode=%s-%s sip=%" PRIu32 ".%" PRIu32 ".%" PRIu32 ".%" PRIu32 ":%d, \
-             dip=%" PRIu32 ".%" PRIu32 ".%" PRIu32 ".%" PRIu32 ":%d, interval=%" PRIu32 ", time=%" PRIu32,
-             cfg.flag & IPERF_FLAG_TCP ? "tcp" : "udp",
-             cfg.flag & IPERF_FLAG_SERVER ? "server" : "client",
-             cfg.source_ip4 & 0xFF, (cfg.source_ip4 >> 8) & 0xFF, (cfg.source_ip4 >> 16) & 0xFF,
-             (cfg.source_ip4 >> 24) & 0xFF, cfg.sport,
-             cfg.destination_ip4 & 0xFF, (cfg.destination_ip4 >> 8) & 0xFF, (cfg.destination_ip4 >> 16) & 0xFF,
-             (cfg.destination_ip4 >> 24) & 0xFF, cfg.dport,
-             cfg.interval, cfg.time);
-
-    iperf_start(&cfg);
-
-    return 0;
-}
-
 static int restart(int argc, char **argv)
 {
     ESP_LOGI(TAG, "Restarting");
@@ -484,26 +351,6 @@ void register_wifi(void)
     };
     ESP_ERROR_CHECK( esp_console_cmd_register(&restart_cmd) );
 
-    iperf_args.ip = arg_str0("c", "client", "<ip>", "run in client mode, connecting to <host>");
-    iperf_args.server = arg_lit0("s", "server", "run in server mode");
-    iperf_args.udp = arg_lit0("u", "udp", "use UDP rather than TCP");
-    iperf_args.version = arg_lit0("V", "ipv6_domain", "use IPV6 address rather than IPV4");
-    iperf_args.port = arg_int0("p", "port", "<port>", "server port to listen on/connect to");
-    iperf_args.length = arg_int0("l", "len", "<length>", "set read/write buffer size");
-    iperf_args.interval = arg_int0("i", "interval", "<interval>", "seconds between periodic bandwidth reports");
-    iperf_args.time = arg_int0("t", "time", "<time>", "time in seconds to transmit for (default 10 secs)");
-    iperf_args.abort = arg_lit0("a", "abort", "abort running iperf");
-    iperf_args.end = arg_end(1);
-    const esp_console_cmd_t iperf_cmd = {
-        .command = "iperf",
-        .help = "iperf command",
-        .hint = NULL,
-        .func = &wifi_cmd_iperf,
-        .argtable = &iperf_args
-    };
-
-    ESP_ERROR_CHECK( esp_console_cmd_register(&iperf_cmd) );
-
     const esp_console_cmd_t heap_cmd = {
         .command = "heap",
         .help = "get min free heap size during test",
diff --git a/examples/bluetooth/esp_ble_mesh/wifi_coexist/main/idf_component.yml b/examples/bluetooth/esp_ble_mesh/wifi_coexist/main/idf_component.yml
index 21aa055cda..04de8d21e9 100644
--- a/examples/bluetooth/esp_ble_mesh/wifi_coexist/main/idf_component.yml
+++ b/examples/bluetooth/esp_ble_mesh/wifi_coexist/main/idf_component.yml
@@ -3,5 +3,5 @@ dependencies:
     path: ${IDF_PATH}/examples/bluetooth/esp_ble_mesh/common_components/fast_prov
   example_init:
     path: ${IDF_PATH}/examples/bluetooth/esp_ble_mesh/common_components/example_init
-  espressif/iperf:
+  espressif/iperf-cmd:
     version: "^1.0.2"
diff --git a/examples/bluetooth/esp_ble_mesh/wifi_coexist/main/main.c b/examples/bluetooth/esp_ble_mesh/wifi_coexist/main/main.c
index e4d4da0bf4..5b01266934 100644
--- a/examples/bluetooth/esp_ble_mesh/wifi_coexist/main/main.c
+++ b/examples/bluetooth/esp_ble_mesh/wifi_coexist/main/main.c
@@ -39,6 +39,8 @@
 #include "ble_mesh_fast_prov_server_model.h"
 #include "ble_mesh_example_init.h"
 
+#include "iperf_cmd.h"
+
 #define TAG "EXAMPLE"
 
 extern struct _led_state led_state[3];
@@ -772,6 +774,7 @@ static void wifi_console_init(void)
 
     /* Register commands */
     register_wifi();
+    iperf_cmd_register_iperf();
 
     printf("\n ==================================================\n");
     printf(" |       Steps to test WiFi throughput            |\n");
diff --git a/examples/bluetooth/esp_ble_mesh/wifi_coexist/tutorial/BLE_Mesh_WiFi_Coexist_Example_Walkthrough.md b/examples/bluetooth/esp_ble_mesh/wifi_coexist/tutorial/BLE_Mesh_WiFi_Coexist_Example_Walkthrough.md
index d7e7623f08..8993ac9fa5 100644
--- a/examples/bluetooth/esp_ble_mesh/wifi_coexist/tutorial/BLE_Mesh_WiFi_Coexist_Example_Walkthrough.md
+++ b/examples/bluetooth/esp_ble_mesh/wifi_coexist/tutorial/BLE_Mesh_WiFi_Coexist_Example_Walkthrough.md
@@ -6,7 +6,7 @@ This demo demonstrates the Wi-Fi and Bluetooth (BLE/BR/EDR) coexistence feature
 * The Bluetooth function is demonstrated by the fast provisioning function. Details can be seen in `fast_prov_server`.
 
 
-> Note: In this demo, you call wifi API and bluetooth API to achieve the functions you want. such as `wifi_get_local_ip` API and `esp_ble_mesh_provisioner_add_unprov_dev` API.
+> Note: In this demo, you call wifi API and bluetooth API to achieve the functions you want. such as `esp_wifi_sta_get_ap_info` API and `esp_ble_mesh_provisioner_add_unprov_dev` API.
 
 # What You Need
 
diff --git a/examples/wifi/iperf/sdkconfig.ci.99 b/examples/wifi/iperf/sdkconfig.ci.99
index e69de29bb2..7b7adde7e4 100644
--- a/examples/wifi/iperf/sdkconfig.ci.99
+++ b/examples/wifi/iperf/sdkconfig.ci.99
@@ -0,0 +1 @@
+CONFIG_LWIP_EXTRA_IRAM_OPTIMIZATION=y
diff --git a/examples/wifi/iperf/sdkconfig.defaults b/examples/wifi/iperf/sdkconfig.defaults
index 5911186722..6296ca9331 100644
--- a/examples/wifi/iperf/sdkconfig.defaults
+++ b/examples/wifi/iperf/sdkconfig.defaults
@@ -7,7 +7,6 @@ CONFIG_ESP_INT_WDT=n
 CONFIG_ESP_TASK_WDT_EN=n
 
 CONFIG_LWIP_IRAM_OPTIMIZATION=y
-CONFIG_LWIP_EXTRA_IRAM_OPTIMIZATION=y
 CONFIG_LWIP_TCPIP_TASK_PRIO=23
 
 CONFIG_COMPILER_OPTIMIZATION_PERF=y
diff --git a/tools/ci/python_packages/idf_iperf_test_util/IperfUtility.py b/tools/ci/python_packages/idf_iperf_test_util/IperfUtility.py
index 5a40b32032..62a186d814 100644
--- a/tools/ci/python_packages/idf_iperf_test_util/IperfUtility.py
+++ b/tools/ci/python_packages/idf_iperf_test_util/IperfUtility.py
@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2022-2026 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Apache-2.0
 import logging
 import os
@@ -13,7 +13,6 @@ from idf_iperf_test_util import LineChart
 
 try:
     from typing import Any
-    from typing import Tuple
 except ImportError:
     # Only used for type annotations
     pass
@@ -31,7 +30,7 @@ INVALID_HEAP_SIZE = 0xFFFFFFFF
 PC_IPERF_TEMP_LOG_FILE = '.tmp_iperf.log'
 
 
-class TestResult(object):
+class TestResult:
     """record, analysis test result and convert data to output format"""
 
     PC_BANDWIDTH_LOG_PATTERN = re.compile(r'(\d+\.\d+)\s*-\s*(\d+.\d+)\s+sec\s+[\d.]+\s+MBytes\s+([\d.]+)\s+Mbits\/sec')
@@ -119,24 +118,21 @@ class TestResult(object):
             if throughput == 0 and rssi > self.ZERO_POINT_THRESHOLD and fall_to_0_recorded < 1:
                 # throughput fall to 0 error. we only record 1 records for one test
                 self.error_list.append(
-                    '[Error][fall to 0][{}][att: {}][rssi: {}]: 0 throughput interval: {}-{}'.format(
-                        ap_ssid, att, rssi, result[0], result[1]
-                    )
+                    f'[Error][fall to 0][{ap_ssid}][att: {att}][rssi: {rssi}]: 0 '
+                    f'throughput interval: {result[0]}-{result[1]}'
                 )
                 fall_to_0_recorded += 1
 
         if len(throughput_list) < self.THROUGHPUT_QUALIFY_COUNT:
             self.error_list.append(
-                '[Error][Fatal][{}][att: {}][rssi: {}]: Only {} throughput values found, expected at least {}'.format(
-                    ap_ssid, att, rssi, len(throughput_list), self.THROUGHPUT_QUALIFY_COUNT
-                )
+                f'[Error][Fatal][{ap_ssid}][att: {att}][rssi: {rssi}]: '
+                f'Only {len(throughput_list)} throughput values found, '
+                f'expected at least {self.THROUGHPUT_QUALIFY_COUNT}'
             )
             max_throughput = 0.0
 
         if max_throughput == 0 and rssi > self.ZERO_THROUGHPUT_THRESHOLD:
-            self.error_list.append(
-                '[Error][Fatal][{}][att: {}][rssi: {}]: No throughput data found'.format(ap_ssid, att, rssi)
-            )
+            self.error_list.append(f'[Error][Fatal][{ap_ssid}][att: {att}][rssi: {rssi}]: No throughput data found')
 
         self._save_result(max_throughput, ap_ssid, att, rssi, heap_size)
 
@@ -167,9 +163,8 @@ class TestResult(object):
                     _percentage = result_dict[index_value] / result_dict[index_list[i]]
                     if _percentage < 1 - self.BAD_POINT_PERCENTAGE_THRESHOLD:
                         self.error_list.append(
-                            '[Error][Bad point][{}][{}: {}]: drop {:.02f}%'.format(
-                                ap_ssid, index_type, index_value, (1 - _percentage) * 100
-                            )
+                            f'[Error][Bad point][{ap_ssid}][{index_type}: {index_value}]: '
+                            f'drop {(1 - _percentage) * 100:.02f}%'
                         )
 
         analysis_bad_point(self.throughput_by_rssi, 'rssi')
@@ -193,14 +188,14 @@ class TestResult(object):
         else:
             raise AssertionError('draw type not supported')
         if isinstance(ap_ssid, list):
-            file_name = 'ThroughputVs{}_{}_{}.html'.format(type_name, self.proto, self.direction)
+            file_name = f'ThroughputVs{type_name}_{self.proto}_{self.direction}.html'
         else:
-            file_name = 'ThroughputVs{}_{}_{}.html'.format(type_name, self.proto, self.direction)
+            file_name = f'ThroughputVs{type_name}_{self.proto}_{self.direction}.html'
 
         LineChart.draw_line_chart(
             os.path.join(path, file_name),
-            'Throughput Vs {} ({} {})'.format(type_name, self.proto, self.direction),
-            '{} (dbm)'.format(type_name),
+            f'Throughput Vs {type_name} ({self.proto} {self.direction})',
+            f'{type_name} (dbm)',
             'Throughput (Mbps)',
             data,
             range_list,
@@ -241,15 +236,15 @@ class TestResult(object):
             )
             ret += 'Performance for each AP:\r\n'
             for ap_ssid in self.throughput_by_att:
-                ret += '[{}]: {:.02f} Mbps\r\n'.format(ap_ssid, max(self.throughput_by_att[ap_ssid].values()))
+                ret += f'[{ap_ssid}]: {max(self.throughput_by_att[ap_ssid].values()):.02f} Mbps\r\n'
             if self.heap_size != INVALID_HEAP_SIZE:
-                ret += 'Minimum heap size: {}'.format(self.heap_size)
+                ret += f'Minimum heap size: {self.heap_size}'
         else:
             ret = ''
         return ret
 
 
-class IperfTestUtility(object):
+class IperfTestUtility:
     """iperf test implementation"""
 
     def __init__(
@@ -282,7 +277,7 @@ class IperfTestUtility(object):
                 'udp_rx': TestResult('udp', 'rx', config_name),
             }
 
-    def setup(self) -> Tuple[str, int]:
+    def setup(self) -> tuple[str, int]:
         """
         setup iperf test:
 
@@ -299,23 +294,23 @@ class IperfTestUtility(object):
         self.dut.write('restart')
         self.dut.expect_exact("Type 'help' to get the list of commands.")
         self.dut.expect('iperf>')
-        self.dut.write('sta_scan {}'.format(self.ap_ssid))
+        self.dut.write(f'sta_scan {self.ap_ssid}')
         for _ in range(SCAN_RETRY_COUNT):
             try:
-                rssi = int(self.dut.expect(r'\[{}]\[rssi=(-\d+)]'.format(self.ap_ssid), timeout=SCAN_TIMEOUT).group(1))
+                rssi = int(self.dut.expect(rf'\[{self.ap_ssid}]\[rssi=(-\d+)]', timeout=SCAN_TIMEOUT).group(1))
                 break
             except pexpect.TIMEOUT:
                 continue
         else:
             raise AssertionError('Failed to scan AP')
-        self.dut.write('sta_connect {} {}'.format(self.ap_ssid, self.ap_password))
+        self.dut.write(f'sta_connect {self.ap_ssid} {self.ap_password}')
         dut_ip = self.dut.expect(r'sta ip: ([\d.]+), mask: ([\d.]+), gw: ([\d.]+)').group(1)
         return dut_ip, rssi
 
     def _save_test_result(self, test_case: str, raw_data: str, att: int, rssi: int, heap_size: int) -> Any:
         return self.test_result[test_case].add_result(raw_data, self.ap_ssid, att, rssi, heap_size)
 
-    def _test_once(self, proto: str, direction: str, bw_limit: int) -> Tuple[str, int, int]:
+    def _test_once(self, proto: str, direction: str, bw_limit: int) -> tuple[str, int, int]:
         """do measure once for one type"""
         # connect and scan to get RSSI
         dut_ip, rssi = self.setup()
@@ -333,9 +328,9 @@ class IperfTestUtility(object):
                         stderr=f,
                     )
                     if bw_limit > 0:
-                        self.dut.write('iperf -c {} -i 1 -t {} -b {}'.format(self.pc_nic_ip, TEST_TIME, bw_limit))
+                        self.dut.write(f'iperf -c {self.pc_nic_ip} -i 1 -t {TEST_TIME} -b {bw_limit}m')
                     else:
-                        self.dut.write('iperf -c {} -i 1 -t {}'.format(self.pc_nic_ip, TEST_TIME))
+                        self.dut.write(f'iperf -c {self.pc_nic_ip} -i 1 -t {TEST_TIME}')
                 else:
                     process = subprocess.Popen(
                         ['iperf', '-s', '-u', '-B', self.pc_nic_ip, '-t', str(TEST_TIME), '-i', '1', '-f', 'm'],
@@ -343,9 +338,9 @@ class IperfTestUtility(object):
                         stderr=f,
                     )
                     if bw_limit > 0:
-                        self.dut.write('iperf -c {} -u -i 1 -t {} -b {}'.format(self.pc_nic_ip, TEST_TIME, bw_limit))
+                        self.dut.write(f'iperf -c {self.pc_nic_ip} -u -i 1 -t {TEST_TIME} -b {bw_limit}m')
                     else:
-                        self.dut.write('iperf -c {} -u -i 1 -t {}'.format(self.pc_nic_ip, TEST_TIME))
+                        self.dut.write(f'iperf -c {self.pc_nic_ip} -u -i 1 -t {TEST_TIME}')
 
                 for _ in range(TEST_TIMEOUT):
                     if process.poll() is not None:
@@ -354,12 +349,12 @@ class IperfTestUtility(object):
                 else:
                     process.terminate()
 
-            with open(PC_IPERF_TEMP_LOG_FILE, 'r') as f:
+            with open(PC_IPERF_TEMP_LOG_FILE) as f:
                 pc_raw_data = server_raw_data = f.read()
         else:
             with open(PC_IPERF_TEMP_LOG_FILE, 'w') as f:
                 if proto == 'tcp':
-                    self.dut.write('iperf -s -i 1 -t {}'.format(TEST_TIME))
+                    self.dut.write(f'iperf -s -i 1 -t {TEST_TIME}')
                     # wait until DUT TCP server created
                     try:
                         self.dut.expect('Socket created', timeout=5)
@@ -384,7 +379,7 @@ class IperfTestUtility(object):
                         process.terminate()
                 else:
                     if bw_limit > 0:
-                        self.dut.write('iperf -s -u -i 1 -t {}'.format(TEST_TIME))
+                        self.dut.write(f'iperf -s -u -i 1 -t {TEST_TIME}')
                         # wait until DUT TCP server created
                         try:
                             self.dut.expect('Socket created', timeout=5)
@@ -408,7 +403,7 @@ class IperfTestUtility(object):
                         n = 10
                         step = int((stop_bw - start_bw) / n)
                         self.dut.write(
-                            'iperf -s -u -i 1 -t {}'.format(TEST_TIME + 4 * (n + 1))
+                            f'iperf -s -u -i 1 -t {TEST_TIME + 4 * (n + 1)}'
                         )  # 4 sec for each bw step instance start/stop
                         # wait until DUT TCP server created
                         try:
@@ -441,7 +436,7 @@ class IperfTestUtility(object):
                                 process.terminate()
 
             server_raw_data = self.dut.expect(pexpect.TIMEOUT, timeout=5).decode('utf-8')
-            with open(PC_IPERF_TEMP_LOG_FILE, 'r') as f:
+            with open(PC_IPERF_TEMP_LOG_FILE) as f:
                 pc_raw_data = f.read()
 
         if os.path.exists(PC_IPERF_TEMP_LOG_FILE):
@@ -452,7 +447,7 @@ class IperfTestUtility(object):
             f.write(
                 '## [{}] `{}`\r\n##### {}'.format(
                     self.config_name,
-                    '{}_{}'.format(proto, direction),
+                    f'{proto}_{direction}',
                     time.strftime('%m-%d %H:%M:%S', time.localtime(time.time())),
                 )
             )
@@ -476,17 +471,11 @@ class IperfTestUtility(object):
         heap_size = INVALID_HEAP_SIZE
         try:
             server_raw_data, rssi, heap_size = self._test_once(proto, direction, bw_limit)
-            throughput = self._save_test_result(
-                '{}_{}'.format(proto, direction), server_raw_data, atten_val, rssi, heap_size
-            )
-            logging.info(
-                '[{}][{}_{}][{}][{}]: {:.02f}'.format(
-                    self.config_name, proto, direction, rssi, self.ap_ssid, throughput
-                )
-            )
+            throughput = self._save_test_result(f'{proto}_{direction}', server_raw_data, atten_val, rssi, heap_size)
+            logging.info(f'[{self.config_name}][{proto}_{direction}][{rssi}][{self.ap_ssid}]: {throughput:.02f}')
             self.lowest_rssi_scanned = min(self.lowest_rssi_scanned, rssi)
         except (ValueError, IndexError):
-            self._save_test_result('{}_{}'.format(proto, direction), '', atten_val, rssi, heap_size)
+            self._save_test_result(f'{proto}_{direction}', '', atten_val, rssi, heap_size)
             logging.info('Fail to get throughput results.')
         except AssertionError:
             self.fail_to_scan += 1
@@ -504,9 +493,7 @@ class IperfTestUtility(object):
         self.run_test('udp', 'tx', atten_val, bw_limit)
         self.run_test('udp', 'rx', atten_val, bw_limit)
         if self.fail_to_scan > 10:
-            logging.info(
-                'Fail to scan AP for more than 10 times. Lowest RSSI scanned is {}'.format(self.lowest_rssi_scanned)
-            )
+            logging.info(f'Fail to scan AP for more than 10 times. Lowest RSSI scanned is {self.lowest_rssi_scanned}')
             raise AssertionError
 
     def wait_ap_power_on(self) -> bool:
@@ -520,8 +507,8 @@ class IperfTestUtility(object):
         self.dut.expect('iperf>')
         for _ in range(WAIT_AP_POWER_ON_TIMEOUT // SCAN_TIMEOUT):
             try:
-                self.dut.write('scan {}'.format(self.ap_ssid))
-                self.dut.expect(r'\[{}]\[rssi=(-\d+)]'.format(self.ap_ssid), timeout=SCAN_TIMEOUT)
+                self.dut.write(f'scan {self.ap_ssid}')
+                self.dut.expect(rf'\[{self.ap_ssid}]\[rssi=(-\d+)]', timeout=SCAN_TIMEOUT)
                 ret = True
                 break
             except pexpect.TIMEOUT: