Network packages and tests

src/Network.c

@@ -66,7 +66,7 @@ bool coreInPacketReadFloat(CoreInPacket* in, float* f) {
     if(coreInPacketReadU32(in, &u)) {
         return true;
     }
-    memcpy(&f, &u, sizeof(float));
+    memcpy(f, &u, sizeof(float));
     return false;
 }
 
@@ -79,14 +79,17 @@ size_t coreInPacketReadString(CoreInPacket* in, char* buffer, size_t n) {
         return 0;
     }
     size_t end = size;
+    char* bufferStart = buffer;
     n--;
     while(n-- > 0 && end-- > 0) {
         u8 u;
         if(coreInPacketReadU8(in, &u)) {
+            *bufferStart = '\0';
             break;
         }
         *(buffer++) = (char)u;
     }
+    while(end-- > 0 && !coreInPacketReadU8(in, &(u8){0})) {}
     *buffer = '\0';
     return size;
 }

tasks

@@ -141,7 +141,7 @@ if $install; then
 fi
 
 function runTests() {
-    LLVM_PROFILE_FILE="default.profraw" $valgrind ./test $valgrind || true
+    LLVM_PROFILE_FILE="default.profraw" $valgrind ./test wusi $valgrind || true
 }
 
 if $test_debug; then

test/Main.c

@@ -1,4 +1,5 @@
 #include <core/Logger.h>
+#include <core/Utility.h>
 
 #include "Tests.h"
 // #include "core/Window.h"
@@ -25,6 +26,7 @@ int main(int argAmount, char** args) {
     }
     coreTestImageReader(args[1]);
     coreTestNetwork();
+    coreFinalizeTests();
 
     // Window::Options options(4, 3, {800, 480}, false, "Test");
     // Error error = Window::open(options);
@@ -35,6 +37,6 @@ int main(int argAmount, char** args) {
     // Window::show();
     // Window::run<isRunning, tick, render>(50'000'000);
     // Window::close();
-
+    corePrintMemoryReport();
     return 0;
 }

test/modules/NetworkTests.c

@@ -1,4 +1,122 @@
+#include <string.h>
+
 #include "../Tests.h"
+#include "core/Network.h"
+
+#define TEST_READ(Type, type, value)                                           \
+    {                                                                          \
+        type u;                                                                \
+        CORE_TEST_FALSE(coreInPacketRead##Type(&in, &u));                      \
+        CORE_TEST_TRUE(u == value);                                            \
+    }
+
+static void testWriteRead(void) {
+    CoreOutPacket out;
+    coreInitOutPacket(&out);
+    coreOutPacketWriteU8(&out, 200);
+    coreOutPacketWriteU16(&out, 6656);
+    coreOutPacketWriteU32(&out, 348923689);
+    coreOutPacketWriteI8(&out, 90);
+    coreOutPacketWriteI8(&out, -35);
+    coreOutPacketWriteI16(&out, 843);
+    coreOutPacketWriteI16(&out, -8961);
+    coreOutPacketWriteI32(&out, 100430199);
+    coreOutPacketWriteI32(&out, -534534);
+    coreOutPacketWriteFloat(&out, 64564.5346f);
+    const char s[] = "This is Great";
+    coreOutPacketWriteString(&out, s, sizeof(s));
+
+    CoreInPacket in;
+    coreInitInPacket(&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;
+    CORE_TEST_FALSE(coreInPacketReadFloat(&in, &f));
+    CORE_TEST_FLOAT(64564.5346f, f, 0.00001f);
+    char buffer[256];
+    size_t n = coreInPacketReadString(&in, buffer, sizeof(buffer));
+    CORE_TEST_SIZE(14, n);
+    CORE_TEST_STRING(s, buffer);
+
+    CORE_TEST_TRUE(coreInPacketReadU8(&in, &(u8){0}));
+    CORE_TEST_TRUE(coreInPacketReadU16(&in, &(u16){0}));
+    CORE_TEST_TRUE(coreInPacketReadU32(&in, &(u32){0}));
+    CORE_TEST_TRUE(coreInPacketReadI8(&in, &(i8){0}));
+    CORE_TEST_TRUE(coreInPacketReadI16(&in, &(i16){0}));
+    CORE_TEST_TRUE(coreInPacketReadI32(&in, &(i32){0}));
+    CORE_TEST_TRUE(coreInPacketReadFloat(&in, &(float){0}));
+    CORE_TEST_SIZE(0, coreInPacketReadString(&in, nullptr, 0));
+    CORE_TEST_SIZE(0, coreInPacketReadString(&in, buffer, sizeof(buffer)));
+
+    coreDestroyOutPacket(&out);
+}
+
+static void testTooShortBuffer(void) {
+    CoreOutPacket out;
+    coreInitOutPacket(&out);
+    const char s[] = "This is Great";
+    coreOutPacketWriteString(&out, s, sizeof(s));
+    const char s2[] = "Well hoho";
+    coreOutPacketWriteString(&out, s2, sizeof(s2));
+
+    CoreInPacket in;
+    coreInitInPacket(&in, out.data.buffer, out.data.size);
+    char buffer[8];
+    size_t n = coreInPacketReadString(&in, buffer, sizeof(buffer));
+    CORE_TEST_SIZE(14, n);
+    CORE_TEST_STRING("This is", buffer);
+    char buffer2[6];
+    size_t n2 = coreInPacketReadString(&in, buffer2, sizeof(buffer2));
+    CORE_TEST_SIZE(10, n2);
+    CORE_TEST_STRING("Well ", buffer2);
+
+    coreDestroyOutPacket(&out);
+}
+
+typedef struct {
+    u8 a;
+    u8 b;
+} PacketTest;
+
+static void testBinaryData(void) {
+    CoreOutPacket out;
+    coreInitOutPacket(&out);
+    PacketTest data = {56, 3};
+    coreOutPacketWrite(&out, &data, sizeof(data));
+
+    CoreInPacket in;
+    coreInitInPacket(&in, out.data.buffer, out.data.size);
+
+    PacketTest inData;
+    CORE_TEST_FALSE(coreInPacketRead(&in, &inData, sizeof(inData)));
+    CORE_TEST_TRUE(memcmp(&inData, &data, sizeof(inData)) == 0);
+
+    coreDestroyOutPacket(&out);
+}
+
+static void testShortString(void) {
+    CoreOutPacket out;
+    coreInitOutPacket(&out);
+    coreOutPacketWriteU16(&out, 200);
+    coreOutPacketWriteU16(&out, 65535);
+
+    CoreInPacket in;
+    coreInitInPacket(&in, out.data.buffer, out.data.size);
+
+    char buffer[256];
+    size_t n = coreInPacketReadString(&in, buffer, sizeof(buffer));
+    CORE_TEST_SIZE(200, n);
+    CORE_TEST_STRING("", buffer);
+
+    coreDestroyOutPacket(&out);
+}
 
 /*static bool checkError(Test& test, const Error e, const char* msg) {
     if(e.has()) {
@@ -202,6 +320,10 @@ static void testStop(Test& test) {
 }*/
 
 void coreTestNetwork() {
+    testWriteRead();
+    testTooShortBuffer();
+    testBinaryData();
+    testShortString();
     // testConnect(test, PacketSendMode::UNSEQUENCED);
     // testConnect(test, PacketSendMode::RELIABLE);
     // testConnect(test, PacketSendMode::SEQUENCED);