#include <tap/tap.h>
-#include <common/utils.h>
-#include <common/common.h>
+#include <common/utils.hpp>
+#include <common/path.hpp>
+#include <common/common.hpp>
/* For error.h */
int lttng_opt_quiet = 1;
int lttng_opt_verbose = 3;
int lttng_opt_mi;
+namespace {
struct valid_test_input {
const char *input;
const char *relative_part;
};
/* Valid test cases */
-static struct valid_test_input valid_tests_inputs[] = {
+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/..", "", "/" },
};
char **valid_tests_expected_results;
-static const int num_valid_tests =
+const int num_valid_tests =
sizeof(valid_tests_inputs) / sizeof(valid_tests_inputs[0]);
/* Symlinks test cases */
char tree_origin[] = "/tmp/test_utils_expand_path.XXXXXX";
-static const char * const tree_dirs[] = {
+const char * const tree_dirs[] = {
"a",
"a/b",
"a/b/c",
"a/e",
};
-static const int num_tree_dirs =
+const int num_tree_dirs =
sizeof(tree_dirs) / sizeof(tree_dirs[0]);
-static struct tree_symlink tree_symlinks[] = {
+struct tree_symlink tree_symlinks[] = {
{ "a/d", "b/c/" },
{ "a/g", "d/" },
{ "a/b/f", "../e/" },
{ "a/b/k", "c/g/" },
{ "a/b/c/g", "../../../" },
};
-static const int num_tree_symlinks =
+const int num_tree_symlinks =
sizeof(tree_symlinks) / sizeof(tree_symlinks[0]);
static struct symlink_test_input symlink_tests_inputs[] = {
{ "a/g/../l/../", "a/b/" },
{ "a/b/h/g/", "" },
};
-static const int num_symlink_tests =
+const int num_symlink_tests =
sizeof(symlink_tests_inputs) / sizeof(symlink_tests_inputs[0]);
/* Invalid test cases */
-static char *invalid_tests_inputs[] = {
+char *invalid_tests_inputs[] = {
NULL,
};
-static const int num_invalid_tests =
+const int num_invalid_tests =
sizeof(invalid_tests_inputs) / sizeof(invalid_tests_inputs[0]);
+} /* namespace */
#define PRINT_ERR(fmt, args...) \
fprintf(stderr, "test_utils_expand_path: error: " fmt "\n", ## args)
}
/* allocate memory for the expected results */
- valid_tests_expected_results = (char **) zmalloc(sizeof(char *) * num_valid_tests);
+ valid_tests_expected_results = calloc<char *>(num_valid_tests);
if (!valid_tests_expected_results) {
PRINT_ERR("out of memory");
ret = -1;
goto end;
}
for (i = 0; i < num_valid_tests; i++) {
- valid_tests_expected_results[i] = (char *) malloc(PATH_MAX);
+ valid_tests_expected_results[i] = calloc<char>(PATH_MAX);
if (valid_tests_expected_results[i] == NULL) {
PRINT_ERR("malloc expected results");
ret = -1;
result = utils_expand_path(valid_tests_inputs[i].input);
ok(result != NULL &&
- strcmp(result, valid_tests_expected_results[i]) == 0, name);
+ strcmp(result, valid_tests_expected_results[i]) == 0, "%s", name);
free(result);
}
PRINT_ERR("truncation occurred while concatenating paths \"%s\" and \"%s\"",
real_tree_origin,
symlink_tests_inputs[i].input);
- fail(name);
+ fail("%s", name);
continue;
}
result = utils_expand_path(tmppath);
ok(result != NULL && strcmp(result + treelen,
- symlink_tests_inputs[i].expected_result) == 0, name);
+ symlink_tests_inputs[i].expected_result) == 0, "%s", name);
free(result);
}
if (result != NULL) {
free(result);
}
- ok(result == NULL, name);
+ ok(result == NULL, "%s", name);
}
}
-int main(int argc, char **argv)
+int main(void)
{
if (prepare_symlink_tree() != 0) {
goto error_mkdir;