test_utilMore.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <array>
#include <chrono>
#include <cstdint>
#include <string>
#include <vector>
 
#include "profinet/exceptions.h"
#include "profinet/protocol.h"
#include "profinet/udpSocket.h"
#include "profinet/util.h"
 
using namespace profinet;
 
namespace
{ 
class UtilMoreTests : public ::testing::Test
{
};
} // namespace
 
TEST_F(UtilMoreTests, HexFormattersHandleBoundaries)
{
  EXPECT_EQ(Hex4(0), "0x0000");
  EXPECT_EQ(Hex4(0x000F), "0x000F");
  EXPECT_EQ(Hex4(0xFFFF), "0xFFFF");
 
  EXPECT_EQ(Hex2(0), "0x00");
  EXPECT_EQ(Hex2(0x0F), "0x0F");
  EXPECT_EQ(Hex2(0xFF), "0xFF");
}
 
TEST_F(UtilMoreTests, ToVecConvertsStringBytes)
{
  const auto bytes = ToVec(std::string{"A\x00\xFF", 3});
 
  ASSERT_EQ(bytes.size(), 3U);
  EXPECT_EQ(bytes[0], static_cast<std::uint8_t>('A'));
  EXPECT_EQ(bytes[1], 0U);
  EXPECT_EQ(bytes[2], 0xFFU);
}
 
TEST_F(UtilMoreTests, ToHexHandlesRawPointerAndEmptyInput)
{
  const std::uint8_t bytes[] = {0x00, 0x01, 0xAB, 0xFF};
 
  EXPECT_EQ(ToHex(bytes, 4), "0001abff");
  EXPECT_EQ(ToHex(bytes, 0), "");
  EXPECT_EQ(ToHex(std::vector<std::uint8_t>{}), "");
}
 
TEST_F(UtilMoreTests, DecodeBytesPreservesEmbeddedNul)
{
  const std::vector<std::uint8_t> bytes{'A', 0, 'B', 0, 0};
 
  EXPECT_EQ(DecodeBytes(bytes), std::string("A\0B", 3));
  EXPECT_EQ(DecodeBytes(static_cast<const std::uint8_t*>(nullptr), 0), "");
}
 
TEST_F(UtilMoreTests, String2MacAcceptsCanonicalHexDigits)
{
  const auto expectedMac = MacAddress{0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF};
  EXPECT_EQ(String2Mac("AA:bb:CC:dd:EE:ff"), expectedMac);
}
 
TEST_F(UtilMoreTests, String2MacRejectsMalformedVariants)
{
  EXPECT_THROW(String2Mac("aa-bb-cc-dd-ee-ff"), std::exception);
  EXPECT_THROW(String2Mac("aa:bb:cc:dd:ee:ff:00"), std::exception);
  EXPECT_THROW(String2Mac("a:bb:cc:dd:ee:ff"), std::exception);
  EXPECT_THROW(String2Mac("aa:bb:cc:dd:ee:fg"), std::exception);
}
 
TEST_F(UtilMoreTests, IpConversionHandlesBoundaryAddresses)
{
  EXPECT_EQ(String2Ip(Ip2String("0.0.0.0").data(), 4), "0.0.0.0");
  EXPECT_EQ(String2Ip(Ip2String("255.255.255.255").data(), 4), "255.255.255.255");
}
 
TEST_F(UtilMoreTests, String2IpRejectsInvalidLength)
{
  const std::array<std::uint8_t, 3> shortIp{1, 2, 3};
  EXPECT_THROW(String2Ip(shortIp.data(), shortIp.size()), std::exception);
}
 
TEST_F(UtilMoreTests, Ip2StringRejectsExtraComponents)
{
  EXPECT_THROW(Ip2String("1.2.3.4.5"), std::exception);
}
 
TEST_F(UtilMoreTests, SkipVlanTagsHandlesTruncatedTag)
{
  Bytes frame(14U, 0);
  frame[12] = 0x81;
  frame[13] = 0x00;
 
  EXPECT_EQ(SkipVlanTags(frame), 12U);
}
 
TEST_F(UtilMoreTests, SkipVlanTagsLeavesOrdinaryEtherTypeUntouched)
{
  Bytes frame(14U, 0);
  frame[12] = 0x08;
  frame[13] = 0x00;
 
  EXPECT_EQ(SkipVlanTags(frame), 12U);
}
 
TEST_F(UtilMoreTests, SkipVlanTagsHandlesTripleTaggedFrame)
{
  Bytes frame(12U, 0);
 
  const std::array<std::uint8_t, 4> outer{0x88, 0xA8, 0, 1};
  const std::array<std::uint8_t, 4> middle{0x81, 0x00, 0, 2};
  const std::array<std::uint8_t, 4> inner{0x81, 0x00, 0, 3};
 
  frame.insert(frame.end(), outer.begin(), outer.end());
  frame.insert(frame.end(), middle.begin(), middle.end());
  frame.insert(frame.end(), inner.begin(), inner.end());
  frame.push_back(0x88);
  frame.push_back(0x92);
 
  EXPECT_EQ(SkipVlanTags(frame), 24U);
}
 
TEST_F(UtilMoreTests, MaxTimeoutRemainingIsPositiveBeforeExpiry)
{
  const MaxTimeout timeout(std::chrono::duration<double>(1.0));
 
  EXPECT_GT(timeout.Remaining().count(), 0.0);
  EXPECT_FALSE(timeout.TimedOut());
}
 
TEST_F(UtilMoreTests, MaxTimeoutRemainingIsZeroAfterExpiry)
{
  const MaxTimeout timeout(std::chrono::duration<double>(-1.0));
 
  EXPECT_TRUE(timeout.TimedOut());
  EXPECT_EQ(timeout.Remaining().count(), 0.0);
}
 
TEST_F(UtilMoreTests, MaxTimeoutHandlesPastDeadline)
{
  const MaxTimeout timeout(std::chrono::duration<double>(-0.001));
 
  EXPECT_TRUE(timeout.TimedOut());
}
 
TEST_F(UtilMoreTests, GetExecutableDirectoryReturnsExistingDirectory)
{
  const auto directory = GetExecutableDirectory();
 
  EXPECT_TRUE(directory.is_absolute());
  EXPECT_TRUE(std::filesystem::exists(directory));
  EXPECT_TRUE(std::filesystem::is_directory(directory));
}
 
TEST_F(UtilMoreTests, GetMacRejectsUnknownInterface)
{
  EXPECT_THROW(GetInterfaceMac("this-interface-does-not-exist"), std::exception);
}
 
TEST_F(UtilMoreTests, GetMacReadsLoopbackInterface)
{
  const auto mac = GetInterfaceMac("lo");
  EXPECT_EQ(mac.size(), static_cast<std::size_t>(macAddressLength));
}
 
TEST_F(UtilMoreTests, SkipVlanTagsRecognizesSupportedTpids)
{
  for (const auto tpid : std::array<std::array<std::uint8_t, 2>, 3>{
           std::array<std::uint8_t, 2>{0x81, 0x00},
           std::array<std::uint8_t, 2>{0x88, 0xA8},
           std::array<std::uint8_t, 2>{0x91, 0x00}})
  {
    Bytes frame(12U, 0);
    frame.push_back(tpid[0]);
    frame.push_back(tpid[1]);
    frame.push_back(0x00);
    frame.push_back(0x01);
 
    EXPECT_EQ(SkipVlanTags(frame), 16U);
  }
}
 
TEST_F(UtilMoreTests, SkipVlanTagsStopsAfterSupportedTag)
{
  Bytes frame(12U, 0);
 
  frame.insert(frame.end(), {0x81, 0x00, 0xC0, 0x00});
  frame.insert(frame.end(), {0x88, 0x92});
 
  EXPECT_EQ(SkipVlanTags(frame), 16U);
}
 
TEST_F(UtilMoreTests, SkipVlanTagsHandlesShortFrame)
{
  EXPECT_EQ(SkipVlanTags(Bytes{}), 12U);
}
 
TEST_F(UtilMoreTests, SkipVlanTagsHandlesIncompleteVlanHeader)
{
  Bytes frame(15U, 0);
  frame[12] = 0x81;
  frame[13] = 0x00;
  frame[14] = 0xC0;
 
  EXPECT_EQ(SkipVlanTags(frame), 12U);
}
TEST_F(UtilMoreTests, String2MacHandlesBoundaryValues)
{
  EXPECT_EQ(
      String2Mac("00:00:00:00:00:00"),
      (MacAddress{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}));
 
  EXPECT_EQ(
      String2Mac("FF:FF:FF:FF:FF:FF"),
      (MacAddress{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}));
}
 
TEST_F(UtilMoreTests, String2MacRejectsWrongDelimiterPosition)
{
  EXPECT_THROW(String2Mac("aa:bb-cc:dd:ee:ff"), InvalidMACError);
}
 
TEST_F(UtilMoreTests, String2MacRejectsWhitespace)
{
  EXPECT_THROW(String2Mac("aa:bb:cc:dd:ee: f"), InvalidMACError);
}
TEST_F(UtilMoreTests, Mac2StringRejectsInvalidLength)
{
  const std::array<std::uint8_t, 5> shortMac{1, 2, 3, 4, 5};
 
  EXPECT_THROW(Mac2String(shortMac.data(), shortMac.size()), InvalidMACError);
}
TEST_F(UtilMoreTests, String2IpHandlesExactAndExtendedInput)
{
  EXPECT_EQ(String2Ip(std::array<std::uint8_t, 4>{192, 168, 1, 42}), "192.168.1.42");
 
  const std::array<std::uint8_t, 6> extended{192, 168, 1, 42, 0xAA, 0xBB};
  EXPECT_EQ(String2Ip(extended), "192.168.1.42");
}
TEST_F(UtilMoreTests, DecodeBytesPreservesNonPaddedData)
{
  const std::vector<std::uint8_t> data{'a', 'b', 'c'};
 
  EXPECT_EQ(DecodeBytes(data), "abc");
}
 
TEST_F(UtilMoreTests, DecodeBytesHandlesAllNuls)
{
  const std::vector<std::uint8_t> data(8U, 0);
 
  EXPECT_EQ(DecodeBytes(data), "");
}