test_cyclicMore.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <array>
#include <cstdint>
#include <future>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
 
#include "mocks/cyclic_raw_ethernet_socket_stub.h"
#include "mocks/mockRawEthernetSocket.h"
#include "profinet/cyclic.h"
#include "profinet/rt.h"
 
using namespace profinet;
using namespace profinet::cyclic;
 
namespace
{
 
constexpr MacAddress kControllerMac{0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
constexpr MacAddress kDeviceMac{0x02, 0x00, 0x00, 0x00, 0x00, 0x01};
constexpr std::uint16_t kInputFrameId = 0xC001;
constexpr std::uint16_t kOutputFrameId = 0xC000;
constexpr std::uint16_t kProfinetEtherType = rt::ETHERTYPE_PROFINET;
 
rt::IOCRConfig MakeConfig(std::uint16_t frameId,
                          std::uint16_t sendClockFactor = 32,
                          std::uint16_t reductionRatio = 8,
                          std::uint16_t watchdogFactor = 3)
{
  rt::IOCRConfig config;
  config.frameId = frameId;
  config.sendClockFactor = sendClockFactor;
  config.reductionRatio = reductionRatio;
  config.watchdogFactor = watchdogFactor;
  config.dataLength = 40;
  config.objects.push_back(rt::IODataObject{
      .slot = 1,
      .subslot = 1,
      .frameOffset = 0,
      .dataLength = 4,
      .offsetIOPS = 4,
      .offsetIOCS = 0});
  return config;
}
 
Bytes BuildInputFrame(const MacAddress& source,
                      const MacAddress& destination,
                      std::uint16_t frameId = kInputFrameId,
                      std::uint16_t cycleCounter = 1,
                      std::uint8_t dataStatus = rt::RTFrame::DATA_VALID | rt::RTFrame::DATA_RUN,
                      std::uint8_t transferStatus = 0,
                      Bytes payload = {})
{
  if (payload.empty())
  {
    payload = {0xAA, 0xBB, 0xCC, 0xDD, rt::IOXS_GOOD};
    payload.resize(40U, 0x00);
  }
 
  rt::RTFrame frame;
  frame.frameId = frameId;
  frame.cycleCounter = cycleCounter;
  frame.dataStatus = dataStatus;
  frame.transferStatus = transferStatus;
  frame.payload = std::move(payload);
 
  const Bytes rtBytes = frame.ToBytes();
  Bytes ethernet;
  ethernet.insert(ethernet.end(), destination.begin(), destination.end());
  ethernet.insert(ethernet.end(), source.begin(), source.end());
  ethernet.push_back(static_cast<std::uint8_t>((kProfinetEtherType >> 8U) & 0xFFU));
  ethernet.push_back(static_cast<std::uint8_t>(kProfinetEtherType & 0xFFU));
  ethernet.insert(ethernet.end(), rtBytes.begin(), rtBytes.end());
  return ethernet;
}
 
} // namespace
 
namespace profinet::cyclic
{
 
class CyclicControllerTestAccess
{
 public:
  static void SetState(CyclicController& controller, CyclicState value)
  {
    controller.state = value;
  }
 
  static void SetRunning(CyclicController& controller, bool value)
  {
    controller.running = value;
  }
 
  static void SetTxSock(CyclicController& controller, std::unique_ptr<IRawEthernetSocket> txSock)
  {
    controller.txSock = std::move(txSock);
  }
 
  static void SetRxSock(CyclicController& controller, std::unique_ptr<IRawEthernetSocket> rxSock)
  {
    controller.rxSock = std::move(rxSock);
  }
 
  static void Transition(CyclicController& controller, CyclicState value)
  {
    controller.Transition(value);
  }
 
  static void TxCycle(CyclicController& controller)
  {
    controller.TxCycle();
  }
 
  static void TxLoop(CyclicController& controller)
  {
    controller.TxLoop();
  }
 
  static void SendOutputFrame(CyclicController& controller,
                              std::optional<std::uint8_t> dataStatusOverride = std::nullopt)
  {
    controller.SendOutputFrame(dataStatusOverride);
  }
 
  static void SendStopFrames(CyclicController& controller)
  {
    controller.SendStopFrames();
  }
 
  static void ProcessInputFrame(CyclicController& controller, const Bytes& data)
  {
    controller.ProcessInputFrame(data);
  }
 
  static void HandleWatchdogTimeout(CyclicController& controller)
  {
    controller.HandleWatchdogTimeout();
  }
 
  static void RxLoop(CyclicController& controller)
  {
    controller.RxLoop();
  }
 
  static void TrackCycleCounter(CyclicController& controller, std::uint16_t cycleCounter)
  {
    controller.TrackCycleCounter(cycleCounter);
  }
 
  static void SetMaxConsecutiveTimeouts(CyclicController& controller, int value)
  {
    controller.maxConsecutiveTimeouts = value;
  }
 
  static void SetIocsGood(CyclicController& controller, bool value)
  {
    controller.iocsGood = value;
  }
  static void SetAllOutputIocs(CyclicController& controller, std::uint8_t status)
  {
    controller.outputBuilder.SetAllIocs(status);
  }
  [[nodiscard]] static bool IocsGood(const CyclicController& controller)
  {
    return controller.iocsGood;
  }
 
  static void SwapOutputBuilder(CyclicController& controller)
  {
    controller.outputBuilder.Swap();
  }
 
  [[nodiscard]] static std::uint8_t FirstOutputByte(const CyclicController& controller)
  {
    return controller.outputBuilder.Build().at(0);
  }
 
  static void SetRxCounterStep(CyclicController& controller, std::uint32_t value)
  {
    controller.rxCounterStep = value;
  }
 
  static rt::IODataObject& InputObject(CyclicController& controller, std::size_t index)
  {
    return controller.inputIocr.objects.at(index);
  }
 
  static void ResetTxSocket(CyclicController& controller)
  {
    controller.txSock.reset();
  }
 
  static void ResetRxSocket(CyclicController& controller)
  {
    controller.rxSock.reset();
  }
 
  static CyclicStats& Stats(CyclicController& controller)
  {
    return controller.stats;
  }
  [[nodiscard]] static std::uint8_t FirstOutputIocs(const CyclicController& controller)
  {
    const auto& object = controller.outputIocr.objects.front();
    const Bytes frame = controller.outputBuilder.Build();
 
    return object.offsetIOCS.has_value() ? frame.at(*object.offsetIOCS) : 0x00;
  }
};
 
class CyclicStateTests : public ::testing::Test
{
 protected:
  std::unique_ptr<CyclicController> MakeController()
  {
    asio::io_context ioContext;
 
    return std::make_unique<CyclicController>(
        ioContext, "eth0", kControllerMac, kDeviceMac,
        MakeConfig(kInputFrameId), MakeConfig(kOutputFrameId),
        DEFAULT_MAX_CONSECUTIVE_TIMEOUTS, kProfinetEtherType);
  }
 
  std::unique_ptr<CyclicController> controller = MakeController();
 
  std::unique_ptr<MockRawEthernetSocket> txSock = std::make_unique<MockRawEthernetSocket>();
 
  std::unique_ptr<MockRawEthernetSocket> rxSock = std::make_unique<MockRawEthernetSocket>();
 
  int callbackCount{0};
};
 
TEST_F(CyclicStateTests, StopDoesNotDestroyRxSocketBeforeRxThreadExits)
{
  auto socketState = std::make_shared<test::LifetimeTrackingSocketState>();
 
  auto txSocket = std::make_unique<MockRawEthernetSocket>();
  auto rxSocket = std::make_unique<test::LifetimeTrackingRawEthernetSocket>(socketState);
  auto* rxSocketPtr = rxSocket.get();
  auto ioContext = std::make_unique<asio::io_context>();
  controller = std::make_unique<CyclicController>(
      *ioContext, "eth0", kControllerMac, kDeviceMac,
      MakeConfig(kInputFrameId), MakeConfig(kOutputFrameId),
      DEFAULT_MAX_CONSECUTIVE_TIMEOUTS, kProfinetEtherType);
 
  controller->Start(std::move(txSocket), std::move(rxSocket));
 
  // Prove the RX thread is inside Recv().
  {
    std::unique_lock lock(socketState->mutex);
 
    socketState->receiveEnteredCv.wait(lock, [&]
    {
      return socketState->receiveEntered;
    });
  }
 
 
  std::atomic<bool> stopFinished;
  std::thread stopThread(
      [&]
  {
    // stopStarted.set_value();
    controller->Stop();
    stopFinished.store(true, std::memory_order_release);
  });
 
  // Give Stop() time to execute. It needs to pass txThread.join()
  // and the sleeps inside SendStopFrames(), then block on rxThread.join().
  // Adjust this delay if your STOP_FRAME_COUNT * cycleTimeS is larger.
  std::this_thread::sleep_for(std::chrono::milliseconds(100));
  EXPECT_FALSE(stopFinished.load(std::memory_order_acquire));
 
  EXPECT_FALSE(socketState->destroyed.load(std::memory_order_acquire));
  EXPECT_FALSE(socketState->destroyedWhileReceiving.load(std::memory_order_acquire));
  /*
    // Allow Recv() to return so the RX thread can terminate.
    rxSocketPtr->ReleaseReceive();
 
    // Recv() must now be able to finish.
    rxSocketPtr->WaitUntilReceiveExited();
  */
  // Release Recv().
  {
    std::lock_guard lock(socketState->mutex);
    socketState->releaseReceive = true;
  }
 
  socketState->receiveCv.notify_one();
 
  // Wait for Recv() itself to finish, using state rather than the socket.
  {
    std::unique_lock lock(socketState->mutex);
 
    socketState->receiveExitedCv.wait(lock, [&]
    {
      return socketState->receiveExited;
    });
  }
  // Stop should finish its rxThread.join().
  stopThread.join();
 
  EXPECT_TRUE(stopFinished.load(std::memory_order_acquire));
  EXPECT_TRUE(socketState->destroyed.load(std::memory_order_acquire));
  EXPECT_FALSE(socketState->destroyedWhileReceiving.load(std::memory_order_acquire));
}
 
TEST_F(CyclicStateTests, StopIsIdempotent)
{
  controller->Start(std::move(txSock), std::move(rxSock));
  controller->Stop();
  EXPECT_NO_THROW(controller->Stop());
}
 
TEST_F(CyclicStateTests, CanStartAgainAfterStop)
{
  controller->Start(std::move(txSock), std::move(rxSock));
  controller->Stop();
 
  txSock = std::make_unique<MockRawEthernetSocket>();
  rxSock = std::make_unique<MockRawEthernetSocket>();
 
  EXPECT_NO_THROW(controller->Start(std::move(txSock), std::move(rxSock)));
  controller->Stop();
}
TEST_F(CyclicStateTests, ToStringReturnsUnknownForInvalidValue)
{
  const auto invalidState = static_cast<CyclicState>(0xFF);
  EXPECT_EQ(ToString(invalidState), "unknown");
}
 
TEST_F(CyclicStateTests, TransitionCallsCallbackForStateChange)
{
  CyclicState oldSeen = CyclicState::Idle;
  CyclicState newSeen = CyclicState::Idle;
  controller->OnStateChange(
      [&callbackCount = callbackCount, &oldSeen, &newSeen](CyclicState oldState, CyclicState newState)
  {
    ++callbackCount;
    oldSeen = oldState;
    newSeen = newState;
  });
 
  CyclicControllerTestAccess::Transition(*controller, CyclicState::Starting);
 
  EXPECT_EQ(controller->State(), CyclicState::Starting);
  EXPECT_EQ(callbackCount, 1);
  EXPECT_EQ(oldSeen, CyclicState::Idle);
  EXPECT_EQ(newSeen, CyclicState::Starting);
}
 
TEST_F(CyclicStateTests, TransitionSkipsCallbackForSameState)
{
  controller->OnStateChange(
      [this](CyclicState, CyclicState)
  {
    ++callbackCount;
  });
 
  CyclicControllerTestAccess::Transition(*controller, CyclicState::Idle);
 
  EXPECT_EQ(callbackCount, 0);
}
 
TEST_F(CyclicStateTests, TransitionSwallowsCallbackException)
{
  controller->OnStateChange(
      [](CyclicState, CyclicState)
  {
    throw std::runtime_error("state callback failure");
  });
 
  EXPECT_NO_THROW(CyclicControllerTestAccess::Transition(*controller, CyclicState::Running));
  EXPECT_EQ(controller->State(), CyclicState::Running);
}
 
TEST_F(CyclicStateTests, StartRejectsInvalidStartingStates)
{
  const std::array<CyclicState, 3> invalidStates{
      CyclicState::Starting, CyclicState::Running, CyclicState::Stopping};
 
  for (const CyclicState state : invalidStates)
  {
    CyclicControllerTestAccess::SetState(*controller, state);
    CyclicControllerTestAccess::SetRunning(*controller, false);
    EXPECT_THROW(controller->Start(std::move(txSock), std::move(rxSock)), std::runtime_error);
  }
}
 
TEST_F(CyclicStateTests, StartAcceptsFaultState)
{
  CyclicControllerTestAccess::SetState(*controller, CyclicState::Fault);
  CyclicControllerTestAccess::SetRunning(*controller, false);
 
  controller->Start(std::move(txSock), std::move(rxSock));
  EXPECT_TRUE(controller->IsRunning());
  EXPECT_EQ(controller->State(), CyclicState::Running);
 
  controller->Stop();
  EXPECT_EQ(controller->State(), CyclicState::Stopped);
}
 
TEST_F(CyclicStateTests, StartAcceptsStoppedState)
{
  CyclicControllerTestAccess::SetState(*controller, CyclicState::Stopped);
  CyclicControllerTestAccess::SetRunning(*controller, false);
 
  controller->Start(std::move(txSock), std::move(rxSock));
  EXPECT_TRUE(controller->IsRunning());
  EXPECT_EQ(controller->State(), CyclicState::Running);
  controller->Stop();
}
 
TEST_F(CyclicStateTests, StopDoesNothingWhenNotRunning)
{
  EXPECT_NO_THROW(controller->Stop());
  EXPECT_EQ(controller->State(), CyclicState::Idle);
}
 
TEST_F(CyclicStateTests, StartAndStopCompleteNormalLifecycle)
{
  controller->Start(std::move(txSock), std::move(rxSock));
  EXPECT_TRUE(controller->IsRunning());
  EXPECT_EQ(controller->State(), CyclicState::Running);
 
  controller->Stop();
  EXPECT_FALSE(controller->IsRunning());
  EXPECT_EQ(controller->State(), CyclicState::Stopped);
}
 
TEST_F(CyclicStateTests, FailedStartLeavesStoppedState)
{
  auto* rx = rxSock.get();
 
  EXPECT_CALL(*rx, SetTimeout(testing::_))
      .WillOnce(testing::Throw(std::runtime_error("timeout")));
 
  EXPECT_THROW(controller->Start(std::move(txSock), std::move(rxSock)), std::runtime_error);
  EXPECT_FALSE(controller->IsRunning());
  EXPECT_EQ(controller->State(), CyclicState::Fault);
}
 
TEST_F(CyclicStateTests, FailedStartCanBeRetried)
{
  auto* rx = rxSock.get();
  EXPECT_CALL(*rx, SetTimeout(testing::_))
      .WillOnce(testing::Throw(std::runtime_error("timeout")));
 
  EXPECT_THROW(controller->Start(std::move(txSock), std::move(rxSock)), std::exception);
  txSock = std::make_unique<MockRawEthernetSocket>();
  rxSock = std::make_unique<MockRawEthernetSocket>();
  EXPECT_NO_THROW(controller->Start(std::move(txSock), std::move(rxSock)));
  EXPECT_EQ(controller->State(), CyclicState::Running);
  controller->Stop();
}
 
class CyclicStatsTests : public ::testing::Test
{
 protected:
  static std::unique_ptr<CyclicController> MakeController()
  {
    asio::io_context ioContext;
 
    return std::make_unique<CyclicController>(
        ioContext, "eth0", kControllerMac, kDeviceMac,
        MakeConfig(kInputFrameId), MakeConfig(kOutputFrameId));
  }
 
  std::unique_ptr<CyclicController> controller = MakeController();
};
 
TEST_F(CyclicStatsTests, AverageCycleTimeReturnsIntegerAverage)
{
  CyclicStats stats;
  stats.cycleTimeSumUs = 10001;
  stats.cycleCount = 10;
 
  EXPECT_EQ(stats.AvgCycleTimeUs(), 1000U);
}
 
TEST_F(CyclicStatsTests, AverageCycleTimeReturnsZeroWhenNoCycles)
{
  const CyclicStats stats{};
  EXPECT_EQ(stats.AvgCycleTimeUs(), 0U);
}
 
TEST_F(CyclicStatsTests, SnapshotAverageCycleTimeReturnsZeroWhenNoCycles)
{
  const CyclicStatsSnapshot snapshot{};
  EXPECT_EQ(snapshot.AvgCycleTimeUs(), 0U);
}
 
TEST_F(CyclicStatsTests, StatsSnapshotCopiesAllFields)
{
  auto& stats = CyclicControllerTestAccess::Stats(*controller);
  stats.framesSent = 10;
  stats.framesReceived = 9;
  stats.framesMissed = 2;
  stats.framesInvalid = 1;
  stats.framesDuplicate = 3;
  stats.framesOutOfOrder = 4;
  stats.lastCycleTimeUs = 8000;
  stats.maxJitterUs = 100;
  stats.minCycleTimeUs = 7900;
  stats.maxCycleTimeUs = 8100;
  stats.consecutiveTimeouts = 2;
  stats.cycleTimeSumUs = 80000;
  stats.cycleCount = 10;
 
  const CyclicStatsSnapshot snapshot = controller->StatsSnapshot();
 
  EXPECT_EQ(snapshot.framesSent, 10U);
  EXPECT_EQ(snapshot.framesReceived, 9U);
  EXPECT_EQ(snapshot.framesMissed, 2U);
  EXPECT_EQ(snapshot.framesInvalid, 1U);
  EXPECT_EQ(snapshot.framesDuplicate, 3U);
  EXPECT_EQ(snapshot.framesOutOfOrder, 4U);
  EXPECT_EQ(snapshot.lastCycleTimeUs, 8000U);
  EXPECT_EQ(snapshot.maxJitterUs, 100U);
  EXPECT_EQ(snapshot.minCycleTimeUs, 7900U);
  EXPECT_EQ(snapshot.maxCycleTimeUs, 8100U);
  EXPECT_EQ(snapshot.consecutiveTimeouts, 2);
  EXPECT_EQ(snapshot.cycleTimeSumUs, 80000U);
  EXPECT_EQ(snapshot.cycleCount, 10U);
  EXPECT_EQ(snapshot.AvgCycleTimeUs(), 8000U);
}
 
TEST_F(CyclicStatsTests, ResetRestoresInitialValues)
{
  CyclicStats stats;
  stats.framesSent = 10;
  stats.framesReceived = 20;
  stats.framesMissed = 30;
  stats.framesInvalid = 40;
  stats.framesDuplicate = 50;
  stats.framesOutOfOrder = 60;
  stats.lastCycleTimeUs = 70;
  stats.maxJitterUs = 80;
  stats.minCycleTimeUs = 90;
  stats.maxCycleTimeUs = 100;
  stats.consecutiveTimeouts = 2;
  stats.cycleTimeSumUs = 1000;
  stats.cycleCount = 10;
 
  stats.Reset();
 
  EXPECT_EQ(stats.framesSent.load(), 0U);
  EXPECT_EQ(stats.framesReceived.load(), 0U);
  EXPECT_EQ(stats.framesMissed.load(), 0U);
  EXPECT_EQ(stats.framesInvalid.load(), 0U);
  EXPECT_EQ(stats.framesDuplicate.load(), 0U);
  EXPECT_EQ(stats.framesOutOfOrder.load(), 0U);
  EXPECT_EQ(stats.lastCycleTimeUs.load(), 0U);
  EXPECT_EQ(stats.maxJitterUs.load(), 0U);
  EXPECT_EQ(stats.minCycleTimeUs.load(), 0x7FFFFFFFU);
  EXPECT_EQ(stats.maxCycleTimeUs.load(), 0U);
  EXPECT_EQ(stats.consecutiveTimeouts.load(), 0);
  EXPECT_EQ(stats.cycleTimeSumUs.load(), 0U);
  EXPECT_EQ(stats.cycleCount.load(), 0U);
  EXPECT_EQ(stats.AvgCycleTimeUs(), 0U);
}
 
class CyclicDataTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    ioContext = std::make_unique<asio::io_context>();
    controller = std::make_unique<CyclicController>(
        *ioContext, "eth0", kControllerMac, kDeviceMac,
        MakeConfig(kInputFrameId), MakeConfig(kOutputFrameId));
  }
 
  void DeliverInput(std::uint8_t iops)
  {
    Bytes payload{0xAA, 0xBB, 0xCC, 0xDD, iops};
    payload.resize(40U, 0x00);
    CyclicControllerTestAccess::ProcessInputFrame(
        *controller,
        BuildInputFrame(kDeviceMac, kControllerMac, kInputFrameId, 1,
                        rt::RTFrame::DATA_VALID | rt::RTFrame::DATA_RUN, 0,
                        std::move(payload)));
  }
 
  std::unique_ptr<CyclicController> controller;
 
  std::unique_ptr<asio::io_context> ioContext;
};
 
TEST_F(CyclicDataTests, GetInputDataReturnsNulloptForUnknownObject)
{
  EXPECT_FALSE(controller->GetInputData(99, 99).has_value());
}
 
TEST_F(CyclicDataTests, GetInputDataReturnsGoodInput)
{
  DeliverInput(rt::IOXS_GOOD);
 
  const auto data = controller->GetInputData(1, 1);
  ASSERT_TRUE(data.has_value());
  EXPECT_EQ(*data, Bytes({0xAA, 0xBB, 0xCC, 0xDD}));
}
 
TEST_F(CyclicDataTests, GetInputDataRejectsBadInputByDefault)
{
  DeliverInput(rt::IOXS_BAD);
 
  EXPECT_FALSE(controller->GetInputData(1, 1).has_value());
  ASSERT_TRUE(controller->GetInputData(1, 1, true).has_value());
}
 
TEST_F(CyclicDataTests, GetInputStatusReturnsNulloptForUnknownObject)
{
  EXPECT_FALSE(controller->GetInputStatus(1, 1).has_value());
}
 
TEST_F(CyclicDataTests, GetInputStatusReturnsReceivedIops)
{
  DeliverInput(rt::IOXS_GOOD);
 
  ASSERT_TRUE(controller->GetInputStatus(1, 1).has_value());
  EXPECT_EQ(*controller->GetInputStatus(1, 1), rt::IOXS_GOOD);
}
 
TEST_F(CyclicDataTests, IsInputGoodReturnsFalseForUnknownObject)
{
  EXPECT_FALSE(controller->IsInputGood(1, 1));
}
 
TEST_F(CyclicDataTests, IsInputGoodReturnsTrueForGoodInput)
{
  DeliverInput(rt::IOXS_GOOD);
  EXPECT_TRUE(controller->IsInputGood(1, 1));
}
 
TEST_F(CyclicDataTests, IsInputGoodReturnsFalseForBadInput)
{
  DeliverInput(rt::IOXS_BAD);
  EXPECT_FALSE(controller->IsInputGood(1, 1));
}
 
TEST_F(CyclicDataTests, SetOutputDataAcceptsIdleState)
{
  EXPECT_NO_THROW(controller->SetOutputData(1, 1, {0xDE, 0xAD, 0xBE, 0xEF}));
}
 
TEST_F(CyclicDataTests, SetOutputDataRejectsStoppedState)
{
  CyclicControllerTestAccess::SetState(*controller, CyclicState::Stopped);
  EXPECT_THROW(controller->SetOutputData(1, 1, {0x01}), std::runtime_error);
}
 
TEST_F(CyclicDataTests, SetOutputDataRejectsFaultState)
{
  CyclicControllerTestAccess::SetState(*controller, CyclicState::Fault);
  EXPECT_THROW(controller->SetOutputData(1, 1, {0x01}), std::runtime_error);
}
 
class CyclicCallbackTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    ioContext = std::make_unique<asio::io_context>();
    controller = std::make_unique<CyclicController>(
        *ioContext, "eth0", kControllerMac, kDeviceMac,
        MakeConfig(kInputFrameId), MakeConfig(kOutputFrameId));
  }
 
  void DeliverInput(std::uint8_t iops)
  {
    Bytes payload{0xAA, 0xBB, 0xCC, 0xDD, iops};
    payload.resize(40U, 0x00);
    CyclicControllerTestAccess::ProcessInputFrame(
        *controller,
        BuildInputFrame(kDeviceMac, kControllerMac, kInputFrameId, 1,
                        rt::RTFrame::DATA_VALID | rt::RTFrame::DATA_RUN, 0,
                        std::move(payload)));
  }
 
  std::unique_ptr<CyclicController> controller;
 
  std::unique_ptr<asio::io_context> ioContext;
};
 
TEST_F(CyclicCallbackTests, InputStatusCallbackRunsOnGoodTransition)
{
  int calls = 0;
  controller->OnInputStatus(
      [&calls](std::uint16_t slot, std::uint16_t subslot, std::uint8_t status)
  {
    ++calls;
    EXPECT_EQ(slot, 1U);
    EXPECT_EQ(subslot, 1U);
    EXPECT_EQ(status, rt::IOXS_GOOD);
  });
 
  DeliverInput(rt::IOXS_GOOD);
  EXPECT_EQ(calls, 1);
}
 
TEST_F(CyclicCallbackTests, InputStatusCallbackSkipsUnchangedStatus)
{
  int calls = 0;
  controller->OnInputStatus(
      [&calls](std::uint16_t, std::uint16_t, std::uint8_t)
  {
    ++calls;
  });
 
  DeliverInput(rt::IOXS_GOOD);
  DeliverInput(rt::IOXS_GOOD);
  EXPECT_EQ(calls, 1);
}
 
TEST_F(CyclicCallbackTests, InputStatusCallbackRunsOnBadTransition)
{
  std::vector<std::uint8_t> statuses;
  int calls = 0;
  controller->OnInputStatus(
      [&calls, &statuses](std::uint16_t, std::uint16_t, std::uint8_t status)
  {
    ++calls;
    statuses.push_back(status);
  });
 
  DeliverInput(rt::IOXS_GOOD);
  DeliverInput(rt::IOXS_BAD);
  EXPECT_EQ(calls, 2);
  EXPECT_EQ(statuses[0], rt::IOXS_GOOD);
  EXPECT_EQ(statuses[1], rt::IOXS_BAD);
}
 
TEST_F(CyclicCallbackTests, InputStatusCallbackSwallowsException)
{
  controller->OnInputStatus(
      [](std::uint16_t, std::uint16_t, std::uint8_t)
  {
    throw std::runtime_error("status callback failure");
  });
 
  EXPECT_NO_THROW(DeliverInput(rt::IOXS_GOOD));
}
 
TEST_F(CyclicCallbackTests, InputDataCallbackRunsForGoodInput)
{
  int calls = 0;
  controller->OnInput(
      [&calls](int slot, int subslot, const Bytes& data)
  {
    ++calls;
    EXPECT_EQ(slot, 1);
    EXPECT_EQ(subslot, 1);
    EXPECT_EQ(data, Bytes({0xAA, 0xBB, 0xCC, 0xDD}));
  });
 
  DeliverInput(rt::IOXS_GOOD);
  EXPECT_EQ(calls, 1);
}
 
TEST_F(CyclicCallbackTests, InputDataCallbackSkipsBadInput)
{
  int calls = 0;
  controller->OnInput(
      [&calls](int, int, const Bytes&)
  {
    ++calls;
  });
 
  DeliverInput(rt::IOXS_BAD);
  EXPECT_EQ(calls, 0);
}
 
TEST_F(CyclicCallbackTests, InputDataCallbackSkipsEmptyData)
{
  CyclicControllerTestAccess::InputObject(*controller, 0).dataLength = 0;
  int calls = 0;
  controller->OnInput(
      [&calls](int, int, const Bytes&)
  {
    ++calls;
  });
 
  DeliverInput(rt::IOXS_GOOD);
  EXPECT_EQ(calls, 0);
}
 
TEST_F(CyclicCallbackTests, InputDataCallbackSwallowsException)
{
  controller->OnInput(
      [](int, int, const Bytes&)
  {
    throw std::runtime_error("data callback failure");
  });
 
  EXPECT_NO_THROW(DeliverInput(rt::IOXS_GOOD));
}
 
TEST_F(CyclicCallbackTests, TimeoutAndErrorCallbacksCanBeRegistered)
{
  auto ioContext = std::make_unique<asio::io_context>();
  CyclicController controller(
      *ioContext, "eth0", kControllerMac, kDeviceMac,
      MakeConfig(kInputFrameId), MakeConfig(kOutputFrameId));
 
  bool timeoutCalled = false;
  bool errorCalled = false;
  controller.OnTimeout([&timeoutCalled]
  { timeoutCalled = true; });
  controller.OnError([&errorCalled](const std::string&)
  { errorCalled = true; });
 
  EXPECT_FALSE(timeoutCalled);
  EXPECT_FALSE(errorCalled);
}
 
class CyclicFrameTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    ioContext = std::make_unique<asio::io_context>();
 
    controller = std::make_unique<CyclicController>(
        *ioContext, "eth0", kControllerMac, kDeviceMac,
        MakeConfig(kInputFrameId, 1, 1), MakeConfig(kOutputFrameId));
  }
 
  void ProcessCounter(std::uint16_t cycleCounter)
  {
    CyclicControllerTestAccess::ProcessInputFrame(
        *controller,
        BuildInputFrame(kDeviceMac, kControllerMac, kInputFrameId, cycleCounter));
  }
 
  std::unique_ptr<CyclicController> controller;
 
  std::unique_ptr<asio::io_context> ioContext;
};
 
TEST_F(CyclicFrameTests, RejectsTooShortEthernetFrame)
{
  CyclicControllerTestAccess::ProcessInputFrame(*controller, Bytes(17U, 0x00));
  EXPECT_EQ(controller->StatsSnapshot().framesReceived, 0U);
}
 
TEST_F(CyclicFrameTests, RejectsUnexpectedEtherType)
{
  Bytes frame = BuildInputFrame(kDeviceMac, kControllerMac);
  frame[12] = 0x08;
  frame[13] = 0x00;
 
  CyclicControllerTestAccess::ProcessInputFrame(*controller, frame);
  EXPECT_EQ(controller->StatsSnapshot().framesReceived, 0U);
}
 
TEST_F(CyclicFrameTests, RejectsUnexpectedSourceMac)
{
  const MacAddress wrongSource = String2Mac("02:00:00:00:00:02");
  CyclicControllerTestAccess::ProcessInputFrame(
      *controller, BuildInputFrame(wrongSource, kControllerMac));
 
  EXPECT_EQ(controller->StatsSnapshot().framesReceived, 0U);
}
 
TEST_F(CyclicFrameTests, RejectsMalformedRtFrame)
{
  Bytes frame;
  frame.insert(frame.end(), kControllerMac.begin(), kControllerMac.end());
  frame.insert(frame.end(), kDeviceMac.begin(), kDeviceMac.end());
  frame.push_back(0x88);
  frame.push_back(0x92);
  frame.push_back(0xC0);
 
  EXPECT_NO_THROW(CyclicControllerTestAccess::ProcessInputFrame(*controller, frame));
  EXPECT_EQ(controller->StatsSnapshot().framesReceived, 0U);
}
 
TEST_F(CyclicFrameTests, RejectsUnexpectedFrameId)
{
  CyclicControllerTestAccess::ProcessInputFrame(
      *controller, BuildInputFrame(kDeviceMac, kControllerMac, 0xC123));
  EXPECT_EQ(controller->StatsSnapshot().framesReceived, 0U);
}
 
TEST_F(CyclicFrameTests, AcceptsVlanTaggedInputFrame)
{
  // The helper is intentionally built from the public RT serializer and then
  // adjusted into a VLAN frame below so SkipVlanTags() is exercised.
  Bytes frame = BuildInputFrame(kDeviceMac, kControllerMac);
  const Bytes rtBytes(frame.begin() + 14, frame.end());
 
  frame.resize(12);
  frame.insert(frame.end(), {0x81, 0x00, 0xC0, 0x00, 0x88, 0x92});
  frame.insert(frame.end(), rtBytes.begin(), rtBytes.end());
 
  CyclicControllerTestAccess::ProcessInputFrame(*controller, frame);
 
  EXPECT_EQ(controller->StatsSnapshot().framesReceived, 1U);
  const auto data = controller->GetInputData(1, 1);
  ASSERT_TRUE(data.has_value());
  EXPECT_EQ(*data, Bytes({0xAA, 0xBB, 0xCC, 0xDD}));
}
 
TEST_F(CyclicFrameTests, RejectsInvalidDataStatus)
{
  CyclicControllerTestAccess::ProcessInputFrame(
      *controller,
      BuildInputFrame(kDeviceMac, kControllerMac, kInputFrameId, 1, 0x00));
 
  EXPECT_EQ(controller->StatsSnapshot().framesReceived, 1U);
  EXPECT_EQ(controller->StatsSnapshot().framesInvalid, 1U);
}
 
TEST_F(CyclicFrameTests, RejectsNonZeroTransferStatus)
{
  CyclicControllerTestAccess::ProcessInputFrame(
      *controller,
      BuildInputFrame(kDeviceMac, kControllerMac, kInputFrameId, 1,
                      rt::RTFrame::DATA_VALID | rt::RTFrame::DATA_RUN, 1));
 
  EXPECT_EQ(controller->StatsSnapshot().framesInvalid, 1U);
}
 
TEST_F(CyclicFrameTests, DISABLED_ValidInputRestoresIocsGoodState)
{
  // CyclicControllerTestAccess::SetAllOutputIocs(*controller, rt::IOXS_BAD);
  CyclicControllerTestAccess::HandleWatchdogTimeout(*controller);
  EXPECT_FALSE(CyclicControllerTestAccess::IocsGood(*controller));
 
  CyclicControllerTestAccess::SwapOutputBuilder(*controller);
  EXPECT_EQ(CyclicControllerTestAccess::FirstOutputIocs(*controller), rt::IOXS_BAD);
 
  // CyclicControllerTestAccess::SetIocsGood(*controller, false);
  CyclicControllerTestAccess::ProcessInputFrame(*controller, BuildInputFrame(kDeviceMac, kControllerMac));
 
  EXPECT_TRUE(CyclicControllerTestAccess::IocsGood(*controller));
  // SetAllIocs() updates the write buffer. Swap() promotes it to the
  // send buffer, which is what Build() exposes.
  CyclicControllerTestAccess::SwapOutputBuilder(*controller);
  EXPECT_EQ(CyclicControllerTestAccess::FirstOutputIocs(*controller), rt::IOXS_GOOD);
}
 
TEST_F(CyclicFrameTests, SkipsObjectWithInvalidIopsOffset)
{
  CyclicControllerTestAccess::InputObject(*controller, 0).offsetIOPS = 100;
  CyclicControllerTestAccess::ProcessInputFrame(
      *controller, BuildInputFrame(kDeviceMac, kControllerMac));
 
  EXPECT_EQ(controller->StatsSnapshot().framesReceived, 1U);
  EXPECT_FALSE(controller->GetInputStatus(1, 1).has_value());
}
 
TEST_F(CyclicFrameTests, SkipsObjectWithInvalidDataRange)
{
  auto& object = CyclicControllerTestAccess::InputObject(*controller, 0);
  object.frameOffset = 39;
  object.dataLength = 4;
 
  CyclicControllerTestAccess::ProcessInputFrame(
      *controller, BuildInputFrame(kDeviceMac, kControllerMac));
 
  EXPECT_EQ(controller->StatsSnapshot().framesReceived, 1U);
  EXPECT_FALSE(controller->GetInputStatus(1, 1).has_value());
}
 
TEST_F(CyclicFrameTests, TrackCycleCounterInitializesOnFirstFrame)
{
  ProcessCounter(10);
  EXPECT_EQ(controller->StatsSnapshot().framesMissed, 0U);
}
 
TEST_F(CyclicFrameTests, TrackCycleCounterCountsDuplicate)
{
  ProcessCounter(10);
  ProcessCounter(10);
  EXPECT_EQ(controller->StatsSnapshot().framesDuplicate, 1U);
}
 
TEST_F(CyclicFrameTests, TrackCycleCounterAcceptsExpectedStep)
{
  ProcessCounter(10);
  ProcessCounter(11);
  const auto snapshot = controller->StatsSnapshot();
  EXPECT_EQ(snapshot.framesMissed, 0U);
  EXPECT_EQ(snapshot.framesDuplicate, 0U);
  EXPECT_EQ(snapshot.framesOutOfOrder, 0U);
}
 
TEST_F(CyclicFrameTests, TrackCycleCounterCountsForwardGap)
{
  ProcessCounter(10);
  ProcessCounter(12);
  EXPECT_EQ(controller->StatsSnapshot().framesMissed, 1U);
}
 
TEST_F(CyclicFrameTests, TrackCycleCounterCountsOutOfOrder)
{
  ProcessCounter(100);
  ProcessCounter(99);
  EXPECT_EQ(controller->StatsSnapshot().framesOutOfOrder, 1U);
}
 
TEST_F(CyclicFrameTests, TrackCycleCounterHandlesZeroStep)
{
  CyclicControllerTestAccess::TrackCycleCounter(*controller, 100);
  CyclicControllerTestAccess::SetRxCounterStep(*controller, 0);
  CyclicControllerTestAccess::TrackCycleCounter(*controller, 102);
 
  EXPECT_EQ(controller->StatsSnapshot().framesMissed, 0U);
  EXPECT_EQ(controller->StatsSnapshot().framesOutOfOrder, 0U);
}
 
class CyclicWatchdogTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    tx = std::make_unique<test::CyclicRawEthernetSocketStub>();
    rxSocket = std::make_unique<test::CyclicRawEthernetSocketStub>();
    rx = rxSocket.get();
    ioContext = std::make_unique<asio::io_context>();
    controller = std::make_unique<CyclicController>(
        *ioContext, "eth0", kControllerMac, kDeviceMac,
        MakeConfig(kInputFrameId, 1, 1, 1), MakeConfig(kOutputFrameId),
        DEFAULT_MAX_CONSECUTIVE_TIMEOUTS, kProfinetEtherType);
    CyclicControllerTestAccess::SetRxSock(*controller, std::move(rxSocket));
    CyclicControllerTestAccess::SetState(*controller, CyclicState::Running);
  }
 
  std::unique_ptr<CyclicController> controller;
 
  std::unique_ptr<test::CyclicRawEthernetSocketStub> tx = std::make_unique<test::CyclicRawEthernetSocketStub>();
  std::unique_ptr<test::CyclicRawEthernetSocketStub> rxSocket = std::make_unique<test::CyclicRawEthernetSocketStub>();
 
  test::CyclicRawEthernetSocketStub* rx{nullptr};
 
  std::unique_ptr<asio::io_context> ioContext;
};
 
TEST_F(CyclicWatchdogTests, WatchdogTimeoutUpdatesStatistics)
{
  int timeoutCalls = 0;
  controller->OnTimeout(
      [&timeoutCalls]
  {
    ++timeoutCalls;
  });
 
  CyclicControllerTestAccess::HandleWatchdogTimeout(*controller);
 
  EXPECT_EQ(controller->StatsSnapshot().framesMissed, 1U);
  EXPECT_EQ(controller->StatsSnapshot().consecutiveTimeouts, 1);
  EXPECT_EQ(timeoutCalls, 1);
  EXPECT_FALSE(CyclicControllerTestAccess::IocsGood(*controller));
}
 
TEST_F(CyclicWatchdogTests, MonitoringOnlyWatchdogKeepsIocsGood)
{
  CyclicControllerTestAccess::SetMaxConsecutiveTimeouts(*controller, 0);
 
  CyclicControllerTestAccess::HandleWatchdogTimeout(*controller);
  CyclicControllerTestAccess::HandleWatchdogTimeout(*controller);
 
  EXPECT_TRUE(CyclicControllerTestAccess::IocsGood(*controller));
  EXPECT_EQ(controller->StatsSnapshot().consecutiveTimeouts, 2);
  EXPECT_EQ(controller->State(), CyclicState::Running);
}
 
TEST_F(CyclicWatchdogTests, WatchdogFaultsAtConfiguredThreshold)
{
  std::string errorMessage;
  controller->OnError(
      [&errorMessage](const std::string& message)
  {
    errorMessage = message;
  });
 
  CyclicControllerTestAccess::HandleWatchdogTimeout(*controller);
  CyclicControllerTestAccess::HandleWatchdogTimeout(*controller);
  CyclicControllerTestAccess::HandleWatchdogTimeout(*controller);
 
  EXPECT_EQ(controller->State(), CyclicState::Fault);
  EXPECT_EQ(controller->StatsSnapshot().consecutiveTimeouts, 3);
  EXPECT_NE(errorMessage.find("Communication lost"), std::string::npos);
}
 
TEST_F(CyclicWatchdogTests, WatchdogDoesNotTransitionWhenAlreadyFaulted)
{
  CyclicControllerTestAccess::SetState(*controller, CyclicState::Fault);
  CyclicControllerTestAccess::Stats(*controller).consecutiveTimeouts = 2;
 
  EXPECT_NO_THROW(CyclicControllerTestAccess::HandleWatchdogTimeout(*controller));
  EXPECT_EQ(controller->State(), CyclicState::Fault);
}
 
TEST_F(CyclicWatchdogTests, TimeoutCallbackSwallowsException)
{
  controller->OnTimeout(
      []
  {
    throw std::runtime_error("timeout callback failure");
  });
 
  EXPECT_NO_THROW(CyclicControllerTestAccess::HandleWatchdogTimeout(*controller));
  EXPECT_EQ(controller->StatsSnapshot().framesMissed, 1U);
}
 
TEST_F(CyclicWatchdogTests, WatchdogDoesNotRepeatBadTransition)
{
  CyclicControllerTestAccess::HandleWatchdogTimeout(*controller);
  ASSERT_FALSE(CyclicControllerTestAccess::IocsGood(*controller));
 
  const std::uint8_t badIocs = CyclicControllerTestAccess::FirstOutputByte(*controller);
  CyclicControllerTestAccess::HandleWatchdogTimeout(*controller);
 
  EXPECT_EQ(CyclicControllerTestAccess::FirstOutputByte(*controller), badIocs);
}
 
TEST_F(CyclicWatchdogTests, RxLoopProcessesValidFrame)
{
  rx->QueueReceive(BuildInputFrame(kDeviceMac, kControllerMac));
 
  int inputCalls = 0;
  controller->OnInput(
      [this, &inputCalls](int, int, const Bytes&)
  {
    ++inputCalls;
    CyclicControllerTestAccess::SetRunning(*controller, false);
  });
 
  CyclicControllerTestAccess::SetRunning(*controller, true);
  EXPECT_NO_THROW(CyclicControllerTestAccess::RxLoop(*controller));
 
  EXPECT_EQ(inputCalls, 1);
  EXPECT_EQ(controller->StatsSnapshot().framesReceived, 1U);
}
 
TEST_F(CyclicWatchdogTests, RxLoopStopsWithoutSocket)
{
  // Resetting the receive socket before entering RxLoop exercises its null-socket branch.
  CyclicControllerTestAccess::ResetRxSocket(*controller);
  CyclicControllerTestAccess::SetRunning(*controller, true);
  EXPECT_NO_THROW(CyclicControllerTestAccess::RxLoop(*controller));
}
 
TEST_F(CyclicWatchdogTests, RxLoopReportsSocketException)
{
  rx->SetRecvExceptionMessage("rx failure");
  rx->QueueReceiveException();
 
  std::string errorMessage;
  controller->OnError(
      [this, &errorMessage](const std::string& message)
  {
    errorMessage = message;
    CyclicControllerTestAccess::SetRunning(*controller, false);
  });
 
  CyclicControllerTestAccess::SetRunning(*controller, true);
  EXPECT_NO_THROW(CyclicControllerTestAccess::RxLoop(*controller));
  EXPECT_EQ(errorMessage, "RX error: rx failure");
}
 
TEST_F(CyclicWatchdogTests, RxLoopHandlesWatchdogTimeout)
{
  rx->QueueTimeout();
 
  int timeoutCalls = 0;
  controller->OnTimeout(
      [this, &timeoutCalls]
  {
    ++timeoutCalls;
    CyclicControllerTestAccess::SetRunning(*controller, false);
  });
 
  CyclicControllerTestAccess::SetRunning(*controller, true);
  EXPECT_NO_THROW(CyclicControllerTestAccess::RxLoop(*controller));
 
  EXPECT_EQ(timeoutCalls, 1);
  EXPECT_GE(controller->StatsSnapshot().framesMissed, 1U);
}
 
class CyclicTxTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    ioContext = std::make_unique<asio::io_context>();
    controller = std::make_unique<CyclicController>(
        *ioContext, "eth0", kControllerMac, kDeviceMac,
        MakeConfig(kInputFrameId), MakeConfig(kOutputFrameId),
        DEFAULT_MAX_CONSECUTIVE_TIMEOUTS, kProfinetEtherType);
    txSocket = std::make_unique<test::CyclicRawEthernetSocketStub>();
    tx = txSocket.get();
    CyclicControllerTestAccess::SetTxSock(*controller, std::move(txSocket));
  }
 
  std::unique_ptr<CyclicController> controller;
  std::unique_ptr<test::CyclicRawEthernetSocketStub> txSocket;
  std::unique_ptr<test::CyclicRawEthernetSocketStub> rxSocket = std::make_unique<test::CyclicRawEthernetSocketStub>();
 
  test::CyclicRawEthernetSocketStub* tx{nullptr};
 
  std::unique_ptr<asio::io_context> ioContext;
};
 
TEST_F(CyclicTxTests, TxLoopRecordsCycleTiming)
{
  ioContext = std::make_unique<asio::io_context>();
  controller = std::make_unique<CyclicController>(
      *ioContext, "eth0", kControllerMac, kDeviceMac,
      MakeConfig(kInputFrameId, 8, 4), MakeConfig(kOutputFrameId, 8, 4),
      DEFAULT_MAX_CONSECUTIVE_TIMEOUTS, kProfinetEtherType);
 
  txSocket = std::make_unique<test::CyclicRawEthernetSocketStub>();
  tx = txSocket.get();
  CyclicControllerTestAccess::SetTxSock(*controller, std::move(txSocket));
 
  tx->OnSend(
      [this]
  {
    if (tx->SentFrameCount() >= 2U)
    {
      CyclicControllerTestAccess::SetRunning(*controller, false);
    }
  });
 
  CyclicControllerTestAccess::SetRunning(*controller, true);
 
  CyclicControllerTestAccess::TxLoop(*controller);
 
  const auto snapshot = controller->StatsSnapshot();
  EXPECT_EQ(snapshot.framesSent, 2U);
  EXPECT_EQ(snapshot.cycleCount, 1U);
  EXPECT_GT(snapshot.lastCycleTimeUs, 0U);
}
 
TEST_F(CyclicTxTests, TxCycleSendsFrameAndUpdatesStatistics)
{
  CyclicControllerTestAccess::TxCycle(*controller);
 
  EXPECT_EQ(tx->SentFrameCount(), 1U);
  EXPECT_EQ(controller->StatsSnapshot().framesSent, 1U);
}
 
TEST_F(CyclicTxTests, TxCycleSendsInFault)
{
  CyclicControllerTestAccess::SetState(*controller, CyclicState::Fault);
  CyclicControllerTestAccess::TxCycle(*controller);
  EXPECT_EQ(tx->SentFrameCount(), 1U);
}
 
TEST_F(CyclicTxTests, SendOutputFrameWithoutSocketDoesNotThrow)
{
  CyclicControllerTestAccess::ResetTxSocket(*controller);
  EXPECT_NO_THROW(CyclicControllerTestAccess::SendOutputFrame(*controller));
}
 
TEST_F(CyclicTxTests, SendOutputFrameReportsSocketError)
{
  tx->SetSendThrows(true);
  tx->SetSendExceptionMessage("tx failure");
 
  std::string errorMessage;
  controller->OnError(
      [&errorMessage](const std::string& message)
  {
    errorMessage = message;
  });
  EXPECT_NO_THROW(CyclicControllerTestAccess::SendOutputFrame(*controller));
  EXPECT_EQ(errorMessage, "TX error: tx failure");
}
 
TEST_F(CyclicTxTests, SendOutputFrameUsesDataStatusOverride)
{
  CyclicControllerTestAccess::SendOutputFrame(*controller, 0x20);
 
  ASSERT_EQ(tx->SentFrameCount(), 1U);
  const Bytes& ethernet = tx->SentFrame(0);
  const auto parsed = rt::RTFrame::FromBytes(Bytes(ethernet.begin() + 14, ethernet.end()));
  // ASSERT_TRUE(parsed.has_value());
  EXPECT_EQ(parsed.dataStatus, 0x20);
}
 
TEST_F(CyclicTxTests, SendStopFramesGeneratesStopFrameCount)
{
  CyclicControllerTestAccess::SendStopFrames(*controller);
 
  EXPECT_EQ(tx->SentFrameCount(), STOP_FRAME_COUNT);
  EXPECT_EQ(controller->StatsSnapshot().framesSent, STOP_FRAME_COUNT);
}
 
TEST_F(CyclicTxTests, SendStopFramesWithoutSocketDoesNothing)
{
  CyclicControllerTestAccess::SetTxSock(*controller, std::move(txSocket));
 
  CyclicControllerTestAccess::ResetTxSocket(*controller);
  EXPECT_NO_THROW(CyclicControllerTestAccess::SendStopFrames(*controller));
  EXPECT_EQ(controller->StatsSnapshot().framesSent, 0U);
}
 
TEST_F(CyclicTxTests, SendStopFramesStopsAfterSendErrorCallbackThrows)
{
  tx->SetSendThrows(true);
  controller->OnError(
      [](const std::string&)
  {
    throw std::runtime_error("stop-send callback failure");
  });
 
  EXPECT_NO_THROW(CyclicControllerTestAccess::SendStopFrames(*controller));
  EXPECT_EQ(tx->SentFrameCount(), 0U);
  EXPECT_EQ(controller->StatsSnapshot().framesSent, 0U);
}
 
TEST_F(CyclicTxTests, SetOutputDataIsReflectedInTransmittedFrame)
{
  controller->SetOutputData(1, 1, {0x11, 0x22, 0x33, 0x44});
  CyclicControllerTestAccess::SwapOutputBuilder(*controller);
  CyclicControllerTestAccess::SendOutputFrame(*controller);
 
  ASSERT_EQ(tx->SentFrameCount(), 1U);
 
  const Bytes& ethernet = tx->SentFrame(0);
 
  const auto parsed = rt::RTFrame::FromBytes(Bytes(ethernet.begin() + 14, ethernet.end()));
 
  ASSERT_GE(parsed.payload.size(), 4U);
  EXPECT_EQ(parsed.payload[0], 0x11);
  EXPECT_EQ(parsed.payload[1], 0x22);
  EXPECT_EQ(parsed.payload[2], 0x33);
  EXPECT_EQ(parsed.payload[3], 0x44);
}
 
TEST_F(CyclicStateTests, CallbackCanBeReplacedWhileRunning)
{
  controller->Start(std::move(txSock), std::move(rxSock));
  for (int i = 0; i < 1000; ++i)
  {
    controller->OnInput([i](int, int, const auto&)
    { (void)i; });
  }
  controller->Stop();
}
 
TEST_F(CyclicStateTests, ClearedCallbackIsNotInvoked)
{
  int calls = 0;
  controller->OnInput([&](int, int, const auto&)
  { ++calls; });
  controller->OnInput(nullptr);
  CyclicControllerTestAccess::ProcessInputFrame(*controller, {});
  EXPECT_EQ(calls, 0);
}
 
TEST_F(CyclicStateTests, CallbackMayRequestStopWithoutDeadlock)
{
  controller->OnTimeout([&]
  { controller->Stop(); });
  controller->Start(std::move(txSock), std::move(rxSock));
  CyclicControllerTestAccess::HandleWatchdogTimeout(*controller);
  while (controller->IsRunning())
  {
    std::this_thread::sleep_for(std::chrono::milliseconds(5));
  }
 
  EXPECT_FALSE(controller->IsRunning());
}
} // namespace profinet::cyclic