git.ozlabs.org Git - ccan/blob - ccan/rune/test/run.c

   1 #include <ccan/rune/rune.c>
   2 #include <ccan/rune/coding.c>
   3 #include <ccan/tal/grab_file/grab_file.h>
   4 #include <ccan/tal/str/str.h>
   5 #include <ccan/tap/tap.h>
   6
   7 static const char *check(const tal_t *ctx,
   8                          const struct rune *rune,
   9                          const struct rune_altern *alt,
  10                          char **parts)
  11 {
  12         const char *val = NULL;
  13
  14         for (size_t i = 1; parts[i]; i++) {
  15                 if (strstarts(parts[i], alt->fieldname)
  16                     && parts[i][strlen(alt->fieldname)] == '=')
  17                         val = parts[i] + strlen(alt->fieldname) + 1;
  18         }
  19
  20         /* If it's an integer, hand it like that */
  21         if (val) {
  22                 char *endp;
  23                 s64 v = strtol(val, &endp, 10);
  24                 if (*endp == '\0' && endp != val)
  25                         return rune_alt_single(ctx, alt, NULL, &v);
  26         }
  27
  28         return rune_alt_single(ctx, alt, val, NULL);
  29 }
  30
  31 int main(void)
  32 {
  33         char *vecs;
  34         char **lines;
  35         static const u8 secret_zero[16];
  36         struct rune *mr;
  37
  38         /* Test vector rune uses all-zero secret */
  39         mr = rune_new(NULL, secret_zero, sizeof(secret_zero), NULL);
  40
  41         /* Python runes library generates test vectors */
  42         vecs = grab_file(mr, "test/test_vectors.csv");
  43         assert(vecs);
  44         lines = tal_strsplit(mr, take(vecs), "\n", STR_NO_EMPTY);
  45
  46         plan_tests(343);
  47
  48         for (size_t i = 0; lines[i]; i++) {
  49                 struct rune *rune1, *rune2;
  50                 char **parts;
  51
  52                 parts = tal_strsplit(lines, lines[i], ",", STR_EMPTY_OK);
  53                 if (streq(parts[0], "VALID")) {
  54                         diag("test %s %s", parts[0], parts[1]);
  55                         rune1 = rune_from_string(parts, parts[2]);
  56                         ok1(rune1);
  57                         rune2 = rune_from_base64(parts, parts[3]);
  58                         ok1(rune2);
  59                         ok1(rune_eq(rune1, rune2));
  60                         ok1(streq(rune_to_string(parts, rune2), parts[2]));
  61                         ok1(streq(rune_to_base64(parts, rune1), parts[3]));
  62                         ok1(rune_is_derived_anyversion(mr, rune1) == NULL);
  63                         ok1(rune_is_derived_anyversion(mr, rune2) == NULL);
  64
  65                         if (parts[4]) {
  66                                 if (parts[5])
  67                                         ok1(streq(rune1->version, parts[5]));
  68                                 ok1(streq(rune1->unique_id, parts[4]));
  69                         } else {
  70                                 ok1(!rune1->version);
  71                                 ok1(!rune1->unique_id);
  72                         }
  73                         mr->version = NULL;
  74                 } else if (streq(parts[0], "DERIVE")) {
  75                         struct rune_restr *restr;
  76                         diag("test %s %s", parts[0], parts[1]);
  77                         rune1 = rune_from_base64(parts, parts[2]);
  78                         ok1(rune1);
  79                         rune2 = rune_from_base64(parts, parts[3]);
  80                         ok1(rune2);
  81                         ok1(rune_is_derived_anyversion(mr, rune1) == NULL);
  82                         ok1(rune_is_derived_anyversion(mr, rune2) == NULL);
  83                         ok1(rune_is_derived_anyversion(rune1, rune2) == NULL);
  84
  85                         restr = rune_restr_new(NULL);
  86                         for (size_t i = 4; parts[i]; i+=3) {
  87                                 struct rune_altern *alt;
  88                                 alt = rune_altern_new(NULL,
  89                                                       parts[i],
  90                                                       parts[i+1][0],
  91                                                       parts[i+2]);
  92                                 rune_restr_add_altern(restr, take(alt));
  93                         }
  94                         rune_add_restr(rune1, take(restr));
  95                         ok1(rune_eq(rune1, rune2));
  96                 } else if (streq(parts[0], "MALFORMED")) {
  97                         diag("test %s %s", parts[0], parts[1]);
  98                         rune1 = rune_from_string(parts, parts[2]);
  99                         ok1(!rune1);
 100                         rune2 = rune_from_base64(parts, parts[3]);
 101                         ok1(!rune2);
 102                 } else if (streq(parts[0], "BAD DERIVATION")) {
 103                         diag("test %s %s", parts[0], parts[1]);
 104                         rune1 = rune_from_string(parts, parts[2]);
 105                         ok1(rune1);
 106                         rune2 = rune_from_base64(parts, parts[3]);
 107                         ok1(rune2);
 108                         ok1(rune_eq(rune1, rune2));
 109                         ok1(rune_is_derived(mr, rune1) != NULL);
 110                         ok1(rune_is_derived(mr, rune2) != NULL);
 111                 } else {
 112                         const char *err;
 113                         diag("test %s", parts[0]);
 114                         err = rune_test(parts, mr, rune1, check, parts);
 115                         if (streq(parts[0], "PASS")) {
 116                                 ok1(!err);
 117                         } else {
 118                                 assert(streq(parts[0], "FAIL"));
 119                                 ok1(err);
 120                         }
 121                 }
 122         }
 123
 124         tal_free(mr);
 125         /* This exits depending on whether all tests passed */
 126         return exit_status();
 127 }