test_alarmListenerRta.cpp

Go to the documentation of this file.

 
 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include <array>
#include <cstdint>
#include <memory>
#include <span>
#include <string>
#include <utility>
#include <vector>
 
#include "mocks/alarmListenerTestAccess.h"
#include "mocks/mockRawEthernetSocket.h"
#include "profinet/alarmListener.h"
#include "profinet/alarms.h"
#include "profinet/protocol.h"
 
namespace profinet
{
 
namespace
{
 
using ::testing::_;
using ::testing::StrictMock;
 
constexpr std::array<std::uint8_t, 6> kControllerMac{0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
 
constexpr std::array<std::uint8_t, 6> kDeviceMac{0x02, 0x00, 0x00, 0x00, 0x00, 0x01};
 
constexpr std::uint16_t kVlanTpid = 0x8100;
constexpr std::uint16_t kVlanPcp6Vid0 = 0xC000;
constexpr std::uint16_t kVlanPcp5Vid0 = 0xA000;
constexpr std::uint16_t kProfinetEtherType = 0x8892;
 
constexpr std::uint16_t kControllerReference = 1;
constexpr std::uint16_t kDeviceReference = 42;
 
constexpr std::uint8_t kRtaVersion = 1;
 
constexpr std::uint8_t kRtaTypeData = 0x01;
constexpr std::uint8_t kRtaTypeAck = 0x03;
constexpr std::uint8_t kRtaTypeNack = 0x02;
constexpr std::uint8_t kRtaTypeErr = 0x0F; // niet 0x04?
 
constexpr std::uint8_t kAddFlagsWindow1 = 0x80;
constexpr std::uint8_t kAddFlagsTack = 0x10;
 
Bytes MakeChannelDiagnosisItem()
{
  Bytes item;
 
  wire::PutU16(item, 0x8000);
  wire::PutU16(item, 1);
  wire::PutU16(item, 0x0800);
  wire::PutU16(item, 9);
 
  return item;
}
[[nodiscard]] Bytes BuildAlarmBlock(bool highPriority = false, std::uint16_t specifier = 0x0401, std::span<const std::uint8_t> items = {})
{
  Bytes body;
 
  wire::PutU16(body, 0x0001);     // AlarmType
  wire::PutU32(body, 0x00000000); // API
  wire::PutU16(body, 0x0001);     // Slot
  wire::PutU16(body, 0x0001);     // Subslot
  wire::PutU32(body, 0x00000001); // ModuleIdent
  wire::PutU32(body, 0x00000001); // SubmoduleIdent
  wire::PutU16(body, specifier);  // AlarmSpecifier
 
  EXPECT_EQ(body.size(), 20U);
 
  Bytes rest{0x01, 0x00};
 
  rest.insert(rest.end(), body.begin(), body.end());
  rest.insert(rest.end(), items.begin(), items.end());
 
  const std::uint16_t blockType = highPriority ? 0x0001 : 0x0002;
 
  Bytes block;
 
  wire::PutU16(block, blockType);
  wire::PutU16(block, static_cast<std::uint16_t>(rest.size()));
  block.insert(block.end(), rest.begin(), rest.end());
 
  return block;
}
 
[[nodiscard]] Bytes BuildRtaFrame(
    std::uint8_t pduType,
    std::uint8_t addFlags,
    std::uint16_t sendSeq,
    std::uint16_t ackSeq,
    std::span<const std::uint8_t> varPart = {},
    std::uint16_t dstRef = kControllerReference,
    std::uint16_t srcRef = kDeviceReference,
    std::uint8_t version = kRtaVersion,
    bool vlan = false,
    std::uint16_t frameId = FRAME_ID_ALARM_LOW)
{
  Bytes rta;
 
  wire::PutU16(rta, dstRef);
  wire::PutU16(rta, srcRef);
  rta.push_back(static_cast<std::uint8_t>((version << 4U) | pduType));
  rta.push_back(addFlags);
  wire::PutU16(rta, sendSeq);
  wire::PutU16(rta, ackSeq);
  wire::PutU16(rta, static_cast<std::uint16_t>(varPart.size()));
  rta.insert(rta.end(), varPart.begin(), varPart.end());
 
  Bytes frame;
 
  // Device -> controller.
  frame.insert(frame.end(), kControllerMac.begin(), kControllerMac.end());
  frame.insert(frame.end(), kDeviceMac.begin(), kDeviceMac.end());
 
  if (vlan)
  {
    wire::PutU16(frame, kVlanTpid);
    wire::PutU16(frame, kVlanPcp6Vid0);
  }
 
  wire::PutU16(frame, kProfinetEtherType);
  wire::PutU16(frame, frameId);
  frame.insert(frame.end(), rta.begin(), rta.end());
 
  return frame;
}
 
struct SentRtaFrame
{
  std::uint16_t frameId = 0;
 
  std::uint16_t dstRef = 0;
 
  std::uint16_t srcRef = 0;
 
  std::uint8_t pduType = 0;
 
  std::uint8_t addFlags = 0;
 
  std::uint16_t sendSeq = 0;
 
  std::uint16_t ackSeq = 0;
 
  Bytes varPart;
};
 
[[nodiscard]] SentRtaFrame ParseSentRta(std::span<const std::uint8_t> frame)
{
  EXPECT_GE(frame.size(), 32U);
  if (frame.size() < 32U)
  {
    return {}; // Return empty frame on size failure
  }
 
  wire::Reader r(frame);
 
  // EXPECT_EQ((MacAddress{frame[0], frame[1], frame[2], frame[3], frame[4], frame[5]}), kDeviceMac);
  // EXPECT_EQ((MacAddress{frame[6], frame[7], frame[8], frame[9], frame[10], frame[11]}), kControllerMac);
  EXPECT_EQ(r.Fixed<macAddressLength>(), kDeviceMac);
  EXPECT_EQ(r.Fixed<macAddressLength>(), kControllerMac);
  EXPECT_EQ(r.U16(), kVlanTpid);
 
  const std::uint16_t tci = r.U16();
  EXPECT_TRUE(tci == kVlanPcp6Vid0 || tci == kVlanPcp5Vid0);
 
  EXPECT_EQ(r.U16(), kProfinetEtherType);
 
  SentRtaFrame result;
  result.frameId = r.U16();
  result.dstRef = r.U16();
  result.srcRef = r.U16();
  result.pduType = r.U8();
  result.addFlags = r.U8();
  result.sendSeq = r.U16();
  result.ackSeq = r.U16();
 
  const std::uint16_t variablePartLength = r.U16();
  EXPECT_EQ(frame.size(), 32U + variablePartLength);
 
  if (frame.size() >= 32U + variablePartLength)
  {
    result.varPart.assign(frame.begin() + 32, frame.begin() + 32 + variablePartLength);
  }
 
  return result;
}
 
} // namespace
 
class AlarmListenerRtaTest : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    socket = std::make_unique<StrictMock<MockRawEthernetSocket>>();
 
    mockSocket = socket.get();
 
    AlarmEndpoint endpoint;
    endpoint.interface = "eth0";
    endpoint.controllerRef = kControllerReference;
    endpoint.deviceRef = kDeviceReference;
    endpoint.deviceMac = kDeviceMac;
    endpoint.transport = 0;
    ioContext = std::make_unique<asio::io_context>();
    listener = std::make_unique<AlarmListener>(*ioContext, endpoint, kControllerMac);
    AlarmListenerTestAccess::SetSock(*listener, std::move(socket));
  }
 
  void Feed(Bytes frame)
  {
    EXPECT_CALL(*mockSocket, Recv()).WillOnce(::testing::Return(std::move(frame)));
 
    AlarmListenerTestAccess::HandleLayer2Frame(*listener);
  }
 
  [[nodiscard]] static SentRtaFrame ParseSentFrame(std::span<const std::uint8_t> frame)
  {
    return ParseSentRta(frame);
  }
  std::unique_ptr<testing::StrictMock<MockRawEthernetSocket>> socket;
 
  StrictMock<MockRawEthernetSocket>* mockSocket = nullptr;
 
  std::unique_ptr<AlarmListener> listener;
 
  std::unique_ptr<asio::io_context> ioContext;
};
 
class AlarmListenerRtaIntegrationTest : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    socket = std::make_unique<StrictMock<MockRawEthernetSocket>>();
 
    mockSocket = socket.get();
 
    AlarmEndpoint endpoint;
    endpoint.interface = "eth0";
    endpoint.controllerRef = kControllerReference;
    endpoint.deviceRef = kDeviceReference;
    endpoint.deviceMac = kDeviceMac;
    endpoint.transport = 0;
    ioContext = std::make_unique<asio::io_context>();
 
    listener = std::make_unique<AlarmListener>(*ioContext, endpoint, kControllerMac);
    AlarmListenerTestAccess::SetSock(*listener, std::move(socket));
  }
 
  void Feed(Bytes frame)
  {
    EXPECT_CALL(*mockSocket, Recv()).WillOnce(::testing::Return(std::move(frame)));
    AlarmListenerTestAccess::HandleLayer2Frame(*listener);
  }
 
  std::unique_ptr<testing::StrictMock<MockRawEthernetSocket>> socket;
 
  StrictMock<MockRawEthernetSocket>* mockSocket = nullptr;
 
  std::unique_ptr<AlarmListener> listener;
 
  std::unique_ptr<asio::io_context> ioContext;
};
 
class AlarmListenerCallbackTest : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    socket = std::make_unique<StrictMock<MockRawEthernetSocket>>();
    mockSocket = socket.get();
 
    AlarmEndpoint endpoint;
    endpoint.interface = "eth0";
    endpoint.controllerRef = kControllerReference;
    endpoint.deviceRef = kDeviceReference;
    endpoint.deviceMac = kDeviceMac;
    endpoint.transport = 0;
    ioContext = std::make_unique<asio::io_context>();
    listener = std::make_unique<AlarmListener>(*ioContext, endpoint, kControllerMac);
    AlarmListenerTestAccess::SetSock(*listener, std::move(socket));
  }
 
  void Feed(Bytes frame)
  {
    EXPECT_CALL(*mockSocket, Recv()).WillOnce(::testing::Return(std::move(frame)));
    AlarmListenerTestAccess::HandleLayer2Frame(*listener);
  }
 
  std::unique_ptr<testing::StrictMock<MockRawEthernetSocket>> socket;
 
  StrictMock<MockRawEthernetSocket>* mockSocket = nullptr;
 
  std::unique_ptr<AlarmListener> listener;
 
  std::unique_ptr<asio::io_context> ioContext;
};
 
TEST_F(AlarmListenerRtaTest, UntaggedAlarmFrameIsProcessed)
{
  const Bytes alarm = BuildAlarmBlock();
 
  EXPECT_CALL(*mockSocket, Send(_)).Times(1).WillOnce([&](const Bytes& frame)
  {
    const SentRtaFrame sent = ParseSentFrame(frame);
 
    EXPECT_EQ(sent.frameId, FRAME_ID_ALARM_LOW);
    EXPECT_EQ(sent.pduType, 0x11);
    EXPECT_EQ(sent.dstRef, kDeviceReference);
    EXPECT_EQ(sent.srcRef, kControllerReference);
    EXPECT_EQ(sent.varPart.size(), alarm.size() - 4U); //+ 4U ff beter naar kijken
  });
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(kAddFlagsWindow1 | kAddFlagsTack),
                     0xFFFF,
                     0xFFFE,
                     alarm,
                     kControllerReference,
                     kDeviceReference,
                     kRtaVersion,
                     false,
                     FRAME_ID_ALARM_LOW));
}
 
TEST_F(AlarmListenerRtaTest, VlanTaggedAlarmFrameIsProcessed)
{
  const Bytes alarm = BuildAlarmBlock();
  EXPECT_CALL(*mockSocket, Send(_)).Times(1).WillOnce([&](const Bytes& frame)
  {
    const SentRtaFrame sent = ParseSentFrame(frame);
    EXPECT_EQ(sent.frameId, FRAME_ID_ALARM_LOW);
    EXPECT_EQ(sent.pduType, 0x11);
  });
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(kAddFlagsWindow1 | kAddFlagsTack),
                     0xFFFF,
                     0xFFFE,
                     alarm,
                     kControllerReference,
                     kDeviceReference,
                     kRtaVersion,
                     true,
                     FRAME_ID_ALARM_LOW));
}
 
TEST_F(AlarmListenerRtaTest, HighPriorityAlarmUsesHighFrameId)
{
  const Bytes alarm = BuildAlarmBlock(true);
 
  EXPECT_CALL(*mockSocket, Send(_)).Times(1).WillOnce([&](const Bytes& frame)
  {
    const SentRtaFrame sent = ParseSentFrame(frame);
 
    EXPECT_EQ(sent.frameId, FRAME_ID_ALARM_HIGH);
    EXPECT_EQ(sent.pduType, 0x11);
  });
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(kAddFlagsWindow1 | kAddFlagsTack),
                     0xFFFF,
                     0xFFFE,
                     alarm,
                     kControllerReference,
                     kDeviceReference,
                     kRtaVersion,
                     true,
                     FRAME_ID_ALARM_HIGH));
}
 
TEST_F(AlarmListenerRtaTest, NonProfinetEtherTypeIsIgnored)
{
  Bytes frame = BuildRtaFrame(kRtaTypeData,
                              0,
                              0xFFFF,
                              0xFFFE,
                              BuildAlarmBlock());
 
  // EtherType starts at byte 12 for this untagged frame.
  frame[12] = 0x08;
  frame[13] = 0x00;
 
  EXPECT_CALL(*mockSocket, Send(_)).Times(0);
 
  Feed(std::move(frame));
}
 
TEST_F(AlarmListenerRtaTest, WrongSourceMacIsIgnored)
{
  Bytes frame = BuildRtaFrame(kRtaTypeData,
                              0,
                              0xFFFF,
                              0xFFFE,
                              BuildAlarmBlock());
 
  // Replace source MAC with a different device.
  frame[6] = 0xAA;
  frame[7] = 0xBB;
  frame[8] = 0xCC;
  frame[9] = 0xDD;
  frame[10] = 0xEE;
  frame[11] = 0xFF;
 
  EXPECT_CALL(*mockSocket, Send(_)).Times(0);
 
  Feed(std::move(frame));
}
 
TEST_F(AlarmListenerRtaTest, WrongDestinationReferenceIsIgnored)
{
  EXPECT_CALL(*mockSocket, Send(_)).Times(0);
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(
                         kAddFlagsWindow1 |
                         kAddFlagsTack),
                     0xFFFF,
                     0xFFFE,
                     BuildAlarmBlock(),
                     99,
                     kDeviceReference));
}
 
TEST_F(AlarmListenerRtaTest, ShortEthernetFrameIsIgnored)
{
  EXPECT_CALL(*mockSocket, Send(_)).Times(0);
 
  Feed(Bytes(15U, 0x00));
}
 
TEST_F(AlarmListenerRtaTest, AlarmAckIsPriorityVlanTagged)
{
  EXPECT_CALL(*mockSocket, Send(_)).Times(1).WillOnce([&](const Bytes& frame)
  {
    ASSERT_GE(frame.size(), 20U);
    wire::Reader r(frame);
    const MacAddress devMac = r.Fixed<macAddressLength>();
    const MacAddress controllerMac = r.Fixed<macAddressLength>();
 
    EXPECT_EQ(r.U16(), kVlanTpid);
 
    const std::uint16_t tci = r.U16();
 
    EXPECT_TRUE(tci == kVlanPcp6Vid0 || tci == kVlanPcp5Vid0);
 
    EXPECT_EQ(r.U16(), kProfinetEtherType);
  });
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(
                         kAddFlagsWindow1 |
                         kAddFlagsTack),
                     0xFFFF,
                     0xFFFE,
                     BuildAlarmBlock()));
}
 
TEST_F(AlarmListenerRtaTest, AlarmAckUsesDataPdu)
{
  EXPECT_CALL(*mockSocket, Send(_)).Times(1).WillOnce([&](const Bytes& frame)
  {
    const SentRtaFrame sent = ParseSentFrame(frame);
 
    EXPECT_EQ(sent.pduType, 0x11);
  });
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(
                         kAddFlagsWindow1 |
                         kAddFlagsTack),
                     0xFFFF,
                     0xFFFE,
                     BuildAlarmBlock()));
}
 
TEST_F(AlarmListenerRtaTest, AlarmAckUsesDeviceEndpointAsDestination)
{
  EXPECT_CALL(*mockSocket, Send(_)).Times(1).WillOnce([&](const Bytes& frame)
  {
    const SentRtaFrame sent = ParseSentFrame(frame);
 
    EXPECT_EQ(sent.dstRef, kDeviceReference);
 
    EXPECT_EQ(sent.srcRef, kControllerReference);
  });
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(
                         kAddFlagsWindow1 |
                         kAddFlagsTack),
                     0xFFFF,
                     0xFFFE,
                     BuildAlarmBlock()));
}
 
TEST_F(AlarmListenerRtaTest, AlarmAckEchoesReceivedSequenceNumber)
{
  constexpr std::uint16_t kReceivedSequence = 0x1234;
 
  EXPECT_CALL(*mockSocket, Send(_)).Times(1).WillOnce([&](const Bytes& frame)
  {
    const SentRtaFrame sent = ParseSentFrame(frame);
 
    EXPECT_EQ(sent.ackSeq, kReceivedSequence);
  });
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(
                         kAddFlagsWindow1 |
                         kAddFlagsTack),
                     kReceivedSequence,
                     0xFFFE,
                     BuildAlarmBlock()));
}
 
TEST_F(AlarmListenerCallbackTest, ReceivedAlarmInvokesCallback)
{
  std::vector<AlarmNotification> received;
 
  listener->AddAlarmNotificationCallback([&received](const AlarmNotification& alarm)
  {
    received.push_back(alarm);
  });
 
  EXPECT_CALL(*mockSocket, Send(_)).Times(1);
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(kAddFlagsWindow1 | kAddFlagsTack),
                     0xFFFF,
                     0xFFFE,
                     BuildAlarmBlock()));
 
  ASSERT_EQ(received.size(), 1U);
  EXPECT_EQ(received[0].slotNumber, 1U);
}
 
TEST_F(AlarmListenerCallbackTest, MultipleCallbacksAreInvoked)
{
  std::uint32_t callback1Count = 0;
  std::uint32_t callback2Count = 0;
 
  listener->AddAlarmNotificationCallback([&callback1Count](const AlarmNotification&)
  { ++callback1Count; });
  listener->AddAlarmNotificationCallback([&callback2Count](const AlarmNotification&)
  { ++callback2Count; });
 
  EXPECT_CALL(*mockSocket, Send(_)).Times(1);
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(kAddFlagsWindow1 | kAddFlagsTack),
                     0xFFFF,
                     0xFFFE,
                     BuildAlarmBlock()));
 
  EXPECT_EQ(callback1Count, 1U);
  EXPECT_EQ(callback2Count, 1U);
}
 
TEST_F(AlarmListenerCallbackTest, EmptyCallbackIsIgnored)
{
  listener->AddAlarmNotificationCallback({});
 
  EXPECT_CALL(*mockSocket, Send(_)).Times(1);
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(kAddFlagsWindow1 | kAddFlagsTack),
                     0xFFFF,
                     0xFFFE,
                     BuildAlarmBlock()));
}
 
TEST_F(AlarmListenerCallbackTest, CallbackExceptionDoesNotPreventOtherCallbacks)
{
  std::uint32_t callbackCount = 0;
 
  listener->AddAlarmNotificationCallback([](const AlarmNotification&)
  {
    throw std::runtime_error("test callback failure");
  });
 
  listener->AddAlarmNotificationCallback([&callbackCount](const AlarmNotification&)
  { ++callbackCount; });
 
  EXPECT_CALL(*mockSocket, Send(_)).Times(1);
 
  EXPECT_NO_THROW(Feed(BuildRtaFrame(kRtaTypeData,
                                     static_cast<std::uint8_t>(kAddFlagsWindow1 | kAddFlagsTack),
                                     0xFFFF,
                                     0xFFFE,
                                     BuildAlarmBlock())));
 
  EXPECT_EQ(callbackCount, 1U);
}
 
TEST_F(AlarmListenerRtaIntegrationTest, TwoAlarmNotificationsAreDispatched)
{
  std::uint32_t alarmCount = 0;
 
  listener->AddAlarmNotificationCallback([&alarmCount](const AlarmNotification&)
  { ++alarmCount; });
 
  EXPECT_CALL(*mockSocket, Send(_)).Times(2);
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(kAddFlagsWindow1 | kAddFlagsTack),
                     0xFFFF,
                     0xFFFE,
                     BuildAlarmBlock()));
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(kAddFlagsWindow1 | kAddFlagsTack),
                     0x0000,
                     0x0000,
                     BuildAlarmBlock()));
 
  EXPECT_EQ(alarmCount, 2U);
}
 
TEST_F(AlarmListenerRtaTest, InvalidAlarmPayloadIsNotAcknowledged)
{
  EXPECT_CALL(*mockSocket, Send(_)).Times(0);
 
  const Bytes invalidAlarm{0x00, 0x01, 0x00, 0x02, 0x00, 0x00};
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(kAddFlagsWindow1 | kAddFlagsTack),
                     0xFFFF,
                     0xFFFE,
                     invalidAlarm));
}
 
TEST_F(AlarmListenerRtaTest, WrongRtaVersionIsIgnored)
{
  EXPECT_CALL(*mockSocket, Send(_)).Times(0);
  const Bytes alarm = BuildAlarmBlock(
      false,
      0x0401,
      MakeChannelDiagnosisItem());
 
  Bytes frame = BuildRtaFrame(
      kRtaTypeData,
      static_cast<std::uint8_t>(kAddFlagsWindow1 | kAddFlagsTack),
      1,
      0,
      alarm,
      kControllerReference,
      kDeviceReference,
      24,
      false,
      FRAME_ID_ALARM_LOW);
 
  Feed(std::move(frame));
}
 
TEST_F(AlarmListenerRtaTest, DataWithoutTackIsIgnored)
{
  EXPECT_CALL(*mockSocket, Send(_)).Times(0);
 
  Feed(BuildRtaFrame(kRtaTypeData, kAddFlagsWindow1, 0xFFFF, 0xFFFE, BuildAlarmBlock()));
}
 
TEST_F(AlarmListenerRtaIntegrationTest, DISABLED_DuplicateNotificationIsNotDispatchedTwice)
{
  std::uint32_t alarmCount = 0;
 
  listener->AddAlarmNotificationCallback([&alarmCount](const AlarmNotification&)
  { ++alarmCount; });
 
  const Bytes frame = BuildRtaFrame(kRtaTypeData,
                                    static_cast<std::uint8_t>(kAddFlagsWindow1 | kAddFlagsTack),
                                    0xFFFF,
                                    0xFFFE,
                                    BuildAlarmBlock());
 
  EXPECT_CALL(*mockSocket, Send(_)).Times(2);
 
  Feed(frame);
  Feed(frame);
 
  EXPECT_EQ(alarmCount, 1U);
}
 
TEST_F(AlarmListenerRtaTest, DISABLED_OutOfSequenceNotificationIsRejected)
{
  std::uint32_t alarmCount = 0;
 
  listener->AddAlarmNotificationCallback([&alarmCount](const AlarmNotification&)
  { ++alarmCount; });
 
  EXPECT_CALL(*mockSocket, Send(_)).Times(1);
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(kAddFlagsWindow1 | kAddFlagsTack),
                     5,
                     0xFFFE,
                     BuildAlarmBlock()));
 
  EXPECT_EQ(alarmCount, 0U);
}
 
TEST_F(AlarmListenerRtaTest, FirstAlarmAckUsesInitialSequenceNumber)
{
  EXPECT_CALL(*mockSocket, Send(_)).Times(1).WillOnce([&](const Bytes& frame)
  {
    const SentRtaFrame sent = ParseSentFrame(frame);
    // EXPECT_EQ(sent.sendSeq, 0xFFFF);
    EXPECT_EQ(sent.sendSeq, 0x01);
  });
 
  Feed(BuildRtaFrame(kRtaTypeData,
                     static_cast<std::uint8_t>(kAddFlagsWindow1 | kAddFlagsTack),
                     0xFFFF,
                     0xFFFE,
                     BuildAlarmBlock()));
}
 
class RtaErrorTests : public ::testing::Test
{
 protected:
  [[nodiscard]] static Bytes BuildRtaErrorPdu(std::array<std::uint8_t, 4> status, const Bytes& padding = {})
  {
    PNRTAHeader header;
    header.alarmDstEndpoint = 0x8001U;
    header.alarmSrcEndpoint = 0x0000U;
 
    // Version 1 + ERR-RTA (0x04).
    header.pduType =
        static_cast<std::uint8_t>((PNRTAHeader::VERSION_1 << 4U) |
                                  PNRTAHeader::RTA_TYPE_ERR);
 
    header.addFlags = 0x01U;
    header.sendSeqNum = 0xFFFFU;
    header.ackSeqNum = 0xFFFEU;
    header.variablePartLenght = 4U;
    header.payload.assign(status.begin(), status.end());
    header.payload.insert(header.payload.end(), padding.begin(), padding.end());
 
    return header.ToBytes();
  }
};
 
TEST_F(RtaErrorTests, ParsesAumaReleaseIndReceivedError)
{
  const Bytes data = BuildRtaErrorPdu({0xCFU, 0x81U, 0xFDU, 0x0FU},
                                      {0x00U, 0x00U, 0x00U, 0x00U});
 
  const RtaError error = ParseRtaError(data);
 
  EXPECT_EQ(error.header.alarmDstEndpoint, 0x8001U);
  EXPECT_EQ(error.header.alarmSrcEndpoint, 0x0000U);
  EXPECT_EQ(error.header.pduType, 0x14U);
  EXPECT_EQ(error.header.addFlags, 0x01U);
  EXPECT_EQ(error.header.sendSeqNum, 0xFFFFU);
  EXPECT_EQ(error.header.ackSeqNum, 0xFFFEU);
  EXPECT_EQ(error.header.variablePartLenght, 4U);
 
  EXPECT_EQ(error.statusPnio, 0xCF81FD0FU);
  EXPECT_EQ(error.errorCode, 0xCFU);
  EXPECT_EQ(error.errorDecode, 0x81U);
  EXPECT_EQ(error.errorCode1, 0xFDU);
  EXPECT_EQ(error.errorCode2, 0x0FU);
 
  EXPECT_TRUE(error.IsRtaProtocolError());
  // EXPECT_TRUE(error.IsRtaAbort());
  EXPECT_EQ(error.ReasonName(), "AR release.ind received");
}
 
TEST_F(RtaErrorTests, IgnoresEthernetPaddingAfterStatus)
{
  const Bytes data = BuildRtaErrorPdu(
      {0xCFU, 0x81U, 0xFDU, 0x0FU},
      Bytes(32U, 0x00U));
 
  const RtaError error = ParseRtaError(data);
 
  EXPECT_EQ(error.statusPnio, 0xCF81FD0FU);
  EXPECT_EQ(error.errorCode2, 0x0FU);
}
 
TEST_F(RtaErrorTests, RejectsNonErrRtaPdu)
{
  PNRTAHeader header;
  header.pduType = static_cast<std::uint8_t>((PNRTAHeader::VERSION_1 << 4U) |
                                             PNRTAHeader::RTA_TYPE_DATA);
  header.variablePartLenght = 4U;
  header.payload = {0xCFU, 0x81U, 0xFDU, 0x0FU};
 
  EXPECT_THROW(ParseRtaError(header), std::invalid_argument);
}
 
TEST_F(RtaErrorTests, RejectsWrongVariablePartLength)
{
  PNRTAHeader header;
  header.pduType = static_cast<std::uint8_t>((PNRTAHeader::VERSION_1 << 4U) |
                                             PNRTAHeader::RTA_TYPE_ERR);
  header.variablePartLenght = 3U;
  header.payload = {0xCFU, 0x81U, 0xFDU};
 
  EXPECT_THROW(ParseRtaError(header), std::invalid_argument);
}
 
TEST_F(RtaErrorTests, RejectsTruncatedStatus)
{
  PNRTAHeader header;
  header.pduType = static_cast<std::uint8_t>((PNRTAHeader::VERSION_1 << 4U) |
                                             PNRTAHeader::RTA_TYPE_ERR);
  header.variablePartLenght = 4U;
  header.payload = {0xCFU, 0x81U, 0xFDU};
 
  EXPECT_THROW(ParseRtaError(header), std::invalid_argument);
}
 
TEST_F(RtaErrorTests, SequenceErrorIsNotAbort)
{
  const Bytes data = BuildRtaErrorPdu(
      {0xCFU, 0x81U, 0xFDU, 0x01U});
 
  const RtaError error = ParseRtaError(data);
 
  EXPECT_TRUE(error.IsRtaProtocolError());
  // EXPECT_FALSE(error.IsRtaAbort());
  EXPECT_EQ(error.ReasonName(), "Error within the coordination of sequence numbers");
}
 
TEST_F(RtaErrorTests, NonRtaStatusIsNotProtocolError)
{
  const Bytes data = BuildRtaErrorPdu({0x81U, 0x81U, 0x05U, 0x00U});
 
  const RtaError error = ParseRtaError(data);
 
  EXPECT_FALSE(error.IsRtaProtocolError());
  // EXPECT_FALSE(error.IsRtaAbort());
  EXPECT_EQ(error.ReasonName(), "Reserved");
}
 
struct RtaErrorReasonTestCase
{
  std::uint8_t code;
 
  RtaErrorReason errorReason;
 
  RtaErrorClass errorClass;
 
};
class RtaErrorsTests : public ::testing::TestWithParam<RtaErrorReasonTestCase>
{
};
 
TEST_P(RtaErrorsTests, EveryDefinedReasonIsDecoded)
{
  const auto testCase = GetParam();
 
  PNRTAHeader header;
  header.pduType =
      static_cast<std::uint8_t>(
          (PNRTAHeader::VERSION_1 << 4U) |
          PNRTAHeader::RTA_TYPE_ERR);
  header.variablePartLenght = 4U;
  header.payload = {0xCFU, 0x81U, 0xFDU, testCase.code};
 
  const RtaError error = ParseRtaError(header);
 
  EXPECT_EQ(error.errorCode, 0xCFU);
  EXPECT_EQ(error.errorDecode, 0x81U);
  EXPECT_EQ(error.errorCode1, 0xFDU);
  EXPECT_EQ(error.errorCode2, testCase.code);
  EXPECT_EQ(error.ErrorClass(), testCase.errorClass);
  // EXPECT_STREQ(error.ReasonName().c_str(), testCase.description);
}
INSTANTIATE_TEST_SUITE_P(
    AllDefinedReasons,
    RtaErrorsTests,
    ::testing::Values(
        RtaErrorReasonTestCase{0x00, RtaErrorReason::Reserved, RtaErrorClass::Reserved},
        RtaErrorReasonTestCase{0x01, RtaErrorReason::SequenceNumber, RtaErrorClass::SequenceNumber},
        RtaErrorReasonTestCase{0x02, RtaErrorReason::InstanceClosed, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x03, RtaErrorReason::ArOutOfMemory, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x04, RtaErrorReason::ArAddProviderConsumerFailed, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x05, RtaErrorReason::ArConsumerDhtWdtExpired, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x06, RtaErrorReason::ArCmiTimeout, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x07, RtaErrorReason::ArAlarmOpenFailed, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x08, RtaErrorReason::ArAlarmSendConfirmationNegative, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x09, RtaErrorReason::ArAlarmAckSendConfirmationNegative, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x0A, RtaErrorReason::ArAlarmDataTooLong, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x0B, RtaErrorReason::ArAlarmIndError, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x0C, RtaErrorReason::ArRpcClientCallConfirmationNegative, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x0D, RtaErrorReason::ArAbortRequest, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x0E, RtaErrorReason::ArRerunAbortsExisting, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x0F, RtaErrorReason::ArReleaseIndReceived, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x10, RtaErrorReason::ArDeviceDeactivated, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x11, RtaErrorReason::ArRemoved, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x12, RtaErrorReason::ArProtocolViolation, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x13, RtaErrorReason::ArNameResolutionError, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x14, RtaErrorReason::ArRpcBindError, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x15, RtaErrorReason::ArRpcConnectError, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x16, RtaErrorReason::ArRpcReadError, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x17, RtaErrorReason::ArRpcWriteError, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x18, RtaErrorReason::ArRpcControlError, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x19, RtaErrorReason::ArForbiddenPullPlug, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x1A, RtaErrorReason::ArApRemoved, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x1B, RtaErrorReason::ArLinkDown, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x1C, RtaErrorReason::ArMulticastMacRegistrationFailed, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x1D, RtaErrorReason::NotSynchronized, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x1E, RtaErrorReason::WrongTopology, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x1F, RtaErrorReason::DcpStationNameChanged, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x20, RtaErrorReason::DcpResetToFactorySettings, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x21, RtaErrorReason::CompanionAr8ippSubmodule, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x22, RtaErrorReason::NoIrdataRecordYet, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x23, RtaErrorReason::Pdev, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x24, RtaErrorReason::PdevNoRequiredSpeedDuplexity, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x25, RtaErrorReason::IpSuiteChanged, RtaErrorClass::Abort},
        RtaErrorReasonTestCase{0x26, RtaErrorReason::IocarSrRdhtExpired, RtaErrorClass::Extended},
        RtaErrorReasonTestCase{0x27, RtaErrorReason::IocarSrPdevParameterizationImpossible, RtaErrorClass::Extended},
        RtaErrorReasonTestCase{0x28, RtaErrorReason::RemoteApplicationReadyTimeout, RtaErrorClass::Extended},
        RtaErrorReasonTestCase{0x29, RtaErrorReason::IocarSrRedundantInterfaceLost, RtaErrorClass::Extended},
        RtaErrorReasonTestCase{0x2A, RtaErrorReason::IocarSrMtotExpired, RtaErrorClass::Extended},
        RtaErrorReasonTestCase{0x2B, RtaErrorReason::IocarSrArProtocolViolation, RtaErrorClass::Extended},
        RtaErrorReasonTestCase{0x2C, RtaErrorReason::PdevPlugPortWithoutCombinedObjectContainer, RtaErrorClass::Extended},
        RtaErrorReasonTestCase{0x2D, RtaErrorReason::ObsoletedNmeNoConfiguration, RtaErrorClass::Obsoleted},
        RtaErrorReasonTestCase{0xFF, RtaErrorReason::UserAbort, RtaErrorClass::Abort}),
 
    [](const ::testing::TestParamInfo<RtaErrorReasonTestCase>& info)
{
  return std::format("{:#04x}", info.param.code);
});
 
TEST(RtaErrorsTests, UndefinedReasonIsUnknown)
{
  constexpr std::uint8_t kUnknownErrorCode2 = 0x30;
 
  EXPECT_EQ(RtaError::ClassifyRtaErrorReason(kUnknownErrorCode2), RtaErrorReason::Reserved);
 
  EXPECT_EQ(RtaError::ClassifyRtaError(kUnknownErrorCode2), RtaErrorClass::Reserved);
}
} // namespace profinet