test_deviceWrappers.cpp

Go to the documentation of this file.

 
 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include <cstdint>
#include <memory>
#include <optional>
#include <ranges>
#include <string>
#include <utility>
#include <vector>
 
#include "mocks/mockAlarmListener.h"
#include "mocks/mockRPCCon.h"
#include "profinet/device.h"
#include "profinet/exceptions.h"
#include "profinet/indices.h"
 
using ::testing::_;
using ::testing::DoAll;
using ::testing::Eq;
using ::testing::Return;
using ::testing::Throw;
 
namespace profinet::device
{
 
namespace
{
 
constexpr MacAddress kControllerMac{
    0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
 
dcp::DCPDeviceDescription MakeInfo(
    std::string name = "dev",
    std::string ip = "192.168.0.10",
    std::string mac = "02:00:00:00:00:01")
{
  dcp::DCPDeviceDescription info(
      String2Mac(mac),
      {});
 
  info.name = std::move(name);
  info.ip = std::move(ip);
  info.mac = std::move(mac);
  info.deviceType = "test";
  info.netmask = "255.255.255.0";
  info.gateway = "0.0.0.0";
 
  return info;
}
 
} // namespace
 
// ============================================================================
// ParseMacTests
// ============================================================================
 
class ParseMacTests : public ::testing::Test
{
};
 
TEST_F(ParseMacTests, ParsesColonSeparatedMac)
{
  const auto result = ParseMac("02:00:00:00:00:01");
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(*result, (MacAddress{0x02, 0x00, 0x00, 0x00, 0x00, 0x01}));
}
 
TEST_F(ParseMacTests, ParsesDashSeparatedMac)
{
  const auto result = ParseMac("02-00-00-00-00-01");
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(*result, (MacAddress{0x02, 0x00, 0x00, 0x00, 0x00, 0x01}));
}
 
TEST_F(ParseMacTests, ParsesDotSeparatedMac)
{
  const auto result = ParseMac("0200.0000.0001");
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(*result, (MacAddress{0x02, 0x00, 0x00, 0x00, 0x00, 0x01}));
}
 
TEST_F(ParseMacTests, RejectsInvalidMac)
{
  EXPECT_FALSE(ParseMac("not-a-mac").has_value());
}
 
TEST_F(ParseMacTests, IsMacAddressAcceptsValidMac)
{
  EXPECT_TRUE(IsMacAddress("02:00:00:00:00:01"));
}
 
TEST_F(ParseMacTests, IsMacAddressRejectsInvalidIdentifier)
{
  EXPECT_FALSE(IsMacAddress("device-name"));
}
 
// ============================================================================
// DeviceInfoTests
// ============================================================================
 
class DeviceInfoTests : public ::testing::Test
{
};
 
TEST_F(DeviceInfoTests, SerialNumberReturnsEmptyWhenIm0Missing)
{
  DeviceInfo info;
 
  EXPECT_TRUE(info.SerialNumber().empty());
}
 
TEST_F(DeviceInfoTests, OrderIdReturnsEmptyWhenIm0Missing)
{
  DeviceInfo info;
 
  EXPECT_TRUE(info.OrderId().empty());
}
 
TEST_F(DeviceInfoTests, HardwareRevisionReturnsZeroWhenIm0Missing)
{
  DeviceInfo info;
 
  EXPECT_EQ(info.HardwareRevision(), 0);
}
 
TEST_F(DeviceInfoTests, SoftwareRevisionReturnsEmptyWhenIm0Missing)
{
  DeviceInfo info;
 
  EXPECT_TRUE(info.SoftwareRevision().empty());
}
 
// ============================================================================
// ProfinetDeviceReadWriteTests
// ============================================================================
//
// These tests assume an injectable RPC interface. Replace MockRPCCon and the
// injection mechanism with the concrete mock abstraction used by the project.
// ============================================================================
 
class ProfinetDeviceReadWriteTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    auto mock = std::make_unique<testing::NiceMock<rpc::MockRPCCon>>();
    rpc = mock.get();
    device = std::make_unique<ProfinetDevice>(MakeInfo(), "eth0", kControllerMac, 5.0, std::move(mock));
  }
 
  std::unique_ptr<ProfinetDevice> device;
  rpc::MockRPCCon* rpc;
};
 
TEST_F(ProfinetDeviceReadWriteTests, ReadReturnsRpcPayload)
{
  PNIODHeader readResult{};
  readResult.payload = Bytes{0x01, 0x02};
 
  EXPECT_CALL(*rpc, Read(0, 1, 2, 0xAFF0))
      .WillOnce(Return(readResult));
 
  // Expected:
  EXPECT_EQ(device->Read(1, 2, 0xAFF0),
            (Bytes{0x01, 0x02}));
}
 
TEST_F(ProfinetDeviceReadWriteTests, WriteDelegatesArguments)
{
  const Bytes data{0xAB};
 
  EXPECT_CALL(*rpc, Write(3, 1, 2, 0xAFF1, data));
 
  device->Write(1, 2, 0xAFF1, data, 3);
}
 
TEST_F(ProfinetDeviceReadWriteTests, WriteMultipleMapsItems)
{
  const std::vector<WriteItem> writes{
      WriteItem{
          .slot = 1,
          .subslot = 2,
          .index = 0xAFF1,
          .data = Bytes{0x01},
          .api = 0,
      }};
 
  EXPECT_CALL(*rpc, Connect(_, _, _))
      .WillOnce(Return(std::nullopt));
 
  EXPECT_CALL(*rpc, WriteMultiple(_))
      .WillOnce([](const std::vector<rpc::WriteItem>& items)
  {
    EXPECT_EQ(items.size(), 1U);
    if (items.size() != 1U)
    {
      return std::vector<blocks::WriteMultipleResult>{};
    }
    EXPECT_EQ(items[0].slot, 1);
    EXPECT_EQ(items[0].subslot, 2);
    EXPECT_EQ(items[0].index, 0xAFF1);
    EXPECT_EQ(items[0].data, (Bytes{0x01}));
    EXPECT_EQ(items[0].api, 0);
 
    return std::vector<blocks::WriteMultipleResult>{};
  });
 
  device->WriteMultiple(writes);
}
 
// ============================================================================
// ProfinetDeviceImTests
// ============================================================================
 
class ProfinetDeviceImTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    auto mock = std::make_unique<testing::NiceMock<rpc::MockRPCCon>>();
    rpc = mock.get();
 
    device = std::make_unique<ProfinetDevice>(MakeInfo(), "eth0", kControllerMac, 5.0, std::move(mock));
  }
 
  std::unique_ptr<ProfinetDevice> device;
  rpc::MockRPCCon* rpc;
};
 
TEST_F(ProfinetDeviceImTests, ReadIm0Delegates)
{
  PNInM0 expected;
  EXPECT_CALL(*rpc, ReadIm0(1, 2))
      .WillOnce(Return(expected));
 
  EXPECT_EQ(device->ReadIm0(1, 2), expected);
}
 
TEST_F(ProfinetDeviceImTests, ReadIm1Delegates)
{
  PNInM1 expected;
  EXPECT_CALL(*rpc, ReadIm1(1, 2))
      .WillOnce(Return(expected));
 
  EXPECT_EQ(device->ReadIm1(1, 2), expected);
}
 
TEST_F(ProfinetDeviceImTests, ReadIm2Delegates)
{
  PNInM2 expected;
 
  EXPECT_CALL(*rpc, ReadIm2(1, 2))
      .WillOnce(Return(expected));
 
  EXPECT_EQ(device->ReadIm2(1, 2), expected);
}
 
TEST_F(ProfinetDeviceImTests, ReadIm3Delegates)
{
  PNInM3 expected;
  EXPECT_CALL(*rpc, ReadIm3(1, 2))
      .WillOnce(Return(expected));
 
  EXPECT_EQ(device->ReadIm3(1, 2), expected);
}
 
TEST_F(ProfinetDeviceImTests, ReadIm4Delegates)
{
  PNInM4 expected;
  EXPECT_CALL(*rpc, ReadIm4(1, 2))
      .WillOnce(Return(expected));
 
  EXPECT_EQ(device->ReadIm4(1, 2), expected);
}
 
TEST_F(ProfinetDeviceImTests, ReadIm5Delegates)
{
  PNInM5 expected;
  EXPECT_CALL(*rpc, ReadIm5(1, 2))
      .WillOnce(Return(expected));
 
  EXPECT_EQ(device->ReadIm5(1, 2), expected);
}
 
TEST_F(ProfinetDeviceImTests, ReadAllImDelegates)
{
  rpc::AllIM expected;
  EXPECT_CALL(*rpc, ReadAllIm(1, 2))
      .WillOnce(Return(expected));
 
  EXPECT_EQ(device->ReadAllIm(1, 2), expected);
}
 
TEST_F(ProfinetDeviceImTests, WriteIm1BuildsPaddedBlock)
{
  EXPECT_CALL(*rpc, Write(0, 0, 1, IM1, _))
      .WillOnce([](std::uint32_t,
                   std::uint16_t,
                   std::uint16_t,
                   std::uint16_t,
                   const Bytes& data)
  {
    EXPECT_EQ(data.size(), 62U);
    if (data.size() != 62U)
    {
      return;
    }
    wire::Reader r(data);
    EXPECT_EQ(r.U16(), static_cast<std::uint16_t>(0x0021));
    EXPECT_EQ(r.U16(), static_cast<std::uint16_t>(58));
 
    Bytes expected(32, static_cast<std::uint8_t>(' '));
    std::ranges::copy(std::string_view{"func"}, expected.begin());
 
    EXPECT_EQ(Bytes(data.begin() + 8, data.begin() + 40), expected);
 
    return;
  });
 
  device->WriteIm1("func", "loc");
}
 
TEST_F(ProfinetDeviceImTests, WriteIm1RejectsFunctionLongerThan32Characters)
{
  EXPECT_THROW(
      device->WriteIm1(std::string(33, 'x'), "loc"),
      std::invalid_argument);
}
 
TEST_F(ProfinetDeviceImTests, WriteIm1RejectsLocationLongerThan22Characters)
{
  EXPECT_THROW(
      device->WriteIm1("func", std::string(23, 'x')),
      std::invalid_argument);
}
 
TEST_F(ProfinetDeviceImTests, WriteIm2BuildsPaddedBlock)
{
  EXPECT_CALL(*rpc, Write(0, 0, 1, IM2, _))
      .WillOnce([](std::uint32_t,
                   std::uint16_t,
                   std::uint16_t,
                   std::uint16_t,
                   const Bytes& data)
  {
    EXPECT_EQ(data.size(), 24U);
    if (data.size() != 24U)
    {
      return;
    }
    wire::Reader r(data);
 
    EXPECT_EQ(r.U16(), 0x0022);
    EXPECT_EQ(r.U16(), 20);
 
    const Bytes expected{
        '2', '0', '2', '6', '-', '0', '7', '-', '2', '1',
        ' ', '1', '8', ':', '0', '0'};
 
    EXPECT_EQ(Bytes(data.begin() + 8, data.begin() + 24),
              expected);
  });
 
  device->WriteIm2("2026-07-21 18:00");
}
 
TEST_F(ProfinetDeviceImTests, WriteIm2RejectsDateLongerThan16Characters)
{
  EXPECT_THROW(
      device->WriteIm2(std::string(17, 'x')),
      std::invalid_argument);
}
 
TEST_F(ProfinetDeviceImTests, WriteIm3BuildsPaddedBlock)
{
  EXPECT_CALL(*rpc, Write(0, 0, 1, IM3, _))
      .WillOnce([](std::uint32_t,
                   std::uint16_t,
                   std::uint16_t,
                   std::uint16_t,
                   const Bytes& data)
  {
    ASSERT_EQ(data.size(), 62U);
    if (data.size() != 62U)
    {
      return;
    }
    wire::Reader r(data);
 
    EXPECT_EQ(r.U16(), 0x0023);
    EXPECT_EQ(r.U16(), 58);
    Bytes expected(54, static_cast<std::uint8_t>(' '));
    std::ranges::copy("descriptor" | std::views::take(10), expected.begin());
 
    EXPECT_EQ(Bytes(data.begin() + 8, data.begin() + 62), expected);
  });
 
  device->WriteIm3("descriptor");
}
 
TEST_F(ProfinetDeviceImTests, WriteIm3RejectsDescriptorLongerThan54Characters)
{
  EXPECT_THROW(
      device->WriteIm3(std::string(55, 'x')),
      std::invalid_argument);
}
 
// ============================================================================
// ProfinetDeviceDiagnosisTests
// ============================================================================
 
class ProfinetDeviceDiagnosisTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    auto mock = std::make_unique<testing::NiceMock<rpc::MockRPCCon>>();
    rpc = mock.get();
 
    device = std::make_unique<ProfinetDevice>(MakeInfo(), "eth0", kControllerMac, 5.0, std::move(mock));
  }
  Bytes MakeBlockHeader(std::uint16_t blockType,
                        std::uint16_t blockLength,
                        std::uint8_t verHi = 1,
                        std::uint8_t verLo = 0)
  {
    Bytes out;
    wire::PutU16(out, blockType);
    wire::PutU16(out, blockLength);
    wire::PutU8(out, verHi);
    wire::PutU8(out, verLo);
    return out;
  }
 
  Bytes MakeModuleDiffBlock(std::uint16_t slot,
                            std::uint16_t subslot,
                            std::uint16_t moduleState,
                            std::uint16_t submoduleState)
  {
    Bytes body;
 
    wire::PutU16(body, 1);      // NumberOfAPIs
    wire::PutU32(body, 0);      // API
    wire::PutU16(body, 1);      // NumberOfModules
    wire::PutU16(body, slot);   // SlotNumber
    wire::PutU32(body, 0x0001); // ModuleIdentNumber
    wire::PutU16(body, moduleState);
    wire::PutU16(body, 1); // NumberOfSubmodules
    wire::PutU16(body, subslot);
    wire::PutU32(body, 0x0001); // SubmoduleIdentNumber
    wire::PutU16(body, submoduleState);
 
    const Bytes hdr = MakeBlockHeader(
        static_cast<std::uint16_t>(BlockType::ModuleDifference),
        static_cast<std::uint16_t>(body.size() + 2));
 
    Bytes out = hdr;
    out.insert(out.end(), body.begin(), body.end());
 
    return out;
  }
 
  std::unique_ptr<ProfinetDevice> device;
  rpc::MockRPCCon* rpc;
};
 
TEST_F(ProfinetDeviceDiagnosisTests, ReadModuleDiffDelegates)
{
  const Bytes data = MakeModuleDiffBlock(
      1,
      1,
      MODULE_STATE_PROPER_MODULE,
      SUBMODULE_STATE_OK);
 
  auto expected = blocks::ParseModuleDiffBlock(data);
 
  EXPECT_CALL(*rpc, ReadModuleDiff()).WillOnce(Return(expected));
  EXPECT_EQ(device->ReadModuleDiff(), expected);
}
 
TEST_F(ProfinetDeviceDiagnosisTests, ReadDiagnosisDelegatesArguments)
{
  diagnosis::DiagnosisData expected;
  EXPECT_CALL(*rpc, ReadDiagnosis(1, 2, 0xF00C))
      .WillOnce(Return(expected));
 
  EXPECT_EQ(device->ReadDiagnosis(1, 2, 0xF00C), expected);
}
 
TEST_F(ProfinetDeviceDiagnosisTests, ReadAllDiagnosisDelegates)
{
  std::map<std::uint16_t, diagnosis::DiagnosisData> expected;
  EXPECT_CALL(*rpc, ReadAllDiagnosis()).WillOnce(Return(expected));
  EXPECT_EQ(device->ReadAllDiagnosis(), expected);
}
 
TEST_F(ProfinetDeviceDiagnosisTests, DiscoverSlotsDelegates)
{
  std::vector<blocks::SlotInfo> expected;
  EXPECT_CALL(*rpc, DiscoverSlots()).WillOnce(Return(expected));
  EXPECT_EQ(device->DiscoverSlots(), expected);
}
 
TEST_F(ProfinetDeviceDiagnosisTests, ReadTopologyDelegates)
{
  blocks::PDRealData expected;
  EXPECT_CALL(*rpc, ReadPdRealData()).WillOnce(Return(expected));
  EXPECT_EQ(device->ReadTopology(), expected);
}
 
// ============================================================================
// ProfinetDeviceAlarmTests
// ============================================================================
 
class ProfinetDeviceAlarmTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    auto mock = std::make_unique<testing::NiceMock<rpc::MockRPCCon>>();
    rpc = mock.get();
 
    device = std::make_unique<ProfinetDevice>(MakeInfo(), "eth0", kControllerMac, 5.0, std::move(mock));
  }
 
  std::unique_ptr<ProfinetDevice> device;
  rpc::MockRPCCon* rpc;
};
 
TEST_F(ProfinetDeviceAlarmTests, ReturnsNoneOnRpcError)
{
  EXPECT_CALL(*rpc, Read(0, 0, 0, 0x800C))
      .WillOnce(Throw(RPCError("nope")));
 
  EXPECT_FALSE(device->ReadAlarm().has_value());
}
 
TEST_F(ProfinetDeviceAlarmTests, ReturnsNoneOnShortPayload)
{
  PNIODHeader readResult{};
  readResult.payload = Bytes{0x04, 0x00};
 
  EXPECT_CALL(*rpc, Read(_, _, _, _))
      .WillOnce(Return(readResult));
 
  EXPECT_FALSE(device->ReadAlarm().has_value());
}
 
TEST_F(ProfinetDeviceAlarmTests, ParsesAlarmPayload)
{
  const Bytes block{
      // Block header
      0x00, 0x02, // BlockType = 0x0002
      0x00, 0x16, // BlockLength = 20 + 2
      0x01,       // BlockVersionHigh
      0x00,       // BlockVersionLow
 
      // body
      0x00, 0x01,             // H = 0x0001
      0x00, 0x00, 0x00, 0x00, // I = 0
      0x00, 0x01,             // H = 1
      0x00, 0x01,             // H = 1
      0x00, 0x00, 0x00, 0x01, // I = 0x01
      0x00, 0x00, 0x00, 0x01, // I = 0x01
      0x04, 0x05,             // H = 0x0400 | 5
 
      // padding
      0x00, 0x00};
  PNIODHeader readResult{};
  readResult.payload = block;
 
  EXPECT_CALL(*rpc, Read(_, _, _, _))
      .WillOnce(Return(readResult));
 
  const auto alarm = device->ReadAlarm(1, 0);
 
  ASSERT_TRUE(alarm.has_value());
  EXPECT_EQ(alarm->slotNumber, 1);
}
 
// ============================================================================
// ProfinetDeviceConnectionLifecycleTests
// ============================================================================
 
class ProfinetDeviceConnectionLifecycleTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    auto mockRPC = std::make_unique<testing::NiceMock<rpc::MockRPCCon>>();
    rpc = mockRPC.get();
 
    auto mockAL = std::make_unique<testing::NiceMock<MockAlarmListener>>();
    alarmListener = mockAL.get();
    device = std::make_unique<ProfinetDevice>(MakeInfo(), "eth0", kControllerMac, 5.0, std::move(mockRPC), std::move(mockAL));
  }
 
  std::unique_ptr<ProfinetDevice> device;
  rpc::MockRPCCon* rpc;
  MockAlarmListener* alarmListener;
};
 
TEST_F(ProfinetDeviceConnectionLifecycleTests, ConnectSuccess)
{
  EXPECT_CALL(*rpc, Connect);
 
  device->Connect();
 
  EXPECT_TRUE(device->IsConnected());
}
 
TEST_F(ProfinetDeviceConnectionLifecycleTests, ConnectFailureIsWrapped)
{
  EXPECT_CALL(*rpc, Connect)
      .WillOnce(Throw(RPCError("refused")));
 
  EXPECT_THROW(device->Connect(), RPCConnectionError);
  EXPECT_FALSE(device->IsConnected());
}
 
TEST_F(ProfinetDeviceConnectionLifecycleTests, ConnectIsNoOpWhenAlreadyConnected)
{
  // Establish a connected device first.
 
  device->Connect();
 
  EXPECT_CALL(*rpc, Connect).Times(0);
 
  device->Connect();
 
  EXPECT_TRUE(device->IsConnected());
}
 
TEST_F(ProfinetDeviceConnectionLifecycleTests, DisconnectClearsConnectionState)
{
  EXPECT_CALL(*rpc, Disconnect());
 
  device->Disconnect();
 
  EXPECT_FALSE(device->IsConnected());
}
 
TEST_F(ProfinetDeviceConnectionLifecycleTests, CloseClosesRpc)
{
  EXPECT_CALL(*rpc, Close());
 
  device->Close();
 
  EXPECT_FALSE(device->IsConnected());
}
 
TEST_F(ProfinetDeviceConnectionLifecycleTests, DISABLED_CloseStopsAlarmListener)
{
  // Configure alarm listener mock.
 
  device->Close();
 
  EXPECT_CALL(*alarmListener, Stop());
}
 
TEST_F(ProfinetDeviceConnectionLifecycleTests, ReleaseArClearsOnlyCurrentRpc)
{
  // This test requires access to the RPC object/reference used by the
  // ProfinetDevice and a second independent RPCCon instance.
 
  // device->ReleaseAr(otherRpc);
  // EXPECT_TRUE(device->IsConnected());
 
  // device->ReleaseAr(currentRpc);
  // EXPECT_FALSE(device->IsConnected());
}
 
TEST_F(ProfinetDeviceConnectionLifecycleTests, ReleaseArSuppressesDisconnectErrors)
{
  // EXPECT_CALL(*rpc, Disconnect())
  //     .WillOnce(Throw(std::runtime_error("gone")));
  //
  // EXPECT_NO_THROW(device->ReleaseAr(*rpc));
  // EXPECT_FALSE(device->IsConnected());
}
 
// ============================================================================
// ProfinetDeviceAlarmListenerTests
// ============================================================================
 
class ProfinetDeviceAlarmListenerTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    auto mockRPC = std::make_unique<testing::NiceMock<rpc::MockRPCCon>>();
    rpc = mockRPC.get();
 
    auto mockAL = std::make_unique<testing::NiceMock<MockAlarmListener>>();
    alarmListener = mockAL.get();
    device = std::make_unique<ProfinetDevice>(MakeInfo(), "eth0", kControllerMac, 5.0, std::move(mockRPC), std::move(mockAL));
  }
 
  std::unique_ptr<ProfinetDevice> device;
  rpc::MockRPCCon* rpc;
  MockAlarmListener* alarmListener;
};
 
TEST_F(ProfinetDeviceAlarmListenerTests, RequiresConnection)
{
  EXPECT_THROW(device->StartAlarmListener(), std::runtime_error);
}
 
TEST_F(ProfinetDeviceAlarmListenerTests, RequiresAlarmCr)
{
  // Configure a connected RPC mock with HasAlarmCr() == false.
 
  EXPECT_THROW(device->StartAlarmListener(), std::runtime_error);
}
 
TEST_F(ProfinetDeviceAlarmListenerTests, StartAndRunningProperty)
{
  EXPECT_CALL(*rpc, HasAlarmCr())
      .WillOnce(Return(true));
  EXPECT_CALL(*rpc, LocalAlarmRef())
      .WillOnce(Return(1));
  EXPECT_CALL(*rpc, DeviceAlarmRef())
      .WillOnce(Return(42));
 
  EXPECT_CALL(*alarmListener, Start(_, _)).Times(1);
  EXPECT_CALL(*alarmListener, IsRunning())
      .WillOnce(Return(false))
      .WillOnce(Return(false))
      .WillOnce(Return(true));
  EXPECT_CALL(*rpc, Connect);
  device->Connect();
  device->OnAlarm([](const AlarmNotification&) {});
  device->StartAlarmListener();
 
  EXPECT_TRUE(device->AlarmListenerRunning());
}
 
TEST_F(ProfinetDeviceAlarmListenerTests, OnAlarmForwardsToRunningListener)
{
  // Configure an existing alarm listener mock.
 
  const auto callback = [](const AlarmNotification&) {};
 
  EXPECT_CALL(*alarmListener, AddAlarmNotificationCallback(_));
  EXPECT_CALL(*alarmListener, IsRunning())
      .WillOnce(Return(true));
  device->OnAlarm(callback);
}
 
TEST_F(ProfinetDeviceAlarmListenerTests, StopRemovesListener)
{
  device->StopAlarmListener();
 
  EXPECT_FALSE(device->AlarmListenerRunning());
}
TEST_F(ProfinetDeviceAlarmListenerTests, RepeatedStartDoesNotDuplicateCallbackRegistration)
{
  EXPECT_CALL(*rpc, HasAlarmCr())
      .WillRepeatedly(Return(true));
 
  EXPECT_CALL(*rpc, LocalAlarmRef())
      .WillRepeatedly(Return(1));
 
  EXPECT_CALL(*rpc, DeviceAlarmRef())
      .WillRepeatedly(Return(42));
 
  EXPECT_CALL(*alarmListener, IsRunning())
      .WillOnce(Return(false))
      .WillOnce(Return(false))
      .WillRepeatedly(Return(true));
 
  const auto callback = [](const AlarmNotification&) {};
 
  EXPECT_CALL(*alarmListener, AddAlarmNotificationCallback(_))
      .Times(1);
 
  EXPECT_CALL(*alarmListener, Start(_, _))
      .Times(1);
 
  EXPECT_CALL(*rpc, Connect);
 
  device->Connect();
  device->OnAlarm(callback);
 
  device->StartAlarmListener();
  device->StartAlarmListener();
}
 
TEST_F(ProfinetDeviceAlarmListenerTests, CallbackAddedBeforeStartIsRegisteredOnce)
{
  EXPECT_CALL(*rpc, HasAlarmCr())
      .WillOnce(Return(true));
 
  EXPECT_CALL(*rpc, LocalAlarmRef())
      .WillOnce(Return(1));
 
  EXPECT_CALL(*rpc, DeviceAlarmRef())
      .WillOnce(Return(42));
 
  EXPECT_CALL(*alarmListener, IsRunning())
      .WillOnce(Return(false))
      .WillOnce(Return(false));
 
  EXPECT_CALL(*alarmListener, AddAlarmNotificationCallback(_))
      .Times(1);
 
  EXPECT_CALL(*alarmListener, Start(_, _))
      .Times(1);
 
  EXPECT_CALL(*rpc, Connect);
 
  device->Connect();
 
  device->OnAlarm([](const AlarmNotification&) {});
  device->StartAlarmListener();
}
TEST_F(ProfinetDeviceAlarmListenerTests, CallbackAddedWhileRunningIsForwardedOnce)
{
  const auto callback = [](const AlarmNotification&) {};
 
  EXPECT_CALL(*alarmListener, IsRunning())
      .WillOnce(Return(true));
 
  EXPECT_CALL(*alarmListener, AddAlarmNotificationCallback(_))
      .Times(1);
 
  device->OnAlarm(callback);
}
// ============================================================================
// ProfinetDeviceInfoTests
// ============================================================================
 
class ProfinetDeviceInfoTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    auto mock = std::make_unique<testing::NiceMock<rpc::MockRPCCon>>();
    rpc = mock.get();
 
    device = std::make_unique<ProfinetDevice>(MakeInfo(), "eth0", kControllerMac, 5.0, std::move(mock));
  }
 
  std::unique_ptr<ProfinetDevice> device;
  rpc::MockRPCCon* rpc;
};
 
TEST_F(ProfinetDeviceInfoTests, CollectsIm0)
{
  PNInM0 expectedIm0;
  EXPECT_CALL(*rpc, ReadIm0(0, 1))
      .WillOnce(Return(expectedIm0));
 
  const DeviceInfo info = device->GetInfo();
 
  ASSERT_TRUE(info.im0.has_value());
}
 
TEST_F(ProfinetDeviceInfoTests, Im0FailureIsTolerated)
{
  EXPECT_CALL(*rpc, ReadIm0(0, 1))
      .WillOnce(Throw(RPCError("unsupported")));
 
  const DeviceInfo info = device->GetInfo();
 
  EXPECT_FALSE(info.im0.has_value());
}
 
TEST_F(ProfinetDeviceInfoTests, IncludesTopologyWhenRequested)
{
  blocks::PDRealData expectedTopology;
  //   EXPECT_CALL(*rpc, ReadIm0(0, 1))
  //       .WillOnce(Return(std::nullopt));
 
  EXPECT_CALL(*rpc, ReadPdRealData())
      .WillOnce(Return(expectedTopology));
 
  const DeviceInfo info = device->GetInfo(true);
 
  ASSERT_TRUE(info.topology.has_value());
}
 
TEST_F(ProfinetDeviceInfoTests, DoesNotReadTopologyByDefault)
{
  EXPECT_CALL(*rpc, ReadPdRealData()).Times(0);
 
  const DeviceInfo info = device->GetInfo();
 
  EXPECT_FALSE(info.topology.has_value());
}
 
// ============================================================================
// ProfinetDeviceStringTests
// ============================================================================
 
class ProfinetDeviceStringTests : public ::testing::Test
{
};
 
TEST_F(ProfinetDeviceStringTests, ToStringShowsDisconnectedState)
{
  ProfinetDevice device(
      MakeInfo(),
      "eth0",
      kControllerMac);
 
  EXPECT_EQ(
      device.ToString(),
      "ProfinetDevice('dev', 192.168.0.10, disconnected)");
}
 
} // namespace profinet::device