X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=test%2Fbasic.c;h=004e7186437fdc2b9fe8c3e64391eefb81523890;hb=4b6c01b1d5383b1a7417244a31ad4652aab2d5db;hp=33d9297477de39f5e9cd9873590b83b02c8535a7;hpb=cdb3dada645394bb1e0d0bf7816291fbd9a2a4a0;p=meshlink diff --git a/test/basic.c b/test/basic.c index 33d92974..004e7186 100644 --- a/test/basic.c +++ b/test/basic.c @@ -1,131 +1,155 @@ +#ifdef NDEBUG +#undef NDEBUG +#endif + #include #include #include #include #include +#include +#include #include "meshlink.h" +#include "utils.h" -void log_cb(meshlink_handle_t *mesh, meshlink_log_level_t level, const char *text) { - static struct timeval tv0; - struct timeval tv; +int main(void) { + meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb); - if(tv0.tv_sec == 0) { - gettimeofday(&tv0, NULL); - } + // Check that the first time we need to supply a name - gettimeofday(&tv, NULL); - fprintf(stderr, "%u.%.03u ", (unsigned int)(tv.tv_sec - tv0.tv_sec), (unsigned int)tv.tv_usec / 1000); + assert(meshlink_destroy("basic_conf")); - if(mesh) { - fprintf(stderr, "(%s) ", mesh->name); - } + meshlink_handle_t *mesh = meshlink_open("basic_conf", NULL, "basic", DEV_CLASS_BACKBONE); + assert(!mesh); - fprintf(stderr, "[%d] %s\n", level, text); -} + // Open a new meshlink instance. -int main() { - meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb); + mesh = meshlink_open("basic_conf", "foo", "basic", DEV_CLASS_BACKBONE); + assert(mesh); - // Open a new meshlink instance. + // Check that we can't open a second instance of the same node. - meshlink_handle_t *mesh = meshlink_open("basic_conf", "foo", "basic", DEV_CLASS_BACKBONE); + meshlink_handle_t *mesh2 = meshlink_open("basic_conf", "foo", "basic", DEV_CLASS_BACKBONE); + assert(!mesh2); - if(!mesh) { - fprintf(stderr, "Could not initialize configuration for foo\n"); - return 1; - } + // Check that we cannot destroy an instance that is in use. - meshlink_set_log_cb(mesh, MESHLINK_DEBUG, log_cb); + assert(!meshlink_destroy("basic_conf")); // Check that our own node exists. meshlink_node_t *self = meshlink_get_self(mesh); + assert(self); + assert(!strcmp(self->name, "foo")); - if(!self) { - fprintf(stderr, "Foo does not know about itself\n"); - return 1; - } + // Check that we are not reachable. - if(strcmp(self->name, "foo")) { - fprintf(stderr, "Foo thinks its name is %s\n", self->name); - return 1; - } + time_t last_reachable; + time_t last_unreachable; + assert(!meshlink_get_node_reachability(mesh, self, &last_reachable, &last_unreachable)); + assert(!last_reachable); + assert(!last_unreachable); // Start and stop the mesh. - if(!meshlink_start(mesh)) { - fprintf(stderr, "Foo could not start\n"); - return 1; - } + assert(meshlink_start(mesh)); + + // Check that we are now reachable + + assert(meshlink_get_node_reachability(mesh, self, &last_reachable, &last_unreachable)); + assert(last_reachable); + assert(!last_unreachable); meshlink_stop(mesh); - // Make sure we can start and stop the mesh again. + // Check that we are no longer reachable. - if(!meshlink_start(mesh)) { - fprintf(stderr, "Foo could not start twice\n"); - return 1; - } + assert(!meshlink_get_node_reachability(mesh, self, &last_reachable, &last_unreachable)); + assert(last_reachable); + assert(last_unreachable); + // Make sure we can start and stop the mesh again. + + assert(meshlink_start(mesh)); + assert(meshlink_start(mesh)); + meshlink_stop(mesh); meshlink_stop(mesh); // Close the mesh and open it again, now with a different name parameter. meshlink_close(mesh); - - // Check that the name is ignored now, and that we still are "foo". - mesh = meshlink_open("basic_conf", "bar", "basic", DEV_CLASS_BACKBONE); + assert(!mesh); - if(!mesh) { - fprintf(stderr, "Could not open configuration for foo a second time\n"); - return 1; - } - - meshlink_set_log_cb(mesh, MESHLINK_DEBUG, log_cb); + // Open it without providing a name - if(meshlink_get_node(mesh, "bar")) { - fprintf(stderr, "Foo knows about bar, it shouldn't\n"); - return 1; - } + mesh = meshlink_open("basic_conf", NULL, "basic", DEV_CLASS_BACKBONE); + assert(mesh); self = meshlink_get_self(mesh); + assert(self); + assert(!strcmp(mesh->name, "foo")); + assert(!strcmp(self->name, "foo")); - if(!self) { - fprintf(stderr, "Foo doesn't know about itself the second time\n"); - return 1; - } + // Check that we remembered we were reachable - if(strcmp(self->name, "foo")) { - fprintf(stderr, "Foo thinks its name is %s the second time\n", self->name); - return 1; - } + assert(!meshlink_get_node_reachability(mesh, self, &last_reachable, &last_unreachable)); + assert(last_reachable); + assert(last_unreachable); - // Start and stop the mesh. + // Check that the name is ignored now, and that we still are "foo". - if(!meshlink_start(mesh)) { - fprintf(stderr, "Foo could not start a third time\n"); - return 1; - } + assert(!meshlink_get_node(mesh, "bar")); + self = meshlink_get_self(mesh); + assert(self); + assert(!strcmp(self->name, "foo")); + + // Start and stop the mesh. + assert(meshlink_start(mesh)); meshlink_stop(mesh); + meshlink_close(mesh); + + // Check that messing with the config directory will create a new instance. - // That's it. + assert(unlink("basic_conf/current/meshlink.conf") == 0); + mesh = meshlink_open("basic_conf", "bar", "basic", DEV_CLASS_BACKBONE); + assert(mesh); + assert(!meshlink_get_node(mesh, "foo")); + self = meshlink_get_self(mesh); + assert(self); + assert(!strcmp(self->name, "bar")); + assert(access("basic_conf/new", X_OK) == -1 && errno == ENOENT); + meshlink_close(mesh); + assert(rename("basic_conf/current", "basic_conf/new") == 0); + mesh = meshlink_open("basic_conf", "baz", "basic", DEV_CLASS_BACKBONE); + assert(mesh); + assert(!meshlink_get_node(mesh, "bar")); + self = meshlink_get_self(mesh); + assert(self); + assert(!strcmp(self->name, "baz")); + assert(access("basic_conf/new", X_OK) == -1 && errno == ENOENT); meshlink_close(mesh); // Destroy the mesh. - if(!meshlink_destroy("basic_conf")) { - fprintf(stderr, "Could not destroy configuration\n"); - return 1; - } + assert(meshlink_destroy("basic_conf")); + + // Check that the configuration directory is completely empty. + + DIR *dir = opendir("basic_conf"); + assert(dir); + struct dirent *ent; - if(!access("basic_conf", F_OK) || errno != ENOENT) { - fprintf(stderr, "Configuration not fully destroyed\n"); - return 1; + while((ent = readdir(dir))) { + assert(!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, "..")); } - return 0; + closedir(dir); + + // Check that we can destroy it again. + + assert(meshlink_destroy("basic_conf")); }