tests/t0020-dirent.c

   1 #include <stdarg.h>
   2 #include "test_lib.h"
   3 #include "fileops.h"
   4
   5
   6 typedef struct name_data {
   7         int  count;  /* return count */
   8         char *name;  /* filename     */
   9 } name_data;
  10
  11 typedef struct walk_data {
  12         char *sub;        /* sub-directory name */
  13         name_data *names; /* name state data    */
  14 } walk_data;
  15
  16
  17 static char path_buffer[GIT_PATH_MAX];
  18 static char *top_dir = "dir-walk";
  19 static walk_data *state_loc;
  20
  21
  22 static int error(const char *fmt, ...)
  23 {
  24         va_list ap;
  25
  26         va_start(ap, fmt);
  27         vfprintf(stderr, fmt, ap);
  28         va_end(ap);
  29         fprintf(stderr, "\n");
  30         return -1;
  31 }
  32
  33 static int setup(walk_data *d)
  34 {
  35         name_data *n;
  36
  37         if (gitfo_mkdir(top_dir, 0755) < 0)
  38                 return error("can't mkdir(\"%s\")", top_dir);
  39
  40         if (gitfo_chdir(top_dir) < 0)
  41                 return error("can't chdir(\"%s\")", top_dir);
  42
  43         if (strcmp(d->sub, ".") != 0)
  44                 if (gitfo_mkdir(d->sub, 0755) < 0)
  45                         return error("can't mkdir(\"%s\")", d->sub);
  46
  47         strcpy(path_buffer, d->sub);
  48         state_loc = d;
  49
  50         for (n = d->names; n->name; n++) {
  51                 git_file fd = gitfo_creat(n->name, 0600);
  52                 must_be_true(fd >= 0);
  53                 gitfo_close(fd);
  54                 n->count = 0;
  55         }
  56
  57         return 0;
  58 }
  59
  60 static int knockdown(walk_data *d)
  61 {
  62         name_data *n;
  63
  64         for (n = d->names; n->name; n++) {
  65                 if (gitfo_unlink(n->name) < 0)
  66                         return error("can't unlink(\"%s\")", n->name);
  67         }
  68
  69         if (strcmp(d->sub, ".") != 0)
  70                 if (gitfo_rmdir(d->sub) < 0)
  71                         return error("can't rmdir(\"%s\")", d->sub);
  72
  73         if (gitfo_chdir("..") < 0)
  74                 return error("can't chdir(\"..\")");
  75
  76         if (gitfo_rmdir(top_dir) < 0)
  77                 return error("can't rmdir(\"%s\")", top_dir);
  78
  79         return 0;
  80 }
  81
  82 static int check_counts(walk_data *d)
  83 {
  84         int ret = 0;
  85         name_data *n;
  86
  87         for (n = d->names; n->name; n++) {
  88                 if (n->count != 1)
  89                         ret = error("count (%d, %s)", n->count, n->name);
  90         }
  91         return ret;
  92 }
  93
  94 static int one_entry(void *state, char *path)
  95 {
  96         walk_data *d = (walk_data *) state;
  97         name_data *n;
  98
  99         must_be_true(state == state_loc);
 100         must_be_true(path == path_buffer);
 101         for (n = d->names; n->name; n++) {
 102                 if (!strcmp(n->name, path)) {
 103                         n->count++;
 104                         return 0;
 105                 }
 106         }
 107         test_die("unexpected path \"%s\"", path);
 108 }
 109
 110
 111 static name_data dot_names[] = {
 112         { 0, "./a" },
 113         { 0, "./asdf" },
 114         { 0, "./pack-foo.pack" },
 115         { 0, NULL }
 116 };
 117 static walk_data dot = {
 118         ".",
 119         dot_names
 120 };
 121
 122 BEGIN_TEST(dot)
 123
 124         must_pass(setup(&dot));
 125
 126         must_pass(gitfo_dirent(path_buffer,
 127                                sizeof(path_buffer),
 128                                one_entry,
 129                                &dot));
 130
 131         must_pass(check_counts(&dot));
 132
 133         must_pass(knockdown(&dot));
 134 END_TEST
 135
 136 static name_data sub_names[] = {
 137         { 0, "sub/a" },
 138         { 0, "sub/asdf" },
 139         { 0, "sub/pack-foo.pack" },
 140         { 0, NULL }
 141 };
 142 static walk_data sub = {
 143         "sub",
 144         sub_names
 145 };
 146
 147 BEGIN_TEST(sub)
 148
 149         must_pass(setup(&sub));
 150
 151         must_pass(gitfo_dirent(path_buffer,
 152                                sizeof(path_buffer),
 153                                one_entry,
 154                                &sub));
 155
 156         must_pass(check_counts(&sub));
 157
 158         must_pass(knockdown(&sub));
 159 END_TEST
 160
 161 static walk_data sub_slash = {
 162         "sub/",
 163         sub_names
 164 };
 165
 166 BEGIN_TEST(sub_slash)
 167
 168         must_pass(setup(&sub_slash));
 169
 170         must_pass(gitfo_dirent(path_buffer,
 171                                sizeof(path_buffer),
 172                                one_entry,
 173                                &sub_slash));
 174
 175         must_pass(check_counts(&sub_slash));
 176
 177         must_pass(knockdown(&sub_slash));
 178 END_TEST
 179
 180 static name_data empty_names[] = {
 181         { 0, NULL }
 182 };
 183 static walk_data empty = {
 184         "empty",
 185         empty_names
 186 };
 187
 188 static int dont_call_me(void *state, char *path)
 189 {
 190         test_die("dont_call_me: unexpected callback!");
 191 }
 192
 193 BEGIN_TEST(empty)
 194
 195         must_pass(setup(&empty));
 196
 197         must_pass(gitfo_dirent(path_buffer,
 198                                sizeof(path_buffer),
 199                                one_entry,
 200                                &empty));
 201
 202         must_pass(check_counts(&empty));
 203
 204         /* make sure callback not called */
 205         must_pass(gitfo_dirent(path_buffer,
 206                                sizeof(path_buffer),
 207                                dont_call_me,
 208                                &empty));
 209
 210         must_pass(knockdown(&empty));
 211 END_TEST
 212
 213 static name_data odd_names[] = {
 214         { 0, "odd/.a" },
 215         { 0, "odd/..c" },
 216         /* the following don't work on cygwin/win32 */
 217         /* { 0, "odd/.b." }, */
 218         /* { 0, "odd/..d.." },  */
 219         { 0, NULL }
 220 };
 221 static walk_data odd = {
 222         "odd",
 223         odd_names
 224 };
 225
 226 BEGIN_TEST(odd)
 227
 228         must_pass(setup(&odd));
 229
 230         must_pass(gitfo_dirent(path_buffer,
 231                                sizeof(path_buffer),
 232                                one_entry,
 233                                &odd));
 234
 235         must_pass(check_counts(&odd));
 236
 237         must_pass(knockdown(&odd));
 238 END_TEST
 239