test_virtual_auma_valveMore.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <algorithm>
#include <array>
#include <atomic>
#include <chrono>
#include <cstdint>
#include <mutex>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>
 
#include "profinet/alarms.h"
#include "profinet/gsdml.h"
#include "profinet/rt.h"
#include "profinet/sim/virtual_auma_config.h"
#include "profinet/sim/virtual_auma_valve.h"
#include "profinet/sim/virtual_phoenix_plc.h"
#include "virtual_sim_test_helpers.h"
 
namespace profinet::sim
{
 
namespace
{
 
using test::MakeAumaGsdml;
using test::MakeTestAumaIocrs;
using test::WaitUntil;
 
constexpr MacAddress kControllerMac{0x02, 0x00, 0x00, 0x00, 0x10, 0x01};
constexpr MacAddress kValveMac{0x02, 0x00, 0x00, 0x00, 0x20, 0x01};
 
Bytes MakeControllerOutputFrame()
{
  rt::RTFrame frame;
  frame.frameId = 0x8001U;
  frame.cycleCounter = 1U;
  frame.dataStatus = static_cast<std::uint8_t>(rt::DATA_STATUS_VALID |
                                               rt::DATA_STATUS_PROVIDER_RUN |
                                               rt::DATA_STATUS_STATION_OK |
                                               rt::DATA_STATUS_STATE);
  frame.transferStatus = 0U;
  frame.payload.resize(16U, 0U);
  return rt::BuildEthernetFrame(kValveMac, kControllerMac, frame);
}
 
std::uint8_t RtaPduType(const Bytes& frame)
{
  if (frame.size() < 25U || frame[12] != 0x81U || frame[13] != 0x00U ||
      frame[16] != 0x88U || frame[17] != 0x92U)
  {
    return 0U;
  }
  return static_cast<std::uint8_t>(frame[24] & 0x0FU);
}
 
bool IsAlarmEthernetFrame(const Bytes& frame, const std::uint16_t frameId)
{
  return frame.size() >= 20U && frame[12] == 0x81U && frame[13] == 0x00U &&
         frame[16] == 0x88U && frame[17] == 0x92U &&
         static_cast<std::uint16_t>((static_cast<std::uint16_t>(frame[18]) << 8U) | frame[19]) == frameId;
}
 
Bytes ExtractRtaVariablePart(const Bytes& frame)
{
  if (frame.size() < 30U)
  {
    return {};
  }
  const std::uint16_t length = static_cast<std::uint16_t>(
      (static_cast<std::uint16_t>(frame[28]) << 8U) | frame[29]);
  if (frame.size() < 30U + length)
  {
    return {};
  }
  return Bytes(frame.begin() + 30, frame.begin() + 30 + length);
}
 
} // namespace
 
TEST(VirtualAumaValveTests, StartsFromConfiguredGsdmlPosition)
{
  const auto gsdml = MakeAumaGsdml();
  auto iocrs = MakeTestAumaIocrs(gsdml);
  VirtualAumaValve valve("valve1", gsdml, kValveMac,
                         std::move(iocrs.input), std::move(iocrs.output));
 
  EXPECT_EQ(valve.Position(), 0U);
  EXPECT_EQ(valve.TargetPosition(), 0U);
  EXPECT_EQ(valve.Scenario(), VirtualAumaScenario::Normal);
  EXPECT_NE(std::find_if(valve.SignalCatalog().Sensors().begin(),
                         valve.SignalCatalog().Sensors().end(),
                         [](const auto& signal)
  { return signal.textId == "T_ID_ACTPOS_E2"; }),
            valve.SignalCatalog().Sensors().end());
}
 
TEST(VirtualAumaValveTests, OpenCommandMovesValveToEndStop)
{
  const auto gsdml = MakeAumaGsdml();
  auto iocrs = MakeTestAumaIocrs(gsdml);
  InMemoryEthernetBus bus;
  VirtualAumaValveConfiguration config;
  config.initialPosition = 9000U;
  VirtualAumaValve valve("valve1", gsdml, kValveMac,
                         std::move(iocrs.input), std::move(iocrs.output), std::move(config));
  valve.Start(bus);
  auto controllerTx = bus.CreateSocket(kControllerMac);
  controllerTx->SetTimeout(std::chrono::milliseconds(2));
 
  Bytes output(7U, 0U);
  output[0] = 0x01U;
  output[1] = 100U;
  output[2] = 0x27U;
  output[3] = 0x10U;
 
  rt::RTFrame frame;
  frame.frameId = 0x8001U;
  frame.cycleCounter = 1U;
  frame.dataStatus = rt::DATA_STATUS_VALID | rt::DATA_STATUS_PROVIDER_RUN |
                     rt::DATA_STATUS_STATION_OK | rt::DATA_STATUS_STATE;
  frame.payload.resize(16U, 0U);
  std::copy(output.begin(), output.end(), frame.payload.begin());
 
  const Bytes ethernet = rt::BuildEthernetFrame(kValveMac, kControllerMac, frame);
  controllerTx->Send(ethernet);
 
  ASSERT_TRUE(WaitUntil([&valve]
  {
    return valve.Position() > 0U;
  }));
  EXPECT_TRUE(WaitUntil([&valve]
  {
    return valve.Position() == 10000U;
  }, std::chrono::milliseconds(500)));
 
  valve.Stop();
}
 
TEST(VirtualAumaValveTests, RejectsFramesFromSecondController)
{
  const auto gsdml = MakeAumaGsdml();
  auto iocrs = MakeTestAumaIocrs(gsdml);
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("valve1", gsdml, kValveMac,
                         std::move(iocrs.input), std::move(iocrs.output));
  valve.Start(bus);
 
  const MacAddress secondController{0x02, 0x00, 0x00, 0x00, 0x10, 0x02};
  auto controllerA = bus.CreateSocket(kControllerMac);
  auto controllerB = bus.CreateSocket(secondController);
  controllerA->SetTimeout(std::chrono::milliseconds(2));
  controllerB->SetTimeout(std::chrono::milliseconds(2));
 
  controllerA->Send(MakeControllerOutputFrame());
  ASSERT_TRUE(WaitUntil([&valve]
  {
    return valve.OutputProcessData().size() == 7U;
  }));
 
  const Bytes before = valve.OutputProcessData();
  rt::RTFrame secondFrame;
  secondFrame.frameId = 0x8001U;
  secondFrame.cycleCounter = 2U;
  secondFrame.dataStatus = static_cast<std::uint8_t>(rt::DATA_STATUS_VALID |
                                                     rt::DATA_STATUS_PROVIDER_RUN |
                                                     rt::DATA_STATUS_STATION_OK |
                                                     rt::DATA_STATUS_STATE);
  secondFrame.transferStatus = 0U;
  secondFrame.payload.resize(16U, 0U);
  secondFrame.payload[0] = 0x04U;
  controllerB->Send(rt::BuildEthernetFrame(kValveMac, secondController, secondFrame));
  std::this_thread::sleep_for(std::chrono::milliseconds(20));
 
  EXPECT_EQ(valve.OutputProcessData(), before);
  valve.Stop();
}
 
TEST(VirtualAumaValveTests, SlowValveMovesButAtReducedSpeed)
{
  const auto gsdml = MakeAumaGsdml();
  auto iocrs = MakeTestAumaIocrs(gsdml);
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("valve1", gsdml, kValveMac,
                         std::move(iocrs.input), std::move(iocrs.output));
  valve.SetScenario(VirtualAumaScenario::SlowValve);
  valve.Start(bus);
 
  auto controllerTx = bus.CreateSocket(kControllerMac);
  controllerTx->SetTimeout(std::chrono::milliseconds(2));
  Bytes payload(16U, 0U);
  payload[0] = 0x01U;
  rt::RTFrame frame{.frameId = 0x8001U,
                    .cycleCounter = 1U,
                    .dataStatus = static_cast<std::uint8_t>(rt::DATA_STATUS_VALID |
                                                            rt::DATA_STATUS_PROVIDER_RUN |
                                                            rt::DATA_STATUS_STATION_OK |
                                                            rt::DATA_STATUS_STATE),
                    .transferStatus = 0,
                    .payload = payload};
  controllerTx->Send(rt::BuildEthernetFrame(kValveMac, kControllerMac, frame));
 
  std::this_thread::sleep_for(std::chrono::milliseconds(120));
  const auto position = valve.Position();
  EXPECT_GT(position, 0U);
  EXPECT_LT(position, 700U);
 
  valve.Stop();
}
 
TEST(VirtualAumaValveTests, JammedPreventsMovement)
{
  const auto gsdml = MakeAumaGsdml();
  auto iocrs = MakeTestAumaIocrs(gsdml);
  VirtualAumaValve valve("valve1", gsdml, kValveMac,
                         std::move(iocrs.input), std::move(iocrs.output));
  valve.SetScenario(VirtualAumaScenario::Jammed);
 
  InMemoryEthernetBus bus;
  valve.Start(bus);
  auto controllerTx = bus.CreateSocket(kControllerMac);
  controllerTx->SetTimeout(std::chrono::milliseconds(2));
 
  Bytes payload(16U, 0U);
  payload[0] = 0x01U;
  rt::RTFrame frame{.frameId = 0x8001U,
                    .cycleCounter = 1U,
                    .dataStatus = static_cast<std::uint8_t>(rt::DATA_STATUS_VALID |
                                                            rt::DATA_STATUS_PROVIDER_RUN |
                                                            rt::DATA_STATUS_STATION_OK |
                                                            rt::DATA_STATUS_STATE),
                    .transferStatus = 0,
                    .payload = payload};
  controllerTx->Send(rt::BuildEthernetFrame(kValveMac, kControllerMac, frame));
 
  std::this_thread::sleep_for(std::chrono::milliseconds(100));
  EXPECT_EQ(valve.Position(), 0U);
  EXPECT_TRUE(valve.FaultActive());
  valve.Stop();
}
 
TEST(VirtualAumaScenarioTests, JammedKeepsIopsGood)
{
  const auto gsdml = MakeAumaGsdml();
  auto iocrs = MakeTestAumaIocrs(gsdml);
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("valve1", gsdml, kValveMac,
                         std::move(iocrs.input), std::move(iocrs.output));
  valve.SetScenario(VirtualAumaScenario::Jammed);
  valve.Start(bus);
 
  auto controllerTx = bus.CreateSocket(kControllerMac);
  Bytes payload(16U, 0U);
  rt::RTFrame frame{.frameId = 0x8001U,
                    .cycleCounter = 1U,
                    .dataStatus = static_cast<std::uint8_t>(rt::DATA_STATUS_VALID |
                                                            rt::DATA_STATUS_PROVIDER_RUN |
                                                            rt::DATA_STATUS_STATION_OK |
                                                            rt::DATA_STATUS_STATE),
                    .transferStatus = 0U,
                    .payload = payload};
  controllerTx->Send(rt::BuildEthernetFrame(kValveMac, kControllerMac, frame));
 
  auto controllerRx = bus.CreateSocket(kControllerMac);
  ASSERT_TRUE(WaitUntil([&controllerRx]
  {
    return !controllerRx->Recv().empty();
  }));
 
  controllerRx->SetTimeout(std::chrono::milliseconds(2));
  bool goodIops = false;
  for (;;)
  {
    const Bytes received = controllerRx->Recv();
    if (received.empty())
    {
      break;
    }
    const auto parsed = rt::ParseEthernetFrame(received);
    if (parsed.has_value() && parsed->frameId == 0x9000U && parsed->payload.size() > 9U)
    {
      goodIops = parsed->payload[9U] == rt::IOXS_GOOD;
      break;
    }
  }
  EXPECT_TRUE(goodIops);
  valve.Stop();
}
 
TEST(VirtualAumaScenarioTests, BadIopsStillEmitsCyclicFramesWithBadIops)
{
  const auto gsdml = MakeAumaGsdml();
  auto iocrs = MakeTestAumaIocrs(gsdml);
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("valve1", gsdml, kValveMac,
                         std::move(iocrs.input), std::move(iocrs.output));
  std::atomic<std::size_t> frames{0};
  valve.OnFrame([&frames](const Bytes& frame)
  {
    if (frame.size() > 19U && frame[16] == 0x88U && frame[17] == 0x92U)
    {
      ++frames;
    }
  });
  valve.SetScenario(VirtualAumaScenario::BadIops);
  valve.Start(bus);
  auto controllerTx = bus.CreateSocket(kControllerMac);
  controllerTx->SetTimeout(std::chrono::milliseconds(2));
  Bytes payload(16U, 0U);
  rt::RTFrame frame{.frameId = 0x8001U,
                    .cycleCounter = 1U,
                    .dataStatus = static_cast<std::uint8_t>(rt::DATA_STATUS_VALID |
                                                            rt::DATA_STATUS_PROVIDER_RUN |
                                                            rt::DATA_STATUS_STATION_OK |
                                                            rt::DATA_STATUS_STATE),
                    .transferStatus = 0,
                    .payload = payload};
  controllerTx->Send(rt::BuildEthernetFrame(kValveMac, kControllerMac, frame));
 
  EXPECT_TRUE(WaitUntil([&frames]
  {
    return frames.load() >= 2U;
  }));
  valve.Stop();
}
 
TEST(VirtualAumaAlarmTests, RequestedScenariosExposeBothAlarmPaths)
{
  const auto gsdml = MakeAumaGsdml();
  auto iocrs = MakeTestAumaIocrs(gsdml);
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("valve1", gsdml, kValveMac,
                         std::move(iocrs.input), std::move(iocrs.output));
 
  std::vector<VirtualAumaAlarmEvent> events;
  std::mutex eventMutex;
  valve.OnAlarm([&](const VirtualAumaAlarmEvent& event)
  {
    std::lock_guard<std::mutex> lock(eventMutex);
    events.push_back(event);
  });
  valve.Start(bus);
 
  auto controllerTx = bus.CreateSocket(kControllerMac);
  controllerTx->SetTimeout(std::chrono::milliseconds(2));
  controllerTx->Send(MakeControllerOutputFrame());
 
  ASSERT_TRUE(WaitUntil([&valve]
  {
    return valve.OutputProcessData().size() == 7U;
  }));
 
  constexpr std::array<VirtualAumaScenario, 5> kRequestedScenarios{
      VirtualAumaScenario::Fault,
      VirtualAumaScenario::BadIops,
      VirtualAumaScenario::NoInput,
      VirtualAumaScenario::SlowValve,
      VirtualAumaScenario::Jammed};
 
  for (const auto scenario : kRequestedScenarios)
  {
    valve.SetScenario(scenario);
    ASSERT_TRUE(WaitUntil([&events, &eventMutex, scenario]
    {
      std::lock_guard<std::mutex> lock(eventMutex);
      return std::any_of(events.begin(), events.end(), [scenario](const auto& event)
      { return event.scenario == scenario; });
    }));
    valve.SetScenario(VirtualAumaScenario::Normal);
  }
 
  auto controllerAlarm = bus.CreateSocket(kControllerMac);
  controllerAlarm->SetTimeout(std::chrono::milliseconds(5));
  valve.SetScenario(VirtualAumaScenario::Fault);
 
  Bytes errorFrame;
  Bytes notificationFrame;
  ASSERT_TRUE(WaitUntil([&controllerAlarm, &errorFrame, &notificationFrame]
  {
    for (;;)
    {
      const Bytes frame = controllerAlarm->Recv();
      if (frame.empty())
      {
        return !errorFrame.empty() && !notificationFrame.empty();
      }
      const std::uint8_t pduType = RtaPduType(frame);
      if (pduType == 0x0FU)
      {
        errorFrame = frame;
      }
      else if (pduType == 0x01U)
      {
        notificationFrame = frame;
      }
    }
  }));
 
  {
    std::lock_guard<std::mutex> lock(eventMutex);
    ASSERT_EQ(events.size(), kRequestedScenarios.size() + 1U);
    for (const auto& event : events)
    {
      EXPECT_FALSE(event.rtaErrorFrame.empty());
      EXPECT_FALSE(event.alarmNotificationFrame.empty());
      EXPECT_EQ(RtaPduType(event.rtaErrorFrame), 0x0FU);
      EXPECT_EQ(RtaPduType(event.alarmNotificationFrame), 0x01U);
      EXPECT_TRUE(IsAlarmEthernetFrame(event.rtaErrorFrame, rt::FRAME_ID_ALARM_LOW));
      EXPECT_TRUE(IsAlarmEthernetFrame(event.alarmNotificationFrame, rt::FRAME_ID_ALARM_LOW));
 
      const Bytes block = ExtractRtaVariablePart(event.alarmNotificationFrame);
      ASSERT_FALSE(block.empty());
      const auto alarm = ParseAlarmNotification(block);
      EXPECT_EQ(alarm.slotNumber, 1U);
      EXPECT_EQ(alarm.subslotNumber, 1U);
      EXPECT_EQ(alarm.moduleIdentNumber, 0x00008000U);
      EXPECT_EQ(alarm.submoduleIdentNumber, 0x00002200U);
      EXPECT_TRUE(alarm.channelDiagnosis);
      EXPECT_FALSE(alarm.items.empty());
    }
  }
 
  EXPECT_FALSE(errorFrame.empty());
  EXPECT_FALSE(notificationFrame.empty());
  valve.Stop();
}
 
TEST(VirtualAumaAlarmTests, ThrowingAlarmCallbackDoesNotKillSimulator)
{
  const auto gsdml = MakeAumaGsdml();
  auto iocrs = MakeTestAumaIocrs(gsdml);
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("valve1", gsdml, kValveMac,
                         std::move(iocrs.input), std::move(iocrs.output));
  valve.OnAlarm([](const VirtualAumaAlarmEvent&)
  {
    throw std::runtime_error("intentional alarm callback failure");
  });
  valve.Start(bus);
 
  auto controllerTx = bus.CreateSocket(kControllerMac);
  controllerTx->SetTimeout(std::chrono::milliseconds(2));
  controllerTx->Send(MakeControllerOutputFrame());
  ASSERT_TRUE(WaitUntil([&valve]
  {
    return valve.OutputProcessData().size() == 7U;
  }));
 
  valve.SetScenario(VirtualAumaScenario::Fault);
  std::this_thread::sleep_for(std::chrono::milliseconds(30));
  EXPECT_TRUE(valve.FaultActive());
  valve.Stop();
}
 
TEST(VirtualAumaScenarioTests, NoInputSuppressesDeviceInputTraffic)
{
  const auto gsdml = MakeAumaGsdml();
  auto iocrs = MakeTestAumaIocrs(gsdml);
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("valve1", gsdml, kValveMac,
                         std::move(iocrs.input), std::move(iocrs.output));
  valve.SetScenario(VirtualAumaScenario::NoInput);
  valve.Start(bus);
 
  auto controllerTx = bus.CreateSocket(kControllerMac);
  auto controllerRx = bus.CreateSocket(kControllerMac);
  controllerTx->SetTimeout(std::chrono::milliseconds(2));
  controllerRx->SetTimeout(std::chrono::milliseconds(2));
 
  Bytes payload(16U, 0U);
  rt::RTFrame frame{.frameId = 0x8001U,
                    .cycleCounter = 1U,
                    .dataStatus = static_cast<std::uint8_t>(rt::DATA_STATUS_VALID |
                                                            rt::DATA_STATUS_PROVIDER_RUN |
                                                            rt::DATA_STATUS_STATION_OK |
                                                            rt::DATA_STATUS_STATE),
                    .transferStatus = 0,
                    .payload = payload};
  controllerTx->Send(rt::BuildEthernetFrame(kValveMac, kControllerMac, frame));
  std::this_thread::sleep_for(std::chrono::milliseconds(80));
 
  EXPECT_TRUE(controllerRx->Recv().empty());
  valve.Stop();
}
 
TEST(VirtualAumaScenarioTests, InvalidInputClearsDataValidity)
{
  const auto gsdml = MakeAumaGsdml();
  auto iocrs = MakeTestAumaIocrs(gsdml);
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("valve1", gsdml, kValveMac,
                         std::move(iocrs.input), std::move(iocrs.output));
  std::vector<Bytes> frames;
  std::mutex mutex;
  valve.OnFrame([&](const Bytes& frame)
  {
    std::lock_guard<std::mutex> lock(mutex);
    frames.push_back(frame);
  });
  valve.SetScenario(VirtualAumaScenario::InvalidInput);
  valve.Start(bus);
 
  auto controllerTx = bus.CreateSocket(kControllerMac);
  controllerTx->SetTimeout(std::chrono::milliseconds(2));
  rt::RTFrame outputFrame;
  outputFrame.frameId = 0x8001U;
  outputFrame.cycleCounter = 1U;
  outputFrame.dataStatus = rt::DATA_STATUS_VALID | rt::DATA_STATUS_PROVIDER_RUN |
                           rt::DATA_STATUS_STATION_OK | rt::DATA_STATUS_STATE;
  outputFrame.payload.resize(16U, 0U);
  outputFrame.payload[0] = 0x01U;
  controllerTx->Send(rt::BuildEthernetFrame(kValveMac, kControllerMac, outputFrame));
 
  ASSERT_TRUE(WaitUntil([&frames, &mutex]
  {
    std::lock_guard<std::mutex> lock(mutex);
    return !frames.empty();
  }));
 
  bool invalidFound = false;
  {
    std::lock_guard<std::mutex> lock(mutex);
    for (const auto& frame : frames)
    {
      const auto parsed = rt::ParseEthernetFrame(frame);
      if (parsed.has_value() && parsed->frameId == 0x9000U)
      {
        invalidFound = (parsed->dataStatus & rt::DATA_STATUS_VALID) == 0U;
      }
    }
  }
  EXPECT_TRUE(invalidFound);
  valve.Stop();
}
 
TEST(VirtualAumaScenarioTests, DuplicateInputProducesDuplicateCycleCounters)
{
  const auto auma = MakeAumaGsdml();
  const auto phoenix = test::MakePhoenixGsdml();
  auto valveIocrs = MakeTestAumaIocrs(auma);
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("valve1", auma, kValveMac,
                         std::move(valveIocrs.input), std::move(valveIocrs.output));
  valve.Start(bus);
  VirtualPhoenixPlc plc("plc1", phoenix, kControllerMac);
  auto controllerIocrs = MakeTestAumaIocrs(auma);
  asio::io_context ioContext;
  profinet::AsioIoContextRunner ioContextRunner(ioContext);
 
  plc.Connect(ioContext, bus, valve, std::move(controllerIocrs.input), std::move(controllerIocrs.output));
 
  ASSERT_TRUE(WaitUntil([&plc]
  {
    const auto stats = plc.ConnectionStats("valve1");
    return stats.has_value() && stats->framesReceived >= 3U;
  }));
  valve.SetScenario(VirtualAumaScenario::DuplicateInput);
 
  ASSERT_TRUE(WaitUntil([&plc]
  {
    const auto stats = plc.ConnectionStats("valve1");
    return stats.has_value() && stats->framesDuplicate > 0U;
  }));
 
  plc.Stop();
  valve.Stop();
}
 
TEST(VirtualAumaScenarioTests, OutOfOrderInputProducesOutOfOrderCycles)
{
  const auto auma = MakeAumaGsdml();
  const auto phoenix = test::MakePhoenixGsdml();
  auto valveIocrs = MakeTestAumaIocrs(auma);
  InMemoryEthernetBus bus;
  VirtualAumaValve valve("valve1", auma, kValveMac,
                         std::move(valveIocrs.input), std::move(valveIocrs.output));
  valve.Start(bus);
  VirtualPhoenixPlc plc("plc1", phoenix, kControllerMac);
  auto controllerIocrs = MakeTestAumaIocrs(auma);
  asio::io_context ioContext;
  profinet::AsioIoContextRunner ioContextRunner(ioContext);
 
  plc.Connect(ioContext, bus, valve, std::move(controllerIocrs.input), std::move(controllerIocrs.output));
 
  ASSERT_TRUE(WaitUntil([&plc]
  {
    const auto stats = plc.ConnectionStats("valve1");
    return stats.has_value() && stats->framesReceived >= 3U;
  }));
  valve.SetScenario(VirtualAumaScenario::OutOfOrderInput);
 
  ASSERT_TRUE(WaitUntil([&plc]
  {
    const auto stats = plc.ConnectionStats("valve1");
    return stats.has_value() && stats->framesOutOfOrder > 0U;
  }, std::chrono::milliseconds(600)));
 
  plc.Stop();
  valve.Stop();
}
 
TEST(VirtualAumaScenarioTests, EveryScenarioHasStableName)
{
  EXPECT_STREQ(ToString(VirtualAumaScenario::Normal), "normal");
  EXPECT_STREQ(ToString(VirtualAumaScenario::Fault), "fault");
  EXPECT_STREQ(ToString(VirtualAumaScenario::BadIops), "bad-iops");
  EXPECT_STREQ(ToString(VirtualAumaScenario::NoInput), "no-input");
  EXPECT_STREQ(ToString(VirtualAumaScenario::SlowValve), "slow-valve");
  EXPECT_STREQ(ToString(VirtualAumaScenario::Jammed), "jammed");
  EXPECT_STREQ(ToString(VirtualAumaScenario::InvalidInput), "invalid-input");
  EXPECT_STREQ(ToString(VirtualAumaScenario::DuplicateInput), "duplicate-input");
  EXPECT_STREQ(ToString(VirtualAumaScenario::OutOfOrderInput), "out-of-order-input");
}
 
TEST(VirtualAumaValveTests, RejectsInvalidMotionConfiguration)
{
  const auto gsdml = MakeAumaGsdml();
  auto iocrs = MakeTestAumaIocrs(gsdml);
  VirtualAumaValveConfiguration config;
  config.travelUnitsPerSecond = 0.0;
  EXPECT_THROW(VirtualAumaValve("valve1", gsdml, kValveMac,
                                std::move(iocrs.input), std::move(iocrs.output),
                                std::move(config)),
               std::invalid_argument);
}
 
} // namespace profinet::sim