test_indices.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <cstdint>
#include <format>
#include <string>
#include <utility>
#include <vector>
 
#include "profinet/indices.h"
#include "profinet/util.h"
 
namespace profinet
{
 
class IndicesTest : public ::testing::Test
{
 protected:
  void ExpectBlockTypeNames(const std::vector<std::pair<BlockType, std::string>>& values)
  {
    for (const auto& [blockType, expectedName] : values)
    {
      EXPECT_EQ(GetBlockTypeName(blockType), expectedName) << "BlockType value: " << static_cast<std::uint16_t>(blockType);
    }
  }
 
  void ExpectAlarmTypeNames(const std::vector<std::pair<AlarmType, std::string>>& values)
  {
    for (const auto& [alarmType, expectedName] : values)
    {
      EXPECT_EQ(GetAlarmTypeName(alarmType), expectedName) << "AlarmType value: " << static_cast<std::uint16_t>(alarmType);
    }
  }
 
  void ExpectIocrTypeNames(const std::vector<std::pair<IocrType, std::string>>& values)
  {
    for (const auto& [iocrType, expectedName] : values)
    {
      EXPECT_EQ(GetIocrTypeName(iocrType), expectedName) << "IocrType value: " << static_cast<std::uint16_t>(iocrType);
    }
  }
 
  void ExpectIocrRtClassNames(const std::vector<std::pair<IocrRtClass, std::string>>& values)
  {
    for (const auto& [rtClass, expectedName] : values)
    {
      EXPECT_EQ(GetIocrRtClassName(rtClass), expectedName) << "IocrRtClass value: " << static_cast<std::uint8_t>(rtClass);
    }
  }
 
  void ExpectUsiNames(const std::vector<std::pair<Usi, std::string>>& values)
  {
    for (const auto& [usi, expectedName] : values)
    {
      EXPECT_EQ(GetUsiName(usi), expectedName) << "Usi value: " << static_cast<std::uint16_t>(usi);
    }
  }
 
  void ExpectIndexNames(const std::vector<std::pair<std::uint16_t, std::string>>& values)
  {
    for (const auto& [index, expectedName] : values)
    {
      EXPECT_EQ(GetIndexName(index), expectedName) << "Index value: " << index;
    }
  }
 
  void ExpectScopes(const std::vector<std::pair<std::uint16_t, std::string>>& values)
  {
    for (const auto& [index, expectedScope] : values)
    {
      EXPECT_EQ(GetScope(index), expectedScope) << "Index value: " << index;
    }
  }
 
  void ExpectModuleStates(const std::vector<std::pair<std::uint16_t, std::string>>& values)
  {
    for (const auto& [state, expectedName] : values)
    {
      EXPECT_EQ(GetModuleStateName(state), expectedName) << "State value: " << state;
    }
  }
 
  void ExpectSubmoduleStates(const std::vector<std::pair<std::uint16_t, std::string>>& values)
  {
    for (const auto& [state, expectedName] : values)
    {
      EXPECT_EQ(GetSubmoduleStateName(state), expectedName) << "State value: " << state;
    }
  }
 
  void ExpectPeModes(const std::vector<std::pair<std::uint8_t, std::string>>& values)
  {
    for (const auto& [mode, expectedName] : values)
    {
      EXPECT_EQ(GetPeModeName(mode), expectedName) << "Mode value: " << static_cast<unsigned int>(mode);
    }
  }
 
  void ExpectIndexTable(const IndexNamePairs& actual, const IndexNamePairs& expected)
  {
    ASSERT_EQ(actual.size(), expected.size());
 
    for (std::size_t i = 0; i < expected.size(); ++i)
    {
      EXPECT_EQ(actual[i].first, expected[i].first) << "Unexpected index at table position " << i;
      EXPECT_EQ(actual[i].second, expected[i].second) << "Unexpected name at table position " << i;
    }
  }
};
 
TEST_F(IndicesTest, GetBlockTypeNameResolvesEveryKnownBlockType)
{
  ExpectBlockTypeNames({
      {BlockType::DiagnosisData, "Diagnosis Data"},
      {BlockType::ExpectedIdentificationData, "Expected Identification Data"},
      {BlockType::RealIdentificationData, "Real Identification Data"},
      {BlockType::IdentificationMaintenance0, "I&M 0"},
      {BlockType::IdentificationMaintenance1, "I&M 1"},
      {BlockType::IdentificationMaintenance2, "I&M 2"},
      {BlockType::IdentificationMaintenance3, "I&M 3"},
      {BlockType::IdentificationMaintenance4, "I&M 4"},
      {BlockType::IdentificationMaintenance5, "I&M 5"},
      {BlockType::IdentificationMaintenance6, "I&M 6"},
      {BlockType::IdentificationMaintenance7, "I&M 7"},
      {BlockType::IdentificationMaintenance8, "I&M 8"},
      {BlockType::IdentificationMaintenance9, "I&M 9"},
      {BlockType::IdentificationMaintenance10, "I&M 10"},
      {BlockType::IdentificationMaintenance11, "I&M 11"},
      {BlockType::IdentificationMaintenance12, "I&M 12"},
      {BlockType::IdentificationMaintenance13, "I&M 13"},
      {BlockType::IdentificationMaintenance14, "I&M 14"},
      {BlockType::IdentificationMaintenance15, "I&M 15"},
      {BlockType::AlarmNotificationHigh, "Alarm Notification High"},
      {BlockType::AlarmAcknowledgementHigh, "Alarm Acknowledgement High"},
      {BlockType::AlarmNotificationLow, "Alarm Notification Low"},
      {BlockType::AlarmAcknowledgementLow, "Alarm Acknowledgement Low"},
      {BlockType::IoDataWriteRequest, "IO Data Write Request Header"},
      {BlockType::IoDataWriteResponse, "IO Data Write Response Header"},
      {BlockType::IoDataReadRequest, "IO Data Read Request Header"},
      {BlockType::IoDataReadResponse, "IO Data Read Response Header"},
      {BlockType::ApplicationRelationData, "Application Relation Data"},
      {BlockType::LogData, "Log Data"},
      {BlockType::ApiData, "API Data"},
      {BlockType::SrlData, "SRL Data"},
      {BlockType::ApplicationRelationRequest, "Application Relation Request"},
      {BlockType::ApplicationRelationResponse, "Application Relation Response"},
      {BlockType::IoCrRequest, "IOCR Request"},
      {BlockType::IoCrResponse, "IOCR Response"},
      {BlockType::AlarmCrRequest, "Alarm CR Request"},
      {BlockType::AlarmCrResponse, "Alarm CR Response"},
      {BlockType::ExpectedSubmoduleRequest, "Expected Submodule Request"},
      {BlockType::ModuleDifference, "Module Difference"},
      {BlockType::ControlPrmEndRequest, "Control Parameter End Request"},
      {BlockType::ControlPrmEndResponse, "Control Parameter End Response"},
      {BlockType::ControlApplicationReadyRequest, "Control Application Ready Request"},
      {BlockType::ControlApplicationReadyResponse, "Control Application Ready Response"},
      {BlockType::ReleaseRequest, "Release Request"},
      {BlockType::ReleaseResponse, "Release Response"},
      {BlockType::ControlRtClass3Request, "Control RT Class 3 Request"},
      {BlockType::ControlRtClass3Response, "Control RT Class 3 Response"},
      {BlockType::ParameterizationBeginRequest, "Parameterization Begin Request"},
      {BlockType::ParameterizationBeginResponse, "Parameterization Begin Response"},
      {BlockType::SubmoduleList, "Submodule List"},
      {BlockType::PortDataCheck, "Port Data Check"},
      {BlockType::PortDataAdjust, "Port Data Adjust"},
      {BlockType::PortDataReal, "Port Data Real"},
      {BlockType::InterfaceMrpDataAdjust, "Interface MRP Data Adjust"},
      {BlockType::InterfaceMrpDataReal, "Interface MRP Data Real"},
      {BlockType::PortMrpDataReal, "Port MRP Data Real"},
      {BlockType::MrpRingStateData, "MRP Ring State Data"},
      {BlockType::PortFoDataReal, "Port FO Data Real"},
      {BlockType::PortFoDataCheck, "Port FO Data Check"},
      {BlockType::PortFoDataAdjust, "Port FO Data Adjust"},
      {BlockType::PortDataRealExtended, "Port Data Real Extended"},
      {BlockType::PortDataInterfaceDataReal, "Interface Data Real"},
      {BlockType::PortStatistics, "Port Statistics"},
      {BlockType::MultipleHeader, "Multiple Header"},
      {BlockType::ContainerContent, "Container Content"},
      {BlockType::ApplicationRelationServer, "Application Relation Server"},
      {BlockType::RealProcessData, "Real Process Data"},
      {BlockType::ExpectedProcessData, "Expected Process Data"},
      {BlockType::RealIdentificationDataApi, "Real Identification Data API"},
  });
}
 
TEST_F(IndicesTest, GetBlockTypeNameFallsBackForUnknownTypes)
{
  EXPECT_EQ(GetBlockTypeName(static_cast<BlockType>(0x9999)), "Unknown (0x9999)");
}
 
TEST_F(IndicesTest, GetAlarmTypeNameResolvesEveryKnownAlarmType)
{
  ExpectAlarmTypeNames({
      {AlarmType::Diagnosis, "Diagnosis"},
      {AlarmType::Process, "Process"},
      {AlarmType::Pull, "Pull"},
      {AlarmType::Plug, "Plug"},
      {AlarmType::Status, "Status"},
      {AlarmType::Update, "Update"},
      {AlarmType::Redundancy, "Redundancy"},
      {AlarmType::ControlledBySupervisor, "Controlled By Supervisor"},
      {AlarmType::Released, "Released"},
      {AlarmType::PlugWrongSubmodule, "Plug Wrong Submodule"},
      {AlarmType::ReturnOfSubmodule, "Return Of Submodule"},
      {AlarmType::DiagnosisDisappears, "Diagnosis Disappears"},
      {AlarmType::MulticastMismatch, "Multicast Mismatch"},
      {AlarmType::PortDataChange, "Port Data Change"},
      {AlarmType::SyncDataChanged, "Sync Data Changed"},
      {AlarmType::IsochronousModeProblem, "Isochronous Mode Problem"},
      {AlarmType::NetworkComponentProblem, "Network Component Problem"},
      {AlarmType::TimeDataChanged, "Time Data Changed"},
      {AlarmType::DfpProblem, "DFP Problem"},
      {AlarmType::UploadRetrieval, "Upload Retrieval"},
      {AlarmType::PullModule, "Pull Module"},
  });
}
 
TEST_F(IndicesTest, GetAlarmTypeNameFallsBackForUnknownType)
{
  EXPECT_EQ(GetAlarmTypeName(static_cast<AlarmType>(0x9999)), "Unknown");
}
 
TEST_F(IndicesTest, GetIocrTypeNameResolvesEveryKnownType)
{
  ExpectIocrTypeNames({
      {IocrType::Input, "Input"},
      {IocrType::Output, "Output"},
      {IocrType::MulticastProvider, "Multicast Provider"},
      {IocrType::MulticastConsumer, "Multicast Consumer"},
  });
}
 
TEST_F(IndicesTest, GetIocrTypeNameFallsBackForUnknownType)
{
  EXPECT_EQ(GetIocrTypeName(static_cast<IocrType>(0x9999)), "Unknown (0x9999)");
}
 
TEST_F(IndicesTest, GetIocrRtClassNameResolvesUdp)
{
  EXPECT_EQ(GetIocrRtClassName(IocrRtClass::Udp), "RT_CLASS_UDP");
}
 
TEST_F(IndicesTest, GetIocrRtClassNameFallsBackForUnknownType)
{
  EXPECT_EQ(GetIocrRtClassName(static_cast<IocrRtClass>(0x99)), "Unknown (0x99)");
}
 
TEST_F(IndicesTest, GetUsiNameResolvesEveryKnownUsi)
{
  ExpectUsiNames({
      {Usi::ChannelDiagnosis, "Channel Diagnosis"},
      {Usi::MultipleDiagnosis, "Multiple Diagnosis"},
      {Usi::ExtendedChannelDiagnosis, "Extended Channel Diagnosis"},
      {Usi::QualifiedChannelDiagnosis, "Qualified Channel Diagnosis"},
      {Usi::Maintenance, "Maintenance Item"},
      {Usi::Upload, "Upload Record"},
      {Usi::IParameter, "iParameter Item"},
      {Usi::RsAlarmLow, "RS Alarm Item (Low)"},
      {Usi::RsAlarmHigh, "RS Alarm Item (High)"},
      {Usi::RsAlarmSubmodule, "RS Alarm Item (Submodule)"},
      {Usi::PeAlarm, "PE Alarm Item"},
      {Usi::PralAlarm, "PRAL Alarm Item"},
  });
}
 
TEST_F(IndicesTest, GetUsiNameClassifiesManufacturerSpecificValues)
{
  ExpectUsiNames({
      {static_cast<Usi>(0x0000), "Manufacturer Specific (0x0000)"},
      {static_cast<Usi>(0x0001), "Manufacturer Specific (0x0001)"},
      {static_cast<Usi>(0x7FFF), "Manufacturer Specific (0x7FFF)"},
  });
}
 
TEST_F(IndicesTest, GetUsiNameClassifiesProfileSpecificValues)
{
  ExpectUsiNames({
      {static_cast<Usi>(0x8400), "Profile Specific (0x8400)"},
      {static_cast<Usi>(0x8500), "Profile Specific (0x8500)"},
      {static_cast<Usi>(0x8FFF), "Profile Specific (0x8FFF)"},
  });
}
 
TEST_F(IndicesTest, GetUsiNameClassifiesReservedValues)
{
  ExpectUsiNames({
      {static_cast<Usi>(0x8004), "Reserved (0x8004)"},
      {static_cast<Usi>(0x83FF), "Reserved (0x83FF)"},
      {static_cast<Usi>(0x9000), "Reserved (0x9000)"},
      {static_cast<Usi>(0xFFFF), "Reserved (0xFFFF)"},
  });
}
 
TEST_F(IndicesTest, GetModuleStateNameResolvesEveryKnownState)
{
  ExpectModuleStates({
      {MODULE_STATE_NO_MODULE, "NoModule"},
      {MODULE_STATE_WRONG_MODULE, "WrongModule"},
      {MODULE_STATE_PROPER_MODULE, "ProperModule"},
      {MODULE_STATE_SUBSTITUTE_MODULE, "SubstituteModule"},
  });
}
 
TEST_F(IndicesTest, GetModuleStateNameFallsBackForUnknownState)
{
  EXPECT_EQ(GetModuleStateName(0x9999), "Unknown(0x9999)");
}
 
TEST_F(IndicesTest, GetSubmoduleStateNameResolvesEveryKnownState)
{
  ExpectSubmoduleStates({
      {SUBMODULE_STATE_NO_SUBMODULE, "NoSubmodule"},
      {SUBMODULE_STATE_WRONG_SUBMODULE, "WrongSubmodule"},
      {SUBMODULE_STATE_LOCKED_BY_SUPERVISOR, "LockedBySupervisor"},
      {SUBMODULE_STATE_APPLICATION_READY_PENDING, "ApplicationReadyPending"},
      {SUBMODULE_STATE_OK, "OK"},
  });
}
 
TEST_F(IndicesTest, GetSubmoduleStateNameFallsBackForUnknownState)
{
  EXPECT_EQ(GetSubmoduleStateName(0x9999), "Unknown(0x9999)");
}
 
TEST_F(IndicesTest, GetPeModeNameResolvesFixedModes)
{
  ExpectPeModes({
      {PE_MODE_POWER_OFF, "PE_PowerOff"},
      {PE_MODE_OPERATE, "PE_Operate"},
      {PE_MODE_SLEEP_MODE_WOL, "PE_SleepModeWOL"},
      {PE_MODE_READY_TO_OPERATE, "PE_ReadyToOperate"},
  });
}
 
TEST_F(IndicesTest, GetPeModeNameResolvesEnergySavingRange)
{
  for (std::uint8_t mode = PE_MODE_ENERGY_SAVING_MIN; mode <= PE_MODE_ENERGY_SAVING_MAX; ++mode)
  {
    EXPECT_EQ(GetPeModeName(mode), "PE_EnergySavingMode_" + std::to_string(mode) + "(" + Hex2(mode) + ")");
  }
}
 
TEST_F(IndicesTest, GetPeModeNameReturnsReservedForValueBetweenEnergySavingAndOperate)
{
  EXPECT_EQ(GetPeModeName(0x20), "PE_Reserved(0x20)");
}
 
TEST_F(IndicesTest, GetPeModeNameReturnsReservedForValueBetweenOperateAndSleepMode)
{
  EXPECT_EQ(GetPeModeName(0xF1), "PE_Reserved(0xF1)");
}
 
TEST_F(IndicesTest, GetPeModeNameReturnsReservedForValueBetweenSleepModeAndReadyToOperate)
{
  EXPECT_EQ(GetPeModeName(0x1F), "PE_EnergySavingMode_31(" + Hex2(PE_MODE_ENERGY_SAVING_MAX) + ")");
  EXPECT_EQ(GetPeModeName(0xF0), "PE_Operate");
 
  for (uint16_t mode = 0x20; mode <= 0xEF; ++mode)
  {
    const auto byteMode = static_cast<uint8_t>(mode);
    EXPECT_EQ(GetPeModeName(byteMode), "PE_Reserved(" + Hex2(byteMode) + ")");
  }
}
 
TEST_F(IndicesTest, DiagnosisIndicesReturnsSubslotTable)
{
  const IndexNamePairs expected = {
      {DIAG_CHANNEL_SUBSLOT, "DiagnosisChannel"},
      {DIAG_ALL_SUBSLOT, "DiagnosisAll"},
      {DIAG_MAINTENANCE_SUBSLOT, "DiagnosisMaintenance"},
  };
 
  ExpectIndexTable(DiagnosisIndices("subslot"), expected);
}
 
TEST_F(IndicesTest, DiagnosisIndicesReturnsSlotTable)
{
  const IndexNamePairs expected = {
      {DIAG_CHANNEL_SLOT, "DiagnosisChannel"},
      {DIAG_ALL_SLOT, "DiagnosisAll"},
      {DIAG_MAINTENANCE_SLOT, "DiagnosisMaintenance"},
  };
 
  ExpectIndexTable(DiagnosisIndices("slot"), expected);
}
 
TEST_F(IndicesTest, DiagnosisIndicesReturnsArTable)
{
  const IndexNamePairs expected = {
      {DIAG_CHANNEL_AR, "DiagnosisChannel"},
      {DIAG_ALL_AR, "DiagnosisAll"},
      {DIAG_MAINTENANCE_AR, "DiagnosisMaintenance"},
  };
 
  ExpectIndexTable(DiagnosisIndices("ar"), expected);
}
 
TEST_F(IndicesTest, DiagnosisIndicesReturnsApiTable)
{
  const IndexNamePairs expected = {
      {DIAG_CHANNEL_API, "DiagnosisChannel"},
      {DIAG_ALL_API, "DiagnosisAll"},
      {DIAG_MAINTENANCE_API, "DiagnosisMaintenance"},
  };
 
  ExpectIndexTable(DiagnosisIndices("api"), expected);
}
 
TEST_F(IndicesTest, DiagnosisIndicesReturnsDeviceTable)
{
  const IndexNamePairs expected = {
      {DIAG_DEVICE, "DeviceDiagnosis"},
  };
 
  ExpectIndexTable(DiagnosisIndices("device"), expected);
}
 
TEST_F(IndicesTest, DiagnosisIndicesReturnsEmptyTableForUnknownScopes)
{
  EXPECT_TRUE(DiagnosisIndices("").empty());
  EXPECT_TRUE(DiagnosisIndices("unknown").empty());
  EXPECT_TRUE(DiagnosisIndices("SUBSLOT").empty());
}
 
TEST_F(IndicesTest, CriticalIndicesReturnsExpectedEntries)
{
  const IndexNamePairs expected = {
      {IM0, "I&M0 (mandatory)"},
      {IM0_FILTER_DATA, "I&M0FilterData"},
      {DIAG_DEVICE, "Device Diagnosis"},
      {MODULE_DIFF_BLOCK, "ModuleDiffBlock"},
      {PD_REAL_DATA, "PDRealData"},
      {AR_DATA, "ARData"},
      {LOG_DATA, "LogData"},
  };
 
  ExpectIndexTable(CriticalIndices(), expected);
}
 
TEST_F(IndicesTest, ImIndicesReturnsAllImEntries)
{
  const auto& indices = ImIndices();
 
  ASSERT_EQ(indices.size(), 16U);
 
  for (std::size_t i = 0; i < indices.size(); ++i)
  {
    EXPECT_EQ(indices[i].first, static_cast<std::uint16_t>(IM0 + i));
    EXPECT_EQ(indices[i].second, "I&M" + std::to_string(i));
  }
}
 
TEST_F(IndicesTest, PortIndicesReturnsExpectedEntries)
{
  const IndexNamePairs expected = {
      {PD_PORT_DATA_REAL, "PDPortDataReal"},
      {PD_PORT_DATA_CHECK, "PDPortDataCheck"},
      {PD_PORT_DATA_ADJUST, "PDPortDataAdjust"},
      {PD_PORT_STATISTIC, "PDPortStatistic"},
      {PD_PORT_MRP_DATA_REAL, "PDPortMrpDataReal"},
  };
 
  ExpectIndexTable(PortIndices(), expected);
}
 
TEST_F(IndicesTest, InterfaceIndicesReturnsExpectedEntries)
{
  const IndexNamePairs expected = {
      {PD_INTERFACE_DATA_REAL, "PDInterfaceDataReal"},
      {PD_INTERFACE_MRP_DATA_REAL, "PDInterfaceMrpDataReal"},
      {PD_NC_DATA_CHECK, "PDNCDataCheck"},
  };
 
  ExpectIndexTable(InterfaceIndices(), expected);
}
 
TEST_F(IndicesTest, DeviceIndicesReturnsExpectedEntries)
{
  const IndexNamePairs expected = {
      {AR_DATA, "ARData"},
      {API_DATA, "APIData"},
      {PDEV_DATA, "PDevData"},
      {PD_REAL_DATA, "PDRealData"},
      {PD_EXPECTED_DATA, "PDExpectedData"},
      {LOG_DATA, "LogData"},
      {AUTO_CONFIG, "AutoConfiguration"},
  };
 
  ExpectIndexTable(DeviceIndices(), expected);
}
 
TEST_F(IndicesTest, AllStandardIndicesContainsAllStandardCategories)
{
  const auto& indices = AllStandardIndices();
 
  EXPECT_FALSE(indices.empty());
 
  EXPECT_NE(std::ranges::find_if(indices.begin(), indices.end(), [](const auto& entry)
  { return entry.first == IM0; }),
            indices.end());
  EXPECT_NE(std::ranges::find_if(indices.begin(), indices.end(), [](const auto& entry)
  { return entry.first == DIAG_CHANNEL_SUBSLOT; }),
            indices.end());
  EXPECT_NE(std::ranges::find_if(indices.begin(), indices.end(), [](const auto& entry)
  { return entry.first == DIAG_DEVICE; }),
            indices.end());
  EXPECT_NE(std::ranges::find_if(indices.begin(), indices.end(), [](const auto& entry)
  { return entry.first == PD_PORT_DATA_REAL; }),
            indices.end());
  EXPECT_NE(std::ranges::find_if(indices.begin(), indices.end(), [](const auto& entry)
  { return entry.first == PD_INTERFACE_DATA_REAL; }),
            indices.end());
  EXPECT_NE(std::ranges::find_if(indices.begin(), indices.end(), [](const auto& entry)
  { return entry.first == AR_DATA; }),
            indices.end());
  EXPECT_NE(std::ranges::find_if(indices.begin(), indices.end(), [](const auto& entry)
  { return entry.first == EXPECTED_ID_SUBSLOT; }),
            indices.end());
  EXPECT_NE(std::ranges::find_if(indices.begin(), indices.end(), [](const auto& entry)
  { return entry.first == REAL_ID_SUBSLOT; }),
            indices.end());
  EXPECT_NE(std::ranges::find_if(indices.begin(), indices.end(), [](const auto& entry)
  { return entry.first == MODULE_DIFF_BLOCK; }),
            indices.end());
  EXPECT_NE(std::ranges::find_if(indices.begin(), indices.end(), [](const auto& entry)
  { return entry.first == SUBSTITUTE_VALUES; }),
            indices.end());
  EXPECT_NE(std::ranges::find_if(indices.begin(), indices.end(), [](const auto& entry)
  { return entry.first == RECORD_INPUT_DATA; }),
            indices.end());
  EXPECT_NE(std::ranges::find_if(indices.begin(), indices.end(), [](const auto& entry)
  { return entry.first == RECORD_OUTPUT_DATA; }),
            indices.end());
}
 
TEST_F(IndicesTest, GetIndexNameResolvesAllStandardCategories)
{
  ExpectIndexNames({
      {IM0, "I&M0"},
      {IM15, "I&M15"},
      {DIAG_CHANNEL_SUBSLOT, "DiagnosisChannel"},
      {DIAG_ALL_SUBSLOT, "DiagnosisAll"},
      {DIAG_MAINTENANCE_SUBSLOT, "DiagnosisMaintenance"},
      {DIAG_DEVICE, "DeviceDiagnosis"},
      {PD_PORT_DATA_REAL, "PDPortDataReal"},
      {PD_PORT_DATA_CHECK, "PDPortDataCheck"},
      {PD_PORT_DATA_ADJUST, "PDPortDataAdjust"},
      {PD_PORT_STATISTIC, "PDPortStatistic"},
      {PD_PORT_MRP_DATA_REAL, "PDPortMrpDataReal"},
      {PD_INTERFACE_DATA_REAL, "PDInterfaceDataReal"},
      {PD_INTERFACE_MRP_DATA_REAL, "PDInterfaceMrpDataReal"},
      {PD_NC_DATA_CHECK, "PDNCDataCheck"},
      {AR_DATA, "ARData"},
      {API_DATA, "APIData"},
      {PDEV_DATA, "PDevData"},
      {PD_REAL_DATA, "PDRealData"},
      {PD_EXPECTED_DATA, "PDExpectedData"},
      {LOG_DATA, "LogData"},
      {AUTO_CONFIG, "AutoConfiguration"},
      {EXPECTED_ID_SUBSLOT, "ExpectedIdentificationData"},
      {REAL_ID_SUBSLOT, "RealIdentificationData"},
      {MODULE_DIFF_BLOCK, "ModuleDiffBlock"},
      {SUBSTITUTE_VALUES, "SubstituteValues"},
      {RECORD_INPUT_DATA, "RecordInputData"},
      {RECORD_OUTPUT_DATA, "RecordOutputData"},
  });
}
 
TEST_F(IndicesTest, GetIndexNameClassifiesUserSpecificIndices)
{
  ExpectIndexNames({
      {0x0000, "User-specific (0x0000)"},
      {0x0001, "User-specific (0x0001)"},
      {0x7FFF, "User-specific (0x7FFF)"},
  });
}
 
TEST_F(IndicesTest, GetIndexNameClassifiesUnregisteredImIndices)
{
  ExpectIndexNames({
      {0xAFF6, "I&M6"},
      {0xAFF7, "I&M7"},
      {0xAFFE, "I&M14"},
  });
}
 
TEST_F(IndicesTest, GetIndexNameClassifiesUnregisteredSubslotIndices)
{
  ExpectIndexNames({
      {0x8004, "Subslot data (0x8004)"},
      {0x80FF, "Subslot data (0x80FF)"},
      {0x8FFF, "Subslot data (0x8FFF)"},
  });
}
 
TEST_F(IndicesTest, GetIndexNameClassifiesUnregisteredSlotIndices)
{
  ExpectIndexNames({
      {0xC100, "Slot data (0xC100)"},
      {0xCFFF, "Slot data (0xCFFF)"},
  });
}
 
TEST_F(IndicesTest, GetIndexNameClassifiesUnregisteredArIndices)
{
  ExpectIndexNames({
      {0xE100, "AR data (0xE100)"},
      {0xEFFF, "AR data (0xEFFF)"},
  });
}
 
TEST_F(IndicesTest, GetIndexNameClassifiesUnregisteredApiIndices)
{
  ExpectIndexNames({
      {0xF100, "API data (0xF100)"},
      {0xF7FF, "API data (0xF7FF)"},
  });
}
 
TEST_F(IndicesTest, GetIndexNameClassifiesUnregisteredDeviceIndices)
{
  ExpectIndexNames({
      {0xF900, "Device data (0xF900)"},
      {0xFBFF, "Device data (0xFBFF)"},
  });
}
 
TEST_F(IndicesTest, GetIndexNameReturnsUnknownForUnclassifiedIndices)
{
  ExpectIndexNames({
      {0x9000, "Unknown (0x9000)"},
      {0x9FFF, "Unknown (0x9FFF)"},
      {0xB000, "Unknown (0xB000)"},
      {0xFFFF, "Unknown (0xFFFF)"},
  });
}
 
TEST_F(IndicesTest, GetScopeClassifiesAllSupportedScopes)
{
  ExpectScopes({
      {0x0000, "user"},
      {0x7FFF, "user"},
      {0x8000, "subslot"},
      {0x8FFF, "subslot"},
      {0xA000, "slot"},
      {0xAFFF, "slot"},
      {0xC000, "slot"},
      {0xCFFF, "slot"},
      {0xE000, "ar"},
      {0xEFFF, "ar"},
      {0xF000, "api"},
      {0xF7FF, "api"},
      {0xF800, "device"},
      {0xFBFF, "device"},
  });
}
 
TEST_F(IndicesTest, GetScopeReturnsUnknownForUnclassifiedRanges)
{
  ExpectScopes({
      {0x9000, "unknown"},
      {0x9FFF, "unknown"},
      {0xB000, "unknown"},
      {0xFFFF, "unknown"},
  });
}
 
} // namespace profinet