Merge remote-tracking branch 'origin/dev' into esp8266-native-build-spec

tests/component_tests/esp32/config/file_macro_idf_5_0.yaml

@@ -0,0 +1,8 @@
+esphome:
+  name: test
+
+esp32:
+  board: esp32dev
+  framework:
+    type: esp-idf
+    version: 5.0.6

tests/component_tests/esp32/config/flash_chip_gd.yaml

@@ -0,0 +1,9 @@
+esphome:
+  name: test
+
+esp32:
+  board: esp32dev
+  framework:
+    type: esp-idf
+    advanced:
+      flash_chip: gd

tests/component_tests/esp32/config/flash_chip_generic.yaml

@@ -0,0 +1,9 @@
+esphome:
+  name: test
+
+esp32:
+  board: esp32dev
+  framework:
+    type: esp-idf
+    advanced:
+      flash_chip: generic

tests/component_tests/esp32/config/flash_chip_mxic_opi_s3.yaml

@@ -0,0 +1,10 @@
+esphome:
+  name: test
+
+esp32:
+  variant: esp32s3
+  flash_mode: opi
+  framework:
+    type: esp-idf
+    advanced:
+      flash_chip: mxic_opi

tests/component_tests/esp32/config/flash_mode_opi_s3.yaml

@@ -0,0 +1,8 @@
+esphome:
+  name: test
+
+esp32:
+  variant: esp32s3
+  flash_mode: opi
+  framework:
+    type: esp-idf

tests/component_tests/esp32/test_esp32.py

@@ -10,6 +10,7 @@ from typing import Any
 import pytest
 
 from esphome.components.esp32 import (
+    ESP32_FLASH_CHIPS,
     KEY_FATFS_REQUIRED,
     KEY_MBEDTLS_TLS_EXTRAS_REQUIRED,
     KEY_MBEDTLS_TLS_SERVER_REQUIRED,
@@ -252,6 +253,51 @@ def test_esp32_rejects_unsupported_cli_toolchain(
             r"value must be at most 5 .* @ data\['framework'\]\['advanced'\]\['nvs_encryption'\]\['key_id'\]",
             id="nvs_encryption_key_id_out_of_range",
         ),
+        pytest.param(
+            {
+                "variant": "esp32",
+                "board": "esp32dev",
+                "framework": {
+                    "type": "esp-idf",
+                    "advanced": {"flash_chip": "mxic_opi"},
+                },
+            },
+            r"'flash_chip: mxic_opi' is only supported on ESP32S3 @ data\['framework'\]\['advanced'\]\['flash_chip'\]",
+            id="flash_chip_mxic_opi_only_on_s3",
+        ),
+        pytest.param(
+            {
+                "variant": "esp32s3",
+                "flash_mode": "opi",
+                "framework": {
+                    "type": "esp-idf",
+                    "advanced": {"flash_chip": "gd"},
+                },
+            },
+            r"'flash_chip: gd' does not match 'flash_mode: opi'; octal flash uses mxic_opi @ data\['framework'\]\['advanced'\]\['flash_chip'\]",
+            id="flash_chip_must_match_opi_mode",
+        ),
+        pytest.param(
+            {
+                "variant": "esp32s3",
+                "framework": {
+                    "type": "esp-idf",
+                    "advanced": {"flash_chip": "mxic_opi"},
+                },
+            },
+            r"'flash_chip: mxic_opi' requires 'flash_mode: opi' @ data\['framework'\]\['advanced'\]\['flash_chip'\]",
+            id="flash_chip_mxic_opi_requires_opi_mode",
+        ),
+        pytest.param(
+            {
+                "variant": "esp32",
+                "board": "esp32dev",
+                "flash_mode": "opi",
+                "framework": {"type": "esp-idf"},
+            },
+            r"'flash_mode: opi' is only supported on ESP32S3 @ data\['flash_mode'\]",
+            id="flash_mode_opi_only_on_s3",
+        ),
     ],
 )
 def test_esp32_configuration_errors(
@@ -658,6 +704,27 @@ def test_platformio_arduino_enables_reproducible_build(
     assert sdkconfig.get("CONFIG_APP_REPRODUCIBLE_BUILD") is True
 
 
+@pytest.mark.parametrize(
+    ("config_file", "expected"),
+    [
+        ("reproducible_build.yaml", True),
+        ("reproducible_build_arduino.yaml", True),
+        ("file_macro_idf_5_0.yaml", False),
+    ],
+)
+def test_file_macro_is_basename_only(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+    config_file: str,
+    expected: bool,
+) -> None:
+    """__FILE__ becomes the basename on GCC 12 toolchains; IDF 5.0 (GCC 11) is skipped."""
+    generate_main(component_config_path(config_file))
+
+    assert ("-D__FILE__=__FILE_NAME__" in CORE.build_flags) is expected
+    assert ("-Wno-builtin-macro-redefined" in CORE.build_flags) is expected
+
+
 def test_native_idf_enables_reproducible_build(
     component_config_path: Callable[[str], Path],
 ) -> None:
@@ -683,10 +750,59 @@ def test_flash_mode_sets_sdkconfig_and_pio_option(
     sdkconfig = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS]
     assert sdkconfig.get("CONFIG_ESPTOOLPY_FLASHMODE_QIO") is True
     assert sdkconfig.get("CONFIG_ESPTOOLPY_FLASHFREQ_80M") is True
+    assert sdkconfig.get("CONFIG_ESPTOOLPY_OCT_FLASH") is False
     assert CORE.platformio_options.get("board_build.flash_mode") == "qio"
     assert CORE.platformio_options.get("board_build.f_flash") == "80000000L"
 
 
+@pytest.mark.parametrize(
+    ("config_file", "enabled"),
+    [
+        pytest.param("flash_chip_gd.yaml", "CONFIG_SPI_FLASH_SUPPORT_GD_CHIP", id="gd"),
+        pytest.param("flash_chip_generic.yaml", None, id="generic"),
+        pytest.param(
+            "flash_chip_mxic_opi_s3.yaml",
+            "CONFIG_SPI_FLASH_SUPPORT_MXIC_OPI_CHIP",
+            id="mxic_opi_s3",
+        ),
+    ],
+)
+def test_flash_chip_keeps_one_vendor_driver(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+    config_file: str,
+    enabled: str | None,
+) -> None:
+    """flash_chip enables only the chosen vendor driver."""
+    generate_main(component_config_path(config_file))
+    sdkconfig = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS]
+    vendors = {
+        k: v for k, v in sdkconfig.items() if k.startswith("CONFIG_SPI_FLASH_SUPPORT_")
+    }
+    assert vendors == {flag: flag == enabled for flag in ESP32_FLASH_CHIPS.values()}
+
+
+def test_flash_chip_unset_keeps_idf_defaults(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+) -> None:
+    """Without flash_chip every vendor driver stays at its ESP-IDF default."""
+    generate_main(component_config_path("flash_mode_default.yaml"))
+    sdkconfig = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS]
+    assert not any(key.startswith("CONFIG_SPI_FLASH_SUPPORT_") for key in sdkconfig)
+
+
+def test_flash_mode_opi_enables_octal_flash(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+) -> None:
+    """flash_mode: opi needs the octal flash switch or ESP-IDF ignores the mode."""
+    generate_main(component_config_path("flash_mode_opi_s3.yaml"))
+    sdkconfig = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS]
+    assert sdkconfig.get("CONFIG_ESPTOOLPY_FLASHMODE_OPI") is True
+    assert sdkconfig.get("CONFIG_ESPTOOLPY_OCT_FLASH") is True
+
+
 def test_flash_mode_unset_leaves_defaults(
     generate_main: Callable[[str | Path], str],
     component_config_path: Callable[[str], Path],

tests/component_tests/ota/test_esphome_ota.py

@@ -319,6 +319,32 @@ def test_encryption_with_captive_portal_does_not_warn(
         fv.full_config.reset(token)
 
 
+@pytest.mark.parametrize("extra", [{}, {"prometheus": {}}])
+def test_encryption_with_web_server_ota_disabled_does_not_warn(
+    caplog: pytest.LogCaptureFixture, extra: dict[str, Any]
+) -> None:
+    """web_server `ota: false` only serves /update while the captive portal is
+    active, on every listener, so there is no plaintext endpoint to warn about."""
+    full_conf = {
+        "web_server": {CONF_OTA: False},
+        **extra,
+        CONF_OTA: [
+            _make_ota_config(port=3232, **{CONF_ENCRYPTION: {CONF_KEY: OTHER_KEY}}),
+            {CONF_PLATFORM: "web_server", CONF_ID: ID("ota_ws", is_manual=False)},
+        ],
+    }
+    token = fv.full_config.set(full_conf)
+    try:
+        with caplog.at_level(logging.WARNING):
+            ota_esphome_final_validate({})
+        assert not any(
+            "OTA encryption does not cover" in record.message
+            for record in caplog.records
+        )
+    finally:
+        fv.full_config.reset(token)
+
+
 def test_password_with_api_key_warns(caplog: pytest.LogCaptureFixture) -> None:
     """A static api key makes the device offer encryption and the CLI take
     it, so the password is dead weight; the config validates with a warning."""

tests/component_tests/remote_receiver/config/receiver_bk72xx.yaml

@@ -0,0 +1,9 @@
+esphome:
+  name: test
+
+bk72xx:
+  board: generic-bk7252
+
+remote_receiver:
+  - id: rcvr
+    pin: P6

tests/component_tests/remote_receiver/config/receiver_esp32_c61.yaml

@@ -0,0 +1,12 @@
+esphome:
+  name: test
+
+esp32:
+  board: esp32-c61-devkitc1
+  variant: esp32c61
+  framework:
+    type: esp-idf
+
+remote_receiver:
+  - id: rcvr
+    pin: GPIO4

tests/component_tests/remote_receiver/config/receiver_ln882x.yaml

@@ -0,0 +1,9 @@
+esphome:
+  name: test
+
+ln882x:
+  board: generic-ln882h
+
+remote_receiver:
+  - id: rcvr
+    pin: PA4

tests/component_tests/remote_receiver/config/receiver_rp2.yaml

@@ -0,0 +1,9 @@
+esphome:
+  name: test
+
+rp2:
+  board: rpipicow
+
+remote_receiver:
+  - id: rcvr
+    pin: GPIO4

tests/component_tests/remote_receiver/config/receiver_rtl87xx.yaml

@@ -0,0 +1,9 @@
+esphome:
+  name: test
+
+rtl87xx:
+  board: generic-rtl8710bn-2mb-788k
+
+remote_receiver:
+  - id: rcvr
+    pin: PA12

tests/component_tests/remote_receiver/config/receiver_with_external_protocol.yaml

@@ -0,0 +1,36 @@
+esphome:
+  name: test
+
+esp32:
+  board: esp32dev
+
+logger:
+
+external_components:
+  - source:
+      type: local
+      path: ../external_components
+
+fake_protocol:
+
+remote_receiver:
+  - id: rcvr
+    pin: GPIO4
+    dump:
+      - fake
+      - nec
+    on_fake:
+      then:
+        - remote_transmitter.transmit_fake:
+    on_nec:
+      then:
+        - logger.log: nec
+
+remote_transmitter:
+  pin: GPIO5
+  carrier_duty_percent: 50%
+
+binary_sensor:
+  - platform: remote_receiver
+    name: Fake Input
+    fake:

tests/component_tests/remote_receiver/external_components/fake_protocol/__init__.py

@@ -0,0 +1,39 @@
+"""External component registering a protocol that has no source file in remote_base."""
+
+import esphome.codegen as cg
+from esphome.components import remote_base
+import esphome.config_validation as cv
+from esphome.types import ConfigType
+
+DEPENDENCIES = ["remote_base"]
+
+ns = cg.esphome_ns.namespace("fake_protocol")
+FakeData = ns.struct("FakeData")
+FakeBinarySensor = ns.class_(
+    "FakeBinarySensor", remote_base.RemoteReceiverBinarySensorBase
+)
+FakeTrigger = ns.class_("FakeTrigger", remote_base.RemoteReceiverTrigger)
+FakeAction = ns.class_("FakeAction", remote_base.RemoteTransmitterActionBase)
+FakeDumper = ns.class_("FakeDumper", remote_base.RemoteReceiverDumperBase)
+
+CONFIG_SCHEMA = cv.Schema({})
+
+
+@remote_base.register_binary_sensor("fake", FakeBinarySensor, {})
+def fake_binary_sensor(var: cg.MockObj, config: ConfigType) -> None:
+    pass
+
+
+@remote_base.register_trigger("fake", FakeTrigger, FakeData)
+def fake_trigger(var: cg.MockObj, config: ConfigType) -> None:
+    pass
+
+
+@remote_base.register_dumper("fake", FakeDumper)
+def fake_dumper(var: cg.MockObj, config: ConfigType) -> None:
+    pass
+
+
+@remote_base.register_action("fake", FakeAction, {})
+async def fake_action(var: cg.MockObj, config: ConfigType, args: list) -> None:
+    pass

tests/component_tests/remote_receiver/test_buffer_size.py

@@ -1,8 +1,16 @@
-"""buffer_size reaches the receiver when set, and always on the pulse ring targets."""
+"""buffer_size is bytes on the pulse ring targets and only reaches RMT targets when set."""
 
 from collections.abc import Callable
 from pathlib import Path
 
+import pytest
+
+from esphome.components import remote_receiver
+from esphome.components.esp8266 import gpio as esp8266_gpio  # noqa: F401  registers the pin schema
+from esphome.config_validation import Invalid
+from esphome.const import PlatformFramework
+from tests.component_tests.types import SetCoreConfigCallable
+
 
 def test_explicit_buffer_size_is_passed_through(
     generate_main: Callable[[str | Path], str],
@@ -12,17 +20,29 @@ def test_explicit_buffer_size_is_passed_through(
     assert "rcvr->set_buffer_size(2000);" in main_cpp
 
 
-def test_pulse_ring_target_keeps_a_default(
+@pytest.mark.parametrize(
+    "target", ["esp8266", "rp2", "bk72xx", "rtl87xx", "ln882x", "esp32_c2", "esp32_c61"]
+)
+def test_pulse_ring_default_holds_1000_pulses(
     generate_main: Callable[[str | Path], str],
     component_config_path: Callable[[str], Path],
+    target: str,
 ) -> None:
-    main_cpp = generate_main(component_config_path("receiver_esp8266.yaml"))
-    assert "rcvr->set_buffer_size(1000);" in main_cpp
+    main_cpp = generate_main(component_config_path(f"receiver_{target}.yaml"))
+    assert "rcvr->set_buffer_size(4000);" in main_cpp
 
 
-def test_esp32_variant_without_rmt_keeps_a_default(
-    generate_main: Callable[[str | Path], str],
-    component_config_path: Callable[[str], Path],
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    [("32b", None), ("64b", 64), ("65b", 65), ("65535b", 65535), ("65536b", None)],
+)
+def test_buffer_size_range(
+    set_core_config: SetCoreConfigCallable, value: str, expected: int | None
 ) -> None:
-    main_cpp = generate_main(component_config_path("receiver_esp32_c2.yaml"))
-    assert "rcvr->set_buffer_size(1000);" in main_cpp
+    set_core_config(PlatformFramework.ESP8266_ARDUINO)
+    config = {"pin": "GPIO4", "buffer_size": value}
+    if expected is None:
+        with pytest.raises(Invalid):
+            remote_receiver.CONFIG_SCHEMA(config)
+    else:
+        assert remote_receiver.CONFIG_SCHEMA(config)["buffer_size"] == expected

tests/component_tests/remote_receiver/test_slot_counts.py

@@ -1,13 +1,16 @@
 """Listener and dumper StaticVector sizes come from codegen slot counts."""
 
-from collections.abc import Callable
+from collections.abc import Callable, Generator
 from pathlib import Path
+import sys
 
 import pytest
 
+from esphome import loader
 from esphome.automation import ACTION_REGISTRY
 from esphome.components import remote_base
 import esphome.config_validation as cv
+from esphome.core import CORE
 
 from ..helpers import get_define_value
 
@@ -74,6 +77,47 @@ def test_every_registry_name_maps_to_a_protocol_source() -> None:
         assert remote_base._protocol_stem(name) in remote_base._PROTOCOL_STEMS, name
 
 
+@pytest.fixture
+def restore_protocol_registries() -> Generator[None]:
+    """Loading an external protocol component adds to module-level registries; undo that.
+
+    The loader caches the component too, so drop it or a second load would skip the
+    decorators and leave the restored registries without the external names.
+    """
+    registries = (
+        remote_base.BINARY_SENSOR_REGISTRY,
+        remote_base.TRIGGER_REGISTRY,
+        remote_base.DUMPER_REGISTRY,
+        ACTION_REGISTRY,
+    )
+    saved = [dict(registry) for registry in registries]
+    yield
+    for registry, entries in zip(registries, saved, strict=True):
+        registry.clear()
+        registry.update(entries)
+    loader._COMPONENT_CACHE.pop("fake_protocol", None)
+    sys.modules.pop("esphome.components.fake_protocol", None)
+
+
+@pytest.mark.usefixtures("restore_protocol_registries")
+def test_external_protocols_register_without_a_remote_base_source(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+) -> None:
+    """An external protocol goes through all four decorators without a source file here, so no define is emitted."""
+    main_cpp = generate_main(
+        component_config_path("receiver_with_external_protocol.yaml")
+    )
+    defines = {define.name for define in CORE.defines}
+    assert "USE_REMOTE_PROTOCOL_NEC" in defines
+    assert "USE_REMOTE_PROTOCOL_FAKE" not in defines
+    for cls in ("FakeBinarySensor", "FakeTrigger", "FakeDumper", "FakeAction"):
+        assert f"fake_protocol::{cls}" in main_cpp, cls
+    # fake and nec dumpers; on_fake and on_nec triggers plus the fake binary sensor
+    assert get_define_value("REMOTE_BASE_DUMPER_COUNT") == "2"
+    assert get_define_value("REMOTE_BASE_LISTENER_COUNT") == "3"
+
+
 def test_request_protocol_rejects_unknown_names() -> None:
     """A misspelled protocol would otherwise surface only as a link error."""
     with pytest.raises(ValueError, match="Unknown remote protocol 'toshiba'"):

tests/components/esp32/test.esp32-idf.yaml

@@ -22,6 +22,7 @@ esp32:
       disable_regi2c_in_iram: true
       disable_fatfs: true
       sram1_as_iram: true
+      flash_chip: gd
   watchdog_timeout: 7s
 
 wifi:

tests/components/esp32/test.esp32-s3-idf.yaml

@@ -9,6 +9,7 @@ esp32:
     type: esp-idf
     advanced:
       execute_from_psram: true
+      flash_chip: gd
       disable_libc_locks_in_iram: true  # Test default RAM optimization enabled
       disable_debug_stubs: true
       disable_ocd_aware: true

tests/components/icnt86/common.yaml

@@ -0,0 +1,24 @@
+touchscreen:
+  - platform: icnt86
+    i2c_id: i2c_bus
+    interrupt_pin: ${interrupt_pin_touch}
+    reset_pin: ${reset_pin_touch}
+    display: epaper
+    on_touch:
+      - logger.log:
+          format: Touch at (%d, %d)
+          args: [touch.x, touch.y]
+
+display:
+  - platform: waveshare_epaper
+    id: epaper
+    rotation: 90
+    cs_pin: ${cs_pin_display}
+    dc_pin: ${dc_pin_display}
+    busy_pin: ${busy_pin_display}
+    reset_pin: ${reset_pin_display}
+    model: 2.90inv2-r2
+    pages:
+      - id: icnt86_page
+        lambda: |-
+          it.rectangle(0, 0, it.get_width(), it.get_height());

tests/components/icnt86/test.esp32-idf.yaml

@@ -0,0 +1,14 @@
+substitutions:
+  interrupt_pin_touch: GPIO4
+  reset_pin_touch: GPIO32
+  cs_pin_display: GPIO33
+  dc_pin_display: GPIO21
+  busy_pin_display: GPIO27
+  reset_pin_display: GPIO14
+  clk_pin: GPIO25
+  mosi_pin: GPIO26
+
+packages:
+  i2c: !include ../../test_build_components/common/i2c/esp32-idf.yaml
+  spi: !include ../../test_build_components/common/spi/esp32-idf.yaml
+  icnt86: !include common.yaml

tests/components/mixer/common.yaml

@@ -3,7 +3,7 @@ esphome:
     then:
       - mixer_speaker.apply_ducking:
           id: source_speaker_1_id
-          decibel_reduction: 10
+          decibel_reduction: 255
           duration: 1s
 
 speaker:

tests/components/sendspin/common-switch.yaml

@@ -0,0 +1,6 @@
+packages:
+  sendspin: !include common.yaml
+
+switch:
+  - platform: sendspin
+    name: "Sendspin Enabled"

tests/components/sendspin/test-switch.esp32-idf.yaml

@@ -0,0 +1,2 @@
+packages:
+  sendspin: !include common-switch.yaml

tests/integration/fixtures/sensor_raw_state.yaml

@@ -0,0 +1,53 @@
+esphome:
+  name: test-sensor-raw-state
+
+host:
+api:
+  batch_delay: 0ms  # Disable batching to receive all state updates
+logger:
+  level: DEBUG
+
+# Filters are compiled in for this config (USE_SENSOR_FILTER), so raw storage exists
+sensor:
+  # No filters on this sensor: get_raw_state() must equal state
+  - platform: template
+    name: "No Filter Sensor"
+    id: no_filter_sensor
+    accuracy_decimals: 1
+
+  # Filtered sensor: get_raw_state() must be the pre-filter value
+  - platform: template
+    name: "With Filter Sensor"
+    id: with_filter_sensor
+    accuracy_decimals: 1
+    filters:
+      - multiply: 2.0
+
+button:
+  - platform: template
+    name: "Test No Filter Button"
+    id: test_no_filter_button
+    on_press:
+      - sensor.template.publish:
+          id: no_filter_sensor
+          state: 21.5
+      - delay: 50ms
+      - logger.log:
+          format: "NO_FILTER: state=%.1f raw_state=%.1f"
+          args:
+            - id(no_filter_sensor).state
+            - id(no_filter_sensor).get_raw_state()
+
+  - platform: template
+    name: "Test With Filter Button"
+    id: test_with_filter_button
+    on_press:
+      - sensor.template.publish:
+          id: with_filter_sensor
+          state: 21.5
+      - delay: 50ms
+      - logger.log:
+          format: "WITH_FILTER: state=%.1f raw_state=%.1f"
+          args:
+            - id(with_filter_sensor).state
+            - id(with_filter_sensor).get_raw_state()

tests/integration/fixtures/sensor_raw_state_no_filter.yaml

@@ -0,0 +1,31 @@
+esphome:
+  name: test-sensor-raw-state-no-filter
+
+host:
+api:
+  batch_delay: 0ms  # Disable batching to receive all state updates
+logger:
+  level: DEBUG
+
+# No sensor in this config has filters, so USE_SENSOR_FILTER is not defined and
+# get_raw_state() falls back to state
+sensor:
+  - platform: template
+    name: "No Filter Sensor"
+    id: no_filter_sensor
+    accuracy_decimals: 1
+
+button:
+  - platform: template
+    name: "Test No Filter Button"
+    id: test_no_filter_button
+    on_press:
+      - sensor.template.publish:
+          id: no_filter_sensor
+          state: 21.5
+      - delay: 50ms
+      - logger.log:
+          format: "NO_FILTER: state=%.1f raw_state=%.1f"
+          args:
+            - id(no_filter_sensor).state
+            - id(no_filter_sensor).get_raw_state()

tests/integration/fixtures/uart_mock_modbus_mesh.yaml

@@ -17,10 +17,10 @@ uart:
   baud_rate: 115200
   port: /dev/null
 
-# Shared 3-bus mesh (see the shared_yaml markers): addr 1 = typed read-only
-# registers, addr 5 = the read/write 0x17 target, addr 2/3 on the second
-# server hub. auto_start everywhere: the controller polls at boot, so the
-# forwarding must already be live or early requests generate warnings.
+# Shared 3-bus mesh (see the shared_yaml markers): addr 1 = typed registers
+# backed by writable globals, addr 5 = the read/write 0x17 target, addr 2/3/6
+# on the second server hub. auto_start everywhere: the controller polls at
+# boot, so the forwarding must already be live or early requests generate warnings.
 # Every test presses Start Scenario, so all merged actions fire in every test.
 uart_mock:
   - id: virtual_uart_server
@@ -64,6 +64,54 @@ globals:
   - id: stored_1
     type: uint16_t
     initial_value: "0"
+  - id: stored_u_word
+    type: uint16_t
+    initial_value: "99"
+  - id: stored_u_word_s
+    type: uint16_t
+    initial_value: "4660"
+  - id: stored_s_word
+    type: int16_t
+    initial_value: "-99"
+  - id: stored_s_word_s
+    type: int16_t
+    initial_value: "-2"
+  - id: stored_u_dword
+    type: uint32_t
+    initial_value: "16909060"
+  - id: stored_s_dword
+    type: int32_t
+    initial_value: "-16909060"
+  - id: stored_u_dword_r
+    type: uint32_t
+    initial_value: "67305985"
+  - id: stored_s_dword_r
+    type: int32_t
+    initial_value: "-67305985"
+  - id: stored_u_qword
+    type: uint64_t
+    initial_value: "72623859790382856"
+  - id: stored_s_qword
+    type: int64_t
+    initial_value: "-72623859790382856"
+  - id: stored_u_qword_r
+    type: uint64_t
+    initial_value: "578437695752307201"
+  - id: stored_s_qword_r
+    type: int64_t
+    initial_value: "-578437695752307201"
+  - id: stored_fp32
+    type: float
+    initial_value: "3.14"
+  - id: stored_fp32_r
+    type: float
+    initial_value: "2.5"
+  - id: stored_bit_2
+    type: bool
+    initial_value: "false"
+  - id: stored_bit_3
+    type: bool
+    initial_value: "true"
 
 modbus:
   - uart_id: virtual_uart_server
@@ -90,6 +138,10 @@ modbus_controller:
     modbus_id: virtual_modbus_client
     id: modbus_controller_3
     update_interval: 1s
+  - address: 6
+    modbus_id: virtual_modbus_client
+    id: modbus_controller_6
+    update_interval: 1s
 
 modbus_server:
   - address: 1
@@ -97,46 +149,60 @@ modbus_server:
     registers:
       - address: 0x01
         value_type: U_WORD
-        read_lambda: return 99;
+        read_lambda: return id(stored_u_word);
+        write_lambda: id(stored_u_word) = x; return true;
       - address: 0x02
         value_type: U_WORD_S
-        read_lambda: return 4660;
+        read_lambda: return id(stored_u_word_s);
+        write_lambda: id(stored_u_word_s) = x; return true;
       - address: 0x03
         value_type: S_WORD
-        read_lambda: return -99;
+        read_lambda: return id(stored_s_word);
+        write_lambda: id(stored_s_word) = x; return true;
       - address: 0x04
         value_type: S_WORD_S
-        read_lambda: return -2;
+        read_lambda: return id(stored_s_word_s);
+        write_lambda: id(stored_s_word_s) = x; return true;
       - address: 0x05
         value_type: U_DWORD
-        read_lambda: return 16909060;
+        read_lambda: return id(stored_u_dword);
+        write_lambda: id(stored_u_dword) = x; return true;
       - address: 0x08
         value_type: S_DWORD
-        read_lambda: return -16909060;
+        read_lambda: return id(stored_s_dword);
+        write_lambda: id(stored_s_dword) = x; return true;
       - address: 0x0B
         value_type: U_DWORD_R
-        read_lambda: return 67305985;
+        read_lambda: return id(stored_u_dword_r);
+        write_lambda: id(stored_u_dword_r) = x; return true;
       - address: 0x0E
         value_type: S_DWORD_R
-        read_lambda: return -67305985;
+        read_lambda: return id(stored_s_dword_r);
+        write_lambda: id(stored_s_dword_r) = x; return true;
       - address: 0x11
         value_type: U_QWORD
-        read_lambda: return 72623859790382856;
+        read_lambda: return id(stored_u_qword);
+        write_lambda: id(stored_u_qword) = x; return true;
       - address: 0x16
         value_type: S_QWORD
-        read_lambda: return -72623859790382856;
+        read_lambda: return id(stored_s_qword);
+        write_lambda: id(stored_s_qword) = x; return true;
       - address: 0x1B
         value_type: U_QWORD_R
-        read_lambda: return 578437695752307201;
+        read_lambda: return id(stored_u_qword_r);
+        write_lambda: id(stored_u_qword_r) = x; return true;
       - address: 0x20
         value_type: S_QWORD_R
-        read_lambda: return -578437695752307201;
+        read_lambda: return id(stored_s_qword_r);
+        write_lambda: id(stored_s_qword_r) = x; return true;
       - address: 0x25
         value_type: FP32
-        read_lambda: return 3.14;
+        read_lambda: return id(stored_fp32);
+        write_lambda: id(stored_fp32) = x; return true;
       - address: 0x28
         value_type: FP32_R
-        read_lambda: return 3.14;
+        read_lambda: return id(stored_fp32_r);
+        write_lambda: id(stored_fp32_r) = x; return true;
   - address: 5
     modbus_id: virtual_modbus_server
     registers:
@@ -165,6 +231,19 @@ modbus_server:
       - address: 0x01
         value_type: U_WORD
         read_lambda: return 929;
+  - address: 6
+    modbus_id: virtual_modbus_server_2
+    bits:
+      - address: 0x00
+        read_lambda: return true;
+      - address: 0x01
+        read_lambda: return false;
+      - address: 0x02
+        read_lambda: return id(stored_bit_2);
+        write_lambda: id(stored_bit_2) = x; return true;
+      - address: 0x03
+        read_lambda: return id(stored_bit_3);
+        write_lambda: id(stored_bit_3) = x; return true;
 
 sensor:
   - platform: modbus_controller
@@ -280,6 +359,183 @@ sensor:
     name: "client_read_1"
     id: client_read_1
 
+# The number schema caps min/max at 16777215 (float32 integer precision), so
+# the large dword/qword baselines cannot be written back through these numbers.
+number:
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_word"
+    address: 0x01
+    register_type: holding
+    value_type: U_WORD
+    min_value: 0
+    max_value: 65535
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_word_s"
+    address: 0x02
+    register_type: holding
+    value_type: U_WORD_S
+    min_value: 0
+    max_value: 65535
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_word"
+    address: 0x03
+    register_type: holding
+    value_type: S_WORD
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_word_s"
+    address: 0x04
+    register_type: holding
+    value_type: S_WORD_S
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_dword"
+    address: 0x05
+    register_type: holding
+    value_type: U_DWORD
+    min_value: 0
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_dword"
+    address: 0x08
+    register_type: holding
+    value_type: S_DWORD
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_dword_r"
+    address: 0x0B
+    register_type: holding
+    value_type: U_DWORD_R
+    min_value: 0
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_dword_r"
+    address: 0x0E
+    register_type: holding
+    value_type: S_DWORD_R
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_qword"
+    address: 0x11
+    register_type: holding
+    value_type: U_QWORD
+    min_value: 0
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_qword"
+    address: 0x16
+    register_type: holding
+    value_type: S_QWORD
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_qword_r"
+    address: 0x1B
+    register_type: holding
+    value_type: U_QWORD_R
+    min_value: 0
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_qword_r"
+    address: 0x20
+    register_type: holding
+    value_type: S_QWORD_R
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_fp32"
+    address: 0x25
+    register_type: holding
+    value_type: FP32
+    min_value: -16777215
+    max_value: 16777215
+    step: 0.01
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_fp32_r"
+    address: 0x28
+    register_type: holding
+    value_type: FP32_R
+    min_value: -16777215
+    max_value: 16777215
+    step: 0.01
+
+# The four bits are read both as coils (FC 0x01) and discrete inputs (FC 0x02);
+# the server serves both from one shared table, so the two views must agree.
+binary_sensor:
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_coil_0"
+    address: 0x00
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_coil_1"
+    address: 0x01
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_coil_2"
+    address: 0x02
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_coil_3"
+    address: 0x03
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_di_0"
+    address: 0x00
+    register_type: discrete_input
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_di_1"
+    address: 0x01
+    register_type: discrete_input
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_di_2"
+    address: 0x02
+    register_type: discrete_input
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_di_3"
+    address: 0x03
+    register_type: discrete_input
+
+# write_bit_2 uses the single-coil write (FC 0x05); write_bit_3 opts into the
+# multiple-coils write (FC 0x0F) so both server write paths are exercised.
+switch:
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "write_bit_2"
+    address: 0x02
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "write_bit_3"
+    address: 0x03
+    register_type: coil
+    use_write_multiple: true
+
 button:
   - platform: template
     name: "Start Scenario"

tests/integration/fixtures/uart_mock_modbus_server_controller_bits.yaml

@@ -1,147 +0,0 @@
-esphome:
-  name: uart-mock-modbus-srv-bits
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-external_components:
-  - source:
-      type: local
-      path: EXTERNAL_COMPONENT_PATH
-
-# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
-# The actual UART bus used is the uart_mock component below
-uart:
-  baud_rate: 115200
-  port: /dev/null
-
-uart_mock:
-  - id: virtual_uart_server
-    baud_rate: 9600
-    # auto_start must be true for loopback fixtures: the modbus controller
-    # polls on its update_interval immediately at boot, so the uart_mock
-    # forwarding must already be active or early requests are lost and
-    # generate modbus warnings.
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_controller
-              data: !lambda return data;
-  - id: virtual_uart_controller
-    baud_rate: 9600
-    auto_start: true # See comment on virtual_uart_server above
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_server
-              data: !lambda return data;
-
-globals:
-  - id: stored_bit_2
-    type: bool
-    initial_value: "false"
-  - id: stored_bit_3
-    type: bool
-    initial_value: "true"
-
-modbus:
-  - uart_id: virtual_uart_server
-    id: virtual_modbus_server
-    role: server
-  - uart_id: virtual_uart_controller
-    id: virtual_modbus_controller
-    role: client
-    turnaround_time: 10ms
-
-modbus_controller:
-  - address: 1
-    modbus_id: virtual_modbus_controller
-    update_interval: 1s
-    id: modbus_controller_1
-
-modbus_server:
-  - address: 1
-    modbus_id: virtual_modbus_server
-    id: modbus_server_1
-    bits:
-      - address: 0x00
-        read_lambda: return true;
-      - address: 0x01
-        read_lambda: return false;
-      - address: 0x02
-        read_lambda: return id(stored_bit_2);
-        write_lambda: id(stored_bit_2) = x; return true;
-      - address: 0x03
-        read_lambda: return id(stored_bit_3);
-        write_lambda: id(stored_bit_3) = x; return true;
-
-# The same four bits are read both as coils (FC 0x01) and as discrete inputs
-# (FC 0x02): the server serves both from one shared bit table, so the two
-# views must always agree.
-binary_sensor:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_coil_0"
-    address: 0x00
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_coil_1"
-    address: 0x01
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_coil_2"
-    address: 0x02
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_coil_3"
-    address: 0x03
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_di_0"
-    address: 0x00
-    register_type: discrete_input
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_di_1"
-    address: 0x01
-    register_type: discrete_input
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_di_2"
-    address: 0x02
-    register_type: discrete_input
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_di_3"
-    address: 0x03
-    register_type: discrete_input
-
-# write_bit_2 uses the single-coil write (FC 0x05); write_bit_3 opts into the
-# multiple-coils write (FC 0x0F) so both server write paths are exercised.
-switch:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_bit_2"
-    address: 0x02
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_bit_3"
-    address: 0x03
-    register_type: coil
-    use_write_multiple: true
-
-button:
-  - platform: template
-    name: "Start Scenario"
-    id: start_scenario_btn
-    # This test does not have anything to start (mock is autostart)

tests/integration/fixtures/uart_mock_modbus_server_controller_write.yaml

@@ -1,371 +0,0 @@
-esphome:
-  name: uart-mock-modbus-srv-write
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-external_components:
-  - source:
-      type: local
-      path: EXTERNAL_COMPONENT_PATH
-
-# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
-# The actual UART bus used is the uart_mock component below
-uart:
-  baud_rate: 115200
-  port: /dev/null
-
-uart_mock:
-  - id: virtual_uart_server
-    baud_rate: 9600
-    # auto_start must be true for loopback fixtures: the modbus controller
-    # polls on its update_interval immediately at boot, so the uart_mock
-    # forwarding must already be active or early requests are lost and
-    # generate modbus warnings.
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_controller
-              data: !lambda return data;
-  - id: virtual_uart_controller
-    baud_rate: 9600
-    auto_start: true # See comment on virtual_uart_server above
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_server
-              data: !lambda return data;
-
-globals:
-  - id: stored_u_word
-    type: uint16_t
-    initial_value: "11"
-  - id: stored_u_word_s
-    type: uint16_t
-    initial_value: "4660"
-  - id: stored_s_word
-    type: int16_t
-    initial_value: "-11"
-  - id: stored_s_word_s
-    type: int16_t
-    initial_value: "-2"
-  - id: stored_u_dword
-    type: uint32_t
-    initial_value: "1001"
-  - id: stored_s_dword
-    type: int32_t
-    initial_value: "-1001"
-  - id: stored_u_dword_r
-    type: uint32_t
-    initial_value: "3003"
-  - id: stored_s_dword_r
-    type: int32_t
-    initial_value: "-3003"
-  - id: stored_u_qword
-    type: uint64_t
-    initial_value: "5005"
-  - id: stored_s_qword
-    type: int64_t
-    initial_value: "-5005"
-  - id: stored_u_qword_r
-    type: uint64_t
-    initial_value: "7007"
-  - id: stored_s_qword_r
-    type: int64_t
-    initial_value: "-7007"
-  - id: stored_fp32
-    type: float
-    initial_value: "1.5"
-  - id: stored_fp32_r
-    type: float
-    initial_value: "2.5"
-
-modbus:
-  - uart_id: virtual_uart_server
-    id: virtual_modbus_server
-    role: server
-  - uart_id: virtual_uart_controller
-    id: virtual_modbus_controller
-    role: client
-    turnaround_time: 10ms
-
-modbus_controller:
-  - address: 1
-    modbus_id: virtual_modbus_controller
-    update_interval: 2s
-    id: modbus_controller_1
-
-modbus_server:
-  - address: 1
-    modbus_id: virtual_modbus_server
-    id: modbus_server_1
-    registers:
-      - address: 0x01
-        value_type: U_WORD
-        read_lambda: return id(stored_u_word);
-        write_lambda: id(stored_u_word) = x; return true;
-      - address: 0x02
-        value_type: U_WORD_S
-        read_lambda: return id(stored_u_word_s);
-        write_lambda: id(stored_u_word_s) = x; return true;
-      - address: 0x03
-        value_type: S_WORD
-        read_lambda: return id(stored_s_word);
-        write_lambda: id(stored_s_word) = x; return true;
-      - address: 0x04
-        value_type: S_WORD_S
-        read_lambda: return id(stored_s_word_s);
-        write_lambda: id(stored_s_word_s) = x; return true;
-      - address: 0x05
-        value_type: U_DWORD
-        read_lambda: return id(stored_u_dword);
-        write_lambda: id(stored_u_dword) = x; return true;
-      - address: 0x08
-        value_type: S_DWORD
-        read_lambda: return id(stored_s_dword);
-        write_lambda: id(stored_s_dword) = x; return true;
-      - address: 0x0B
-        value_type: U_DWORD_R
-        read_lambda: return id(stored_u_dword_r);
-        write_lambda: id(stored_u_dword_r) = x; return true;
-      - address: 0x0E
-        value_type: S_DWORD_R
-        read_lambda: return id(stored_s_dword_r);
-        write_lambda: id(stored_s_dword_r) = x; return true;
-      - address: 0x11
-        value_type: U_QWORD
-        read_lambda: return id(stored_u_qword);
-        write_lambda: id(stored_u_qword) = x; return true;
-      - address: 0x16
-        value_type: S_QWORD
-        read_lambda: return id(stored_s_qword);
-        write_lambda: id(stored_s_qword) = x; return true;
-      - address: 0x1B
-        value_type: U_QWORD_R
-        read_lambda: return id(stored_u_qword_r);
-        write_lambda: id(stored_u_qword_r) = x; return true;
-      - address: 0x20
-        value_type: S_QWORD_R
-        read_lambda: return id(stored_s_qword_r);
-        write_lambda: id(stored_s_qword_r) = x; return true;
-      - address: 0x25
-        value_type: FP32
-        read_lambda: return id(stored_fp32);
-        write_lambda: id(stored_fp32) = x; return true;
-      - address: 0x28
-        value_type: FP32_R
-        read_lambda: return id(stored_fp32_r);
-        write_lambda: id(stored_fp32_r) = x; return true;
-
-sensor:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_word"
-    address: 0x01
-    register_type: holding
-    value_type: U_WORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_word_s"
-    address: 0x02
-    register_type: holding
-    value_type: U_WORD_S
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_word"
-    address: 0x03
-    register_type: holding
-    value_type: S_WORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_word_s"
-    address: 0x04
-    register_type: holding
-    value_type: S_WORD_S
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_dword"
-    address: 0x05
-    register_type: holding
-    value_type: U_DWORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_dword"
-    address: 0x08
-    register_type: holding
-    value_type: S_DWORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_dword_r"
-    address: 0x0B
-    register_type: holding
-    value_type: U_DWORD_R
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_dword_r"
-    address: 0x0E
-    register_type: holding
-    value_type: S_DWORD_R
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_qword"
-    address: 0x11
-    register_type: holding
-    value_type: U_QWORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_qword"
-    address: 0x16
-    register_type: holding
-    value_type: S_QWORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_qword_r"
-    address: 0x1B
-    register_type: holding
-    value_type: U_QWORD_R
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_qword_r"
-    address: 0x20
-    register_type: holding
-    value_type: S_QWORD_R
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_fp32"
-    address: 0x25
-    register_type: holding
-    value_type: FP32
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_fp32_r"
-    address: 0x28
-    register_type: holding
-    value_type: FP32_R
-
-number:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_word"
-    address: 0x01
-    register_type: holding
-    value_type: U_WORD
-    min_value: 0
-    max_value: 65535
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_word_s"
-    address: 0x02
-    register_type: holding
-    value_type: U_WORD_S
-    min_value: 0
-    max_value: 65535
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_word"
-    address: 0x03
-    register_type: holding
-    value_type: S_WORD
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_word_s"
-    address: 0x04
-    register_type: holding
-    value_type: S_WORD_S
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_dword"
-    address: 0x05
-    register_type: holding
-    value_type: U_DWORD
-    min_value: 0
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_dword"
-    address: 0x08
-    register_type: holding
-    value_type: S_DWORD
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_dword_r"
-    address: 0x0B
-    register_type: holding
-    value_type: U_DWORD_R
-    min_value: 0
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_dword_r"
-    address: 0x0E
-    register_type: holding
-    value_type: S_DWORD_R
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_qword"
-    address: 0x11
-    register_type: holding
-    value_type: U_QWORD
-    min_value: 0
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_qword"
-    address: 0x16
-    register_type: holding
-    value_type: S_QWORD
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_qword_r"
-    address: 0x1B
-    register_type: holding
-    value_type: U_QWORD_R
-    min_value: 0
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_qword_r"
-    address: 0x20
-    register_type: holding
-    value_type: S_QWORD_R
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_fp32"
-    address: 0x25
-    register_type: holding
-    value_type: FP32
-    min_value: -16777215
-    max_value: 16777215
-    step: 0.01
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_fp32_r"
-    address: 0x28
-    register_type: holding
-    value_type: FP32_R
-    min_value: -16777215
-    max_value: 16777215
-    step: 0.01
-
-button:
-  - platform: template
-    name: "Start Scenario"
-    id: start_scenario_btn
-    # This test does not have anything to start (mock is autostart)

tests/integration/test_sensor_raw_state.py

@@ -0,0 +1,108 @@
+"""Integration tests for Sensor::get_raw_state().
+
+Raw state storage only exists when filters are compiled in (USE_SENSOR_FILTER).
+Without it, get_raw_state() returns state, so both build configurations are covered:
+one fixture with a filtered sensor and one with no filters at all.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import re
+
+from aioesphomeapi import APIClient, EntityInfo
+import pytest
+
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+NO_FILTER_PATTERN = re.compile(r"NO_FILTER: state=([\d.]+) raw_state=([\d.]+)")
+WITH_FILTER_PATTERN = re.compile(r"WITH_FILTER: state=([\d.]+) raw_state=([\d.]+)")
+
+
+async def _press_and_read(
+    client: APIClient,
+    entities: list[EntityInfo],
+    button_object_id: str,
+    future: asyncio.Future[tuple[float, float]],
+    label: str,
+) -> tuple[float, float]:
+    button = next(
+        (e for e in entities if button_object_id in e.object_id.lower()), None
+    )
+    assert button is not None, f"{button_object_id} not found"
+    client.button_command(button.key)
+    try:
+        return await asyncio.wait_for(future, timeout=5.0)
+    except TimeoutError:
+        pytest.fail(f"Timeout waiting for {label} log message")
+
+
+@pytest.mark.asyncio
+async def test_sensor_raw_state(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """With filters compiled in, raw state is stored separately from state."""
+    loop = asyncio.get_running_loop()
+    no_filter_future: asyncio.Future[tuple[float, float]] = loop.create_future()
+    with_filter_future: asyncio.Future[tuple[float, float]] = loop.create_future()
+
+    def check_output(line: str) -> None:
+        if not no_filter_future.done() and (match := NO_FILTER_PATTERN.search(line)):
+            no_filter_future.set_result((float(match.group(1)), float(match.group(2))))
+        if not with_filter_future.done() and (
+            match := WITH_FILTER_PATTERN.search(line)
+        ):
+            with_filter_future.set_result(
+                (float(match.group(1)), float(match.group(2)))
+            )
+
+    async with (
+        run_compiled(yaml_config, line_callback=check_output),
+        api_client_connected() as client,
+    ):
+        entities, _ = await client.list_entities_services()
+
+        state, raw_state = await _press_and_read(
+            client, entities, "test_no_filter_button", no_filter_future, "NO_FILTER"
+        )
+        assert state == 21.5
+        assert raw_state == 21.5
+
+        state, raw_state = await _press_and_read(
+            client,
+            entities,
+            "test_with_filter_button",
+            with_filter_future,
+            "WITH_FILTER",
+        )
+        assert state == 43.0
+        assert raw_state == 21.5
+
+
+@pytest.mark.asyncio
+async def test_sensor_raw_state_no_filter(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Without filters compiled in, get_raw_state() returns state."""
+    loop = asyncio.get_running_loop()
+    no_filter_future: asyncio.Future[tuple[float, float]] = loop.create_future()
+
+    def check_output(line: str) -> None:
+        if not no_filter_future.done() and (match := NO_FILTER_PATTERN.search(line)):
+            no_filter_future.set_result((float(match.group(1)), float(match.group(2))))
+
+    async with (
+        run_compiled(yaml_config, line_callback=check_output),
+        api_client_connected() as client,
+    ):
+        entities, _ = await client.list_entities_services()
+
+        state, raw_state = await _press_and_read(
+            client, entities, "test_no_filter_button", no_filter_future, "NO_FILTER"
+        )
+        assert state == 21.5
+        assert raw_state == 21.5

tests/integration/test_uart_mock_modbus.py

@@ -19,23 +19,40 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import Callable
-from dataclasses import dataclass
 
 from aioesphomeapi import ButtonInfo, NumberInfo, SwitchInfo, TextSensorState
 import pytest
 
-from .state_utils import SensorTracker, find_entity, wait_for_state
+from .state_utils import SensorTracker, find_entity, require_entity, wait_for_state
 from .types import APIClientConnectedFactory, RunCompiledFunction
 
 
-@dataclass
-class RegisterTestCase:
-    """Test parameters for a single modbus register write/read round-trip."""
+def _swap16(value: int) -> int:
+    """Byte-swapped view of a 16-bit register as the raw U_WORD wire value."""
+    return ((value & 0xFF) << 8) | (value >> 8)
 
-    initial_value: object
-    write_number_name: str
-    write_value: float
-    post_write_value: object
+
+# Raw U_WORD view of reg_u_word_s's initial 0x1234
+MESH_RAW_U_WORD_S = _swap16(4660)
+
+# Initial values of the mesh fixture's address 1 registers; the
+# server_controller test reads them and the write test uses them as baseline.
+MESH_INITIAL_VALUES: dict[str, object] = {
+    "reg_u_word": 99,
+    "reg_u_word_s": 4660,
+    "reg_s_word": -99,
+    "reg_s_word_s": -2,
+    "reg_u_dword": 16909060,
+    "reg_s_dword": -16909060,
+    "reg_u_dword_r": pytest.approx(67305985),
+    "reg_s_dword_r": pytest.approx(-67305985),
+    "reg_u_qword": pytest.approx(72623859790382856),
+    "reg_s_qword": pytest.approx(-72623859790382856),
+    "reg_u_qword_r": pytest.approx(578437695752307201),
+    "reg_s_qword_r": pytest.approx(-578437695752307201),
+    "reg_fp32": pytest.approx(3.14),
+    "reg_fp32_r": pytest.approx(2.5),
+}
 
 
 # ---------------------------------------------------------------------------
@@ -310,23 +327,7 @@ async def test_uart_mock_modbus_server_controller(
 
     line_callback, error_log_lines, warning_log_lines = _make_modbus_line_callback()
 
-    expected_values = {
-        "reg_u_word": 99,
-        "reg_u_word_s": 4660,
-        "reg_u_word_s_raw": 13330,
-        "reg_s_word": -99,
-        "reg_s_word_s": -2,
-        "reg_u_dword": 16909060,
-        "reg_s_dword": -16909060,
-        "reg_u_dword_r": pytest.approx(67305985),
-        "reg_s_dword_r": pytest.approx(-67305985),
-        "reg_u_qword": pytest.approx(72623859790382856),
-        "reg_s_qword": pytest.approx(-72623859790382856),
-        "reg_u_qword_r": pytest.approx(578437695752307201),
-        "reg_s_qword_r": pytest.approx(-578437695752307201),
-        "reg_fp32": pytest.approx(3.14),
-        "reg_fp32_r": pytest.approx(3.14),
-    }
+    expected_values = MESH_INITIAL_VALUES | {"reg_u_word_s_raw": MESH_RAW_U_WORD_S}
     tracker = SensorTracker(list(expected_values.keys()))
     futures = tracker.expect_all(expected_values)
 
@@ -334,14 +335,12 @@ async def test_uart_mock_modbus_server_controller(
         run_compiled(yaml_config, line_callback=line_callback),
         api_client_connected() as client,
     ):
-        # The controller polls from boot, so the first values can already be in
-        # the states the device sends on connect; matching them there saves
-        # waiting for the next poll
         await tracker.setup_and_start_scenario(client, match_initial_states=True)
         await tracker.await_all(futures)
         _assert_no_modbus_errors(error_log_lines, warning_log_lines)
 
 
+@pytest.mark.shared_yaml("uart_mock_modbus_mesh")
 @pytest.mark.asyncio
 async def test_uart_mock_modbus_server_controller_write(
     yaml_config: str,
@@ -357,51 +356,47 @@ async def test_uart_mock_modbus_server_controller_write(
 
     line_callback, error_log_lines, warning_log_lines = _make_modbus_line_callback()
 
-    register_test_cases: dict[str, RegisterTestCase] = {
-        "reg_u_word": RegisterTestCase(11, "write_u_word", 42, 42),
-        "reg_u_word_s": RegisterTestCase(4660, "write_u_word_s", 17185, 17185),
-        "reg_s_word": RegisterTestCase(-11, "write_s_word", -42, -42),
-        "reg_s_word_s": RegisterTestCase(-2, "write_s_word_s", -257, -257),
-        "reg_u_dword": RegisterTestCase(1001, "write_u_dword", 2002, 2002),
-        "reg_s_dword": RegisterTestCase(-1001, "write_s_dword", -2002, -2002),
-        "reg_u_dword_r": RegisterTestCase(3003, "write_u_dword_r", 4004, 4004),
-        "reg_s_dword_r": RegisterTestCase(-3003, "write_s_dword_r", -4004, -4004),
-        "reg_u_qword": RegisterTestCase(5005, "write_u_qword", 6006, 6006),
-        "reg_s_qword": RegisterTestCase(-5005, "write_s_qword", -6006, -6006),
-        "reg_u_qword_r": RegisterTestCase(7007, "write_u_qword_r", 8008, 8008),
-        "reg_s_qword_r": RegisterTestCase(-7007, "write_s_qword_r", -8008, -8008),
-        "reg_fp32": RegisterTestCase(
-            pytest.approx(1.5, abs=0.01),
-            "write_fp32",
-            3.14,
-            pytest.approx(3.14, abs=0.01),
-        ),
-        "reg_fp32_r": RegisterTestCase(
-            pytest.approx(2.5, abs=0.01),
-            "write_fp32_r",
-            6.28,
-            pytest.approx(6.28, abs=0.01),
-        ),
+    # Per read-back sensor: the number entity to write through and the value;
+    # floats read back within tolerance, everything else exactly
+    register_writes: dict[str, tuple[str, int | float]] = {
+        "reg_u_word": ("write_u_word", 42),
+        "reg_u_word_s": ("write_u_word_s", 17185),
+        "reg_s_word": ("write_s_word", -42),
+        "reg_s_word_s": ("write_s_word_s", -257),
+        "reg_u_dword": ("write_u_dword", 2002),
+        "reg_s_dword": ("write_s_dword", -2002),
+        "reg_u_dword_r": ("write_u_dword_r", 4004),
+        "reg_s_dword_r": ("write_s_dword_r", -4004),
+        "reg_u_qword": ("write_u_qword", 6006),
+        "reg_s_qword": ("write_s_qword", -6006),
+        "reg_u_qword_r": ("write_u_qword_r", 8008),
+        "reg_s_qword_r": ("write_s_qword_r", -8008),
+        "reg_fp32": ("write_fp32", 6.28),
+        "reg_fp32_r": ("write_fp32_r", 9.42),
     }
 
-    tracker = SensorTracker(list(register_test_cases.keys()))
+    tracker = SensorTracker([*register_writes, "reg_u_word_s_raw"])
 
+    # The raw U_WORD view of 0x02 pins the byte swap on the write path: the
+    # round trip through write_u_word_s applies the swap an even number of
+    # times, so only the raw sensor can catch a symmetrically dropped swap.
     # Phase 1: expect initial baseline values
     initial_futures = tracker.expect_all(
-        {name: case.initial_value for name, case in register_test_cases.items()}
+        MESH_INITIAL_VALUES | {"reg_u_word_s_raw": MESH_RAW_U_WORD_S}
     )
     # Phase 2: expect post-write values (registered now so on_state can match them)
     written_futures = tracker.expect_all(
-        {name: case.post_write_value for name, case in register_test_cases.items()}
+        {
+            name: pytest.approx(value, abs=0.01) if isinstance(value, float) else value
+            for name, (_, value) in register_writes.items()
+        }
+        | {"reg_u_word_s_raw": _swap16(register_writes["reg_u_word_s"][1])}
     )
 
     async with (
         run_compiled(yaml_config, line_callback=line_callback),
         api_client_connected() as client,
     ):
-        # The controller polls from boot, so the baseline can already be in the
-        # states the device sends on connect; matching it there saves waiting for
-        # the next poll
         entities = await tracker.setup_and_start_scenario(
             client, match_initial_states=True
         )
@@ -410,19 +405,22 @@ async def test_uart_mock_modbus_server_controller_write(
         # connection is working before issuing writes
         await tracker.await_all(initial_futures, timeout=4.0)
 
-        # Issue write commands for all register types
-        for case in register_test_cases.values():
-            entity = find_entity(entities, case.write_number_name, NumberInfo)
-            assert entity is not None, (
-                f"{case.write_number_name} number entity not found"
-            )
-            client.number_command(entity.key, case.write_value)
+        # Issue write commands for all register types; exact object_id match,
+        # since several write_* names are prefixes of a sibling
+        numbers = {
+            e.object_id.lower(): e for e in entities if isinstance(e, NumberInfo)
+        }
+        for number_name, value in register_writes.values():
+            entity = numbers.get(number_name)
+            assert entity is not None, f"{number_name} number entity not found"
+            client.number_command(entity.key, value)
 
         # Wait for sensors to reflect the written values (round-trip write+read)
         await tracker.await_all(written_futures, timeout=4.0)
         _assert_no_modbus_errors(error_log_lines, warning_log_lines)
 
 
+@pytest.mark.shared_yaml("uart_mock_modbus_mesh")
 @pytest.mark.asyncio
 async def test_uart_mock_modbus_server_controller_bits(
     yaml_config: str,
@@ -468,8 +466,6 @@ async def test_uart_mock_modbus_server_controller_bits(
         run_compiled(yaml_config, line_callback=line_callback),
         api_client_connected() as client,
     ):
-        # The controller polls from boot and binary sensors drop repeats, so the
-        # baseline can arrive only in the states the device sends on connect
         entities = await tracker.setup_and_start_scenario(
             client, match_initial_states=True
         )
@@ -480,8 +476,7 @@ async def test_uart_mock_modbus_server_controller_bits(
 
         # Flip both writable bits: 0x02 false -> true, 0x03 true -> false
         for switch_name, value in (("write_bit_2", True), ("write_bit_3", False)):
-            entity = find_entity(entities, switch_name, SwitchInfo)
-            assert entity is not None, f"{switch_name} switch entity not found"
+            entity = require_entity(entities, switch_name, SwitchInfo)
             client.switch_command(entity.key, value)
 
         # Wait for both read views to reflect the written values
@@ -508,9 +503,6 @@ async def test_uart_mock_modbus_server_controller_multiple(
         run_compiled(yaml_config, line_callback=line_callback),
         api_client_connected() as client,
     ):
-        # The controller polls from boot, so the first values can already be in
-        # the states the device sends on connect; matching them there saves
-        # waiting for the next poll
         await tracker.setup_and_start_scenario(client, match_initial_states=True)
         await tracker.await_all(futures)
         _assert_no_modbus_errors(error_log_lines, warning_log_lines)

tests/unit_tests/build_gen/test_espidf.py

@@ -163,6 +163,18 @@ def test_has_discovered_components_after_configure(tmp_path: Path) -> None:
     assert has_discovered_components()
 
 
+def test_get_project_cmakelists_size_command_uses_json2() -> None:
+    """The POST_BUILD size command uses the cheap json2 format, with --ng
+    only on the 1.x tool bundled with IDF < 6."""
+    content = _render()
+    assert "-m esp_idf_size --ng --format=json2" in content
+
+    CORE.data[KEY_ESP32][KEY_IDF_VERSION] = cv.Version(6, 0, 0)
+    content = _render()
+    assert "--ng" not in content
+    assert "--format=json2" in content
+
+
 def test_get_project_cmakelists_uses_supplied_builtin_components() -> None:
     """A cached list replaces project_description.json and is still filtered
     by EXCLUDE_COMPONENTS."""

tests/unit_tests/test_espidf_toolchain.py

@@ -638,6 +638,43 @@ def test_run_compile_passes_compile_process_limit(setup_core: Path) -> None:
     mock_run.assert_called_once_with("build", "size", jobs=1)
 
 
+def test_run_compile_passes_size_summary_paths(setup_core: Path) -> None:
+    """print_summary receives the size json, partitions.csv, and the built
+    ELF from get_built_elf_path, which must stay in lockstep with the
+    project() name in the generated CMakeLists."""
+    _setup_build(setup_core)
+    config = {CONF_ESPHOME: {}}
+
+    with (
+        patch.object(toolchain, "need_reconfigure", return_value=False),
+        patch.object(toolchain, "run_idf_py", return_value=0),
+        patch.object(toolchain, "print_summary") as mock_summary,
+    ):
+        assert toolchain.run_compile(config, verbose=False) == 0
+
+    mock_summary.assert_called_once_with(
+        CORE.relative_build_path("build", "esp_idf_size.json"),
+        CORE.relative_build_path("partitions.csv"),
+        CORE.relative_build_path("build", f"{CORE.name}.elf"),
+    )
+
+
+def test_create_elf_copy(setup_core: Path) -> None:
+    """The built <name>.elf is copied to the firmware.elf dashboard name."""
+    _setup_build(setup_core)
+    src = toolchain.get_built_elf_path()
+    src.parent.mkdir(parents=True, exist_ok=True)
+    src.write_bytes(b"elf")
+    assert toolchain.create_elf_copy() is True
+    assert toolchain.get_elf_path().read_bytes() == b"elf"
+
+
+def test_create_elf_copy_missing_source(setup_core: Path) -> None:
+    """A missing built ELF is a warning and False, not a crash."""
+    _setup_build(setup_core)
+    assert toolchain.create_elf_copy() is False
+
+
 def test_run_compile_without_compile_process_limit(setup_core: Path) -> None:
     """When no compile_process_limit is set, no job limit is passed to idf.py."""
     _setup_build(setup_core)

tests/unit_tests/test_size_summary.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
+import struct
+from unittest.mock import patch
 
 import pytest
 
@@ -17,64 +19,106 @@ def _write_size_json(tmp_path: Path, data: dict) -> Path:
     return out
 
 
+def _write_partitions(tmp_path: Path) -> Path:
+    """Drop a partitions.csv with a 0x1C0000 (1835008 byte) app slot."""
+    out = tmp_path / "partitions.csv"
+    out.write_text(
+        "# name, type, subtype, offset, size, flags\n"
+        "app0, app, ota_0, 0x10000, 0x1C0000,\n"
+    )
+    return out
+
+
+def _elf_bytes(sections: list[tuple[int, int, int]], shentsize: int = 40) -> bytes:
+    """Build a minimal ELF32 LE whose section headers carry the given
+    (sh_type, sh_flags, sh_size) triples."""
+    out = bytearray(52)
+    out[0:4] = b"\x7fELF"
+    out[4] = out[5] = 1  # 32-bit, little-endian
+    struct.pack_into("<I", out, 0x20, 52)  # e_shoff
+    struct.pack_into("<HH", out, 0x2E, shentsize, len(sections))
+    for sh_type, sh_flags, sh_size in sections:
+        shdr = bytearray(40)
+        struct.pack_into("<II", shdr, 4, sh_type, sh_flags)
+        struct.pack_into("<I", shdr, 20, sh_size)
+        out += shdr
+    return bytes(out)
+
+
 def _esp32_size_data() -> dict:
-    """Synthetic esp_idf_size.json for the original ESP32 (split IRAM/DRAM)."""
+    """Synthetic json2 for the original ESP32 (split IRAM/DRAM), in the
+    esp-idf-size >= 2.1 shape that carries ``total_size``."""
     return {
-        "image_size": 827455,
-        "memory_types": {
-            "DRAM": {
-                "size": 180736,
+        "version": "1.1",
+        "total_size": 827455,
+        "layout": [
+            {
+                "name": "DRAM",
+                "total": 180736,
                 "used": 47332,
-                "sections": {
-                    ".dram0.bss": {"abbrev_name": ".bss", "size": 30616},
-                    ".dram0.data": {"abbrev_name": ".data", "size": 16716},
+                "free": 133404,
+                "parts": {
+                    ".bss": {"size": 30616},
+                    ".data": {"size": 16716},
                 },
             },
-            "IRAM": {
-                "size": 131072,
+            {
+                "name": "IRAM",
+                "total": 131072,
                 "used": 80351,
-                "sections": {
-                    ".iram0.text": {"abbrev_name": ".text", "size": 79323},
-                    ".iram0.vectors": {"abbrev_name": ".vectors", "size": 1028},
+                "free": 50721,
+                "parts": {
+                    ".text": {"size": 79323},
+                    ".vectors": {"size": 1028},
                 },
             },
-        },
+        ],
     }
 
 
 def _s3_size_data() -> dict:
-    """Synthetic esp_idf_size.json for ESP32-S3 (unified DIRAM)."""
+    """Synthetic json2 for ESP32-S3 (unified DIRAM), in the esp-idf-size 1.x
+    shape without ``total_size``."""
     return {
-        "image_size": 724215,
-        "memory_types": {
-            "DIRAM": {
-                "size": 341760,
+        "version": "1.1",
+        "layout": [
+            {
+                "name": "DIRAM",
+                "total": 341760,
                 "used": 104999,
-                "sections": {
-                    ".iram0.text": {"abbrev_name": ".text", "size": 58051},
-                    ".dram0.bss": {"abbrev_name": ".bss", "size": 27088},
-                    ".dram0.data": {"abbrev_name": ".data", "size": 19708},
-                    ".noinit": {"abbrev_name": ".noinit", "size": 152},
+                "free": 236761,
+                "parts": {
+                    ".text": {"size": 58051},
+                    ".bss": {"size": 27088},
+                    ".data": {"size": 19708},
+                    ".noinit": {"size": 152},
                 },
             },
-            "IRAM": {
-                "size": 16384,
+            {
+                "name": "IRAM",
+                "total": 16384,
                 "used": 16384,
-                "sections": {
-                    ".iram0.text": {"abbrev_name": ".text", "size": 15356},
-                    ".iram0.vectors": {"abbrev_name": ".vectors", "size": 1028},
+                "free": 0,
+                "parts": {
+                    ".text": {"size": 15356},
+                    ".vectors": {"size": 1028},
                 },
             },
-        },
+        ],
     }
 
 
+def _print_summary_ram_only(tmp_path: Path, size_json: Path) -> None:
+    """Call print_summary with no partitions.csv or ELF on disk."""
+    print_summary(size_json, tmp_path / "partitions.csv", tmp_path / "firmware.elf")
+
+
 def test_print_summary_esp32_uses_dram(
     tmp_path: Path, capsys: pytest.CaptureFixture[str]
 ) -> None:
-    """Original ESP32: DRAM has no ``.text``, so RAM = DRAM.used / DRAM.size unchanged."""
+    """Original ESP32: RAM = DRAM.used / DRAM.total."""
     size_json = _write_size_json(tmp_path, _esp32_size_data())
-    print_summary(size_json, partitions_csv=None)
+    _print_summary_ram_only(tmp_path, size_json)
     out = capsys.readouterr().out
     assert "RAM:" in out
     assert "used 47332 bytes from 180736 bytes" in out
@@ -83,63 +127,193 @@ def test_print_summary_esp32_uses_dram(
 def test_print_summary_s3_falls_back_to_diram(
     tmp_path: Path, capsys: pytest.CaptureFixture[str]
 ) -> None:
-    """ESP32-S3 with no DRAM key falls back to DIRAM and reports raw region usage."""
+    """ESP32-S3 with no DRAM entry falls back to DIRAM and reports raw region usage."""
     size_json = _write_size_json(tmp_path, _s3_size_data())
-    print_summary(size_json, partitions_csv=None)
+    _print_summary_ram_only(tmp_path, size_json)
     out = capsys.readouterr().out
     assert "used 104999 bytes from 341760 bytes" in out
 
 
 def test_print_summary_skips_when_diram_total_collapses(
-    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+    caplog: pytest.LogCaptureFixture,
 ) -> None:
     """A zero-size region drops the RAM line rather than divide by zero."""
     size_json = _write_size_json(
         tmp_path,
         {
-            "memory_types": {
-                "DIRAM": {
-                    "size": 0,
-                    "used": 0,
-                    "sections": {},
-                },
-            },
+            "version": "1.1",
+            "layout": [{"name": "DIRAM", "total": 0, "used": 0}],
         },
     )
-    print_summary(size_json, partitions_csv=None)
+    _print_summary_ram_only(tmp_path, size_json)
     out = capsys.readouterr().out
     assert "RAM:" not in out
+    assert "unusable region" in caplog.text
 
 
 def test_print_summary_handles_missing_json(
     tmp_path: Path, capsys: pytest.CaptureFixture[str]
 ) -> None:
     """Missing size json is non-fatal and prints nothing."""
-    print_summary(tmp_path / "does_not_exist.json", partitions_csv=None)
+    _print_summary_ram_only(tmp_path, tmp_path / "does_not_exist.json")
     assert capsys.readouterr().out == ""
 
 
-def test_print_summary_handles_no_memory_types(
-    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+def test_print_summary_handles_no_layout(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+    caplog: pytest.LogCaptureFixture,
 ) -> None:
-    """A size json without ``memory_types`` still doesn't crash."""
-    size_json = _write_size_json(tmp_path, {"image_size": 0})
-    print_summary(size_json, partitions_csv=None)
+    """A size json without ``layout`` warns so schema drift is visible."""
+    size_json = _write_size_json(tmp_path, {"version": "1.1"})
+    _print_summary_ram_only(tmp_path, size_json)
     assert capsys.readouterr().out == ""
-
-
-def test_print_summary_flash_line(
-    tmp_path: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    """A partition table with an app row yields the Flash line in the exact
-    padded shape script/ci_memory_impact_extract.py greps."""
-    size_json = _write_size_json(tmp_path, _esp32_size_data())
-    partitions = tmp_path / "partitions.csv"
-    partitions.write_text(
-        "# name, type, subtype, offset, size, flags\n"
-        "app0, app, ota_0, 0x10000, 0x1C0000,\n"
+    assert any(
+        r.levelname == "WARNING" and "no DRAM/DIRAM region" in r.message
+        for r in caplog.records
     )
-    print_summary(size_json, partitions)
+
+
+def test_print_summary_flash_line_prefers_total_size(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """With ``total_size`` in the json, that figure wins without reading the
+    ELF, in the exact shape script/ci_memory_impact_extract.py greps."""
+    size_json = _write_size_json(tmp_path, _esp32_size_data())
+    partitions = _write_partitions(tmp_path)
+    print_summary(size_json, partitions, tmp_path / "firmware.elf")
     out = capsys.readouterr().out
     assert "Flash: " in out
     assert "(used 827455 bytes from 1835008 bytes)" in out
+
+
+def test_print_summary_flash_line_derives_from_elf(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A 1.x json without ``total_size`` sums the ELF's loadable PROGBITS
+    sections; NOBITS and non-alloc sections are excluded."""
+    size_json = _write_size_json(tmp_path, _s3_size_data())
+    partitions = _write_partitions(tmp_path)
+    firmware_elf = tmp_path / "firmware.elf"
+    firmware_elf.write_bytes(
+        _elf_bytes(
+            [
+                (1, 0x6, 700000),  # PROGBITS, alloc+exec: counted
+                (1, 0x2, 24215),  # PROGBITS, alloc: counted
+                (8, 0x2, 50000),  # NOBITS (.bss): excluded
+                (1, 0x0, 12345),  # PROGBITS, no alloc (.debug_*): excluded
+            ]
+        )
+    )
+    print_summary(size_json, partitions, firmware_elf)
+    out = capsys.readouterr().out
+    assert "(used 724215 bytes from 1835008 bytes)" in out
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        pytest.param([1, 2], id="top_level_list"),
+        pytest.param({"version": "1.1", "layout": None}, id="layout_null"),
+        pytest.param({"version": "1.1", "layout": 7}, id="layout_scalar"),
+    ],
+)
+def test_print_summary_handles_unexpected_shapes(
+    data: object, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A foreign-schema size json degrades to a warning, never a traceback."""
+    size_json = _write_size_json(tmp_path, data)
+    _print_summary_ram_only(tmp_path, size_json)
+    assert capsys.readouterr().out == ""
+
+
+def test_print_summary_skips_flash_on_zero_app_partition(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A zero-size app partition skips the Flash line rather than printing
+    a from-0-bytes figure CI would record."""
+    size_json = _write_size_json(tmp_path, _esp32_size_data())
+    partitions = tmp_path / "partitions.csv"
+    partitions.write_text(
+        "# name, type, subtype, offset, size, flags\napp0, app, ota_0, 0x10000, 0x0,\n"
+    )
+    print_summary(size_json, partitions, tmp_path / "firmware.elf")
+    out = capsys.readouterr().out
+    assert "Flash:" not in out
+
+
+def test_print_summary_skips_flash_on_unreadable_partitions(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """An unreadable partitions.csv is non-fatal (chmod tricks don't work
+    for root in CI containers, so simulate the OSError instead)."""
+    size_json = _write_size_json(tmp_path, _esp32_size_data())
+    partitions = _write_partitions(tmp_path)
+    with patch(
+        "esphome.espidf.size_summary._find_app_partition_size",
+        side_effect=PermissionError("denied"),
+    ):
+        print_summary(size_json, partitions, tmp_path / "firmware.elf")
+    assert "Flash:" not in capsys.readouterr().out
+
+
+def test_print_summary_flash_falls_back_on_bad_total_size(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A zero or non-int total_size falls back to the ELF instead of
+    printing a used-0-bytes line CI would read as a real measurement."""
+    data = _s3_size_data()
+    data["total_size"] = 0
+    size_json = _write_size_json(tmp_path, data)
+    partitions = _write_partitions(tmp_path)
+    firmware_elf = tmp_path / "firmware.elf"
+    firmware_elf.write_bytes(_elf_bytes([(1, 0x2, 4096)]))
+    print_summary(size_json, partitions, firmware_elf)
+    out = capsys.readouterr().out
+    assert "(used 4096 bytes from 1835008 bytes)" in out
+
+
+_GOOD_ELF = _elf_bytes([(1, 0x2, 1024)])
+
+
+@pytest.mark.parametrize(
+    ("elf_bytes", "with_partitions"),
+    [
+        pytest.param(None, True, id="missing_elf"),
+        pytest.param(b"junk", True, id="not_an_elf"),
+        pytest.param(
+            _elf_bytes([(1, 0x2, 1024)], shentsize=0), True, id="bad_shentsize"
+        ),
+        pytest.param(_GOOD_ELF[:60], True, id="truncated_table"),
+        pytest.param(_elf_bytes([]), True, id="no_sections"),
+        pytest.param(_elf_bytes([(8, 0x2, 50000)]), True, id="no_progbits"),
+        pytest.param(_GOOD_ELF, False, id="missing_partitions"),
+    ],
+)
+def test_print_summary_skips_flash_on_bad_input(
+    elf_bytes: bytes | None,
+    with_partitions: bool,
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """An unusable ELF or missing partitions.csv skips the Flash line, not the RAM line."""
+    size_json = _write_size_json(tmp_path, _s3_size_data())
+    firmware_elf = tmp_path / "firmware.elf"
+    if elf_bytes is not None:
+        firmware_elf.write_bytes(elf_bytes)
+    if with_partitions:
+        _write_partitions(tmp_path)
+    print_summary(size_json, tmp_path / "partitions.csv", firmware_elf)
+    out = capsys.readouterr().out
+    assert "RAM:" in out
+    assert "Flash:" not in out
+    # ELF problems warn (anomaly after a successful build); a missing
+    # partitions.csv stays at debug
+    warned = any(
+        r.levelname == "WARNING" and "Skipping Flash summary" in r.message
+        for r in caplog.records
+    )
+    assert warned == with_partitions