22275713153

Committed 22 Feb 2026 10:51AM UTC coverage: 74.442% (+0.005%) from 74.437%

Build # 22275713153

Build Type

push

github

Committed by

Razakhel

Commit Message

[Network] Added Tcp/UdpServer::isRunning()

- Servers are automatically stopped on destruction

- Added constructors to TCP & UDP servers taking a port to directly start on

Run Details

24 of 28 new or added lines in 5 files covered. (85.71%)

8578 of 11523 relevant lines covered (74.44%)

1715.77 hits per line

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

89.74

/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(unsigned short)>());
    tcpServer["isRunning"] = &TcpServer::isRunning;
    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(unsigned short)>());
    udpServer["isRunning"] = &UdpServer::isRunning;
    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",
NEW 39	sol::constructors<TcpServer(),	×
40	TcpServer(unsigned short)>());	2✔
41	tcpServer["isRunning"] = &TcpServer::isRunning;	2✔
42	tcpServer["start"] = &TcpServer::start;	2✔
43	tcpServer["stop"] = &TcpServer::stop;	2✔
44	}	2✔
45
46	{
47	sol::usertype<UdpClient> udpClient = state.new_usertype<UdpClient>("UdpClient",
48	sol::constructors<UdpClient(),	×
49	UdpClient(const std::string&, unsigned short)>());	2✔
50	udpClient["setDestination"] = &UdpClient::setDestination;	2✔
51	udpClient["send"] = &UdpClient::send;	2✔
52	udpClient["recoverAvailableByteCount"] = &UdpClient::recoverAvailableByteCount;	2✔
53	udpClient["receive"] = &UdpClient::receive;	2✔
54	udpClient["close"] = &UdpClient::close;	2✔
55	}	2✔
56
57	{
58	sol::usertype<UdpServer> udpServer = state.new_usertype<UdpServer>("UdpServer",
NEW 59	sol::constructors<UdpServer(),	×
60	UdpServer(unsigned short)>());	2✔
61	udpServer["isRunning"] = &UdpServer::isRunning;	2✔
62	udpServer["start"] = &UdpServer::start;	2✔
63	udpServer["stop"] = &UdpServer::stop;	2✔
64	}	2✔
65	}	2✔
66
67	} // namespace Raz

Razakhel / RaZ / 22275713153

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