tcp-lib/tests/tcp.cpp

#include "tcp.hpp"

#include <gtest/gtest.h>


TEST(TcpServer, Accept) {
    tcp::NonBlockingServer server{{.port = 1234}};
    tcp::NonBlockingClient client;

    auto lisRes = server.start_listening();

    EXPECT_FALSE(server.next_client_available());

    auto conRes = client.connect({"localhost"}, 1234);

    EXPECT_TRUE(server.next_client_available());

    auto accRes = server.accept_next_client();

    EXPECT_FALSE(server.next_client_available());
}

TEST(TcpClient, Connect) {
    tcp::NonBlockingServer server{{.port = 1234}};
    tcp::NonBlockingClient client;

    /// Default connection status, i.e., before attempting connection

    auto statRes1 = client.get_last_connection_status();
    if (!statRes1) return;
    EXPECT_EQ(statRes1.value(), ENOTCONN);

    /// Connection status when connection is not acknowledged

    auto conRes = client.connect({"localhost"}, 1234);

    auto statRes2 = client.get_last_connection_status();
    if (!statRes2) return;
    EXPECT_EQ(statRes2.value(), ECONNREFUSED);

    /// Connection status when connection is acknowledged

    auto lisRes = server.start_listening();

    auto conRes2 = client.connect({"localhost"}, 1234);

    auto statRes3 = client.get_last_connection_status();
    if (!statRes3) return;
    EXPECT_EQ(statRes3.value(), EISCONN);

    /// Connection status changes when reattempting connection

    auto conRes3 = client.connect({"localhost"}, 12345);

    auto statRes4 = client.get_last_connection_status();
    if (!statRes4) return;
    EXPECT_EQ(statRes4.value(), ECONNREFUSED);
}

TEST(TcpClient, Reonnect) {
    tcp::NonBlockingServer server1{{.port = 1234}};
    tcp::NonBlockingServer server2{{.port = 2345}};
    tcp::NonBlockingClient client;

    auto lisRes1 = server1.start_listening();
    auto lisRes2 = server2.start_listening();

    auto conRes1 = client.connect({"localhost"}, 1234);

    auto statRes1 = client.get_last_connection_status();
    if (!statRes1) return;
    EXPECT_EQ(statRes1.value(), EISCONN);

    auto conRes2 = client.connect({"localhost"}, 2345);

    auto statRes2 = client.get_last_connection_status();
    if (!statRes2) return;
    EXPECT_EQ(statRes2.value(), EISCONN);
}

TEST(TcpClient, DataAvailable) {
    tcp::NonBlockingServer server{{.port = 1234}};
    tcp::NonBlockingClient client;

    EXPECT_FALSE(client.data_available());

    auto lisRes = server.start_listening();
    auto conRes = client.connect({"localhost"}, 1234);
    auto accRes = server.accept_next_client();

    EXPECT_EQ(client.get_last_connection_status().value(), EISCONN);
    EXPECT_FALSE(client.data_available());

    std::array<char, 14> txMsg   = {"Hello, World!"};
    auto                 sendRes = server.send(std::as_bytes(std::span(txMsg)));

    EXPECT_EQ(sendRes.value(), txMsg.size());
    EXPECT_TRUE(client.data_available());

    std::array<char, 1024> rxBuffer;
    auto recvRes = client.recv(std::as_writable_bytes(std::span(rxBuffer)));
    EXPECT_EQ(recvRes.value(), txMsg.size());

    EXPECT_FALSE(client.data_available());
}

TEST(TcpServer, DataAvailable) {
    tcp::NonBlockingServer server{{.port = 1234}};
    tcp::NonBlockingClient client;

    EXPECT_FALSE(server.data_available());

    auto lisRes = server.start_listening();
    auto conRes = client.connect({"localhost"}, 1234);
    auto accRes = server.accept_next_client();

    EXPECT_FALSE(server.data_available());

    std::array<char, 14> txMsg   = {"Hello, World!"};
    auto                 sendRes = client.send(std::as_bytes(std::span(txMsg)));
    EXPECT_EQ(sendRes.value(), txMsg.size());
    EXPECT_TRUE(server.data_available());

    std::array<char, 1024> rxBuffer;
    auto recvRes = server.recv(std::as_writable_bytes(std::span(rxBuffer)));
    EXPECT_EQ(recvRes.value(), txMsg.size());
    EXPECT_FALSE(server.data_available());
}

TEST(TcpClientServer, ClientSendServerReceive) {
    tcp::NonBlockingServer server{{.port = 1234}};
    tcp::NonBlockingClient client;

    auto lisRes = server.start_listening();
    auto conRes = client.connect({"localhost"}, 1234);
    auto accRes = server.accept_next_client();

    std::array<char, 14> txMsg   = {"Hello, World!"};
    auto                 sendRes = client.send(std::as_bytes(std::span(txMsg)));

    EXPECT_EQ(sendRes.value(), txMsg.size());

    std::array<char, 1024> rxBuffer;
    auto recvRes = server.recv(std::as_writable_bytes(std::span(rxBuffer)));

    EXPECT_EQ(recvRes.value(), txMsg.size());
    EXPECT_EQ(std::strcmp(txMsg.data(), rxBuffer.data()), 0);
}

TEST(TcpClientServer, ClientReceiveServerSend) {
    tcp::NonBlockingServer server{{.port = 1234}};
    tcp::NonBlockingClient client;

    auto lisRes = server.start_listening();
    auto conRes = client.connect({"localhost"}, 1234);
    auto accRes = server.accept_next_client();

    std::array<char, 14> txMsg   = {"Hello, World!"};
    auto                 sendRes = server.send(std::as_bytes(std::span(txMsg)));

    EXPECT_EQ(sendRes.value(), txMsg.size());

    std::array<char, 1024> rxBuffer;
    auto recvRes = client.recv(std::as_writable_bytes(std::span(rxBuffer)));

    EXPECT_EQ(recvRes.value(), txMsg.size());
    EXPECT_EQ(std::strcmp(txMsg.data(), rxBuffer.data()), 0);
}