[hoermann_hcp] Add garage light control (#18190)

Co-authored-by: J. Nick Koston <nick@koston.org>
Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>

tests/components/hoermann_hcp/binary_sensor/hoermann_hcp_binary_sensor_test.cpp

@@ -2,29 +2,9 @@
 
 #include "esphome/components/hoermann_hcp/binary_sensor/hoermann_hcp_binary_sensor.h"
 
-namespace esphome::hoermann_hcp {
+#include "../common.h"
 
-using modbus::RegisterValues;
-
-namespace {
-
-constexpr uint16_t COMMAND_REG = 0x9C41;
-constexpr uint16_t BROADCAST_REG = 0x9D31;
-
-RegisterValues make_registers(std::initializer_list<uint16_t> values) {
-  RegisterValues registers;
-  for (uint16_t value : values)
-    registers.push_back(value);
-  return registers;
-}
-
-// Exposes the connection bookkeeping so a drop can be driven without waiting one out.
-class TestableHoermannHcp : public HoermannHcp {
- public:
-  using HoermannHcp::set_valid_;
-};
-
-}  // namespace
+namespace esphome::hoermann_hcp::testing {
 
 // Nothing has been heard from the bus controller yet, so the sensor starts out seeded as disconnected.
 TEST(HoermannHcpBinarySensorTest, StartsDisconnected) {
@@ -42,7 +22,7 @@ TEST(HoermannHcpBinarySensorTest, FollowsTheConnectionState) {
   sensor.setup();
   ASSERT_FALSE(sensor.state);
 
-  door.on_write_registers(COMMAND_REG, make_registers({0x0000, 0x0000}));
+  connect_controller(door);
   door.update();
   EXPECT_TRUE(sensor.state);
 
@@ -59,7 +39,7 @@ TEST(HoermannHcpBinarySensorTest, UnchangedConnectionIsPublishedOnce) {
   int publishes = 0;
   sensor.add_on_state_callback([&publishes](bool /*state*/) { publishes++; });
 
-  door.on_write_registers(COMMAND_REG, make_registers({0x0000, 0x0000}));
+  connect_controller(door);
   door.update();
   ASSERT_EQ(publishes, 1);
 
@@ -69,4 +49,4 @@ TEST(HoermannHcpBinarySensorTest, UnchangedConnectionIsPublishedOnce) {
   EXPECT_EQ(publishes, 1);
 }
 
-}  // namespace esphome::hoermann_hcp
+}  // namespace esphome::hoermann_hcp::testing

tests/components/hoermann_hcp/common.h

@@ -0,0 +1,68 @@
+#pragma once
+#include <chrono>
+#include <initializer_list>
+#include <thread>
+#include <utility>
+#include <gtest/gtest.h>
+#include "esphome/components/hoermann_hcp/hoermann_hcp.h"
+
+namespace esphome::hoermann_hcp::testing {
+
+using modbus::RegisterValues;
+
+// Register block addresses the Hoermann bus controller polls (see hoermann_hcp.cpp).
+constexpr uint16_t COMMAND_REG = 0x9C41;
+constexpr uint16_t STATE_REG = 0x9CB9;
+constexpr uint16_t BROADCAST_REG = 0x9D31;
+
+// The tests shorten the key-press delay to zero, so the release only needs the millis() clock to tick on.
+constexpr auto KEY_PRESS_ELAPSED = std::chrono::milliseconds(2);
+
+inline RegisterValues make_registers(std::initializer_list<uint16_t> values) {
+  RegisterValues registers;
+  for (uint16_t value : values)
+    registers.push_back(value);
+  return registers;
+}
+
+// A status broadcast carrying the lamp register, which the door reports at index 6.
+inline RegisterValues lamp_broadcast(uint16_t lamp_reg) {
+  return make_registers({0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, lamp_reg});
+}
+
+// The door only accepts commands once the bus controller has actually talked to it.
+inline void connect_controller(HoermannHcp &door) {
+  door.on_write_registers(COMMAND_REG, make_registers({0x0000, 0x0000}));
+}
+
+// Runs one command poll (write 2 / read 8) and returns both key-press registers.
+inline std::pair<uint16_t, uint16_t> poll_command(HoermannHcp &door) {
+  door.on_write_registers(COMMAND_REG, make_registers({0x0000, 0x0000}));
+  RegisterValues response;
+  door.on_read_holding_registers(STATE_REG, 8, response);
+  EXPECT_EQ(response.size(), 8u);
+  if (response.size() != 8u)
+    return {0xFFFF, 0xFFFF};
+  return {response[2], response[3]};
+}
+
+// Presents and then releases the queued command, leaving the slot free.
+inline void consume_command(HoermannHcp &door) {
+  poll_command(door);
+  std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
+  poll_command(door);
+}
+
+// Exposes the internal timings and the connection bookkeeping, so no test has to wait out a real delay.
+class TestableHoermannHcp : public HoermannHcp {
+ public:
+  TestableHoermannHcp() { this->key_press_delay_ms_ = 0; }
+
+  using HoermannHcp::connection_timeout_ms_;
+  using HoermannHcp::is_light_toggle_pending_;
+  using HoermannHcp::light_toggle_released_at_;
+  using HoermannHcp::light_toggles_in_flight_;
+  using HoermannHcp::set_valid_;
+};
+
+}  // namespace esphome::hoermann_hcp::testing

tests/components/hoermann_hcp/common.yaml

@@ -11,3 +11,7 @@ binary_sensor:
   - platform: hoermann_hcp
     is_connected:
       name: Garage Connected
+
+light:
+  - platform: hoermann_hcp
+    name: Garage Light

tests/components/hoermann_hcp/cover/hoermann_hcp_cover_test.cpp

@@ -2,36 +2,9 @@
 
 #include "esphome/components/hoermann_hcp/cover/hoermann_hcp_cover.h"
 
-namespace esphome::hoermann_hcp {
+#include "../common.h"
 
-using modbus::RegisterValues;
-
-namespace {
-
-constexpr uint16_t COMMAND_REG = 0x9C41;
-constexpr uint16_t STATE_REG = 0x9CB9;
-constexpr uint16_t BROADCAST_REG = 0x9D31;
-
-RegisterValues make_registers(std::initializer_list<uint16_t> values) {
-  RegisterValues registers;
-  for (uint16_t value : values)
-    registers.push_back(value);
-  return registers;
-}
-
-// The door only accepts commands once the bus controller has actually talked to it.
-void connect(HoermannHcp &door) { door.on_write_registers(COMMAND_REG, make_registers({0x0000, 0x0000})); }
-
-// Runs one command poll (write 2 / read 8) and returns the register carrying the key-press value.
-uint16_t poll_command(HoermannHcp &door) {
-  door.on_write_registers(COMMAND_REG, make_registers({0x0000, 0x0000}));
-  RegisterValues response;
-  door.on_read_holding_registers(STATE_REG, 8, response);
-  EXPECT_EQ(response.size(), 8u);
-  return response.size() == 8u ? response[2] : 0xFFFF;
-}
-
-}  // namespace
+namespace esphome::hoermann_hcp::testing {
 
 // Cover::position starts at COVER_OPEN, so a door that is already closed still has a state to publish.
 TEST(HoermannHcpCoverTest, ClosedDoorPublishesItsInitialPosition) {
@@ -92,10 +65,10 @@ TEST(HoermannHcpCoverTest, OpenCommandOpensTheDoor) {
   HoermannHcp door;
   HoermannHcpCover cover(&door);
   cover.setup();
-  connect(door);
+  connect_controller(door);
 
   cover.make_call().set_command_open().perform();
-  EXPECT_EQ(poll_command(door), 0x0210);  // COMMAND_OPEN pressed
+  EXPECT_EQ(poll_command(door).first, 0x0210);  // COMMAND_OPEN pressed
 }
 
 // The same for cover.close, which arrives as a position of 0.0.
@@ -103,32 +76,32 @@ TEST(HoermannHcpCoverTest, CloseCommandClosesTheDoor) {
   HoermannHcp door;
   HoermannHcpCover cover(&door);
   cover.setup();
-  connect(door);
+  connect_controller(door);
 
   cover.make_call().set_command_close().perform();
-  EXPECT_EQ(poll_command(door), 0x0220);  // COMMAND_CLOSE pressed
+  EXPECT_EQ(poll_command(door).first, 0x0220);  // COMMAND_CLOSE pressed
 }
 
 TEST(HoermannHcpCoverTest, ToggleCommandSendsAnImpulse) {
   HoermannHcp door;
   HoermannHcpCover cover(&door);
   cover.setup();
-  connect(door);
+  connect_controller(door);
 
   cover.make_call().set_command_toggle().perform();
-  EXPECT_EQ(poll_command(door), 0x0240);  // COMMAND_IMPULSE pressed
+  EXPECT_EQ(poll_command(door).first, 0x0240);  // COMMAND_IMPULSE pressed
 }
 
 TEST(HoermannHcpCoverTest, StopCommandStopsAMovingDoor) {
   HoermannHcp door;
   HoermannHcpCover cover(&door);
   cover.setup();
-  connect(door);
+  connect_controller(door);
   // The door is opening, so it takes an impulse to stop it.
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0064, 0x0100}));
 
   cover.make_call().set_command_stop().perform();
-  EXPECT_EQ(poll_command(door), 0x0240);  // COMMAND_IMPULSE pressed
+  EXPECT_EQ(poll_command(door).first, 0x0240);  // COMMAND_IMPULSE pressed
 }
 
 // A position between the end stops starts the door in the right direction; it is stopped there later.
@@ -136,10 +109,10 @@ TEST(HoermannHcpCoverTest, PositionCommandStartsTheDoorTowardsTheTarget) {
   HoermannHcp door;  // starts out fully closed
   HoermannHcpCover cover(&door);
   cover.setup();
-  connect(door);
+  connect_controller(door);
 
   cover.make_call().set_position(0.5f).perform();
-  EXPECT_EQ(poll_command(door), 0x0210);  // COMMAND_OPEN pressed
+  EXPECT_EQ(poll_command(door).first, 0x0210);  // COMMAND_OPEN pressed
 }
 
 // A command the door cannot take is assumed to have worked by whoever sent it, so the unchanged state has
@@ -153,7 +126,7 @@ TEST(HoermannHcpCoverTest, RefusedCommandPublishesTheUnchangedState) {
 
   cover.make_call().set_command_close().perform();
 
-  EXPECT_EQ(poll_command(door), 0x0000);
+  EXPECT_EQ(poll_command(door).first, 0x0000);
   EXPECT_EQ(publishes, 1);
   EXPECT_FLOAT_EQ(cover.position, cover::COVER_OPEN);
 }
@@ -166,9 +139,9 @@ TEST(HoermannHcpCoverTest, MissingBusControllerIsFlaggedUntilFirstContact) {
   cover.setup();
   EXPECT_TRUE(cover.status_has_warning());
 
-  connect(door);
+  connect_controller(door);
   door.update();
   EXPECT_FALSE(cover.status_has_warning());
 }
 
-}  // namespace esphome::hoermann_hcp
+}  // namespace esphome::hoermann_hcp::testing

tests/components/hoermann_hcp/hoermann_hcp_test.cpp

@@ -3,51 +3,9 @@
 #include <chrono>
 #include <thread>
 
-#include "esphome/components/hoermann_hcp/hoermann_hcp.h"
+#include "common.h"
 
-namespace esphome::hoermann_hcp {
-
-using modbus::RegisterValues;
-
-namespace {
-
-// Register block addresses the Hoermann bus controller polls (see hoermann_hcp.cpp).
-constexpr uint16_t COMMAND_REG = 0x9C41;
-constexpr uint16_t STATE_REG = 0x9CB9;
-constexpr uint16_t BROADCAST_REG = 0x9D31;
-
-// The tests shorten the key-press delay to zero, so the release only needs the millis() clock to tick on.
-constexpr auto KEY_PRESS_ELAPSED = std::chrono::milliseconds(2);
-
-RegisterValues make_registers(std::initializer_list<uint16_t> values) {
-  RegisterValues registers;
-  for (uint16_t value : values)
-    registers.push_back(value);
-  return registers;
-}
-
-// The device only accepts commands once the bus controller has actually talked to it.
-void connect(HoermannHcp &door) { door.on_write_registers(COMMAND_REG, make_registers({0x0000, 0x0000})); }
-
-// Runs one command poll (write 2 / read 8) and returns the register carrying the key-press value.
-uint16_t poll_command(HoermannHcp &door) {
-  door.on_write_registers(COMMAND_REG, make_registers({0x0000, 0x0000}));
-  RegisterValues response;
-  door.on_read_holding_registers(STATE_REG, 8, response);
-  EXPECT_EQ(response.size(), 8u);
-  return response.size() == 8u ? response[2] : 0xFFFF;
-}
-
-// Exposes the internal timings and the connection bookkeeping, so no test has to wait out a real delay.
-class TestableHoermannHcp : public HoermannHcp {
- public:
-  TestableHoermannHcp() { this->key_press_delay_ms_ = 0; }
-
-  using HoermannHcp::connection_timeout_ms_;
-  using HoermannHcp::set_valid_;
-};
-
-}  // namespace
+namespace esphome::hoermann_hcp::testing {
 
 // An empty poll (write 2 / read 2) answers with the fixed status word 0x0004.
 TEST(HoermannHcpReadWrite, EmptyPollReturnsStatusWord) {
@@ -91,7 +49,7 @@ TEST(HoermannHcpReadWrite, IdleCommandPollHasNoCommand) {
 // A queued control command is injected into the next command poll as a simulated key press.
 TEST(HoermannHcpReadWrite, QueuedCommandIsInjectedIntoPoll) {
   HoermannHcp door;
-  connect(door);
+  connect_controller(door);
   door.open_door();
   EXPECT_FALSE(door.on_write_registers(COMMAND_REG, make_registers({0x0000, 0x0000})).has_value());
   RegisterValues response;
@@ -113,31 +71,31 @@ TEST(HoermannHcpReadWrite, UnknownAddressIsRejected) {
 // A command is held for the key-press duration, then released, and only then can the next one be queued.
 TEST(HoermannHcpReadWrite, CommandIsReleasedAfterTheKeyPressDelay) {
   TestableHoermannHcp door;
-  connect(door);
+  connect_controller(door);
   door.open_door();
-  EXPECT_EQ(poll_command(door), 0x0210);  // COMMAND_OPEN pressed
+  EXPECT_EQ(poll_command(door).first, 0x0210);  // COMMAND_OPEN pressed
   // Refused while one is pending: were it accepted, the release below would carry COMMAND_CLOSE's 0x0120.
   door.close_door();
 
   std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
-  EXPECT_EQ(poll_command(door), 0x0110);  // COMMAND_OPEN released
+  EXPECT_EQ(poll_command(door).first, 0x0110);  // COMMAND_OPEN released
   // With the command gone, the next one is accepted again.
   door.close_door();
-  EXPECT_EQ(poll_command(door), 0x0220);  // COMMAND_CLOSE pressed
+  EXPECT_EQ(poll_command(door).first, 0x0220);  // COMMAND_CLOSE pressed
 }
 
 // Commands issued while the bus controller is absent are dropped instead of firing when it returns.
 TEST(HoermannHcpReadWrite, CommandIsDroppedWhileDisconnected) {
   HoermannHcp door;
   door.open_door();
-  EXPECT_EQ(poll_command(door), 0x0000);
+  EXPECT_EQ(poll_command(door).first, 0x0000);
 }
 
 // Losing the controller must drop a command it never fetched, otherwise it blocks every later command
 // and fires unasked once the bus comes back.
 TEST(HoermannHcpReadWrite, ConnectionLossDropsThePendingCommand) {
   TestableHoermannHcp door;
-  connect(door);
+  connect_controller(door);
   door.open_door();
   ASSERT_TRUE(door.is_valid());
 
@@ -145,10 +103,10 @@ TEST(HoermannHcpReadWrite, ConnectionLossDropsThePendingCommand) {
   EXPECT_FALSE(door.is_valid());
 
   // The reconnecting poll must not replay the dropped command.
-  EXPECT_EQ(poll_command(door), 0x0000);
+  EXPECT_EQ(poll_command(door).first, 0x0000);
   // And the slot is free, so a new command is accepted.
   door.close_door();
-  EXPECT_EQ(poll_command(door), 0x0220);
+  EXPECT_EQ(poll_command(door).first, 0x0220);
 }
 
 // The connection is dropped by update() once the controller stops polling, which is what releases a
@@ -157,7 +115,7 @@ TEST(HoermannHcpReadWrite, PollingTimeoutDropsTheConnection) {
   TestableHoermannHcp door;
   // Wide enough that a stall cannot expire the connection before the check below runs.
   door.connection_timeout_ms_ = 10000;
-  connect(door);
+  connect_controller(door);
   door.open_door();
 
   // Still inside the window: the controller counts as present.
@@ -170,7 +128,7 @@ TEST(HoermannHcpReadWrite, PollingTimeoutDropsTheConnection) {
   door.update();
   EXPECT_FALSE(door.is_valid());
   // The pending command went with the connection instead of firing on the reconnecting poll.
-  EXPECT_EQ(poll_command(door), 0x0000);
+  EXPECT_EQ(poll_command(door).first, 0x0000);
 }
 
 // Status broadcasts alone keep the connection alive, so a command the controller never fetches has to
@@ -178,7 +136,7 @@ TEST(HoermannHcpReadWrite, PollingTimeoutDropsTheConnection) {
 TEST(HoermannHcpReadWrite, UnfetchedCommandExpiresWhileConnected) {
   TestableHoermannHcp door;
   door.connection_timeout_ms_ = 200;
-  connect(door);
+  connect_controller(door);
   door.open_door();
 
   std::this_thread::sleep_for(std::chrono::milliseconds(220));
@@ -189,7 +147,7 @@ TEST(HoermannHcpReadWrite, UnfetchedCommandExpiresWhileConnected) {
 
   // With the stale command gone, the door accepts commands again.
   door.close_door();
-  EXPECT_EQ(poll_command(door), 0x0220);
+  EXPECT_EQ(poll_command(door).first, 0x0220);
 }
 
 // The 0x17 read half echoes the message counter and command byte written to COMMAND_REG, packed
@@ -272,7 +230,7 @@ TEST(HoermannHcpWrite, EndStopsReportExactPositions) {
 // A position request below the lower snap threshold becomes a plain close command.
 TEST(HoermannHcpPosition, NearlyClosedTargetClosesTheDoor) {
   HoermannHcp door;
-  connect(door);
+  connect_controller(door);
   door.set_position(0.02f);
   RegisterValues response;
   door.on_read_holding_registers(STATE_REG, 8, response);
@@ -283,7 +241,7 @@ TEST(HoermannHcpPosition, NearlyClosedTargetClosesTheDoor) {
 // A half-open target starts the door moving towards the requested position.
 TEST(HoermannHcpPosition, HalfOpenTargetOpensTheDoor) {
   HoermannHcp door;  // starts out fully closed
-  connect(door);
+  connect_controller(door);
   door.set_position(0.5f);
   RegisterValues response;
   door.on_read_holding_registers(STATE_REG, 8, response);
@@ -294,31 +252,31 @@ TEST(HoermannHcpPosition, HalfOpenTargetOpensTheDoor) {
 // The door has no notion of a target, so it is stopped with an impulse once it travels past the request.
 TEST(HoermannHcpPosition, TargetPositionStopsTheDoor) {
   TestableHoermannHcp door;
-  connect(door);
+  connect_controller(door);
   door.set_position(0.5f);
-  EXPECT_EQ(poll_command(door), 0x0210);  // COMMAND_OPEN pressed
+  EXPECT_EQ(poll_command(door).first, 0x0210);  // COMMAND_OPEN pressed
   std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
-  EXPECT_EQ(poll_command(door), 0x0110);  // COMMAND_OPEN released
+  EXPECT_EQ(poll_command(door).first, 0x0110);  // COMMAND_OPEN released
 
   // Position 20/200 = 0.1 while opening: short of the target, so the door keeps going.
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0014, 0x0100}));
   ASSERT_EQ(door.get_door_state(), DoorState::OPENING);
-  EXPECT_EQ(poll_command(door), 0x0000);
+  EXPECT_EQ(poll_command(door).first, 0x0000);
 
   // Position 120/200 = 0.6 is past the target, so the door is stopped.
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0078, 0x0100}));
-  EXPECT_EQ(poll_command(door), 0x0240);  // COMMAND_IMPULSE pressed
+  EXPECT_EQ(poll_command(door).first, 0x0240);  // COMMAND_IMPULSE pressed
 }
 
 // An impulse restarts a stopped door, so a frame reporting the stop and the target crossing at once
 // must be read as "already stopped" rather than "still opening".
 TEST(HoermannHcpPosition, StopReportedWithTheCrossingSendsNoImpulse) {
   TestableHoermannHcp door;
-  connect(door);
+  connect_controller(door);
   door.set_position(0.5f);
-  EXPECT_EQ(poll_command(door), 0x0210);
+  EXPECT_EQ(poll_command(door).first, 0x0210);
   std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
-  EXPECT_EQ(poll_command(door), 0x0110);
+  EXPECT_EQ(poll_command(door).first, 0x0110);
 
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0014, 0x0100}));
   ASSERT_EQ(door.get_door_state(), DoorState::OPENING);
@@ -326,17 +284,17 @@ TEST(HoermannHcpPosition, StopReportedWithTheCrossingSendsNoImpulse) {
   // Same frame: position 0.6 (past the target) and state 0x20 -> the door has reached its open end stop.
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0078, 0x2000}));
   ASSERT_EQ(door.get_door_state(), DoorState::OPEN);
-  EXPECT_EQ(poll_command(door), 0x0000);
+  EXPECT_EQ(poll_command(door).first, 0x0000);
 }
 
 // A target the door never reaches is dropped once it comes to rest, so a later move is not cut short.
 TEST(HoermannHcpPosition, TargetIsDroppedWhenTheDoorStopsShort) {
   TestableHoermannHcp door;
-  connect(door);
+  connect_controller(door);
   door.set_position(0.5f);
-  EXPECT_EQ(poll_command(door), 0x0210);
+  EXPECT_EQ(poll_command(door).first, 0x0210);
   std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
-  EXPECT_EQ(poll_command(door), 0x0110);
+  EXPECT_EQ(poll_command(door).first, 0x0110);
 
   // The door is stopped at 0.3 by a wall button, short of the requested 0.5.
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0014, 0x0100}));
@@ -346,48 +304,48 @@ TEST(HoermannHcpPosition, TargetIsDroppedWhenTheDoorStopsShort) {
   // A later manual open must run freely instead of being stopped at the abandoned target.
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0050, 0x0100}));
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0078, 0x0100}));
-  EXPECT_EQ(poll_command(door), 0x0000);
+  EXPECT_EQ(poll_command(door).first, 0x0000);
 }
 
 // A target armed while the door is still travelling the other way must not be judged by that old direction,
 // otherwise the very next position it reports counts as reached and stops the door where it stands.
 TEST(HoermannHcpPosition, TargetArmedWhileMovingTheOtherWayWaitsForTheTurnaround) {
   TestableHoermannHcp door;
-  connect(door);
+  connect_controller(door);
   // The door is closing, passing 60/200 = 0.3.
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x003C, 0x0200}));
   ASSERT_EQ(door.get_door_state(), DoorState::CLOSING);
 
   door.set_position(0.5f);
-  EXPECT_EQ(poll_command(door), 0x0210);  // COMMAND_OPEN pressed
+  EXPECT_EQ(poll_command(door).first, 0x0210);  // COMMAND_OPEN pressed
   std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
-  EXPECT_EQ(poll_command(door), 0x0110);  // COMMAND_OPEN released
+  EXPECT_EQ(poll_command(door).first, 0x0110);  // COMMAND_OPEN released
 
   // Still closing at 58/200 = 0.29: below the target, but not on the way to it.
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x003A, 0x0200}));
-  EXPECT_EQ(poll_command(door), 0x0000);
+  EXPECT_EQ(poll_command(door).first, 0x0000);
 
   // Now opening at 62/200 = 0.31, still short of the target.
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x003E, 0x0100}));
-  EXPECT_EQ(poll_command(door), 0x0000);
+  EXPECT_EQ(poll_command(door).first, 0x0000);
 
   // Past the target at 110/200 = 0.55, so the door is stopped.
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x006E, 0x0100}));
-  EXPECT_EQ(poll_command(door), 0x0240);  // COMMAND_IMPULSE pressed
+  EXPECT_EQ(poll_command(door).first, 0x0240);  // COMMAND_IMPULSE pressed
 }
 
 // A motor turning around can report a momentary stop; dropping the target there would let the door run on
 // to the end stop that the reversing command asked for.
 TEST(HoermannHcpPosition, MomentaryStopWhileTurningAroundKeepsTheTarget) {
   TestableHoermannHcp door;
-  connect(door);
+  connect_controller(door);
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x003C, 0x0200}));
   ASSERT_EQ(door.get_door_state(), DoorState::CLOSING);
 
   door.set_position(0.5f);
-  EXPECT_EQ(poll_command(door), 0x0210);
+  EXPECT_EQ(poll_command(door).first, 0x0210);
   std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
-  EXPECT_EQ(poll_command(door), 0x0110);
+  EXPECT_EQ(poll_command(door).first, 0x0110);
 
   // The stop reported on the way from closing to opening.
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x003C, 0x0000}));
@@ -395,23 +353,23 @@ TEST(HoermannHcpPosition, MomentaryStopWhileTurningAroundKeepsTheTarget) {
 
   // The door then opens and still has to be stopped at the requested position.
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x003E, 0x0100}));
-  EXPECT_EQ(poll_command(door), 0x0000);
+  EXPECT_EQ(poll_command(door).first, 0x0000);
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x006E, 0x0100}));
-  EXPECT_EQ(poll_command(door), 0x0240);
+  EXPECT_EQ(poll_command(door).first, 0x0240);
 }
 
 // A door that never turns around has to lose the target as well, otherwise it would cut a later move short.
 TEST(HoermannHcpPosition, TargetIsDroppedWhenTheDoorNeverTurnsAround) {
   TestableHoermannHcp door;
   door.connection_timeout_ms_ = 200;
-  connect(door);
+  connect_controller(door);
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x003C, 0x0200}));
   ASSERT_EQ(door.get_door_state(), DoorState::CLOSING);
 
   door.set_position(0.5f);
-  EXPECT_EQ(poll_command(door), 0x0210);
+  EXPECT_EQ(poll_command(door).first, 0x0210);
   std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
-  EXPECT_EQ(poll_command(door), 0x0110);
+  EXPECT_EQ(poll_command(door).first, 0x0110);
 
   std::this_thread::sleep_for(std::chrono::milliseconds(220));
   // The door ignored the command and closed all the way. Its broadcast keeps the connection alive, so the
@@ -424,7 +382,7 @@ TEST(HoermannHcpPosition, TargetIsDroppedWhenTheDoorNeverTurnsAround) {
   // A later manual open must run freely instead of being stopped at the abandoned target.
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x003E, 0x0100}));
   door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x006E, 0x0100}));
-  EXPECT_EQ(poll_command(door), 0x0000);
+  EXPECT_EQ(poll_command(door).first, 0x0000);
 }
 
-}  // namespace esphome::hoermann_hcp
+}  // namespace esphome::hoermann_hcp::testing

tests/components/hoermann_hcp/light/hoermann_hcp_light_test.cpp

@@ -0,0 +1,761 @@
+#include <gtest/gtest.h>
+
+#include <chrono>
+#include <thread>
+
+#include "esphome/components/hoermann_hcp/light/hoermann_hcp_light.h"
+
+#include "../common.h"
+
+namespace esphome::hoermann_hcp::testing {
+
+namespace {
+
+// Counts how often the platform is asked to write, so a publish that re-triggers itself becomes visible.
+class CountingHoermannHcpLight : public HoermannHcpLight {
+ public:
+  using HoermannHcpLight::HoermannHcpLight;
+
+  void write_state(light::LightState *state) override {
+    this->writes++;
+    HoermannHcpLight::write_state(state);
+  }
+
+  int writes{0};
+};
+
+// Drives the platform against a real LightState. ALWAYS_OFF keeps setup() clear of preferences.
+struct LightFixture {
+  TestableHoermannHcp door;
+  CountingHoermannHcpLight output{&door};
+  light::LightState state{&output};
+
+  explicit LightFixture(light::LightRestoreMode restore_mode = light::LIGHT_ALWAYS_OFF) {
+    this->state.set_restore_mode(restore_mode);
+    this->output.setup();
+    // setup() queues the restored state for write_state(); the first settle() below delivers it, which is the
+    // boot ordering tests need to be able to place around the bus controller coming up.
+    this->state.setup();
+  }
+
+  // Brings the bus controller up and lets the platform read the lamp once, which is what a device does before
+  // any user command can arrive.
+  void bring_up() {
+    connect_controller(this->door);
+    this->report_lamp(false);
+  }
+
+  // Issues a command the way Home Assistant would, then lets the state machine settle.
+  void command(bool on) {
+    auto call = this->state.make_call();
+    call.set_state(on);
+    call.perform();
+    this->settle();
+  }
+
+  // Delivers a status broadcast and runs the hub's notification pass.
+  void report_broadcast(const RegisterValues &registers) {
+    this->door.on_write_registers(BROADCAST_REG, registers);
+    this->pump();
+  }
+
+  void report_lamp(bool on) { this->report_broadcast(lamp_broadcast(on ? 0x0010 : 0x0000)); }
+
+  // Runs the hub's notification pass and lets the resulting publishes settle.
+  void pump() {
+    this->door.update();
+    this->settle();
+  }
+
+  void settle() {
+    for (int i = 0; i < 4; i++)
+      this->state.loop();
+  }
+
+  bool entity_on() { return this->state.remote_values.is_on(); }
+};
+
+}  // namespace
+
+// The lamp state lives in the low byte of register 6; only 0x14 and 0x10 mean lit.
+TEST(HoermannHcpLightTest, LampStateIsDecodedFromTheBroadcast) {
+  HoermannHcp door;
+  EXPECT_FALSE(door.is_light_on());
+
+  door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0014));
+  EXPECT_TRUE(door.is_light_on());
+
+  door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0000));
+  EXPECT_FALSE(door.is_light_on());
+}
+
+// The lamp command is the only one that drives the second command register, on both halves of the press.
+TEST(HoermannHcpLightTest, LampCommandUsesTheSecondRegister) {
+  TestableHoermannHcp door;
+  connect_controller(door);
+  ASSERT_FALSE(door.is_light_on());
+  ASSERT_TRUE(door.toggle_light());
+
+  auto [pressed, pressed_2] = poll_command(door);
+  EXPECT_EQ(pressed, 0x0100);
+  EXPECT_EQ(pressed_2, 0x0200);
+
+  std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
+  auto [released, released_2] = poll_command(door);
+  EXPECT_EQ(released, 0x0800);
+  EXPECT_EQ(released_2, 0x0200);
+
+  // The command is spent, so the next poll carries nothing.
+  auto [idle, idle_2] = poll_command(door);
+  EXPECT_EQ(idle, 0x0000);
+  EXPECT_EQ(idle_2, 0x0000);
+}
+
+// Toggling the lamp must not disturb a cover position the door is still travelling to.
+TEST(HoermannHcpLightTest, LampToggleKeepsTheCoverTarget) {
+  TestableHoermannHcp door;
+  connect_controller(door);
+  // Position 60/200 = 0.3 while opening, so a 0.5 target is armed and under way.
+  door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x003C, 0x0100}));
+  ASSERT_TRUE(door.set_position(0.5f));
+  consume_command(door);
+
+  ASSERT_TRUE(door.toggle_light());
+  consume_command(door);
+
+  // Past the target: the door still has to be stopped despite the lamp command in between.
+  door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0078, 0x0100}));
+  auto [pressed, pressed_2] = poll_command(door);
+  EXPECT_EQ(pressed, 0x0240);  // COMMAND_IMPULSE
+  EXPECT_EQ(pressed_2, 0x0000);
+}
+
+// A lamp toggle occupies the single command slot, so a target stop falling due while it waits to be fetched
+// has to wait too. The target stays armed and the stop goes out on the next position report, which costs the
+// door a little overshoot but never loses the stop.
+TEST(HoermannHcpLightTest, LampToggleDelaysButDoesNotLoseTheTargetStop) {
+  TestableHoermannHcp door;
+  connect_controller(door);
+  // Position 60/200 = 0.3 while opening, so a 0.5 target is armed and under way.
+  door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x003C, 0x0100}));
+  ASSERT_TRUE(door.set_position(0.5f));
+  consume_command(door);
+
+  ASSERT_TRUE(door.toggle_light());
+  // The door passes the target while the lamp toggle still holds the slot, so the lamp goes out first.
+  door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0078, 0x0100}));
+  auto [pressed, pressed_2] = poll_command(door);
+  EXPECT_EQ(pressed, 0x0100);
+  EXPECT_EQ(pressed_2, 0x0200);
+  std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
+  poll_command(door);
+
+  // The target survived the refusal, so the next position report still stops the door.
+  door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0079, 0x0100}));
+  auto [stop, stop_2] = poll_command(door);
+  EXPECT_EQ(stop, 0x0240);  // COMMAND_IMPULSE
+  EXPECT_EQ(stop_2, 0x0000);
+}
+
+// The target's start deadline is its own, so toggling the lamp cannot keep a stale target alive.
+TEST(HoermannHcpLightTest, LampToggleDoesNotExtendTheTargetWatchdog) {
+  TestableHoermannHcp door;
+  door.connection_timeout_ms_ = 20;
+  connect_controller(door);
+  // The door is closing, so an opening target is armed but not yet under way.
+  door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x003C, 0x0200}));
+  ASSERT_TRUE(door.set_position(0.5f));
+  consume_command(door);
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(30));
+  ASSERT_TRUE(door.toggle_light());
+  consume_command(door);
+  door.update();
+
+  // The target expired on its own schedule, so a later opening move runs freely.
+  door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0050, 0x0100}));
+  door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0078, 0x0100}));
+  auto [pressed, pressed_2] = poll_command(door);
+  EXPECT_EQ(pressed, 0x0000);
+  EXPECT_EQ(pressed_2, 0x0000);
+}
+
+// Without a bus controller the command cannot be delivered, and the caller is told.
+TEST(HoermannHcpLightTest, LampCommandIsRefusedWhileDisconnected) {
+  HoermannHcp door;
+  EXPECT_FALSE(door.toggle_light());
+}
+
+// Switching the entity on sends one toggle, and the door's own report does not send a second.
+TEST(HoermannHcpLightPlatformTest, CommandTogglesOnceAndSettles) {
+  LightFixture fixture;
+  fixture.bring_up();
+
+  fixture.command(true);
+  auto [pressed, pressed_2] = poll_command(fixture.door);
+  EXPECT_EQ(pressed, 0x0100);
+  EXPECT_EQ(pressed_2, 0x0200);
+  std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
+  poll_command(fixture.door);  // release, clearing the slot
+
+  // The lamp is now on, and the resulting broadcast must not queue another toggle.
+  fixture.report_lamp(true);
+  EXPECT_TRUE(fixture.entity_on());
+  auto [idle, idle_2] = poll_command(fixture.door);
+  EXPECT_EQ(idle, 0x0000);
+  EXPECT_EQ(idle_2, 0x0000);
+}
+
+// A broadcast arriving while a toggle is queued must not reconcile against the not-yet-inverted lamp, which
+// would cancel the user's own command.
+TEST(HoermannHcpLightPlatformTest, BroadcastDuringPendingToggleKeepsTheCommand) {
+  LightFixture fixture;
+  fixture.bring_up();
+
+  fixture.command(true);
+  ASSERT_TRUE(fixture.door.is_light_toggle_pending_());
+
+  // A door movement sets changed_, firing the state callback while the toggle is still queued.
+  fixture.report_broadcast(make_registers({0x0000, 0x0064, 0x0100}));
+
+  EXPECT_TRUE(fixture.door.is_light_toggle_pending_());
+  EXPECT_TRUE(fixture.entity_on());
+}
+
+// A lamp switched on at the door itself has to reach the entity.
+TEST(HoermannHcpLightPlatformTest, DoorDrivenChangeReachesTheEntity) {
+  LightFixture fixture;
+  fixture.bring_up();
+  ASSERT_FALSE(fixture.entity_on());
+
+  fixture.report_lamp(true);
+  EXPECT_TRUE(fixture.entity_on());
+
+  fixture.report_lamp(false);
+  EXPECT_FALSE(fixture.entity_on());
+}
+
+// A refused command must leave the entity showing the lamp, not the request.
+TEST(HoermannHcpLightPlatformTest, RefusedCommandRepublishesTheLamp) {
+  LightFixture fixture;  // never connected, so the hub refuses every command
+
+  fixture.command(true);
+  EXPECT_FALSE(fixture.entity_on());
+}
+
+// A reversing press once the toggle is already on the wire cannot stop it, so the entity has to end up
+// showing the lamp rather than the request that was refused.
+TEST(HoermannHcpLightPlatformTest, RefusedPressAfterFetchShowsWhereTheLampIsHeading) {
+  LightFixture fixture;
+  fixture.bring_up();
+
+  fixture.command(true);
+  poll_command(fixture.door);  // the controller fetches the press, so it can no longer be cancelled
+  ASSERT_TRUE(fixture.door.is_light_toggle_pending_());
+
+  fixture.command(false);
+  EXPECT_TRUE(fixture.entity_on());
+
+  // A door movement while the refused toggle is still on the wire must not pull the entity back either.
+  fixture.report_broadcast(make_registers({0x0000, 0x0064, 0x0100}));
+  EXPECT_TRUE(fixture.entity_on());
+
+  // The toggle lands and the door confirms it; the entity must already agree.
+  fixture.report_lamp(true);
+  EXPECT_TRUE(fixture.entity_on());
+}
+
+// The lamp is only reported some time after the key press is released, so an unrelated door broadcast in
+// that gap must not publish the state the lamp is about to leave.
+TEST(HoermannHcpLightPlatformTest, DoorMovementDoesNotFlipTheEntityBeforeTheLampReports) {
+  LightFixture fixture;
+  fixture.bring_up();
+
+  fixture.command(true);
+  poll_command(fixture.door);
+  std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
+  poll_command(fixture.door);  // release, so nothing is pending any more
+  ASSERT_FALSE(fixture.door.is_light_toggle_pending_());
+  ASSERT_FALSE(fixture.door.is_light_on());  // the lamp has still not been reported
+
+  fixture.report_broadcast(make_registers({0x0000, 0x0064, 0x0100}));
+
+  EXPECT_TRUE(fixture.entity_on());
+}
+
+// A toggle the controller never fetches is eventually dropped, and nothing else will ever report the lamp
+// moving, so the entity has to be brought back to what the lamp actually is.
+TEST(HoermannHcpLightPlatformTest, DroppedToggleReturnsTheEntityToTheLamp) {
+  LightFixture fixture;
+  fixture.door.connection_timeout_ms_ = 20;
+  fixture.bring_up();
+
+  fixture.command(true);
+  ASSERT_TRUE(fixture.door.is_light_toggle_pending_());
+  EXPECT_TRUE(fixture.entity_on());
+
+  // The controller keeps broadcasting but never fetches the command, so the connection stays up.
+  std::this_thread::sleep_for(std::chrono::milliseconds(30));
+  fixture.door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0000));
+  fixture.pump();
+
+  EXPECT_FALSE(fixture.door.is_light_toggle_pending_());
+  EXPECT_FALSE(fixture.entity_on());
+}
+
+// Losing the bus controller discards the queued toggle too, so the entity must not keep showing it once the
+// controller is back and still reporting the lamp unchanged.
+TEST(HoermannHcpLightPlatformTest, ToggleLostWithTheConnectionReturnsTheEntityToTheLamp) {
+  LightFixture fixture;
+  fixture.door.connection_timeout_ms_ = 20;
+  fixture.bring_up();
+
+  fixture.command(true);
+  ASSERT_TRUE(fixture.door.is_light_toggle_pending_());
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(30));
+  fixture.pump();  // the connection times out and the command goes with it
+  ASSERT_FALSE(fixture.door.is_valid());
+
+  connect_controller(fixture.door);
+  fixture.report_lamp(false);
+  EXPECT_FALSE(fixture.entity_on());
+}
+
+// The lamp can be switched at the door while the bus is quiet, so what was read before an outage must not
+// decide whether a toggle is needed after it.
+TEST(HoermannHcpLightPlatformTest, LampIsNotTrustedAcrossAConnectionLoss) {
+  LightFixture fixture;
+  fixture.door.connection_timeout_ms_ = 20;
+  fixture.bring_up();
+  fixture.report_lamp(true);
+  ASSERT_TRUE(fixture.entity_on());
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(30));
+  fixture.pump();
+  ASSERT_FALSE(fixture.door.is_valid());
+
+  // Back on the bus, but nothing has said what the lamp is doing yet.
+  connect_controller(fixture.door);
+  fixture.pump();
+  ASSERT_TRUE(fixture.door.is_valid());
+  ASSERT_FALSE(fixture.door.is_light_known());
+
+  fixture.command(false);
+  auto [idle, idle_2] = poll_command(fixture.door);
+  EXPECT_EQ(idle, 0x0000);
+  EXPECT_EQ(idle_2, 0x0000);
+}
+
+// A door that never reports the lamp leaves the entity unable to do anything, so it must not look healthy.
+TEST(HoermannHcpLightPlatformTest, UnreportedLampIsFlaggedOnTheEntity) {
+  LightFixture fixture;
+  connect_controller(fixture.door);
+  fixture.pump();
+  ASSERT_TRUE(fixture.door.is_valid());
+  EXPECT_TRUE(fixture.output.status_has_warning());
+
+  fixture.report_lamp(false);
+  EXPECT_FALSE(fixture.output.status_has_warning());
+}
+
+// Two outstanding toggles leave the lamp where it started, so a third tap has to be judged against that and
+// withdraw the one still waiting rather than deciding nothing is needed.
+TEST(HoermannHcpLightPlatformTest, ThirdTapWithTwoTogglesOutstandingIsHonoured) {
+  LightFixture fixture;
+  fixture.bring_up();
+
+  fixture.command(true);
+  poll_command(fixture.door);
+  std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
+  poll_command(fixture.door);  // the first toggle is released but not reported back
+  fixture.command(false);
+  ASSERT_TRUE(fixture.door.is_light_toggle_pending_());
+  ASSERT_EQ(fixture.door.light_toggles_in_flight_, 2);
+
+  // Two toggles cancel out, so asking for on again means withdrawing the second one.
+  fixture.command(true);
+  EXPECT_FALSE(fixture.door.is_light_toggle_pending_());
+  EXPECT_EQ(fixture.door.light_toggles_in_flight_, 1);
+  EXPECT_TRUE(fixture.entity_on());
+}
+
+// The boot replay is the first write and nothing else, so a real command arriving before the hub's next poll
+// must not be mistaken for it and swallowed.
+TEST(HoermannHcpLightPlatformTest, CommandBeforeTheFirstPollIsNotMistakenForTheBootReplay) {
+  LightFixture fixture;
+  connect_controller(fixture.door);
+  fixture.settle();  // the boot replay lands here, while the lamp is still unknown
+
+  // The first status broadcast arrives, but the hub has not polled yet, so no callback has fired.
+  fixture.door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0000));
+  ASSERT_TRUE(fixture.door.is_light_known());
+
+  fixture.command(true);
+  auto [pressed, pressed_2] = poll_command(fixture.door);
+  EXPECT_EQ(pressed, 0x0100);  // COMMAND_TOGGLE_LAMP
+  EXPECT_EQ(pressed_2, 0x0200);
+}
+
+// On boot the restored state is replayed through write_state() before the lamp has ever been read. A lamp
+// that is already on must not be switched off by that replay.
+TEST(HoermannHcpLightPlatformTest, RestoredStateOnBootDoesNotCommandTheLamp) {
+  LightFixture fixture;
+  // The controller is already up and reporting the lamp lit before the entity's first loop.
+  connect_controller(fixture.door);
+  fixture.door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0010));
+  ASSERT_TRUE(fixture.door.is_light_on());
+
+  fixture.settle();
+  auto [idle, idle_2] = poll_command(fixture.door);
+  EXPECT_EQ(idle, 0x0000);
+  EXPECT_EQ(idle_2, 0x0000);
+  // Once the platform has read the lamp the entity follows it, still without commanding anything.
+  fixture.pump();
+  EXPECT_TRUE(fixture.entity_on());
+}
+
+// Bus traffic makes the connection valid without saying anything about the lamp, so a request arriving before
+// the first status broadcast must not be judged against a lamp state that was never read.
+TEST(HoermannHcpLightPlatformTest, RequestBeforeTheLampIsReportedDoesNotCommandTheLamp) {
+  LightFixture fixture;
+  // The controller polls for commands, which is enough to connect but carries no lamp register.
+  connect_controller(fixture.door);
+  fixture.pump();
+  ASSERT_TRUE(fixture.door.is_valid());
+  ASSERT_FALSE(fixture.door.is_light_known());
+
+  fixture.command(true);
+  auto [idle, idle_2] = poll_command(fixture.door);
+  EXPECT_EQ(idle, 0x0000);
+  EXPECT_EQ(idle_2, 0x0000);
+  EXPECT_FALSE(fixture.entity_on());
+}
+
+// A toggle that has been released onto the wire is no longer pending, but the lamp has not reported it yet.
+// A reversing request in that window is a real request and has to be sent, not swallowed.
+TEST(HoermannHcpLightPlatformTest, ReversingRequestAfterReleaseQueuesASecondToggle) {
+  LightFixture fixture;
+  fixture.bring_up();
+
+  fixture.command(true);
+  poll_command(fixture.door);
+  std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
+  poll_command(fixture.door);  // released, so nothing is pending and the lamp is still unreported
+  ASSERT_FALSE(fixture.door.is_light_toggle_pending_());
+  ASSERT_FALSE(fixture.door.is_light_on());
+
+  fixture.command(false);
+  auto [pressed, pressed_2] = poll_command(fixture.door);
+  EXPECT_EQ(pressed, 0x0100);  // COMMAND_TOGGLE_LAMP
+  EXPECT_EQ(pressed_2, 0x0200);
+  EXPECT_FALSE(fixture.entity_on());
+
+  // The first toggle lands and is reported, but the entity is already heading for off.
+  fixture.report_lamp(true);
+  EXPECT_FALSE(fixture.entity_on());
+
+  // The second toggle lands too, and the lamp finally agrees with the request.
+  std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
+  poll_command(fixture.door);
+  fixture.report_lamp(false);
+  EXPECT_FALSE(fixture.entity_on());
+}
+
+// A refusal that has no toggle on the wire leaves nothing outstanding, so it must not latch the entity
+// against the next lamp change the door reports.
+TEST(HoermannHcpLightPlatformTest, RefusalWithoutAToggleStillFollowsTheLamp) {
+  LightFixture fixture;
+  fixture.door.connection_timeout_ms_ = 20;
+  fixture.bring_up();
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(30));
+  fixture.pump();
+  ASSERT_FALSE(fixture.door.is_valid());
+
+  // Refused because the bus is down, so no toggle is heading for the lamp.
+  fixture.command(true);
+  EXPECT_FALSE(fixture.entity_on());
+
+  // The controller returns and reports the lamp switched on at the door itself.
+  connect_controller(fixture.door);
+  fixture.report_lamp(true);
+  EXPECT_TRUE(fixture.entity_on());
+}
+
+// A lamp toggle carries no target, so dropping it unfetched must leave the cover's target alone.
+TEST(HoermannHcpLightTest, DroppedLampToggleKeepsTheCoverTarget) {
+  TestableHoermannHcp door;
+  door.connection_timeout_ms_ = 20;
+  connect_controller(door);
+  // Position 60/200 = 0.3 while opening, so a 0.5 target is armed and under way.
+  door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x003C, 0x0100}));
+  ASSERT_TRUE(door.set_position(0.5f));
+  consume_command(door);
+
+  // The controller keeps broadcasting but stops fetching, so the lamp toggle expires on its own.
+  ASSERT_TRUE(door.toggle_light());
+  std::this_thread::sleep_for(std::chrono::milliseconds(30));
+  door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0050, 0x0100}));
+  door.update();
+
+  // The target survived the lamp toggle being dropped, so the door is still stopped on the way.
+  door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0078, 0x0100}));
+  auto [pressed, pressed_2] = poll_command(door);
+  EXPECT_EQ(pressed, 0x0240);  // COMMAND_IMPULSE
+  EXPECT_EQ(pressed_2, 0x0000);
+}
+
+// A door that takes the key press but never actually switches the lamp must not leave the entity showing the
+// request for ever; the wait has to end so the entity can settle back on what the door reports.
+TEST(HoermannHcpLightPlatformTest, ToggleTheDoorIgnoresStopsBeingWaitedFor) {
+  LightFixture fixture;
+  fixture.door.connection_timeout_ms_ = 20;
+  fixture.bring_up();
+
+  fixture.command(true);
+  consume_command(fixture.door);  // the door takes press and release, then does nothing
+  ASSERT_FALSE(fixture.door.is_light_toggle_pending_());
+  EXPECT_TRUE(fixture.entity_on());
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(30));
+  fixture.report_lamp(false);  // the lamp is still off, and keeps saying so
+  EXPECT_FALSE(fixture.entity_on());
+}
+
+// A resting door's first broadcast changes nothing except the lamp finally being reported, so unless that
+// counts as a change the light never hears about it and swallows the first command.
+TEST(HoermannHcpLightPlatformTest, FirstLampReportReachesTheEntity) {
+  LightFixture fixture;
+  // A command poll connects the controller without saying anything about the lamp.
+  connect_controller(fixture.door);
+  fixture.pump();
+  ASSERT_FALSE(fixture.door.is_light_known());
+
+  // Closed, at rest, lamp off: every field matches the defaults the hub started with.
+  fixture.report_broadcast(make_registers({0x0000, 0x0000, 0x4000, 0x0000, 0x0000, 0x0000, 0x0000}));
+  ASSERT_TRUE(fixture.door.is_light_known());
+
+  fixture.command(true);
+  auto [pressed, pressed_2] = poll_command(fixture.door);
+  EXPECT_EQ(pressed, 0x0100);  // COMMAND_TOGGLE_LAMP
+  EXPECT_EQ(pressed_2, 0x0200);
+}
+
+// A lost connection means the door can travel unwatched, so a target left armed would stop it long afterwards.
+// Which command happened to be in the slot must not change that.
+TEST(HoermannHcpLightTest, ConnectionLossWithALampTogglePendingClearsTheTarget) {
+  TestableHoermannHcp door;
+  door.connection_timeout_ms_ = 20;
+  connect_controller(door);
+  // Position 60/200 = 0.3 while opening, so a 0.5 target is armed and under way.
+  door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x003C, 0x0100}));
+  ASSERT_TRUE(door.set_position(0.5f));
+  consume_command(door);
+  ASSERT_TRUE(door.toggle_light());
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(30));
+  door.update();
+  ASSERT_FALSE(door.is_valid());
+
+  // Back on the bus and travelling past where the target was: nothing should stop the door now.
+  connect_controller(door);
+  door.on_write_registers(BROADCAST_REG, make_registers({0x0000, 0x0078, 0x0100}));
+  auto [pressed, pressed_2] = poll_command(door);
+  EXPECT_EQ(pressed, 0x0000);
+  EXPECT_EQ(pressed_2, 0x0000);
+}
+
+// Withdrawing a later toggle must not take the deadline of the one already on the wire with it, or a door
+// that never reports the lamp would leave the entity waiting for ever.
+TEST(HoermannHcpLightPlatformTest, WithdrawingALaterToggleKeepsTheWatchdogArmed) {
+  LightFixture fixture;
+  fixture.door.connection_timeout_ms_ = 20;
+  fixture.bring_up();
+
+  fixture.command(true);
+  consume_command(fixture.door);  // the first toggle is released but never reported back
+  fixture.command(false);
+  ASSERT_EQ(fixture.door.light_toggles_in_flight_, 2);
+  fixture.command(true);  // withdraws the second, leaving the first outstanding
+  ASSERT_EQ(fixture.door.light_toggles_in_flight_, 1);
+
+  // The door still says nothing about the lamp, so the wait has to time out on its own.
+  std::this_thread::sleep_for(std::chrono::milliseconds(30));
+  fixture.report_lamp(false);
+  EXPECT_EQ(fixture.door.light_toggles_in_flight_, 0);
+  EXPECT_FALSE(fixture.entity_on());
+}
+
+// A request refused while the lamp is unknown must leave the entity idle. Republishing unconditionally would
+// re-enter write_state() on every loop, so the platform would never stop asking to be written.
+TEST(HoermannHcpLightPlatformTest, RefusedRequestLeavesTheEntityIdle) {
+  LightFixture fixture;
+  connect_controller(fixture.door);
+  fixture.settle();
+  ASSERT_FALSE(fixture.door.is_light_known());
+
+  // The lamp is unknown and the entity already shows off, so asking for off cannot be serviced or displayed.
+  fixture.command(false);
+  const int settled_writes = fixture.output.writes;
+  fixture.settle();
+  EXPECT_EQ(fixture.output.writes, settled_writes);
+}
+
+// A door that acts on the key press and reports the lamp before the release is even fetched leaves nothing
+// outstanding. Arming the watchdog on that release anyway would leave it firing on every poll and abandoning
+// the next toggle the moment it is queued.
+TEST(HoermannHcpLightTest, ReleaseWithNothingOutstandingLeavesTheWatchdogDisarmed) {
+  TestableHoermannHcp door;
+  connect_controller(door);
+  door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0000));
+  ASSERT_TRUE(door.toggle_light());
+  poll_command(door);  // the door is shown the key press
+
+  // The door acts on it and reports the lamp straight away, which settles the count.
+  door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0010));
+  ASSERT_EQ(door.light_toggles_in_flight_, 0);
+
+  std::this_thread::sleep_for(KEY_PRESS_ELAPSED);
+  poll_command(door);  // the release, with nothing left to wait for
+  EXPECT_EQ(door.light_toggle_released_at_, 0u);
+}
+
+// A restore mode that boots the entity on replays a lit state the door has never confirmed, so it has to be
+// adopted back to what is known rather than turned into a command.
+TEST(HoermannHcpLightPlatformTest, RestoredOnStateIsAdoptedNotCommanded) {
+  LightFixture fixture{light::LIGHT_ALWAYS_ON};
+  connect_controller(fixture.door);
+  fixture.settle();
+
+  auto [idle, idle_2] = poll_command(fixture.door);
+  EXPECT_EQ(idle, 0x0000);
+  EXPECT_EQ(idle_2, 0x0000);
+  EXPECT_FALSE(fixture.entity_on());
+}
+
+// A reversing press before the toggle is fetched cancels it, so the lamp never moves.
+TEST(HoermannHcpLightPlatformTest, ReversingPressCancelsTheQueuedToggle) {
+  LightFixture fixture;
+  fixture.bring_up();
+
+  fixture.command(true);
+  ASSERT_TRUE(fixture.door.is_light_toggle_pending_());
+
+  fixture.command(false);
+  EXPECT_FALSE(fixture.door.is_light_toggle_pending_());
+  EXPECT_FALSE(fixture.entity_on());
+
+  // Nothing is left for the controller to fetch, so the lamp stays off as asked.
+  auto [pressed, pressed_2] = poll_command(fixture.door);
+  EXPECT_EQ(pressed, 0x0000);
+  EXPECT_EQ(pressed_2, 0x0000);
+}
+
+// A lamp switched at the door itself is not one of our toggles landing, so a toggle the door has not even
+// been shown has to keep counting.
+TEST(HoermannHcpLightTest, DoorSideLampChangeLeavesAnUnsentToggleCounted) {
+  TestableHoermannHcp door;
+  connect_controller(door);
+  door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0000));
+  ASSERT_TRUE(door.toggle_light());
+
+  door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0010));
+
+  EXPECT_EQ(door.light_toggles_in_flight_, 1);
+  // The toggle still in the slot will invert what the door just reported.
+  EXPECT_FALSE(door.is_light_heading_on());
+}
+
+// Once the toggles left over are all still waiting in the slot, nothing the door has seen is outstanding,
+// so the wait has to end rather than time out against toggles the door was never shown.
+TEST(HoermannHcpLightTest, SettlingTheLastSentToggleEndsTheWait) {
+  TestableHoermannHcp door;
+  connect_controller(door);
+  door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0000));
+  ASSERT_TRUE(door.toggle_light());
+  consume_command(door);             // shown to the door, so the wait for a lamp report starts
+  ASSERT_TRUE(door.toggle_light());  // queued behind it, never shown
+  ASSERT_NE(door.light_toggle_released_at_, 0u);
+
+  // The door reports the lamp change the first toggle caused, leaving only the unsent one.
+  door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0010));
+
+  ASSERT_EQ(door.light_toggles_in_flight_, 1);
+  EXPECT_EQ(door.light_toggle_released_at_, 0u);
+}
+
+// The watchdog gives up on the toggles the door was shown, but one still waiting in the command slot is
+// going to fire, so it keeps counting.
+TEST(HoermannHcpLightTest, WatchdogKeepsAToggleTheDoorHasNotSeen) {
+  TestableHoermannHcp door;
+  // Wide enough that the toggle queued after the sleep cannot expire before update() runs.
+  door.connection_timeout_ms_ = 200;
+  connect_controller(door);
+  door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0000));
+  ASSERT_TRUE(door.toggle_light());
+  consume_command(door);  // shown to the door, which then says nothing about the lamp
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(220));
+  // Queued just now, so only the wait for the first toggle is overdue.
+  door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0000));
+  ASSERT_TRUE(door.toggle_light());
+  door.update();
+
+  EXPECT_EQ(door.light_toggles_in_flight_, 1);
+  EXPECT_TRUE(door.is_light_toggle_pending_());
+  EXPECT_TRUE(door.is_light_heading_on());
+}
+
+// Only the parity of the outstanding count says where the lamp is heading, so the count must not run away.
+TEST(HoermannHcpLightTest, TogglesAreRefusedOnceTooManyAreOutstanding) {
+  TestableHoermannHcp door;
+  connect_controller(door);
+  door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0000));
+
+  // The door takes every key press but never reports the lamp, so nothing is ever confirmed.
+  for (int i = 0; i < 4; i++) {
+    ASSERT_TRUE(door.toggle_light());
+    consume_command(door);
+  }
+
+  EXPECT_FALSE(door.toggle_light());
+  EXPECT_EQ(door.light_toggles_in_flight_, 4);
+}
+
+// A controller that stops carrying the lamp register leaves nothing refreshing it, so the entity has to flag
+// itself rather than command against what was read before.
+TEST(HoermannHcpLightPlatformTest, BroadcastWithoutTheLampRegisterMarksItUnknown) {
+  LightFixture fixture;
+  fixture.bring_up();
+  ASSERT_TRUE(fixture.door.is_light_known());
+
+  fixture.report_broadcast(make_registers({0x0000, 0x0000, 0x4000}));
+
+  EXPECT_FALSE(fixture.door.is_light_known());
+  EXPECT_TRUE(fixture.output.status_has_warning());
+}
+
+// A publish of ours only reaches write_state() a loop pass later. If the lamp changed at the door in that
+// gap, the write still carries the old value and must not be taken for a request to invert the lamp.
+TEST(HoermannHcpLightPlatformTest, PublishOvertakenByTheLampIsNotARequest) {
+  LightFixture fixture;
+  fixture.bring_up();
+  // A door command holds the only command slot, so the request below is refused and the lamp published back.
+  ASSERT_TRUE(fixture.door.open_door());
+
+  auto call = fixture.state.make_call();
+  call.set_state(true);
+  call.perform();
+  fixture.state.loop();  // the refusal happens here and schedules the publish for a later pass
+
+  // The slot frees up and the lamp is switched on at the door before that publish arrives.
+  consume_command(fixture.door);
+  fixture.door.on_write_registers(BROADCAST_REG, lamp_broadcast(0x0010));
+  fixture.settle();
+
+  EXPECT_EQ(fixture.door.light_toggles_in_flight_, 0);
+  EXPECT_TRUE(fixture.entity_on());
+}
+
+}  // namespace esphome::hoermann_hcp::testing