Commit 498bc090 by Ramsay Jones Committed by Shawn O. Pearce

t0020-dirent.c: allow test to be run standalone

This test assumed that it was invoked in an empty directory,
which is true when run from the Makefile, and so would fail
if run standalone. In order to allow the test to work when
run from any directory, create a sub directory "dir-walk"
and chdir() into this directory while running the tests.

Also, add some additional tests.

Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
parent 502acd16
......@@ -44,6 +44,7 @@ extern void gitfo_free_buf(gitfo_buf *obj);
#define gitfo_unlink(p) unlink(p)
#define gitfo_rmdir(p) rmdir(p)
#define gitfo_chdir(p) chdir(p)
#ifdef GIT_WIN32
#define gitfo_mkdir(p,m) mkdir(p)
......
#include <stdarg.h>
#include "test_lib.h"
#include "fileops.h"
typedef struct name_data {
int count; /* return count */
char *name; /* filename */
} name_data;
typedef struct walk_data {
char *sub; /* sub-directory name */
name_data *names; /* name state data */
} walk_data;
static char path_buffer[GIT_PATH_MAX];
static int state_loc;
static const char* names[] = {
"./a",
"./asdf",
"./pack-foo.pack",
NULL
};
static char *top_dir = "dir-walk";
static walk_data *state_loc;
static int error(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fprintf(stderr, "\n");
return -1;
}
static int setup(walk_data *d)
{
name_data *n;
if (gitfo_mkdir(top_dir, 0755) < 0)
return error("can't mkdir(\"%s\")", top_dir);
if (gitfo_chdir(top_dir) < 0)
return error("can't chdir(\"%s\")", top_dir);
if (strcmp(d->sub, ".") != 0)
if (gitfo_mkdir(d->sub, 0755) < 0)
return error("can't mkdir(\"%s\")", d->sub);
strcpy(path_buffer, d->sub);
state_loc = d;
for (n = d->names; n->name; n++) {
git_file fd = gitfo_creat(n->name, 0600);
must_be_true(fd >= 0);
gitfo_close(fd);
n->count = 0;
}
return 0;
}
static int knockdown(walk_data *d)
{
name_data *n;
for (n = d->names; n->name; n++) {
if (gitfo_unlink(n->name) < 0)
return error("can't unlink(\"%s\")", n->name);
}
if (strcmp(d->sub, ".") != 0)
if (gitfo_rmdir(d->sub) < 0)
return error("can't rmdir(\"%s\")", d->sub);
if (gitfo_chdir("..") < 0)
return error("can't chdir(\"..\")");
if (gitfo_rmdir(top_dir) < 0)
return error("can't rmdir(\"%s\")", top_dir);
return 0;
}
static int check_counts(walk_data *d)
{
int ret = 0;
name_data *n;
for (n = d->names; n->name; n++) {
if (n->count != 1)
ret = error("count (%d, %s)", n->count, n->name);
}
return ret;
}
static int one_entry(void *state, char *path)
{
const char **c;
walk_data *d = (walk_data *) state;
name_data *n;
must_be_true(state == &state_loc);
must_be_true(state == state_loc);
must_be_true(path == path_buffer);
for (c = names; *c; c++) {
if (!strcmp(*c, path)) {
*c = "";
for (n = d->names; n->name; n++) {
if (!strcmp(n->name, path)) {
n->count++;
return 0;
}
}
test_die("unexpected path \"%s\"", path);
}
BEGIN_TEST(setup)
const char **c;
for (c = names; *c; c++) {
git_file fd = gitfo_creat(*c, 0600);
must_be_true(fd >= 0);
gitfo_close(fd);
}
static name_data dot_names[] = {
{ 0, "./a" },
{ 0, "./asdf" },
{ 0, "./pack-foo.pack" },
{ 0, NULL }
};
static walk_data dot = {
".",
dot_names
};
BEGIN_TEST(dot)
must_pass(setup(&dot));
must_pass(gitfo_dirent(path_buffer,
sizeof(path_buffer),
one_entry,
&dot));
must_pass(check_counts(&dot));
must_pass(knockdown(&dot));
END_TEST
static name_data sub_names[] = {
{ 0, "sub/a" },
{ 0, "sub/asdf" },
{ 0, "sub/pack-foo.pack" },
{ 0, NULL }
};
static walk_data sub = {
"sub",
sub_names
};
BEGIN_TEST(sub)
must_pass(setup(&sub));
must_pass(gitfo_dirent(path_buffer,
sizeof(path_buffer),
one_entry,
&sub));
must_pass(check_counts(&sub));
must_pass(knockdown(&sub));
END_TEST
static walk_data sub_slash = {
"sub/",
sub_names
};
BEGIN_TEST(sub_slash)
must_pass(setup(&sub_slash));
must_pass(gitfo_dirent(path_buffer,
sizeof(path_buffer),
one_entry,
&sub_slash));
must_pass(check_counts(&sub_slash));
must_pass(knockdown(&sub_slash));
END_TEST
BEGIN_TEST(direent_walk)
const char **c;
static name_data empty_names[] = {
{ 0, NULL }
};
static walk_data empty = {
"empty",
empty_names
};
static int dont_call_me(void *state, char *path)
{
test_die("dont_call_me: unexpected callback!");
}
BEGIN_TEST(empty)
must_pass(setup(&empty));
must_pass(gitfo_dirent(path_buffer,
sizeof(path_buffer),
one_entry,
&empty));
must_pass(check_counts(&empty));
/* make sure callback not called */
must_pass(gitfo_dirent(path_buffer,
sizeof(path_buffer),
dont_call_me,
&empty));
must_pass(knockdown(&empty));
END_TEST
static name_data odd_names[] = {
{ 0, "odd/.a" },
{ 0, "odd/..c" },
/* the following don't work on cygwin/win32 */
/* { 0, "odd/.b." }, */
/* { 0, "odd/..d.." }, */
{ 0, NULL }
};
static walk_data odd = {
"odd",
odd_names
};
BEGIN_TEST(odd)
must_pass(setup(&odd));
strcpy(path_buffer, ".");
must_pass(gitfo_dirent(path_buffer,
sizeof(path_buffer),
one_entry,
&state_loc));
&odd));
must_pass(check_counts(&odd));
for (c = names; *c; c++)
must_pass(strcmp("", *c));
must_pass(knockdown(&odd));
END_TEST
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment