test_cyclicCapture.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <algorithm>
#include <array>
#include <condition_variable>
#include <cstdint>
#include <filesystem>
#include <fstream>
#include <functional>
#include <iterator>
#include <memory>
#include <mutex>
#include <numeric>
#include <optional>
#include <stdexcept>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include "mocks/mockRawEthernetSocket.h"
#include "profinet/cyclic.h"
#include "profinet/gsdml.h"
#include "profinet/protocol.h"
#include "profinet/rpc.h"
#include "profinet/rt.h"
#include "profinet/util.h"
#include "stubs/stubRpcTransport.h"
 
namespace profinet::CyclicCaptureTests
{
namespace
{
using Mac = std::array<std::uint8_t, 6>;
 
constexpr Mac kPhoenixMac{0xA8, 0x74, 0x1D, 0x44, 0x7A, 0xBB};
constexpr Mac kAumaMac{0xA0, 0xD3, 0x85, 0x00, 0xF6, 0x13};
 
constexpr std::size_t kEthernetHeaderLength = 14U;
constexpr std::size_t kRtHeaderFrameIdLength = 2U;
constexpr std::size_t kOutputPayloadLength = 40U;
constexpr std::size_t kInputPayloadLength = 43U;
constexpr std::size_t kCommandOffset = 8U;
constexpr std::size_t kPositionOffset = 3U;
 
constexpr std::uint8_t kStopCommand = 0x00;
constexpr std::uint8_t kOpenCommand = 0x01;
constexpr std::uint8_t kCloseCommand = 0x02;
 
constexpr std::uint8_t kOutputDataStatus = 0x35;
constexpr std::uint8_t kInputDataStatus = 0x15;
 
constexpr std::uint32_t kExpectedCycleTimeUs = 8000U;
constexpr double kExpectedCommandDurationMs = 1000.0;
constexpr double kCommandDurationToleranceMs = 5.0;
 
constexpr char kAumaGsdml[] = "GSDML-V2.42-AUMA-SGX-20220920.xml";
constexpr char kPhoenixGsdml[] =
    "GSDML-V2.45-Phoenix Contact-AXC F 1252-20250813.xml";
 
struct CapturedPacket
{
  std::uint64_t timestampNs = 0U;
  Bytes frame;
};
 
struct Capture
{
  std::vector<CapturedPacket> phoenixToAuma;
  std::vector<CapturedPacket> aumaToPhoenix;
};
 
std::uint32_t ReadU32(
    const Bytes& bytes,
    std::size_t offset,
    bool littleEndian)
{
  if (offset + 4U > bytes.size())
  {
    throw std::runtime_error("PCAPNG u32 read out of range");
  }
 
  if (littleEndian)
  {
    return static_cast<std::uint32_t>(bytes[offset]) |
           (static_cast<std::uint32_t>(bytes[offset + 1U]) << 8U) |
           (static_cast<std::uint32_t>(bytes[offset + 2U]) << 16U) |
           (static_cast<std::uint32_t>(bytes[offset + 3U]) << 24U);
  }
 
  return (static_cast<std::uint32_t>(bytes[offset]) << 24U) |
         (static_cast<std::uint32_t>(bytes[offset + 1U]) << 16U) |
         (static_cast<std::uint32_t>(bytes[offset + 2U]) << 8U) |
         static_cast<std::uint32_t>(bytes[offset + 3U]);
}
 
std::uint64_t TimestampToNs(
    std::uint64_t ticks,
    std::uint8_t resolution)
{
  if ((resolution & 0x80U) == 0U)
  {
    const auto exponent = static_cast<unsigned>(resolution);
    std::uint64_t divisor = 1U;
    for (unsigned index = 0U; index < exponent; ++index)
    {
      divisor *= 10U;
    }
 
    return static_cast<std::uint64_t>(
        static_cast<long double>(ticks) * 1'000'000'000.0L /
        static_cast<long double>(divisor));
  }
 
  const auto exponent = static_cast<unsigned>(resolution & 0x7FU);
  return static_cast<std::uint64_t>(
      static_cast<long double>(ticks) * 1'000'000'000.0L /
      static_cast<long double>(std::uint64_t{1} << exponent));
}
 
std::filesystem::path CapturePath(const std::string& fileName)
{
  const std::array<std::filesystem::path, 5> candidates{
      GetExecutableDirectory() / "captures" / fileName,
      GetExecutableDirectory() / fileName,
      std::filesystem::current_path() / "tests" / "captures" / fileName,
      std::filesystem::current_path() / "captures" / fileName,
      std::filesystem::current_path() / fileName};
 
  for (const auto& candidate : candidates)
  {
    if (std::filesystem::exists(candidate))
    {
      return candidate;
    }
  }
 
  ADD_FAILURE() << "PCAPNG fixture not found: " << fileName;
  return {};
}
 
std::vector<CapturedPacket> ReadPcapng(const std::filesystem::path& path)
{
  std::ifstream file(path, std::ios::binary);
  if (!file)
  {
    throw std::runtime_error("Cannot open PCAPNG fixture: " + path.string());
  }
 
  const Bytes bytes{
      std::istreambuf_iterator<char>(file),
      std::istreambuf_iterator<char>()};
 
  if (bytes.size() < 12U)
  {
    throw std::runtime_error("PCAPNG fixture is too short: " + path.string());
  }
 
  const auto byteOrderMagic = ReadU32(bytes, 8U, true);
  const bool littleEndian = byteOrderMagic == 0x1A2B3C4DU;
  if (!littleEndian && byteOrderMagic != 0x4D3C2B1AU)
  {
    throw std::runtime_error("Unsupported PCAPNG byte-order magic");
  }
 
  std::vector<std::uint8_t> timestampResolution{6U};
  std::vector<CapturedPacket> packets;
 
  std::size_t offset = 0U;
  while (offset + 12U <= bytes.size())
  {
    const auto blockType = ReadU32(bytes, offset, littleEndian);
    const auto blockLength = ReadU32(bytes, offset + 4U, littleEndian);
 
    if (blockLength < 12U || offset + blockLength > bytes.size())
    {
      throw std::runtime_error("Invalid PCAPNG block length");
    }
 
    if (blockType == 0x00000001U && blockLength >= 20U)
    {
      std::size_t optionOffset = offset + 16U;
      const std::size_t optionEnd = offset + blockLength - 4U;
 
      while (optionOffset + 4U <= optionEnd)
      {
        const auto code = static_cast<std::uint16_t>(
            ReadU32(bytes, optionOffset, littleEndian) & 0xFFFFU);
        const auto optionLength = static_cast<std::uint16_t>(
            (ReadU32(bytes, optionOffset, littleEndian) >> 16U) & 0xFFFFU);
 
        optionOffset += 4U;
        if (code == 0U)
        {
          break;
        }
 
        if (optionOffset + optionLength > optionEnd)
        {
          break;
        }
 
        if (code == 9U && optionLength >= 1U)
        {
          timestampResolution[0] = bytes[optionOffset];
        }
 
        optionOffset += ((optionLength + 3U) / 4U) * 4U;
      }
    }
    else if (blockType == 0x00000006U && blockLength >= 32U)
    {
      const auto interfaceId = ReadU32(bytes, offset + 8U, littleEndian);
      if (interfaceId >= timestampResolution.size())
      {
        throw std::runtime_error("PCAPNG interface id out of range");
      }
 
      const auto timestampHigh = ReadU32(bytes, offset + 12U, littleEndian);
      const auto timestampLow = ReadU32(bytes, offset + 16U, littleEndian);
      const auto capturedLength = ReadU32(bytes, offset + 20U, littleEndian);
 
      const auto packetOffset = offset + 28U;
      if (packetOffset + capturedLength > offset + blockLength - 4U)
      {
        throw std::runtime_error("PCAPNG packet exceeds its block");
      }
 
      const auto ticks =
          (static_cast<std::uint64_t>(timestampHigh) << 32U) |
          static_cast<std::uint64_t>(timestampLow);
 
      CapturedPacket packet;
      packet.timestampNs =
          TimestampToNs(ticks, timestampResolution[interfaceId]);
      packet.frame.assign(
          bytes.begin() + packetOffset,
          bytes.begin() +
              packetOffset + capturedLength);
      packets.push_back(std::move(packet));
    }
 
    offset += blockLength;
  }
 
  return packets;
}
 
bool IsDirection(
    const Bytes& frame,
    const Mac& source,
    const Mac& destination)
{
  return frame.size() >= kEthernetHeaderLength + kRtHeaderFrameIdLength &&
         std::equal(destination.begin(), destination.end(), frame.begin()) &&
         std::equal(source.begin(), source.end(), frame.begin() + 6) &&
         frame[12] == 0x88U &&
         frame[13] == 0x92U;
}
 
Capture LoadCapture(const std::string& fileName)
{
  const auto packets = ReadPcapng(CapturePath(fileName));
 
  Capture capture;
  for (const auto& packet : packets)
  {
    if (IsDirection(packet.frame, kPhoenixMac, kAumaMac))
    {
      capture.phoenixToAuma.push_back(packet);
    }
    else if (IsDirection(packet.frame, kAumaMac, kPhoenixMac))
    {
      capture.aumaToPhoenix.push_back(packet);
    }
  }
 
  return capture;
}
 
rt::RTFrame ParseCapturedRtFrame(const CapturedPacket& packet)
{
  const auto parsed = rt::ParseEthernetFrame(packet.frame);
  if (!parsed.has_value())
  {
    throw std::runtime_error("Captured frame is not a valid PROFINET RT frame");
  }
  return *parsed;
}
 
std::uint8_t CommandByte(const CapturedPacket& packet)
{
  return ParseCapturedRtFrame(packet).payload.at(kCommandOffset);
}
 
std::uint16_t Position(const CapturedPacket& packet)
{
  const auto payload = ParseCapturedRtFrame(packet).payload;
  return static_cast<std::uint16_t>(
      (static_cast<std::uint16_t>(payload.at(kPositionOffset)) << 8U) |
      static_cast<std::uint16_t>(payload.at(kPositionOffset + 1U)));
}
 
std::vector<std::tuple<std::size_t, std::uint8_t, std::uint8_t>> CommandTransitions(
    const std::vector<CapturedPacket>& packets)
{
  std::vector<std::tuple<std::size_t, std::uint8_t, std::uint8_t>> transitions;
  if (packets.empty())
  {
    return transitions;
  }
 
  auto previous = CommandByte(packets.front());
  for (std::size_t index = 1U; index < packets.size(); ++index)
  {
    const auto current = CommandByte(packets[index]);
    if (current != previous)
    {
      transitions.emplace_back(index, previous, current);
      previous = current;
    }
  }
  return transitions;
}
 
std::vector<std::pair<std::size_t, std::uint16_t>> PositionTransitions(
    const std::vector<CapturedPacket>& packets)
{
  std::vector<std::pair<std::size_t, std::uint16_t>> transitions;
  if (packets.empty())
  {
    return transitions;
  }
 
  auto previous = Position(packets.front());
  for (std::size_t index = 1U; index < packets.size(); ++index)
  {
    const auto current = Position(packets[index]);
    if (current != previous)
    {
      transitions.emplace_back(index, current);
      previous = current;
    }
  }
  return transitions;
}
 
double AveragePeriodUs(const std::vector<CapturedPacket>& packets)
{
  if (packets.size() < 2U)
  {
    return 0.0;
  }
 
  std::uint64_t sumNs = 0U;
  for (std::size_t index = 1U; index < packets.size(); ++index)
  {
    sumNs += packets[index].timestampNs - packets[index - 1U].timestampNs;
  }
 
  return static_cast<double>(sumNs) /
         static_cast<double>(packets.size() - 1U) /
         1000.0;
}
 
gsdml::GSDMLDevice LoadGsdml(const std::string& fileName)
{
  const std::array<std::filesystem::path, 4> candidates{
      GetExecutableDirectory() / "gsdml" / fileName,
      GetExecutableDirectory() / "tests" / "gsdml" / fileName,
      std::filesystem::current_path() / "tests" / "gsdml" / fileName,
      std::filesystem::current_path() / "gsdml" / fileName};
 
  for (const auto& candidate : candidates)
  {
    if (std::filesystem::exists(candidate))
    {
      return gsdml::ParseGsdml(candidate.string());
    }
  }
 
  ADD_FAILURE() << "GSDML fixture not found: " << fileName;
  return {};
}
 
const rpc::IOSlot* FindSlot(
    const std::vector<rpc::IOSlot>& slots,
    std::uint16_t slot,
    std::uint16_t subslot)
{
  const auto it = std::find_if(
      slots.begin(),
      slots.end(),
      [slot, subslot](const rpc::IOSlot& value)
  {
    return value.slot == slot && value.subslot == subslot;
  });
 
  return it == slots.end() ? nullptr : &(*it);
}
 
std::vector<rpc::IOSlot> PhoenixAumaCapturedSlots()
{
  std::vector<rpc::IOSlot> slots;
 
  const auto addDap = [&slots](
                          std::uint16_t subslot,
                          std::uint32_t moduleIdent,
                          std::uint32_t submoduleIdent)
  {
    rpc::IOSlot slot;
    slot.slot = 0;
    slot.subslot = subslot;
    slot.moduleIdent = moduleIdent;
    slot.submoduleIdent = submoduleIdent;
    slots.push_back(slot);
  };
 
  // These identifiers are the DAP/PDEV submodule identifiers represented in
  // the captured ExpectedSubmoduleBlockReq.
  addDap(0x0001, 0x00008001U, 0x00000000U);
  addDap(0x0002, 0x00000010U, 0x00000001U);
  addDap(0x0003, 0x00000010U, 0x00000001U);
  addDap(0x0004, 0x00000010U, 0x00000001U);
  addDap(0x8000, 0x00000010U, 0x00000001U);
  addDap(0x8001, 0x00000003U, 0x00000001U);
  addDap(0x8002, 0x00000003U, 0x00000001U);
 
  rpc::IOSlot input;
  input.slot = 1;
  input.subslot = 1;
  input.inputLength = 34;
  input.moduleIdent = 0x00008000U;
  input.submoduleIdent = 0x00002200U;
  slots.push_back(input);
 
  rpc::IOSlot output;
  output.slot = 2;
  output.subslot = 1;
  output.outputLength = 16;
  output.moduleIdent = 0x00008100U;
  output.submoduleIdent = 0x10001000U;
  slots.push_back(output);
 
  return slots;
}
 
rt::IOCRConfig CapturedInputIocr()
{
  rt::IOCRConfig config;
  config.typeIOCR = rt::IOCR_TYPE_INPUT;
  config.referenceIOCR = 1;
  config.frameId = kInputFrameId;
  config.sendClockFactor = 32;
  config.reductionRatio = 8;
  config.phase = 8;
  config.watchdogFactor = 3;
  config.dataLength = 43;
  config.objects = {
      {0, 0x0001, 36, 0, 0, 0},
      {0, 0x0002, 37, 0, 0, 0},
      {0, 0x0003, 38, 0, 0, 0},
      {0, 0x0004, 39, 0, 0, 0},
      {0, 0x8000, 40, 0, 0, 0},
      {0, 0x8001, 41, 0, 0, 0},
      {0, 0x8002, 42, 0, 0, 0},
      {1, 1, 1, 34, 35, 0},
      {2, 1, 0, 0, 0, 0}};
  config.objects.back().offsetIOCS = 0;
  return config;
}
 
rt::IOCRConfig CapturedOutputIocr()
{
  rt::IOCRConfig config;
  config.typeIOCR = rt::IOCR_TYPE_OUTPUT;
  config.referenceIOCR = 2;
  config.frameId = kOutputFrameId;
  config.sendClockFactor = 32;
  config.reductionRatio = 8;
  config.phase = 8;
  config.watchdogFactor = 3;
  config.dataLength = 40;
  config.objects = {
      {0, 0x0001, 0, 0, 0, 0},
      {0, 0x0002, 1, 0, 0, 0},
      {0, 0x0003, 2, 0, 0, 0},
      {0, 0x0004, 3, 0, 0, 0},
      {0, 0x8000, 4, 0, 0, 0},
      {0, 0x8001, 5, 0, 0, 0},
      {0, 0x8002, 6, 0, 0, 0},
      {1, 1, 7, 0, 0, 0},
      {2, 1, 8, 16, 24, 0}};
  return config;
}
 
std::vector<Bytes> ExtractBlocks(const Bytes& payload)
{
  std::vector<Bytes> result;
  std::size_t offset = 0U;
  while (offset + blockHeaderLength <= payload.size())
  {
    const auto header = rpc::PeekBlockHeader(payload, offset);
    const std::size_t blockSize = 4U + header.blockLength;
    if (blockSize > payload.size() - offset)
    {
      break;
    }
 
    result.emplace_back(
        payload.begin() + offset,
        payload.begin() + offset + blockSize);
    offset += blockSize;
  }
  return result;
}
 
std::vector<Bytes> CapturedConnectBlocks(std::uint16_t captureThisBlock)
{
  const auto packets = ReadPcapng(CapturePath("phoenix_to_auma.pcapng"));
  std::vector<Bytes> blocks;
 
  for (const auto& packet : packets)
  {
    // The CONNECT request contains the distinctive ARBlockReq prefix.
    const Bytes marker{0x01, 0x01, 0x00, 0x43};
    const auto markerIt = std::search(
        packet.frame.begin(),
        packet.frame.end(),
        marker.begin(),
        marker.end());
 
    if (markerIt == packet.frame.end())
    {
      continue;
    }
 
    const std::size_t start = static_cast<std::size_t>(
        std::distance(packet.frame.begin(), markerIt));
 
    std::size_t offset = start;
    while (offset + blockHeaderLength <= packet.frame.size())
    {
      const auto header = rpc::PeekBlockHeader(packet.frame, offset);
      const std::size_t blockSize = 4U + header.blockLength;
 
      if (blockSize > packet.frame.size() - offset)
      {
        break;
      }
 
      if (header.blockType == static_cast<std::uint16_t>(BlockType::ApplicationRelationRequest))
      {
        blocks.emplace_back(
            packet.frame.begin() + offset,
            packet.frame.begin() +
                offset + blockSize);
      }
      if (header.blockType == captureThisBlock)
      {
        blocks.emplace_back(
            packet.frame.begin() + offset,
            packet.frame.begin() +
                offset + blockSize);
      }
      offset += blockSize;
    }
  }
  if (!blocks.empty())
  {
    return blocks;
  }
  ADD_FAILURE() << "CONNECT request blocks were not found in phoenix_to_auma.pcapng";
  return {};
}
 
const Bytes* FindBlock(
    const std::vector<Bytes>& blocks,
    std::uint16_t blockType,
    std::size_t occurrence = 0U)
{
  std::size_t count = 0U;
  for (const auto& block : blocks)
  {
    if (rpc::PeekBlockHeader(block, 0U).blockType == blockType)
    {
      if (count == occurrence)
      {
        return &block;
      }
      ++count;
    }
  }
  return nullptr;
}
 
dcp::DCPDeviceDescription AumaRpcInfo()
{
  dcp::DCPDeviceDescription info(kAumaMac, {});
  info.name = "axcf1252-lan1";
  info.ip = "127.0.0.1";
  info.vendorHigh = 0x01;
  info.vendorLow = 0x3F;
  info.deviceHigh = 0x00;
  info.deviceLow = 0x02;
  return info;
}
 
class CyclicControllerCapture
{
 public:
  explicit CyclicControllerCapture(
      rt::IOCRConfig input,
      rt::IOCRConfig output)
  {
    tx = std::make_unique<testing::NiceMock<MockRawEthernetSocket>>();
    rx = std::make_unique<testing::NiceMock<MockRawEthernetSocket>>();
 
    txSocket = tx.get();
    rxSocket = rx.get();
 
    ON_CALL(*txSocket, Send(testing::_))
        .WillByDefault([this](const Bytes& frame)
    {
      {
        const std::lock_guard lock(mutex);
        sentFrames.push_back(frame);
      }
      condition.notify_all();
    });
 
    ON_CALL(*rxSocket, Recv())
        .WillByDefault([this]
    {
      const std::lock_guard lock(mutex);
      return rxFrame;
    });
 
    ON_CALL(*rxSocket, SetTimeout(testing::_))
        .WillByDefault([](std::chrono::milliseconds) {});
    ioContext = std::make_unique<asio::io_context>();
 
    controller = std::make_unique<cyclic::CyclicController>(
        *ioContext,
        "test0",
        kPhoenixMac,
        kAumaMac,
        std::move(input),
        std::move(output),
        3,
        rt::ETHERTYPE_PROFINET);
  }
 
  void SetRxFrame(Bytes frame)
  {
    const std::lock_guard lock(mutex);
    rxFrame = std::move(frame);
  }
 
  void Start()
  {
    controller->Start(std::move(tx), std::move(rx));
  }
 
  void Stop()
  {
    controller->Stop();
  }
 
  void SetOutputData(
      int slot,
      int subslot,
      const Bytes& data)
  {
    controller->SetOutputData(slot, subslot, data);
  }
 
  void OnInput(std::function<void(int, int, const Bytes&)> callback)
  {
    controller->OnInput(std::move(callback));
  }
 
  template <typename Predicate>
  bool WaitForSent(Predicate&& predicate, std::chrono::milliseconds timeout)
  {
    std::unique_lock lock(mutex);
    return condition.wait_for(
        lock,
        timeout,
        [&]
    {
      return std::ranges::any_of(sentFrames, predicate);
    });
  }
 
  std::vector<Bytes> SentFrames() const
  {
    const std::lock_guard lock(mutex);
    return sentFrames;
  }
 
 private:
  std::unique_ptr<cyclic::CyclicController> controller;
 
  std::unique_ptr<MockRawEthernetSocket> tx;
  std::unique_ptr<MockRawEthernetSocket> rx;
 
  MockRawEthernetSocket* txSocket = nullptr;
  MockRawEthernetSocket* rxSocket = nullptr;
 
  mutable std::mutex mutex;
  std::condition_variable condition;
  Bytes rxFrame;
  std::vector<Bytes> sentFrames;
 
  std::unique_ptr<asio::io_context> ioContext;
};
 
} // namespace
 
TEST(CyclicCaptureTests, PhoenixToAumaCaptureHasExpectedCyclicContract)
{
  const auto capture = LoadCapture("phoenix_to_auma.pcapng");
 
  ASSERT_EQ(capture.phoenixToAuma.size(), 399U);
  ASSERT_EQ(capture.aumaToPhoenix.size(), 399U);
 
  const auto phoenixRt = std::count_if(
      capture.phoenixToAuma.begin(),
      capture.phoenixToAuma.end(),
      [](const CapturedPacket& packet)
  {
    return packet.frame.size() >= 16U &&
           ParseCapturedRtFrame(packet).frameId == kOutputFrameId;
  });
 
  const auto aumaRt = std::count_if(
      capture.aumaToPhoenix.begin(),
      capture.aumaToPhoenix.end(),
      [](const CapturedPacket& packet)
  {
    return packet.frame.size() >= 16U &&
           ParseCapturedRtFrame(packet).frameId == kInputFrameId;
  });
 
  EXPECT_EQ(phoenixRt, 399);
  EXPECT_EQ(aumaRt, 398);
 
  const auto firstAumaFrame = ParseCapturedRtFrame(capture.aumaToPhoenix.front());
  EXPECT_EQ(firstAumaFrame.frameId, 0xFEFF);
  EXPECT_EQ(firstAumaFrame.payload.size(), 102U);
 
  for (const auto& packet : capture.phoenixToAuma)
  {
    const auto frame = ParseCapturedRtFrame(packet);
    EXPECT_EQ(frame.frameId, kOutputFrameId);
    EXPECT_EQ(frame.payload.size(), kOutputPayloadLength);
    EXPECT_TRUE(frame.dataStatus | kOutputDataStatus);
    EXPECT_EQ(frame.transferStatus, 0U);
    EXPECT_EQ(packet.frame.size(), 60U);
  }
 
  for (std::size_t index = 1U; index < capture.aumaToPhoenix.size(); ++index)
  {
    const auto frame = ParseCapturedRtFrame(capture.aumaToPhoenix[index]);
    EXPECT_EQ(frame.frameId, kInputFrameId);
    EXPECT_EQ(frame.payload.size(), kInputPayloadLength);
    EXPECT_TRUE(frame.dataStatus | kInputDataStatus);
    EXPECT_EQ(frame.transferStatus, 0U);
    EXPECT_EQ(capture.aumaToPhoenix[index].frame.size(), 63U);
  }
 
  EXPECT_NEAR(
      AveragePeriodUs(capture.phoenixToAuma),
      8000.0,
      500.0);
}
 
TEST(CyclicCaptureTests, SetValveOpenContainsOneSecondOpenCommand)
{
  const auto capture = LoadCapture("Set valve open.pcapng");
 
  ASSERT_EQ(capture.aumaToPhoenix.size(), 626U);
  ASSERT_EQ(capture.phoenixToAuma.size(), 627U);
 
  for (const auto& packet : capture.phoenixToAuma)
  {
    const auto frame = ParseCapturedRtFrame(packet);
    EXPECT_EQ(frame.frameId, kOutputFrameId);
    EXPECT_EQ(frame.payload.size(), kOutputPayloadLength);
    EXPECT_EQ(frame.dataStatus, kOutputDataStatus);
    EXPECT_EQ(frame.transferStatus, 0U);
    EXPECT_EQ(packet.frame.size(), 60U);
  }
 
  for (const auto& packet : capture.aumaToPhoenix)
  {
    const auto frame = ParseCapturedRtFrame(packet);
    EXPECT_EQ(frame.frameId, kInputFrameId);
    EXPECT_EQ(frame.payload.size(), kInputPayloadLength);
    EXPECT_EQ(frame.dataStatus, kInputDataStatus);
    EXPECT_EQ(frame.transferStatus, 0U);
    EXPECT_EQ(packet.frame.size(), 63U);
  }
 
  const auto transitions = CommandTransitions(capture.phoenixToAuma);
  const std::vector<std::tuple<std::size_t, std::uint8_t, std::uint8_t>>
      expected{{196U, kStopCommand, kOpenCommand},
               {321U, kOpenCommand, kStopCommand}};
  EXPECT_EQ(transitions, expected);
 
  const auto startPacket = capture.phoenixToAuma[196U];
  const auto stopPacket = capture.phoenixToAuma[321U];
  const auto durationMs =
      static_cast<double>(stopPacket.timestampNs - startPacket.timestampNs) /
      1'000'000.0;
 
  EXPECT_NEAR(
      durationMs,
      kExpectedCommandDurationMs,
      kCommandDurationToleranceMs);
 
  EXPECT_EQ(CommandByte(startPacket), kOpenCommand);
  EXPECT_EQ(CommandByte(stopPacket), kStopCommand);
 
  const auto positionTransitions = PositionTransitions(capture.aumaToPhoenix);
  const std::vector<std::pair<std::size_t, std::uint16_t>> expectedPositions{
      {232U, 0x0206U},
      {264U, 0x0207U},
      {279U, 0x020FU},
      {298U, 0x0217U},
      {311U, 0x0221U},
      {330U, 0x0230U},
      {348U, 0x0232U}};
  EXPECT_EQ(positionTransitions, expectedPositions);
 
  std::uint16_t previous = Position(capture.aumaToPhoenix.front());
  EXPECT_EQ(previous, 0x0202U);
  for (std::size_t index = 1U; index < capture.aumaToPhoenix.size(); ++index)
  {
    const auto current = Position(capture.aumaToPhoenix[index]);
    EXPECT_GE(current, previous);
    previous = current;
  }
 
  EXPECT_EQ(previous, 0x0232U);
  EXPECT_NEAR(
      AveragePeriodUs(capture.phoenixToAuma),
      static_cast<double>(kExpectedCycleTimeUs),
      30.0);
}
 
TEST(CyclicCaptureTests, SetValveCloseContainsOneSecondCloseCommand)
{
  const auto capture = LoadCapture("Set valve close.pcapng");
 
  ASSERT_EQ(capture.phoenixToAuma.size(), 552U);
  ASSERT_EQ(capture.aumaToPhoenix.size(), 553U);
 
  const auto transitions = CommandTransitions(capture.phoenixToAuma);
  const std::vector<std::tuple<std::size_t, std::uint8_t, std::uint8_t>>
      expected{{259U, kStopCommand, kCloseCommand},
               {384U, kCloseCommand, kStopCommand}};
  EXPECT_EQ(transitions, expected);
 
  const auto startPacket = capture.phoenixToAuma[259U];
  const auto stopPacket = capture.phoenixToAuma[384U];
  const auto durationMs =
      static_cast<double>(stopPacket.timestampNs - startPacket.timestampNs) /
      1'000'000.0;
 
  EXPECT_NEAR(
      durationMs,
      kExpectedCommandDurationMs,
      kCommandDurationToleranceMs);
 
  EXPECT_EQ(CommandByte(startPacket), kCloseCommand);
  EXPECT_EQ(CommandByte(stopPacket), kStopCommand);
 
  const auto positionTransitions = PositionTransitions(capture.aumaToPhoenix);
  const std::vector<std::pair<std::size_t, std::uint16_t>> expectedPositions{
      {295U, 0x022EU},
      {332U, 0x022AU},
      {345U, 0x0222U},
      {371U, 0x021CU},
      {385U, 0x0207U},
      {398U, 0x01FFU}};
  EXPECT_EQ(positionTransitions, expectedPositions);
 
  std::uint16_t previous = Position(capture.aumaToPhoenix.front());
  EXPECT_EQ(previous, 0x0231U);
  for (std::size_t index = 1U; index < capture.aumaToPhoenix.size(); ++index)
  {
    const auto current = Position(capture.aumaToPhoenix[index]);
    EXPECT_LE(current, previous);
    previous = current;
  }
 
  EXPECT_EQ(previous, 0x01FFU);
  EXPECT_NEAR(
      AveragePeriodUs(capture.phoenixToAuma),
      static_cast<double>(kExpectedCycleTimeUs),
      30.0);
}
 
TEST(CyclicCaptureTests, CapturesUseExpectedPhoenixAndAumaMacAddresses)
{
  for (const auto& fileName :
       std::array<std::string, 3>{
           "phoenix_to_auma.pcapng",
           "Set valve open.pcapng",
           "Set valve close.pcapng"})
  {
    const auto capture = LoadCapture(fileName);
    ASSERT_FALSE(capture.phoenixToAuma.empty());
    ASSERT_FALSE(capture.aumaToPhoenix.empty());
 
    for (const auto& packet : capture.phoenixToAuma)
    {
      EXPECT_TRUE(IsDirection(packet.frame, kPhoenixMac, kAumaMac));
    }
 
    for (const auto& packet : capture.aumaToPhoenix)
    {
      EXPECT_TRUE(IsDirection(packet.frame, kAumaMac, kPhoenixMac));
    }
  }
}
 
TEST(CyclicCaptureTests, EveryCapturedCyclicRtFrameRoundTrips)
{
  for (const auto& fileName :
       std::array<std::string, 3>{
           "phoenix_to_auma.pcapng",
           "Set valve open.pcapng",
           "Set valve close.pcapng"})
  {
    const auto capture = LoadCapture(fileName);
 
    for (const auto& packet : capture.phoenixToAuma)
    {
      const auto parsed = ParseCapturedRtFrame(packet);
      const Bytes actual = parsed.ToBytes();
      const Bytes expected(
          packet.frame.begin() + 14U,
          packet.frame.end());
      EXPECT_EQ(actual, expected);
    }
 
    for (const auto& packet : capture.phoenixToAuma)
    {
      const auto parsed = ParseCapturedRtFrame(packet);
      const Bytes actual = parsed.ToBytes();
      const Bytes expected(
          packet.frame.begin() + 14U,
          packet.frame.end());
      EXPECT_EQ(actual, expected);
    }
  }
}
 
TEST(CyclicCaptureTests, AumaGsdmlMatchesCapturedProcessData)
{
  const auto auma = LoadGsdml(kAumaGsdml);
 
  EXPECT_EQ(auma.vendorId, 0x013FU);
  EXPECT_EQ(auma.deviceId, 0x0002U);
  EXPECT_EQ(auma.dapModuleIdentNumber, 0x80010000U);
 
  const auto slots = auma.BuildIoSlots();
  const auto* input = FindSlot(slots, 1U, 1U);
  const auto* output = FindSlot(slots, 2U, 1U);
 
  ASSERT_NE(input, nullptr);
  ASSERT_NE(output, nullptr);
 
  EXPECT_EQ(input->moduleIdent, 0x00008000U);
  EXPECT_EQ(input->submoduleIdent, 0x00002200U);
  EXPECT_EQ(input->inputLength, 34U);
 
  EXPECT_EQ(output->moduleIdent, 0x00008100U);
  EXPECT_EQ(output->submoduleIdent, 0x10001000U);
  EXPECT_EQ(output->outputLength, 16U);
 
  EXPECT_EQ(kInputPayloadLength, 34U + 9U);
  EXPECT_EQ(kOutputPayloadLength, 16U + 24U);
}
 
TEST(CyclicCaptureTests, PhoenixGsdmlMatchesCapturedControllerIdentity)
{
  const auto phoenix = LoadGsdml(kPhoenixGsdml);
 
  EXPECT_EQ(phoenix.vendorId, 0x00B0U);
  EXPECT_EQ(phoenix.deviceId, 0x0193U);
  EXPECT_EQ(phoenix.dapModuleIdentNumber, 0x00000300U);
  EXPECT_NE(phoenix.FindModule("PNSlot1"), nullptr);
}
 
TEST(CyclicCaptureTests, CommandByteIsAtEthernetByteTwentyFive)
{
  const auto openCapture = LoadCapture("Set valve open.pcapng");
  const auto closeCapture = LoadCapture("Set valve close.pcapng");
 
  ASSERT_EQ(CommandByte(openCapture.phoenixToAuma[196U]), kOpenCommand);
  ASSERT_EQ(CommandByte(openCapture.phoenixToAuma[321U]), kStopCommand);
  ASSERT_EQ(CommandByte(closeCapture.phoenixToAuma[259U]), kCloseCommand);
  ASSERT_EQ(CommandByte(closeCapture.phoenixToAuma[384U]), kStopCommand);
 
  EXPECT_EQ(openCapture.phoenixToAuma[196U].frame.at(24U), kOpenCommand);
  EXPECT_EQ(openCapture.phoenixToAuma[321U].frame.at(24U), kStopCommand);
  EXPECT_EQ(closeCapture.phoenixToAuma[259U].frame.at(24U), kCloseCommand);
  EXPECT_EQ(closeCapture.phoenixToAuma[384U].frame.at(24U), kStopCommand);
}
 
TEST(CyclicCaptureTests, AumaGsdmlResolvesCompletePhoenixAumaSlotSet)
{
  const auto auma = LoadGsdml(kAumaGsdml);
  const auto slots = auma.BuildIoSlots();
 
  ASSERT_EQ(slots.size(), 9U);
 
  const std::array<std::pair<std::uint16_t, std::uint16_t>, 9> required{
      {{0, 0x0001},
       {0, 0x0002},
       {0, 0x0003},
       {0, 0x0004},
       {0, 0x8000},
       {0, 0x8001},
       {0, 0x8002},
       {1, 1},
       {2, 1}}};
 
  for (const auto& [slot, subslot] : required)
  {
    ASSERT_NE(FindSlot(slots, slot, subslot), nullptr);
  }
 
  const auto* input = FindSlot(slots, 1U, 1U);
  const auto* output = FindSlot(slots, 2U, 1U);
  ASSERT_NE(input, nullptr);
  ASSERT_NE(output, nullptr);
 
  EXPECT_EQ(input->inputLength, 34U);
  EXPECT_EQ(output->outputLength, 16U);
  EXPECT_EQ(input->moduleIdent, 0x00008000U);
  EXPECT_EQ(input->submoduleIdent, 0x00002200U);
  EXPECT_EQ(output->moduleIdent, 0x00008100U);
  EXPECT_EQ(output->submoduleIdent, 0x10001000U);
}
 
TEST(CyclicCaptureTests, DISABLED_BuildIocrConfigsMatchesPhoenixAumaWireLayout)
{
  const auto slots = PhoenixAumaCapturedSlots();
  const auto [input, output] =
      rt::BuildIocrConfigs(slots, kInputFrameId, kOutputFrameId, 32, 8, 3, 43);
 
  ASSERT_EQ(input.frameId, kInputFrameId);
  ASSERT_EQ(input.dataLength, 43U);
  ASSERT_EQ(input.objects.size(), 9U);
 
  const auto inputSlot1 = std::find_if(
      input.objects.begin(),
      input.objects.end(),
      [](const rt::IODataObject& object)
  {
    return object.slot == 1U && object.subslot == 1U;
  });
  ASSERT_NE(inputSlot1, input.objects.end());
  EXPECT_EQ(inputSlot1->frameOffset, 1U);
  EXPECT_EQ(inputSlot1->dataLength, 34U);
  EXPECT_EQ(inputSlot1->offsetIOPS, 35U);
 
  const auto inputIocs = std::find_if(
      input.objects.begin(),
      input.objects.end(),
      [](const rt::IODataObject& object)
  {
    return object.slot == 2U && object.subslot == 1U;
  });
  ASSERT_NE(inputIocs, input.objects.end());
  EXPECT_EQ(inputIocs->frameOffset, 0U);
  EXPECT_EQ(inputIocs->dataLength, 0U);
  EXPECT_EQ(inputIocs->offsetIOCS, 0U);
 
  for (std::uint16_t subslot = 1U; subslot <= 4U; ++subslot)
  {
    const auto object = std::find_if(
        input.objects.begin(),
        input.objects.end(),
        [subslot](const rt::IODataObject& value)
    {
      return value.slot == 0U && value.subslot == subslot;
    });
    ASSERT_NE(object, input.objects.end());
  }
 
  ASSERT_EQ(output.frameId, kOutputFrameId);
  ASSERT_EQ(output.dataLength, 40U);
  ASSERT_EQ(output.objects.size(), 9U);
 
  const auto outputData = std::find_if(
      output.objects.begin(),
      output.objects.end(),
      [](const rt::IODataObject& object)
  {
    return object.slot == 2U && object.subslot == 1U;
  });
  ASSERT_NE(outputData, output.objects.end());
  EXPECT_EQ(outputData->frameOffset, 8U);
  EXPECT_EQ(outputData->dataLength, 16U);
 
  for (std::uint16_t subslot : {1U, 2U, 3U, 4U, 0x8000U, 0x8001U, 0x8002U})
  {
    const auto object = std::find_if(
        output.objects.begin(),
        output.objects.end(),
        [subslot](const rt::IODataObject& value)
    {
      return value.slot == 0U && value.subslot == subslot;
    });
    ASSERT_NE(object, output.objects.end());
    EXPECT_EQ(object->offsetIOCS, object->frameOffset);
  }
 
  const auto slot1Iocs = std::find_if(
      output.objects.begin(),
      output.objects.end(),
      [](const rt::IODataObject& object)
  {
    return object.slot == 1U && object.subslot == 1U;
  });
  ASSERT_NE(slot1Iocs, output.objects.end());
  EXPECT_EQ(slot1Iocs->frameOffset, 7U);
  EXPECT_EQ(slot1Iocs->offsetIOCS, 7U);
}
 
TEST(CyclicCaptureTests, DISABLED_WIPRtBuildIocrConfigsMatchesPhoenixAumaWireLayout)
{
  const auto auma = LoadGsdml(kAumaGsdml);
 
  const auto slots = auma.BuildIoSlots();
 
  const auto [input, output] =
      rt::BuildIocrConfigs(slots, kInputFrameId, kOutputFrameId, 32, 8, 3, 43);
 
  ASSERT_EQ(input.frameId, kInputFrameId);
  ASSERT_EQ(input.dataLength, 43U);
  ASSERT_EQ(input.objects.size(), 9U);
 
  const auto inputSlot1 = std::find_if(
      input.objects.begin(),
      input.objects.end(),
      [](const rt::IODataObject& object)
  {
    return object.slot == 1U && object.subslot == 1U;
  });
  const auto capturedBlocks = CapturedConnectBlocks(static_cast<std::uint16_t>(BlockType::IoCrRequest));
  auto fullDataBlock = *FindBlock(capturedBlocks, static_cast<std::uint16_t>(BlockType::IoCrRequest));
 
  auto capturedInput = PNIOCRBlockReqHeader::Parse(fullDataBlock);
  Bytes dataBlock(fullDataBlock.begin() + PNIOCRBlockReqHeader::kSize + 4 + 2, fullDataBlock.end()); //+4 = api nr; +2 = nr of objects
 
  wire::Reader r(fullDataBlock);
 
  r.SkipTo(PNIOCRBlockReqHeader::kSize + 4U);
  const auto numberOfIODataObjects = r.U16();
 
  r.SkipTo(PNIOCRBlockReqHeader::kSize + 6U + numberOfIODataObjects * IOCRAPIObject::kSize);
  const auto numberOfIOCSObjects = r.U16();
 
  Bytes iocsBlock(fullDataBlock.begin() + PNIOCRBlockReqHeader::kSize + 4 + 2 + numberOfIODataObjects * IOCRAPIObject::kSize + 2, fullDataBlock.end()); //+4 = api nr; +2 = nr of objects
 
  std::vector<IOCRAPIObject> objects;
 
  for (std::size_t i = 0; i < numberOfIODataObjects * IOCRAPIObject::kSize; i = i + IOCRAPIObject::kSize)
  {
    const Bytes objBytes(dataBlock.begin() + i, dataBlock.begin() + i * IOCRAPIObject::kSize + IOCRAPIObject::kSize);
    auto obj = IOCRAPIObject::Parse(objBytes);
    objects.push_back(obj);
  }
  for (std::size_t i = 0; i < numberOfIOCSObjects * IOCRAPIObject::kSize; i = i + IOCRAPIObject::kSize)
  {
    const Bytes objBytes(iocsBlock.begin() + i, iocsBlock.begin() + i * IOCRAPIObject::kSize + IOCRAPIObject::kSize);
    auto obj = IOCRAPIObject::Parse(objBytes);
    objects.push_back(obj);
  }
 
  //  auto capturedInput = a;
  ASSERT_NE(inputSlot1, input.objects.end());
  EXPECT_EQ(inputSlot1->frameOffset, 1U);
  EXPECT_EQ(inputSlot1->frameOffset, capturedInput.frameSendOffset);
  EXPECT_EQ(inputSlot1->dataLength, 34U);
  EXPECT_EQ(inputSlot1->dataLength, capturedInput.dataLength);
  EXPECT_EQ(inputSlot1->offsetIOPS, 35U);
 
  const auto inputIocs = std::find_if(
      input.objects.begin(),
      input.objects.end(),
      [](const rt::IODataObject& object)
  {
    return object.slot == 2U && object.subslot == 1U;
  });
  ASSERT_NE(inputIocs, input.objects.end());
  EXPECT_EQ(inputIocs->frameOffset, 0U);
  EXPECT_EQ(inputIocs->dataLength, 0U);
  EXPECT_EQ(inputIocs->offsetIOCS, 0U);
 
  for (std::uint16_t subslot = 1U; subslot <= 4U; ++subslot)
  {
    const auto object = std::find_if(
        input.objects.begin(),
        input.objects.end(),
        [subslot](const rt::IODataObject& value)
    {
      return value.slot == 0U && value.subslot == subslot;
    });
    ASSERT_NE(object, input.objects.end());
  }
 
  ASSERT_EQ(output.frameId, kOutputFrameId);
  ASSERT_EQ(output.dataLength, 40U);
  ASSERT_EQ(output.objects.size(), 9U);
 
  const auto outputData = std::find_if(
      output.objects.begin(),
      output.objects.end(),
      [](const rt::IODataObject& object)
  {
    return object.slot == 2U && object.subslot == 1U;
  });
  ASSERT_NE(outputData, output.objects.end());
  EXPECT_EQ(outputData->frameOffset, 8U);
  EXPECT_EQ(outputData->dataLength, 16U);
 
  for (std::uint16_t subslot : {1U, 2U, 3U, 4U, 0x8000U, 0x8001U, 0x8002U})
  {
    const auto object = std::find_if(
        output.objects.begin(),
        output.objects.end(),
        [subslot](const rt::IODataObject& value)
    {
      return value.slot == 0U && value.subslot == subslot;
    });
    ASSERT_NE(object, output.objects.end());
    EXPECT_EQ(object->offsetIOCS, object->frameOffset);
  }
 
  const auto slot1Iocs = std::find_if(
      output.objects.begin(),
      output.objects.end(),
      [](const rt::IODataObject& object)
  {
    return object.slot == 1U && object.subslot == 1U;
  });
  ASSERT_NE(slot1Iocs, output.objects.end());
  EXPECT_EQ(slot1Iocs->frameOffset, 7U);
  EXPECT_EQ(slot1Iocs->offsetIOCS, 7U);
}
 
TEST(CyclicCaptureTests, CyclicControllerTransmitsCapturedCloseCommand)
{
  auto input = CapturedInputIocr();
  auto output = CapturedOutputIocr();
  CyclicControllerCapture capture(std::move(input), std::move(output));
 
  capture.SetOutputData(2, 1, Bytes{kCloseCommand});
  capture.Start();
 
  const bool received = capture.WaitForSent(
      [](const Bytes& frame)
  {
    const auto parsed = rt::ParseEthernetFrame(frame);
    return parsed.has_value() &&
           parsed->frameId == kOutputFrameId &&
           parsed->payload.size() == kOutputPayloadLength &&
           parsed->payload.at(kCommandOffset) == kCloseCommand;
  },
      std::chrono::milliseconds(250));
 
  capture.Stop();
  ASSERT_TRUE(received);
 
  const auto frames = capture.SentFrames();
  const auto it = std::find_if(
      frames.begin(),
      frames.end(),
      [](const Bytes& frame)
  {
    const auto parsed = rt::ParseEthernetFrame(frame);
    return parsed.has_value() &&
           parsed->frameId == kOutputFrameId &&
           parsed->payload.size() == kOutputPayloadLength &&
           parsed->payload.at(kCommandOffset) == kCloseCommand;
  });
 
  ASSERT_NE(it, frames.end());
  EXPECT_EQ(
      std::vector<std::uint8_t>(it->begin(), it->begin() + 6),
      std::vector<std::uint8_t>(kAumaMac.begin(), kAumaMac.end()));
  EXPECT_EQ(
      std::vector<std::uint8_t>(it->begin() + 6, it->begin() + 12),
      std::vector<std::uint8_t>(kPhoenixMac.begin(), kPhoenixMac.end()));
  EXPECT_EQ((*it)[12], 0x88U);
  EXPECT_EQ((*it)[13], 0x92U);
  EXPECT_EQ((*it)[14], 0x80U);
  EXPECT_EQ((*it)[15], 0x01U);
  EXPECT_EQ((*it)[24], kCloseCommand);
}
 
TEST(CyclicCaptureTests, CyclicControllerReceivesCapturedAumaPosition)
{
  const auto capture = LoadCapture("Set valve close.pcapng");
  ASSERT_FALSE(capture.aumaToPhoenix.empty());
 
  const auto firstInput = capture.aumaToPhoenix.front().frame;
  const auto expectedPosition = Position(capture.aumaToPhoenix.front());
  const auto expectedFrame = ParseCapturedRtFrame(capture.aumaToPhoenix.front());
  ASSERT_EQ(expectedFrame.frameId, kInputFrameId);
  ASSERT_EQ(expectedFrame.payload.size(), kInputPayloadLength);
 
  CyclicControllerCapture controller{CapturedInputIocr(), CapturedOutputIocr()};
 
  std::mutex callbackMutex;
  std::condition_variable callbackCondition;
  std::optional<Bytes> receivedData;
  controller.OnInput(
      [&](int slot, int subslot, const Bytes& data)
  {
    if (slot == 1 && subslot == 1)
    {
      {
        const std::lock_guard lock(callbackMutex);
        receivedData = data;
      }
      callbackCondition.notify_all();
    }
  });
 
  controller.SetRxFrame(firstInput);
  controller.Start();
 
  {
    std::unique_lock lock(callbackMutex);
    ASSERT_TRUE(callbackCondition.wait_for(
        lock,
        std::chrono::milliseconds(250),
        [&]
    {
      return receivedData.has_value();
    }));
  }
 
  controller.Stop();
 
  ASSERT_TRUE(receivedData.has_value());
  ASSERT_EQ(receivedData->size(), 34U);
 
  const auto receivedPosition = static_cast<std::uint16_t>(
      (static_cast<std::uint16_t>(receivedData->at(2U)) << 8U) |
      receivedData->at(3U));
  EXPECT_EQ(receivedPosition, expectedPosition);
}
 
TEST(CyclicCaptureTests, DISABLED_BuildInputIocrBlockMatchesPhoenixAumaCapture)
{
  auto transport = std::make_unique<StubRpcTransport>();
  auto* capture = transport.get();
  auto controlTransport = std::make_unique<StubRpcTransport>();
 
  rpc::RPCCon connection(
      AumaRpcInfo(),
      {},
      std::move(transport),
      std::move(controlTransport));
 
  const auto auma = LoadGsdml(kAumaGsdml);
 
  rpc::IOCRSetup setup;
  setup.slots = auma.BuildIoSlots();
  setup.sendClockFactor = 32;
  setup.reductionRatio = 8;
  setup.watchdogFactor = 3;
  setup.dataHoldFactor = 3;
 
  const auto result = connection.Connect(kPhoenixMac, true, setup);
  ASSERT_TRUE(result.has_value());
  ASSERT_EQ(capture->requests.size(), 1U);
 
  const auto rpcPacket = PNRPCHeader::Parse(capture->requests.front());
  const auto nrd = PNNRDData::Parse(rpcPacket.payload);
  const auto generatedBlocks = ExtractBlocks(nrd.payload);
  const auto capturedBlocks = CapturedConnectBlocks(static_cast<std::uint16_t>(BlockType::IoCrRequest));
 
  ASSERT_GE(generatedBlocks.size(), 3U);
  ASSERT_GE(capturedBlocks.size(), 3U);
 
  ASSERT_NE(FindBlock(capturedBlocks, static_cast<std::uint16_t>(BlockType::IoCrRequest)), nullptr);
  ASSERT_NE(FindBlock(capturedBlocks, static_cast<std::uint16_t>(BlockType::IoCrRequest), 1U), nullptr);
 
  EXPECT_EQ(generatedBlocks[1], *FindBlock(capturedBlocks, static_cast<std::uint16_t>(BlockType::IoCrRequest)));
 
  auto parsed = PNIOCRBlockReqHeader::Parse(generatedBlocks[1]);
  EXPECT_EQ(parsed.iocrType, 1U);
  EXPECT_EQ(parsed.iocrReference, 1U);
  EXPECT_EQ(parsed.frameId, kInputFrameId);
  EXPECT_EQ(parsed.dataLength, 43U);
  EXPECT_EQ(parsed.sendClockFactor, 32U);
  EXPECT_EQ(parsed.reductionRatio, 8U);
  EXPECT_EQ(parsed.phase, 8U);
  EXPECT_EQ(parsed.watchdogFactor, 3U);
  EXPECT_EQ(parsed.dataHoldFactor, 3U);
 
  EXPECT_EQ(generatedBlocks[2], *FindBlock(capturedBlocks, static_cast<std::uint16_t>(BlockType::IoCrRequest), 1U));
  parsed = PNIOCRBlockReqHeader::Parse(generatedBlocks[2]);
  EXPECT_EQ(parsed.iocrType, 2U);
  EXPECT_EQ(parsed.iocrReference, 2U);
  //  EXPECT_EQ(parsed.frameId, kOutputFrameId);
  EXPECT_EQ(parsed.dataLength, 40U);
  EXPECT_EQ(parsed.sendClockFactor, 32U);
  EXPECT_EQ(parsed.reductionRatio, 8U);
  EXPECT_EQ(parsed.phase, 8U);
  EXPECT_EQ(parsed.watchdogFactor, 3U);
  EXPECT_EQ(parsed.dataHoldFactor, 3U);
}
 
TEST(CyclicCaptureTests, DISABLED_BuildOutputIocrBlockMatchesPhoenixAumaCapture)
{
  auto transport = std::make_unique<StubRpcTransport>();
  auto* capture = transport.get();
  auto controlTransport = std::make_unique<StubRpcTransport>();
 
  rpc::RPCCon connection(
      AumaRpcInfo(),
      {},
      std::move(transport),
      std::move(controlTransport));
 
  const auto auma = LoadGsdml(kAumaGsdml);
 
  rpc::IOCRSetup setup;
  setup.slots = auma.BuildIoSlots();
  setup.sendClockFactor = 32;
  setup.reductionRatio = 8;
  setup.watchdogFactor = 3;
  setup.dataHoldFactor = 3;
 
  const auto result = connection.Connect(kPhoenixMac, true, setup);
  ASSERT_TRUE(result.has_value());
  ASSERT_EQ(capture->requests.size(), 1U);
 
  const auto rpcPacket = PNRPCHeader::Parse(capture->requests.front());
  const auto nrd = PNNRDData::Parse(rpcPacket.payload);
  const auto generatedBlocks = ExtractBlocks(nrd.payload);
  const auto capturedBlocks = CapturedConnectBlocks(static_cast<std::uint16_t>(BlockType::IoCrRequest));
 
  ASSERT_GE(generatedBlocks.size(), 3U);
 
  const auto* capturedOutput =
      FindBlock(capturedBlocks, static_cast<std::uint16_t>(BlockType::IoCrRequest), 1U);
  ASSERT_NE(capturedOutput, nullptr);
  EXPECT_EQ(generatedBlocks[2], *capturedOutput);
 
  const auto parsed = PNIOCRBlockReqHeader::Parse(generatedBlocks[2]);
  EXPECT_EQ(parsed.iocrType, 2U);
  EXPECT_EQ(parsed.iocrReference, 2U);
  EXPECT_EQ(parsed.frameId, 0xC001U);
  EXPECT_EQ(parsed.dataLength, 40U);
  EXPECT_EQ(parsed.sendClockFactor, 32U);
  EXPECT_EQ(parsed.reductionRatio, 8U);
  EXPECT_EQ(parsed.phase, 8U);
  EXPECT_EQ(parsed.watchdogFactor, 3U);
  EXPECT_EQ(parsed.dataHoldFactor, 3U);
}
 
TEST(CyclicCaptureTests, BuildExpectedSubmoduleBlocksMatchPhoenixAumaCapture)
{
  auto transport = std::make_unique<StubRpcTransport>();
  auto* capture = transport.get();
  auto controlTransport = std::make_unique<StubRpcTransport>();
 
  rpc::RPCCon connection(
      AumaRpcInfo(),
      {},
      std::move(transport),
      std::move(controlTransport));
 
  const auto auma = LoadGsdml(kAumaGsdml);
 
  rpc::IOCRSetup setup;
  setup.slots = auma.BuildIoSlots();
  setup.sendClockFactor = 32;
  setup.reductionRatio = 8;
  setup.watchdogFactor = 3;
  setup.dataHoldFactor = 3;
 
  const auto result = connection.Connect(kPhoenixMac, true, setup);
  ASSERT_TRUE(result.has_value());
  ASSERT_EQ(capture->requests.size(), 1U);
 
  const auto rpcPacket = PNRPCHeader::Parse(capture->requests.front());
  const auto nrd = PNNRDData::Parse(rpcPacket.payload);
  const auto generatedBlocks = ExtractBlocks(nrd.payload);
  const auto capturedBlocks = CapturedConnectBlocks(static_cast<std::uint16_t>(BlockType::ExpectedSubmoduleRequest));
 
  std::vector<Bytes> generatedExpected;
  std::vector<Bytes> capturedExpected;
 
  for (const auto& block : generatedBlocks)
  {
    if (rpc::PeekBlockHeader(block, 0U).blockType ==
        static_cast<std::uint16_t>(BlockType::ExpectedSubmoduleRequest))
    {
      generatedExpected.push_back(block);
    }
  }
 
  for (const auto& block : capturedBlocks)
  {
    if (rpc::PeekBlockHeader(block, 0U).blockType ==
        static_cast<std::uint16_t>(BlockType::ExpectedSubmoduleRequest))
    {
      capturedExpected.push_back(block);
    }
  }
 
  ASSERT_EQ(capturedExpected.size(), 3U);
  EXPECT_EQ(generatedExpected, capturedExpected);
}
 
} // namespace profinet::CyclicCaptureTests