t/unit-tests/t-reftable-basics.c

   1 /*
   2 Copyright 2020 Google LLC
   3
   4 Use of this source code is governed by a BSD-style
   5 license that can be found in the LICENSE file or at
   6 https://developers.google.com/open-source/licenses/bsd
   7 */
   8
   9 #include "test-lib.h"
  10 #include "reftable/basics.h"
  11
  12 struct integer_needle_lesseq_args {
  13         int needle;
  14         int *haystack;
  15 };
  16
  17 static int integer_needle_lesseq(size_t i, void *_args)
  18 {
  19         struct integer_needle_lesseq_args *args = _args;
  20         return args->needle <= args->haystack[i];
  21 }
  22
  23 int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
  24 {
  25         if_test ("binary search with binsearch works") {
  26                 int haystack[] = { 2, 4, 6, 8, 10 };
  27                 struct {
  28                         int needle;
  29                         size_t expected_idx;
  30                 } testcases[] = {
  31                         {-9000, 0},
  32                         {-1, 0},
  33                         {0, 0},
  34                         {2, 0},
  35                         {3, 1},
  36                         {4, 1},
  37                         {7, 3},
  38                         {9, 4},
  39                         {10, 4},
  40                         {11, 5},
  41                         {9000, 5},
  42                 };
  43
  44                 for (size_t i = 0; i < ARRAY_SIZE(testcases); i++) {
  45                         struct integer_needle_lesseq_args args = {
  46                                 .haystack = haystack,
  47                                 .needle = testcases[i].needle,
  48                         };
  49                         size_t idx;
  50
  51                         idx = binsearch(ARRAY_SIZE(haystack),
  52                                         &integer_needle_lesseq, &args);
  53                         check_int(idx, ==, testcases[i].expected_idx);
  54                 }
  55         }
  56
  57         if_test ("names_length returns size of a NULL-terminated string array") {
  58                 const char *a[] = { "a", "b", NULL };
  59                 check_int(names_length(a), ==, 2);
  60         }
  61
  62         if_test ("names_equal compares NULL-terminated string arrays") {
  63                 const char *a[] = { "a", "b", "c", NULL };
  64                 const char *b[] = { "a", "b", "d", NULL };
  65                 const char *c[] = { "a", "b", NULL };
  66
  67                 check(names_equal(a, a));
  68                 check(!names_equal(a, b));
  69                 check(!names_equal(a, c));
  70         }
  71
  72         if_test ("parse_names works for basic input") {
  73                 char in1[] = "line\n";
  74                 char in2[] = "a\nb\nc";
  75                 char **out = NULL;
  76                 parse_names(in1, strlen(in1), &out);
  77                 check_str(out[0], "line");
  78                 check(!out[1]);
  79                 free_names(out);
  80
  81                 parse_names(in2, strlen(in2), &out);
  82                 check_str(out[0], "a");
  83                 check_str(out[1], "b");
  84                 check_str(out[2], "c");
  85                 check(!out[3]);
  86                 free_names(out);
  87         }
  88
  89         if_test ("parse_names drops empty string") {
  90                 char in[] = "a\n\nb\n";
  91                 char **out = NULL;
  92                 parse_names(in, strlen(in), &out);
  93                 check_str(out[0], "a");
  94                 /* simply '\n' should be dropped as empty string */
  95                 check_str(out[1], "b");
  96                 check(!out[2]);
  97                 free_names(out);
  98         }
  99
 100         if_test ("common_prefix_size works") {
 101                 struct strbuf a = STRBUF_INIT;
 102                 struct strbuf b = STRBUF_INIT;
 103                 struct {
 104                         const char *a, *b;
 105                         int want;
 106                 } cases[] = {
 107                         {"abcdef", "abc", 3},
 108                         { "abc", "ab", 2 },
 109                         { "", "abc", 0 },
 110                         { "abc", "abd", 2 },
 111                         { "abc", "pqr", 0 },
 112                 };
 113
 114                 for (size_t i = 0; i < ARRAY_SIZE(cases); i++) {
 115                         strbuf_addstr(&a, cases[i].a);
 116                         strbuf_addstr(&b, cases[i].b);
 117                         check_int(common_prefix_size(&a, &b), ==, cases[i].want);
 118                         strbuf_reset(&a);
 119                         strbuf_reset(&b);
 120                 }
 121                 strbuf_release(&a);
 122                 strbuf_release(&b);
 123         }
 124
 125         if_test ("put_be24 and get_be24 work") {
 126                 uint32_t in = 0x112233;
 127                 uint8_t dest[3];
 128                 uint32_t out;
 129                 put_be24(dest, in);
 130                 out = get_be24(dest);
 131                 check_int(in, ==, out);
 132         }
 133
 134         if_test ("put_be16 and get_be16 work") {
 135                 uint32_t in = 0xfef1;
 136                 uint8_t dest[3];
 137                 uint32_t out;
 138                 put_be16(dest, in);
 139                 out = get_be16(dest);
 140                 check_int(in, ==, out);
 141         }
 142
 143         return test_done();
 144 }