Merge remote-tracking branch 'upstream/dev' into move_device_class_progmem

esphome/components/api/api_frame_helper_noise.cpp

@@ -269,7 +269,7 @@ APIError APINoiseFrameHelper::state_action_() {
   }
   if (state_ == State::SERVER_HELLO) {
     // send server hello
-    const std::string &name = App.get_name();
+    const auto &name = App.get_name();
     char mac[MAC_ADDRESS_BUFFER_SIZE];
     get_mac_address_into_buffer(mac);
 

esphome/components/e131/e131_addressable_light_effect.cpp

@@ -54,8 +54,10 @@ bool E131AddressableLightEffect::process_(int universe, const E131Packet &packet
 
   int32_t output_offset = (universe - first_universe_) * get_lights_per_universe();
   // limit amount of lights per universe and received
+  // packet.count is the number of DMX bytes including start code; divide by channels to get the number of lights
+  int lights_in_packet = (packet.count > 0) ? (packet.count - 1) / channels_ : 0;
   int output_end =
-      std::min(it->size(), std::min(output_offset + get_lights_per_universe(), output_offset + packet.count - 1));
+      std::min(it->size(), std::min(output_offset + get_lights_per_universe(), output_offset + lights_in_packet));
   auto *input_data = packet.values + 1;
 
   auto effect_name = get_name();

esphome/components/esp32/__init__.py

@@ -464,6 +464,8 @@ def only_on_variant(*, supported=None, unsupported=None, msg_prefix="This featur
         unsupported = [unsupported]
 
     def validator_(obj):
+        if not CORE.is_esp32:
+            raise cv.Invalid(f"{msg_prefix} is only available on ESP32")
         variant = get_esp32_variant()
         if supported is not None and variant not in supported:
             raise cv.Invalid(

esphome/components/esp32/gpio_esp32_p4.py

@@ -33,7 +33,7 @@ def esp32_p4_validate_supports(value):
     is_input = mode[CONF_INPUT]
 
     if num < 0 or num > 54:
-        raise cv.Invalid(f"Invalid pin number: {value} (must be 0-54)")
+        raise cv.Invalid(f"Invalid pin number: {num} (must be 0-54)")
     if is_input:
         # All ESP32 pins support input mode
         pass

esphome/components/esp32/gpio_esp32_s3.py

@@ -29,7 +29,7 @@ _LOGGER = logging.getLogger(__name__)
 
 def esp32_s3_validate_gpio_pin(value):
     if value < 0 or value > 48:
-        raise cv.Invalid(f"Invalid pin number: {value} (must be 0-46)")
+        raise cv.Invalid(f"Invalid pin number: {value} (must be 0-48)")
 
     if value in _ESP_32S3_SPI_PSRAM_PINS:
         raise cv.Invalid(
@@ -55,7 +55,7 @@ def esp32_s3_validate_supports(value):
     is_input = mode[CONF_INPUT]
 
     if num < 0 or num > 48:
-        raise cv.Invalid(f"Invalid pin number: {num} (must be 0-46)")
+        raise cv.Invalid(f"Invalid pin number: {num} (must be 0-48)")
     if is_input:
         # All ESP32 pins support input mode
         pass

esphome/components/esp32_ble/ble.cpp

@@ -273,7 +273,7 @@ bool ESP32BLE::ble_setup_() {
       device_name = this->name_;
     }
   } else {
-    const std::string &app_name = App.get_name();
+    const auto &app_name = App.get_name();
     size_t name_len = app_name.length();
     if (name_len > 20) {
       if (App.is_name_add_mac_suffix_enabled()) {

esphome/components/max6956/max6956.cpp

@@ -111,6 +111,8 @@ void MAX6956::write_brightness_mode() {
 }
 
 void MAX6956::set_pin_brightness(uint8_t pin, float brightness) {
+  if (pin < MAX6956_MIN || pin > MAX6956_MAX)
+    return;
   uint8_t reg_addr = MAX6956_CURRENT_START + (pin - MAX6956_MIN) / 2;
   uint8_t config = 0;
   uint8_t shift = 4 * (pin % 2);

esphome/components/mdns/mdns_component.cpp

@@ -59,7 +59,7 @@ void MDNSComponent::compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUN
     service.proto = MDNS_STR(SERVICE_TCP);
     service.port = api::global_api_server->get_port();
 
-    const std::string &friendly_name = App.get_friendly_name();
+    const auto &friendly_name = App.get_friendly_name();
     bool friendly_name_empty = friendly_name.empty();
 
     // Calculate exact capacity for txt_records

esphome/components/mipi_dsi/mipi_dsi.cpp

@@ -10,7 +10,7 @@ namespace mipi_dsi {
 static constexpr size_t MIPI_DSI_MAX_CMD_LOG_BYTES = 64;
 
 static bool notify_refresh_ready(esp_lcd_panel_handle_t panel, esp_lcd_dpi_panel_event_data_t *edata, void *user_ctx) {
-  auto *sem = static_cast<SemaphoreHandle_t *>(user_ctx);
+  auto sem = static_cast<SemaphoreHandle_t>(user_ctx);
   BaseType_t need_yield = pdFALSE;
   xSemaphoreGiveFromISR(sem, &need_yield);
   return (need_yield == pdTRUE);
@@ -190,6 +190,7 @@ void MIPI_DSI::draw_pixels_at(int x_start, int y_start, int w, int h, const uint
   if (bitness != this->color_depth_) {
     display::Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset,
                                      x_pad);
+    return;
   }
   this->write_to_display_(x_start, y_start, w, h, ptr, x_offset, y_offset, x_pad);
 }

esphome/components/mqtt/mqtt_component.cpp

@@ -272,7 +272,7 @@ bool MQTTComponent::send_discovery_() {
           root[MQTT_UNIQUE_ID] = unique_id_buf;
         }
 
-        const std::string &node_name = App.get_name();
+        const auto &node_name = App.get_name();
         if (discovery_info.object_id_generator == MQTT_DEVICE_NAME_OBJECT_ID_GENERATOR) {
           // node_name (max 31) + "_" (1) + object_id (max 128) + null
           char object_id_full[ESPHOME_DEVICE_NAME_MAX_LEN + 1 + OBJECT_ID_MAX_LEN + 1];
@@ -280,8 +280,8 @@ bool MQTTComponent::send_discovery_() {
           root[MQTT_OBJECT_ID] = object_id_full;
         }
 
-        const std::string &friendly_name_ref = App.get_friendly_name();
-        const std::string &node_friendly_name = friendly_name_ref.empty() ? node_name : friendly_name_ref;
+        const auto &friendly_name_ref = App.get_friendly_name();
+        const auto &node_friendly_name = friendly_name_ref.empty() ? node_name : friendly_name_ref;
         const char *node_area = App.get_area();
 
         JsonObject device_info = root[MQTT_DEVICE].to<JsonObject>();

esphome/components/openthread/openthread.cpp

@@ -132,7 +132,7 @@ void OpenThreadSrpComponent::setup() {
   // set the host name
   uint16_t size;
   char *existing_host_name = otSrpClientBuffersGetHostNameString(instance, &size);
-  const std::string &host_name = App.get_name();
+  const auto &host_name = App.get_name();
   uint16_t host_name_len = host_name.size();
   if (host_name_len > size) {
     ESP_LOGW(TAG, "Hostname is too long, choose a shorter project name");

esphome/components/sx126x/sx126x.cpp

@@ -155,7 +155,8 @@ void SX126x::configure() {
   }
 
   // check silicon version to make sure hw is ok
-  this->read_register_(REG_VERSION_STRING, (uint8_t *) this->version_, 16);
+  this->read_register_(REG_VERSION_STRING, (uint8_t *) this->version_, sizeof(this->version_));
+  this->version_[sizeof(this->version_) - 1] = '\0';
   if (strncmp(this->version_, "SX126", 5) != 0 && strncmp(this->version_, "LLCC68", 6) != 0) {
     this->mark_failed();
     return;

esphome/components/sx127x/sx127x.cpp

@@ -260,6 +260,11 @@ SX127xError SX127x::transmit_packet(const std::vector<uint8_t> &packet) {
     return SX127xError::INVALID_PARAMS;
   }
 
+  if (this->dio0_pin_ == nullptr) {
+    ESP_LOGE(TAG, "DIO0 pin not configured, cannot wait for transmit completion");
+    return SX127xError::INVALID_PARAMS;
+  }
+
   SX127xError ret = SX127xError::NONE;
   if (this->modulation_ == MOD_LORA) {
     this->set_mode_standby();

esphome/components/web_server/web_server_v1.cpp

@@ -75,7 +75,7 @@ void WebServer::set_js_url(const char *js_url) { this->js_url_ = js_url; }
 
 void WebServer::handle_index_request(AsyncWebServerRequest *request) {
   AsyncResponseStream *stream = request->beginResponseStream(ESPHOME_F("text/html"));
-  const std::string &title = App.get_name();
+  const auto &title = App.get_name();
   stream->print(ESPHOME_F("<!DOCTYPE html><html lang=\"en\"><head><meta charset=UTF-8><meta "
                           "name=viewport content=\"width=device-width, initial-scale=1,user-scalable=no\"><title>"));
   stream->print(title.c_str());

esphome/components/wifi/wifi_component.cpp

@@ -913,7 +913,7 @@ void WiFiComponent::setup_ap_config_() {
     static constexpr size_t AP_SSID_PREFIX_LEN = 25;
     static constexpr size_t AP_SSID_SUFFIX_LEN = 7;
 
-    const std::string &app_name = App.get_name();
+    const auto &app_name = App.get_name();
     const char *name_ptr = app_name.c_str();
     size_t name_len = app_name.length();
 

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -212,7 +212,7 @@ network::IPAddresses WiFiComponent::wifi_sta_ip_addresses() {
   return addresses;
 }
 bool WiFiComponent::wifi_apply_hostname_() {
-  const std::string &hostname = App.get_name();
+  const auto &hostname = App.get_name();
   bool ret = wifi_station_set_hostname(const_cast<char *>(hostname.c_str()));
   if (!ret) {
     ESP_LOGV(TAG, "Set hostname failed");

esphome/core/application.h

@@ -138,26 +138,36 @@ static constexpr uint32_t TEARDOWN_TIMEOUT_REBOOT_MS = 1000;  // 1 second for qu
 
 class Application {
  public:
-  void pre_setup(const std::string &name, const std::string &friendly_name, bool name_add_mac_suffix) {
+#ifdef ESPHOME_NAME_ADD_MAC_SUFFIX
+  /// Pre-setup with MAC suffix: overwrites placeholder in mutable static buffers with actual MAC.
+  void pre_setup(char *name, size_t name_len, char *friendly_name, size_t friendly_name_len) {
     arch_init();
-    this->name_add_mac_suffix_ = name_add_mac_suffix;
-    if (name_add_mac_suffix) {
-      // MAC address length: 12 hex chars + null terminator
-      constexpr size_t mac_address_len = 13;
-      // MAC address suffix length (last 6 characters of 12-char MAC address string)
-      constexpr size_t mac_address_suffix_len = 6;
-      char mac_addr[mac_address_len];
-      get_mac_address_into_buffer(mac_addr);
-      const char *mac_suffix_ptr = mac_addr + mac_address_suffix_len;
-      this->name_ = make_name_with_suffix(name, '-', mac_suffix_ptr, mac_address_suffix_len);
-      if (!friendly_name.empty()) {
-        this->friendly_name_ = make_name_with_suffix(friendly_name, ' ', mac_suffix_ptr, mac_address_suffix_len);
-      }
-    } else {
-      this->name_ = name;
-      this->friendly_name_ = friendly_name;
+    this->name_add_mac_suffix_ = true;
+    // MAC address length: 12 hex chars + null terminator
+    constexpr size_t mac_address_len = 13;
+    // MAC address suffix length (last 6 characters of 12-char MAC address string)
+    constexpr size_t mac_address_suffix_len = 6;
+    char mac_addr[mac_address_len];
+    get_mac_address_into_buffer(mac_addr);
+    // Overwrite the placeholder suffix in the mutable static buffers with actual MAC
+    // name is always non-empty (validated by validate_hostname in Python config)
+    memcpy(name + name_len - mac_address_suffix_len, mac_addr + mac_address_suffix_len, mac_address_suffix_len);
+    if (friendly_name_len > 0) {
+      memcpy(friendly_name + friendly_name_len - mac_address_suffix_len, mac_addr + mac_address_suffix_len,
+             mac_address_suffix_len);
     }
+    this->name_ = StringRef(name, name_len);
+    this->friendly_name_ = StringRef(friendly_name, friendly_name_len);
   }
+#else
+  /// Pre-setup without MAC suffix: StringRef points directly at const string literals in flash.
+  void pre_setup(const char *name, size_t name_len, const char *friendly_name, size_t friendly_name_len) {
+    arch_init();
+    this->name_add_mac_suffix_ = false;
+    this->name_ = StringRef(name, name_len);
+    this->friendly_name_ = StringRef(friendly_name, friendly_name_len);
+  }
+#endif
 
 #ifdef USE_DEVICES
   void register_device(Device *device) { this->devices_.push_back(device); }
@@ -274,10 +284,10 @@ class Application {
   void loop();
 
   /// Get the name of this Application set by pre_setup().
-  const std::string &get_name() const { return this->name_; }
+  const StringRef &get_name() const { return this->name_; }
 
   /// Get the friendly name of this Application set by pre_setup().
-  const std::string &get_friendly_name() const { return this->friendly_name_; }
+  const StringRef &get_friendly_name() const { return this->friendly_name_; }
 
   /// Get the area of this Application set by pre_setup().
   const char *get_area() const {
@@ -627,9 +637,9 @@ class Application {
 #endif
 #endif
 
-  // std::string members (typically 24-32 bytes each)
-  std::string name_;
-  std::string friendly_name_;
+  // StringRef members (8 bytes each: pointer + size)
+  StringRef name_;
+  StringRef friendly_name_;
 
   // 4-byte members
   uint32_t last_loop_{0};

esphome/core/config.py

@@ -50,6 +50,7 @@ from esphome.core import (
 )
 from esphome.helpers import (
     copy_file_if_changed,
+    cpp_string_escape,
     fnv1a_32bit_hash,
     get_str_env,
     walk_files,
@@ -58,6 +59,38 @@ from esphome.types import ConfigType
 
 _LOGGER = logging.getLogger(__name__)
 
+# C++ variable names and separators for app name buffers (used with MAC suffix)
+_APP_NAME_BUF_VAR = "esphome_app_name_buf"
+_APP_NAME_MAC_SEP = "-"
+_APP_FRIENDLY_NAME_BUF_VAR = "esphome_app_friendly_name_buf"
+_APP_FRIENDLY_NAME_MAC_SEP = " "
+# Placeholder suffix for MAC address (last 6 hex chars)
+_MAC_SUFFIX_PLACEHOLDER = "XXXXXX"
+
+
+def make_app_name_cpp(
+    value: str, var_name: str, sep: str, *, add_mac_suffix: bool
+) -> tuple[str, str | None, int]:
+    """Compute C++ expression and optional global declaration for an app name.
+
+    Returns (cpp_expr, global_decl_or_none, byte_length).
+    - cpp_expr: The C++ expression to pass to pre_setup (var name or string literal).
+    - global_decl: A static char[] declaration string, or None if not needed.
+    - byte_length: The UTF-8 byte length of the string value.
+    """
+    if add_mac_suffix:
+        buf_value = "" if not value else f"{value}{sep}{_MAC_SUFFIX_PLACEHOLDER}"
+        escaped = cpp_string_escape(buf_value)
+        return (
+            var_name,
+            f"static char {var_name}[] = {escaped};",
+            len(buf_value.encode("utf-8")),
+        )
+    if not value:
+        return '""', None, 0
+    return cpp_string_escape(value), None, len(value.encode("utf-8"))
+
+
 StartupTrigger = cg.esphome_ns.class_(
     "StartupTrigger", cg.Component, automation.Trigger.template()
 )
@@ -78,6 +111,8 @@ VALID_INCLUDE_EXTS = {".h", ".hpp", ".tcc", ".ino", ".cpp", ".c"}
 
 def validate_hostname(config):
     # Keep in sync with ESPHOME_DEVICE_NAME_MAX_LEN in esphome/core/entity_base.h
+    if not config[CONF_NAME]:
+        raise cv.Invalid("Hostname must not be empty", path=[CONF_NAME])
     max_length = 31
     if config[CONF_NAME_ADD_MAC_SUFFIX]:
         max_length -= 7  # "-AABBCC" is appended when add mac suffix option is used
@@ -192,6 +227,7 @@ FRIENDLY_NAME_MAX_LEN = 120
 # Keep in sync with MAX_DEVICE_CLASS_LENGTH in esphome/core/entity_base.h
 DEVICE_CLASS_MAX_LENGTH = 47
 
+
 # Max icon string length (63 chars + null = 64-byte PROGMEM buffer)
 # Keep in sync with MAX_ICON_LENGTH in esphome/core/entity_base.h
 ICON_MAX_LENGTH = 63
@@ -559,13 +595,28 @@ async def to_code(config: ConfigType) -> None:
     # Construct App via placement new — see application.cpp for storage details
     cg.add_global(cg.RawStatement("#include <new>"))
     cg.add(cg.RawExpression("new (&App) Application()"))
-    cg.add(
-        cg.App.pre_setup(
-            config[CONF_NAME],
-            config[CONF_FRIENDLY_NAME],
-            config[CONF_NAME_ADD_MAC_SUFFIX],
+    name = config[CONF_NAME]
+    friendly_name = config[CONF_FRIENDLY_NAME]
+    name_add_mac_suffix = config[CONF_NAME_ADD_MAC_SUFFIX]
+
+    def _emit_app_name(
+        value: str, var_name: str, sep: str
+    ) -> tuple[cg.Expression, int]:
+        """Emit codegen for an app name and return (expression, byte_length)."""
+        cpp_expr, global_decl, byte_len = make_app_name_cpp(
+            value, var_name, sep, add_mac_suffix=name_add_mac_suffix
         )
+        if global_decl is not None:
+            cg.add_global(cg.RawStatement(global_decl))
+        return cg.RawExpression(cpp_expr), byte_len
+
+    name_expr, name_len = _emit_app_name(name, _APP_NAME_BUF_VAR, _APP_NAME_MAC_SEP)
+    friendly_expr, friendly_len = _emit_app_name(
+        friendly_name, _APP_FRIENDLY_NAME_BUF_VAR, _APP_FRIENDLY_NAME_MAC_SEP
     )
+    if name_add_mac_suffix:
+        cg.add_define("ESPHOME_NAME_ADD_MAC_SUFFIX")
+    cg.add(cg.App.pre_setup(name_expr, name_len, friendly_expr, friendly_len))
     # Define component count for static allocation
     cg.add_define("ESPHOME_COMPONENT_COUNT", len(CORE.component_ids))
 

esphome/core/defines.h

@@ -13,6 +13,7 @@
 #define ESPHOME_PROJECT_VERSION "v2"
 #define ESPHOME_PROJECT_VERSION_30 "v2"
 #define ESPHOME_VARIANT "ESP32"
+#define ESPHOME_NAME_ADD_MAC_SUFFIX
 #define ESPHOME_DEBUG_SCHEDULER
 #define ESPHOME_DEBUG_API
 

esphome/core/entity_base.cpp

@@ -23,13 +23,13 @@ void EntityBase::set_name(const char *name, uint32_t object_id_hash) {
       // Bug-for-bug compatibility with OLD behavior:
       // - With MAC suffix: OLD code used App.get_friendly_name() directly (no fallback)
       // - Without MAC suffix: OLD code used pre-computed object_id with fallback to device name
-      const std::string &friendly = App.get_friendly_name();
+      const auto &friendly = App.get_friendly_name();
       if (App.is_name_add_mac_suffix_enabled()) {
         // MAC suffix enabled - use friendly_name directly (even if empty) for compatibility
-        this->name_ = StringRef(friendly);
+        this->name_ = friendly;
       } else {
         // No MAC suffix - fallback to device name if friendly_name is empty
-        this->name_ = StringRef(!friendly.empty() ? friendly : App.get_name());
+        this->name_ = !friendly.empty() ? friendly : App.get_name();
       }
     }
     this->flags_.has_own_name = false;

esphome/core/event_pool.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#if defined(USE_ESP32)
+#if defined(USE_ESP32) || defined(USE_ZEPHYR)
 
 #include <atomic>
 #include <cstddef>

tests/dummy_main.cpp

@@ -12,7 +12,9 @@
 using namespace esphome;
 
 void setup() {
-  App.pre_setup("livingroom", "LivingRoom", false);
+  static char name[] = "livingroom";
+  static char friendly_name[] = "LivingRoom";
+  App.pre_setup(name, sizeof(name) - 1, friendly_name, sizeof(friendly_name) - 1);
   auto *log = new logger::Logger(115200);  // NOLINT
   log->pre_setup();
   log->set_uart_selection(logger::UART_SELECTION_UART0);

tests/unit_tests/core/test_config.py

@@ -23,6 +23,7 @@ from esphome.const import (
 from esphome.core import CORE, config
 from esphome.core.config import (
     Area,
+    make_app_name_cpp,
     preload_core_config,
     valid_include,
     valid_project_name,
@@ -969,3 +970,79 @@ def test_config_hash_different_for_different_configs() -> None:
     hash2 = CORE.config_hash
 
     assert hash1 != hash2
+
+
+def test_make_app_name_cpp_no_mac_simple() -> None:
+    """Test simple name without MAC suffix returns string literal."""
+    cpp_expr, global_decl, byte_len = make_app_name_cpp(
+        "my-device", "buf", "-", add_mac_suffix=False
+    )
+    assert cpp_expr == '"my-device"'
+    assert global_decl is None
+    assert byte_len == 9
+
+
+def test_make_app_name_cpp_no_mac_empty() -> None:
+    """Test empty name without MAC suffix."""
+    cpp_expr, global_decl, byte_len = make_app_name_cpp(
+        "", "buf", "-", add_mac_suffix=False
+    )
+    assert cpp_expr == '""'
+    assert global_decl is None
+    assert byte_len == 0
+
+
+def test_make_app_name_cpp_mac_suffix() -> None:
+    """Test name with MAC suffix emits static buffer."""
+    cpp_expr, global_decl, byte_len = make_app_name_cpp(
+        "my-device", "esphome_app_name_buf", "-", add_mac_suffix=True
+    )
+    assert cpp_expr == "esphome_app_name_buf"
+    assert global_decl is not None
+    assert "static char esphome_app_name_buf[]" in global_decl
+    assert "my-device-XXXXXX" in global_decl
+    assert byte_len == len("my-device-XXXXXX")
+
+
+def test_make_app_name_cpp_mac_suffix_empty() -> None:
+    """Test empty name with MAC suffix emits empty static buffer."""
+    cpp_expr, global_decl, byte_len = make_app_name_cpp(
+        "", "esphome_app_name_buf", "-", add_mac_suffix=True
+    )
+    assert cpp_expr == "esphome_app_name_buf"
+    assert global_decl is not None
+    assert "static char esphome_app_name_buf[]" in global_decl
+    assert byte_len == 0
+
+
+def test_make_app_name_cpp_mac_suffix_space_sep() -> None:
+    """Test friendly name uses space separator for MAC suffix."""
+    cpp_expr, global_decl, byte_len = make_app_name_cpp(
+        "My Device", "esphome_app_friendly_name_buf", " ", add_mac_suffix=True
+    )
+    assert cpp_expr == "esphome_app_friendly_name_buf"
+    assert global_decl is not None
+    assert "My Device XXXXXX" in global_decl
+    assert byte_len == len("My Device XXXXXX")
+
+
+def test_make_app_name_cpp_non_ascii_utf8_length() -> None:
+    """Test non-ASCII characters use UTF-8 byte length."""
+    _, global_decl, byte_len = make_app_name_cpp(
+        "café", "buf", "-", add_mac_suffix=False
+    )
+    assert byte_len == len("café".encode())  # 5 bytes, not 4 chars
+    assert global_decl is None
+
+
+def test_make_app_name_cpp_non_ascii_mac_suffix_utf8_length() -> None:
+    """Test non-ASCII with MAC suffix uses UTF-8 byte length."""
+    _, _, byte_len = make_app_name_cpp("café", "buf", "-", add_mac_suffix=True)
+    assert byte_len == len("café-XXXXXX".encode())
+
+
+def test_make_app_name_cpp_special_chars_escaped() -> None:
+    """Test special characters are properly escaped in C++ string."""
+    cpp_expr, _, _ = make_app_name_cpp('my "device"', "buf", "-", add_mac_suffix=False)
+    # cpp_string_escape uses octal escapes for quotes
+    assert '"' not in cpp_expr[1:-1]  # no unescaped quotes inside the outer quotes