test_ethernetPacketBackend.cpp

Go to the documentation of this file.

 
 
#include <chrono>
#include <cstdint>
#include <stdexcept>
#include <vector>
 
#include "ethernetPacketBackendTestFixture.h"
#include "profinet/exceptions.h"
#include "profinet/protocol.h"
#include "profinet/util.h"
 
using namespace profinet;
using namespace std::chrono_literals;
 
namespace
{
constexpr std::uint16_t kTestEtherType = 0x88B5;
 
const Bytes kUntaggedFrame{
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0x02, 0x00, 0x00, 0x00, 0x00, 0x01,
    0x88, 0xB5,
    0x01, 0x02, 0x03, 0x04};
 
const Bytes kSingleVlanFrame{
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0x02, 0x00, 0x00, 0x00, 0x00, 0x02,
    0x81, 0x00,
    0x00, 0x64,
    0x88, 0xB5,
    0x05, 0x06, 0x07, 0x08};
 
const Bytes kQinQFrame{
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0x02, 0x00, 0x00, 0x00, 0x00, 0x03,
    0x88, 0xA8,
    0x00, 0x64,
    0x81, 0x00,
    0x00, 0x65,
    0x88, 0xB5,
    0x09, 0x0A, 0x0B, 0x0C};
} // namespace
 
TEST_F(EthernetPacketBackendTestFixture, ConstructorRejectsEmptyInterface)
{
  EXPECT_THROW(CreateBackend(""), SocketError);
}
 
TEST_F(EthernetPacketBackendTestFixture, ConstructorRejectsUnknownInterface)
{
  EXPECT_THROW(CreateBackend("this-interface-does-not-exist"), SocketError);
}
 
TEST_F(EthernetPacketBackendTestFixture, ConstructorAcceptsConfiguredInterface)
{
  const auto interfaceValue = GetTestInterface();
  if (!interfaceValue.has_value())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet backend tests";
  }
  const std::string& interface = *interfaceValue;
 
  EXPECT_NO_THROW(CreateBackend(interface, kTestEtherType));
}
 
TEST_F(EthernetPacketBackendTestFixture, SendAcceptsMinimumEthernetFrame)
{
  const auto interfaceValue = GetTestInterface();
  if (!interfaceValue.has_value())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet backend tests";
  }
  const std::string& interface = *interfaceValue;
  const Bytes frame(kUntaggedFrame.begin(), kUntaggedFrame.begin() + 14);
 
  auto backend = CreateBackend(interface, kTestEtherType);
 
  EXPECT_NO_THROW(backend->Send(frame));
}
 
TEST_F(EthernetPacketBackendTestFixture, SendRejectsShortEthernetFrame)
{
  const auto interfaceValue = GetTestInterface();
  if (!interfaceValue.has_value())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet backend tests";
  }
  const std::string& interface = *interfaceValue;
  auto backend = CreateBackend(interface, kTestEtherType);
 
  EXPECT_THROW(backend->Send(Bytes(13U, 0x00)), std::invalid_argument);
}
 
TEST_F(EthernetPacketBackendTestFixture, EtherTypeFilterAcceptsMatchingUntaggedFrame)
{
  const auto interfaceValue = GetTestInterface();
  if (!interfaceValue.has_value())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet backend tests";
  }
  const std::string& interface = *interfaceValue;
  auto backend = CreateBackend(interface, kTestEtherType);
 
  EXPECT_TRUE(MatchesEtherType(*backend, kUntaggedFrame));
}
 
TEST_F(EthernetPacketBackendTestFixture, EtherTypeFilterRejectsNonMatchingUntaggedFrame)
{
  const auto interfaceValue = GetTestInterface();
  if (!interfaceValue.has_value())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet backend tests";
  }
  const std::string& interface = *interfaceValue;
  auto backend = CreateBackend(interface, kTestEtherType);
 
  Bytes frame = kUntaggedFrame;
  frame[12] = 0x88;
  frame[13] = 0x92;
 
  EXPECT_FALSE(MatchesEtherType(*backend, frame));
}
 
TEST_F(EthernetPacketBackendTestFixture, EtherTypeFilterAcceptsSingleVlanTaggedFrame)
{
  const auto interfaceValue = GetTestInterface();
  if (!interfaceValue.has_value())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet backend tests";
  }
  const std::string& interface = *interfaceValue;
  auto backend = CreateBackend(interface, kTestEtherType);
 
  EXPECT_TRUE(MatchesEtherType(*backend, kSingleVlanFrame));
}
 
TEST_F(EthernetPacketBackendTestFixture, EtherTypeFilterAcceptsQinQFrame)
{
  const auto interfaceValue = GetTestInterface();
  if (!interfaceValue.has_value())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet backend tests";
  }
  const std::string& interface = *interfaceValue;
  auto backend = CreateBackend(interface, kTestEtherType);
 
  EXPECT_TRUE(MatchesEtherType(*backend, kQinQFrame));
}
 
TEST_F(EthernetPacketBackendTestFixture, EtherTypeFilterAcceptsLegacyDoubleTaggedFrame)
{
  const auto interfaceValue = GetTestInterface();
  if (!interfaceValue.has_value())
  {
    GTEST_SKIP()
        << "Set PROFINET_TEST_INTERFACE to run live Ethernet backend tests";
  }
  const std::string& interface = *interfaceValue;
  auto backend = CreateBackend(interface, kTestEtherType);
 
  Bytes frame{
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0x02, 0x00, 0x00, 0x00, 0x00, 0x04,
      0x91, 0x00,
      0x00, 0x64,
      0x88, 0xB5,
      0x01, 0x02};
 
  EXPECT_TRUE(MatchesEtherType(*backend, frame));
}
 
TEST_F(EthernetPacketBackendTestFixture, EtherTypeFilterRejectsFrameShorterThanHeader)
{
  const auto interfaceValue = GetTestInterface();
  if (!interfaceValue.has_value())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet backend tests";
  }
  const std::string& interface = *interfaceValue;
  auto backend = CreateBackend(interface, kTestEtherType);
 
  EXPECT_FALSE(MatchesEtherType(*backend, Bytes(13U, 0x00)));
}
 
TEST_F(EthernetPacketBackendTestFixture, EtherTypeFilterRejectsTruncatedVlanFrame)
{
  const auto interfaceValue = GetTestInterface();
  if (!interfaceValue.has_value())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet backend tests";
  }
  const std::string& interface = *interfaceValue;
  auto backend = CreateBackend(interface, kTestEtherType);
 
  const Bytes frame{
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0x02, 0x00, 0x00, 0x00, 0x00, 0x05,
      0x81, 0x00};
 
  EXPECT_FALSE(MatchesEtherType(*backend, frame));
}
 
TEST_F(EthernetPacketBackendTestFixture, ZeroEtherTypeAcceptsCompleteFrame)
{
  const auto interfaceValue = GetTestInterface();
  if (!interfaceValue.has_value())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet backend tests";
  }
  const std::string& interface = *interfaceValue;
  auto backend = CreateBackend(interface, 0U);
 
  EXPECT_TRUE(MatchesEtherType(*backend, kUntaggedFrame));
}
 
TEST_F(EthernetPacketBackendTestFixture, RecvReturnsEmptyFrameOnTimeout)
{
  const auto interfaceValue = GetTestInterface();
  if (!interfaceValue.has_value())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet backend tests";
  }
  const std::string& interface = *interfaceValue;
  auto backend = CreateBackend(interface, kTestEtherType);
 
  backend->SetTimeout(25ms);
 
  const Bytes received = backend->Recv();
 
  EXPECT_TRUE(received.empty());
}
 
TEST_F(EthernetPacketBackendTestFixture, RecvSkipsNonMatchingTraffic)
{
  const auto interfaceValue = GetTestInterface();
  if (!interfaceValue.has_value())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet backend tests";
  }
  const std::string& interface = *interfaceValue;
  auto sender = CreateBackend(interface, 0U);
  auto receiver = CreateBackend(interface, kTestEtherType);
 
  Bytes nonMatching = kUntaggedFrame;
  nonMatching[12] = 0x88;
  nonMatching[13] = 0x92;
 
  receiver->SetTimeout(1000ms);
 
  sender->Send(nonMatching);
  sender->Send(kUntaggedFrame);
 
  const Bytes received = receiver->Recv();
 
  ASSERT_FALSE(received.empty());
  EXPECT_EQ(received, kUntaggedFrame);
}