test_rt.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include "profinet/rpc.h"
#include "profinet/rt.h"
 
using namespace profinet;
using namespace profinet::rt;
 
class RTTest : public ::testing::Test
{
};
 
TEST_F(RTTest, RTFrameRoundTrips)
{
  RTFrame frame;
  frame.frameId = 0xC001;
  frame.cycleCounter = 1024;
  frame.dataStatus = DATA_STATUS_VALID |
                     DATA_STATUS_PROVIDER_RUN;
  frame.transferStatus = 0;
  frame.payload = {0xDE, 0xAD, 0xBE, 0xEF};
 
  const Bytes encoded = frame.ToBytes();
 
  EXPECT_EQ(encoded.size(), static_cast<std::size_t>(2 + 4 + 4));
 
  const RTFrame decoded = RTFrame::FromBytes(encoded);
 
  EXPECT_EQ(decoded.frameId, frame.frameId);
  EXPECT_EQ(decoded.cycleCounter, frame.cycleCounter);
  EXPECT_EQ(decoded.dataStatus, frame.dataStatus);
  EXPECT_EQ(decoded.payload, frame.payload);
 
  EXPECT_TRUE(decoded.IsValid());
  EXPECT_TRUE(decoded.IsRunning());
  EXPECT_FALSE(decoded.IsOk());
}
 
TEST_F(RTTest, RTFrameRejectsTooShortData)
{
  EXPECT_THROW(RTFrame::FromBytes({0x01, 0x02}), std::exception);
}
 
TEST_F(RTTest, BuildAndParseEthernetFrameRoundTrips)
{
  const MacAddress dst = String2Mac("aa:bb:cc:dd:ee:ff");
 
  const MacAddress src = String2Mac("11:22:33:44:55:66");
 
  RTFrame frame;
  frame.frameId = 0x8001;
  frame.cycleCounter = 5;
  frame.dataStatus = DATA_STATUS_VALID;
  frame.payload = {0x01, 0x02, 0x03};
 
  const Bytes eth = BuildEthernetFrame(dst, src, frame);
 
  auto parsed = ParseEthernetFrame(eth);
 
  ASSERT_TRUE(parsed.has_value());
 
  EXPECT_EQ(parsed->frameId, frame.frameId);
 
  EXPECT_EQ(parsed->payload, frame.payload);
}
 
TEST_F(RTTest, ParseEthernetFrameRejectsNonProfinetEthertype)
{
  Bytes eth(18, 0);
 
  eth[12] = 0x08;
  eth[13] = 0x00; // IPv4 ethertype
 
  auto parsed = ParseEthernetFrame(eth);
 
  EXPECT_FALSE(parsed.has_value());
}
 
TEST_F(RTTest, CyclicDataBuilderSetGetDataRoundTripsThroughSwap)
{
  IOCRConfig config;
  config.dataLength = 10;
  config.objects = {{.slot = 1, .subslot = 1, .frameOffset = 0, .dataLength = 4, .offsetIOPS = 4, .offsetIOCS = 0}};
 
  CyclicDataBuilder builder(config);
 
  builder.SetData(1, 1, {0x11, 0x22, 0x33, 0x44});
 
  builder.SetIops(1, 1, IOXS_GOOD);
 
  Bytes beforeSwap = builder.Build();
 
  EXPECT_EQ(beforeSwap[0], static_cast<std::uint8_t>(0));
 
  builder.Swap();
 
  Bytes afterSwap = builder.Build();
 
  EXPECT_EQ(afterSwap[0], static_cast<std::uint8_t>(0x11));
 
  EXPECT_EQ(afterSwap[4], IOXS_GOOD);
 
  const Bytes readback = builder.GetData(1, 1);
 
  EXPECT_EQ(readback, Bytes({0x11, 0x22, 0x33, 0x44}));
}
 
TEST_F(RTTest, CyclicDataBuilderRejectsUnknownSlotSubslot)
{
  IOCRConfig config;
  config.dataLength = 4;
 
  CyclicDataBuilder builder(config);
 
  EXPECT_THROW(builder.SetData(9, 9, {0x01}), std::exception);
}
 
TEST_F(RTTest, BuildReturnsStablePublishedSnapshot)
{
  IOCRConfig config;
  config.dataLength = 10;
  config.objects = {{.slot = 1, .subslot = 1, .frameOffset = 0, .dataLength = 4, .offsetIOPS = 4, .offsetIOCS = 0}};
  CyclicDataBuilder builder(config);
  builder.SetData(1, 1, {0x80, 0x01});
  builder.Swap();
  const auto first = builder.Build();
 
  builder.SetData(1, 1, {0x80, 0x02});
  EXPECT_EQ(builder.Build(), first);
 
  builder.Swap();
  EXPECT_NE(builder.Build(), first);
}
 
TEST_F(RTTest, ConcurrentSetDataAndBuildIsRaceFree)
{
  IOCRConfig config;
  config.dataLength = 10;
  config.objects = {{.slot = 1, .subslot = 1, .frameOffset = 0, .dataLength = 4, .offsetIOPS = 4, .offsetIOCS = 0}};
  CyclicDataBuilder builder(config);
 
  std::atomic_bool stop{false};
  std::jthread writer([&]
  {
    while (!stop.load())
    {
      builder.SetData(1, 1, {0x80, 0x01});
      builder.Swap();
    }
  });
  auto expectedFrameSize = 10U;
  for (int i = 0; i < 10000; ++i)
  {
    const auto frame = builder.Build();
    ASSERT_LE(frame.size(), expectedFrameSize);
  }
  stop = true;
}
 
TEST_F(RTTest, DISABLED_BuildIocrConfigsComputesExpectedFrameOffsets)
{
  const std::vector<rpc::IOSlot> slots = {{.slot = 0, .subslot = 1, /*input=*/.inputLength = 4, /*output=*/.outputLength = 0, .moduleIdent = 0, .submoduleIdent = 0}, {.slot = 1, .subslot = 1, /*input=*/.inputLength = 0, /*output=*/.outputLength = 2, .moduleIdent = 0, .submoduleIdent = 0}};
 
  auto [input_iocr, output_iocr] = BuildIocrConfigs(slots, 0xC001, 0x8001);
 
  // Input IOCR:
  // slot 0 has 4 bytes data + 1 IOPS = 5 bytes.
  // slot 1 has no input and gets a 1-byte IOCS placeholder.
  // Total is padded to the 40-byte minimum.
  ASSERT_EQ(input_iocr.objects.size(), static_cast<std::size_t>(1));
 
  EXPECT_EQ(input_iocr.objects[0].frameOffset, 0);
  EXPECT_EQ(input_iocr.objects[0].dataLength, 4);
 
  EXPECT_EQ(input_iocr.objects[0].offsetIOPS, 4);
 
  EXPECT_EQ(input_iocr.dataLength, 40);
 
  EXPECT_EQ(input_iocr.frameId, static_cast<std::uint16_t>(0xC001));
 
  // Output IOCR:
  // slot 1 has 2 bytes data + 1 IOPS.
  // slot 0 has no output and gets an IOCS entry.
  ASSERT_EQ(output_iocr.objects.size(), static_cast<std::size_t>(2));
 
  EXPECT_EQ(output_iocr.objects[0].slot, 1);
 
  EXPECT_EQ(output_iocr.objects[0].dataLength, 2);
 
  EXPECT_EQ(output_iocr.objects[1].slot, 0);
 
  EXPECT_EQ(output_iocr.objects[1].dataLength, 0);
 
  EXPECT_GT(output_iocr.objects[1].offsetIOCS, 0);
 
  EXPECT_EQ(output_iocr.frameId, static_cast<std::uint16_t>(0x8001));
}