test_blocksMore.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <array>
#include <cstdint>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include "profinet/blocks.h"
#include "profinet/indices.h"
#include "profinet/wire.h"
 
using namespace profinet;
using namespace profinet::blocks;
 
namespace
{
Bytes MakeHeader(const BlockType blockType, const std::uint16_t blockLength,
                 const std::uint8_t versionHigh = 1, const std::uint8_t versionLow = 0)
{
  Bytes out;
  wire::PutU16(out, static_cast<std::uint16_t>(blockType));
  wire::PutU16(out, blockLength);
  wire::PutU8(out, versionHigh);
  wire::PutU8(out, versionLow);
  return out;
}
 
void AlignFromHeader(Bytes& data, const std::size_t blockHeaderSize)
{
  while (((blockHeaderSize + data.size()) % 4U) != 0U)
  {
    data.push_back(0);
  }
}
 
Bytes MakeInterfaceBody(const std::string& chassisId, const MacAddress& mac,
                        const std::array<std::uint8_t, 4>& ip, const std::array<std::uint8_t, 4>& subnet,
                        const std::array<std::uint8_t, 4>& gateway, const std::size_t blockHeaderSize = blockHeaderLength)
{
  Bytes body;
  wire::PutU8(body, static_cast<std::uint8_t>(chassisId.size()));
  body.insert(body.end(), chassisId.begin(), chassisId.end());
  AlignFromHeader(body, blockHeaderSize);
  body.insert(body.end(), mac.begin(), mac.end());
  AlignFromHeader(body, blockHeaderSize);
  body.insert(body.end(), ip.begin(), ip.end());
  body.insert(body.end(), subnet.begin(), subnet.end());
  body.insert(body.end(), gateway.begin(), gateway.end());
  return body;
}
 
Bytes MakePortBody(const std::string& portId, const std::vector<PeerInfo>& peers,
                   const bool includeMau = true, const bool includeBoundaries = true,
                   const bool includeLink = true, const bool includeMedia = true)
{
  Bytes body;
  wire::PutU16(body, 1);
  wire::PutU16(body, 0x8001);
 
  wire::PutU8(body, static_cast<std::uint8_t>(portId.size()));
  body.insert(body.end(), portId.begin(), portId.end());
  wire::PutU8(body, static_cast<std::uint8_t>(peers.size()));
  while ((body.size() % 4U) != 0U)
  {
    body.push_back(0);
  }
 
  for (const auto& peer : peers)
  {
    wire::PutU8(body, static_cast<std::uint8_t>(peer.portId.size()));
    body.insert(body.end(), peer.portId.begin(), peer.portId.end());
    wire::PutU8(body, static_cast<std::uint8_t>(peer.chassisId.size()));
    body.insert(body.end(), peer.chassisId.begin(), peer.chassisId.end());
 
    while ((body.size() % 4U) != 0U)
    {
      body.push_back(0);
    }
 
    body.insert(body.end(), peer.macAddress.begin(), peer.macAddress.end());
 
    while ((body.size() % 4U) != 0U)
    {
      body.push_back(0);
    }
  }
 
  if (includeMau)
  {
    wire::PutU16(body, 30);
  }
 
  while ((body.size() % 4U) != 0U)
  {
    body.push_back(0);
  }
 
  if (includeBoundaries)
  {
    wire::PutU32(body, 0x11223344);
    wire::PutU32(body, 0x55667788);
  }
 
  if (includeLink)
  {
    wire::PutU8(body, 1);
    wire::PutU8(body, 2);
  }
 
  while ((body.size() % 4U) != 0U)
  {
    body.push_back(0);
  }
 
  if (includeMedia)
  {
    wire::PutU32(body, 0x99AABBCC);
  }
 
  return body;
}
 
Bytes MakeBlock(const BlockType type, const Bytes& body)
{
  Bytes out = MakeHeader(type, static_cast<std::uint16_t>(body.size() + 2U));
  wire::PutFixed(out, body);
 
  return out;
}
 
Bytes MakeMultipleBlock(const std::uint32_t api, const std::uint16_t slot,
                        const std::uint16_t subslot, const std::vector<Bytes>& nested)
{
  Bytes body;
  wire::PutU16(body, 0);
  wire::PutU32(body, api);
  wire::PutU16(body, slot);
  wire::PutU16(body, subslot);
 
  for (const auto& block : nested)
  {
    body.insert(body.end(), block.begin(), block.end());
  }
 
  return MakeBlock(BlockType::MultipleHeader, body);
}
 
Bytes MakeRidBody(const std::vector<std::tuple<std::uint16_t, std::uint16_t, std::uint32_t, std::uint32_t>>& entries)
{
  Bytes out;
  wire::PutU16(out, static_cast<std::uint16_t>(entries.size()));
  for (const auto& [slot, subslot, moduleIdent, submoduleIdent] : entries)
  {
    wire::PutU16(out, slot);
    wire::PutU32(out, moduleIdent);
    wire::PutU16(out, 1);
    wire::PutU16(out, subslot);
    wire::PutU32(out, submoduleIdent);
  }
  return out;
}
 
Bytes MakeModuleDiff(const std::uint16_t moduleState, const std::uint16_t submoduleState)
{
  Bytes body;
  wire::PutU16(body, 1);
  wire::PutU32(body, 0);
  wire::PutU16(body, 1);
  wire::PutU16(body, 1);
  wire::PutU32(body, 0x1234);
  wire::PutU16(body, moduleState);
  wire::PutU16(body, 1);
  wire::PutU16(body, 1);
  wire::PutU32(body, 0x5678);
  wire::PutU16(body, submoduleState);
  return MakeBlock(BlockType::ModuleDifference, body);
}
 
Bytes MakeMinimalWriteMultipleResponse()
{
  Bytes data(64U, 0);
  data[0] = 0x00;
  data[1] = 0x08;
  data[2] = 0x00;
  data[3] = 0x3A;
  data[4] = 0x01;
  data[5] = 0x00;
  return data;
}
Bytes MakeRidV11Body()
{
  Bytes out;
 
  wire::PutU16(out, 1);          // NumberOfAPIs
  wire::PutU32(out, 0x12345678); // API
  wire::PutU16(out, 1);          // NumberOfSlots
 
  wire::PutU16(out, 2);      // Slot
  wire::PutU32(out, 0x1000); // ModuleIdent
  wire::PutU16(out, 2);      // NumberOfSubslots
 
  wire::PutU16(out, 0x8001);
  wire::PutU32(out, 0x2001);
 
  wire::PutU16(out, 0x8002);
  wire::PutU32(out, 0x2002);
 
  return out;
}
 
Bytes MakeWriteMultipleResponseBlock(
    std::uint16_t blockType,
    std::uint16_t sequence,
    std::uint32_t api,
    std::uint16_t slot,
    std::uint16_t subslot,
    std::uint16_t index,
    std::uint16_t additionalValue1,
    std::uint16_t additionalValue2,
    std::uint32_t status)
{
  Bytes block;
 
  // Block header: 4 bytes.
  wire::PutU16(block, blockType);
  wire::PutU16(block, 52); // BlockLength: total block size is 4 + 52 = 56.
 
  // Version + sequence number: 4 bytes.
  wire::PutU8(block, 0x01);
  wire::PutU8(block, 0x00);
  wire::PutU16(block, sequence);
 
  // AR UUID: 16 bytes.
  block.insert(block.end(), uuidLenght, 0);
 
  // API + slot + subslot + padding.
  wire::PutU32(block, api);
  wire::PutU16(block, slot);
  wire::PutU16(block, subslot);
  wire::PutU16(block, 0);
 
  // Record index + record-data length.
  wire::PutU16(block, index);
  wire::PutU32(block, 0);
 
  // Additional status values + PNIO status.
  wire::PutU16(block, additionalValue1);
  wire::PutU16(block, additionalValue2);
  wire::PutU32(block, status);
 
  // The parser consumes a fixed 56-byte result block.
  EXPECT_EQ(block.size(), 48U);
  if (block.size() < 48U)
  {
    return {};
  }
  block.resize(56U, 0);
 
  return block;
}
} // namespace
 
namespace
{ 
class BlocksMoreTests : public ::testing::Test
{
};
} // namespace
 
TEST_F(BlocksMoreTests, BlockHeaderBodyLengthHandlesLengthsBelowTwo)
{
  EXPECT_EQ(BlockHeader{.blockLength = 0}.BodyLength(), 0U);
  EXPECT_EQ(BlockHeader{.blockLength = 1}.BodyLength(), 0U);
  EXPECT_EQ(BlockHeader{.blockLength = 2}.BodyLength(), 0U);
  EXPECT_EQ(BlockHeader{.blockLength = 9}.BodyLength(), 7U);
}
 
TEST_F(BlocksMoreTests, BlockHeaderTypeNameHandlesUnknownType)
{
  BlockHeader header{.blockType = static_cast<BlockType>(0xFFFF)};
  EXPECT_FALSE(header.TypeName().empty());
}
 
TEST_F(BlocksMoreTests, SlotInfoToStringFormatsSubslot)
{
  const SlotInfo info{.slot = 7, .subslot = 0x8001, .api = 0x42};
 
  EXPECT_EQ(info.ToString(), "SlotInfo(api=66, slot=7, subslot=0x8001)");
}
 
TEST_F(BlocksMoreTests, PeerInfoMacStrFormatsAddress)
{
  const PeerInfo peer{.macAddress = {0x00, 0x01, 0x02, 0xA0, 0xB0, 0xC0}};
 
  EXPECT_EQ(peer.MacStr(), "00:01:02:a0:b0:c0");
}
 
TEST_F(BlocksMoreTests, PortInfoMauTypeNameCoversKnownAndUnknownValues)
{
  const std::vector<std::pair<std::uint16_t, std::string>> values{
      {0, "Unknown"},
      {10, "10BASE-T HD"},
      {11, "10BASE-T FD"},
      {15, "100BASE-TX HD"},
      {16, "100BASE-TX FD"},
      {17, "100BASE-FX HD"},
      {18, "100BASE-FX FD"},
      {29, "1000BASE-T HD"},
      {30, "1000BASE-T FD"},
      {21, "1000BASE-X HD"},
      {22, "1000BASE-X FD"},
      {40, "10GBASE-T"}};
 
  for (const auto& [value, expected] : values)
  {
    PortInfo info;
    info.mauType = value;
    EXPECT_EQ(info.MauTypeName(), expected);
  }
 
  PortInfo unknown;
  unknown.mauType = 999;
  EXPECT_EQ(unknown.MauTypeName(), "Unknown(999)");
}
 
TEST_F(BlocksMoreTests, PortInfoLinkStateCoversAllBranches)
{
  const std::vector<std::pair<std::uint8_t, std::string>> values{{0, "Unknown"},
                                                                 {1, "Up"},
                                                                 {2, "Down"},
                                                                 {3, "Testing"},
                                                                 {4, "Unknown(4)"}};
 
  for (const auto& [value, expected] : values)
  {
    PortInfo info;
    info.linkStateLink = value;
    EXPECT_EQ(info.LinkState(), expected);
  }
}
 
TEST_F(BlocksMoreTests, InterfaceInfoFormattingHelpers)
{
  const InterfaceInfo info{
      .chassisId = "chassis", .macAddress = {1, 2, 3, 4, 5, 6}, .ipAddress = {192, 168, 1, 10}, .subnetMask = {255, 255, 255, 0}, .gateway = {192, 168, 1, 1}};
 
  EXPECT_EQ(info.MacStr(), "01:02:03:04:05:06");
  EXPECT_EQ(info.IpStr(), "192.168.1.10");
  EXPECT_EQ(info.SubnetStr(), "255.255.255.0");
  EXPECT_EQ(info.GatewayStr(), "192.168.1.1");
}
 
TEST_F(BlocksMoreTests, ParseBlockHeaderSupportsOffset)
{
  Bytes data{0xAA, 0xBB};
  const Bytes header = MakeHeader(BlockType::ModuleDifference, 12, 2, 3);
  data.insert(data.end(), header.begin(), header.end());
 
  const auto [parsed, next] = ParseBlockHeader(data, 2);
 
  EXPECT_EQ(parsed.blockType, BlockType::ModuleDifference);
  EXPECT_EQ(parsed.blockLength, 12U);
  EXPECT_EQ(parsed.versionHigh, 2U);
  EXPECT_EQ(parsed.versionLow, 3U);
  EXPECT_EQ(next, 8U);
}
 
TEST_F(BlocksMoreTests, ParseBlockHeaderRejectsTruncatedOffset)
{
  const Bytes data{0x00, 0x01, 0x02, 0x03};
  EXPECT_THROW(ParseBlockHeader(data, 3), std::invalid_argument);
}
 
TEST_F(BlocksMoreTests, ParseMultipleBlockHeaderParsesAllFields)
{
  Bytes data(3U, 0xAA);
  wire::PutU16(data, 0x0000);
  wire::PutU32(data, 0x01020304);
  wire::PutU16(data, 0x0007);
  wire::PutU16(data, 0x8001);
 
  const auto [api, slot, subslot, next] = ParseMultipleBlockHeader(data, 3);
 
  EXPECT_EQ(api, 0x01020304U);
  EXPECT_EQ(slot, 7U);
  EXPECT_EQ(subslot, 0x8001U);
  EXPECT_EQ(next, 13U);
}
 
TEST_F(BlocksMoreTests, ParseMultipleBlockHeaderRejectsTruncatedInput)
{
  EXPECT_THROW(ParseMultipleBlockHeader(Bytes(12U, 0), 3), std::invalid_argument);
}
 
TEST_F(BlocksMoreTests, ParsePdInterfaceDataRealParsesCompleteData)
{
  const auto body = MakeInterfaceBody("Chass\xC3\xA9", {0x00, 0x11, 0x22, 0x33, 0x44, 0x55}, {10, 20, 30, 40}, {255, 255, 255, 0}, {10, 20, 30, 1});
 
  const auto result = ParsePdInterfaceDataReal(body);
 
  EXPECT_EQ(result.chassisId, "Chassé");
  EXPECT_EQ(result.MacStr(), "00:11:22:33:44:55");
  EXPECT_EQ(result.IpStr(), "10.20.30.40");
  EXPECT_EQ(result.SubnetStr(), "255.255.255.0");
  EXPECT_EQ(result.GatewayStr(), "10.20.30.1");
}
 
TEST_F(BlocksMoreTests, ParsePdInterfaceDataRealRejectsMissingChassisLength)
{
  EXPECT_THROW(ParsePdInterfaceDataReal(Bytes{}), std::invalid_argument);
}
 
TEST_F(BlocksMoreTests, ParsePdInterfaceDataRealRejectsTruncatedChassis)
{
  EXPECT_THROW(ParsePdInterfaceDataReal(Bytes{0x05, 'a', 'b'}), std::invalid_argument);
}
 
TEST_F(BlocksMoreTests, ParsePdInterfaceDataRealRejectsTruncatedMac)
{
  Bytes body{0x00};
  body.push_back(0);
  EXPECT_THROW(ParsePdInterfaceDataReal(body), std::invalid_argument);
}
 
TEST_F(BlocksMoreTests, ParsePdInterfaceDataRealRejectsTruncatedIpConfiguration)
{
  const auto body = MakeInterfaceBody("A",
                                      {0, 1, 2, 3, 4, 5},
                                      {1, 2, 3, 4},
                                      {255, 255, 255, 0},
                                      {1, 2, 3, 1});
 
  Bytes truncated = body;
  truncated.resize(truncated.size() - 1U);
 
  EXPECT_THROW(ParsePdInterfaceDataReal(truncated), std::invalid_argument);
}
 
TEST_F(BlocksMoreTests, ParsePdPortDataRealKeepsSuppliedLocationForEmptyInput)
{
  const auto result = ParsePdPortDataReal({}, 0, 7, 0x8002);
 
  EXPECT_EQ(result.slot, 7U);
  EXPECT_EQ(result.subslot, 0x8002U);
  EXPECT_TRUE(result.portId.empty());
}
 
TEST_F(BlocksMoreTests, ParsePdPortDataRealHandlesMissingPortLength)
{
  const Bytes body{0x00, 0x01, 0x80, 0x01};
  const auto result = ParsePdPortDataReal(body, 0, 9, 9);
 
  EXPECT_EQ(result.slot, 1U);
  EXPECT_EQ(result.subslot, 0x8001U);
  EXPECT_TRUE(result.portId.empty());
}
 
TEST_F(BlocksMoreTests, ParsePdPortDataRealHandlesMissingPeerCount)
{
  const Bytes body{0x00, 0x01, 0x80, 0x01, 0x01, 'P'};
 
  const auto result = ParsePdPortDataReal(body, 0, 9, 9);
 
  EXPECT_EQ(result.portId, "P");
  EXPECT_TRUE(result.peers.empty());
}
 
TEST_F(BlocksMoreTests, ParsePdPortDataRealHandlesMissingPeerMac)
{
  const auto expectedMacAddress = MacAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06};
  const PeerInfo peer{.portId = "P", .chassisId = "C", .macAddress = expectedMacAddress};
 
  Bytes body = MakePortBody("Port", {peer});
  body.resize(body.size() - 4U);
 
  const auto result = ParsePdPortDataReal(body);
 
  ASSERT_EQ(result.peers.size(), 1U);
  EXPECT_EQ(result.peers[0].portId, "P");
  EXPECT_EQ(result.peers[0].chassisId, "C");
  EXPECT_EQ(result.peers[0].macAddress, expectedMacAddress);
}
 
TEST_F(BlocksMoreTests, ParsePdPortDataRealHandlesMissingMau)
{
  const auto result = ParsePdPortDataReal(MakePortBody("Port", {}, false, false, false, false));
 
  EXPECT_EQ(result.mauType, 0U);
  EXPECT_EQ(result.domainBoundary, 0U);
  EXPECT_EQ(result.multicastBoundary, 0U);
  EXPECT_EQ(result.linkStatePort, 0U);
  EXPECT_EQ(result.linkStateLink, 0U);
  EXPECT_EQ(result.mediaType, 0U);
}
 
TEST_F(BlocksMoreTests, ParsePdPortDataRealHandlesIncompleteBoundaries)
{
  Bytes body = MakePortBody("Port", {}, true, true, false, false);
  body.resize(body.size() - 4U);
 
  const auto result = ParsePdPortDataReal(body);
 
  EXPECT_EQ(result.mauType, 30U);
  EXPECT_EQ(result.domainBoundary, 0U);
  EXPECT_EQ(result.multicastBoundary, 0U);
}
 
TEST_F(BlocksMoreTests, ParsePdPortDataRealHandlesIncompleteLinkState)
{
  Bytes body = MakePortBody("Port", {}, true, true, true, false);
 
  // The helper adds two alignment bytes after the two link-state bytes.
  // Remove the padding and one link-state byte, leaving only one byte
  // of the required two-byte link-state field.
  body.resize(body.size() - 3U);
  const auto result = ParsePdPortDataReal(body);
 
  EXPECT_EQ(result.domainBoundary, 0x11223344U);
  EXPECT_EQ(result.multicastBoundary, 0x55667788U);
  EXPECT_EQ(result.linkStatePort, 0U);
  EXPECT_EQ(result.linkStateLink, 0U);
}
 
TEST_F(BlocksMoreTests, ParsePdPortDataRealHandlesIncompleteMediaType)
{
  Bytes body = MakePortBody("Port", {}, true, true, true, true);
  body.resize(body.size() - 1U);
 
  const auto result = ParsePdPortDataReal(body);
 
  EXPECT_EQ(result.linkStatePort, 1U);
  EXPECT_EQ(result.linkStateLink, 2U);
  EXPECT_EQ(result.mediaType, 0U);
}
 
TEST_F(BlocksMoreTests, ParsePdRealDataCollectsMultipleHeaderContent)
{
  const auto interfaceBody = MakeInterfaceBody("PLC",
                                               {0x10, 0x11, 0x12, 0x13, 0x14,
                                                0x15},
                                               {192, 168, 1, 10},
                                               {255, 255, 255, 0},
                                               {192, 168, 1, 1});
 
  const auto interfaceBlock = MakeBlock(BlockType::PortDataInterfaceDataReal, interfaceBody);
 
  const auto portBlock = MakeBlock(BlockType::PortDataReal, MakePortBody("P1", {}));
 
  const auto outer = MakeMultipleBlock(0, 1, 0x8001, {interfaceBlock, portBlock});
 
  const auto result = ParsePdRealData(outer);
 
  ASSERT_EQ(result.slots.size(), 1U);
  EXPECT_EQ(result.slots[0].api, 0U);
  EXPECT_EQ(result.slots[0].slot, 1U);
  EXPECT_EQ(result.slots[0].subslot, 0x8001U);
  ASSERT_EQ(result.slots[0].blocks.size(), 2U);
  EXPECT_EQ(result.ports.size(), 1U);
  EXPECT_TRUE(result.interface.has_value());
  ASSERT_EQ(result.rawBlocks.size(), 1U);
  EXPECT_EQ(std::get<1>(result.rawBlocks[0]), 1U);
}
 
TEST_F(BlocksMoreTests, ParsePdRealDataSkipsNonMultipleBlock)
{
  const auto data = MakeBlock(BlockType::PortDataReal, MakePortBody("P1", {}));
 
  const auto result = ParsePdRealData(data);
 
  EXPECT_TRUE(result.slots.empty());
  EXPECT_TRUE(result.ports.empty());
  EXPECT_TRUE(result.rawBlocks.empty());
}
 
TEST_F(BlocksMoreTests, ParsePdRealDataIgnoresMalformedMultipleHeader)
{
  const auto malformed = MakeHeader(BlockType::MultipleHeader, 20);
 
  const auto result = ParsePdRealData(malformed);
 
  EXPECT_TRUE(result.slots.empty());
  EXPECT_TRUE(result.rawBlocks.empty());
}
 
TEST_F(BlocksMoreTests, ParseRealIdentificationDataAcceptsRecognizedHeader)
{
  const auto body = MakeRidBody({{1, 0x8001, 0x1000, 0x2000}});
  const auto data = MakeBlock(BlockType::RealIdentificationDataApi, body);
 
  const auto result = ParseRealIdentificationData(data);
 
  EXPECT_EQ(result.version.first, 1U);
  EXPECT_EQ(result.version.second, 0U);
  ASSERT_EQ(result.slots.size(), 1U);
  EXPECT_EQ(result.slots[0].slot, 1U);
  EXPECT_EQ(result.slots[0].subslot, 0x8001U);
}
 
TEST_F(BlocksMoreTests, ParseRealIdentificationDataFallsBackToRawBody)
{
  const auto body = MakeRidBody({{2, 3, 0x1234, 0x5678}});
  const auto result = ParseRealIdentificationData(body);
 
  const auto expectedVersion = std::pair<std::uint8_t, std::uint8_t>{1, 0};
 
  EXPECT_EQ(result.version, expectedVersion);
  ASSERT_EQ(result.slots.size(), 1U);
  EXPECT_EQ(result.slots[0].moduleIdent, 0x1234U);
  EXPECT_EQ(result.slots[0].submoduleIdent, 0x5678U);
}
 
TEST_F(BlocksMoreTests, ParseRealIdentificationDataHandlesTruncatedEntry)
{
  Bytes body;
  wire::PutU16(body, 1);
  wire::PutU16(body, 1);
  wire::PutU32(body, 0x1234);
  wire::PutU16(body, 1);
  wire::PutU16(body, 2);
  body.push_back(0x56);
 
  const auto result = ParseRealIdentificationData(body);
 
  EXPECT_TRUE(result.slots.empty());
}
 
TEST_F(BlocksMoreTests, ParsePortStatisticsSupportsOffset)
{
  Bytes data(4U, 0xAA);
  wire::PutU16(data, 0x0007);
  wire::PutU32(data, 1);
  wire::PutU32(data, 2);
  wire::PutU32(data, 3);
  wire::PutU32(data, 4);
  wire::PutU32(data, 5);
  wire::PutU32(data, 6);
 
  const auto result = ParsePortStatistics(data, 4);
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(result->counterStatus, 7U);
  EXPECT_EQ(result->inOctets, 1U);
  EXPECT_EQ(result->outErrors, 6U);
}
 
TEST_F(BlocksMoreTests, ModuleDiffSubmoduleStateNameCoversValues)
{
  ModuleDiffSubmodule submodule;
  submodule.submoduleState = SUBMODULE_STATE_OK;
  EXPECT_EQ(submodule.StateName(), "OK");
  EXPECT_TRUE(submodule.IsOk());
 
  submodule.submoduleState = SUBMODULE_STATE_WRONG_SUBMODULE;
  EXPECT_FALSE(submodule.IsOk());
  EXPECT_FALSE(submodule.StateName().empty());
 
  submodule.submoduleState = 0xFFFF;
  EXPECT_FALSE(submodule.IsOk());
  EXPECT_FALSE(submodule.StateName().empty());
}
 
TEST_F(BlocksMoreTests, ModuleDiffModuleEvaluatesState)
{
  ModuleDiffModule module;
  module.moduleState = MODULE_STATE_PROPER_MODULE;
  EXPECT_TRUE(module.IsProper());
 
  module.moduleState = 0xFFFF;
  EXPECT_FALSE(module.IsProper());
  EXPECT_FALSE(module.StateName().empty());
}
 
TEST_F(BlocksMoreTests, ModuleDiffBlockReportsAllMismatches)
{
  ModuleDiffBlock block;
 
  ModuleDiffModule proper;
  proper.slotNumber = 1;
  proper.moduleState = MODULE_STATE_PROPER_MODULE;
  proper.submodules.push_back(ModuleDiffSubmodule{.subslotNumber = 1, .submoduleState = SUBMODULE_STATE_OK});
 
  ModuleDiffModule wrongModule;
  wrongModule.slotNumber = 2;
  wrongModule.moduleState = 0xFFFF;
  wrongModule.submodules.push_back(ModuleDiffSubmodule{.subslotNumber = 3, .submoduleState = SUBMODULE_STATE_WRONG_SUBMODULE});
 
  block.modules = {proper, wrongModule};
 
  EXPECT_FALSE(block.AllOk());
  const auto mismatches = block.GetMismatches();
  ASSERT_EQ(mismatches.size(), 2U);
  EXPECT_EQ(std::get<0>(mismatches[0]), 2U);
  EXPECT_EQ(std::get<1>(mismatches[0]), 0U);
  EXPECT_EQ(std::get<0>(mismatches[1]), 2U);
  EXPECT_EQ(std::get<1>(mismatches[1]), 3U);
}
 
TEST_F(BlocksMoreTests, IODWriteMultipleBuilderBuildsEmptyPacket)
{
  std::array<std::uint8_t, uuidLenght> uuid{};
  IODWriteMultipleBuilder builder(uuid);
 
  const auto packet = builder.Build();
 
  EXPECT_FALSE(packet.empty());
  wire::Reader r(packet);
  EXPECT_EQ(r.U16(), IODWriteMultipleBuilder::writeMultipleBlockType);
}
 
TEST_F(BlocksMoreTests, IODWriteMultipleBuilderStoresApiAndMultipleWrites)
{
  std::array<std::uint8_t, uuidLenght> uuid{};
  uuid[15] = 0xEE;
 
  IODWriteMultipleBuilder builder(uuid, 0x1234);
  builder.AddWrite(1, 1, 0xAFF0, {0x01}, 0x1000)
      .AddWrite(2, 3, 0xAFF1, {0x02, 0x03}, 0x2000);
 
  const auto packet = builder.Build();
 
  EXPECT_GT(packet.size(), 64U);
  wire::Reader r(packet);
  r.Skip(34);
  EXPECT_EQ(r.U16(), WRITE_MULTIPLE);
}
 
TEST_F(BlocksMoreTests, ParseWriteMultipleResponseRejectsShortInput)
{
  EXPECT_TRUE(ParseWriteMultipleResponse({}).empty());
  EXPECT_TRUE(ParseWriteMultipleResponse(Bytes(63U, 0)).empty());
}
 
TEST_F(BlocksMoreTests, ParseWriteMultipleResponseHandlesMinimalResponse)
{
  const auto response = MakeMinimalWriteMultipleResponse();
  const auto results = ParseWriteMultipleResponse(response);
 
  EXPECT_TRUE(results.empty());
}
 
TEST_F(BlocksMoreTests, ExpectedSubmoduleDataDescriptionSerializes)
{
  ExpectedSubmoduleDataDescription description{
      .dataDescription = 2,
      .submoduleDataLength = 42,
      .lengthIocs = 2,
      .lengthIops = 3};
 
  const auto bytes = description.ToBytes();
 
  ASSERT_EQ(bytes.size(), 6U);
  EXPECT_EQ(bytes[0], 0U);
  EXPECT_EQ(bytes[1], 2U);
  EXPECT_EQ(bytes[2], 0U);
  EXPECT_EQ(bytes[3], 42U);
  EXPECT_EQ(bytes[4], 2U);
  EXPECT_EQ(bytes[5], 3U);
}
 
TEST_F(BlocksMoreTests, ExpectedSubmoduleSubmoduleTypeMasksLowBits)
{
  ExpectedSubmodule submodule{.submoduleProperties = 0xFFFC};
  EXPECT_EQ(submodule.SubmoduleType(), 0U);
 
  submodule.submoduleProperties = 0xFFFF;
  EXPECT_EQ(submodule.SubmoduleType(), 3U);
}
 
TEST_F(BlocksMoreTests, ExpectedSubmoduleSerializes)
{
  ExpectedSubmodule submodule{
      .subslotNumber = 0x8001,
      .submoduleIdentNumber = 0x12345678,
      .submoduleProperties = 3};
 
  submodule.dataDescriptions.push_back(ExpectedSubmoduleDataDescription{.dataDescription = 1, .submoduleDataLength = 4});
 
  const auto bytes = submodule.ToBytes();
 
  EXPECT_GT(bytes.size(), 8U);
}
 
TEST_F(BlocksMoreTests, ExpectedSubmoduleSlotSerializes)
{
  ExpectedSubmoduleSlot slot{.api = 0, .slotNumber = 1, .moduleIdentNumber = 0x100, .moduleProperties = 0};
 
  slot.submodules.push_back(ExpectedSubmodule{
      .subslotNumber = 1,
      .submoduleIdentNumber = 0x200,
      .submoduleProperties = 1});
 
  const auto bytes = slot.ToBytes();
 
  EXPECT_GT(bytes.size(), 14U);
}
 
TEST_F(BlocksMoreTests, ExpectedSubmoduleAPISerializes)
{
  ExpectedSubmoduleAPI api{.api = 0x1234};
 
  api.slots.push_back(ExpectedSubmoduleSlot{
      .api = 0x1234,
      .slotNumber = 1,
      .moduleIdentNumber = 0x100});
 
  const auto bytes = api.ToBytes();
 
  EXPECT_GT(bytes.size(), 0U);
}
 
TEST_F(BlocksMoreTests, ExpectedSubmoduleBlockReqCreatesSeparateApis)
{
  ExpectedSubmoduleBlockReq req;
  req.AddSubmodule(801, 1, 1, 0x100, 0x200, 1, 4, 0)
      .AddSubmodule(1, 2, 1, 0x300, 0x400, 2, 0, 4);
 
  const auto bytes = req.ToBytes();
 
  ASSERT_GE(bytes.size(), 8U);
 
  // The body starts at offset 6. The first API contains one slot.
  wire::Reader r(bytes);
  r.Skip(6);
  EXPECT_EQ(r.U16(), 1U);
 
  // The first API slot starts at offset 8:
  // API(4), Slot(2), ModuleIdent(4), ModuleProperties(2),
  // NumberOfSubmodules(2), ...
  ASSERT_GE(bytes.size(), 14U);
 
  EXPECT_EQ(r.U32(), 801U);
}
 
TEST_F(BlocksMoreTests, ExpectedSubmoduleBlockReqBuildsOutputOnlySubmodule)
{
  ExpectedSubmoduleBlockReq req;
 
  req.AddSubmodule(0, 1, 2, 0x100, 0x200, 2, 0, 4);
 
  const auto bytes = req.ToBytes();
 
  EXPECT_GT(bytes.size(), 30U);
}
 
TEST_F(BlocksMoreTests, WriteMultipleResultSuccessReflectsStatus)
{
  WriteMultipleResult result;
 
  result.status = 0;
  EXPECT_TRUE(result.Success());
 
  result.status = 1;
  EXPECT_FALSE(result.Success());
 
  result.status = 0xFFFFFFFFU;
  EXPECT_FALSE(result.Success());
}
 
TEST_F(BlocksMoreTests, ExpectedSubmoduleBlockReqCoversAllSubmoduleTypes)
{
  struct Case
  {
    std::uint16_t type;
    std::size_t expectedDescriptionCount;
  };
 
  const std::vector<Case> cases{
      {0, 1},
      {1, 1},
      {2, 1},
      {3, 2},
      {99, 0},
  };
 
  for (const auto& testCase : cases)
  {
    ExpectedSubmoduleBlockReq req;
 
    req.AddSubmodule(
        0,
        1,
        1,
        0x100,
        0x200,
        testCase.type,
        4,
        8);
 
    const auto bytes = req.ToBytes();
 
    // Header = 6 bytes.
    // API entry starts with NumberOfSlots = 2 bytes.
    // Slot header:
    // API(4) + Slot(2) + ModuleIdent(4) + Properties(2) +
    // NumberOfSubmodules(2) = 14 bytes.
    constexpr std::size_t headerAndSlot = 6U + 2U + 14U;
 
    const std::size_t expectedSize =
        headerAndSlot + 2U + 4U + 2U + testCase.expectedDescriptionCount * 6U;
 
    EXPECT_EQ(bytes.size(), expectedSize)
        << "submoduleType=" << testCase.type;
  }
}
 
TEST_F(BlocksMoreTests, ExpectedSubmoduleBlockReqReusesExistingApiAndSlot)
{
  ExpectedSubmoduleBlockReq req;
 
  req.AddSubmodule(0, 1, 1, 0x100, 0x200, 1, 4, 0);
  req.AddSubmodule(0, 1, 2, 0x100, 0x201, 2, 0, 8);
 
  const auto bytes = req.ToBytes();
  wire::Reader r(bytes);
  r.Skip(6);
  // One API, one slot, two submodules.
  EXPECT_EQ(r.U16(), 1U);
 
  // NumberOfSubmodules is at offset:
  // 6 header + 2 API slot count + 4 API + 2 slot + 4 ident + 2 properties.
  constexpr std::size_t numberOfSubmodulesOffset = 6U + 2U + 4U + 2U + 4U + 2U;
  r.SkipTo(numberOfSubmodulesOffset);
  EXPECT_EQ(r.U16(), 2U);
}
 
TEST_F(BlocksMoreTests, ParseModuleDiffBlockHandlesHeaderWithoutBody)
{
  const auto data = MakeHeader(BlockType::ModuleDifference, 2);
 
  const auto result = ParseModuleDiffBlock(data);
 
  EXPECT_TRUE(result.modules.empty());
}
 
TEST_F(BlocksMoreTests, ParseModuleDiffBlockStopsOnTruncatedApi)
{
  Bytes data = MakeHeader(BlockType::ModuleDifference, 8);
 
  wire::PutU16(data, 1);
  wire::PutU32(data, 0x12345678);
 
  const auto result = ParseModuleDiffBlock(data);
 
  EXPECT_TRUE(result.modules.empty());
}
 
TEST_F(BlocksMoreTests, ParseModuleDiffBlockStopsOnTruncatedModule)
{
  Bytes data = MakeHeader(BlockType::ModuleDifference, 8);
 
  wire::PutU16(data, 1);
  wire::PutU32(data, 0);
  wire::PutU16(data, 1);
 
  const auto result = ParseModuleDiffBlock(data);
 
  EXPECT_TRUE(result.modules.empty());
}
 
TEST_F(BlocksMoreTests, ParsePortStatisticsRejectsTruncatedOffset)
{
  Bytes data(4U, 0xAA);
  data.resize(4U + 25U);
 
  EXPECT_FALSE(ParsePortStatistics(data, 4).has_value());
}
 
TEST_F(BlocksMoreTests, ParseRealIdentificationDataParsesV11ApiGroupedLayout)
{
  auto data = MakeBlock(
      BlockType::RealIdentificationDataApi,
      MakeRidV11Body());
 
  // Change the version bytes to 1.1.
  ASSERT_GE(data.size(), 6U);
  data[4] = 1;
  data[5] = 1;
 
  const auto result = ParseRealIdentificationData(data);
  const auto expectedVersion = std::pair<std::uint8_t, std::uint8_t>{1, 1};
  EXPECT_EQ(result.version, expectedVersion);
 
  ASSERT_EQ(result.slots.size(), 2U);
 
  EXPECT_EQ(result.slots[0].api, 0x12345678U);
  EXPECT_EQ(result.slots[0].slot, 2U);
  EXPECT_EQ(result.slots[0].moduleIdent, 0x1000U);
  EXPECT_EQ(result.slots[0].subslot, 0x8001U);
  EXPECT_EQ(result.slots[0].submoduleIdent, 0x2001U);
 
  EXPECT_EQ(result.slots[1].api, 0x12345678U);
  EXPECT_EQ(result.slots[1].subslot, 0x8002U);
  EXPECT_EQ(result.slots[1].submoduleIdent, 0x2002U);
}
 
TEST_F(BlocksMoreTests, ParseWriteMultipleResponseParsesSuccessfulResult)
{
  Bytes response(64U, 0);
 
  const auto block = MakeWriteMultipleResponseBlock(
      0x8008,
      7,
      0x12345678,
      3,
      0x8001,
      0xAFF0,
      0x1111,
      0x2222,
      0);
 
  ASSERT_EQ(block.size(), 56U);
 
  // The outer response stores the length of the nested result data
  // at byte offsets 36..39.
  const std::uint32_t recordLength =
      static_cast<std::uint32_t>(block.size());
 
  response[36] = static_cast<std::uint8_t>(recordLength >> 24U);
  response[37] = static_cast<std::uint8_t>(recordLength >> 16U);
  response[38] = static_cast<std::uint8_t>(recordLength >> 8U);
  response[39] = static_cast<std::uint8_t>(recordLength);
 
  response.insert(response.end(), block.begin(), block.end());
 
  const auto results = ParseWriteMultipleResponse(response);
 
  ASSERT_EQ(results.size(), 1U);
 
  EXPECT_EQ(results[0].seqNum, 7U);
  EXPECT_EQ(results[0].api, 0x12345678U);
  EXPECT_EQ(results[0].slot, 3U);
  EXPECT_EQ(results[0].subslot, 0x8001U);
  EXPECT_EQ(results[0].index, 0xAFF0U);
  EXPECT_EQ(results[0].additionalValue1, 0x1111U);
  EXPECT_EQ(results[0].additionalValue2, 0x2222U);
  EXPECT_EQ(results[0].status, 0U);
  EXPECT_TRUE(results[0].Success());
}
 
TEST_F(BlocksMoreTests, ParseWriteMultipleResponseParsesFailedResult)
{
  Bytes response(64U, 0);
 
  const auto block = MakeWriteMultipleResponseBlock(
      0x8008,
      2,
      0x00000010,
      1,
      2,
      3,
      0xAAAA,
      0xBBBB,
      0xC0000001U);
 
  ASSERT_EQ(block.size(), 56U);
 
  const std::uint32_t recordLength =
      static_cast<std::uint32_t>(block.size());
 
  response[36] = static_cast<std::uint8_t>(recordLength >> 24U);
  response[37] = static_cast<std::uint8_t>(recordLength >> 16U);
  response[38] = static_cast<std::uint8_t>(recordLength >> 8U);
  response[39] = static_cast<std::uint8_t>(recordLength);
 
  response.insert(response.end(), block.begin(), block.end());
 
  const auto results = ParseWriteMultipleResponse(response);
 
  ASSERT_EQ(results.size(), 1U);
 
  EXPECT_EQ(results[0].seqNum, 2U);
  EXPECT_EQ(results[0].api, 0x00000010U);
  EXPECT_EQ(results[0].slot, 1U);
  EXPECT_EQ(results[0].subslot, 2U);
  EXPECT_EQ(results[0].index, 3U);
  EXPECT_EQ(results[0].additionalValue1, 0xAAAAU);
  EXPECT_EQ(results[0].additionalValue2, 0xBBBBU);
  EXPECT_EQ(results[0].status, 0xC0000001U);
  EXPECT_FALSE(results[0].Success());
}
 
TEST_F(BlocksMoreTests, ParseWriteMultipleResponseStopsOnUnexpectedBlockType)
{
  Bytes response(64U, 0);
 
  const auto block = MakeWriteMultipleResponseBlock(
      0x9999,
      1,
      0,
      1,
      1,
      1,
      0,
      0,
      0);
 
  ASSERT_EQ(block.size(), 56U);
 
  response[36] = 0;
  response[37] = 0;
  response[38] = 0;
  response[39] = 56;
 
  response.insert(response.end(), block.begin(), block.end());
 
  EXPECT_TRUE(ParseWriteMultipleResponse(response).empty());
}
 
TEST_F(BlocksMoreTests, IODWriteMultipleBuilderSerializesWriteDetails)
{
  std::array<std::uint8_t, uuidLenght> uuid{};
  uuid[0] = 0xDE;
  uuid[1] = 0xAD;
  uuid[15] = 0xEF;
 
  IODWriteMultipleBuilder builder(uuid, 0x1234);
 
  builder.AddWrite(1, 0x8001, 0x0100, {0x11, 0x22}, 0x1000)
      .AddWrite(2, 0x8002, 0x0101, {0x33, 0x44, 0x55}, 0x2000);
 
  const auto packet = builder.Build();
 
  ASSERT_GT(packet.size(), 64U);
  wire::Reader r(packet);
  r.SkipTo(6U);
 
  // Outer sequence number.
  EXPECT_EQ(r.U16(), 0x1234U);
 
  // First nested block starts immediately after the 64-byte outer header.
  constexpr std::size_t firstBlock = 64U;
  r.SkipTo(firstBlock);
 
  EXPECT_EQ(r.U16(), IODWriteMultipleBuilder::writeMultipleBlockType);
  r.SkipTo(firstBlock + 6U);
  // Nested sequence number.
  EXPECT_EQ(r.U16(), 0U);
}