test_alarms.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include "profinet/alarms.h"
 
using namespace profinet;
using namespace profinet::wire;
using namespace profinet;
 
namespace
{
class AlarmItemTest : public ::testing::Test
{
};
} // namespace
  //
TEST_F(AlarmItemTest, ParseChannelDiagnosis)
{
  Bytes data;
  PutU16(data, static_cast<std::uint16_t>(Usi::ChannelDiagnosis));
  PutU16(data, 0x8005); // channel_number: accumulative bit set, value 5
  PutU16(data, 0x0001); // channel_properties
  PutU16(data, 0x0002); // channel_error_type
 
  auto [item, Offset] = ParseAlarmItem(data, 0);
 
  EXPECT_EQ(Offset, data.size());
 
  auto* diag = std::get_if<DiagnosisItem>(&item);
  ASSERT_NE(diag, nullptr);
 
  EXPECT_EQ(diag->ChannelNumberValue(), static_cast<std::uint16_t>(5));
  EXPECT_TRUE(diag->IsAccumulative());
  EXPECT_FALSE(diag->IsExtended());
  EXPECT_EQ(diag->UsiName(), "Channel Diagnosis");
}
 
TEST_F(AlarmItemTest, ParseExtChannelDiagnosis)
{
  Bytes data;
  PutU16(data, static_cast<std::uint16_t>(Usi::ExtendedChannelDiagnosis));
  PutU16(data, 1);
  PutU16(data, 2);
  PutU16(data, 3);
  PutU16(data, 0x1234);     // ext_channel_error_type
  PutU32(data, 0xDEADBEEF); // ext_channel_add_value
 
  auto [item, Offset] = ParseAlarmItem(data, 0);
 
  EXPECT_EQ(Offset, data.size());
 
  auto* diag = std::get_if<DiagnosisItem>(&item);
  ASSERT_NE(diag, nullptr);
 
  EXPECT_TRUE(diag->IsExtended());
 
  EXPECT_EQ(diag->extChannelErrorType, static_cast<std::uint16_t>(0x1234));
 
  EXPECT_EQ(diag->extChannelAddValue, static_cast<std::uint32_t>(0xDEADBEEF));
}
 
TEST_F(AlarmItemTest, ParsePEAlarmItem)
{
  Bytes data;
  PutU16(data, static_cast<std::uint16_t>(Usi::PeAlarm));
  PutU16(data, 0x8310); // block_type
  PutU16(data, 3);      // block_length
  data.push_back(0x01); // ver_high
  data.push_back(0x00); // ver_low
  data.push_back(0xF0); // pe_operational_mode = Operate
 
  auto [item, Offset] = ParseAlarmItem(data, 0);
 
  EXPECT_EQ(Offset, data.size());
 
  auto* pe = std::get_if<PEAlarmItem>(&item);
  ASSERT_NE(pe, nullptr);
 
  EXPECT_EQ(pe->ModeName(), "PE_Operate");
}
 
TEST_F(AlarmItemTest, ParseUnknownUSI)
{
  Bytes data;
  PutU16(data, 0x1234); // manufacturer-specific range
  data.push_back(0xAA);
  data.push_back(0xBB);
 
  auto [item, Offset] = ParseAlarmItem(data, 0);
 
  EXPECT_EQ(Offset, data.size());
 
  auto* generic = std::get_if<AlarmItem>(&item);
  ASSERT_NE(generic, nullptr);
 
  EXPECT_EQ(generic->rawData, Bytes({0xAA, 0xBB}));
 
  EXPECT_EQ(generic->UsiName().rfind("Manufacturer Specific", 0), 0U);
}
 
TEST_F(AlarmItemTest, RejectsTruncatedData)
{
  EXPECT_THROW(ParseAlarmItem({0x80}, 0), std::exception);
}
 
TEST_F(AlarmItemTest, ParseAlarmNotificationParsesHeaderAndItems)
{
  Bytes data;
 
  // BlockHeader: type + block length + block version.
  PutU16(data, static_cast<std::uint16_t>(BlockType::AlarmNotificationHigh));
 
  // BlockLength counts everything after the BlockLength field:
  // BlockVersion (2) + AlarmNotification fixed body (20)
  // + ChannelDiagnosis item (8) = 30 bytes.
  PutU16(data, 30);
 
  PutU8(data, 0x01);
  PutU8(data, 0x00);
 
  // AlarmNotification fixed body (20 bytes).
  PutU16(data, 0x0001); // alarm_type = Diagnosis
  PutU32(data, 0);      // api
  PutU16(data, 1);      // slot
  PutU16(data, 1);      // subslot
  PutU32(data, 0);      // module_ident
  PutU32(data, 0);      // submodule_ident
  PutU16(data, 0x0805); // sequence=5, channel diagnosis bit
 
  // One ChannelDiagnosis item (8 bytes).
  PutU16(data, static_cast<std::uint16_t>(Usi::ChannelDiagnosis));
  PutU16(data, 1);
  PutU16(data, 2);
  PutU16(data, 3);
 
  AlarmNotification n = ParseAlarmNotification(data);
 
  ASSERT_TRUE(n.IsHighPriority());
  EXPECT_EQ(n.AlarmTypeName(), "Diagnosis");
  EXPECT_EQ(n.alarmSequenceNumber, static_cast<std::uint16_t>(5));
  ASSERT_TRUE(n.channelDiagnosis);
  EXPECT_EQ(n.Location(), "0:1:0x0001");
 
  ASSERT_EQ(n.items.size(), static_cast<std::size_t>(1));
  EXPECT_NE(std::get_if<DiagnosisItem>(&n.items[0]), nullptr);
}
 
TEST_F(AlarmItemTest, ParseAlarmNotificationRejectsTooShortData)
{
  EXPECT_THROW(ParseAlarmNotification(Bytes(10, 0)), std::exception);
}