test_cyclic.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <chrono>
#include <future>
#include <thread>
 
#include "mocks/cyclic_raw_ethernet_socket_stub.h"
#include "mocks/mockRawEthernetSocket.h"
#include "profinet/cyclic.h"
 
using namespace profinet;
using namespace profinet::cyclic;
 
namespace
{
 
rt::IOCRConfig MakeConfig(
    std::uint16_t sendClockFactor,
    std::uint16_t reductionRatio,
    std::uint16_t frameId)
{
  rt::IOCRConfig c;
  c.sendClockFactor = sendClockFactor;
  c.reductionRatio = reductionRatio;
  c.frameId = frameId;
  c.dataLength = 40;
  return c;
}
 
} // namespace
 
namespace profinet::cyclic
{
 
class CyclicTest : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    controller = MakeController();
  }
 
  static rt::IOCRConfig MakeConfig(std::uint16_t sendClockFactor, std::uint16_t reductionRatio, std::uint16_t frameId)
  {
    rt::IOCRConfig config;
    config.sendClockFactor = sendClockFactor;
    config.reductionRatio = reductionRatio;
    config.frameId = frameId;
    config.dataLength = 40;
    return config;
  }
 
  static std::unique_ptr<CyclicController> MakeController()
  {
    const auto input = MakeConfig(32, 32, 0xC001);
    const auto output = MakeConfig(32, 32, 0x8001);
    const MacAddress src = String2Mac("aa:bb:cc:dd:ee:ff");
    const MacAddress dst = String2Mac("11:22:33:44:55:66");
    auto ioContext = std::make_unique<asio::io_context>();
    return std::make_unique<CyclicController>(*ioContext, "lo", src, dst, input, output);
  }
  void StartControllerWithBlockedReceive()
  {
    auto rxSocket = std::make_unique<test::BlockingRawEthernetSocket>();
 
    auto* rxSocketForTest = rxSocket.get();
 
    const auto input = MakeConfig(32, 32, 0xC001);
    const auto output = MakeConfig(32, 32, 0x8001);
 
    const MacAddress src = String2Mac("aa:bb:cc:dd:ee:ff");
    const MacAddress dst = String2Mac("11:22:33:44:55:66");
    auto ioContext = std::make_unique<asio::io_context>();
 
    controller = std::make_unique<CyclicController>(
        *ioContext,
        "lo",
        src,
        dst,
        input,
        output,
        DEFAULT_MAX_CONSECUTIVE_TIMEOUTS,
        rt::ETHERTYPE_PROFINET);
 
    controller->Start(nullptr, std::move(rxSocket));
 
    rxSocketForTest->WaitUntilReceiveEntered();
  }
 
 
  [[nodiscard]] bool RxThreadJoinableForTest()
  {
    auto placeholder = controller->rxThread.joinable();
    return placeholder;
  }
  std::unique_ptr<CyclicController> controller;
};
TEST_F(CyclicTest, CyclicStateToStringCoversAllStates)
{
  EXPECT_EQ(ToString(CyclicState::Idle), "idle");
  EXPECT_EQ(ToString(CyclicState::Starting), "starting");
  EXPECT_EQ(ToString(CyclicState::Running), "running");
  EXPECT_EQ(ToString(CyclicState::Stopping), "stopping");
  EXPECT_EQ(ToString(CyclicState::Stopped), "stopped");
  EXPECT_EQ(ToString(CyclicState::Fault), "fault");
}
 
TEST_F(CyclicTest, CyclicStatsResetRestoresInitialValues)
{
  CyclicStats stats;
 
  stats.framesSent = 100;
  stats.framesMissed = 5;
  stats.cycleTimeSumUs = 5000;
  stats.cycleCount = 10;
 
  stats.Reset();
 
  EXPECT_EQ(stats.framesSent.load(), static_cast<std::uint64_t>(0));
  EXPECT_EQ(stats.framesMissed.load(), static_cast<std::uint64_t>(0));
  EXPECT_EQ(stats.AvgCycleTimeUs(), static_cast<std::uint64_t>(0));
}
 
TEST_F(CyclicTest, CyclicControllerRejectsNegativeMaxConsecutiveTimeouts)
{
  auto input = MakeConfig(32, 32, 0xC001);
  auto output = MakeConfig(32, 32, 0x8001);
 
  const MacAddress src = String2Mac("aa:bb:cc:dd:ee:ff");
 
  const MacAddress dst = String2Mac("11:22:33:44:55:66");
  auto ioContext = std::make_unique<asio::io_context>();
 
  EXPECT_THROW(CyclicController(
                   *ioContext,
                   "lo",
                   src,
                   dst,
                   input,
                   output,
                   /*MaxConsecutiveTimeouts=*/-1),
               std::invalid_argument);
}
 
TEST_F(CyclicTest, CyclicControllerRejectsSub1msCycleTime)
{
  // send_clock_factor=1, reduction_ratio=1
  // cycle_time_us = 1*1*125/4 = 31us
  auto input = MakeConfig(1, 1, 0xC001);
  auto output = MakeConfig(1, 1, 0x8001);
 
  const MacAddress src = String2Mac("aa:bb:cc:dd:ee:ff");
 
  const MacAddress dst = String2Mac("11:22:33:44:55:66");
  auto ioContext = std::make_unique<asio::io_context>();
  EXPECT_THROW(CyclicController(
                   *ioContext,
                   "lo",
                   src,
                   dst,
                   input,
                   output),
               std::exception);
}
 
TEST_F(CyclicTest, CyclicControllerConstructsWithSafeCycleTime)
{
  auto input = MakeConfig(32, 32, 0xC001);
  auto output = MakeConfig(32, 32, 0x8001);
 
  const MacAddress src = String2Mac("aa:bb:cc:dd:ee:ff");
 
  const MacAddress dst = String2Mac("11:22:33:44:55:66");
  auto ioContext = std::make_unique<asio::io_context>();
  const CyclicController c(
      *ioContext,
      "lo",
      src,
      dst,
      input,
      output);
 
  EXPECT_EQ(ToString(c.State()), "idle");
 
  EXPECT_FALSE(c.IsRunning());
}
 
} // namespace profinet::cyclic