Merge branch 'pw/reftable-libgit2-cleanup' into seen

Code clean-ups.

Comments?

* pw/reftable-libgit2-cleanup:
  reftable/stack: allow passing flags to `reftable_stack_add()`
  reftable/stack: reorder code to avoid forward declarations
  reftable/stack: fix compiler warning due to missing braces
  reftable/writer: drop Git-specific `QSORT()` macro
  reftable/writer: fix type used for number of records

diff --cc refs/reftable-backend.c
Simple merge

diff --cc t/unit-tests/u-reftable-stack.c
index e4ea57138ef73fabdd47061c2bd1d5e27d4ee240,ce10247903c5f3c00833ebbea0e81dfab9d6397c..a8b91812e89ab00710bdd25144d462023cf51d54
--- 1/t/unit-tests/u-reftable-stack.c
--- 2/t/unit-tests/t-reftable-stack.c
+++ b/t/unit-tests/u-reftable-stack.c
@@@ -125,10 -126,10 +125,10 @@@ static void write_n_ref_tables(struct r
  
                snprintf(buf, sizeof(buf), "refs/heads/branch-%04"PRIuMAX, (uintmax_t)i);
                ref.refname = buf;
 -              t_reftable_set_hash(ref.value.val1, i, REFTABLE_HASH_SHA1);
 +              cl_reftable_set_hash(ref.value.val1, i, REFTABLE_HASH_SHA1);
  
 -              err = reftable_stack_add(st, &write_test_ref, &ref, 0);
 -              check(!err);
 +              cl_assert_equal_i(reftable_stack_add(st,
-                                                    &write_test_ref, &ref), 0);
++                                                   &write_test_ref, &ref, 0), 0);
        }
  
        st->opts.disable_auto_compact = disable_auto_compact;
@@@ -166,37 -167,32 +166,37 @@@ void test_reftable_stack__add_one(void
        };
        struct reftable_ref_record dest = { 0 };
        struct stat stat_result = { 0 };
 +      int err;
 +
        err = reftable_new_stack(&st, dir, &opts);
 -      check(!err);
 +      cl_assert(!err);
  
-       err = reftable_stack_add(st, write_test_ref, &ref);
+       err = reftable_stack_add(st, write_test_ref, &ref, 0);
 -      check(!err);
 +      cl_assert(!err);
  
        err = reftable_stack_read_ref(st, ref.refname, &dest);
 -      check(!err);
 -      check(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));
 -      check_int(st->tables_len, >, 0);
 +      cl_assert(!err);
 +      cl_assert(reftable_ref_record_equal(&ref, &dest,
 +                                          REFTABLE_HASH_SIZE_SHA1));
 +      cl_assert(st->tables_len > 0);
  
  #ifndef GIT_WINDOWS_NATIVE
 -      check(!reftable_buf_addstr(&scratch, dir));
 -      check(!reftable_buf_addstr(&scratch, "/tables.list"));
 -      err = stat(scratch.buf, &stat_result);
 -      check(!err);
 -      check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
 +      cl_assert_equal_i(reftable_buf_addstr(&scratch, dir), 0);
 +      cl_assert_equal_i(reftable_buf_addstr(&scratch,
 +                                            "/tables.list"), 0);
 +      cl_assert_equal_i(stat(scratch.buf, &stat_result), 0);
 +      cl_assert_equal_i((stat_result.st_mode & 0777),
 +                        opts.default_permissions);
  
        reftable_buf_reset(&scratch);
 -      check(!reftable_buf_addstr(&scratch, dir));
 -      check(!reftable_buf_addstr(&scratch, "/"));
 +      cl_assert_equal_i(reftable_buf_addstr(&scratch, dir), 0);
 +      cl_assert_equal_i(reftable_buf_addstr(&scratch, "/"), 0);
        /* do not try at home; not an external API for reftable. */
 -      check(!reftable_buf_addstr(&scratch, st->tables[0]->name));
 +      cl_assert(!reftable_buf_addstr(&scratch, st->tables[0]->name));
        err = stat(scratch.buf, &stat_result);
 -      check(!err);
 -      check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
 +      cl_assert(!err);
 +      cl_assert_equal_i((stat_result.st_mode & 0777),
 +                         opts.default_permissions);
  #else
        (void) stat_result;
  #endif
@@@ -232,15 -229,23 +232,15 @@@ void test_reftable_stack__uptodate(void
        /* simulate multi-process access to the same stack
           by creating two stacks for the same directory.
         */
 -      err = reftable_new_stack(&st1, dir, &opts);
 -      check(!err);
 -
 -      err = reftable_new_stack(&st2, dir, &opts);
 -      check(!err);
 -
 -      err = reftable_stack_add(st1, write_test_ref, &ref1, 0);
 -      check(!err);
 -
 -      err = reftable_stack_add(st2, write_test_ref, &ref2, 0);
 -      check_int(err, ==, REFTABLE_OUTDATED_ERROR);
 -
 -      err = reftable_stack_reload(st2);
 -      check(!err);
 -
 -      err = reftable_stack_add(st2, write_test_ref, &ref2, 0);
 -      check(!err);
 +      cl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);
 +      cl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);
 +      cl_assert_equal_i(reftable_stack_add(st1, write_test_ref,
-                                            &ref1), 0);
++                                           &ref1, 0), 0);
 +      cl_assert_equal_i(reftable_stack_add(st2, write_test_ref,
-                                            &ref2), REFTABLE_OUTDATED_ERROR);
++                                           &ref2, 0), REFTABLE_OUTDATED_ERROR);
 +      cl_assert_equal_i(reftable_stack_reload(st2), 0);
 +      cl_assert_equal_i(reftable_stack_add(st2, write_test_ref,
-                                            &ref2), 0);
++                                           &ref2, 0), 0);
        reftable_stack_destroy(st1);
        reftable_stack_destroy(st2);
        clear_dir(dir);
@@@ -404,12 -425,14 +404,12 @@@ void test_reftable_stack__auto_compacti
        char *dir = get_tmp_dir(__LINE__);
        int err;
  
 -      err = reftable_new_stack(&st, dir, &opts);
 -      check(!err);
 -
 -      err = reftable_stack_add(st, write_test_ref, &ref, 0);
 -      check(!err);
 -      check_int(st->merged->tables_len, ==, 1);
 -      check_int(st->stats.attempts, ==, 0);
 -      check_int(st->stats.failures, ==, 0);
 +      cl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);
 +      cl_assert_equal_i(reftable_stack_add(st, write_test_ref,
-                                            &ref), 0);
++                                           &ref, 0), 0);
 +      cl_assert_equal_i(st->merged->tables_len, 1);
 +      cl_assert_equal_i(st->stats.attempts, 0);
 +      cl_assert_equal_i(st->stats.failures, 0);
  
        /*
         * Lock the newly written table such that it cannot be compacted.
@@@ -424,11 -446,11 +424,11 @@@
        write_file_buf(table_path.buf, "", 0);
  
        ref.update_index = 2;
-       err = reftable_stack_add(st, write_test_ref, &ref);
+       err = reftable_stack_add(st, write_test_ref, &ref, 0);
 -      check(!err);
 -      check_int(st->merged->tables_len, ==, 2);
 -      check_int(st->stats.attempts, ==, 1);
 -      check_int(st->stats.failures, ==, 1);
 +      cl_assert(!err);
 +      cl_assert_equal_i(st->merged->tables_len, 2);
 +      cl_assert_equal_i(st->stats.attempts, 1);
 +      cl_assert_equal_i(st->stats.failures, 1);
  
        reftable_stack_destroy(st);
        reftable_buf_release(&table_path);
@@@ -458,11 -481,14 +458,11 @@@ void test_reftable_stack__update_index_
                .value.symref = (char *) "master",
        };
  
 -      err = reftable_new_stack(&st, dir, &opts);
 -      check(!err);
 -
 -      err = reftable_stack_add(st, write_test_ref, &ref1, 0);
 -      check(!err);
 -
 -      err = reftable_stack_add(st, write_test_ref, &ref2, 0);
 -      check_int(err, ==, REFTABLE_API_ERROR);
 +      cl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);
 +      cl_assert_equal_i(reftable_stack_add(st, write_test_ref,
-                                            &ref1), 0);
++                                           &ref1, 0), 0);
 +      cl_assert_equal_i(reftable_stack_add(st, write_test_ref,
-                                            &ref2), REFTABLE_API_ERROR);
++                                           &ref2, 0), REFTABLE_API_ERROR);
        reftable_stack_destroy(st);
        clear_dir(dir);
  }
@@@ -472,12 -498,14 +472,12 @@@ void test_reftable_stack__lock_failure(
        char *dir = get_tmp_dir(__LINE__);
        struct reftable_write_options opts = { 0 };
        struct reftable_stack *st = NULL;
 -      int err, i;
 +      int i;
  
 -      err = reftable_new_stack(&st, dir, &opts);
 -      check(!err);
 -      for (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {
 -              err = reftable_stack_add(st, write_error, &i, 0);
 -              check_int(err, ==, i);
 -      }
 +      cl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);
 +      for (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--)
 +              cl_assert_equal_i(reftable_stack_add(st, write_error,
-                                                    &i), i);
++                                                   &i, 0), i);
  
        reftable_stack_destroy(st);
        clear_dir(dir);
@@@ -515,24 -542,25 +515,24 @@@ void test_reftable_stack__add(void
                logs[i].update_index = N + i + 1;
                logs[i].value_type = REFTABLE_LOG_UPDATE;
                logs[i].value.update.email = xstrdup("identity@invalid");
 -              t_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);
 +              cl_reftable_set_hash(logs[i].value.update.new_hash, i,
 +                                   REFTABLE_HASH_SHA1);
        }
  
 -      for (i = 0; i < N; i++) {
 -              int err = reftable_stack_add(st, write_test_ref, &refs[i], 0);
 -              check(!err);
 -      }
 +      for (i = 0; i < N; i++)
 +              cl_assert_equal_i(reftable_stack_add(st, write_test_ref,
-                                            &refs[i]), 0);
++                                                   &refs[i], 0), 0);
  
        for (i = 0; i < N; i++) {
                struct write_log_arg arg = {
                        .log = &logs[i],
                        .update_index = reftable_stack_next_update_index(st),
                };
 -              int err = reftable_stack_add(st, write_test_log, &arg, 0);
 -              check(!err);
 +              cl_assert_equal_i(reftable_stack_add(st, write_test_log,
-                                                    &arg), 0);
++                                                   &arg, 0), 0);
        }
  
 -      err = reftable_stack_compact_all(st, NULL);
 -      check(!err);
 +      cl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);
  
        for (i = 0; i < N; i++) {
                struct reftable_ref_record dest = { 0 };
@@@ -607,13 -635,13 +607,13 @@@ void test_reftable_stack__iterator(void
                logs[i].value_type = REFTABLE_LOG_UPDATE;
                logs[i].value.update.email = xstrdup("johndoe@invalid");
                logs[i].value.update.message = xstrdup("commit\n");
 -              t_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);
 +              cl_reftable_set_hash(logs[i].value.update.new_hash, i,
 +                                   REFTABLE_HASH_SHA1);
        }
  
 -      for (i = 0; i < N; i++) {
 -              err = reftable_stack_add(st, write_test_ref, &refs[i], 0);
 -              check(!err);
 -      }
 +      for (i = 0; i < N; i++)
-               cl_assert_equal_i(reftable_stack_add(st,
-                                                    write_test_ref, &refs[i]), 0);
++              cl_assert_equal_i(reftable_stack_add(st, write_test_ref,
++                                                   &refs[i], 0), 0);
  
        for (i = 0; i < N; i++) {
                struct write_log_arg arg = {
@@@ -621,8 -649,8 +621,8 @@@
                        .update_index = reftable_stack_next_update_index(st),
                };
  
-               cl_assert_equal_i(reftable_stack_add(st,
-                                                    write_test_log, &arg), 0);
 -              err = reftable_stack_add(st, write_test_log, &arg, 0);
 -              check(!err);
++              cl_assert_equal_i(reftable_stack_add(st, write_test_log,
++                                                   &arg, 0), 0);
        }
  
        reftable_stack_init_ref_iterator(st, &it);
@@@ -693,26 -721,28 +693,26 @@@ void test_reftable_stack__log_normalize
                .update_index = 1,
        };
  
 -      err = reftable_new_stack(&st, dir, &opts);
 -      check(!err);
 +      cl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);
  
        input.value.update.message = (char *) "one\ntwo";
 -      err = reftable_stack_add(st, write_test_log, &arg, 0);
 -      check_int(err, ==, REFTABLE_API_ERROR);
 +      cl_assert_equal_i(reftable_stack_add(st, write_test_log,
-                                            &arg), REFTABLE_API_ERROR);
++                                           &arg, 0), REFTABLE_API_ERROR);
  
        input.value.update.message = (char *) "one";
 -      err = reftable_stack_add(st, write_test_log, &arg, 0);
 -      check(!err);
 -
 -      err = reftable_stack_read_log(st, input.refname, &dest);
 -      check(!err);
 -      check_str(dest.value.update.message, "one\n");
 +      cl_assert_equal_i(reftable_stack_add(st, write_test_log,
-                                            &arg), 0);
++                                           &arg, 0), 0);
 +      cl_assert_equal_i(reftable_stack_read_log(st, input.refname,
 +                                                &dest), 0);
 +      cl_assert_equal_s(dest.value.update.message, "one\n");
  
        input.value.update.message = (char *) "two\n";
        arg.update_index = 2;
 -      err = reftable_stack_add(st, write_test_log, &arg, 0);
 -      check(!err);
 -      err = reftable_stack_read_log(st, input.refname, &dest);
 -      check(!err);
 -      check_str(dest.value.update.message, "two\n");
 +      cl_assert_equal_i(reftable_stack_add(st, write_test_log,
-                                            &arg), 0);
++                                           &arg, 0), 0);
 +      cl_assert_equal_i(reftable_stack_read_log(st, input.refname,
 +                                                &dest), 0);
 +      cl_assert_equal_s(dest.value.update.message, "two\n");
  
        /* cleanup */
        reftable_stack_destroy(st);
@@@ -758,31 -791,36 +758,32 @@@ void test_reftable_stack__tombstone(voi
                                xstrdup("identity@invalid");
                }
        }
 -      for (i = 0; i < N; i++) {
 -              int err = reftable_stack_add(st, write_test_ref, &refs[i], 0);
 -              check(!err);
 -      }
 +      for (i = 0; i < N; i++)
-               cl_assert_equal_i(reftable_stack_add(st, write_test_ref, &refs[i]), 0);
++              cl_assert_equal_i(reftable_stack_add(st, write_test_ref,
++                                                   &refs[i], 0), 0);
  
        for (i = 0; i < N; i++) {
                struct write_log_arg arg = {
                        .log = &logs[i],
                        .update_index = reftable_stack_next_update_index(st),
                };
-               cl_assert_equal_i(reftable_stack_add(st,
-                                                    write_test_log, &arg), 0);
 -              int err = reftable_stack_add(st, write_test_log, &arg, 0);
 -              check(!err);
++              cl_assert_equal_i(reftable_stack_add(st, write_test_log,
++                                                   &arg, 0), 0);
        }
  
 -      err = reftable_stack_read_ref(st, "branch", &dest);
 -      check_int(err, ==, 1);
 +      cl_assert_equal_i(reftable_stack_read_ref(st, "branch",
 +                                                &dest), 1);
        reftable_ref_record_release(&dest);
  
 -      err = reftable_stack_read_log(st, "branch", &log_dest);
 -      check_int(err, ==, 1);
 +      cl_assert_equal_i(reftable_stack_read_log(st, "branch",
 +                                                &log_dest), 1);
        reftable_log_record_release(&log_dest);
  
 -      err = reftable_stack_compact_all(st, NULL);
 -      check(!err);
 -
 -      err = reftable_stack_read_ref(st, "branch", &dest);
 -      check_int(err, ==, 1);
 -
 -      err = reftable_stack_read_log(st, "branch", &log_dest);
 -      check_int(err, ==, 1);
 +      cl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);
 +      cl_assert_equal_i(reftable_stack_read_ref(st, "branch",
 +                                                &dest), 1);
 +      cl_assert_equal_i(reftable_stack_read_log(st, "branch",
 +                                                &log_dest), 1);
        reftable_ref_record_release(&dest);
        reftable_log_record_release(&log_dest);
  
@@@ -813,21 -852,24 +814,21 @@@ void test_reftable_stack__hash_id(void
        struct reftable_stack *st_default = NULL;
        struct reftable_ref_record dest = { 0 };
  
 -      err = reftable_new_stack(&st, dir, &opts);
 -      check(!err);
 -
 -      err = reftable_stack_add(st, write_test_ref, &ref, 0);
 -      check(!err);
 +      cl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);
 +      cl_assert_equal_i(reftable_stack_add(st, write_test_ref,
-                                            &ref), 0);
++                                           &ref, 0), 0);
  
        /* can't read it with the wrong hash ID. */
 -      err = reftable_new_stack(&st32, dir, &opts32);
 -      check_int(err, ==, REFTABLE_FORMAT_ERROR);
 +      cl_assert_equal_i(reftable_new_stack(&st32, dir,
 +                                           &opts32), REFTABLE_FORMAT_ERROR);
  
        /* check that we can read it back with default opts too. */
 -      err = reftable_new_stack(&st_default, dir, &opts_default);
 -      check(!err);
 -
 -      err = reftable_stack_read_ref(st_default, "master", &dest);
 -      check(!err);
 -
 -      check(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));
 +      cl_assert_equal_i(reftable_new_stack(&st_default, dir,
 +                                           &opts_default), 0);
 +      cl_assert_equal_i(reftable_stack_read_ref(st_default, "master",
 +                                                &dest), 0);
 +      cl_assert(reftable_ref_record_equal(&ref, &dest,
 +                                          REFTABLE_HASH_SIZE_SHA1) != 0);
        reftable_ref_record_release(&dest);
        reftable_stack_destroy(st);
        reftable_stack_destroy(st_default);
@@@ -883,23 -927,31 +884,23 @@@ void test_reftable_stack__reflog_expire
                        .log = &logs[i],
                        .update_index = reftable_stack_next_update_index(st),
                };
 -              int err = reftable_stack_add(st, write_test_log, &arg, 0);
 -              check(!err);
 +              cl_assert_equal_i(reftable_stack_add(st, write_test_log,
-                                                    &arg), 0);
++                                                   &arg, 0), 0);
        }
  
 -      err = reftable_stack_compact_all(st, NULL);
 -      check(!err);
 -
 -      err = reftable_stack_compact_all(st, &expiry);
 -      check(!err);
 -
 -      err = reftable_stack_read_log(st, logs[9].refname, &log);
 -      check_int(err, ==, 1);
 -
 -      err = reftable_stack_read_log(st, logs[11].refname, &log);
 -      check(!err);
 +      cl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);
 +      cl_assert_equal_i(reftable_stack_compact_all(st, &expiry), 0);
 +      cl_assert_equal_i(reftable_stack_read_log(st, logs[9].refname,
 +                                                &log), 1);
 +      cl_assert_equal_i(reftable_stack_read_log(st, logs[11].refname,
 +                                                &log), 0);
  
        expiry.min_update_index = 15;
 -      err = reftable_stack_compact_all(st, &expiry);
 -      check(!err);
 -
 -      err = reftable_stack_read_log(st, logs[14].refname, &log);
 -      check_int(err, ==, 1);
 -
 -      err = reftable_stack_read_log(st, logs[16].refname, &log);
 -      check(!err);
 +      cl_assert_equal_i(reftable_stack_compact_all(st, &expiry), 0);
 +      cl_assert_equal_i(reftable_stack_read_log(st, logs[14].refname,
 +                                                &log), 1);
 +      cl_assert_equal_i(reftable_stack_read_log(st, logs[16].refname,
 +                                                &log), 0);
  
        /* cleanup */
        reftable_stack_destroy(st);
@@@ -922,10 -974,15 +923,10 @@@ void test_reftable_stack__empty_add(voi
        char *dir = get_tmp_dir(__LINE__);
        struct reftable_stack *st2 = NULL;
  
 -      err = reftable_new_stack(&st, dir, &opts);
 -      check(!err);
 -
 -      err = reftable_stack_add(st, write_nothing, NULL, 0);
 -      check(!err);
 -
 -      err = reftable_new_stack(&st2, dir, &opts);
 -      check(!err);
 +      cl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);
 +      cl_assert_equal_i(reftable_stack_add(st, write_nothing,
-                                            NULL), 0);
++                                           NULL, 0), 0);
 +      cl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);
        clear_dir(dir);
        reftable_stack_destroy(st);
        reftable_stack_destroy(st2);
@@@ -963,16 -1021,16 +964,16 @@@ void test_reftable_stack__auto_compacti
                };
                snprintf(name, sizeof(name), "branch%04"PRIuMAX, (uintmax_t)i);
  
-               err = reftable_stack_add(st, write_test_ref, &ref);
+               err = reftable_stack_add(st, write_test_ref, &ref, 0);
 -              check(!err);
 +              cl_assert(!err);
  
                err = reftable_stack_auto_compact(st);
 -              check(!err);
 -              check(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));
 +              cl_assert(!err);
 +              cl_assert(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));
        }
  
 -      check_int(reftable_stack_compaction_stats(st)->entries_written, <,
 -             (uint64_t)(N * fastlogN(N, 2)));
 +      cl_assert(reftable_stack_compaction_stats(st)->entries_written <
 +                        (uint64_t)(N * fastlogN(N, 2)));
  
        reftable_stack_destroy(st);
        clear_dir(dir);
@@@ -999,10 -1058,10 +1000,10 @@@ void test_reftable_stack__auto_compacti
                };
                xsnprintf(name, sizeof(name), "branch%04"PRIuMAX, (uintmax_t)i);
  
-               err = reftable_stack_add(st, &write_test_ref, &ref);
+               err = reftable_stack_add(st, &write_test_ref, &ref, 0);
 -              check(!err);
 +              cl_assert(!err);
  
 -              check(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));
 +              cl_assert(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));
        }
  
        reftable_stack_destroy(st);
@@@ -1078,8 -1140,8 +1079,8 @@@ void test_reftable_stack__add_performs_
                snprintf(buf, sizeof(buf), "branch-%04"PRIuMAX, (uintmax_t)i);
                ref.refname = buf;
  
-               cl_assert_equal_i(reftable_stack_add(st,
-                                                    write_test_ref, &ref), 0);
 -              err = reftable_stack_add(st, write_test_ref, &ref, 0);
 -              check(!err);
++              cl_assert_equal_i(reftable_stack_add(st, write_test_ref,
++                                                   &ref, 0), 0);
  
                /*
                 * The stack length should grow continuously for all runs where