Skip to content

Commit

Permalink
test: use unspecified localhost addresses, cleanup
Browse files Browse the repository at this point in the history
  • Loading branch information
@mporsch
mporsch committed Aug 8, 2023
1 parent ada025a commit 2d12709
Show file tree
Hide file tree
Showing 7 changed files with 117 additions and 100 deletions.
49 changes: 26 additions & 23 deletions test/sockpuppet_tcp_async_performance_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,13 +23,13 @@ struct Server
{
struct ClientSession
{
SocketTcpAsync client;
SocketTcpAsync clientSock;

ClientSession(Server *parent, SocketTcp &&client)
: client({std::move(client)},
parent->driver,
std::bind(&ClientSession::HandleReceive, this, std::placeholders::_1),
std::bind(&Server::HandleDisconnect, parent, std::placeholders::_1))
ClientSession(Server *parent, SocketTcp &&clientSock)
: clientSock({std::move(clientSock)},
parent->driver,
std::bind(&ClientSession::HandleReceive, this, std::placeholders::_1),
std::bind(&Server::HandleDisconnect, parent, std::placeholders::_1))
{
}
ClientSession(ClientSession const &) = delete;
Expand All @@ -41,21 +41,21 @@ struct Server
std::this_thread::sleep_for(std::chrono::microseconds(100));

// echo received data
(void)client.Send(std::move(buffer));
(void)clientSock.Send(std::move(buffer));
}
};

AcceptorAsync server;
AcceptorAsync serverSock;
Driver &driver;
std::map<Address, std::unique_ptr<ClientSession>> clientSessions;

Server(Address bindAddress, Driver &driver)
: server(MakeTestSocket<Acceptor>(bindAddress),
driver,
std::bind(&Server::HandleConnect,
this,
std::placeholders::_1,
std::placeholders::_2))
Server(Acceptor serverSock, Driver &driver)
: serverSock(std::move(serverSock),
driver,
std::bind(&Server::HandleConnect,
this,
std::placeholders::_1,
std::placeholders::_2))
, driver(driver)
{
}
Expand Down Expand Up @@ -141,15 +141,15 @@ struct Clients

SocketTcpAsync &Add(Address serverAddr, Driver &driver)
{
auto client = MakeTestSocket<SocketTcp>(serverAddr);
auto clientAddr = client.LocalAddress();
auto clientSock = MakeTestSocket<SocketTcp>(serverAddr);
auto clientAddr = clientSock.LocalAddress();

std::cout << "client " << to_string(clientAddr)
<< " connecting to server" << std::endl;

auto p = clients.emplace(
std::move(clientAddr),
std::make_unique<Client>(this, std::move(client), driver));
std::make_unique<Client>(this, std::move(clientSock), driver));
return p.first->second->client;
}

Expand All @@ -172,11 +172,13 @@ void ClientSend(SocketTcpAsync &client)
}
}

void RunServer(Address serverAddr, Driver &driver)
void RunServer(Acceptor serverSock, Driver &driver)
{
Server server(serverAddr, driver);
std::cout << "server listening at "
<< to_string(serverSock.LocalAddress())
<< std::endl;

std::cout << "server listening at " << to_string(serverAddr) << std::endl;
auto server = Server(std::move(serverSock), driver);

// run server until stopped by main thread
driver.Run();
Expand Down Expand Up @@ -219,10 +221,11 @@ try {
Driver serverDriver;
Driver clientDriver;

Address serverAddr("localhost:8554");
auto serverSock = MakeTestSocket<Acceptor>(Address());
auto serverAddr = serverSock.LocalAddress();

// set up a server that echoes all input data on multiple sessions
auto serverThread = std::thread(RunServer, serverAddr, std::ref(serverDriver));
auto serverThread = std::thread(RunServer, std::move(serverSock), std::ref(serverDriver));

// wait for server to come up
std::this_thread::sleep_for(1s);
Expand Down
25 changes: 13 additions & 12 deletions test/sockpuppet_tcp_async_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,20 +24,20 @@ std::promise<void> promisedServerDisconnect;

struct Server
{
AcceptorAsync server;
AcceptorAsync sock;
Driver &driver;
size_t bytesReceived;
std::map<Address, SocketTcpAsync> serverHandlers;
std::mutex mtx;

Server(Address bindAddress,
Driver &driver)
: server(MakeTestSocket<Acceptor>(bindAddress),
driver,
std::bind(&Server::HandleConnect,
this,
std::placeholders::_1,
std::placeholders::_2))
: sock(MakeTestSocket<Acceptor>(bindAddress),
driver,
std::bind(&Server::HandleConnect,
this,
std::placeholders::_1,
std::placeholders::_2))
, driver(driver)
, bytesReceived(0U)
{
Expand Down Expand Up @@ -138,10 +138,11 @@ int main(int, char **)
Driver driver;
auto thread = std::thread(&Driver::Run, &driver);

Address serverAddress("localhost:8554");
auto server = std::make_unique<Server>(serverAddress, driver);
auto server = std::make_unique<Server>(Address(), driver);
auto serverAddr = server->sock.LocalAddress();

std::cout << "server listening at " << to_string(serverAddress)
std::cout << "server listening at "
<< to_string(serverAddr)
<< std::endl;

{
Expand All @@ -153,7 +154,7 @@ int main(int, char **)
for(auto &&client : clients)
{
client.reset(new SocketTcpAsync(
{MakeTestSocket<SocketTcp>(serverAddress)},
{MakeTestSocket<SocketTcp>(serverAddr)},
driver,
ReceiveDummy,
DisconnectDummy));
Expand Down Expand Up @@ -193,7 +194,7 @@ int main(int, char **)

// try the disconnect the other way around
loneClient.reset(new SocketTcpAsync(
{MakeTestSocket<SocketTcp>(serverAddress)},
{MakeTestSocket<SocketTcp>(serverAddr)},
driver,
ReceiveDummy,
HandleDisconnect));
Expand Down
26 changes: 14 additions & 12 deletions test/sockpuppet_tcp_buffered_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,25 +8,26 @@
#include <thread> // for std::thread

using namespace sockpuppet;
using namespace std::chrono_literals;

constexpr size_t testDataSize = 100U * 1024 * 1024;
static TestData const testData(testDataSize);
static std::atomic<bool> success(true);

void ServerHandler(std::pair<SocketTcp, Address> p)
{
SocketTcpBuffered serverHandler(std::move(p.first), 0U, 1500U);
SocketTcpBuffered clientSock(std::move(p.first), 0U, 1500U);

std::vector<BufferPtr> storage;
storage.reserve(testDataSize / TestData::tcpPacketSizeMin);

// receive until disconnect
try {
for(;;) {
storage.emplace_back(serverHandler.Receive().value());
storage.emplace_back(clientSock.Receive().value());

// simulate some processing delay to trigger TCP congestion control
std::this_thread::sleep_for(std::chrono::microseconds(100));
std::this_thread::sleep_for(100us);
}
} catch(std::exception const &) {
}
Expand All @@ -36,14 +37,13 @@ void ServerHandler(std::pair<SocketTcp, Address> p)
}
}

void Server(Address serverAddress)
void Server(Acceptor serverSock)
try {
auto server = MakeTestSocket<Acceptor>(serverAddress);

std::cout << "server listening at " << to_string(serverAddress)
std::cout << "server listening at "
<< to_string(serverSock.LocalAddress())
<< std::endl;

ServerHandler(server.Listen().value());
ServerHandler(serverSock.Listen().value());
} catch (std::exception const &e) {
std::cerr << e.what() << std::endl;
success = false;
Expand All @@ -67,12 +67,14 @@ try {

void Test(Duration perPacketSendTimeout)
{
auto serverSock = MakeTestSocket<Acceptor>(Address());
auto serverAddr = serverSock.LocalAddress();

// start client and server threads
Address serverAddr("localhost:8554");
std::thread server(Server, serverAddr);
std::thread server(Server, std::move(serverSock));

// wait for server to come up
std::this_thread::sleep_for(std::chrono::seconds(1));
std::this_thread::sleep_for(1s);

std::thread client(Client, serverAddr, perPacketSendTimeout);

Expand All @@ -91,7 +93,7 @@ int main(int, char **)
Test(Duration(-1));

std::cout << "test case #2: limited send timeout" << std::endl;
Test(std::chrono::milliseconds(1));
Test(Duration(1));

std::cout << "test case #3: non-blocking send" << std::endl;
Test(Duration(0));
Expand Down
25 changes: 14 additions & 11 deletions test/sockpuppet_tcp_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,17 +32,17 @@ try {
success = false;
}

void Server(Address serverAddr)
void Server(Acceptor serverSock)
try {
auto server = MakeTestSocket<Acceptor>(serverAddr);

std::cout << "server listening at " << to_string(serverAddr) << std::endl;
std::cout << "server listening at "
<< to_string(serverSock.LocalAddress())
<< std::endl;

std::thread serverHandlers[clientCount];
for(auto &&serverHandler : serverHandlers) {
serverHandler = std::thread(
ServerHandler,
server.Listen(seconds(2)).value());
serverSock.Listen(seconds(2)).value());
}

for(auto &&serverHandler : serverHandlers) {
Expand All @@ -57,23 +57,24 @@ try {

void Client(Address serverAddr)
try {
auto client = MakeTestSocket<SocketTcp>(serverAddr);
auto const clientAddr = client.LocalAddress();
auto clientSock = MakeTestSocket<SocketTcp>(serverAddr);
auto clientAddr = clientSock.LocalAddress();

std::cout << "client " << to_string(clientAddr)
<< " connected to server " << to_string(serverAddr)
<< std::endl;

char buffer[256];
if(auto rx = client.Receive(buffer, sizeof(buffer), seconds(1))) {
constexpr Duration receiveTimeout = seconds(1);
if(auto rx = clientSock.Receive(buffer, sizeof(buffer), receiveTimeout)) {
if(std::string_view(buffer, rx.value()).find("hello") != std::string::npos) {
std::cout << "client " << to_string(clientAddr)
<< " received from server" << std::endl;

try {
// the server closes the connection after the "hello" message
// we expect to get the corresponding exception now
(void)client.Receive(buffer, sizeof(buffer), seconds(1));
(void)clientSock.Receive(buffer, sizeof(buffer), receiveTimeout);
success = false;
} catch(std::exception const &e) {
std::cout << e.what() << std::endl;
Expand All @@ -90,8 +91,10 @@ try {

int main(int, char **)
{
Address const serverAddr("localhost:8554");
std::thread server(Server, serverAddr);
auto serverSock = MakeTestSocket<Acceptor>(Address());
auto serverAddr = serverSock.LocalAddress();

std::thread server(Server, std::move(serverSock));

// wait for server thread to come up
std::this_thread::sleep_for(seconds(1));
Expand Down
28 changes: 15 additions & 13 deletions test/sockpuppet_udp_async_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -34,33 +34,35 @@ int main(int, char **)
auto thread = std::thread(&Driver::Run, &driver);

{
Address serverAddress("localhost:8554");
SocketUdpAsync server({serverAddress, 1U, 1500U},
driver,
HandleReceiveFrom);

std::cout << "waiting for receipt at " << to_string(serverAddress)
auto serverSock = SocketUdpAsync(
{Address(), 1U, 1500U},
driver,
HandleReceiveFrom);
auto serverAddr = serverSock.LocalAddress();

std::cout << "waiting for receipt at "
<< to_string(serverAddr)
<< std::endl;

auto futureReceipt = promisedReceipt->get_future();

{
BufferPool sendPool(clientSendCount, clientSendSize);

SocketUdpAsync client({Address("localhost")},
driver,
ReceiveFromDummy);
auto clientSock = SocketUdpAsync(
{Address()},
driver,
ReceiveFromDummy);

std::cout << "sending from " << to_string(client.LocalAddress())
<< " to " << to_string(serverAddress) << std::endl;
std::cout << "sending from " << to_string(clientSock.LocalAddress())
<< " to " << to_string(serverAddr) << std::endl;

std::vector<std::future<void>> futuresSend;
futuresSend.reserve(clientSendCount);
for(size_t i = 0U; i < clientSendCount; ++i) {
auto buffer = sendPool.Get();
buffer->assign(clientSendSize, 'a');
futuresSend.emplace_back(
client.SendTo(std::move(buffer), serverAddress));
futuresSend.emplace_back(clientSock.SendTo(std::move(buffer), serverAddr));
}

auto deadline = steady_clock::now() + seconds(1);
Expand Down
Loading

0 comments on commit 2d12709

Please sign in to comment.