test_rpc.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <deque>
#include <optional>
#include <thread>
 
#include "mocks/mockRawEthernetSocket.h"
#include "profinet/rpc.h"
#include "profinet/rpcTypes.h"
 
namespace profinet::rpc
{
class RpcTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    transport = std::make_unique<TestRpcTransport>();
    rawTransport = transport.get();
    ctransport = std::make_unique<TestRpcTransport>();
    rawcTransport = ctransport.get();
    conn = MakeTestTransportRpcConnection(std::move(transport), std::move(ctransport));
  }
 
  void TearDown() override
  {
  }
 
  dcp::DCPDeviceDescription MakeRpcTestDeviceInfo()
  {
    dcp::DCPDeviceDescription info(String2Mac("aa:bb:cc:dd:ee:ff"), {});
    info.name = "test-device";
    info.deviceHigh = 0x12;
    info.deviceLow = 0x34;
    info.vendorHigh = 0x56;
    info.vendorLow = 0x78;
    return info;
  }
 
  bool IsAllZeroUuid(const std::array<std::uint8_t, uuidLenght>& uuid)
  {
    return std::ranges::all_of(uuid, [](const std::uint8_t byte)
    {
      return byte == 0;
    });
  }
 
  PNRPCHeader CreateRpc(const Bytes& payload, RPCCon* conn = nullptr)
  {
    if (conn != nullptr)
    {
      return conn->CreateRpc(PNRPCHeader::CONNECT, payload);
    }
    return this->conn->CreateRpc(PNRPCHeader::CONNECT, payload);
  }
 
  Bytes InvokeBuildIocrBlock(IocrType iocrType, const IOCRSetup& setup)
  {
    return rpc::RPCCon::BuildIocrBlock(iocrType, setup);
  }
 
  Bytes MakeEpmTowerFloor(const Bytes& lhs, const Bytes& rhs)
  {
    Bytes result;
    wire::PutLittleEndian(result, static_cast<std::uint16_t>(lhs.size()));
 
    wire::PutFixed(result, lhs);
 
    wire::PutLittleEndian(result, static_cast<std::uint16_t>(rhs.size()));
 
    wire::PutFixed(result, rhs);
 
    return result;
  }
 
  Bytes MakeEpmTower(const std::vector<Bytes>& floors)
  {
    Bytes result;
 
    wire::PutLittleEndian(result, static_cast<std::uint16_t>(floors.size()));
 
    for (const auto& floor : floors)
    {
      wire::PutFixed(result, floor);
    }
 
    return result;
  }
 
  Bytes MakeInterfaceTowerLhs(const std::string& uuid, std::uint16_t major)
  {
    Bytes lhs;
    lhs.push_back(0x0D);
 
    const auto uuidBytes = StringToUuidBytes(uuid);
    wire::PutFixed(lhs, uuidBytes);
 
    wire::PutLittleEndian(lhs, major);
 
    return lhs;
  }
 
  Bytes MakeInterfaceTowerRhs(std::uint16_t minor)
  {
    Bytes rhs;
    wire::PutLittleEndian(rhs, minor);
    return rhs;
  }
 
  Bytes MakeCompleteEpmTower(const std::string& interfaceUuid, std::uint16_t major, std::uint16_t minor,
                             std::uint16_t port, const std::array<std::uint8_t, 4>& ipAddress)
  {
    const Bytes interfaceFloor = MakeEpmTowerFloor(MakeInterfaceTowerLhs(interfaceUuid, major), MakeInterfaceTowerRhs(minor));
 
    const Bytes udpFloor = MakeEpmTowerFloor({0x0A}, {});
 
    Bytes portData;
    wire::PutBigEndian(portData, port);
    const Bytes portFloor = MakeEpmTowerFloor({0x08}, portData);
 
    const Bytes ipFloor = MakeEpmTowerFloor({0x09}, {
                                                        ipAddress[0],
                                                        ipAddress[1],
                                                        ipAddress[2],
                                                        ipAddress[3],
                                                    });
 
    return MakeEpmTower({interfaceFloor, udpFloor, portFloor, ipFloor});
  }
 
  bool IsZeroUuid(const std::array<std::uint8_t, uuidLenght>& uuid)
  {
    return std::ranges::all_of(uuid, [](std::uint8_t value)
    {
      return value == 0;
    });
  }
 
  Bytes MakeEpmLookupBody(const std::array<std::uint8_t, uuidLenght>& objectUuid, const std::string& annotation, const Bytes& tower)
  {
    Bytes body;
    // wire::PutLittleEndian<std::uint32_t>(body, 0);
 
    wire::PutLittleEndian<std::uint32_t>(body, 0); // entry_handle
    wire::PutLittleEndian<std::uint32_t>(body, 1); // num_entries
 
    wire::PutLittleEndian<std::uint32_t>(body, 1); // max_count
    wire::PutLittleEndian<std::uint32_t>(body, 0); // offset
    wire::PutLittleEndian<std::uint32_t>(body, 1); // actual_count
 
    wire::PutFixed(body, objectUuid);
 
    wire::PutLittleEndian<std::uint32_t>(body, 0); // tower pointer
 
    wire::PutLittleEndian(body, static_cast<std::uint32_t>(annotation.size() + 1));
 
    wire::PutFixed(body, annotation);
 
    body.push_back(0);
 
    while ((body.size() & 3U) != 0U)
    {
      body.push_back(0);
    }
 
    wire::PutLittleEndian(body, static_cast<std::uint32_t>(tower.size()));
 
    body.insert(body.end(), tower.begin(), tower.end());
 
    while ((body.size() & 3U) != 0U)
    {
      body.push_back(0);
    }
 
    return body;
  }
 
  Bytes MakeEpmResponse(const Bytes& body)
  {
    Bytes response;
    response.reserve(PNRPCHeader::kFixedSize + body.size());
 
    response.push_back(4);
    response.push_back(PNRPCHeader::RESPONSE);
    response.push_back(0x00);
    response.push_back(0x00);
 
    response.push_back(0x10);
    response.push_back(0x00);
    response.push_back(0x00);
    response.push_back(0x00);
 
    response.insert(response.end(), 16, 0x00);
    response.insert(response.end(), 16, 0x00);
    response.insert(response.end(), 16, 0x00);
 
    wire::PutLittleEndian<std::uint32_t>(response, 0);
    wire::PutLittleEndian<std::uint32_t>(response, 3);
    wire::PutLittleEndian<std::uint32_t>(response, 0);
 
    wire::PutLittleEndian<std::uint16_t>(response, EPM_LOOKUP);
    wire::PutLittleEndian(response, PNRPCHeader::defaultInterfaceHint);
    wire::PutLittleEndian(response, PNRPCHeader::defaultActivityHint);
    wire::PutLittleEndian(response, static_cast<std::uint16_t>(body.size()));
    wire::PutLittleEndian<std::uint16_t>(response, 0);
    response.push_back(0);
    response.push_back(0);
    wire::PutFixed(response, body);
 
    return response;
  }
 
  void ReplyToEpmLookup(asio::ip::udp::socket& server, const Bytes& response, Bytes& request)
  {
    std::array<std::uint8_t, 4096> buffer{};
    asio::ip::udp::endpoint sender;
 
    const std::size_t received = server.receive_from(asio::buffer(buffer), sender);
 
    request.assign(buffer.begin(), buffer.begin() + received);
 
    server.send_to(asio::buffer(response), sender);
  }
 
  Bytes MakeDcpBlock(DcpOption option, std::uint8_t suboption, const Bytes& payload)
  {
    PNDCPBlockRequest block;
    block.option = option;
    block.suboption = suboption;
    block.length = static_cast<std::uint16_t>(payload.size());
    block.payload = payload;
 
    Bytes result = block.ToBytes();
 
    if ((payload.size() % 2U) != 0U)
    {
      result.push_back(0);
    }
 
    return result;
  }
 
  Bytes MakeDcpResponseFrame(const MacAddress& src, const MacAddress& dst, DcpServiceId serviceId, std::uint32_t xid, const Bytes& payload)
  {
    PNDCPHeader dcp;
    dcp.frameId = DcpFrameId::GetSet;
    dcp.serviceId = serviceId;
    dcp.serviceType = DcpServiceType::ResponseSuccess;
    dcp.xId = xid;
    dcp.respDelay = 0;
    dcp.length = static_cast<std::uint16_t>(payload.size());
    dcp.payload = payload;
 
    EthernetHeader eth;
    eth.dst = dst;
    eth.src = src;
    eth.type = PROFINET_ETHERTYPE;
    eth.payload = dcp.ToBytes();
 
    return eth.ToBytes();
  }
 
  Bytes MakeStationNameResponse(const MacAddress& deviceMac, const MacAddress& controllerMac, const std::string& stationName)
  {
    const Bytes block = MakeDcpBlock(DcpOption::Device, PNDCPBlock::NAME_OF_STATION.second, Bytes(stationName.begin(), stationName.end()));
 
    return MakeDcpResponseFrame(deviceMac, controllerMac, DcpServiceId::Get, 0x12345678, block);
  }
 
  Bytes MakeDeviceResponse(const MacAddress& deviceMac, const MacAddress& controllerMac, const std::string& stationName, const Bytes& additionalBlocks = {})
  {
    Bytes payload = MakeDcpBlock(DcpOption::Device, PNDCPBlock::NAME_OF_STATION.second, Bytes(stationName.begin(), stationName.end()));
 
    payload.insert(payload.end(), additionalBlocks.begin(), additionalBlocks.end());
 
    return MakeDcpResponseFrame(deviceMac, controllerMac, DcpServiceId::Get, 0x12345678, payload);
  }
 
  std::map<dcp::BlockKey, std::vector<std::uint8_t>> MakeStationBlocks(const std::string& stationName)
  {
    return {
        {
            dcp::MakeBlockKey(static_cast<std::uint16_t>(DcpOption::Device), PNDCPBlock::NAME_OF_STATION.second),
            std::vector<std::uint8_t>(stationName.begin(), stationName.end()),
        },
    };
  }
 
  PNNRDData InvokeCreateNrd(const Bytes& payload)
  {
    return conn->CreateNrd(payload);
  }
 
  Bytes InvokeBuildAlarmCrBlock(int transport, int priority)
  {
    return conn->BuildAlarmCrBlock(transport, priority);
  }
 
  int InvokeParseAlarmCrResponse(const Bytes& responseData)
  {
    return conn->ParseAlarmCrResponse(responseData);
  }
 
  std::unique_ptr<RPCCon> MakeTestRpcConnection()
  {
    return std::make_unique<RPCCon>(MakeRpcTestDeviceInfo());
  }
 
  Bytes MakeAlarmCrResponseBlock(std::uint16_t localAlarmReference)
  {
    PNAlarmCRBlockRes response;
 
    PNBlockHeader header;
    header.blockType = BlockType::AlarmCrResponse; // PNAlarmCRBlockRes::BLOCK_TYPE;
    header.blockLength = static_cast<std::uint16_t>(PNAlarmCRBlockRes::kSize - 4);
    header.blockVersionHigh = 0x01;
    header.blockVersionLow = 0x00;
 
    const Bytes headerBytes = header.ToBytes();
 
    std::ranges::copy(headerBytes, response.blockHeader.begin());
 
    response.localAlarmReference = localAlarmReference;
 
    return response.ToBytes();
  }
 
  Bytes MakeBlockHeader(BlockType blockType, std::uint16_t blockLength)
  {
    PNBlockHeader header;
    header.blockType = blockType;
    header.blockLength = blockLength;
    header.blockVersionHigh = 0x01;
    header.blockVersionLow = 0x00;
 
    return header.ToBytes();
  }
 
  class TestRpcTransport final : public IRpcTransport
  {
   public:
    using ResponseHandler = std::function<Bytes(const Bytes&)>;
 
    ResponseHandler responseHandler;
 
    std::deque<Bytes> responses;
 
    std::vector<Bytes> receivedRequests;
 
    std::vector<Bytes> sentRequests;
 
    std::string openedAddress;
 
    std::uint16_t openedPort = 0;
 
    bool openedAsListener = false;
 
    std::size_t openCount = 0;
 
    std::size_t receiveCount = 0;
 
    std::size_t sendToCount = 0;
 
    std::size_t closeCount = 0;
 
    asio::ip::udp::endpoint lastSendToEndpoint;
 
    asio::ip::udp::endpoint receiveEndpoint; 
 
    Bytes receiveData;
 
    std::deque<Bytes> incomingDatagrams;
 
    std::exception_ptr receiveException;
 
    std::exception_ptr sendException;
 
    void Open(const std::string& address, std::uint16_t port, bool isListener = false) override
    {
      openedAddress = address;
      openedPort = port;
      openedAsListener = isListener;
      ++openCount;
    }
 
    Bytes Receive(std::chrono::milliseconds, asio::ip::udp::endpoint& remoteEndpoint) override
    {
      ++receiveCount;
      if (receiveException)
      {
        std::rethrow_exception(receiveException);
      }
      remoteEndpoint = receiveEndpoint;
      if (!incomingDatagrams.empty())
      {
        Bytes result = std::move(incomingDatagrams.front());
        incomingDatagrams.pop_front();
        return result;
      }
      return receiveData;
    }
 
    void QueueIncomingDatagram(const Bytes& data)
    {
      incomingDatagrams.push_back(data);
    }
 
    void SendTo(const Bytes& data, const asio::ip::udp::endpoint& targetEndpoint) override
    {
      sentRequests.push_back(data);
      lastSendToEndpoint = targetEndpoint;
      ++sendToCount;
    }
 
    Bytes SendReceive(const Bytes& request, std::chrono::milliseconds) override
    {
      receivedRequests.push_back(request);
 
      if (responseHandler)
      {
        return responseHandler(request);
      }
 
      if (responses.empty())
      {
        throw RPCError("TestRpcTransport: no response configured");
      }
 
      Bytes response = responses.front();
      responses.pop_front();
      return response;
    }
 
    void Send(const Bytes& request) override
    {
      if (sendException)
      {
        std::rethrow_exception(sendException);
      }
      sentRequests.push_back(request);
    }
 
    void Close() noexcept override
    {
      ++closeCount;
    }
  };
 
  std::unique_ptr<RPCCon> MakeTestTransportRpcConnection(std::unique_ptr<IRpcTransport> transport, std::unique_ptr<IRpcTransport> ctransport = nullptr)
  {
    RPCConOptions options;
    options.timeoutSec = 1.0;
    options.rpcPort = 0;
 
    return std::make_unique<RPCCon>(MakeRpcTestDeviceInfo(), options, std::move(transport), std::move(ctransport));
  }
 
  Bytes MakeRpcResponseBytes(std::uint8_t packetType = PNRPCHeader::RESPONSE, std::uint16_t operationNumber = 0, const Bytes& payload = {})
  {
    PNRPCHeader response;
    response.packetType = packetType;
    response.operationNumber = operationNumber;
    response.lengthOfBody = static_cast<std::uint16_t>(payload.size());
    response.payload = payload;
 
    return response.ToBytes();
  }
 
  Bytes MakeNrdResponseBytes(const Bytes& payload = {})
  {
    PNNRDData nrd;
    nrd.argsMaximumStatus = 0;
    nrd.argsLength = static_cast<std::uint32_t>(payload.size());
    nrd.maximumCount = 1500;
    nrd.offset = 0;
    nrd.actualCount = static_cast<std::uint32_t>(payload.size());
    nrd.payload = payload;
 
    return nrd.ToBytes();
  }
 
  Bytes MakeNrdRpcResponseBytes(std::uint16_t operationNumber, const Bytes& payload = {})
  {
    return MakeRpcResponseBytes(
        PNRPCHeader::RESPONSE,
        operationNumber,
        MakeNrdResponseBytes(payload));
  }
 
  Bytes MakePnioErrorNrdResponse(std::uint32_t status, const Bytes& payload = {})
  {
    PNNRDData nrd;
    nrd.argsMaximumStatus = status;
    nrd.argsLength = static_cast<std::uint32_t>(payload.size());
    nrd.maximumCount = 1500;
    nrd.offset = 0;
    nrd.actualCount = static_cast<std::uint32_t>(payload.size());
    nrd.payload = payload;
 
    return nrd.ToBytes();
  }
 
  Bytes MakeIodResponsePayload(std::uint32_t api, std::uint16_t slot, std::uint16_t subslot,
                               std::uint16_t idx, const Bytes& payload)
  {
    PNBlockHeader block;
    block.blockType = static_cast<BlockType>(PNBlockHeader::IODReadResponseHeader);
    block.blockLength = static_cast<std::uint16_t>(PNIODHeader::kFixedSize - 4);
    block.blockVersionHigh = 0x01;
    block.blockVersionLow = 0x00;
 
    PNIODHeader iod;
    const Bytes blockBytes = block.ToBytes();
    std::ranges::copy(blockBytes, iod.blockHeader.begin());
 
    iod.sequenceNumber = 0;
    iod.api = api;
    iod.slot = slot;
    iod.subslot = subslot;
    iod.index = idx;
    iod.length = static_cast<std::uint32_t>(payload.size());
    iod.payload = payload;
 
    return iod.ToBytes();
  }
 
  Bytes MakeImPayload(std::uint16_t index)
  {
    std::size_t size = 6;
 
    switch (index)
    {
      case PNInM0::IDX:
        size = PNInM0::kSize;
        break;
 
      case PNInM1::IDX:
        size = PNInM1::kSize;
        break;
 
      case PNInM2::IDX:
        size = PNInM2::kSize;
        break;
 
      case PNInM3::IDX:
        size = PNInM3::kSize;
        break;
 
      case PNInM4::IDX:
        size = PNInM4::kSize;
        break;
 
      case PNInM5::IDX:
        size = PNInM5::kSize;
        break;
 
      default:
        size = 6;
        break;
    }
 
    return Bytes(size, 0);
  }
 
  Bytes MakeDiagnosisPayload()
  {
    Bytes data;
 
    wire::PutU16(data, 0x0010); // DiagnosisData block type
    wire::PutU16(data, 14);     // block length
    wire::PutU8(data, 1);
    wire::PutU8(data, 0);
 
    wire::PutU16(data, 1);      // channel
    wire::PutU16(data, 0);      // channel properties
    wire::PutU16(data, 0x8000); // ChannelDiagnosis USI
    wire::PutU16(data, 0x0006); // Line break
 
    return data;
  }
 
  Bytes MakeRealIdentificationPayload()
  {
    Bytes data;
 
    wire::PutU16(data, 1);    // number of modules
    wire::PutU16(data, 1);    // slot
    wire::PutU32(data, 0x42); // module ident
    wire::PutU16(data, 1);    // number of subslots
    wire::PutU16(data, 1);    // subslot
    wire::PutU32(data, 0x99); // submodule ident
 
    return data;
  }
 
  Bytes MakeModuleDiffPayload()
  {
    Bytes body;
 
    wire::PutU16(body, 1);    // number of APIs
    wire::PutU32(body, 0);    // API
    wire::PutU16(body, 1);    // number of modules
    wire::PutU16(body, 1);    // slot
    wire::PutU32(body, 0x42); // module ident
    wire::PutU16(body, MODULE_STATE_PROPER_MODULE);
    wire::PutU16(body, 1);    // number of submodules
    wire::PutU16(body, 1);    // subslot
    wire::PutU32(body, 0x99); // submodule ident
    wire::PutU16(body, SUBMODULE_STATE_OK);
 
    Bytes data = MakeBlockHeader(BlockType::ModuleDifference, static_cast<std::uint16_t>(body.size() + 2));
 
    data.insert(data.end(), body.begin(), body.end());
    return data;
  }
 
  Bytes MakeWriteMultipleResponsePayload()
  {
    Bytes data(64, 0);
 
    // Record data length at offset 36.
    data[36] = 0x00;
    data[37] = 0x00;
    data[38] = 0x00;
    data[39] = 0x38; // 56-byte response block
 
    wire::PutU16(data, 0x8008); // block type
    wire::PutU16(data, 52);     // block length
    wire::PutU8(data, 1);
    wire::PutU8(data, 0);
 
    wire::PutU16(data, 0); // sequence
    data.insert(data.end(), uuidLenght, 0);
    wire::PutU32(data, 0);      // API
    wire::PutU16(data, 1);      // slot
    wire::PutU16(data, 1);      // subslot
    wire::PutU16(data, 0);      // padding
    wire::PutU16(data, 0xAFF1); // index
    wire::PutU32(data, 0);      // record data length
    wire::PutU16(data, 0);      // additional value 1
    wire::PutU16(data, 0);      // additional value 2
    wire::PutU32(data, 0);      // status
 
    return data;
  }
  Bytes MakeIocrResponseBlock(std::uint16_t iocrType, std::uint16_t iocrReference, std::uint16_t frameId)
  {
    Bytes data;
 
    wire::PutU16(data, PNIOCRBlockRes::BLOCK_TYPE);
    wire::PutU16(data, PNIOCRBlockRes::kSize - 4);
    wire::PutU8(data, 1);
    wire::PutU8(data, 0);
    wire::PutU16(data, iocrType);
    wire::PutU16(data, iocrReference);
    wire::PutU16(data, frameId);
 
    return data;
  }
  std::uint16_t InvokeParseIocrResponse(const Bytes& responseData, int iocrType)
  {
    return RPCCon::ParseIocrResponse(responseData, iocrType);
  }
 
  std::unique_ptr<RPCCon> conn;
  std::unique_ptr<TestRpcTransport> transport;
  TestRpcTransport* rawTransport = nullptr;
 
  std::unique_ptr<TestRpcTransport> ctransport;
  TestRpcTransport* rawcTransport = nullptr;
 
  PNRPCHeader InvokeSendReceive(const PNRPCHeader& request)
  {
    return conn->SendReceive(request);
  }
  void InvokeSetRPCConLive(bool live)
  {
    conn->live = live;
  }
  void InvokeSetRPCConArUuid(std::uint8_t byte)
  {
    conn->arUuid.fill(byte);
  }
 
  void InvokeSetRPCConArUuid(const std::array<std::uint8_t, uuidLenght>& bytes)
  {
    conn->arUuid = bytes;
  }
 
  void InvokeSetRPCConSessionKey(std::uint16_t byte)
  {
    conn->sessionKey = byte;
  }
  void InvokeSetRPCConInfo(std::uint8_t deviceHigh, std::uint8_t deviceLow,
                           std::uint8_t vendorHigh, std::uint8_t vendorLow)
  {
    conn->info.deviceHigh = deviceHigh;
    conn->info.deviceLow = deviceLow;
    conn->info.vendorHigh = vendorHigh;
    conn->info.vendorLow = vendorLow;
    conn->remoteObjectUuid = BuildObjectUuid(0x00, 0x01, conn->info.deviceHigh, conn->info.deviceLow, conn->info.vendorHigh, conn->info.vendorLow);
  }
 
  void InvokeSetRPCConSrcMac(std::string mac)
  {
    conn->srcMac = String2Mac(mac);
  }
 
  void InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::time_point time)
  {
    conn->liveMonotonic = time;
  }
  void InvokeRPCConCheckTimeout()
  {
    conn->CheckTimeout();
  }
  bool InvokeGetRPCConLive()
  {
    return conn->live;
  }
 
  std::optional<MacAddress> InvokeGetRPCConSrcMac()
  {
    return conn->srcMac;
  }
  Bytes InvokeSendControl(BlockType blockType, ControlCommand controlCommand,
                          bool waitResponse = true, const Bytes& subBlocks = {})
  {
    return conn->SendControl(blockType, controlCommand, waitResponse, subBlocks);
  }
 
  Bytes MakeRawRpcHeader(bool littleEndian, std::uint8_t packetType, std::uint32_t interfaceVersion,
                         std::uint32_t sequenceNumber, std::uint16_t operationNumber, const Bytes& payload)
  {
    Bytes data;
    data.reserve(PNRPCHeader::kFixedSize + payload.size());
 
    wire::PutU8(data, 0x04);
    wire::PutU8(data, packetType);
    wire::PutU8(data, 0x01);
    wire::PutU8(data, 0x02);
 
    // DREP.
    wire::PutU8(data, littleEndian ? 0x10 : 0x00);
    wire::PutU8(data, 0x00);
    wire::PutU8(data, 0x00);
    wire::PutU8(data, 0x5A);
 
    std::array<std::uint8_t, uuidLenght> objectUuid{};
    std::array<std::uint8_t, uuidLenght> interfaceUuid{};
    std::array<std::uint8_t, uuidLenght> activityUuid{};
 
    for (std::size_t i = 0U; i < uuidLenght; ++i)
    {
      objectUuid[i] = static_cast<std::uint8_t>(0x10U + i);
      interfaceUuid[i] = static_cast<std::uint8_t>(0x20U + i);
      activityUuid[i] = static_cast<std::uint8_t>(0x30U + i);
    }
 
    wire::PutFixed(data, objectUuid);
    wire::PutFixed(data, interfaceUuid);
    wire::PutFixed(data, activityUuid);
 
    // Bytes 56-59: server_boot_time.
    data.insert(data.end(), 4U, 0U);
 
    if (littleEndian)
    {
      wire::PutLittleEndian(data, interfaceVersion);
      wire::PutLittleEndian(data, sequenceNumber);
      wire::PutLittleEndian(data, operationNumber);
    }
    else
    {
      wire::PutBigEndian(data, interfaceVersion);
      wire::PutBigEndian(data, sequenceNumber);
      wire::PutBigEndian(data, operationNumber);
    }
 
    // Bytes 70-79: interface_hint, activity_hint, args_len, fragnum,
    // auth_proto and remaining fixed header fields.
    data.insert(data.end(), PNRPCHeader::kFixedSize - data.size(), 0U);
 
    wire::PutFixed(data, payload);
 
    return data;
  }
 
  Bytes MakeApplicationReadyControlBlock(std::uint16_t blockType = BLOCK_IOD_CONTROL_APP_READY_REQ,
                                         ControlCommand controlCommand = ControlCommand::ApplicationReady)
  {
    PNBlockHeader block;
    block.blockType = static_cast<BlockType>(blockType);
    block.blockLength = static_cast<std::uint16_t>(PNIODReleaseBlock::kSize - 4);
    block.blockVersionHigh = 0x01;
    block.blockVersionLow = 0x00;
 
    PNIODReleaseBlock control;
    const Bytes blockBytes = block.ToBytes();
    std::ranges::copy(blockBytes, control.blockHeader.begin());
 
    control.padding1 = 0;
    control.arUuid = {};
    control.sessionKey = 0x1234;
    control.padding2 = 0;
    control.controlCommand = controlCommand;
    control.controlBlockProperties = 0;
 
    return control.ToBytes();
  }
 
  Bytes MakeApplicationReadyNrd(const Bytes& block, bool littleEndian)
  {
    Bytes nrd;
 
    const auto blockLength = static_cast<std::uint32_t>(block.size());
 
    if (littleEndian)
    {
      wire::PutLittleEndian<std::uint32_t>(nrd, 0);
      wire::PutLittleEndian(nrd, blockLength);
      wire::PutLittleEndian(nrd, blockLength);
      wire::PutLittleEndian<std::uint32_t>(nrd, 0);
      wire::PutLittleEndian(nrd, blockLength);
    }
    else
    {
      wire::PutU32(nrd, 0);
      wire::PutU32(nrd, blockLength);
      wire::PutU32(nrd, blockLength);
      wire::PutU32(nrd, 0);
      wire::PutU32(nrd, blockLength);
    }
 
    nrd.insert(nrd.end(), block.begin(), block.end());
    return nrd;
  }
 
  Bytes MakeApplicationReadyRequest(bool littleEndian,
                                    std::uint16_t blockType = BLOCK_IOD_CONTROL_APP_READY_REQ,
                                    ControlCommand controlCommand = ControlCommand::ApplicationReady)
  {
    const Bytes controlBlock = MakeApplicationReadyControlBlock(blockType, controlCommand);
 
    const Bytes nrd = MakeApplicationReadyNrd(controlBlock, littleEndian);
 
    return MakeRawRpcHeader(littleEndian,
                            PNRPCHeader::REQUEST,
                            0x11223344,
                            0x55667788,
                            PNRPCHeader::CONTROL,
                            nrd);
  }
};
 
TEST_F(RpcTests, UuidBytesToStringStringToUuidBytesRoundtrip)
{
  auto readBytes = StringToUuidBytes("dea00001-6c97-11d1-8271-00a02442df7d");
 
  const std::string back = UuidBytesToString(readBytes);
 
  EXPECT_EQ(back, "dea00001-6c97-11d1-8271-00a02442df7d");
}
 
TEST_F(RpcTests, StringToUuidBytesRejectsMalformedInput)
{
  EXPECT_THROW(StringToUuidBytes("not-a-uuid"), std::exception);
 
  EXPECT_THROW(StringToUuidBytes("dea00001-6c97-11d1-8271"), std::exception);
}
 
TEST_F(RpcTests, EPMEndpointResolvesWellKnownProfinetInterfaceNames)
{
  profinet::rpc::EPMEndpoint ep;
 
  ep.interfaceUuid = UUID_PNIO_DEVICE;
  EXPECT_EQ(ep.InterfaceName(), "PNIO-Device");
 
  ep.interfaceUuid = UUID_PNIO_CONTROLLER;
  EXPECT_EQ(ep.InterfaceName(), "PNIO-Controller");
 
  ep.interfaceUuid = "00000000-0000-0000-0000-000000000000";
 
  EXPECT_EQ(ep.InterfaceName().rfind("Unknown(", 0), 0U);
}
 
TEST_F(RpcTests, EPMEndpointUnknownUuidIncludesUuid)
{
  profinet::rpc::EPMEndpoint ep;
 
  ep.interfaceUuid = "11111111-2222-3333-4444-555555555555";
 
  EXPECT_EQ(ep.InterfaceName(), "Unknown(11111111-2222-3333-4444-555555555555)");
}
 
TEST_F(RpcTests, EPMEndpointInterfaceNameIsCaseInsensitive)
{
  profinet::rpc::EPMEndpoint ep;
 
  ep.interfaceUuid = "DEA00001-6C97-11D1-8271-00A02442DF7D";
 
  EXPECT_EQ(ep.InterfaceName(), "PNIO-Device");
}
 
TEST_F(RpcTests, IOCRSetupCycleTimeCalculation)
{
  profinet::rpc::IOCRSetup setup;
  setup.sendClockFactor = 32;
  setup.reductionRatio = 32;
 
  // cycle_time_us = reduction_ratio * send_clock_factor * 125 / 4
  //               = 32 * 32 * 125 / 4 = 32000 us = 32ms
  EXPECT_EQ(setup.CycleTimeUs(), static_cast<std::uint32_t>(32000));
 
  EXPECT_GT(setup.CycleTimeMs(), 31.9);
  EXPECT_LT(setup.CycleTimeMs(), 32.1);
}
 
TEST_F(RpcTests, IOCRSetupValidateFlagsEmptySlotsAndLowWatchdog)
{
  profinet::rpc::IOCRSetup setup;
  setup.watchdogFactor = 1;
 
  auto warnings = setup.Validate();
 
  EXPECT_FALSE(warnings.empty());
}
 
TEST_F(RpcTests, IOCRSetupValidateEmptySlots)
{
  profinet::rpc::IOCRSetup setup;
 
  setup.watchdogFactor = 6;
 
  const auto warnings = setup.Validate();
 
  EXPECT_NE(std::ranges::find(warnings, "No IO slots configured"), warnings.end());
}
 
TEST_F(RpcTests, IOCRSetupValidateLowWatchdog)
{
  profinet::rpc::IOCRSetup setup;
 
  setup.watchdogFactor = 1;
 
  const auto warnings = setup.Validate();
 
  EXPECT_NE(std::ranges::find(warnings, "Watchdog factor too low (use 6+)"), warnings.end());
}
 
TEST_F(RpcTests, IOCRSetupValidateNormalConfiguration)
{
  profinet::rpc::IOCRSetup setup;
 
  setup.sendClockFactor = 32;
  setup.reductionRatio = 32;
  setup.watchdogFactor = 6;
 
  setup.slots.push_back({});
 
  const auto warnings = setup.Validate();
 
  EXPECT_TRUE(warnings.empty());
}
 
TEST_F(RpcTests, CreateRpcBuildsExpectedHeader)
{
  // profinet::dcp::DCPDeviceDescription info(profinet::String2Mac("aa:bb:cc:dd:ee:ff"), {});
  // profinet::rpc::RPCCon conn(info);
 
  const profinet::Bytes payload{0x01, 0x02, 0x03};
 
  const auto rpc = CreateRpc(payload);
 
  EXPECT_EQ(rpc.version, 4);
  EXPECT_EQ(rpc.packetType, profinet::PNRPCHeader::REQUEST);
  EXPECT_EQ(rpc.flags1, 0x20);
  EXPECT_EQ(rpc.interfaceVersion, 1);
  EXPECT_EQ(rpc.operationNumber, PNRPCHeader::CONNECT);
  EXPECT_EQ(rpc.interfaceHint, 0xFFFF);
  EXPECT_EQ(rpc.activityHint, 0xFFFF);
  EXPECT_EQ(rpc.lengthOfBody, payload.size());
  EXPECT_EQ(rpc.payload, payload);
}
 
TEST_F(RpcTests, PNRPCHeaderInterfaceUuidBytes)
{ // PROFINET interface UUIDs are embedded on the wire as a literal byte
  // sequence matching their canonical hex string directly (unlike EPM
  // tower UUIDs, which use genuine DCE/RPC mixed-endian NDR encoding).
  auto deviceUuid = profinet::PNRPCHeader::IfaceUuidDevice();
 
  EXPECT_EQ(ToHex(deviceUuid.data(), deviceUuid.size()), "dea000016c9711d1827100a02442df7d");
}
 
TEST_F(RpcTests, BuildIocrBlockUsesConfiguredSlots)
{
  IOCRSetup setup;
 
  setup.slots = {
      {
          .slot = 0,
          .subslot = 0x0001,
          .inputLength = 0,
          .outputLength = 0,
          .moduleIdent = 0x80010000,
          .submoduleIdent = 0x00000001,
      },
      {
          .slot = 0,
          .subslot = 0x0002,
          .inputLength = 0,
          .outputLength = 0,
          .moduleIdent = 0x80010000,
          .submoduleIdent = 0x00000010,
      },
      {
          .slot = 0,
          .subslot = 0x0003,
          .inputLength = 0,
          .outputLength = 0,
          .moduleIdent = 0x80010000,
          .submoduleIdent = 0x00000010,
      },
      {
          .slot = 0,
          .subslot = 0x0004,
          .inputLength = 0,
          .outputLength = 0,
          .moduleIdent = 0x80010000,
          .submoduleIdent = 0x00000010,
      },
      {
          .slot = 0,
          .subslot = 0x8000,
          .inputLength = 0,
          .outputLength = 0,
          .moduleIdent = 0x80010000,
          .submoduleIdent = 0x00000002,
      },
      {
          .slot = 0,
          .subslot = 0x8001,
          .inputLength = 0,
          .outputLength = 0,
          .moduleIdent = 0x80010000,
          .submoduleIdent = 0x00000003,
      },
      {
          .slot = 0,
          .subslot = 0x8002,
          .inputLength = 0,
          .outputLength = 0,
          .moduleIdent = 0x80010000,
          .submoduleIdent = 0x00000003,
      },
      {
          .slot = 1,
          .subslot = 0x0001,
          .inputLength = 34,
          .outputLength = 0,
          .moduleIdent = 0x00008000,
          .submoduleIdent = 0x00002200,
      },
      {
          .slot = 2,
          .subslot = 0x0001,
          .inputLength = 0,
          .outputLength = 16,
          .moduleIdent = 0x00008100,
          .submoduleIdent = 0x10001000,
      },
  };
 
  const Bytes input = InvokeBuildIocrBlock(IocrType::Input, setup);
 
  const Bytes output = InvokeBuildIocrBlock(IocrType::Output, setup);
 
  // Parse the fixed headers.
  const auto inputHeader = PNIOCRBlockReqHeader::Parse(input);
 
  const auto outputHeader = PNIOCRBlockReqHeader::Parse(output);
 
  EXPECT_EQ(inputHeader.iocrType, 1);
  EXPECT_EQ(outputHeader.iocrType, 2);
 
  EXPECT_EQ(inputHeader.dataLength, 43);
  EXPECT_EQ(outputHeader.dataLength, 40);
 
  EXPECT_EQ(inputHeader.numberOfApis, 1);
  EXPECT_EQ(outputHeader.numberOfApis, 1);
}
TEST_F(RpcTests, GenerateNonZeroArUuid)
{
  const auto info = MakeRpcTestDeviceInfo();
 
  RPCCon conn(info);
 
  const auto& arUuid = conn.ArUuid();
 
  EXPECT_FALSE(IsAllZeroUuid(arUuid));
  EXPECT_EQ(arUuid.size(), uuidLenght);
}
 
TEST_F(RpcTests, GenerateDifferentArUuids)
{
  const auto info = MakeRpcTestDeviceInfo();
 
  RPCCon first(info);
  RPCCon second(info);
 
  EXPECT_FALSE(IsAllZeroUuid(first.ArUuid()));
  EXPECT_FALSE(IsAllZeroUuid(second.ArUuid()));
 
  // Two independently generated 128-bit random UUIDs should not match.
  EXPECT_NE(first.ArUuid(), second.ArUuid());
}
 
TEST_F(RpcTests, GenerateIndependentArAndActivityUuids)
{
  const auto rpc = CreateRpc({});
 
  EXPECT_FALSE(IsAllZeroUuid(conn->ArUuid()));
  EXPECT_FALSE(IsAllZeroUuid(rpc.activityUuid));
  EXPECT_NE(conn->ArUuid(), rpc.activityUuid);
}
 
TEST_F(RpcTests, GenerateNonZeroSessionKey)
{
  const auto info = MakeRpcTestDeviceInfo();
 
  RPCCon conn(info);
 
  EXPECT_NE(conn.SessionKey(), static_cast<std::uint16_t>(0));
}
 
TEST_F(RpcTests, GeneratedSessionKeysAreAlwaysNonZero)
{
  const auto info = MakeRpcTestDeviceInfo();
 
  constexpr int connectionCount = 32;
 
  for (int i = 0; i < connectionCount; ++i)
  {
    RPCCon conn(info);
 
    EXPECT_NE(conn.SessionKey(), static_cast<std::uint16_t>(0));
  }
}
 
TEST_F(RpcTests, BuildsExpectedRemoteObjectUuid)
{
  const auto rpc = CreateRpc({});
 
  EXPECT_EQ(ToHex(rpc.objectUuid.data(), rpc.objectUuid.size()), "dea000006c9711d18271000112345678");
}
 
TEST_F(RpcTests, BuildObjectUuidPreservesDeviceAndVendorBytes)
{
  InvokeSetRPCConInfo(0xA1, 0xB2, 0xC3, 0xD4);
 
  const auto rpc = CreateRpc({});
 
  EXPECT_EQ(ToHex(rpc.objectUuid.data(), rpc.objectUuid.size()), "dea000006c9711d182710001a1b2c3d4");
}
 
TEST_F(RpcTests, BuildObjectUuidUsesFixedProfinetPrefixAndSuffix)
{
  InvokeSetRPCConInfo(0xAA, 0xBB, 0xCC, 0xDD);
  const auto rpc = CreateRpc({});
 
  const std::string uuidHex = ToHex(rpc.objectUuid.data(), rpc.objectUuid.size());
 
  EXPECT_EQ(uuidHex.substr(0, 20), "dea000006c9711d18271");
  EXPECT_EQ(uuidHex.substr(20), "0001aabbccdd");
}
 
TEST_F(RpcTests, RemoteObjectUuidHasExpectedLength)
{
  const auto rpc = CreateRpc({});
 
  EXPECT_EQ(rpc.objectUuid.size(), uuidLenght);
}
 
TEST_F(RpcTests, EPMEndpointInterfaceNamePnioDevice)
{
  EPMEndpoint endpoint;
  endpoint.interfaceUuid = UUID_PNIO_DEVICE;
 
  EXPECT_EQ(endpoint.InterfaceName(), "PNIO-Device");
}
 
TEST_F(RpcTests, EPMEndpointInterfaceNamePnioController)
{
  EPMEndpoint endpoint;
  endpoint.interfaceUuid = UUID_PNIO_CONTROLLER;
 
  EXPECT_EQ(endpoint.InterfaceName(), "PNIO-Controller");
}
 
TEST_F(RpcTests, EPMEndpointInterfaceNamePnioSupervisor)
{
  EPMEndpoint endpoint;
  endpoint.interfaceUuid = "dea00003-6c97-11d1-8271-00a02442df7d";
 
  EXPECT_EQ(endpoint.InterfaceName(), "PNIO-Supervisor");
}
 
TEST_F(RpcTests, EPMEndpointInterfaceNamePnioParameterServer)
{
  EPMEndpoint endpoint;
  endpoint.interfaceUuid = "dea00004-6c97-11d1-8271-00a02442df7d";
 
  EXPECT_EQ(endpoint.InterfaceName(), "PNIO-ParameterServer");
}
 
TEST_F(RpcTests, EPMEndpointInterfaceNameEpm)
{
  EPMEndpoint endpoint;
  endpoint.interfaceUuid = UUID_EPM_V4;
 
  EXPECT_EQ(endpoint.InterfaceName(), "EPM");
}
 
TEST_F(RpcTests, EPMEndpointInterfaceNameUnknown)
{
  EPMEndpoint endpoint;
  endpoint.interfaceUuid = "11111111-2222-3333-4444-555555555555";
 
  EXPECT_EQ(endpoint.InterfaceName(), "Unknown(11111111-2222-3333-4444-555555555555)");
}
 
TEST_F(RpcTests, EPMEndpointInterfaceNameIsCaseInsensitiveForAllKnownInterfaces)
{
  const std::array<std::pair<std::string_view, std::string_view>, 6> cases = {{{UUID_PNIO_DEVICE, "PNIO-Device"}, {UUID_PNIO_CONTROLLER, "PNIO-Controller"}, {UUID_PNIO_SUPERVISOR, "PNIO-Supervisor"}, {UUID_PNIO_PARAMETER_SERVER, "PNIO-ParameterServer"}, {UUID_EPM_V4, "EPM"}, {"DEA00006-6C97-11D1-8271-00A02442DF7D", "Unknown(DEA00006-6C97-11D1-8271-00A02442DF7D)"}}};
 
  for (const auto& [uuid, expected] : cases)
  {
    EPMEndpoint endpoint;
    endpoint.interfaceUuid = uuid;
 
    EXPECT_EQ(endpoint.InterfaceName(), expected);
  }
}
 
TEST_F(RpcTests, ParseEpmTowerRejectsTooShortTower)
{
  EXPECT_FALSE(ParseEpmTower({}).has_value());
  EXPECT_FALSE(ParseEpmTower({0x01, 0x00, 0x00}).has_value());
}
 
TEST_F(RpcTests, ParseEpmTowerStopsOnTruncatedFloorHeader)
{
  const Bytes tower = {0x01, 0x00, 0x01};
 
  EXPECT_FALSE(ParseEpmTower(tower).has_value());
}
 
TEST_F(RpcTests, ParseEpmTowerStopsOnTruncatedLhs)
{
  const Bytes tower = {0x01, 0x00, 0x05, 0x00, 0x0D, 0x01};
 
  EXPECT_FALSE(ParseEpmTower(tower).has_value());
}
 
TEST_F(RpcTests, ParseEpmTowerStopsOnTruncatedRhsLength)
{
  const Bytes tower = {0x01, 0x00, 0x01, 0x00, 0x0A};
 
  EXPECT_FALSE(ParseEpmTower(tower).has_value());
}
 
TEST_F(RpcTests, ParseEpmTowerStopsOnTruncatedRhs)
{
  const Bytes tower = {0x01, 0x00, 0x01, 0x00, 0x0A, 0x04, 0x00, 0x01};
 
  EXPECT_FALSE(ParseEpmTower(tower).has_value());
}
TEST_F(RpcTests, ParseEpmTowerSkipsEmptyLhs)
{
  const Bytes interfaceFloor = MakeEpmTowerFloor(
      MakeInterfaceTowerLhs(UUID_PNIO_DEVICE, 3),
      MakeInterfaceTowerRhs(7));
 
  const Bytes emptyFloor = MakeEpmTowerFloor({}, {});
 
  const Bytes tower = MakeEpmTower({
      interfaceFloor,
      emptyFloor,
  });
 
  const auto result = ParseEpmTower(tower);
 
  ASSERT_TRUE(result.has_value());
 
  EXPECT_EQ(result->interfaceUuid, UUID_PNIO_DEVICE);
  EXPECT_EQ(result->interfaceVersionMajor, 3);
  EXPECT_EQ(result->interfaceVersionMinor, 7);
}
 
TEST_F(RpcTests, MakeInterfaceTowerLhsCreatesValidInterfaceBlock)
{
  const Bytes lhs = MakeInterfaceTowerLhs(UUID_PNIO_DEVICE, 3);
 
  ASSERT_EQ(lhs.size(), 19U);
 
  EXPECT_EQ(lhs[0], 0x0D);
 
  const std::array<std::uint8_t, uuidLenght> uuidBytes = StringToUuidBytes(UUID_PNIO_DEVICE);
 
  EXPECT_TRUE(std::equal(uuidBytes.begin(), uuidBytes.end(), lhs.begin() + 1));
 
  EXPECT_EQ(lhs[17], 0x03);
  EXPECT_EQ(lhs[18], 0x00);
}
 
TEST_F(RpcTests, ParseEpmTowerParsesInterfaceFloor)
{
  const Bytes interfaceFloor =
      MakeEpmTowerFloor(
          MakeInterfaceTowerLhs(UUID_PNIO_DEVICE, 3),
          MakeInterfaceTowerRhs(7));
 
  const Bytes tower =
      MakeEpmTower({interfaceFloor});
 
  const auto result =
      ParseEpmTower(tower);
 
  ASSERT_TRUE(result.has_value());
 
  EXPECT_EQ(result->interfaceUuid, UUID_PNIO_DEVICE);
  EXPECT_EQ(result->interfaceVersionMajor, 3);
  EXPECT_EQ(result->interfaceVersionMinor, 7);
}
TEST_F(RpcTests, ParseEpmTowerSkipsEmptyFloor)
{
  const Bytes emptyFloor = MakeEpmTowerFloor({}, {});
 
  ASSERT_EQ(emptyFloor, (Bytes{0x00, 0x00, 0x00, 0x00}));
}
 
TEST_F(RpcTests, MakeEpmTowerEncodesEmptyThenInterfaceFloor)
{
  const Bytes emptyFloor = MakeEpmTowerFloor({}, {});
 
  const Bytes interfaceFloor = MakeEpmTowerFloor(
      MakeInterfaceTowerLhs(UUID_PNIO_DEVICE, 3),
      MakeInterfaceTowerRhs(7));
 
  const Bytes tower = MakeEpmTower({emptyFloor, interfaceFloor});
 
  ASSERT_GE(tower.size(), 6U);
 
  EXPECT_EQ(tower[0], 0x02);
  EXPECT_EQ(tower[1], 0x00);
 
  EXPECT_EQ(tower[2], 0x00);
  EXPECT_EQ(tower[3], 0x00);
  EXPECT_EQ(tower[4], 0x00);
  EXPECT_EQ(tower[5], 0x00);
 
  EXPECT_EQ(tower[6], 0x13);
  EXPECT_EQ(tower[7], 0x00);
}
 
TEST_F(RpcTests, ParseEpmTowerParsesInterfaceUuidAndVersions)
{
  const Bytes tower = MakeEpmTower({
      MakeEpmTowerFloor(MakeInterfaceTowerLhs(UUID_PNIO_DEVICE, 0x1234), MakeInterfaceTowerRhs(0x5678)),
  });
 
  const auto result = ParseEpmTower(tower);
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(result->interfaceUuid, UUID_PNIO_DEVICE);
  EXPECT_EQ(result->interfaceVersionMajor, 0x1234);
  EXPECT_EQ(result->interfaceVersionMinor, 0x5678);
}
 
TEST_F(RpcTests, ParseEpmTowerInterfaceFloorWithoutMinorVersion)
{
  const Bytes tower = MakeEpmTower({
      MakeEpmTowerFloor(MakeInterfaceTowerLhs(UUID_PNIO_DEVICE, 5), {0x01}),
  });
 
  const auto result = ParseEpmTower(tower);
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(result->interfaceUuid, UUID_PNIO_DEVICE);
  EXPECT_EQ(result->interfaceVersionMajor, 5);
  EXPECT_EQ(result->interfaceVersionMinor, 0);
}
 
TEST_F(RpcTests, ParseEpmTowerRejectsShortInterfaceFloor)
{
  const Bytes tower = MakeEpmTower({
      MakeEpmTowerFloor({0x0D, 0x01, 0x02}, {}),
  });
 
  EXPECT_FALSE(ParseEpmTower(tower).has_value());
}
 
TEST_F(RpcTests, ParseEpmTowerParsesUdpProtocol)
{
  const Bytes interfaceFloor = MakeEpmTowerFloor(MakeInterfaceTowerLhs(UUID_PNIO_DEVICE, 1), {});
 
  const Bytes udpFloor = MakeEpmTowerFloor({0x0A}, {});
 
  const Bytes tower = MakeEpmTower({interfaceFloor, udpFloor});
 
  const auto result = ParseEpmTower(tower);
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(result->protocol, "ncadg_ip_udp");
}
 
TEST_F(RpcTests, ParseEpmTowerParsesBigEndianPort)
{
  const Bytes interfaceFloor = MakeEpmTowerFloor(MakeInterfaceTowerLhs(UUID_PNIO_DEVICE, 1), {});
 
  const Bytes portFloor = MakeEpmTowerFloor({0x08}, {0x12, 0x34});
 
  const Bytes tower = MakeEpmTower({interfaceFloor, portFloor});
 
  const auto result = ParseEpmTower(tower);
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(result->port, 0x1234);
}
 
TEST_F(RpcTests, ParseEpmTowerIgnoresShortPortRhs)
{
  const Bytes interfaceFloor = MakeEpmTowerFloor(MakeInterfaceTowerLhs(UUID_PNIO_DEVICE, 1), {});
 
  const Bytes portFloor = MakeEpmTowerFloor({0x08}, {0x12});
 
  const Bytes tower = MakeEpmTower({interfaceFloor, portFloor});
 
  const auto result = ParseEpmTower(tower);
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(result->port, 0);
}
 
TEST_F(RpcTests, ParseEpmTowerParsesIpv4Address)
{
  const Bytes interfaceFloor = MakeEpmTowerFloor(MakeInterfaceTowerLhs(UUID_PNIO_DEVICE, 1), {});
 
  const Bytes ipFloor = MakeEpmTowerFloor({0x09}, {192, 168, 10, 25});
 
  const Bytes tower = MakeEpmTower({interfaceFloor, ipFloor});
 
  const auto result = ParseEpmTower(tower);
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(result->ipAddress, "192.168.10.25");
}
 
TEST_F(RpcTests, ParseEpmTowerIgnoresShortIpRhs)
{
  const Bytes interfaceFloor = MakeEpmTowerFloor(MakeInterfaceTowerLhs(UUID_PNIO_DEVICE, 1), {});
 
  const Bytes ipFloor = MakeEpmTowerFloor({0x09}, {192, 168, 10});
 
  const Bytes tower = MakeEpmTower({interfaceFloor, ipFloor});
 
  const auto result = ParseEpmTower(tower);
 
  ASSERT_TRUE(result.has_value());
  EXPECT_TRUE(result->ipAddress.empty());
}
 
TEST_F(RpcTests, ParseEpmTowerParsesCompleteEndpoint)
{
  const Bytes tower = MakeCompleteEpmTower(UUID_PNIO_CONTROLLER, 3, 7, 0x8894, {10, 250, 21, 110});
 
  const auto result = ParseEpmTower(tower);
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(result->interfaceUuid, UUID_PNIO_CONTROLLER);
  EXPECT_EQ(result->interfaceVersionMajor, 3);
  EXPECT_EQ(result->interfaceVersionMinor, 7);
  EXPECT_EQ(result->protocol, "ncadg_ip_udp");
  EXPECT_EQ(result->port, 0x8894);
  EXPECT_EQ(result->ipAddress, "10.250.21.110");
}
 
TEST_F(RpcTests, ParseEpmTowerOnlyUsesFirstInterfaceFloorForInterfaceData)
{
  const Bytes firstInterface = MakeEpmTowerFloor(MakeInterfaceTowerLhs(UUID_PNIO_DEVICE, 1), MakeInterfaceTowerRhs(2));
 
  const Bytes secondInterface = MakeEpmTowerFloor(MakeInterfaceTowerLhs(UUID_PNIO_CONTROLLER, 3), MakeInterfaceTowerRhs(4));
 
  const Bytes tower = MakeEpmTower({firstInterface, secondInterface});
 
  const auto result = ParseEpmTower(tower);
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(result->interfaceUuid, UUID_PNIO_DEVICE);
  EXPECT_EQ(result->interfaceVersionMajor, 1);
  EXPECT_EQ(result->interfaceVersionMinor, 2);
}
 
TEST_F(RpcTests, ParseEpmTowerIgnoresInterfaceDataFromLaterFloor)
{
  const Bytes firstFloor = MakeEpmTowerFloor({0x0A}, {});
  const Bytes secondFloor = MakeEpmTowerFloor(MakeInterfaceTowerLhs(UUID_PNIO_DEVICE, 1), MakeInterfaceTowerRhs(2));
 
  const Bytes tower = MakeEpmTower({firstFloor, secondFloor});
 
  const auto result = ParseEpmTower(tower);
 
  EXPECT_FALSE(result.has_value());
}
TEST_F(RpcTests, ParseEpmTowerIgnoresUnknownProtocol)
{
  const Bytes interfaceFloor = MakeEpmTowerFloor(MakeInterfaceTowerLhs(UUID_PNIO_DEVICE, 1), {});
 
  const Bytes unknownFloor = MakeEpmTowerFloor({0xFE}, {0x01, 0x02, 0x03});
 
  const Bytes tower = MakeEpmTower({interfaceFloor, unknownFloor});
 
  const auto result = ParseEpmTower(tower);
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(result->interfaceUuid, UUID_PNIO_DEVICE);
  EXPECT_TRUE(result->protocol.empty());
  EXPECT_EQ(result->port, 0);
  EXPECT_TRUE(result->ipAddress.empty());
}
TEST_F(RpcTests, ParseEpmTowerContinuesAcrossAllFloors)
{
  const auto result = ParseEpmTower(
      MakeCompleteEpmTower(
          UUID_PNIO_DEVICE,
          1,
          2,
          0x8894,
          {192, 168, 1, 20}));
 
  ASSERT_TRUE(result.has_value());
 
  EXPECT_EQ(result->protocol, "ncadg_ip_udp");
  EXPECT_EQ(result->port, 0x8894);
  EXPECT_EQ(result->ipAddress, "192.168.1.20");
}
 
TEST_F(RpcTests, EpmLookupReturnsParsedEndpoint)
{
  asio::io_context serverIo;
  asio::ip::udp::socket server(serverIo, asio::ip::udp::endpoint(asio::ip::udp::v4(), 0));
 
  const std::uint16_t serverPort = server.local_endpoint().port();
 
  const auto objectUuid = StringToUuidBytes("01234567-89ab-cdef-0123-456789abcdef");
 
  const Bytes tower = MakeCompleteEpmTower(UUID_PNIO_DEVICE, 3, 7, 0x8894, {10, 250, 21, 110});
 
  const Bytes body = MakeEpmLookupBody(objectUuid, "AUMA-SGx", tower);
 
  const Bytes response = MakeEpmResponse(body);
 
  // 80-byte RPC header:
 
  // 0..3     version/type/flags
  // 4..7     data representation
  // 8..23    object UUID
  // 24..39   interface UUID
  // 40..55   activity UUID
 
  // 56..59   server_boot_time
  // 60..63   interface_version
  // 64..67   sequence_number
  // 68..69   operation_number
  // 70..71   interface_hint
  // 72..73   activity_hint
  // 74..75   length_of_body
  // 76..77   fragment_number
  // 78       authentication_protocol
  // 79       serial_low
 
  std::thread serverThread([&server, &response, this]()
  {
    Bytes request;
    ReplyToEpmLookup(server, response, request);
 
    ASSERT_GE(request.size(), PNRPCHeader::kFixedSize);
    EXPECT_EQ(request[0], 4);
    EXPECT_EQ(request[1], PNRPCHeader::REQUEST);
    EXPECT_EQ(request[2], 0x20);
    wire::Reader r(request);
    r.SkipTo(56);
 
    // server_boot_time
    EXPECT_EQ(r.U32LittleEndian(), 0U);
 
    // interface_version
    EXPECT_EQ(r.U32LittleEndian(), 3U);
 
    // sequence_number
    EXPECT_EQ(r.U32LittleEndian(), 0U);
 
    // operation_number
    EXPECT_EQ(r.U16LittleEndian(), EPM_LOOKUP);
  });
 
  const auto results = conn->EpmLookup("127.0.0.1", serverPort, 1.0);
 
  serverThread.join();
 
  ASSERT_EQ(results.size(), 1U);
 
  EXPECT_EQ(results[0].objectUuid, "01234567-89ab-cdef-0123-456789abcdef");
  EXPECT_EQ(results[0].interfaceUuid, UUID_PNIO_DEVICE);
  EXPECT_EQ(results[0].interfaceVersionMajor, 3);
  EXPECT_EQ(results[0].interfaceVersionMinor, 7);
  EXPECT_EQ(results[0].protocol, "ncadg_ip_udp");
  EXPECT_EQ(results[0].port, 0x8894);
  EXPECT_EQ(results[0].ipAddress, "10.250.21.110");
  EXPECT_EQ(results[0].annotation, "AUMA-SGx");
}
 
TEST_F(RpcTests, EpmLookupBuildsInterfaceFilteredRequest)
{
  asio::io_context serverIo;
  asio::ip::udp::socket server(serverIo, asio::ip::udp::endpoint(asio::ip::udp::v4(), 0));
 
  const std::uint16_t serverPort = server.local_endpoint().port();
 
  const Bytes responseBody = {
      0x00,
      0x00,
      0x00,
      0x00,
      0x00,
      0x00,
      0x00,
      0x00,
      0x00,
      0x00,
      0x00,
      0x00,
  };
 
  const Bytes response = MakeEpmResponse(responseBody);
 
  Bytes request;
 
  std::jthread serverThread([&server, &response, &request, this]()
  {
    ReplyToEpmLookup(server, response, request);
  });
 
  EXPECT_NO_THROW(conn->EpmLookup("127.0.0.1", serverPort, 1.0, UUID_PNIO_DEVICE));
 
  serverThread.join();
 
  ASSERT_GE(request.size(), PNRPCHeader::kFixedSize + 4U + 16U + 4U);
 
  const std::size_t bodyOffset = PNRPCHeader::kFixedSize;
  wire::Reader r(request);
  r.SkipTo(bodyOffset);
 
  EXPECT_EQ(r.U32LittleEndian(), EPM_INQUIRY_INTERFACE);
 
  const auto expectedUuid = StringToUuidBytes(UUID_PNIO_DEVICE);
 
  EXPECT_TRUE(std::equal(expectedUuid.begin(), expectedUuid.end(), request.begin() + bodyOffset + 4));
  r.SkipTo(bodyOffset + 20);
  EXPECT_EQ(r.U16LittleEndian(), 1);
  r.SkipTo(bodyOffset + 22);
  EXPECT_EQ(r.U16LittleEndian(), 0);
}
TEST_F(RpcTests, EpmLookupReturnsEmptyForShortResponse)
{
  asio::io_context serverIo;
  asio::ip::udp::socket server(serverIo, asio::ip::udp::endpoint(asio::ip::udp::v4(), 0));
 
  const Bytes response = {0x04, 0x02};
 
  Bytes request;
 
  std::jthread serverThread([&server, &response, &request, this]()
  {
    ReplyToEpmLookup(server, response, request);
  });
 
  const auto results = conn->EpmLookup("127.0.0.1", server.local_endpoint().port(), 1.0);
 
  serverThread.join();
 
  EXPECT_TRUE(results.empty());
}
 
TEST_F(RpcTests, EpmLookupReturnsEmptyForFaultResponse)
{
  asio::io_context serverIo;
  asio::ip::udp::socket server(serverIo, asio::ip::udp::endpoint(asio::ip::udp::v4(), 0));
 
  Bytes response(PNRPCHeader::kFixedSize, 0);
  response[0] = 4;
  response[1] = 0x03;
 
  Bytes request;
 
  std::jthread serverThread([&server, &response, &request, this]()
  {
    ReplyToEpmLookup(server, response, request);
  });
 
  const auto results = conn->EpmLookup("127.0.0.1", server.local_endpoint().port(), 1.0);
 
  serverThread.join();
 
  EXPECT_TRUE(results.empty());
}
 
TEST_F(RpcTests, EpmLookupReturnsEmptyForUnexpectedResponseType)
{
  asio::io_context serverIo;
  asio::ip::udp::socket server(serverIo, asio::ip::udp::endpoint(asio::ip::udp::v4(), 0));
 
  Bytes response(PNRPCHeader::kFixedSize, 0);
  response[0] = 4;
  response[1] = 0x07;
 
  Bytes request;
 
  std::jthread serverThread([&server, &response, &request, this]()
  {
    ReplyToEpmLookup(server, response, request);
  });
 
  const auto results = conn->EpmLookup("127.0.0.1", server.local_endpoint().port(), 1.0);
 
  serverThread.join();
 
  EXPECT_TRUE(results.empty());
}
TEST_F(RpcTests, EpmLookupReturnsEmptyForShortBody)
{
  asio::io_context serverIo;
  asio::ip::udp::socket server(serverIo, asio::ip::udp::endpoint(asio::ip::udp::v4(), 0));
 
  const Bytes response = MakeEpmResponse({0x00, 0x00, 0x00, 0x00});
 
  Bytes request;
 
  std::jthread serverThread([&server, &response, &request, this]()
  {
    ReplyToEpmLookup(server, response, request);
  });
 
  const auto results = conn->EpmLookup("127.0.0.1", server.local_endpoint().port(), 1.0);
 
  serverThread.join();
 
  EXPECT_TRUE(results.empty());
}
 
TEST_F(RpcTests, EpmLookupClampsBodyLengthToReceivedData)
{
  asio::io_context serverIo;
  asio::ip::udp::socket server(serverIo, asio::ip::udp::endpoint(asio::ip::udp::v4(), 0));
 
  Bytes response = MakeEpmResponse({
      0x00,
      0x00,
      0x00,
      0x00,
      0x01,
      0x00,
      0x00,
      0x00,
      0x00,
      0x00,
      0x00,
      0x00,
  });
 
  ASSERT_EQ(response.size(), PNRPCHeader::kFixedSize + 12U);
  wire::PutLittleEndian<std::uint16_t>(response, 0xFFFF);
 
  // The previous append is intentionally not at offset 74, so patch the
  // existing body-length bytes directly.
  response[74] = 0xFF;
  response[75] = 0xFF;
 
  Bytes request;
 
  std::jthread serverThread([&server, &response, &request, this]()
  {
    ReplyToEpmLookup(server, response, request);
  });
 
  const auto results = conn->EpmLookup("127.0.0.1", server.local_endpoint().port(), 1.0);
 
  serverThread.join();
 
  EXPECT_TRUE(results.empty());
}
TEST_F(RpcTests, EpmLookupStopsOnTruncatedEntryUuid)
{
  asio::io_context serverIo;
  asio::ip::udp::socket server(serverIo, asio::ip::udp::endpoint(asio::ip::udp::v4(), 0));
 
  Bytes body;
  wire::PutLittleEndian<std::uint32_t>(body, 0);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
  wire::PutLittleEndian<std::uint32_t>(body, 0);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
  body.insert(body.end(), 5, 0x00);
 
  const Bytes response = MakeEpmResponse(body);
  Bytes request;
 
  std::jthread serverThread([&server, &response, &request, this]()
  {
    ReplyToEpmLookup(server, response, request);
  });
 
  const auto results = conn->EpmLookup("127.0.0.1", server.local_endpoint().port(), 1.0);
 
  serverThread.join();
 
  EXPECT_TRUE(results.empty());
}
 
TEST_F(RpcTests, EpmLookupStopsOnTruncatedTowerPointer)
{
  asio::io_context serverIo;
  asio::ip::udp::socket server(serverIo, asio::ip::udp::endpoint(asio::ip::udp::v4(), 0));
 
  Bytes body;
  wire::PutLittleEndian<std::uint32_t>(body, 0);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
  wire::PutLittleEndian<std::uint32_t>(body, 0);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
  body.insert(body.end(), uuidLenght, 0x00);
  body.push_back(0x00);
 
  const Bytes response = MakeEpmResponse(body);
  Bytes request;
 
  std::jthread serverThread([&server, &response, &request, this]()
  {
    ReplyToEpmLookup(server, response, request);
  });
 
  const auto results = conn->EpmLookup("127.0.0.1", server.local_endpoint().port(), 1.0);
 
  serverThread.join();
 
  EXPECT_TRUE(results.empty());
}
 
TEST_F(RpcTests, EpmLookupStopsOnTruncatedAnnotationLength)
{
  asio::io_context serverIo;
  asio::ip::udp::socket server(serverIo, asio::ip::udp::endpoint(asio::ip::udp::v4(), 0));
 
  Bytes body;
  wire::PutLittleEndian<std::uint32_t>(body, 0);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
  wire::PutLittleEndian<std::uint32_t>(body, 0);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
  body.insert(body.end(), uuidLenght, 0x00);
  wire::PutLittleEndian<std::uint32_t>(body, 0);
  body.push_back(0x00);
 
  const Bytes response = MakeEpmResponse(body);
  Bytes request;
 
  std::jthread serverThread([&server, &response, &request, this]()
  {
    ReplyToEpmLookup(server, response, request);
  });
 
  const auto results = conn->EpmLookup("127.0.0.1", server.local_endpoint().port(), 1.0);
 
  serverThread.join();
 
  EXPECT_TRUE(results.empty());
}
 
TEST_F(RpcTests, EpmLookupHandlesZeroLengthAnnotation)
{
  asio::io_context serverIo;
  asio::ip::udp::socket server(serverIo, asio::ip::udp::endpoint(asio::ip::udp::v4(), 0));
 
  const auto objectUuid = StringToUuidBytes("01234567-89ab-cdef-0123-456789abcdef");
 
  const Bytes tower = MakeCompleteEpmTower(UUID_PNIO_DEVICE, 1, 2, 0x8894, {192, 168, 1, 10});
 
  Bytes body;
  wire::PutLittleEndian<std::uint32_t>(body, 0);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
  wire::PutLittleEndian<std::uint32_t>(body, 0);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
 
  body.insert(body.end(), objectUuid.begin(), objectUuid.end());
 
  wire::PutLittleEndian<std::uint32_t>(body, 0);
  wire::PutLittleEndian<std::uint32_t>(body, 0);
 
  while ((body.size() & 3U) != 0U)
  {
    body.push_back(0);
  }
 
  wire::PutLittleEndian<std::uint32_t>(body, static_cast<std::uint32_t>(tower.size()));
  body.insert(body.end(), tower.begin(), tower.end());
 
  while ((body.size() & 3U) != 0U)
  {
    body.push_back(0);
  }
 
  const Bytes response = MakeEpmResponse(body);
  Bytes request;
 
  std::jthread serverThread([&server, &response, &request, this]()
  {
    ReplyToEpmLookup(server, response, request);
  });
 
  const auto results = conn->EpmLookup("127.0.0.1", server.local_endpoint().port(), 1.0);
 
  serverThread.join();
 
  ASSERT_EQ(results.size(), 1U);
  EXPECT_TRUE(results[0].annotation.empty());
}
 
TEST_F(RpcTests, EpmLookupTrimsTrailingAnnotationZeros)
{
  asio::io_context serverIo;
  asio::ip::udp::socket server(serverIo, asio::ip::udp::endpoint(asio::ip::udp::v4(), 0));
 
  const auto objectUuid = StringToUuidBytes("11111111-2222-3333-4444-555555555555");
 
  const Bytes tower = MakeCompleteEpmTower(UUID_PNIO_DEVICE, 1, 1, 0x8894, {10, 0, 0, 1});
 
  Bytes body;
  wire::PutLittleEndian<std::uint32_t>(body, 0);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
  wire::PutLittleEndian<std::uint32_t>(body, 0);
  wire::PutLittleEndian<std::uint32_t>(body, 1);
 
  body.insert(body.end(), objectUuid.begin(), objectUuid.end());
 
  wire::PutLittleEndian<std::uint32_t>(body, 0);
 
  const Bytes annotation = {'A', 'B', 'C', 0, 0, 0};
 
  wire::PutLittleEndian<std::uint32_t>(body, static_cast<std::uint32_t>(annotation.size()));
 
  body.insert(body.end(), annotation.begin(), annotation.end());
 
  while ((body.size() & 3U) != 0U)
  {
    body.push_back(0);
  }
 
  wire::PutLittleEndian<std::uint32_t>(body, static_cast<std::uint32_t>(tower.size()));
 
  body.insert(body.end(), tower.begin(), tower.end());
 
  while ((body.size() & 3U) != 0U)
  {
    body.push_back(0);
  }
 
  const Bytes response = MakeEpmResponse(body);
  Bytes request;
 
  std::jthread serverThread([&server, &response, &request, this]()
  {
    ReplyToEpmLookup(server, response, request);
  });
 
  const auto results = conn->EpmLookup("127.0.0.1", server.local_endpoint().port(), 1.0);
 
  serverThread.join();
 
  ASSERT_EQ(results.size(), 1U);
  EXPECT_EQ(results[0].annotation, "ABC");
}
 
TEST_F(RpcTests, EpmLookupIgnoresEntryWithInvalidTower)
{
  asio::io_context serverIo;
  asio::ip::udp::socket server(serverIo, asio::ip::udp::endpoint(asio::ip::udp::v4(), 0));
 
  const auto objectUuid = StringToUuidBytes("01234567-89ab-cdef-0123-456789abcdef");
 
  const Bytes invalidTower = MakeEpmTower({
      MakeEpmTowerFloor({0x0A}, {}),
  });
 
  const Bytes body = MakeEpmLookupBody(objectUuid, "invalid", invalidTower);
 
  const Bytes response = MakeEpmResponse(body);
  Bytes request;
 
  std::jthread serverThread([&server, &response, &request, this]()
  {
    ReplyToEpmLookup(server, response, request);
  });
 
  const auto results = conn->EpmLookup("127.0.0.1", server.local_endpoint().port(), 1.0);
 
  serverThread.join();
 
  EXPECT_TRUE(results.empty());
}
 
TEST_F(RpcTests, GetStationInfoReturnsFirstDirectResponse)
{
  using testing::_;
  using testing::InSequence;
  using testing::Return;
  using testing::StrictMock;
 
  StrictMock<MockRawEthernetSocket> sock;
 
  const MacAddress src = String2Mac("08:00:27:31:39:dc");
 
  const MacAddress deviceMac = String2Mac("a0:d3:85:00:f6:13");
 
  const std::string stationName = "valve2";
 
  const Bytes response = MakeStationNameResponse(deviceMac, src, stationName);
 
  {
    InSequence sequence;
 
    EXPECT_CALL(sock, Send(_))
        .Times(1);
 
    EXPECT_CALL(sock, SetTimeout(_))
        .Times(1);
 
    EXPECT_CALL(sock, Recv())
        .WillOnce(Return(response))
        .WillRepeatedly(Return(Bytes{}));
  }
 
  const auto result = GetStationInfo(sock, src, stationName, 1);
 
  EXPECT_EQ(result.mac, "a0:d3:85:00:f6:13");
  EXPECT_EQ(result.name, stationName);
}
TEST_F(RpcTests, GetStationInfoSendsStationNameRequest)
{
  using testing::_;
  using testing::Return;
  using testing::StrictMock;
 
  StrictMock<MockRawEthernetSocket> sock;
 
  const MacAddress src = String2Mac("08:00:27:31:39:dc");
 
  const MacAddress deviceMac = String2Mac("a0:d3:85:00:f6:13");
 
  const std::string stationName = "valve2";
 
  const Bytes response = MakeStationNameResponse(deviceMac, src, stationName);
 
  Bytes transmitted;
 
  EXPECT_CALL(sock, Send(_))
      .WillOnce([&transmitted](const std::vector<std::uint8_t>& frame)
  {
    transmitted = frame;
  });
 
  EXPECT_CALL(sock, SetTimeout(_))
      .Times(1);
 
  EXPECT_CALL(sock, Recv())
      .WillOnce(Return(response))
      .WillRepeatedly(Return(Bytes{}));
 
  const auto result = GetStationInfo(sock, src, stationName, 1);
 
  ASSERT_FALSE(transmitted.empty());
 
  EXPECT_EQ(result.name, stationName);
 
  EthernetHeader eth = EthernetHeader::Parse(transmitted);
 
  EXPECT_EQ(eth.dst, String2Mac(dcp::DCP_MULTICAST_MAC));
 
  EXPECT_EQ(eth.src, src);
  EXPECT_EQ(eth.type, PROFINET_ETHERTYPE);
 
  const PNDCPHeader dcpHeader = PNDCPHeader::Parse(eth.payload);
 
  EXPECT_EQ(dcpHeader.serviceId, DcpServiceId::Identify);
}
 
TEST_F(RpcTests, GetStationInfoFallsBackToDiscovery)
{
  using testing::_;
  using testing::InSequence;
  using testing::Return;
  using testing::StrictMock;
 
  StrictMock<MockRawEthernetSocket> sock;
 
  const MacAddress src = String2Mac("08:00:27:31:39:dc");
 
  const MacAddress deviceMac = String2Mac("a0:d3:85:00:f6:13");
 
  const std::string stationName = "valve2";
 
  const Bytes response = MakeStationNameResponse(deviceMac, src, stationName);
 
  EXPECT_CALL(sock, Send(_))
      .Times(2);
 
  EXPECT_CALL(sock, SetTimeout(_))
      .Times(2);
 
  EXPECT_CALL(sock, Recv())
      .WillOnce(Return(Bytes{}))
      .WillOnce(Return(response))
      .WillRepeatedly(Return(Bytes{}));
 
  const auto result = GetStationInfo(sock, src, stationName, 0.01);
 
  EXPECT_EQ(result.mac, "a0:d3:85:00:f6:13");
  EXPECT_EQ(result.name, stationName);
}
TEST_F(RpcTests, GetStationInfoDiscoveryMatchesStationNameCaseInsensitive)
{
  using testing::_;
  using testing::InSequence;
  using testing::Return;
  using testing::StrictMock;
 
  StrictMock<MockRawEthernetSocket> sock;
 
  const MacAddress src = String2Mac("08:00:27:31:39:dc");
 
  const MacAddress deviceMac = String2Mac("a0:d3:85:00:f6:13");
 
  const Bytes response = MakeStationNameResponse(deviceMac, src, "VaLvE2");
 
  EXPECT_CALL(sock, Send(_))
      .Times(2);
 
  EXPECT_CALL(sock, SetTimeout(_))
      .Times(2);
 
  EXPECT_CALL(sock, Recv())
      .WillOnce(Return(Bytes{}))
      .WillOnce(Return(response))
      .WillRepeatedly(Return(Bytes{}));
 
  const auto result = GetStationInfo(sock, src, "vAlVe2", 0.01);
 
  EXPECT_EQ(result.mac, "a0:d3:85:00:f6:13");
  EXPECT_EQ(result.name, "VaLvE2");
}
TEST_F(RpcTests, GetStationInfoDiscoverySkipsNonMatchingDevice)
{
  using testing::_;
  using testing::InSequence;
  using testing::Return;
  using testing::StrictMock;
 
  StrictMock<MockRawEthernetSocket> sock;
 
  const MacAddress src = String2Mac("08:00:27:31:39:dc");
 
  const MacAddress firstMac = String2Mac("a0:d3:85:00:f6:13");
 
  const MacAddress secondMac = String2Mac("a0:d3:85:00:f6:14");
 
  // This requires a single response containing multiple DCP devices.
  // Build that using the normal IdentifyResponse block construction used by
  // the DCP tests in this repository.
  const Bytes discoveryResponse = MakeStationNameResponse(secondMac, src, "valve2");
 
  EXPECT_CALL(sock, Send(_))
      .Times(2);
 
  EXPECT_CALL(sock, SetTimeout(_))
      .Times(2);
 
  EXPECT_CALL(sock, Recv())
      .WillOnce(Return(Bytes{}))
      .WillOnce(Return(discoveryResponse))
      .WillRepeatedly(Return(Bytes{}));
 
  const auto result = GetStationInfo(sock, src, "VALVE2", 0.01);
 
  EXPECT_EQ(result.mac, "a0:d3:85:00:f6:14");
}
TEST_F(RpcTests, GetStationInfoThrowsWhenDiscoveryFindsNoMatchingDevice)
{
  using testing::_;
  using testing::InSequence;
  using testing::Return;
  using testing::StrictMock;
 
  StrictMock<MockRawEthernetSocket> sock;
 
  const MacAddress src = String2Mac("08:00:27:31:39:dc");
 
  const MacAddress deviceMac = String2Mac("a0:d3:85:00:f6:13");
 
  const Bytes response = MakeStationNameResponse(deviceMac, src, "different-device");
 
  EXPECT_CALL(sock, Send(_))
      .Times(2);
 
  EXPECT_CALL(sock, SetTimeout(_))
      .Times(2);
 
  EXPECT_CALL(sock, Recv())
      .WillOnce(Return(Bytes{}))
      .WillOnce(Return(response))
      .WillRepeatedly(Return(Bytes{}));
 
  EXPECT_THROW(GetStationInfo(sock, src, "valve2", 0.01), DCPDeviceNotFoundError);
}
TEST_F(RpcTests, GetStationInfoNotFoundExceptionContainsStationName)
{
  using testing::_;
  using testing::InSequence;
  using testing::Return;
  using testing::StrictMock;
 
  StrictMock<MockRawEthernetSocket> sock;
 
  const MacAddress src = String2Mac("08:00:27:31:39:dc");
 
  const MacAddress deviceMac = String2Mac("a0:d3:85:00:f6:13");
 
  const Bytes response = MakeStationNameResponse(deviceMac, src, "different-device");
 
  EXPECT_CALL(sock, Send(_))
      .Times(2);
 
  EXPECT_CALL(sock, SetTimeout(_))
      .Times(2);
 
  EXPECT_CALL(sock, Recv())
      .WillOnce(Return(Bytes{}))
      .WillOnce(Return(response))
      .WillRepeatedly(Return(Bytes{}));
  EXPECT_THROW(GetStationInfo(sock, src, "Valve2", 0.01), DCPDeviceNotFoundError);
}
TEST_F(RpcTests, GetStationInfoThrowsWhenDiscoveryReturnsNoResponses)
{
  using testing::_;
  using testing::InSequence;
  using testing::Return;
  using testing::StrictMock;
 
  StrictMock<MockRawEthernetSocket> sock;
 
  const MacAddress src = String2Mac("08:00:27:31:39:dc");
 
  EXPECT_CALL(sock, Send(_))
      .Times(2);
 
  EXPECT_CALL(sock, SetTimeout(_))
      .Times(2);
 
  EXPECT_CALL(sock, Recv())
      .WillOnce(Return(Bytes{}))
      .WillOnce(Return(Bytes{}))
      .WillRepeatedly(Return(Bytes{}));
 
  EXPECT_THROW(GetStationInfo(sock, src, "valve2", 0.01), DCPDeviceNotFoundError);
}
TEST_F(RpcTests, GetStationInfoDoesNotFilterNonEmptyDirectResponse)
{
  using testing::_;
  using testing::InSequence;
  using testing::Return;
  using testing::StrictMock;
 
  StrictMock<MockRawEthernetSocket> sock;
 
  const MacAddress src = String2Mac("08:00:27:31:39:dc");
 
  const MacAddress deviceMac = String2Mac("a0:d3:85:00:f6:13");
 
  const Bytes response = MakeStationNameResponse(deviceMac, src, "some-other-device");
 
  {
    InSequence sequence;
 
    EXPECT_CALL(sock, Send(_))
        .Times(1);
 
    EXPECT_CALL(sock, SetTimeout(_))
        .Times(1);
 
    EXPECT_CALL(sock, Recv())
        .WillOnce(Return(response))
        .WillRepeatedly(Return(Bytes{}));
  }
 
  const auto result = GetStationInfo(sock, src, "valve2", 0.01);
 
  EXPECT_EQ(result.name, "some-other-device");
}
 
TEST_F(RpcTests, CreateNrdBuildsExpectedWrapper)
{
  const Bytes payload = {
      0x01,
      0x02,
      0x03,
      0x04,
  };
 
  const PNNRDData result = InvokeCreateNrd(payload);
 
  EXPECT_EQ(result.argsMaximumStatus, 1500U);
  EXPECT_EQ(result.argsLength, payload.size());
  EXPECT_EQ(result.maximumCount, 1500U);
  EXPECT_EQ(result.offset, 0U);
  EXPECT_EQ(result.actualCount, payload.size());
  EXPECT_EQ(result.payload, payload);
}
 
TEST_F(RpcTests, CreateNrdHandlesEmptyPayload)
{
  const PNNRDData result = InvokeCreateNrd({});
 
  EXPECT_EQ(result.argsMaximumStatus, 1500U);
  EXPECT_EQ(result.argsLength, 0U);
  EXPECT_EQ(result.maximumCount, 1500U);
  EXPECT_EQ(result.offset, 0U);
  EXPECT_EQ(result.actualCount, 0U);
  EXPECT_TRUE(result.payload.empty());
}
 
TEST_F(RpcTests, CreateNrdRoundTripsThroughSerialization)
{
  const Bytes payload = {
      0x10,
      0x20,
      0x30,
      0x40,
      0x50,
  };
 
  const PNNRDData original = InvokeCreateNrd(payload);
 
  const PNNRDData parsed = PNNRDData::Parse(original.ToBytes());
 
  EXPECT_EQ(parsed.argsMaximumStatus, original.argsMaximumStatus);
  EXPECT_EQ(parsed.argsLength, original.argsLength);
  EXPECT_EQ(parsed.maximumCount, original.maximumCount);
  EXPECT_EQ(parsed.offset, original.offset);
  EXPECT_EQ(parsed.actualCount, original.actualCount);
  EXPECT_EQ(parsed.payload, original.payload);
}
TEST_F(RpcTests, BuildAlarmCrBlockUsesProfinetEtherTypeForTransportZero)
{
  const Bytes bytes = InvokeBuildAlarmCrBlock(0, 0);
 
  ASSERT_EQ(bytes.size(), PNAlarmCRBlockReq::kSize);
 
  const PNAlarmCRBlockReq block = PNAlarmCRBlockReq::Parse(bytes);
 
  EXPECT_EQ(block.alarmCrType, 0x0001);
  EXPECT_EQ(block.etherTypeLT, PROFINET_ETHERTYPE);
  EXPECT_EQ(block.alarmCrProperties, 0U);
  EXPECT_EQ(block.localAlarmReference, conn->LocalAlarmRef());
  EXPECT_EQ(block.rtaTimeoutFactor, PNAlarmCRBlockReq::DEFAULT_RTA_TIMEOUT_FACTOR);
  EXPECT_EQ(block.rtaRetries, PNAlarmCRBlockReq::DEFAULT_RTA_RETRIES);
  EXPECT_EQ(block.maxAlarmDataLength, PNAlarmCRBlockReq::DEFAULT_MAX_ALARM_DATA_LENGTH);
  EXPECT_EQ(block.alarmCrTagHeaderHigh, PNAlarmCRBlockReq::DEFAULT_TAG_HEADER_HIGH);
  EXPECT_EQ(block.alarmCrTagHeaderLow, PNAlarmCRBlockReq::DEFAULT_TAG_HEADER_LOW);
}
 
TEST_F(RpcTests, BuildAlarmCrBlockUsesIpEtherTypeForNonZeroTransport)
{
  const Bytes bytes = InvokeBuildAlarmCrBlock(1, 0);
 
  const PNAlarmCRBlockReq block = PNAlarmCRBlockReq::Parse(bytes);
 
  EXPECT_EQ(block.etherTypeLT, IP_ETHERTYPE);
  EXPECT_EQ(block.alarmCrProperties, 2U);
}
 
TEST_F(RpcTests, BuildAlarmCrBlockEncodesPriority)
{
  const Bytes bytes = InvokeBuildAlarmCrBlock(0, 1);
 
  const PNAlarmCRBlockReq block = PNAlarmCRBlockReq::Parse(bytes);
 
  EXPECT_EQ(block.etherTypeLT, PROFINET_ETHERTYPE);
  EXPECT_EQ(block.alarmCrProperties, 1U);
}
 
TEST_F(RpcTests, BuildAlarmCrBlockCombinesTransportAndPriority)
{
  const Bytes bytes = InvokeBuildAlarmCrBlock(1, 1);
 
  const PNAlarmCRBlockReq block = PNAlarmCRBlockReq::Parse(bytes);
  EXPECT_EQ(block.etherTypeLT, IP_ETHERTYPE);
  EXPECT_EQ(block.alarmCrProperties, 3U);
}
 
TEST_F(RpcTests, BuildAlarmCrBlockCreatesExpectedBlockHeader)
{
  const Bytes bytes = InvokeBuildAlarmCrBlock(0, 0);
 
  const PNBlockHeader header = PNBlockHeader::Parse(bytes);
 
  EXPECT_EQ(header.blockType, PNAlarmCRBlockReq::BLOCK_TYPE);
  EXPECT_EQ(header.blockLength, PNAlarmCRBlockReq::kSize - 4);
  EXPECT_EQ(header.blockVersionHigh, 0x01);
  EXPECT_EQ(header.blockVersionLow, 0x00);
}
TEST_F(RpcTests, ParseAlarmCrResponseReturnsMinusOneForEmptyData)
{
  EXPECT_EQ(InvokeParseAlarmCrResponse({}), -1);
}
TEST_F(RpcTests, ParseAlarmCrResponseReturnsMinusOneForShortData)
{
  const Bytes data = {
      0x01,
      0x02,
      0x03,
  };
 
  EXPECT_EQ(InvokeParseAlarmCrResponse(data), -1);
}
TEST_F(RpcTests, ParseAlarmCrResponseIgnoresUnrelatedBlock)
{
  const Bytes data = MakeBlockHeader(static_cast<BlockType>(0x9999), 0);
 
  EXPECT_EQ(InvokeParseAlarmCrResponse(data), -1);
}
TEST_F(RpcTests, ParseAlarmCrResponseReturnsLocalAlarmReference)
{
  constexpr std::uint16_t expectedAlarmReference = 0x1234;
 
  const Bytes data = MakeAlarmCrResponseBlock(expectedAlarmReference);
 
  EXPECT_EQ(InvokeParseAlarmCrResponse(data), static_cast<int>(expectedAlarmReference));
}
TEST_F(RpcTests, ParseAlarmCrResponseContinuesAfterUnrelatedBlock)
{
  constexpr std::uint16_t expectedAlarmReference = 0x4321;
 
  Bytes data = MakeBlockHeader(static_cast<BlockType>(0x9999), 2);
 
  const Bytes alarmBlock = MakeAlarmCrResponseBlock(expectedAlarmReference);
 
  data.insert(data.end(), alarmBlock.begin(), alarmBlock.end());
 
  EXPECT_EQ(InvokeParseAlarmCrResponse(data), static_cast<int>(expectedAlarmReference));
}
TEST_F(RpcTests, ParseAlarmCrResponseContinuesAfterMalformedAlarmBlock)
{
  Bytes malformed = MakeAlarmCrResponseBlock(0x1234);
 
  ASSERT_GT(malformed.size(), blockHeaderLength);
 
  malformed.resize(blockHeaderLength);
 
  const int result = InvokeParseAlarmCrResponse(malformed);
 
  EXPECT_EQ(result, -1);
}
TEST_F(RpcTests, ParseAlarmCrResponseIgnoresTruncatedAlarmBlock)
{
  Bytes malformed = MakeAlarmCrResponseBlock(0x1234);
 
  malformed[2] = 0xFF;
  malformed[3] = 0xFF;
 
  EXPECT_EQ(InvokeParseAlarmCrResponse(malformed), -1);
}
TEST_F(RpcTests, ParseAlarmCrResponseContinuesAfterMalformedBlock)
{
  Bytes malformed = MakeAlarmCrResponseBlock(0x1111);
 
  malformed[2] = 0xFF;
  malformed[3] = 0xFF;
 
  // The malformed block's declared length must not consume the valid block,  // so construct the malformed header separately with a zero-sized actual
  // block followed by a valid block.
  malformed.resize(blockHeaderLength);
 
  PNBlockHeader malformedHeader;
  malformedHeader.blockType = BlockType::AlarmCrResponse;
  malformedHeader.blockLength = 0xFFFF;
  malformedHeader.blockVersionHigh = 0x01;
  malformedHeader.blockVersionLow = 0x00;
 
  const Bytes malformedHeaderBytes = malformedHeader.ToBytes();
 
  const Bytes validBlock = MakeAlarmCrResponseBlock(0x5678);
 
  Bytes data = malformedHeaderBytes;
  data.insert(data.end(), validBlock.begin(), validBlock.end());
 
  const int result = InvokeParseAlarmCrResponse(data);
 
  // Current parser uses the declared block length to advance its offset, so
  // this malformed block consumes the remainder of the input.
  EXPECT_EQ(result, -1);
}
TEST_F(RpcTests, ParseAlarmCrResponseReturnsMinusOneAfterUnrelatedBlocks)
{
  Bytes data = MakeBlockHeader(static_cast<BlockType>(0x1000), 0);
 
  const Bytes second = MakeBlockHeader(static_cast<BlockType>(0x2000), 0);
 
  const Bytes third = MakeBlockHeader(static_cast<BlockType>(0x3000), 0);
 
  data.insert(data.end(), second.begin(), second.end());
 
  data.insert(data.end(), third.begin(), third.end());
 
  EXPECT_EQ(InvokeParseAlarmCrResponse(data), -1);
}
 
TEST_F(RpcTests, IsConnectedReturnsFalseInitially)
{
  EXPECT_FALSE(conn->IsConnected());
}
 
TEST_F(RpcTests, InfoReturnsDeviceDescription)
{
  const auto& info = conn->Info();
 
  EXPECT_EQ(info.name, "test-device");
}
 
TEST_F(RpcTests, ArUuidReturnsConnectionArUuid)
{
  const auto& uuid = conn->ArUuid();
 
  EXPECT_EQ(uuid.size(), uuidLenght);
}
 
TEST_F(RpcTests, SessionKeyReturnsInitialValue)
{
  EXPECT_NE(conn->SessionKey(), 0U);
}
 
TEST_F(RpcTests, LocalAlarmRefReturnsConfiguredValue)
{
  EXPECT_EQ(conn->LocalAlarmRef(), conn->LocalAlarmRef());
}
 
TEST_F(RpcTests, DeviceAlarmRefReturnsZeroInitially)
{
  EXPECT_EQ(conn->DeviceAlarmRef(), 0);
}
 
TEST_F(RpcTests, HasAlarmCrReturnsFalseInitially)
{
  EXPECT_FALSE(conn->HasAlarmCr());
}
 
TEST_F(RpcTests, ParseIocrResponseReturnsZeroForEmptyData)
{
  EXPECT_EQ(InvokeParseIocrResponse({}, 1), 0);
}
 
TEST_F(RpcTests, ParseIocrResponseReturnsZeroForShortData)
{
  const Bytes data = {0x81, 0x02, 0x00};
 
  EXPECT_EQ(InvokeParseIocrResponse(data, 1), 0);
}
 
TEST_F(RpcTests, ParseIocrResponseIgnoresUnrelatedBlock)
{
  Bytes data = MakeBlockHeader(static_cast<BlockType>(0x9999), 2);
 
  EXPECT_EQ(InvokeParseIocrResponse(data, 1), 0);
}
 
TEST_F(RpcTests, ParseIocrResponseIgnoresDifferentIocrType)
{
  const Bytes data = MakeIocrResponseBlock(2, 7, 0x1234);
 
  EXPECT_EQ(InvokeParseIocrResponse(data, 1), 0);
}
 
TEST_F(RpcTests, ParseIocrResponseReturnsMatchingFrameId)
{
  const Bytes data = MakeIocrResponseBlock(1, 7, 0x8001);
 
  EXPECT_EQ(InvokeParseIocrResponse(data, 1), 0x8001);
}
 
TEST_F(RpcTests, ParseIocrResponseIgnoresMalformedIocrBlock)
{
  Bytes malformed = MakeBlockHeader(static_cast<BlockType>(PNIOCRBlockRes::BLOCK_TYPE), PNIOCRBlockRes::kSize - 4);
 
  ASSERT_EQ(malformed.size(), blockHeaderLength);
 
  EXPECT_EQ(InvokeParseIocrResponse(malformed, 1), 0);
}
 
TEST_F(RpcTests, ParseIocrResponseFindsMatchingBlockAfterUnrelatedBlock)
{
  Bytes data = MakeBlockHeader(static_cast<BlockType>(0x9999), 2);
 
  const Bytes iocr = MakeIocrResponseBlock(2, 9, 0x8123);
  data.insert(data.end(), iocr.begin(), iocr.end());
 
  EXPECT_EQ(InvokeParseIocrResponse(data, 2), 0x8123);
}
TEST_F(RpcTests, SendReceiveReturnsResponseAndMarksConnectionLive)
{
  transport = std::make_unique<TestRpcTransport>();
  rawTransport = transport.get();
 
  const Bytes payload = {0x10, 0x20, 0x30};
  rawTransport->responses.push_back(MakeRpcResponseBytes(PNRPCHeader::RESPONSE, PNRPCHeader::READ, payload));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  PNRPCHeader request;
  request.packetType = PNRPCHeader::REQUEST;
  request.operationNumber = PNRPCHeader::READ;
 
  const PNRPCHeader response = InvokeSendReceive(request);
 
  EXPECT_EQ(response.packetType, PNRPCHeader::RESPONSE);
  EXPECT_EQ(response.operationNumber, PNRPCHeader::READ);
  EXPECT_EQ(response.payload, payload);
  EXPECT_TRUE(conn->IsConnected());
  EXPECT_EQ(rawTransport->receivedRequests.size(), 1U);
}
 
TEST_F(RpcTests, SendReceiveRetriesAfterRequestPacket)
{
  transport = std::make_unique<TestRpcTransport>();
  rawTransport = transport.get();
 
  rawTransport->responses.push_back(MakeRpcResponseBytes(PNRPCHeader::REQUEST, PNRPCHeader::READ));
 
  rawTransport->responses.push_back(MakeRpcResponseBytes(PNRPCHeader::RESPONSE, PNRPCHeader::READ));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  PNRPCHeader request;
  request.operationNumber = PNRPCHeader::READ;
 
  const PNRPCHeader response = InvokeSendReceive(request);
 
  EXPECT_EQ(response.packetType, PNRPCHeader::RESPONSE);
  EXPECT_EQ(rawTransport->receivedRequests.size(), 2U);
}
 
TEST_F(RpcTests, SendReceiveThrowsForShortResponse)
{
  transport = std::make_unique<TestRpcTransport>();
  transport->responses.emplace_back(10, 0);
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  PNRPCHeader request;
 
  EXPECT_THROW(InvokeSendReceive(request), RPCError);
}
 
TEST_F(RpcTests, SendReceiveThrowsRpcFaultError)
{
  transport = std::make_unique<TestRpcTransport>();
  transport->responses.push_back(MakeRpcResponseBytes(PNRPCHeader::FAULT, PNRPCHeader::READ));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  PNRPCHeader request;
  request.operationNumber = PNRPCHeader::READ;
 
  EXPECT_THROW(InvokeSendReceive(request), RPCFaultError);
}
 
TEST_F(RpcTests, SendReceiveThrowsForRejectedResponse)
{
  transport = std::make_unique<TestRpcTransport>();
  transport->responses.push_back(MakeRpcResponseBytes(PNRPCHeader::REJECT, PNRPCHeader::READ));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  PNRPCHeader request;
 
  EXPECT_THROW(InvokeSendReceive(request), RPCError);
}
 
TEST_F(RpcTests, SendReceiveThrowsForUnexpectedPacketType)
{
  transport = std::make_unique<TestRpcTransport>();
  transport->responses.push_back(MakeRpcResponseBytes(0x99, PNRPCHeader::READ));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  PNRPCHeader request;
 
  try
  {
    InvokeSendReceive(request);
    FAIL() << "Expected RPCError";
  }
  catch (const RPCError& e)
  {
    EXPECT_NE(std::string(e.what()).find("Unexpected RPC packet type"), std::string::npos);
  }
}
TEST_F(RpcTests, CheckTimeoutDoesNothingWhenNotConnected)
{
  InvokeSetRPCConLive(false);
 
  EXPECT_FALSE(conn->IsConnected());
}
 
TEST_F(RpcTests, CheckTimeoutDoesNotReconnectBeforeTimeout)
{
  InvokeSetRPCConLive(true);
  InvokeSetRPCConSrcMac("02:00:00:00:00:01");
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
  InvokeRPCConCheckTimeout();
 
  EXPECT_TRUE(InvokeGetRPCConLive());
  EXPECT_TRUE(rawTransport->receivedRequests.empty());
}
 
TEST_F(RpcTests, CheckTimeoutReconnectsAfterTimeout)
{
  transport = std::make_unique<TestRpcTransport>();
  rawTransport = transport.get();
 
  rawTransport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::CONNECT));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConSrcMac("02:00:00:00:00:01");
  auto timePoint = std::chrono::steady_clock::now() -
                   std::chrono::duration_cast<std::chrono::steady_clock::duration>(std::chrono::duration<double>(CONNECTION_TIMEOUT + 1.0));
 
  InvokeSetRPCConLiveMonotonic(timePoint);
  InvokeRPCConCheckTimeout();
 
  EXPECT_TRUE(InvokeGetRPCConLive());
  EXPECT_EQ(rawTransport->receivedRequests.size(), 1U);
}
 
TEST_F(RpcTests, ConnectRequiresSourceMacForInitialConnection)
{
  EXPECT_THROW(conn->Connect(), std::invalid_argument);
}
 
TEST_F(RpcTests, ConnectEstablishesBasicApplicationRelation)
{
  transport = std::make_unique<TestRpcTransport>();
  rawTransport = transport.get();
 
  rawTransport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::CONNECT));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  const MacAddress mac = String2Mac("02:00:00:00:00:01");
 
  const auto result = conn->Connect(mac);
 
  EXPECT_FALSE(result.has_value());
  EXPECT_TRUE(conn->IsConnected());
  EXPECT_EQ(conn->LocalAlarmRef(), 0x8001);
  EXPECT_FALSE(conn->HasAlarmCr());
  EXPECT_EQ(rawTransport->receivedRequests.size(), 1U);
}
 
TEST_F(RpcTests, ConnectRequestsAlarmCr)
{
  transport = std::make_unique<TestRpcTransport>();
 
  const Bytes alarm = MakeAlarmCrResponseBlock(0x4321);
 
  Bytes responsePayload = alarm;
 
  transport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::CONNECT, responsePayload));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  const auto result = conn->Connect(String2Mac("02:00:00:00:00:01"), true);
 
  EXPECT_FALSE(result.has_value());
  EXPECT_TRUE(conn->IsConnected());
  EXPECT_TRUE(conn->HasAlarmCr());
  EXPECT_EQ(conn->DeviceAlarmRef(), 0x4321);
}
 
TEST_F(RpcTests, ConnectLeavesAlarmCrDisabledWhenResponseHasNoAlarmCr)
{
  transport = std::make_unique<TestRpcTransport>();
  transport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::CONNECT));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  const auto result = conn->Connect(String2Mac("02:00:00:00:00:01"), true);
 
  EXPECT_FALSE(result.has_value());
  EXPECT_FALSE(conn->HasAlarmCr());
  EXPECT_EQ(conn->DeviceAlarmRef(), -1);
}
 
TEST_F(RpcTests, ConnectConvertsDevicePnioError)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(MakeRpcResponseBytes(PNRPCHeader::RESPONSE, PNRPCHeader::CONNECT, MakePnioErrorNrdResponse(0x00000001)));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  EXPECT_THROW(conn->Connect(String2Mac("02:00:00:00:00:01")), RPCConnectionError);
}
 
TEST_F(RpcTests, ConnectConvertsRpcError)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responseHandler = [](const Bytes&) -> Bytes
  {
    throw RPCError("transport failure");
  };
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  EXPECT_THROW(conn->Connect(String2Mac("02:00:00:00:00:01")), RPCConnectionError);
}
 
TEST_F(RpcTests, ConnectReusesSourceMacDuringReconnect)
{
  transport = std::make_unique<TestRpcTransport>();
  transport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::CONNECT));
  transport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::CONNECT));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  const MacAddress mac = String2Mac("02:00:00:00:00:01");
 
  ASSERT_NO_THROW(conn->Connect(mac));
 
  InvokeSetRPCConLive(true);
 
  EXPECT_NO_THROW(conn->Connect());
}
 
TEST_F(RpcTests, ConnectReplacesSourceMacDuringReconnect)
{
  transport = std::make_unique<TestRpcTransport>();
  transport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::CONNECT));
  transport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::CONNECT));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  const MacAddress initialMac = String2Mac("02:00:00:00:00:01");
 
  const MacAddress replacementMac = String2Mac("02:00:00:00:00:02");
 
  ASSERT_NO_THROW(conn->Connect(initialMac));
 
  auto rpcConMac = InvokeGetRPCConSrcMac();
  ASSERT_TRUE(rpcConMac.has_value());
 
  ASSERT_NO_THROW(conn->Connect(replacementMac));
 
  rpcConMac = InvokeGetRPCConSrcMac();
  EXPECT_EQ(rpcConMac.value(), replacementMac);
}
 
TEST_F(RpcTests, ConnectRejectsMissingSourceMacDuringReconnect)
{
  conn = MakeTestTransportRpcConnection(std::make_unique<TestRpcTransport>());
 
  InvokeSetRPCConLive(true);
  InvokeGetRPCConSrcMac().reset();
 
  EXPECT_THROW(conn->Connect(), std::invalid_argument);
}
TEST_F(RpcTests, ConnectReturnsConnectResultForIocrSetup)
{
  transport = std::make_unique<TestRpcTransport>();
 
  Bytes responsePayload = MakeIocrResponseBlock(1, 1, 0x8001);
 
  const Bytes outputIocr = MakeIocrResponseBlock(2, 2, 0x8002);
 
  responsePayload.insert(responsePayload.end(), outputIocr.begin(), outputIocr.end());
 
  const Bytes alarm = MakeAlarmCrResponseBlock(0x4321);
 
  responsePayload.insert(responsePayload.end(), alarm.begin(), alarm.end());
 
  transport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::CONNECT, responsePayload));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  IOCRSetup setup;
  setup.slots.push_back({
      .slot = 1,
      .subslot = 1,
      .inputLength = 4,
      .outputLength = 4,
      .moduleIdent = 0x42,
      .submoduleIdent = 0x99,
  });
 
  const auto result = conn->Connect(String2Mac("02:00:00:00:00:01"), false, setup);
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(result->inputFrameId, 0x8001);
  EXPECT_EQ(result->outputFrameId, 0x8002);
  EXPECT_EQ(result->deviceAlarmRef, 0x4321);
  EXPECT_TRUE(conn->HasAlarmCr());
}
TEST_F(RpcTests, ReadReturnsParsedIodResponse)
{
  constexpr std::uint16_t index = 0xAFF0;
  const Bytes record = {0x11, 0x22, 0x33};
 
  transport = std::make_unique<TestRpcTransport>();
  rawTransport = transport.get();
 
  transport->responses.push_back(
      MakeNrdRpcResponseBytes(
          PNRPCHeader::READ,
          MakeIodResponsePayload(7, 3, 4, index, record)));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const PNIODHeader result = conn->Read(7, 3, 4, index);
 
  EXPECT_EQ(result.api, 7U);
  EXPECT_EQ(result.slot, 3U);
  EXPECT_EQ(result.subslot, 4U);
  EXPECT_EQ(result.index, index);
  EXPECT_EQ(result.payload, record);
  EXPECT_EQ(rawTransport->receivedRequests.size(), 1U);
}
 
TEST_F(RpcTests, ReadThrowsPnioErrorForDeviceError)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(MakeRpcResponseBytes(PNRPCHeader::RESPONSE, PNRPCHeader::READ, MakePnioErrorNrdResponse(1)));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  EXPECT_THROW(conn->Read(0, 0, 1, 0xAFF0), PNIOError);
}
TEST_F(RpcTests, ReadImplicitReturnsParsedIodResponse)
{
  constexpr std::uint16_t index = 0xAFF0;
  const Bytes record = {0xAA, 0xBB};
 
  transport = std::make_unique<TestRpcTransport>();
  rawTransport = transport.get();
 
  transport->responses.push_back(MakeNrdRpcResponseBytes(
      PNRPCHeader::IMPLICIT_READ,
      MakeIodResponsePayload(0, 0, 1, index, record)));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  const PNIODHeader result = conn->ReadImplicit(0, 0, 1, index);
 
  EXPECT_EQ(result.index, index);
  EXPECT_EQ(result.payload, record);
  EXPECT_EQ(rawTransport->receivedRequests.size(), 1U);
}
 
TEST_F(RpcTests, ReadImplicitThrowsPnioErrorForDeviceError)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(MakeRpcResponseBytes(PNRPCHeader::RESPONSE, PNRPCHeader::IMPLICIT_READ, MakePnioErrorNrdResponse(1)));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  EXPECT_THROW(conn->ReadImplicit(0, 0, 1, 0xAFF0), PNIOError);
}
TEST_F(RpcTests, WriteCompletesSuccessfully)
{
  transport = std::make_unique<TestRpcTransport>();
  rawTransport = transport.get();
 
  transport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::WRITE));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  EXPECT_NO_THROW(conn->Write(1, 2, 3., 0xAFF1, {0x10, 0x20, 0x30}));
 
  EXPECT_EQ(rawTransport->receivedRequests.size(), 1U);
}
 
TEST_F(RpcTests, WriteThrowsPnioErrorForDeviceError)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(MakeRpcResponseBytes(PNRPCHeader::RESPONSE, PNRPCHeader::WRITE, MakePnioErrorNrdResponse(1)));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  EXPECT_THROW(conn->Write(0, 0, 1, 0xAFF1, {0x01}), PNIOError);
}
TEST_F(RpcTests, ReadRawReturnsPayload)
{
  constexpr std::uint16_t index = 0xAFF0;
  const Bytes payload = {0x01, 0x02, 0x03};
 
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(MakeNrdRpcResponseBytes(
      PNRPCHeader::READ,
      MakeIodResponsePayload(0, 0, 1, index, payload)));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  EXPECT_EQ(conn->ReadRaw(index, 2, 3), payload);
}
TEST_F(RpcTests, ReadImWrappersReadAllIndividualIndices)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responseHandler = [this](const Bytes& request) -> Bytes
  {
    const PNRPCHeader rpcRequest = PNRPCHeader::Parse(request);
 
    const PNNRDData nrd = PNNRDData::Parse(rpcRequest.payload);
 
    const PNIODHeader iod = PNIODHeader::Parse(nrd.payload);
 
    return MakeNrdRpcResponseBytes(
        rpcRequest.operationNumber,
        MakeIodResponsePayload(0, 0, 1, iod.index,
                               MakeImPayload(iod.index)));
  };
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  EXPECT_NO_THROW(conn->ReadIm0());
  EXPECT_NO_THROW(conn->ReadIm1());
  EXPECT_NO_THROW(conn->ReadIm2());
  EXPECT_NO_THROW(conn->ReadIm3());
  EXPECT_NO_THROW(conn->ReadIm4());
  EXPECT_NO_THROW(conn->ReadIm5());
  EXPECT_NO_THROW(conn->ReadIm6());
  EXPECT_NO_THROW(conn->ReadIm7());
  EXPECT_NO_THROW(conn->ReadIm8());
  EXPECT_NO_THROW(conn->ReadIm9());
  EXPECT_NO_THROW(conn->ReadIm10());
  EXPECT_NO_THROW(conn->ReadIm11());
  EXPECT_NO_THROW(conn->ReadIm12());
  EXPECT_NO_THROW(conn->ReadIm13());
  EXPECT_NO_THROW(conn->ReadIm14());
  EXPECT_NO_THROW(conn->ReadIm15());
}
TEST_F(RpcTests, ReadAllImReturnsAllSuccessfulRecords)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responseHandler = [this](const Bytes& request) -> Bytes
  {
    const PNRPCHeader rpcRequest = PNRPCHeader::Parse(request);
 
    const PNNRDData nrd = PNNRDData::Parse(rpcRequest.payload);
 
    const PNIODHeader iod = PNIODHeader::Parse(nrd.payload);
 
    return MakeNrdRpcResponseBytes(
        rpcRequest.operationNumber,
        MakeIodResponsePayload(0, 0, 1, iod.index,
                               MakeImPayload(iod.index)));
  };
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const AllIM result = conn->ReadAllIm();
 
  EXPECT_TRUE(result.im0.has_value());
  EXPECT_TRUE(result.im1.has_value());
  EXPECT_TRUE(result.im2.has_value());
  EXPECT_TRUE(result.im3.has_value());
  EXPECT_TRUE(result.im4.has_value());
  EXPECT_TRUE(result.im5.has_value());
  EXPECT_TRUE(result.im6.has_value());
  EXPECT_TRUE(result.im7.has_value());
  EXPECT_TRUE(result.im8.has_value());
  EXPECT_TRUE(result.im9.has_value());
  EXPECT_TRUE(result.im10.has_value());
  EXPECT_TRUE(result.im11.has_value());
  EXPECT_TRUE(result.im12.has_value());
  EXPECT_TRUE(result.im13.has_value());
  EXPECT_TRUE(result.im14.has_value());
  EXPECT_TRUE(result.im15.has_value());
}
 
TEST_F(RpcTests, ReadAllImIgnoresRpcErrorForOptionalRecord)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responseHandler = [this](const Bytes& request) -> Bytes
  {
    const PNRPCHeader rpcRequest = PNRPCHeader::Parse(request);
 
    const PNNRDData nrd = PNNRDData::Parse(rpcRequest.payload);
 
    const PNIODHeader iod = PNIODHeader::Parse(nrd.payload);
 
    if (iod.index == PNInM2::IDX)
    {
      throw RPCError("I&M2 unavailable");
    }
 
    return MakeNrdRpcResponseBytes(
        rpcRequest.operationNumber,
        MakeIodResponsePayload(0, 0, 1, iod.index,
                               MakeImPayload(iod.index)));
  };
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const AllIM result = conn->ReadAllIm();
 
  EXPECT_TRUE(result.im0.has_value());
  EXPECT_TRUE(result.im1.has_value());
  EXPECT_FALSE(result.im2.has_value());
  EXPECT_TRUE(result.im3.has_value());
}
 
TEST_F(RpcTests, ReadAllImIgnoresStandardExceptionForOptionalRecord)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responseHandler = [this](const Bytes& request) -> Bytes
  {
    const PNRPCHeader rpcRequest = PNRPCHeader::Parse(request);
 
    const PNNRDData nrd = PNNRDData::Parse(rpcRequest.payload);
 
    const PNIODHeader iod = PNIODHeader::Parse(nrd.payload);
 
    if (iod.index == PNInM3::IDX)
    {
      return MakeNrdRpcResponseBytes(rpcRequest.operationNumber, {});
    }
 
    return MakeNrdRpcResponseBytes(
        rpcRequest.operationNumber,
        MakeIodResponsePayload(0, 0, 1, iod.index,
                               MakeImPayload(iod.index)));
  };
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const AllIM result = conn->ReadAllIm();
 
  EXPECT_TRUE(result.im0.has_value());
  EXPECT_TRUE(result.im1.has_value());
  EXPECT_FALSE(result.im3.has_value());
  EXPECT_TRUE(result.im4.has_value());
}
 
TEST_F(RpcTests, ReadAllImPropagatesIm0Failure)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responseHandler = [](const Bytes&) -> Bytes
  {
    throw RPCError("I&M0 unavailable");
  };
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  EXPECT_THROW(conn->ReadAllIm(), RPCError);
}
TEST_F(RpcTests, WriteMultipleReturnsEmptyForNoWrites)
{
  transport = std::make_unique<TestRpcTransport>();
  rawTransport = transport.get();
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const auto result = conn->WriteMultiple({});
 
  EXPECT_TRUE(result.empty());
  EXPECT_TRUE(rawTransport->receivedRequests.empty());
}
 
TEST_F(RpcTests, WriteMultipleSendsMultipleWrites)
{
  transport = std::make_unique<TestRpcTransport>();
  rawTransport = transport.get();
 
  transport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::WRITE, MakeWriteMultipleResponsePayload()));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const std::vector<WriteItem> writes = {
      {
          .slot = 1,
          .subslot = 1,
          .index = 0xAFF1,
          .data = {0x10, 0x20},
          .api = 0,
      },
      {
          .slot = 2,
          .subslot = 1,
          .index = 0xAFF2,
          .data = {0x30, 0x40, 0x50},
          .api = 0,
      },
  };
 
  EXPECT_NO_THROW(conn->WriteMultiple(writes));
  EXPECT_EQ(rawTransport->receivedRequests.size(), 1U);
}
 
TEST_F(RpcTests, WriteMultipleThrowsPnioErrorForDeviceError)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(MakeRpcResponseBytes(PNRPCHeader::RESPONSE, PNRPCHeader::WRITE, MakePnioErrorNrdResponse(1)));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  const std::vector<WriteItem> writes = {
      {
          .slot = 1,
          .subslot = 1,
          .index = 0xAFF1,
          .data = {0x10},
          .api = 0,
      },
  };
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
  EXPECT_THROW(conn->WriteMultiple(writes), PNIOError);
}
TEST_F(RpcTests, ReadModuleDiffReturnsParsedModuleDifference)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(MakeNrdRpcResponseBytes(
      PNRPCHeader::READ,
      MakeIodResponsePayload(0, 0, 1, MODULE_DIFF_BLOCK,
                             MakeModuleDiffPayload())));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
  const auto result = conn->ReadModuleDiff();
 
  ASSERT_EQ(result.modules.size(), 1U);
  EXPECT_EQ(result.modules[0].slotNumber, 1U);
}
TEST_F(RpcTests, ReadDiagnosisUsesFullDiagnosisParser)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(MakeNrdRpcResponseBytes(
      PNRPCHeader::READ,
      MakeIodResponsePayload(0, 0, 1, 0xF000,
                             MakeDiagnosisPayload())));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const auto result = conn->ReadDiagnosis(3, 4, 0xF000);
 
  ASSERT_EQ(result.entries.size(), 1U);
  EXPECT_EQ(result.slot, 3U);
  EXPECT_EQ(result.subslot, 4U);
}
 
TEST_F(RpcTests, ReadDiagnosisFallsBackToSimpleParser)
{
  Bytes simple;
 
  wire::PutU16(simple, 0x0010);
  wire::PutU16(simple, 6);
  wire::PutU8(simple, 1);
  wire::PutU8(simple, 0);
 
  // Simple diagnosis data.
  // ChannelNumber(2) + ChannelProperties(2) + ErrorType(2).
  wire::PutU16(simple, 0);
  wire::PutU16(simple, 0);
  wire::PutU16(simple, 9); // -> "Error"
 
  // Zero-filled sentinel.
  wire::PutU16(simple, 0);
  wire::PutU16(simple, 0);
  wire::PutU16(simple, 0);
 
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(
      MakeNrdRpcResponseBytes(
          PNRPCHeader::READ,
          MakeIodResponsePayload(0, 0, 1, 0xF000, simple)));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const auto result = conn->ReadDiagnosis();
 
  ASSERT_EQ(result.entries.size(), 1U);
  EXPECT_EQ(result.entries[0].base.errorTypeName, "Error");
  EXPECT_EQ(result.entries[0].base.errorType, 0x0009);
  EXPECT_EQ(result.entries[0].base.channelNumber, 0U);
}
 
TEST_F(RpcTests, ReadDiagnosisReturnsEmptyForShortDiagnosisPayload)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(MakeNrdRpcResponseBytes(
      PNRPCHeader::READ,
 
      MakeIodResponsePayload(0, 0, 1, 0xF000, {0x01, 0x02, 0x03, 0x04, 0x05, 0x06})));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const auto result = conn->ReadDiagnosis(7, 8, 0xF000);
 
  EXPECT_TRUE(result.entries.empty());
  EXPECT_EQ(result.api, 0U);
  EXPECT_EQ(result.slot, 7U);
  EXPECT_EQ(result.subslot, 8U);
  EXPECT_EQ(result.rawData.size(), 6U);
}
 
TEST_F(RpcTests, ReadDiagnosisReturnsEmptyForRpcError)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responseHandler = [](const Bytes&) -> Bytes
  {
    throw RPCError("diagnosis unavailable");
  };
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const auto result = conn->ReadDiagnosis(2, 3, 0xF000);
 
  EXPECT_TRUE(result.entries.empty());
  EXPECT_EQ(result.api, 0U);
  EXPECT_EQ(result.slot, 2U);
  EXPECT_EQ(result.subslot, 3U);
}
TEST_F(RpcTests, ReadAllDiagnosisReturnsNonEmptyDiagnosisResults)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responseHandler = [this](const Bytes& request) -> Bytes
  {
    const PNRPCHeader rpcRequest = PNRPCHeader::Parse(request);
 
    const PNNRDData nrd = PNNRDData::Parse(rpcRequest.payload);
 
    const PNIODHeader iod = PNIODHeader::Parse(nrd.payload);
 
    if (iod.index == 0x800A)
    {
      return MakeNrdRpcResponseBytes(
          rpcRequest.operationNumber,
          MakeIodResponsePayload(0, 0, 1, iod.index, MakeDiagnosisPayload()));
    }
 
    return MakeNrdRpcResponseBytes(
        rpcRequest.operationNumber,
        MakeIodResponsePayload(0, 0, 1, iod.index, {}));
  };
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const auto result = conn->ReadAllDiagnosis();
 
  ASSERT_EQ(result.size(), 1U);
  EXPECT_TRUE(result.contains(0x800A));
}
 
TEST_F(RpcTests, ReadAllDiagnosisContinuesAfterRpcError)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responseHandler = [this](const Bytes& request) -> Bytes
  {
    const PNRPCHeader rpcRequest = PNRPCHeader::Parse(request);
 
    const PNNRDData nrd = PNNRDData::Parse(rpcRequest.payload);
 
    const PNIODHeader iod = PNIODHeader::Parse(nrd.payload);
 
    if (iod.index == 0x800B)
    {
      throw RPCError("probe failed");
    }
 
    return MakeNrdRpcResponseBytes(
        rpcRequest.operationNumber,
 
        MakeIodResponsePayload(0, 0, 1, iod.index, MakeDiagnosisPayload()));
  };
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  EXPECT_NO_THROW(conn->ReadAllDiagnosis());
}
TEST_F(RpcTests, ReadPdRealDataReturnsParsedData)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(
      MakeNrdRpcResponseBytes(
          PNRPCHeader::READ,
          MakeIodResponsePayload(0, 0, 1, PD_REAL_DATA, {})));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  EXPECT_NO_THROW(conn->ReadPdRealData());
}
TEST_F(RpcTests, ReadRealIdentificationDataReturnsParsedData)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(
      MakeNrdRpcResponseBytes(
          PNRPCHeader::READ,
          MakeIodResponsePayload(0, 0, 1, REAL_ID_API, MakeRealIdentificationPayload())));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const auto result = conn->ReadRealIdentificationData();
 
  ASSERT_EQ(result.slots.size(), 1U);
  EXPECT_EQ(result.slots[0].slot, 1U);
  EXPECT_EQ(result.slots[0].submoduleIdent, 0x99U);
}
TEST_F(RpcTests, DiscoverSlotsReturnsRealIdentificationSlots)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(
      MakeNrdRpcResponseBytes(
          PNRPCHeader::READ,
          MakeIodResponsePayload(0, 0, 1, REAL_ID_API, MakeRealIdentificationPayload())));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const auto result = conn->DiscoverSlots();
 
  ASSERT_EQ(result.size(), 1U);
  EXPECT_EQ(result[0].slot, 1U);
}
TEST_F(RpcTests, DiscoverTopologyReturnsBothTopologyRecords)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(
      MakeNrdRpcResponseBytes(
          PNRPCHeader::READ,
          MakeIodResponsePayload(0, 0, 1, PD_REAL_DATA, {})));
 
  transport->responses.push_back(
      MakeNrdRpcResponseBytes(
          PNRPCHeader::READ,
          MakeIodResponsePayload(0, 0, 1, REAL_ID_API, MakeRealIdentificationPayload())));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const auto [pdReal, realId] = conn->DiscoverTopology();
 
  EXPECT_EQ(pdReal.slots.size(), 0U);
  ASSERT_EQ(realId.slots.size(), 1U);
  EXPECT_EQ(realId.slots[0].slot, 1U);
}
TEST_F(RpcTests, EnumerateIndicesReportsAllProbeOutcomes)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responseHandler = [this](const Bytes& request) -> Bytes
  {
    const PNRPCHeader rpcRequest = PNRPCHeader::Parse(request);
 
    const PNNRDData nrd = PNNRDData::Parse(rpcRequest.payload);
 
    const PNIODHeader iod = PNIODHeader::Parse(nrd.payload);
 
    switch (iod.index)
    {
      case 0x1001:
        return MakeNrdRpcResponseBytes(
            rpcRequest.operationNumber,
            MakeIodResponsePayload(0, 0, 1, iod.index, {0x01, 0x02, 0x03}));
 
      case 0x1002:
        return MakeNrdRpcResponseBytes(
            rpcRequest.operationNumber,
            MakeIodResponsePayload(0, 0, 1, iod.index, {}));
 
      case 0x1003:
        return MakeRpcResponseBytes(
            PNRPCHeader::RESPONSE,
            rpcRequest.operationNumber, MakePnioErrorNrdResponse(1));
 
      case 0x1004:
        throw RPCError("RPC probe failure");
 
      default:
        throw RPCError("unexpected test index");
    }
  };
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const auto result = conn->EnumerateIndices(1, 2, std::vector<std::uint16_t>{0x1001, 0x1002, 0x1003, 0x1004, 0x1001});
 
  ASSERT_EQ(result.size(), 4U);
 
  EXPECT_EQ(result.at(0x1001).status, "readable");
  EXPECT_EQ(result.at(0x1001).size, 3U);
 
  EXPECT_EQ(result.at(0x1002).status, "empty");
  EXPECT_EQ(result.at(0x1002).size, 0U);
 
  EXPECT_EQ(result.at(0x1003).status, "error");
  EXPECT_FALSE(result.at(0x1003).error.empty());
 
  EXPECT_EQ(result.at(0x1004).status, "error");
  EXPECT_EQ(result.at(0x1004).error, "RPC probe failure");
}
TEST_F(RpcTests, SendControlRejectsDisconnectedConnection)
{
  InvokeSetRPCConLive(false);
 
  EXPECT_THROW(InvokeSendControl(static_cast<BlockType>(0x0118), ControlCommand::PrmBegin), RPCError);
}
 
TEST_F(RpcTests, SendControlSendsWithoutWaiting)
{
  InvokeSetRPCConLive(true);
  InvokeSetRPCConArUuid(0x11);
  InvokeSetRPCConSessionKey(0x1234);
 
  const Bytes subBlocks = {0xAA, 0xBB};
 
  const Bytes result = InvokeSendControl(static_cast<BlockType>(BLOCK_PRM_BEGIN_REQ), ControlCommand::PrmBegin, false, subBlocks);
 
  EXPECT_TRUE(result.empty());
  ASSERT_EQ(rawTransport->sentRequests.size(), 1U);
 
  const PNRPCHeader request = PNRPCHeader::Parse(rawTransport->sentRequests.back());
 
  EXPECT_EQ(request.packetType, PNRPCHeader::REQUEST);
  EXPECT_EQ(request.operationNumber, PNRPCHeader::CONTROL);
 
  const PNNRDData nrd = PNNRDData::Parse(request.payload);
 
  EXPECT_GE(nrd.payload.size(), static_cast<std::size_t>(32));
 
  const auto begin = nrd.payload.end() - subBlocks.size();
 
  EXPECT_EQ(Bytes(begin, nrd.payload.end()), subBlocks);
}
 
TEST_F(RpcTests, SendControlReturnsResponsePayload)
{
  transport = std::make_unique<TestRpcTransport>();
 
  const Bytes expectedPayload = {0x10, 0x20, 0x30};
 
  transport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::CONTROL, expectedPayload));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const Bytes result = InvokeSendControl(static_cast<BlockType>(BLOCK_PRM_BEGIN_REQ), ControlCommand::PrmBegin);
 
  EXPECT_EQ(result, expectedPayload);
}
 
TEST_F(RpcTests, SendControlThrowsPnioErrorForDeviceError)
{
  transport = std::make_unique<TestRpcTransport>();
 
  transport->responses.push_back(MakeRpcResponseBytes(PNRPCHeader::RESPONSE, PNRPCHeader::CONTROL, MakePnioErrorNrdResponse(1)));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  EXPECT_THROW(InvokeSendControl(static_cast<BlockType>(BLOCK_PRM_BEGIN_REQ), ControlCommand::PrmBegin), PNIOError);
}
TEST_F(RpcTests, PrmBeginSendsExpectedControlCommand)
{
  transport = std::make_unique<TestRpcTransport>();
  rawTransport = transport.get();
 
  transport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::CONTROL));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  InvokeSetRPCConArUuid(0x11);
  InvokeSetRPCConSessionKey(0x1234);
 
  EXPECT_NO_THROW(conn->PrmBegin());
 
  ASSERT_EQ(rawTransport->receivedRequests.size(), 1U);
 
  const PNRPCHeader request = PNRPCHeader::Parse(rawTransport->receivedRequests.back());
  const PNNRDData nrd = PNNRDData::Parse(request.payload);
  const PNIODReleaseBlock block = PNIODReleaseBlock::Parse(nrd.payload);
 
  EXPECT_EQ(static_cast<std::uint16_t>(block.controlCommand), CONTROL_CMD_PRM_BEGIN);
}
 
TEST_F(RpcTests, PrmEndSendsExpectedControlCommand)
{
  transport = std::make_unique<TestRpcTransport>();
  rawTransport = transport.get();
 
  transport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::CONTROL));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  EXPECT_NO_THROW(conn->PrmEnd());
 
  ASSERT_EQ(rawTransport->receivedRequests.size(), 1U);
 
  const PNRPCHeader request = PNRPCHeader::Parse(rawTransport->receivedRequests.back());
  const PNNRDData nrd = PNNRDData::Parse(request.payload);
  const PNIODReleaseBlock block = PNIODReleaseBlock::Parse(nrd.payload);
 
  EXPECT_EQ(static_cast<std::uint16_t>(block.controlCommand), CONTROL_CMD_PRM_END);
}
 
TEST_F(RpcTests, ReadyForRtClass3SendsExpectedControlCommand)
{
  transport = std::make_unique<TestRpcTransport>();
  rawTransport = transport.get();
 
  transport->responses.push_back(MakeNrdRpcResponseBytes(PNRPCHeader::CONTROL));
 
  conn = MakeTestTransportRpcConnection(std::move(transport));
 
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  EXPECT_NO_THROW(conn->ReadyForRtClass3());
 
  ASSERT_EQ(rawTransport->receivedRequests.size(), 1U);
 
  const PNRPCHeader request = PNRPCHeader::Parse(rawTransport->receivedRequests.back());
  const PNNRDData nrd = PNNRDData::Parse(request.payload);
  const PNIODReleaseBlock block = PNIODReleaseBlock::Parse(nrd.payload);
 
  EXPECT_EQ(static_cast<std::uint16_t>(block.controlCommand), CONTROL_CMD_READY_FOR_RT_CLASS_3);
}
 
TEST_F(RpcTests, ParseRawRpcHeaderRejectsShortData)
{
  const Bytes data(PNRPCHeader::kFixedSize - 1, 0);
 
  const auto result = rpc::raw::ParseRawRpcHeader(data);
 
  EXPECT_FALSE(result.has_value());
}
 
TEST_F(RpcTests, ParseRawRpcHeaderParsesBigEndian)
{
  const Bytes payload = {0xAA, 0xBB, 0xCC};
 
  const Bytes data = MakeRawRpcHeader(
      false,
      PNRPCHeader::REQUEST,
      0x11223344,
      0x55667788,
      0x99AA,
      payload);
 
  const auto result = rpc::raw::ParseRawRpcHeader(data);
 
  ASSERT_TRUE(result.has_value());
 
  EXPECT_EQ(result->version, 0x04);
  EXPECT_EQ(result->packetType, PNRPCHeader::REQUEST);
  EXPECT_EQ(result->flags1, 0x01);
  EXPECT_EQ(result->flags2, 0x02);
 
  EXPECT_EQ(result->drep[0], 0x00);
  EXPECT_EQ(result->drep[1], 0x00);
  EXPECT_EQ(result->drep[2], 0x00);
 
  EXPECT_FALSE(result->isLittleEndian);
 
  EXPECT_EQ(result->interfaceVersion, 0x11223344U);
  EXPECT_EQ(result->sequenceNumber, 0x55667788U);
  EXPECT_EQ(result->operationNumber, 0x99AA);
 
  EXPECT_EQ(result->serialHigh, 0x5A);
  EXPECT_EQ(result->serialLow, 0x00);
  EXPECT_EQ(result->payload, payload);
 
  for (std::size_t i = 0; i < uuidLenght; ++i)
  {
    EXPECT_EQ(result->objectUuid[i], static_cast<std::uint8_t>(0x10 + i));
    EXPECT_EQ(result->interfaceUuid[i], static_cast<std::uint8_t>(0x20 + i));
    EXPECT_EQ(result->activityUuid[i], static_cast<std::uint8_t>(0x30 + i));
  }
}
 
TEST_F(RpcTests, ParseRawRpcHeaderParsesLittleEndian)
{
  const Bytes payload = {0x01, 0x02, 0x03, 0x04};
 
  const Bytes data = MakeRawRpcHeader(true,
                                      PNRPCHeader::RESPONSE,
                                      0x11223344,
                                      0x55667788,
                                      0x99AA,
                                      payload);
 
  const auto result = rpc::raw::ParseRawRpcHeader(data);
 
  ASSERT_TRUE(result.has_value());
 
  EXPECT_EQ(result->packetType, PNRPCHeader::RESPONSE);
  EXPECT_TRUE(result->isLittleEndian);
 
  EXPECT_EQ(result->interfaceVersion, 0x11223344U);
  EXPECT_EQ(result->sequenceNumber, 0x55667788U);
  EXPECT_EQ(result->operationNumber, 0x99AA);
 
  EXPECT_EQ(result->payload, payload);
}
 
TEST_F(RpcTests, ParseRawRpcHeaderPreservesSerialHigh)
{
  Bytes data = MakeRawRpcHeader(false,
                                PNRPCHeader::REQUEST,
                                0x01020304,
                                0x05060708,
                                0x090A,
                                {});
 
  data[7] = 0xAB;
 
  const auto result = rpc::raw::ParseRawRpcHeader(data);
 
  ASSERT_TRUE(result.has_value());
  EXPECT_EQ(result->serialHigh, 0xAB);
}
 
TEST_F(RpcTests, ParseRawRpcHeaderExtractsPayloadAfterFixedHeader)
{
  const Bytes payload = {0xDE, 0xAD, 0xBE, 0xEF};
 
  const Bytes data = MakeRawRpcHeader(false,
                                      PNRPCHeader::REQUEST,
                                      1,
                                      2,
                                      3,
                                      payload);
 
  ASSERT_EQ(data.size(), PNRPCHeader::kFixedSize + payload.size());
 
  const auto result = rpc::raw::ParseRawRpcHeader(data);
 
  ASSERT_TRUE(result.has_value());
 
  EXPECT_EQ(result->payload, payload);
}
 
TEST_F(RpcTests, ApplicationReadyThrowsWhenNotConnected)
{
  InvokeSetRPCConLive(false);
 
  EXPECT_THROW(conn->ApplicationReady(1.0), RPCError);
 
  EXPECT_EQ(rawTransport->receiveCount, 0U);
}
 
TEST_F(RpcTests, ApplicationReadySkipsInvalidRawRpcPacket)
{
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  rawcTransport->QueueIncomingDatagram(Bytes(PNRPCHeader::kFixedSize - 1, 0x00));
 
  rawcTransport->QueueIncomingDatagram(MakeApplicationReadyRequest(false));
 
  const Bytes result = conn->ApplicationReady(1.5);
 
  EXPECT_EQ(rawcTransport->receiveCount, 2U);
  EXPECT_FALSE(result.empty());
  EXPECT_EQ(rawcTransport->sentRequests.size(), 1U);
}
TEST_F(RpcTests, ApplicationReadySkipsNonRequestPacket)
{
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  rawcTransport->QueueIncomingDatagram(MakeRawRpcHeader(false,
                                                        PNRPCHeader::RESPONSE,
                                                        0x11223344,
                                                        0x55667788,
                                                        PNRPCHeader::CONTROL,
                                                        MakeApplicationReadyNrd(
                                                            MakeApplicationReadyControlBlock(),
                                                            false)));
 
  rawcTransport->QueueIncomingDatagram(MakeApplicationReadyRequest(false));
 
  const Bytes result = conn->ApplicationReady(2.0);
 
  EXPECT_FALSE(result.empty());
  EXPECT_EQ(rawcTransport->receiveCount, 2U);
  EXPECT_EQ(rawcTransport->sentRequests.size(), 1U);
}
 
TEST_F(RpcTests, ApplicationReadySkipsNonControlOperation)
{
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const Bytes controlBlock = MakeApplicationReadyControlBlock();
  const Bytes nrd = MakeApplicationReadyNrd(controlBlock, false);
 
  rawcTransport->QueueIncomingDatagram(MakeRawRpcHeader(
      false,
      PNRPCHeader::REQUEST,
      0x11223344,
      0x55667788,
      PNRPCHeader::READ,
      nrd));
 
  rawcTransport->QueueIncomingDatagram(MakeApplicationReadyRequest(false));
 
  const Bytes result = conn->ApplicationReady(3.0);
 
  EXPECT_FALSE(result.empty());
  EXPECT_EQ(rawcTransport->receiveCount, 2U);
  EXPECT_EQ(rawcTransport->sentRequests.size(), 1U);
}
 
TEST_F(RpcTests, ApplicationReadySkipsShortNrdPayload)
{
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const Bytes shortNrd(19, 0x00);
 
  rawcTransport->QueueIncomingDatagram(MakeRawRpcHeader(
      false,
      PNRPCHeader::REQUEST,
      0x11223344,
      0x55667788,
      PNRPCHeader::CONTROL,
      shortNrd));
 
  rawcTransport->QueueIncomingDatagram(MakeApplicationReadyRequest(false));
 
  const Bytes result = conn->ApplicationReady(4.0);
 
  EXPECT_FALSE(result.empty());
  EXPECT_EQ(rawcTransport->receiveCount, 2U);
  EXPECT_EQ(rawcTransport->sentRequests.size(), 1U);
}
TEST_F(RpcTests, ApplicationReadySkipsShortNrdBody)
{
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const Bytes shortNrdBody(31, 0x00);
  const Bytes nrd = MakeApplicationReadyNrd(shortNrdBody, false);
 
  rawcTransport->QueueIncomingDatagram(MakeRawRpcHeader(
      false,
      PNRPCHeader::REQUEST,
      0x11223344,
      0x55667788,
      PNRPCHeader::CONTROL,
      nrd));
 
  rawcTransport->QueueIncomingDatagram(MakeApplicationReadyRequest(false));
 
  const Bytes result = conn->ApplicationReady(5.0);
 
  EXPECT_FALSE(result.empty());
  EXPECT_EQ(rawcTransport->receiveCount, 2U);
  EXPECT_EQ(rawcTransport->sentRequests.size(), 1U);
}
TEST_F(RpcTests, ApplicationReadySkipsWrongControlBlockType)
{
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  constexpr std::uint16_t wrongBlockType = 0x0110;
 
  rawcTransport->QueueIncomingDatagram(MakeApplicationReadyRequest(false, wrongBlockType));
 
  rawcTransport->QueueIncomingDatagram(MakeApplicationReadyRequest(false));
 
  const Bytes result = conn->ApplicationReady(6.0);
 
  EXPECT_FALSE(result.empty());
  EXPECT_EQ(rawcTransport->receiveCount, 2U);
  EXPECT_EQ(rawcTransport->sentRequests.size(), 1U);
}
 
TEST_F(RpcTests, ApplicationReadyProcessesBigEndianRequest)
{
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const auto expectedEndpoint = asio::ip::udp::endpoint(
      asio::ip::make_address("192.168.1.20"),
      0x1234);
 
  rawcTransport->receiveEndpoint = expectedEndpoint;
 
  const Bytes expectedResult = MakeApplicationReadyControlBlock();
 
  rawcTransport->QueueIncomingDatagram(MakeApplicationReadyRequest(false));
 
  const Bytes result = conn->ApplicationReady(7.0);
 
  ASSERT_EQ(result, expectedResult);
  ASSERT_EQ(rawcTransport->sentRequests.size(), 1U);
 
  EXPECT_EQ(rawcTransport->lastSendToEndpoint, expectedEndpoint);
 
  const auto response = raw::ParseRawRpcHeader(rawcTransport->sentRequests.front());
 
  ASSERT_TRUE(response.has_value());
 
  EXPECT_EQ(response->version, 0x04);
  EXPECT_EQ(response->packetType, PNRPCHeader::RESPONSE);
  EXPECT_FALSE(response->isLittleEndian);
  EXPECT_EQ(response->interfaceVersion, 0x11223344U);
  EXPECT_EQ(response->sequenceNumber, 0x55667788U);
  EXPECT_EQ(response->operationNumber, PNRPCHeader::CONTROL);
 
  ASSERT_EQ(response->payload.size(), 20U + PNIODReleaseBlock::kSize);
 
  const Bytes responseNrdBody(response->payload.begin() + 20, response->payload.end());
 
  const PNIODReleaseBlock responseBlock = PNIODReleaseBlock::Parse(responseNrdBody);
 
  EXPECT_EQ(static_cast<std::uint16_t>(responseBlock.blockHeader[0]) << 8 | responseBlock.blockHeader[1],
            BLOCK_IOD_CONTROL_APP_READY_RES);
 
  EXPECT_EQ(responseBlock.controlCommand, ControlCommand::Done);
 
  EXPECT_EQ(responseBlock.sessionKey, conn->SessionKey());
  EXPECT_TRUE(InvokeGetRPCConLive());
}
TEST_F(RpcTests, ApplicationReadyProcessesLittleEndianRequest)
{
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  const auto expectedEndpoint = asio::ip::udp::endpoint(
      asio::ip::make_address("10.0.0.20"),
      0x4321);
 
  rawcTransport->receiveEndpoint = expectedEndpoint;
 
  const Bytes expectedResult = MakeApplicationReadyControlBlock();
 
  rawcTransport->QueueIncomingDatagram(MakeApplicationReadyRequest(true));
 
  const Bytes result = conn->ApplicationReady(8.0);
 
  ASSERT_EQ(result, expectedResult);
  ASSERT_EQ(rawcTransport->sentRequests.size(), 1U);
 
  const auto response = raw::ParseRawRpcHeader(rawcTransport->sentRequests.front());
 
  ASSERT_TRUE(response.has_value());
 
  EXPECT_EQ(response->packetType, PNRPCHeader::RESPONSE);
  // EXPECT_TRUE(response->isLittleEndian); Jaa...  dit moet nog dynamisch op het response Peelen!
  EXPECT_EQ(response->interfaceVersion, 0x11223344U);
  EXPECT_EQ(response->sequenceNumber, 0x55667788U);
  EXPECT_EQ(response->operationNumber, PNRPCHeader::CONTROL);
 
  ASSERT_EQ(response->payload.size(), 20U + PNIODReleaseBlock::kSize);
 
  const Bytes responseNrdBody(response->payload.begin() + 20, response->payload.end());
 
  const PNIODReleaseBlock responseBlock = PNIODReleaseBlock::Parse(responseNrdBody);
 
  EXPECT_EQ(static_cast<std::uint16_t>(responseBlock.blockHeader[0]) << 8 | responseBlock.blockHeader[1],
            BLOCK_IOD_CONTROL_APP_READY_RES);
 
  EXPECT_EQ(responseBlock.controlCommand, ControlCommand::Done);
 
  EXPECT_EQ(responseBlock.sessionKey, conn->SessionKey());
}
TEST_F(RpcTests, ApplicationReadyAcceptsUnexpectedControlCommand)
{
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  rawcTransport->QueueIncomingDatagram(MakeApplicationReadyRequest(
      false,
      BLOCK_IOD_CONTROL_APP_READY_REQ,
      ControlCommand::ReadyForRtClass3));
 
  const Bytes result = conn->ApplicationReady(9.0);
 
  EXPECT_EQ(result, MakeApplicationReadyControlBlock(BLOCK_IOD_CONTROL_APP_READY_REQ, ControlCommand::ReadyForRtClass3));
 
  EXPECT_EQ(rawcTransport->receiveCount, 1U);
  EXPECT_EQ(rawcTransport->sentRequests.size(), 1U);
}
 
TEST_F(RpcTests, ApplicationReadyPropagatesReceiveException)
{
  InvokeSetRPCConLive(true);
  InvokeSetRPCConLiveMonotonic(std::chrono::steady_clock::now());
 
  rawcTransport->receiveException = std::make_exception_ptr(RPCError("Receive failed"));
 
  EXPECT_THROW(conn->ApplicationReady(1.0), RPCError);
 
  EXPECT_EQ(rawcTransport->receiveCount, 1U);
  EXPECT_TRUE(rawcTransport->sentRequests.empty());
}
TEST_F(RpcTests, DisconnectSendsReleaseRequestAndClearsLive)
{
  InvokeSetRPCConLive(true);
 
  const auto expectedArUuid = StringToUuidBytes("deadbeef-1234-5678-9abc-001122334455");
  const auto expectedSessionKey = static_cast<std::uint16_t>(0x3456);
 
  InvokeSetRPCConArUuid(expectedArUuid);
  InvokeSetRPCConSessionKey(expectedSessionKey);
 
  conn->Disconnect();
 
  ASSERT_EQ(rawTransport->sentRequests.size(), 1U);
  EXPECT_FALSE(InvokeGetRPCConLive());
 
  const PNRPCHeader request = PNRPCHeader::Parse(rawTransport->sentRequests.front());
 
  EXPECT_EQ(request.packetType, PNRPCHeader::REQUEST);
  EXPECT_EQ(request.operationNumber, PNRPCHeader::RELEASE);
 
  const PNNRDData nrd = PNNRDData::Parse(request.payload);
 
  ASSERT_EQ(nrd.payload.size(), PNIODReleaseBlock::kSize);
 
  const PNIODReleaseBlock release = PNIODReleaseBlock::Parse(nrd.payload);
 
  ASSERT_EQ(static_cast<std::uint16_t>(release.blockHeader[0] << 8U | release.blockHeader[1]),
            static_cast<std::uint16_t>(BlockType::ReleaseRequest));
 
  EXPECT_EQ(release.padding1, 0U);
  EXPECT_EQ(release.arUuid, expectedArUuid);
  EXPECT_EQ(release.sessionKey, expectedSessionKey);
  EXPECT_EQ(release.padding2, 0U);
  EXPECT_EQ(release.controlCommand, ControlCommand::Release);
  EXPECT_EQ(release.controlBlockProperties, 0U);
}
 
TEST_F(RpcTests, DisconnectBuildsCorrectReleaseBlock)
{
  InvokeSetRPCConLive(true);
 
  const auto expectedArUuid = StringToUuidBytes("deadbeef-1234-5678-9abc-001122334455");
  const auto expectedSessionKey = static_cast<std::uint16_t>(0x3456);
 
  InvokeSetRPCConArUuid(expectedArUuid);
  InvokeSetRPCConSessionKey(expectedSessionKey);
 
  conn->Disconnect();
 
  ASSERT_EQ(rawTransport->sentRequests.size(), 1U);
 
  const PNRPCHeader request = PNRPCHeader::Parse(rawTransport->sentRequests.front());
 
  const PNNRDData nrd = PNNRDData::Parse(request.payload);
 
  const PNIODReleaseBlock release = PNIODReleaseBlock::Parse(nrd.payload);
 
  const Bytes blockHeaderBytes(release.blockHeader.begin(), release.blockHeader.end());
 
  const PNBlockHeader block = PNBlockHeader::Parse(blockHeaderBytes);
 
  EXPECT_EQ(block.blockType, BlockType::ReleaseRequest);
  EXPECT_EQ(block.blockLength, 28U);
  EXPECT_EQ(block.blockVersionHigh, 0x01U);
  EXPECT_EQ(block.blockVersionLow, 0x00U);
 
  EXPECT_EQ(release.padding1, 0U);
  EXPECT_EQ(release.arUuid, expectedArUuid);
  EXPECT_EQ(release.sessionKey, expectedSessionKey);
  EXPECT_EQ(release.padding2, 0U);
  EXPECT_EQ(release.controlCommand, ControlCommand::Release);
  EXPECT_EQ(release.controlBlockProperties, 0U);
}
 
TEST_F(RpcTests, DisconnectDoesNothingWhenNotLive)
{
  InvokeSetRPCConLive(false);
 
  conn->Disconnect();
 
  EXPECT_FALSE(InvokeGetRPCConLive());
  EXPECT_TRUE(rawTransport->sentRequests.empty());
}
TEST_F(RpcTests, DisconnectSwallowsSendExceptionAndClearsLive)
{
  InvokeSetRPCConLive(true);
 
  rawTransport->sendException = std::make_exception_ptr(RPCError("simulated RELEASE send failure"));
 
  EXPECT_NO_THROW(conn->Disconnect());
 
  EXPECT_FALSE(InvokeGetRPCConLive());
  EXPECT_TRUE(rawTransport->sentRequests.empty());
}
TEST_F(RpcTests, DisconnectAlwaysClearsLive)
{
  InvokeSetRPCConLive(true);
 
  rawTransport->sendException = std::make_exception_ptr(std::runtime_error("send failed"));
 
  conn->Disconnect();
 
  EXPECT_FALSE(InvokeGetRPCConLive());
}
TEST_F(RpcTests, CloseDisconnectsAndClosesBothTransports)
{
  InvokeSetRPCConLive(true);
 
  conn->Close();
 
  EXPECT_FALSE(InvokeGetRPCConLive());
 
  EXPECT_EQ(rawTransport->sentRequests.size(), 1U);
 
  EXPECT_EQ(rawTransport->closeCount, 1U);
  EXPECT_EQ(rawcTransport->closeCount, 1U);
}
 
TEST_F(RpcTests, CloseClosesBothTransportsWhenNotLive)
{
  InvokeSetRPCConLive(false);
 
  conn->Close();
 
  EXPECT_FALSE(InvokeGetRPCConLive());
 
  EXPECT_TRUE(rawTransport->sentRequests.empty());
 
  EXPECT_EQ(rawTransport->closeCount, 1U);
  EXPECT_EQ(rawcTransport->closeCount, 1U);
}
} // namespace profinet::rpc