test_asioEthernetSocket.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <asio.hpp>
#include <chrono>
#include <cstdint>
#include <cstdlib>
#include <memory>
#include <optional>
#include <thread>
#include <vector>
 
#include "profinet/asioEthernetSocket.h"
#include "profinet/exceptions.h"
#include "profinet/protocol.h"
#include "profinet/util.h"
 
using namespace profinet;
using namespace std::chrono_literals;
 
namespace
{
 
class TestIoContextRunner
{
 public:
  explicit TestIoContextRunner(asio::io_context& ioContext)
      : ioContext(ioContext),
        workGuard(asio::make_work_guard(ioContext)),
        thread([&]
  {
    ioContext.run();
  })
  {
  }
 
  ~TestIoContextRunner()
  {
    workGuard.reset();
    ioContext.stop();
 
    if (thread.joinable())
    {
      thread.join();
    }
  }
 
  TestIoContextRunner(const TestIoContextRunner&) = delete;
  TestIoContextRunner& operator=(const TestIoContextRunner&) = delete;
 
 private:
  asio::io_context& ioContext;
 
  asio::executor_work_guard<asio::io_context::executor_type> workGuard;
 
  std::thread thread;
};
 
std::string GetTestInterface()
{
  const char* value = std::getenv("PROFINET_TEST_INTERFACE");
 
  if (value == nullptr)
  {
    return {};
  }
 
  return value;
}
 
class AsioEthernetSocketTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    runner = std::make_unique<TestIoContextRunner>(ioContext);
  }
 
  void TearDown() override
  {
    runner.reset();
  }
 
  asio::io_context ioContext;
 
  std::unique_ptr<TestIoContextRunner> runner;
};
 
} // namespace
 
TEST_F(AsioEthernetSocketTests, ConstructorRejectsUnknownInterface)
{
  EXPECT_THROW(AsioEthernetSocket(ioContext, "this-interface-does-not-exist"), SocketError);
}
 
TEST_F(AsioEthernetSocketTests, ConstructorAcceptsEthernetInterface)
{
  const std::string interface = GetTestInterface();
 
  if (interface.empty())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet tests";
  }
 
  EXPECT_NO_THROW(AsioEthernetSocket(ioContext, interface));
}
 
TEST_F(AsioEthernetSocketTests, ConstructorAcceptsSpecificEtherType)
{
  const std::string interface = GetTestInterface();
 
  if (interface.empty())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet tests";
  }
 
  EXPECT_NO_THROW(AsioEthernetSocket(ioContext, interface, PROFINET_ETHERTYPE));
}
 
TEST_F(AsioEthernetSocketTests, SetTimeoutAcceptsFiniteDuration)
{
  const std::string interface = GetTestInterface();
 
  if (interface.empty())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet tests";
  }
 
  AsioEthernetSocket socket(ioContext, interface);
 
  EXPECT_NO_THROW(socket.SetTimeout(20ms));
}
 
TEST_F(AsioEthernetSocketTests, RecvReturnsEmptyFrameOnTimeout)
{
  const std::string interface = GetTestInterface();
 
  if (interface.empty())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet tests";
  }
 
  AsioEthernetSocket socket(ioContext, interface);
 
  socket.SetTimeout(20ms);
 
  const std::vector<std::uint8_t> received = socket.Recv();
 
  EXPECT_TRUE(received.empty());
}
 
TEST_F(AsioEthernetSocketTests, RecvUsesExternallyDrivenIoContext)
{
  const std::string interface = GetTestInterface();
 
  if (interface.empty())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet tests";
  }
 
  AsioEthernetSocket socket(ioContext, interface);
 
  socket.SetTimeout(20ms);
 
  // If the Asio execution context were not driven by the fixture's
  // external runner, this call would never complete. The test therefore
  // verifies the execution model used by the production transport.
 
  const std::vector<std::uint8_t> received = socket.Recv();
 
  EXPECT_TRUE(received.empty());
}
TEST_F(AsioEthernetSocketTests, InjectedEthernetFrameCanBeCapturedByPeer)
{
  const std::string interface = GetTestInterface();
 
  if (interface.empty())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet tests";
  }
 
  AsioEthernetSocket sender(ioContext, interface);
  AsioEthernetSocket receiver(ioContext, interface);
 
  const Bytes frame{
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0x02, 0x00, 0x00, 0x00, 0x00, 0x01,
      0x88, 0x92,
      0x01, 0x02, 0x03, 0x04};
 
  receiver.SetTimeout(1000ms);
 
  sender.Send(frame);
 
  const Bytes received = receiver.Recv();
 
  ASSERT_FALSE(received.empty());
  EXPECT_EQ(received, frame);
}
 
TEST_F(AsioEthernetSocketTests, EtherTypeFilterAcceptsVlanTaggedFrame)
{
  const std::string interface = GetTestInterface();
 
  if (interface.empty())
  {
    GTEST_SKIP()
        << "Set PROFINET_TEST_INTERFACE to run live Ethernet tests";
  }
 
  AsioEthernetSocket sender(ioContext, interface);
 
  AsioEthernetSocket receiver(
      ioContext,
      interface,
      PROFINET_ETHERTYPE);
 
  const Bytes frame{
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0x02, 0x00, 0x00, 0x00, 0x00, 0x02,
 
      0x81, 0x00,
      0xC0, 0x00,
 
      0x88, 0x92,
      0x01, 0x02, 0x03, 0x04};
 
  receiver.SetTimeout(1000ms);
 
  sender.Send(frame);
 
  const Bytes received = receiver.Recv();
 
  ASSERT_FALSE(received.empty());
  EXPECT_EQ(received, frame);
}
 
TEST_F(AsioEthernetSocketTests, UnicastFrameCanBeReceivedByPeer)
{
  const std::string interface = GetTestInterface();
 
  if (interface.empty())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet tests";
  }
 
  AsioEthernetSocket sender(ioContext, interface);
  AsioEthernetSocket receiver(ioContext, interface);
 
  const Bytes frame{
      0xA0, 0xD3, 0x85, 0x00, 0xF6, 0x13,
      0x08, 0x00, 0x27, 0x31, 0x39, 0xDC,
      0x88, 0x92,
      0x01, 0x02, 0x03, 0x04};
 
  receiver.SetTimeout(1000ms);
 
  sender.Send(frame);
 
  const Bytes received = receiver.Recv();
 
  ASSERT_FALSE(received.empty());
  EXPECT_EQ(received, frame);
}
 
TEST_F(AsioEthernetSocketTests, ConcurrentUnicastFrameCanBeReceivedByPeer)
{
  const std::string interface = GetTestInterface();
 
  if (interface.empty())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet tests";
  }
 
  AsioEthernetSocket sender(ioContext, interface);
  AsioEthernetSocket receiver(ioContext, interface);
 
  const Bytes frame{
      0xA0, 0xD3, 0x85, 0x00, 0xF6, 0x13,
      0x08, 0x00, 0x27, 0x31, 0x39, 0xDC,
      0x88, 0x92,
      0x01, 0x02, 0x03, 0x04};
 
  Bytes received;
  std::jthread receiverThread([&]
  {
    receiver.SetTimeout(1000ms);
    received = receiver.Recv();
  });
 
  sender.Send(frame);
 
  receiverThread.join();
 
  ASSERT_FALSE(received.empty());
  EXPECT_EQ(received, frame);
}
 
TEST_F(AsioEthernetSocketTests, PeerCanReceiveAndRespondToController)
{
  const std::string interface = GetTestInterface();
 
  if (interface.empty())
  {
    GTEST_SKIP() << "Set PROFINET_TEST_INTERFACE to run live Ethernet tests";
  }
  constexpr std::uint16_t testEtherType = 0x88B5;
  AsioEthernetSocket controller(ioContext, interface, testEtherType);
  AsioEthernetSocket peer(ioContext, interface, testEtherType);
 
  const Bytes request{
      0xA0, 0xD3, 0x85, 0x00, 0xF6, 0x13,
      0x08, 0x00, 0x27, 0x31, 0x39, 0xDC,
      0x88, 0xB5,
      0x01, 0x02, 0x03, 0x04};
 
  const Bytes response{
      0x08, 0x00, 0x27, 0x31, 0x39, 0xDC,
      0xA0, 0xD3, 0x85, 0x00, 0xF6, 0x13,
      0x88, 0xB5,
      0x05, 0x06, 0x07, 0x08};
 
  Bytes receivedRequest;
  std::exception_ptr peerException;
 
  std::jthread peerThread([&]
  {
    try
    {
      peer.SetTimeout(1000ms);
 
      receivedRequest = peer.Recv();
 
      if (receivedRequest.empty())
      {
        throw std::runtime_error("Peer did not receive request");
      }
 
      if (receivedRequest != request)
      {
        throw std::runtime_error("Peer received unexpected request");
      }
 
      peer.Send(response);
    }
    catch (...)
    {
      peerException = std::current_exception();
    }
  });
 
  controller.SetTimeout(2000ms);
  controller.Send(request);
 
  // the controller send request, is received by a peer socket
  // the peer socket send reponse, is received by controller socket
 
  peerThread.join();
 
  if (peerException)
  {
    std::rethrow_exception(peerException);
  }
 
  ASSERT_EQ(receivedRequest, request);
 
  const Bytes receivedResponse = controller.Recv();
 
  ASSERT_FALSE(receivedResponse.empty());
  EXPECT_EQ(receivedResponse, response);
}