Merge branch 'dev' into feature/ethernet-automations

tests/components/ch423/common.yaml

@@ -0,0 +1,36 @@
+ch423:
+  - id: ch423_hub
+    i2c_id: i2c_bus
+
+binary_sensor:
+  - platform: gpio
+    id: ch423_input
+    name: CH423 Binary Sensor
+    pin:
+      ch423: ch423_hub
+      number: 1
+      mode: INPUT
+      inverted: true
+  - platform: gpio
+    id: ch423_input_2
+    name: CH423 Binary Sensor 2
+    pin:
+      ch423: ch423_hub
+      number: 0
+      mode: INPUT
+      inverted: false
+output:
+  - platform: gpio
+    id: ch423_out_11
+    pin:
+      ch423: ch423_hub
+      number: 11
+      mode: OUTPUT_OPEN_DRAIN
+      inverted: true
+  - platform: gpio
+    id: ch423_out_23
+    pin:
+      ch423: ch423_hub
+      number: 23
+      mode: OUTPUT_OPEN_DRAIN
+      inverted: false

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

@@ -0,0 +1,4 @@
+packages:
+  i2c: !include ../../test_build_components/common/i2c/esp32-idf.yaml
+
+<<: !include common.yaml

tests/components/ch423/test.esp8266-ard.yaml

@@ -0,0 +1,4 @@
+packages:
+  i2c: !include ../../test_build_components/common/i2c/esp8266-ard.yaml
+
+<<: !include common.yaml

tests/components/ch423/test.rp2040-ard.yaml

@@ -0,0 +1,4 @@
+packages:
+  i2c: !include ../../test_build_components/common/i2c/rp2040-ard.yaml
+
+<<: !include common.yaml

tests/components/dlms_meter/common-generic.yaml

@@ -0,0 +1,11 @@
+dlms_meter:
+  decryption_key: "36C66639E48A8CA4D6BC8B282A793BBB"   # change this to your decryption key!
+
+sensor:
+  - platform: dlms_meter
+    reactive_energy_plus:
+      name: "Reactive energy taken from grid"
+    reactive_energy_minus:
+      name: "Reactive energy put into grid"
+
+<<: !include common.yaml

tests/components/dlms_meter/common-netznoe.yaml

@@ -0,0 +1,17 @@
+dlms_meter:
+  decryption_key: "36C66639E48A8CA4D6BC8B282A793BBB"  # change this to your decryption key!
+  provider: netznoe                                   # (optional) key - only set if using evn
+
+sensor:
+  - platform: dlms_meter
+    # EVN
+    power_factor:
+      name: "Power Factor"
+
+text_sensor:
+  - platform: dlms_meter
+    # EVN
+    meternumber:
+      name: "meterNumber"
+
+<<: !include common.yaml

tests/components/dlms_meter/common.yaml

@@ -0,0 +1,27 @@
+sensor:
+  - platform: dlms_meter
+    voltage_l1:
+      name: "Voltage L1"
+    voltage_l2:
+      name: "Voltage L2"
+    voltage_l3:
+      name: "Voltage L3"
+    current_l1:
+      name: "Current L1"
+    current_l2:
+      name: "Current L2"
+    current_l3:
+      name: "Current L3"
+    active_power_plus:
+      name: "Active power taken from grid"
+    active_power_minus:
+      name: "Active power put into grid"
+    active_energy_plus:
+      name: "Active energy taken from grid"
+    active_energy_minus:
+      name: "Active energy put into grid"
+
+text_sensor:
+  - platform: dlms_meter
+    timestamp:
+      name: "timestamp"

tests/components/dlms_meter/test.esp32-ard.yaml

@@ -0,0 +1,4 @@
+packages:
+  uart: !include ../../test_build_components/common/uart_2400/esp32-ard.yaml
+
+<<: !include common-generic.yaml

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

@@ -0,0 +1,4 @@
+packages:
+  uart: !include ../../test_build_components/common/uart_2400/esp32-idf.yaml
+
+<<: !include common-netznoe.yaml

tests/components/dlms_meter/test.esp8266-ard.yaml

@@ -0,0 +1,4 @@
+packages:
+  uart: !include ../../test_build_components/common/uart_2400/esp8266-ard.yaml
+
+<<: !include common-generic.yaml

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

@@ -8,6 +8,16 @@ esp32:
       enable_lwip_bridge_interface: true
       disable_libc_locks_in_iram: false  # Test explicit opt-out of RAM optimization
       use_full_certificate_bundle: false  # Test CMN bundle (default)
+      include_builtin_idf_components:
+        - freertos  # Test escape hatch (freertos is always included anyway)
+      disable_debug_stubs: true
+      disable_ocd_aware: true
+      disable_usb_serial_jtag_secondary: true
+      disable_dev_null_vfs: true
+      disable_mbedtls_peer_cert: true
+      disable_mbedtls_pkcs7: true
+      disable_regi2c_in_iram: true
+      disable_fatfs: true
 
 wifi:
   ssid: MySSID

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

@@ -10,6 +10,14 @@ esp32:
         ref: 2.7.0
     advanced:
       enable_idf_experimental_features: yes
+      disable_debug_stubs: true
+      disable_ocd_aware: true
+      disable_usb_serial_jtag_secondary: true
+      disable_dev_null_vfs: true
+      disable_mbedtls_peer_cert: true
+      disable_mbedtls_pkcs7: true
+      disable_regi2c_in_iram: true
+      disable_fatfs: true
 
 ota:
   platform: esphome

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

@@ -5,6 +5,14 @@ esp32:
     advanced:
       execute_from_psram: true
       disable_libc_locks_in_iram: true  # Test default RAM optimization enabled
+      disable_debug_stubs: true
+      disable_ocd_aware: true
+      disable_usb_serial_jtag_secondary: true
+      disable_dev_null_vfs: true
+      disable_mbedtls_peer_cert: true
+      disable_mbedtls_pkcs7: true
+      disable_regi2c_in_iram: true
+      disable_fatfs: true
 
 psram:
   mode: octal

tests/components/mipi_spi/test.esp8266-ard.yaml

@@ -0,0 +1,10 @@
+substitutions:
+  dc_pin: GPIO15
+  cs_pin: GPIO5
+  enable_pin: GPIO4
+  reset_pin: GPIO16
+
+packages:
+  spi: !include ../../test_build_components/common/spi/esp8266-ard.yaml
+
+<<: !include common.yaml

tests/components/pmsx003/common.yaml

@@ -8,11 +8,11 @@ sensor:
     pm_10_0:
       name: PM 10.0 Concentration
     pm_1_0_std:
-      name: PM 1.0 Standard Atmospher Concentration
+      name: PM 1.0 Standard Atmospheric Concentration
     pm_2_5_std:
-      name: PM 2.5 Standard Atmospher Concentration
+      name: PM 2.5 Standard Atmospheric Concentration
     pm_10_0_std:
-      name: PM 10.0 Standard Atmospher Concentration
+      name: PM 10.0 Standard Atmospheric Concentration
     pm_0_3um:
       name: Particulate Count >0.3um
     pm_0_5um:

tests/components/zigbee/common.yaml

@@ -6,8 +6,6 @@ binary_sensor:
     name: "Garage Door Open 2"
   - platform: template
     name: "Garage Door Open 3"
-  - platform: template
-    name: "Garage Door Open 4"
   - platform: template
     name: "Garage Door Internal"
     internal: True
@@ -44,3 +42,11 @@ switch:
   - platform: template
     name: "Template Switch"
     optimistic: true
+
+number:
+  - platform: template
+    name: "Template number"
+    optimistic: true
+    min_value: 2
+    max_value: 100
+    step: 1

tests/test_build_components/common/uart_2400/esp32-ard.yaml

@@ -0,0 +1,11 @@
+# Common UART configuration for ESP32 Arduino tests - 2400 baud
+
+substitutions:
+  tx_pin: GPIO17
+  rx_pin: GPIO16
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 2400

tests/test_build_components/common/uart_2400/esp32-idf.yaml

@@ -0,0 +1,11 @@
+# Common UART configuration for ESP32 IDF tests - 2400 baud
+
+substitutions:
+  tx_pin: GPIO17
+  rx_pin: GPIO16
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 2400

tests/test_build_components/common/uart_2400/esp8266-ard.yaml

@@ -0,0 +1,11 @@
+# Common UART configuration for ESP8266 Arduino tests - 2400 baud
+
+substitutions:
+  tx_pin: GPIO4
+  rx_pin: GPIO5
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 2400

tests/unit_tests/components/test_ch423.py

@@ -0,0 +1,58 @@
+"""Tests for ch423 component validation."""
+
+from unittest.mock import patch
+
+from esphome import config, yaml_util
+from esphome.core import CORE
+
+
+def test_ch423_mixed_gpio_modes_fails(tmp_path, capsys):
+    """Test that mixing input/output on GPIO pins 0-7 fails validation."""
+    test_file = tmp_path / "test.yaml"
+    test_file.write_text("""
+esphome:
+  name: test
+
+esp8266:
+  board: esp01_1m
+
+i2c:
+  sda: GPIO4
+  scl: GPIO5
+
+ch423:
+  - id: ch423_hub
+
+binary_sensor:
+  - platform: gpio
+    name: "CH423 Input 0"
+    pin:
+      ch423: ch423_hub
+      number: 0
+      mode: input
+
+switch:
+  - platform: gpio
+    name: "CH423 Output 1"
+    pin:
+      ch423: ch423_hub
+      number: 1
+      mode: output
+""")
+
+    parsed_yaml = yaml_util.load_yaml(test_file)
+
+    with (
+        patch.object(yaml_util, "load_yaml", return_value=parsed_yaml),
+        patch.object(CORE, "config_path", test_file),
+    ):
+        result = config.read_config({})
+
+    assert result is None, "Expected validation to fail with mixed GPIO modes"
+
+    # Check that the error message mentions the GPIO pin restriction
+    captured = capsys.readouterr()
+    assert (
+        "GPIO pins (0-7) must all be configured as input or all as output"
+        in captured.out
+    )

tests/unit_tests/test_cpp_generator.py

@@ -347,3 +347,280 @@ class TestMockObj:
         assert isinstance(actual, cg.MockObj)
         assert actual.base == "foo.eek"
         assert actual.op == "."
+
+
+class TestStatementFunction:
+    """Tests for the statement() function."""
+
+    def test_statement__expression_converted_to_statement(self):
+        """Test that expressions are converted to ExpressionStatement."""
+        expr = cg.RawExpression("foo()")
+        result = cg.statement(expr)
+
+        assert isinstance(result, cg.ExpressionStatement)
+        assert str(result) == "foo();"
+
+    def test_statement__statement_unchanged(self):
+        """Test that statements are returned unchanged."""
+        stmt = cg.RawStatement("foo()")
+        result = cg.statement(stmt)
+
+        assert result is stmt
+        assert str(result) == "foo()"
+
+    def test_statement__expression_statement_unchanged(self):
+        """Test that ExpressionStatement is returned unchanged."""
+        stmt = cg.ExpressionStatement(42)
+        result = cg.statement(stmt)
+
+        assert result is stmt
+        assert str(result) == "42;"
+
+    def test_statement__line_comment_unchanged(self):
+        """Test that LineComment is returned unchanged."""
+        stmt = cg.LineComment("This is a comment")
+        result = cg.statement(stmt)
+
+        assert result is stmt
+        assert str(result) == "// This is a comment"
+
+
+class TestLiteralFunction:
+    """Tests for the literal() function."""
+
+    def test_literal__creates_mockobj(self):
+        """Test that literal() creates a MockObj."""
+        result = cg.literal("MY_CONSTANT")
+
+        assert isinstance(result, cg.MockObj)
+        assert result.base == "MY_CONSTANT"
+        assert result.op == ""
+
+    def test_literal__string_representation(self):
+        """Test that literal names appear unquoted in generated code."""
+        result = cg.literal("nullptr")
+
+        assert str(result) == "nullptr"
+
+    def test_literal__can_be_used_in_expressions(self):
+        """Test that literals can be used as part of larger expressions."""
+        null_lit = cg.literal("nullptr")
+        expr = cg.CallExpression(cg.RawExpression("my_func"), null_lit)
+
+        assert str(expr) == "my_func(nullptr)"
+
+    def test_literal__common_cpp_literals(self):
+        """Test common C++ literal values."""
+        test_cases = [
+            ("nullptr", "nullptr"),
+            ("true", "true"),
+            ("false", "false"),
+            ("NULL", "NULL"),
+            ("NAN", "NAN"),
+        ]
+
+        for name, expected in test_cases:
+            result = cg.literal(name)
+            assert str(result) == expected
+
+
+class TestLambdaConstructor:
+    """Tests for the Lambda class constructor in core/__init__.py."""
+
+    def test_lambda__from_string(self):
+        """Test Lambda constructor with string argument."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + 1;")
+
+        assert lambda_obj.value == "return x + 1;"
+        assert str(lambda_obj) == "return x + 1;"
+
+    def test_lambda__from_expression(self):
+        """Test Lambda constructor with Expression argument."""
+        from esphome.core import Lambda
+
+        expr = cg.RawExpression("x + 1")
+        lambda_obj = Lambda(expr)
+
+        # Expression should be converted to statement (with semicolon)
+        assert lambda_obj.value == "x + 1;"
+
+    def test_lambda__from_lambda(self):
+        """Test Lambda constructor with another Lambda argument."""
+        from esphome.core import Lambda
+
+        original = Lambda("return x + 1;")
+        copy = Lambda(original)
+
+        assert copy.value == original.value
+        assert copy.value == "return x + 1;"
+
+    def test_lambda__parts_parsing(self):
+        """Test that Lambda correctly parses parts with id() references."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return id(my_sensor).state;")
+        parts = lambda_obj.parts
+
+        # Parts should be split by LAMBDA_PROG regex: text, id, op, text
+        assert len(parts) == 4
+        assert parts[0] == "return "
+        assert parts[1] == "my_sensor"
+        assert parts[2] == "."
+        assert parts[3] == "state;"
+
+    def test_lambda__requires_ids(self):
+        """Test that Lambda correctly extracts required IDs."""
+        from esphome.core import ID, Lambda
+
+        lambda_obj = Lambda("return id(sensor1).state + id(sensor2).value;")
+        ids = lambda_obj.requires_ids
+
+        assert len(ids) == 2
+        assert all(isinstance(id_obj, ID) for id_obj in ids)
+        assert ids[0].id == "sensor1"
+        assert ids[1].id == "sensor2"
+
+    def test_lambda__no_ids(self):
+        """Test Lambda with no id() references."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return 42;")
+        ids = lambda_obj.requires_ids
+
+        assert len(ids) == 0
+
+    def test_lambda__comment_removal(self):
+        """Test that comments are removed when parsing parts."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return id(sensor).state; // Get sensor state")
+        parts = lambda_obj.parts
+
+        # Comment should be replaced with space, not affect parsing
+        assert "my_sensor" not in str(parts)
+
+    def test_lambda__multiline_string(self):
+        """Test Lambda with multiline string."""
+        from esphome.core import Lambda
+
+        code = """if (id(sensor).state > 0) {
+  return true;
+}
+return false;"""
+        lambda_obj = Lambda(code)
+
+        assert lambda_obj.value == code
+        assert "sensor" in [id_obj.id for id_obj in lambda_obj.requires_ids]
+
+
+@pytest.mark.asyncio
+class TestProcessLambda:
+    """Tests for the process_lambda() async function."""
+
+    async def test_process_lambda__none_value(self):
+        """Test that None returns None."""
+        result = await cg.process_lambda(None, [])
+
+        assert result is None
+
+    async def test_process_lambda__with_expression(self):
+        """Test process_lambda with Expression argument."""
+
+        expr = cg.RawExpression("return x + 1")
+        result = await cg.process_lambda(expr, [(int, "x")])
+
+        assert isinstance(result, cg.LambdaExpression)
+        assert "x + 1" in str(result)
+
+    async def test_process_lambda__simple_lambda_no_ids(self):
+        """Test process_lambda with simple Lambda without id() references."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + 1;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")])
+
+        assert isinstance(result, cg.LambdaExpression)
+        # Should have parameter
+        lambda_str = str(result)
+        assert "int32_t x" in lambda_str
+        assert "return x + 1;" in lambda_str
+
+    async def test_process_lambda__with_return_type(self):
+        """Test process_lambda with return type specified."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x > 0;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")], return_type=bool)
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "-> bool" in lambda_str
+
+    async def test_process_lambda__with_capture(self):
+        """Test process_lambda with capture specified."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return captured + x;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")], capture="captured")
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "[captured]" in lambda_str
+
+    async def test_process_lambda__empty_capture(self):
+        """Test process_lambda with empty capture (stateless lambda)."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + 1;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")], capture="")
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "[]" in lambda_str
+
+    async def test_process_lambda__no_parameters(self):
+        """Test process_lambda with no parameters."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return 42;")
+        result = await cg.process_lambda(lambda_obj, [])
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        # Should have empty parameter list
+        assert "()" in lambda_str
+
+    async def test_process_lambda__multiple_parameters(self):
+        """Test process_lambda with multiple parameters."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + y + z;")
+        result = await cg.process_lambda(
+            lambda_obj, [(int, "x"), (float, "y"), (bool, "z")]
+        )
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "int32_t x" in lambda_str
+        assert "float y" in lambda_str
+        assert "bool z" in lambda_str
+
+    async def test_process_lambda__parameter_validation(self):
+        """Test that malformed parameters raise assertion error."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x;")
+
+        # Test invalid parameter format (not list of tuples)
+        with pytest.raises(AssertionError):
+            await cg.process_lambda(lambda_obj, "invalid")
+
+        # Test invalid tuple format (not 2-element tuples)
+        with pytest.raises(AssertionError):
+            await cg.process_lambda(lambda_obj, [(int, "x", "extra")])
+
+        # Test invalid tuple format (single element)
+        with pytest.raises(AssertionError):
+            await cg.process_lambda(lambda_obj, [(int,)])