Full coverage of network

include/core/Network.h

@@ -74,6 +74,8 @@ void coreServerTick(void);
 void coreServerSendAll(const CoreOutPacket* p, CorePacketSendMode mode);
 void coreServerSend(CoreClient client, const CoreOutPacket* p,
                     CorePacketSendMode mode);
+void coreServerTimeout(CoreClient client, u32 timeout, u32 timeoutMin,
+                       u32 timeoutMax);
 void coreServerDisconnect(CoreClient client);
 void coreServerSetConnectHandler(CoreServerOnConnect oc);
 void coreServerSetDisconnectHandler(CoreServerOnDisconnect od);

src/Network.c

@@ -1,6 +1,7 @@
 #include "core/Network.h"
 
 #define ENET_IMPLEMENTATION
+#include <assert.h>
 #include <core/HashMap.h>
 #include <core/Logger.h>
 #include <core/Utility.h>
@@ -247,7 +248,8 @@ bool coreClientStart(void) {
 void coreClientStop(void) {
     if(client.connection != nullptr) {
         client.onDisconnect();
-        enet_peer_disconnect_now(client.connection, 0);
+        CORE_FAIL(enet_peer_disconnect_now(client.connection, 0),
+                  enet_peer_reset(client.connection));
         client.connection = nullptr;
     }
     if(client.client != nullptr) {
@@ -449,6 +451,7 @@ static void writeId(ENetPeer* peer, CoreClient id) {
 }
 
 static CoreClient getId(ENetPeer* peer) {
+    assert(peer->data != nullptr);
     CoreClient id = -1;
     memcpy(&id, &(peer->data), sizeof(id));
     return id;
@@ -456,20 +459,13 @@ static CoreClient getId(ENetPeer* peer) {
 
 static void handleConnect(ENetEvent* e) {
     CoreClient id = server.idCounter++;
-    if(coreHashMapContains(&server.clients, CoreClient, id)) {
-        CORE_LOG_WARNING("Id is connected twice");
-        return;
-    }
+    assert(!coreHashMapContains(&server.clients, CoreClient, id));
     coreHashMapPut(&server.clients, CoreClient, id, ENetPeer*, e->peer);
     writeId(e->peer, id);
     server.onConnect(id);
 }
 
 static void handlePacket(ENetEvent* e) {
-    if(e->peer->data == nullptr) {
-        CORE_LOG_WARNING("Client without data sent package");
-        return;
-    }
     CoreClient id = getId(e->peer);
     CoreInPacket in;
     coreInitInPacket(&in, e->packet->data, e->packet->dataLength);
@@ -477,15 +473,9 @@ static void handlePacket(ENetEvent* e) {
 }
 
 static void handleDisconnect(ENetEvent* e) {
-    if(e->peer->data == nullptr) {
-        CORE_LOG_WARNING("Client without data disconnected");
-        return;
-    }
     CoreClient id = getId(e->peer);
     server.onDisconnect(id);
-    if(!coreHashMapRemove(&server.clients, CoreClient, id)) {
-        CORE_LOG_WARNING("Removed non existing client");
-    }
+    coreHashMapRemove(&server.clients, CoreClient, id);
 }
 
 void coreServerTick(void) {
@@ -493,7 +483,7 @@ void coreServerTick(void) {
         return;
     }
     ENetEvent e;
-    while(enet_host_service(server.server, &e, 0) > 0) {
+    while(enet_host_service(server.server, &e, 0) >= 0) {
         switch(e.type) {
             case ENET_EVENT_TYPE_CONNECT: handleConnect(&e); break;
             case ENET_EVENT_TYPE_RECEIVE:
@@ -532,6 +522,17 @@ void coreServerSend(CoreClient clientId, const CoreOutPacket* p,
     }
 }
 
+void coreServerTimeout(CoreClient clientId, u32 timeout, u32 timeoutMin,
+                       u32 timeoutMax) {
+    if(server.server == nullptr) {
+        return;
+    }
+    ENetPeer** peer = coreHashMapSearchPointer(&server.clients, &clientId);
+    if(peer != nullptr) {
+        enet_peer_timeout(*peer, timeout, timeoutMin, timeoutMax);
+    }
+}
+
 void coreServerDisconnect(CoreClient clientId) {
     if(server.server == nullptr) {
         return;

test/modules/NetworkTests.c

@@ -392,17 +392,55 @@ static void testServerClosesOnConnected(void) {
     coreClientStop();
 }
 
+static CoreClient clientId = 0;
+
+static void onConnectSetClient(CoreClient client) {
+    clientId = client;
+}
+
+static void testServerDisconnectsClient(void) {
+    clientDisconnected = false;
+    CORE_TEST_FALSE(coreServerStart(54321, 5));
+    CORE_TEST_FALSE(coreClientStart());
+    coreClientSetDisconnectHandler(onClientDisconnect);
+    coreServerSetConnectHandler(onConnectSetClient);
+    CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 50));
+    tick(100);
+    CORE_TEST_TRUE(coreClientIsConnected());
+
+    coreServerDisconnect(clientId);
+
+    for(int i = 0; i < 500 && coreClientIsConnected(); i++) {
+        coreClientTick();
+        coreServerTick();
+        coreSleep(10000000);
+    }
+    CORE_TEST_FALSE(coreClientIsConnected());
+    CORE_TEST_TRUE(clientDisconnected);
+    coreClientStop();
+    coreServerStop();
+}
+
+static void onConnectSetTimeout(CoreClient client) {
+    coreServerTimeout(client, 500, 500, 500);
+}
+
 static void testClientClosesOnConnected(void) {
     serverDisconnect = false;
     CORE_TEST_FALSE(coreServerStart(54321, 5));
     CORE_TEST_FALSE(coreClientStart());
     coreServerSetDisconnectHandler(onServerDisconnect);
+    coreServerSetConnectHandler(onConnectSetTimeout);
     CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 50));
     tick(100);
     CORE_TEST_TRUE(coreClientIsConnected());
+#ifdef ERROR_SIMULATOR
+    coreFailCounter = 0;
+#endif
     coreClientStop();
-
-    // coreServerTimeout(500, 500, 500);
+#ifdef ERROR_SIMULATOR
+    coreFailCounter = -1;
+#endif
     for(int i = 0; i < 500 && !serverDisconnect; i++) {
         coreServerTick();
         coreSleep(10000000);
@@ -411,6 +449,31 @@ static void testClientClosesOnConnected(void) {
     coreServerStop();
 }
 
+static void testInvalidServerAccess(void) {
+    coreServerTick();
+    coreServerSend(0, nullptr, 0);
+    coreServerTimeout(0, 500, 500, 500);
+    coreServerDisconnect(0);
+}
+
+static void testDummyCallbacks(void) {
+    coreClientResetHandler();
+    coreServerResetHandler();
+    CORE_TEST_FALSE(coreServerStart(54321, 5));
+    CORE_TEST_FALSE(coreClientStart());
+    CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 50));
+    tick(100);
+    CORE_TEST_TRUE(coreClientIsConnected());
+    CoreOutPacket out;
+    coreInitOutPacket(&out);
+    coreServerSendAll(&out, CORE_RELIABLE);
+    coreClientSend(&out, CORE_RELIABLE);
+    tick(100);
+    coreDestroyOutPacket(&out);
+    coreClientStop();
+    coreServerStop();
+}
+
 void coreTestNetwork(void) {
     testWriteRead();
     testTooShortBuffer();
@@ -426,5 +489,8 @@ void coreTestNetwork(void) {
     testInvalidClientAccess();
     testServerStartFails();
     testServerClosesOnConnected();
+    testServerDisconnectsClient();
     testClientClosesOnConnected();
+    testInvalidServerAccess();
+    testDummyCallbacks();
 }