test_alarmListener.cpp

Go to the documentation of this file.

 
#include <gtest/gtest.h>
 
#include <cstdint>
#include <functional>
#include <memory>
 
#include "mocks/alarmListenerTestAccess.h"
#include "mocks/mockRawEthernetSocket.h"
#include "profinet/alarmListener.h"
 
namespace profinet
{
 
namespace
{
 
void TestAlarmCallback(const AlarmNotification& /*alarm*/)
{
}
 
AlarmEndpoint MakeEndpoint()
{
  return AlarmEndpoint{
      .interface = "lo",
      .controllerRef = 1,
      .deviceRef = 42,
      .deviceMac = MacAddress{0, 0, 0, 0, 0, 0},
  };
}
 
} // namespace
 
// -----------------------------------------------------------------------------
// AlarmEndpoint
// -----------------------------------------------------------------------------
 
TEST(AlarmEndpointTests, DefaultTransportIsLayer2)
{
  auto expectedMac = MacAddress{0x02, 0x00, 0x00, 0x00, 0x00, 0x01};
  const AlarmEndpoint endpoint{
      .interface = "eth0",
      .controllerRef = 1,
      .deviceRef = 42,
      .deviceMac = expectedMac,
  };
  EXPECT_EQ(endpoint.interface, "eth0");
  EXPECT_EQ(endpoint.controllerRef, 1);
  EXPECT_EQ(endpoint.deviceRef, 42);
  EXPECT_EQ(endpoint.deviceMac, expectedMac);
  EXPECT_EQ(endpoint.transport, 0);
}
 
TEST(AlarmEndpointTests, AllFieldsCanBeConfigured)
{
  const MacAddress deviceMac{0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
 
  const AlarmEndpoint endpoint{
      .interface = "eth0",
      .controllerRef = 100,
      .deviceRef = 200,
      .deviceMac = deviceMac,
      .transport = 1,
  };
 
  EXPECT_EQ(endpoint.interface, "eth0");
  EXPECT_EQ(endpoint.controllerRef, 100);
  EXPECT_EQ(endpoint.deviceRef, 200);
  EXPECT_EQ(endpoint.deviceMac, deviceMac);
  EXPECT_EQ(endpoint.transport, 1);
}
 
// -----------------------------------------------------------------------------
// AlarmListener
// -----------------------------------------------------------------------------
class AlarmListenerTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    endpoint = MakeEndpoint();
    ioContext = std::make_unique<asio::io_context>();
    listener = std::make_unique<AlarmListener>(*ioContext, endpoint);
  }
 
  std::unique_ptr<asio::io_context> ioContext;
  AlarmEndpoint endpoint;
  std::unique_ptr<AlarmListener> listener;
};
TEST_F(AlarmListenerTests, InitializesWithEndpoint)
{
  EXPECT_EQ(listener->IsRunning(), false);
}
 
TEST_F(AlarmListenerTests, InitializesWithoutCallbacks)
{
  // There is intentionally no public callback-count API. Registration is
  // tested through callback invocation in the callback-specific tests.
  EXPECT_FALSE(listener->IsRunning());
  // Verify that no callbacks are registered initially.
  EXPECT_EQ(AlarmListenerTestAccess::CallbackCount(*listener), 0U);
}
 
TEST_F(AlarmListenerTests, AddLambaCallbackRegistersCallback)
{
  bool callbackRegistered = false;
 
  listener->AddAlarmNotificationCallback([&callbackRegistered](const AlarmNotification&)
  {
    callbackRegistered = true;
  });
 
  // AddCallback() itself does not invoke the callback. The registered
  // callback is exercised by the alarm-processing tests.
  EXPECT_FALSE(callbackRegistered);
  ASSERT_EQ(AlarmListenerTestAccess::CallbackCount(*listener), 1U);
}
 
TEST_F(AlarmListenerTests, AddCallbackRegistersCallback)
{
  bool callbackRegistered = false;
 
  listener->AddAlarmNotificationCallback(TestAlarmCallback);
 
  // AddCallback() itself does not invoke the callback. The registered
  // callback is exercised by the alarm-processing tests.
  ASSERT_EQ(AlarmListenerTestAccess::CallbackCount(*listener), 1U);
}
TEST_F(AlarmListenerTests, AddEmptyCallbackDoesNothing)
{
  // Attempt to register an empty callback.
  listener->AddAlarmNotificationCallback({});
  // Verify that no callback was registered.
  EXPECT_EQ(AlarmListenerTestAccess::CallbackCount(*listener), 0U);
}
 
TEST_F(AlarmListenerTests, RemoveCallback)
{ // Register the callback that will subsequently be removed.
  listener->AddAlarmNotificationCallback(TestAlarmCallback);
 
  // Verify that registration succeeded before removal.
  ASSERT_EQ(AlarmListenerTestAccess::CallbackCount(*listener), 1U);
 
  // Remove the previously registered callback.
  listener->RemoveAlarmNotificationCallback(TestAlarmCallback);
 
  // Verify that the callback collection is now empty.
  EXPECT_EQ(AlarmListenerTestAccess::CallbackCount(*listener), 0U);
}
 
TEST_F(AlarmListenerTests, RemoveNonexistentCallbackDoesNotThrow)
{
  // Verify that removing an unregistered callback does not throw.
  EXPECT_NO_THROW(listener->RemoveAlarmNotificationCallback(TestAlarmCallback));
 
  // Verify that the callback collection remains empty.
  EXPECT_EQ(AlarmListenerTestAccess::CallbackCount(*listener), 0U);
}
 
TEST_F(AlarmListenerTests, RemoveEmptyCallbackDoesNothing)
{
  // Register a valid callback first.
  listener->AddAlarmNotificationCallback(TestAlarmCallback);
 
  // Verify that the callback was registered.
  ASSERT_EQ(AlarmListenerTestAccess::CallbackCount(*listener), 1U);
 
  // Attempt to remove an empty callback.
  listener->RemoveAlarmNotificationCallback({});
 
  // Verify that the existing callback remains registered.
  EXPECT_EQ(AlarmListenerTestAccess::CallbackCount(*listener), 1U);
}
 
TEST_F(AlarmListenerTests, IsRunningInitiallyFalse)
{
  // Verify the initial running state.
  EXPECT_FALSE(listener->IsRunning());
}
 
TEST_F(AlarmListenerTests, IsRunningReflectsState)
{
  auto socket = std::make_unique<::testing::NiceMock<MockRawEthernetSocket>>();
 
  ON_CALL(*socket, Recv())
      .WillByDefault(::testing::Return(std::vector<std::uint8_t>{}));
 
  ON_CALL(*socket, SetTimeout(::testing::_))
      .WillByDefault(::testing::Return());
  auto ioContext = std::make_unique<asio::io_context>();
  listener = std::make_unique<AlarmListener>(*ioContext, endpoint, std::nullopt);
 
  EXPECT_FALSE(listener->IsRunning());
 
  listener->Start(std::move(socket));
 
  EXPECT_TRUE(listener->IsRunning());
 
  listener->Stop();
 
  EXPECT_FALSE(listener->IsRunning());
}
 
TEST_F(AlarmListenerTests, ControllerMacDefaultsToZero)
{
  const MacAddress defaultMac{0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
  EXPECT_EQ(AlarmListenerTestAccess::ControllerMac(*listener), defaultMac);
}
 
TEST_F(AlarmListenerTests, AcceptsCustomControllerMac)
{
  const MacAddress customMac{
      0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
  auto ioContext = std::make_unique<asio::io_context>();
  listener = std::make_unique<AlarmListener>(*ioContext, endpoint, customMac);
 
  EXPECT_EQ(AlarmListenerTestAccess::ControllerMac(*listener), customMac);
}
 
// -----------------------------------------------------------------------------
// Frame IDs
// -----------------------------------------------------------------------------
 
TEST(AlarmFrameIdTests, HighPriorityAlarmFrameId)
{
  EXPECT_EQ(FRAME_ID_ALARM_HIGH, 0xFC01);
}
 
TEST(AlarmFrameIdTests, LowPriorityAlarmFrameId)
{
  EXPECT_EQ(FRAME_ID_ALARM_LOW, 0xFE01);
}
TEST_F(AlarmListenerTests, FailedStartLeavesListenerStopped)
{
  auto socket = std::make_unique<::testing::NiceMock<MockRawEthernetSocket>>();
  auto* s = socket.get();
 
  EXPECT_CALL(*s, SetTimeout(testing::_))
      .WillOnce(testing::Throw(std::runtime_error("timeout")));
 
  EXPECT_THROW(listener->Start(std::move(socket)), std::runtime_error);
  EXPECT_FALSE(listener->IsRunning());
}
 
TEST_F(AlarmListenerTests, StartAfterFailedStartSucceeds)
{
  auto socket = std::make_unique<::testing::NiceMock<MockRawEthernetSocket>>();
 
  auto* s = socket.get();
 
  EXPECT_CALL(*s, SetTimeout(testing::_))
      .WillOnce(testing::Throw(std::runtime_error("timeout")));
 
  EXPECT_THROW(listener->Start(std::move(socket)), std::runtime_error);
 
  // clean socket:
  socket = std::make_unique<::testing::NiceMock<MockRawEthernetSocket>>();
  EXPECT_NO_THROW(listener->Start(std::move(socket)));
  EXPECT_TRUE(listener->IsRunning());
  listener->Stop();
}
 
TEST_F(AlarmListenerTests, StopIsIdempotent)
{
  auto socket = std::make_unique<::testing::NiceMock<MockRawEthernetSocket>>();
 
  listener->Start(std::move(socket));
  listener->Stop();
  EXPECT_NO_THROW(listener->Stop());
}
} // namespace profinet