Merge branch 'ci/apply-common-scripts-v5.4' into 'release/v5.4'

ci: apply common-scripts refactor (v5.4)

See merge request espressif/esp-idf!51101

components/bootloader_support/test_apps/bootloader_support/pytest_bootloader_support.py

@@ -11,14 +11,12 @@ def test_bootloader_support(dut: Dut) -> None:
     dut.run_all_single_board_cases()
 
 
-@pytest.mark.host_test
 @pytest.mark.qemu
 @idf_parametrize('target', ['esp32'], indirect=['target'])
 def test_bootloader_support_qemu_esp32(dut: Dut) -> None:
     dut.run_all_single_board_cases()
 
 
-@pytest.mark.host_test
 @pytest.mark.qemu
 @idf_parametrize('target', ['esp32c3'], indirect=['target'])
 def test_bootloader_support_qemu_esp32c3(dut: Dut) -> None:

components/console/test_apps/console/pytest_console.py

@@ -14,7 +14,10 @@ def do_test_quit(dut: Dut) -> None:
 
 def do_test_help_generic(dut: Dut, registration_order: str) -> None:
     dut.expect_exact('Press ENTER to see the list of tests')
-    dut.confirm_write('"esp console help command - {} registration"'.format(registration_order), expect_str='esp>')
+    dut.confirm_write(
+        f'"esp console help command - {registration_order} registration"',
+        expect_str='esp>',
+    )
 
     dut.confirm_write('help', expect_str='aaa')
 
@@ -45,63 +48,59 @@ def do_test_help_quit(dut: Dut) -> None:
     dut.expect(r'quit\s+Quit REPL environment\s+esp>')
 
 
-@idf_parametrize('config', ['defaults'], indirect=['config'])
 @idf_parametrize(
-    'target,test_on,markers',
+    'target,config,embedded_services,markers',
     [
-        ('linux', 'host', (pytest.mark.host_test,)),
-        ('esp32', 'target', (pytest.mark.generic,)),
-        ('esp32c3', 'target', (pytest.mark.generic,)),
-        ('esp32', 'qemu', (pytest.mark.host_test, pytest.mark.qemu)),
+        ('linux', 'defaults', 'idf', ()),
+        ('esp32', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32c3', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32', 'defaults', 'idf,qemu', (pytest.mark.qemu,)),
     ],
-    indirect=['target'],
+    indirect=['target', 'config', 'embedded_services'],
 )
-def test_console(dut: Dut, test_on: str) -> None:
+def test_console(dut: Dut) -> None:
     dut.run_all_single_board_cases(group='!ignore', timeout=120)
 
 
-@idf_parametrize('config', ['defaults'], indirect=['config'])
 @idf_parametrize(
-    'target,test_on,markers',
+    'target,config,embedded_services,markers',
     [
-        ('linux', 'host', (pytest.mark.host_test,)),
-        ('esp32', 'target', (pytest.mark.generic,)),
-        ('esp32c3', 'target', (pytest.mark.generic,)),
-        ('esp32', 'qemu', (pytest.mark.host_test, pytest.mark.qemu)),
+        ('linux', 'defaults', 'idf', ()),
+        ('esp32', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32c3', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32', 'defaults', 'idf,qemu', (pytest.mark.qemu,)),
     ],
-    indirect=['target'],
+    indirect=['target', 'config', 'embedded_services'],
 )
-def test_console_repl(dut: Dut, test_on: str) -> None:
+def test_console_repl(dut: Dut) -> None:
     do_test_quit(dut)
 
 
-@idf_parametrize('config', ['defaults'], indirect=['config'])
 @idf_parametrize(
-    'target,test_on,markers',
+    'target,config,embedded_services,markers',
     [
-        ('linux', 'host', (pytest.mark.host_test,)),
-        ('esp32', 'target', (pytest.mark.generic,)),
-        ('esp32c3', 'target', (pytest.mark.generic,)),
-        ('esp32', 'qemu', (pytest.mark.host_test, pytest.mark.qemu)),
+        ('linux', 'defaults', 'idf', ()),
+        ('esp32', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32c3', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32', 'defaults', 'idf,qemu', (pytest.mark.qemu,)),
     ],
-    indirect=['target'],
+    indirect=['target', 'config', 'embedded_services'],
 )
-def test_console_help_sorted_registration(dut: Dut, test_on: str) -> None:
+def test_console_help_sorted_registration(dut: Dut) -> None:
     do_test_help_generic(dut, 'sorted')
 
 
-@idf_parametrize('config', ['defaults'], indirect=['config'])
 @idf_parametrize(
-    'target,test_on,markers',
+    'target,config,embedded_services,markers',
     [
-        ('linux', 'host', (pytest.mark.host_test,)),
-        ('esp32', 'target', (pytest.mark.generic,)),
-        ('esp32c3', 'target', (pytest.mark.generic,)),
-        ('esp32', 'qemu', (pytest.mark.host_test, pytest.mark.qemu)),
+        ('linux', 'defaults', 'idf', ()),
+        ('esp32', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32c3', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32', 'defaults', 'idf,qemu', (pytest.mark.qemu,)),
     ],
-    indirect=['target'],
+    indirect=['target', 'config', 'embedded_services'],
 )
-def test_console_help_reverse_registration(dut: Dut, test_on: str) -> None:
+def test_console_help_reverse_registration(dut: Dut) -> None:
     dut.expect_exact('Press ENTER to see the list of tests')
     dut.confirm_write('"esp console help command - reverse registration"', expect_str='esp>')
 
@@ -126,45 +125,41 @@ def test_console_help_reverse_registration(dut: Dut, test_on: str) -> None:
 
 @idf_parametrize('config', ['sorted'], indirect=['config'])
 @idf_parametrize('target', ['linux'], indirect=['target'])
-@idf_parametrize('test_on,markers', [('host', (pytest.mark.host_test,))])
-def test_console_sorted_help_sorted_registration(dut: Dut, test_on: str) -> None:
+def test_console_sorted_help_sorted_registration(dut: Dut) -> None:
     do_test_help_generic(dut, 'sorted')
 
 
 @idf_parametrize('config', ['sorted'], indirect=['config'])
 @idf_parametrize('target', ['linux'], indirect=['target'])
-@idf_parametrize('test_on,markers', [('host', (pytest.mark.host_test,))])
-def test_console_sorted_help_reverse_registration(dut: Dut, test_on: str) -> None:
+def test_console_sorted_help_reverse_registration(dut: Dut) -> None:
     do_test_help_generic(dut, 'reverse')
 
 
-@idf_parametrize('config', ['defaults'], indirect=['config'])
 @idf_parametrize(
-    'target,test_on,markers',
+    'target,config,embedded_services,markers',
     [
-        ('linux', 'host', (pytest.mark.host_test,)),
-        ('esp32', 'target', (pytest.mark.generic,)),
-        ('esp32c3', 'target', (pytest.mark.generic,)),
-        ('esp32', 'qemu', (pytest.mark.host_test, pytest.mark.qemu)),
+        ('linux', 'defaults', 'idf', ()),
+        ('esp32', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32c3', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32', 'defaults', 'idf,qemu', (pytest.mark.qemu,)),
     ],
-    indirect=['target'],
+    indirect=['target', 'config', 'embedded_services'],
 )
-def test_console_help_quit(dut: Dut, test_on: str) -> None:
+def test_console_help_quit(dut: Dut) -> None:
     do_test_help_quit(dut)
 
 
-@idf_parametrize('config', ['defaults'], indirect=['config'])
 @idf_parametrize(
-    'target,test_on,markers',
+    'target,config,embedded_services,markers',
     [
-        ('linux', 'host', (pytest.mark.host_test,)),
-        ('esp32', 'target', (pytest.mark.generic,)),
-        ('esp32c3', 'target', (pytest.mark.generic,)),
-        ('esp32', 'qemu', (pytest.mark.host_test, pytest.mark.qemu)),
+        ('linux', 'defaults', 'idf', ()),
+        ('esp32', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32c3', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32', 'defaults', 'idf,qemu', (pytest.mark.qemu,)),
     ],
-    indirect=['target'],
+    indirect=['target', 'config', 'embedded_services'],
 )
-def test_console_help_verbose_level_0(dut: Dut, test_on: str) -> None:
+def test_console_help_verbose_level_0(dut: Dut) -> None:
     help_verbose_info = 'Print the summary of all registered commands if no arguments are given,'
     dut.expect_exact('Press ENTER to see the list of tests')
     dut.confirm_write('"esp console help command - set verbose level = 0"', expect_str='esp>')
@@ -175,18 +170,17 @@ def test_console_help_verbose_level_0(dut: Dut, test_on: str) -> None:
     dut.expect_exact('help', not_matching=help_verbose_info)
 
 
-@idf_parametrize('config', ['defaults'], indirect=['config'])
 @idf_parametrize(
-    'target,test_on,markers',
+    'target,config,embedded_services,markers',
     [
-        ('linux', 'host', (pytest.mark.host_test,)),
-        ('esp32', 'target', (pytest.mark.generic,)),
-        ('esp32c3', 'target', (pytest.mark.generic,)),
-        ('esp32', 'qemu', (pytest.mark.host_test, pytest.mark.qemu)),
+        ('linux', 'defaults', 'idf', ()),
+        ('esp32', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32c3', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32', 'defaults', 'idf,qemu', (pytest.mark.qemu,)),
     ],
-    indirect=['target'],
+    indirect=['target', 'config', 'embedded_services'],
 )
-def test_console_help_verbose_level_1(dut: Dut, test_on: str) -> None:
+def test_console_help_verbose_level_1(dut: Dut) -> None:
     help_verbose_info = 'Print the summary of all registered commands if no arguments are given,'
     dut.expect_exact('Press ENTER to see the list of tests')
     dut.confirm_write('"esp console help command - set verbose level = 1"', expect_str='esp>')
@@ -196,18 +190,17 @@ def test_console_help_verbose_level_1(dut: Dut, test_on: str) -> None:
     dut.expect_exact(help_verbose_info)
 
 
-@idf_parametrize('config', ['defaults'], indirect=['config'])
 @idf_parametrize(
-    'target,test_on,markers',
+    'target,config,embedded_services,markers',
     [
-        ('linux', 'host', (pytest.mark.host_test,)),
-        ('esp32', 'target', (pytest.mark.generic,)),
-        ('esp32c3', 'target', (pytest.mark.generic,)),
-        ('esp32', 'qemu', (pytest.mark.host_test, pytest.mark.qemu)),
+        ('linux', 'defaults', 'idf', ()),
+        ('esp32', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32c3', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32', 'defaults', 'idf,qemu', (pytest.mark.qemu,)),
     ],
-    indirect=['target'],
+    indirect=['target', 'config', 'embedded_services'],
 )
-def test_console_help_verbose_subcommand(dut: Dut, test_on: str) -> None:
+def test_console_help_verbose_subcommand(dut: Dut) -> None:
     help_verbose_info = 'Print the summary of all registered commands if no arguments are given,'
     dut.expect_exact('Press ENTER to see the list of tests')
     dut.confirm_write('"esp console help command - --verbose sub command"', expect_str='esp>')
@@ -222,18 +215,17 @@ def test_console_help_verbose_subcommand(dut: Dut, test_on: str) -> None:
     dut.expect_exact(help_verbose_info)
 
 
-@idf_parametrize('config', ['defaults'], indirect=['config'])
 @idf_parametrize(
-    'target,test_on,markers',
+    'target,config,embedded_services,markers',
     [
-        ('linux', 'host', (pytest.mark.host_test,)),
-        ('esp32', 'target', (pytest.mark.generic,)),
-        ('esp32c3', 'target', (pytest.mark.generic,)),
-        ('esp32', 'qemu', (pytest.mark.host_test, pytest.mark.qemu)),
+        ('linux', 'defaults', 'idf', ()),
+        ('esp32', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32c3', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32', 'defaults', 'idf,qemu', (pytest.mark.qemu,)),
     ],
-    indirect=['target'],
+    indirect=['target', 'config', 'embedded_services'],
 )
-def test_console_help_deregister(dut: Dut, test_on: str) -> None:
+def test_console_help_deregister(dut: Dut) -> None:
     dut.expect_exact('Press ENTER to see the list of tests')
     dut.confirm_write('"esp console deregister commands"', expect_str='esp>')
 
@@ -241,22 +233,24 @@ def test_console_help_deregister(dut: Dut, test_on: str) -> None:
 
     # in the test sequence, command a is registered before registering command z, then
     # command a is deregistered; therefore, console shall not print command a's description
-    cmd_a_description, cmd_z_description = 'should appear first in help', 'should appear last in help'
+    cmd_a_description, cmd_z_description = (
+        'should appear first in help',
+        'should appear last in help',
+    )
     dut.expect_exact(cmd_z_description, not_matching=cmd_a_description)
 
 
-@idf_parametrize('config', ['defaults'], indirect=['config'])
 @idf_parametrize(
-    'target,test_on,markers',
+    'target,config,embedded_services,markers',
     [
-        ('linux', 'host', (pytest.mark.host_test,)),
-        ('esp32', 'target', (pytest.mark.generic,)),
-        ('esp32c3', 'target', (pytest.mark.generic,)),
-        ('esp32', 'qemu', (pytest.mark.host_test, pytest.mark.qemu)),
+        ('linux', 'defaults', 'idf', ()),
+        ('esp32', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32c3', 'defaults', 'esp,idf', (pytest.mark.generic,)),
+        ('esp32', 'defaults', 'idf,qemu', (pytest.mark.qemu,)),
     ],
-    indirect=['target'],
+    indirect=['target', 'config', 'embedded_services'],
 )
-def test_console_help_re_register(dut: Dut, test_on: str) -> None:
+def test_console_help_re_register(dut: Dut) -> None:
     dut.expect_exact('Press ENTER to see the list of tests')
     dut.confirm_write('"esp console re-register commands"', expect_str='esp>')
 

components/efuse/test_apps/pytest_efuse.py

@@ -6,7 +6,8 @@ from pytest_embedded_idf.utils import idf_parametrize
 
 
 @pytest.mark.temp_skip_ci(
-    targets=['esp32s2', 'esp32s3'], reason='eFuse for S2 and S3 is similar to the C3 chip, so testing on C3 is enough'
+    targets=['esp32s2', 'esp32s3'],
+    reason='eFuse for S2 and S3 is similar to the C3 chip, so testing on C3 is enough',
 )
 @pytest.mark.generic
 @idf_parametrize('target', ['supported_targets'], indirect=['target'])
@@ -15,13 +16,11 @@ def test_efuse(dut: Dut) -> None:
 
 
 @pytest.mark.qemu
-@pytest.mark.host_test
 @idf_parametrize('target', ['esp32'], indirect=['target'])
 def test_efuse_qemu(dut: Dut) -> None:
     dut.run_all_single_board_cases()
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_efuse_linux(dut: Dut) -> None:
     dut.run_all_single_board_cases(timeout=60)

components/esp_app_format/test_apps/pytest_esp_app_format.py

@@ -11,7 +11,6 @@ def test_esp_app_format(dut: Dut) -> None:
     dut.expect_unity_test_output()
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_esp_app_format_linux(dut: Dut) -> None:
     dut.expect_unity_test_output()

components/esp_coex/test_apps/external_coex_function/pytest_external_coex_function.py

@@ -6,9 +6,7 @@ from pytest_embedded_idf.utils import idf_parametrize
 
 
 @pytest.mark.generic
-@idf_parametrize(
-    'target', ['esp32h2', 'esp32c3', 'esp32s2', 'esp32s3', 'esp32c6'], indirect=['target']
-)
+@idf_parametrize('target', ['esp32h2', 'esp32c3', 'esp32s2', 'esp32s3', 'esp32c6'], indirect=['target'])
 def test_external_coex_unit_test(dut: Dut) -> None:
     dut.run_all_single_board_cases()
 
@@ -27,30 +25,30 @@ def test_external_coex_unit_test_esp32c2_xtal26m(dut: Dut) -> None:
     dut.run_all_single_board_cases()
 
 
-@pytest.mark.esp32c2eco4
+@pytest.mark.esp32c2_rev2
 @pytest.mark.xtal_26mhz
 @pytest.mark.generic
 @pytest.mark.parametrize(
     'config, baud',
     [
-        ('esp32c2eco4_xtal26m', '74880'),
+        ('esp32c2_rev2_xtal26m', '74880'),
     ],
     indirect=True,
 )
 @idf_parametrize('target', ['esp32c2'], indirect=['target'])
-def test_external_coex_unit_test_esp32c2eco4_xtal26m(dut: Dut) -> None:
+def test_external_coex_unit_test_esp32c2_rev2_xtal26m(dut: Dut) -> None:
     dut.run_all_single_board_cases()
 
 
-@pytest.mark.esp32c3eco7
+@pytest.mark.esp32c3_rev1
 @pytest.mark.generic
 @pytest.mark.parametrize(
     'config',
     [
-        'esp32c3eco7',
+        'esp32c3_rev1',
     ],
     indirect=True,
 )
 @idf_parametrize('target', ['esp32c3'], indirect=['target'])
-def test_external_coex_unit_test_esp32c3eco7(dut: Dut) -> None:
+def test_external_coex_unit_test_esp32c3_rev1(dut: Dut) -> None:
     dut.run_all_single_board_cases()

components/esp_driver_usb_serial_jtag/test_apps/usb_serial_jtag_vfs/pytest_usb_serial_jtag_vfs.py

@@ -13,9 +13,10 @@ from pytest_embedded_idf.utils import idf_parametrize
     ],
     indirect=True,
 )
-@pytest.mark.parametrize('test_message', ['test123456789!@#%^&*'])
 @idf_parametrize('target', ['esp32s3', 'esp32c3', 'esp32c6', 'esp32h2'], indirect=['target'])
-def test_usj_vfs_select(dut: Dut, test_message: list) -> None:
+def test_usj_vfs_select(dut: Dut) -> None:
+    test_message = 'test123456789!@#%^&*'
+
     dut.expect_exact('Press ENTER to see the list of tests')
     dut.write('"test select read, write and timeout"')
     dut.expect_exact('select timed out', timeout=2)
@@ -32,9 +33,10 @@ def test_usj_vfs_select(dut: Dut, test_message: list) -> None:
     ],
     indirect=True,
 )
-@pytest.mark.parametrize('test_message', ['!(@*#&(!*@&#((SDasdkjhad\nce'])
 @idf_parametrize('target', ['esp32s3', 'esp32c3', 'esp32c6', 'esp32h2'], indirect=['target'])
-def test_usj_vfs_read_return(dut: Dut, test_message: list) -> None:
+def test_usj_vfs_read_return(dut: Dut) -> None:
+    test_message = '!(@*#&(!*@&#((SDasdkjhad\nce'
+
     dut.expect_exact('Press ENTER to see the list of tests')
     dut.write('"read does not return on new line character"')
     dut.expect_exact('ready to receive', timeout=2)
@@ -50,9 +52,10 @@ def test_usj_vfs_read_return(dut: Dut, test_message: list) -> None:
     ],
     indirect=True,
 )
-@pytest.mark.parametrize('test_message', ['testdata'])
 @idf_parametrize('target', ['esp32s3', 'esp32c3', 'esp32c6', 'esp32h2'], indirect=['target'])
-def test_usj_vfs_read_blocking(dut: Dut, test_message: list) -> None:
+def test_usj_vfs_read_blocking(dut: Dut) -> None:
+    test_message = 'testdata'
+
     dut.expect_exact('Press ENTER to see the list of tests')
     dut.write('"blocking read returns with available data"')
     dut.expect_exact('ready to receive', timeout=2)

components/esp_event/host_test/esp_event_unit_test/pytest_esp_event_linux.py

@@ -1,11 +1,9 @@
 # SPDX-FileCopyrightText: 2023-2026 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Unlicense OR CC0-1.0
-import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_esp_event_linux(dut: Dut) -> None:
     dut.expect_exact('All tests passed', timeout=5)

components/esp_event/test_apps/pytest_esp_event.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: CC0-1.0
 import pytest
 from pytest_embedded import Dut
@@ -19,24 +19,21 @@ def test_esp_event(dut: Dut) -> None:
     dut.run_all_single_board_cases()
 
 
-@pytest.mark.host_test
 @pytest.mark.qemu
-@pytest.mark.xfail('config.getvalue("target") == "esp32c3"', reason='Unstable on QEMU, needs investigation')
-@pytest.mark.parametrize(
-    'config',
+@idf_parametrize(
+    'config,target,markers',
     [
-        'defaults',
+        ('defaults', 'esp32'),
+        ('defaults', 'esp32c3', (pytest.mark.xfail(reason='Unstable on QEMU, needs investigation'),)),
     ],
-    indirect=True,
+    indirect=['config', 'target'],
 )
-@idf_parametrize('target', ['esp32', 'esp32c3'], indirect=['target'])
 def test_esp_event_qemu(dut: Dut) -> None:
     for case in dut.test_menu:
         if 'qemu-ignore' not in case.groups and not case.is_ignored and case.type == 'normal':
             dut._run_normal_case(case)
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 @pytest.mark.parametrize(
     'config',

components/esp_hw_support/test_apps/host_test_linux/pytest_esp_hw_support_linux.py

@@ -1,11 +1,9 @@
 # SPDX-FileCopyrightText: 2023-2026 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Unlicense OR CC0-1.0
-import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_esp_hw_support_linux(dut: Dut) -> None:
     dut.run_all_single_board_cases(group='!ignore', timeout=120)

components/esp_hw_support/test_apps/sleep_retention/pytest_retention.py

@@ -1,34 +1,10 @@
 # SPDX-FileCopyrightText: 2022-2026 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: CC0-1.0
-import functools
-from typing import Callable
-from typing import Dict
-from typing import List
-
 import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
 
-def target_list(targets: List[str]) -> Callable:
-    def decorator(func: Callable) -> Callable:
-        @functools.wraps(func)
-        def wrapper(*args: List, **kwargs: Dict) -> Callable:
-            return func(*args, **kwargs)  # type: ignore
-
-        for target in targets:
-            wrapper = pytest.mark.__getattr__(target)(wrapper)
-
-        return wrapper
-
-    return decorator
-
-
-# SOC_PAU_SUPPORTED == 1
-retention_targets = ['esp32c6', 'esp32h2', 'esp32p4', 'esp32c5', 'esp32c61']
-
-
-@target_list(retention_targets)
 @pytest.mark.generic
 @idf_parametrize('target', ['esp32c61', 'esp32c5', 'esp32p4', 'esp32h2', 'esp32c6'], indirect=['target'])
 def test_sleep_retention(dut: Dut) -> None:

components/esp_mm/test_apps/mm/pytest_mmap.py

@@ -3,6 +3,7 @@
 import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
+
 # normal mmu tests
 
 
@@ -20,14 +21,6 @@ def test_mmap(dut: Dut) -> None:
 
 
 # mmu tests with psram enabled
-PSRAM_RELEASE_CONFIGS = [
-    pytest.param('psram_release_esp32', marks=[pytest.mark.esp32]),
-    pytest.param('psram_release_esp32s2', marks=[pytest.mark.esp32s2]),
-    pytest.param('psram_release_esp32s3', marks=[pytest.mark.esp32s3]),
-    pytest.param('psram_release_esp32p4', marks=[pytest.mark.esp32p4]),
-]
-
-
 @pytest.mark.generic
 @idf_parametrize(
     'config,target',
@@ -44,12 +37,6 @@ def test_mmap_psram(dut: Dut) -> None:
 
 
 # mmu tests with xip_psram
-XIP_CONFIGS = [
-    pytest.param('xip_psram_esp32s2', marks=[pytest.mark.esp32s2]),
-    pytest.param('xip_psram_esp32s3', marks=[pytest.mark.esp32s3]),
-]
-
-
 @pytest.mark.generic
 @idf_parametrize(
     'config,target', [('xip_psram_esp32s2', 'esp32s2'), ('xip_psram_esp32s3', 'esp32s3')], indirect=['config', 'target']

components/esp_partition/host_test/partition_api_test/pytest_esp_partition_linux.py

@@ -1,11 +1,9 @@
 # SPDX-FileCopyrightText: 2023-2026 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Unlicense OR CC0-1.0
-import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_esp_partition_linux(dut: Dut) -> None:
     dut.expect_unity_test_output(timeout=5)

components/esp_ringbuf/test_apps/pytest_esp_ringbuf.py

@@ -24,7 +24,6 @@ def test_esp_ringbuf(dut: Dut) -> None:
     dut.run_all_single_board_cases()
 
 
-@pytest.mark.host_test
 @pytest.mark.qemu
 @pytest.mark.parametrize(
     'target',
@@ -46,7 +45,6 @@ def test_esp_ringbuf_qemu(dut: Dut) -> None:
             dut._run_normal_case(case)
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_esp_ringbuf_posix_simulator(dut: Dut) -> None:
     dut.run_all_single_board_cases(group='linux')

components/esp_rom/test_apps/linux_rom_apis/pytest_esp_rom_linux.py

@@ -1,11 +1,9 @@
 # SPDX-FileCopyrightText: 2023-2026 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Unlicense OR CC0-1.0
-import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_esp_rom_linux(dut: Dut) -> None:
     dut.expect_exact('All tests passed', timeout=5)

components/esp_rom/test_apps/rom_tests/pytest_esp_rom.py

@@ -8,14 +8,22 @@ from pytest_embedded_idf.utils import idf_parametrize
 @pytest.mark.generic
 @idf_parametrize(
     'target',
-    ['esp32c3', 'esp32s2', 'esp32s3', 'esp32c5', 'esp32c6', 'esp32c61', 'esp32h2', 'esp32p4'],
+    [
+        'esp32c3',
+        'esp32s2',
+        'esp32s3',
+        'esp32c5',
+        'esp32c6',
+        'esp32c61',
+        'esp32h2',
+        'esp32p4',
+    ],
     indirect=['target'],
 )
 def test_esp_rom(dut: Dut) -> None:
     dut.run_all_single_board_cases()
 
 
-@pytest.mark.host_test
 @pytest.mark.qemu
 @idf_parametrize('target', ['esp32c3'], indirect=['target'])
 def test_esp_rom_qemu(dut: Dut) -> None:

components/esp_system/test_apps/console/pytest_esp_system_console_tests.py

@@ -15,15 +15,6 @@ def not_expect(dut: Dut, output_regex: str) -> None:
         raise RuntimeError(f'Found not_expect output {output_regex}')
 
 
-JTAG_SERIAL_MARKS = [
-    pytest.mark.esp32s3,
-    pytest.mark.esp32c2,
-    pytest.mark.esp32c3,
-    pytest.mark.esp32c6,
-    pytest.mark.esp32h2,
-]
-
-
 @pytest.mark.generic
 @idf_parametrize('config', ['console_none'], indirect=['config'])
 @idf_parametrize('target', ['supported_targets'], indirect=['target'])

components/esp_system/test_apps/linux_apis/pytest_esp_system_linux.py

@@ -1,11 +1,9 @@
 # SPDX-FileCopyrightText: 2023-2026 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Unlicense OR CC0-1.0
-import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_esp_system_linux(dut: Dut) -> None:
     dut.run_all_single_board_cases(timeout=60)

components/esp_timer/test_apps/pytest_esp_timer_ut.py

@@ -4,19 +4,6 @@ import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
-CONFIGS = [
-    pytest.param('general', marks=[pytest.mark.supported_targets]),
-    pytest.param('release', marks=[pytest.mark.supported_targets]),
-    pytest.param('single_core', marks=[pytest.mark.esp32]),
-    pytest.param('freertos_compliance', marks=[pytest.mark.esp32]),
-    pytest.param('isr_dispatch_esp32', marks=[pytest.mark.esp32]),
-    pytest.param('isr_dispatch_esp32c3', marks=[pytest.mark.esp32c3]),
-    pytest.param('cpu1_esp32', marks=[pytest.mark.esp32]),
-    pytest.param('any_cpu_esp32', marks=[pytest.mark.esp32]),
-    pytest.param('cpu1_esp32s3', marks=[pytest.mark.esp32s3]),
-    pytest.param('any_cpu_esp32s3', marks=[pytest.mark.esp32s3]),
-]
-
 
 @pytest.mark.generic
 @idf_parametrize(

components/esp_wifi/test_apps/wifi_connect/pytest_wifi_connect.py

@@ -36,28 +36,28 @@ def test_wifi_connect_cases_esp32c2_xtal26m(case_tester: CaseTester) -> None:
     case_tester.run_all_cases()
 
 
-@pytest.mark.esp32c2eco4
+@pytest.mark.esp32c2_rev2
 @pytest.mark.two_duts
 @pytest.mark.xtal_26mhz
 @pytest.mark.parametrize(
     'count, config, target, baud',
     [
-        (2, 'esp32c2eco4_xtal26m', 'esp32c2', '74880'),
+        (2, 'esp32c2_rev2_xtal26m', 'esp32c2', '74880'),
     ],
     indirect=True,
 )
-def test_wifi_connect_cases_esp32c2eco4_xtal26m(case_tester: CaseTester) -> None:
+def test_wifi_connect_cases_esp32c2_rev2_xtal26m(case_tester: CaseTester) -> None:
     case_tester.run_all_cases()
 
 
 @pytest.mark.two_duts
-@pytest.mark.esp32c3eco7
+@pytest.mark.esp32c3_rev1
 @pytest.mark.parametrize(
     'count, config, target',
     [
-        (2, 'esp32c3eco7', 'esp32c3'),
+        (2, 'esp32c3_rev1', 'esp32c3'),
     ],
     indirect=True,
 )
-def test_wifi_connect_cases_esp32c3eco7(case_tester: CaseTester) -> None:
+def test_wifi_connect_cases_esp32c3_rev1(case_tester: CaseTester) -> None:
     case_tester.run_all_cases()

components/esp_wifi/test_apps/wifi_function/pytest_wifi_function.py

@@ -3,6 +3,7 @@
 import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
+
 # @pytest.mark.esp32c2  # esp32c2 are using xtal_26mhz
 
 
@@ -28,26 +29,26 @@ def test_wifi_unit_test_esp32c2_xtal26m(dut: Dut) -> None:
     dut.run_all_single_board_cases()
 
 
-@pytest.mark.esp32c2eco4
+@pytest.mark.esp32c2_rev2
 @pytest.mark.xtal_26mhz
 @pytest.mark.generic
 @pytest.mark.parametrize(
     'config, target, baud',
     [
-        ('esp32c2eco4_xtal26m', 'esp32c2', '74880'),
+        ('esp32c2_rev2_xtal26m', 'esp32c2', '74880'),
     ],
     indirect=True,
 )
-def test_wifi_unit_test_esp32c2eco4_xtal26m(dut: Dut) -> None:
+def test_wifi_unit_test_esp32c2_rev2_xtal26m(dut: Dut) -> None:
     dut.run_all_single_board_cases()
 
 
-@pytest.mark.esp32c3eco7
+@pytest.mark.esp32c3_rev1
 @pytest.mark.generic
 @pytest.mark.parametrize(
     'config, target',
-    [('esp32c3eco7', 'esp32c3')],
+    [('esp32c3_rev1', 'esp32c3')],
     indirect=True,
 )
-def test_wifi_unit_test_esp32c3eco7(dut: Dut) -> None:
+def test_wifi_unit_test_esp32c3_rev1(dut: Dut) -> None:
     dut.run_all_single_board_cases()

components/fatfs/host_test/pytest_fatfs_linux.py

@@ -1,11 +1,9 @@
 # SPDX-FileCopyrightText: 2023-2026 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Unlicense OR CC0-1.0
-import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_fatfs_linux(dut: Dut) -> None:
     dut.expect_exact('All tests passed', timeout=120)

components/freertos/test_apps/freertos/pytest_freertos.py

@@ -4,28 +4,6 @@ import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
-CONFIGS = [
-    pytest.param(
-        'default',
-        marks=[
-            pytest.mark.supported_targets,
-        ],
-    ),
-    pytest.param('freertos_options', marks=[pytest.mark.supported_targets]),
-    pytest.param('psram', marks=[pytest.mark.esp32, pytest.mark.esp32s3, pytest.mark.esp32p4, pytest.mark.esp32c5]),
-    pytest.param('single_core', marks=[pytest.mark.esp32, pytest.mark.esp32p4]),
-    # TODO: [ESP32C5] IDF-10335
-    # TODO: [ESP32C61] IDF-11146
-    pytest.param(
-        'smp',
-        marks=[
-            pytest.mark.supported_targets,
-            pytest.mark.temp_skip_ci(targets=['esp32p4', 'esp32c5', 'esp32c61'], reason='test failed/TBD IDF-8113'),
-        ],
-    ),
-    pytest.param('tickless_idle', marks=[pytest.mark.supported_targets]),
-]
-
 
 @pytest.mark.generic
 @idf_parametrize(
@@ -34,9 +12,6 @@ CONFIGS = [
         ('default', 'supported_targets'),
         ('freertos_options', 'supported_targets'),
         ('psram', 'esp32'),
-        ('psram', 'esp32c5'),
-        ('psram', 'esp32p4'),
-        ('psram', 'esp32s3'),
         ('single_core', 'esp32'),
         ('single_core', 'esp32p4'),
         (

components/hal/test_apps/hal_utils/pytest_hal_utils.py

@@ -1,11 +1,9 @@
 # SPDX-FileCopyrightText: 2023-2026 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Apache-2.0
-import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_hal_utils(dut: Dut) -> None:
     dut.run_all_single_board_cases()

components/heap/test_apps/heap_tests/pytest_heap.py

@@ -20,11 +20,14 @@ def test_heap_poisoning(dut: Dut) -> None:
     dut.run_all_single_board_cases()
 
 
-@pytest.mark.host_test
 @pytest.mark.qemu
 @pytest.mark.parametrize(
     'config, embedded_services',
-    [('no_poisoning', 'idf,qemu'), ('light_poisoning', 'idf,qemu'), ('comprehensive_poisoning', 'idf,qemu')],
+    [
+        ('no_poisoning', 'idf,qemu'),
+        ('light_poisoning', 'idf,qemu'),
+        ('comprehensive_poisoning', 'idf,qemu'),
+    ],
 )
 @idf_parametrize('target', ['esp32', 'esp32c3'], indirect=['target'])
 def test_heap_poisoning_qemu(dut: Dut) -> None:

components/heap/test_apps/host_test_linux/pytest_heap_linux.py

@@ -1,11 +1,9 @@
 # SPDX-FileCopyrightText: 2023-2026 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Unlicense OR CC0-1.0
-import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_heap_linux(dut: Dut) -> None:
     dut.run_all_single_board_cases(timeout=60)

components/linux/test_apps/linux_test/pytest_linux_test.py

@@ -1,11 +1,9 @@
 # SPDX-FileCopyrightText: 2024-2026 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: CC0-1.0
-import pytest
 from pytest_embedded_idf.dut import IdfDut
 from pytest_embedded_idf.utils import idf_parametrize
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_linux_component(dut: IdfDut) -> None:
     dut.expect_exact('Press ENTER to see the list of tests.')

components/log/host_test/log_test/pytest_log_linux.py

@@ -5,12 +5,12 @@ from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
 
-@pytest.mark.host_test
 @pytest.mark.parametrize(
     'config',
     [
         'default',
-        'system_timestamptag_level_linked_list',
+        'system_timestamp',
+        'tag_level_linked_list',
         'tag_level_linked_list_and_array_cache',
         'tag_level_none',
     ],

components/nvs_flash/host_test/nvs_host_test/pytest_nvs_host_linux.py

@@ -1,11 +0,0 @@
-# SPDX-FileCopyrightText: 2023-2026 Espressif Systems (Shanghai) CO LTD
-# SPDX-License-Identifier: Unlicense OR CC0-1.0
-import pytest
-from pytest_embedded import Dut
-from pytest_embedded_idf.utils import idf_parametrize
-
-
-@pytest.mark.host_test
-@idf_parametrize('target', ['linux'], indirect=['target'])
-def test_nvs_host_linux(dut: Dut) -> None:
-    dut.expect_exact('All tests passed', timeout=60)

components/nvs_flash/host_test/nvs_page_test/pytest_nvs_page_linux.py

@@ -1,11 +1,9 @@
 # SPDX-FileCopyrightText: 2023-2026 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Unlicense OR CC0-1.0
-import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_nvs_page_linux(dut: Dut) -> None:
     dut.expect_unity_test_output(timeout=120)

components/nvs_flash/test_apps/pytest_nvs_flash.py

@@ -4,11 +4,6 @@ import pytest
 from pytest_embedded_idf.dut import IdfDut
 from pytest_embedded_idf.utils import idf_parametrize
 
-CONFIGS_NVS_ENCR_FLASH_ENC = [
-    pytest.param('nvs_encr_flash_enc_esp32', marks=[pytest.mark.esp32]),
-    pytest.param('nvs_encr_flash_enc_esp32c3', marks=[pytest.mark.esp32c3]),
-]
-
 
 @pytest.mark.generic
 @pytest.mark.parametrize('config', ['default'], indirect=True)

components/pthread/test_apps/pthread_unity_tests/pytest_pthread_unity_tests.py

@@ -20,7 +20,9 @@ def test_pthread(dut: Dut) -> None:
 
 @pytest.mark.generic
 @idf_parametrize(
-    'config,target', [('single_core_esp32', 'esp32'), ('single_core_esp32s3', 'esp32s3')], indirect=['config', 'target']
+    'config,target',
+    [('single_core_esp32', 'esp32'), ('single_core_esp32s3', 'esp32s3')],
+    indirect=['config', 'target'],
 )
 def test_pthread_single_core(dut: Dut) -> None:
     dut.run_all_single_board_cases(group='!thread-specific', timeout=300)
@@ -46,7 +48,6 @@ def test_pthread_single_core_tls(dut: Dut) -> None:
     dut.run_all_single_board_cases(group='thread-specific', timeout=300)
 
 
-@pytest.mark.host_test
 @pytest.mark.qemu
 @idf_parametrize('target', ['esp32'], indirect=['target'])
 def test_pthread_qemu(dut: Dut) -> None:
@@ -55,7 +56,6 @@ def test_pthread_qemu(dut: Dut) -> None:
             dut._run_normal_case(case, timeout=75)
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_pthread_linux(dut: Dut) -> None:
     dut.run_all_single_board_cases(timeout=120)

components/spiffs/host_test/pytest_spiffs_linux.py

@@ -5,7 +5,6 @@ from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
 
-@pytest.mark.host_test
 @pytest.mark.parametrize('config', ['erase_check', 'no_erase_check'])
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_spiffs_linux(dut: Dut) -> None:

components/tcp_transport/test_apps/pytest_tcp_transport_ut.py

@@ -4,11 +4,6 @@ import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
-CONFIGS = [
-    pytest.param('default', marks=[pytest.mark.esp32, pytest.mark.esp32c3]),
-    pytest.param('psram_esp32', marks=[pytest.mark.esp32]),
-]
-
 
 @pytest.mark.generic
 @idf_parametrize(

components/usb/test_apps/hcd/pytest_usb_hcd.py

@@ -4,11 +4,6 @@ import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
-CONFIGS = [
-    pytest.param('default', marks=[pytest.mark.esp32s2, pytest.mark.esp32s3, pytest.mark.esp32p4]),
-    pytest.param('esp32p4_psram', marks=[pytest.mark.esp32p4]),
-]
-
 
 @pytest.mark.usb_host_flash_disk
 @pytest.mark.temp_skip_ci(targets=['esp32s2'], reason='lack of runners with usb_host_flash_disk tag')

components/wear_levelling/host_test/pytest_wear_levelling_linux.py

@@ -1,11 +1,9 @@
 # SPDX-FileCopyrightText: 2023-2026 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Unlicense OR CC0-1.0
-import pytest
 from pytest_embedded import Dut
 from pytest_embedded_idf.utils import idf_parametrize
 
 
-@pytest.mark.host_test
 @idf_parametrize('target', ['linux'], indirect=['target'])
 def test_wear_levelling_linux(dut: Dut) -> None:
     dut.expect_exact('All tests passed', timeout=120)

components/wpa_supplicant/test_apps/pytest_wpa_supplicant_ut.py

@@ -34,40 +34,40 @@ def test_wpa_supplicant_ut_offchan(case_tester: CaseTester) -> None:
 
 
 @pytest.mark.two_duts
-@pytest.mark.esp32c2eco4
+@pytest.mark.esp32c2_rev2
 @pytest.mark.xtal_26mhz
 @pytest.mark.parametrize(
     'count, config, target, baud',
     [
         (
             2,
-            'esp32c2eco4_xtal26m',
+            'esp32c2_rev2_xtal26m',
             'esp32c2',
             '74880',
         ),
     ],
     indirect=True,
 )
-def test_wpa_supplicant_esp32c2eco4_xtal26mhz(case_tester: CaseTester) -> None:
+def test_wpa_supplicant_esp32c2_rev2_xtal26mhz(case_tester: CaseTester) -> None:
     for case in case_tester.test_menu:
         if case.attributes.get('test_env') == 'two_duts':
             case_tester.run_multi_dev_case(case=case, reset=True)
 
 
 @pytest.mark.two_duts
-@pytest.mark.esp32c3eco7
+@pytest.mark.esp32c3_rev1
 @pytest.mark.parametrize(
     'count, config, target',
     [
         (
             2,
-            'esp32c3eco7',
+            'esp32c3_rev1',
             'esp32c3',
         ),
     ],
     indirect=True,
 )
-def test_wpa_supplicant_esp32c3eco7(case_tester: CaseTester) -> None:
+def test_wpa_supplicant_esp32c3_rev1(case_tester: CaseTester) -> None:
     for case in case_tester.test_menu:
         if case.attributes.get('test_env') == 'two_duts':
             case_tester.run_multi_dev_case(case=case, reset=True)