freshlybakedca.ke
Git fork
1/*
2Copyright 2020 Google LLC
3
4Use of this source code is governed by a BSD-style
5license that can be found in the LICENSE file or at
6https://developers.google.com/open-source/licenses/bsd
7*/
8
9#include "unit-test.h"
10#include "lib-reftable.h"
11#include "reftable/basics.h"
12#include "reftable/reftable-error.h"
13
14struct integer_needle_lesseq_args {
15 int needle;
16 int *haystack;
17};
18
19static int integer_needle_lesseq(size_t i, void *_args)
20{
21 struct integer_needle_lesseq_args *args = _args;
22 return args->needle <= args->haystack[i];
23}
24
25static void *realloc_stub(void *p UNUSED, size_t size UNUSED)
26{
27 return NULL;
28}
29
30void test_reftable_basics__binsearch(void)
31{
32 int haystack[] = { 2, 4, 6, 8, 10 };
33 struct {
34 int needle;
35 size_t expected_idx;
36 } testcases[] = {
37 {-9000, 0},
38 {-1, 0},
39 {0, 0},
40 {2, 0},
41 {3, 1},
42 {4, 1},
43 {7, 3},
44 {9, 4},
45 {10, 4},
46 {11, 5},
47 {9000, 5},
48 };
49
50 for (size_t i = 0; i < ARRAY_SIZE(testcases); i++) {
51 struct integer_needle_lesseq_args args = {
52 .haystack = haystack,
53 .needle = testcases[i].needle,
54 };
55 size_t idx;
56
57 idx = binsearch(ARRAY_SIZE(haystack),
58 &integer_needle_lesseq, &args);
59 cl_assert_equal_i(idx, testcases[i].expected_idx);
60 }
61}
62
63void test_reftable_basics__names_length(void)
64{
65 const char *a[] = { "a", "b", NULL };
66 cl_assert_equal_i(names_length(a), 2);
67}
68
69void test_reftable_basics__names_equal(void)
70{
71 const char *a[] = { "a", "b", "c", NULL };
72 const char *b[] = { "a", "b", "d", NULL };
73 const char *c[] = { "a", "b", NULL };
74
75 cl_assert(names_equal(a, a));
76 cl_assert(!names_equal(a, b));
77 cl_assert(!names_equal(a, c));
78}
79
80void test_reftable_basics__parse_names(void)
81{
82 char in1[] = "line\n";
83 char in2[] = "a\nb\nc\n";
84 char **out = NULL;
85 int err = parse_names(in1, strlen(in1), &out);
86 cl_assert(err == 0);
87 cl_assert(out != NULL);
88 cl_assert_equal_s(out[0], "line");
89 cl_assert(!out[1]);
90 free_names(out);
91
92 out = NULL;
93 err = parse_names(in2, strlen(in2), &out);
94 cl_assert(err == 0);
95 cl_assert(out != NULL);
96 cl_assert_equal_s(out[0], "a");
97 cl_assert_equal_s(out[1], "b");
98 cl_assert_equal_s(out[2], "c");
99 cl_assert(!out[3]);
100 free_names(out);
101}
102
103void test_reftable_basics__parse_names_missing_newline(void)
104{
105 char in1[] = "line\nline2";
106 char **out = NULL;
107 int err = parse_names(in1, strlen(in1), &out);
108 cl_assert(err == REFTABLE_FORMAT_ERROR);
109 cl_assert(out == NULL);
110}
111
112void test_reftable_basics__parse_names_drop_empty_string(void)
113{
114 char in[] = "a\n\nb\n";
115 char **out = NULL;
116 int err = parse_names(in, strlen(in), &out);
117 cl_assert(err == 0);
118 cl_assert(out != NULL);
119 cl_assert_equal_s(out[0], "a");
120 /* simply '\n' should be dropped as empty string */
121 cl_assert_equal_s(out[1], "b");
122 cl_assert(out[2] == NULL);
123 free_names(out);
124}
125
126void test_reftable_basics__common_prefix_size(void)
127{
128 struct reftable_buf a = REFTABLE_BUF_INIT;
129 struct reftable_buf b = REFTABLE_BUF_INIT;
130 struct {
131 const char *a, *b;
132 int want;
133 } cases[] = {
134 {"abcdef", "abc", 3},
135 { "abc", "ab", 2 },
136 { "", "abc", 0 },
137 { "abc", "abd", 2 },
138 { "abc", "pqr", 0 },
139 };
140
141 for (size_t i = 0; i < ARRAY_SIZE(cases); i++) {
142 cl_assert_equal_i(reftable_buf_addstr(&a, cases[i].a), 0);
143 cl_assert_equal_i(reftable_buf_addstr(&b, cases[i].b), 0);
144 cl_assert_equal_i(common_prefix_size(&a, &b), cases[i].want);
145 reftable_buf_reset(&a);
146 reftable_buf_reset(&b);
147 }
148 reftable_buf_release(&a);
149 reftable_buf_release(&b);
150}
151
152void test_reftable_basics__put_get_be64(void)
153{
154 uint64_t in = 0x1122334455667788;
155 uint8_t dest[8];
156 uint64_t out;
157 reftable_put_be64(dest, in);
158 out = reftable_get_be64(dest);
159 cl_assert(in == out);
160}
161
162void test_reftable_basics__put_get_be32(void)
163{
164 uint32_t in = 0x11223344;
165 uint8_t dest[4];
166 uint32_t out;
167 reftable_put_be32(dest, in);
168 out = reftable_get_be32(dest);
169 cl_assert_equal_i(in, out);
170}
171
172void test_reftable_basics__put_get_be24(void)
173{
174 uint32_t in = 0x112233;
175 uint8_t dest[3];
176 uint32_t out;
177 reftable_put_be24(dest, in);
178 out = reftable_get_be24(dest);
179 cl_assert_equal_i(in, out);
180}
181
182void test_reftable_basics__put_get_be16(void)
183{
184 uint32_t in = 0xfef1;
185 uint8_t dest[3];
186 uint32_t out;
187 reftable_put_be16(dest, in);
188 out = reftable_get_be16(dest);
189 cl_assert_equal_i(in, out);
190}
191
192void test_reftable_basics__alloc_grow(void)
193{
194 int *arr = NULL, *old_arr;
195 size_t alloc = 0, old_alloc;
196
197 cl_assert_equal_i(REFTABLE_ALLOC_GROW(arr, 1, alloc), 0);
198 cl_assert(arr != NULL);
199 cl_assert(alloc >= 1);
200 arr[0] = 42;
201
202 old_alloc = alloc;
203 old_arr = arr;
204 reftable_set_alloc(NULL, realloc_stub, NULL);
205 cl_assert(REFTABLE_ALLOC_GROW(arr, old_alloc + 1, alloc));
206 cl_assert(arr == old_arr);
207 cl_assert_equal_i(alloc, old_alloc);
208
209 old_alloc = alloc;
210 reftable_set_alloc(NULL, NULL, NULL);
211 cl_assert_equal_i(REFTABLE_ALLOC_GROW(arr, old_alloc + 1, alloc), 0);
212 cl_assert(arr != NULL);
213 cl_assert(alloc > old_alloc);
214 arr[alloc - 1] = 42;
215
216 reftable_free(arr);
217}
218
219void test_reftable_basics__alloc_grow_or_null(void)
220{
221 int *arr = NULL;
222 size_t alloc = 0, old_alloc;
223
224 REFTABLE_ALLOC_GROW_OR_NULL(arr, 1, alloc);
225 cl_assert(arr != NULL);
226 cl_assert(alloc >= 1);
227 arr[0] = 42;
228
229 old_alloc = alloc;
230 REFTABLE_ALLOC_GROW_OR_NULL(arr, old_alloc + 1, alloc);
231 cl_assert(arr != NULL);
232 cl_assert(alloc > old_alloc);
233 arr[alloc - 1] = 42;
234
235 old_alloc = alloc;
236 reftable_set_alloc(NULL, realloc_stub, NULL);
237 REFTABLE_ALLOC_GROW_OR_NULL(arr, old_alloc + 1, alloc);
238 cl_assert(arr == NULL);
239 cl_assert_equal_i(alloc, 0);
240 reftable_set_alloc(NULL, NULL, NULL);
241
242 reftable_free(arr);
243}