test_dcpWireFormat.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <array>
#include <cstdint>
#include <span>
#include <string>
 
#include "profinet/dcp.h"
#include "profinet/exceptions.h"
#include "profinet/protocol.h"
#include "profinet/wire.h"
 
namespace profinet::dcp
{
 
namespace
{
 
constexpr MacAddress kControllerMac{0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
constexpr MacAddress kDeviceMac{0x02, 0x00, 0x00, 0x00, 0x00, 0x01};
 
constexpr std::size_t kEthernetHeaderLength = 14U;
constexpr std::size_t kDcpHeaderLength = 12U;
constexpr std::size_t kDcpPayloadOffset = kEthernetHeaderLength + kDcpHeaderLength;
 
constexpr std::uint16_t kExpectedDcpFrameId = static_cast<std::uint16_t>(DcpFrameId::GetSet);
constexpr std::uint8_t kExpectedSetServiceId = static_cast<std::uint8_t>(DcpServiceId::Set);
constexpr std::uint8_t kExpectedRequestServiceType = static_cast<std::uint8_t>(DcpServiceType::Request);
 
[[nodiscard]] std::uint16_t ReadU16(std::span<const std::uint8_t> frame, std::size_t offset)
{
  EXPECT_GE(frame.size(), offset + 2U);
 
  return static_cast<std::uint16_t>((static_cast<std::uint16_t>(frame[offset]) << 8U) |
                                    static_cast<std::uint16_t>(frame[offset + 1U]));
}
 
[[nodiscard]] std::uint32_t ReadU32(std::span<const std::uint8_t> frame, std::size_t offset)
{
  EXPECT_GE(frame.size(), offset + 4U);
 
  return (static_cast<std::uint32_t>(frame[offset]) << 24U) |
         (static_cast<std::uint32_t>(frame[offset + 1U]) << 16U) |
         (static_cast<std::uint32_t>(frame[offset + 2U]) << 8U) |
         static_cast<std::uint32_t>(frame[offset + 3U]);
}
 
[[nodiscard]] std::size_t VerifySetFrameHeader(std::span<const std::uint8_t> frame)
{
  EXPECT_GE(frame.size(), kDcpPayloadOffset);
 
  if (frame.size() < kDcpPayloadOffset)
  {
    return {};
  }
  EXPECT_EQ((std::array<std::uint8_t, 6>{frame[0], frame[1], frame[2], frame[3], frame[4], frame[5]}), kDeviceMac);
  EXPECT_EQ((std::array<std::uint8_t, 6>{frame[6], frame[7], frame[8], frame[9], frame[10], frame[11]}), kControllerMac);
 
  EXPECT_EQ(ReadU16(frame, 12), PROFINET_ETHERTYPE);
  EXPECT_EQ(ReadU16(frame, 14), kExpectedDcpFrameId);
 
  EXPECT_EQ(frame[16], kExpectedSetServiceId);
  EXPECT_EQ(frame[17], kExpectedRequestServiceType);
 
  // XID occupies bytes 18..21 and is intentionally not checked because it is generated dynamically.
 
  // Response delay occupies bytes 22..23.
  EXPECT_EQ(ReadU16(frame, 22), 0U);
 
  // DCP length occupies bytes 24..25.
  const std::uint16_t dcpLength = ReadU16(frame, 24);
 
  EXPECT_EQ(frame.size() - kDcpPayloadOffset, dcpLength);
 
  return kDcpPayloadOffset;
}
 
} // namespace
 
class DcpWireFormatTest : public ::testing::Test
{
 protected:
  [[nodiscard]] Bytes BuildSetNameRequest(const std::string& name, bool permanent = false) const
  {
    return BuildSetParamRequest(kDeviceMac, kControllerMac, "name", name, permanent);
  }
 
  [[nodiscard]] profinet::Bytes BuildSignalRequest() const
  {
    return BuildDcpSignalRequest(kDeviceMac, kControllerMac);
  }
};
 
TEST_F(DcpWireFormatTest, OddLengthNameIsPaddedAndBlockLengthExcludesPadding)
{
  const Bytes frame = BuildSetNameRequest("abc");
  const std::size_t payloadOffset = VerifySetFrameHeader(frame);
  const auto payload = std::span<const std::uint8_t>(frame).subspan(payloadOffset);
 
  ASSERT_EQ(payload.size(), 10U);
 
  EXPECT_EQ(payload[0], PNDCPBlock::NAME_OF_STATION.first);
  EXPECT_EQ(payload[1], PNDCPBlock::NAME_OF_STATION.second);
  EXPECT_EQ(ReadU16(payload, 2), 5U);
  EXPECT_EQ(ReadU16(payload, 4), static_cast<std::uint16_t>(DcpBlockQualifier::Temporary));
 
  EXPECT_EQ(payload[6], static_cast<std::uint8_t>('a'));
  EXPECT_EQ(payload[7], static_cast<std::uint8_t>('b'));
  EXPECT_EQ(payload[8], static_cast<std::uint8_t>('c'));
 
  // Padding is present physically but excluded from BlockLength.
  EXPECT_EQ(payload[9], 0x00);
}
 
TEST_F(DcpWireFormatTest, EvenLengthNameIsNotPadded)
{
  const Bytes frame = BuildSetNameRequest("abcd");
  const std::size_t payloadOffset = VerifySetFrameHeader(frame);
  const auto payload = std::span<const std::uint8_t>(frame).subspan(payloadOffset);
 
  ASSERT_EQ(payload.size(), 10U);
 
  EXPECT_EQ(payload[0], PNDCPBlock::NAME_OF_STATION.first);
  EXPECT_EQ(payload[1], PNDCPBlock::NAME_OF_STATION.second);
 
  // BlockLength = BlockQualifier (2 bytes) + name (4 bytes).
  EXPECT_EQ(ReadU16(payload, 2), 6U);
  EXPECT_EQ(ReadU16(payload, 4), static_cast<std::uint16_t>(DcpBlockQualifier::Temporary));
 
  EXPECT_EQ(payload[6], static_cast<std::uint8_t>('a'));
  EXPECT_EQ(payload[7], static_cast<std::uint8_t>('b'));
  EXPECT_EQ(payload[8], static_cast<std::uint8_t>('c'));
  EXPECT_EQ(payload[9], static_cast<std::uint8_t>('d'));
}
 
TEST_F(DcpWireFormatTest, DefaultQualifierIsTemporary)
{
  const Bytes frame = BuildSetNameRequest("abcd");
  const std::size_t payloadOffset = VerifySetFrameHeader(frame);
  const auto payload = std::span<const std::uint8_t>(frame).subspan(payloadOffset);
 
  EXPECT_EQ(ReadU16(payload, 4), static_cast<std::uint16_t>(DcpBlockQualifier::Temporary));
}
 
TEST_F(DcpWireFormatTest, PermanentQualifierIsSerialized)
{
  const Bytes frame = BuildSetNameRequest("abcd", true);
  const std::size_t payloadOffset = VerifySetFrameHeader(frame);
  const auto payload = std::span<const std::uint8_t>(frame).subspan(payloadOffset);
 
  EXPECT_EQ(ReadU16(payload, 4), static_cast<std::uint16_t>(DcpBlockQualifier::Permanent));
}
 
TEST_F(DcpWireFormatTest, IpSetOperationIsRejected)
{
  EXPECT_THROW(BuildSetParamRequest(kDeviceMac,
                                    kControllerMac,
                                    "ip",
                                    "192.168.0.1",
                                    false),
               DCPError);
}
 
TEST_F(DcpWireFormatTest, IpParameterMatchingIsCaseInsensitive)
{
  EXPECT_THROW(BuildSetParamRequest(kDeviceMac,
                                    kControllerMac,
                                    "IP",
                                    "192.168.0.1",
                                    false),
               DCPError);
 
  EXPECT_THROW(BuildSetParamRequest(kDeviceMac,
                                    kControllerMac,
                                    "Ip",
                                    "192.168.0.1",
                                    false),
               DCPError);
 
  EXPECT_THROW(BuildSetParamRequest(kDeviceMac,
                                    kControllerMac,
                                    "iP",
                                    "192.168.0.1",
                                    false),
               DCPError);
}
 
TEST_F(DcpWireFormatTest, SignalUsesFlashOnceValue)
{
  const Bytes frame = BuildSignalRequest();
 
  ASSERT_GE(frame.size(), kDcpPayloadOffset + 8U);
 
  const auto payload = std::span<const std::uint8_t>(frame).subspan(kDcpPayloadOffset);
 
  EXPECT_EQ(payload[0], static_cast<std::uint16_t>(DcpOption::Control));
  EXPECT_EQ(payload[1], static_cast<std::uint8_t>(DcpControlSuboption::Signal));
  EXPECT_EQ(ReadU16(payload, 2), 4U);
 
  EXPECT_EQ(ReadU16(payload, 4), 0x0000U);
 
  EXPECT_EQ(payload[6], 0x01U);
  EXPECT_EQ(payload[7], 0x00U);
 
  EXPECT_EQ(payload.size(), 8U);
}
 
} // namespace profinet::dcp