]> git.ipfire.org Git - thirdparty/git.git/blob - reftable/stack_test.c
projects / thirdparty / git.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'ps/reftable-styles'
[thirdparty/git.git] / reftable / stack_test.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 "stack.h"
10
11 #include "system.h"
12
13 #include "reftable-reader.h"
14 #include "merged.h"
15 #include "basics.h"
16 #include "record.h"
17 #include "test_framework.h"
18 #include "reftable-tests.h"
19 #include "reader.h"
20
21 #include <sys/types.h>
22 #include <dirent.h>
23
24 static 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
32 static int count_dir_entries(const char *dirname)
33 {
34 DIR *dir = opendir(dirname);
35 int len = 0;
36 struct dirent *d;
37 if (!dir)
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 */
53 static 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
62 static char *get_tmp_dir(int linenumber)
63 {
64 char *dir = get_tmp_template(linenumber);
65 EXPECT(mkdtemp(dir));
66 return dir;
67 }
68
69 static 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);
80 n = write_in_full(fd, out, strlen(out));
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);
92 (void) remove(fn);
93 }
94
95 static 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
107 static 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
118 static 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
125 struct write_log_arg {
126 struct reftable_log_record *log;
127 uint64_t update_index;
128 };
129
130 static 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
138 static void test_reftable_stack_add_one(void)
139 {
140 char *dir = get_tmp_dir(__LINE__);
141 struct strbuf scratch = STRBUF_INIT;
142 int mask = umask(002);
143 struct reftable_write_options cfg = {
144 .default_permissions = 0660,
145 };
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 };
155 struct stat stat_result = { 0 };
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));
165 EXPECT(st->readers_len > 0);
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
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
193 reftable_ref_record_release(&dest);
194 reftable_stack_destroy(st);
195 strbuf_release(&scratch);
196 clear_dir(dir);
197 umask(mask);
198 }
199
200 static 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
247 static 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
291 static 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
346 static 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
384 static int write_error(struct reftable_writer *wr, void *arg)
385 {
386 return *((int *)arg);
387 }
388
389 static 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
421 static 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
440 static 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,
446 .default_permissions = 0660,
447 };
448 struct reftable_stack *st = NULL;
449 char *dir = get_tmp_dir(__LINE__);
450 struct reftable_ref_record refs[2] = { { NULL } };
451 struct reftable_log_record logs[2] = { { NULL } };
452 struct strbuf path = STRBUF_INIT;
453 struct stat stat_result;
454 int N = ARRAY_SIZE(refs);
455
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;
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;
471
472 logs[i].value.update.new_hash = reftable_malloc(GIT_SHA1_RAWSZ);
473 logs[i].value.update.email = xstrdup("identity@invalid");
474 set_test_hash(logs[i].value.update.new_hash, i);
475 }
476
477 for (i = 0; i < N; i++) {
478 int err = reftable_stack_add(st, &write_test_ref, &refs[i]);
479 EXPECT_ERR(err);
480 }
481
482 for (i = 0; i < N; i++) {
483 struct write_log_arg arg = {
484 .log = &logs[i],
485 .update_index = reftable_stack_next_update_index(st),
486 };
487 int err = reftable_stack_add(st, &write_test_log, &arg);
488 EXPECT_ERR(err);
489 }
490
491 err = reftable_stack_compact_all(st, NULL);
492 EXPECT_ERR(err);
493
494 for (i = 0; i < N; i++) {
495 struct reftable_ref_record dest = { NULL };
496
497 int err = reftable_stack_read_ref(st, refs[i].refname, &dest);
498 EXPECT_ERR(err);
499 EXPECT(reftable_ref_record_equal(&dest, refs + i,
500 GIT_SHA1_RAWSZ));
501 reftable_ref_record_release(&dest);
502 }
503
504 for (i = 0; i < N; i++) {
505 struct reftable_log_record dest = { NULL };
506 int err = reftable_stack_read_log(st, refs[i].refname, &dest);
507 EXPECT_ERR(err);
508 EXPECT(reftable_log_record_equal(&dest, logs + i,
509 GIT_SHA1_RAWSZ));
510 reftable_log_record_release(&dest);
511 }
512
513 #ifndef GIT_WINDOWS_NATIVE
514 strbuf_addstr(&path, dir);
515 strbuf_addstr(&path, "/tables.list");
516 err = stat(path.buf, &stat_result);
517 EXPECT(!err);
518 EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
519
520 strbuf_reset(&path);
521 strbuf_addstr(&path, dir);
522 strbuf_addstr(&path, "/");
523 /* do not try at home; not an external API for reftable. */
524 strbuf_addstr(&path, st->readers[0]->name);
525 err = stat(path.buf, &stat_result);
526 EXPECT(!err);
527 EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
528 #else
529 (void) stat_result;
530 #endif
531
532 /* cleanup */
533 reftable_stack_destroy(st);
534 for (i = 0; i < N; i++) {
535 reftable_ref_record_release(&refs[i]);
536 reftable_log_record_release(&logs[i]);
537 }
538 strbuf_release(&path);
539 clear_dir(dir);
540 }
541
542 static void test_reftable_stack_log_normalize(void)
543 {
544 int err = 0;
545 struct reftable_write_options cfg = {
546 0,
547 };
548 struct reftable_stack *st = NULL;
549 char *dir = get_tmp_dir(__LINE__);
550
551 uint8_t h1[GIT_SHA1_RAWSZ] = { 0x01 }, h2[GIT_SHA1_RAWSZ] = { 0x02 };
552
553 struct reftable_log_record input = { .refname = "branch",
554 .update_index = 1,
555 .value_type = REFTABLE_LOG_UPDATE,
556 .value = { .update = {
557 .new_hash = h1,
558 .old_hash = h2,
559 } } };
560 struct reftable_log_record dest = {
561 .update_index = 0,
562 };
563 struct write_log_arg arg = {
564 .log = &input,
565 .update_index = 1,
566 };
567
568 err = reftable_new_stack(&st, dir, cfg);
569 EXPECT_ERR(err);
570
571 input.value.update.message = "one\ntwo";
572 err = reftable_stack_add(st, &write_test_log, &arg);
573 EXPECT(err == REFTABLE_API_ERROR);
574
575 input.value.update.message = "one";
576 err = reftable_stack_add(st, &write_test_log, &arg);
577 EXPECT_ERR(err);
578
579 err = reftable_stack_read_log(st, input.refname, &dest);
580 EXPECT_ERR(err);
581 EXPECT(0 == strcmp(dest.value.update.message, "one\n"));
582
583 input.value.update.message = "two\n";
584 arg.update_index = 2;
585 err = reftable_stack_add(st, &write_test_log, &arg);
586 EXPECT_ERR(err);
587 err = reftable_stack_read_log(st, input.refname, &dest);
588 EXPECT_ERR(err);
589 EXPECT(0 == strcmp(dest.value.update.message, "two\n"));
590
591 /* cleanup */
592 reftable_stack_destroy(st);
593 reftable_log_record_release(&dest);
594 clear_dir(dir);
595 }
596
597 static void test_reftable_stack_tombstone(void)
598 {
599 int i = 0;
600 char *dir = get_tmp_dir(__LINE__);
601
602 struct reftable_write_options cfg = { 0 };
603 struct reftable_stack *st = NULL;
604 int err;
605 struct reftable_ref_record refs[2] = { { NULL } };
606 struct reftable_log_record logs[2] = { { NULL } };
607 int N = ARRAY_SIZE(refs);
608 struct reftable_ref_record dest = { NULL };
609 struct reftable_log_record log_dest = { NULL };
610
611
612 err = reftable_new_stack(&st, dir, cfg);
613 EXPECT_ERR(err);
614
615 /* even entries add the refs, odd entries delete them. */
616 for (i = 0; i < N; i++) {
617 const char *buf = "branch";
618 refs[i].refname = xstrdup(buf);
619 refs[i].update_index = i + 1;
620 if (i % 2 == 0) {
621 refs[i].value_type = REFTABLE_REF_VAL1;
622 set_test_hash(refs[i].value.val1, i);
623 }
624
625 logs[i].refname = xstrdup(buf);
626 /* update_index is part of the key. */
627 logs[i].update_index = 42;
628 if (i % 2 == 0) {
629 logs[i].value_type = REFTABLE_LOG_UPDATE;
630 logs[i].value.update.new_hash =
631 reftable_malloc(GIT_SHA1_RAWSZ);
632 set_test_hash(logs[i].value.update.new_hash, i);
633 logs[i].value.update.email =
634 xstrdup("identity@invalid");
635 }
636 }
637 for (i = 0; i < N; i++) {
638 int err = reftable_stack_add(st, &write_test_ref, &refs[i]);
639 EXPECT_ERR(err);
640 }
641
642 for (i = 0; i < N; i++) {
643 struct write_log_arg arg = {
644 .log = &logs[i],
645 .update_index = reftable_stack_next_update_index(st),
646 };
647 int err = reftable_stack_add(st, &write_test_log, &arg);
648 EXPECT_ERR(err);
649 }
650
651 err = reftable_stack_read_ref(st, "branch", &dest);
652 EXPECT(err == 1);
653 reftable_ref_record_release(&dest);
654
655 err = reftable_stack_read_log(st, "branch", &log_dest);
656 EXPECT(err == 1);
657 reftable_log_record_release(&log_dest);
658
659 err = reftable_stack_compact_all(st, NULL);
660 EXPECT_ERR(err);
661
662 err = reftable_stack_read_ref(st, "branch", &dest);
663 EXPECT(err == 1);
664
665 err = reftable_stack_read_log(st, "branch", &log_dest);
666 EXPECT(err == 1);
667 reftable_ref_record_release(&dest);
668 reftable_log_record_release(&log_dest);
669
670 /* cleanup */
671 reftable_stack_destroy(st);
672 for (i = 0; i < N; i++) {
673 reftable_ref_record_release(&refs[i]);
674 reftable_log_record_release(&logs[i]);
675 }
676 clear_dir(dir);
677 }
678
679 static void test_reftable_stack_hash_id(void)
680 {
681 char *dir = get_tmp_dir(__LINE__);
682
683 struct reftable_write_options cfg = { 0 };
684 struct reftable_stack *st = NULL;
685 int err;
686
687 struct reftable_ref_record ref = {
688 .refname = "master",
689 .value_type = REFTABLE_REF_SYMREF,
690 .value.symref = "target",
691 .update_index = 1,
692 };
693 struct reftable_write_options cfg32 = { .hash_id = GIT_SHA256_FORMAT_ID };
694 struct reftable_stack *st32 = NULL;
695 struct reftable_write_options cfg_default = { 0 };
696 struct reftable_stack *st_default = NULL;
697 struct reftable_ref_record dest = { NULL };
698
699 err = reftable_new_stack(&st, dir, cfg);
700 EXPECT_ERR(err);
701
702 err = reftable_stack_add(st, &write_test_ref, &ref);
703 EXPECT_ERR(err);
704
705 /* can't read it with the wrong hash ID. */
706 err = reftable_new_stack(&st32, dir, cfg32);
707 EXPECT(err == REFTABLE_FORMAT_ERROR);
708
709 /* check that we can read it back with default config too. */
710 err = reftable_new_stack(&st_default, dir, cfg_default);
711 EXPECT_ERR(err);
712
713 err = reftable_stack_read_ref(st_default, "master", &dest);
714 EXPECT_ERR(err);
715
716 EXPECT(reftable_ref_record_equal(&ref, &dest, GIT_SHA1_RAWSZ));
717 reftable_ref_record_release(&dest);
718 reftable_stack_destroy(st);
719 reftable_stack_destroy(st_default);
720 clear_dir(dir);
721 }
722
723 static void test_log2(void)
724 {
725 EXPECT(1 == fastlog2(3));
726 EXPECT(2 == fastlog2(4));
727 EXPECT(2 == fastlog2(5));
728 }
729
730 static void test_sizes_to_segments(void)
731 {
732 uint64_t sizes[] = { 2, 3, 4, 5, 7, 9 };
733 /* .................0 1 2 3 4 5 */
734
735 size_t seglen = 0;
736 struct segment *segs =
737 sizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));
738 EXPECT(segs[2].log == 3);
739 EXPECT(segs[2].start == 5);
740 EXPECT(segs[2].end == 6);
741
742 EXPECT(segs[1].log == 2);
743 EXPECT(segs[1].start == 2);
744 EXPECT(segs[1].end == 5);
745 reftable_free(segs);
746 }
747
748 static void test_sizes_to_segments_empty(void)
749 {
750 size_t seglen = 0;
751 struct segment *segs = sizes_to_segments(&seglen, NULL, 0);
752 EXPECT(seglen == 0);
753 reftable_free(segs);
754 }
755
756 static void test_sizes_to_segments_all_equal(void)
757 {
758 uint64_t sizes[] = { 5, 5 };
759 size_t seglen = 0;
760 struct segment *segs =
761 sizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));
762 EXPECT(seglen == 1);
763 EXPECT(segs[0].start == 0);
764 EXPECT(segs[0].end == 2);
765 reftable_free(segs);
766 }
767
768 static void test_suggest_compaction_segment(void)
769 {
770 uint64_t sizes[] = { 128, 64, 17, 16, 9, 9, 9, 16, 16 };
771 /* .................0 1 2 3 4 5 6 */
772 struct segment min =
773 suggest_compaction_segment(sizes, ARRAY_SIZE(sizes));
774 EXPECT(min.start == 2);
775 EXPECT(min.end == 7);
776 }
777
778 static void test_suggest_compaction_segment_nothing(void)
779 {
780 uint64_t sizes[] = { 64, 32, 16, 8, 4, 2 };
781 struct segment result =
782 suggest_compaction_segment(sizes, ARRAY_SIZE(sizes));
783 EXPECT(result.start == result.end);
784 }
785
786 static void test_reflog_expire(void)
787 {
788 char *dir = get_tmp_dir(__LINE__);
789
790 struct reftable_write_options cfg = { 0 };
791 struct reftable_stack *st = NULL;
792 struct reftable_log_record logs[20] = { { NULL } };
793 int N = ARRAY_SIZE(logs) - 1;
794 int i = 0;
795 int err;
796 struct reftable_log_expiry_config expiry = {
797 .time = 10,
798 };
799 struct reftable_log_record log = { NULL };
800
801
802 err = reftable_new_stack(&st, dir, cfg);
803 EXPECT_ERR(err);
804
805 for (i = 1; i <= N; i++) {
806 char buf[256];
807 snprintf(buf, sizeof(buf), "branch%02d", i);
808
809 logs[i].refname = xstrdup(buf);
810 logs[i].update_index = i;
811 logs[i].value_type = REFTABLE_LOG_UPDATE;
812 logs[i].value.update.time = i;
813 logs[i].value.update.new_hash = reftable_malloc(GIT_SHA1_RAWSZ);
814 logs[i].value.update.email = xstrdup("identity@invalid");
815 set_test_hash(logs[i].value.update.new_hash, i);
816 }
817
818 for (i = 1; i <= N; i++) {
819 struct write_log_arg arg = {
820 .log = &logs[i],
821 .update_index = reftable_stack_next_update_index(st),
822 };
823 int err = reftable_stack_add(st, &write_test_log, &arg);
824 EXPECT_ERR(err);
825 }
826
827 err = reftable_stack_compact_all(st, NULL);
828 EXPECT_ERR(err);
829
830 err = reftable_stack_compact_all(st, &expiry);
831 EXPECT_ERR(err);
832
833 err = reftable_stack_read_log(st, logs[9].refname, &log);
834 EXPECT(err == 1);
835
836 err = reftable_stack_read_log(st, logs[11].refname, &log);
837 EXPECT_ERR(err);
838
839 expiry.min_update_index = 15;
840 err = reftable_stack_compact_all(st, &expiry);
841 EXPECT_ERR(err);
842
843 err = reftable_stack_read_log(st, logs[14].refname, &log);
844 EXPECT(err == 1);
845
846 err = reftable_stack_read_log(st, logs[16].refname, &log);
847 EXPECT_ERR(err);
848
849 /* cleanup */
850 reftable_stack_destroy(st);
851 for (i = 0; i <= N; i++) {
852 reftable_log_record_release(&logs[i]);
853 }
854 clear_dir(dir);
855 reftable_log_record_release(&log);
856 }
857
858 static int write_nothing(struct reftable_writer *wr, void *arg)
859 {
860 reftable_writer_set_limits(wr, 1, 1);
861 return 0;
862 }
863
864 static void test_empty_add(void)
865 {
866 struct reftable_write_options cfg = { 0 };
867 struct reftable_stack *st = NULL;
868 int err;
869 char *dir = get_tmp_dir(__LINE__);
870
871 struct reftable_stack *st2 = NULL;
872
873
874 err = reftable_new_stack(&st, dir, cfg);
875 EXPECT_ERR(err);
876
877 err = reftable_stack_add(st, &write_nothing, NULL);
878 EXPECT_ERR(err);
879
880 err = reftable_new_stack(&st2, dir, cfg);
881 EXPECT_ERR(err);
882 clear_dir(dir);
883 reftable_stack_destroy(st);
884 reftable_stack_destroy(st2);
885 }
886
887 static void test_reftable_stack_auto_compaction(void)
888 {
889 struct reftable_write_options cfg = { 0 };
890 struct reftable_stack *st = NULL;
891 char *dir = get_tmp_dir(__LINE__);
892
893 int err, i;
894 int N = 100;
895
896 err = reftable_new_stack(&st, dir, cfg);
897 EXPECT_ERR(err);
898
899 st->disable_auto_compact = 1; /* call manually below for coverage. */
900 for (i = 0; i < N; i++) {
901 char name[100];
902 struct reftable_ref_record ref = {
903 .refname = name,
904 .update_index = reftable_stack_next_update_index(st),
905 .value_type = REFTABLE_REF_SYMREF,
906 .value.symref = "master",
907 };
908 snprintf(name, sizeof(name), "branch%04d", i);
909
910 err = reftable_stack_add(st, &write_test_ref, &ref);
911 EXPECT_ERR(err);
912
913 err = reftable_stack_auto_compact(st);
914 EXPECT_ERR(err);
915 EXPECT(i < 3 || st->merged->stack_len < 2 * fastlog2(i));
916 }
917
918 EXPECT(reftable_stack_compaction_stats(st)->entries_written <
919 (uint64_t)(N * fastlog2(N)));
920
921 reftable_stack_destroy(st);
922 clear_dir(dir);
923 }
924
925 static void test_reftable_stack_add_performs_auto_compaction(void)
926 {
927 struct reftable_write_options cfg = { 0 };
928 struct reftable_stack *st = NULL;
929 struct strbuf refname = STRBUF_INIT;
930 char *dir = get_tmp_dir(__LINE__);
931 int err, i, n = 20;
932
933 err = reftable_new_stack(&st, dir, cfg);
934 EXPECT_ERR(err);
935
936 for (i = 0; i <= n; i++) {
937 struct reftable_ref_record ref = {
938 .update_index = reftable_stack_next_update_index(st),
939 .value_type = REFTABLE_REF_SYMREF,
940 .value.symref = "master",
941 };
942
943 /*
944 * Disable auto-compaction for all but the last runs. Like this
945 * we can ensure that we indeed honor this setting and have
946 * better control over when exactly auto compaction runs.
947 */
948 st->disable_auto_compact = i != n;
949
950 strbuf_reset(&refname);
951 strbuf_addf(&refname, "branch-%04d", i);
952 ref.refname = refname.buf;
953
954 err = reftable_stack_add(st, &write_test_ref, &ref);
955 EXPECT_ERR(err);
956
957 /*
958 * The stack length should grow continuously for all runs where
959 * auto compaction is disabled. When enabled, we should merge
960 * all tables in the stack.
961 */
962 if (i != n)
963 EXPECT(st->merged->stack_len == i + 1);
964 else
965 EXPECT(st->merged->stack_len == 1);
966 }
967
968 reftable_stack_destroy(st);
969 strbuf_release(&refname);
970 clear_dir(dir);
971 }
972
973 static void test_reftable_stack_compaction_concurrent(void)
974 {
975 struct reftable_write_options cfg = { 0 };
976 struct reftable_stack *st1 = NULL, *st2 = NULL;
977 char *dir = get_tmp_dir(__LINE__);
978
979 int err, i;
980 int N = 3;
981
982 err = reftable_new_stack(&st1, dir, cfg);
983 EXPECT_ERR(err);
984
985 for (i = 0; i < N; i++) {
986 char name[100];
987 struct reftable_ref_record ref = {
988 .refname = name,
989 .update_index = reftable_stack_next_update_index(st1),
990 .value_type = REFTABLE_REF_SYMREF,
991 .value.symref = "master",
992 };
993 snprintf(name, sizeof(name), "branch%04d", i);
994
995 err = reftable_stack_add(st1, &write_test_ref, &ref);
996 EXPECT_ERR(err);
997 }
998
999 err = reftable_new_stack(&st2, dir, cfg);
1000 EXPECT_ERR(err);
1001
1002 err = reftable_stack_compact_all(st1, NULL);
1003 EXPECT_ERR(err);
1004
1005 reftable_stack_destroy(st1);
1006 reftable_stack_destroy(st2);
1007
1008 EXPECT(count_dir_entries(dir) == 2);
1009 clear_dir(dir);
1010 }
1011
1012 static void unclean_stack_close(struct reftable_stack *st)
1013 {
1014 /* break abstraction boundary to simulate unclean shutdown. */
1015 int i = 0;
1016 for (; i < st->readers_len; i++) {
1017 reftable_reader_free(st->readers[i]);
1018 }
1019 st->readers_len = 0;
1020 FREE_AND_NULL(st->readers);
1021 }
1022
1023 static void test_reftable_stack_compaction_concurrent_clean(void)
1024 {
1025 struct reftable_write_options cfg = { 0 };
1026 struct reftable_stack *st1 = NULL, *st2 = NULL, *st3 = NULL;
1027 char *dir = get_tmp_dir(__LINE__);
1028
1029 int err, i;
1030 int N = 3;
1031
1032 err = reftable_new_stack(&st1, dir, cfg);
1033 EXPECT_ERR(err);
1034
1035 for (i = 0; i < N; i++) {
1036 char name[100];
1037 struct reftable_ref_record ref = {
1038 .refname = name,
1039 .update_index = reftable_stack_next_update_index(st1),
1040 .value_type = REFTABLE_REF_SYMREF,
1041 .value.symref = "master",
1042 };
1043 snprintf(name, sizeof(name), "branch%04d", i);
1044
1045 err = reftable_stack_add(st1, &write_test_ref, &ref);
1046 EXPECT_ERR(err);
1047 }
1048
1049 err = reftable_new_stack(&st2, dir, cfg);
1050 EXPECT_ERR(err);
1051
1052 err = reftable_stack_compact_all(st1, NULL);
1053 EXPECT_ERR(err);
1054
1055 unclean_stack_close(st1);
1056 unclean_stack_close(st2);
1057
1058 err = reftable_new_stack(&st3, dir, cfg);
1059 EXPECT_ERR(err);
1060
1061 err = reftable_stack_clean(st3);
1062 EXPECT_ERR(err);
1063 EXPECT(count_dir_entries(dir) == 2);
1064
1065 reftable_stack_destroy(st1);
1066 reftable_stack_destroy(st2);
1067 reftable_stack_destroy(st3);
1068
1069 clear_dir(dir);
1070 }
1071
1072 int stack_test_main(int argc, const char *argv[])
1073 {
1074 RUN_TEST(test_empty_add);
1075 RUN_TEST(test_log2);
1076 RUN_TEST(test_names_equal);
1077 RUN_TEST(test_parse_names);
1078 RUN_TEST(test_read_file);
1079 RUN_TEST(test_reflog_expire);
1080 RUN_TEST(test_reftable_stack_add);
1081 RUN_TEST(test_reftable_stack_add_one);
1082 RUN_TEST(test_reftable_stack_auto_compaction);
1083 RUN_TEST(test_reftable_stack_add_performs_auto_compaction);
1084 RUN_TEST(test_reftable_stack_compaction_concurrent);
1085 RUN_TEST(test_reftable_stack_compaction_concurrent_clean);
1086 RUN_TEST(test_reftable_stack_hash_id);
1087 RUN_TEST(test_reftable_stack_lock_failure);
1088 RUN_TEST(test_reftable_stack_log_normalize);
1089 RUN_TEST(test_reftable_stack_tombstone);
1090 RUN_TEST(test_reftable_stack_transaction_api);
1091 RUN_TEST(test_reftable_stack_transaction_api_performs_auto_compaction);
1092 RUN_TEST(test_reftable_stack_update_index_check);
1093 RUN_TEST(test_reftable_stack_uptodate);
1094 RUN_TEST(test_reftable_stack_validate_refname);
1095 RUN_TEST(test_sizes_to_segments);
1096 RUN_TEST(test_sizes_to_segments_all_equal);
1097 RUN_TEST(test_sizes_to_segments_empty);
1098 RUN_TEST(test_suggest_compaction_segment);
1099 RUN_TEST(test_suggest_compaction_segment_nothing);
1100 return 0;
1101 }
Unnamed repository; edit this file 'description' to name the repository.