Cppcheck report - GATE C/C++ Framework: gate/net/tests/gatenet_cpp_test/test_sockets.cpp

#include "gate/tests.hpp"
#include "gate/net/sockets.hpp"
#include "gate/net/sockettools.hpp"
#include "gate/synchronization.hpp"

using namespace gate;
using namespace gate::net;

static void testUdpCommunication(Socket& s1, Socket& s2, String const& addr1, String const& addr2)
{
    Socket::Endpoint ep1 = Socket::parseAddress(addr1);
    Socket::Endpoint ep2 = Socket::parseAddress(addr2);

    GATEXX_TEST_CHECK(ep1.getFamily() != Socket::Family_None);
    GATEXX_TEST_CHECK(ep2.getFamily() != Socket::Family_None);

    GATEXX_TEST_REQUIRE_NOTHROW(s1.bind(ep1));
    GATEXX_TEST_REQUIRE_NOTHROW(s2.bind(addr2));

    GATEXX_TEST_REQUIRE_NOTHROW(s2.setOption(Socket::Option_ReceiveTimeout, 5000));

    static char const* sendText = "Hello";
    static gate::size_t sendTextLen = 5;

    gate::size_t bytes_sent = 0;
    GATEXX_TEST_CHECK_NOTHROW(bytes_sent = s1.sendTo(ep2, sendText, sendTextLen));
    GATEXX_TEST_CHECK_EQUAL(bytes_sent, sendTextLen);

    Socket::Endpoint remoteEp;
    char buffer[32];
    gate::size_t bytes_received = 0;
    GATEXX_TEST_CHECK_NOTHROW(bytes_received = s2.receiveFrom(remoteEp, buffer, sizeof(buffer)));
    GATEXX_TEST_CHECK_EQUAL(bytes_received, sendTextLen);
    GATEXX_TEST_CHECK(gate_str_compare(buffer, bytes_received, sendText, sendTextLen) == 0);

    GATEXX_TEST_CHECK_NOTHROW(s1.close());
    GATEXX_TEST_CHECK_NOTHROW(s2.close());
}

GATEXX_TEST_UNIT(Udp4Sockets)
{
    String addr1;
    {
        static const Socket::Ip4Address ip1(127, 0, 0, 1);
        static const Socket::Endpoint ep1(ip1, 34567);
        GATEXX_TEST_CHECK_NOTHROW(addr1 = Socket::printAddress(ep1));
    }
    static StaticString const addr2 = "127.0.0.1:45678";

    Socket s1(Socket::SocketType_Udp4);
    Socket s2(Socket::Family_Inet4, Socket::MsgType_Datagram, Socket::Protocol_Udp);

    testUdpCommunication(s1, s2, addr1, addr2);
}

GATEXX_TEST_UNIT(Udp6Sockets)
{
    if (!Socket::hasSupportFor(Socket::Family_Inet6))
    {
        return;
    }

    String addr1;
    {
        static const Socket::Ip6Address ip1(0, 0, 0, 0, 0, 0, 0, 1);
        static const Socket::Endpoint ep1(ip1, 34567);
        GATEXX_TEST_CHECK_NOTHROW(addr1 = Socket::printAddress(ep1));
    }
    static StaticString const addr2 = "[::1]:45678";

    Socket s1(Socket::SocketType_Udp6);
    Socket s2(Socket::Family_Inet6, Socket::MsgType_Datagram, Socket::Protocol_Udp);

    testUdpCommunication(s1, s2, addr1, addr2);
}


static void testSendReceive(Socket& sender, Socket& receiver, char const* text, gate::size_t textlen)
{
    char buffer[4096];
    gate::size_t offset_in = 0;
    gate::size_t offset_out = 0;

    while ((offset_in < textlen) || (offset_out < textlen))
    {
        if (offset_in < textlen)
        {
            gate::size_t sent = 0;
            GATEXX_TEST_CHECK_NOTHROW(sent = sender.send(&text[offset_in], textlen - offset_in));
            GATEXX_TEST_REQUIRE(sent > 0);
            offset_in += sent;
        }

        gate::size_t received = 0;
        GATEXX_TEST_CHECK_NOTHROW(received = receiver.receive(&buffer[offset_out], textlen - offset_out));
        GATEXX_TEST_REQUIRE(received > 0);
        offset_out += received;
    }

    GATEXX_TEST_CHECK(Mem::compare(text, buffer, textlen) == 0);
}

static void testTcpServerClient(Socket& server, Socket& client, String const& server_address)
{
    GATEXX_TEST_CHECK_NOTHROW(server.bind(server_address));
    GATEXX_TEST_CHECK_NOTHROW(server.listen());

    GATEXX_TEST_CHECK_NOTHROW(client.setOption(Socket::Option_Blocking, 0));
    GATEXX_TEST_CHECK_NOTHROW(client.setOption(Socket::Option_ReceiveTimeout, 5000));
    GATEXX_TEST_CHECK_NOTHROW(client.setOption(Socket::Option_SendTimeout, 5000));

    GATEXX_TEST_CHECK_NOTHROW(client.connect(server_address));

    bool_t canRead = true, canWrite = true, hasError = true;
    GATEXX_TEST_CHECK_NOTHROW(server.select(&canRead, &canWrite, &hasError, 1000));
    GATEXX_TEST_CHECK_EQUAL(canRead, true);
    GATEXX_TEST_CHECK_EQUAL(canWrite, false);
    GATEXX_TEST_CHECK_EQUAL(hasError, false);

    Socket serverside;
    GATEXX_TEST_CHECK_NOTHROW(server.accept(serverside));

    canRead = canWrite = hasError = true;
    GATEXX_TEST_CHECK_NOTHROW(client.select(&canRead, &canWrite, &hasError, 1000));
    GATEXX_TEST_CHECK_EQUAL(canRead, false);
    GATEXX_TEST_CHECK_EQUAL(canWrite, true);
    GATEXX_TEST_CHECK_EQUAL(hasError, false);

    GATEXX_TEST_CHECK_NOTHROW(client.setOption(Socket::Option_Blocking, 1));

    String localAddr;
    GATEXX_TEST_CHECK_NOTHROW(localAddr = client.getLocalAddress());
    GATEXX_TEST_CHECK(!localAddr.empty());

    String removeAddr;
    GATEXX_TEST_CHECK_NOTHROW(removeAddr = client.getRemoteAddress());
    GATEXX_TEST_CHECK(!removeAddr.empty());

    static const StaticString testMessage = "Hello world, world of hellos";
    testSendReceive(client, serverside, testMessage.c_str(), testMessage.length());

    GATEXX_TEST_CHECK_NOTHROW(client.shutdown(false, true));
    char dummy = 0;
    gate::size_t zeroReceived = 0;
    GATEXX_TEST_CHECK_NOTHROW(zeroReceived = serverside.receive(&dummy, 1));
    GATEXX_TEST_CHECK_EQUAL(zeroReceived, 0);
    GATEXX_TEST_CHECK_NOTHROW(serverside.shutdown(false, true));

    GATEXX_TEST_CHECK_NOTHROW(client.close());
    GATEXX_TEST_CHECK_NOTHROW(serverside.close());
    GATEXX_TEST_CHECK_NOTHROW(server.close());
}

GATEXX_TEST_UNIT(Tcp4Sockets)
{
    static const StaticString server_addr("127.0.0.1:56789");

    Socket server(Socket::SocketType_Tcp4);
    Socket client(Socket::Family_Inet4, Socket::MsgType_Stream, Socket::Protocol_Tcp);

    testTcpServerClient(server, client, server_addr);
}


GATEXX_TEST_UNIT(Tcp6Sockets)
{
    if (!Socket::hasSupportFor(Socket::Family_Inet6))
    {
        return;
    }

    static const StaticString server_addr("[::1]:56789");

    Socket server(Socket::SocketType_Tcp6);
    Socket client(Socket::Family_Inet6, Socket::MsgType_Stream, Socket::Protocol_Tcp);

    testTcpServerClient(server, client, server_addr);
}


class GATE_API_LOCAL TestQueueHandler : public DataQueueSink
{
public:
    SocketQueue queue;
    SocketQueue::channel_id_t idServer;
    SocketQueue::channel_id_t idServerConnection;
    SocketQueue::channel_id_t idIncorrect;
    SocketQueue::channel_id_t idClient;
    SyncEvent tasksCompleted;
    AtomicInt taskCounter;

    explicit TestQueueHandler(SocketQueue socketQueue)
    :   queue(socketQueue),
        idServer(0), idServerConnection(0), idIncorrect(0), idClient(0),
        tasksCompleted(false)
    {
    }

    virtual ~TestQueueHandler() noexcept
    {
    }

private:

    void notifyTaskCompleted()
    {
        int32_t const completedTasks = ++this->taskCounter;
        if (completedTasks == 5)
        {
            tasksCompleted.set();
        }
    }

    void onOpen(channel_id_t channel_id, char const* address, gate::size_t addressLength, void* userParam) override
    {
        if(userParam == &this->idClient)
        {
            this->notifyTaskCompleted();
            GATEXX_TEST_CHECK_NOTHROW(this->queue.beginWrite(this->idClient, "Hello", 5, &this->idClient));
        }
    }

    void onOpenFailed(channel_id_t channel_id, result_t result, char const* errorMsg, gate::size_t errorMsgLength, void* userParam) override
    {
        if(userParam == &this->idIncorrect)
        {
            GATEXX_TEST_CHECK_EQUAL(channel_id, this->idIncorrect);
            this->notifyTaskCompleted();
        }
    }

    void onOpenNew(channel_id_t channel_id, char const* address, gate::size_t addressLength, void* userParam) override
    {
        if(userParam == &this->idServer)
        {
            this->idServerConnection = channel_id;
            this->notifyTaskCompleted();
            GATEXX_TEST_CHECK_NOTHROW(this->queue.beginRead(channel_id, 1024, &this->idServerConnection));
        }
    }

    void onReadCompleted(channel_id_t channel_id, char const* buffer, gate::size_t bufferLength, void* userParam) override
    {
        if(userParam == &this->idServerConnection)
        {
            this->notifyTaskCompleted();
        }
    }
    void onWriteCompleted(channel_id_t channel_id, char const* buffer, gate::size_t bufferLength, void* userParam) override
    {
        if(userParam == &this->idClient)
        {
            this->notifyTaskCompleted();
        }
    }
};

GATEXX_TEST_UNIT(SocketQueue)
{
    static StaticString serverAddress("127.0.0.1:9876");
    static StaticString serverAddressIncorrect("127.0.0.1:9877");
    TestQueueHandler handler(SocketQueue::create(1000));
    {
        SocketQueue queue = SocketQueue::create(1000);<--- Variable 'queue' is reassigned a value before the old one has been used.
        queue = handler.queue;<--- Variable 'queue' is reassigned a value before the old one has been used.
    }
    handler.queue.setCallback(handler);

    GATEXX_TEST_CHECK_NOTHROW(handler.idServer = handler.queue.open(serverAddress, SocketQueue::Flag_OpenServer, &handler.idServer));
    GATEXX_TEST_CHECK_NOTHROW(handler.idIncorrect = handler.queue.open(serverAddressIncorrect, SocketQueue::Flag_OpenClient, &handler.idIncorrect));
    GATEXX_TEST_CHECK_NOTHROW(handler.idClient = handler.queue.open(serverAddress, SocketQueue::Flag_OpenClient, &handler.idClient));

    GATEXX_TEST_CHECK_NOTHROW(handler.queue.start());
    bool completionSignalReceived = handler.tasksCompleted.waitFor(gate::time::Seconds(5));
    GATEXX_TEST_CHECK_NOTHROW(handler.queue.close(handler.idServer));
    GATEXX_TEST_CHECK_NOTHROW(handler.queue.closeAll());
    GATEXX_TEST_CHECK_NOTHROW(handler.queue.stop());
    GATEXX_TEST_CHECK(completionSignalReceived);

    {
        DataQueueSink sink;
        sink.onStatus(0, 0, 0, NULL, 0, NULL);
        sink.onOpen(0, NULL, 0, NULL);
        sink.onOpenFailed(0, 0, NULL, 0, NULL);
        sink.onOpenNew(0, NULL, 0, NULL);
        sink.onOpenNewFailed(0, 0, NULL, 0, NULL);
        sink.onReadCompleted(0, NULL, 0, NULL);
        sink.onWriteCompleted(0, NULL, 0, NULL);
        sink.onReadError(0, 0, NULL);
        sink.onWriteError(0, 0, NULL);
        sink.onError(0, 0, NULL, 0);
    }
}