test_diagnosisMore.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <cstdint>
#include <vector>
 
#include "profinet/diagnosis.h"
#include "profinet/wire.h"
 
using namespace profinet;
using namespace profinet::diagnosis;
 
namespace
{
Bytes MakeDiagnosisHeader(const std::uint16_t bodyLength, const std::uint16_t type = 0x0010)
{
  Bytes data;
  wire::PutU16(data, type);
  wire::PutU16(data, static_cast<std::uint16_t>(bodyLength + 2U));
  wire::PutU8(data, 1);
  wire::PutU8(data, 0);
  return data;
}
 
Bytes MakeEntry(const std::uint16_t channel, const std::uint16_t properties,
                const std::uint16_t usi, const std::uint16_t errorType)
{
  Bytes out;
  wire::PutU16(out, channel);
  wire::PutU16(out, properties);
  wire::PutU16(out, usi);
  wire::PutU16(out, errorType);
  return out;
}
 
Bytes MakeExtendedEntry(const std::uint16_t channel, const std::uint16_t properties,
                        const std::uint16_t errorType, const std::uint16_t extErrorType,
                        const std::uint32_t extAddValue)
{
  Bytes out = MakeEntry(channel, properties,
                        static_cast<std::uint16_t>(Usi::Bit15AndExternalChannelDiagnosisOfChannelNumber), errorType);
  wire::PutU16(out, extErrorType);
  wire::PutU32(out, extAddValue);
  return out;
}
 
Bytes MakeQualifiedEntry(const std::uint16_t channel, const std::uint16_t properties,
                         const std::uint16_t errorType, const std::uint16_t extErrorType,
                         const std::uint32_t extAddValue, const std::uint32_t qualifier)
{
  Bytes out = MakeEntry(channel, properties,
                        static_cast<std::uint16_t>(Usi::Bit15AndQualifiedChannelDiagnosisOfChannelNumber), errorType);
  wire::PutU16(out, extErrorType);
  wire::PutU32(out, extAddValue);
  wire::PutU32(out, qualifier);
  return out;
}
 
Bytes MakeSimpleBlock(const Bytes& entries)
{
  Bytes out = MakeDiagnosisHeader(static_cast<std::uint16_t>(entries.size()));
  out.insert(out.end(), entries.begin(), entries.end());
  return out;
}
 
} // namespace
 
namespace
{ 
class DiagnosisMoreTests : public ::testing::Test
{
};
} // namespace
 
TEST_F(DiagnosisMoreTests, ChannelTypeNamesCoverAllValues)
{
  ChannelProperties props;
 
  props.channelTypeValue = ChannelType::Reserved;
  EXPECT_EQ(props.ChannelTypeName(), "Reserved");
 
  props.channelTypeValue = ChannelType::Specific;
  EXPECT_EQ(props.ChannelTypeName(), "Specific");
 
  props.channelTypeValue = ChannelType::All;
  EXPECT_EQ(props.ChannelTypeName(), "All");
 
  props.channelTypeValue = ChannelType::Submodule;
  EXPECT_EQ(props.ChannelTypeName(), "Submodule");
 
  props.channelTypeValue = static_cast<ChannelType>(0xFF);
  EXPECT_FALSE(props.ChannelTypeName().empty());
}
 
TEST_F(DiagnosisMoreTests, SpecifierNamesCoverAllValues)
{
  ChannelProperties props;
 
  props.specifier = ChannelSpecifier::AllDisappears;
  EXPECT_EQ(props.SpecifierName(), "All Disappears");
 
  props.specifier = ChannelSpecifier::Appears;
  EXPECT_EQ(props.SpecifierName(), "Appears");
 
  props.specifier = ChannelSpecifier::Disappears;
  EXPECT_EQ(props.SpecifierName(), "Disappears");
 
  props.specifier = ChannelSpecifier::DisappearsOther;
  EXPECT_EQ(props.SpecifierName(), "Disappears Other");
 
  props.specifier = static_cast<ChannelSpecifier>(0xFF);
  EXPECT_FALSE(props.SpecifierName().empty());
}
 
TEST_F(DiagnosisMoreTests, DirectionNamesCoverAllValues)
{
  ChannelProperties props;
 
  props.direction = ChannelDirection::Manufacturer;
  EXPECT_EQ(props.DirectionName(), "Manufacturer");
 
  props.direction = ChannelDirection::Input;
  EXPECT_EQ(props.DirectionName(), "Input");
 
  props.direction = ChannelDirection::Output;
  EXPECT_EQ(props.DirectionName(), "Output");
 
  props.direction = ChannelDirection::Bidirectional;
  EXPECT_EQ(props.DirectionName(), "Bidirectional");
 
  props.direction = static_cast<ChannelDirection>(0xFF);
  EXPECT_FALSE(props.DirectionName().empty());
}
 
TEST_F(DiagnosisMoreTests, ChannelPropertiesFromUint16RetainsRawValue)
{
  const auto props = ChannelProperties::FromUint16(0xFFFF);
 
  EXPECT_EQ(props.raw, 0xFFFFU);
  EXPECT_EQ(props.channelTypeValue, ChannelType::Submodule);
  EXPECT_EQ(props.accumulative, ChannelAccumulative::No);
  EXPECT_EQ(props.specifier, ChannelSpecifier::AllDisappears);
  EXPECT_EQ(props.direction, ChannelDirection::Bidirectional);
}
 
TEST_F(DiagnosisMoreTests, AnyChannelDiagnosisUsiClassification)
{
  AnyChannelDiagnosis entry;
  entry.usi = Usi::NoIdentifier;
  EXPECT_TRUE(entry.IsChannelDiagnosis());
  EXPECT_FALSE(entry.IsExtChannelDiagnosis());
  EXPECT_FALSE(entry.IsQualifiedChannelDiagnosis());
 
  entry.usi = Usi::Bit15OfChannelNumber;
  EXPECT_TRUE(entry.IsChannelDiagnosis());
 
  entry.usi = Usi::Bit15AndExternalChannelDiagnosisOfChannelNumber;
  EXPECT_TRUE(entry.IsExtChannelDiagnosis());
  EXPECT_FALSE(entry.IsQualifiedChannelDiagnosis());
 
  entry.usi = Usi::Bit15AndQualifiedChannelDiagnosisOfChannelNumber;
  EXPECT_TRUE(entry.IsQualifiedChannelDiagnosis());
  EXPECT_FALSE(entry.IsExtChannelDiagnosis());
}
 
TEST_F(DiagnosisMoreTests, DiagnosisDataMaintenanceFlagsAreFalseWhenClear)
{
  DiagnosisData data;
 
  AnyChannelDiagnosis entry;
  entry.base.properties.maintenanceRequired = false;
  entry.base.properties.naintenanceDemanded = false;
  data.entries.push_back(entry);
 
  EXPECT_FALSE(data.HasMaintenanceRequired());
  EXPECT_FALSE(data.HasMaintenanceDemanded());
}
 
TEST_F(DiagnosisMoreTests, DiagnosisDataDetectsMaintenanceDemanded)
{
  DiagnosisData data;
 
  AnyChannelDiagnosis entry;
  entry.base.properties.naintenanceDemanded = true;
  data.entries.push_back(entry);
 
  EXPECT_TRUE(data.HasMaintenanceDemanded());
  EXPECT_FALSE(data.HasMaintenanceRequired());
}
 
TEST_F(DiagnosisMoreTests, DecodeChannelErrorTypeCoversAdditionalRanges)
{
  EXPECT_EQ(DecodeChannelErrorType(0x8001), "Remote mismatch");
  EXPECT_FALSE(DecodeChannelErrorType(0x8100).empty());
  EXPECT_EQ(DecodeChannelErrorType(0x0100), "Manufacturer-specific (0x0100)");
}
 
TEST_F(DiagnosisMoreTests, DecodeExtChannelErrorTypeHandlesUnknownValues)
{
  EXPECT_EQ(DecodeExtChannelErrorType(0x8001, 0x8005), "No peer detected");
 
  EXPECT_EQ(DecodeExtChannelErrorType(0x8001, 0x1234), "Manufacturer-specific (0x1234)");
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisBlockAcceptsUsiZero)
{
  Bytes body = MakeEntry(4, 0, 0, 0x0001);
  Bytes data = MakeDiagnosisHeader(static_cast<std::uint16_t>(body.size()));
  data.insert(data.end(), body.begin(), body.end());
 
  const auto result = ParseDiagnosisBlock(data, 7, 8, 9);
 
  ASSERT_EQ(result.entries.size(), 1U);
  EXPECT_EQ(result.entries[0].base.api, 7U);
  EXPECT_EQ(result.entries[0].base.slot, 8U);
  EXPECT_EQ(result.entries[0].base.subslot, 9U);
  EXPECT_TRUE(result.entries[0].IsChannelDiagnosis());
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisBlockStoresExtendedDiagnosis)
{
  Bytes body = MakeExtendedEntry(2, 0, 0x8001, 0x8005, 0x11223344);
  Bytes data = MakeDiagnosisHeader(static_cast<std::uint16_t>(body.size()));
  data.insert(data.end(), body.begin(), body.end());
 
  const auto result = ParseDiagnosisBlock(data);
 
  ASSERT_EQ(result.entries.size(), 1U);
  ASSERT_TRUE(result.entries[0].ext.has_value());
  EXPECT_EQ(result.entries[0].ext->extErrorType, 0x8005U);
  EXPECT_EQ(result.entries[0].ext->extAddValue, 0x11223344U);
  EXPECT_EQ(result.entries[0].ext->extErrorTypeName, "No peer detected");
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisBlockStoresQualifiedDiagnosis)
{
  Bytes body = MakeQualifiedEntry(3, 0, 0x8000, 0x8000, 0x01020304, 0xAABBCCDD);
  Bytes data = MakeDiagnosisHeader(static_cast<std::uint16_t>(body.size()));
  data.insert(data.end(), body.begin(), body.end());
 
  const auto result = ParseDiagnosisBlock(data);
 
  ASSERT_EQ(result.entries.size(), 1U);
  ASSERT_TRUE(result.entries[0].qualified.has_value());
  EXPECT_EQ(result.entries[0].qualified->extErrorType, 0x8000U);
  EXPECT_EQ(result.entries[0].qualified->extAddValue, 0x01020304U);
  EXPECT_EQ(result.entries[0].qualified->qualifier, 0xAABBCCDDU);
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisBlockStopsOnTruncatedEntry)
{
  Bytes data = MakeDiagnosisHeader(5);
  data.insert(data.end(), {0, 1, 0, 0, 0});
 
  const auto result = ParseDiagnosisBlock(data);
 
  EXPECT_TRUE(result.entries.empty());
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisBlockStopsOnZeroEntry)
{
  Bytes data = MakeDiagnosisHeader(8);
  data.insert(data.end(), 8, 0);
 
  const auto result = ParseDiagnosisBlock(data);
 
  EXPECT_TRUE(result.entries.empty());
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisBlockAcceptsAlternativeBlockTypes)
{
  const std::vector<std::uint16_t> types{0x0010, 0x0011, 0x8010, 0x8011, 0x8012};
 
  for (const auto type : types)
  {
    Bytes entry = MakeEntry(1, 0, 0x8000, 1);
    Bytes data = MakeDiagnosisHeader(static_cast<std::uint16_t>(entry.size()), type);
    data.insert(data.end(), entry.begin(), entry.end());
 
    const auto result = ParseDiagnosisBlock(data);
    ASSERT_EQ(result.entries.size(), 1U) << "type=0x" << std::hex << type;
  }
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisBlockAcceptsRawEntry)
{
  const Bytes data = MakeEntry(1, 0, 0x8000, 1);
 
  const auto result = ParseDiagnosisBlock(data, 1, 2, 3);
 
  ASSERT_EQ(result.entries.size(), 1U);
  EXPECT_EQ(result.entries[0].base.slot, 2U);
  EXPECT_EQ(result.entries[0].base.subslot, 3U);
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisSimpleStopsOnIncompleteEntry)
{
  Bytes data = MakeDiagnosisHeader(9);
  wire::PutU16(data, 1);
  wire::PutU16(data, 0);
  wire::PutU16(data, 1);
  wire::PutU16(data, 2);
  wire::PutU16(data, 0);
 
  const auto result = ParseDiagnosisSimple(data, 0, 1, 2);
 
  ASSERT_EQ(result.entries.size(), 1U);
  EXPECT_EQ(result.entries[0].base.channelNumber, 1U);
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisSimplePreservesLocation)
{
  Bytes data = MakeDiagnosisHeader(12);
  wire::PutU16(data, 3);
  wire::PutU16(data, 0);
  wire::PutU16(data, 1);
  wire::PutU16(data, 0);
  wire::PutU16(data, 0);
  wire::PutU16(data, 0);
 
  const auto result = ParseDiagnosisSimple(data, 0, 4, 5);
 
  ASSERT_EQ(result.entries.size(), 1U);
  EXPECT_EQ(result.entries[0].base.slot, 4U);
  EXPECT_EQ(result.entries[0].base.subslot, 5U);
}
TEST_F(DiagnosisMoreTests, ChannelPropertiesFromUint16CoversAllValidFields)
{
  for (std::uint16_t channelType = 0; channelType <= 3; ++channelType)
  {
    const auto props = ChannelProperties::FromUint16(channelType);
    EXPECT_EQ(static_cast<std::uint8_t>(props.channelTypeValue), channelType);
  }
 
  for (std::uint16_t accumulative = 0; accumulative <= 2; ++accumulative)
  {
    const auto props =
        ChannelProperties::FromUint16(static_cast<std::uint16_t>(accumulative << 2));
    EXPECT_EQ(static_cast<std::uint8_t>(props.accumulative), accumulative);
  }
 
  const auto maintenance = ChannelProperties::FromUint16(
      static_cast<std::uint16_t>((1U << 5U) | (1U << 6U)));
 
  EXPECT_TRUE(maintenance.maintenanceRequired);
  EXPECT_TRUE(maintenance.naintenanceDemanded);
 
  for (std::uint16_t specifier = 0; specifier <= 3; ++specifier)
  {
    const auto props =
        ChannelProperties::FromUint16(static_cast<std::uint16_t>(specifier << 8));
    EXPECT_EQ(static_cast<std::uint8_t>(props.specifier), specifier);
  }
 
  for (std::uint16_t direction = 0; direction <= 3; ++direction)
  {
    const auto props =
        ChannelProperties::FromUint16(static_cast<std::uint16_t>(direction << 11));
    EXPECT_EQ(static_cast<std::uint8_t>(props.direction), direction);
  }
}
 
TEST_F(DiagnosisMoreTests, ChannelPropertiesFromUint16UsesFallbacks)
{
  const auto invalidAccumulative = ChannelProperties::FromUint16(3U << 2U);
  EXPECT_EQ(invalidAccumulative.accumulative, ChannelAccumulative::No);
 
  const auto invalidSpecifier = ChannelProperties::FromUint16(4U << 8U);
  EXPECT_EQ(invalidSpecifier.specifier, ChannelSpecifier::AllDisappears);
}
 
TEST_F(DiagnosisMoreTests, ChannelDiagnosisDetectsSubmoduleLevel)
{
  ChannelDiagnosis diagnosis;
 
  diagnosis.channelNumber = static_cast<std::uint16_t>(Usi::Bit15OfChannelNumber);
  EXPECT_TRUE(diagnosis.IsSubmoduleLevel());
 
  diagnosis.channelNumber = 1;
  EXPECT_FALSE(diagnosis.IsSubmoduleLevel());
}
 
TEST_F(DiagnosisMoreTests, DiagnosisDataGetByChannelFiltersAllMatchingEntries)
{
  DiagnosisData data;
 
  AnyChannelDiagnosis first;
  first.base.channelNumber = 7;
 
  AnyChannelDiagnosis second;
  second.base.channelNumber = 3;
 
  AnyChannelDiagnosis third;
  third.base.channelNumber = 7;
 
  data.entries = {first, second, third};
 
  const auto matches = data.GetByChannel(7);
 
  ASSERT_EQ(matches.size(), 2U);
  EXPECT_EQ(matches[0], &data.entries[0]);
  EXPECT_EQ(matches[1], &data.entries[2]);
 
  EXPECT_TRUE(data.GetByChannel(99).empty());
}
 
TEST_F(DiagnosisMoreTests, DiagnosisDataHasErrorsReflectsEntries)
{
  DiagnosisData data;
 
  EXPECT_FALSE(data.HasErrors());
 
  data.entries.emplace_back();
 
  EXPECT_TRUE(data.HasErrors());
}
 
TEST_F(DiagnosisMoreTests, DecodeChannelErrorTypeCoversAllFallbackRanges)
{
  EXPECT_EQ(DecodeChannelErrorType(0x000B), "Reserved (0x000B)");
  EXPECT_EQ(DecodeChannelErrorType(0x000E), "Reserved (0x000E)");
 
  EXPECT_EQ(DecodeChannelErrorType(0x001C), "Unknown (0x001C)");
 
  EXPECT_EQ(DecodeChannelErrorType(0x0020), "Reserved (0x0020)");
  EXPECT_EQ(DecodeChannelErrorType(0x00FF), "Reserved (0x00FF)");
 
  EXPECT_EQ(DecodeChannelErrorType(0x0100), "Manufacturer-specific (0x0100)");
  EXPECT_EQ(DecodeChannelErrorType(0x7FFF), "Manufacturer-specific (0x7FFF)");
 
  EXPECT_EQ(DecodeChannelErrorType(0x800E), "Reserved (0x800E)");
  EXPECT_EQ(DecodeChannelErrorType(0x8FFF), "Reserved (0x8FFF)");
 
  EXPECT_EQ(DecodeChannelErrorType(0x9000), "Profile-specific (0x9000)");
  EXPECT_EQ(DecodeChannelErrorType(0x9FFF), "Profile-specific (0x9FFF)");
 
  EXPECT_EQ(DecodeChannelErrorType(0xA000), "Reserved (0xA000)");
  EXPECT_EQ(DecodeChannelErrorType(0xFFFF), "Reserved (0xFFFF)");
}
 
TEST_F(DiagnosisMoreTests, DecodeExtChannelErrorTypeCoversFallbackRanges)
{
  EXPECT_EQ(DecodeExtChannelErrorType(0x1234, 0x0001),
            "Manufacturer-specific (0x0001)");
 
  EXPECT_EQ(DecodeExtChannelErrorType(0x1234, 0x8001),
            "Reserved (0x8001)");
 
  EXPECT_EQ(DecodeExtChannelErrorType(0x1234, 0x9000),
            "Profile-specific (0x9000)");
 
  EXPECT_EQ(DecodeExtChannelErrorType(0x1234, 0x0000),
            "Reserved");
 
  EXPECT_EQ(DecodeExtChannelErrorType(0x1234, 0xFFFF),
            "Unknown (0xFFFF)");
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisBlockConsumesLocationHeader)
{
  Bytes data;
 
  wire::PutU32(data, 0x00001234);
  wire::PutU16(data, 7);
  wire::PutU16(data, 0x8001);
 
  const Bytes entry = MakeEntry(5, 0, 0x8000, 0x0001);
  data.insert(data.end(), entry.begin(), entry.end());
 
  const auto result = ParseDiagnosisBlock(data, 99, 99, 99);
 
  ASSERT_EQ(result.entries.size(), 1U);
  EXPECT_EQ(result.entries[0].base.api, 0x1234U);
  EXPECT_EQ(result.entries[0].base.slot, 7U);
  EXPECT_EQ(result.entries[0].base.subslot, 0x8001U);
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisBlockHandlesUnknownUsi)
{
  const Bytes data = MakeEntry(4, 0, 0x1234, 0x0009);
 
  const auto result = ParseDiagnosisBlock(data);
 
  ASSERT_EQ(result.entries.size(), 1U);
  EXPECT_EQ(result.entries[0].usi, 0x1234U);
  EXPECT_EQ(result.entries[0].base.errorType, 0x0009U);
  EXPECT_EQ(result.entries[0].base.errorTypeName, "Error");
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisBlockStopsOnTruncatedExtendedDiagnosis)
{
  Bytes data = MakeDiagnosisHeader(10);
  wire::PutU16(data, 1);
  wire::PutU16(data, 0);
  wire::PutU16(
      data,
      static_cast<std::uint16_t>(Usi::Bit15AndExternalChannelDiagnosisOfChannelNumber));
  wire::PutU16(data, 0x8001);
  wire::PutU16(data, 0x8000);
 
  const auto result = ParseDiagnosisBlock(data);
 
  EXPECT_TRUE(result.entries.empty());
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisBlockStopsOnTruncatedQualifiedDiagnosis)
{
  Bytes data = MakeDiagnosisHeader(14);
  wire::PutU16(data, 1);
  wire::PutU16(data, 0);
  wire::PutU16(
      data,
      static_cast<std::uint16_t>(Usi::Bit15AndQualifiedChannelDiagnosisOfChannelNumber));
  wire::PutU16(data, 0x8000);
  wire::PutU16(data, 0x8000);
  wire::PutU32(data, 0x12345678);
  wire::PutU16(data, 0xABCD);
 
  const auto result = ParseDiagnosisBlock(data);
 
  EXPECT_TRUE(result.entries.empty());
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisBlockRejectsTooShortInput)
{
  EXPECT_TRUE(ParseDiagnosisBlock({}).entries.empty());
  EXPECT_TRUE(ParseDiagnosisBlock(Bytes(5U, 0)).entries.empty());
}
 
TEST_F(DiagnosisMoreTests, ParseDiagnosisSimpleRejectsTooShortInput)
{
  EXPECT_TRUE(ParseDiagnosisSimple({}).entries.empty());
  EXPECT_TRUE(ParseDiagnosisSimple(Bytes(5U, 0)).entries.empty());
}