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_table_read_write_sequential(void)
 292 {
 293         char **names;
 294         struct strbuf buf = STRBUF_INIT;
 295         int N = 50;
 296         struct reftable_iterator it = { NULL };
 297         struct reftable_block_source source = { NULL };
 298         struct reftable_reader rd = { NULL };
 299         int err = 0;
 300         int j = 0;
 301
 302         write_table(&names, &buf, N, 256, GIT_SHA1_FORMAT_ID);
 303
 304         block_source_from_strbuf(&source, &buf);
 305
 306         err = init_reader(&rd, &source, "file.ref");
 307         EXPECT_ERR(err);
 308
 309         err = reftable_reader_seek_ref(&rd, &it, "");
 310         EXPECT_ERR(err);
 311
 312         while (1) {
 313                 struct reftable_ref_record ref = { NULL };
 314                 int r = reftable_iterator_next_ref(&it, &ref);
 315                 EXPECT(r >= 0);
 316                 if (r > 0) {
 317                         break;
 318                 }
 319                 EXPECT(0 == strcmp(names[j], ref.refname));
 320                 EXPECT(update_index == ref.update_index);
 321
 322                 j++;
 323                 reftable_ref_record_release(&ref);
 324         }
 325         EXPECT(j == N);
 326         reftable_iterator_destroy(&it);
 327         strbuf_release(&buf);
 328         free_names(names);
 329
 330         reader_close(&rd);
 331 }
 332
 333 static void test_table_write_small_table(void)
 334 {
 335         char **names;
 336         struct strbuf buf = STRBUF_INIT;
 337         int N = 1;
 338         write_table(&names, &buf, N, 4096, GIT_SHA1_FORMAT_ID);
 339         EXPECT(buf.len < 200);
 340         strbuf_release(&buf);
 341         free_names(names);
 342 }
 343
 344 static void test_table_read_api(void)
 345 {
 346         char **names;
 347         struct strbuf buf = STRBUF_INIT;
 348         int N = 50;
 349         struct reftable_reader rd = { NULL };
 350         struct reftable_block_source source = { NULL };
 351         int err;
 352         int i;
 353         struct reftable_log_record log = { NULL };
 354         struct reftable_iterator it = { NULL };
 355
 356         write_table(&names, &buf, N, 256, GIT_SHA1_FORMAT_ID);
 357
 358         block_source_from_strbuf(&source, &buf);
 359
 360         err = init_reader(&rd, &source, "file.ref");
 361         EXPECT_ERR(err);
 362
 363         err = reftable_reader_seek_ref(&rd, &it, names[0]);
 364         EXPECT_ERR(err);
 365
 366         err = reftable_iterator_next_log(&it, &log);
 367         EXPECT(err == REFTABLE_API_ERROR);
 368
 369         strbuf_release(&buf);
 370         for (i = 0; i < N; i++) {
 371                 reftable_free(names[i]);
 372         }
 373         reftable_iterator_destroy(&it);
 374         reftable_free(names);
 375         reader_close(&rd);
 376         strbuf_release(&buf);
 377 }
 378
 379 static void test_table_read_write_seek(int index, int hash_id)
 380 {
 381         char **names;
 382         struct strbuf buf = STRBUF_INIT;
 383         int N = 50;
 384         struct reftable_reader rd = { NULL };
 385         struct reftable_block_source source = { NULL };
 386         int err;
 387         int i = 0;
 388
 389         struct reftable_iterator it = { NULL };
 390         struct strbuf pastLast = STRBUF_INIT;
 391         struct reftable_ref_record ref = { NULL };
 392
 393         write_table(&names, &buf, N, 256, hash_id);
 394
 395         block_source_from_strbuf(&source, &buf);
 396
 397         err = init_reader(&rd, &source, "file.ref");
 398         EXPECT_ERR(err);
 399         EXPECT(hash_id == reftable_reader_hash_id(&rd));
 400
 401         if (!index) {
 402                 rd.ref_offsets.index_offset = 0;
 403         } else {
 404                 EXPECT(rd.ref_offsets.index_offset > 0);
 405         }
 406
 407         for (i = 1; i < N; i++) {
 408                 int err = reftable_reader_seek_ref(&rd, &it, names[i]);
 409                 EXPECT_ERR(err);
 410                 err = reftable_iterator_next_ref(&it, &ref);
 411                 EXPECT_ERR(err);
 412                 EXPECT(0 == strcmp(names[i], ref.refname));
 413                 EXPECT(REFTABLE_REF_VAL1 == ref.value_type);
 414                 EXPECT(i == ref.value.val1[0]);
 415
 416                 reftable_ref_record_release(&ref);
 417                 reftable_iterator_destroy(&it);
 418         }
 419
 420         strbuf_addstr(&pastLast, names[N - 1]);
 421         strbuf_addstr(&pastLast, "/");
 422
 423         err = reftable_reader_seek_ref(&rd, &it, pastLast.buf);
 424         if (err == 0) {
 425                 struct reftable_ref_record ref = { NULL };
 426                 int err = reftable_iterator_next_ref(&it, &ref);
 427                 EXPECT(err > 0);
 428         } else {
 429                 EXPECT(err > 0);
 430         }
 431
 432         strbuf_release(&pastLast);
 433         reftable_iterator_destroy(&it);
 434
 435         strbuf_release(&buf);
 436         for (i = 0; i < N; i++) {
 437                 reftable_free(names[i]);
 438         }
 439         reftable_free(names);
 440         reader_close(&rd);
 441 }
 442
 443 static void test_table_read_write_seek_linear(void)
 444 {
 445         test_table_read_write_seek(0, GIT_SHA1_FORMAT_ID);
 446 }
 447
 448 static void test_table_read_write_seek_linear_sha256(void)
 449 {
 450         test_table_read_write_seek(0, GIT_SHA256_FORMAT_ID);
 451 }
 452
 453 static void test_table_read_write_seek_index(void)
 454 {
 455         test_table_read_write_seek(1, GIT_SHA1_FORMAT_ID);
 456 }
 457
 458 static void test_table_refs_for(int indexed)
 459 {
 460         int N = 50;
 461         char **want_names = reftable_calloc(sizeof(char *) * (N + 1));
 462         int want_names_len = 0;
 463         uint8_t want_hash[GIT_SHA1_RAWSZ];
 464
 465         struct reftable_write_options opts = {
 466                 .block_size = 256,
 467         };
 468         struct reftable_ref_record ref = { NULL };
 469         int i = 0;
 470         int n;
 471         int err;
 472         struct reftable_reader rd;
 473         struct reftable_block_source source = { NULL };
 474
 475         struct strbuf buf = STRBUF_INIT;
 476         struct reftable_writer *w =
 477                 reftable_new_writer(&strbuf_add_void, &buf, &opts);
 478
 479         struct reftable_iterator it = { NULL };
 480         int j;
 481
 482         set_test_hash(want_hash, 4);
 483
 484         for (i = 0; i < N; i++) {
 485                 uint8_t hash[GIT_SHA1_RAWSZ];
 486                 char fill[51] = { 0 };
 487                 char name[100];
 488                 uint8_t hash1[GIT_SHA1_RAWSZ];
 489                 uint8_t hash2[GIT_SHA1_RAWSZ];
 490                 struct reftable_ref_record ref = { NULL };
 491
 492                 memset(hash, i, sizeof(hash));
 493                 memset(fill, 'x', 50);
 494                 /* Put the variable part in the start */
 495                 snprintf(name, sizeof(name), "br%02d%s", i, fill);
 496                 name[40] = 0;
 497                 ref.refname = name;
 498
 499                 set_test_hash(hash1, i / 4);
 500                 set_test_hash(hash2, 3 + i / 4);
 501                 ref.value_type = REFTABLE_REF_VAL2;
 502                 ref.value.val2.value = hash1;
 503                 ref.value.val2.target_value = hash2;
 504
 505                 /* 80 bytes / entry, so 3 entries per block. Yields 17
 506                  */
 507                 /* blocks. */
 508                 n = reftable_writer_add_ref(w, &ref);
 509                 EXPECT(n == 0);
 510
 511                 if (!memcmp(hash1, want_hash, GIT_SHA1_RAWSZ) ||
 512                     !memcmp(hash2, want_hash, GIT_SHA1_RAWSZ)) {
 513                         want_names[want_names_len++] = xstrdup(name);
 514                 }
 515         }
 516
 517         n = reftable_writer_close(w);
 518         EXPECT(n == 0);
 519
 520         reftable_writer_free(w);
 521         w = NULL;
 522
 523         block_source_from_strbuf(&source, &buf);
 524
 525         err = init_reader(&rd, &source, "file.ref");
 526         EXPECT_ERR(err);
 527         if (!indexed) {
 528                 rd.obj_offsets.is_present = 0;
 529         }
 530
 531         err = reftable_reader_seek_ref(&rd, &it, "");
 532         EXPECT_ERR(err);
 533         reftable_iterator_destroy(&it);
 534
 535         err = reftable_reader_refs_for(&rd, &it, want_hash);
 536         EXPECT_ERR(err);
 537
 538         j = 0;
 539         while (1) {
 540                 int err = reftable_iterator_next_ref(&it, &ref);
 541                 EXPECT(err >= 0);
 542                 if (err > 0) {
 543                         break;
 544                 }
 545
 546                 EXPECT(j < want_names_len);
 547                 EXPECT(0 == strcmp(ref.refname, want_names[j]));
 548                 j++;
 549                 reftable_ref_record_release(&ref);
 550         }
 551         EXPECT(j == want_names_len);
 552
 553         strbuf_release(&buf);
 554         free_names(want_names);
 555         reftable_iterator_destroy(&it);
 556         reader_close(&rd);
 557 }
 558
 559 static void test_table_refs_for_no_index(void)
 560 {
 561         test_table_refs_for(0);
 562 }
 563
 564 static void test_table_refs_for_obj_index(void)
 565 {
 566         test_table_refs_for(1);
 567 }
 568
 569 static void test_write_empty_table(void)
 570 {
 571         struct reftable_write_options opts = { 0 };
 572         struct strbuf buf = STRBUF_INIT;
 573         struct reftable_writer *w =
 574                 reftable_new_writer(&strbuf_add_void, &buf, &opts);
 575         struct reftable_block_source source = { NULL };
 576         struct reftable_reader *rd = NULL;
 577         struct reftable_ref_record rec = { NULL };
 578         struct reftable_iterator it = { NULL };
 579         int err;
 580
 581         reftable_writer_set_limits(w, 1, 1);
 582
 583         err = reftable_writer_close(w);
 584         EXPECT(err == REFTABLE_EMPTY_TABLE_ERROR);
 585         reftable_writer_free(w);
 586
 587         EXPECT(buf.len == header_size(1) + footer_size(1));
 588
 589         block_source_from_strbuf(&source, &buf);
 590
 591         err = reftable_new_reader(&rd, &source, "filename");
 592         EXPECT_ERR(err);
 593
 594         err = reftable_reader_seek_ref(rd, &it, "");
 595         EXPECT_ERR(err);
 596
 597         err = reftable_iterator_next_ref(&it, &rec);
 598         EXPECT(err > 0);
 599
 600         reftable_iterator_destroy(&it);
 601         reftable_reader_free(rd);
 602         strbuf_release(&buf);
 603 }
 604
 605 static void test_write_key_order(void)
 606 {
 607         struct reftable_write_options opts = { 0 };
 608         struct strbuf buf = STRBUF_INIT;
 609         struct reftable_writer *w =
 610                 reftable_new_writer(&strbuf_add_void, &buf, &opts);
 611         struct reftable_ref_record refs[2] = {
 612                 {
 613                         .refname = "b",
 614                         .update_index = 1,
 615                         .value_type = REFTABLE_REF_SYMREF,
 616                         .value = {
 617                                 .symref = "target",
 618                         },
 619                 }, {
 620                         .refname = "a",
 621                         .update_index = 1,
 622                         .value_type = REFTABLE_REF_SYMREF,
 623                         .value = {
 624                                 .symref = "target",
 625                         },
 626                 }
 627         };
 628         int err;
 629
 630         reftable_writer_set_limits(w, 1, 1);
 631         err = reftable_writer_add_ref(w, &refs[0]);
 632         EXPECT_ERR(err);
 633         err = reftable_writer_add_ref(w, &refs[1]);
 634         printf("%d\n", err);
 635         EXPECT(err == REFTABLE_API_ERROR);
 636         reftable_writer_close(w);
 637         reftable_writer_free(w);
 638         strbuf_release(&buf);
 639 }
 640
 641 static void test_corrupt_table_empty(void)
 642 {
 643         struct strbuf buf = STRBUF_INIT;
 644         struct reftable_block_source source = { NULL };
 645         struct reftable_reader rd = { NULL };
 646         int err;
 647
 648         block_source_from_strbuf(&source, &buf);
 649         err = init_reader(&rd, &source, "file.log");
 650         EXPECT(err == REFTABLE_FORMAT_ERROR);
 651 }
 652
 653 static void test_corrupt_table(void)
 654 {
 655         uint8_t zeros[1024] = { 0 };
 656         struct strbuf buf = STRBUF_INIT;
 657         struct reftable_block_source source = { NULL };
 658         struct reftable_reader rd = { NULL };
 659         int err;
 660         strbuf_add(&buf, zeros, sizeof(zeros));
 661
 662         block_source_from_strbuf(&source, &buf);
 663         err = init_reader(&rd, &source, "file.log");
 664         EXPECT(err == REFTABLE_FORMAT_ERROR);
 665         strbuf_release(&buf);
 666 }
 667
 668 int readwrite_test_main(int argc, const char *argv[])
 669 {
 670         RUN_TEST(test_corrupt_table);
 671         RUN_TEST(test_corrupt_table_empty);
 672         RUN_TEST(test_log_write_read);
 673         RUN_TEST(test_write_key_order);
 674         RUN_TEST(test_table_read_write_seek_linear_sha256);
 675         RUN_TEST(test_log_buffer_size);
 676         RUN_TEST(test_table_write_small_table);
 677         RUN_TEST(test_buffer);
 678         RUN_TEST(test_table_read_api);
 679         RUN_TEST(test_table_read_write_sequential);
 680         RUN_TEST(test_table_read_write_seek_linear);
 681         RUN_TEST(test_table_read_write_seek_index);
 682         RUN_TEST(test_table_refs_for_no_index);
 683         RUN_TEST(test_table_refs_for_obj_index);
 684         RUN_TEST(test_write_empty_table);
 685         RUN_TEST(test_log_overflow);
 686         return 0;
 687 }