sid/NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move ComputeTest,GraphicsTest,RenderTest and Std140Debug to the tests folder

Browse Source 
Also renamed NazaraUnitTests to UnitTests
This commit is contained in:
SirLynix
2022-12-26 08:44:11 +01:00
parent fe8715f1fb
commit 4b804dc613
71 changed files with 33 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
tests/UnitTests/Engine/Network/IpAddressTest.cpp Normal file
View File

@@ -0,0 +1,156 @@
#include <Nazara/Network/Algorithm.hpp>
#include <Nazara/Network/IpAddress.hpp>
#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
SCENARIO("IpAddress", "[NETWORK][IPADDRESS]")
{
WHEN("Parsing IP")
{
// IPv4
CHECK(Nz::IpAddress("0.0.0.0") == Nz::IpAddress::AnyIpV4);
CHECK(Nz::IpAddress("0.0.0.0:0") == Nz::IpAddress::AnyIpV4);
CHECK(Nz::IpAddress("0.0.0.0:12345") == Nz::IpAddress(0, 0, 0, 0, 12345));
Nz::IpAddress loopbackIpV4("127.0.0.1");
CHECK(loopbackIpV4 == Nz::IpAddress::LoopbackIpV4);
CHECK(static_cast<bool>(loopbackIpV4));
CHECK(loopbackIpV4.IsValid());
CHECK(loopbackIpV4.IsLoopback());
CHECK(loopbackIpV4.GetPort() == 0);
CHECK(loopbackIpV4.GetProtocol() == Nz::NetProtocol::IPv4);
CHECK(loopbackIpV4.ToString() == "127.0.0.1");
CHECK(loopbackIpV4.ToUInt32() == 0x7F000001);
Nz::IpAddress loopbackIpV4WithPort("127.0.0.1:80");
CHECK(loopbackIpV4WithPort != Nz::IpAddress::LoopbackIpV4);
CHECK(static_cast<bool>(loopbackIpV4WithPort));
CHECK(loopbackIpV4WithPort.IsValid());
CHECK(loopbackIpV4WithPort.IsLoopback());
CHECK(loopbackIpV4WithPort.GetPort() == 80);
CHECK(loopbackIpV4WithPort.GetProtocol() == Nz::NetProtocol::IPv4);
CHECK(loopbackIpV4WithPort.ToString() == "127.0.0.1:80");
CHECK(loopbackIpV4WithPort.ToUInt32() == 0x7F000001);
Nz::IpAddress nonregularLoopbackIpV4("127.147.254.15:41235");
CHECK(nonregularLoopbackIpV4 != Nz::IpAddress::LoopbackIpV4);
CHECK(static_cast<bool>(nonregularLoopbackIpV4));
CHECK(nonregularLoopbackIpV4.IsValid());
CHECK(nonregularLoopbackIpV4.IsLoopback());
CHECK(nonregularLoopbackIpV4.GetPort() == 41235);
CHECK(nonregularLoopbackIpV4.GetProtocol() == Nz::NetProtocol::IPv4);
CHECK(nonregularLoopbackIpV4.ToString() == "127.147.254.15:41235");
CHECK(nonregularLoopbackIpV4.ToUInt32() == 0x7F93FE0F);
nonregularLoopbackIpV4.SetPort(14738);
CHECK(nonregularLoopbackIpV4.GetPort() == 14738);
CHECK(nonregularLoopbackIpV4.ToString() == "127.147.254.15:14738");
// IPv6
CHECK(Nz::IpAddress("::") == Nz::IpAddress::AnyIpV6);
CHECK(Nz::IpAddress("[::]:0") == Nz::IpAddress::AnyIpV6);
CHECK(Nz::IpAddress("[::]:80") == Nz::IpAddress(0, 0, 0, 0, 0, 0, 0, 0, 80));
CHECK(Nz::IpAddress("1:2:3:4:5:6:7:8") == Nz::IpAddress(1, 2, 3, 4, 5, 6, 7, 8));
CHECK(Nz::IpAddress("1:2:3:4:5::7:8") == Nz::IpAddress(1, 2, 3, 4, 5, 0, 7, 8));
CHECK(Nz::IpAddress("1:2:3:4::7:8") == Nz::IpAddress(1, 2, 3, 4, 0, 0, 7, 8));
CHECK(Nz::IpAddress("1:2:3::7:8") == Nz::IpAddress(1, 2, 3, 0, 0, 0, 7, 8));
CHECK(Nz::IpAddress("1:2::5:6:7:8") == Nz::IpAddress(1, 2, 0, 0, 5, 6, 7, 8));
CHECK(Nz::IpAddress("1::7:8") == Nz::IpAddress(1, 0, 0, 0, 0, 0, 7, 8));
CHECK(Nz::IpAddress("1::8") == Nz::IpAddress(1, 0, 0, 0, 0, 0, 0, 8));
CHECK(Nz::IpAddress("::8") == Nz::IpAddress(0, 0, 0, 0, 0, 0, 0, 8));
CHECK(Nz::IpAddress("1::") == Nz::IpAddress(1, 0, 0, 0, 0, 0, 0, 0));
CHECK(Nz::IpAddress("1:2::8") == Nz::IpAddress(1, 2, 0, 0, 0, 0, 0, 8));
CHECK(Nz::IpAddress("2001:41d0:2:d4cd::") == Nz::IpAddress(0x2001, 0x41D0, 0x2, 0xD4CD, 0, 0, 0, 0));
CHECK(Nz::IpAddress("[2001:41D0:2:D4CD::]:80") == Nz::IpAddress(0x2001, 0x41D0, 0x2, 0xD4CD, 0, 0, 0, 0, 80));
CHECK(Nz::IpAddress(0x2001, 0x41D0, 0x2, 0, 0, 0, 0, 0xD4CD).ToString() == "2001:41d0:2::d4cd");
CHECK(Nz::IpAddress(0x2001, 0x41D0, 0x2, 0, 0, 0, 0, 0xD4CD, 443).ToString() == "[2001:41d0:2::d4cd]:443");
CHECK(Nz::IpAddress(0x2001, 0x41D0, 0x2, 0xDEAD, 0xBEEF, 0x42, 0x2022, 0xD4CD, 443).ToString() == "[2001:41d0:2:dead:beef:42:2022:d4cd]:443");
// All of theses are differents representations of the same IPv6 address
std::array<std::string, 8> testAddresses {
"2001:db8:0:0:1:0:0:1",
"2001:0db8:0:0:1:0:0:1",
"2001:db8::1:0:0:1",
"2001:db8::0:1:0:0:1",
"2001:0db8::1:0:0:1",
"2001:db8:0:0:1::1",
"2001:db8:0000:0:1::1",
"2001:DB8:0:0:1::1"
};
Nz::IpAddress referenceAddress(0x2001, 0xDB8, 0, 0, 1, 0, 0, 1);
for (const std::string& str : testAddresses)
{
INFO(str);
CHECK(Nz::IpAddress(str) == referenceAddress);
}
Nz::IpAddress loopbackIpV6("::1");
CHECK(loopbackIpV6 == Nz::IpAddress::LoopbackIpV6);
CHECK(loopbackIpV6.IsValid());
CHECK(loopbackIpV6.IsLoopback());
CHECK(loopbackIpV6.GetPort() == 0);
CHECK(loopbackIpV6.GetProtocol() == Nz::NetProtocol::IPv6);
CHECK(loopbackIpV6.ToString() == "::1");
Nz::IpAddress loopbackIpV6WithPort("[::1]:443");
CHECK(loopbackIpV6WithPort != Nz::IpAddress::LoopbackIpV6);
CHECK(loopbackIpV6WithPort.IsValid());
CHECK(loopbackIpV6WithPort.IsLoopback());
CHECK(loopbackIpV6WithPort.GetPort() == 443);
CHECK(loopbackIpV6WithPort.GetProtocol() == Nz::NetProtocol::IPv6);
CHECK(loopbackIpV6WithPort.ToString() == "[::1]:443");
// IPv4-mapped IPv6
Nz::IpAddress ipv4MappedIPv6("::ffff:192.168.173.22");
CHECK(ipv4MappedIPv6.IsValid());
CHECK_FALSE(ipv4MappedIPv6.IsLoopback());
CHECK(ipv4MappedIPv6.GetProtocol() == Nz::NetProtocol::IPv6);
CHECK(ipv4MappedIPv6.ToString() == "::ffff:192.168.173.22");
CHECK(ipv4MappedIPv6 == Nz::IpAddress(0, 0, 0, 0, 0, 0xFFFF, 0xC0A8, 0xAD16));
Nz::IpAddress ipv4MappedIPv6WithPort("::ffff:192.168.173.22");
CHECK(ipv4MappedIPv6WithPort.IsValid());
CHECK_FALSE(ipv4MappedIPv6WithPort.IsLoopback());
CHECK(ipv4MappedIPv6WithPort.GetProtocol() == Nz::NetProtocol::IPv6);
CHECK(ipv4MappedIPv6WithPort.ToString() == "::ffff:192.168.173.22");
CHECK(ipv4MappedIPv6WithPort == Nz::IpAddress(0, 0, 0, 0, 0, 0xFFFF, 0xC0A8, 0xAD16));
// Invalid addresses
CHECK_FALSE(Nz::IpAddress("000.123.456.789").IsValid());
CHECK_FALSE(Nz::IpAddress("0.0.0.0SomeGarbage").IsValid());
CHECK_FALSE(Nz::IpAddress("0.0.0.0:Hell0").IsValid());
CHECK_FALSE(Nz::IpAddress("Hey0.0.0.0:12345").IsValid());
CHECK_FALSE(Nz::IpAddress("::1:ffff:192.168.173.22").IsValid());
CHECK_FALSE(Nz::IpAddress("::ffff:123.412.210.230").IsValid());
CHECK_FALSE(Nz::IpAddress("::ffff:127.0.0.0.1").IsValid());
CHECK_FALSE(Nz::IpAddress("::ffff:0:255.255.255.255").IsValid());
}
GIVEN("No IpAddress")
{
WHEN("We get the IP of Nazara")
{
std::vector<Nz::HostnameInfo> hostnameInfos = Nz::IpAddress::ResolveHostname(Nz::NetProtocol::Any, "nazara.digitalpulsesoftware.net");
THEN("Result is not null")
{
CHECK_FALSE(hostnameInfos.empty());
}
}
WHEN("We convert IP to hostname")
{
Nz::IpAddress google(8, 8, 8, 8);
THEN("Google (DNS) is 8.8.8.8")
{
std::string dnsAddress = Nz::IpAddress::ResolveAddress(google);
bool dnsCheck = dnsAddress == "google-public-dns-a.google.com" || dnsAddress == "dns.google";
CHECK(dnsCheck);
}
}
}
}

85
tests/UnitTests/Engine/Network/SocketPollerTest.cpp Normal file
View File

@@ -0,0 +1,85 @@
#include <Nazara/Math/Vector3.hpp>
#include <Nazara/Network/NetPacket.hpp>
#include <Nazara/Network/SocketPoller.hpp>
#include <Nazara/Network/TcpClient.hpp>
#include <Nazara/Network/TcpServer.hpp>
#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
#include <random>
SCENARIO("SocketPoller", "[NETWORK][SOCKETPOLLER]")
{
GIVEN("A TcpServer and a TcpClient in a selector")
{
std::random_device rd;
std::uniform_int_distribution<Nz::UInt16> dis(1025, 65535);
Nz::UInt16 port = dis(rd);
Nz::TcpServer server;
server.EnableBlocking(false);
REQUIRE(server.Listen(Nz::NetProtocol::IPv4, port) == Nz::SocketState::Bound);
Nz::IpAddress serverIP(Nz::IpAddress::LoopbackIpV4.ToIPv4(), port);
REQUIRE(serverIP.IsValid());
Nz::SocketPoller serverPoller;
Nz::TcpClient clientToServer;
WHEN("We register the server socket to the poller")
{
REQUIRE(serverPoller.RegisterSocket(server, Nz::SocketPollEvent::Read));
THEN("The poller should have registered our socket")
{
REQUIRE(serverPoller.IsRegistered(server));
}
AND_THEN("We connect using a TcpClient")
{
Nz::SocketState state = clientToServer.Connect(serverIP);
CHECK(state != Nz::SocketState::NotConnected);
AND_THEN("We wait on our selector, it should return true")
{
REQUIRE(serverPoller.Wait(1000));
Nz::TcpClient serverToClient;
REQUIRE(server.AcceptClient(&serverToClient));
WHEN("We register the client socket to the poller")
{
REQUIRE(serverPoller.RegisterSocket(serverToClient, Nz::SocketPollEvent::Read));
THEN("The poller should have registered our socket")
{
REQUIRE(serverPoller.IsRegistered(serverToClient));
}
AND_WHEN("We test sending data from the client to the server and checking the poller")
{
std::array<char, 5> buffer = {"Data"};
std::size_t sent;
REQUIRE(clientToServer.Send(buffer.data(), buffer.size(), &sent));
REQUIRE(sent == buffer.size());
REQUIRE(serverPoller.Wait(1000));
CHECK(serverPoller.IsReadyToRead(serverToClient));
CHECK(serverToClient.Read(buffer.data(), buffer.size()) == sent);
AND_THEN("Our selector should report no socket ready")
{
REQUIRE_FALSE(serverPoller.Wait(100));
REQUIRE_FALSE(serverPoller.IsReadyToRead(serverToClient));
}
}
}
}
}
}
}
}

65
tests/UnitTests/Engine/Network/TCPTest.cpp Normal file
View File

@@ -0,0 +1,65 @@
#include <Nazara/Math/Vector3.hpp>
#include <Nazara/Network/NetPacket.hpp>
#include <Nazara/Network/TcpClient.hpp>
#include <Nazara/Network/TcpServer.hpp>
#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
#include <chrono>
#include <thread>
SCENARIO("TCP", "[NETWORK][TCP]")
{
GIVEN("Two TCP, one client, one server")
{
Nz::TcpServer server;
server.EnableBlocking(false);
REQUIRE(server.Listen(Nz::NetProtocol::IPv4, 0) == Nz::SocketState::Bound);
Nz::IpAddress serverIP(Nz::IpAddress::LoopbackIpV4.ToIPv4(), server.GetBoundPort());
REQUIRE(serverIP.IsValid());
Nz::TcpClient client;
CHECK(client.WaitForConnected(100) == Nz::SocketState::NotConnected);
REQUIRE(client.Connect(serverIP) == Nz::SocketState::Connecting);
Nz::IpAddress clientIP = client.GetRemoteAddress();
CHECK(clientIP.IsValid());
REQUIRE(client.WaitForConnected(100) == Nz::SocketState::Connected);
CHECK(client.IsBlockingEnabled());
CHECK_FALSE(client.IsKeepAliveEnabled());
CHECK_FALSE(client.IsLowDelayEnabled());
CHECK(client.QueryReceiveBufferSize() > 0);
CHECK(client.QuerySendBufferSize() > 0);
Nz::TcpClient serverToClient;
REQUIRE(server.AcceptClient(&serverToClient));
WHEN("We send data from client")
{
CHECK(serverToClient.EndOfStream());
Nz::NetPacket packet(1);
Nz::Vector3f vector123(1.f, 2.f, 3.f);
packet << vector123;
REQUIRE(client.SendPacket(packet));
std::this_thread::yield();
THEN("We should get it on the server")
{
CHECK(!serverToClient.EndOfStream());
Nz::NetPacket resultPacket;
REQUIRE(serverToClient.ReceivePacket(&resultPacket));
Nz::Vector3f result;
resultPacket >> result;
CHECK(result == vector123);
}
}
}
}

42
tests/UnitTests/Engine/Network/UdpSocketTest.cpp Normal file
View File

@@ -0,0 +1,42 @@
#include <Nazara/Math/Vector3.hpp>
#include <Nazara/Network/UdpSocket.hpp>
#include <Nazara/Network/NetPacket.hpp>
#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
SCENARIO("UdpSocket", "[NETWORK][UDPSOCKET]")
{
GIVEN("Two UdpSocket, one client, one server")
{
Nz::UdpSocket server(Nz::NetProtocol::IPv4);
REQUIRE(server.Bind(0) == Nz::SocketState::Bound);
Nz::UInt16 port = server.GetBoundPort();
Nz::IpAddress serverIP(Nz::IpAddress::LoopbackIpV4.ToIPv4(), port);
REQUIRE(serverIP.IsValid());
Nz::UdpSocket client(Nz::NetProtocol::IPv4);
CHECK_FALSE(client.IsBroadcastingEnabled());
CHECK(client.QueryMaxDatagramSize() > 1500);
WHEN("We send data from client")
{
Nz::NetPacket packet(1);
Nz::Vector3f vector123(1.f, 2.f, 3.f);
packet << vector123;
REQUIRE(client.SendPacket(serverIP, packet));
THEN("We should get it on the server")
{
Nz::NetPacket resultPacket;
Nz::IpAddress fromIp;
REQUIRE(server.ReceivePacket(&resultPacket, &fromIp));
Nz::Vector3f result;
resultPacket >> result;
REQUIRE(result == vector123);
}
}
}
}