regress/path/path_test.c

   1 /*
   2  * Copyright (c) 2018, 2019 Stefan Sperling <stsp@openbsd.org>
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "got_compat.h"
  18
  19 #include <sys/queue.h>
  20
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include <unistd.h>
  26 #include <err.h>
  27
  28 #include "got_error.h"
  29 #include "got_path.h"
  30
  31 #ifndef nitems
  32 #define nitems(_a) (sizeof(_a) / sizeof((_a)[0]))
  33 #endif
  34
  35 static int verbose;
  36 static int quiet;
  37
  38 static void
  39 test_printf(const char *fmt, ...)
  40 {
  41         va_list ap;
  42
  43         if (!verbose)
  44                 return;
  45
  46         va_start(ap, fmt);
  47         vprintf(fmt, ap);
  48         va_end(ap);
  49 }
  50
  51 static int
  52 path_cmp(void)
  53 {
  54         const struct path_cmp_test {
  55                 const char *path1;
  56                 const char *path2;
  57                 int expected;
  58         } test_data[] = {
  59                 { "", "", 0 },
  60                 { "/", "/", 0 },
  61                 { "/a", "/b", -1 },
  62                 { "x/a", "x.a", -1 },
  63                 { "x.a", "x/a", 1 },
  64                 { "//foo", "/bar", 1 },
  65                 { "/foo", "/bar", 1 },
  66                 { "foo", "bar", 1 },
  67                 { "/foo/sub", "/bar", 1 },
  68                 { "/foo", "/bar/sub", 1 },
  69                 { "/foo/", "/bar", 1 },
  70                 { "/foo", "/bar/", 1 },
  71                 { "/foo/", "/bar/", 1 },
  72                 { "/bar/", "/bar/", 0 },
  73                 { "/bar/", "/bar", 0 },
  74                 { "//bar//", "/bar/", 0 },
  75                 { "//bar//", "/bar////", 0 },
  76                 { "/bar/sub", "/bar.", -1 },
  77                 { "/bar/sub", "/bar/", 1 },
  78                 { "/bar/sub/", "/bar///", 1 },
  79                 { "/bar/sub/sub2", "/bar/", 1 },
  80                 { "/bar/sub/sub2", "/bar", 1 },
  81                 { "/bar.sub.sub2", "/bar", 1 },
  82                 { "/bar/sub/sub2", "/bar.c", -1 },
  83         };
  84         size_t i;
  85
  86         for (i = 0; i < nitems(test_data); i++) {
  87                 const char *path1 = test_data[i].path1;
  88                 const char *path2 = test_data[i].path2;
  89                 int expected = test_data[i].expected;
  90                 int cmp = got_path_cmp(path1, path2,
  91                     strlen(path1), strlen(path2));
  92
  93                 if (cmp != expected) {
  94                         test_printf("%d: '%s' vs '%s' == %d; expected %d\n",
  95                             i, path1, path2, cmp, expected);
  96                         return 0;
  97                 }
  98         }
  99
 100         return 1;
 101 }
 102
 103 const char *path_list_input[] = {
 104         "", "/", "a", "/b", "/bar", "bar/sub", "/bar/sub", "/bar/",
 105         "/bar.c", "/bar/sub/sub2", "/bar.sub.sub2", "/foo",
 106         "/foo/sub", "/foo/", "/foo/", "x/a",
 107 };
 108 const char *path_list_expected[] = {
 109         "",
 110         "a",
 111         "/b",
 112         "/bar",
 113         "bar/sub",
 114         "/bar/sub/sub2",
 115         "/bar.c",
 116         "/bar.sub.sub2",
 117         "/foo",
 118         "/foo/sub",
 119         "x/a",
 120 };
 121
 122 /* If inserting pathlist_input in reverse the result is slightly different. */
 123 const char *path_list_expected_reverse[] = {
 124         "/",
 125         "a",
 126         "/b",
 127         "/bar/",
 128         "/bar/sub",
 129         "/bar/sub/sub2",
 130         "/bar.c",
 131         "/bar.sub.sub2",
 132         "/foo/",
 133         "/foo/sub",
 134         "x/a",
 135 };
 136
 137
 138 static int
 139 path_list(void)
 140 {
 141         const struct got_error *err = NULL;
 142         struct got_pathlist_head paths;
 143         struct got_pathlist_entry *pe;
 144         size_t i;
 145
 146         TAILQ_INIT(&paths);
 147         for (i = 0; i < nitems(path_list_input); i++) {
 148                 err = got_pathlist_insert(NULL, &paths, path_list_input[i],
 149                     NULL);
 150                 if (err) {
 151                         test_printf("%s\n", __func__, err->msg);
 152                         return 0;
 153                 }
 154         }
 155
 156         i = 0;
 157         TAILQ_FOREACH(pe, &paths, entry) {
 158                 test_printf("'%s' -- '%s'\n", pe->path, path_list_expected[i]);
 159                 if (i >= nitems(path_list_expected)) {
 160                         test_printf("too many elements on list\n");
 161                         return 0;
 162                 }
 163                 if (strcmp(pe->path, path_list_expected[i]) != 0) {
 164                         test_printf("unordered elements on list\n");
 165                         return 0;
 166                 }
 167                 i++;
 168         }
 169
 170         got_pathlist_free(&paths, GOT_PATHLIST_FREE_NONE);
 171         return 1;
 172 }
 173
 174 static int
 175 path_list_reverse_input(void)
 176 {
 177         const struct got_error *err = NULL;
 178         struct got_pathlist_head paths;
 179         struct got_pathlist_entry *pe;
 180         size_t i;
 181
 182         TAILQ_INIT(&paths);
 183         for (i = nitems(path_list_input); i > 0;) {
 184                 err = got_pathlist_insert(NULL, &paths, path_list_input[--i],
 185                     NULL);
 186                 if (err) {
 187                         test_printf("%s\n", __func__, err->msg);
 188                         return 0;
 189                 }
 190         }
 191
 192         i = 0;
 193         TAILQ_FOREACH(pe, &paths, entry) {
 194                 test_printf("'%s' -- '%s'\n", pe->path,
 195                     path_list_expected_reverse[i]);
 196                 if (i >= nitems(path_list_expected_reverse)) {
 197                         test_printf("too many elements on list\n");
 198                         return 0;
 199                 }
 200                 if (strcmp(pe->path, path_list_expected_reverse[i]) != 0) {
 201                         test_printf("unordered elements on list\n");
 202                         return 0;
 203                 }
 204                 i++;
 205         }
 206
 207         got_pathlist_free(&paths, GOT_PATHLIST_FREE_NONE);
 208         return 1;
 209 }
 210
 211 #define RUN_TEST(expr, name) \
 212         { test_ok = (expr);  \
 213         if (!quiet) printf("test_%s %s\n", (name), test_ok ? "ok" : "failed"); \
 214         failure = (failure || !test_ok); }
 215
 216 static void
 217 usage(void)
 218 {
 219         fprintf(stderr, "usage: path_test [-v] [-q]\n");
 220 }
 221
 222 int
 223 main(int argc, char *argv[])
 224 {
 225         int test_ok = 0, failure = 0;
 226         int ch;
 227
 228 #ifndef PROFILE
 229         if (pledge("stdio", NULL) == -1)
 230                 err(1, "pledge");
 231 #endif
 232
 233         while ((ch = getopt(argc, argv, "qv")) != -1) {
 234                 switch (ch) {
 235                 case 'q':
 236                         quiet = 1;
 237                         verbose = 0;
 238                         break;
 239                 case 'v':
 240                         verbose = 1;
 241                         quiet = 0;
 242                         break;
 243                 default:
 244                         usage();
 245                         return 1;
 246                 }
 247         }
 248         argc -= optind;
 249         argv += optind;
 250
 251         RUN_TEST(path_cmp(), "path_cmp");
 252         RUN_TEST(path_list(), "path_list");
 253         RUN_TEST(path_list_reverse_input(), "path_list_reverse_input");
 254
 255         return failure ? 1 : 0;
 256 }