tests/t0020-dirent.c

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