test(opcua,#386): cover the missing AlarmStateMachine transition cells

Verification round on the post-#386 review found 9 untested cells in
the AlarmStateMachine transition matrix (issue #389 follow-up). Adding
focused tests so a future refactor cannot silently break a corner case.

New cells covered:
- ``DisabledClearsHealedAlarm`` - Healed exit via Rule 2 (was_active=true
  for Healed too, so disabling a latched alarm must ClearFault, not just
  flip to Suppressed).
- ``DisabledNoOpWhenAlreadyCleared`` - confirms Cleared+disabled lands at
  Suppressed/NoOp (no spurious second clear).
- ``ShelvedClearsHealedAlarm`` / ``ShelvedNoOpWhenAlreadyCleared`` - same
  pair via Rule 3.
- ``ActiveAlarmReportsConfirmedFromSuppressed`` - operator
  unshelves/re-enables an alarm whose source is still active; Rule 4
  must promote Suppressed -> Confirmed with ReportConfirmed (NOT NoOp).
  This is exactly the unshelve+re-fire path scenario 2 of
  run_alarm_tests.sh exercises end-to-end.
- ``BranchEventFromHealedNoOp`` / ``BranchEventFromSuppressedNoOp`` -
  Rule 1 precedence holds across all four prev_status values.
- ``AckedAndConfirmedNoOpFromSuppressed`` - ``was_active=false`` branch
  of Rule 5: a fully cleared event delivered while suppressed advances
  next_status to Cleared but issues no ClearFault (no fault to clear).
- ``InactiveUnackedFromSuppressedReportsHealed`` - ditto but with the
  ack/confirm bits unset, must surface as Healed/ReportHealed so the
  unfinished ack/confirm workflow item stays visible.

State machine code itself is unchanged. 27 gtest cases, all PASSED.
Pure-function tests, deterministic, no I/O.

Author: mfaferek93

src/ros2_medkit_plugins/ros2_medkit_opcua/test/test_alarm_state_machine.cpp

@@ -208,4 +208,107 @@ TEST(AlarmStateMachineTest, ShelvedTakesPrecedenceOverActive) {
   EXPECT_EQ(out.action, AlarmAction::NoOp);
 }
 
+// -- Coverage of remaining transition matrix cells (issue #389 follow-up).
+// The above tests exercise the obvious paths; these cover the corners where
+// prev_status is Healed or Suppressed and an exit / re-entry rule fires.
+
+TEST(AlarmStateMachineTest, DisabledClearsHealedAlarm) {
+  // Operator disables an already-latched (Healed) alarm: must transition to
+  // Cleared with a ClearFault action so the latched fault disappears from
+  // /faults instead of orphaning between HEALED and Cleared forever.
+  AlarmEventInput in;
+  in.enabled_state = false;
+  auto out = AlarmStateMachine::compute(SovdAlarmStatus::Healed, in);
+  EXPECT_EQ(out.next_status, SovdAlarmStatus::Cleared);
+  EXPECT_EQ(out.action, AlarmAction::ClearFault);
+}
+
+TEST(AlarmStateMachineTest, DisabledNoOpWhenAlreadyCleared) {
+  AlarmEventInput in;
+  in.enabled_state = false;
+  auto out = AlarmStateMachine::compute(SovdAlarmStatus::Cleared, in);
+  EXPECT_EQ(out.next_status, SovdAlarmStatus::Suppressed);
+  EXPECT_EQ(out.action, AlarmAction::NoOp);
+}
+
+TEST(AlarmStateMachineTest, ShelvedClearsHealedAlarm) {
+  // Same exit shape as Disabled, via the shelving rule.
+  AlarmEventInput in;
+  in.enabled_state = true;
+  in.active_state = false;
+  in.shelved = true;
+  auto out = AlarmStateMachine::compute(SovdAlarmStatus::Healed, in);
+  EXPECT_EQ(out.next_status, SovdAlarmStatus::Cleared);
+  EXPECT_EQ(out.action, AlarmAction::ClearFault);
+}
+
+TEST(AlarmStateMachineTest, ShelvedNoOpWhenAlreadyCleared) {
+  AlarmEventInput in;
+  in.enabled_state = true;
+  in.active_state = false;
+  in.shelved = true;
+  auto out = AlarmStateMachine::compute(SovdAlarmStatus::Cleared, in);
+  EXPECT_EQ(out.next_status, SovdAlarmStatus::Suppressed);
+  EXPECT_EQ(out.action, AlarmAction::NoOp);
+}
+
+TEST(AlarmStateMachineTest, ActiveAlarmReportsConfirmedFromSuppressed) {
+  // Operator unshelves / re-enables an alarm whose underlying source is
+  // still active: the next event has active=true and the state machine
+  // must promote Suppressed -> Confirmed with a ReportConfirmed action.
+  AlarmEventInput in = live_event(true);
+  auto out = AlarmStateMachine::compute(SovdAlarmStatus::Suppressed, in);
+  EXPECT_EQ(out.next_status, SovdAlarmStatus::Confirmed);
+  EXPECT_EQ(out.action, AlarmAction::ReportConfirmed);
+}
+
+TEST(AlarmStateMachineTest, BranchEventFromHealedNoOp) {
+  AlarmEventInput in;
+  in.enabled_state = true;
+  in.branch_id_present = true;
+  auto out = AlarmStateMachine::compute(SovdAlarmStatus::Healed, in);
+  EXPECT_EQ(out.next_status, SovdAlarmStatus::Healed);
+  EXPECT_EQ(out.action, AlarmAction::NoOp);
+}
+
+TEST(AlarmStateMachineTest, BranchEventFromSuppressedNoOp) {
+  AlarmEventInput in;
+  in.enabled_state = true;
+  in.branch_id_present = true;
+  auto out = AlarmStateMachine::compute(SovdAlarmStatus::Suppressed, in);
+  EXPECT_EQ(out.next_status, SovdAlarmStatus::Suppressed);
+  EXPECT_EQ(out.action, AlarmAction::NoOp);
+}
+
+TEST(AlarmStateMachineTest, AckedAndConfirmedNoOpFromSuppressed) {
+  // Suppressed alarm receives a fully-cleared event (active=false,
+  // acked=true, confirmed=true). Was already not-active per the
+  // suppression; no ClearFault to issue, but next_status should track
+  // to Cleared so a later re-fire re-promotes correctly. This is the
+  // ``was_active=false`` branch of rule 5.
+  AlarmEventInput in;
+  in.enabled_state = true;
+  in.active_state = false;
+  in.acked_state = true;
+  in.confirmed_state = true;
+  auto out = AlarmStateMachine::compute(SovdAlarmStatus::Suppressed, in);
+  EXPECT_EQ(out.next_status, SovdAlarmStatus::Cleared);
+  EXPECT_EQ(out.action, AlarmAction::NoOp);
+}
+
+TEST(AlarmStateMachineTest, InactiveUnackedFromSuppressedReportsHealed) {
+  // Suppressed alarm sees an inactive+unacked event (operator unshelved
+  // while the source had already self-cleared but wasn't acked). The
+  // state machine must surface this as Healed so the operator sees the
+  // pending ack/confirm workflow item rather than silently forgetting it.
+  AlarmEventInput in;
+  in.enabled_state = true;
+  in.active_state = false;
+  in.acked_state = false;
+  in.confirmed_state = false;
+  auto out = AlarmStateMachine::compute(SovdAlarmStatus::Suppressed, in);
+  EXPECT_EQ(out.next_status, SovdAlarmStatus::Healed);
+  EXPECT_EQ(out.action, AlarmAction::ReportHealed);
+}
+
 }  // namespace ros2_medkit_gateway