test_alarmsMore.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <cstdint>
#include <string>
#include <utility>
#include <vector>
 
#include "profinet/alarms.h"
#include "profinet/protocol.h"
#include "profinet/wire.h"
 
namespace profinet
{
namespace
{
 
[[nodiscard]] Bytes BuildBlockHeader(
    std::uint16_t blockType,
    std::uint16_t blockLength,
    std::uint8_t versionHigh = 1U,
    std::uint8_t versionLow = 2U)
{
  Bytes data;
  wire::PutU16(data, blockType);
  wire::PutU16(data, blockLength);
  data.push_back(versionHigh);
  data.push_back(versionLow);
  return data;
}
 
[[nodiscard]] Bytes BuildMaintenanceItem(
    std::uint16_t blockType,
    std::uint16_t blockLength,
    std::uint32_t maintenanceStatus)
{
  Bytes item;
  wire::PutU16(item, static_cast<std::uint16_t>(Usi::Maintenance));
 
  const Bytes header = BuildBlockHeader(blockType, blockLength);
  item.insert(item.end(), header.begin(), header.end());
 
  item.push_back(0x00);
  item.push_back(0x00);
 
  wire::PutU32(item, maintenanceStatus);
 
  return item;
}
 
[[nodiscard]] Bytes BuildUploadRetrievalItem(
    Usi usi,
    std::uint16_t blockType,
    std::uint16_t blockLength,
    std::uint32_t recordIndex,
    std::uint32_t recordLength)
{
  Bytes item;
  wire::PutU16(item, static_cast<std::uint16_t>(usi));
 
  const Bytes header = BuildBlockHeader(blockType, blockLength);
  item.insert(item.end(), header.begin(), header.end());
 
  item.push_back(0x00);
  item.push_back(0x00);
 
  wire::PutU32(item, recordIndex);
  wire::PutU32(item, recordLength);
 
  return item;
}
 
[[nodiscard]] Bytes BuildPeAlarmItem(
    std::uint16_t blockType,
    std::uint16_t blockLength,
    std::uint8_t versionHigh,
    std::uint8_t versionLow,
    std::uint8_t operationalMode)
{
  Bytes item;
  wire::PutU16(item, static_cast<std::uint16_t>(Usi::PeAlarm));
 
  const Bytes header = BuildBlockHeader(blockType, blockLength, versionHigh, versionLow);
  item.insert(item.end(), header.begin(), header.end());
  item.push_back(operationalMode);
 
  return item;
}
 
[[nodiscard]] Bytes BuildRsAlarmItem(Usi usi, std::uint16_t alarmInfo)
{
  Bytes item;
  wire::PutU16(item, static_cast<std::uint16_t>(usi));
  wire::PutU16(item, alarmInfo);
  return item;
}
 
[[nodiscard]] Bytes BuildPralAlarmItem(
    std::uint16_t channelNumber,
    std::uint16_t channelProperties,
    std::uint16_t reason,
    std::uint16_t extendedReason,
    const Bytes& additionalValue = {})
{
  Bytes item;
  wire::PutU16(item, static_cast<std::uint16_t>(Usi::PralAlarm));
  wire::PutU16(item, channelNumber);
  wire::PutU16(item, channelProperties);
  wire::PutU16(item, reason);
  wire::PutU16(item, extendedReason);
  item.insert(item.end(), additionalValue.begin(), additionalValue.end());
  return item;
}
 
[[nodiscard]] Bytes BuildAlarmNotification(
    std::uint16_t blockType,
    std::uint16_t specifier,
    const Bytes& items = {},
    std::uint16_t blockLengthOverride = 0)
{
  Bytes body;
 
  wire::PutU16(body, 0x0007);     // AlarmType.
  wire::PutU32(body, 0x12345678); // API.
  wire::PutU16(body, 0x0021);     // Slot.
  wire::PutU16(body, 0x1002);     // Subslot.
  wire::PutU32(body, 0x11223344); // ModuleIdent.
  wire::PutU32(body, 0x55667788); // SubmoduleIdent.
  wire::PutU16(body, specifier);  // AlarmSpecifier.
 
  EXPECT_EQ(body.size(), 20U);
 
  if (body.size() < 20U)
  {
    return {};
  }
 
  Bytes bodyWithItems{0x02U, 0x01U};
  bodyWithItems.insert(bodyWithItems.end(), body.begin(), body.end());
  bodyWithItems.insert(bodyWithItems.end(), items.begin(), items.end());
 
  const auto actualBlockLength = static_cast<std::uint16_t>(bodyWithItems.size());
  const auto blockLength =
      blockLengthOverride == 0U ? actualBlockLength : blockLengthOverride;
 
  Bytes result;
  wire::PutU16(result, blockType);
  wire::PutU16(result, blockLength);
  result.insert(result.end(), bodyWithItems.begin(), bodyWithItems.end());
 
  return result;
}
 
[[nodiscard]] Bytes BuildChannelDiagnosisItem(
    std::uint16_t channelNumber,
    std::uint16_t channelProperties,
    std::uint16_t channelErrorType)
{
  Bytes item;
  wire::PutU16(item, static_cast<std::uint16_t>(Usi::ChannelDiagnosis));
  wire::PutU16(item, channelNumber);
  wire::PutU16(item, channelProperties);
  wire::PutU16(item, channelErrorType);
  return item;
}
 
[[nodiscard]] Bytes BuildQualifiedDiagnosisItem(
    std::uint16_t channelNumber,
    std::uint16_t channelProperties,
    std::uint16_t channelErrorType,
    std::uint16_t extendedErrorType,
    std::uint32_t extendedAdditionalValue,
    std::uint32_t qualifier)
{
  Bytes item;
  wire::PutU16(item, static_cast<std::uint16_t>(Usi::QualifiedChannelDiagnosis));
  wire::PutU16(item, channelNumber);
  wire::PutU16(item, channelProperties);
  wire::PutU16(item, channelErrorType);
  wire::PutU16(item, extendedErrorType);
  wire::PutU32(item, extendedAdditionalValue);
  wire::PutU32(item, qualifier);
  return item;
}
 
class DiagnosisItemTests : public ::testing::Test
{
};
 
class MaintenanceItemTests : public ::testing::Test
{
};
 
class UploadRetrievalItemTests : public ::testing::Test
{
};
 
class RsAlarmItemTests : public ::testing::Test
{
};
 
class PralAlarmItemTests : public ::testing::Test
{
};
 
class PeAlarmItemTests : public ::testing::Test
{
};
 
class AlarmItemVariantTests : public ::testing::Test
{
};
 
class AlarmNotificationTests : public ::testing::Test
{
};
 
TEST_F(DiagnosisItemTests, ChannelNumberWithoutAccumulativeBit)
{
  DiagnosisItem item;
  item.channelNumber = 0x1234U;
 
  EXPECT_EQ(item.ChannelNumberValue(), 0x1234U);
  EXPECT_FALSE(item.IsAccumulative());
}
 
TEST_F(DiagnosisItemTests, ChannelTypeUsesLowByte)
{
  DiagnosisItem item;
  item.channelProperties = 0xABCDU;
 
  EXPECT_EQ(item.ChannelTypeValue(), static_cast<std::uint8_t>(0xCDU));
}
 
TEST_F(DiagnosisItemTests, QualifiedDiagnosisIsExtendedAndQualified)
{
  DiagnosisItem item;
  item.userStructureId = Usi::QualifiedChannelDiagnosis;
 
  EXPECT_TRUE(item.IsExtended());
  EXPECT_TRUE(item.IsQualified());
}
 
TEST_F(DiagnosisItemTests, ExtendedDiagnosisIsExtendedButNotQualified)
{
  DiagnosisItem item;
  item.userStructureId = Usi::ExtendedChannelDiagnosis;
 
  EXPECT_TRUE(item.IsExtended());
  EXPECT_FALSE(item.IsQualified());
}
 
TEST_F(DiagnosisItemTests, StandardDiagnosisIsNeitherExtendedNorQualified)
{
  DiagnosisItem item;
  item.userStructureId = Usi::ChannelDiagnosis;
 
  EXPECT_FALSE(item.IsExtended());
  EXPECT_FALSE(item.IsQualified());
}
 
TEST_F(DiagnosisItemTests, ParseQualifiedChannelDiagnosis)
{
  const Bytes data = BuildQualifiedDiagnosisItem(
      0x8005U,
      0xA5C3U,
      0x1122U,
      0x3344U,
      0x55667788U,
      0x99AABBCCU);
 
  const auto [variant, offset] = ParseAlarmItem(data);
 
  EXPECT_EQ(offset, data.size());
 
  const auto* item = std::get_if<DiagnosisItem>(&variant);
  ASSERT_NE(item, nullptr);
 
  EXPECT_EQ(item->userStructureId, Usi::QualifiedChannelDiagnosis);
  EXPECT_EQ(item->channelNumber, 0x8005U);
  EXPECT_EQ(item->ChannelNumberValue(), 5U);
  EXPECT_TRUE(item->IsAccumulative());
  EXPECT_EQ(item->channelProperties, 0xA5C3U);
  EXPECT_EQ(item->ChannelTypeValue(), 0xC3U);
  EXPECT_EQ(item->channelErrorType, 0x1122U);
  EXPECT_EQ(item->extChannelErrorType, 0x3344U);
  EXPECT_EQ(item->extChannelAddValue, 0x55667788U);
  EXPECT_EQ(item->qualifiedChannelQualifier, 0x99AABBCCU);
  EXPECT_TRUE(item->IsExtended());
  EXPECT_TRUE(item->IsQualified());
}
 
TEST_F(DiagnosisItemTests, RejectsTruncatedExtendedDiagnosis)
{
  Bytes data;
  wire::PutU16(data, static_cast<std::uint16_t>(Usi::ExtendedChannelDiagnosis));
  wire::PutU16(data, 1U);
  wire::PutU16(data, 2U);
  wire::PutU16(data, 3U);
  wire::PutU16(data, 4U);
  wire::PutU8(data, 0x12U);
 
  EXPECT_THROW(ParseAlarmItem(data), std::invalid_argument);
}
 
TEST_F(DiagnosisItemTests, RejectsTruncatedQualifiedQualifier)
{
  Bytes data = BuildQualifiedDiagnosisItem(
      1U,
      2U,
      3U,
      4U,
      0x11223344U,
      0xAABBCCDDU);
 
  ASSERT_GT(data.size(), 0U);
  data.pop_back();
 
  EXPECT_THROW(ParseAlarmItem(data), std::invalid_argument);
}
 
TEST_F(MaintenanceItemTests, MaintenanceStatusFlagsAreIndependent)
{
  MaintenanceItem item;
 
  item.maintenanceStatus = 0U;
  EXPECT_FALSE(item.MaintenanceRequired());
  EXPECT_FALSE(item.MaintenanceDemanded());
 
  item.maintenanceStatus = 0x01U;
  EXPECT_TRUE(item.MaintenanceRequired());
  EXPECT_FALSE(item.MaintenanceDemanded());
 
  item.maintenanceStatus = 0x02U;
  EXPECT_FALSE(item.MaintenanceRequired());
  EXPECT_TRUE(item.MaintenanceDemanded());
 
  item.maintenanceStatus = 0x03U;
  EXPECT_TRUE(item.MaintenanceRequired());
  EXPECT_TRUE(item.MaintenanceDemanded());
}
 
TEST_F(MaintenanceItemTests, ParseMaintenanceItem)
{
  constexpr std::uint16_t blockType = 0x8101U;
  constexpr std::uint16_t blockLength = 0x0010U;
  constexpr std::uint32_t maintenanceStatus = 0xA5A5A5A5U;
 
  const Bytes data = BuildMaintenanceItem(blockType, blockLength, maintenanceStatus);
 
  const auto [variant, offset] = ParseAlarmItem(data);
 
  EXPECT_EQ(offset, data.size());
 
  const auto* item = std::get_if<MaintenanceItem>(&variant);
  ASSERT_NE(item, nullptr);
 
  EXPECT_EQ(item->userStructureId, Usi::Maintenance);
  EXPECT_EQ(static_cast<std::uint16_t>(item->blockType), blockType);
  EXPECT_EQ(item->blockLength, blockLength);
  EXPECT_EQ(item->blockVersion, 0x0102U);
  EXPECT_EQ(item->maintenanceStatus, maintenanceStatus);
  EXPECT_TRUE(item->MaintenanceRequired());
  EXPECT_FALSE(item->MaintenanceDemanded());
  EXPECT_EQ(item->UsiName(), GetUsiName(Usi::Maintenance));
}
 
TEST_F(MaintenanceItemTests, RejectsTruncatedMaintenanceItem)
{
  Bytes data;
  wire::PutU16(data, static_cast<std::uint16_t>(Usi::Maintenance));
 
  const Bytes header = BuildBlockHeader(0x8101U, 0x0010U);
  data.insert(data.end(), header.begin(), header.end());
 
  EXPECT_THROW(ParseAlarmItem(data), std::invalid_argument);
}
 
TEST_F(UploadRetrievalItemTests, ParseUploadItem)
{
  const Bytes data = BuildUploadRetrievalItem(
      Usi::Upload,
      0x8201U,
      0x0020U,
      0x01020304U,
      0xA1B2C3D4U);
 
  const auto [variant, offset] = ParseAlarmItem(data);
 
  EXPECT_EQ(offset, data.size());
 
  const auto* item = std::get_if<UploadRetrievalItem>(&variant);
  ASSERT_NE(item, nullptr);
 
  EXPECT_EQ(item->userStructureId, Usi::Upload);
  EXPECT_EQ(static_cast<std::uint16_t>(item->blockType), 0x8201U);
  EXPECT_EQ(item->blockLength, 0x0020U);
  EXPECT_EQ(item->blockVersion, 0x0102U);
  EXPECT_EQ(item->urRecordIndex, 0x01020304U);
  EXPECT_EQ(item->urRecordLength, 0xA1B2C3D4U);
  EXPECT_TRUE(item->IsUpload());
  EXPECT_FALSE(item->IsRetrieval());
}
 
TEST_F(UploadRetrievalItemTests, ParseIParameterItemAsRetrieval)
{
  const Bytes data = BuildUploadRetrievalItem(
      Usi::IParameter,
      0x8202U,
      0x0030U,
      0x11223344U,
      0x55667788U);
 
  const auto [variant, offset] = ParseAlarmItem(data);
 
  EXPECT_EQ(offset, data.size());
 
  const auto* item = std::get_if<UploadRetrievalItem>(&variant);
  ASSERT_NE(item, nullptr);
 
  EXPECT_EQ(item->userStructureId, Usi::IParameter);
  EXPECT_EQ(item->urRecordIndex, 0x11223344U);
  EXPECT_EQ(item->urRecordLength, 0x55667788U);
  EXPECT_FALSE(item->IsUpload());
  EXPECT_TRUE(item->IsRetrieval());
}
 
TEST_F(UploadRetrievalItemTests, RejectsTruncatedUploadRetrievalItem)
{
  Bytes data;
  wire::PutU16(data, static_cast<std::uint16_t>(Usi::Upload));
 
  const Bytes header = BuildBlockHeader(0x8201U, 0x0020U);
  data.insert(data.end(), header.begin(), header.end());
 
  EXPECT_THROW(ParseAlarmItem(data), std::invalid_argument);
}
 
TEST_F(RsAlarmItemTests, DISABLED_ParsesAllRsAlarmVariants)
{
  const std::vector<Usi> usis{
      Usi::RsAlarmLow,
      Usi::RsAlarmHigh,
      Usi::RsAlarmSubmodule,
  };
 
  for (const Usi usi : usis)
  {
    SCOPED_TRACE(static_cast<std::uint16_t>(usi));
 
    const Bytes data = BuildRsAlarmItem(usi, 0xF8A5U);
 
    const auto [variant, offset] = ParseAlarmItem(data);
 
    EXPECT_EQ(offset, data.size());
 
    const auto* item = std::get_if<RSAlarmItem>(&variant);
    ASSERT_NE(item, nullptr);
 
    EXPECT_EQ(item->userStructureId, usi);
    EXPECT_EQ(item->rsAlarmInfo, 0xF8A5U);
    EXPECT_EQ(item->RsSpecifier(), 0x08A5U);
    EXPECT_EQ(item->RsSequenceNumber(), 0x08A5U);
    EXPECT_EQ(item->UsiName(), GetUsiName(usi));
  }
}
 
TEST_F(RsAlarmItemTests, RejectsTruncatedRsAlarm)
{
  Bytes data;
  wire::PutU16(data, static_cast<std::uint16_t>(Usi::RsAlarmLow));
  data.push_back(0x12U);
 
  EXPECT_THROW(ParseAlarmItem(data), std::invalid_argument);
}
 
TEST_F(PralAlarmItemTests, ParsePralAlarm)
{
  const Bytes additional{0xDEU, 0xADU, 0xBEU, 0xEFU};
 
  const Bytes data = BuildPralAlarmItem(
      0x8005U,
      0x1234U,
      0x5678U,
      0x9ABCU,
      additional);
 
  const auto [variant, offset] = ParseAlarmItem(data);
 
  EXPECT_EQ(offset, data.size());
 
  const auto* item = std::get_if<PRALAlarmItem>(&variant);
  ASSERT_NE(item, nullptr);
 
  EXPECT_EQ(item->userStructureId, Usi::PralAlarm);
  EXPECT_EQ(item->channelNumber, 0x8005U);
  EXPECT_EQ(item->propAlChannelProperties, 0x1234U);
  EXPECT_EQ(item->prAlReason, 0x5678U);
  EXPECT_EQ(item->prAlExtReason, 0x9ABCU);
  EXPECT_EQ(item->prAlReasonAddValue, additional);
  EXPECT_EQ(item->UsiName(), GetUsiName(Usi::PralAlarm));
}
 
TEST_F(PralAlarmItemTests, ParsePralAlarmWithoutAdditionalData)
{
  const Bytes data = BuildPralAlarmItem(
      1U,
      2U,
      3U,
      4U);
 
  const auto [variant, offset] = ParseAlarmItem(data);
 
  EXPECT_EQ(offset, data.size());
 
  const auto* item = std::get_if<PRALAlarmItem>(&variant);
  ASSERT_NE(item, nullptr);
 
  EXPECT_TRUE(item->prAlReasonAddValue.empty());
}
 
TEST_F(PralAlarmItemTests, RejectsTruncatedPralAlarm)
{
  Bytes data;
  wire::PutU16(data, static_cast<std::uint16_t>(Usi::PralAlarm));
 
  wire::PutU16(data, 1U);
  wire::PutU16(data, 2U);
  wire::PutU16(data, 3U);
 
  EXPECT_THROW(ParseAlarmItem(data), std::invalid_argument);
}
 
TEST_F(PeAlarmItemTests, ParsePeAlarmFields)
{
  const Bytes data = BuildPeAlarmItem(
      0x8311U,
      0x0042U,
      0x03U,
      0x04U,
      0x7FU);
 
  const auto [variant, offset] = ParseAlarmItem(data);
 
  EXPECT_EQ(offset, data.size());
 
  const auto* item = std::get_if<PEAlarmItem>(&variant);
  ASSERT_NE(item, nullptr);
 
  EXPECT_EQ(item->userStructureId, Usi::PeAlarm);
  EXPECT_EQ(static_cast<std::uint16_t>(item->blockType), 0x8311U);
  EXPECT_EQ(item->blockLength, 0x0042U);
  EXPECT_EQ(item->blockVersion, 0x0304U);
  EXPECT_EQ(item->peOperationalMode, 0x7FU);
  EXPECT_EQ(item->UsiName(), GetUsiName(Usi::PeAlarm));
  EXPECT_EQ(item->ModeName(), GetPeModeName(0x7FU));
}
 
TEST_F(PeAlarmItemTests, RejectsTruncatedPeAlarm)
{
  Bytes data;
  wire::PutU16(data, static_cast<std::uint16_t>(Usi::PeAlarm));
 
  const Bytes header = BuildBlockHeader(0x8311U, 0x0003U);
  data.insert(data.end(), header.begin(), header.end());
 
  EXPECT_THROW(ParseAlarmItem(data), std::invalid_argument);
}
 
TEST_F(AlarmItemVariantTests, VariantHelpersCoverAllAlarmItemTypes)
{
  AlarmItem generic;
  // generic.userStructureId;
 
  DiagnosisItem diagnosis;
  diagnosis.userStructureId = Usi::ChannelDiagnosis;
 
  MaintenanceItem maintenance;
  maintenance.userStructureId = Usi::Maintenance;
 
  UploadRetrievalItem upload;
  upload.userStructureId = Usi::Upload;
 
  PEAlarmItem pe;
  pe.userStructureId = Usi::PeAlarm;
 
  RSAlarmItem rs;
  rs.userStructureId = Usi::RsAlarmHigh;
 
  PRALAlarmItem pral;
  pral.userStructureId = Usi::PralAlarm;
 
  const std::vector<AlarmItemVariant> items{
      generic,
      diagnosis,
      maintenance,
      upload,
      pe,
      rs,
      pral,
  };
 
  for (const AlarmItemVariant& item : items)
  {
    SCOPED_TRACE(GetUsiName(UsiOf(item)));
 
    EXPECT_EQ(UsiNameOf(item), GetUsiName(UsiOf(item)));
  }
}
 
TEST_F(AlarmItemVariantTests, IParameterItemUsiName)
{
  IParameterItem item;
 
  EXPECT_EQ(item.userStructureId, Usi::IParameter);
  EXPECT_EQ(item.UsiName(), GetUsiName(Usi::IParameter));
}
 
TEST_F(AlarmItemVariantTests, ConcreteItemsExposeUsiNames)
{
  AlarmItem generic;
  generic.userStructureId = Usi::ChannelDiagnosis;
 
  DiagnosisItem diagnosis;
  diagnosis.userStructureId = Usi::ExtendedChannelDiagnosis;
 
  MaintenanceItem maintenance;
  UploadRetrievalItem upload;
  PEAlarmItem pe;
  RSAlarmItem rs;
  rs.userStructureId = Usi::RsAlarmLow;
  PRALAlarmItem pral;
 
  EXPECT_EQ(generic.UsiName(), GetUsiName(Usi::ChannelDiagnosis));
  EXPECT_EQ(diagnosis.UsiName(), GetUsiName(Usi::ExtendedChannelDiagnosis));
  EXPECT_EQ(maintenance.UsiName(), GetUsiName(Usi::Maintenance));
  EXPECT_EQ(upload.UsiName(), GetUsiName(Usi::Upload));
  EXPECT_EQ(pe.UsiName(), GetUsiName(Usi::PeAlarm));
  EXPECT_EQ(rs.UsiName(), GetUsiName(Usi::RsAlarmLow));
  EXPECT_EQ(pral.UsiName(), GetUsiName(Usi::PralAlarm));
}
 
TEST_F(AlarmItemVariantTests, ParseAlarmItemHonorsOffset)
{
  Bytes data{0xAAU, 0xBBU, 0xCCU};
 
  const Bytes item = BuildChannelDiagnosisItem(
      0x8001U,
      0x1234U,
      0x5678U);
 
  data.insert(data.end(), item.begin(), item.end());
 
  const auto [variant, offset] = ParseAlarmItem(data, 3U);
 
  EXPECT_EQ(offset, data.size());
 
  const auto* diagnosis = std::get_if<DiagnosisItem>(&variant);
  ASSERT_NE(diagnosis, nullptr);
 
  EXPECT_EQ(diagnosis->channelNumber, 0x8001U);
  EXPECT_EQ(diagnosis->channelProperties, 0x1234U);
  EXPECT_EQ(diagnosis->channelErrorType, 0x5678U);
}
 
TEST_F(AlarmItemVariantTests, ParseGenericAlarmWithOffset)
{
  Bytes data{0x00U, 0x01U, 0x02U};
 
  wire::PutU16(data, 0x1234U);
  data.push_back(0xDEU);
  data.push_back(0xADU);
 
  const auto [variant, offset] = ParseAlarmItem(data, 3U);
 
  EXPECT_EQ(offset, data.size());
 
  const auto* generic = std::get_if<AlarmItem>(&variant);
  ASSERT_NE(generic, nullptr);
 
  EXPECT_EQ(generic->userStructureId, static_cast<Usi>(0x1234U));
  EXPECT_EQ(generic->rawData, Bytes({0xDEU, 0xADU}));
}
 
TEST_F(AlarmNotificationTests, LowPriorityHelperReturnsTrue)
{
  const Bytes data = BuildAlarmNotification(
      static_cast<std::uint16_t>(BlockType::AlarmNotificationLow),
      0U);
 
  const AlarmNotification notification = ParseAlarmNotification(data);
 
  EXPECT_TRUE(notification.IsLowPriority());
  EXPECT_FALSE(notification.IsHighPriority());
}
 
TEST_F(AlarmNotificationTests, ParsesAllAlarmNotificationFields)
{
  constexpr std::uint16_t sequence = 0x0345U;
 
  const std::uint16_t specifier =
      sequence |
      0x0800U | // Channel diagnosis.
      0x1000U | // Manufacturer specific.
      0x2000U | // Submodule diagnosis state.
      0x4000U;  // AR diagnosis state.
 
  const Bytes data = BuildAlarmNotification(
      static_cast<std::uint16_t>(BlockType::AlarmNotificationHigh),
      specifier);
 
  const AlarmNotification notification = ParseAlarmNotification(data);
 
  EXPECT_TRUE(notification.IsHighPriority());
  EXPECT_FALSE(notification.IsLowPriority());
 
  EXPECT_EQ(notification.blockVersion.first, 0x02U);
  EXPECT_EQ(notification.blockVersion.second, 0x01U);
  EXPECT_EQ(notification.alarmType, static_cast<AlarmType>(0x0007U));
  EXPECT_EQ(notification.AlarmTypeName(), GetAlarmTypeName(
                                              static_cast<AlarmType>(0x0007U)));
 
  EXPECT_EQ(notification.api, 0x12345678U);
  EXPECT_EQ(notification.slotNumber, 0x0021U);
  EXPECT_EQ(notification.subslotNumber, 0x1002U);
  EXPECT_EQ(notification.moduleIdentNumber, 0x11223344U);
  EXPECT_EQ(notification.submoduleIdentNumber, 0x55667788U);
 
  EXPECT_EQ(notification.alarmSequenceNumber, sequence);
  EXPECT_TRUE(notification.channelDiagnosis);
  EXPECT_TRUE(notification.manufacturerSpecific);
  EXPECT_TRUE(notification.submoduleDiagnosisState);
  EXPECT_TRUE(notification.arDiagnosisState);
 
  EXPECT_EQ(notification.Location(), "305419896:33:0x1002");
  EXPECT_TRUE(notification.rawPayload.empty());
  EXPECT_TRUE(notification.items.empty());
}
 
TEST_F(AlarmNotificationTests, DiagnosisFlagsRemainFalseWhenUnset)
{
  const Bytes data = BuildAlarmNotification(
      static_cast<std::uint16_t>(BlockType::AlarmNotificationLow),
      0x0005U);
 
  const AlarmNotification notification = ParseAlarmNotification(data);
 
  EXPECT_FALSE(notification.channelDiagnosis);
  EXPECT_FALSE(notification.manufacturerSpecific);
  EXPECT_FALSE(notification.submoduleDiagnosisState);
  EXPECT_FALSE(notification.arDiagnosisState);
  EXPECT_EQ(notification.alarmSequenceNumber, 5U);
}
 
TEST_F(AlarmNotificationTests, RawPayloadContainsOnlyBlockBodyAfterFixedHeader)
{
  const Bytes item = BuildChannelDiagnosisItem(
      0x8001U,
      0x0802U,
      0x0009U);
 
  const Bytes data = BuildAlarmNotification(
      static_cast<std::uint16_t>(BlockType::AlarmNotificationLow),
      0x0001U,
      item);
 
  const AlarmNotification notification = ParseAlarmNotification(data);
 
  ASSERT_EQ(notification.items.size(), 1U);
 
  ASSERT_EQ(notification.rawPayload.size(), 8U);
  EXPECT_EQ(Bytes(notification.rawPayload.begin(), notification.rawPayload.end()),
            item);
}
 
TEST_F(AlarmNotificationTests, TruncatedTrailingAlarmItemIsIgnoredAfterValidItems)
{
  Bytes items = BuildChannelDiagnosisItem(
      0x0002U,
      0x0803U,
      0x0004U);
 
  items.push_back(0x80U);
 
  const Bytes data = BuildAlarmNotification(
      static_cast<std::uint16_t>(BlockType::AlarmNotificationLow),
      0x0001U,
      items);
 
  const AlarmNotification notification = ParseAlarmNotification(data);
 
  ASSERT_EQ(notification.items.size(), 1U);
 
  const auto* diagnosis = std::get_if<DiagnosisItem>(&notification.items.front());
  ASSERT_NE(diagnosis, nullptr);
 
  EXPECT_EQ(diagnosis->channelNumber, 2U);
  EXPECT_EQ(diagnosis->channelProperties, 0x0803U);
  EXPECT_EQ(diagnosis->channelErrorType, 4U);
}
 
TEST_F(AlarmNotificationTests, RejectsTooSmallBlockLength)
{
  const Bytes data = BuildAlarmNotification(
      static_cast<std::uint16_t>(BlockType::AlarmNotificationLow),
      0U,
      {},
      21U);
 
  EXPECT_THROW(ParseAlarmNotification(data), std::invalid_argument);
}
 
TEST_F(AlarmNotificationTests, RejectsBlockExtendingPastInput)
{
  const Bytes data = BuildAlarmNotification(
      static_cast<std::uint16_t>(BlockType::AlarmNotificationLow),
      0U,
      {},
      30U);
 
  ASSERT_EQ(data.size(), 26U);
 
  EXPECT_THROW(ParseAlarmNotification(data), std::invalid_argument);
}
 
TEST_F(AlarmNotificationTests, AcceptsExactFixedSizeBlock)
{
  const Bytes data = BuildAlarmNotification(
      static_cast<std::uint16_t>(BlockType::AlarmNotificationLow),
      0U);
 
  ASSERT_EQ(data.size(), 26U);
 
  const AlarmNotification notification = ParseAlarmNotification(data);
 
  EXPECT_TRUE(notification.items.empty());
  EXPECT_TRUE(notification.rawPayload.empty());
}
 
TEST_F(AlarmNotificationTests, IgnoresBytesAfterDeclaredBlock)
{
  Bytes data = BuildAlarmNotification(
      static_cast<std::uint16_t>(BlockType::AlarmNotificationLow),
      0U);
 
  data.push_back(0xDEU);
  data.push_back(0xADU);
  data.push_back(0xBEU);
  data.push_back(0xEFU);
 
  const AlarmNotification notification = ParseAlarmNotification(data);
 
  EXPECT_TRUE(notification.items.empty());
  EXPECT_TRUE(notification.rawPayload.empty());
  EXPECT_EQ(data.size(), 30U);
}
 
TEST_F(AlarmNotificationTests, ValidItemsRemainBoundedByBlockLength)
{
  const Bytes item = BuildChannelDiagnosisItem(
      7U,
      0x0801U,
      0x0033U);
 
  Bytes data = BuildAlarmNotification(
      static_cast<std::uint16_t>(BlockType::AlarmNotificationLow),
      0x0001U,
      item);
 
  const std::size_t blockSize = data.size();
 
  data.insert(data.end(), 16U, 0x00U);
 
  const AlarmNotification notification = ParseAlarmNotification(data);
 
  EXPECT_EQ(notification.items.size(), 1U);
  EXPECT_EQ(notification.rawPayload.size(), 8U);
  EXPECT_EQ(blockSize, 34U);
}
 
TEST_F(AlarmNotificationTests, LocationFormatsApiSlotAndSubslot)
{
  AlarmNotification notification;
  notification.api = 0xFFFFFFFFU;
  notification.slotNumber = 0xFFFFU;
  notification.subslotNumber = 0xFFFFU;
 
  EXPECT_EQ(notification.Location(), "4294967295:65535:0xFFFF");
}
 
TEST_F(AlarmNotificationTests, RejectsEmptyInput)
{
  EXPECT_THROW(ParseAlarmNotification({}), std::invalid_argument);
}
 
TEST_F(AlarmItemVariantTests, UsiNameOfMatchesUsiOf)
{
  std::vector<AlarmItemVariant> items;
 
  AlarmItem generic;
  generic.userStructureId = static_cast<Usi>(0x7001U);
  items.emplace_back(generic);
 
  DiagnosisItem diagnosis;
  diagnosis.userStructureId = Usi::QualifiedChannelDiagnosis;
  items.emplace_back(diagnosis);
 
  MaintenanceItem maintenance;
  items.emplace_back(maintenance);
 
  UploadRetrievalItem upload;
  upload.userStructureId = Usi::IParameter;
  items.emplace_back(upload);
 
  PEAlarmItem pe;
  items.emplace_back(pe);
 
  RSAlarmItem rs;
  rs.userStructureId = Usi::RsAlarmSubmodule;
  items.emplace_back(rs);
 
  PRALAlarmItem pral;
  items.emplace_back(pral);
 
  for (const AlarmItemVariant& item : items)
  {
    EXPECT_EQ(UsiNameOf(item), GetUsiName(UsiOf(item)));
  }
}
 
} // namespace
} // namespace profinet