cgaming-core/test/modules/NetworkTests.c

#include <core/Logger.h>
#include <core/Utility.h>
#include <string.h>

#include "../Tests.h"
#include "../src/ErrorSimulator.h"
#include "core/Network.h"

#define TEST_READ(Type, type, value)                                           \
    {                                                                          \
        type u;                                                                \
        TEST_FALSE(readInPacket##Type(&in, &u));                               \
        TEST_TRUE(u == value);                                                 \
    }

static void testWriteRead(void) {
    OutPacket out;
    initOutPacket(&out);
    writeOutPacketU8(&out, 200);
    writeOutPacketU16(&out, 6656);
    writeOutPacketU32(&out, 348923689);
    writeOutPacketI8(&out, 90);
    writeOutPacketI8(&out, -35);
    writeOutPacketI16(&out, 843);
    writeOutPacketI16(&out, -8961);
    writeOutPacketI32(&out, 100430199);
    writeOutPacketI32(&out, -534534);
    writeOutPacketFloat(&out, 64564.5346f);
    const char s[] = "This is Great";
    writeOutPacketString(&out, s);

    InPacket in;
    initInPacket(&in, out.data.buffer, out.data.size);
    TEST_READ(U8, u8, 200)
    TEST_READ(U16, u16, 6656)
    TEST_READ(U32, u32, 348923689)
    TEST_READ(I8, i8, 90)
    TEST_READ(I8, i8, -35)
    TEST_READ(I16, i16, 843)
    TEST_READ(I16, i16, -8961)
    TEST_READ(I32, i32, 100430199)
    TEST_READ(I32, i32, -534534)
    float f;
    TEST_FALSE(readInPacketFloat(&in, &f));
    TEST_FLOAT(64564.5346f, f, 0.00001f);
    char buffer[256];
    size_t n = readInPacketString(&in, buffer, sizeof(buffer));
    TEST_SIZE(14, n);
    TEST_STRING(s, buffer);

    TEST_TRUE(readInPacketU8(&in, &(u8){0}));
    TEST_TRUE(readInPacketU16(&in, &(u16){0}));
    TEST_TRUE(readInPacketU32(&in, &(u32){0}));
    TEST_TRUE(readInPacketI8(&in, &(i8){0}));
    TEST_TRUE(readInPacketI16(&in, &(i16){0}));
    TEST_TRUE(readInPacketI32(&in, &(i32){0}));
    TEST_TRUE(readInPacketFloat(&in, &(float){0}));
    TEST_SIZE(0, readInPacketString(&in, nullptr, 0));
    TEST_SIZE(0, readInPacketString(&in, buffer, sizeof(buffer)));

    destroyOutPacket(&out);
}

static void testTooShortBuffer(void) {
    OutPacket out;
    initOutPacket(&out);
    writeOutPacketString(&out, "This is Great");
    writeOutPacketString(&out, "Well hoho");

    InPacket in;
    initInPacket(&in, out.data.buffer, out.data.size);
    char buffer[8];
    size_t n = readInPacketString(&in, buffer, sizeof(buffer));
    TEST_SIZE(14, n);
    TEST_STRING("This is", buffer);
    char buffer2[6];
    size_t n2 = readInPacketString(&in, buffer2, sizeof(buffer2));
    TEST_SIZE(10, n2);
    TEST_STRING("Well ", buffer2);

    destroyOutPacket(&out);
}

typedef struct {
    u8 a;
    u8 b;
} PacketTest;

static void testBinaryData(void) {
    OutPacket out;
    initOutPacket(&out);
    PacketTest data = {56, 3};
    writeOutPacket(&out, &data, sizeof(data));

    InPacket in;
    initInPacket(&in, out.data.buffer, out.data.size);

    PacketTest inData;
    TEST_FALSE(readInPacket(&in, &inData, sizeof(inData)));
    TEST_TRUE(memcmp(&inData, &data, sizeof(inData)) == 0);

    destroyOutPacket(&out);
}

static void testShortString(void) {
    OutPacket out;
    initOutPacket(&out);
    writeOutPacketU16(&out, 200);
    writeOutPacketU16(&out, 65535);

    InPacket in;
    initInPacket(&in, out.data.buffer, out.data.size);

    char buffer[256];
    size_t n = readInPacketString(&in, buffer, sizeof(buffer));
    TEST_SIZE(200, n);
    TEST_STRING("", buffer);

    destroyOutPacket(&out);
}

static void tickClientN(int ticks) {
    for(int i = 0; i < ticks; i++) {
        tickClient();
    }
}

static void tick(int ticks) {
    for(int i = 0; i < ticks; i++) {
        tickClient();
        tickServer();
    }
}

static bool clientConnected = false;
static bool clientDisconnected = false;
static bool clientPackage = false;
static int packageCounter = 0;
static bool serverConnected = false;
static bool serverDisconnect = false;
static u8 data1 = 0;
static u16 data2 = 0;
static u32 data3 = 0;
static i8 data4 = 0;
static i16 data5 = 0;
static i32 data6 = 0;
static i8 data7 = 0;
static i16 data8 = 0;
static i32 data9 = 0;
static char data10[20];
static float data11 = 0.0f;

static void onServerConnect(Client) {
    serverConnected = true;
}

static void onServerDisconnect(Client) {
    serverDisconnect = true;
}

static void onServerPacket(Client client, InPacket* in) {
    TEST_FALSE(readInPacketU8(in, &data1));
    TEST_FALSE(readInPacketU16(in, &data2));
    TEST_FALSE(readInPacketU32(in, &data3));
    TEST_FALSE(readInPacketI8(in, &data4));
    TEST_FALSE(readInPacketI16(in, &data5));
    TEST_FALSE(readInPacketI32(in, &data6));
    TEST_FALSE(readInPacketI8(in, &data7));
    TEST_FALSE(readInPacketI16(in, &data8));
    TEST_FALSE(readInPacketI32(in, &data9));
    TEST_SIZE(9, readInPacketString(in, data10, sizeof(data10)));
    TEST_FALSE(readInPacketFloat(in, &data11));

    OutPacket out;
    initOutPacket(&out);
    if(packageCounter == 0) {
        sendServerPacket(client, &out, PACKET_RELIABLE);
    } else if(packageCounter == 1) {
        sendServerPacket(client, &out, PACKET_SEQUENCED);
    } else if(packageCounter == 2) {
        sendServerPacket(client, &out, PACKET_UNSEQUENCED);
    }
    destroyOutPacket(&out);
    packageCounter++;
}

static void onClientConnect() {
    clientConnected = true;
}

static void onClientDisconnect() {
    clientDisconnected = true;
}

static void onClientPacket(InPacket*) {
    clientPackage = true;
}

static void testConnect(PacketSendMode mode) {
    clientConnected = false;
    clientDisconnected = false;
    clientPackage = false;
    serverConnected = false;
    serverDisconnect = false;
    data1 = 0;
    data2 = 0;
    data3 = 0;
    data4 = 0;
    data5 = 0;
    data6 = 0;
    data7 = 0;
    data8 = 0;
    data9 = 0;
    *data10 = '\0';
    data11 = 0.0f;

    resetServerHandler();
    setServerConnectHandler(onServerConnect);
    setServerDisconnectHandler(onServerDisconnect);
    setServerPacketHandler(onServerPacket);

    resetClientHandler();
    setClientConnectHandler(onClientConnect);
    setClientDisconnectHandler(onClientDisconnect);
    setClientPacketHandler(onClientPacket);

    if(!TEST_FALSE(startServer(54321, 5))) {
        return;
    } else if(!TEST_FALSE(startClient())) {
        return;
    } else if(!TEST_FALSE(connectClient("127.0.0.1", 54321, 90))) {
        return;
    }
    TEST_FALSE(isClientConnected());
    TEST_TRUE(isClientConnecting());
    tick(100);
    TEST_TRUE(clientConnected);
    TEST_TRUE(isClientConnected());
    TEST_FALSE(isClientConnecting());

    OutPacket out;
    initOutPacket(&out);
    writeOutPacketU8(&out, 0xF1);
    writeOutPacketU16(&out, 0xF123);
    writeOutPacketU32(&out, 0xF1234567);
    writeOutPacketI8(&out, -0x71);
    writeOutPacketI16(&out, -0x7123);
    writeOutPacketI32(&out, -0x71234567);
    writeOutPacketI8(&out, 0x71);
    writeOutPacketI16(&out, 0x7123);
    writeOutPacketI32(&out, 0x71234567);
    const char s[] = "Hi there";
    writeOutPacketString(&out, s);
    writeOutPacketFloat(&out, 252345.983f);
    sendClientPacket(&out, mode);
    destroyOutPacket(&out);

    tick(100);

    TEST_TRUE(clientPackage);
    TEST_TRUE(serverConnected);

    TEST_U64(0xF1, data1);
    TEST_U64(0xF123, data2);
    TEST_U64(0xF1234567, data3);
    TEST_I64(-0x71, data4);
    TEST_I64(-0x7123, data5);
    TEST_I64(-0x71234567, data6);
    TEST_I64(0x71, data7);
    TEST_I64(0x7123, data8);
    TEST_I64(0x71234567, data9);
    TEST_STRING(s, data10);
    TEST_FLOAT(252345.983f, data11, 0.01f);

    disconnectClient(90);
    TEST_FALSE(isClientConnected());
    TEST_FALSE(isClientConnecting());
    tick(100);
    TEST_TRUE(clientDisconnected);
    TEST_TRUE(serverDisconnect);

    stopClient();
    stopServer();
}

static bool disconnected = false;

static void testStopDisconnect(void) {
    disconnected = true;
}

static void testDisconnect(void) {
    disconnected = false;
    resetClientHandler();
    setClientDisconnectHandler(testStopDisconnect);
    if(!TEST_FALSE(startClient())) {
        return;
    } else if(!TEST_FALSE(connectClient("127.0.0.1", 54321, 90))) {
        return;
    }
    TEST_FALSE(isClientConnected());
    TEST_TRUE(isClientConnecting());
    disconnectClient(50);
    tickClientN(100);
    TEST_FALSE(isClientConnected());
    TEST_FALSE(isClientConnecting());
    TEST_TRUE(disconnected);
    stopClient();
}

static void testStop(void) {
    disconnected = false;
    resetClientHandler();
    setClientDisconnectHandler(testStopDisconnect);
    if(!TEST_FALSE(startClient())) {
        return;
    } else if(!TEST_FALSE(connectClient("127.0.0.1", 54321, 90))) {
        return;
    }
    TEST_FALSE(isClientConnected());
    TEST_TRUE(isClientConnecting());
    stopClient();
    TEST_FALSE(isClientConnected());
    TEST_FALSE(isClientConnecting());
    TEST_TRUE(disconnected);
}

static void testClientStartFails(void) {
    TEST_FALSE(startClient());
    logLevel = LOG_NONE;
    TEST_TRUE(startClient());
    stopClient();
#ifdef ERROR_SIMULATOR
    failCounter = 0;
    TEST_TRUE(startClient());
    failCounter = 1;
    TEST_TRUE(startClient());
    failCounter = -1;
#endif
    logLevel = LOG_DEBUG;
}

static void testClientConnectionFails(void) {
    resetClientHandler();
    logLevel = LOG_NONE;
    TEST_TRUE(connectClient("", 54321, 100));
    TEST_FALSE(startClient());
#ifdef ERROR_SIMULATOR
    failCounter = 0;
    TEST_TRUE(connectClient("", 54321, 100));
    failCounter = -1;
#endif
    TEST_FALSE(connectClient("", 54321, 100));
    TEST_TRUE(connectClient("", 54321, 100));
    logLevel = LOG_DEBUG;
    tickClientN(100);
    stopClient();
}

static void testInvalidClientAccess(void) {
    disconnectClient(0);
    sendClientPacket(nullptr, 0);
    tickClient();
}

static void testServerStartFails(void) {
    logLevel = LOG_NONE;
    TEST_TRUE(startServer(54321, 0));
#ifdef ERROR_SIMULATOR
    failCounter = 0;
    TEST_TRUE(startServer(54321, 5));
    failCounter = 1;
    TEST_TRUE(startServer(54321, 5));
    failCounter = -1;
#endif
    TEST_FALSE(startServer(54321, 5));
    TEST_TRUE(startServer(54321, 5));
    logLevel = LOG_DEBUG;
    stopServer();
}

static void testServerClosesOnConnected(void) {
    clientDisconnected = false;
    TEST_FALSE(startServer(54321, 5));
    TEST_FALSE(startClient());
    setClientDisconnectHandler(onClientDisconnect);
    TEST_FALSE(connectClient("127.0.0.1", 54321, 50));
    tick(100);
    TEST_TRUE(isClientConnected());
    stopServer();

    setClientTimeout(500, 500, 500);
    for(int i = 0; i < 500 && isClientConnected(); i++) {
        tickClient();
        sleepNanos(10000000);
    }
    TEST_FALSE(isClientConnected());
    TEST_TRUE(clientDisconnected);
    stopClient();
}

static Client clientId = 0;

static void onConnectSetClient(Client client) {
    clientId = client;
}

static void testServerDisconnectsClient(void) {
    clientDisconnected = false;
    TEST_FALSE(startServer(54321, 5));
    TEST_FALSE(startClient());
    setClientDisconnectHandler(onClientDisconnect);
    setServerConnectHandler(onConnectSetClient);
    TEST_FALSE(connectClient("127.0.0.1", 54321, 50));
    tick(100);
    TEST_TRUE(isClientConnected());

    disconnectServerClient(clientId);

    for(int i = 0; i < 500 && isClientConnected(); i++) {
        tickClient();
        tickServer();
        sleepNanos(10000000);
    }
    TEST_FALSE(isClientConnected());
    TEST_TRUE(clientDisconnected);
    stopClient();
    stopServer();
}

static void onConnectSetTimeout(Client client) {
    setServerTimeout(client, 500, 500, 500);
}

static void testClientClosesOnConnected(void) {
    serverDisconnect = false;
    TEST_FALSE(startServer(54321, 5));
    TEST_FALSE(startClient());
    setServerDisconnectHandler(onServerDisconnect);
    setServerConnectHandler(onConnectSetTimeout);
    TEST_FALSE(connectClient("127.0.0.1", 54321, 50));
    tick(100);
    TEST_TRUE(isClientConnected());
#ifdef ERROR_SIMULATOR
    failCounter = 0;
#endif
    stopClient();
#ifdef ERROR_SIMULATOR
    failCounter = -1;
#endif
    for(int i = 0; i < 500 && !serverDisconnect; i++) {
        tickServer();
        sleepNanos(10000000);
    }
    TEST_TRUE(serverDisconnect);
    stopServer();
}

static void testInvalidServerAccess(void) {
    tickServer();
    sendServerPacket(0, nullptr, 0);
    setServerTimeout(0, 500, 500, 500);
    disconnectServerClient(0);
}

static void testDummyCallbacks(void) {
    resetClientHandler();
    resetServerHandler();
    TEST_FALSE(startServer(54321, 5));
    TEST_FALSE(startClient());
    TEST_FALSE(connectClient("127.0.0.1", 54321, 50));
    tick(100);
    TEST_TRUE(isClientConnected());
    OutPacket out;
    initOutPacket(&out);
    sendServerPacketBroadcast(&out, PACKET_RELIABLE);
    sendClientPacket(&out, PACKET_RELIABLE);
    tick(100);
    destroyOutPacket(&out);
    stopClient();
    stopServer();
}

void testNetwork(void) {
    testWriteRead();
    testTooShortBuffer();
    testBinaryData();
    testShortString();
    testConnect(PACKET_UNSEQUENCED);
    testConnect(PACKET_SEQUENCED);
    testConnect(PACKET_RELIABLE);
    testDisconnect();
    testStop();
    testClientStartFails();
    testClientConnectionFails();
    testInvalidClientAccess();
    testServerStartFails();
    testServerClosesOnConnected();
    testServerDisconnectsClient();
    testClientClosesOnConnected();
    testInvalidServerAccess();
    testDummyCallbacks();
}