]> git.ipfire.org Git - thirdparty/git.git/blame - reftable/stack_test.c
projects / thirdparty / git.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'bb/iso-strict-utc'
[thirdparty/git.git] / reftable / stack_test.c
CommitLineData
e48d4272
HWN		 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 "stack.h"
10
11#include "system.h"
12
13#include "reftable-reader.h"
14#include "merged.h"
15#include "basics.h"
e48d4272
HWN		 16#include "record.h"
17#include "test_framework.h"
18#include "reftable-tests.h"
cd1799de 19#include "reader.h"
e48d4272
HWN		 20
21#include <sys/types.h>
22#include <dirent.h>
23
24static void clear_dir(const char *dirname)
25{
26 struct strbuf path = STRBUF_INIT;
27 strbuf_addstr(&path, dirname);
28 remove_dir_recursively(&path, 0);
29 strbuf_release(&path);
30}
31
32static int count_dir_entries(const char *dirname)
33{
34 DIR *dir = opendir(dirname);
35 int len = 0;
36 struct dirent *d;
72a4ea71 37 if (!dir)
e48d4272
HWN		 38 return 0;
39
40 while ((d = readdir(dir))) {
41 if (!strcmp(d->d_name, "..") || !strcmp(d->d_name, "."))
42 continue;
43 len++;
44 }
45 closedir(dir);
46 return len;
47}
48
49/*
50 * Work linenumber into the tempdir, so we can see which tests forget to
51 * cleanup.
52 */
53static char *get_tmp_template(int linenumber)
54{
55 const char *tmp = getenv("TMPDIR");
56 static char template[1024];
57 snprintf(template, sizeof(template) - 1, "%s/stack_test-%d.XXXXXX",
58 tmp ? tmp : "/tmp", linenumber);
59 return template;
60}
61
62static char *get_tmp_dir(int linenumber)
63{
64 char *dir = get_tmp_template(linenumber);
65 EXPECT(mkdtemp(dir));
66 return dir;
67}
68
69static void test_read_file(void)
70{
71 char *fn = get_tmp_template(__LINE__);
72 int fd = mkstemp(fn);
73 char out[1024] = "line1\n\nline2\nline3";
74 int n, err;
75 char **names = NULL;
76 char *want[] = { "line1", "line2", "line3" };
77 int i = 0;
78
79 EXPECT(fd > 0);
85a8c899 80 n = write_in_full(fd, out, strlen(out));
e48d4272
HWN		 81 EXPECT(n == strlen(out));
82 err = close(fd);
83 EXPECT(err >= 0);
84
85 err = read_lines(fn, &names);
86 EXPECT_ERR(err);
87
88 for (i = 0; names[i]; i++) {
89 EXPECT(0 == strcmp(want[i], names[i]));
90 }
91 free_names(names);
f5f6a6cd 92 (void) remove(fn);
e48d4272
HWN		 93}
94
95static void test_parse_names(void)
96{
97 char buf[] = "line\n";
98 char **names = NULL;
99 parse_names(buf, strlen(buf), &names);
100
101 EXPECT(NULL != names[0]);
102 EXPECT(0 == strcmp(names[0], "line"));
103 EXPECT(NULL == names[1]);
104 free_names(names);
105}
106
107static void test_names_equal(void)
108{
109 char *a[] = { "a", "b", "c", NULL };
110 char *b[] = { "a", "b", "d", NULL };
111 char *c[] = { "a", "b", NULL };
112
113 EXPECT(names_equal(a, a));
114 EXPECT(!names_equal(a, b));
115 EXPECT(!names_equal(a, c));
116}
117
118static int write_test_ref(struct reftable_writer *wr, void *arg)
119{
120 struct reftable_ref_record *ref = arg;
121 reftable_writer_set_limits(wr, ref->update_index, ref->update_index);
122 return reftable_writer_add_ref(wr, ref);
123}
124
125struct write_log_arg {
126 struct reftable_log_record *log;
127 uint64_t update_index;
128};
129
130static int write_test_log(struct reftable_writer *wr, void *arg)
131{
132 struct write_log_arg *wla = arg;
133
134 reftable_writer_set_limits(wr, wla->update_index, wla->update_index);
135 return reftable_writer_add_log(wr, wla->log);
136}
137
138static void test_reftable_stack_add_one(void)
139{
140 char *dir = get_tmp_dir(__LINE__);
cd1799de
HWN		 141 struct strbuf scratch = STRBUF_INIT;
142 int mask = umask(002);
143 struct reftable_write_options cfg = {
144 .default_permissions = 0660,
145 };
e48d4272
HWN		 146 struct reftable_stack *st = NULL;
147 int err;
148 struct reftable_ref_record ref = {
149 .refname = "HEAD",
150 .update_index = 1,
151 .value_type = REFTABLE_REF_SYMREF,
152 .value.symref = "master",
153 };
154 struct reftable_ref_record dest = { NULL };
cd1799de 155 struct stat stat_result = { 0 };
e48d4272
HWN		 156 err = reftable_new_stack(&st, dir, cfg);
157 EXPECT_ERR(err);
158
159 err = reftable_stack_add(st, &write_test_ref, &ref);
160 EXPECT_ERR(err);
161
162 err = reftable_stack_read_ref(st, ref.refname, &dest);
163 EXPECT_ERR(err);
164 EXPECT(0 == strcmp("master", dest.value.symref));
cd1799de 165 EXPECT(st->readers_len > 0);
e48d4272
HWN		 166
167 printf("testing print functionality:\n");
168 err = reftable_stack_print_directory(dir, GIT_SHA1_FORMAT_ID);
169 EXPECT_ERR(err);
170
171 err = reftable_stack_print_directory(dir, GIT_SHA256_FORMAT_ID);
172 EXPECT(err == REFTABLE_FORMAT_ERROR);
173
cd1799de
HWN		 174#ifndef GIT_WINDOWS_NATIVE
175 strbuf_addstr(&scratch, dir);
176 strbuf_addstr(&scratch, "/tables.list");
177 err = stat(scratch.buf, &stat_result);
178 EXPECT(!err);
179 EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
180
181 strbuf_reset(&scratch);
182 strbuf_addstr(&scratch, dir);
183 strbuf_addstr(&scratch, "/");
184 /* do not try at home; not an external API for reftable. */
185 strbuf_addstr(&scratch, st->readers[0]->name);
186 err = stat(scratch.buf, &stat_result);
187 EXPECT(!err);
188 EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
189#else
190 (void) stat_result;
191#endif
192
e48d4272
HWN		 193 reftable_ref_record_release(&dest);
194 reftable_stack_destroy(st);
cd1799de 195 strbuf_release(&scratch);
e48d4272 196 clear_dir(dir);
cd1799de 197 umask(mask);
e48d4272
HWN		 198}
199
200static void test_reftable_stack_uptodate(void)
201{
202 struct reftable_write_options cfg = { 0 };
203 struct reftable_stack *st1 = NULL;
204 struct reftable_stack *st2 = NULL;
205 char *dir = get_tmp_dir(__LINE__);
206
207 int err;
208 struct reftable_ref_record ref1 = {
209 .refname = "HEAD",
210 .update_index = 1,
211 .value_type = REFTABLE_REF_SYMREF,
212 .value.symref = "master",
213 };
214 struct reftable_ref_record ref2 = {
215 .refname = "branch2",
216 .update_index = 2,
217 .value_type = REFTABLE_REF_SYMREF,
218 .value.symref = "master",
219 };
220
221
222 /* simulate multi-process access to the same stack
223 by creating two stacks for the same directory.
224 */
225 err = reftable_new_stack(&st1, dir, cfg);
226 EXPECT_ERR(err);
227
228 err = reftable_new_stack(&st2, dir, cfg);
229 EXPECT_ERR(err);
230
231 err = reftable_stack_add(st1, &write_test_ref, &ref1);
232 EXPECT_ERR(err);
233
234 err = reftable_stack_add(st2, &write_test_ref, &ref2);
235 EXPECT(err == REFTABLE_LOCK_ERROR);
236
237 err = reftable_stack_reload(st2);
238 EXPECT_ERR(err);
239
240 err = reftable_stack_add(st2, &write_test_ref, &ref2);
241 EXPECT_ERR(err);
242 reftable_stack_destroy(st1);
243 reftable_stack_destroy(st2);
244 clear_dir(dir);
245}
246
247static void test_reftable_stack_transaction_api(void)
248{
249 char *dir = get_tmp_dir(__LINE__);
250
251 struct reftable_write_options cfg = { 0 };
252 struct reftable_stack *st = NULL;
253 int err;
254 struct reftable_addition *add = NULL;
255
256 struct reftable_ref_record ref = {
257 .refname = "HEAD",
258 .update_index = 1,
259 .value_type = REFTABLE_REF_SYMREF,
260 .value.symref = "master",
261 };
262 struct reftable_ref_record dest = { NULL };
263
264
265 err = reftable_new_stack(&st, dir, cfg);
266 EXPECT_ERR(err);
267
268 reftable_addition_destroy(add);
269
270 err = reftable_stack_new_addition(&add, st);
271 EXPECT_ERR(err);
272
273 err = reftable_addition_add(add, &write_test_ref, &ref);
274 EXPECT_ERR(err);
275
276 err = reftable_addition_commit(add);
277 EXPECT_ERR(err);
278
279 reftable_addition_destroy(add);
280
281 err = reftable_stack_read_ref(st, ref.refname, &dest);
282 EXPECT_ERR(err);
283 EXPECT(REFTABLE_REF_SYMREF == dest.value_type);
284 EXPECT(0 == strcmp("master", dest.value.symref));
285
286 reftable_ref_record_release(&dest);
287 reftable_stack_destroy(st);
288 clear_dir(dir);
289}
290
5c086453
PS		 291static void test_reftable_stack_transaction_api_performs_auto_compaction(void)
292{
293 char *dir = get_tmp_dir(__LINE__);
294 struct reftable_write_options cfg = {0};
295 struct reftable_addition *add = NULL;
296 struct reftable_stack *st = NULL;
297 int i, n = 20, err;
298
299 err = reftable_new_stack(&st, dir, cfg);
300 EXPECT_ERR(err);
301
302 for (i = 0; i <= n; i++) {
303 struct reftable_ref_record ref = {
304 .update_index = reftable_stack_next_update_index(st),
305 .value_type = REFTABLE_REF_SYMREF,
306 .value.symref = "master",
307 };
308 char name[100];
309
310 snprintf(name, sizeof(name), "branch%04d", i);
311 ref.refname = name;
312
313 /*
314 * Disable auto-compaction for all but the last runs. Like this
315 * we can ensure that we indeed honor this setting and have
316 * better control over when exactly auto compaction runs.
317 */
318 st->disable_auto_compact = i != n;
319
320 err = reftable_stack_new_addition(&add, st);
321 EXPECT_ERR(err);
322
323 err = reftable_addition_add(add, &write_test_ref, &ref);
324 EXPECT_ERR(err);
325
326 err = reftable_addition_commit(add);
327 EXPECT_ERR(err);
328
329 reftable_addition_destroy(add);
330
331 /*
332 * The stack length should grow continuously for all runs where
333 * auto compaction is disabled. When enabled, we should merge
334 * all tables in the stack.
335 */
336 if (i != n)
337 EXPECT(st->merged->stack_len == i + 1);
338 else
339 EXPECT(st->merged->stack_len == 1);
340 }
341
342 reftable_stack_destroy(st);
343 clear_dir(dir);
344}
345
e48d4272
HWN		 346static void test_reftable_stack_validate_refname(void)
347{
348 struct reftable_write_options cfg = { 0 };
349 struct reftable_stack *st = NULL;
350 int err;
351 char *dir = get_tmp_dir(__LINE__);
352
353 int i;
354 struct reftable_ref_record ref = {
355 .refname = "a/b",
356 .update_index = 1,
357 .value_type = REFTABLE_REF_SYMREF,
358 .value.symref = "master",
359 };
360 char *additions[] = { "a", "a/b/c" };
361
362 err = reftable_new_stack(&st, dir, cfg);
363 EXPECT_ERR(err);
364
365 err = reftable_stack_add(st, &write_test_ref, &ref);
366 EXPECT_ERR(err);
367
368 for (i = 0; i < ARRAY_SIZE(additions); i++) {
369 struct reftable_ref_record ref = {
370 .refname = additions[i],
371 .update_index = 1,
372 .value_type = REFTABLE_REF_SYMREF,
373 .value.symref = "master",
374 };
375
376 err = reftable_stack_add(st, &write_test_ref, &ref);
377 EXPECT(err == REFTABLE_NAME_CONFLICT);
378 }
379
380 reftable_stack_destroy(st);
381 clear_dir(dir);
382}
383
384static int write_error(struct reftable_writer *wr, void *arg)
385{
386 return *((int *)arg);
387}
388
389static void test_reftable_stack_update_index_check(void)
390{
391 char *dir = get_tmp_dir(__LINE__);
392
393 struct reftable_write_options cfg = { 0 };
394 struct reftable_stack *st = NULL;
395 int err;
396 struct reftable_ref_record ref1 = {
397 .refname = "name1",
398 .update_index = 1,
399 .value_type = REFTABLE_REF_SYMREF,
400 .value.symref = "master",
401 };
402 struct reftable_ref_record ref2 = {
403 .refname = "name2",
404 .update_index = 1,
405 .value_type = REFTABLE_REF_SYMREF,
406 .value.symref = "master",
407 };
408
409 err = reftable_new_stack(&st, dir, cfg);
410 EXPECT_ERR(err);
411
412 err = reftable_stack_add(st, &write_test_ref, &ref1);
413 EXPECT_ERR(err);
414
415 err = reftable_stack_add(st, &write_test_ref, &ref2);
416 EXPECT(err == REFTABLE_API_ERROR);
417 reftable_stack_destroy(st);
418 clear_dir(dir);
419}
420
421static void test_reftable_stack_lock_failure(void)
422{
423 char *dir = get_tmp_dir(__LINE__);
424
425 struct reftable_write_options cfg = { 0 };
426 struct reftable_stack *st = NULL;
427 int err, i;
428
429 err = reftable_new_stack(&st, dir, cfg);
430 EXPECT_ERR(err);
431 for (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {
432 err = reftable_stack_add(st, &write_error, &i);
433 EXPECT(err == i);
434 }
435
436 reftable_stack_destroy(st);
437 clear_dir(dir);
438}
439
440static void test_reftable_stack_add(void)
441{
442 int i = 0;
443 int err = 0;
444 struct reftable_write_options cfg = {
445 .exact_log_message = 1,
b3a79dd4 446 .default_permissions = 0660,
e48d4272
HWN		 447 };
448 struct reftable_stack *st = NULL;
449 char *dir = get_tmp_dir(__LINE__);
e48d4272
HWN		 450 struct reftable_ref_record refs[2] = { { NULL } };
451 struct reftable_log_record logs[2] = { { NULL } };
b3a79dd4
PS		 452 struct strbuf path = STRBUF_INIT;
453 struct stat stat_result;
e48d4272
HWN		 454 int N = ARRAY_SIZE(refs);
455
e48d4272
HWN		 456 err = reftable_new_stack(&st, dir, cfg);
457 EXPECT_ERR(err);
458 st->disable_auto_compact = 1;
459
460 for (i = 0; i < N; i++) {
461 char buf[256];
462 snprintf(buf, sizeof(buf), "branch%02d", i);
463 refs[i].refname = xstrdup(buf);
464 refs[i].update_index = i + 1;
465 refs[i].value_type = REFTABLE_REF_VAL1;
e48d4272
HWN		 466 set_test_hash(refs[i].value.val1, i);
467
468 logs[i].refname = xstrdup(buf);
469 logs[i].update_index = N + i + 1;
470 logs[i].value_type = REFTABLE_LOG_UPDATE;
e48d4272
HWN		 471 logs[i].value.update.email = xstrdup("identity@invalid");
472 set_test_hash(logs[i].value.update.new_hash, i);
473 }
474
475 for (i = 0; i < N; i++) {
476 int err = reftable_stack_add(st, &write_test_ref, &refs[i]);
477 EXPECT_ERR(err);
478 }
479
480 for (i = 0; i < N; i++) {
481 struct write_log_arg arg = {
482 .log = &logs[i],
483 .update_index = reftable_stack_next_update_index(st),
484 };
485 int err = reftable_stack_add(st, &write_test_log, &arg);
486 EXPECT_ERR(err);
487 }
488
489 err = reftable_stack_compact_all(st, NULL);
490 EXPECT_ERR(err);
491
492 for (i = 0; i < N; i++) {
493 struct reftable_ref_record dest = { NULL };
494
495 int err = reftable_stack_read_ref(st, refs[i].refname, &dest);
496 EXPECT_ERR(err);
497 EXPECT(reftable_ref_record_equal(&dest, refs + i,
498 GIT_SHA1_RAWSZ));
499 reftable_ref_record_release(&dest);
500 }
501
502 for (i = 0; i < N; i++) {
503 struct reftable_log_record dest = { NULL };
504 int err = reftable_stack_read_log(st, refs[i].refname, &dest);
505 EXPECT_ERR(err);
506 EXPECT(reftable_log_record_equal(&dest, logs + i,
507 GIT_SHA1_RAWSZ));
508 reftable_log_record_release(&dest);
509 }
510
b3a79dd4
PS		 511#ifndef GIT_WINDOWS_NATIVE
512 strbuf_addstr(&path, dir);
513 strbuf_addstr(&path, "/tables.list");
514 err = stat(path.buf, &stat_result);
515 EXPECT(!err);
516 EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
517
518 strbuf_reset(&path);
519 strbuf_addstr(&path, dir);
520 strbuf_addstr(&path, "/");
521 /* do not try at home; not an external API for reftable. */
522 strbuf_addstr(&path, st->readers[0]->name);
523 err = stat(path.buf, &stat_result);
524 EXPECT(!err);
525 EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
526#else
527 (void) stat_result;
528#endif
529
e48d4272
HWN		 530 /* cleanup */
531 reftable_stack_destroy(st);
532 for (i = 0; i < N; i++) {
533 reftable_ref_record_release(&refs[i]);
534 reftable_log_record_release(&logs[i]);
535 }
b3a79dd4 536 strbuf_release(&path);
e48d4272
HWN		 537 clear_dir(dir);
538}
539
540static void test_reftable_stack_log_normalize(void)
541{
542 int err = 0;
543 struct reftable_write_options cfg = {
544 0,
545 };
546 struct reftable_stack *st = NULL;
547 char *dir = get_tmp_dir(__LINE__);
87ff7230
PS		 548 struct reftable_log_record input = {
549 .refname = "branch",
550 .update_index = 1,
551 .value_type = REFTABLE_LOG_UPDATE,
552 .value = {
553 .update = {
554 .new_hash = { 1 },
555 .old_hash = { 2 },
556 },
557 },
558 };
e48d4272
HWN		 559 struct reftable_log_record dest = {
560 .update_index = 0,
561 };
562 struct write_log_arg arg = {
563 .log = &input,
564 .update_index = 1,
565 };
566
567 err = reftable_new_stack(&st, dir, cfg);
568 EXPECT_ERR(err);
569
570 input.value.update.message = "one\ntwo";
571 err = reftable_stack_add(st, &write_test_log, &arg);
572 EXPECT(err == REFTABLE_API_ERROR);
573
574 input.value.update.message = "one";
575 err = reftable_stack_add(st, &write_test_log, &arg);
576 EXPECT_ERR(err);
577
578 err = reftable_stack_read_log(st, input.refname, &dest);
579 EXPECT_ERR(err);
580 EXPECT(0 == strcmp(dest.value.update.message, "one\n"));
581
582 input.value.update.message = "two\n";
583 arg.update_index = 2;
584 err = reftable_stack_add(st, &write_test_log, &arg);
585 EXPECT_ERR(err);
586 err = reftable_stack_read_log(st, input.refname, &dest);
587 EXPECT_ERR(err);
588 EXPECT(0 == strcmp(dest.value.update.message, "two\n"));
589
590 /* cleanup */
591 reftable_stack_destroy(st);
592 reftable_log_record_release(&dest);
593 clear_dir(dir);
594}
595
596static void test_reftable_stack_tombstone(void)
597{
598 int i = 0;
599 char *dir = get_tmp_dir(__LINE__);
600
601 struct reftable_write_options cfg = { 0 };
602 struct reftable_stack *st = NULL;
603 int err;
604 struct reftable_ref_record refs[2] = { { NULL } };
605 struct reftable_log_record logs[2] = { { NULL } };
606 int N = ARRAY_SIZE(refs);
607 struct reftable_ref_record dest = { NULL };
608 struct reftable_log_record log_dest = { NULL };
609
610
611 err = reftable_new_stack(&st, dir, cfg);
612 EXPECT_ERR(err);
613
614 /* even entries add the refs, odd entries delete them. */
615 for (i = 0; i < N; i++) {
616 const char *buf = "branch";
617 refs[i].refname = xstrdup(buf);
618 refs[i].update_index = i + 1;
619 if (i % 2 == 0) {
620 refs[i].value_type = REFTABLE_REF_VAL1;
e48d4272
HWN		 621 set_test_hash(refs[i].value.val1, i);
622 }
623
624 logs[i].refname = xstrdup(buf);
625 /* update_index is part of the key. */
626 logs[i].update_index = 42;
627 if (i % 2 == 0) {
628 logs[i].value_type = REFTABLE_LOG_UPDATE;
e48d4272
HWN		 629 set_test_hash(logs[i].value.update.new_hash, i);
630 logs[i].value.update.email =
631 xstrdup("identity@invalid");
632 }
633 }
634 for (i = 0; i < N; i++) {
635 int err = reftable_stack_add(st, &write_test_ref, &refs[i]);
636 EXPECT_ERR(err);
637 }
638
639 for (i = 0; i < N; i++) {
640 struct write_log_arg arg = {
641 .log = &logs[i],
642 .update_index = reftable_stack_next_update_index(st),
643 };
644 int err = reftable_stack_add(st, &write_test_log, &arg);
645 EXPECT_ERR(err);
646 }
647
648 err = reftable_stack_read_ref(st, "branch", &dest);
649 EXPECT(err == 1);
650 reftable_ref_record_release(&dest);
651
652 err = reftable_stack_read_log(st, "branch", &log_dest);
653 EXPECT(err == 1);
654 reftable_log_record_release(&log_dest);
655
656 err = reftable_stack_compact_all(st, NULL);
657 EXPECT_ERR(err);
658
659 err = reftable_stack_read_ref(st, "branch", &dest);
660 EXPECT(err == 1);
661
662 err = reftable_stack_read_log(st, "branch", &log_dest);
663 EXPECT(err == 1);
664 reftable_ref_record_release(&dest);
665 reftable_log_record_release(&log_dest);
666
667 /* cleanup */
668 reftable_stack_destroy(st);
669 for (i = 0; i < N; i++) {
670 reftable_ref_record_release(&refs[i]);
671 reftable_log_record_release(&logs[i]);
672 }
673 clear_dir(dir);
674}
675
676static void test_reftable_stack_hash_id(void)
677{
678 char *dir = get_tmp_dir(__LINE__);
679
680 struct reftable_write_options cfg = { 0 };
681 struct reftable_stack *st = NULL;
682 int err;
683
684 struct reftable_ref_record ref = {
685 .refname = "master",
686 .value_type = REFTABLE_REF_SYMREF,
687 .value.symref = "target",
688 .update_index = 1,
689 };
690 struct reftable_write_options cfg32 = { .hash_id = GIT_SHA256_FORMAT_ID };
691 struct reftable_stack *st32 = NULL;
692 struct reftable_write_options cfg_default = { 0 };
693 struct reftable_stack *st_default = NULL;
694 struct reftable_ref_record dest = { NULL };
695
696 err = reftable_new_stack(&st, dir, cfg);
697 EXPECT_ERR(err);
698
699 err = reftable_stack_add(st, &write_test_ref, &ref);
700 EXPECT_ERR(err);
701
702 /* can't read it with the wrong hash ID. */
703 err = reftable_new_stack(&st32, dir, cfg32);
704 EXPECT(err == REFTABLE_FORMAT_ERROR);
705
706 /* check that we can read it back with default config too. */
707 err = reftable_new_stack(&st_default, dir, cfg_default);
708 EXPECT_ERR(err);
709
710 err = reftable_stack_read_ref(st_default, "master", &dest);
711 EXPECT_ERR(err);
712
713 EXPECT(reftable_ref_record_equal(&ref, &dest, GIT_SHA1_RAWSZ));
714 reftable_ref_record_release(&dest);
715 reftable_stack_destroy(st);
716 reftable_stack_destroy(st_default);
717 clear_dir(dir);
718}
719
720static void test_log2(void)
721{
722 EXPECT(1 == fastlog2(3));
723 EXPECT(2 == fastlog2(4));
724 EXPECT(2 == fastlog2(5));
725}
726
727static void test_sizes_to_segments(void)
728{
729 uint64_t sizes[] = { 2, 3, 4, 5, 7, 9 };
730 /* .................0 1 2 3 4 5 */
731
6d5e80fb 732 size_t seglen = 0;
e48d4272
HWN		 733 struct segment *segs =
734 sizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));
735 EXPECT(segs[2].log == 3);
736 EXPECT(segs[2].start == 5);
737 EXPECT(segs[2].end == 6);
738
739 EXPECT(segs[1].log == 2);
740 EXPECT(segs[1].start == 2);
741 EXPECT(segs[1].end == 5);
742 reftable_free(segs);
743}
744
745static void test_sizes_to_segments_empty(void)
746{
6d5e80fb 747 size_t seglen = 0;
e48d4272
HWN		 748 struct segment *segs = sizes_to_segments(&seglen, NULL, 0);
749 EXPECT(seglen == 0);
750 reftable_free(segs);
751}
752
753static void test_sizes_to_segments_all_equal(void)
754{
755 uint64_t sizes[] = { 5, 5 };
6d5e80fb 756 size_t seglen = 0;
e48d4272
HWN		 757 struct segment *segs =
758 sizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));
759 EXPECT(seglen == 1);
760 EXPECT(segs[0].start == 0);
761 EXPECT(segs[0].end == 2);
762 reftable_free(segs);
763}
764
765static void test_suggest_compaction_segment(void)
766{
767 uint64_t sizes[] = { 128, 64, 17, 16, 9, 9, 9, 16, 16 };
768 /* .................0 1 2 3 4 5 6 */
769 struct segment min =
770 suggest_compaction_segment(sizes, ARRAY_SIZE(sizes));
771 EXPECT(min.start == 2);
772 EXPECT(min.end == 7);
773}
774
775static void test_suggest_compaction_segment_nothing(void)
776{
777 uint64_t sizes[] = { 64, 32, 16, 8, 4, 2 };
778 struct segment result =
779 suggest_compaction_segment(sizes, ARRAY_SIZE(sizes));
780 EXPECT(result.start == result.end);
781}
782
783static void test_reflog_expire(void)
784{
785 char *dir = get_tmp_dir(__LINE__);
786
787 struct reftable_write_options cfg = { 0 };
788 struct reftable_stack *st = NULL;
789 struct reftable_log_record logs[20] = { { NULL } };
790 int N = ARRAY_SIZE(logs) - 1;
791 int i = 0;
792 int err;
793 struct reftable_log_expiry_config expiry = {
794 .time = 10,
795 };
796 struct reftable_log_record log = { NULL };
797
798
799 err = reftable_new_stack(&st, dir, cfg);
800 EXPECT_ERR(err);
801
802 for (i = 1; i <= N; i++) {
803 char buf[256];
804 snprintf(buf, sizeof(buf), "branch%02d", i);
805
806 logs[i].refname = xstrdup(buf);
807 logs[i].update_index = i;
808 logs[i].value_type = REFTABLE_LOG_UPDATE;
809 logs[i].value.update.time = i;
e48d4272
HWN		 810 logs[i].value.update.email = xstrdup("identity@invalid");
811 set_test_hash(logs[i].value.update.new_hash, i);
812 }
813
814 for (i = 1; i <= N; i++) {
815 struct write_log_arg arg = {
816 .log = &logs[i],
817 .update_index = reftable_stack_next_update_index(st),
818 };
819 int err = reftable_stack_add(st, &write_test_log, &arg);
820 EXPECT_ERR(err);
821 }
822
823 err = reftable_stack_compact_all(st, NULL);
824 EXPECT_ERR(err);
825
826 err = reftable_stack_compact_all(st, &expiry);
827 EXPECT_ERR(err);
828
829 err = reftable_stack_read_log(st, logs[9].refname, &log);
830 EXPECT(err == 1);
831
832 err = reftable_stack_read_log(st, logs[11].refname, &log);
833 EXPECT_ERR(err);
834
835 expiry.min_update_index = 15;
836 err = reftable_stack_compact_all(st, &expiry);
837 EXPECT_ERR(err);
838
839 err = reftable_stack_read_log(st, logs[14].refname, &log);
840 EXPECT(err == 1);
841
842 err = reftable_stack_read_log(st, logs[16].refname, &log);
843 EXPECT_ERR(err);
844
845 /* cleanup */
846 reftable_stack_destroy(st);
847 for (i = 0; i <= N; i++) {
848 reftable_log_record_release(&logs[i]);
849 }
850 clear_dir(dir);
851 reftable_log_record_release(&log);
852}
853
854static int write_nothing(struct reftable_writer *wr, void *arg)
855{
856 reftable_writer_set_limits(wr, 1, 1);
857 return 0;
858}
859
860static void test_empty_add(void)
861{
862 struct reftable_write_options cfg = { 0 };
863 struct reftable_stack *st = NULL;
864 int err;
865 char *dir = get_tmp_dir(__LINE__);
866
867 struct reftable_stack *st2 = NULL;
868
869
870 err = reftable_new_stack(&st, dir, cfg);
871 EXPECT_ERR(err);
872
873 err = reftable_stack_add(st, &write_nothing, NULL);
874 EXPECT_ERR(err);
875
876 err = reftable_new_stack(&st2, dir, cfg);
877 EXPECT_ERR(err);
878 clear_dir(dir);
879 reftable_stack_destroy(st);
880 reftable_stack_destroy(st2);
881}
882
883static void test_reftable_stack_auto_compaction(void)
884{
885 struct reftable_write_options cfg = { 0 };
886 struct reftable_stack *st = NULL;
887 char *dir = get_tmp_dir(__LINE__);
888
889 int err, i;
890 int N = 100;
891
892 err = reftable_new_stack(&st, dir, cfg);
893 EXPECT_ERR(err);
894
895 st->disable_auto_compact = 1; /* call manually below for coverage. */
896 for (i = 0; i < N; i++) {
897 char name[100];
898 struct reftable_ref_record ref = {
899 .refname = name,
900 .update_index = reftable_stack_next_update_index(st),
901 .value_type = REFTABLE_REF_SYMREF,
902 .value.symref = "master",
903 };
904 snprintf(name, sizeof(name), "branch%04d", i);
905
906 err = reftable_stack_add(st, &write_test_ref, &ref);
907 EXPECT_ERR(err);
908
909 err = reftable_stack_auto_compact(st);
f7445865 910 EXPECT_ERR(err);
e48d4272
HWN		 911 EXPECT(i < 3 || st->merged->stack_len < 2 * fastlog2(i));
912 }
913
914 EXPECT(reftable_stack_compaction_stats(st)->entries_written <
915 (uint64_t)(N * fastlog2(N)));
916
917 reftable_stack_destroy(st);
918 clear_dir(dir);
919}
920
15f98b60
PS		 921static void test_reftable_stack_add_performs_auto_compaction(void)
922{
923 struct reftable_write_options cfg = { 0 };
924 struct reftable_stack *st = NULL;
925 struct strbuf refname = STRBUF_INIT;
926 char *dir = get_tmp_dir(__LINE__);
927 int err, i, n = 20;
928
929 err = reftable_new_stack(&st, dir, cfg);
930 EXPECT_ERR(err);
931
932 for (i = 0; i <= n; i++) {
933 struct reftable_ref_record ref = {
934 .update_index = reftable_stack_next_update_index(st),
935 .value_type = REFTABLE_REF_SYMREF,
936 .value.symref = "master",
937 };
938
939 /*
940 * Disable auto-compaction for all but the last runs. Like this
941 * we can ensure that we indeed honor this setting and have
942 * better control over when exactly auto compaction runs.
943 */
944 st->disable_auto_compact = i != n;
945
946 strbuf_reset(&refname);
947 strbuf_addf(&refname, "branch-%04d", i);
948 ref.refname = refname.buf;
949
950 err = reftable_stack_add(st, &write_test_ref, &ref);
951 EXPECT_ERR(err);
952
953 /*
954 * The stack length should grow continuously for all runs where
955 * auto compaction is disabled. When enabled, we should merge
956 * all tables in the stack.
957 */
958 if (i != n)
959 EXPECT(st->merged->stack_len == i + 1);
960 else
961 EXPECT(st->merged->stack_len == 1);
962 }
963
964 reftable_stack_destroy(st);
965 strbuf_release(&refname);
966 clear_dir(dir);
967}
968
e48d4272
HWN		 969static void test_reftable_stack_compaction_concurrent(void)
970{
971 struct reftable_write_options cfg = { 0 };
972 struct reftable_stack *st1 = NULL, *st2 = NULL;
973 char *dir = get_tmp_dir(__LINE__);
974
975 int err, i;
976 int N = 3;
977
978 err = reftable_new_stack(&st1, dir, cfg);
979 EXPECT_ERR(err);
980
981 for (i = 0; i < N; i++) {
982 char name[100];
983 struct reftable_ref_record ref = {
984 .refname = name,
985 .update_index = reftable_stack_next_update_index(st1),
986 .value_type = REFTABLE_REF_SYMREF,
987 .value.symref = "master",
988 };
989 snprintf(name, sizeof(name), "branch%04d", i);
990
991 err = reftable_stack_add(st1, &write_test_ref, &ref);
992 EXPECT_ERR(err);
993 }
994
995 err = reftable_new_stack(&st2, dir, cfg);
996 EXPECT_ERR(err);
997
998 err = reftable_stack_compact_all(st1, NULL);
999 EXPECT_ERR(err);
1000
1001 reftable_stack_destroy(st1);
1002 reftable_stack_destroy(st2);
1003
1004 EXPECT(count_dir_entries(dir) == 2);
1005 clear_dir(dir);
1006}
1007
1008static void unclean_stack_close(struct reftable_stack *st)
1009{
1010 /* break abstraction boundary to simulate unclean shutdown. */
1011 int i = 0;
1012 for (; i < st->readers_len; i++) {
1013 reftable_reader_free(st->readers[i]);
1014 }
1015 st->readers_len = 0;
1016 FREE_AND_NULL(st->readers);
1017}
1018
1019static void test_reftable_stack_compaction_concurrent_clean(void)
1020{
1021 struct reftable_write_options cfg = { 0 };
1022 struct reftable_stack *st1 = NULL, *st2 = NULL, *st3 = NULL;
1023 char *dir = get_tmp_dir(__LINE__);
1024
1025 int err, i;
1026 int N = 3;
1027
1028 err = reftable_new_stack(&st1, dir, cfg);
1029 EXPECT_ERR(err);
1030
1031 for (i = 0; i < N; i++) {
1032 char name[100];
1033 struct reftable_ref_record ref = {
1034 .refname = name,
1035 .update_index = reftable_stack_next_update_index(st1),
1036 .value_type = REFTABLE_REF_SYMREF,
1037 .value.symref = "master",
1038 };
1039 snprintf(name, sizeof(name), "branch%04d", i);
1040
1041 err = reftable_stack_add(st1, &write_test_ref, &ref);
1042 EXPECT_ERR(err);
1043 }
1044
1045 err = reftable_new_stack(&st2, dir, cfg);
1046 EXPECT_ERR(err);
1047
1048 err = reftable_stack_compact_all(st1, NULL);
1049 EXPECT_ERR(err);
1050
1051 unclean_stack_close(st1);
1052 unclean_stack_close(st2);
1053
1054 err = reftable_new_stack(&st3, dir, cfg);
1055 EXPECT_ERR(err);
1056
1057 err = reftable_stack_clean(st3);
1058 EXPECT_ERR(err);
1059 EXPECT(count_dir_entries(dir) == 2);
1060
1061 reftable_stack_destroy(st1);
1062 reftable_stack_destroy(st2);
1063 reftable_stack_destroy(st3);
1064
1065 clear_dir(dir);
1066}
1067
1068int stack_test_main(int argc, const char *argv[])
1069{
1070 RUN_TEST(test_empty_add);
1071 RUN_TEST(test_log2);
1072 RUN_TEST(test_names_equal);
1073 RUN_TEST(test_parse_names);
1074 RUN_TEST(test_read_file);
1075 RUN_TEST(test_reflog_expire);
1076 RUN_TEST(test_reftable_stack_add);
1077 RUN_TEST(test_reftable_stack_add_one);
1078 RUN_TEST(test_reftable_stack_auto_compaction);
15f98b60 1079 RUN_TEST(test_reftable_stack_add_performs_auto_compaction);
e48d4272
HWN		 1080 RUN_TEST(test_reftable_stack_compaction_concurrent);
1081 RUN_TEST(test_reftable_stack_compaction_concurrent_clean);
1082 RUN_TEST(test_reftable_stack_hash_id);
1083 RUN_TEST(test_reftable_stack_lock_failure);
1084 RUN_TEST(test_reftable_stack_log_normalize);
1085 RUN_TEST(test_reftable_stack_tombstone);
1086 RUN_TEST(test_reftable_stack_transaction_api);
5c086453 1087 RUN_TEST(test_reftable_stack_transaction_api_performs_auto_compaction);
e48d4272
HWN		 1088 RUN_TEST(test_reftable_stack_update_index_check);
1089 RUN_TEST(test_reftable_stack_uptodate);
1090 RUN_TEST(test_reftable_stack_validate_refname);
1091 RUN_TEST(test_sizes_to_segments);
1092 RUN_TEST(test_sizes_to_segments_all_equal);
1093 RUN_TEST(test_sizes_to_segments_empty);
1094 RUN_TEST(test_suggest_compaction_segment);
1095 RUN_TEST(test_suggest_compaction_segment_nothing);
1096 return 0;
1097}
Unnamed repository; edit this file 'description' to name the repository.