21179551844

Committed 19 Jan 2026 09:37PM UTC coverage: 74.437% (-0.004%) from 74.441%

Build # 21179551844

Build Type

push

github

Committed by

Razakhel

Commit Message

[Tests/Script/LuaNetwork] Added UDP client & server unit tests

Run Details

1 of 2 new or added lines in 1 file covered. (50.0%)

8564 of 11505 relevant lines covered (74.44%)

1718.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.29

/src/RaZ/Script/LuaNetwork.cpp

#include "RaZ/Network/TcpClient.hpp"
#include "RaZ/Network/TcpServer.hpp"
#include "RaZ/Network/UdpClient.hpp"
#include "RaZ/Network/UdpServer.hpp"
#include "RaZ/Script/LuaWrapper.hpp"
#include "RaZ/Utils/TypeUtils.hpp"

#define SOL_ALL_SAFETIES_ON 1
#include "sol/sol.hpp"

namespace Raz {

using namespace TypeUtils;

void LuaWrapper::registerNetworkTypes() {
  sol::state& state = getState();

  {
    sol::usertype<TcpClient> tcpClient = state.new_usertype<TcpClient>("TcpClient",
                                                                       sol::constructors<TcpClient(),
                                                                                         TcpClient(const std::string&, unsigned short)>());
    tcpClient["isConnected"]               = &TcpClient::isConnected;
    tcpClient["connect"]                   = &TcpClient::connect;
    tcpClient["send"]                      = &TcpClient::send;
    tcpClient["recoverAvailableByteCount"] = &TcpClient::recoverAvailableByteCount;
    tcpClient["receive"]                   = sol::overload([] (TcpClient& c) { return c.receive(); },
                                                           PickOverload<bool>(&TcpClient::receive));
    tcpClient["receiveAtLeast"]            = sol::overload([] (TcpClient& c, std::size_t b) { return c.receiveAtLeast(b); },
                                                           PickOverload<std::size_t, bool>(&TcpClient::receiveAtLeast));
    tcpClient["receiveExactly"]            = sol::overload([] (TcpClient& c, std::size_t b) { return c.receiveExactly(b); },
                                                           PickOverload<std::size_t, bool>(&TcpClient::receiveExactly));
    tcpClient["receiveUntil"]              = sol::overload([] (TcpClient& c, std::string_view d) { return c.receiveUntil(d); },
                                                           PickOverload<std::string_view, bool>(&TcpClient::receiveUntil));
    tcpClient["disconnect"]                = &TcpClient::disconnect;
  }

  {
    sol::usertype<TcpServer> tcpServer = state.new_usertype<TcpServer>("TcpServer",
                                                                       sol::constructors<TcpServer()>());
    tcpServer["start"] = &TcpServer::start;
    tcpServer["stop"]  = &TcpServer::stop;
  }

  {
    sol::usertype<UdpClient> udpClient = state.new_usertype<UdpClient>("UdpClient",
                                                                       sol::constructors<UdpClient(),
                                                                                         UdpClient(const std::string&, unsigned short)>());
    udpClient["setDestination"]            = &UdpClient::setDestination;
    udpClient["send"]                      = &UdpClient::send;
    udpClient["recoverAvailableByteCount"] = &UdpClient::recoverAvailableByteCount;
    udpClient["receive"]                   = &UdpClient::receive;
    udpClient["close"]                     = &UdpClient::close;
  }

  {
    sol::usertype<UdpServer> udpServer = state.new_usertype<UdpServer>("UdpServer",
                                                                       sol::constructors<UdpServer()>());
    udpServer["start"] = &UdpServer::start;
    udpServer["stop"]  = &UdpServer::stop;
  }
}

} // namespace Raz

1	#include "RaZ/Network/TcpClient.hpp"
2	#include "RaZ/Network/TcpServer.hpp"
3	#include "RaZ/Network/UdpClient.hpp"
4	#include "RaZ/Network/UdpServer.hpp"
5	#include "RaZ/Script/LuaWrapper.hpp"
6	#include "RaZ/Utils/TypeUtils.hpp"
7
8	#define SOL_ALL_SAFETIES_ON 1
9	#include "sol/sol.hpp"
10
11	namespace Raz {
12
13	using namespace TypeUtils;
14
15	void LuaWrapper::registerNetworkTypes() {	2✔
16	sol::state& state = getState();	2✔
17
18	{
19	sol::usertype<TcpClient> tcpClient = state.new_usertype<TcpClient>("TcpClient",
20	sol::constructors<TcpClient(),	×
21	TcpClient(const std::string&, unsigned short)>());	2✔
22	tcpClient["isConnected"] = &TcpClient::isConnected;	2✔
23	tcpClient["connect"] = &TcpClient::connect;	2✔
24	tcpClient["send"] = &TcpClient::send;	2✔
25	tcpClient["recoverAvailableByteCount"] = &TcpClient::recoverAvailableByteCount;	2✔
26	tcpClient["receive"] = sol::overload([] (TcpClient& c) { return c.receive(); },	2✔
27	PickOverload<bool>(&TcpClient::receive));	4✔
28	tcpClient["receiveAtLeast"] = sol::overload([] (TcpClient& c, std::size_t b) { return c.receiveAtLeast(b); },	2✔
29	PickOverload<std::size_t, bool>(&TcpClient::receiveAtLeast));	4✔
30	tcpClient["receiveExactly"] = sol::overload([] (TcpClient& c, std::size_t b) { return c.receiveExactly(b); },	2✔
31	PickOverload<std::size_t, bool>(&TcpClient::receiveExactly));	4✔
32	tcpClient["receiveUntil"] = sol::overload([] (TcpClient& c, std::string_view d) { return c.receiveUntil(d); },	2✔
33	PickOverload<std::string_view, bool>(&TcpClient::receiveUntil));	4✔
34	tcpClient["disconnect"] = &TcpClient::disconnect;	2✔
35	}	2✔
36
37	{
38	sol::usertype<TcpServer> tcpServer = state.new_usertype<TcpServer>("TcpServer",
39	sol::constructors<TcpServer()>());	2✔
40	tcpServer["start"] = &TcpServer::start;	2✔
41	tcpServer["stop"] = &TcpServer::stop;	2✔
42	}	2✔
43
44	{
45	sol::usertype<UdpClient> udpClient = state.new_usertype<UdpClient>("UdpClient",
NEW 46	sol::constructors<UdpClient(),	×
47	UdpClient(const std::string&, unsigned short)>());	2✔
48	udpClient["setDestination"] = &UdpClient::setDestination;	2✔
49	udpClient["send"] = &UdpClient::send;	2✔
50	udpClient["recoverAvailableByteCount"] = &UdpClient::recoverAvailableByteCount;	2✔
51	udpClient["receive"] = &UdpClient::receive;	2✔
52	udpClient["close"] = &UdpClient::close;	2✔
53	}	2✔
54
55	{
56	sol::usertype<UdpServer> udpServer = state.new_usertype<UdpServer>("UdpServer",
57	sol::constructors<UdpServer()>());	2✔
58	udpServer["start"] = &UdpServer::start;	2✔
59	udpServer["stop"] = &UdpServer::stop;	2✔
60	}	2✔
61	}	2✔
62
63	} // namespace Raz

Razakhel / RaZ / 21179551844

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous