test_alarmListenerUdp.cpp

Go to the documentation of this file.

 
 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <cstdint>
#include <memory>
#include <mutex>
#include <vector>
 
#include "mocks/mockUdpSocket.h"
#include "profinet/alarmListener.h"
#include "profinet/protocol.h"
#include "profinet/wire.h"
 
namespace profinet
{
 
namespace
{
 
using ::testing::_;
using ::testing::StrictMock;
 
constexpr std::uint16_t kControllerReference = 1;
constexpr std::uint16_t kDeviceReference = 42;
 
constexpr std::uint16_t kUdpSourcePort = 45000;
 
UdpEndpoint MakeSourceAddress()
{
  return {
      .address = "127.0.0.1",
      .port = kUdpSourcePort};
}
 
Bytes BuildUdpAlarmNotification()
{
  Bytes body;
 
  wire::PutU16(body, 0x0001);     // AlarmType
  wire::PutU32(body, 0x00000000); // API
  wire::PutU16(body, 0x0001);     // Slot
  wire::PutU16(body, 0x0001);     // Subslot
  wire::PutU32(body, 0x00000001); // ModuleIdent
  wire::PutU32(body, 0x00000001); // SubmoduleIdent
  wire::PutU16(body, 0x0401);     // AlarmSpecifier
 
  EXPECT_EQ(body.size(), 20U);
  if (body.size() < 20U)
  {
    return {};
  }
 
  Bytes payload{
      0x00,
      0x00,
  }; // Block version
 
  payload.insert(payload.end(), body.begin(), body.end());
 
  // Unknown/generic USI. ParseAlarmItem() accepts this and stores the
  // remaining payload as raw data.
  payload.push_back(0xFF);
  payload.push_back(0xFF);
 
  Bytes block;
 
  constexpr std::uint16_t blockType = 0x0002;
 
  wire::PutU16(block, blockType);
  wire::PutU16(block, static_cast<std::uint16_t>(payload.size()));
 
  block.insert(block.end(), payload.begin(), payload.end());
 
  return block;
}
} // namespace
class AlarmListenerUdpTest : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    endpoint.interface = "lo";
    endpoint.controllerRef = kControllerReference;
    endpoint.deviceRef = kDeviceReference;
    endpoint.deviceMac = MacAddress{0x02, 0x00, 0x00, 0x00, 0x00, 0x01};
    endpoint.transport = 1;
    ioContext = std::make_unique<asio::io_context>();
    listener = std::make_unique<AlarmListener>(*ioContext, endpoint);
  }
 
  [[nodiscard]] UdpEndpoint SourceAddress() const
  {
    return MakeSourceAddress();
  }
  std::unique_ptr<asio::io_context> ioContext;
 
  AlarmEndpoint endpoint;
  std::unique_ptr<AlarmListener> listener;
};
 
TEST_F(AlarmListenerUdpTest, ReceivesAlarmAndSendsAckToSource)
{
  auto socket = std::make_unique<StrictMock<MockUdpSocket>>();
 
  MockUdpSocket* mockSocket = socket.get();
 
  const UdpEndpoint source = SourceAddress();
 
  UdpDatagram datagram;
  datagram.data = BuildUdpAlarmNotification();
  datagram.source = source;
 
  std::mutex callbackMutex;
  std::condition_variable callbackCondition;
  bool callbackReceived = false;
 
  listener->AddAlarmNotificationCallback(
      [&](const AlarmNotification& alarm)
  {
    EXPECT_EQ(alarm.slotNumber, 1U);
    EXPECT_EQ(alarm.subslotNumber, 1U);
 
    {
      std::scoped_lock lock(callbackMutex);
      callbackReceived = true;
    }
 
    callbackCondition.notify_one();
  });
 
  EXPECT_CALL(*mockSocket, RecvFrom(RECEIVE_BUFFER_LENGTH))
      .WillOnce(::testing::Return(datagram))
      .WillRepeatedly(
          ::testing::Return(UdpDatagram{}));
 
  EXPECT_CALL(*mockSocket, SendTo(_, _))
      .WillOnce(
          [&](const Bytes& ack,
              const UdpEndpoint& destination)
  {
    const UdpEndpoint source = SourceAddress();
    EXPECT_EQ(destination, source);
 
    EXPECT_FALSE(ack.empty());
    EXPECT_EQ(ack.size(), PNAlarmAckPDU::kSize);
  });
 
  listener->Start(nullptr, std::move(socket));
 
  {
    std::unique_lock lock(callbackMutex);
 
    const bool received =
        callbackCondition.wait_for(
            lock,
            std::chrono::seconds(1),
            [&callbackReceived]
    {
      return callbackReceived;
    });
 
    EXPECT_TRUE(received);
  }
 
  EXPECT_TRUE(listener->IsRunning());
 
  listener->Stop();
 
  EXPECT_FALSE(listener->IsRunning());
 
  (void)mockSocket;
}
 
TEST_F(AlarmListenerUdpTest, IgnoresTooShortUdpPayload)
{
  auto socket = std::make_unique<StrictMock<MockUdpSocket>>();
 
  MockUdpSocket* mockSocket = socket.get();
 
  std::mutex callbackMutex;
  std::condition_variable callbackCondition;
  bool callbackReceived = false;
 
  listener->AddAlarmNotificationCallback(
      [&](const AlarmNotification&)
  {
    {
      std::scoped_lock lock(callbackMutex);
      callbackReceived = true;
    }
 
    callbackCondition.notify_one();
  });
 
  UdpDatagram invalidDatagram;
  invalidDatagram.data = {0x01, 0x02, 0x03};
  invalidDatagram.source = SourceAddress();
 
  EXPECT_CALL(*mockSocket, RecvFrom(RECEIVE_BUFFER_LENGTH))
      .WillOnce(::testing::Return(invalidDatagram))
      .WillRepeatedly(::testing::Return(UdpDatagram{}));
 
  EXPECT_CALL(*mockSocket, SendTo(_, _))
      .Times(0);
 
  listener->Start(nullptr, std::move(socket));
 
  std::unique_lock lock(callbackMutex);
 
  EXPECT_FALSE(callbackCondition.wait_for(lock,
                                          std::chrono::milliseconds(50),
                                          [&callbackReceived]
  {
    return callbackReceived;
  }));
 
  lock.unlock();
 
  listener->Stop();
}
 
TEST_F(AlarmListenerUdpTest, StartWhileRunningDoesNothing)
{
  auto socket = std::make_unique<StrictMock<MockUdpSocket>>();
 
  MockUdpSocket* mockSocket = socket.get();
 
  EXPECT_CALL(*mockSocket, RecvFrom(RECEIVE_BUFFER_LENGTH))
      .WillRepeatedly(::testing::Return(UdpDatagram{}));
 
  listener->Start(nullptr, std::move(socket));
 
  ASSERT_TRUE(listener->IsRunning());
 
  listener->Start();
 
  EXPECT_TRUE(listener->IsRunning());
 
  listener->Stop();
 
  EXPECT_FALSE(listener->IsRunning());
}
 
TEST_F(AlarmListenerUdpTest, StopBeforeStartIsSafe)
{
  EXPECT_FALSE(listener->IsRunning());
 
  EXPECT_NO_THROW(listener->Stop());
 
  EXPECT_FALSE(listener->IsRunning());
}
 
} // namespace profinet