reftable/readwrite_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 "system.h"
  10
  11 #include "basics.h"
  12 #include "block.h"
  13 #include "blocksource.h"
  14 #include "reader.h"
  15 #include "record.h"
  16 #include "test_framework.h"
  17 #include "reftable-tests.h"
  18 #include "reftable-writer.h"
  19
  20 static const int update_index = 5;
  21
  22 static void test_buffer(void)
  23 {
  24         struct strbuf buf = STRBUF_INIT;
  25         struct reftable_block_source source = { NULL };
  26         struct reftable_block out = { NULL };
  27         int n;
  28         uint8_t in[] = "hello";
  29         strbuf_add(&buf, in, sizeof(in));
  30         block_source_from_strbuf(&source, &buf);
  31         EXPECT(block_source_size(&source) == 6);
  32         n = block_source_read_block(&source, &out, 0, sizeof(in));
  33         EXPECT(n == sizeof(in));
  34         EXPECT(!memcmp(in, out.data, n));
  35         reftable_block_done(&out);
  36
  37         n = block_source_read_block(&source, &out, 1, 2);
  38         EXPECT(n == 2);
  39         EXPECT(!memcmp(out.data, "el", 2));
  40
  41         reftable_block_done(&out);
  42         block_source_close(&source);
  43         strbuf_release(&buf);
  44 }
  45
  46 static void write_table(char ***names, struct strbuf *buf, int N,
  47                         int block_size, uint32_t hash_id)
  48 {
  49         struct reftable_write_options opts = {
  50                 .block_size = block_size,
  51                 .hash_id = hash_id,
  52         };
  53         struct reftable_writer *w =
  54                 reftable_new_writer(&strbuf_add_void, &noop_flush, buf, &opts);
  55         struct reftable_ref_record ref = { NULL };
  56         int i = 0, n;
  57         struct reftable_log_record log = { NULL };
  58         const struct reftable_stats *stats = NULL;
  59
  60         REFTABLE_CALLOC_ARRAY(*names, N + 1);
  61
  62         reftable_writer_set_limits(w, update_index, update_index);
  63         for (i = 0; i < N; i++) {
  64                 char name[100];
  65                 int n;
  66
  67                 snprintf(name, sizeof(name), "refs/heads/branch%02d", i);
  68
  69                 ref.refname = name;
  70                 ref.update_index = update_index;
  71                 ref.value_type = REFTABLE_REF_VAL1;
  72                 set_test_hash(ref.value.val1, i);
  73                 (*names)[i] = xstrdup(name);
  74
  75                 n = reftable_writer_add_ref(w, &ref);
  76                 EXPECT(n == 0);
  77         }
  78
  79         for (i = 0; i < N; i++) {
  80                 char name[100];
  81                 int n;
  82
  83                 snprintf(name, sizeof(name), "refs/heads/branch%02d", i);
  84
  85                 log.refname = name;
  86                 log.update_index = update_index;
  87                 log.value_type = REFTABLE_LOG_UPDATE;
  88                 set_test_hash(log.value.update.new_hash, i);
  89                 log.value.update.message = "message";
  90
  91                 n = reftable_writer_add_log(w, &log);
  92                 EXPECT(n == 0);
  93         }
  94
  95         n = reftable_writer_close(w);
  96         EXPECT(n == 0);
  97
  98         stats = reftable_writer_stats(w);
  99         for (i = 0; i < stats->ref_stats.blocks; i++) {
 100                 int off = i * opts.block_size;
 101                 if (off == 0) {
 102                         off = header_size(
 103                                 (hash_id == GIT_SHA256_FORMAT_ID) ? 2 : 1);
 104                 }
 105                 EXPECT(buf->buf[off] == 'r');
 106         }
 107
 108         EXPECT(stats->log_stats.blocks > 0);
 109         reftable_writer_free(w);
 110 }
 111
 112 static void test_log_buffer_size(void)
 113 {
 114         struct strbuf buf = STRBUF_INIT;
 115         struct reftable_write_options opts = {
 116                 .block_size = 4096,
 117         };
 118         int err;
 119         int i;
 120         struct reftable_log_record
 121                 log = { .refname = "refs/heads/master",
 122                         .update_index = 0xa,
 123                         .value_type = REFTABLE_LOG_UPDATE,
 124                         .value = { .update = {
 125                                            .name = "Han-Wen Nienhuys",
 126                                            .email = "hanwen@google.com",
 127                                            .tz_offset = 100,
 128                                            .time = 0x5e430672,
 129                                            .message = "commit: 9\n",
 130                                    } } };
 131         struct reftable_writer *w =
 132                 reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
 133
 134         /* This tests buffer extension for log compression. Must use a random
 135            hash, to ensure that the compressed part is larger than the original.
 136         */
 137         for (i = 0; i < GIT_SHA1_RAWSZ; i++) {
 138                 log.value.update.old_hash[i] = (uint8_t)(git_rand() % 256);
 139                 log.value.update.new_hash[i] = (uint8_t)(git_rand() % 256);
 140         }
 141         reftable_writer_set_limits(w, update_index, update_index);
 142         err = reftable_writer_add_log(w, &log);
 143         EXPECT_ERR(err);
 144         err = reftable_writer_close(w);
 145         EXPECT_ERR(err);
 146         reftable_writer_free(w);
 147         strbuf_release(&buf);
 148 }
 149
 150 static void test_log_overflow(void)
 151 {
 152         struct strbuf buf = STRBUF_INIT;
 153         char msg[256] = { 0 };
 154         struct reftable_write_options opts = {
 155                 .block_size = ARRAY_SIZE(msg),
 156         };
 157         int err;
 158         struct reftable_log_record log = {
 159                 .refname = "refs/heads/master",
 160                 .update_index = 0xa,
 161                 .value_type = REFTABLE_LOG_UPDATE,
 162                 .value = {
 163                         .update = {
 164                                 .old_hash = { 1 },
 165                                 .new_hash = { 2 },
 166                                 .name = "Han-Wen Nienhuys",
 167                                 .email = "hanwen@google.com",
 168                                 .tz_offset = 100,
 169                                 .time = 0x5e430672,
 170                                 .message = msg,
 171                         },
 172                 },
 173         };
 174         struct reftable_writer *w =
 175                 reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
 176
 177         memset(msg, 'x', sizeof(msg) - 1);
 178         reftable_writer_set_limits(w, update_index, update_index);
 179         err = reftable_writer_add_log(w, &log);
 180         EXPECT(err == REFTABLE_ENTRY_TOO_BIG_ERROR);
 181         reftable_writer_free(w);
 182         strbuf_release(&buf);
 183 }
 184
 185 static void test_log_write_read(void)
 186 {
 187         int N = 2;
 188         char **names = reftable_calloc(N + 1, sizeof(*names));
 189         int err;
 190         struct reftable_write_options opts = {
 191                 .block_size = 256,
 192         };
 193         struct reftable_ref_record ref = { NULL };
 194         int i = 0;
 195         struct reftable_log_record log = { NULL };
 196         int n;
 197         struct reftable_iterator it = { NULL };
 198         struct reftable_reader rd = { NULL };
 199         struct reftable_block_source source = { NULL };
 200         struct strbuf buf = STRBUF_INIT;
 201         struct reftable_writer *w =
 202                 reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
 203         const struct reftable_stats *stats = NULL;
 204         reftable_writer_set_limits(w, 0, N);
 205         for (i = 0; i < N; i++) {
 206                 char name[256];
 207                 struct reftable_ref_record ref = { NULL };
 208                 snprintf(name, sizeof(name), "b%02d%0*d", i, 130, 7);
 209                 names[i] = xstrdup(name);
 210                 ref.refname = name;
 211                 ref.update_index = i;
 212
 213                 err = reftable_writer_add_ref(w, &ref);
 214                 EXPECT_ERR(err);
 215         }
 216         for (i = 0; i < N; i++) {
 217                 struct reftable_log_record log = { NULL };
 218
 219                 log.refname = names[i];
 220                 log.update_index = i;
 221                 log.value_type = REFTABLE_LOG_UPDATE;
 222                 set_test_hash(log.value.update.old_hash, i);
 223                 set_test_hash(log.value.update.new_hash, i + 1);
 224
 225                 err = reftable_writer_add_log(w, &log);
 226                 EXPECT_ERR(err);
 227         }
 228
 229         n = reftable_writer_close(w);
 230         EXPECT(n == 0);
 231
 232         stats = reftable_writer_stats(w);
 233         EXPECT(stats->log_stats.blocks > 0);
 234         reftable_writer_free(w);
 235         w = NULL;
 236
 237         block_source_from_strbuf(&source, &buf);
 238
 239         err = init_reader(&rd, &source, "file.log");
 240         EXPECT_ERR(err);
 241
 242         err = reftable_reader_seek_ref(&rd, &it, names[N - 1]);
 243         EXPECT_ERR(err);
 244
 245         err = reftable_iterator_next_ref(&it, &ref);
 246         EXPECT_ERR(err);
 247
 248         /* end of iteration. */
 249         err = reftable_iterator_next_ref(&it, &ref);
 250         EXPECT(0 < err);
 251
 252         reftable_iterator_destroy(&it);
 253         reftable_ref_record_release(&ref);
 254
 255         err = reftable_reader_seek_log(&rd, &it, "");
 256         EXPECT_ERR(err);
 257
 258         i = 0;
 259         while (1) {
 260                 int err = reftable_iterator_next_log(&it, &log);
 261                 if (err > 0) {
 262                         break;
 263                 }
 264
 265                 EXPECT_ERR(err);
 266                 EXPECT_STREQ(names[i], log.refname);
 267                 EXPECT(i == log.update_index);
 268                 i++;
 269                 reftable_log_record_release(&log);
 270         }
 271
 272         EXPECT(i == N);
 273         reftable_iterator_destroy(&it);
 274
 275         /* cleanup. */
 276         strbuf_release(&buf);
 277         free_names(names);
 278         reader_close(&rd);
 279 }
 280
 281 static void test_log_zlib_corruption(void)
 282 {
 283         struct reftable_write_options opts = {
 284                 .block_size = 256,
 285         };
 286         struct reftable_iterator it = { 0 };
 287         struct reftable_reader rd = { 0 };
 288         struct reftable_block_source source = { 0 };
 289         struct strbuf buf = STRBUF_INIT;
 290         struct reftable_writer *w =
 291                 reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
 292         const struct reftable_stats *stats = NULL;
 293         char message[100] = { 0 };
 294         int err, i, n;
 295         struct reftable_log_record log = {
 296                 .refname = "refname",
 297                 .value_type = REFTABLE_LOG_UPDATE,
 298                 .value = {
 299                         .update = {
 300                                 .new_hash = { 1 },
 301                                 .old_hash = { 2 },
 302                                 .name = "My Name",
 303                                 .email = "myname@invalid",
 304                                 .message = message,
 305                         },
 306                 },
 307         };
 308
 309         for (i = 0; i < sizeof(message) - 1; i++)
 310                 message[i] = (uint8_t)(git_rand() % 64 + ' ');
 311
 312         reftable_writer_set_limits(w, 1, 1);
 313
 314         err = reftable_writer_add_log(w, &log);
 315         EXPECT_ERR(err);
 316
 317         n = reftable_writer_close(w);
 318         EXPECT(n == 0);
 319
 320         stats = reftable_writer_stats(w);
 321         EXPECT(stats->log_stats.blocks > 0);
 322         reftable_writer_free(w);
 323         w = NULL;
 324
 325         /* corrupt the data. */
 326         buf.buf[50] ^= 0x99;
 327
 328         block_source_from_strbuf(&source, &buf);
 329
 330         err = init_reader(&rd, &source, "file.log");
 331         EXPECT_ERR(err);
 332
 333         err = reftable_reader_seek_log(&rd, &it, "refname");
 334         EXPECT(err == REFTABLE_ZLIB_ERROR);
 335
 336         reftable_iterator_destroy(&it);
 337
 338         /* cleanup. */
 339         strbuf_release(&buf);
 340         reader_close(&rd);
 341 }
 342
 343 static void test_table_read_write_sequential(void)
 344 {
 345         char **names;
 346         struct strbuf buf = STRBUF_INIT;
 347         int N = 50;
 348         struct reftable_iterator it = { NULL };
 349         struct reftable_block_source source = { NULL };
 350         struct reftable_reader rd = { NULL };
 351         int err = 0;
 352         int j = 0;
 353
 354         write_table(&names, &buf, N, 256, GIT_SHA1_FORMAT_ID);
 355
 356         block_source_from_strbuf(&source, &buf);
 357
 358         err = init_reader(&rd, &source, "file.ref");
 359         EXPECT_ERR(err);
 360
 361         err = reftable_reader_seek_ref(&rd, &it, "");
 362         EXPECT_ERR(err);
 363
 364         while (1) {
 365                 struct reftable_ref_record ref = { NULL };
 366                 int r = reftable_iterator_next_ref(&it, &ref);
 367                 EXPECT(r >= 0);
 368                 if (r > 0) {
 369                         break;
 370                 }
 371                 EXPECT(0 == strcmp(names[j], ref.refname));
 372                 EXPECT(update_index == ref.update_index);
 373
 374                 j++;
 375                 reftable_ref_record_release(&ref);
 376         }
 377         EXPECT(j == N);
 378         reftable_iterator_destroy(&it);
 379         strbuf_release(&buf);
 380         free_names(names);
 381
 382         reader_close(&rd);
 383 }
 384
 385 static void test_table_write_small_table(void)
 386 {
 387         char **names;
 388         struct strbuf buf = STRBUF_INIT;
 389         int N = 1;
 390         write_table(&names, &buf, N, 4096, GIT_SHA1_FORMAT_ID);
 391         EXPECT(buf.len < 200);
 392         strbuf_release(&buf);
 393         free_names(names);
 394 }
 395
 396 static void test_table_read_api(void)
 397 {
 398         char **names;
 399         struct strbuf buf = STRBUF_INIT;
 400         int N = 50;
 401         struct reftable_reader rd = { NULL };
 402         struct reftable_block_source source = { NULL };
 403         int err;
 404         int i;
 405         struct reftable_log_record log = { NULL };
 406         struct reftable_iterator it = { NULL };
 407
 408         write_table(&names, &buf, N, 256, GIT_SHA1_FORMAT_ID);
 409
 410         block_source_from_strbuf(&source, &buf);
 411
 412         err = init_reader(&rd, &source, "file.ref");
 413         EXPECT_ERR(err);
 414
 415         err = reftable_reader_seek_ref(&rd, &it, names[0]);
 416         EXPECT_ERR(err);
 417
 418         err = reftable_iterator_next_log(&it, &log);
 419         EXPECT(err == REFTABLE_API_ERROR);
 420
 421         strbuf_release(&buf);
 422         for (i = 0; i < N; i++) {
 423                 reftable_free(names[i]);
 424         }
 425         reftable_iterator_destroy(&it);
 426         reftable_free(names);
 427         reader_close(&rd);
 428         strbuf_release(&buf);
 429 }
 430
 431 static void test_table_read_write_seek(int index, int hash_id)
 432 {
 433         char **names;
 434         struct strbuf buf = STRBUF_INIT;
 435         int N = 50;
 436         struct reftable_reader rd = { NULL };
 437         struct reftable_block_source source = { NULL };
 438         int err;
 439         int i = 0;
 440
 441         struct reftable_iterator it = { NULL };
 442         struct strbuf pastLast = STRBUF_INIT;
 443         struct reftable_ref_record ref = { NULL };
 444
 445         write_table(&names, &buf, N, 256, hash_id);
 446
 447         block_source_from_strbuf(&source, &buf);
 448
 449         err = init_reader(&rd, &source, "file.ref");
 450         EXPECT_ERR(err);
 451         EXPECT(hash_id == reftable_reader_hash_id(&rd));
 452
 453         if (!index) {
 454                 rd.ref_offsets.index_offset = 0;
 455         } else {
 456                 EXPECT(rd.ref_offsets.index_offset > 0);
 457         }
 458
 459         for (i = 1; i < N; i++) {
 460                 int err = reftable_reader_seek_ref(&rd, &it, names[i]);
 461                 EXPECT_ERR(err);
 462                 err = reftable_iterator_next_ref(&it, &ref);
 463                 EXPECT_ERR(err);
 464                 EXPECT(0 == strcmp(names[i], ref.refname));
 465                 EXPECT(REFTABLE_REF_VAL1 == ref.value_type);
 466                 EXPECT(i == ref.value.val1[0]);
 467
 468                 reftable_ref_record_release(&ref);
 469                 reftable_iterator_destroy(&it);
 470         }
 471
 472         strbuf_addstr(&pastLast, names[N - 1]);
 473         strbuf_addstr(&pastLast, "/");
 474
 475         err = reftable_reader_seek_ref(&rd, &it, pastLast.buf);
 476         if (err == 0) {
 477                 struct reftable_ref_record ref = { NULL };
 478                 int err = reftable_iterator_next_ref(&it, &ref);
 479                 EXPECT(err > 0);
 480         } else {
 481                 EXPECT(err > 0);
 482         }
 483
 484         strbuf_release(&pastLast);
 485         reftable_iterator_destroy(&it);
 486
 487         strbuf_release(&buf);
 488         for (i = 0; i < N; i++) {
 489                 reftable_free(names[i]);
 490         }
 491         reftable_free(names);
 492         reader_close(&rd);
 493 }
 494
 495 static void test_table_read_write_seek_linear(void)
 496 {
 497         test_table_read_write_seek(0, GIT_SHA1_FORMAT_ID);
 498 }
 499
 500 static void test_table_read_write_seek_linear_sha256(void)
 501 {
 502         test_table_read_write_seek(0, GIT_SHA256_FORMAT_ID);
 503 }
 504
 505 static void test_table_read_write_seek_index(void)
 506 {
 507         test_table_read_write_seek(1, GIT_SHA1_FORMAT_ID);
 508 }
 509
 510 static void test_table_refs_for(int indexed)
 511 {
 512         int N = 50;
 513         char **want_names = reftable_calloc(N + 1, sizeof(*want_names));
 514         int want_names_len = 0;
 515         uint8_t want_hash[GIT_SHA1_RAWSZ];
 516
 517         struct reftable_write_options opts = {
 518                 .block_size = 256,
 519         };
 520         struct reftable_ref_record ref = { NULL };
 521         int i = 0;
 522         int n;
 523         int err;
 524         struct reftable_reader rd;
 525         struct reftable_block_source source = { NULL };
 526
 527         struct strbuf buf = STRBUF_INIT;
 528         struct reftable_writer *w =
 529                 reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
 530
 531         struct reftable_iterator it = { NULL };
 532         int j;
 533
 534         set_test_hash(want_hash, 4);
 535
 536         for (i = 0; i < N; i++) {
 537                 uint8_t hash[GIT_SHA1_RAWSZ];
 538                 char fill[51] = { 0 };
 539                 char name[100];
 540                 struct reftable_ref_record ref = { NULL };
 541
 542                 memset(hash, i, sizeof(hash));
 543                 memset(fill, 'x', 50);
 544                 /* Put the variable part in the start */
 545                 snprintf(name, sizeof(name), "br%02d%s", i, fill);
 546                 name[40] = 0;
 547                 ref.refname = name;
 548
 549                 ref.value_type = REFTABLE_REF_VAL2;
 550                 set_test_hash(ref.value.val2.value, i / 4);
 551                 set_test_hash(ref.value.val2.target_value, 3 + i / 4);
 552
 553                 /* 80 bytes / entry, so 3 entries per block. Yields 17
 554                  */
 555                 /* blocks. */
 556                 n = reftable_writer_add_ref(w, &ref);
 557                 EXPECT(n == 0);
 558
 559                 if (!memcmp(ref.value.val2.value, want_hash, GIT_SHA1_RAWSZ) ||
 560                     !memcmp(ref.value.val2.target_value, want_hash, GIT_SHA1_RAWSZ)) {
 561                         want_names[want_names_len++] = xstrdup(name);
 562                 }
 563         }
 564
 565         n = reftable_writer_close(w);
 566         EXPECT(n == 0);
 567
 568         reftable_writer_free(w);
 569         w = NULL;
 570
 571         block_source_from_strbuf(&source, &buf);
 572
 573         err = init_reader(&rd, &source, "file.ref");
 574         EXPECT_ERR(err);
 575         if (!indexed) {
 576                 rd.obj_offsets.is_present = 0;
 577         }
 578
 579         err = reftable_reader_seek_ref(&rd, &it, "");
 580         EXPECT_ERR(err);
 581         reftable_iterator_destroy(&it);
 582
 583         err = reftable_reader_refs_for(&rd, &it, want_hash);
 584         EXPECT_ERR(err);
 585
 586         j = 0;
 587         while (1) {
 588                 int err = reftable_iterator_next_ref(&it, &ref);
 589                 EXPECT(err >= 0);
 590                 if (err > 0) {
 591                         break;
 592                 }
 593
 594                 EXPECT(j < want_names_len);
 595                 EXPECT(0 == strcmp(ref.refname, want_names[j]));
 596                 j++;
 597                 reftable_ref_record_release(&ref);
 598         }
 599         EXPECT(j == want_names_len);
 600
 601         strbuf_release(&buf);
 602         free_names(want_names);
 603         reftable_iterator_destroy(&it);
 604         reader_close(&rd);
 605 }
 606
 607 static void test_table_refs_for_no_index(void)
 608 {
 609         test_table_refs_for(0);
 610 }
 611
 612 static void test_table_refs_for_obj_index(void)
 613 {
 614         test_table_refs_for(1);
 615 }
 616
 617 static void test_write_empty_table(void)
 618 {
 619         struct reftable_write_options opts = { 0 };
 620         struct strbuf buf = STRBUF_INIT;
 621         struct reftable_writer *w =
 622                 reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
 623         struct reftable_block_source source = { NULL };
 624         struct reftable_reader *rd = NULL;
 625         struct reftable_ref_record rec = { NULL };
 626         struct reftable_iterator it = { NULL };
 627         int err;
 628
 629         reftable_writer_set_limits(w, 1, 1);
 630
 631         err = reftable_writer_close(w);
 632         EXPECT(err == REFTABLE_EMPTY_TABLE_ERROR);
 633         reftable_writer_free(w);
 634
 635         EXPECT(buf.len == header_size(1) + footer_size(1));
 636
 637         block_source_from_strbuf(&source, &buf);
 638
 639         err = reftable_new_reader(&rd, &source, "filename");
 640         EXPECT_ERR(err);
 641
 642         err = reftable_reader_seek_ref(rd, &it, "");
 643         EXPECT_ERR(err);
 644
 645         err = reftable_iterator_next_ref(&it, &rec);
 646         EXPECT(err > 0);
 647
 648         reftable_iterator_destroy(&it);
 649         reftable_reader_free(rd);
 650         strbuf_release(&buf);
 651 }
 652
 653 static void test_write_object_id_min_length(void)
 654 {
 655         struct reftable_write_options opts = {
 656                 .block_size = 75,
 657         };
 658         struct strbuf buf = STRBUF_INIT;
 659         struct reftable_writer *w =
 660                 reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
 661         struct reftable_ref_record ref = {
 662                 .update_index = 1,
 663                 .value_type = REFTABLE_REF_VAL1,
 664                 .value.val1 = {42},
 665         };
 666         int err;
 667         int i;
 668
 669         reftable_writer_set_limits(w, 1, 1);
 670
 671         /* Write the same hash in many refs. If there is only 1 hash, the
 672          * disambiguating prefix is length 0 */
 673         for (i = 0; i < 256; i++) {
 674                 char name[256];
 675                 snprintf(name, sizeof(name), "ref%05d", i);
 676                 ref.refname = name;
 677                 err = reftable_writer_add_ref(w, &ref);
 678                 EXPECT_ERR(err);
 679         }
 680
 681         err = reftable_writer_close(w);
 682         EXPECT_ERR(err);
 683         EXPECT(reftable_writer_stats(w)->object_id_len == 2);
 684         reftable_writer_free(w);
 685         strbuf_release(&buf);
 686 }
 687
 688 static void test_write_object_id_length(void)
 689 {
 690         struct reftable_write_options opts = {
 691                 .block_size = 75,
 692         };
 693         struct strbuf buf = STRBUF_INIT;
 694         struct reftable_writer *w =
 695                 reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
 696         struct reftable_ref_record ref = {
 697                 .update_index = 1,
 698                 .value_type = REFTABLE_REF_VAL1,
 699                 .value.val1 = {42},
 700         };
 701         int err;
 702         int i;
 703
 704         reftable_writer_set_limits(w, 1, 1);
 705
 706         /* Write the same hash in many refs. If there is only 1 hash, the
 707          * disambiguating prefix is length 0 */
 708         for (i = 0; i < 256; i++) {
 709                 char name[256];
 710                 snprintf(name, sizeof(name), "ref%05d", i);
 711                 ref.refname = name;
 712                 ref.value.val1[15] = i;
 713                 err = reftable_writer_add_ref(w, &ref);
 714                 EXPECT_ERR(err);
 715         }
 716
 717         err = reftable_writer_close(w);
 718         EXPECT_ERR(err);
 719         EXPECT(reftable_writer_stats(w)->object_id_len == 16);
 720         reftable_writer_free(w);
 721         strbuf_release(&buf);
 722 }
 723
 724 static void test_write_empty_key(void)
 725 {
 726         struct reftable_write_options opts = { 0 };
 727         struct strbuf buf = STRBUF_INIT;
 728         struct reftable_writer *w =
 729                 reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
 730         struct reftable_ref_record ref = {
 731                 .refname = "",
 732                 .update_index = 1,
 733                 .value_type = REFTABLE_REF_DELETION,
 734         };
 735         int err;
 736
 737         reftable_writer_set_limits(w, 1, 1);
 738         err = reftable_writer_add_ref(w, &ref);
 739         EXPECT(err == REFTABLE_API_ERROR);
 740
 741         err = reftable_writer_close(w);
 742         EXPECT(err == REFTABLE_EMPTY_TABLE_ERROR);
 743         reftable_writer_free(w);
 744         strbuf_release(&buf);
 745 }
 746
 747 static void test_write_key_order(void)
 748 {
 749         struct reftable_write_options opts = { 0 };
 750         struct strbuf buf = STRBUF_INIT;
 751         struct reftable_writer *w =
 752                 reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
 753         struct reftable_ref_record refs[2] = {
 754                 {
 755                         .refname = "b",
 756                         .update_index = 1,
 757                         .value_type = REFTABLE_REF_SYMREF,
 758                         .value = {
 759                                 .symref = "target",
 760                         },
 761                 }, {
 762                         .refname = "a",
 763                         .update_index = 1,
 764                         .value_type = REFTABLE_REF_SYMREF,
 765                         .value = {
 766                                 .symref = "target",
 767                         },
 768                 }
 769         };
 770         int err;
 771
 772         reftable_writer_set_limits(w, 1, 1);
 773         err = reftable_writer_add_ref(w, &refs[0]);
 774         EXPECT_ERR(err);
 775         err = reftable_writer_add_ref(w, &refs[1]);
 776         EXPECT(err == REFTABLE_API_ERROR);
 777         reftable_writer_close(w);
 778         reftable_writer_free(w);
 779         strbuf_release(&buf);
 780 }
 781
 782 static void test_write_multiple_indices(void)
 783 {
 784         struct reftable_write_options opts = {
 785                 .block_size = 100,
 786         };
 787         struct strbuf writer_buf = STRBUF_INIT, buf = STRBUF_INIT;
 788         struct reftable_block_source source = { 0 };
 789         struct reftable_iterator it = { 0 };
 790         const struct reftable_stats *stats;
 791         struct reftable_writer *writer;
 792         struct reftable_reader *reader;
 793         int err, i;
 794
 795         writer = reftable_new_writer(&strbuf_add_void, &noop_flush, &writer_buf, &opts);
 796         reftable_writer_set_limits(writer, 1, 1);
 797         for (i = 0; i < 100; i++) {
 798                 struct reftable_ref_record ref = {
 799                         .update_index = 1,
 800                         .value_type = REFTABLE_REF_VAL1,
 801                         .value.val1 = {i},
 802                 };
 803
 804                 strbuf_reset(&buf);
 805                 strbuf_addf(&buf, "refs/heads/%04d", i);
 806                 ref.refname = buf.buf,
 807
 808                 err = reftable_writer_add_ref(writer, &ref);
 809                 EXPECT_ERR(err);
 810         }
 811
 812         for (i = 0; i < 100; i++) {
 813                 struct reftable_log_record log = {
 814                         .update_index = 1,
 815                         .value_type = REFTABLE_LOG_UPDATE,
 816                         .value.update = {
 817                                 .old_hash = { i },
 818                                 .new_hash = { i },
 819                         },
 820                 };
 821
 822                 strbuf_reset(&buf);
 823                 strbuf_addf(&buf, "refs/heads/%04d", i);
 824                 log.refname = buf.buf,
 825
 826                 err = reftable_writer_add_log(writer, &log);
 827                 EXPECT_ERR(err);
 828         }
 829
 830         reftable_writer_close(writer);
 831
 832         /*
 833          * The written data should be sufficiently large to result in indices
 834          * for each of the block types.
 835          */
 836         stats = reftable_writer_stats(writer);
 837         EXPECT(stats->ref_stats.index_offset > 0);
 838         EXPECT(stats->obj_stats.index_offset > 0);
 839         EXPECT(stats->log_stats.index_offset > 0);
 840
 841         block_source_from_strbuf(&source, &writer_buf);
 842         err = reftable_new_reader(&reader, &source, "filename");
 843         EXPECT_ERR(err);
 844
 845         /*
 846          * Seeking the log uses the log index now. In case there is any
 847          * confusion regarding indices we would notice here.
 848          */
 849         err = reftable_reader_seek_log(reader, &it, "");
 850         EXPECT_ERR(err);
 851
 852         reftable_iterator_destroy(&it);
 853         reftable_writer_free(writer);
 854         reftable_reader_free(reader);
 855         strbuf_release(&writer_buf);
 856         strbuf_release(&buf);
 857 }
 858
 859 static void test_write_multi_level_index(void)
 860 {
 861         struct reftable_write_options opts = {
 862                 .block_size = 100,
 863         };
 864         struct strbuf writer_buf = STRBUF_INIT, buf = STRBUF_INIT;
 865         struct reftable_block_source source = { 0 };
 866         struct reftable_iterator it = { 0 };
 867         const struct reftable_stats *stats;
 868         struct reftable_writer *writer;
 869         struct reftable_reader *reader;
 870         int err;
 871
 872         writer = reftable_new_writer(&strbuf_add_void, &noop_flush, &writer_buf, &opts);
 873         reftable_writer_set_limits(writer, 1, 1);
 874         for (size_t i = 0; i < 200; i++) {
 875                 struct reftable_ref_record ref = {
 876                         .update_index = 1,
 877                         .value_type = REFTABLE_REF_VAL1,
 878                         .value.val1 = {i},
 879                 };
 880
 881                 strbuf_reset(&buf);
 882                 strbuf_addf(&buf, "refs/heads/%03" PRIuMAX, (uintmax_t)i);
 883                 ref.refname = buf.buf,
 884
 885                 err = reftable_writer_add_ref(writer, &ref);
 886                 EXPECT_ERR(err);
 887         }
 888         reftable_writer_close(writer);
 889
 890         /*
 891          * The written refs should be sufficiently large to result in a
 892          * multi-level index.
 893          */
 894         stats = reftable_writer_stats(writer);
 895         EXPECT(stats->ref_stats.max_index_level == 2);
 896
 897         block_source_from_strbuf(&source, &writer_buf);
 898         err = reftable_new_reader(&reader, &source, "filename");
 899         EXPECT_ERR(err);
 900
 901         /*
 902          * Seeking the last ref should work as expected.
 903          */
 904         err = reftable_reader_seek_ref(reader, &it, "refs/heads/199");
 905         EXPECT_ERR(err);
 906
 907         reftable_iterator_destroy(&it);
 908         reftable_writer_free(writer);
 909         reftable_reader_free(reader);
 910         strbuf_release(&writer_buf);
 911         strbuf_release(&buf);
 912 }
 913
 914 static void test_corrupt_table_empty(void)
 915 {
 916         struct strbuf buf = STRBUF_INIT;
 917         struct reftable_block_source source = { NULL };
 918         struct reftable_reader rd = { NULL };
 919         int err;
 920
 921         block_source_from_strbuf(&source, &buf);
 922         err = init_reader(&rd, &source, "file.log");
 923         EXPECT(err == REFTABLE_FORMAT_ERROR);
 924 }
 925
 926 static void test_corrupt_table(void)
 927 {
 928         uint8_t zeros[1024] = { 0 };
 929         struct strbuf buf = STRBUF_INIT;
 930         struct reftable_block_source source = { NULL };
 931         struct reftable_reader rd = { NULL };
 932         int err;
 933         strbuf_add(&buf, zeros, sizeof(zeros));
 934
 935         block_source_from_strbuf(&source, &buf);
 936         err = init_reader(&rd, &source, "file.log");
 937         EXPECT(err == REFTABLE_FORMAT_ERROR);
 938         strbuf_release(&buf);
 939 }
 940
 941 int readwrite_test_main(int argc, const char *argv[])
 942 {
 943         RUN_TEST(test_log_zlib_corruption);
 944         RUN_TEST(test_corrupt_table);
 945         RUN_TEST(test_corrupt_table_empty);
 946         RUN_TEST(test_log_write_read);
 947         RUN_TEST(test_write_key_order);
 948         RUN_TEST(test_table_read_write_seek_linear_sha256);
 949         RUN_TEST(test_log_buffer_size);
 950         RUN_TEST(test_table_write_small_table);
 951         RUN_TEST(test_buffer);
 952         RUN_TEST(test_table_read_api);
 953         RUN_TEST(test_table_read_write_sequential);
 954         RUN_TEST(test_table_read_write_seek_linear);
 955         RUN_TEST(test_table_read_write_seek_index);
 956         RUN_TEST(test_table_refs_for_no_index);
 957         RUN_TEST(test_table_refs_for_obj_index);
 958         RUN_TEST(test_write_empty_key);
 959         RUN_TEST(test_write_empty_table);
 960         RUN_TEST(test_log_overflow);
 961         RUN_TEST(test_write_object_id_length);
 962         RUN_TEST(test_write_object_id_min_length);
 963         RUN_TEST(test_write_multiple_indices);
 964         RUN_TEST(test_write_multi_level_index);
 965         return 0;
 966 }