test_diagnosis.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include "profinet/diagnosis.h"
#include "profinet/wire.h"
 
using namespace profinet;
using namespace profinet::diagnosis;
 
class DiagnosisTest : public ::testing::Test
{
};
 
TEST_F(DiagnosisTest, ChannelPropertiesFromUint16DecodesAllBitFields)
{
  // channel_type=Specific(1) | accumulative=MainFault(1)<<2 |
  // maintenance_required(1)<<5 | maintenance_demanded(1)<<6 |
  // specifier=Appears(1)<<8 | direction=Input(1)<<11
  const std::uint16_t raw =
      0x01 |
      (0x01 << 2) |
      (1 << 5) |
      (1 << 6) |
      (0x01 << 8) |
      (0x01 << 11);
 
  auto props = ChannelProperties::FromUint16(raw);
 
  EXPECT_EQ(props.channelTypeValue, ChannelType::Specific);
  EXPECT_EQ(props.accumulative, ChannelAccumulative::MainFault);
  EXPECT_TRUE(props.maintenanceRequired);
  EXPECT_TRUE(props.naintenanceDemanded);
  EXPECT_EQ(props.specifier, ChannelSpecifier::Appears);
  EXPECT_EQ(props.direction, ChannelDirection::Input);
}
 
TEST_F(DiagnosisTest, ChannelPropertiesFromUint16HandlesZeroValue)
{
  auto props = ChannelProperties::FromUint16(0);
 
  EXPECT_EQ(props.channelTypeValue, ChannelType::Reserved);
  EXPECT_FALSE(props.maintenanceRequired);
  EXPECT_FALSE(props.naintenanceDemanded);
}
 
TEST_F(DiagnosisTest, DecodeChannelErrorTypeResolvesKnownAndRangeBasedFallbacks)
{
  EXPECT_EQ(
      DecodeChannelErrorType(0x0001),
      "Short circuit");
 
  EXPECT_EQ(
      DecodeChannelErrorType(0x8000),
      "Data transmission impossible");
 
  EXPECT_EQ(
      DecodeChannelErrorType(0x9500),
      "IO-Link device event");
 
  EXPECT_EQ(
      DecodeChannelErrorType(0x0050),
      "Reserved (0x0050)");
 
  EXPECT_EQ(
      DecodeChannelErrorType(0x0200),
      "Manufacturer-specific (0x0200)");
 
  EXPECT_EQ(
      DecodeChannelErrorType(0x9100),
      "Profile-specific (0x9100)");
}
 
TEST_F(DiagnosisTest, DecodeExtChannelErrorTypeUsesContextSpecificTables)
{
  // 0x8000 (Data transmission impossible) + ext 0x8000 -> link state,
  // NOT "Accumulative info".
  EXPECT_EQ(
      DecodeExtChannelErrorType(0x8000, 0x8000),
      "Link state mismatch - Loss of link");
 
  // 0x8001 (Remote mismatch) + ext 0x8005 -> "No peer detected".
  EXPECT_EQ(
      DecodeExtChannelErrorType(0x8001, 0x8005),
      "No peer detected");
 
  // Error type with no dedicated table falls back to general table.
  EXPECT_EQ(
      DecodeExtChannelErrorType(0x0001, 0x8000),
      "Accumulative info");
 
  EXPECT_EQ(
      DecodeExtChannelErrorType(0x0001, 0x1234),
      "Manufacturer-specific (0x1234)");
}
 
namespace
{
 
// Build a ChannelDiagnosis-only entry (USI 0x8000):
// ChannelNumber(2) + ChannelProperties(2) + USI(2) +
// ChannelErrorType(2) = 8 bytes.
Bytes MakeChannelDiagEntry(
    std::uint16_t channel,
    std::uint16_t props,
    std::uint16_t errorType)
{
  Bytes out;
 
  wire::PutU16(out, channel);
  wire::PutU16(out, props);
  wire::PutU16(out, 0x8000); // USI
  wire::PutU16(out, errorType);
 
  return out;
}
 
Bytes MakeExtChannelDiagEntry(
    std::uint16_t channel,
    std::uint16_t props,
    std::uint16_t errorType,
    std::uint16_t extErrorType,
    std::uint32_t extAddValue)
{
  Bytes out;
 
  wire::PutU16(out, channel);
  wire::PutU16(out, props);
  wire::PutU16(out, 0x8002); // USI
  wire::PutU16(out, errorType);
  wire::PutU16(out, extErrorType);
  wire::PutU32(out, extAddValue);
 
  return out;
}
 
} // namespace
 
TEST_F(DiagnosisTest, ParseDiagnosisBlockParsesSingleChannelDiagnosisEntry)
{
  Bytes data;
 
  // 6-byte diagnosis block header (type=0x0010)
  wire::PutU16(data, 0x0010);
  wire::PutU16(data, 14); // block_length
  wire::PutU8(data, 1);
  wire::PutU8(data, 0);
 
  // Entry
  Bytes entry =
      MakeChannelDiagEntry(0x0001, 0x0000, 0x0006); // "Line break"
 
  data.insert(data.end(), entry.begin(), entry.end());
 
  auto result = ParseDiagnosisBlock(
      data,
      /*api=*/0,
      /*slot=*/1,
      /*subslot=*/1);
 
  ASSERT_EQ(result.entries.size(), 1U);
 
  EXPECT_TRUE(result.HasErrors());
  EXPECT_EQ(result.entries[0].base.channelNumber, 0x0001);
  EXPECT_EQ(result.entries[0].base.errorType, 0x0006);
  EXPECT_EQ(result.entries[0].base.errorTypeName, "Line break");
  EXPECT_TRUE(result.entries[0].IsChannelDiagnosis());
}
 
TEST_F(DiagnosisTest, ParseDiagnosisBlockParsesExtChannelDiagnosisEntry)
{
  Bytes data;
 
  wire::PutU16(data, 0x0010);
  wire::PutU16(data, 18);
  wire::PutU8(data, 1);
  wire::PutU8(data, 0);
 
  Bytes entry =
      MakeExtChannelDiagEntry(
          0x0002,
          0x0000,
          0x8001,
          0x8005,
          0); // Remote mismatch / No peer
 
  data.insert(data.end(), entry.begin(), entry.end());
 
  auto result = ParseDiagnosisBlock(data, 0, 1, 1);
 
  ASSERT_EQ(result.entries.size(), 1U);
 
  EXPECT_TRUE(result.entries[0].IsExtChannelDiagnosis());
  ASSERT_TRUE(result.entries[0].ext.has_value());
 
  EXPECT_EQ(
      result.entries[0].ext->extErrorTypeName,
      "No peer detected");
}
 
TEST_F(DiagnosisTest, ParseDiagnosisBlockLocationHeaderUpdatesLocation)
{
  Bytes data;
 
  wire::PutU16(data, 0x0010);
  wire::PutU16(data, 22);
  wire::PutU8(data, 1);
  wire::PutU8(data, 0);
 
  // Location header:
  // API(4)=0, Slot(2)=3, Subslot(2)=1
  wire::PutU32(data, 0);
  wire::PutU16(data, 3);
  wire::PutU16(data, 1);
 
  Bytes entry =
      MakeChannelDiagEntry(0x0001, 0x0000, 0x0001);
 
  data.insert(data.end(), entry.begin(), entry.end());
 
  auto result = ParseDiagnosisBlock(data);
 
  ASSERT_EQ(result.entries.size(), 1U);
 
  EXPECT_EQ(result.entries[0].base.slot, 3);
  EXPECT_EQ(result.entries[0].base.subslot, 1);
}
 
TEST_F(DiagnosisTest, ParseDiagnosisBlockReturnsEmptyForTooShortData)
{
  const Bytes data = {0x01, 0x02, 0x03};
 
  auto result = ParseDiagnosisBlock(data);
 
  EXPECT_FALSE(result.HasErrors());
  EXPECT_TRUE(result.entries.empty());
}
 
TEST_F(DiagnosisTest, ParseDiagnosisSimpleStopsOnZeroFilledSentinelEntry)
{
  Bytes data;
 
  wire::PutU16(data, 0x0010);
  wire::PutU16(data, 6);
  wire::PutU8(data, 1);
  wire::PutU8(data, 0);
 
  // One real entry:
  // ChannelNumber(2) + Properties(2) + ErrorType(2)
  // Simple format, no USI field.
  wire::PutU16(data, 0x0001);
  wire::PutU16(data, 0x0000);
  wire::PutU16(data, 0x0009); // "Error"
 
  // Sentinel (all zero)
  wire::PutU16(data, 0);
  wire::PutU16(data, 0);
  wire::PutU16(data, 0);
 
  auto result = ParseDiagnosisSimple(data, 0, 2, 1);
 
  ASSERT_EQ(result.entries.size(), 1U);
 
  EXPECT_EQ(result.entries[0].base.errorTypeName, "Error");
  EXPECT_EQ(result.entries[0].base.slot, 2);
}
 
TEST_F(DiagnosisTest, DiagnosisDataMaintenanceFlagsReflectEntryFlags)
{
  Bytes data;
 
  wire::PutU16(data, 0x0010);
  wire::PutU16(data, 14);
  wire::PutU8(data, 1);
  wire::PutU8(data, 0);
 
  // maintenance_required = bit 5 set
  Bytes entry =
      MakeChannelDiagEntry(
          0x0001,
          (1 << 5),
          0x0009);
 
  data.insert(data.end(), entry.begin(), entry.end());
 
  auto result = ParseDiagnosisBlock(data);
 
  EXPECT_TRUE(result.HasMaintenanceRequired());
  EXPECT_FALSE(result.HasMaintenanceDemanded());
}
 
TEST_F(DiagnosisTest, DiagnosisDataGetByChannelFiltersEntries)
{
  Bytes data;
 
  wire::PutU16(data, 0x0010);
  wire::PutU16(data, 22);
  wire::PutU8(data, 1);
  wire::PutU8(data, 0);
 
  Bytes e1 = MakeChannelDiagEntry(0x0001, 0, 0x0001);
 
  Bytes e2 = MakeChannelDiagEntry(0x0002, 0, 0x0002);
 
  data.insert(data.end(), e1.begin(), e1.end());
  data.insert(data.end(), e2.begin(), e2.end());
 
  auto result = ParseDiagnosisBlock(data);
 
  ASSERT_EQ(result.entries.size(), 2U);
 
  auto matches = result.GetByChannel(0x0002);
 
  ASSERT_EQ(matches.size(), 1U);
  EXPECT_EQ(matches[0]->base.channelNumber, 0x0002);
}