test_rpc_Integration.cpp

Go to the documentation of this file.

 
 
#include <array>
#include <asio.hpp>
#include <atomic>
#include <chrono>
#include <cstdint>
#include <cstring>
#include <functional>
#include <mutex>
#include <optional>
#include <ranges>
#include <string>
#include <thread>
#include <utility>
#include <vector>
 
#include "profinet/exceptions.h"
#include "profinet/protocol.h"
#include "profinet/rpc.h"
 
using namespace profinet;
using namespace profinet::rpc;
 
/*
class RpcTestServer
{
 public:
  explicit RpcTestServer(asio::io_context& ioContext);
 
  void Start();
  void Stop();
 
  std::uint16_t Port() const;
 
  Bytes Receive();
 
  void Send(const Bytes& response);
 
 private:
  asio::ip::udp::socket socket;
  asio::ip::udp::endpoint remoteEndpoint;
};
 
class ProfinetRpcTestDevice
{
 public:
  void Start();
 
  void ExpectConnect();
  void ExpectRead(...);
  void ExpectWrite(...);
 
  void Stop();
 
 private:
  ...
};
namespace rpc
{
 
TEST_F(RpcConIntegrationTest, ConnectAndReadIm0)
{
  ProfinetRpcTestDevice device;
  device.Start();
 
  RPCCon connection(MakeDeviceDescription(device.Port()));
 
  connection.Connect(TestMacAddress());
 
  auto im0 = connection.ReadIm0();
 
  EXPECT_EQ(im0.OrderId, "...");
}
} // namespace rpc
*/
 
using namespace std::chrono_literals;
 
// ---------------------------------------------------------------------------
// Test constants
// ---------------------------------------------------------------------------
 
constexpr std::uint16_t kTestRpcPort = RPC_PORT;
 
constexpr std::uint32_t kTestApi = 0;
 
constexpr std::uint16_t kTestSlot = 0;
constexpr std::uint16_t kTestSubslot = 1;
 
constexpr std::uint16_t kTestReadIndex = 0xAFF0;
constexpr std::uint16_t kTestWriteIndex = 0xAFF1;
 
constexpr std::uint16_t kTestAlarmReference = 0x1234;
 
// ---------------------------------------------------------------------------
// Test MAC address
// ---------------------------------------------------------------------------
 
MacAddress TestMac()
{
  MacAddress mac{};
 
  mac[0] = 0x02;
  mac[1] = 0x00;
  mac[2] = 0x00;
  mac[3] = 0x00;
  mac[4] = 0x00;
  mac[5] = 0x01;
 
  return mac;
}
 
// ---------------------------------------------------------------------------
// Test device description
// ---------------------------------------------------------------------------
 
dcp::DCPDeviceDescription MakeTestDeviceDescription()
{
  dcp::DCPDeviceDescription info(String2Mac("aa:bb:cc:dd:ee:ff"),
                                 {});
 
  info.name = "test-device";
  info.ip = "127.0.0.1";
 
  // Arbitrary values used to construct the remote object UUID.
  info.deviceHigh = 0x1234;
  info.deviceLow = 0x5678;
  info.vendorHigh = 0x9ABC;
  info.vendorLow = 0xDEF0;
 
  return info;
}
 
// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------
 
Bytes MakeNrdResponse(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();
}
 
PNRPCHeader MakeRpcResponse(
    const PNRPCHeader& request,
    const Bytes& payload)
{
  PNRPCHeader response = request;
 
  response.packetType = PNRPCHeader::RESPONSE;
  response.flags1 = 0x00;
  response.flags2 = 0x00;
  response.lengthOfBody = static_cast<std::uint16_t>(payload.size());
  response.payload = payload;
 
  return response;
}
 
PNRPCHeader MakeRpcFault(
    const PNRPCHeader& request)
{
  PNRPCHeader response = request;
 
  response.packetType = PNRPCHeader::FAULT;
  response.flags1 = 0x00;
  response.flags2 = 0x00;
  response.lengthOfBody = 0;
  response.payload.clear();
 
  return response;
}
 
PNRPCHeader MakeRpcReject(
    const PNRPCHeader& request)
{
  PNRPCHeader response = request;
 
  response.packetType = PNRPCHeader::REJECT;
  response.flags1 = 0x00;
  response.flags2 = 0x00;
  response.lengthOfBody = 0;
  response.payload.clear();
 
  return response;
}
 
Bytes MakePnioStatusResponse(
    std::uint32_t argsMaximumStatus,
    const Bytes& payload = {})
{
  PNNRDData nrd;
  nrd.argsMaximumStatus = argsMaximumStatus;
  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 ExtractNrdPayload(const PNRPCHeader& request)
{
  const PNNRDData nrd = PNNRDData::Parse(request.payload);
  return nrd.payload;
}
 
/*
std::vector<PNBlockHeader> FindBlocks(const Bytes& data)
{
  std::vector<PNBlockHeader> result;
 
  std::size_t offset = 0;
 
  while (offset + blockHeaderLength <= data.size())
  {
    const PNBlockHeader header = PeekBlockHeader(data, offset);
 
    result.push_back(header);
 
    const std::size_t next =
        offset +
        4 +
        static_cast<std::size_t>(header.blockLength);
 
    if (next <= offset || next > data.size())
    {
      break;
    }
 
    offset = next;
  }
 
  return result;
}
*/
struct BlockView
{
  std::size_t offset;
  std::uint16_t blockType;
  std::uint16_t blockLength;
};
 
std::vector<BlockView> FindBlocks(const Bytes& data)
{
  std::vector<BlockView> result;
 
  std::size_t offset = 0;
 
  while (offset + 4 <= data.size())
  {
    const BlockHeaderView header =
        PeekBlockHeader(data, offset);
 
    const std::size_t blockSize =
        4U + static_cast<std::size_t>(header.blockLength);
 
    if (blockSize > data.size() - offset)
    {
      break;
    }
 
    result.push_back({
        .offset = offset,
        .blockType = header.blockType,
        .blockLength = header.blockLength,
    });
 
    offset += blockSize;
  }
 
  return result;
}
 
Bytes GetBlock(const Bytes& data, const BlockView& block)
{
  const std::size_t size =
      4U + static_cast<std::size_t>(block.blockLength);
 
  return Bytes(
      data.begin() + block.offset,
      data.begin() + block.offset + size);
}
 
bool ContainsBlockType(
    const Bytes& data,
    std::uint16_t blockType)
{
  const auto blocks = FindBlocks(data);
 
  for (const auto& block : blocks)
  {
    if (block.blockType == blockType)
    {
      return true;
    }
  }
 
  return false;
}
 
std::size_t CountBlockType(
    const Bytes& data,
    std::uint16_t blockType)
{
  std::size_t count = 0;
 
  const auto blocks = FindBlocks(data);
 
  for (const auto& block : blocks)
  {
    if (block.blockType == blockType)
    {
      ++count;
    }
  }
 
  return count;
}
 
// ---------------------------------------------------------------------------
// Simulated PROFINET RPC device
// ---------------------------------------------------------------------------
 
class TestRpcDevice
{
 public:
  struct ControlRequest
  {
    std::uint16_t blockType = 0;
    std::uint16_t controlCommand = 0;
    std::uint16_t controlBlockProperties = 0;
    std::array<std::uint8_t, uuidLenght> arUuid{};
    std::uint16_t sessionKey = 0;
  };
 
  struct ControlResponse
  {
    std::uint16_t blockType = 0;
    std::uint16_t controlCommand = 0;
    std::uint16_t controlBlockProperties = 0;
    std::array<std::uint8_t, uuidLenght> arUuid{};
    std::uint16_t sessionKey = 0;
    std::uint16_t operationNumber = 0;
    std::uint16_t packetType = 0;
  };
 
  enum class ResponseMode
  {
    ConnectOk,
    ConnectPnioError,
    RpcFault,
    RpcReject,
    ConnectTimeout,
    ConnectIgnoreRequestThenRespond,
    Read,
    Write,
    AlarmCr,
    Iocr
  };
 
  explicit TestRpcDevice(ResponseMode mode)
      : mode(mode),
        socket(ioContext)
  {
  }
 
  ~TestRpcDevice()
  {
    Stop();
  }
 
  void Start()
  {
    asio::error_code ec;
 
    socket.open(
        asio::ip::udp::v4(),
        ec);
 
    ASSERT_FALSE(ec)
        << "Failed to open test UDP socket: "
        << ec.message();
 
    // Use an ephemeral source port. RPCCon's CControl socket owns
    // RPC_PORT, so the simulated device must not bind to that port.
    socket.bind(
        asio::ip::udp::endpoint(
            asio::ip::udp::v4(),
            0),
        ec);
 
    ASSERT_FALSE(ec)
        << "Failed to bind test UDP socket: "
        << ec.message();
 
    running.store(true);
 
    worker = std::thread(
        [this]()
    {
      Run();
    });
  }
 
  void Stop()
  {
    if (!running.exchange(false))
    {
      return;
    }
 
    asio::error_code ec;
 
    if (socket.is_open())
    {
      socket.cancel(ec);
      socket.close(ec);
    }
 
    stateCondition.notify_all();
 
    if (worker.joinable())
    {
      worker.join();
    }
  }
 
  // -------------------------------------------------------------------------
  // General test state
  // -------------------------------------------------------------------------
 
  [[nodiscard]] std::size_t RequestCount() const
  {
    return requestCount.load();
  }
 
  [[nodiscard]] bool SawExpectedConnect() const
  {
    return sawExpectedConnect.load();
  }
 
  [[nodiscard]] bool SawAlarmCr() const
  {
    return sawAlarmCr.load();
  }
 
  [[nodiscard]] bool SawInputIocr() const
  {
    return sawInputIocr.load();
  }
 
  [[nodiscard]] bool SawOutputIocr() const
  {
    return sawOutputIocr.load();
  }
 
  [[nodiscard]] bool SawExpectedSubmodule() const
  {
    return sawExpectedSubmodule.load();
  }
 
  [[nodiscard]] bool SawRead() const
  {
    return sawRead.load();
  }
 
  [[nodiscard]] bool SawWrite() const
  {
    return sawWrite.load();
  }
 
  [[nodiscard]] std::uint16_t ReadIndex() const
  {
    return readIndex.load();
  }
 
  [[nodiscard]] std::uint16_t WriteIndex() const
  {
    return writeIndex.load();
  }
 
  [[nodiscard]] Bytes LastWritePayload() const
  {
    std::scoped_lock lock(mutex);
    return lastWritePayload;
  }
 
  // -------------------------------------------------------------------------
  // CONNECT synchronization
  // -------------------------------------------------------------------------
 
  [[nodiscard]] bool WaitForConnect(
      std::chrono::milliseconds timeout =
          std::chrono::milliseconds{1000})
  {
    std::unique_lock lock(stateMutex);
 
    return stateCondition.wait_for(
        lock,
        timeout,
        [this]()
    {
      return connected.load();
    });
  }
 
  // -------------------------------------------------------------------------
  // ApplicationReady
  // -------------------------------------------------------------------------
 
  void SendApplicationReadyRequest(
      const std::array<std::uint8_t, uuidLenght>& arUuid,
      std::uint16_t sessionKey)
  {
    if (!connected.load())
    {
      throw std::runtime_error(
          "Cannot send ApplicationReady before CONNECT");
    }
 
    {
      std::scoped_lock lock(stateMutex);
 
      if (!lastConnectRequest)
      {
        throw std::runtime_error(
            "No CONNECT request has been received");
      }
    }
 
    SendControlRequest(
        BLOCK_IOD_CONTROL_APP_READY_REQ,
        CONTROL_CMD_APP_READY,
        arUuid,
        sessionKey);
 
    {
      std::scoped_lock lock(stateMutex);
 
      if (lastApplicationReadyRequestRpc)
      {
        applicationReadyRequest =
            ParseControlRequest(
                *lastApplicationReadyRequestRpc);
      }
    }
 
    stateCondition.notify_all();
  }
 
  [[nodiscard]] bool WaitForApplicationReadyResponse(
      std::chrono::milliseconds timeout =
          std::chrono::milliseconds{1000}) const
  {
    std::unique_lock lock(stateMutex);
 
    return stateCondition.wait_for(
        lock,
        timeout,
        [this]()
    {
      return applicationReadyResponse.has_value();
    });
  }
 
  [[nodiscard]] bool ReceivedApplicationReadyResponse() const
  {
    std::scoped_lock lock(stateMutex);
 
    return applicationReadyResponse.has_value();
  }
 
  [[nodiscard]] std::optional<ControlResponse>
  ApplicationReadyResponse() const
  {
    std::scoped_lock lock(stateMutex);
 
    return applicationReadyResponse;
  }
 
  [[nodiscard]] std::optional<ControlRequest>
  LastApplicationReadyRequest() const
  {
    std::scoped_lock lock(stateMutex);
 
    return applicationReadyRequest;
  }
 
  [[nodiscard]] std::optional<PNRPCHeader>
  LastApplicationReadyRpcRequest() const
  {
    std::scoped_lock lock(stateMutex);
 
    return lastApplicationReadyRequestRpc;
  }
 
  [[nodiscard]] std::optional<PNRPCHeader>
  LastApplicationReadyRpcResponse() const
  {
    std::scoped_lock lock(stateMutex);
 
    return lastApplicationReadyResponseRpc;
  }
 
  [[nodiscard]] std::optional<PNNRDData>
  LastApplicationReadyResponseNrd() const
  {
    std::scoped_lock lock(stateMutex);
 
    if (!lastApplicationReadyResponseRpc)
    {
      return std::nullopt;
    }
 
    try
    {
      return PNNRDData::Parse(
          lastApplicationReadyResponseRpc->payload);
    }
    catch (...)
    {
      return std::nullopt;
    }
  }
 
  PNRPCHeader SendRpcRequest(
      std::uint16_t operation,
      const Bytes& payload = {},
      std::optional<PNRPCHeader> packetTemplate = std::nullopt)
  {
    PNRPCHeader request;
 
    {
      std::scoped_lock lock(stateMutex);
 
      if (packetTemplate)
      {
        request = *packetTemplate;
      }
      else if (lastConnectRequest)
      {
        request = *lastConnectRequest;
      }
      else
      {
        throw std::runtime_error(
            "Cannot send RPC REQUEST: no packet template is available");
      }
    }
 
    request.packetType = PNRPCHeader::REQUEST;
    request.operationNumber = operation;
    request.lengthOfBody =
        static_cast<std::uint16_t>(payload.size());
    request.payload = payload;
 
    SendPacket(request);
 
    return request;
  }
 
  void SendRpcResponse(
      std::uint16_t operation,
      const Bytes& payload = {},
      std::optional<PNRPCHeader> packetTemplate = std::nullopt)
  {
    PNRPCHeader response;
 
    {
      std::scoped_lock lock(stateMutex);
 
      if (packetTemplate)
      {
        response = *packetTemplate;
      }
      else if (lastConnectRequest)
      {
        response = *lastConnectRequest;
      }
      else
      {
        throw std::runtime_error(
            "Cannot send RPC RESPONSE: no packet template is available");
      }
    }
 
    response.packetType = PNRPCHeader::RESPONSE;
    response.operationNumber = operation;
    response.lengthOfBody =
        static_cast<std::uint16_t>(payload.size());
    response.payload = payload;
 
    SendPacket(response);
  }
 
  void SendControlRequest(
      std::uint16_t blockType,
      std::uint16_t controlCommand,
      const std::array<std::uint8_t, uuidLenght>& arUuid,
      std::uint16_t sessionKey,
      std::uint16_t controlBlockProperties = 0)
  {
    const Bytes controlBlock =
        BuildControlRequestPayload(
            blockType,
            controlCommand,
            arUuid,
            sessionKey,
            controlBlockProperties);
 
    const Bytes nrd =
        MakeNrdResponse(controlBlock);
 
    const PNRPCHeader request =
        SendRpcRequest(
            PNRPCHeader::CONTROL,
            nrd);
 
    {
      std::scoped_lock lock(stateMutex);
 
      lastApplicationReadyRequestRpc =
          request;
 
      if (blockType ==
          BLOCK_IOD_CONTROL_APP_READY_REQ)
      {
        applicationReadyRequest =
            ParseControlRequest(request);
      }
    }
 
    stateCondition.notify_all();
  }
 
 private:
  // -------------------------------------------------------------------------
  // Worker
  // -------------------------------------------------------------------------
 
  void Run()
  {
    while (running)
    {
      Bytes buffer(RECEIVE_BUFFER_LENGTH);
 
      asio::ip::udp::endpoint sender;
      asio::error_code ec;
 
      const std::size_t received =
          socket.receive_from(
              asio::buffer(buffer),
              sender,
              0,
              ec);
 
      if (!running)
      {
        break;
      }
 
      if (ec)
      {
        continue;
      }
 
      buffer.resize(received);
 
      HandleRequest(
          buffer,
          sender);
    }
  }
 
  // -------------------------------------------------------------------------
  // Receive / dispatch
  // -------------------------------------------------------------------------
 
  void HandleRequest(
      const Bytes& bytes,
      const asio::ip::udp::endpoint& sender)
  {
    ++requestCount;
 
    PNRPCHeader packet;
 
    try
    {
      packet =
          PNRPCHeader::Parse(bytes);
    }
    catch (...)
    {
      return;
    }
 
    // ApplicationReady is initiated by the device, so its response comes
    // back as an RPC RESPONSE on the same UDP socket.
    if (packet.packetType == PNRPCHeader::RESPONSE &&
        packet.operationNumber == PNRPCHeader::CONTROL)
    {
      HandleApplicationReadyResponse(packet);
      return;
    }
 
    // All remaining device handling expects incoming RPC REQUEST packets.
    if (packet.packetType != PNRPCHeader::REQUEST)
    {
      return;
    }
 
    switch (mode)
    {
      case ResponseMode::ConnectOk:
        HandleConnect(
            packet,
            sender,
            false,
            false);
        break;
 
      case ResponseMode::ConnectPnioError:
        HandleConnectPnioError(
            packet,
            sender);
        break;
 
      case ResponseMode::RpcFault:
        HandleRpcFault(
            packet,
            sender);
        break;
 
      case ResponseMode::RpcReject:
        HandleRpcReject(
            packet,
            sender);
        break;
 
      case ResponseMode::ConnectTimeout:
        // Deliberately do nothing.
        break;
 
      case ResponseMode::ConnectIgnoreRequestThenRespond:
        HandleConnect(
            packet,
            sender,
            true,
            false);
        break;
 
      case ResponseMode::Read:
        HandleRead(
            packet,
            sender);
        break;
 
      case ResponseMode::Write:
        HandleWrite(
            packet,
            sender);
        break;
 
      case ResponseMode::AlarmCr:
        HandleConnect(
            packet,
            sender,
            false,
            true);
        break;
 
      case ResponseMode::Iocr:
        HandleConnect(
            packet,
            sender,
            false,
            false);
        break;
    }
  }
 
  // -------------------------------------------------------------------------
  // UDP
  // -------------------------------------------------------------------------
 
  void SendRpcResponse(
      const PNRPCHeader& response,
      const asio::ip::udp::endpoint& remote)
  {
    const Bytes bytes =
        response.ToBytes();
 
    asio::error_code ec;
 
    socket.send_to(
        asio::buffer(bytes),
        remote,
        0,
        ec);
  }
 
  [[nodiscard]] asio::ip::udp::endpoint
  ControllerCControlEndpoint() const
  {
    std::scoped_lock lock(stateMutex);
 
    if (controllerEndpoint.address().is_unspecified())
    {
      return {
          asio::ip::make_address_v4("127.0.0.1"),
          RPC_PORT};
    }
 
    return {
        controllerEndpoint.address(),
        RPC_PORT};
  }
 
  // -------------------------------------------------------------------------
  // RPC error responses
  // -------------------------------------------------------------------------
 
  void HandleRpcFault(
      const PNRPCHeader& request,
      const asio::ip::udp::endpoint& sender)
  {
    SendRpcResponse(
        MakeRpcFault(request),
        sender);
  }
 
  void HandleRpcReject(
      const PNRPCHeader& request,
      const asio::ip::udp::endpoint& sender)
  {
    SendRpcResponse(
        MakeRpcReject(request),
        sender);
  }
 
  void HandleConnectPnioError(
      const PNRPCHeader& request,
      const asio::ip::udp::endpoint& sender)
  {
    const Bytes nrd =
        MakePnioStatusResponse(
            0x81DB0307);
 
    const PNRPCHeader response =
        MakeRpcResponse(
            request,
            nrd);
 
    SendRpcResponse(
        response,
        sender);
  }
 
  // -------------------------------------------------------------------------
  // CONNECT
  // -------------------------------------------------------------------------
 
  void HandleConnect(
      const PNRPCHeader& request,
      const asio::ip::udp::endpoint& sender,
      bool sendRequestBeforeResponse,
      bool checkAlarmCr)
  {
    if (request.operationNumber != PNRPCHeader::CONNECT)
    {
      return;
    }
 
    const Bytes nrdPayload =
        ExtractNrdPayload(request);
 
    const bool hasArBlock =
        ContainsBlockType(
            nrdPayload,
            BlockType::ApplicationRelationData);
 
    sawExpectedConnect.store(
        hasArBlock);
 
    if (!hasArBlock)
    {
      return;
    }
 
    if (checkAlarmCr)
    {
      const bool hasAlarmCr =
          ContainsBlockType(
              nrdPayload,
              BlockType::AlarmCrRequest);
 
      sawAlarmCr.store(
          hasAlarmCr);
    }
 
    if (mode == ResponseMode::Iocr)
    {
      bool sawInput = false;
      bool sawOutput = false;
 
      std::size_t offset = 0;
 
      while (offset + blockHeaderLength <= nrdPayload.size())
      {
        const BlockHeaderView header =
            PeekBlockHeader(
                nrdPayload,
                offset);
 
        const std::size_t blockSize =
            4U +
            static_cast<std::size_t>(
                header.blockLength);
 
        if (blockSize >
            nrdPayload.size() - offset)
        {
          break;
        }
 
        if (header.blockType ==
            PNIOCRBlockReqHeader::BLOCK_TYPE)
        {
          const Bytes blockBytes(
              nrdPayload.begin() +
                  offset),
              nrdPayload.begin() +
                  
                      offset + blockSize));
 
          try
          {
            const PNIOCRBlockReqHeader iocr =
                PNIOCRBlockReqHeader::Parse(
                    blockBytes);
 
            if (iocr.iocrType == 1)
            {
              sawInput = true;
            }
            else if (iocr.iocrType == 2)
            {
              sawOutput = true;
            }
          }
          catch (const std::exception&)
          {
            // Ignore malformed IOCR blocks.
          }
        }
 
        offset += blockSize;
      }
 
      sawInputIocr.store(sawInput);
      sawOutputIocr.store(sawOutput);
 
      sawExpectedSubmodule.store(
          ContainsBlockType(
              nrdPayload,
              BLOCK_EXPECTED_SUBMODULE_REQ));
    }
 
    {
      std::scoped_lock lock(stateMutex);
 
      lastConnectRequest =
          request;
 
      controllerEndpoint =
          sender;
 
      connected.store(true);
    }
 
    stateCondition.notify_all();
 
    if (sendRequestBeforeResponse)
    {
      // Send the original request back as an unsolicited REQUEST.
      // RPCCon::SendReceive() should ignore it and continue waiting
      // for the actual RESPONSE.
      const Bytes unsolicited =
          request.ToBytes();
 
      asio::error_code ec;
 
      socket.send_to(
          asio::buffer(unsolicited),
          sender,
          0,
          ec);
 
      if (ec)
      {
        return;
      }
    }
 
    const Bytes nrd =
        MakeNrdResponse({});
 
    const PNRPCHeader response =
        MakeRpcResponse(
            request,
            nrd);
 
    SendRpcResponse(
        response,
        sender);
  }
 
  // -------------------------------------------------------------------------
  // READ
  // -------------------------------------------------------------------------
 
  void HandleRead(
      const PNRPCHeader& request,
      const asio::ip::udp::endpoint& sender)
  {
    if (request.operationNumber != PNRPCHeader::READ)
    {
      return;
    }
 
    const Bytes nrdPayload =
        ExtractNrdPayload(request);
 
    PNIODHeader readRequest;
 
    try
    {
      readRequest =
          PNIODHeader::Parse(
              nrdPayload);
    }
    catch (...)
    {
      return;
    }
 
    sawRead.store(true);
    readIndex.store(readRequest.index);
 
    Bytes recordData = {
        0x01,
        0x02,
        0x03,
        0x04,
        0x05,
        0x06,
        0x07,
        0x08};
 
    readRequest.length =
        static_cast<std::uint32_t>(
            recordData.size());
 
    readRequest.payload =
        recordData;
 
    const Bytes responsePayload =
        readRequest.ToBytes();
 
    const Bytes responseNrd =
        MakePnioStatusResponse(
            0,
            responsePayload);
 
    const PNRPCHeader response =
        MakeRpcResponse(
            request,
            responseNrd);
 
    SendRpcResponse(
        response,
        sender);
  }
 
  // -------------------------------------------------------------------------
  // WRITE
  // -------------------------------------------------------------------------
 
  void HandleWrite(
      const PNRPCHeader& request,
      const asio::ip::udp::endpoint& sender)
  {
    if (request.operationNumber != PNRPCHeader::WRITE)
    {
      return;
    }
 
    const Bytes nrdPayload =
        ExtractNrdPayload(request);
 
    PNIODHeader writeRequest;
 
    try
    {
      writeRequest =
          PNIODHeader::Parse(
              nrdPayload);
    }
    catch (...)
    {
      return;
    }
 
    sawWrite.store(true);
    writeIndex.store(writeRequest.index);
 
    {
      std::scoped_lock lock(mutex);
 
      lastWritePayload =
          writeRequest.payload;
    }
 
    const Bytes responseNrd =
        MakePnioStatusResponse(0);
 
    const PNRPCHeader response =
        MakeRpcResponse(
            request,
            responseNrd);
 
    SendRpcResponse(
        response,
        sender);
  }
 
  // -------------------------------------------------------------------------
  // ApplicationReady
  // -------------------------------------------------------------------------
 
  static Bytes BuildApplicationReadyRequestPayload(
      const std::array<std::uint8_t, uuidLenght>& arUuid,
      std::uint16_t sessionKey)
  {
    PNBlockHeader block;
    block.blockType =
        BLOCK_IOD_CONTROL_APP_READY_REQ;
    block.blockLength = 28;
    block.blockVersionHigh = 0x01;
    block.blockVersionLow = 0x00;
 
    PNIODReleaseBlock controlBlock;
    std::ranges::copy(block.ToBytes() | std::views::take(blockHeaderLength), controlBlock.blockHeader.begin());
 
    controlBlock.padding1 = 0;
    controlBlock.arUuid = arUuid;
    controlBlock.sessionKey = sessionKey;
    controlBlock.padding2 = 0;
    controlBlock.controlCommand =
        CONTROL_CMD_APP_READY;
    controlBlock.controlBlockProperties = 0;
 
    return controlBlock.ToBytes();
  }
 
  static std::optional<ControlRequest>
  ParseControlRequest(
      const PNRPCHeader& request)
  {
    if (request.packetType !=
        PNRPCHeader::REQUEST)
    {
      return std::nullopt;
    }
 
    if (request.operationNumber !=
        PNRPCHeader::CONTROL)
    {
      return std::nullopt;
    }
 
    PNNRDData nrd;
 
    try
    {
      nrd =
          PNNRDData::Parse(
              request.payload);
    }
    catch (...)
    {
      return std::nullopt;
    }
 
    constexpr std::size_t kControlBlockSize = 32;
 
    if (nrd.payload.size() <
        kControlBlockSize)
    {
      return std::nullopt;
    }
 
    const Bytes& data =
        nrd.payload;
 
    ControlRequest result;
 
    result.blockType =
        static_cast<std::uint16_t>(
            (static_cast<std::uint16_t>(data[0]) << OneOctetShift) |
            static_cast<std::uint16_t>(data[1]));
 
    if (result.blockType !=
        BLOCK_IOD_CONTROL_APP_READY_REQ)
    {
      return std::nullopt;
    }
 
    result.arUuid = {};
 
    std::ranges::copy(data | std::views::drop(8) | std::views::take(uuidLenght), result.arUuid.begin());
 
    result.sessionKey =
        static_cast<std::uint16_t>(
            (static_cast<std::uint16_t>(data[24]) << OneOctetShift) |
            static_cast<std::uint16_t>(data[25]));
 
    result.controlCommand =
        static_cast<std::uint16_t>(
            (static_cast<std::uint16_t>(data[28]) << OneOctetShift) |
            static_cast<std::uint16_t>(data[29]));
 
    result.controlBlockProperties =
        static_cast<std::uint16_t>(
            (static_cast<std::uint16_t>(data[30]) << OneOctetShift) |
            static_cast<std::uint16_t>(data[31]));
 
    return result;
  }
 
  static std::optional<ControlResponse>
  ParseControlResponse(
      const PNRPCHeader& response)
  {
    if (response.packetType !=
        PNRPCHeader::RESPONSE)
    {
      return std::nullopt;
    }
 
    if (response.operationNumber !=
        PNRPCHeader::CONTROL)
    {
      return std::nullopt;
    }
 
    PNNRDData nrd;
 
    try
    {
      nrd =
          PNNRDData::Parse(
              response.payload);
    }
    catch (...)
    {
      return std::nullopt;
    }
 
    constexpr std::size_t kControlBlockSize = 32;
 
    if (nrd.payload.size() <
        kControlBlockSize)
    {
      return std::nullopt;
    }
 
    const Bytes& data =
        nrd.payload;
 
    ControlResponse result;
 
    result.blockType =
        static_cast<std::uint16_t>(
            (static_cast<std::uint16_t>(data[0]) << OneOctetShift) |
            static_cast<std::uint16_t>(data[1]));
 
    if (result.blockType !=
        BLOCK_IOD_CONTROL_APP_READY_RES)
    {
      return std::nullopt;
    }
 
    std::ranges::copy(data | std::views::drop(8) | std::views::take(uuidLenght), result.arUuid.begin());
 
    result.sessionKey =
        static_cast<std::uint16_t>(
            (static_cast<std::uint16_t>(data[24]) << OneOctetShift) |
            static_cast<std::uint16_t>(data[25]));
 
    result.controlCommand =
        static_cast<std::uint16_t>(
            (static_cast<std::uint16_t>(data[28]) << OneOctetShift) |
            static_cast<std::uint16_t>(data[29]));
 
    result.controlBlockProperties =
        static_cast<std::uint16_t>(
            (static_cast<std::uint16_t>(data[30]) << OneOctetShift) |
            static_cast<std::uint16_t>(data[31]));
 
    return result;
  }
 
  void HandleApplicationReadyResponse(
      const PNRPCHeader& response)
  {
    const auto parsed =
        ParseControlResponse(
            response);
 
    if (!parsed)
    {
      return;
    }
 
    {
      std::scoped_lock lock(stateMutex);
 
      lastApplicationReadyResponseRpc =
          response;
 
      applicationReadyResponse =
          parsed;
    }
 
    stateCondition.notify_all();
  }
  void SendPacket(
      const PNRPCHeader& packet)
  {
    const Bytes bytes =
        packet.ToBytes();
 
    const asio::ip::udp::endpoint target =
        ControllerCControlEndpoint();
 
    asio::error_code ec;
 
    socket.send_to(
        asio::buffer(bytes),
        target,
        0,
        ec);
 
    if (ec)
    {
      throw std::system_error(
          ec,
          "Failed to send RPC packet");
    }
  }
 
  static Bytes BuildControlRequestPayload(
      std::uint16_t blockType,
      std::uint16_t controlCommand,
      const std::array<std::uint8_t, uuidLenght>& arUuid,
      std::uint16_t sessionKey,
      std::uint16_t controlBlockProperties)
  {
    PNBlockHeader block;
    block.blockType = blockType;
    block.blockLength = 28;
    block.blockVersionHigh = 0x01;
    block.blockVersionLow = 0x00;
 
    PNIODReleaseBlock controlBlock;
 
    std::ranges::copy(block.ToBytes() | std::views::take(blockHeaderLength), controlBlock.blockHeader.begin());
 
    controlBlock.padding1 = 0;
    controlBlock.arUuid = arUuid;
    controlBlock.sessionKey = sessionKey;
    controlBlock.padding2 = 0;
    controlBlock.controlCommand = controlCommand;
    controlBlock.controlBlockProperties =
        controlBlockProperties;
 
    return controlBlock.ToBytes();
  }
 
 private:
  ResponseMode mode;
 
  asio::io_context ioContext;
  asio::ip::udp::socket socket;
  std::thread worker;
 
  std::atomic_bool running{false};
  std::atomic<std::size_t> requestCount{0};
 
  std::atomic_bool connected{false};
 
  std::atomic_bool sawExpectedConnect{false};
  std::atomic_bool sawAlarmCr{false};
  std::atomic_bool sawInputIocr{false};
  std::atomic_bool sawOutputIocr{false};
  std::atomic_bool sawExpectedSubmodule{false};
  std::atomic_bool sawRead{false};
  std::atomic_bool sawWrite{false};
 
  std::atomic<std::uint16_t> readIndex{0};
  std::atomic<std::uint16_t> writeIndex{0};
 
  mutable std::mutex mutex;
  Bytes lastWritePayload;
 
  mutable std::mutex stateMutex;
  mutable std::condition_variable stateCondition;
 
  asio::ip::udp::endpoint controllerEndpoint;
 
  std::optional<PNRPCHeader> lastConnectRequest;
 
  std::optional<PNRPCHeader>
      lastApplicationReadyRequestRpc;
 
  std::optional<PNRPCHeader>
      lastApplicationReadyResponseRpc;
 
  std::optional<ControlRequest>
      applicationReadyRequest;
 
  std::optional<ControlResponse>
      applicationReadyResponse;
};
 
// ---------------------------------------------------------------------------
// IOCR test setup
// ---------------------------------------------------------------------------
 
IOCRSetup MakeAumaLikeIocrSetup()
{
  IOCRSetup setup{};
 
  // The values here intentionally mirror the three-slot configuration
  // used by the AUMA CDT device in the integration work.
 
  IOSlot slot0{};
  slot0.slot = 0;
  slot0.subslot = 1;
  slot0.moduleIdent = 0x00008001;
  slot0.submoduleIdent = 0x00000000;
  slot0.inputLength = 0;
  slot0.outputLength = 0;
 
  IOSlot slot1{};
  slot1.slot = 1;
  slot1.subslot = 1;
  slot1.moduleIdent = 0x00008000;
  slot1.submoduleIdent = 0x00000022;
  slot1.inputLength = 34;
  slot1.outputLength = 0;
 
  IOSlot slot2{};
  slot2.slot = 2;
  slot2.subslot = 1;
  slot2.moduleIdent = 0x00008100;
  slot2.submoduleIdent = 0x00000011;
  slot2.inputLength = 0;
  slot2.outputLength = 16;
 
  setup.slots.push_back(slot0);
  setup.slots.push_back(slot1);
  setup.slots.push_back(slot2);
 
  return setup;
}
class RpcConIntegrationTest : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    options.timeoutSec = 1.0;
 
    info = MakeTestDeviceDescription();
 
    testDevice =
        std::make_unique<TestRpcDevice>(
            TestRpcDevice::ResponseMode::ConnectOk);
 
    connection =
        std::make_unique<RPCCon>(
            info.value(),
            options);
  }
 
  void TearDown() override
  {
    if (connection)
    {
      connection->Close();
    }
    if (testDevice)
    {
      testDevice->Stop();
    }
  }
 
  void Connect()
  {
    ASSERT_NE(
        connection,
        nullptr);
    ASSERT_NE(testDevice, nullptr);
 
    ASSERT_NO_THROW(
        connection->Connect(
            TestMac()));
  }
  RPCConOptions options;
  std::optional<dcp::DCPDeviceDescription> info;
  std::unique_ptr<RPCCon> connection;
  std::unique_ptr<TestRpcDevice> testDevice;
};
 
// =============================================================================
// CONNECT
// =============================================================================
 
TEST_F(RpcConIntegrationTest, ConnectEstablishesApplicationRelationship)
{
  TestRpcDevice device(
      TestRpcDevice::ResponseMode::ConnectOk);
 
  device.Start();
 
  auto info = MakeTestDeviceDescription();
 
  RPCCon connection(
      info, options);
 
  ASSERT_FALSE(
      connection.IsConnected());
 
  const auto result =
      connection.Connect(TestMac());
 
  EXPECT_FALSE(result.has_value());
  EXPECT_TRUE(connection.IsConnected());
 
  EXPECT_EQ(
      connection.Info().name,
      "test-device");
 
  EXPECT_NE(
      connection.SessionKey(),
      0);
 
  EXPECT_TRUE(
      device.SawExpectedConnect());
 
  connection.Disconnect();
 
  EXPECT_FALSE(
      connection.IsConnected());
}
 
// =============================================================================
// CONNECT requires source MAC for initial connection
// =============================================================================
 
TEST_F(RpcConIntegrationTest, ConnectRequiresSourceMac)
{
  TestRpcDevice device(
      TestRpcDevice::ResponseMode::ConnectOk);
 
  device.Start();
 
  RPCCon connection(
      MakeTestDeviceDescription(),
      options);
 
  EXPECT_THROW(connection.Connect(), std::invalid_argument);
 
  EXPECT_FALSE(
      connection.IsConnected());
}
 
// =============================================================================
// CONNECT PNIO error
// =============================================================================
 
TEST_F(RpcConIntegrationTest, ConnectConvertsPnioErrorToRpcConnectionError)
{
  TestRpcDevice device(
      TestRpcDevice::ResponseMode::ConnectPnioError);
 
  device.Start();
 
  RPCCon connection(
      MakeTestDeviceDescription(),
      options);
 
  EXPECT_THROW(
      connection.Connect(TestMac()),
      RPCConnectionError);
 
  EXPECT_FALSE(
      connection.IsConnected());
 
  EXPECT_TRUE(
      device.SawExpectedConnect());
}
 
// =============================================================================
// RPC FAULT
// =============================================================================
 
TEST_F(RpcConIntegrationTest, ConnectConvertsRpcFault)
{
  TestRpcDevice device(
      TestRpcDevice::ResponseMode::RpcFault);
 
  device.Start();
 
  RPCCon connection(
      MakeTestDeviceDescription(),
      options);
 
  EXPECT_THROW(
      connection.Connect(TestMac()),
      RPCConnectionError);
 
  EXPECT_FALSE(
      connection.IsConnected());
}
 
// =============================================================================
// RPC REJECT
// =============================================================================
 
TEST_F(RpcConIntegrationTest, ConnectConvertsRpcReject)
{
  TestRpcDevice device(
      TestRpcDevice::ResponseMode::RpcReject);
 
  device.Start();
 
  RPCCon connection(
      MakeTestDeviceDescription(),
      options);
 
  EXPECT_THROW(
      connection.Connect(TestMac()),
      RPCConnectionError);
 
  EXPECT_FALSE(
      connection.IsConnected());
}
 
// =============================================================================
// RPC REQUEST before RESPONSE
//
// RPCCon::SendReceive() explicitly ignores RPC REQUEST packets and keeps
// waiting for the actual RESPONSE. Verify that behavior here.
// =============================================================================
 
TEST_F(RpcConIntegrationTest, IgnoresIncomingRpcRequestBeforeResponse)
{
  TestRpcDevice device(
      TestRpcDevice::ResponseMode::ConnectIgnoreRequestThenRespond);
 
  device.Start();
 
  RPCCon connection(
      MakeTestDeviceDescription(),
      options);
 
  EXPECT_NO_THROW(
      connection.Connect(TestMac()));
 
  EXPECT_TRUE(
      connection.IsConnected());
 
  EXPECT_TRUE(
      device.SawExpectedConnect());
 
  EXPECT_GE(
      device.RequestCount(),
      1U);
}
 
// =============================================================================
// Timeout
// =============================================================================
 
TEST_F(RpcConIntegrationTest, ConnectTimesOutWhenDeviceDoesNotRespond)
{
  TestRpcDevice device(
      TestRpcDevice::ResponseMode::ConnectTimeout);
 
  device.Start();
  RPCConOptions testOptions{.timeoutSec = 0.05};
 
  RPCCon connection(
      MakeTestDeviceDescription(),
      testOptions);
 
  EXPECT_THROW(
      connection.Connect(TestMac()),
      RPCConnectionError);
 
  EXPECT_FALSE(
      connection.IsConnected());
 
  EXPECT_GE(
      device.RequestCount(),
      1U);
}
 
// =============================================================================
// AlarmCR request
// =============================================================================
 
TEST_F(RpcConIntegrationTest, ConnectWithAlarmCrSendsAlarmCrBlock)
{
  TestRpcDevice device(
      TestRpcDevice::ResponseMode::AlarmCr);
 
  device.Start();
 
  RPCCon connection(
      MakeTestDeviceDescription(),
      options);
 
  // The test device validates that AlarmCRBlockReq was included.
  //
  // The simulated response deliberately does not include AlarmCRBlockRes,
  // so HasAlarmCr() remains false. A separate AlarmCR response test can
  // be added once the device-side response structure is exposed in the
  // protocol types.
  EXPECT_NO_THROW(
      connection.Connect(
          TestMac(),
          true));
 
  EXPECT_TRUE(
      connection.IsConnected());
 
  EXPECT_TRUE(
      device.SawExpectedConnect());
 
  EXPECT_TRUE(
      device.SawAlarmCr());
 
  EXPECT_FALSE(
      connection.HasAlarmCr());
}
 
// =============================================================================
// IOCR / ExpectedSubmodule
// =============================================================================
 
TEST_F(RpcConIntegrationTest, ConnectWithIocrSendsIocrAndExpectedSubmoduleBlocks)
{
  TestRpcDevice device(
      TestRpcDevice::ResponseMode::Iocr);
 
  device.Start();
 
  RPCCon connection(
      MakeTestDeviceDescription(),
      options);
 
  const IOCRSetup setup =
      MakeAumaLikeIocrSetup();
 
  const auto result =
      connection.Connect(
          TestMac(),
          false,
          setup);
 
  ASSERT_TRUE(result.has_value());
 
  EXPECT_TRUE(
      connection.IsConnected());
 
  EXPECT_TRUE(
      device.SawExpectedConnect());
 
  EXPECT_TRUE(
      device.SawInputIocr());
 
  EXPECT_TRUE(
      device.SawOutputIocr());
 
  EXPECT_TRUE(
      device.SawExpectedSubmodule());
 
  EXPECT_EQ(
      result->arUuid,
      connection.ArUuid());
 
  EXPECT_EQ(
      result->sessionKey,
      connection.SessionKey());
}
 
// =============================================================================
// READ
// =============================================================================
 
TEST_F(RpcConIntegrationTest, ReadSendsIodReadAndReturnsPayload)
{
  TestRpcDevice device(
      TestRpcDevice::ResponseMode::ConnectOk);
 
  device.Start();
 
  RPCCon connection(
      MakeTestDeviceDescription(),
      options);
 
  ASSERT_NO_THROW(
      connection.Connect(TestMac()));
 
  // The device thread above only handles CONNECT. Stop it and replace it
  // with a READ-capable device would require reconnecting RPCCon to a new
  // port. Because the current RPCCon hardcodes RPC_PORT, perform this test
  // against a server that handles both CONNECT and READ below.
  device.Stop();
 
  class ConnectReadDevice : public TestRpcDevice
  {
   public:
    ConnectReadDevice()
        : TestRpcDevice(ResponseMode::Read)
    {
    }
  };
 
  // The current test server's ResponseMode::Read intentionally handles
  // READ packets but not CONNECT. Therefore this test focuses on the
  // transport/RPC path after an externally established AR and is disabled
  // below until the simulated device is made stateful.
  GTEST_SKIP()
      << "Enable once the test device supports CONNECT + READ in one "
         "stateful session.";
}
 
// =============================================================================
// WRITE
// =============================================================================
 
TEST_F(RpcConIntegrationTest, WriteSendsIodWritePayload)
{
  GTEST_SKIP()
      << "Enable once the test device supports CONNECT + WRITE in one "
         "stateful session.";
}
 
// =============================================================================
// ReadImplicit
// =============================================================================
 
TEST_F(RpcConIntegrationTest, ImplicitReadRequiresStatefulSimulatedDevice)
{
  GTEST_SKIP()
      << "Enable once the simulated device supports a complete implicit "
         "IODReadReq/IODReadRes exchange.";
}
 
// =============================================================================
// Disconnect
// =============================================================================
 
TEST_F(RpcConIntegrationTest, DisconnectClosesApplicationRelationship)
{
  TestRpcDevice device(
      TestRpcDevice::ResponseMode::ConnectOk);
 
  device.Start();
 
  RPCCon connection(
      MakeTestDeviceDescription(),
      options);
 
  ASSERT_NO_THROW(
      connection.Connect(TestMac()));
 
  ASSERT_TRUE(
      connection.IsConnected());
 
  EXPECT_NO_THROW(
      connection.Disconnect());
 
  EXPECT_FALSE(
      connection.IsConnected());
 
  // Disconnect() is explicitly best-effort and does not require
  // a response from the simulated device.
}
 
// =============================================================================
// Close / RAII
// =============================================================================
 
TEST_F(RpcConIntegrationTest, CloseIsIdempotent)
{
  TestRpcDevice device(
      TestRpcDevice::ResponseMode::ConnectOk);
 
  device.Start();
 
  RPCCon connection(
      MakeTestDeviceDescription(),
      options);
 
  ASSERT_NO_THROW(
      connection.Connect(TestMac()));
 
  EXPECT_TRUE(
      connection.IsConnected());
 
  EXPECT_NO_THROW(
      connection.Close());
 
  EXPECT_FALSE(
      connection.IsConnected());
 
  // Close() should be safe to call repeatedly.
  EXPECT_NO_THROW(
      connection.Close());
 
  EXPECT_FALSE(
      connection.IsConnected());
}
 
// =============================================================================
// IoContext
// =============================================================================
 
TEST_F(RpcConIntegrationTest, ExposesIoContext)
{
  RPCCon connection(
      MakeTestDeviceDescription(),
      options);
 
  auto& io = connection.IoContext();
 
  EXPECT_EQ(
      &io,
      &connection.IoContext());
}
 
// =============================================================================
// Hardware-oriented configuration sanity test
//
// This does not contact hardware. It simply verifies that our test IOCR
// configuration contains the same slot structure used by the integration
// work with the AUMA actuator.
// =============================================================================
 
TEST_F(RpcConIntegrationTest, AumaLikeIocrConfigurationHasExpectedSlots)
{
  const IOCRSetup setup =
      MakeAumaLikeIocrSetup();
 
  ASSERT_EQ(
      setup.slots.size(),
      3U);
 
  EXPECT_EQ(
      setup.slots[0].slot,
      0);
 
  EXPECT_EQ(
      setup.slots[0].moduleIdent,
      0x00008001U);
 
  EXPECT_EQ(
      setup.slots[1].slot,
      1);
 
  EXPECT_EQ(
      setup.slots[1].moduleIdent,
      0x00008000U);
 
  EXPECT_EQ(
      setup.slots[1].submoduleIdent,
      0x00000022U);
 
  EXPECT_EQ(
      setup.slots[1].inputLength,
      34U);
 
  EXPECT_EQ(
      setup.slots[1].outputLength,
      0U);
 
  EXPECT_EQ(
      setup.slots[2].slot,
      2);
 
  EXPECT_EQ(
      setup.slots[2].moduleIdent,
      0x00008100U);
 
  EXPECT_EQ(
      setup.slots[2].submoduleIdent,
      0x00000011U);
 
  EXPECT_EQ(
      setup.slots[2].inputLength,
      0U);
 
  EXPECT_EQ(
      setup.slots[2].outputLength,
      16U);
}
 
// -----------------------------------------------------------------------------
// ApplicationReady integration tests
// -----------------------------------------------------------------------------
 
TEST_F(RpcConIntegrationTest, ApplicationReady)
{
  ASSERT_NO_THROW(
      Connect());
 
  ASSERT_TRUE(
      connection->IsConnected());
 
  ASSERT_TRUE(
      testDevice->WaitForConnect());
 
  ASSERT_NO_THROW(
      testDevice->SendApplicationReadyRequest(
          connection->ArUuid(),
          connection->SessionKey()));
 
  EXPECT_NO_THROW(
      connection->ApplicationReady(1.0));
 
  EXPECT_TRUE(
      testDevice->ReceivedApplicationReadyResponse());
 
  const auto response =
      testDevice->ApplicationReadyResponse();
 
  ASSERT_TRUE(
      response.has_value());
 
  EXPECT_EQ(
      response->blockType,
      BLOCK_IOD_CONTROL_APP_READY_RES);
 
  EXPECT_EQ(
      response->controlCommand,
      CONTROL_CMD_DONE);
 
  EXPECT_EQ(
      response->arUuid,
      connection->ArUuid());
 
  EXPECT_EQ(
      response->sessionKey,
      connection->SessionKey());
}
 
TEST_F(RpcConIntegrationTest, ApplicationReadyReceivesCorrectRequest)
{
  ASSERT_NO_THROW(
      Connect());
 
  ASSERT_TRUE(
      testDevice->WaitForConnect());
 
  ASSERT_NO_THROW(
      testDevice->SendApplicationReadyRequest(
          connection->ArUuid(),
          connection->SessionKey()));
 
  EXPECT_NO_THROW(
      connection->ApplicationReady(1.0));
 
  const auto request =
      testDevice->LastApplicationReadyRequest();
 
  ASSERT_TRUE(
      request.has_value());
 
  EXPECT_EQ(
      request->blockType,
      BLOCK_IOD_CONTROL_APP_READY_REQ);
 
  EXPECT_EQ(
      request->controlCommand,
      CONTROL_CMD_APP_READY);
 
  EXPECT_EQ(
      request->arUuid,
      connection->ArUuid());
 
  EXPECT_EQ(
      request->sessionKey,
      connection->SessionKey());
 
  EXPECT_EQ(
      request->controlBlockProperties,
      0);
}
 
TEST_F(RpcConIntegrationTest, ApplicationReadyResponseMatchesRequest)
{
  ASSERT_NO_THROW(
      Connect());
 
  ASSERT_TRUE(
      testDevice->WaitForConnect());
 
  ASSERT_NO_THROW(
      testDevice->SendApplicationReadyRequest(
          connection->ArUuid(),
          connection->SessionKey()));
 
  EXPECT_NO_THROW(
      connection->ApplicationReady(1.0));
 
  const auto request =
      testDevice->LastApplicationReadyRpcRequest();
 
  const auto response =
      testDevice->LastApplicationReadyRpcResponse();
 
  ASSERT_TRUE(
      request.has_value());
 
  ASSERT_TRUE(
      response.has_value());
 
  EXPECT_EQ(
      response->packetType,
      PNRPCHeader::RESPONSE);
 
  EXPECT_EQ(
      response->version,
      request->version);
  /*
    EXPECT_EQ(
        response->drep,
        request->drep);
 
*/
  EXPECT_EQ(
      response->objectUuid,
      request->objectUuid);
 
  EXPECT_EQ(
      response->interfaceUuid,
      request->interfaceUuid);
 
  EXPECT_EQ(
      response->activityUuid,
      request->activityUuid);
 
  EXPECT_EQ(
      response->sequenceNumber,
      request->sequenceNumber);
 
  EXPECT_EQ(
      response->operationNumber,
      PNRPCHeader::CONTROL);
 
  EXPECT_EQ(
      response->interfaceHint,
      0xFFFF);
 
  EXPECT_EQ(
      response->activityHint,
      0xFFFF);
}
 
TEST_F(RpcConIntegrationTest, ApplicationReadyResponseHasSuccessfulNrdStatus)
{
  ASSERT_NO_THROW(
      Connect());
 
  ASSERT_TRUE(
      testDevice->WaitForConnect());
 
  ASSERT_NO_THROW(
      testDevice->SendApplicationReadyRequest(
          connection->ArUuid(),
          connection->SessionKey()));
 
  EXPECT_NO_THROW(
      connection->ApplicationReady(1.0));
 
  const auto nrd =
      testDevice->LastApplicationReadyResponseNrd();
 
  ASSERT_TRUE(
      nrd.has_value());
 
  EXPECT_EQ(
      nrd->argsMaximumStatus,
      0U);
 
  EXPECT_EQ(
      nrd->offset,
      0U);
 
  EXPECT_EQ(
      nrd->actualCount,
      nrd->argsLength);
 
  EXPECT_EQ(
      nrd->maximumCount,
      nrd->argsLength);
}
 
TEST_F(RpcConIntegrationTest, ApplicationReadyTimesOut)
{
  ASSERT_NO_THROW(
      Connect());
 
  ASSERT_TRUE(
      testDevice->WaitForConnect());
 
  EXPECT_THROW(
      connection->ApplicationReady(
          std::chrono::milliseconds{50}.count() / 1000.0),
      RPCTimeoutError);
}
 
TEST_F(RpcConIntegrationTest, ApplicationReadyIgnoresNonControlRequest)
{
  ASSERT_NO_THROW(
      Connect());
 
  ASSERT_TRUE(
      testDevice->WaitForConnect());
 
  testDevice->SendRpcRequest(
      PNRPCHeader::READ);
 
  testDevice->SendApplicationReadyRequest(
      connection->ArUuid(),
      connection->SessionKey());
 
  EXPECT_NO_THROW(
      connection->ApplicationReady(1.0));
 
  EXPECT_TRUE(
      testDevice->ReceivedApplicationReadyResponse());
 
  const auto response =
      testDevice->ApplicationReadyResponse();
 
  ASSERT_TRUE(
      response.has_value());
 
  EXPECT_EQ(
      response->operationNumber,
      PNRPCHeader::CONTROL);
 
  EXPECT_EQ(
      response->controlCommand,
      CONTROL_CMD_DONE);
}
 
TEST_F(RpcConIntegrationTest, ApplicationReadyIgnoresRpcResponse)
{
  ASSERT_NO_THROW(
      Connect());
 
  ASSERT_TRUE(
      testDevice->WaitForConnect());
 
  testDevice->SendRpcResponse(
      PNRPCHeader::CONTROL);
 
  testDevice->SendApplicationReadyRequest(
      connection->ArUuid(),
      connection->SessionKey());
 
  EXPECT_NO_THROW(
      connection->ApplicationReady(1.0));
 
  EXPECT_TRUE(
      testDevice->ReceivedApplicationReadyResponse());
 
  const auto response =
      testDevice->ApplicationReadyResponse();
 
  ASSERT_TRUE(
      response.has_value());
 
  EXPECT_EQ(
      response->packetType,
      PNRPCHeader::RESPONSE);
 
  EXPECT_EQ(
      response->operationNumber,
      PNRPCHeader::CONTROL);
 
  EXPECT_EQ(
      response->controlCommand,
      CONTROL_CMD_DONE);
}
 
TEST_F(RpcConIntegrationTest, ApplicationReadyIgnoresOtherControlBlock)
{
  ASSERT_NO_THROW(
      Connect());
 
  ASSERT_TRUE(
      testDevice->WaitForConnect());
 
  testDevice->SendControlRequest(
      BLOCK_IOD_CONTROL_PRM_END_REQ,
      CONTROL_CMD_PRM_END,
      connection->ArUuid(),
      connection->SessionKey());
 
  EXPECT_THROW(
      connection->ApplicationReady(
          std::chrono::milliseconds{50}.count() / 1000.0),
      RPCTimeoutError);
 
  EXPECT_FALSE(
      testDevice->ReceivedApplicationReadyResponse());
}
 
TEST_F(RpcConIntegrationTest, ApplicationReadyAcceptsUnexpectedControlCommand)
{
  ASSERT_NO_THROW(
      Connect());
 
  ASSERT_TRUE(
      testDevice->WaitForConnect());
 
  testDevice->SendControlRequest(
      BLOCK_IOD_CONTROL_APP_READY_REQ,
      0x1234,
      connection->ArUuid(),
      connection->SessionKey());
 
  EXPECT_NO_THROW(
      connection->ApplicationReady(1.0));
 
  EXPECT_TRUE(
      testDevice->ReceivedApplicationReadyResponse());
 
  const auto response =
      testDevice->ApplicationReadyResponse();
 
  ASSERT_TRUE(
      response.has_value());
 
  EXPECT_EQ(
      response->blockType,
      BLOCK_IOD_CONTROL_APP_READY_RES);
 
  EXPECT_EQ(
      response->controlCommand,
      CONTROL_CMD_DONE);
 
  EXPECT_EQ(
      response->arUuid,
      connection->ArUuid());
 
  EXPECT_EQ(
      response->sessionKey,
      connection->SessionKey());
}