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