test_blocks.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include "profinet/blocks.h"
#include "profinet/indices.h"
#include "profinet/wire.h"
 
using namespace profinet;
using namespace profinet::blocks;
 
// =============================================================================
// Helpers to build raw wire bytes for test fixtures
// =============================================================================
 
namespace
{
 
Bytes MakeBlockHeader(BlockType blockType,
                      std::uint16_t blockLength,
                      std::uint8_t verHi = 1,
                      std::uint8_t verLo = 0)
{
  Bytes out;
  wire::PutU16(out, static_cast<std::uint16_t>(blockType));
  wire::PutU16(out, blockLength);
  wire::PutU8(out, verHi);
  wire::PutU8(out, verLo);
  return out;
}
 
Bytes MakeModuleDiffBlock(std::uint16_t slot,
                          std::uint16_t subslot,
                          std::uint16_t moduleState,
                          std::uint16_t submoduleState)
{
  Bytes body;
 
  wire::PutU16(body, 1);      // NumberOfAPIs
  wire::PutU32(body, 0);      // API
  wire::PutU16(body, 1);      // NumberOfModules
  wire::PutU16(body, slot);   // SlotNumber
  wire::PutU32(body, 0x0001); // ModuleIdentNumber
  wire::PutU16(body, moduleState);
  wire::PutU16(body, 1); // NumberOfSubmodules
  wire::PutU16(body, subslot);
  wire::PutU32(body, 0x0001); // SubmoduleIdentNumber
  wire::PutU16(body, submoduleState);
 
  const Bytes hdr = MakeBlockHeader(BlockType::ModuleDifference, body.size() + 2);
 
  Bytes out = hdr;
  out.insert(out.end(), body.begin(), body.end());
 
  return out;
}
 
Bytes MakeRealIdDataV10(const std::vector<std::pair<std::uint16_t, std::uint16_t>>& slots)
{
  // No outer block header for v1.0.
  Bytes body;
 
  wire::PutU16(body, slots.size());
 
  for (auto [Slot, Subslot] : slots)
  {
    wire::PutU16(body, Slot);
    wire::PutU32(body, 0x42); // ModuleIdentNumber
    wire::PutU16(body, 1);    // NumberOfSubslots
    wire::PutU16(body, Subslot);
    wire::PutU32(body, 0x99); // SubmoduleIdentNumber
  }
 
  return body;
}
 
Bytes MakeExpectedSubmoduleDD(std::uint16_t dataDescription,
                              std::uint16_t dataLen)
{
  Bytes out;
 
  wire::PutU16(out, dataDescription);
  wire::PutU16(out, dataLen);
  wire::PutU8(out, 1); // length_iocs
  wire::PutU8(out, 1); // length_iops
 
  return out;
}
 
} // namespace
 
// =============================================================================
// Test fixture
// =============================================================================
namespace
{
class BlocksTest : public ::testing::Test
{
};
} // namespace
  //
// =============================================================================
// parse_block_header
// =============================================================================
 
TEST_F(BlocksTest, ParseBlockHeader)
{
  const Bytes data = MakeBlockHeader(BlockType::ApplicationRelationRequest, 58);
 
  auto [hdr, newOffset] = ParseBlockHeader(data);
 
  EXPECT_EQ(hdr.blockType, BlockType::ApplicationRelationRequest);
  EXPECT_EQ(hdr.blockLength, 58);
  EXPECT_EQ(hdr.versionHigh, 1);
  EXPECT_EQ(hdr.versionLow, 0);
  EXPECT_EQ(newOffset, 6U);
  EXPECT_EQ(hdr.BodyLength(), 56);
  EXPECT_EQ(hdr.TypeName(), "Application Relation Request");
}
 
TEST_F(BlocksTest, ParseBlockHeaderRejectsTooShortData)
{
  const Bytes data = {0x01, 0x01, 0x00};
 
  EXPECT_THROW(ParseBlockHeader(data), std::exception);
}
 
TEST_F(BlocksTest, Align4)
{
  EXPECT_EQ(Align4(0), 0);
  EXPECT_EQ(Align4(1), 4);
  EXPECT_EQ(Align4(4), 4);
  EXPECT_EQ(Align4(5), 8);
  EXPECT_EQ(Align4(7), 8);
  EXPECT_EQ(Align4(8), 8);
}
 
// =============================================================================
// ModuleDiffBlock
// =============================================================================
 
TEST_F(BlocksTest, ParseModuleDiffBlockAllOk)
{
  const Bytes data = MakeModuleDiffBlock(
      1,
      1,
      MODULE_STATE_PROPER_MODULE,
      SUBMODULE_STATE_OK);
 
  auto mdb = ParseModuleDiffBlock(data);
 
  ASSERT_EQ(mdb.modules.size(), 1);
 
  ASSERT_FALSE(mdb.modules[0].submodules.empty());
 
  EXPECT_TRUE(mdb.modules[0].IsProper());
  EXPECT_TRUE(mdb.modules[0].submodules[0].IsOk());
  EXPECT_TRUE(mdb.AllOk());
  EXPECT_TRUE(mdb.GetMismatches().empty());
}
 
TEST_F(BlocksTest, ParseModuleDiffBlockWrongSubmodule)
{
  const Bytes data = MakeModuleDiffBlock(
      1,
      2,
      MODULE_STATE_PROPER_MODULE,
      SUBMODULE_STATE_WRONG_SUBMODULE);
 
  auto mdb = ParseModuleDiffBlock(data);
 
  EXPECT_FALSE(mdb.AllOk());
 
  auto mismatches = mdb.GetMismatches();
 
  ASSERT_EQ(mismatches.size(), 1);
 
  EXPECT_EQ(std::get<0>(mismatches[0]), 1);
 
  EXPECT_EQ(std::get<1>(mismatches[0]), 2);
 
  EXPECT_EQ(std::get<2>(mismatches[0]), "WrongSubmodule");
}
 
TEST_F(BlocksTest, ParseModuleDiffBlockRejectsWrongBlockType)
{
  Bytes data = MakeBlockHeader(BlockType::ExpectedSubmoduleRequest, 10);
 
  data.insert(data.end(), 10, 0);
 
  EXPECT_THROW(ParseModuleDiffBlock(data), std::exception);
}
 
TEST_F(BlocksTest, ParseModuleDiffBlockTooShortReturnsEmpty)
{
  const Bytes data = {0x01, 0x02};
 
  auto mdb = ParseModuleDiffBlock(data);
 
  EXPECT_TRUE(mdb.modules.empty());
}
 
// =============================================================================
// RealIdentificationData
// =============================================================================
 
TEST_F(BlocksTest, ParseRealIdentificationDataV10)
{
  const Bytes data = MakeRealIdDataV10({{0, 1},
                                        {1, 1}});
 
  auto result = ParseRealIdentificationData(data);
 
  // v1.0 has no outer block header; version defaults to 1.0.
  ASSERT_EQ(result.slots.size(), 2);
 
  EXPECT_EQ(result.slots[0].slot, 0);
  EXPECT_EQ(result.slots[1].slot, 1);
  EXPECT_EQ(result.slots[0].moduleIdent, 0x42);
  EXPECT_EQ(result.slots[0].submoduleIdent, 0x99);
}
 
TEST_F(BlocksTest, ParseRealIdentificationDataTooShortReturnsEmpty)
{
  const Bytes data = {0x01};
 
  auto result = ParseRealIdentificationData(data);
 
  EXPECT_TRUE(result.slots.empty());
}
 
// =============================================================================
// IODWriteMultipleBuilder + parse_write_multiple_response
// =============================================================================
 
TEST_F(BlocksTest, IODWriteMultipleBuilderBuildsValidPacket)
{
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  arUuid[0] = 0xAA;
 
  IODWriteMultipleBuilder builder(arUuid, 0);
 
  builder.AddWrite(
      1,
      1,
      0xAFF1,
      {0x11, 0x22, 0x33, 0x44});
 
  builder.AddWrite(
      1,
      1,
      0xAFF2,
      {0x55, 0x66});
 
  Bytes packet = builder.Build();
 
  // Outer header:
  // 6 (block header)
  // + 2 (seq)
  // + 16 (ar_uuid)
  // + 4 (api)
  // + 2 (slot)
  // + 2 (subslot)
  // + 2 (pad)
  // + 2 (idx)
  // + 4 (len)
  // + 24 (padding)
  // = 64
  ASSERT_GE(packet.size(), 64);
 
  // INDEX field is at bytes 34-35.
  ASSERT_GE(packet.size(), 36);
 
  wire::Reader r(packet);
  r.SkipTo(34);
  const auto outerIdx = r.U16();
 
  EXPECT_EQ(outerIdx, WRITE_MULTIPLE);
}
 
// =============================================================================
// ExpectedSubmoduleBlockReq
// =============================================================================
 
TEST_F(BlocksTest, ExpectedSubmoduleBlockReqBuildsInputBlock)
{
  ExpectedSubmoduleBlockReq req;
 
  req.AddSubmodule(
      0,
      1,
      1,
      0x0001,
      0x0001,
      1, // INPUT
      4,
      0);
 
  Bytes out = req.ToBytes();
  wire::Reader r(out);
 
  ASSERT_GE(out.size(), 6U);
 
  const auto blockType = r.U16();
 
  EXPECT_EQ(blockType, BlockType::ExpectedSubmoduleRequest);
 
  // Body starts at offset 6:
  r.SkipTo(6);
  // NumberOfAPIs
  const auto numApis = r.U16();
 
  EXPECT_EQ(numApis, 1U);
}
 
TEST_F(BlocksTest, ExpectedSubmoduleBlockReqInputOutputIncludesTwoDataDescriptions)
{
  ExpectedSubmoduleBlockReq req;
 
  req.AddSubmodule(
      0,
      1,
      1,
      0x0001,
      0x0001,
      3, // INPUT_OUTPUT
      4,
      2);
 
  const Bytes out = req.ToBytes();
 
  // Body:
  // NumAPIs(2)
  // + API entry(14)
  // + submodule header(8)
  // + 2 DDs(12)
  // = 36 bytes
  //
  // Total with header = 6 + 36 = 42 bytes.
  EXPECT_EQ(out.size(), 42);
}
 
TEST_F(BlocksTest, ExpectedSubmoduleBlockReqNoIoProducesOneDataDescription)
{
  ExpectedSubmoduleBlockReq req;
 
  req.AddSubmodule(
      0,
      0,
      1,
      0x0001,
      0x0001,
      0, // NO_IO
      0,
      0);
 
  const Bytes out = req.ToBytes();
 
  // Body:
  // NumAPIs(2)
  // + API entry(14)
  // + submodule header(8)
  // + 1 DD(6)
  // = 30 bytes
  //
  // Total with header = 6 + 30 = 36 bytes.
  EXPECT_EQ(out.size(), 36);
}
 
// =============================================================================
// parse_port_statistics
// =============================================================================
 
TEST_F(BlocksTest, ParsePortStatistics)
{
  Bytes data;
 
  wire::PutU16(data, 0x0003); // counter_status
  wire::PutU32(data, 100000); // in_octets
  wire::PutU32(data, 200000); // out_octets
  wire::PutU32(data, 10);     // in_discards
  wire::PutU32(data, 20);     // out_discards
  wire::PutU32(data, 5);      // in_errors
  wire::PutU32(data, 7);      // out_errors
 
  auto stats = ParsePortStatistics(data);
 
  ASSERT_TRUE(stats.has_value());
 
  EXPECT_EQ(stats->counterStatus, 0x0003);
  EXPECT_EQ(stats->inOctets, 100000);
  EXPECT_EQ(stats->outOctets, 200000);
  EXPECT_EQ(stats->inErrors, 5);
}
 
TEST_F(BlocksTest, ParsePortStatisticsTooShortReturnsNullopt)
{
  const Bytes data = {0x00, 0x03, 0x00};
 
  auto stats = ParsePortStatistics(data);
 
  EXPECT_FALSE(stats.has_value());
}
 
namespace
{
 
constexpr std::size_t TestAlign4(const std::size_t offset)
{
  return (offset + 3U) & ~3U;
}
 
void AlignBuffer4(Bytes& data)
{
  data.resize(TestAlign4(data.size()), 0);
}
 
Bytes BuildPdPortData(
    const std::uint16_t slot,
    const std::uint16_t subslot,
    const std::string& portId,
    const std::vector<PeerInfo>& peers,
    const std::uint16_t mauType = 0,
    const std::uint32_t domainBoundary = 0,
    const std::uint32_t multicastBoundary = 0,
    const std::uint8_t linkStatePort = 0,
    const std::uint8_t linkStateLink = 0,
    const std::uint32_t mediaType = 0)
{
  Bytes data;
 
  // Slot / subslot.
  wire::PutU16(data, slot);
  wire::PutU16(data, subslot);
 
  // Port ID.
  wire::PutU8(data, portId.size());
  wire::PutFixed(data, portId);
 
  // Number of peers.
  wire::PutU8(data, peers.size());
 
  // Peer records start on a 4-byte boundary.
  AlignBuffer4(data);
 
  for (const auto& peer : peers)
  {
    wire::PutU8(data, peer.portId.size());
    wire::PutFixed(data, peer.portId);
 
    wire::PutU8(data, peer.chassisId.size());
    wire::PutFixed(data, peer.chassisId);
 
    // Parser aligns before reading the MAC address.
    AlignBuffer4(data);
 
    wire::PutFixed(data, peer.macAddress);
    // Parser aligns before the next peer / MAU type.
    AlignBuffer4(data);
  }
 
  // MAU type.
  wire::PutU16(data, mauType);
 
  // Parser aligns before boundaries.
  AlignBuffer4(data);
 
  // Domain boundary.
  wire::PutU32(data, domainBoundary);
 
  // Multicast boundary.
  wire::PutU32(data, multicastBoundary);
 
  // Link state.
  wire::PutU8(data, linkStatePort);
  wire::PutU8(data, linkStateLink);
 
  // Parser aligns before media type.
  AlignBuffer4(data);
 
  // Media type.
  wire::PutU32(data, mediaType);
 
  return data;
}
 
} // namespace
 
TEST_F(BlocksTest, ParsePdPortDataRealParsesSlotAndSubslot)
{
  const Bytes data = BuildPdPortData(
      1,
      0x8001,
      "",
      {});
 
  const auto result = ParsePdPortDataReal(data, 0, 99, 99);
 
  EXPECT_EQ(result.slot, 1);
  EXPECT_EQ(result.subslot, 0x8001);
}
 
TEST_F(BlocksTest, ParsePdPortDataRealDecodesAsciiPortId)
{
  const Bytes data = BuildPdPortData(
      1,
      0x8001,
      "Port",
      {});
 
  const auto result = ParsePdPortDataReal(data, 0, 99, 99);
 
  EXPECT_EQ(result.slot, 1);
  EXPECT_EQ(result.subslot, 0x8001);
  EXPECT_EQ(result.portId, "Port");
}
 
TEST_F(BlocksTest, ParsePdPortDataRealDecodesExtendedLatin1PortId)
{
  const std::string latin1PortId{
      'P',
      static_cast<char>(0xE9), // é
      static_cast<char>(0xF6)  // ö
  };
 
  const Bytes data = BuildPdPortData(
      1,
      0x8001,
      latin1PortId,
      {});
 
  const auto result = ParsePdPortDataReal(data, 0, 99, 99);
 
  EXPECT_EQ(
      result.portId,
      "P\xC3\xA9\xC3\xB6");
}
 
TEST_F(BlocksTest, ParsePdPortDataRealParsesPeer)
{
  const PeerInfo peer{
      .portId = "Peer1",
      .chassisId = "Chass1",
      .macAddress = {
          0x00, 0x11, 0x22,
          0x33, 0x44, 0x55}};
 
  const Bytes data = BuildPdPortData(
      1,
      0x8001,
      "Port",
      {peer});
 
  const auto result = ParsePdPortDataReal(data, 0, 99, 99);
 
  ASSERT_EQ(result.peers.size(), 1U);
 
  EXPECT_EQ(result.peers[0].portId, "Peer1");
  EXPECT_EQ(result.peers[0].chassisId, "Chass1");
 
  const std::array<std::uint8_t, 6> expectedMac{
      0x00, 0x11, 0x22,
      0x33, 0x44, 0x55};
 
  EXPECT_EQ(result.peers[0].macAddress, expectedMac);
}
 
TEST_F(BlocksTest, ParsePdPortDataRealDecodesExtendedLatin1PeerIds)
{
  const PeerInfo peer{
      .portId = std::string{
          static_cast<char>(0xE9) // é
      },
      .chassisId = std::string{
          static_cast<char>(0xF6) // ö
      },
      .macAddress = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55}};
 
  const Bytes data = BuildPdPortData(
      1,
      0x8001,
      "Port",
      {peer});
 
  const auto result = ParsePdPortDataReal(data, 0, 99, 99);
 
  ASSERT_EQ(result.peers.size(), 1U);
 
  EXPECT_EQ(result.peers[0].portId, "\xC3\xA9");
  EXPECT_EQ(result.peers[0].chassisId, "\xC3\xB6");
}
 
TEST_F(BlocksTest, ParsePdPortDataRealParsesMauType)
{
  const Bytes data = BuildPdPortData(
      1,
      0x8001,
      "Port",
      {},
      30);
 
  const auto result = ParsePdPortDataReal(data, 0, 99, 99);
 
  EXPECT_EQ(result.mauType, 30);
}
 
TEST_F(BlocksTest, ParsePdPortDataRealParsesPortProperties)
{
  const Bytes data = BuildPdPortData(
      1,
      0x8001,
      "Port",
      {},
      30,
      0x12345678,
      0x9ABCDEF0,
      0x01,
      0x02,
      0x11223344);
 
  const auto result = ParsePdPortDataReal(data, 0, 99, 99);
 
  EXPECT_EQ(result.mauType, 30);
  EXPECT_EQ(result.domainBoundary, 0x12345678U);
  EXPECT_EQ(result.multicastBoundary, 0x9ABCDEF0U);
  EXPECT_EQ(result.linkStatePort, 0x01);
  EXPECT_EQ(result.linkStateLink, 0x02);
  EXPECT_EQ(result.mediaType, 0x11223344U);
}
 
TEST_F(BlocksTest, ParsePdPortDataRealParsesCompletePortData)
{
  const PeerInfo peer{
      .portId = "Peer1",
      .chassisId = "Chass1",
      .macAddress = {
          0xAA, 0xBB, 0xCC,
          0xDD, 0xEE, 0xFF}};
 
  const Bytes data = BuildPdPortData(
      1,
      0x8001,
      "Port",
      {peer},
      30,
      0x12345678,
      0x9ABCDEF0,
      0x01,
      0x02,
      0x11223344);
 
  const auto result = ParsePdPortDataReal(data, 0, 0, 0);
 
  EXPECT_EQ(result.slot, 1);
  EXPECT_EQ(result.subslot, 0x8001);
  EXPECT_EQ(result.portId, "Port");
 
  EXPECT_EQ(result.mauType, 30);
  EXPECT_EQ(result.domainBoundary, 0x12345678U);
  EXPECT_EQ(result.multicastBoundary, 0x9ABCDEF0U);
  EXPECT_EQ(result.linkStatePort, 0x01);
  EXPECT_EQ(result.linkStateLink, 0x02);
  EXPECT_EQ(result.mediaType, 0x11223344U);
 
  ASSERT_EQ(result.peers.size(), 1U);
 
  EXPECT_EQ(result.peers[0].portId, "Peer1");
  EXPECT_EQ(result.peers[0].chassisId, "Chass1");
 
  const std::array<std::uint8_t, 6> expectedMac{
      0xAA, 0xBB, 0xCC,
      0xDD, 0xEE, 0xFF};
 
  EXPECT_EQ(result.peers[0].macAddress, expectedMac);
}
 
TEST_F(BlocksTest, ParsePdPortDataRealHandlesEmptyData)
{
  const Bytes data;
 
  const auto result = ParsePdPortDataReal(data, 0, 7, 0x8001);
 
  EXPECT_EQ(result.slot, 7);
  EXPECT_EQ(result.subslot, 0x8001);
  EXPECT_TRUE(result.portId.empty());
  EXPECT_EQ(result.mauType, 0);
  EXPECT_EQ(result.linkStatePort, 0);
  EXPECT_EQ(result.linkStateLink, 0);
  EXPECT_EQ(result.mediaType, 0);
  EXPECT_TRUE(result.peers.empty());
  EXPECT_EQ(result.domainBoundary, 0U);
  EXPECT_EQ(result.multicastBoundary, 0U);
}
 
TEST_F(BlocksTest, ParsePdPortDataRealHandlesMissingPortIdLength)
{
  const Bytes data{
      0x00, 0x01,
      0x80, 0x01};
 
  const auto result = ParsePdPortDataReal(data, 0, 7, 0x8001);
 
  EXPECT_EQ(result.slot, 1);
  EXPECT_EQ(result.subslot, 0x8001);
  EXPECT_TRUE(result.portId.empty());
  EXPECT_TRUE(result.peers.empty());
}
 
TEST_F(BlocksTest, ParsePdPortDataRealHandlesTruncatedPortId)
{
  const Bytes data{
      0x00, 0x01,
      0x80, 0x01,
 
      // Port ID length = 5, but only 2 bytes follow.
      0x05,
      'P',
      'o'};
 
  const auto result = ParsePdPortDataReal(data, 0, 7, 0x8001);
 
  EXPECT_TRUE(result.portId.empty());
  EXPECT_TRUE(result.peers.empty());
}
 
TEST_F(BlocksTest, ParsePdPortDataRealHandlesMissingPeerCount)
{
  const Bytes data{
      0x00, 0x01,
      0x80, 0x01,
 
      0x01,
      'P'};
 
  const auto result = ParsePdPortDataReal(data, 0, 7, 0x8001);
 
  EXPECT_EQ(result.portId, "P");
  EXPECT_TRUE(result.peers.empty());
}
 
TEST_F(BlocksTest, DISABLED_ParsePdPortDataRealHandlesTruncatedPeerPortId)
{
  const Bytes data{
      // Slot/subslot.
      0x00, 0x01,
      0x80, 0x01,
 
      // Port ID: "P".
      0x01,
      'P',
 
      // One peer.
      0x01,
 
      // Padding to relative offset 8.
      0x00,
 
      // Peer port ID length = 5, but only "Pe" is present.
      0x05,
      'P',
      'e'};
 
  ASSERT_EQ(data.size(), 11U);
 
  const auto result = ParsePdPortDataReal(data, 0, 7, 0x8001);
 
  EXPECT_EQ(result.slot, 1);
  EXPECT_EQ(result.subslot, 0x8001);
  EXPECT_EQ(result.portId, "P");
  EXPECT_TRUE(result.peers.empty());
}