test_alarmNotification.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <cstdint>
 
#include "profinet/alarms.h"
 
namespace profinet
{
namespace
{
Bytes BuildAlarmBlock(bool highPriority = false, std::uint16_t specifier = 0x0401, const Bytes& items = {})
{
  Bytes body;
 
  wire::PutU16(body, 0x0001);
  wire::PutU32(body, 0x00000000);
  wire::PutU16(body, 1);
  wire::PutU16(body, 1);
  wire::PutU32(body, 0x00000001);
  wire::PutU32(body, 0x00000001);
  wire::PutU16(body, specifier);
 
  EXPECT_EQ(body.size(), 20U);
 
  const std::uint16_t blockType = highPriority ? 0x0001 : 0x0002;
 
  Bytes rest{0x01, 0x00};
 
  rest.insert(rest.end(), body.begin(), body.end());
  rest.insert(rest.end(), items.begin(), items.end());
 
  Bytes result;
 
  wire::PutU16(result, blockType);
  wire::PutU16(result, static_cast<std::uint16_t>(rest.size()));
  result.insert(result.end(), rest.begin(), rest.end());
 
  return result;
}
 
class AlarmNotificationTest : public ::testing::Test
{
 protected:
  static Bytes MakeChannelDiagnosisItem()
  {
    Bytes item;
 
    wire::PutU16(item, 0x8000);
    wire::PutU16(item, 1);
    wire::PutU16(item, 0x0800);
    wire::PutU16(item, 9);
 
    return item;
  }
};
 
} // namespace
 
TEST_F(AlarmNotificationTest, ItemLessAlarmIsAccepted)
{
  const Bytes block = BuildAlarmBlock();
 
  EXPECT_EQ(block.size(), 26U);
 
  const auto notification = ParseAlarmNotification(block);
 
  EXPECT_EQ(notification.slotNumber, 1U);
 
  EXPECT_TRUE(notification.items.empty());
}
 
TEST_F(AlarmNotificationTest, ChannelDiagnosisItemIsDecoded)
{
  const Bytes item = MakeChannelDiagnosisItem();
 
  const auto notification = ParseAlarmNotification(BuildAlarmBlock(false, 0x0401, item));
 
  ASSERT_EQ(notification.items.size(), 1U);
  auto* diag = std::get_if<DiagnosisItem>(&notification.items[0]);
  EXPECT_EQ(diag->userStructureId, static_cast<Usi>(0x8000U));
  EXPECT_EQ(diag->channelNumber, 1U);
  EXPECT_EQ(diag->channelErrorType, 9U);
}
 
TEST_F(AlarmNotificationTest, EthernetPaddingIsNotParsedAsItems)
{
  const Bytes block = BuildAlarmBlock(false, 0x0401, MakeChannelDiagnosisItem());
 
  Bytes padded = block;
 
  padded.insert(padded.end(), 6U, 0x00);
 
  const auto notification = ParseAlarmNotification(padded);
 
  EXPECT_EQ(notification.items.size(), 1U);
}
 
TEST_F(AlarmNotificationTest, ArDiagnosisIsBit14)
{
  const auto notification = ParseAlarmNotification(BuildAlarmBlock(false, 0x4000 | 1));
 
  EXPECT_TRUE(notification.arDiagnosisState);
}
 
TEST_F(AlarmNotificationTest, ReservedBit15IsNotArDiagnosis)
{
  const auto notification = ParseAlarmNotification(BuildAlarmBlock(false, 0x8000 | 1));
 
  EXPECT_FALSE(notification.arDiagnosisState);
}
} // namespace profinet