test_in_memory_ethernetMore.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <chrono>
#include <cstdint>
#include <memory>
#include <thread>
#include <vector>
 
#include "profinet/protocol.h"
#include "profinet/sim/in_memory_ethernet.h"
 
namespace profinet::sim
{
 
namespace
{
 
constexpr MacAddress kMacA{0x02, 0x00, 0x00, 0x00, 0x00, 0x0A};
constexpr MacAddress kMacB{0x02, 0x00, 0x00, 0x00, 0x00, 0x0B};
constexpr MacAddress kMacC{0x02, 0x00, 0x00, 0x00, 0x00, 0x0C};
 
Bytes MakeFrame(const MacAddress& destination,
                const MacAddress& source,
                const std::uint8_t marker)
{
  Bytes frame;
  frame.insert(frame.end(), destination.begin(), destination.end());
  frame.insert(frame.end(), source.begin(), source.end());
  frame.push_back(0x88U);
  frame.push_back(0x92U);
  frame.push_back(marker);
  return frame;
}
 
} // namespace
 
TEST(InMemoryEthernetRoutingTests, UnicastReachesOnlyMatchingEndpoint)
{
  InMemoryEthernetBus bus;
  auto socketA = bus.CreateSocket(kMacA);
  auto socketB = bus.CreateSocket(kMacB);
  auto socketC = bus.CreateSocket(kMacC);
  socketA->SetTimeout(std::chrono::milliseconds(10));
  socketB->SetTimeout(std::chrono::milliseconds(10));
  socketC->SetTimeout(std::chrono::milliseconds(10));
 
  const Bytes frame = MakeFrame(kMacB, kMacA, 0x42U);
  socketA->Send(frame);
 
  EXPECT_EQ(socketB->Recv(), frame);
  EXPECT_TRUE(socketC->Recv().empty());
  EXPECT_TRUE(socketA->Recv().empty());
}
 
TEST(InMemoryEthernetRoutingTests, BroadcastIsFloodedWithoutLoopback)
{
  InMemoryEthernetBus bus;
  auto socketA = bus.CreateSocket(kMacA);
  auto socketB = bus.CreateSocket(kMacB);
  auto socketC = bus.CreateSocket(kMacC);
  for (auto* socket : {socketA.get(), socketB.get(), socketC.get()})
  {
    socket->SetTimeout(std::chrono::milliseconds(10));
  }
 
  const MacAddress broadcast{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
  const Bytes frame = MakeFrame(broadcast, kMacA, 0x43U);
  socketA->Send(frame);
 
  EXPECT_EQ(socketB->Recv(), frame);
  EXPECT_EQ(socketC->Recv(), frame);
  EXPECT_TRUE(socketA->Recv().empty());
}
 
TEST(InMemoryEthernetRoutingTests, MulticastIsFlooded)
{
  InMemoryEthernetBus bus;
  auto socketA = bus.CreateSocket(kMacA);
  auto socketB = bus.CreateSocket(kMacB);
  auto socketC = bus.CreateSocket(kMacC);
  for (auto* socket : {socketA.get(), socketB.get(), socketC.get()})
  {
    socket->SetTimeout(std::chrono::milliseconds(10));
  }
 
  const MacAddress multicast{0x01, 0x0E, 0xCF, 0x00, 0x00, 0x00};
  const Bytes frame = MakeFrame(multicast, kMacA, 0x44U);
  socketA->Send(frame);
 
  EXPECT_EQ(socketB->Recv(), frame);
  EXPECT_EQ(socketC->Recv(), frame);
}
 
TEST(InMemoryEthernetRoutingTests, SameMacSocketsDoNotLoopBackTraffic)
{
  InMemoryEthernetBus bus;
  auto tx = bus.CreateSocket(kMacA);
  auto rx = bus.CreateSocket(kMacA);
  auto peer = bus.CreateSocket(kMacB);
  tx->SetTimeout(std::chrono::milliseconds(10));
  rx->SetTimeout(std::chrono::milliseconds(10));
  peer->SetTimeout(std::chrono::milliseconds(10));
 
  const Bytes frame = MakeFrame(kMacB, kMacA, 0x45U);
  tx->Send(frame);
 
  EXPECT_EQ(peer->Recv(), frame);
  EXPECT_TRUE(rx->Recv().empty());
}
 
TEST(InMemoryEthernetSocketTests, ReceiveTimeoutReturnsEmptyFrame)
{
  InMemoryEthernetBus bus;
  auto socket = bus.CreateSocket(kMacA);
  socket->SetTimeout(std::chrono::milliseconds(2));
 
  const auto start = std::chrono::steady_clock::now();
  EXPECT_TRUE(socket->Recv().empty());
  const auto elapsed = std::chrono::steady_clock::now() - start;
 
  EXPECT_GE(elapsed, std::chrono::milliseconds(1));
}
 
TEST(InMemoryEthernetSocketTests, NegativeTimeoutThrows)
{
  InMemoryEthernetBus bus;
  auto socket = bus.CreateSocket(kMacA);
 
  EXPECT_THROW(socket->SetTimeout(std::chrono::milliseconds(-1)), std::invalid_argument);
}
 
TEST(InMemoryEthernetRoutingTests, ShortFrameThrows)
{
  InMemoryEthernetBus bus;
  auto socket = bus.CreateSocket(kMacA);
 
  EXPECT_THROW(socket->Send(Bytes{0x00, 0x01, 0x02}), std::invalid_argument);
}
 
TEST(InMemoryEthernetBusTests, ClearQueuesRemovesPendingFrames)
{
  InMemoryEthernetBus bus;
  auto socketA = bus.CreateSocket(kMacA);
  auto socketB = bus.CreateSocket(kMacB);
  socketB->SetTimeout(std::chrono::milliseconds(10));
 
  socketA->Send(MakeFrame(kMacB, kMacA, 0x46U));
  EXPECT_EQ(bus.EndpointCount(), 2U);
 
  bus.ClearQueues();
  EXPECT_TRUE(socketB->Recv().empty());
  EXPECT_EQ(bus.EndpointCount(), 2U);
}
 
TEST(InMemoryEthernetBusTests, EndpointDestructionDetachesSocket)
{
  InMemoryEthernetBus bus;
  auto socketA = bus.CreateSocket(kMacA);
  EXPECT_EQ(bus.EndpointCount(), 1U);
 
  {
    auto socketB = bus.CreateSocket(kMacB);
    EXPECT_EQ(bus.EndpointCount(), 2U);
  }
 
  EXPECT_EQ(bus.EndpointCount(), 1U);
  socketA.reset();
  EXPECT_EQ(bus.EndpointCount(), 0U);
}
 
} // namespace profinet::sim