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 "constants.h"
  17 #include "record.h"
  18 #include "test_framework.h"
  19 #include "reftable-tests.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 == NULL)
  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(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         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
 142         struct reftable_write_options cfg = { 0 };
 143         struct reftable_stack *st = NULL;
 144         int err;
 145         struct reftable_ref_record ref = {
 146                 .refname = "HEAD",
 147                 .update_index = 1,
 148                 .value_type = REFTABLE_REF_SYMREF,
 149                 .value.symref = "master",
 150         };
 151         struct reftable_ref_record dest = { NULL };
 152
 153
 154         err = reftable_new_stack(&st, dir, cfg);
 155         EXPECT_ERR(err);
 156
 157         err = reftable_stack_add(st, &write_test_ref, &ref);
 158         EXPECT_ERR(err);
 159
 160         err = reftable_stack_read_ref(st, ref.refname, &dest);
 161         EXPECT_ERR(err);
 162         EXPECT(0 == strcmp("master", dest.value.symref));
 163
 164         printf("testing print functionality:\n");
 165         err = reftable_stack_print_directory(dir, GIT_SHA1_FORMAT_ID);
 166         EXPECT_ERR(err);
 167
 168         err = reftable_stack_print_directory(dir, GIT_SHA256_FORMAT_ID);
 169         EXPECT(err == REFTABLE_FORMAT_ERROR);
 170
 171         reftable_ref_record_release(&dest);
 172         reftable_stack_destroy(st);
 173         clear_dir(dir);
 174 }
 175
 176 static void test_reftable_stack_uptodate(void)
 177 {
 178         struct reftable_write_options cfg = { 0 };
 179         struct reftable_stack *st1 = NULL;
 180         struct reftable_stack *st2 = NULL;
 181         char *dir = get_tmp_dir(__LINE__);
 182
 183         int err;
 184         struct reftable_ref_record ref1 = {
 185                 .refname = "HEAD",
 186                 .update_index = 1,
 187                 .value_type = REFTABLE_REF_SYMREF,
 188                 .value.symref = "master",
 189         };
 190         struct reftable_ref_record ref2 = {
 191                 .refname = "branch2",
 192                 .update_index = 2,
 193                 .value_type = REFTABLE_REF_SYMREF,
 194                 .value.symref = "master",
 195         };
 196
 197
 198         /* simulate multi-process access to the same stack
 199            by creating two stacks for the same directory.
 200          */
 201         err = reftable_new_stack(&st1, dir, cfg);
 202         EXPECT_ERR(err);
 203
 204         err = reftable_new_stack(&st2, dir, cfg);
 205         EXPECT_ERR(err);
 206
 207         err = reftable_stack_add(st1, &write_test_ref, &ref1);
 208         EXPECT_ERR(err);
 209
 210         err = reftable_stack_add(st2, &write_test_ref, &ref2);
 211         EXPECT(err == REFTABLE_LOCK_ERROR);
 212
 213         err = reftable_stack_reload(st2);
 214         EXPECT_ERR(err);
 215
 216         err = reftable_stack_add(st2, &write_test_ref, &ref2);
 217         EXPECT_ERR(err);
 218         reftable_stack_destroy(st1);
 219         reftable_stack_destroy(st2);
 220         clear_dir(dir);
 221 }
 222
 223 static void test_reftable_stack_transaction_api(void)
 224 {
 225         char *dir = get_tmp_dir(__LINE__);
 226
 227         struct reftable_write_options cfg = { 0 };
 228         struct reftable_stack *st = NULL;
 229         int err;
 230         struct reftable_addition *add = NULL;
 231
 232         struct reftable_ref_record ref = {
 233                 .refname = "HEAD",
 234                 .update_index = 1,
 235                 .value_type = REFTABLE_REF_SYMREF,
 236                 .value.symref = "master",
 237         };
 238         struct reftable_ref_record dest = { NULL };
 239
 240
 241         err = reftable_new_stack(&st, dir, cfg);
 242         EXPECT_ERR(err);
 243
 244         reftable_addition_destroy(add);
 245
 246         err = reftable_stack_new_addition(&add, st);
 247         EXPECT_ERR(err);
 248
 249         err = reftable_addition_add(add, &write_test_ref, &ref);
 250         EXPECT_ERR(err);
 251
 252         err = reftable_addition_commit(add);
 253         EXPECT_ERR(err);
 254
 255         reftable_addition_destroy(add);
 256
 257         err = reftable_stack_read_ref(st, ref.refname, &dest);
 258         EXPECT_ERR(err);
 259         EXPECT(REFTABLE_REF_SYMREF == dest.value_type);
 260         EXPECT(0 == strcmp("master", dest.value.symref));
 261
 262         reftable_ref_record_release(&dest);
 263         reftable_stack_destroy(st);
 264         clear_dir(dir);
 265 }
 266
 267 static void test_reftable_stack_validate_refname(void)
 268 {
 269         struct reftable_write_options cfg = { 0 };
 270         struct reftable_stack *st = NULL;
 271         int err;
 272         char *dir = get_tmp_dir(__LINE__);
 273
 274         int i;
 275         struct reftable_ref_record ref = {
 276                 .refname = "a/b",
 277                 .update_index = 1,
 278                 .value_type = REFTABLE_REF_SYMREF,
 279                 .value.symref = "master",
 280         };
 281         char *additions[] = { "a", "a/b/c" };
 282
 283         err = reftable_new_stack(&st, dir, cfg);
 284         EXPECT_ERR(err);
 285
 286         err = reftable_stack_add(st, &write_test_ref, &ref);
 287         EXPECT_ERR(err);
 288
 289         for (i = 0; i < ARRAY_SIZE(additions); i++) {
 290                 struct reftable_ref_record ref = {
 291                         .refname = additions[i],
 292                         .update_index = 1,
 293                         .value_type = REFTABLE_REF_SYMREF,
 294                         .value.symref = "master",
 295                 };
 296
 297                 err = reftable_stack_add(st, &write_test_ref, &ref);
 298                 EXPECT(err == REFTABLE_NAME_CONFLICT);
 299         }
 300
 301         reftable_stack_destroy(st);
 302         clear_dir(dir);
 303 }
 304
 305 static int write_error(struct reftable_writer *wr, void *arg)
 306 {
 307         return *((int *)arg);
 308 }
 309
 310 static void test_reftable_stack_update_index_check(void)
 311 {
 312         char *dir = get_tmp_dir(__LINE__);
 313
 314         struct reftable_write_options cfg = { 0 };
 315         struct reftable_stack *st = NULL;
 316         int err;
 317         struct reftable_ref_record ref1 = {
 318                 .refname = "name1",
 319                 .update_index = 1,
 320                 .value_type = REFTABLE_REF_SYMREF,
 321                 .value.symref = "master",
 322         };
 323         struct reftable_ref_record ref2 = {
 324                 .refname = "name2",
 325                 .update_index = 1,
 326                 .value_type = REFTABLE_REF_SYMREF,
 327                 .value.symref = "master",
 328         };
 329
 330         err = reftable_new_stack(&st, dir, cfg);
 331         EXPECT_ERR(err);
 332
 333         err = reftable_stack_add(st, &write_test_ref, &ref1);
 334         EXPECT_ERR(err);
 335
 336         err = reftable_stack_add(st, &write_test_ref, &ref2);
 337         EXPECT(err == REFTABLE_API_ERROR);
 338         reftable_stack_destroy(st);
 339         clear_dir(dir);
 340 }
 341
 342 static void test_reftable_stack_lock_failure(void)
 343 {
 344         char *dir = get_tmp_dir(__LINE__);
 345
 346         struct reftable_write_options cfg = { 0 };
 347         struct reftable_stack *st = NULL;
 348         int err, i;
 349
 350         err = reftable_new_stack(&st, dir, cfg);
 351         EXPECT_ERR(err);
 352         for (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {
 353                 err = reftable_stack_add(st, &write_error, &i);
 354                 EXPECT(err == i);
 355         }
 356
 357         reftable_stack_destroy(st);
 358         clear_dir(dir);
 359 }
 360
 361 static void test_reftable_stack_add(void)
 362 {
 363         int i = 0;
 364         int err = 0;
 365         struct reftable_write_options cfg = {
 366                 .exact_log_message = 1,
 367         };
 368         struct reftable_stack *st = NULL;
 369         char *dir = get_tmp_dir(__LINE__);
 370
 371         struct reftable_ref_record refs[2] = { { NULL } };
 372         struct reftable_log_record logs[2] = { { NULL } };
 373         int N = ARRAY_SIZE(refs);
 374
 375
 376         err = reftable_new_stack(&st, dir, cfg);
 377         EXPECT_ERR(err);
 378         st->disable_auto_compact = 1;
 379
 380         for (i = 0; i < N; i++) {
 381                 char buf[256];
 382                 snprintf(buf, sizeof(buf), "branch%02d", i);
 383                 refs[i].refname = xstrdup(buf);
 384                 refs[i].update_index = i + 1;
 385                 refs[i].value_type = REFTABLE_REF_VAL1;
 386                 refs[i].value.val1 = reftable_malloc(GIT_SHA1_RAWSZ);
 387                 set_test_hash(refs[i].value.val1, i);
 388
 389                 logs[i].refname = xstrdup(buf);
 390                 logs[i].update_index = N + i + 1;
 391                 logs[i].value_type = REFTABLE_LOG_UPDATE;
 392
 393                 logs[i].value.update.new_hash = reftable_malloc(GIT_SHA1_RAWSZ);
 394                 logs[i].value.update.email = xstrdup("identity@invalid");
 395                 set_test_hash(logs[i].value.update.new_hash, i);
 396         }
 397
 398         for (i = 0; i < N; i++) {
 399                 int err = reftable_stack_add(st, &write_test_ref, &refs[i]);
 400                 EXPECT_ERR(err);
 401         }
 402
 403         for (i = 0; i < N; i++) {
 404                 struct write_log_arg arg = {
 405                         .log = &logs[i],
 406                         .update_index = reftable_stack_next_update_index(st),
 407                 };
 408                 int err = reftable_stack_add(st, &write_test_log, &arg);
 409                 EXPECT_ERR(err);
 410         }
 411
 412         err = reftable_stack_compact_all(st, NULL);
 413         EXPECT_ERR(err);
 414
 415         for (i = 0; i < N; i++) {
 416                 struct reftable_ref_record dest = { NULL };
 417
 418                 int err = reftable_stack_read_ref(st, refs[i].refname, &dest);
 419                 EXPECT_ERR(err);
 420                 EXPECT(reftable_ref_record_equal(&dest, refs + i,
 421                                                  GIT_SHA1_RAWSZ));
 422                 reftable_ref_record_release(&dest);
 423         }
 424
 425         for (i = 0; i < N; i++) {
 426                 struct reftable_log_record dest = { NULL };
 427                 int err = reftable_stack_read_log(st, refs[i].refname, &dest);
 428                 EXPECT_ERR(err);
 429                 EXPECT(reftable_log_record_equal(&dest, logs + i,
 430                                                  GIT_SHA1_RAWSZ));
 431                 reftable_log_record_release(&dest);
 432         }
 433
 434         /* cleanup */
 435         reftable_stack_destroy(st);
 436         for (i = 0; i < N; i++) {
 437                 reftable_ref_record_release(&refs[i]);
 438                 reftable_log_record_release(&logs[i]);
 439         }
 440         clear_dir(dir);
 441 }
 442
 443 static void test_reftable_stack_log_normalize(void)
 444 {
 445         int err = 0;
 446         struct reftable_write_options cfg = {
 447                 0,
 448         };
 449         struct reftable_stack *st = NULL;
 450         char *dir = get_tmp_dir(__LINE__);
 451
 452         uint8_t h1[GIT_SHA1_RAWSZ] = { 0x01 }, h2[GIT_SHA1_RAWSZ] = { 0x02 };
 453
 454         struct reftable_log_record input = { .refname = "branch",
 455                                              .update_index = 1,
 456                                              .value_type = REFTABLE_LOG_UPDATE,
 457                                              .value = { .update = {
 458                                                                 .new_hash = h1,
 459                                                                 .old_hash = h2,
 460                                                         } } };
 461         struct reftable_log_record dest = {
 462                 .update_index = 0,
 463         };
 464         struct write_log_arg arg = {
 465                 .log = &input,
 466                 .update_index = 1,
 467         };
 468
 469         err = reftable_new_stack(&st, dir, cfg);
 470         EXPECT_ERR(err);
 471
 472         input.value.update.message = "one\ntwo";
 473         err = reftable_stack_add(st, &write_test_log, &arg);
 474         EXPECT(err == REFTABLE_API_ERROR);
 475
 476         input.value.update.message = "one";
 477         err = reftable_stack_add(st, &write_test_log, &arg);
 478         EXPECT_ERR(err);
 479
 480         err = reftable_stack_read_log(st, input.refname, &dest);
 481         EXPECT_ERR(err);
 482         EXPECT(0 == strcmp(dest.value.update.message, "one\n"));
 483
 484         input.value.update.message = "two\n";
 485         arg.update_index = 2;
 486         err = reftable_stack_add(st, &write_test_log, &arg);
 487         EXPECT_ERR(err);
 488         err = reftable_stack_read_log(st, input.refname, &dest);
 489         EXPECT_ERR(err);
 490         EXPECT(0 == strcmp(dest.value.update.message, "two\n"));
 491
 492         /* cleanup */
 493         reftable_stack_destroy(st);
 494         reftable_log_record_release(&dest);
 495         clear_dir(dir);
 496 }
 497
 498 static void test_reftable_stack_tombstone(void)
 499 {
 500         int i = 0;
 501         char *dir = get_tmp_dir(__LINE__);
 502
 503         struct reftable_write_options cfg = { 0 };
 504         struct reftable_stack *st = NULL;
 505         int err;
 506         struct reftable_ref_record refs[2] = { { NULL } };
 507         struct reftable_log_record logs[2] = { { NULL } };
 508         int N = ARRAY_SIZE(refs);
 509         struct reftable_ref_record dest = { NULL };
 510         struct reftable_log_record log_dest = { NULL };
 511
 512
 513         err = reftable_new_stack(&st, dir, cfg);
 514         EXPECT_ERR(err);
 515
 516         /* even entries add the refs, odd entries delete them. */
 517         for (i = 0; i < N; i++) {
 518                 const char *buf = "branch";
 519                 refs[i].refname = xstrdup(buf);
 520                 refs[i].update_index = i + 1;
 521                 if (i % 2 == 0) {
 522                         refs[i].value_type = REFTABLE_REF_VAL1;
 523                         refs[i].value.val1 = reftable_malloc(GIT_SHA1_RAWSZ);
 524                         set_test_hash(refs[i].value.val1, i);
 525                 }
 526
 527                 logs[i].refname = xstrdup(buf);
 528                 /* update_index is part of the key. */
 529                 logs[i].update_index = 42;
 530                 if (i % 2 == 0) {
 531                         logs[i].value_type = REFTABLE_LOG_UPDATE;
 532                         logs[i].value.update.new_hash =
 533                                 reftable_malloc(GIT_SHA1_RAWSZ);
 534                         set_test_hash(logs[i].value.update.new_hash, i);
 535                         logs[i].value.update.email =
 536                                 xstrdup("identity@invalid");
 537                 }
 538         }
 539         for (i = 0; i < N; i++) {
 540                 int err = reftable_stack_add(st, &write_test_ref, &refs[i]);
 541                 EXPECT_ERR(err);
 542         }
 543
 544         for (i = 0; i < N; i++) {
 545                 struct write_log_arg arg = {
 546                         .log = &logs[i],
 547                         .update_index = reftable_stack_next_update_index(st),
 548                 };
 549                 int err = reftable_stack_add(st, &write_test_log, &arg);
 550                 EXPECT_ERR(err);
 551         }
 552
 553         err = reftable_stack_read_ref(st, "branch", &dest);
 554         EXPECT(err == 1);
 555         reftable_ref_record_release(&dest);
 556
 557         err = reftable_stack_read_log(st, "branch", &log_dest);
 558         EXPECT(err == 1);
 559         reftable_log_record_release(&log_dest);
 560
 561         err = reftable_stack_compact_all(st, NULL);
 562         EXPECT_ERR(err);
 563
 564         err = reftable_stack_read_ref(st, "branch", &dest);
 565         EXPECT(err == 1);
 566
 567         err = reftable_stack_read_log(st, "branch", &log_dest);
 568         EXPECT(err == 1);
 569         reftable_ref_record_release(&dest);
 570         reftable_log_record_release(&log_dest);
 571
 572         /* cleanup */
 573         reftable_stack_destroy(st);
 574         for (i = 0; i < N; i++) {
 575                 reftable_ref_record_release(&refs[i]);
 576                 reftable_log_record_release(&logs[i]);
 577         }
 578         clear_dir(dir);
 579 }
 580
 581 static void test_reftable_stack_hash_id(void)
 582 {
 583         char *dir = get_tmp_dir(__LINE__);
 584
 585         struct reftable_write_options cfg = { 0 };
 586         struct reftable_stack *st = NULL;
 587         int err;
 588
 589         struct reftable_ref_record ref = {
 590                 .refname = "master",
 591                 .value_type = REFTABLE_REF_SYMREF,
 592                 .value.symref = "target",
 593                 .update_index = 1,
 594         };
 595         struct reftable_write_options cfg32 = { .hash_id = GIT_SHA256_FORMAT_ID };
 596         struct reftable_stack *st32 = NULL;
 597         struct reftable_write_options cfg_default = { 0 };
 598         struct reftable_stack *st_default = NULL;
 599         struct reftable_ref_record dest = { NULL };
 600
 601         err = reftable_new_stack(&st, dir, cfg);
 602         EXPECT_ERR(err);
 603
 604         err = reftable_stack_add(st, &write_test_ref, &ref);
 605         EXPECT_ERR(err);
 606
 607         /* can't read it with the wrong hash ID. */
 608         err = reftable_new_stack(&st32, dir, cfg32);
 609         EXPECT(err == REFTABLE_FORMAT_ERROR);
 610
 611         /* check that we can read it back with default config too. */
 612         err = reftable_new_stack(&st_default, dir, cfg_default);
 613         EXPECT_ERR(err);
 614
 615         err = reftable_stack_read_ref(st_default, "master", &dest);
 616         EXPECT_ERR(err);
 617
 618         EXPECT(reftable_ref_record_equal(&ref, &dest, GIT_SHA1_RAWSZ));
 619         reftable_ref_record_release(&dest);
 620         reftable_stack_destroy(st);
 621         reftable_stack_destroy(st_default);
 622         clear_dir(dir);
 623 }
 624
 625 static void test_log2(void)
 626 {
 627         EXPECT(1 == fastlog2(3));
 628         EXPECT(2 == fastlog2(4));
 629         EXPECT(2 == fastlog2(5));
 630 }
 631
 632 static void test_sizes_to_segments(void)
 633 {
 634         uint64_t sizes[] = { 2, 3, 4, 5, 7, 9 };
 635         /* .................0  1  2  3  4  5 */
 636
 637         int seglen = 0;
 638         struct segment *segs =
 639                 sizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));
 640         EXPECT(segs[2].log == 3);
 641         EXPECT(segs[2].start == 5);
 642         EXPECT(segs[2].end == 6);
 643
 644         EXPECT(segs[1].log == 2);
 645         EXPECT(segs[1].start == 2);
 646         EXPECT(segs[1].end == 5);
 647         reftable_free(segs);
 648 }
 649
 650 static void test_sizes_to_segments_empty(void)
 651 {
 652         int seglen = 0;
 653         struct segment *segs = sizes_to_segments(&seglen, NULL, 0);
 654         EXPECT(seglen == 0);
 655         reftable_free(segs);
 656 }
 657
 658 static void test_sizes_to_segments_all_equal(void)
 659 {
 660         uint64_t sizes[] = { 5, 5 };
 661
 662         int seglen = 0;
 663         struct segment *segs =
 664                 sizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));
 665         EXPECT(seglen == 1);
 666         EXPECT(segs[0].start == 0);
 667         EXPECT(segs[0].end == 2);
 668         reftable_free(segs);
 669 }
 670
 671 static void test_suggest_compaction_segment(void)
 672 {
 673         uint64_t sizes[] = { 128, 64, 17, 16, 9, 9, 9, 16, 16 };
 674         /* .................0    1    2  3   4  5  6 */
 675         struct segment min =
 676                 suggest_compaction_segment(sizes, ARRAY_SIZE(sizes));
 677         EXPECT(min.start == 2);
 678         EXPECT(min.end == 7);
 679 }
 680
 681 static void test_suggest_compaction_segment_nothing(void)
 682 {
 683         uint64_t sizes[] = { 64, 32, 16, 8, 4, 2 };
 684         struct segment result =
 685                 suggest_compaction_segment(sizes, ARRAY_SIZE(sizes));
 686         EXPECT(result.start == result.end);
 687 }
 688
 689 static void test_reflog_expire(void)
 690 {
 691         char *dir = get_tmp_dir(__LINE__);
 692
 693         struct reftable_write_options cfg = { 0 };
 694         struct reftable_stack *st = NULL;
 695         struct reftable_log_record logs[20] = { { NULL } };
 696         int N = ARRAY_SIZE(logs) - 1;
 697         int i = 0;
 698         int err;
 699         struct reftable_log_expiry_config expiry = {
 700                 .time = 10,
 701         };
 702         struct reftable_log_record log = { NULL };
 703
 704
 705         err = reftable_new_stack(&st, dir, cfg);
 706         EXPECT_ERR(err);
 707
 708         for (i = 1; i <= N; i++) {
 709                 char buf[256];
 710                 snprintf(buf, sizeof(buf), "branch%02d", i);
 711
 712                 logs[i].refname = xstrdup(buf);
 713                 logs[i].update_index = i;
 714                 logs[i].value_type = REFTABLE_LOG_UPDATE;
 715                 logs[i].value.update.time = i;
 716                 logs[i].value.update.new_hash = reftable_malloc(GIT_SHA1_RAWSZ);
 717                 logs[i].value.update.email = xstrdup("identity@invalid");
 718                 set_test_hash(logs[i].value.update.new_hash, i);
 719         }
 720
 721         for (i = 1; i <= N; i++) {
 722                 struct write_log_arg arg = {
 723                         .log = &logs[i],
 724                         .update_index = reftable_stack_next_update_index(st),
 725                 };
 726                 int err = reftable_stack_add(st, &write_test_log, &arg);
 727                 EXPECT_ERR(err);
 728         }
 729
 730         err = reftable_stack_compact_all(st, NULL);
 731         EXPECT_ERR(err);
 732
 733         err = reftable_stack_compact_all(st, &expiry);
 734         EXPECT_ERR(err);
 735
 736         err = reftable_stack_read_log(st, logs[9].refname, &log);
 737         EXPECT(err == 1);
 738
 739         err = reftable_stack_read_log(st, logs[11].refname, &log);
 740         EXPECT_ERR(err);
 741
 742         expiry.min_update_index = 15;
 743         err = reftable_stack_compact_all(st, &expiry);
 744         EXPECT_ERR(err);
 745
 746         err = reftable_stack_read_log(st, logs[14].refname, &log);
 747         EXPECT(err == 1);
 748
 749         err = reftable_stack_read_log(st, logs[16].refname, &log);
 750         EXPECT_ERR(err);
 751
 752         /* cleanup */
 753         reftable_stack_destroy(st);
 754         for (i = 0; i <= N; i++) {
 755                 reftable_log_record_release(&logs[i]);
 756         }
 757         clear_dir(dir);
 758         reftable_log_record_release(&log);
 759 }
 760
 761 static int write_nothing(struct reftable_writer *wr, void *arg)
 762 {
 763         reftable_writer_set_limits(wr, 1, 1);
 764         return 0;
 765 }
 766
 767 static void test_empty_add(void)
 768 {
 769         struct reftable_write_options cfg = { 0 };
 770         struct reftable_stack *st = NULL;
 771         int err;
 772         char *dir = get_tmp_dir(__LINE__);
 773
 774         struct reftable_stack *st2 = NULL;
 775
 776
 777         err = reftable_new_stack(&st, dir, cfg);
 778         EXPECT_ERR(err);
 779
 780         err = reftable_stack_add(st, &write_nothing, NULL);
 781         EXPECT_ERR(err);
 782
 783         err = reftable_new_stack(&st2, dir, cfg);
 784         EXPECT_ERR(err);
 785         clear_dir(dir);
 786         reftable_stack_destroy(st);
 787         reftable_stack_destroy(st2);
 788 }
 789
 790 static void test_reftable_stack_auto_compaction(void)
 791 {
 792         struct reftable_write_options cfg = { 0 };
 793         struct reftable_stack *st = NULL;
 794         char *dir = get_tmp_dir(__LINE__);
 795
 796         int err, i;
 797         int N = 100;
 798
 799         err = reftable_new_stack(&st, dir, cfg);
 800         EXPECT_ERR(err);
 801
 802         st->disable_auto_compact = 1; /* call manually below for coverage. */
 803         for (i = 0; i < N; i++) {
 804                 char name[100];
 805                 struct reftable_ref_record ref = {
 806                         .refname = name,
 807                         .update_index = reftable_stack_next_update_index(st),
 808                         .value_type = REFTABLE_REF_SYMREF,
 809                         .value.symref = "master",
 810                 };
 811                 snprintf(name, sizeof(name), "branch%04d", i);
 812
 813                 err = reftable_stack_add(st, &write_test_ref, &ref);
 814                 EXPECT_ERR(err);
 815
 816                 err = reftable_stack_auto_compact(st);
 817                 EXPECT(i < 3 || st->merged->stack_len < 2 * fastlog2(i));
 818         }
 819
 820         EXPECT(reftable_stack_compaction_stats(st)->entries_written <
 821                (uint64_t)(N * fastlog2(N)));
 822
 823         reftable_stack_destroy(st);
 824         clear_dir(dir);
 825 }
 826
 827 static void test_reftable_stack_compaction_concurrent(void)
 828 {
 829         struct reftable_write_options cfg = { 0 };
 830         struct reftable_stack *st1 = NULL, *st2 = NULL;
 831         char *dir = get_tmp_dir(__LINE__);
 832
 833         int err, i;
 834         int N = 3;
 835
 836         err = reftable_new_stack(&st1, dir, cfg);
 837         EXPECT_ERR(err);
 838
 839         for (i = 0; i < N; i++) {
 840                 char name[100];
 841                 struct reftable_ref_record ref = {
 842                         .refname = name,
 843                         .update_index = reftable_stack_next_update_index(st1),
 844                         .value_type = REFTABLE_REF_SYMREF,
 845                         .value.symref = "master",
 846                 };
 847                 snprintf(name, sizeof(name), "branch%04d", i);
 848
 849                 err = reftable_stack_add(st1, &write_test_ref, &ref);
 850                 EXPECT_ERR(err);
 851         }
 852
 853         err = reftable_new_stack(&st2, dir, cfg);
 854         EXPECT_ERR(err);
 855
 856         err = reftable_stack_compact_all(st1, NULL);
 857         EXPECT_ERR(err);
 858
 859         reftable_stack_destroy(st1);
 860         reftable_stack_destroy(st2);
 861
 862         EXPECT(count_dir_entries(dir) == 2);
 863         clear_dir(dir);
 864 }
 865
 866 static void unclean_stack_close(struct reftable_stack *st)
 867 {
 868         /* break abstraction boundary to simulate unclean shutdown. */
 869         int i = 0;
 870         for (; i < st->readers_len; i++) {
 871                 reftable_reader_free(st->readers[i]);
 872         }
 873         st->readers_len = 0;
 874         FREE_AND_NULL(st->readers);
 875 }
 876
 877 static void test_reftable_stack_compaction_concurrent_clean(void)
 878 {
 879         struct reftable_write_options cfg = { 0 };
 880         struct reftable_stack *st1 = NULL, *st2 = NULL, *st3 = NULL;
 881         char *dir = get_tmp_dir(__LINE__);
 882
 883         int err, i;
 884         int N = 3;
 885
 886         err = reftable_new_stack(&st1, dir, cfg);
 887         EXPECT_ERR(err);
 888
 889         for (i = 0; i < N; i++) {
 890                 char name[100];
 891                 struct reftable_ref_record ref = {
 892                         .refname = name,
 893                         .update_index = reftable_stack_next_update_index(st1),
 894                         .value_type = REFTABLE_REF_SYMREF,
 895                         .value.symref = "master",
 896                 };
 897                 snprintf(name, sizeof(name), "branch%04d", i);
 898
 899                 err = reftable_stack_add(st1, &write_test_ref, &ref);
 900                 EXPECT_ERR(err);
 901         }
 902
 903         err = reftable_new_stack(&st2, dir, cfg);
 904         EXPECT_ERR(err);
 905
 906         err = reftable_stack_compact_all(st1, NULL);
 907         EXPECT_ERR(err);
 908
 909         unclean_stack_close(st1);
 910         unclean_stack_close(st2);
 911
 912         err = reftable_new_stack(&st3, dir, cfg);
 913         EXPECT_ERR(err);
 914
 915         err = reftable_stack_clean(st3);
 916         EXPECT_ERR(err);
 917         EXPECT(count_dir_entries(dir) == 2);
 918
 919         reftable_stack_destroy(st1);
 920         reftable_stack_destroy(st2);
 921         reftable_stack_destroy(st3);
 922
 923         clear_dir(dir);
 924 }
 925
 926 int stack_test_main(int argc, const char *argv[])
 927 {
 928         RUN_TEST(test_empty_add);
 929         RUN_TEST(test_log2);
 930         RUN_TEST(test_names_equal);
 931         RUN_TEST(test_parse_names);
 932         RUN_TEST(test_read_file);
 933         RUN_TEST(test_reflog_expire);
 934         RUN_TEST(test_reftable_stack_add);
 935         RUN_TEST(test_reftable_stack_add_one);
 936         RUN_TEST(test_reftable_stack_auto_compaction);
 937         RUN_TEST(test_reftable_stack_compaction_concurrent);
 938         RUN_TEST(test_reftable_stack_compaction_concurrent_clean);
 939         RUN_TEST(test_reftable_stack_hash_id);
 940         RUN_TEST(test_reftable_stack_lock_failure);
 941         RUN_TEST(test_reftable_stack_log_normalize);
 942         RUN_TEST(test_reftable_stack_tombstone);
 943         RUN_TEST(test_reftable_stack_transaction_api);
 944         RUN_TEST(test_reftable_stack_update_index_check);
 945         RUN_TEST(test_reftable_stack_uptodate);
 946         RUN_TEST(test_reftable_stack_validate_refname);
 947         RUN_TEST(test_sizes_to_segments);
 948         RUN_TEST(test_sizes_to_segments_all_equal);
 949         RUN_TEST(test_sizes_to_segments_empty);
 950         RUN_TEST(test_suggest_compaction_segment);
 951         RUN_TEST(test_suggest_compaction_segment_nothing);
 952         return 0;
 953 }