tests: make functions static in test_utils_expand_path.c

[lttng-tools.git] / tests / unit / test_utils_expand_path.c

diff --git a/tests/unit/test_utils_expand_path.c b/tests/unit/test_utils_expand_path.c
index aa7984b4026b38e4385f11d26b07545444c9bb1c..e0cd366132b8184b7f4e8e362507cdd3f31660ac 100644 (file)
--- a/tests/unit/test_utils_expand_path.c
+++ b/tests/unit/test_utils_expand_path.c
@@ -53,6 +53,7 @@ struct symlink_test_input {
 /* Valid test cases */
 static struct valid_test_input valid_tests_inputs[] = {
        { "/a/b/c/d/e",                 "",             "/a/b/c/d/e"    },
+       { "/a//b//c/d/e",               "",             "/a/b/c/d/e"    },
        { "./a/b/c/d/e",                ".",            "/a/b/c/d/e"    },
        { "../a/b/c/d/../e",            "..",           "/a/b/c/e"      },
        { ".././a/b/c/d/./e",           "..",           "/a/b/c/d/e"    },
@@ -119,14 +120,10 @@ static char *invalid_tests_inputs[] = {
 static const int num_invalid_tests =
                sizeof(invalid_tests_inputs) / sizeof(invalid_tests_inputs[0]);
 
-#define ERRSIZE 100
-char errmsg[ERRSIZE];
-static void printerr(char *msg)
-{
-       fprintf(stderr, "test_utils_expand_path: error: %s\n", msg);
-}
+#define PRINT_ERR(fmt, args...)                                                \
+       fprintf(stderr, "test_utils_expand_path: error: " fmt "\n", ## args)
 
-int prepare_valid_results(void)
+static int prepare_valid_results(void)
 {
        int i;
        char *relative, *cur_path = NULL, *prev_path = NULL,
@@ -139,7 +136,7 @@ int prepare_valid_results(void)
        pprev_path = realpath("../..", NULL);
        empty = strdup("");
        if (!cur_path || !prev_path || !pprev_path || !empty) {
-               printerr("strdup out of memory");
+               PRINT_ERR("strdup out of memory");
                ret = -1;
                goto end;
        }
@@ -147,14 +144,14 @@ int prepare_valid_results(void)
        /* allocate memory for the expected results */
        valid_tests_expected_results = zmalloc(sizeof(char *) * num_valid_tests);
        if (!valid_tests_expected_results) {
-               printerr("out of memory");
+               PRINT_ERR("out of memory");
                ret = -1;
                goto end;
        }
        for (i = 0; i < num_valid_tests; i++) {
                valid_tests_expected_results[i] = malloc(PATH_MAX);
                if (valid_tests_expected_results[i] == NULL) {
-                       printerr("malloc expected results");
+                       PRINT_ERR("malloc expected results");
                        ret = -1;
                        goto end;
                }
@@ -182,7 +179,7 @@ end:
        return ret;
 }
 
-int free_valid_results(void)
+static int free_valid_results(void)
 {
        int i;
 
@@ -195,37 +192,36 @@ int free_valid_results(void)
        return 0;
 }
 
-int prepare_symlink_tree(void)
+static int prepare_symlink_tree(void)
 {
        int i;
-       char tmppath[PATH_MAX];
+       char tmppath[PATH_MAX] = {};
 
        /* Create the temporary directory */
        if (mkdtemp(tree_origin) == NULL) {
-               printerr("mkdtemp");
+               PRINT_ERR("failed to mkdtemp");
                goto error;
        }
 
        /* Create the directories of the test tree */
        for (i = 0; i < num_tree_dirs; i++) {
-               snprintf(tmppath, PATH_MAX, "%s/%s", tree_origin, tree_dirs[i]);
+               snprintf(tmppath, sizeof(tmppath), "%s/%s", tree_origin,
+                               tree_dirs[i]);
 
                if (mkdir(tmppath, 0755) != 0) {
-                       snprintf(errmsg, ERRSIZE, "mkdir %s", tmppath);
-                       printerr(errmsg);
+                       PRINT_ERR("mkdir failed with path \"%s\"", tmppath);
                        goto error;
                }
        }
 
        /* Create the symlinks of the test tree */
        for (i = 0; i < num_tree_symlinks; i++) {
-               snprintf(tmppath, PATH_MAX, "%s/%s",
+               snprintf(tmppath, sizeof(tmppath), "%s/%s",
                                tree_origin, tree_symlinks[i].orig);
 
                if (symlink(tree_symlinks[i].dest, tmppath) != 0) {
-                       snprintf(errmsg, ERRSIZE, "symlink %s to %s",
-                                       tmppath, tree_symlinks[i].dest);
-                       printerr(errmsg);
+                       PRINT_ERR("failed to symlink \"%s\" to \"%s\"", tmppath,
+                                       tree_symlinks[i].dest);
                        goto error;
                }
        }
@@ -236,7 +232,7 @@ error:
        return 1;
 }
 
-int free_symlink_tree(void)
+static int free_symlink_tree(void)
 {
        int i;
        char tmppath[PATH_MAX];
@@ -247,8 +243,7 @@ int free_symlink_tree(void)
                                tree_origin, tree_symlinks[i].orig);
 
                if (unlink(tmppath) != 0) {
-                       snprintf(errmsg, ERRSIZE, "unlink %s", tmppath);
-                       printerr(errmsg);
+                       PRINT_ERR("failed to unlink \"%s\"", tmppath);
                        goto error;
                }
        }
@@ -258,16 +253,14 @@ int free_symlink_tree(void)
                snprintf(tmppath, PATH_MAX, "%s/%s", tree_origin, tree_dirs[i]);
 
                if (rmdir(tmppath) != 0) {
-                       snprintf(errmsg, ERRSIZE, "rmdir %s", tmppath);
-                       printerr(errmsg);
+                       PRINT_ERR("failed to rmdir \"%s\"", tmppath);
                        goto error;
                }
        }
 
        /* Remove the temporary directory */
        if (rmdir(tree_origin) != 0) {
-               snprintf(errmsg, ERRSIZE, "rmdir %s", tree_origin);
-               printerr(errmsg);
+               PRINT_ERR("failed to rmdir \"%s\"", tree_origin);
                goto error;
        }
 
@@ -280,8 +273,8 @@ error:
 static void test_utils_expand_path(void)
 {
        char *result;
-       char name[100], tmppath[PATH_MAX];
-       int i;
+       char name[100], tmppath[PATH_MAX], real_tree_origin[PATH_MAX];
+       int i, treelen;
 
        /* Test valid cases */
        for (i = 0; i < num_valid_tests; i++) {
@@ -294,14 +287,34 @@ static void test_utils_expand_path(void)
                free(result);
        }
 
+       /*
+        * Get the realpath for the tree_origin since it can itself be a
+        * symlink.
+        */
+       result = realpath(tree_origin, real_tree_origin);
+       if (!result) {
+               fail("realpath failed.");
+               return;
+       }
+
        /* Test symlink tree cases */
-       int treelen = strlen(tree_origin) + 1;
+       treelen = strlen(real_tree_origin) + 1;
        for (i = 0; i < num_symlink_tests; i++) {
+               int ret;
+
                sprintf(name, "symlink tree test case: [tmppath/]%s",
                                symlink_tests_inputs[i].input);
 
-               snprintf(tmppath, PATH_MAX, "%s/%s",
-                               tree_origin, symlink_tests_inputs[i].input);
+               ret = snprintf(tmppath, PATH_MAX, "%s/%s",
+                               real_tree_origin,
+                               symlink_tests_inputs[i].input);
+               if (ret == -1 || ret >= PATH_MAX) {
+                       PRINT_ERR("truncation occurred while concatenating paths \"%s\" and \"%s\"",
+                                       real_tree_origin,
+                                       symlink_tests_inputs[i].input);
+                       fail(name);
+                       continue;
+               }
                result = utils_expand_path(tmppath);
                ok(result != NULL && strcmp(result + treelen,
                                        symlink_tests_inputs[i].expected_result) == 0, name);