test_gsdml_real_device.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <algorithm>
#include <cstdint>
#include <filesystem>
#include <string>
#include <vector>
 
#include "profinet/IOSignal.h"
#include "profinet/gsdml.h"
 
namespace profinet::gsdml
{
 
namespace
{
std::filesystem::path FindGsdmlFile(const std::string& fileName)
{
  const std::vector<std::filesystem::path> candidates = {
      profinet::GetExecutableDirectory() / std::filesystem::path("gsdml") / fileName,
      profinet::GetExecutableDirectory() / std::filesystem::path("test_data") / fileName,
      profinet::GetExecutableDirectory() / std::filesystem::path("test_data") / "gsdml" / fileName,
      profinet::GetExecutableDirectory() / std::filesystem::path("tests") / "data" / fileName,
      profinet::GetExecutableDirectory() / std::filesystem::path("tests") / "data" / "gsdml" / fileName,
  };
 
  for (const auto& candidate : candidates)
  {
    if (std::filesystem::exists(candidate))
    {
      return candidate;
    }
  }
 
  ADD_FAILURE() << "Unable to locate GSDML fixture '" << fileName << "'";
  return {};
}
 
GSDMLDevice ParseAumaGsdml()
{
  const auto path = FindGsdmlFile("GSDML-V2.42-AUMA-SGX-20220920.xml");
 
  if (path.empty())
  {
    return {};
  }
 
  return ParseGsdml(path.string());
}
 
GSDMLDevice ParsePhoenixGsdml()
{
  const auto path = FindGsdmlFile("GSDML-V2.45-Phoenix Contact-AXC F 1252-20250813.xml");
 
  if (path.empty())
  {
    return {};
  }
 
  return ParseGsdml(path.string());
}
 
const rpc::IOSlot* FindSlot(const std::vector<rpc::IOSlot>& slots,
                            std::uint16_t slotNumber)
{
  for (const auto& slot : slots)
  {
    if (slot.slot == slotNumber)
    {
      return &slot;
    }
  }
 
  return nullptr;
}
 
const rpc::IOSlot* FindSlot(const std::vector<rpc::IOSlot>& slots,
                            std::uint16_t slotNumber,
                            std::uint16_t subslotNumber)
{
  for (const auto& slot : slots)
  {
    if ((slot.slot == slotNumber) && (slot.subslot == subslotNumber))
    {
      return &slot;
    }
  }
 
  return nullptr;
}
 
} // namespace
 
class GsdmlRealDeviceTest : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    auma = ParseAumaGsdml();
    phoenix = ParsePhoenixGsdml();
  }
 
  GSDMLDevice auma;
 
  GSDMLDevice phoenix;
};
 
TEST_F(GsdmlRealDeviceTest, ParsesAumaGsdml)
{
  EXPECT_EQ(auma.vendorId, 0x013F);
  EXPECT_EQ(auma.deviceId, 0x0002);
  EXPECT_EQ(auma.dapModuleIdentNumber, 0x80010000U);
}
 
TEST_F(GsdmlRealDeviceTest, ParsesPhoenixGsdml)
{
  EXPECT_EQ(phoenix.vendorId, 0x00B0);
  EXPECT_EQ(phoenix.deviceId, 0x0193);
  EXPECT_EQ(phoenix.dapModuleIdentNumber, 0x00000300U);
}
 
TEST_F(GsdmlRealDeviceTest, ParsesVendorId)
{
  EXPECT_EQ(auma.vendorId, 0x013F);
}
 
TEST_F(GsdmlRealDeviceTest, ParsesDeviceId)
{
  EXPECT_EQ(auma.deviceId, 0x0002);
}
 
TEST_F(GsdmlRealDeviceTest, FindsDap)
{
  ASSERT_NE(auma.dapModuleIdentNumber, 0U);
  EXPECT_EQ(auma.dapModuleIdentNumber, 0x80010000U);
  EXPECT_EQ(auma.dapSubmoduleIdentNumber, 0x00000001U);
  EXPECT_EQ(auma.dapSlots, (std::vector<int>{0, 1, 2}));
}
 
TEST_F(GsdmlRealDeviceTest, FindsActuatorStatusModule)
{
  const auto* module = auma.FindModule("ID_MODULE_ADI_IN_0");
 
  ASSERT_NE(module, nullptr);
  EXPECT_EQ(module->moduleIdentNumber, 0x00008000U);
  EXPECT_EQ(module->submodules.size(), 1U);
}
 
TEST_F(GsdmlRealDeviceTest, FindsActuatorControlModule)
{
  const auto* module = auma.FindModule("ID_MODULE_ADI_OUT_0");
 
  ASSERT_NE(module, nullptr);
  EXPECT_EQ(module->moduleIdentNumber, 0x00008100U);
  EXPECT_EQ(module->submodules.size(), 1U);
}
 
TEST_F(GsdmlRealDeviceTest, ParsesStatusInputLength)
{
  const auto* module = auma.FindModule("ID_MODULE_ADI_IN_0");
 
  ASSERT_NE(module, nullptr);
 
  const auto submodule = module->submodules.find("ID_SUBMOD_ADI_IN_0");
 
  ASSERT_NE(submodule, module->submodules.end());
  EXPECT_EQ(submodule->second.inputLength, 34);
  EXPECT_EQ(submodule->second.outputLength, 0);
}
 
TEST_F(GsdmlRealDeviceTest, ParsesControlOutputLength)
{
  const auto* module = auma.FindModule("ID_MODULE_ADI_OUT_0");
 
  ASSERT_NE(module, nullptr);
 
  const auto submodule = module->submodules.find("ID_SUBMOD_ADI_OUT_0");
 
  ASSERT_NE(submodule, module->submodules.end());
  EXPECT_EQ(submodule->second.inputLength, 0);
  EXPECT_EQ(submodule->second.outputLength, 16);
}
 
TEST_F(GsdmlRealDeviceTest, ParsesStatusSubmoduleIdent)
{
  const auto* module = auma.FindModule("ID_MODULE_ADI_IN_0");
 
  ASSERT_NE(module, nullptr);
 
  const auto submodule = module->submodules.find("ID_SUBMOD_ADI_IN_0");
 
  ASSERT_NE(submodule, module->submodules.end());
  EXPECT_EQ(submodule->second.submoduleIdentNumber, 0x00002200U);
}
 
TEST_F(GsdmlRealDeviceTest, ParsesControlSubmoduleIdent)
{
  const auto* module = auma.FindModule("ID_MODULE_ADI_OUT_0");
 
  ASSERT_NE(module, nullptr);
 
  const auto submodule = module->submodules.find("ID_SUBMOD_ADI_OUT_0");
 
  ASSERT_NE(submodule, module->submodules.end());
  EXPECT_EQ(submodule->second.submoduleIdentNumber, 0x10001000U);
}
 
TEST_F(GsdmlRealDeviceTest, BuildIoSlotsMatchesExpectedInputLengths)
{
  const auto slots = auma.BuildIoSlots();
 
  const auto* status = FindSlot(slots, 1, 1);
  const auto* control = FindSlot(slots, 2, 1);
 
  ASSERT_NE(status, nullptr);
  ASSERT_NE(control, nullptr);
 
  EXPECT_EQ(status->inputLength, 34);
  EXPECT_EQ(status->outputLength, 0);
 
  EXPECT_EQ(control->inputLength, 0);
  EXPECT_EQ(control->outputLength, 16);
}
 
TEST_F(GsdmlRealDeviceTest, BuildIoSlotsMatchesExpectedOutputLengths)
{
  const auto slots = auma.BuildIoSlots();
 
  const auto* status = FindSlot(slots, 1, 1);
  const auto* control = FindSlot(slots, 2, 1);
 
  ASSERT_NE(status, nullptr);
  ASSERT_NE(control, nullptr);
 
  EXPECT_EQ(status->outputLength, 0);
  EXPECT_EQ(control->outputLength, 16);
}
 
TEST_F(GsdmlRealDeviceTest, BuildIoSlotsProducesExpectedModuleIdents)
{
  const auto slots = auma.BuildIoSlots();
 
  const auto* status = FindSlot(slots, 1, 1);
  const auto* control = FindSlot(slots, 2, 1);
 
  ASSERT_NE(status, nullptr);
  ASSERT_NE(control, nullptr);
 
  EXPECT_EQ(status->moduleIdent, 0x00008000U);
  EXPECT_EQ(status->submoduleIdent, 0x00002200U);
 
  EXPECT_EQ(control->moduleIdent, 0x00008100U);
  EXPECT_EQ(control->submoduleIdent, 0x10001000U);
}
 
TEST_F(GsdmlRealDeviceTest, FindsPhoenixIoModule)
{
  const auto* module = phoenix.FindModule("PNSlot1");
 
  ASSERT_NE(module, nullptr);
  EXPECT_EQ(module->moduleIdentNumber, 0x00000001U);
}
 
TEST_F(GsdmlRealDeviceTest, FindsPhoenixDap)
{
  EXPECT_EQ(phoenix.dapModuleIdentNumber, 0x00000300U);
  EXPECT_EQ(phoenix.dapSubmoduleIdentNumber, 0x00000001U);
}
TEST_F(GsdmlRealDeviceTest, BuildsPhoenixDefaultIoSlotConfiguration)
{
  const auto slots = phoenix.BuildIoSlots();
 
  ASSERT_EQ(slots.size(), 4U);
 
  const auto* dap = FindSlot(slots, 0, 1);
  const auto* interface = FindSlot(slots, 0, 0x8000);
  const auto* port = FindSlot(slots, 0, 0x8001);
  const auto* io = FindSlot(slots, 1, 1);
 
  ASSERT_NE(dap, nullptr);
  ASSERT_NE(interface, nullptr);
  ASSERT_NE(port, nullptr);
  ASSERT_NE(io, nullptr);
 
  EXPECT_EQ(dap->moduleIdent, phoenix.dapModuleIdentNumber);
  EXPECT_EQ(dap->submoduleIdent, phoenix.dapSubmoduleIdentNumber);
 
  EXPECT_EQ(interface->submoduleIdent, 0x00000002U);
  EXPECT_EQ(port->submoduleIdent, 0x00000003U);
 
  EXPECT_EQ(io->moduleIdent, 0x00000001U);
  EXPECT_EQ(io->submoduleIdent, 0x00000001U);
}
 
TEST_F(GsdmlRealDeviceTest, PhoenixFixedModuleResolvesToSlotOne)
{
  const auto slots = phoenix.BuildIoSlots();
 
  const auto* slot = FindSlot(slots, 1, 1);
 
  ASSERT_NE(slot, nullptr);
 
  EXPECT_EQ(slot->moduleIdent, 0x00000001U);
  EXPECT_EQ(slot->submoduleIdent, 0x00000001U);
  EXPECT_EQ(slot->inputLength, 512);
  EXPECT_EQ(slot->outputLength, 512);
}
 
TEST_F(GsdmlRealDeviceTest, PhoenixDefaultSubmoduleResolvesToPnio512512)
{
  const auto* module = phoenix.FindModule("PNSlot1");
 
  ASSERT_NE(module, nullptr);
  ASSERT_EQ(module->submoduleReferences.size(), 9U);
 
  const auto* submodule = phoenix.FindSubmodule("PNIO512512");
 
  ASSERT_NE(submodule, nullptr);
 
  EXPECT_EQ(submodule->submoduleIdentNumber, 0x00000001U);
  EXPECT_EQ(submodule->inputLength, 512);
  EXPECT_EQ(submodule->outputLength, 512);
}
 
TEST_F(GsdmlRealDeviceTest, PhoenixModuleReferenceContainsUsedSubslot)
{
  const auto* module = phoenix.FindModule("PNSlot1");
 
  ASSERT_NE(module, nullptr);
 
  bool foundUsedSubslot = false;
 
  for (const auto& reference : module->submoduleReferences)
  {
    if (reference.submoduleId == "PNIO512512")
    {
      foundUsedSubslot = true;
 
      EXPECT_EQ(reference.allowedSubslots, (std::vector<int>{1}));
      EXPECT_EQ(reference.fixedSubslots, std::vector<int>{});
      EXPECT_EQ(reference.usedSubslots, (std::vector<int>{1}));
    }
  }
 
  EXPECT_TRUE(foundUsedSubslot);
}
 
TEST_F(GsdmlRealDeviceTest, PhoenixApplicationRelationsExposeTimingProperties)
{
  EXPECT_EQ(phoenix.applicationRelations.numberOfAr, 3U);
 
  EXPECT_EQ(phoenix.applicationRelations.sendClockTimingProperties,
            (std::vector<std::uint16_t>{32}));
 
  EXPECT_EQ(phoenix.applicationRelations.reductionRatioTimingProperties,
            (std::vector<std::uint16_t>{
                1, 2, 4, 8, 16, 32, 64, 128, 256, 512}));
 
  EXPECT_EQ(
      phoenix.applicationRelations.startupMode,
      rpc::StartupMode::Advanced);
}
 
TEST_F(GsdmlRealDeviceTest, PhoenixDapVirtualSubmoduleBuildsSlotZero)
{
  const auto slots = phoenix.BuildIoSlots();
 
  const auto* slot = FindSlot(slots, 0, 1);
 
  ASSERT_NE(slot, nullptr);
 
  EXPECT_EQ(slot->moduleIdent, phoenix.dapModuleIdentNumber);
  EXPECT_EQ(slot->submoduleIdent, phoenix.dapSubmoduleIdentNumber);
  EXPECT_EQ(slot->inputLength, 0U);
  EXPECT_EQ(slot->outputLength, 0U);
}
 
TEST_F(GsdmlRealDeviceTest, PhoenixInterfaceSubmoduleBuildsAtPdevSubslot)
{
  const auto slots = phoenix.BuildIoSlots();
 
  const auto* slot = FindSlot(slots, 0, 0x8000);
 
  ASSERT_NE(slot, nullptr);
 
  EXPECT_EQ(slot->submoduleIdent, 0x00000002U);
  EXPECT_EQ(slot->inputLength, 0U);
  EXPECT_EQ(slot->outputLength, 0U);
}
 
TEST_F(GsdmlRealDeviceTest, PhoenixPortSubmoduleBuildsAtPdevSubslot)
{
  const auto slots = phoenix.BuildIoSlots();
 
  const auto* slot = FindSlot(slots, 0, 0x8001);
 
  ASSERT_NE(slot, nullptr);
 
  EXPECT_EQ(slot->submoduleIdent, 0x00000003U);
  EXPECT_EQ(slot->inputLength, 0U);
  EXPECT_EQ(slot->outputLength, 0U);
}
 
TEST_F(GsdmlRealDeviceTest, PhoenixExplicitPluggedConfigurationOverridesDefault)
{
  const auto slots = phoenix.BuildIoSlots(
      {{1, "PNSlot1", 1, "PNIO0202"}});
 
  const auto* slot = FindSlot(slots, 1, 1);
 
  ASSERT_NE(slot, nullptr);
 
  EXPECT_EQ(slot->moduleIdent, 0x00000001U);
  EXPECT_EQ(slot->submoduleIdent, 0x00000009U);
  EXPECT_EQ(slot->inputLength, 2U);
  EXPECT_EQ(slot->outputLength, 2U);
}
 
TEST_F(GsdmlRealDeviceTest, ExplicitModuleAssignmentRejectsDisallowedPhoenixSlot)
{
  EXPECT_THROW(
      phoenix.BuildIoSlots(
          {{2, "PNSlot1", 1, "PNIO0202"}}),
      std::invalid_argument);
}
 
TEST_F(GsdmlRealDeviceTest, ExplicitConfigurationRejectsUnknownModule)
{
  EXPECT_THROW(
      phoenix.BuildIoSlots(
          {{1, "DOES_NOT_EXIST", 1, "PNIO0202"}}),
      std::invalid_argument);
}
 
TEST_F(GsdmlRealDeviceTest, ExplicitConfigurationRejectsUnknownSubmodule)
{
  EXPECT_THROW(
      phoenix.BuildIoSlots(
          {{1, "PNSlot1", 1, "DOES_NOT_EXIST"}}),
      std::invalid_argument);
}
 
TEST_F(GsdmlRealDeviceTest, ExplicitConfigurationRejectsDisallowedSubslot)
{
  EXPECT_THROW(
      phoenix.BuildIoSlots(
          {{1, "PNSlot1", 2, "PNIO0202"}}),
      std::invalid_argument);
}
 
TEST_F(GsdmlRealDeviceTest, BuildIoSlotsIsDeterministic)
{
  const auto first = phoenix.BuildIoSlots();
  const auto second = phoenix.BuildIoSlots();
 
  ASSERT_EQ(first.size(), second.size());
 
  for (std::size_t index = 0; index < first.size(); ++index)
  {
    EXPECT_EQ(first[index].slot, second[index].slot);
    EXPECT_EQ(first[index].subslot, second[index].subslot);
    EXPECT_EQ(first[index].moduleIdent, second[index].moduleIdent);
    EXPECT_EQ(first[index].submoduleIdent, second[index].submoduleIdent);
    EXPECT_EQ(first[index].inputLength, second[index].inputLength);
    EXPECT_EQ(first[index].outputLength, second[index].outputLength);
  }
}
 
TEST_F(GsdmlRealDeviceTest, AumaInputDataItemsMatchReportedLength)
{
  for (const auto& [moduleId, module] : auma.modules)
  {
    (void)moduleId;
 
    for (const auto& [submoduleId, submodule] : module.submodules)
    {
      (void)submoduleId;
 
      int length = 0;
 
      for (const auto& item : submodule.inputItems)
      {
        length += item.length;
      }
 
      EXPECT_EQ(length, submodule.inputLength)
          << "Module '" << module.id
          << "', submodule '" << submodule.id << "'";
    }
  }
}
 
TEST_F(GsdmlRealDeviceTest, AumaOutputDataItemsMatchReportedLength)
{
  for (const auto& [moduleId, module] : auma.modules)
  {
    (void)moduleId;
 
    for (const auto& [submoduleId, submodule] : module.submodules)
    {
      (void)submoduleId;
 
      int length = 0;
 
      for (const auto& item : submodule.outputItems)
      {
        length += item.length;
      }
 
      EXPECT_EQ(length, submodule.outputLength)
          << "Module '" << module.id
          << "', submodule '" << submodule.id << "'";
    }
  }
}
 
TEST_F(GsdmlRealDeviceTest, PhoenixInputDataItemsMatchReportedLength)
{
  for (const auto& [submoduleId, submodule] : phoenix.submodules)
  {
    (void)submoduleId;
 
    int length = 0;
 
    for (const auto& item : submodule.inputItems)
    {
      length += item.length;
    }
 
    EXPECT_EQ(length, submodule.inputLength)
        << "Submodule '" << submodule.id << "'";
  }
}
 
TEST_F(GsdmlRealDeviceTest, PhoenixOutputDataItemsMatchReportedLength)
{
  for (const auto& [submoduleId, submodule] : phoenix.submodules)
  {
    (void)submoduleId;
 
    int length = 0;
 
    for (const auto& item : submodule.outputItems)
    {
      length += item.length;
    }
 
    EXPECT_EQ(length, submodule.outputLength)
        << "Submodule '" << submodule.id << "'";
  }
}
TEST_F(GsdmlRealDeviceTest, AumaBuildIoSlotsContainsExpectedDeviceConfiguration)
{
  const auto slots = auma.BuildIoSlots();
 
  const auto* dap = FindSlot(slots, 0, 1);
  const auto* input = FindSlot(slots, 1, 1);
  const auto* output = FindSlot(slots, 2, 1);
 
  ASSERT_NE(dap, nullptr);
  ASSERT_NE(input, nullptr);
  ASSERT_NE(output, nullptr);
 
  EXPECT_EQ(dap->moduleIdent, auma.dapModuleIdentNumber);
  EXPECT_EQ(dap->submoduleIdent, auma.dapSubmoduleIdentNumber);
 
  EXPECT_EQ(input->moduleIdent, 0x00008000U);
  EXPECT_EQ(input->submoduleIdent, 0x00002200U);
  EXPECT_EQ(input->inputLength, 34U);
  EXPECT_EQ(input->outputLength, 0U);
 
  EXPECT_EQ(output->moduleIdent, 0x00008100U);
  EXPECT_EQ(output->submoduleIdent, 0x10001000U);
  EXPECT_EQ(output->inputLength, 0U);
  EXPECT_EQ(output->outputLength, 16U);
}
 
TEST_F(GsdmlRealDeviceTest, AumaBuildIoSlotsDoesNotMutateParsedDevice)
{
  const auto vendorId = auma.vendorId;
  const auto deviceId = auma.deviceId;
  const auto moduleCount = auma.modules.size();
  const auto submoduleCount = auma.submodules.size();
 
  const auto first = auma.BuildIoSlots();
  const auto second = auma.BuildIoSlots();
 
  EXPECT_EQ(vendorId, auma.vendorId);
  EXPECT_EQ(deviceId, auma.deviceId);
  EXPECT_EQ(moduleCount, auma.modules.size());
  EXPECT_EQ(submoduleCount, auma.submodules.size());
 
  ASSERT_EQ(first.size(), second.size());
 
  for (std::size_t index = 0; index < first.size(); ++index)
  {
    EXPECT_EQ(first[index].slot, second[index].slot);
    EXPECT_EQ(first[index].subslot, second[index].subslot);
    EXPECT_EQ(first[index].moduleIdent, second[index].moduleIdent);
    EXPECT_EQ(first[index].submoduleIdent, second[index].submoduleIdent);
    EXPECT_EQ(first[index].inputLength, second[index].inputLength);
    EXPECT_EQ(first[index].outputLength, second[index].outputLength);
  }
}
 
TEST_F(GsdmlRealDeviceTest, AumaCyclicIoLengthsMatchConfiguredModules)
{
  const auto* inputModule = auma.FindModule("ID_MODULE_ADI_IN_0");
  const auto* outputModule = auma.FindModule("ID_MODULE_ADI_OUT_0");
 
  ASSERT_NE(inputModule, nullptr);
  ASSERT_NE(outputModule, nullptr);
 
  const auto inputIt =
      inputModule->submodules.find("ID_SUBMOD_ADI_IN_0");
  const auto outputIt =
      outputModule->submodules.find("ID_SUBMOD_ADI_OUT_0");
 
  ASSERT_NE(inputIt, inputModule->submodules.end());
  ASSERT_NE(outputIt, outputModule->submodules.end());
 
  const auto slots = auma.BuildIoSlots();
 
  const auto* input = FindSlot(slots, 1, 1);
  const auto* output = FindSlot(slots, 2, 1);
 
  ASSERT_NE(input, nullptr);
  ASSERT_NE(output, nullptr);
 
  EXPECT_EQ(input->inputLength, inputIt->second.inputLength);
  EXPECT_EQ(input->outputLength, inputIt->second.outputLength);
 
  EXPECT_EQ(output->inputLength, outputIt->second.inputLength);
  EXPECT_EQ(output->outputLength, outputIt->second.outputLength);
}
 
TEST_F(GsdmlRealDeviceTest, AumaRepeatedParsingProducesSameMetadata)
{
  const auto firstPath =
      FindGsdmlFile("GSDML-V2.42-AUMA-SGX-20220920.xml");
 
  ASSERT_FALSE(firstPath.empty());
 
  const auto first = ParseGsdml(firstPath.string());
  const auto second = ParseGsdml(firstPath.string());
 
  EXPECT_EQ(first.vendorId, second.vendorId);
  EXPECT_EQ(first.deviceId, second.deviceId);
  EXPECT_EQ(first.dapModuleId, second.dapModuleId);
  EXPECT_EQ(first.dapModuleIdentNumber, second.dapModuleIdentNumber);
  EXPECT_EQ(first.dapSubmoduleIdentNumber, second.dapSubmoduleIdentNumber);
  EXPECT_EQ(first.modules.size(), second.modules.size());
  EXPECT_EQ(first.submodules.size(), second.submodules.size());
}
TEST_F(GsdmlRealDeviceTest, BuildIoSlotsMatchesExpectedSlots)
{
  const auto slots = auma.BuildIoSlots();
  const auto numberOfIoSlotEntries = slots.size();
  ASSERT_EQ(numberOfIoSlotEntries, 9U);
 
  // -------------------------------------------------------------------------
  // DAP / PDEV entries.
  //
  // The AUMA DAP contributes seven IOSlot entries at slot 0:
  //
  //   0/0x0001
  //   0/0x0002
  //   0/0x0003
  //   0/0x0004
  //   0/0x8000
  //   0/0x8001
  //   0/0x8002
  // -------------------------------------------------------------------------
 
  ASSERT_NE(FindSlot(slots, 0, 0x0001), nullptr);
  ASSERT_NE(FindSlot(slots, 0, 0x0002), nullptr);
  ASSERT_NE(FindSlot(slots, 0, 0x0003), nullptr);
  ASSERT_NE(FindSlot(slots, 0, 0x0004), nullptr);
  ASSERT_NE(FindSlot(slots, 0, 0x8000), nullptr);
  ASSERT_NE(FindSlot(slots, 0, 0x8001), nullptr);
  ASSERT_NE(FindSlot(slots, 0, 0x8002), nullptr);
 
  // -------------------------------------------------------------------------
  // Configured cyclic I/O entries.
  // -------------------------------------------------------------------------
 
  ASSERT_NE(FindSlot(slots, 1, 1), nullptr);
  ASSERT_NE(FindSlot(slots, 2, 1), nullptr);
}
 
TEST_F(GsdmlRealDeviceTest, BuildIoSlotsMatchesExpectedInputOutputLengths)
{
  const auto slots = auma.BuildIoSlots();
 
  const auto* status = FindSlot(slots, 1, 1);
  const auto* control = FindSlot(slots, 2, 1);
 
  ASSERT_NE(status, nullptr);
  ASSERT_NE(control, nullptr);
 
  EXPECT_EQ(status->inputLength, 34U);
  EXPECT_EQ(status->outputLength, 0U);
 
  EXPECT_EQ(control->inputLength, 0U);
  EXPECT_EQ(control->outputLength, 16U);
}
namespace
{
bool Contains(const std::vector<int>& values, const int value)
{
  return std::ranges::find(values, value) != values.end();
}
 
const GSDMLSubmodule* FindSignalSubmodule(const GSDMLDevice& device, const profinet::io::IoSignal& signal)
{
  if (signal.moduleId == device.dapModuleId)
  {
    return nullptr;
  }
 
  const auto* module = device.FindModule(signal.moduleId);
  if (module == nullptr)
  {
    return nullptr;
  }
 
  const auto inlineIt = module->submodules.find(signal.submoduleId);
  if (inlineIt != module->submodules.end())
  {
    return &inlineIt->second;
  }
 
  return device.FindSubmodule(signal.submoduleId);
}
 
const rpc::IOSlot* FindSignalIoSlot(const std::vector<rpc::IOSlot>& slots, const profinet::io::IoSignal& signal)
{
  for (const auto& slot : slots)
  {
    if ((slot.moduleIdent == signal.moduleIdentNumber) && (slot.submoduleIdent == signal.submoduleIdentNumber))
    {
      return &slot;
    }
  }
 
  return nullptr;
}
} // namespace
 
TEST_F(GsdmlRealDeviceTest, BuildsAumaIoSignalCatalog)
{
  const auto catalog = profinet::io::IoSignalCatalog::FromGsdml(auma);
 
  EXPECT_GT(catalog.Size(), 0U);
  EXPECT_GT(catalog.Sensors().size(), 0U);
  EXPECT_GT(catalog.Actuators().size(), 0U);
 
  for (const auto& signal : catalog.Sensors())
  {
    EXPECT_TRUE(signal.IsSensor());
    EXPECT_FALSE(signal.IsActuator());
    EXPECT_FALSE(signal.name.empty());
    EXPECT_FALSE(signal.submoduleId.empty());
    EXPECT_GT(signal.byteLength, 0U);
  }
 
  for (const auto& signal : catalog.Actuators())
  {
    EXPECT_TRUE(signal.IsActuator());
    EXPECT_FALSE(signal.IsSensor());
    EXPECT_FALSE(signal.name.empty());
    EXPECT_FALSE(signal.submoduleId.empty());
    EXPECT_GT(signal.byteLength, 0U);
  }
}
 
TEST_F(GsdmlRealDeviceTest, AumaSensorSignalsUseStatusSubmodule)
{
  const auto catalog = profinet::io::IoSignalCatalog::FromGsdml(auma);
 
  ASSERT_GT(catalog.Sensors().size(), 0U);
 
  for (const auto& signal : catalog.Sensors())
  {
    if (signal.moduleId != "ID_MODULE_ADI_IN_0")
    {
      continue;
    }
 
    EXPECT_EQ(signal.submoduleId, "ID_SUBMOD_ADI_IN_0");
    EXPECT_EQ(signal.moduleIdentNumber, 0x00008000U);
    EXPECT_EQ(signal.submoduleIdentNumber, 0x00002200U);
    EXPECT_TRUE(Contains(signal.possibleSlots, 1));
    EXPECT_TRUE(Contains(signal.possibleSubslots, 1));
  }
}
 
TEST_F(GsdmlRealDeviceTest, AumaActuatorSignalsUseControlSubmodule)
{
  const auto catalog = profinet::io::IoSignalCatalog::FromGsdml(auma);
 
  ASSERT_GT(catalog.Actuators().size(), 0U);
 
  for (const auto& signal : catalog.Actuators())
  {
    if (signal.moduleId != "ID_MODULE_ADI_OUT_0")
    {
      continue;
    }
 
    EXPECT_EQ(signal.submoduleId, "ID_SUBMOD_ADI_OUT_0");
    EXPECT_EQ(signal.moduleIdentNumber, 0x00008100U);
    EXPECT_EQ(signal.submoduleIdentNumber, 0x10001000U);
    EXPECT_TRUE(Contains(signal.possibleSlots, 2));
    EXPECT_TRUE(Contains(signal.possibleSubslots, 1));
  }
}
 
TEST_F(GsdmlRealDeviceTest, AumaSignalsStayWithinProcessDataLengths)
{
  const auto catalog = profinet::io::IoSignalCatalog::FromGsdml(auma);
 
  for (const auto& signal : catalog.Sensors())
  {
    const auto* submodule = FindSignalSubmodule(auma, signal);
 
    ASSERT_NE(submodule, nullptr)
        << "Unable to resolve sensor submodule '" << signal.submoduleId << "'";
 
    ASSERT_GE(signal.byteOffset + signal.byteLength, signal.byteOffset);
    EXPECT_LE(signal.byteOffset + signal.byteLength,
              static_cast<std::size_t>(submodule->inputLength))
        << "Signal '" << signal.name << "' exceeds input process-data length";
  }
 
  for (const auto& signal : catalog.Actuators())
  {
    const auto* submodule = FindSignalSubmodule(auma, signal);
 
    ASSERT_NE(submodule, nullptr)
        << "Unable to resolve actuator submodule '" << signal.submoduleId << "'";
 
    ASSERT_GE(signal.byteOffset + signal.byteLength, signal.byteOffset);
    EXPECT_LE(signal.byteOffset + signal.byteLength, static_cast<std::size_t>(submodule->outputLength))
        << "Signal '" << signal.name << "' exceeds output process-data length";
  }
}
 
TEST_F(GsdmlRealDeviceTest, AumaCatalogExcludesReservedSignals)
{
  const auto catalog = profinet::io::IoSignalCatalog::FromGsdml(auma);
 
  for (const auto& signal : catalog.Sensors())
  {
    EXPECT_FALSE(profinet::io::IsReservedSignal(signal.textId, signal.name))
        << "Reserved sensor signal exposed: '" << signal.name << "'";
  }
 
  for (const auto& signal : catalog.Actuators())
  {
    EXPECT_FALSE(profinet::io::IsReservedSignal(signal.textId, signal.name))
        << "Reserved actuator signal exposed: '" << signal.name << "'";
  }
}
 
TEST_F(GsdmlRealDeviceTest, AumaCatalogSignalsHaveValueClassification)
{
  const auto catalog = profinet::io::IoSignalCatalog::FromGsdml(auma);
 
  ASSERT_GT(catalog.Size(), 0U);
 
  for (const auto& signal : catalog.Sensors())
  {
    EXPECT_NE(signal.valueType, profinet::io::IoSignalValueType::Unsupported)
        << "Unsupported sensor DataType '" << signal.gsdmlDataType
        << "' for signal '" << signal.name << "'";
  }
 
  for (const auto& signal : catalog.Actuators())
  {
    EXPECT_NE(signal.valueType, profinet::io::IoSignalValueType::Unsupported)
        << "Unsupported actuator DataType '" << signal.gsdmlDataType
        << "' for signal '" << signal.name << "'";
  }
}
 
TEST_F(GsdmlRealDeviceTest, BuildsPhoenixIoSignalCatalog)
{
  const auto catalog = profinet::io::IoSignalCatalog::FromGsdml(phoenix);
 
  EXPECT_GT(catalog.Size(), 0U);
 
  for (const auto& signal : catalog.Sensors())
  {
    EXPECT_FALSE(signal.name.empty());
    EXPECT_FALSE(signal.submoduleId.empty());
    EXPECT_GT(signal.byteLength, 0U);
  }
 
  for (const auto& signal : catalog.Actuators())
  {
    EXPECT_FALSE(signal.name.empty());
    EXPECT_FALSE(signal.submoduleId.empty());
    EXPECT_GT(signal.byteLength, 0U);
  }
}
 
TEST_F(GsdmlRealDeviceTest, PhoenixCatalogExcludesReservedSignals)
{
  const auto catalog = profinet::io::IoSignalCatalog::FromGsdml(phoenix);
 
  for (const auto& signal : catalog.Sensors())
  {
    EXPECT_FALSE(profinet::io::IsReservedSignal(signal.textId, signal.name));
  }
 
  for (const auto& signal : catalog.Actuators())
  {
    EXPECT_FALSE(profinet::io::IsReservedSignal(signal.textId, signal.name));
  }
}
TEST_F(GsdmlRealDeviceTest, AumaSignalsMatchGeneratedIoSlots)
{
  const auto catalog = profinet::io::IoSignalCatalog::FromGsdml(auma);
  const auto slots = auma.BuildIoSlots();
 
  const auto* status = FindSlot(slots, 1, 1);
  const auto* control = FindSlot(slots, 2, 1);
 
  ASSERT_NE(status, nullptr);
  ASSERT_NE(control, nullptr);
 
  for (const auto& signal : catalog.Sensors())
  {
    if (signal.moduleId != "ID_MODULE_ADI_IN_0")
    {
      continue;
    }
 
    EXPECT_EQ(signal.moduleIdentNumber, status->moduleIdent);
    EXPECT_EQ(signal.submoduleIdentNumber, status->submoduleIdent);
 
    EXPECT_LE(signal.byteOffset + signal.byteLength,
              static_cast<std::size_t>(status->inputLength));
  }
 
  for (const auto& signal : catalog.Actuators())
  {
    if (signal.moduleId != "ID_MODULE_ADI_OUT_0")
    {
      continue;
    }
 
    EXPECT_EQ(signal.moduleIdentNumber, control->moduleIdent);
    EXPECT_EQ(signal.submoduleIdentNumber, control->submoduleIdent);
 
    EXPECT_LE(signal.byteOffset + signal.byteLength,
              static_cast<std::size_t>(control->outputLength));
  }
}
TEST_F(GsdmlRealDeviceTest, ParsesAumaBitDataItems)
{
  const auto* module = auma.FindModule("ID_MODULE_ADI_IN_0");
 
  ASSERT_NE(module, nullptr);
 
  const auto it = module->submodules.find("ID_SUBMOD_ADI_IN_0");
 
  ASSERT_NE(it, module->submodules.end());
 
  const auto& items = it->second.inputItems;
 
  ASSERT_GE(items.size(), 1U);
 
  const auto& log = items[0];
 
  EXPECT_EQ(log.textId, "T_ID_LOG");
  EXPECT_EQ(log.dataType, "Unsigned8");
  EXPECT_EQ(log.length, 1);
  EXPECT_TRUE(log.useAsBits);
 
  ASSERT_EQ(log.bitDataItems.size(), 8U);
 
  for (std::size_t index = 0; index < log.bitDataItems.size(); ++index)
  {
    EXPECT_EQ(log.bitDataItems[index].bitOffset, index);
    EXPECT_EQ(
        log.bitDataItems[index].textId,
        "T_ID_LOG_" + std::to_string(index));
  }
}
 
TEST_F(GsdmlRealDeviceTest, AumaLogByteCreatesEightBitSignals)
{
  const auto catalog = profinet::io::IoSignalCatalog::FromGsdml(auma);
 
  std::vector<const profinet::io::IoSignal*> logBits;
 
  for (const auto& signal : catalog.Sensors())
  {
    if (signal.parentDataItemTextId == "T_ID_LOG")
    {
      logBits.push_back(&signal);
    }
  }
 
  ASSERT_EQ(logBits.size(), 8U);
 
  std::ranges::sort(logBits, [](const auto* lhs, const auto* rhs)
  {
    return lhs->bitOffset < rhs->bitOffset;
  });
 
  for (std::size_t index = 0; index < logBits.size(); ++index)
  {
    const auto& signal = *logBits[index];
 
    EXPECT_TRUE(signal.IsBitSignal());
    EXPECT_EQ(signal.textId, "T_ID_LOG_" + std::to_string(index));
    EXPECT_EQ(signal.byteOffset, 0U);
    EXPECT_EQ(signal.bitOffset, index);
    EXPECT_EQ(signal.valueType,
              profinet::io::IoSignalValueType::Boolean);
  }
}
TEST_F(GsdmlRealDeviceTest, AumaCommandBitsHaveCorrectByteAndBitOffsets)
{
  const auto catalog =
      profinet::io::IoSignalCatalog::FromGsdml(auma);
 
  std::vector<const profinet::io::IoSignal*> commandBits;
 
  for (const auto& signal : catalog.Actuators())
  {
    if (signal.parentDataItemTextId == "T_ID_CMD")
    {
      commandBits.push_back(&signal);
    }
  }
 
  ASSERT_EQ(commandBits.size(), 5U); // 5 because 3 are reserved
 
  std::ranges::sort(commandBits, [](const auto* lhs, const auto* rhs)
  {
    return lhs->bitOffset < rhs->bitOffset;
  });
 
  for (std::size_t index = 0;
       index < commandBits.size();
       ++index)
  {
    const auto& signal = *commandBits[index];
 
    EXPECT_EQ(signal.byteOffset, 0U);
    EXPECT_EQ(signal.bitOffset, index);
    EXPECT_EQ(signal.parentDataItemByteOffset, 0U);
    EXPECT_EQ(signal.byteLength, 1U);
  }
}
} // namespace profinet::gsdml