update tests

tests/component_tests/text/test_text.py

@@ -58,7 +58,7 @@ def test_text_config_value_mode_set(generate_main):
 
 def test_text_config_lamda_is_set(generate_main):
     """
-    Test if lambda is set for lambda mode
+    Test if lambda is set for lambda mode (optimized with stateless lambda)
     """
     # Given
 
@@ -66,5 +66,5 @@ def test_text_config_lamda_is_set(generate_main):
     main_cpp = generate_main("tests/component_tests/text/test_text.yaml")
 
     # Then
-    assert "it_4->set_template([=]() -> esphome::optional<std::string> {" in main_cpp
+    assert "it_4->set_template([]() -> esphome::optional<std::string> {" in main_cpp
     assert 'return std::string{"Hello"};' in main_cpp

tests/unit_tests/test_cpp_generator.py

@@ -173,6 +173,61 @@ class TestLambdaExpression:
             "}"
         )
 
+    def test_str__stateless_no_return(self):
+        """Test stateless lambda (empty capture) generates correctly"""
+        target = cg.LambdaExpression(
+            ('ESP_LOGD("main", "Test message");',),
+            (),  # No parameters
+            "",  # Empty capture (stateless)
+        )
+
+        actual = str(target)
+
+        assert actual == ('[]() {\n  ESP_LOGD("main", "Test message");\n}')
+
+    def test_str__stateless_with_return(self):
+        """Test stateless lambda with return type generates correctly"""
+        target = cg.LambdaExpression(
+            ("return global_value > 0;",),
+            (),  # No parameters
+            "",  # Empty capture (stateless)
+            bool,  # Return type
+        )
+
+        actual = str(target)
+
+        assert actual == ("[]() -> bool {\n  return global_value > 0;\n}")
+
+    def test_str__stateless_with_params(self):
+        """Test stateless lambda with parameters generates correctly"""
+        target = cg.LambdaExpression(
+            ("return foo + bar;",),
+            ((int, "foo"), (float, "bar")),
+            "",  # Empty capture (stateless)
+            float,
+        )
+
+        actual = str(target)
+
+        assert actual == (
+            "[](int32_t foo, float bar) -> float {\n  return foo + bar;\n}"
+        )
+
+    def test_str__with_capture(self):
+        """Test lambda with capture generates correctly"""
+        target = cg.LambdaExpression(
+            ("return captured_var + x;",),
+            ((int, "x"),),
+            "captured_var",  # Has capture (not stateless)
+            int,
+        )
+
+        actual = str(target)
+
+        assert actual == (
+            "[captured_var](int32_t x) -> int32_t {\n  return captured_var + x;\n}"
+        )
+
 
 class TestLiterals:
     @pytest.mark.parametrize(