test_protocol.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include "profinet/protocol.h"
 
using namespace profinet;
 
class ProtocolTest : public ::testing::Test
{
};
 
TEST_F(ProtocolTest, PNDCPHeaderRoundTrips)
{
  PNDCPHeader h;
  h.frameId = DcpFrameId::GetSet;
  h.serviceId = DcpServiceId::Identify;
  h.serviceType = DcpServiceType::Request;
  h.xId = 0x12345678;
  h.respDelay = 0x0080;
  h.length = 4;
  h.payload = {0xFF, 0xFF, 0x00, 0x00};
 
  const Bytes encoded = h.ToBytes();
 
  EXPECT_EQ(encoded.size(), PNDCPHeader::kFixedSize + h.payload.size());
 
  const PNDCPHeader decoded = PNDCPHeader::Parse(encoded);
 
  EXPECT_EQ(decoded.frameId, h.frameId);
  EXPECT_EQ(decoded.serviceId, h.serviceId);
  EXPECT_EQ(decoded.xId, h.xId);
  EXPECT_EQ(decoded.respDelay, h.respDelay);
  EXPECT_EQ(decoded.length, h.length);
  EXPECT_EQ(decoded.payload, h.payload);
}
 
TEST_F(ProtocolTest, PNDCPBlockParsesStatusAndPayload)
{
  // option=1 suboption=2, length=14
  // 2 status bytes + 12 IP payload bytes
  Bytes data = {
      0x01,
      0x02,
      0x00,
      0x0E,
      0x00,
      0x00};
 
  std::vector<std::uint8_t> ipPayload = {
      192, 168, 1, 1,
      255, 255, 255, 0,
      192, 168, 1, 254};
 
  data.insert(
      data.end(),
      ipPayload.begin(),
      ipPayload.end());
 
  const PNDCPBlock block = PNDCPBlock::Parse(data);
 
  EXPECT_EQ(
      block.option,
      static_cast<std::uint8_t>(1));
 
  EXPECT_EQ(
      block.suboption,
      static_cast<std::uint8_t>(2));
 
  EXPECT_EQ(
      block.payload.size(),
      static_cast<std::size_t>(12));
 
  const IPConfiguration ip = block.ParseIp();
 
  EXPECT_EQ(ip.address, "192.168.1.1");
  EXPECT_EQ(ip.netmask, "255.255.255.0");
  EXPECT_EQ(ip.gateway, "192.168.1.254");
}
 
TEST_F(ProtocolTest, EthernetHeaderRoundTrips)
{
  EthernetHeader eth;
 
  eth.dst = String2Mac("01:0e:cf:00:00:00");
  eth.src = String2Mac("aa:bb:cc:dd:ee:ff");
  eth.type = PROFINET_ETHERTYPE;
  eth.payload = {
      0x01,
      0x02,
      0x03};
 
  const Bytes encoded = eth.ToBytes();
 
  const EthernetHeader decoded =
      EthernetHeader::Parse(encoded);
 
  EXPECT_EQ(decoded.dst, eth.dst);
  EXPECT_EQ(decoded.src, eth.src);
  EXPECT_EQ(decoded.type, eth.type);
  EXPECT_EQ(decoded.payload, eth.payload);
}
 
// This test pins them so a future edit can't silently
// reintroduce a sizing bug that would break wire compatibility.
 
TEST_F(ProtocolTest, PacketStructFixedSizesMatchExpectedSizes)
{
  EXPECT_EQ(
      PNDCPHeader::kFixedSize,
      static_cast<std::size_t>(12));
 
  EXPECT_EQ(
      PNDCPBlockRequest::kFixedSize,
      static_cast<std::size_t>(4));
 
  EXPECT_EQ(
      PNDCPBlock::kFixedSize,
      static_cast<std::size_t>(6));
 
  EXPECT_EQ(
      PNRPCHeader::kFixedSize,
      static_cast<std::size_t>(80));
 
  EXPECT_EQ(
      PNNRDData::kFixedSize,
      static_cast<std::size_t>(20));
 
  EXPECT_EQ(
      PNIODHeader::kFixedSize,
      static_cast<std::size_t>(64));
 
  EXPECT_EQ(
      PNBlockHeader::kSize,
      static_cast<std::size_t>(6));
 
  EXPECT_EQ(
      PNARBlockRequest::kFixedSize,
      static_cast<std::size_t>(58));
 
  EXPECT_EQ(
      PNIODReleaseBlock::kSize,
      static_cast<std::size_t>(32));
 
  EXPECT_EQ(
      PNInM0::kSize,
      static_cast<std::size_t>(60));
 
  EXPECT_EQ(
      PNInM1::kSize,
      static_cast<std::size_t>(60));
 
  EXPECT_EQ(
      PNInM2::kSize,
      static_cast<std::size_t>(22));
 
  EXPECT_EQ(
      PNInM3::kSize,
      static_cast<std::size_t>(60));
 
  EXPECT_EQ(
      PNInM4::kSize,
      static_cast<std::size_t>(60));
 
  EXPECT_EQ(
      PNInM5::kSize,
      static_cast<std::size_t>(70));
 
  EXPECT_EQ(
      IOCRAPIObject::kSize,
      static_cast<std::size_t>(6));
 
  EXPECT_EQ(
      PNIOCRBlockRes::kSize,
      static_cast<std::size_t>(12));
 
  EXPECT_EQ(
      PNIOCRBlockReqHeader::kSize,
      static_cast<std::size_t>(46));
 
  EXPECT_EQ(
      PNAlarmCRBlockReq::kSize,
      static_cast<std::size_t>(26));
 
  EXPECT_EQ(
      PNAlarmCRBlockRes::kSize,
      static_cast<std::size_t>(12));
 
  EXPECT_EQ(
      PNAlarmNotificationPDU::kFixedSize,
      static_cast<std::size_t>(26));
 
  EXPECT_EQ(
      PNAlarmAckPDU::kSize,
      static_cast<std::size_t>(22));
 
  EXPECT_EQ(
      PNRTAHeader::kFixedSize,
      static_cast<std::size_t>(12));
 
  EXPECT_EQ(
      PNExpectedSubmoduleDataDescription::kSize,
      static_cast<std::size_t>(6));
 
  EXPECT_EQ(
      PNIODWriteReq::kFixedSize,
      static_cast<std::size_t>(64));
 
  EXPECT_EQ(
      PNIODWriteRes::kSize,
      static_cast<std::size_t>(64));
 
  // Cross-check against ToBytes() actually producing the expected size.
  EXPECT_EQ(
      PNARBlockRequest{}.ToBytes().size(),
      PNARBlockRequest::kFixedSize);
 
  EXPECT_EQ(
      PNAlarmCRBlockReq{}.ToBytes().size(),
      PNAlarmCRBlockReq::kSize);
 
  EXPECT_EQ(
      PNIOCRBlockReqHeader{}.ToBytes().size(),
      PNIOCRBlockReqHeader::kSize);
 
  EXPECT_EQ(
      PNAlarmAckPDU{}.ToBytes().size(),
      PNAlarmAckPDU::kSize);
 
  EXPECT_EQ(
      PNRTAHeader{}.ToBytes().size(),
      PNRTAHeader::kFixedSize);
 
  EXPECT_EQ(
      PNIODWriteReq{}.ToBytes().size(),
      PNIODWriteReq::kFixedSize);
}
 
TEST_F(ProtocolTest, PNRPCHeaderInterfaceUUIDMatchesExpectedPrefix)
{
  auto uuid = PNRPCHeader::IfaceUuidDevice();
 
  EXPECT_EQ(
      uuid[0],
      static_cast<std::uint8_t>(0xDE));
 
  EXPECT_EQ(
      uuid[1],
      static_cast<std::uint8_t>(0xA0));
 
  EXPECT_EQ(
      uuid[2],
      static_cast<std::uint8_t>(0x00));
 
  EXPECT_EQ(
      uuid[3],
      static_cast<std::uint8_t>(0x01));
}
TEST(EthernetVLANHeaderTests, RejectsTruncatedHeader)
{
  constexpr std::size_t kHeaderSize = 18U;
 
  for (std::size_t size = 0U; size < kHeaderSize; ++size)
  {
    const Bytes data(size);
 
    EXPECT_THROW((void)EthernetVLANHeader::Parse(data), std::runtime_error);
  }
}
TEST(EthernetVLANHeaderTests, AcceptsCompleteHeader)
{
  constexpr std::size_t kHeaderSize = 18U;
 
  Bytes data(kHeaderSize, 0U);
 
  EXPECT_NO_THROW((void)EthernetVLANHeader::Parse(data));
}