Fix the channels-udp test case.

[meshlink] / test / channels-udp.c

diff --git a/test/channels-udp.c b/test/channels-udp.c
index 0c24a9376e04f979fb80921154e1e7169f6ac863..6ed2abe63d72d2189fe49d11e5153b13e4b8e336 100644 (file)
--- a/test/channels-udp.c
+++ b/test/channels-udp.c
@@ -14,51 +14,30 @@
 #include "utils.h"
 
 static struct sync_flag accept_flag;
-static struct sync_flag close_flag;
 
 struct client {
        meshlink_handle_t *mesh;
        meshlink_channel_t *channel;
        size_t received;
        bool got_large_packet;
+       struct sync_flag close_flag;
 };
 
-static void server_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
-       (void)data;
-
-       // We expect no data from clients, apart from disconnections.
-       assert(len == 0);
-
-       meshlink_channel_t **c = mesh->priv;
-       int count = 0;
-
-       for(int i = 0; i < 3; i++) {
-               if(c[i] == channel) {
-                       c[i] = NULL;
-                       meshlink_channel_close(mesh, channel);
-               }
-
-               if(c[i]) {
-                       count++;
-               }
-       }
+static void client_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
+       assert(mesh->priv);
+       struct client *client = mesh->priv;
 
-       if(!count) {
-               set_sync_flag(&close_flag, true);
+       if(!data && !len) {
+               set_sync_flag(&client->close_flag, true);
+               meshlink_channel_close(mesh, channel);
+               return;
        }
-}
-
-static void client_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
-       (void)channel;
-       (void)data;
 
        // We expect always the same amount of data from the server.
-       assert(mesh->priv);
-       struct client *client = mesh->priv;
-       assert(len == 512 || len == 2000);
+       assert(len == 512 || len == 65536);
        client->received += len;
 
-       if(len == 2000) {
+       if(len == 65536) {
                client->got_large_packet = true;
        }
 }
@@ -80,7 +59,6 @@ static bool accept_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint
 
        assert(port == 1);
        assert(meshlink_channel_get_flags(mesh, channel) == MESHLINK_CHANNEL_UDP);
-       meshlink_set_channel_receive_cb(mesh, channel, server_receive_cb);
 
        assert(mesh->priv);
        meshlink_channel_t **c = mesh->priv;
@@ -100,7 +78,9 @@ static bool accept_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint
        return false;
 }
 
-int main() {
+int main(void) {
+       init_sync_flag(&accept_flag);
+
        meshlink_set_log_cb(NULL, MESHLINK_WARNING, log_cb);
 
        // Open four new meshlink instance, the server and three peers.
@@ -122,6 +102,7 @@ int main() {
                char dir[100];
                snprintf(dir, sizeof(dir), "channels_udp_conf.%d", i + 1);
                assert(meshlink_destroy(dir));
+               init_sync_flag(&clients[i].close_flag);
                clients[i].mesh = meshlink_open(dir, names[i], "channels-udp", DEV_CLASS_STATIONARY);
                assert(clients[i].mesh);
                clients[i].mesh->priv = &clients[i];
@@ -140,11 +121,12 @@ int main() {
                assert(clients[i].channel);
        }
 
-       // Send a packet larger than the MTU
+       // Check that we can send up to 65535 bytes without errors
 
-       char large_data[2000] = "";
+       char large_data[65536] = "";
 
        for(int i = 0; i < 3; i++) {
+               assert(meshlink_channel_send(server, channels[i], large_data, sizeof(large_data) + 1) == -1);
                assert(meshlink_channel_send(server, channels[i], large_data, sizeof(large_data)) == sizeof(large_data));
        }
 
@@ -163,17 +145,20 @@ int main() {
                }
 
                const struct timespec req = {0, 2000000};
-               clock_nanosleep(CLOCK_MONOTONIC, 0, &req, NULL);
+               nanosleep(&req, NULL);
        }
 
-       // Let the clients close the channels
+       // Shutdown the write side of the server's channels
 
        for(int i = 0; i < 3; i++) {
-               meshlink_channel_close(clients[i].mesh, clients[i].channel);
-               meshlink_set_node_status_cb(clients[i].mesh, NULL);
+               meshlink_channel_shutdown(server, channels[i], SHUT_WR);
        }
 
-       assert(wait_sync_flag(&close_flag, 10));
+       // Wait for the clients to finish reading all the data
+
+       for(int i = 0; i < 3; i++) {
+               assert(wait_sync_flag(&clients[i].close_flag, 10));
+       }
 
        // Check that the clients have received (most of) the data
 
@@ -183,7 +168,7 @@ int main() {
 
        for(int i = 0; i < 3; i++) {
                assert(clients[i].received >= 1000000);
-               assert(clients[i].received <= 1282000);
+               assert(clients[i].received <= 1345536);
                assert(clients[i].got_large_packet);
        }