{"thread":{"id":"63589","subject":"[PATCH v4 00/10] t/unit-tests: convert unit-tests to use clar","startedAt":"2025-06-05T14:07:15Z","lastAt":"2025-07-24T18:48:31Z","messageCount":33,"participants":["Seyi Kuforiji","Junio C Hamano","Patrick Steinhardt","Seyi Kufoiji"],"isPatch":true,"patchVersion":4,"patchTotal":10},"messages":[{"id":"519772","messageId":"20250605140644.239199-1-kuforiji98@gmail.com","threadId":"63589","inReplyTo":null,"subject":"[PATCH v4 00/10] t/unit-tests: convert unit-tests to use clar","fromName":"Seyi Kuforiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-06-05T14:06:34Z","receivedAt":"2025-06-05T14:07:15Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"Hello,\n\nThis patch series marks the final batch of our existing unit test files\ntransitioned to the Clar testing framework. It covers all the\nreftable-related test files, and is part of our ongoing effort to\nstandardize our testing framework to enhance its maintainability.\n\nChanges in v4:\n - some code refactoring and cleanup based on review.\n\nThanks\nSeyi\n\nSigned-off-by: Seyi Kuforiji \n\nSeyi Kuforiji (10):\n t/unit-tests: implement clar specific reftable test helper functions\n t/unit-tests: convert reftable basics test to use clar test framework\n t/unit-tests: convert reftable block test to use clar\n t/unit-tests: convert reftable merged test to use clar\n t/unit-tests: convert reftable pq test to use clar\n t/unit-tests: convert reftable table test to use clar\n t/unit-tests: convert reftable readwrite test to use clar\n t/unit-tests: convert reftable record test to use clar\n t/unit-tests: convert reftable stack test to use clar\n t/unit-tests: finalize migration of reftable-related tests\n\n Makefile | 20 +-\n t/Makefile | 1 -\n t/meson.build | 42 +-\n t/unit-tests/lib-reftable.c | 35 +-\n t/unit-tests/lib-reftable.h | 15 +-\n t/unit-tests/t-reftable-basics.c | 219 -----\n t/unit-tests/u-reftable-basics.c | 227 +++++\n ...{t-reftable-block.c => u-reftable-block.c} | 164 ++--\n ...-reftable-merged.c => u-reftable-merged.c} | 160 ++--\n .../{t-reftable-pq.c => u-reftable-pq.c} | 59 +-\n ...ble-readwrite.c => u-reftable-readwrite.c} | 403 ++++-----\n ...-reftable-record.c => u-reftable-record.c} | 250 +++---\n ...{t-reftable-stack.c => u-reftable-stack.c} | 780 ++++++++----------\n ...{t-reftable-table.c => u-reftable-table.c} | 73 +-\n 14 files changed, 1117 insertions(+), 1331 deletions(-)\n delete mode 100644 t/unit-tests/t-reftable-basics.c\n create mode 100644 t/unit-tests/u-reftable-basics.c\n rename t/unit-tests/{t-reftable-block.c => u-reftable-block.c} (74%)\n rename t/unit-tests/{t-reftable-merged.c => u-reftable-merged.c} (77%)\n rename t/unit-tests/{t-reftable-pq.c => u-reftable-pq.c} (64%)\n rename t/unit-tests/{t-reftable-readwrite.c => u-reftable-readwrite.c} (68%)\n rename t/unit-tests/{t-reftable-record.c => u-reftable-record.c} (62%)\n rename t/unit-tests/{t-reftable-stack.c => u-reftable-stack.c} (59%)\n rename t/unit-tests/{t-reftable-table.c => u-reftable-table.c} (75%)\n\nRange-diff against v3:\n 1: 53a64f5551 = 1: 53a64f5551 t/unit-tests: implement clar specific reftable test helper functions\n 2: fec29d94d8 = 2: fec29d94d8 t/unit-tests: convert reftable basics test to use clar test framework\n 3: 57d7541caa ! 3: e717e4529d t/unit-tests: convert reftable block test to use clar\n @@ t/unit-tests/u-reftable-block.c: license that can be found in the LICENSE file o\n #include \"strbuf.h\"\n \n -static void t_ref_block_read_write(void)\n -+void test_reftable_block__index_read_write(void)\n ++void test_reftable_block__read_write(void)\n {\n \tconst int header_off = 21; /* random */\n \tstruct reftable_record recs[30];\n @@ t/unit-tests/u-reftable-block.c: static void t_ref_block_read_write(void)\n +\t\t\t\t(uint8_t *) block_data.buf, block_size,\n \t\t\t\theader_off, hash_size(REFTABLE_HASH_SHA1));\n -\tcheck(!ret);\n -+\tcl_assert(ret == 0);\n ++\tcl_assert(!ret);\n \n \trec.u.ref.refname = (char *) \"\";\n \trec.u.ref.value_type = REFTABLE_REF_DELETION;\n @@ t/unit-tests/u-reftable-block.c: static void t_log_block_read_write(void)\n \tret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_LOG, (uint8_t *) block_data.buf, block_size,\n \t\t\t\theader_off, hash_size(REFTABLE_HASH_SHA1));\n -\tcheck(!ret);\n -+\tcl_assert(ret == 0);\n ++\tcl_assert(!ret);\n \n \tfor (i = 0; i < N; i++) {\n \t\trec.u.log.refname = xstrfmt(\"branch%02\"PRIuMAX , (uintmax_t)i);\n @@ t/unit-tests/u-reftable-block.c: static void t_obj_block_read_write(void)\n \tret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_OBJ, (uint8_t *) block_data.buf, block_size,\n \t\t\t\theader_off, hash_size(REFTABLE_HASH_SHA1));\n -\tcheck(!ret);\n -+\tcl_assert(ret == 0);\n ++\tcl_assert(!ret);\n \n \tfor (i = 0; i < N; i++) {\n \t\tuint8_t bytes[] = { i, i + 1, i + 2, i + 3, i + 5 }, *allocated;\n @@ t/unit-tests/u-reftable-block.c: static void t_index_block_read_write(void)\n \tret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_INDEX, (uint8_t *) block_data.buf, block_size,\n \t\t\t\theader_off, hash_size(REFTABLE_HASH_SHA1));\n -\tcheck(!ret);\n -+\tcl_assert(ret == 0);\n ++\tcl_assert(!ret);\n \n \tfor (i = 0; i < N; i++) {\n \t\tchar buf[128];\n 4: db11c0eb30 ! 4: dc176ad6d9 t/unit-tests: convert reftable merged test to use clar\n @@ t/unit-tests/u-reftable-merged.c: static void t_merged_single_record(void)\n +\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"a\");\n -\tcheck(!err);\n -+\tcl_assert(err == 0);\n ++\tcl_assert(!err);\n \n \terr = reftable_iterator_next_ref(&it, &ref);\n -\tcheck(!err);\n -\tcheck(reftable_ref_record_equal(&r2[0], &ref, REFTABLE_HASH_SIZE_SHA1));\n -+\tcl_assert(err == 0);\n ++\tcl_assert(!err);\n +\tcl_assert(reftable_ref_record_equal(&r2[0], &ref,\n +\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \treftable_ref_record_release(&ref);\n @@ t/unit-tests/u-reftable-merged.c: static void t_merged_seek_multiple_times(void)\n \tfor (size_t i = 0; i < 5; i++) {\n \t\tint err = reftable_iterator_seek_ref(&it, \"c\");\n -\t\tcheck(!err);\n -+\t\tcl_assert(err == 0);\n ++\t\tcl_assert(!err);\n \n -\t\terr = reftable_iterator_next_ref(&it, &rec);\n -\t\tcheck(!err);\n @@ t/unit-tests/u-reftable-merged.c: static void t_default_write_opts(void)\n \n -\terr = reftable_writer_add_ref(w, &rec);\n -\tcheck(!err);\n -+\tcl_assert(reftable_writer_add_ref(w, &rec) == 0);\n ++\tcl_assert_equal_i(reftable_writer_add_ref(w, &rec), 0);\n \n -\terr = reftable_writer_close(w);\n -\tcheck(!err);\n -+\tcl_assert(reftable_writer_close(w) == 0);\n ++\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \treftable_writer_free(w);\n \n \tblock_source_from_buf(&source, &buf);\n 5: 60cf81862a ! 5: 1694375fab t/unit-tests: convert reftable pq test to use clar\n @@ t/unit-tests/u-reftable-pq.c: static void merged_iter_pqueue_check(const struct\n {\n \tint cmp;\n -\tcheck(!reftable_record_cmp(a->rec, b->rec, &cmp));\n -+\tcl_assert(reftable_record_cmp(a->rec, b->rec, &cmp) == 0);\n ++\tcl_assert_equal_i(reftable_record_cmp(a->rec, b->rec, &cmp), 0);\n \treturn !cmp && (a->index == b->index);\n }\n \n @@ t/unit-tests/u-reftable-pq.c: static void t_pq_record(void)\n \t\tstruct pq_entry e;\n \n -\t\tcheck(!merged_iter_pqueue_remove(&pq, &e));\n -+\t\tcl_assert(merged_iter_pqueue_remove(&pq, &e) == 0);\n ++\t\tcl_assert_equal_i(merged_iter_pqueue_remove(&pq, &e), 0);\n \t\tmerged_iter_pqueue_check(&pq);\n \n -\t\tcheck(pq_entry_equal(&top, &e));\n @@ t/unit-tests/u-reftable-pq.c: static void t_pq_index(void)\n \t\tstruct pq_entry e;\n \n -\t\tcheck(!merged_iter_pqueue_remove(&pq, &e));\n -+\t\tcl_assert(merged_iter_pqueue_remove(&pq, &e) == 0);\n ++\t\tcl_assert_equal_i(merged_iter_pqueue_remove(&pq, &e), 0);\n \t\tmerged_iter_pqueue_check(&pq);\n \n -\t\tcheck(pq_entry_equal(&top, &e));\n @@ t/unit-tests/u-reftable-pq.c: static void t_merged_iter_pqueue_top(void)\n \t\tstruct pq_entry e;\n \n -\t\tcheck(!merged_iter_pqueue_remove(&pq, &e));\n -+\t\tcl_assert(merged_iter_pqueue_remove(&pq, &e) == 0);\n ++\t\tcl_assert_equal_i(merged_iter_pqueue_remove(&pq, &e), 0);\n \n \t\tmerged_iter_pqueue_check(&pq);\n -\t\tcheck(pq_entry_equal(&top, &e));\n 6: 0eec9f7601 ! 6: 9842215a17 t/unit-tests: convert reftable table test to use clar\n @@ t/meson.build: if perl.found() and time.found()\n \n ## t/unit-tests/t-reftable-table.c => t/unit-tests/u-reftable-table.c ##\n @@\n - #include \"test-lib.h\"\n +-#include \"test-lib.h\"\n -#include \"lib-reftable.h\"\n ++#include \"unit-test.h\"\n +#include \"lib-reftable-clar.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/constants.h\"\n 7: 36bdd9b003 ! 7: acc72b57b2 t/unit-tests: convert reftable readwrite test to use clar\n @@ t/unit-tests/u-reftable-readwrite.c: license that can be found in the LICENSE fi\n \tint n;\n \tuint8_t in[] = \"hello\";\n -\tcheck(!reftable_buf_add(&buf, in, sizeof(in)));\n -+\tcl_assert(reftable_buf_add(&buf, in, sizeof(in)) == 0);\n ++\tcl_assert_equal_i(reftable_buf_add(&buf, in, sizeof(in)), 0);\n \tblock_source_from_buf(&source, &buf);\n -\tcheck_int(block_source_size(&source), ==, 6);\n +\tcl_assert_equal_i(block_source_size(&source), 6);\n @@ t/unit-tests/u-reftable-readwrite.c: static void write_table(char ***names, stru\n \t\trefs[i].update_index = update_index;\n \t\trefs[i].value_type = REFTABLE_REF_VAL1;\n -\t\tt_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n -+\t\tcl_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n ++\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n ++\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n @@ t/unit-tests/u-reftable-readwrite.c: static void write_table(char ***names, stru\n \t\tlogs[i].update_index = update_index;\n \t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n -\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i,\n +-\t\t\t\t REFTABLE_HASH_SHA1);\n +\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n - \t\t\t\t REFTABLE_HASH_SHA1);\n ++\t\t\t\t REFTABLE_HASH_SHA1);\n \t\tlogs[i].value.update.message = (char *) \"message\";\n \t}\n \n @@ t/unit-tests/u-reftable-readwrite.c: static void t_log_buffer_size(void)\n \t\t\t\t\t .message = (char *) \"commit: 9\\n\",\n \t\t\t\t } } };\n -\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n -+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n ++\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n ++\t\t\t\t\t\t\t &opts);\n \n \t/* This tests buffer extension for log compression. Must use a random\n \t hash, to ensure that the compressed part is larger than the original.\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_log_buffer_size(void)\n -\tcheck(!err);\n -\terr = reftable_writer_close(w);\n -\tcheck(!err);\n -+\tcl_assert(reftable_writer_add_log(w, &log) == 0);\n -+\tcl_assert(reftable_writer_close(w) == 0);\n ++\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n ++\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_log_overflow(void)\n \t\t},\n \t};\n -\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n -+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n ++\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n ++\t\t\t\t\t\t\t &opts);\n \n \tmemset(msg, 'x', sizeof(msg) - 1);\n \treftable_writer_set_limits(w, update_index, update_index);\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_log_overflow(void)\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n -\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n -+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n ++\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n ++\t\t\t\t\t\t\t &opts);\n \tstruct reftable_log_record log = {\n \t\t.refname = (char *)\"refs/head/master\",\n \t\t.update_index = 0,\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_log_write_read(void)\n \n -\t\terr = reftable_writer_add_ref(w, &ref);\n -\t\tcheck(!err);\n -+\t\tcl_assert(reftable_writer_add_ref(w, &ref) == 0);\n ++\t\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_log_write_read(void)\n \t\tlog.update_index = i;\n \t\tlog.value_type = REFTABLE_LOG_UPDATE;\n -\t\tt_reftable_set_hash(log.value.update.old_hash, i,\n -+\t\tcl_reftable_set_hash(log.value.update.old_hash, i,\n - \t\t\t\t REFTABLE_HASH_SHA1);\n +-\t\t\t\t REFTABLE_HASH_SHA1);\n -\t\tt_reftable_set_hash(log.value.update.new_hash, i + 1,\n +-\t\t\t\t REFTABLE_HASH_SHA1);\n ++\t\tcl_reftable_set_hash(log.value.update.old_hash, i,\n ++\t\t\t\t REFTABLE_HASH_SHA1);\n +\t\tcl_reftable_set_hash(log.value.update.new_hash, i + 1,\n - \t\t\t\t REFTABLE_HASH_SHA1);\n ++\t\t\t\t REFTABLE_HASH_SHA1);\n \n -\t\terr = reftable_writer_add_log(w, &log);\n -\t\tcheck(!err);\n -+\t\tcl_assert(reftable_writer_add_log(w, &log) == 0);\n ++\t\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n \t}\n \n -\tn = reftable_writer_close(w);\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_log_write_read(void)\n -\t\tcheck(!err);\n -\t\tcheck_str(names[i], log.refname);\n -\t\tcheck_int(i, ==, log.update_index);\n -+\t\tcl_assert(err == 0);\n ++\t\tcl_assert(!err);\n +\t\tcl_assert_equal_s(names[i], log.refname);\n +\t\tcl_assert_equal_i(i, log.update_index);\n \t\treftable_log_record_release(&log);\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_log_zlib_corruption(void)\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n -\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n -+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n ++\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n ++\t\t\t\t\t\t\t &opts);\n \tconst struct reftable_stats *stats = NULL;\n \tchar message[100] = { 0 };\n -\tint err, i, n;\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_log_zlib_corruption(void)\n -\n -\tn = reftable_writer_close(w);\n -\tcheck_int(n, ==, 0);\n -+\tcl_assert(reftable_writer_add_log(w, &log) == 0);\n ++\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n +\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \n \tstats = reftable_writer_stats(w);\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_table_read_write_seek(int ind\n \n -\tcheck(!reftable_buf_addstr(&pastLast, names[N - 1]));\n -\tcheck(!reftable_buf_addstr(&pastLast, \"/\"));\n -+\tcl_assert(reftable_buf_addstr(&pastLast, names[N - 1]) == 0);\n -+\tcl_assert(reftable_buf_addstr(&pastLast, \"/\") == 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&pastLast, names[N - 1]),\n ++\t\t\t\t\t 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&pastLast, \"/\"), 0);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n -\tcheck(!err);\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_table_refs_for(int indexed)\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n -\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n -+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n ++\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n ++\t\t\t\t\t\t\t &opts);\n \tstruct reftable_iterator it = { 0 };\n -\tint N = 50, n, j, err, i;\n +\tint N = 50, j, i;\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_table_refs_for(int indexed)\n \n \t\tref.value_type = REFTABLE_REF_VAL2;\n -\t\tt_reftable_set_hash(ref.value.val2.value, i / 4,\n -+\t\tcl_reftable_set_hash(ref.value.val2.value, i / 4,\n - \t\t\t\t REFTABLE_HASH_SHA1);\n +-\t\t\t\t REFTABLE_HASH_SHA1);\n -\t\tt_reftable_set_hash(ref.value.val2.target_value, 3 + i / 4,\n -+\t\tcl_reftable_set_hash(ref.value.val2.target_value, 3 + i / 4,\n - \t\t\t\t REFTABLE_HASH_SHA1);\n +-\t\t\t\t REFTABLE_HASH_SHA1);\n ++\t\tcl_reftable_set_hash(ref.value.val2.value, i / 4,\n ++\t\t\t\t REFTABLE_HASH_SHA1);\n ++\t\tcl_reftable_set_hash(ref.value.val2.target_value,\n ++\t\t\t\t 3 + i / 4, REFTABLE_HASH_SHA1);\n \n \t\t/* 80 bytes / entry, so 3 entries per block. Yields 17\n \t\t */\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_write_object_id_min_length(vo\n \t\tref.refname = name;\n -\t\terr = reftable_writer_add_ref(w, &ref);\n -\t\tcheck(!err);\n -+\t\tcl_assert(reftable_writer_add_ref(w, &ref) == 0);\n ++\t\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);\n \t}\n \n -\terr = reftable_writer_close(w);\n -\tcheck(!err);\n -\tcheck_int(reftable_writer_stats(w)->object_id_len, ==, 2);\n -+\tcl_assert(reftable_writer_close(w) == 0);\n ++\tcl_assert_equal_i(reftable_writer_close(w), 0);\n +\tcl_assert_equal_i(reftable_writer_stats(w)->object_id_len, 2);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_write_object_id_length(void)\n -\terr = reftable_writer_close(w);\n -\tcheck(!err);\n -\tcheck_int(reftable_writer_stats(w)->object_id_len, ==, 16);\n -+\tcl_assert(reftable_writer_close(w) == 0);\n ++\tcl_assert_equal_i(reftable_writer_close(w), 0);\n +\tcl_assert_equal_i(reftable_writer_stats(w)->object_id_len, 16);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_write_object_id_length(void)\n -\terr = reftable_writer_close(w);\n -\tcheck_int(err, ==, REFTABLE_EMPTY_TABLE_ERROR);\n +\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), REFTABLE_API_ERROR);\n -+\tcl_assert_equal_i(reftable_writer_close(w), REFTABLE_EMPTY_TABLE_ERROR);\n ++\tcl_assert_equal_i(reftable_writer_close(w),\n ++\t\t\t REFTABLE_EMPTY_TABLE_ERROR);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_write_key_order(void)\n -\tcheck(!err);\n -\terr = reftable_writer_add_ref(w, &refs[1]);\n -\tcheck_int(err, ==, REFTABLE_API_ERROR);\n -+\tcl_assert(reftable_writer_add_ref(w, &refs[0]) == 0);\n -+\tcl_assert_equal_i(reftable_writer_add_ref(w, &refs[1]), REFTABLE_API_ERROR);\n ++\tcl_assert_equal_i(reftable_writer_add_ref(w, &refs[0]), 0);\n ++\tcl_assert_equal_i(reftable_writer_add_ref(w, &refs[1]),\n ++\t\t\t REFTABLE_API_ERROR);\n \n \trefs[0].update_index = 2;\n -\terr = reftable_writer_add_ref(w, &refs[0]);\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_write_multiple_indices(void)\n \n -\t\terr = reftable_writer_add_ref(writer, &ref);\n -\t\tcheck(!err);\n -+\t\tcl_assert(reftable_writer_add_ref(writer, &ref) == 0);\n ++\t\tcl_assert_equal_i(reftable_writer_add_ref(writer, &ref), 0);\n \t}\n \n \tfor (i = 0; i < 100; i++) {\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_write_multiple_indices(void)\n \n -\t\terr = reftable_writer_add_log(writer, &log);\n -\t\tcheck(!err);\n -+\t\tcl_assert(reftable_writer_add_log(writer, &log) == 0);\n ++\t\tcl_assert_equal_i(reftable_writer_add_log(writer, &log), 0);\n \t}\n \n \treftable_writer_close(writer);\n @@ t/unit-tests/u-reftable-readwrite.c: static void t_write_multi_level_index(void)\n \n -\t\terr = reftable_writer_add_ref(writer, &ref);\n -\t\tcheck(!err);\n -+\t\tcl_assert(reftable_writer_add_ref(writer, &ref) == 0);\n ++\t\tcl_assert_equal_i(reftable_writer_add_ref(writer, &ref), 0);\n \t}\n \treftable_writer_close(writer);\n \n 8: df744c1458 ! 8: 7b54300fac t/unit-tests: convert reftable record test to use clar\n @@ t/unit-tests/u-reftable-record.c: static void t_copy(struct reftable_record *rec\n \n \ttyp = reftable_record_type(rec);\n -\tcheck(!reftable_record_init(©, typ));\n -+\tcl_assert(reftable_record_init(©, typ) == 0);\n ++\tcl_assert_equal_i(reftable_record_init(©, typ), 0);\n \treftable_record_copy_from(©, rec, REFTABLE_HASH_SIZE_SHA1);\n \t/* do it twice to catch memory leaks */\n \treftable_record_copy_from(©, rec, REFTABLE_HASH_SIZE_SHA1);\n -\tcheck(reftable_record_equal(rec, ©, REFTABLE_HASH_SIZE_SHA1));\n -+\tcl_assert(reftable_record_equal(rec, ©, REFTABLE_HASH_SIZE_SHA1) != 0);\n ++\tcl_assert(reftable_record_equal(rec, ©,\n ++\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n \n \treftable_record_release(©);\n }\n @@ t/unit-tests/u-reftable-record.c: static void t_reftable_ref_record_comparison(v\n -\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n -\tcheck(!cmp);\n +\tcl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);\n -+\tcl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);\n -+\tcl_assert(cmp == 0);\n ++\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n ++\tcl_assert(!cmp);\n \n -\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n -\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n -\tcheck_int(cmp, >, 0);\n -+\tcl_assert(reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1) == 0);\n -+\tcl_assert(reftable_record_cmp(&in[1], &in[2], &cmp) == 0);\n ++\tcl_assert(reftable_record_equal(&in[1], &in[2],\n ++\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) == 0);\n ++\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n +\tcl_assert(cmp > 0);\n \n \tin[1].u.ref.value_type = in[0].u.ref.value_type;\n -\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n -\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n -\tcheck(!cmp);\n -+\tcl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);\n -+\tcl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);\n -+\tcl_assert(cmp == 0);\n ++\tcl_assert(reftable_record_equal(&in[0], &in[1],\n ++\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n ++\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n ++\tcl_assert(!cmp);\n }\n \n -static void t_reftable_ref_record_compare_name(void)\n @@ t/unit-tests/u-reftable-record.c: static void t_reftable_ref_record_compare_name\n -\tcheck_int(reftable_ref_record_compare_name(&recs[0], &recs[1]), <, 0);\n -\tcheck_int(reftable_ref_record_compare_name(&recs[1], &recs[0]), >, 0);\n -\tcheck_int(reftable_ref_record_compare_name(&recs[0], &recs[2]), ==, 0);\n -+\tcl_assert(reftable_ref_record_compare_name(&recs[0], &recs[1]) < 0);\n -+\tcl_assert(reftable_ref_record_compare_name(&recs[1], &recs[0]) > 0);\n -+\tcl_assert_equal_i(reftable_ref_record_compare_name(&recs[0], &recs[2]), 0);\n ++\tcl_assert(reftable_ref_record_compare_name(&recs[0],\n ++\t\t\t\t\t\t &recs[1]) < 0);\n ++\tcl_assert(reftable_ref_record_compare_name(&recs[1],\n ++\t\t\t\t\t\t &recs[0]) > 0);\n ++\tcl_assert_equal_i(reftable_ref_record_compare_name(&recs[0],\n ++\t\t\t\t\t\t\t &recs[2]), 0);\n }\n \n -static void t_reftable_ref_record_roundtrip(void)\n @@ t/unit-tests/u-reftable-record.c: static void t_reftable_ref_record_roundtrip(vo\n -\t\tcheck_int(reftable_record_val_type(&in), ==, i);\n -\t\tcheck_int(reftable_record_is_deletion(&in), ==, i == REFTABLE_REF_DELETION);\n +\t\tcl_assert_equal_i(reftable_record_val_type(&in), i);\n -+\t\tcl_assert_equal_i(reftable_record_is_deletion(&in), i == REFTABLE_REF_DELETION);\n ++\t\tcl_assert_equal_i(reftable_record_is_deletion(&in),\n ++\t\t\t\t i == REFTABLE_REF_DELETION);\n \n \t\treftable_record_key(&in, &key);\n \t\tn = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);\n @@ t/unit-tests/u-reftable-record.c: static void t_reftable_ref_record_roundtrip(vo\n \n -\t\tcheck(reftable_ref_record_equal(&in.u.ref, &out.u.ref,\n -\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n -+\t\tcl_assert(reftable_ref_record_equal(&in.u.ref, &out.u.ref,\n -+\t\t\t\t\t\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n ++\t\tcl_assert(reftable_ref_record_equal(&in.u.ref,\n ++\t\t\t\t\t\t &out.u.ref,\n ++\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_record_release(&in);\n \n \t\treftable_buf_release(&key);\n @@ t/unit-tests/u-reftable-record.c: static void t_reftable_log_record_comparison(v\n -\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n -\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n -\tcheck_int(cmp, >, 0);\n -+\tcl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);\n -+\tcl_assert(reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1) == 0);\n -+\tcl_assert(reftable_record_cmp(&in[1], &in[2], &cmp) == 0);\n ++\tcl_assert_equal_i(reftable_record_equal(&in[0], &in[1],\n ++\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n ++\tcl_assert_equal_i(reftable_record_equal(&in[1], &in[2],\n ++\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n ++\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n +\tcl_assert(cmp > 0);\n \t/* comparison should be reversed for equal keys, because\n \t * comparison is now performed on the basis of update indices */\n -\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n -\tcheck_int(cmp, <, 0);\n -+\tcl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);\n ++\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n +\tcl_assert(cmp < 0);\n \n \tin[1].u.log.update_index = in[0].u.log.update_index;\n -\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n -\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n -+\tcl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);\n -+\tcl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);\n ++\tcl_assert(reftable_record_equal(&in[0], &in[1],\n ++\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n ++\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n }\n \n -static void t_reftable_log_record_compare_key(void)\n @@ t/unit-tests/u-reftable-record.c: static void t_reftable_log_record_compare_key(\n \n -\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[1]), <, 0);\n -\tcheck_int(reftable_log_record_compare_key(&logs[1], &logs[0]), >, 0);\n -+\tcl_assert(reftable_log_record_compare_key(&logs[0], &logs[1]) < 0);\n -+\tcl_assert(reftable_log_record_compare_key(&logs[1], &logs[0]) > 0);\n ++\tcl_assert(reftable_log_record_compare_key(&logs[0],\n ++\t\t\t\t\t\t &logs[1]) < 0);\n ++\tcl_assert(reftable_log_record_compare_key(&logs[1],\n ++\t\t\t\t\t\t &logs[0]) > 0);\n \n \tlogs[1].update_index = logs[0].update_index;\n -\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[1]), <, 0);\n -+\tcl_assert(reftable_log_record_compare_key(&logs[0], &logs[1]) < 0);\n ++\tcl_assert(reftable_log_record_compare_key(&logs[0],\n ++\t\t\t\t\t\t &logs[1]) < 0);\n \n -\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[2]), >, 0);\n -\tcheck_int(reftable_log_record_compare_key(&logs[2], &logs[0]), <, 0);\n -+\tcl_assert(reftable_log_record_compare_key(&logs[0], &logs[2]) > 0);\n -+\tcl_assert(reftable_log_record_compare_key(&logs[2], &logs[0]) < 0);\n ++\tcl_assert(reftable_log_record_compare_key(&logs[0],\n ++\t\t\t\t\t\t &logs[2]) > 0);\n ++\tcl_assert(reftable_log_record_compare_key(&logs[2],\n ++\t\t\t\t\t\t &logs[0]) < 0);\n \tlogs[2].update_index = logs[0].update_index;\n -\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[2]), ==, 0);\n +\tcl_assert_equal_i(reftable_log_record_compare_key(&logs[0], &logs[2]), 0);\n @@ t/unit-tests/u-reftable-record.c: static void t_reftable_log_record_roundtrip(vo\n -\tcheck(!reftable_log_record_is_deletion(&in[0]));\n -\tcheck(reftable_log_record_is_deletion(&in[1]));\n -\tcheck(!reftable_log_record_is_deletion(&in[2]));\n -+\tcl_assert(reftable_log_record_is_deletion(&in[0]) == 0);\n ++\tcl_assert_equal_i(reftable_log_record_is_deletion(&in[0]), 0);\n +\tcl_assert(reftable_log_record_is_deletion(&in[1]) != 0);\n -+\tcl_assert(reftable_log_record_is_deletion(&in[2]) == 0);\n ++\tcl_assert_equal_i(reftable_log_record_is_deletion(&in[2]), 0);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(in); i++) {\n \t\tstruct reftable_record rec = { .type = REFTABLE_BLOCK_TYPE_LOG };\n @@ t/unit-tests/u-reftable-record.c: static void t_reftable_log_record_roundtrip(vo\n -\t\tcheck(reftable_log_record_equal(&in[i], &out.u.log,\n -\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n +\t\tcl_assert(reftable_log_record_equal(&in[i], &out.u.log,\n -+\t\t\t\t\t\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n ++\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_log_record_release(&in[i]);\n \t\treftable_buf_release(&key);\n \t\treftable_record_release(&out);\n @@ t/unit-tests/u-reftable-record.c: static void t_key_roundtrip(void)\n \n -\tcheck(!reftable_buf_addstr(&last_key, \"refs/heads/master\"));\n -\tcheck(!reftable_buf_addstr(&key, \"refs/tags/bla\"));\n -+\tcl_assert(reftable_buf_addstr(&last_key, \"refs/heads/master\") == 0);\n -+\tcl_assert(reftable_buf_addstr(&key, \"refs/tags/bla\") == 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&last_key,\n ++\t\t\t\t\t \"refs/heads/master\"), 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&key,\n ++\t\t\t\t\t \"refs/tags/bla\"), 0);\n \textra = 6;\n \tn = reftable_encode_key(&restart, dest, last_key, key, extra);\n -\tcheck(!restart);\n -\tcheck_int(n, >, 0);\n -+\tcl_assert(restart == 0);\n ++\tcl_assert(!restart);\n +\tcl_assert(n > 0);\n \n -\tcheck(!reftable_buf_addstr(&roundtrip, \"refs/heads/master\"));\n -+\tcl_assert(reftable_buf_addstr(&roundtrip, \"refs/heads/master\") == 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&roundtrip,\n ++\t\t\t\t\t \"refs/heads/master\"), 0);\n \tm = reftable_decode_key(&roundtrip, &rt_extra, dest);\n -\tcheck_int(n, ==, m);\n -\tcheck(!reftable_buf_cmp(&key, &roundtrip));\n -\tcheck_int(rt_extra, ==, extra);\n +\tcl_assert_equal_i(n, m);\n -+\tcl_assert(reftable_buf_cmp(&key, &roundtrip) == 0);\n ++\tcl_assert_equal_i(reftable_buf_cmp(&key, &roundtrip), 0);\n +\tcl_assert_equal_i(rt_extra, extra);\n \n \treftable_buf_release(&last_key);\n @@ t/unit-tests/u-reftable-record.c: static void t_reftable_obj_record_comparison(v\n -\tcheck(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n -\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n -\tcheck(!cmp);\n -+\tcl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);\n -+\tcl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);\n -+\tcl_assert(cmp == 0);\n ++\tcl_assert_equal_i(reftable_record_equal(&in[0], &in[1],\n ++\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n ++\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n ++\tcl_assert(!cmp);\n \n -\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n -\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n -\tcheck_int(cmp, >, 0);\n -+\tcl_assert(reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1) == 0);\n -+\tcl_assert(reftable_record_cmp(&in[1], &in[2], &cmp) == 0);\n ++\tcl_assert_equal_i(reftable_record_equal(&in[1], &in[2],\n ++\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n ++\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n +\tcl_assert(cmp > 0);\n \n \tin[1].u.obj.offset_len = in[0].u.obj.offset_len;\n @@ t/unit-tests/u-reftable-record.c: static void t_reftable_obj_record_comparison(v\n -\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n -\tcheck(!cmp);\n +\tcl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);\n -+\tcl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);\n -+\tcl_assert(cmp == 0);\n ++\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n ++\tcl_assert(!cmp);\n }\n \n -static void t_reftable_obj_record_roundtrip(void)\n @@ t/unit-tests/u-reftable-record.c: static void t_reftable_obj_record_roundtrip(vo\n \t\tuint8_t extra;\n \n -\t\tcheck(!reftable_record_is_deletion(&in));\n -+\t\tcl_assert(reftable_record_is_deletion(&in) == 0);\n ++\t\tcl_assert_equal_i(reftable_record_is_deletion(&in), 0);\n \t\tt_copy(&in);\n \t\treftable_record_key(&in, &key);\n \t\tn = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);\n @@ t/unit-tests/u-reftable-record.c: static void t_reftable_obj_record_roundtrip(vo\n +\t\tcl_assert_equal_i(n, m);\n \n -\t\tcheck(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1));\n -+\t\tcl_assert(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1) != 0);\n ++\t\tcl_assert(reftable_record_equal(&in, &out,\n ++\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_buf_release(&key);\n \t\treftable_record_release(&out);\n \t}\n @@ t/unit-tests/u-reftable-record.c: static void t_reftable_index_record_comparison\n -\tcheck(!reftable_buf_addstr(&in[0].u.idx.last_key, \"refs/heads/master\"));\n -\tcheck(!reftable_buf_addstr(&in[1].u.idx.last_key, \"refs/heads/master\"));\n -\tcheck(!reftable_buf_addstr(&in[2].u.idx.last_key, \"refs/heads/branch\"));\n -+\tcl_assert(reftable_buf_addstr(&in[0].u.idx.last_key, \"refs/heads/master\") == 0);\n -+\tcl_assert(reftable_buf_addstr(&in[1].u.idx.last_key, \"refs/heads/master\") == 0);\n -+\tcl_assert(reftable_buf_addstr(&in[2].u.idx.last_key, \"refs/heads/branch\") == 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&in[0].u.idx.last_key,\n ++\t\t\t\t\t \"refs/heads/master\"), 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&in[1].u.idx.last_key, \"refs/heads/master\"), 0);\n ++\tcl_assert(reftable_buf_addstr(&in[2].u.idx.last_key,\n ++\t\t\t\t \"refs/heads/branch\") == 0);\n \n -\tcheck(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n -\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n -\tcheck(!cmp);\n -+\tcl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);\n -+\tcl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);\n -+\tcl_assert(cmp == 0);\n ++\tcl_assert_equal_i(reftable_record_equal(&in[0], &in[1],\n ++\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n ++\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n ++\tcl_assert(!cmp);\n \n -\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n -\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n -\tcheck_int(cmp, >, 0);\n -+\tcl_assert(reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1) == 0);\n -+\tcl_assert(reftable_record_cmp(&in[1], &in[2], &cmp) == 0);\n ++\tcl_assert_equal_i(reftable_record_equal(&in[1], &in[2],\n ++\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n ++\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n +\tcl_assert(cmp > 0);\n \n \tin[1].u.idx.offset = in[0].u.idx.offset;\n -\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n -\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n -\tcheck(!cmp);\n -+\tcl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);\n -+\tcl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);\n -+\tcl_assert(cmp == 0);\n ++\tcl_assert(reftable_record_equal(&in[0], &in[1],\n ++\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n ++\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n ++\tcl_assert(!cmp);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(in); i++)\n \t\treftable_record_release(&in[i]);\n @@ t/unit-tests/u-reftable-record.c: static void t_reftable_index_record_roundtrip(\n \tuint8_t extra;\n \n -\tcheck(!reftable_buf_addstr(&in.u.idx.last_key, \"refs/heads/master\"));\n -+\tcl_assert(reftable_buf_addstr(&in.u.idx.last_key, \"refs/heads/master\") == 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&in.u.idx.last_key,\n ++\t\t\t\t\t \"refs/heads/master\"), 0);\n \treftable_record_key(&in, &key);\n \tt_copy(&in);\n \n -\tcheck(!reftable_record_is_deletion(&in));\n -\tcheck(!reftable_buf_cmp(&key, &in.u.idx.last_key));\n -+\tcl_assert(reftable_record_is_deletion(&in) == 0);\n -+\tcl_assert(reftable_buf_cmp(&key, &in.u.idx.last_key) == 0);\n ++\tcl_assert_equal_i(reftable_record_is_deletion(&in), 0);\n ++\tcl_assert_equal_i(reftable_buf_cmp(&key, &in.u.idx.last_key), 0);\n \tn = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);\n -\tcheck_int(n, >, 0);\n +\tcl_assert(n > 0);\n \n \textra = reftable_record_val_type(&in);\n - \tm = reftable_record_decode(&out, key, extra, dest, REFTABLE_HASH_SIZE_SHA1,\n - \t\t\t\t &scratch);\n +-\tm = reftable_record_decode(&out, key, extra, dest, REFTABLE_HASH_SIZE_SHA1,\n +-\t\t\t\t &scratch);\n -\tcheck_int(m, ==, n);\n ++\tm = reftable_record_decode(&out, key, extra, dest,\n ++\t\t\t\t REFTABLE_HASH_SIZE_SHA1, &scratch);\n +\tcl_assert_equal_i(m, n);\n \n -\tcheck(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1));\n -+\tcl_assert(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1) != 0);\n ++\tcl_assert(reftable_record_equal(&in, &out,\n ++\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n \n \treftable_record_release(&out);\n \treftable_buf_release(&key);\n 9: 4a247de9e4 ! 9: 8250eb25e8 t/unit-tests: convert reftable stack test to use clar\n @@ t/unit-tests/u-reftable-stack.c: static void t_read_file(void)\n \n \terr = read_lines(fn, &names);\n -\tcheck(!err);\n -+\tcl_assert(err == 0);\n ++\tcl_assert(!err);\n \n \tfor (size_t i = 0; names[i]; i++)\n -\t\tcheck_str(want[i], names[i]);\n @@ t/unit-tests/u-reftable-stack.c: static void t_read_file(void)\n \tstruct reftable_ref_record *ref = arg;\n -\tcheck(!reftable_writer_set_limits(wr, ref->update_index,\n -\t\t\t\t\t ref->update_index));\n -+\tcl_assert(reftable_writer_set_limits(wr, ref->update_index,\n -+\t\t\t\t\t\t\t\t\t\t ref->update_index) == 0);\n ++\tcl_assert_equal_i(reftable_writer_set_limits(wr,\n ++\t\t\t\t\t\t ref->update_index, ref->update_index), 0);\n \treturn reftable_writer_add_ref(wr, ref);\n }\n \n @@ t/unit-tests/u-reftable-stack.c: static void write_n_ref_tables(struct reftable_\n \n -\t\terr = reftable_stack_add(st, &write_test_ref, &ref);\n -\t\tcheck(!err);\n -+\t\tcl_assert(reftable_stack_add(st, &write_test_ref, &ref) == 0);\n ++\t\tcl_assert_equal_i(reftable_stack_add(st,\n ++\t\t\t\t\t\t &write_test_ref, &ref), 0);\n \t}\n \n \tst->opts.disable_auto_compact = disable_auto_compact;\n @@ t/unit-tests/u-reftable-stack.c: static int write_test_log(struct reftable_write\n \n -\tcheck(!reftable_writer_set_limits(wr, wla->update_index,\n -\t\t\t\t\t wla->update_index));\n -+\tcl_assert(reftable_writer_set_limits(wr, wla->update_index,\n -+\t\t\t\t\t\t\t\t\t\t wla->update_index) == 0);\n ++\tcl_assert_equal_i(reftable_writer_set_limits(wr,\n ++\t\t\t\t\t\t wla->update_index,\n ++\t\t\t\t\t\t wla->update_index), 0);\n \treturn reftable_writer_add_log(wr, wla->log);\n }\n \n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add_one(void)\n -\terr = stat(scratch.buf, &stat_result);\n -\tcheck(!err);\n -\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n -+\tcl_assert(reftable_buf_addstr(&scratch, dir) == 0);\n -+\tcl_assert(reftable_buf_addstr(&scratch, \"/tables.list\") == 0);\n -+\tcl_assert(stat(scratch.buf, &stat_result) == 0);\n -+\tcl_assert_equal_i((stat_result.st_mode & 0777), opts.default_permissions);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&scratch, dir), 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&scratch,\n ++\t\t\t\t\t \"/tables.list\"), 0);\n ++\tcl_assert_equal_i(stat(scratch.buf, &stat_result), 0);\n ++\tcl_assert_equal_i((stat_result.st_mode & 0777),\n ++\t\t\t opts.default_permissions);\n \n \treftable_buf_reset(&scratch);\n -\tcheck(!reftable_buf_addstr(&scratch, dir));\n -\tcheck(!reftable_buf_addstr(&scratch, \"/\"));\n -+\tcl_assert(reftable_buf_addstr(&scratch, dir) == 0);\n -+\tcl_assert(reftable_buf_addstr(&scratch, \"/\") == 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&scratch, dir), 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&scratch, \"/\"), 0);\n \t/* do not try at home; not an external API for reftable. */\n -\tcheck(!reftable_buf_addstr(&scratch, st->tables[0]->name));\n +\tcl_assert(!reftable_buf_addstr(&scratch, st->tables[0]->name));\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_uptodate(void)\n -\n -\terr = reftable_stack_add(st2, write_test_ref, &ref2);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st1, dir, &opts) == 0);\n -+\tcl_assert(reftable_new_stack(&st2, dir, &opts) == 0);\n -+\tcl_assert(reftable_stack_add(st1, write_test_ref, &ref1) == 0);\n -+\tcl_assert_equal_i(reftable_stack_add(st2, write_test_ref, &ref2),\n -+\t\t\t\t\t REFTABLE_OUTDATED_ERROR);\n -+\tcl_assert(reftable_stack_reload(st2) == 0);\n -+\tcl_assert(reftable_stack_add(st2, write_test_ref, &ref2) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n ++\tcl_assert_equal_i(reftable_stack_add(st1, write_test_ref,\n ++\t\t\t\t\t &ref1), 0);\n ++\tcl_assert_equal_i(reftable_stack_add(st2, write_test_ref,\n ++\t\t\t\t\t &ref2), REFTABLE_OUTDATED_ERROR);\n ++\tcl_assert_equal_i(reftable_stack_reload(st2), 0);\n ++\tcl_assert_equal_i(reftable_stack_add(st2, write_test_ref,\n ++\t\t\t\t\t &ref2), 0);\n \treftable_stack_destroy(st1);\n \treftable_stack_destroy(st2);\n \tclear_dir(dir);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_transaction_api(vo\n \n -\terr = reftable_new_stack(&st, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \treftable_addition_destroy(add);\n \n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_transaction_api(vo\n -\n -\terr = reftable_addition_commit(add);\n -\tcheck(!err);\n -+\tcl_assert(reftable_stack_new_addition(&add, st, 0) == 0);\n -+\tcl_assert(reftable_addition_add(add, write_test_ref, &ref) == 0);\n -+\tcl_assert(reftable_addition_commit(add) == 0);\n ++\tcl_assert_equal_i(reftable_stack_new_addition(&add, st, 0), 0);\n ++\tcl_assert_equal_i(reftable_addition_add(add, write_test_ref,\n ++\t\t\t\t\t\t&ref), 0);\n ++\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \n \treftable_addition_destroy(add);\n \n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_transaction_api(vo\n -\tcheck(!err);\n -\tcheck_int(REFTABLE_REF_SYMREF, ==, dest.value_type);\n -\tcheck(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));\n -+\tcl_assert(reftable_stack_read_ref(st, ref.refname, &dest) == 0);\n ++\tcl_assert_equal_i(reftable_stack_read_ref(st, ref.refname,\n ++\t\t\t\t\t\t &dest), 0);\n +\tcl_assert_equal_i(REFTABLE_REF_SYMREF, dest.value_type);\n -+\tcl_assert(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1) != 0);\n ++\tcl_assert(reftable_ref_record_equal(&ref, &dest,\n ++\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \n \treftable_ref_record_release(&dest);\n \treftable_stack_destroy(st);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_transaction_with_r\n -\tcheck(!err);\n -\terr = reftable_addition_commit(add);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st1, dir, NULL) == 0);\n -+\tcl_assert(reftable_new_stack(&st2, dir, NULL) == 0);\n -+\tcl_assert(reftable_stack_new_addition(&add, st1, 0) == 0);\n -+\tcl_assert(reftable_addition_add(add, write_test_ref, &refs[0]) == 0);\n -+\tcl_assert(reftable_addition_commit(add) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st1, dir, NULL), 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st2, dir, NULL), 0);\n ++\tcl_assert_equal_i(reftable_stack_new_addition(&add, st1, 0), 0);\n ++\tcl_assert_equal_i(reftable_addition_add(add, write_test_ref,\n ++\t\t\t\t\t\t&refs[0]), 0);\n ++\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \treftable_addition_destroy(add);\n \n \t/*\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_transaction_with_r\n -\terr = reftable_addition_commit(add);\n -\tcheck(!err);\n +\tcl_assert_equal_i(reftable_stack_new_addition(&add, st2, 0),\n -+\t\t\t\t\t REFTABLE_OUTDATED_ERROR);\n -+\tcl_assert(reftable_stack_new_addition(&add, st2,\n -+\t\t\t\t\t\t\t\t\t\t REFTABLE_STACK_NEW_ADDITION_RELOAD) == 0);\n -+\tcl_assert(reftable_addition_add(add, write_test_ref, &refs[1]) == 0);\n -+\tcl_assert(reftable_addition_commit(add) == 0);\n ++\t\t\t\t\t\t REFTABLE_OUTDATED_ERROR);\n ++\tcl_assert_equal_i(reftable_stack_new_addition(&add, st2,\n ++\t\t\t\t\t\t REFTABLE_STACK_NEW_ADDITION_RELOAD), 0);\n ++\tcl_assert_equal_i(reftable_addition_add(add, write_test_ref,\n ++\t\t\t\t\t\t&refs[1]), 0);\n ++\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \treftable_addition_destroy(add);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(refs); i++) {\n -\t\terr = reftable_stack_read_ref(st2, refs[i].refname, &ref);\n -\t\tcheck(!err);\n -\t\tcheck(reftable_ref_record_equal(&refs[i], &ref, REFTABLE_HASH_SIZE_SHA1));\n -+\t\tcl_assert(reftable_stack_read_ref(st2, refs[i].refname, &ref) == 0);\n ++\t\tcl_assert_equal_i(reftable_stack_read_ref(st2,\n ++\t\t\t\t\t\t\t refs[i].refname, &ref) , 0);\n +\t\tcl_assert(reftable_ref_record_equal(&refs[i], &ref,\n -+\t\t\t\t\t\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n ++\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t}\n \n \treftable_ref_record_release(&ref);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_transaction_with_r\n \n -\terr = reftable_new_stack(&st, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (size_t i = 0; i <= n; i++) {\n \t\tstruct reftable_ref_record ref = {\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_transaction_api_pe\n -\n -\t\terr = reftable_addition_commit(add);\n -\t\tcheck(!err);\n -+\t\tcl_assert(reftable_stack_new_addition(&add, st, 0) == 0);\n -+\t\tcl_assert(reftable_addition_add(add, write_test_ref, &ref) == 0);\n -+\t\tcl_assert(reftable_addition_commit(add) == 0);\n ++\t\tcl_assert_equal_i(reftable_stack_new_addition(&add,\n ++\t\t\t\t\t\t\t st, 0), 0);\n ++\t\tcl_assert_equal_i(reftable_addition_add(add,\n ++\t\t\t\t\t\t\twrite_test_ref, &ref), 0);\n ++\t\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \n \t\treftable_addition_destroy(add);\n \n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_auto_compaction_fa\n -\tcheck_int(st->merged->tables_len, ==, 1);\n -\tcheck_int(st->stats.attempts, ==, 0);\n -\tcheck_int(st->stats.failures, ==, 0);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n -+\tcl_assert(reftable_stack_add(st, write_test_ref, &ref) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n ++\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n ++\t\t\t\t\t &ref), 0);\n +\tcl_assert_equal_i(st->merged->tables_len, 1);\n +\tcl_assert_equal_i(st->stats.attempts, 0);\n +\tcl_assert_equal_i(st->stats.failures, 0);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_update_index_check\n -\n -\terr = reftable_stack_add(st, write_test_ref, &ref2);\n -\tcheck_int(err, ==, REFTABLE_API_ERROR);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n -+\tcl_assert(reftable_stack_add(st, write_test_ref, &ref1) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n +\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n -+\t\t\t\t\t\t\t\t\t\t &ref2), REFTABLE_API_ERROR);\n ++\t\t\t\t\t &ref1), 0);\n ++\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n ++\t\t\t\t\t &ref2), REFTABLE_API_ERROR);\n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_update_index_check\n -\t\terr = reftable_stack_add(st, write_error, &i);\n -\t\tcheck_int(err, ==, i);\n -\t}\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n +\tfor (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--)\n -+\t\tcl_assert_equal_i(reftable_stack_add(st, write_error, &i), i);\n ++\t\tcl_assert_equal_i(reftable_stack_add(st, write_error,\n ++\t\t\t\t\t\t &i), i);\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add(void)\n \t\trefs[i].update_index = i + 1;\n \t\trefs[i].value_type = REFTABLE_REF_VAL1;\n -\t\tt_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n -+\t\tcl_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n ++\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n ++\t\t\t\t REFTABLE_HASH_SHA1);\n \n \t\tlogs[i].refname = xstrdup(buf);\n \t\tlogs[i].update_index = N + i + 1;\n \t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n \t\tlogs[i].value.update.email = xstrdup(\"identity@invalid\");\n -\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);\n -+\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);\n ++\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n ++\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n -\tfor (i = 0; i < N; i++) {\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add(void)\n -\t\tcheck(!err);\n -\t}\n +\tfor (i = 0; i < N; i++)\n -+\t\tcl_assert(reftable_stack_add(st, write_test_ref, &refs[i]) == 0);\n ++\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n ++\t\t\t\t\t &refs[i]), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct write_log_arg arg = {\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add(void)\n \t\t};\n -\t\tint err = reftable_stack_add(st, write_test_log, &arg);\n -\t\tcheck(!err);\n -+\t\tcl_assert(reftable_stack_add(st, write_test_log, &arg) == 0);\n ++\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n ++\t\t\t\t\t\t &arg), 0);\n \t}\n \n -\terr = reftable_stack_compact_all(st, NULL);\n -\tcheck(!err);\n -+\tcl_assert(reftable_stack_compact_all(st, NULL) == 0);\n ++\tcl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct reftable_ref_record dest = { 0 };\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add(void)\n -\t\tcheck(!err);\n -\t\tcheck(reftable_ref_record_equal(&dest, refs + i,\n -\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n -+\t\tcl_assert(reftable_stack_read_ref(st, refs[i].refname, &dest) == 0);\n ++\t\tcl_assert_equal_i(reftable_stack_read_ref(st,\n ++\t\t\t\t\t\t\t refs[i].refname, &dest), 0);\n +\t\tcl_assert(reftable_ref_record_equal(&dest, refs + i,\n -+\t\t\t\t\t\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n ++\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_ref_record_release(&dest);\n \t}\n \n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add(void)\n -\t\tcheck(!err);\n -\t\tcheck(reftable_log_record_equal(&dest, logs + i,\n -\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n -+\t\tcl_assert(reftable_stack_read_log(st, refs[i].refname, &dest) == 0);\n ++\t\tcl_assert_equal_i(reftable_stack_read_log(st,\n ++\t\t\t\t\t\t\t refs[i].refname, &dest), 0);\n +\t\tcl_assert(reftable_log_record_equal(&dest, logs + i,\n -+\t\t\t\t\t\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n ++\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_log_record_release(&dest);\n \t}\n \n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add(void)\n -\terr = stat(path.buf, &stat_result);\n -\tcheck(!err);\n -\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n -+\tcl_assert(reftable_buf_addstr(&path, dir) == 0);\n -+\tcl_assert(reftable_buf_addstr(&path, \"/tables.list\") == 0);\n -+\tcl_assert(stat(path.buf, &stat_result) == 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&path, dir), 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&path, \"/tables.list\"), 0);\n ++\tcl_assert_equal_i(stat(path.buf, &stat_result), 0);\n +\tcl_assert_equal_i((stat_result.st_mode & 0777), opts.default_permissions);\n \n \treftable_buf_reset(&path);\n -\tcheck(!reftable_buf_addstr(&path, dir));\n -\tcheck(!reftable_buf_addstr(&path, \"/\"));\n -+\tcl_assert(reftable_buf_addstr(&path, dir) == 0);\n -+\tcl_assert(reftable_buf_addstr(&path, \"/\") == 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&path, dir), 0);\n ++\tcl_assert_equal_i(reftable_buf_addstr(&path, \"/\"), 0);\n \t/* do not try at home; not an external API for reftable. */\n -\tcheck(!reftable_buf_addstr(&path, st->tables[0]->name));\n +\tcl_assert(!reftable_buf_addstr(&path, st->tables[0]->name));\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add(void)\n -\tcheck(!err);\n -\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n +\tcl_assert(!err);\n -+\tcl_assert_equal_i((stat_result.st_mode & 0777), opts.default_permissions);\n ++\tcl_assert_equal_i((stat_result.st_mode & 0777),\n ++\t\t\t opts.default_permissions);\n #else\n \t(void) stat_result;\n #endif\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_iterator(void)\n \n -\terr = reftable_new_stack(&st, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\trefs[i].refname = xstrfmt(\"branch%02\"PRIuMAX, (uintmax_t)i);\n \t\trefs[i].update_index = i + 1;\n \t\trefs[i].value_type = REFTABLE_REF_VAL1;\n -\t\tt_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n -+\t\tcl_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n ++\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n ++\t\t\t\t REFTABLE_HASH_SHA1);\n \n \t\tlogs[i].refname = xstrfmt(\"branch%02\"PRIuMAX, (uintmax_t)i);\n \t\tlogs[i].update_index = i + 1;\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_iterator(void)\n \t\tlogs[i].value.update.email = xstrdup(\"johndoe@invalid\");\n \t\tlogs[i].value.update.message = xstrdup(\"commit\\n\");\n -\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);\n -+\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);\n ++\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n ++\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n -\tfor (i = 0; i < N; i++) {\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_iterator(void)\n -\t\tcheck(!err);\n -\t}\n +\tfor (i = 0; i < N; i++)\n -+\t\tcl_assert(reftable_stack_add(st, write_test_ref, &refs[i]) == 0);\n ++\t\tcl_assert_equal_i(reftable_stack_add(st,\n ++\t\t\t\t\t\t write_test_ref, &refs[i]), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct write_log_arg arg = {\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_iterator(void)\n \n -\t\terr = reftable_stack_add(st, write_test_log, &arg);\n -\t\tcheck(!err);\n -+\t\tcl_assert(reftable_stack_add(st, write_test_log, &arg) == 0);\n ++\t\tcl_assert_equal_i(reftable_stack_add(st,\n ++\t\t\t\t\t\t write_test_log, &arg), 0);\n \t}\n \n \treftable_stack_init_ref_iterator(st, &it);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_iterator(void)\n \t\t\tbreak;\n -\t\tcheck(!err);\n -\t\tcheck(reftable_ref_record_equal(&ref, &refs[i], REFTABLE_HASH_SIZE_SHA1));\n -+\t\tcl_assert(err == 0);\n ++\t\tcl_assert(!err);\n +\t\tcl_assert(reftable_ref_record_equal(&ref, &refs[i],\n -+\t\t\t\t\t\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n ++\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_ref_record_release(&ref);\n \t}\n -\tcheck_int(i, ==, N);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_iterator(void)\n \n -\terr = reftable_stack_init_log_iterator(st, &it);\n -\tcheck(!err);\n -+\tcl_assert(reftable_stack_init_log_iterator(st, &it) == 0);\n ++\tcl_assert_equal_i(reftable_stack_init_log_iterator(st, &it), 0);\n \n \treftable_iterator_seek_log(&it, logs[0].refname);\n \tfor (i = 0; ; i++) {\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_iterator(void)\n \t\t\tbreak;\n -\t\tcheck(!err);\n -\t\tcheck(reftable_log_record_equal(&log, &logs[i], REFTABLE_HASH_SIZE_SHA1));\n -+\t\tcl_assert(err == 0);\n ++\t\tcl_assert(!err);\n +\t\tcl_assert(reftable_log_record_equal(&log, &logs[i],\n -+\t\t\t\t\t\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n ++\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_log_record_release(&log);\n \t}\n -\tcheck_int(i, ==, N);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_log_normalize(void\n \n -\terr = reftable_new_stack(&st, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tinput.value.update.message = (char *) \"one\\ntwo\";\n -\terr = reftable_stack_add(st, write_test_log, &arg);\n -\tcheck_int(err, ==, REFTABLE_API_ERROR);\n +\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n -+\t\t\t\t\t\t\t\t\t\t &arg), REFTABLE_API_ERROR);\n ++\t\t\t\t\t &arg), REFTABLE_API_ERROR);\n \n \tinput.value.update.message = (char *) \"one\";\n -\terr = reftable_stack_add(st, write_test_log, &arg);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_log_normalize(void\n -\terr = reftable_stack_read_log(st, input.refname, &dest);\n -\tcheck(!err);\n -\tcheck_str(dest.value.update.message, \"one\\n\");\n -+\tcl_assert(reftable_stack_add(st, write_test_log, &arg) == 0);\n -+\tcl_assert(reftable_stack_read_log(st, input.refname, &dest) == 0);\n ++\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n ++\t\t\t\t\t &arg), 0);\n ++\tcl_assert_equal_i(reftable_stack_read_log(st, input.refname,\n ++\t\t\t\t\t\t &dest), 0);\n +\tcl_assert_equal_s(dest.value.update.message, \"one\\n\");\n \n \tinput.value.update.message = (char *) \"two\\n\";\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_log_normalize(void\n -\terr = reftable_stack_read_log(st, input.refname, &dest);\n -\tcheck(!err);\n -\tcheck_str(dest.value.update.message, \"two\\n\");\n -+\tcl_assert(reftable_stack_add(st, write_test_log, &arg) == 0);\n -+\tcl_assert(reftable_stack_read_log(st, input.refname, &dest) == 0);\n ++\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n ++\t\t\t\t\t &arg), 0);\n ++\tcl_assert_equal_i(reftable_stack_read_log(st, input.refname,\n ++\t\t\t\t\t\t &dest), 0);\n +\tcl_assert_equal_s(dest.value.update.message, \"two\\n\");\n \n \t/* cleanup */\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_log_normalize(void\n \n -\terr = reftable_new_stack(&st, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \t/* even entries add the refs, odd entries delete them. */\n \tfor (i = 0; i < N; i++) {\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_tombstone(void)\n \t\tif (i % 2 == 0) {\n \t\t\trefs[i].value_type = REFTABLE_REF_VAL1;\n -\t\t\tt_reftable_set_hash(refs[i].value.val1, i,\n +-\t\t\t\t\t REFTABLE_HASH_SHA1);\n +\t\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n - \t\t\t\t\t REFTABLE_HASH_SHA1);\n ++\t\t\t\t\t REFTABLE_HASH_SHA1);\n \t\t}\n \n + \t\tlogs[i].refname = xstrdup(buf);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_tombstone(void)\n \t\tlogs[i].update_index = 1;\n \t\tif (i % 2 == 0) {\n \t\t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n -\t\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i,\n -+\t\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n - \t\t\t\t\t REFTABLE_HASH_SHA1);\n +-\t\t\t\t\t REFTABLE_HASH_SHA1);\n ++\t\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);\n \t\t\tlogs[i].value.update.email =\n \t\t\t\txstrdup(\"identity@invalid\");\n \t\t}\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_tombstone(void)\n -\t\tcheck(!err);\n -\t}\n +\tfor (i = 0; i < N; i++)\n -+\t\tcl_assert(reftable_stack_add(st, write_test_ref, &refs[i]) == 0);\n ++\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref, &refs[i]), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct write_log_arg arg = {\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_tombstone(void)\n \t\t};\n -\t\tint err = reftable_stack_add(st, write_test_log, &arg);\n -\t\tcheck(!err);\n -+\t\tcl_assert(reftable_stack_add(st, write_test_log, &arg) == 0);\n ++\t\tcl_assert_equal_i(reftable_stack_add(st,\n ++\t\t\t\t\t\t write_test_log, &arg), 0);\n \t}\n \n -\terr = reftable_stack_read_ref(st, \"branch\", &dest);\n -\tcheck_int(err, ==, 1);\n -+\tcl_assert_equal_i(reftable_stack_read_ref(st, \"branch\", &dest), 1);\n ++\tcl_assert_equal_i(reftable_stack_read_ref(st, \"branch\",\n ++\t\t\t\t\t\t &dest), 1);\n \treftable_ref_record_release(&dest);\n \n -\terr = reftable_stack_read_log(st, \"branch\", &log_dest);\n -\tcheck_int(err, ==, 1);\n -+\tcl_assert_equal_i(reftable_stack_read_log(st, \"branch\", &log_dest), 1);\n ++\tcl_assert_equal_i(reftable_stack_read_log(st, \"branch\",\n ++\t\t\t\t\t\t &log_dest), 1);\n \treftable_log_record_release(&log_dest);\n \n -\terr = reftable_stack_compact_all(st, NULL);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_tombstone(void)\n -\n -\terr = reftable_stack_read_log(st, \"branch\", &log_dest);\n -\tcheck_int(err, ==, 1);\n -+\tcl_assert(reftable_stack_compact_all(st, NULL) == 0);\n -+\tcl_assert_equal_i(reftable_stack_read_ref(st, \"branch\", &dest), 1);\n -+\tcl_assert_equal_i(reftable_stack_read_log(st, \"branch\", &log_dest), 1);\n ++\tcl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);\n ++\tcl_assert_equal_i(reftable_stack_read_ref(st, \"branch\",\n ++\t\t\t\t\t\t &dest), 1);\n ++\tcl_assert_equal_i(reftable_stack_read_log(st, \"branch\",\n ++\t\t\t\t\t\t &log_dest), 1);\n \treftable_ref_record_release(&dest);\n \treftable_log_record_release(&log_dest);\n \n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_hash_id(void)\n -\n -\terr = reftable_stack_add(st, write_test_ref, &ref);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n -+\tcl_assert(reftable_stack_add(st, write_test_ref, &ref) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n ++\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n ++\t\t\t\t\t &ref), 0);\n \n \t/* can't read it with the wrong hash ID. */\n -\terr = reftable_new_stack(&st32, dir, &opts32);\n -\tcheck_int(err, ==, REFTABLE_FORMAT_ERROR);\n -+\tcl_assert_equal_i(reftable_new_stack(&st32, dir, &opts32), REFTABLE_FORMAT_ERROR);\n ++\tcl_assert_equal_i(reftable_new_stack(&st32, dir,\n ++\t\t\t\t\t &opts32), REFTABLE_FORMAT_ERROR);\n \n \t/* check that we can read it back with default opts too. */\n -\terr = reftable_new_stack(&st_default, dir, &opts_default);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_hash_id(void)\n -\tcheck(!err);\n -\n -\tcheck(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));\n -+\tcl_assert(reftable_new_stack(&st_default, dir, &opts_default) == 0);\n -+\tcl_assert(reftable_stack_read_ref(st_default, \"master\", &dest) == 0);\n -+\tcl_assert(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1) != 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st_default, dir,\n ++\t\t\t\t\t &opts_default), 0);\n ++\tcl_assert_equal_i(reftable_stack_read_ref(st_default, \"master\",\n ++\t\t\t\t\t\t &dest), 0);\n ++\tcl_assert(reftable_ref_record_equal(&ref, &dest,\n ++\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \treftable_ref_record_release(&dest);\n \treftable_stack_destroy(st);\n \treftable_stack_destroy(st_default);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_hash_id(void)\n \n -\terr = reftable_new_stack(&st, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 1; i <= N; i++) {\n \t\tchar buf[256];\n @@ t/unit-tests/u-reftable-stack.c: static void t_reflog_expire(void)\n \t\tlogs[i].value.update.time = i;\n \t\tlogs[i].value.update.email = xstrdup(\"identity@invalid\");\n -\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i,\n +-\t\t\t\t REFTABLE_HASH_SHA1);\n +\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n - \t\t\t\t REFTABLE_HASH_SHA1);\n ++\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n + \tfor (i = 1; i <= N; i++) {\n @@ t/unit-tests/u-reftable-stack.c: static void t_reflog_expire(void)\n \t\t\t.log = &logs[i],\n \t\t\t.update_index = reftable_stack_next_update_index(st),\n \t\t};\n -\t\tint err = reftable_stack_add(st, write_test_log, &arg);\n -\t\tcheck(!err);\n -+\t\tcl_assert(reftable_stack_add(st, write_test_log, &arg) == 0);\n ++\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n ++\t\t\t\t\t\t &arg), 0);\n \t}\n \n -\terr = reftable_stack_compact_all(st, NULL);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reflog_expire(void)\n -\n -\terr = reftable_stack_read_log(st, logs[11].refname, &log);\n -\tcheck(!err);\n -+\tcl_assert(reftable_stack_compact_all(st, NULL) == 0);\n -+\tcl_assert(reftable_stack_compact_all(st, &expiry) == 0);\n -+\tcl_assert_equal_i(reftable_stack_read_log(st, logs[9].refname, &log), 1);\n -+\tcl_assert(reftable_stack_read_log(st, logs[11].refname, &log) == 0);\n ++\tcl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);\n ++\tcl_assert_equal_i(reftable_stack_compact_all(st, &expiry), 0);\n ++\tcl_assert_equal_i(reftable_stack_read_log(st, logs[9].refname,\n ++\t\t\t\t\t\t &log), 1);\n ++\tcl_assert_equal_i(reftable_stack_read_log(st, logs[11].refname,\n ++\t\t\t\t\t\t &log), 0);\n \n \texpiry.min_update_index = 15;\n -\terr = reftable_stack_compact_all(st, &expiry);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reflog_expire(void)\n -\n -\terr = reftable_stack_read_log(st, logs[16].refname, &log);\n -\tcheck(!err);\n -+\tcl_assert(reftable_stack_compact_all(st, &expiry) == 0);\n -+\tcl_assert_equal_i(reftable_stack_read_log(st, logs[14].refname, &log), 1);\n -+\tcl_assert(reftable_stack_read_log(st, logs[16].refname, &log) == 0);\n ++\tcl_assert_equal_i(reftable_stack_compact_all(st, &expiry), 0);\n ++\tcl_assert_equal_i(reftable_stack_read_log(st, logs[14].refname,\n ++\t\t\t\t\t\t &log), 1);\n ++\tcl_assert_equal_i(reftable_stack_read_log(st, logs[16].refname,\n ++\t\t\t\t\t\t &log), 0);\n \n \t/* cleanup */\n \treftable_stack_destroy(st);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reflog_expire(void)\n static int write_nothing(struct reftable_writer *wr, void *arg UNUSED)\n {\n -\tcheck(!reftable_writer_set_limits(wr, 1, 1));\n -+\tcl_assert(reftable_writer_set_limits(wr, 1, 1) == 0);\n ++\tcl_assert_equal_i(reftable_writer_set_limits(wr, 1, 1), 0);\n \treturn 0;\n }\n \n @@ t/unit-tests/u-reftable-stack.c: static void t_reflog_expire(void)\n -\n -\terr = reftable_new_stack(&st2, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n -+\tcl_assert(reftable_stack_add(st, write_nothing, NULL) == 0);\n -+\tcl_assert(reftable_new_stack(&st2, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n ++\tcl_assert_equal_i(reftable_stack_add(st, write_nothing,\n ++\t\t\t\t\t NULL), 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n \tclear_dir(dir);\n \treftable_stack_destroy(st);\n \treftable_stack_destroy(st2);\n @@ t/unit-tests/u-reftable-stack.c: static int fastlogN(uint64_t sz, uint64_t N)\n \n -\terr = reftable_new_stack(&st, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tchar name[100];\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_auto_compaction(vo\n \n -\terr = reftable_new_stack(&st, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (size_t i = 0; i < N; i++) {\n \t\tchar name[20];\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_auto_compaction_wi\n \n -\terr = reftable_new_stack(&st, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \twrite_n_ref_tables(st, 5);\n -\tcheck_int(st->merged->tables_len, ==, 5);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_auto_compaction_wi\n \n -\terr = reftable_new_stack(&st, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 0; i <= n; i++) {\n \t\tstruct reftable_ref_record ref = {\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add_performs_auto_\n \n -\t\terr = reftable_stack_add(st, write_test_ref, &ref);\n -\t\tcheck(!err);\n -+\t\tcl_assert(reftable_stack_add(st, write_test_ref, &ref) == 0);\n ++\t\tcl_assert_equal_i(reftable_stack_add(st,\n ++\t\t\t\t\t\t write_test_ref, &ref), 0);\n \n \t\t/*\n \t\t * The stack length should grow continuously for all runs where\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_compaction_with_lo\n \n -\terr = reftable_new_stack(&st, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \twrite_n_ref_tables(st, 3);\n -\tcheck_int(st->merged->tables_len, ==, 3);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_compaction_with_lo\n \n -\terr = reftable_new_stack(&st1, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st1, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n \twrite_n_ref_tables(st1, 3);\n \n -\terr = reftable_new_stack(&st2, dir, &opts);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_compaction_with_lo\n -\n -\terr = reftable_stack_compact_all(st1, NULL);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st2, dir, &opts) == 0);\n -+\tcl_assert(reftable_stack_compact_all(st1, NULL) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n ++\tcl_assert_equal_i(reftable_stack_compact_all(st1, NULL), 0);\n \n \treftable_stack_destroy(st1);\n \treftable_stack_destroy(st2);\n @@ t/unit-tests/u-reftable-stack.c: static void unclean_stack_close(struct reftable\n \n -\terr = reftable_new_stack(&st1, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st1, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n \twrite_n_ref_tables(st1, 3);\n \n -\terr = reftable_new_stack(&st2, dir, &opts);\n @@ t/unit-tests/u-reftable-stack.c: static void unclean_stack_close(struct reftable\n -\n -\terr = reftable_stack_compact_all(st1, NULL);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st2, dir, &opts) == 0);\n -+\tcl_assert(reftable_stack_compact_all(st1, NULL) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n ++\tcl_assert_equal_i(reftable_stack_compact_all(st1, NULL), 0);\n \n \tunclean_stack_close(st1);\n \tunclean_stack_close(st2);\n @@ t/unit-tests/u-reftable-stack.c: static void unclean_stack_close(struct reftable\n -\terr = reftable_stack_clean(st3);\n -\tcheck(!err);\n -\tcheck_int(count_dir_entries(dir), ==, 2);\n -+\tcl_assert(reftable_new_stack(&st3, dir, &opts) == 0);\n -+\tcl_assert(reftable_stack_clean(st3) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st3, dir, &opts), 0);\n ++\tcl_assert_equal_i(reftable_stack_clean(st3), 0);\n +\tcl_assert_equal_i(count_dir_entries(dir), 2);\n \n \treftable_stack_destroy(st1);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_read_across_reload\n \t/* Create a first stack and set up an iterator for it. */\n -\terr = reftable_new_stack(&st1, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st1, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n \twrite_n_ref_tables(st1, 2);\n -\tcheck_int(st1->merged->tables_len, ==, 2);\n +\tcl_assert_equal_i(st1->merged->tables_len, 2);\n \treftable_stack_init_ref_iterator(st1, &it);\n -\terr = reftable_iterator_seek_ref(&it, \"\");\n -\tcheck(!err);\n -+\tcl_assert(reftable_iterator_seek_ref(&it, \"\") == 0);\n ++\tcl_assert_equal_i(reftable_iterator_seek_ref(&it, \"\"), 0);\n \n \t/* Set up a second stack for the same directory and compact it. */\n \terr = reftable_new_stack(&st2, dir, &opts);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_reload_with_missin\n \t/* Create a first stack and set up an iterator for it. */\n -\terr = reftable_new_stack(&st, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \twrite_n_ref_tables(st, 2);\n -\tcheck_int(st->merged->tables_len, ==, 2);\n +\tcl_assert_equal_i(st->merged->tables_len, 2);\n \treftable_stack_init_ref_iterator(st, &it);\n -\terr = reftable_iterator_seek_ref(&it, \"\");\n -\tcheck(!err);\n -+\tcl_assert(reftable_iterator_seek_ref(&it, \"\") == 0);\n ++\tcl_assert_equal_i(reftable_iterator_seek_ref(&it, \"\"), 0);\n \n \t/*\n \t * Update the tables.list file with some garbage data, while reusing\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_reload_with_missin\n \twrite_file_buf(table_path.buf, content.buf, content.len);\n -\terr = rename(table_path.buf, st->list_file);\n -\tcheck(!err);\n -+\tcl_assert(rename(table_path.buf, st->list_file) == 0);\n ++\tcl_assert_equal_i(rename(table_path.buf, st->list_file), 0);\n \n \terr = reftable_stack_reload(st);\n -\tcheck_int(err, ==, -4);\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_reload_with_missin\n -\tcheck_str(rec.refname, \"refs/heads/branch-0001\");\n -\terr = reftable_iterator_next_ref(&it, &rec);\n -\tcheck_int(err, >, 0);\n -+\tcl_assert(reftable_iterator_next_ref(&it, &rec) == 0);\n ++\tcl_assert_equal_i(reftable_iterator_next_ref(&it, &rec), 0);\n +\tcl_assert_equal_s(rec.refname, \"refs/heads/branch-0000\");\n -+\tcl_assert(reftable_iterator_next_ref(&it, &rec) == 0);\n ++\tcl_assert_equal_i(reftable_iterator_next_ref(&it, &rec), 0);\n +\tcl_assert_equal_s(rec.refname, \"refs/heads/branch-0001\");\n +\tcl_assert(reftable_iterator_next_ref(&it, &rec) > 0);\n \n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_reload_with_missin\n \tstruct reftable_ref_record *ref = arg;\n -\tcheck(!reftable_writer_set_limits(wr, ref->update_index, ref->update_index));\n -\tcheck(!reftable_writer_add_ref(wr, ref));\n -+\tcl_assert(reftable_writer_set_limits(wr, ref->update_index,\n -+\t\t\t\t\t\t\t\t\t\t ref->update_index) == 0);\n -+\tcl_assert(reftable_writer_add_ref(wr, ref) == 0);\n ++\tcl_assert_equal_i(reftable_writer_set_limits(wr,\n ++\t\t\t\t\t\t ref->update_index, ref->update_index), 0);\n ++\tcl_assert_equal_i(reftable_writer_add_ref(wr, ref), 0);\n \treturn reftable_writer_set_limits(wr, ref->update_index, ref->update_index);\n }\n \n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_invalid_limit_updates(vo\n \n -\terr = reftable_new_stack(&st, dir, &opts);\n -\tcheck(!err);\n -+\tcl_assert(reftable_new_stack(&st, dir, &opts) == 0);\n ++\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \treftable_addition_destroy(add);\n \n -\terr = reftable_stack_new_addition(&add, st, 0);\n -\tcheck(!err);\n -+\tcl_assert(reftable_stack_new_addition(&add, st, 0) == 0);\n ++\tcl_assert_equal_i(reftable_stack_new_addition(&add, st, 0), 0);\n \n \t/*\n \t * write_limits_after_ref also updates the update indexes after adding\n @@ t/unit-tests/u-reftable-stack.c: static void t_reftable_invalid_limit_updates(vo\n \t */\n -\terr = reftable_addition_add(add, write_limits_after_ref, &ref);\n -\tcheck_int(err, ==, REFTABLE_API_ERROR);\n -+\tcl_assert_equal_i(reftable_addition_add(add, write_limits_after_ref, &ref),\n -+\t\t\t\t\t REFTABLE_API_ERROR);\n ++\tcl_assert_equal_i(reftable_addition_add(add,\n ++\t\t\t\t\t\twrite_limits_after_ref, &ref), REFTABLE_API_ERROR);\n \n \treftable_addition_destroy(add);\n \treftable_stack_destroy(st);\n10: bf271f4ddf ! 10: 8469fe3c0f t/unit-tests: finalize migration of reftable-related tests\n @@ Commit message\n tests to the Clar framework, Clar-specific versions of these functions\n in `lib-reftable-clar.{c,h}` were introduced.\n \n - Now that all test files using these helpers have been converted to Clar, we\n - can safely remove the original `lib-reftable.{c,h}` and rename the Clar-\n - specific versions back to `lib-reftable.{c,h}`. This restores a clean and\n - consistent naming scheme for shared test utilities.\n + Now that all test files using these helpers have been converted to Clar,\n + we can safely remove the original `lib-reftable.{c,h}` and rename the\n + Clar- specific versions back to `lib-reftable.{c,h}`. This restores a\n + clean and consistent naming scheme for shared test utilities.\n \n Finally, update our build system to reflect the changes made and remove\n redundant code related to the reftable tests and our old homegrown\n - unit-testing setup.\n + unit-testing setup. `test-lib.{c,h}` remains unchanged in our build\n + system as some files particularly `t/helper/test-example-tap.c` depends\n + on it in order to run, and removing that would be beyond the scope of\n + this patch.\n \n Signed-off-by: Seyi Kuforiji \n \n @@ t/unit-tests/u-reftable-stack.c: void test_reftable_stack__add(void)\n \n ## t/unit-tests/u-reftable-table.c ##\n @@\n - #include \"test-lib.h\"\n + #include \"unit-test.h\"\n -#include \"lib-reftable-clar.h\"\n +#include \"lib-reftable.h\"\n #include \"reftable/blocksource.h\"\n-- \n2.43.0\n\n"},{"id":"519773","messageId":"20250605140644.239199-2-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250605140644.239199-1-kuforiji98@gmail.com","subject":"[PATCH v4 01/10] t/unit-tests: implement clar specific reftable test helper functions","fromName":"Seyi Kuforiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-06-05T14:06:35Z","receivedAt":"2025-06-05T14:07:18Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"Helper functions defined in `t/unit-tests/lib-reftable.{c,h}` are\nrequired for the reftable-related test files to run. In the current\nimplementation these functions are designed to conform with our\nhomegrown unit-testing structure. So in other to convert the reftable\ntest files, there is need for a clar specific implementation of these\nhelper functions.\n\nImplement equivalent helper functions in `lib-reftable-clar.{c,h}` to\nuse clar. These functions conform with the clar testing framework and\nbecome available for all reftable-related test files implemented using\nthe clar testing framework, which requires them. This will be used by\nsubsequent commits.\n\nSigned-off-by: Seyi Kuforiji \n---\n Makefile | 1 +\n t/meson.build | 3 +-\n t/unit-tests/lib-reftable-clar.c | 101 +++++++++++++++++++++++++++++++\n t/unit-tests/lib-reftable-clar.h | 20 ++++++\n 4 files changed, 124 insertions(+), 1 deletion(-)\n create mode 100644 t/unit-tests/lib-reftable-clar.c\n create mode 100644 t/unit-tests/lib-reftable-clar.h\n\ndiff --git a/Makefile b/Makefile\nindex 70d1543b6b..e4fa038508 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1375,6 +1375,7 @@ CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n+CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n UNIT_TEST_PROGRAMS += t-reftable-basics\n UNIT_TEST_PROGRAMS += t-reftable-block\ndiff --git a/t/meson.build b/t/meson.build\nindex d052fc3e23..f77f21536e 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -19,7 +19,8 @@ clar_test_suites = [\n clar_sources = [\n 'unit-tests/clar/clar.c',\n 'unit-tests/unit-test.c',\n- 'unit-tests/lib-oid.c'\n+ 'unit-tests/lib-oid.c',\n+ 'unit-tests/lib-reftable-clar.c'\n ]\n \n clar_decls_h = custom_target(\ndiff --git a/t/unit-tests/lib-reftable-clar.c b/t/unit-tests/lib-reftable-clar.c\nnew file mode 100644\nindex 0000000000..64e40a106e\n--- /dev/null\n+++ b/t/unit-tests/lib-reftable-clar.c\n@@ -0,0 +1,101 @@\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n+#include \"hex.h\"\n+#include \"parse-options.h\"\n+#include \"reftable/constants.h\"\n+#include \"reftable/writer.h\"\n+#include \"strbuf.h\"\n+#include \"string-list.h\"\n+#include \"strvec.h\"\n+\n+void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id)\n+{\n+\tmemset(p, (uint8_t)i, hash_size(id));\n+}\n+\n+static ssize_t strbuf_writer_write(void *b, const void *data, size_t sz)\n+{\n+\tstrbuf_add(b, data, sz);\n+\treturn sz;\n+}\n+\n+static int strbuf_writer_flush(void *arg UNUSED)\n+{\n+\treturn 0;\n+}\n+\n+struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,\n+\t\t\t\t\t\t struct reftable_write_options *opts)\n+{\n+\tstruct reftable_writer *writer;\n+\tint ret = reftable_writer_new(&writer, &strbuf_writer_write, &strbuf_writer_flush,\n+\t\t\t\t buf, opts);\n+\tcl_assert(!ret);\n+\treturn writer;\n+}\n+\n+void cl_reftable_write_to_buf(struct reftable_buf *buf,\n+\t\t\t struct reftable_ref_record *refs,\n+\t\t\t size_t nrefs,\n+\t\t\t struct reftable_log_record *logs,\n+\t\t\t size_t nlogs,\n+\t\t\t struct reftable_write_options *_opts)\n+{\n+\tstruct reftable_write_options opts = { 0 };\n+\tconst struct reftable_stats *stats;\n+\tstruct reftable_writer *writer;\n+\tuint64_t min = 0xffffffff;\n+\tuint64_t max = 0;\n+\tint ret;\n+\n+\tif (_opts)\n+\t\topts = *_opts;\n+\n+\tfor (size_t i = 0; i < nrefs; i++) {\n+\t\tuint64_t ui = refs[i].update_index;\n+\t\tif (ui > max)\n+\t\t\tmax = ui;\n+\t\tif (ui < min)\n+\t\t\tmin = ui;\n+\t}\n+\tfor (size_t i = 0; i < nlogs; i++) {\n+\t\tuint64_t ui = logs[i].update_index;\n+\t\tif (ui > max)\n+\t\t\tmax = ui;\n+\t\tif (ui < min)\n+\t\t\tmin = ui;\n+\t}\n+\n+\twriter = cl_reftable_strbuf_writer(buf, &opts);\n+\tret = reftable_writer_set_limits(writer, min, max);\n+\tcl_assert_equal_i(ret, 0);\n+\n+\tif (nrefs) {\n+\t\tret = reftable_writer_add_refs(writer, refs, nrefs);\n+\t\tcl_assert_equal_i(ret, 0);\n+\t}\n+\n+\tif (nlogs) {\n+\t\tret = reftable_writer_add_logs(writer, logs, nlogs);\n+\t\tcl_assert_equal_i(ret, 0);\n+\t}\n+\n+\tret = reftable_writer_close(writer);\n+\tcl_assert_equal_i(ret, 0);\n+\n+\tstats = reftable_writer_stats(writer);\n+\tfor (size_t i = 0; i < (size_t)stats->ref_stats.blocks; i++) {\n+\t\tsize_t off = i * (opts.block_size ? opts.block_size\n+\t\t\t\t\t\t : DEFAULT_BLOCK_SIZE);\n+\t\tif (!off)\n+\t\t\toff = header_size(opts.hash_id == REFTABLE_HASH_SHA256 ? 2 : 1);\n+\t\tcl_assert(buf->buf[off] == 'r');\n+\t}\n+\n+\tif (nrefs)\n+\t\tcl_assert(stats->ref_stats.blocks > 0);\n+\tif (nlogs)\n+\t\tcl_assert(stats->log_stats.blocks > 0);\n+\n+\treftable_writer_free(writer);\n+}\ndiff --git a/t/unit-tests/lib-reftable-clar.h b/t/unit-tests/lib-reftable-clar.h\nnew file mode 100644\nindex 0000000000..b562648973\n--- /dev/null\n+++ b/t/unit-tests/lib-reftable-clar.h\n@@ -0,0 +1,20 @@\n+#include \"git-compat-util.h\"\n+#include \"clar/clar.h\"\n+#include \"clar-decls.h\"\n+#include \"git-compat-util.h\"\n+#include \"reftable/reftable-writer.h\"\n+#include \"strbuf.h\"\n+\n+struct reftable_buf;\n+\n+void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id);\n+\n+struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,\n+\t\t\t\t\t\t struct reftable_write_options *opts);\n+\n+void cl_reftable_write_to_buf(struct reftable_buf *buf,\n+\t\t\t struct reftable_ref_record *refs,\n+\t\t\t size_t nrecords,\n+\t\t\t struct reftable_log_record *logs,\n+\t\t\t size_t nlogs,\n+\t\t\t struct reftable_write_options *opts);\n-- \n2.43.0\n\n"},{"id":"519774","messageId":"20250605140644.239199-3-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250605140644.239199-1-kuforiji98@gmail.com","subject":"[PATCH v4 02/10] t/unit-tests: convert reftable basics test to use clar test framework","fromName":"Seyi Kuforiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-06-05T14:06:36Z","receivedAt":"2025-06-05T14:07:23Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"Adapt reftable basics test file to clar by using clar assertions\nwhere necessary.Break up test edge case to improve modularity and\nclarity.\n\nSigned-off-by: Seyi Kuforiji \n---\n Makefile | 2 +-\n t/meson.build | 2 +-\n t/unit-tests/t-reftable-basics.c | 219 -----------------------------\n t/unit-tests/u-reftable-basics.c | 227 +++++++++++++++++++++++++++++++\n 4 files changed, 229 insertions(+), 221 deletions(-)\n delete mode 100644 t/unit-tests/t-reftable-basics.c\n create mode 100644 t/unit-tests/u-reftable-basics.c\n\ndiff --git a/Makefile b/Makefile\nindex e4fa038508..a01103e3a6 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1364,6 +1364,7 @@ CLAR_TEST_SUITES += u-oid-array\n CLAR_TEST_SUITES += u-oidmap\n CLAR_TEST_SUITES += u-oidtree\n CLAR_TEST_SUITES += u-prio-queue\n+CLAR_TEST_SUITES += u-reftable-basics\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n CLAR_TEST_SUITES += u-strcmp-offset\n@@ -1377,7 +1378,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-basics\n UNIT_TEST_PROGRAMS += t-reftable-block\n UNIT_TEST_PROGRAMS += t-reftable-merged\n UNIT_TEST_PROGRAMS += t-reftable-pq\ndiff --git a/t/meson.build b/t/meson.build\nindex f77f21536e..e00e8d41d6 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -8,6 +8,7 @@ clar_test_suites = [\n 'unit-tests/u-oidmap.c',\n 'unit-tests/u-oidtree.c',\n 'unit-tests/u-prio-queue.c',\n+ 'unit-tests/u-reftable-basics.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n 'unit-tests/u-strcmp-offset.c',\n@@ -55,7 +56,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-basics.c',\n 'unit-tests/t-reftable-block.c',\n 'unit-tests/t-reftable-merged.c',\n 'unit-tests/t-reftable-pq.c',\ndiff --git a/t/unit-tests/t-reftable-basics.c b/t/unit-tests/t-reftable-basics.c\ndeleted file mode 100644\nindex c9e751e49e..0000000000\n--- a/t/unit-tests/t-reftable-basics.c\n+++ /dev/null\n@@ -1,219 +0,0 @@\n-/*\n-Copyright 2020 Google LLC\n-\n-Use of this source code is governed by a BSD-style\n-license that can be found in the LICENSE file or at\n-https://developers.google.com/open-source/licenses/bsd\n-*/\n-\n-#include \"test-lib.h\"\n-#include \"reftable/basics.h\"\n-\n-struct integer_needle_lesseq_args {\n-\tint needle;\n-\tint *haystack;\n-};\n-\n-static int integer_needle_lesseq(size_t i, void *_args)\n-{\n-\tstruct integer_needle_lesseq_args *args = _args;\n-\treturn args->needle <= args->haystack[i];\n-}\n-\n-static void *realloc_stub(void *p UNUSED, size_t size UNUSED)\n-{\n-\treturn NULL;\n-}\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tif_test (\"binary search with binsearch works\") {\n-\t\tint haystack[] = { 2, 4, 6, 8, 10 };\n-\t\tstruct {\n-\t\t\tint needle;\n-\t\t\tsize_t expected_idx;\n-\t\t} testcases[] = {\n-\t\t\t{-9000, 0},\n-\t\t\t{-1, 0},\n-\t\t\t{0, 0},\n-\t\t\t{2, 0},\n-\t\t\t{3, 1},\n-\t\t\t{4, 1},\n-\t\t\t{7, 3},\n-\t\t\t{9, 4},\n-\t\t\t{10, 4},\n-\t\t\t{11, 5},\n-\t\t\t{9000, 5},\n-\t\t};\n-\n-\t\tfor (size_t i = 0; i < ARRAY_SIZE(testcases); i++) {\n-\t\t\tstruct integer_needle_lesseq_args args = {\n-\t\t\t\t.haystack = haystack,\n-\t\t\t\t.needle = testcases[i].needle,\n-\t\t\t};\n-\t\t\tsize_t idx;\n-\n-\t\t\tidx = binsearch(ARRAY_SIZE(haystack),\n-\t\t\t\t\t&integer_needle_lesseq, &args);\n-\t\t\tcheck_int(idx, ==, testcases[i].expected_idx);\n-\t\t}\n-\t}\n-\n-\tif_test (\"names_length returns size of a NULL-terminated string array\") {\n-\t\tconst char *a[] = { \"a\", \"b\", NULL };\n-\t\tcheck_int(names_length(a), ==, 2);\n-\t}\n-\n-\tif_test (\"names_equal compares NULL-terminated string arrays\") {\n-\t\tconst char *a[] = { \"a\", \"b\", \"c\", NULL };\n-\t\tconst char *b[] = { \"a\", \"b\", \"d\", NULL };\n-\t\tconst char *c[] = { \"a\", \"b\", NULL };\n-\n-\t\tcheck(names_equal(a, a));\n-\t\tcheck(!names_equal(a, b));\n-\t\tcheck(!names_equal(a, c));\n-\t}\n-\n-\tif_test (\"parse_names works for basic input\") {\n-\t\tchar in1[] = \"line\\n\";\n-\t\tchar in2[] = \"a\\nb\\nc\";\n-\t\tchar **out = parse_names(in1, strlen(in1));\n-\t\tcheck(out != NULL);\n-\t\tcheck_str(out[0], \"line\");\n-\t\tcheck(!out[1]);\n-\t\tfree_names(out);\n-\n-\t\tout = parse_names(in2, strlen(in2));\n-\t\tcheck(out != NULL);\n-\t\tcheck_str(out[0], \"a\");\n-\t\tcheck_str(out[1], \"b\");\n-\t\tcheck_str(out[2], \"c\");\n-\t\tcheck(!out[3]);\n-\t\tfree_names(out);\n-\t}\n-\n-\tif_test (\"parse_names drops empty string\") {\n-\t\tchar in[] = \"a\\n\\nb\\n\";\n-\t\tchar **out = parse_names(in, strlen(in));\n-\t\tcheck(out != NULL);\n-\t\tcheck_str(out[0], \"a\");\n-\t\t/* simply '\\n' should be dropped as empty string */\n-\t\tcheck_str(out[1], \"b\");\n-\t\tcheck(!out[2]);\n-\t\tfree_names(out);\n-\t}\n-\n-\tif_test (\"common_prefix_size works\") {\n-\t\tstruct reftable_buf a = REFTABLE_BUF_INIT;\n-\t\tstruct reftable_buf b = REFTABLE_BUF_INIT;\n-\t\tstruct {\n-\t\t\tconst char *a, *b;\n-\t\t\tint want;\n-\t\t} cases[] = {\n-\t\t\t{\"abcdef\", \"abc\", 3},\n-\t\t\t{ \"abc\", \"ab\", 2 },\n-\t\t\t{ \"\", \"abc\", 0 },\n-\t\t\t{ \"abc\", \"abd\", 2 },\n-\t\t\t{ \"abc\", \"pqr\", 0 },\n-\t\t};\n-\n-\t\tfor (size_t i = 0; i < ARRAY_SIZE(cases); i++) {\n-\t\t\tcheck(!reftable_buf_addstr(&a, cases[i].a));\n-\t\t\tcheck(!reftable_buf_addstr(&b, cases[i].b));\n-\t\t\tcheck_uint(common_prefix_size(&a, &b), ==, cases[i].want);\n-\t\t\treftable_buf_reset(&a);\n-\t\t\treftable_buf_reset(&b);\n-\t\t}\n-\t\treftable_buf_release(&a);\n-\t\treftable_buf_release(&b);\n-\t}\n-\n-\tif_test (\"reftable_put_be64 and reftable_get_be64 work\") {\n-\t\tuint64_t in = 0x1122334455667788;\n-\t\tuint8_t dest[8];\n-\t\tuint64_t out;\n-\t\treftable_put_be64(dest, in);\n-\t\tout = reftable_get_be64(dest);\n-\t\tcheck_int(in, ==, out);\n-\t}\n-\n-\tif_test (\"reftable_put_be32 and reftable_get_be32 work\") {\n-\t\tuint32_t in = 0x11223344;\n-\t\tuint8_t dest[4];\n-\t\tuint32_t out;\n-\t\treftable_put_be32(dest, in);\n-\t\tout = reftable_get_be32(dest);\n-\t\tcheck_int(in, ==, out);\n-\t}\n-\n-\tif_test (\"reftable_put_be24 and reftable_get_be24 work\") {\n-\t\tuint32_t in = 0x112233;\n-\t\tuint8_t dest[3];\n-\t\tuint32_t out;\n-\t\treftable_put_be24(dest, in);\n-\t\tout = reftable_get_be24(dest);\n-\t\tcheck_int(in, ==, out);\n-\t}\n-\n-\tif_test (\"put_be16 and get_be16 work\") {\n-\t\tuint32_t in = 0xfef1;\n-\t\tuint8_t dest[3];\n-\t\tuint32_t out;\n-\t\treftable_put_be16(dest, in);\n-\t\tout = reftable_get_be16(dest);\n-\t\tcheck_int(in, ==, out);\n-\t}\n-\n-\tif_test (\"REFTABLE_ALLOC_GROW works\") {\n-\t\tint *arr = NULL, *old_arr;\n-\t\tsize_t alloc = 0, old_alloc;\n-\n-\t\tcheck(!REFTABLE_ALLOC_GROW(arr, 1, alloc));\n-\t\tcheck(arr != NULL);\n-\t\tcheck_uint(alloc, >=, 1);\n-\t\tarr[0] = 42;\n-\n-\t\told_alloc = alloc;\n-\t\told_arr = arr;\n-\t\treftable_set_alloc(NULL, realloc_stub, NULL);\n-\t\tcheck(REFTABLE_ALLOC_GROW(arr, old_alloc + 1, alloc));\n-\t\tcheck(arr == old_arr);\n-\t\tcheck_uint(alloc, ==, old_alloc);\n-\n-\t\told_alloc = alloc;\n-\t\treftable_set_alloc(NULL, NULL, NULL);\n-\t\tcheck(!REFTABLE_ALLOC_GROW(arr, old_alloc + 1, alloc));\n-\t\tcheck(arr != NULL);\n-\t\tcheck_uint(alloc, >, old_alloc);\n-\t\tarr[alloc - 1] = 42;\n-\n-\t\treftable_free(arr);\n-\t}\n-\n-\tif_test (\"REFTABLE_ALLOC_GROW_OR_NULL works\") {\n-\t\tint *arr = NULL;\n-\t\tsize_t alloc = 0, old_alloc;\n-\n-\t\tREFTABLE_ALLOC_GROW_OR_NULL(arr, 1, alloc);\n-\t\tcheck(arr != NULL);\n-\t\tcheck_uint(alloc, >=, 1);\n-\t\tarr[0] = 42;\n-\n-\t\told_alloc = alloc;\n-\t\tREFTABLE_ALLOC_GROW_OR_NULL(arr, old_alloc + 1, alloc);\n-\t\tcheck(arr != NULL);\n-\t\tcheck_uint(alloc, >, old_alloc);\n-\t\tarr[alloc - 1] = 42;\n-\n-\t\told_alloc = alloc;\n-\t\treftable_set_alloc(NULL, realloc_stub, NULL);\n-\t\tREFTABLE_ALLOC_GROW_OR_NULL(arr, old_alloc + 1, alloc);\n-\t\tcheck(arr == NULL);\n-\t\tcheck_uint(alloc, ==, 0);\n-\t\treftable_set_alloc(NULL, NULL, NULL);\n-\n-\t\treftable_free(arr);\n-\t}\n-\n-\treturn test_done();\n-}\ndiff --git a/t/unit-tests/u-reftable-basics.c b/t/unit-tests/u-reftable-basics.c\nnew file mode 100644\nindex 0000000000..f105c22d15\n--- /dev/null\n+++ b/t/unit-tests/u-reftable-basics.c\n@@ -0,0 +1,227 @@\n+/*\n+Copyright 2020 Google LLC\n+\n+Use of this source code is governed by a BSD-style\n+license that can be found in the LICENSE file or at\n+https://developers.google.com/open-source/licenses/bsd\n+*/\n+\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n+#include \"reftable/basics.h\"\n+\n+struct integer_needle_lesseq_args {\n+\tint needle;\n+\tint *haystack;\n+};\n+\n+static int integer_needle_lesseq(size_t i, void *_args)\n+{\n+\tstruct integer_needle_lesseq_args *args = _args;\n+\treturn args->needle <= args->haystack[i];\n+}\n+\n+static void *realloc_stub(void *p UNUSED, size_t size UNUSED)\n+{\n+\treturn NULL;\n+}\n+\n+void test_reftable_basics__binsearch(void)\n+{\n+\tint haystack[] = { 2, 4, 6, 8, 10 };\n+\tstruct {\n+\t\tint needle;\n+\t\tsize_t expected_idx;\n+\t} testcases[] = {\n+\t\t{-9000, 0},\n+\t\t{-1, 0},\n+\t\t{0, 0},\n+\t\t{2, 0},\n+\t\t{3, 1},\n+\t\t{4, 1},\n+\t\t{7, 3},\n+\t\t{9, 4},\n+\t\t{10, 4},\n+\t\t{11, 5},\n+\t\t{9000, 5},\n+\t};\n+\n+\tfor (size_t i = 0; i < ARRAY_SIZE(testcases); i++) {\n+\t\tstruct integer_needle_lesseq_args args = {\n+\t\t\t.haystack = haystack,\n+\t\t\t.needle = testcases[i].needle,\n+\t\t};\n+\t\tsize_t idx;\n+\n+\t\tidx = binsearch(ARRAY_SIZE(haystack),\n+\t\t\t\t&integer_needle_lesseq, &args);\n+\t\tcl_assert_equal_i(idx, testcases[i].expected_idx);\n+\t}\n+}\n+\n+void test_reftable_basics__names_length(void)\n+{\n+\tconst char *a[] = { \"a\", \"b\", NULL };\n+\tcl_assert_equal_i(names_length(a), 2);\n+}\n+\n+void test_reftable_basics__names_equal(void)\n+{\n+\tconst char *a[] = { \"a\", \"b\", \"c\", NULL };\n+\tconst char *b[] = { \"a\", \"b\", \"d\", NULL };\n+\tconst char *c[] = { \"a\", \"b\", NULL };\n+\n+\tcl_assert(names_equal(a, a));\n+\tcl_assert(!names_equal(a, b));\n+\tcl_assert(!names_equal(a, c));\n+}\n+\n+void test_reftable_basics__parse_names(void)\n+{\n+\tchar in1[] = \"line\\n\";\n+\tchar in2[] = \"a\\nb\\nc\";\n+\tchar **out = parse_names(in1, strlen(in1));\n+\tcl_assert(out != NULL);\n+\tcl_assert_equal_s(out[0], \"line\");\n+\tcl_assert(!out[1]);\n+\tfree_names(out);\n+\n+\tout = parse_names(in2, strlen(in2));\n+\tcl_assert(out != NULL);\n+\tcl_assert_equal_s(out[0], \"a\");\n+\tcl_assert_equal_s(out[1], \"b\");\n+\tcl_assert_equal_s(out[2], \"c\");\n+\tcl_assert(!out[3]);\n+\tfree_names(out);\n+}\n+\n+void test_reftable_basics__parse_names_drop_empty_string(void)\n+{\n+\tchar in[] = \"a\\n\\nb\\n\";\n+\tchar **out = parse_names(in, strlen(in));\n+\tcl_assert(out != NULL);\n+\tcl_assert_equal_s(out[0], \"a\");\n+\t/* simply '\\n' should be dropped as empty string */\n+\tcl_assert_equal_s(out[1], \"b\");\n+\tcl_assert(out[2] == NULL);\n+\tfree_names(out);\n+}\n+\n+void test_reftable_basics__common_prefix_size(void)\n+{\n+\tstruct reftable_buf a = REFTABLE_BUF_INIT;\n+\tstruct reftable_buf b = REFTABLE_BUF_INIT;\n+\tstruct {\n+\t\tconst char *a, *b;\n+\t\tint want;\n+\t} cases[] = {\n+\t\t{\"abcdef\", \"abc\", 3},\n+\t\t{ \"abc\", \"ab\", 2 },\n+\t\t{ \"\", \"abc\", 0 },\n+\t\t{ \"abc\", \"abd\", 2 },\n+\t\t{ \"abc\", \"pqr\", 0 },\n+\t};\n+\n+\tfor (size_t i = 0; i < ARRAY_SIZE(cases); i++) {\n+\t\tcl_assert_equal_i(reftable_buf_addstr(&a, cases[i].a), 0);\n+\t\tcl_assert_equal_i(reftable_buf_addstr(&b, cases[i].b), 0);\n+\t\tcl_assert_equal_i(common_prefix_size(&a, &b), cases[i].want);\n+\t\treftable_buf_reset(&a);\n+\t\treftable_buf_reset(&b);\n+\t}\n+\treftable_buf_release(&a);\n+\treftable_buf_release(&b);\n+}\n+\n+void test_reftable_basics__put_get_be64(void)\n+{\n+\tuint64_t in = 0x1122334455667788;\n+\tuint8_t dest[8];\n+\tuint64_t out;\n+\treftable_put_be64(dest, in);\n+\tout = reftable_get_be64(dest);\n+\tcl_assert(in == out);\n+}\n+\n+void test_reftable_basics__put_get_be32(void)\n+{\n+\tuint32_t in = 0x11223344;\n+\tuint8_t dest[4];\n+\tuint32_t out;\n+\treftable_put_be32(dest, in);\n+\tout = reftable_get_be32(dest);\n+\tcl_assert_equal_i(in, out);\n+}\n+\n+void test_reftable_basics__put_get_be24(void)\n+{\n+\tuint32_t in = 0x112233;\n+\tuint8_t dest[3];\n+\tuint32_t out;\n+\treftable_put_be24(dest, in);\n+\tout = reftable_get_be24(dest);\n+\tcl_assert_equal_i(in, out);\n+}\n+\n+void test_reftable_basics__put_get_be16(void)\n+{\n+\tuint32_t in = 0xfef1;\n+\tuint8_t dest[3];\n+\tuint32_t out;\n+\treftable_put_be16(dest, in);\n+\tout = reftable_get_be16(dest);\n+\tcl_assert_equal_i(in, out);\n+}\n+\n+void test_reftable_basics__alloc_grow(void)\n+{\n+\tint *arr = NULL, *old_arr;\n+\tsize_t alloc = 0, old_alloc;\n+\n+\tcl_assert_equal_i(REFTABLE_ALLOC_GROW(arr, 1, alloc), 0);\n+\tcl_assert(arr != NULL);\n+\tcl_assert(alloc >= 1);\n+\tarr[0] = 42;\n+\n+\told_alloc = alloc;\n+\told_arr = arr;\n+\treftable_set_alloc(NULL, realloc_stub, NULL);\n+\tcl_assert(REFTABLE_ALLOC_GROW(arr, old_alloc + 1, alloc));\n+\tcl_assert(arr == old_arr);\n+\tcl_assert_equal_i(alloc, old_alloc);\n+\n+\told_alloc = alloc;\n+\treftable_set_alloc(NULL, NULL, NULL);\n+\tcl_assert_equal_i(REFTABLE_ALLOC_GROW(arr, old_alloc + 1, alloc), 0);\n+\tcl_assert(arr != NULL);\n+\tcl_assert(alloc > old_alloc);\n+\tarr[alloc - 1] = 42;\n+\n+\treftable_free(arr);\n+}\n+\n+void test_reftable_basics__alloc_grow_or_null(void)\n+{\n+\tint *arr = NULL;\n+\tsize_t alloc = 0, old_alloc;\n+\n+\tREFTABLE_ALLOC_GROW_OR_NULL(arr, 1, alloc);\n+\tcl_assert(arr != NULL);\n+\tcl_assert(alloc >= 1);\n+\tarr[0] = 42;\n+\n+\told_alloc = alloc;\n+\tREFTABLE_ALLOC_GROW_OR_NULL(arr, old_alloc + 1, alloc);\n+\tcl_assert(arr != NULL);\n+\tcl_assert(alloc > old_alloc);\n+\tarr[alloc - 1] = 42;\n+\n+\told_alloc = alloc;\n+\treftable_set_alloc(NULL, realloc_stub, NULL);\n+\tREFTABLE_ALLOC_GROW_OR_NULL(arr, old_alloc + 1, alloc);\n+\tcl_assert(arr == NULL);\n+\tcl_assert_equal_i(alloc, 0);\n+\treftable_set_alloc(NULL, NULL, NULL);\n+\n+\treftable_free(arr);\n+}\n-- \n2.43.0\n\n"},{"id":"519775","messageId":"20250605140644.239199-4-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250605140644.239199-1-kuforiji98@gmail.com","subject":"[PATCH v4 03/10] t/unit-tests: convert reftable block test to use clar","fromName":"Seyi Kuforiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-06-05T14:06:37Z","receivedAt":"2025-06-05T14:08:08Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"Adapt reftable block test file to use clar testing framework by using\nclar assertions where necessary.\n\nSigned-off-by: Seyi Kuforiji \n---\n Makefile | 2 +-\n t/meson.build | 2 +-\n ...{t-reftable-block.c => u-reftable-block.c} | 164 +++++++++---------\n 3 files changed, 80 insertions(+), 88 deletions(-)\n rename t/unit-tests/{t-reftable-block.c => u-reftable-block.c} (74%)\n\ndiff --git a/Makefile b/Makefile\nindex a01103e3a6..d01dfd179b 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1365,6 +1365,7 @@ CLAR_TEST_SUITES += u-oidmap\n CLAR_TEST_SUITES += u-oidtree\n CLAR_TEST_SUITES += u-prio-queue\n CLAR_TEST_SUITES += u-reftable-basics\n+CLAR_TEST_SUITES += u-reftable-block\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n CLAR_TEST_SUITES += u-strcmp-offset\n@@ -1378,7 +1379,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-block\n UNIT_TEST_PROGRAMS += t-reftable-merged\n UNIT_TEST_PROGRAMS += t-reftable-pq\n UNIT_TEST_PROGRAMS += t-reftable-readwrite\ndiff --git a/t/meson.build b/t/meson.build\nindex e00e8d41d6..b1d9dea9e7 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -9,6 +9,7 @@ clar_test_suites = [\n 'unit-tests/u-oidtree.c',\n 'unit-tests/u-prio-queue.c',\n 'unit-tests/u-reftable-basics.c',\n+ 'unit-tests/u-reftable-block.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n 'unit-tests/u-strcmp-offset.c',\n@@ -56,7 +57,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-block.c',\n 'unit-tests/t-reftable-merged.c',\n 'unit-tests/t-reftable-pq.c',\n 'unit-tests/t-reftable-readwrite.c',\ndiff --git a/t/unit-tests/t-reftable-block.c b/t/unit-tests/u-reftable-block.c\nsimilarity index 74%\nrename from t/unit-tests/t-reftable-block.c\nrename to t/unit-tests/u-reftable-block.c\nindex 52f1dae1c9..97a1348563 100644\n--- a/t/unit-tests/t-reftable-block.c\n+++ b/t/unit-tests/u-reftable-block.c\n@@ -6,14 +6,15 @@ license that can be found in the LICENSE file or at\n https://developers.google.com/open-source/licenses/bsd\n */\n \n-#include \"test-lib.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/block.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/reftable-error.h\"\n #include \"strbuf.h\"\n \n-static void t_ref_block_read_write(void)\n+void test_reftable_block__read_write(void)\n {\n \tconst int header_off = 21; /* random */\n \tstruct reftable_record recs[30];\n@@ -34,17 +35,18 @@ static void t_ref_block_read_write(void)\n \tstruct reftable_buf block_data = REFTABLE_BUF_INIT;\n \n \tREFTABLE_CALLOC_ARRAY(block_data.buf, block_size);\n-\tcheck(block_data.buf != NULL);\n+\tcl_assert(block_data.buf != NULL);\n \tblock_data.len = block_size;\n \n-\tret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_REF, (uint8_t *) block_data.buf, block_size,\n+\tret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_REF,\n+\t\t\t\t(uint8_t *) block_data.buf, block_size,\n \t\t\t\theader_off, hash_size(REFTABLE_HASH_SHA1));\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \trec.u.ref.refname = (char *) \"\";\n \trec.u.ref.value_type = REFTABLE_REF_DELETION;\n \tret = block_writer_add(&bw, &rec);\n-\tcheck_int(ret, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(ret, REFTABLE_API_ERROR);\n \n \tfor (i = 0; i < N; i++) {\n \t\trec.u.ref.refname = xstrfmt(\"branch%02\"PRIuMAX, (uintmax_t)i);\n@@ -55,11 +57,11 @@ static void t_ref_block_read_write(void)\n \t\tret = block_writer_add(&bw, &rec);\n \t\trec.u.ref.refname = NULL;\n \t\trec.u.ref.value_type = REFTABLE_REF_DELETION;\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \t}\n \n \tret = block_writer_finish(&bw);\n-\tcheck_int(ret, >, 0);\n+\tcl_assert(ret > 0);\n \n \tblock_writer_release(&bw);\n \n@@ -71,32 +73,32 @@ static void t_ref_block_read_write(void)\n \n \tfor (i = 0; ; i++) {\n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, >=, 0);\n+\t\tcl_assert(ret >= 0);\n \t\tif (ret > 0) {\n-\t\t\tcheck_int(i, ==, N);\n+\t\t\tcl_assert_equal_i(i, N);\n \t\t\tbreak;\n \t\t}\n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n \t\treftable_record_key(&recs[i], &want);\n \n \t\tret = block_iter_seek_key(&it, &want);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \n \t\twant.len--;\n \t\tret = block_iter_seek_key(&it, &want);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, ==, 0);\n-\t\tcheck(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(ret, 0);\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \treftable_block_release(&block);\n@@ -108,7 +110,7 @@ static void t_ref_block_read_write(void)\n \t\treftable_record_release(&recs[i]);\n }\n \n-static void t_log_block_read_write(void)\n+void test_reftable_block__log_read_write(void)\n {\n \tconst int header_off = 21;\n \tstruct reftable_record recs[30];\n@@ -129,12 +131,12 @@ static void t_log_block_read_write(void)\n \tstruct reftable_buf block_data = REFTABLE_BUF_INIT;\n \n \tREFTABLE_CALLOC_ARRAY(block_data.buf, block_size);\n-\tcheck(block_data.buf != NULL);\n+\tcl_assert(block_data.buf != NULL);\n \tblock_data.len = block_size;\n \n \tret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_LOG, (uint8_t *) block_data.buf, block_size,\n \t\t\t\theader_off, hash_size(REFTABLE_HASH_SHA1));\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \tfor (i = 0; i < N; i++) {\n \t\trec.u.log.refname = xstrfmt(\"branch%02\"PRIuMAX , (uintmax_t)i);\n@@ -145,11 +147,11 @@ static void t_log_block_read_write(void)\n \t\tret = block_writer_add(&bw, &rec);\n \t\trec.u.log.refname = NULL;\n \t\trec.u.log.value_type = REFTABLE_LOG_DELETION;\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \t}\n \n \tret = block_writer_finish(&bw);\n-\tcheck_int(ret, >, 0);\n+\tcl_assert(ret > 0);\n \n \tblock_writer_release(&bw);\n \n@@ -161,33 +163,33 @@ static void t_log_block_read_write(void)\n \n \tfor (i = 0; ; i++) {\n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, >=, 0);\n+\t\tcl_assert(ret >= 0);\n \t\tif (ret > 0) {\n-\t\t\tcheck_int(i, ==, N);\n+\t\t\tcl_assert_equal_i(i, N);\n \t\t\tbreak;\n \t\t}\n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n \t\treftable_buf_reset(&want);\n-\t\tcheck(!reftable_buf_addstr(&want, recs[i].u.log.refname));\n+\t\tcl_assert(reftable_buf_addstr(&want, recs[i].u.log.refname) == 0);\n \n \t\tret = block_iter_seek_key(&it, &want);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \n \t\twant.len--;\n \t\tret = block_iter_seek_key(&it, &want);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, ==, 0);\n-\t\tcheck(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(ret, 0);\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \treftable_block_release(&block);\n@@ -199,7 +201,7 @@ static void t_log_block_read_write(void)\n \t\treftable_record_release(&recs[i]);\n }\n \n-static void t_obj_block_read_write(void)\n+void test_reftable_block__obj_read_write(void)\n {\n \tconst int header_off = 21;\n \tstruct reftable_record recs[30];\n@@ -220,12 +222,12 @@ static void t_obj_block_read_write(void)\n \tstruct reftable_buf block_data = REFTABLE_BUF_INIT;\n \n \tREFTABLE_CALLOC_ARRAY(block_data.buf, block_size);\n-\tcheck(block_data.buf != NULL);\n+\tcl_assert(block_data.buf != NULL);\n \tblock_data.len = block_size;\n \n \tret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_OBJ, (uint8_t *) block_data.buf, block_size,\n \t\t\t\theader_off, hash_size(REFTABLE_HASH_SHA1));\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \tfor (i = 0; i < N; i++) {\n \t\tuint8_t bytes[] = { i, i + 1, i + 2, i + 3, i + 5 }, *allocated;\n@@ -238,11 +240,11 @@ static void t_obj_block_read_write(void)\n \t\tret = block_writer_add(&bw, &rec);\n \t\trec.u.obj.hash_prefix = NULL;\n \t\trec.u.obj.hash_prefix_len = 0;\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \t}\n \n \tret = block_writer_finish(&bw);\n-\tcheck_int(ret, >, 0);\n+\tcl_assert(ret > 0);\n \n \tblock_writer_release(&bw);\n \n@@ -254,24 +256,24 @@ static void t_obj_block_read_write(void)\n \n \tfor (i = 0; ; i++) {\n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, >=, 0);\n+\t\tcl_assert(ret >= 0);\n \t\tif (ret > 0) {\n-\t\t\tcheck_int(i, ==, N);\n+\t\t\tcl_assert_equal_i(i, N);\n \t\t\tbreak;\n \t\t}\n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n \t\treftable_record_key(&recs[i], &want);\n \n \t\tret = block_iter_seek_key(&it, &want);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \treftable_block_release(&block);\n@@ -283,7 +285,7 @@ static void t_obj_block_read_write(void)\n \t\treftable_record_release(&recs[i]);\n }\n \n-static void t_index_block_read_write(void)\n+void test_reftable_block__ref_read_write(void)\n {\n \tconst int header_off = 21;\n \tstruct reftable_record recs[30];\n@@ -305,12 +307,12 @@ static void t_index_block_read_write(void)\n \tstruct reftable_buf block_data = REFTABLE_BUF_INIT;\n \n \tREFTABLE_CALLOC_ARRAY(block_data.buf, block_size);\n-\tcheck(block_data.buf != NULL);\n+\tcl_assert(block_data.buf != NULL);\n \tblock_data.len = block_size;\n \n \tret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_INDEX, (uint8_t *) block_data.buf, block_size,\n \t\t\t\theader_off, hash_size(REFTABLE_HASH_SHA1));\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \tfor (i = 0; i < N; i++) {\n \t\tchar buf[128];\n@@ -319,15 +321,15 @@ static void t_index_block_read_write(void)\n \n \t\treftable_buf_init(&recs[i].u.idx.last_key);\n \t\trecs[i].type = REFTABLE_BLOCK_TYPE_INDEX;\n-\t\tcheck(!reftable_buf_addstr(&recs[i].u.idx.last_key, buf));\n+\t\tcl_assert(!reftable_buf_addstr(&recs[i].u.idx.last_key, buf));\n \t\trecs[i].u.idx.offset = i;\n \n \t\tret = block_writer_add(&bw, &recs[i]);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \t}\n \n \tret = block_writer_finish(&bw);\n-\tcheck_int(ret, >, 0);\n+\tcl_assert(ret > 0);\n \n \tblock_writer_release(&bw);\n \n@@ -339,32 +341,32 @@ static void t_index_block_read_write(void)\n \n \tfor (i = 0; ; i++) {\n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, >=, 0);\n+\t\tcl_assert(ret >= 0);\n \t\tif (ret > 0) {\n-\t\t\tcheck_int(i, ==, N);\n+\t\t\tcl_assert_equal_i(i, N);\n \t\t\tbreak;\n \t\t}\n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n \t\treftable_record_key(&recs[i], &want);\n \n \t\tret = block_iter_seek_key(&it, &want);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \n \t\twant.len--;\n \t\tret = block_iter_seek_key(&it, &want);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, ==, 0);\n-\t\tcheck(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(ret, 0);\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \treftable_block_release(&block);\n@@ -376,7 +378,7 @@ static void t_index_block_read_write(void)\n \t\treftable_record_release(&recs[i]);\n }\n \n-static void t_block_iterator(void)\n+void test_reftable_block__iterator(void)\n {\n \tstruct reftable_block_source source = { 0 };\n \tstruct block_writer writer = {\n@@ -391,11 +393,12 @@ static void t_block_iterator(void)\n \n \tdata.len = 1024;\n \tREFTABLE_CALLOC_ARRAY(data.buf, data.len);\n-\tcheck(data.buf != NULL);\n+\tcl_assert(data.buf != NULL);\n \n-\terr = block_writer_init(&writer, REFTABLE_BLOCK_TYPE_REF, (uint8_t *) data.buf, data.len,\n+\terr = block_writer_init(&writer, REFTABLE_BLOCK_TYPE_REF,\n+\t\t\t\t(uint8_t *) data.buf, data.len,\n \t\t\t\t0, hash_size(REFTABLE_HASH_SHA1));\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(expected_refs); i++) {\n \t\texpected_refs[i] = (struct reftable_record) {\n@@ -408,42 +411,42 @@ static void t_block_iterator(void)\n \t\tmemset(expected_refs[i].u.ref.value.val1, i, REFTABLE_HASH_SIZE_SHA1);\n \n \t\terr = block_writer_add(&writer, &expected_refs[i]);\n-\t\tcheck_int(err, ==, 0);\n+\t\tcl_assert_equal_i(err, 0);\n \t}\n \n \terr = block_writer_finish(&writer);\n-\tcheck_int(err, >, 0);\n+\tcl_assert(err > 0);\n \n \tblock_source_from_buf(&source, &data);\n \treftable_block_init(&block, &source, 0, 0, data.len,\n \t\t\t REFTABLE_HASH_SIZE_SHA1, REFTABLE_BLOCK_TYPE_REF);\n \n \terr = reftable_block_init_iterator(&block, &it);\n-\tcheck_int(err, ==, 0);\n+\tcl_assert_equal_i(err, 0);\n \n \tfor (size_t i = 0; ; i++) {\n \t\terr = reftable_iterator_next_ref(&it, &ref);\n \t\tif (err > 0) {\n-\t\t\tcheck_int(i, ==, ARRAY_SIZE(expected_refs));\n+\t\t\tcl_assert_equal_i(i, ARRAY_SIZE(expected_refs));\n \t\t\tbreak;\n \t\t}\n-\t\tcheck_int(err, ==, 0);\n+\t\tcl_assert_equal_i(err, 0);\n \n-\t\tcheck(reftable_ref_record_equal(&ref, &expected_refs[i].u.ref,\n-\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_ref_record_equal(&ref,\n+\t\t\t\t\t\t &expected_refs[i].u.ref, REFTABLE_HASH_SIZE_SHA1));\n \t}\n \n \terr = reftable_iterator_seek_ref(&it, \"refs/heads/does-not-exist\");\n-\tcheck_int(err, ==, 0);\n+\tcl_assert_equal_i(err, 0);\n \terr = reftable_iterator_next_ref(&it, &ref);\n-\tcheck_int(err, ==, 1);\n+\tcl_assert_equal_i(err, 1);\n \n \terr = reftable_iterator_seek_ref(&it, \"refs/heads/branch-13\");\n-\tcheck_int(err, ==, 0);\n+\tcl_assert_equal_i(err, 0);\n \terr = reftable_iterator_next_ref(&it, &ref);\n-\tcheck_int(err, ==, 0);\n-\tcheck(reftable_ref_record_equal(&ref, &expected_refs[13].u.ref,\n-\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert_equal_i(err, 0);\n+\tcl_assert(reftable_ref_record_equal(&ref,\n+\t\t\t\t\t &expected_refs[13].u.ref,REFTABLE_HASH_SIZE_SHA1));\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(expected_refs); i++)\n \t\treftable_free(expected_refs[i].u.ref.refname);\n@@ -453,14 +456,3 @@ static void t_block_iterator(void)\n \tblock_writer_release(&writer);\n \treftable_buf_release(&data);\n }\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_index_block_read_write(), \"read-write operations on index blocks work\");\n-\tTEST(t_log_block_read_write(), \"read-write operations on log blocks work\");\n-\tTEST(t_obj_block_read_write(), \"read-write operations on obj blocks work\");\n-\tTEST(t_ref_block_read_write(), \"read-write operations on ref blocks work\");\n-\tTEST(t_block_iterator(), \"block iterator works\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"519776","messageId":"20250605140644.239199-5-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250605140644.239199-1-kuforiji98@gmail.com","subject":"[PATCH v4 04/10] t/unit-tests: convert reftable merged test to use clar","fromName":"Seyi Kuforiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-06-05T14:06:38Z","receivedAt":"2025-06-05T14:08:12Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"Adapt reftable merged test file to use clar testing framework by using\nclar assertions where necessary.\n\nSigned-off-by: Seyi Kuforiji \n---\n Makefile | 2 +-\n t/meson.build | 2 +-\n ...-reftable-merged.c => u-reftable-merged.c} | 162 ++++++++----------\n 3 files changed, 72 insertions(+), 94 deletions(-)\n rename t/unit-tests/{t-reftable-merged.c => u-reftable-merged.c} (77%)\n\ndiff --git a/Makefile b/Makefile\nindex d01dfd179b..fb0ef10ff2 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1366,6 +1366,7 @@ CLAR_TEST_SUITES += u-oidtree\n CLAR_TEST_SUITES += u-prio-queue\n CLAR_TEST_SUITES += u-reftable-basics\n CLAR_TEST_SUITES += u-reftable-block\n+CLAR_TEST_SUITES += u-reftable-merged\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n CLAR_TEST_SUITES += u-strcmp-offset\n@@ -1379,7 +1380,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-merged\n UNIT_TEST_PROGRAMS += t-reftable-pq\n UNIT_TEST_PROGRAMS += t-reftable-readwrite\n UNIT_TEST_PROGRAMS += t-reftable-record\ndiff --git a/t/meson.build b/t/meson.build\nindex b1d9dea9e7..d25dfb0c92 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -10,6 +10,7 @@ clar_test_suites = [\n 'unit-tests/u-prio-queue.c',\n 'unit-tests/u-reftable-basics.c',\n 'unit-tests/u-reftable-block.c',\n+ 'unit-tests/u-reftable-merged.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n 'unit-tests/u-strcmp-offset.c',\n@@ -57,7 +58,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-merged.c',\n 'unit-tests/t-reftable-pq.c',\n 'unit-tests/t-reftable-readwrite.c',\n 'unit-tests/t-reftable-record.c',\ndiff --git a/t/unit-tests/t-reftable-merged.c b/t/unit-tests/u-reftable-merged.c\nsimilarity index 77%\nrename from t/unit-tests/t-reftable-merged.c\nrename to t/unit-tests/u-reftable-merged.c\nindex 18c3251a56..62b02baa14 100644\n--- a/t/unit-tests/t-reftable-merged.c\n+++ b/t/unit-tests/u-reftable-merged.c\n@@ -6,8 +6,8 @@ license that can be found in the LICENSE file or at\n https://developers.google.com/open-source/licenses/bsd\n */\n \n-#include \"test-lib.h\"\n-#include \"lib-reftable.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/merged.h\"\n@@ -29,21 +29,21 @@ merged_table_from_records(struct reftable_ref_record **refs,\n \tint err;\n \n \tREFTABLE_CALLOC_ARRAY(*tables, n);\n-\tcheck(*tables != NULL);\n+\tcl_assert(*tables != NULL);\n \tREFTABLE_CALLOC_ARRAY(*source, n);\n-\tcheck(*source != NULL);\n+\tcl_assert(*source != NULL);\n \n \tfor (size_t i = 0; i < n; i++) {\n-\t\tt_reftable_write_to_buf(&buf[i], refs[i], sizes[i], NULL, 0, &opts);\n+\t\tcl_reftable_write_to_buf(&buf[i], refs[i], sizes[i], NULL, 0, &opts);\n \t\tblock_source_from_buf(&(*source)[i], &buf[i]);\n \n \t\terr = reftable_table_new(&(*tables)[i], &(*source)[i],\n \t\t\t\t\t \"name\");\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \t}\n \n \terr = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \treturn mt;\n }\n \n@@ -54,7 +54,7 @@ static void tables_destroy(struct reftable_table **tables, const size_t n)\n \treftable_free(tables);\n }\n \n-static void t_merged_single_record(void)\n+void test_reftable_merged__single_record(void)\n {\n \tstruct reftable_ref_record r1[] = { {\n \t\t.refname = (char *) \"b\",\n@@ -85,13 +85,14 @@ static void t_merged_single_record(void)\n \tint err;\n \n \terr = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"a\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_iterator_next_ref(&it, &ref);\n-\tcheck(!err);\n-\tcheck(reftable_ref_record_equal(&r2[0], &ref, REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert(!err);\n+\tcl_assert(reftable_ref_record_equal(&r2[0], &ref,\n+\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \treftable_ref_record_release(&ref);\n \treftable_iterator_destroy(&it);\n \ttables_destroy(tables, 3);\n@@ -101,7 +102,7 @@ static void t_merged_single_record(void)\n \treftable_free(bs);\n }\n \n-static void t_merged_refs(void)\n+void test_reftable_merged__refs(void)\n {\n \tstruct reftable_ref_record r1[] = {\n \t\t{\n@@ -165,12 +166,12 @@ static void t_merged_refs(void)\n \tsize_t i;\n \n \terr = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"a\");\n-\tcheck(!err);\n-\tcheck_int(reftable_merged_table_hash_id(mt), ==, REFTABLE_HASH_SHA1);\n-\tcheck_int(reftable_merged_table_min_update_index(mt), ==, 1);\n-\tcheck_int(reftable_merged_table_max_update_index(mt), ==, 3);\n+\tcl_assert(err == 0);\n+\tcl_assert_equal_i(reftable_merged_table_hash_id(mt), REFTABLE_HASH_SHA1);\n+\tcl_assert_equal_i(reftable_merged_table_min_update_index(mt), 1);\n+\tcl_assert_equal_i(reftable_merged_table_max_update_index(mt), 3);\n \n \twhile (len < 100) { /* cap loops/recursion. */\n \t\tstruct reftable_ref_record ref = { 0 };\n@@ -178,15 +179,15 @@ static void t_merged_refs(void)\n \t\tif (err > 0)\n \t\t\tbreak;\n \n-\t\tcheck(!REFTABLE_ALLOC_GROW(out, len + 1, cap));\n+\t\tcl_assert(REFTABLE_ALLOC_GROW(out, len + 1, cap) == 0);\n \t\tout[len++] = ref;\n \t}\n \treftable_iterator_destroy(&it);\n \n-\tcheck_int(ARRAY_SIZE(want), ==, len);\n+\tcl_assert_equal_i(ARRAY_SIZE(want), len);\n \tfor (i = 0; i < len; i++)\n-\t\tcheck(reftable_ref_record_equal(want[i], &out[i],\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_ref_record_equal(want[i], &out[i],\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \tfor (i = 0; i < len; i++)\n \t\treftable_ref_record_release(&out[i]);\n \treftable_free(out);\n@@ -198,7 +199,7 @@ static void t_merged_refs(void)\n \treftable_free(bs);\n }\n \n-static void t_merged_seek_multiple_times(void)\n+void test_reftable_merged__seek_multiple_times(void)\n {\n \tstruct reftable_ref_record r1[] = {\n \t\t{\n@@ -248,20 +249,17 @@ static void t_merged_seek_multiple_times(void)\n \n \tfor (size_t i = 0; i < 5; i++) {\n \t\tint err = reftable_iterator_seek_ref(&it, \"c\");\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \n-\t\terr = reftable_iterator_next_ref(&it, &rec);\n-\t\tcheck(!err);\n-\t\terr = reftable_ref_record_equal(&rec, &r1[1], REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck(err == 1);\n+\t\tcl_assert(reftable_iterator_next_ref(&it, &rec) == 0);\n+\t\tcl_assert_equal_i(reftable_ref_record_equal(&rec, &r1[1],\n+\t\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1), 1);\n \n-\t\terr = reftable_iterator_next_ref(&it, &rec);\n-\t\tcheck(!err);\n-\t\terr = reftable_ref_record_equal(&rec, &r2[1], REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck(err == 1);\n+\t\tcl_assert(reftable_iterator_next_ref(&it, &rec) == 0);\n+\t\tcl_assert_equal_i(reftable_ref_record_equal(&rec, &r2[1],\n+\t\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1), 1);\n \n-\t\terr = reftable_iterator_next_ref(&it, &rec);\n-\t\tcheck(err > 0);\n+\t\tcl_assert(reftable_iterator_next_ref(&it, &rec) > 0);\n \t}\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(bufs); i++)\n@@ -273,7 +271,7 @@ static void t_merged_seek_multiple_times(void)\n \treftable_free(sources);\n }\n \n-static void t_merged_seek_multiple_times_without_draining(void)\n+void test_reftable_merged__seek_multiple_times_no_drain(void)\n {\n \tstruct reftable_ref_record r1[] = {\n \t\t{\n@@ -317,24 +315,19 @@ static void t_merged_seek_multiple_times_without_draining(void)\n \tstruct reftable_ref_record rec = { 0 };\n \tstruct reftable_iterator it = { 0 };\n \tstruct reftable_merged_table *mt;\n-\tint err;\n \n \tmt = merged_table_from_records(refs, &sources, &tables, sizes, bufs, 2);\n \tmerged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);\n \n-\terr = reftable_iterator_seek_ref(&it, \"b\");\n-\tcheck(!err);\n-\terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\terr = reftable_ref_record_equal(&rec, &r2[0], REFTABLE_HASH_SIZE_SHA1);\n-\tcheck(err == 1);\n+\tcl_assert(reftable_iterator_seek_ref(&it, \"b\") == 0);\n+\tcl_assert(reftable_iterator_next_ref(&it, &rec) == 0);\n+\tcl_assert_equal_i(reftable_ref_record_equal(&rec, &r2[0],\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1), 1);\n \n-\terr = reftable_iterator_seek_ref(&it, \"a\");\n-\tcheck(!err);\n-\terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\terr = reftable_ref_record_equal(&rec, &r1[0], REFTABLE_HASH_SIZE_SHA1);\n-\tcheck(err == 1);\n+\tcl_assert(reftable_iterator_seek_ref(&it, \"a\") == 0);\n+\tcl_assert(reftable_iterator_next_ref(&it, &rec) == 0);\n+\tcl_assert_equal_i(reftable_ref_record_equal(&rec, &r1[0],\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1), 1);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(bufs); i++)\n \t\treftable_buf_release(&bufs[i]);\n@@ -359,25 +352,25 @@ merged_table_from_log_records(struct reftable_log_record **logs,\n \tint err;\n \n \tREFTABLE_CALLOC_ARRAY(*tables, n);\n-\tcheck(*tables != NULL);\n+\tcl_assert(*tables != NULL);\n \tREFTABLE_CALLOC_ARRAY(*source, n);\n-\tcheck(*source != NULL);\n+\tcl_assert(*source != NULL);\n \n \tfor (size_t i = 0; i < n; i++) {\n-\t\tt_reftable_write_to_buf(&buf[i], NULL, 0, logs[i], sizes[i], &opts);\n+\t\tcl_reftable_write_to_buf(&buf[i], NULL, 0, logs[i], sizes[i], &opts);\n \t\tblock_source_from_buf(&(*source)[i], &buf[i]);\n \n \t\terr = reftable_table_new(&(*tables)[i], &(*source)[i],\n \t\t\t\t\t \"name\");\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \t}\n \n \terr = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \treturn mt;\n }\n \n-static void t_merged_logs(void)\n+void test_reftable_merged__logs(void)\n {\n \tstruct reftable_log_record r1[] = {\n \t\t{\n@@ -439,19 +432,19 @@ static void t_merged_logs(void)\n \tstruct reftable_merged_table *mt = merged_table_from_log_records(\n \t\tlogs, &bs, &tables, sizes, bufs, 3);\n \tstruct reftable_iterator it = { 0 };\n-\tint err;\n \tstruct reftable_log_record *out = NULL;\n \tsize_t len = 0;\n \tsize_t cap = 0;\n \tsize_t i;\n+\tint err;\n \n \terr = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_log(&it, \"a\");\n-\tcheck(!err);\n-\tcheck_int(reftable_merged_table_hash_id(mt), ==, REFTABLE_HASH_SHA1);\n-\tcheck_int(reftable_merged_table_min_update_index(mt), ==, 1);\n-\tcheck_int(reftable_merged_table_max_update_index(mt), ==, 3);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(reftable_merged_table_hash_id(mt), REFTABLE_HASH_SHA1);\n+\tcl_assert_equal_i(reftable_merged_table_min_update_index(mt), 1);\n+\tcl_assert_equal_i(reftable_merged_table_max_update_index(mt), 3);\n \n \twhile (len < 100) { /* cap loops/recursion. */\n \t\tstruct reftable_log_record log = { 0 };\n@@ -459,24 +452,24 @@ static void t_merged_logs(void)\n \t\tif (err > 0)\n \t\t\tbreak;\n \n-\t\tcheck(!REFTABLE_ALLOC_GROW(out, len + 1, cap));\n+\t\tcl_assert(REFTABLE_ALLOC_GROW(out, len + 1, cap) == 0);\n \t\tout[len++] = log;\n \t}\n \treftable_iterator_destroy(&it);\n \n-\tcheck_int(ARRAY_SIZE(want), ==, len);\n+\tcl_assert_equal_i(ARRAY_SIZE(want), len);\n \tfor (i = 0; i < len; i++)\n-\t\tcheck(reftable_log_record_equal(want[i], &out[i],\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_log_record_equal(want[i], &out[i],\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \n \terr = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_log_at(&it, \"a\", 2);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \treftable_log_record_release(&out[0]);\n-\terr = reftable_iterator_next_log(&it, &out[0]);\n-\tcheck(!err);\n-\tcheck(reftable_log_record_equal(&out[0], &r3[0], REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert(reftable_iterator_next_log(&it, &out[0]) == 0);\n+\tcl_assert(reftable_log_record_equal(&out[0], &r3[0],\n+\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \treftable_iterator_destroy(&it);\n \n \tfor (i = 0; i < len; i++)\n@@ -490,11 +483,11 @@ static void t_merged_logs(void)\n \treftable_free(bs);\n }\n \n-static void t_default_write_opts(void)\n+void test_reftable_merged__default_write_opts(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_ref_record rec = {\n \t\t.refname = (char *) \"master\",\n \t\t.update_index = 1,\n@@ -507,40 +500,25 @@ static void t_default_write_opts(void)\n \n \treftable_writer_set_limits(w, 1, 1);\n \n-\terr = reftable_writer_add_ref(w, &rec);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_writer_add_ref(w, &rec), 0);\n \n-\terr = reftable_writer_close(w);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \treftable_writer_free(w);\n \n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"filename\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \thash_id = reftable_table_hash_id(table);\n-\tcheck_int(hash_id, ==, REFTABLE_HASH_SHA1);\n+\tcl_assert_equal_i(hash_id, REFTABLE_HASH_SHA1);\n \n \terr = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA256);\n-\tcheck_int(err, ==, REFTABLE_FORMAT_ERROR);\n+\tcl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);\n \terr = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA1);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \treftable_table_decref(table);\n \treftable_merged_table_free(merged);\n \treftable_buf_release(&buf);\n }\n-\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_default_write_opts(), \"merged table with default write opts\");\n-\tTEST(t_merged_logs(), \"merged table with multiple log updates for same ref\");\n-\tTEST(t_merged_refs(), \"merged table with multiple updates to same ref\");\n-\tTEST(t_merged_seek_multiple_times(), \"merged table can seek multiple times\");\n-\tTEST(t_merged_seek_multiple_times_without_draining(), \"merged table can seek multiple times without draining\");\n-\tTEST(t_merged_single_record(), \"ref occurring in only one record can be fetched\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"519777","messageId":"20250605140644.239199-6-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250605140644.239199-1-kuforiji98@gmail.com","subject":"[PATCH v4 05/10] t/unit-tests: convert reftable pq test to use clar","fromName":"Seyi Kuforiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-06-05T14:06:39Z","receivedAt":"2025-06-05T14:08:18Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"Adapt reftable priority queue test file to use clar by using clar\nassertions where necessary.\n\nSigned-off-by: Seyi Kuforiji \n---\n Makefile | 2 +-\n t/meson.build | 3 +-\n .../{t-reftable-pq.c => u-reftable-pq.c} | 59 +++++++++----------\n 3 files changed, 30 insertions(+), 34 deletions(-)\n rename t/unit-tests/{t-reftable-pq.c => u-reftable-pq.c} (64%)\n\ndiff --git a/Makefile b/Makefile\nindex fb0ef10ff2..3cccc73073 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1367,6 +1367,7 @@ CLAR_TEST_SUITES += u-prio-queue\n CLAR_TEST_SUITES += u-reftable-basics\n CLAR_TEST_SUITES += u-reftable-block\n CLAR_TEST_SUITES += u-reftable-merged\n+CLAR_TEST_SUITES += u-reftable-pq\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n CLAR_TEST_SUITES += u-strcmp-offset\n@@ -1380,7 +1381,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-pq\n UNIT_TEST_PROGRAMS += t-reftable-readwrite\n UNIT_TEST_PROGRAMS += t-reftable-record\n UNIT_TEST_PROGRAMS += t-reftable-stack\ndiff --git a/t/meson.build b/t/meson.build\nindex d25dfb0c92..ac4394b7a2 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -11,6 +11,7 @@ clar_test_suites = [\n 'unit-tests/u-reftable-basics.c',\n 'unit-tests/u-reftable-block.c',\n 'unit-tests/u-reftable-merged.c',\n+ 'unit-tests/u-reftable-pq.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n 'unit-tests/u-strcmp-offset.c',\n@@ -58,7 +59,7 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-pq.c',\n+ 'unit-tests/t-reftable-reader.c',\n 'unit-tests/t-reftable-readwrite.c',\n 'unit-tests/t-reftable-record.c',\n 'unit-tests/t-reftable-stack.c',\ndiff --git a/t/unit-tests/t-reftable-pq.c b/t/unit-tests/u-reftable-pq.c\nsimilarity index 64%\nrename from t/unit-tests/t-reftable-pq.c\nrename to t/unit-tests/u-reftable-pq.c\nindex fb5a4eb187..d55792ca6f 100644\n--- a/t/unit-tests/t-reftable-pq.c\n+++ b/t/unit-tests/u-reftable-pq.c\n@@ -6,7 +6,8 @@ license that can be found in the LICENSE file or at\n https://developers.google.com/open-source/licenses/bsd\n */\n \n-#include \"test-lib.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/pq.h\"\n #include \"strbuf.h\"\n@@ -15,18 +16,18 @@ static void merged_iter_pqueue_check(const struct merged_iter_pqueue *pq)\n {\n \tfor (size_t i = 1; i < pq->len; i++) {\n \t\tsize_t parent = (i - 1) / 2;\n-\t\tcheck(pq_less(&pq->heap[parent], &pq->heap[i]));\n+\t\tcl_assert(pq_less(&pq->heap[parent], &pq->heap[i]) != 0);\n \t}\n }\n \n static int pq_entry_equal(struct pq_entry *a, struct pq_entry *b)\n {\n \tint cmp;\n-\tcheck(!reftable_record_cmp(a->rec, b->rec, &cmp));\n+\tcl_assert_equal_i(reftable_record_cmp(a->rec, b->rec, &cmp), 0);\n \treturn !cmp && (a->index == b->index);\n }\n \n-static void t_pq_record(void)\n+void test_reftable_pq__record(void)\n {\n \tstruct merged_iter_pqueue pq = { 0 };\n \tstruct reftable_record recs[54];\n@@ -34,7 +35,8 @@ static void t_pq_record(void)\n \tchar *last = NULL;\n \n \tfor (i = 0; i < N; i++) {\n-\t\tcheck(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));\n+\t\tcl_assert(!reftable_record_init(&recs[i],\n+\t\t\t\t\t\tREFTABLE_BLOCK_TYPE_REF));\n \t\trecs[i].u.ref.refname = xstrfmt(\"%02\"PRIuMAX, (uintmax_t)i);\n \t}\n \n@@ -53,13 +55,13 @@ static void t_pq_record(void)\n \t\tstruct pq_entry top = merged_iter_pqueue_top(pq);\n \t\tstruct pq_entry e;\n \n-\t\tcheck(!merged_iter_pqueue_remove(&pq, &e));\n+\t\tcl_assert_equal_i(merged_iter_pqueue_remove(&pq, &e), 0);\n \t\tmerged_iter_pqueue_check(&pq);\n \n-\t\tcheck(pq_entry_equal(&top, &e));\n-\t\tcheck(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);\n+\t\tcl_assert(pq_entry_equal(&top, &e));\n+\t\tcl_assert(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);\n \t\tif (last)\n-\t\t\tcheck_int(strcmp(last, e.rec->u.ref.refname), <, 0);\n+\t\t\tcl_assert(strcmp(last, e.rec->u.ref.refname) < 0);\n \t\tlast = e.rec->u.ref.refname;\n \t}\n \n@@ -68,7 +70,7 @@ static void t_pq_record(void)\n \tmerged_iter_pqueue_release(&pq);\n }\n \n-static void t_pq_index(void)\n+void test_reftable_pq__index(void)\n {\n \tstruct merged_iter_pqueue pq = { 0 };\n \tstruct reftable_record recs[13];\n@@ -76,7 +78,8 @@ static void t_pq_index(void)\n \tsize_t N = ARRAY_SIZE(recs), i;\n \n \tfor (i = 0; i < N; i++) {\n-\t\tcheck(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));\n+\t\tcl_assert(!reftable_record_init(&recs[i],\n+\t\t\t\t\t\tREFTABLE_BLOCK_TYPE_REF));\n \t\trecs[i].u.ref.refname = (char *) \"refs/heads/master\";\n \t}\n \n@@ -96,28 +99,29 @@ static void t_pq_index(void)\n \t\tstruct pq_entry top = merged_iter_pqueue_top(pq);\n \t\tstruct pq_entry e;\n \n-\t\tcheck(!merged_iter_pqueue_remove(&pq, &e));\n+\t\tcl_assert_equal_i(merged_iter_pqueue_remove(&pq, &e), 0);\n \t\tmerged_iter_pqueue_check(&pq);\n \n-\t\tcheck(pq_entry_equal(&top, &e));\n-\t\tcheck(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);\n-\t\tcheck_int(e.index, ==, i);\n+\t\tcl_assert(pq_entry_equal(&top, &e));\n+\t\tcl_assert(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);\n+\t\tcl_assert_equal_i(e.index, i);\n \t\tif (last)\n-\t\t\tcheck_str(last, e.rec->u.ref.refname);\n+\t\t\tcl_assert_equal_s(last, e.rec->u.ref.refname);\n \t\tlast = e.rec->u.ref.refname;\n \t}\n \n \tmerged_iter_pqueue_release(&pq);\n }\n \n-static void t_merged_iter_pqueue_top(void)\n+void test_reftable_pq__merged_iter_pqueue_top(void)\n {\n \tstruct merged_iter_pqueue pq = { 0 };\n \tstruct reftable_record recs[13];\n \tsize_t N = ARRAY_SIZE(recs), i;\n \n \tfor (i = 0; i < N; i++) {\n-\t\tcheck(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));\n+\t\tcl_assert(!reftable_record_init(&recs[i],\n+\t\t\t\t\t\tREFTABLE_BLOCK_TYPE_REF));\n \t\trecs[i].u.ref.refname = (char *) \"refs/heads/master\";\n \t}\n \n@@ -137,25 +141,16 @@ static void t_merged_iter_pqueue_top(void)\n \t\tstruct pq_entry top = merged_iter_pqueue_top(pq);\n \t\tstruct pq_entry e;\n \n-\t\tcheck(!merged_iter_pqueue_remove(&pq, &e));\n+\t\tcl_assert_equal_i(merged_iter_pqueue_remove(&pq, &e), 0);\n \n \t\tmerged_iter_pqueue_check(&pq);\n-\t\tcheck(pq_entry_equal(&top, &e));\n-\t\tcheck(reftable_record_equal(top.rec, &recs[i], REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(pq_entry_equal(&top, &e) != 0);\n+\t\tcl_assert(reftable_record_equal(top.rec, &recs[i], REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\tfor (size_t j = 0; i < pq.len; j++) {\n-\t\t\tcheck(pq_less(&top, &pq.heap[j]));\n-\t\t\tcheck_int(top.index, >, j);\n+\t\t\tcl_assert(pq_less(&top, &pq.heap[j]) != 0);\n+\t\t\tcl_assert(top.index > j);\n \t\t}\n \t}\n \n \tmerged_iter_pqueue_release(&pq);\n }\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_pq_record(), \"pq works with record-based comparison\");\n-\tTEST(t_pq_index(), \"pq works with index-based comparison\");\n-\tTEST(t_merged_iter_pqueue_top(), \"merged_iter_pqueue_top works\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"519778","messageId":"20250605140644.239199-7-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250605140644.239199-1-kuforiji98@gmail.com","subject":"[PATCH v4 06/10] t/unit-tests: convert reftable table test to use clar","fromName":"Seyi Kuforiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-06-05T14:06:40Z","receivedAt":"2025-06-05T14:08:20Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"Adapt reftable table test file to use clar by using clar assertions\nwhere necessary.\n\nSigned-off-by: Seyi Kuforiji \n---\n Makefile | 4 +-\n t/meson.build | 5 +-\n ...{t-reftable-table.c => u-reftable-table.c} | 75 +++++++++----------\n 3 files changed, 39 insertions(+), 45 deletions(-)\n rename t/unit-tests/{t-reftable-table.c => u-reftable-table.c} (75%)\n\ndiff --git a/Makefile b/Makefile\nindex 3cccc73073..0227fdb3e1 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1368,6 +1368,7 @@ CLAR_TEST_SUITES += u-reftable-basics\n CLAR_TEST_SUITES += u-reftable-block\n CLAR_TEST_SUITES += u-reftable-merged\n CLAR_TEST_SUITES += u-reftable-pq\n+CLAR_TEST_SUITES += u-reftable-table\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n CLAR_TEST_SUITES += u-strcmp-offset\n@@ -1384,7 +1385,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n UNIT_TEST_PROGRAMS += t-reftable-readwrite\n UNIT_TEST_PROGRAMS += t-reftable-record\n UNIT_TEST_PROGRAMS += t-reftable-stack\n-UNIT_TEST_PROGRAMS += t-reftable-table\n UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o\n@@ -3972,4 +3972,4 @@ $(LIBGIT_HIDDEN_EXPORT): $(LIBGIT_PARTIAL_EXPORT)\n \t$(OBJCOPY) --localize-hidden $^ $@\n \n contrib/libgit-sys/libgitpub.a: $(LIBGIT_HIDDEN_EXPORT)\n-\t$(AR) $(ARFLAGS) $@ $^\n+\t$(AR) $(ARFLAGS) $@ $^\n\\ No newline at end of file\ndiff --git a/t/meson.build b/t/meson.build\nindex ac4394b7a2..46d3a8580b 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -12,6 +12,7 @@ clar_test_suites = [\n 'unit-tests/u-reftable-block.c',\n 'unit-tests/u-reftable-merged.c',\n 'unit-tests/u-reftable-pq.c',\n+ 'unit-tests/u-reftable-table.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n 'unit-tests/u-strcmp-offset.c',\n@@ -59,11 +60,9 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-reader.c',\n 'unit-tests/t-reftable-readwrite.c',\n 'unit-tests/t-reftable-record.c',\n 'unit-tests/t-reftable-stack.c',\n- 'unit-tests/t-reftable-table.c',\n ]\n \n foreach unit_test_program : unit_test_programs\n@@ -1233,4 +1232,4 @@ if perl.found() and time.found()\n timeout: 0,\n )\n endforeach\n-endif\n+endif\n\\ No newline at end of file\ndiff --git a/t/unit-tests/t-reftable-table.c b/t/unit-tests/u-reftable-table.c\nsimilarity index 75%\nrename from t/unit-tests/t-reftable-table.c\nrename to t/unit-tests/u-reftable-table.c\nindex 7e1eb533d0..839107d8a4 100644\n--- a/t/unit-tests/t-reftable-table.c\n+++ b/t/unit-tests/u-reftable-table.c\n@@ -1,12 +1,12 @@\n-#include \"test-lib.h\"\n-#include \"lib-reftable.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/iter.h\"\n #include \"reftable/table.h\"\n #include \"strbuf.h\"\n \n-static int t_table_seek_once(void)\n+void test_reftable_table__seek_once(void)\n {\n \tstruct reftable_ref_record records[] = {\n \t\t{\n@@ -22,32 +22,32 @@ static int t_table_seek_once(void)\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tint ret;\n \n-\tt_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);\n+\tcl_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);\n \tblock_source_from_buf(&source, &buf);\n \n \tret = reftable_table_new(&table, &source, \"name\");\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \treftable_table_init_ref_iterator(table, &it);\n \tret = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \tret = reftable_iterator_next_ref(&it, &ref);\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n-\tret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1);\n-\tcheck_int(ret, ==, 1);\n+\tret = reftable_ref_record_equal(&ref, &records[0],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1);\n+\tcl_assert_equal_i(ret, 1);\n \n \tret = reftable_iterator_next_ref(&it, &ref);\n-\tcheck_int(ret, ==, 1);\n+\tcl_assert_equal_i(ret, 1);\n \n \treftable_ref_record_release(&ref);\n \treftable_iterator_destroy(&it);\n \treftable_table_decref(table);\n \treftable_buf_release(&buf);\n-\treturn 0;\n }\n \n-static int t_table_reseek(void)\n+void test_reftable_table__reseek(void)\n {\n \tstruct reftable_ref_record records[] = {\n \t\t{\n@@ -63,35 +63,35 @@ static int t_table_reseek(void)\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tint ret;\n \n-\tt_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);\n+\tcl_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records),\n+\t\t\t\t NULL, 0, NULL);\n \tblock_source_from_buf(&source, &buf);\n \n \tret = reftable_table_new(&table, &source, \"name\");\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \treftable_table_init_ref_iterator(table, &it);\n \n \tfor (size_t i = 0; i < 5; i++) {\n \t\tret = reftable_iterator_seek_ref(&it, \"\");\n-\t\tcheck(!ret);\n+\t\tcl_assert(!ret);\n \t\tret = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck(!ret);\n+\t\tcl_assert(!ret);\n \n \t\tret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck_int(ret, ==, 1);\n+\t\tcl_assert_equal_i(ret, 1);\n \n \t\tret = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck_int(ret, ==, 1);\n+\t\tcl_assert_equal_i(ret, 1);\n \t}\n \n \treftable_ref_record_release(&ref);\n \treftable_iterator_destroy(&it);\n \treftable_table_decref(table);\n \treftable_buf_release(&buf);\n-\treturn 0;\n }\n \n-static int t_table_block_iterator(void)\n+void test_reftable_table__block_iterator(void)\n {\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_table_iterator it = { 0 };\n@@ -147,14 +147,14 @@ static int t_table_block_iterator(void)\n \t\t\t\t\t (uintmax_t) i);\n \t}\n \n-\tt_reftable_write_to_buf(&buf, records, nrecords, NULL, 0, NULL);\n+\tcl_reftable_write_to_buf(&buf, records, nrecords, NULL, 0, NULL);\n \tblock_source_from_buf(&source, &buf);\n \n \tret = reftable_table_new(&table, &source, \"name\");\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \tret = reftable_table_iterator_init(&it, table);\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(expected_blocks); i++) {\n \t\tstruct reftable_iterator record_it = { 0 };\n@@ -163,22 +163,26 @@ static int t_table_block_iterator(void)\n \t\t};\n \n \t\tret = reftable_table_iterator_next(&it, &block);\n-\t\tcheck(!ret);\n+\t\tcl_assert(!ret);\n \n-\t\tcheck_int(block->block_type, ==, expected_blocks[i].block_type);\n-\t\tcheck_int(block->header_off, ==, expected_blocks[i].header_off);\n-\t\tcheck_int(block->restart_count, ==, expected_blocks[i].restart_count);\n+\t\tcl_assert_equal_i(block->block_type,\n+\t\t\t\t expected_blocks[i].block_type);\n+\t\tcl_assert_equal_i(block->header_off,\n+\t\t\t\t expected_blocks[i].header_off);\n+\t\tcl_assert_equal_i(block->restart_count,\n+\t\t\t\t expected_blocks[i].restart_count);\n \n \t\tret = reftable_block_init_iterator(block, &record_it);\n-\t\tcheck(!ret);\n+\t\tcl_assert(!ret);\n \n \t\tfor (size_t j = 0; ; j++) {\n \t\t\tret = iterator_next(&record_it, &record);\n \t\t\tif (ret > 0) {\n-\t\t\t\tcheck_int(j, ==, expected_blocks[i].record_count);\n+\t\t\t\tcl_assert_equal_i(j,\n+\t\t\t\t\t\t expected_blocks[i].record_count);\n \t\t\t\tbreak;\n \t\t\t}\n-\t\t\tcheck(!ret);\n+\t\t\tcl_assert(!ret);\n \t\t}\n \n \t\treftable_iterator_destroy(&record_it);\n@@ -186,7 +190,7 @@ static int t_table_block_iterator(void)\n \t}\n \n \tret = reftable_table_iterator_next(&it, &block);\n-\tcheck_int(ret, ==, 1);\n+\tcl_assert_equal_i(ret, 1);\n \n \tfor (size_t i = 0; i < nrecords; i++)\n \t\treftable_free(records[i].refname);\n@@ -194,13 +198,4 @@ static int t_table_block_iterator(void)\n \treftable_table_decref(table);\n \treftable_buf_release(&buf);\n \treftable_free(records);\n-\treturn 0;\n-}\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_table_seek_once(), \"table can seek once\");\n-\tTEST(t_table_reseek(), \"table can reseek multiple times\");\n-\tTEST(t_table_block_iterator(), \"table can iterate through blocks\");\n-\treturn test_done();\n }\n-- \n2.43.0\n\n"},{"id":"519779","messageId":"20250605140644.239199-8-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250605140644.239199-1-kuforiji98@gmail.com","subject":"[PATCH v4 07/10] t/unit-tests: convert reftable readwrite test to use clar","fromName":"Seyi Kuforiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-06-05T14:06:41Z","receivedAt":"2025-06-05T14:08:24Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"Adapt reftable readwrite test file to use clar by using clar assertions\nwhere necessary.\n\nSigned-off-by: Seyi Kuforiji \n---\n Makefile | 2 +-\n t/meson.build | 2 +-\n ...ble-readwrite.c => u-reftable-readwrite.c} | 405 ++++++++----------\n 3 files changed, 179 insertions(+), 230 deletions(-)\n rename t/unit-tests/{t-reftable-readwrite.c => u-reftable-readwrite.c} (68%)\n\ndiff --git a/Makefile b/Makefile\nindex 0227fdb3e1..d86ef5a142 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1368,6 +1368,7 @@ CLAR_TEST_SUITES += u-reftable-basics\n CLAR_TEST_SUITES += u-reftable-block\n CLAR_TEST_SUITES += u-reftable-merged\n CLAR_TEST_SUITES += u-reftable-pq\n+CLAR_TEST_SUITES += u-reftable-readwrite\n CLAR_TEST_SUITES += u-reftable-table\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n@@ -1382,7 +1383,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-readwrite\n UNIT_TEST_PROGRAMS += t-reftable-record\n UNIT_TEST_PROGRAMS += t-reftable-stack\n UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\ndiff --git a/t/meson.build b/t/meson.build\nindex 46d3a8580b..5189176472 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -12,6 +12,7 @@ clar_test_suites = [\n 'unit-tests/u-reftable-block.c',\n 'unit-tests/u-reftable-merged.c',\n 'unit-tests/u-reftable-pq.c',\n+ 'unit-tests/u-reftable-readwrite.c',\n 'unit-tests/u-reftable-table.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n@@ -60,7 +61,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-readwrite.c',\n 'unit-tests/t-reftable-record.c',\n 'unit-tests/t-reftable-stack.c',\n ]\ndiff --git a/t/unit-tests/t-reftable-readwrite.c b/t/unit-tests/u-reftable-readwrite.c\nsimilarity index 68%\nrename from t/unit-tests/t-reftable-readwrite.c\nrename to t/unit-tests/u-reftable-readwrite.c\nindex 4c49129439..9aac74a011 100644\n--- a/t/unit-tests/t-reftable-readwrite.c\n+++ b/t/unit-tests/u-reftable-readwrite.c\n@@ -8,8 +8,8 @@ license that can be found in the LICENSE file or at\n \n #define DISABLE_SIGN_COMPARE_WARNINGS\n \n-#include \"test-lib.h\"\n-#include \"lib-reftable.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/basics.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/reftable-error.h\"\n@@ -19,24 +19,24 @@ license that can be found in the LICENSE file or at\n \n static const int update_index = 5;\n \n-static void t_buffer(void)\n+void test_reftable_readwrite__buffer(void)\n {\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_block_data out = { 0 };\n \tint n;\n \tuint8_t in[] = \"hello\";\n-\tcheck(!reftable_buf_add(&buf, in, sizeof(in)));\n+\tcl_assert_equal_i(reftable_buf_add(&buf, in, sizeof(in)), 0);\n \tblock_source_from_buf(&source, &buf);\n-\tcheck_int(block_source_size(&source), ==, 6);\n+\tcl_assert_equal_i(block_source_size(&source), 6);\n \tn = block_source_read_data(&source, &out, 0, sizeof(in));\n-\tcheck_int(n, ==, sizeof(in));\n-\tcheck(!memcmp(in, out.data, n));\n+\tcl_assert_equal_i(n, sizeof(in));\n+\tcl_assert(!memcmp(in, out.data, n));\n \tblock_source_release_data(&out);\n \n \tn = block_source_read_data(&source, &out, 1, 2);\n-\tcheck_int(n, ==, 2);\n-\tcheck(!memcmp(out.data, \"el\", 2));\n+\tcl_assert_equal_i(n, 2);\n+\tcl_assert(!memcmp(out.data, \"el\", 2));\n \n \tblock_source_release_data(&out);\n \tblock_source_close(&source);\n@@ -55,41 +55,41 @@ static void write_table(char ***names, struct reftable_buf *buf, int N,\n \tint i;\n \n \tREFTABLE_CALLOC_ARRAY(*names, N + 1);\n-\tcheck(*names != NULL);\n+\tcl_assert(*names != NULL);\n \tREFTABLE_CALLOC_ARRAY(refs, N);\n-\tcheck(refs != NULL);\n+\tcl_assert(refs != NULL);\n \tREFTABLE_CALLOC_ARRAY(logs, N);\n-\tcheck(logs != NULL);\n+\tcl_assert(logs != NULL);\n \n \tfor (i = 0; i < N; i++) {\n \t\trefs[i].refname = (*names)[i] = xstrfmt(\"refs/heads/branch%02d\", i);\n \t\trefs[i].update_index = update_index;\n \t\trefs[i].value_type = REFTABLE_REF_VAL1;\n-\t\tt_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n \t\tlogs[i].refname = (*names)[i];\n \t\tlogs[i].update_index = update_index;\n \t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n-\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t\tlogs[i].value.update.message = (char *) \"message\";\n \t}\n \n-\tt_reftable_write_to_buf(buf, refs, N, logs, N, &opts);\n+\tcl_reftable_write_to_buf(buf, refs, N, logs, N, &opts);\n \n \treftable_free(refs);\n \treftable_free(logs);\n }\n \n-static void t_log_buffer_size(void)\n+void test_reftable_readwrite__log_buffer_size(void)\n {\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 4096,\n \t};\n-\tint err;\n \tint i;\n \tstruct reftable_log_record\n \t\tlog = { .refname = (char *) \"refs/heads/master\",\n@@ -102,7 +102,8 @@ static void t_log_buffer_size(void)\n \t\t\t\t\t .time = 0x5e430672,\n \t\t\t\t\t .message = (char *) \"commit: 9\\n\",\n \t\t\t\t } } };\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \n \t/* This tests buffer extension for log compression. Must use a random\n \t hash, to ensure that the compressed part is larger than the original.\n@@ -112,22 +113,19 @@ static void t_log_buffer_size(void)\n \t\tlog.value.update.new_hash[i] = (uint8_t)(git_rand(0) % 256);\n \t}\n \treftable_writer_set_limits(w, update_index, update_index);\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck(!err);\n-\terr = reftable_writer_close(w);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_log_overflow(void)\n+void test_reftable_readwrite__log_overflow(void)\n {\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tchar msg[256] = { 0 };\n \tstruct reftable_write_options opts = {\n \t\t.block_size = ARRAY_SIZE(msg),\n \t};\n-\tint err;\n \tstruct reftable_log_record log = {\n \t\t.refname = (char *) \"refs/heads/master\",\n \t\t.update_index = update_index,\n@@ -144,21 +142,22 @@ static void t_log_overflow(void)\n \t\t\t},\n \t\t},\n \t};\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \n \tmemset(msg, 'x', sizeof(msg) - 1);\n \treftable_writer_set_limits(w, update_index, update_index);\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck_int(err, ==, REFTABLE_ENTRY_TOO_BIG_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), REFTABLE_ENTRY_TOO_BIG_ERROR);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_log_write_limits(void)\n+void test_reftable_readwrite__log_write_limits(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \tstruct reftable_log_record log = {\n \t\t.refname = (char *)\"refs/head/master\",\n \t\t.update_index = 0,\n@@ -174,29 +173,25 @@ static void t_log_write_limits(void)\n \t\t\t},\n \t\t},\n \t};\n-\tint err;\n \n \treftable_writer_set_limits(w, 1, 1);\n \n \t/* write with update_index (0) below set limits (1, 1) */\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck_int(err, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n \n \t/* write with update_index (1) in the set limits (1, 1) */\n \tlog.update_index = 1;\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck_int(err, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n \n \t/* write with update_index (3) above set limits (1, 1) */\n \tlog.update_index = 3;\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), REFTABLE_API_ERROR);\n \n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_log_write_read(void)\n+void test_reftable_readwrite__log_write_read(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 256,\n@@ -207,13 +202,14 @@ static void t_log_write_read(void)\n \tstruct reftable_table *table;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tconst struct reftable_stats *stats = NULL;\n-\tint N = 2, err, i, n;\n+\tint N = 2, i;\n \tchar **names;\n+\tint err;\n \n \tnames = reftable_calloc(N + 1, sizeof(*names));\n-\tcheck(names != NULL);\n+\tcl_assert(names != NULL);\n \n \treftable_writer_set_limits(w, 0, N);\n \n@@ -225,8 +221,7 @@ static void t_log_write_read(void)\n \t\tref.refname = name;\n \t\tref.update_index = i;\n \n-\t\terr = reftable_writer_add_ref(w, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n@@ -235,60 +230,57 @@ static void t_log_write_read(void)\n \t\tlog.refname = names[i];\n \t\tlog.update_index = i;\n \t\tlog.value_type = REFTABLE_LOG_UPDATE;\n-\t\tt_reftable_set_hash(log.value.update.old_hash, i,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n-\t\tt_reftable_set_hash(log.value.update.new_hash, i + 1,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(log.value.update.old_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(log.value.update.new_hash, i + 1,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \n-\t\terr = reftable_writer_add_log(w, &log);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n \t}\n \n-\tn = reftable_writer_close(w);\n-\tcheck_int(n, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \n \tstats = reftable_writer_stats(w);\n-\tcheck_int(stats->log_stats.blocks, >, 0);\n+\tcl_assert(stats->log_stats.blocks > 0);\n \treftable_writer_free(w);\n \tw = NULL;\n \n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.log\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_iterator_seek_ref(&it, names[N - 1]);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_iterator_next_ref(&it, &ref);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \t/* end of iteration. */\n-\terr = reftable_iterator_next_ref(&it, &ref);\n-\tcheck_int(err, >, 0);\n+\tcl_assert(reftable_iterator_next_ref(&it, &ref) > 0);\n \n \treftable_iterator_destroy(&it);\n \treftable_ref_record_release(&ref);\n \n \terr = reftable_table_init_log_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_log(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (i = 0; ; i++) {\n \t\tint err = reftable_iterator_next_log(&it, &log);\n \t\tif (err > 0)\n \t\t\tbreak;\n-\t\tcheck(!err);\n-\t\tcheck_str(names[i], log.refname);\n-\t\tcheck_int(i, ==, log.update_index);\n+\t\tcl_assert(!err);\n+\t\tcl_assert_equal_s(names[i], log.refname);\n+\t\tcl_assert_equal_i(i, log.update_index);\n \t\treftable_log_record_release(&log);\n \t}\n \n-\tcheck_int(i, ==, N);\n+\tcl_assert_equal_i(i, N);\n \treftable_iterator_destroy(&it);\n \n \t/* cleanup. */\n@@ -297,7 +289,7 @@ static void t_log_write_read(void)\n \treftable_table_decref(table);\n }\n \n-static void t_log_zlib_corruption(void)\n+void test_reftable_readwrite__log_zlib_corruption(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 256,\n@@ -306,10 +298,12 @@ static void t_log_zlib_corruption(void)\n \tstruct reftable_table *table;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \tconst struct reftable_stats *stats = NULL;\n \tchar message[100] = { 0 };\n-\tint err, i, n;\n+\tint i;\n+\tint err;\n \tstruct reftable_log_record log = {\n \t\t.refname = (char *) \"refname\",\n \t\t.value_type = REFTABLE_LOG_UPDATE,\n@@ -329,14 +323,11 @@ static void t_log_zlib_corruption(void)\n \n \treftable_writer_set_limits(w, 1, 1);\n \n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck(!err);\n-\n-\tn = reftable_writer_close(w);\n-\tcheck_int(n, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \n \tstats = reftable_writer_stats(w);\n-\tcheck_int(stats->log_stats.blocks, >, 0);\n+\tcl_assert(stats->log_stats.blocks > 0);\n \treftable_writer_free(w);\n \tw = NULL;\n \n@@ -346,12 +337,12 @@ static void t_log_zlib_corruption(void)\n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.log\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_log_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_log(&it, \"refname\");\n-\tcheck_int(err, ==, REFTABLE_ZLIB_ERROR);\n+\tcl_assert_equal_i(err, REFTABLE_ZLIB_ERROR);\n \n \treftable_iterator_destroy(&it);\n \n@@ -360,7 +351,7 @@ static void t_log_zlib_corruption(void)\n \treftable_buf_release(&buf);\n }\n \n-static void t_table_read_write_sequential(void)\n+void test_reftable_readwrite__table_read_write_sequential(void)\n {\n \tchar **names;\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n@@ -376,24 +367,24 @@ static void t_table_read_write_sequential(void)\n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.ref\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (j = 0; ; j++) {\n \t\tstruct reftable_ref_record ref = { 0 };\n \t\tint r = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck_int(r, >=, 0);\n+\t\tcl_assert(r >= 0);\n \t\tif (r > 0)\n \t\t\tbreak;\n-\t\tcheck_str(names[j], ref.refname);\n-\t\tcheck_int(update_index, ==, ref.update_index);\n+\t\tcl_assert_equal_s(names[j], ref.refname);\n+\t\tcl_assert_equal_i(update_index, ref.update_index);\n \t\treftable_ref_record_release(&ref);\n \t}\n-\tcheck_int(j, ==, N);\n+\tcl_assert_equal_i(j, N);\n \n \treftable_iterator_destroy(&it);\n \treftable_table_decref(table);\n@@ -401,42 +392,42 @@ static void t_table_read_write_sequential(void)\n \tfree_names(names);\n }\n \n-static void t_table_write_small_table(void)\n+void test_reftable_readwrite__table_write_small_table(void)\n {\n \tchar **names;\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tint N = 1;\n \twrite_table(&names, &buf, N, 4096, REFTABLE_HASH_SHA1);\n-\tcheck_int(buf.len, <, 200);\n+\tcl_assert(buf.len < 200);\n \treftable_buf_release(&buf);\n \tfree_names(names);\n }\n \n-static void t_table_read_api(void)\n+void test_reftable_readwrite__table_read_api(void)\n {\n \tchar **names;\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tint N = 50;\n \tstruct reftable_table *table;\n \tstruct reftable_block_source source = { 0 };\n-\tint err;\n \tstruct reftable_log_record log = { 0 };\n \tstruct reftable_iterator it = { 0 };\n+\tint err;\n \n \twrite_table(&names, &buf, N, 256, REFTABLE_HASH_SHA1);\n \n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.ref\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, names[0]);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_iterator_next_log(&it, &log);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(err, REFTABLE_API_ERROR);\n \n \treftable_buf_release(&buf);\n \tfree_names(names);\n@@ -464,42 +455,43 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)\n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.ref\");\n-\tcheck(!err);\n-\tcheck_int(hash_id, ==, reftable_table_hash_id(table));\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(hash_id, reftable_table_hash_id(table));\n \n \tif (!index) {\n \t\ttable->ref_offsets.index_offset = 0;\n \t} else {\n-\t\tcheck_int(table->ref_offsets.index_offset, >, 0);\n+\t\tcl_assert(table->ref_offsets.index_offset > 0);\n \t}\n \n \tfor (i = 1; i < N; i++) {\n \t\terr = reftable_table_init_ref_iterator(table, &it);\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \t\terr = reftable_iterator_seek_ref(&it, names[i]);\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \t\terr = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck(!err);\n-\t\tcheck_str(names[i], ref.refname);\n-\t\tcheck_int(REFTABLE_REF_VAL1, ==, ref.value_type);\n-\t\tcheck_int(i, ==, ref.value.val1[0]);\n+\t\tcl_assert(!err);\n+\t\tcl_assert_equal_s(names[i], ref.refname);\n+\t\tcl_assert_equal_i(REFTABLE_REF_VAL1, ref.value_type);\n+\t\tcl_assert_equal_i(i, ref.value.val1[0]);\n \n \t\treftable_ref_record_release(&ref);\n \t\treftable_iterator_destroy(&it);\n \t}\n \n-\tcheck(!reftable_buf_addstr(&pastLast, names[N - 1]));\n-\tcheck(!reftable_buf_addstr(&pastLast, \"/\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&pastLast, names[N - 1]),\n+\t\t\t\t\t 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&pastLast, \"/\"), 0);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, pastLast.buf);\n \tif (err == 0) {\n \t\tstruct reftable_ref_record ref = { 0 };\n \t\tint err = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck_int(err, >, 0);\n+\t\tcl_assert(err > 0);\n \t} else {\n-\t\tcheck_int(err, >, 0);\n+\t\tcl_assert(err > 0);\n \t}\n \n \treftable_buf_release(&pastLast);\n@@ -510,17 +502,17 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)\n \treftable_table_decref(table);\n }\n \n-static void t_table_read_write_seek_linear(void)\n+void test_reftable_readwrite__table_read_write_seek_linear(void)\n {\n \tt_table_read_write_seek(0, REFTABLE_HASH_SHA1);\n }\n \n-static void t_table_read_write_seek_linear_sha256(void)\n+void test_reftable_readwrite__table_read_write_seek_linear_sha256(void)\n {\n \tt_table_read_write_seek(0, REFTABLE_HASH_SHA256);\n }\n \n-static void t_table_read_write_seek_index(void)\n+void test_reftable_readwrite__table_read_write_seek_index(void)\n {\n \tt_table_read_write_seek(1, REFTABLE_HASH_SHA1);\n }\n@@ -538,14 +530,16 @@ static void t_table_refs_for(int indexed)\n \tstruct reftable_table *table;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \tstruct reftable_iterator it = { 0 };\n-\tint N = 50, n, j, err, i;\n+\tint N = 50, j, i;\n+\tint err;\n \n \twant_names = reftable_calloc(N + 1, sizeof(*want_names));\n-\tcheck(want_names != NULL);\n+\tcl_assert(want_names != NULL);\n \n-\tt_reftable_set_hash(want_hash, 4, REFTABLE_HASH_SHA1);\n+\tcl_reftable_set_hash(want_hash, 4, REFTABLE_HASH_SHA1);\n \n \tfor (i = 0; i < N; i++) {\n \t\tuint8_t hash[REFTABLE_HASH_SIZE_SHA1];\n@@ -561,24 +555,22 @@ static void t_table_refs_for(int indexed)\n \t\tref.refname = name;\n \n \t\tref.value_type = REFTABLE_REF_VAL2;\n-\t\tt_reftable_set_hash(ref.value.val2.value, i / 4,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n-\t\tt_reftable_set_hash(ref.value.val2.target_value, 3 + i / 4,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(ref.value.val2.value, i / 4,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(ref.value.val2.target_value,\n+\t\t\t\t 3 + i / 4, REFTABLE_HASH_SHA1);\n \n \t\t/* 80 bytes / entry, so 3 entries per block. Yields 17\n \t\t */\n \t\t/* blocks. */\n-\t\tn = reftable_writer_add_ref(w, &ref);\n-\t\tcheck_int(n, ==, 0);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);\n \n \t\tif (!memcmp(ref.value.val2.value, want_hash, REFTABLE_HASH_SIZE_SHA1) ||\n \t\t !memcmp(ref.value.val2.target_value, want_hash, REFTABLE_HASH_SIZE_SHA1))\n \t\t\twant_names[want_names_len++] = xstrdup(name);\n \t}\n \n-\tn = reftable_writer_close(w);\n-\tcheck_int(n, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \n \treftable_writer_free(w);\n \tw = NULL;\n@@ -586,29 +578,29 @@ static void t_table_refs_for(int indexed)\n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.ref\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \tif (!indexed)\n \t\ttable->obj_offsets.is_present = 0;\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \treftable_iterator_destroy(&it);\n \n \terr = reftable_table_refs_for(table, &it, want_hash);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (j = 0; ; j++) {\n \t\tint err = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck_int(err, >=, 0);\n+\t\tcl_assert(err >= 0);\n \t\tif (err > 0)\n \t\t\tbreak;\n-\t\tcheck_int(j, <, want_names_len);\n-\t\tcheck_str(ref.refname, want_names[j]);\n+\t\tcl_assert(j < want_names_len);\n+\t\tcl_assert_equal_s(ref.refname, want_names[j]);\n \t\treftable_ref_record_release(&ref);\n \t}\n-\tcheck_int(j, ==, want_names_len);\n+\tcl_assert_equal_i(j, want_names_len);\n \n \treftable_buf_release(&buf);\n \tfree_names(want_names);\n@@ -616,21 +608,21 @@ static void t_table_refs_for(int indexed)\n \treftable_table_decref(table);\n }\n \n-static void t_table_refs_for_no_index(void)\n+void test_reftable_readwrite__table_refs_for_no_index(void)\n {\n \tt_table_refs_for(0);\n }\n \n-static void t_table_refs_for_obj_index(void)\n+void test_reftable_readwrite__table_refs_for_obj_index(void)\n {\n \tt_table_refs_for(1);\n }\n \n-static void t_write_empty_table(void)\n+void test_reftable_readwrite__write_empty_table(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_table *table = NULL;\n \tstruct reftable_ref_record rec = { 0 };\n@@ -639,43 +631,41 @@ static void t_write_empty_table(void)\n \n \treftable_writer_set_limits(w, 1, 1);\n \n-\terr = reftable_writer_close(w);\n-\tcheck_int(err, ==, REFTABLE_EMPTY_TABLE_ERROR);\n+\tcl_assert_equal_i(reftable_writer_close(w), REFTABLE_EMPTY_TABLE_ERROR);\n \treftable_writer_free(w);\n \n-\tcheck_uint(buf.len, ==, header_size(1) + footer_size(1));\n+\tcl_assert_equal_i(buf.len, header_size(1) + footer_size(1));\n \n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"filename\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck_int(err, >, 0);\n+\tcl_assert(err > 0);\n \n \treftable_iterator_destroy(&it);\n \treftable_table_decref(table);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_object_id_min_length(void)\n+void test_reftable_readwrite__write_object_id_min_length(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 75,\n \t};\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_ref_record ref = {\n \t\t.update_index = 1,\n \t\t.value_type = REFTABLE_REF_VAL1,\n \t\t.value.val1 = {42},\n \t};\n-\tint err;\n \tint i;\n \n \treftable_writer_set_limits(w, 1, 1);\n@@ -686,30 +676,27 @@ static void t_write_object_id_min_length(void)\n \t\tchar name[256];\n \t\tsnprintf(name, sizeof(name), \"ref%05d\", i);\n \t\tref.refname = name;\n-\t\terr = reftable_writer_add_ref(w, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);\n \t}\n \n-\terr = reftable_writer_close(w);\n-\tcheck(!err);\n-\tcheck_int(reftable_writer_stats(w)->object_id_len, ==, 2);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n+\tcl_assert_equal_i(reftable_writer_stats(w)->object_id_len, 2);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_object_id_length(void)\n+void test_reftable_readwrite__write_object_id_length(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 75,\n \t};\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_ref_record ref = {\n \t\t.update_index = 1,\n \t\t.value_type = REFTABLE_REF_VAL1,\n \t\t.value.val1 = {42},\n \t};\n-\tint err;\n \tint i;\n \n \treftable_writer_set_limits(w, 1, 1);\n@@ -721,44 +708,39 @@ static void t_write_object_id_length(void)\n \t\tsnprintf(name, sizeof(name), \"ref%05d\", i);\n \t\tref.refname = name;\n \t\tref.value.val1[15] = i;\n-\t\terr = reftable_writer_add_ref(w, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert(reftable_writer_add_ref(w, &ref) == 0);\n \t}\n \n-\terr = reftable_writer_close(w);\n-\tcheck(!err);\n-\tcheck_int(reftable_writer_stats(w)->object_id_len, ==, 16);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n+\tcl_assert_equal_i(reftable_writer_stats(w)->object_id_len, 16);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_empty_key(void)\n+void test_reftable_readwrite__write_empty_key(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"\",\n \t\t.update_index = 1,\n \t\t.value_type = REFTABLE_REF_DELETION,\n \t};\n-\tint err;\n \n \treftable_writer_set_limits(w, 1, 1);\n-\terr = reftable_writer_add_ref(w, &ref);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n-\n-\terr = reftable_writer_close(w);\n-\tcheck_int(err, ==, REFTABLE_EMPTY_TABLE_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_writer_close(w),\n+\t\t\t REFTABLE_EMPTY_TABLE_ERROR);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_key_order(void)\n+void test_reftable_readwrite__write_key_order(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_ref_record refs[2] = {\n \t\t{\n \t\t\t.refname = (char *) \"b\",\n@@ -776,24 +758,21 @@ static void t_write_key_order(void)\n \t\t\t},\n \t\t}\n \t};\n-\tint err;\n \n \treftable_writer_set_limits(w, 1, 1);\n-\terr = reftable_writer_add_ref(w, &refs[0]);\n-\tcheck(!err);\n-\terr = reftable_writer_add_ref(w, &refs[1]);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_ref(w, &refs[0]), 0);\n+\tcl_assert_equal_i(reftable_writer_add_ref(w, &refs[1]),\n+\t\t\t REFTABLE_API_ERROR);\n \n \trefs[0].update_index = 2;\n-\terr = reftable_writer_add_ref(w, &refs[0]);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_ref(w, &refs[0]), REFTABLE_API_ERROR);\n \n \treftable_writer_close(w);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_multiple_indices(void)\n+void test_reftable_readwrite__write_multiple_indices(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 100,\n@@ -805,9 +784,10 @@ static void t_write_multiple_indices(void)\n \tstruct reftable_writer *writer;\n \tstruct reftable_table *table;\n \tchar buf[128];\n-\tint err, i;\n+\tint i;\n+\tint err;\n \n-\twriter = t_reftable_strbuf_writer(&writer_buf, &opts);\n+\twriter = cl_reftable_strbuf_writer(&writer_buf, &opts);\n \treftable_writer_set_limits(writer, 1, 1);\n \tfor (i = 0; i < 100; i++) {\n \t\tstruct reftable_ref_record ref = {\n@@ -819,8 +799,7 @@ static void t_write_multiple_indices(void)\n \t\tsnprintf(buf, sizeof(buf), \"refs/heads/%04d\", i);\n \t\tref.refname = buf;\n \n-\t\terr = reftable_writer_add_ref(writer, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(writer, &ref), 0);\n \t}\n \n \tfor (i = 0; i < 100; i++) {\n@@ -836,8 +815,7 @@ static void t_write_multiple_indices(void)\n \t\tsnprintf(buf, sizeof(buf), \"refs/heads/%04d\", i);\n \t\tlog.refname = buf;\n \n-\t\terr = reftable_writer_add_log(writer, &log);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_log(writer, &log), 0);\n \t}\n \n \treftable_writer_close(writer);\n@@ -847,22 +825,22 @@ static void t_write_multiple_indices(void)\n \t * for each of the block types.\n \t */\n \tstats = reftable_writer_stats(writer);\n-\tcheck_int(stats->ref_stats.index_offset, >, 0);\n-\tcheck_int(stats->obj_stats.index_offset, >, 0);\n-\tcheck_int(stats->log_stats.index_offset, >, 0);\n+\tcl_assert(stats->ref_stats.index_offset > 0);\n+\tcl_assert(stats->obj_stats.index_offset > 0);\n+\tcl_assert(stats->log_stats.index_offset > 0);\n \n \tblock_source_from_buf(&source, &writer_buf);\n \terr = reftable_table_new(&table, &source, \"filename\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \t/*\n \t * Seeking the log uses the log index now. In case there is any\n \t * confusion regarding indices we would notice here.\n \t */\n \terr = reftable_table_init_log_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_log(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \treftable_iterator_destroy(&it);\n \treftable_writer_free(writer);\n@@ -870,7 +848,7 @@ static void t_write_multiple_indices(void)\n \treftable_buf_release(&writer_buf);\n }\n \n-static void t_write_multi_level_index(void)\n+void test_reftable_readwrite__write_multi_level_index(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 100,\n@@ -883,7 +861,7 @@ static void t_write_multi_level_index(void)\n \tstruct reftable_table *table;\n \tint err;\n \n-\twriter = t_reftable_strbuf_writer(&writer_buf, &opts);\n+\twriter = cl_reftable_strbuf_writer(&writer_buf, &opts);\n \treftable_writer_set_limits(writer, 1, 1);\n \tfor (size_t i = 0; i < 200; i++) {\n \t\tstruct reftable_ref_record ref = {\n@@ -896,8 +874,7 @@ static void t_write_multi_level_index(void)\n \t\tsnprintf(buf, sizeof(buf), \"refs/heads/%03\" PRIuMAX, (uintmax_t)i);\n \t\tref.refname = buf;\n \n-\t\terr = reftable_writer_add_ref(writer, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(writer, &ref), 0);\n \t}\n \treftable_writer_close(writer);\n \n@@ -906,19 +883,19 @@ static void t_write_multi_level_index(void)\n \t * multi-level index.\n \t */\n \tstats = reftable_writer_stats(writer);\n-\tcheck_int(stats->ref_stats.max_index_level, ==, 2);\n+\tcl_assert_equal_i(stats->ref_stats.max_index_level, 2);\n \n \tblock_source_from_buf(&source, &writer_buf);\n \terr = reftable_table_new(&table, &source, \"filename\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \t/*\n \t * Seeking the last ref should work as expected.\n \t */\n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"refs/heads/199\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \treftable_iterator_destroy(&it);\n \treftable_writer_free(writer);\n@@ -927,7 +904,7 @@ static void t_write_multi_level_index(void)\n \treftable_buf_release(&buf);\n }\n \n-static void t_corrupt_table_empty(void)\n+void test_reftable_readwrite__corrupt_table_empty(void)\n {\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tstruct reftable_block_source source = { 0 };\n@@ -936,50 +913,22 @@ static void t_corrupt_table_empty(void)\n \n \tblock_source_from_buf(&source, &buf);\n \terr = reftable_table_new(&table, &source, \"file.log\");\n-\tcheck_int(err, ==, REFTABLE_FORMAT_ERROR);\n+\tcl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);\n }\n \n-static void t_corrupt_table(void)\n+void test_reftable_readwrite__corrupt_table(void)\n {\n \tuint8_t zeros[1024] = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_table *table;\n \tint err;\n-\tcheck(!reftable_buf_add(&buf, zeros, sizeof(zeros)));\n+\n+\tcl_assert(!reftable_buf_add(&buf, zeros, sizeof(zeros)));\n \n \tblock_source_from_buf(&source, &buf);\n \terr = reftable_table_new(&table, &source, \"file.log\");\n-\tcheck_int(err, ==, REFTABLE_FORMAT_ERROR);\n+\tcl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);\n \n \treftable_buf_release(&buf);\n }\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_buffer(), \"strbuf works as blocksource\");\n-\tTEST(t_corrupt_table(), \"read-write on corrupted table\");\n-\tTEST(t_corrupt_table_empty(), \"read-write on an empty table\");\n-\tTEST(t_log_buffer_size(), \"buffer extension for log compression\");\n-\tTEST(t_log_overflow(), \"log overflow returns expected error\");\n-\tTEST(t_log_write_limits(), \"writer limits for writing log records\");\n-\tTEST(t_log_write_read(), \"read-write on log records\");\n-\tTEST(t_log_zlib_corruption(), \"reading corrupted log record returns expected error\");\n-\tTEST(t_table_read_api(), \"read on a table\");\n-\tTEST(t_table_read_write_seek_index(), \"read-write on a table with index\");\n-\tTEST(t_table_read_write_seek_linear(), \"read-write on a table without index (SHA1)\");\n-\tTEST(t_table_read_write_seek_linear_sha256(), \"read-write on a table without index (SHA256)\");\n-\tTEST(t_table_read_write_sequential(), \"sequential read-write on a table\");\n-\tTEST(t_table_refs_for_no_index(), \"refs-only table with no index\");\n-\tTEST(t_table_refs_for_obj_index(), \"refs-only table with index\");\n-\tTEST(t_table_write_small_table(), \"write_table works\");\n-\tTEST(t_write_empty_key(), \"write on refs with empty keys\");\n-\tTEST(t_write_empty_table(), \"read-write on empty tables\");\n-\tTEST(t_write_key_order(), \"refs must be written in increasing order\");\n-\tTEST(t_write_multi_level_index(), \"table with multi-level index\");\n-\tTEST(t_write_multiple_indices(), \"table with indices for multiple block types\");\n-\tTEST(t_write_object_id_length(), \"prefix compression on writing refs\");\n-\tTEST(t_write_object_id_min_length(), \"prefix compression on writing refs\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"519780","messageId":"20250605140644.239199-9-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250605140644.239199-1-kuforiji98@gmail.com","subject":"[PATCH v4 08/10] t/unit-tests: convert reftable record test to use clar","fromName":"Seyi Kuforiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-06-05T14:06:42Z","receivedAt":"2025-06-05T14:08:35Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"Adapt reftable record test file to use clar by using clar assertions\nwhere necessary.\n\nSigned-off-by: Seyi Kuforiji \n---\n Makefile | 1 -\n t/meson.build | 1 -\n ...-reftable-record.c => u-reftable-record.c} | 250 +++++++++---------\n 3 files changed, 130 insertions(+), 122 deletions(-)\n rename t/unit-tests/{t-reftable-record.c => u-reftable-record.c} (62%)\n\ndiff --git a/Makefile b/Makefile\nindex d86ef5a142..3b41342ddb 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1383,7 +1383,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-record\n UNIT_TEST_PROGRAMS += t-reftable-stack\n UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\ndiff --git a/t/meson.build b/t/meson.build\nindex 5189176472..297937f307 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -61,7 +61,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-record.c',\n 'unit-tests/t-reftable-stack.c',\n ]\n \ndiff --git a/t/unit-tests/t-reftable-record.c b/t/unit-tests/u-reftable-record.c\nsimilarity index 62%\nrename from t/unit-tests/t-reftable-record.c\nrename to t/unit-tests/u-reftable-record.c\nindex 553a007664..650b0aa0d3 100644\n--- a/t/unit-tests/t-reftable-record.c\n+++ b/t/unit-tests/u-reftable-record.c\n@@ -6,7 +6,8 @@\n https://developers.google.com/open-source/licenses/bsd\n */\n \n-#include \"test-lib.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/basics.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/record.h\"\n@@ -17,16 +18,17 @@ static void t_copy(struct reftable_record *rec)\n \tuint8_t typ;\n \n \ttyp = reftable_record_type(rec);\n-\tcheck(!reftable_record_init(©, typ));\n+\tcl_assert_equal_i(reftable_record_init(©, typ), 0);\n \treftable_record_copy_from(©, rec, REFTABLE_HASH_SIZE_SHA1);\n \t/* do it twice to catch memory leaks */\n \treftable_record_copy_from(©, rec, REFTABLE_HASH_SIZE_SHA1);\n-\tcheck(reftable_record_equal(rec, ©, REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert(reftable_record_equal(rec, ©,\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n \n \treftable_record_release(©);\n }\n \n-static void t_varint_roundtrip(void)\n+void test_reftable_record__varint_roundtrip(void)\n {\n \tuint64_t inputs[] = { 0,\n \t\t\t 1,\n@@ -49,16 +51,16 @@ static void t_varint_roundtrip(void)\n \t\tint n = put_var_int(&out, in);\n \t\tuint64_t got = 0;\n \n-\t\tcheck_int(n, >, 0);\n+\t\tcl_assert(n > 0);\n \t\tout.len = n;\n \t\tn = get_var_int(&got, &out);\n-\t\tcheck_int(n, >, 0);\n+\t\tcl_assert(n > 0);\n \n-\t\tcheck_int(got, ==, in);\n+\t\tcl_assert_equal_i(got, in);\n \t}\n }\n \n-static void t_varint_overflow(void)\n+void test_reftable_record__varint_overflow(void)\n {\n \tunsigned char buf[] = {\n \t\t0xFF, 0xFF, 0xFF, 0xFF,\n@@ -70,8 +72,7 @@ static void t_varint_overflow(void)\n \t\t.len = sizeof(buf),\n \t};\n \tuint64_t value;\n-\tint err = get_var_int(&value, &view);\n-\tcheck_int(err, ==, -1);\n+\tcl_assert_equal_i(get_var_int(&value, &view), -1);\n }\n \n static void set_hash(uint8_t *h, int j)\n@@ -80,7 +81,7 @@ static void set_hash(uint8_t *h, int j)\n \t\th[i] = (j >> i) & 0xff;\n }\n \n-static void t_reftable_ref_record_comparison(void)\n+void test_reftable_record__ref_record_comparison(void)\n {\n \tstruct reftable_record in[3] = {\n \t\t{\n@@ -102,21 +103,23 @@ static void t_reftable_ref_record_comparison(void)\n \t};\n \tint cmp;\n \n-\tcheck(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n \n-\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n-\tcheck_int(cmp, >, 0);\n+\tcl_assert(reftable_record_equal(&in[1], &in[2],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) == 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n+\tcl_assert(cmp > 0);\n \n \tin[1].u.ref.value_type = in[0].u.ref.value_type;\n-\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n }\n \n-static void t_reftable_ref_record_compare_name(void)\n+void test_reftable_record__ref_record_compare_name(void)\n {\n \tstruct reftable_ref_record recs[3] = {\n \t\t{\n@@ -130,12 +133,15 @@ static void t_reftable_ref_record_compare_name(void)\n \t\t},\n \t};\n \n-\tcheck_int(reftable_ref_record_compare_name(&recs[0], &recs[1]), <, 0);\n-\tcheck_int(reftable_ref_record_compare_name(&recs[1], &recs[0]), >, 0);\n-\tcheck_int(reftable_ref_record_compare_name(&recs[0], &recs[2]), ==, 0);\n+\tcl_assert(reftable_ref_record_compare_name(&recs[0],\n+\t\t\t\t\t\t &recs[1]) < 0);\n+\tcl_assert(reftable_ref_record_compare_name(&recs[1],\n+\t\t\t\t\t\t &recs[0]) > 0);\n+\tcl_assert_equal_i(reftable_ref_record_compare_name(&recs[0],\n+\t\t\t\t\t\t\t &recs[2]), 0);\n }\n \n-static void t_reftable_ref_record_roundtrip(void)\n+void test_reftable_record__ref_record_roundtrip(void)\n {\n \tstruct reftable_buf scratch = REFTABLE_BUF_INIT;\n \n@@ -172,19 +178,21 @@ static void t_reftable_ref_record_roundtrip(void)\n \n \t\tt_copy(&in);\n \n-\t\tcheck_int(reftable_record_val_type(&in), ==, i);\n-\t\tcheck_int(reftable_record_is_deletion(&in), ==, i == REFTABLE_REF_DELETION);\n+\t\tcl_assert_equal_i(reftable_record_val_type(&in), i);\n+\t\tcl_assert_equal_i(reftable_record_is_deletion(&in),\n+\t\t\t\t i == REFTABLE_REF_DELETION);\n \n \t\treftable_record_key(&in, &key);\n \t\tn = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck_int(n, >, 0);\n+\t\tcl_assert(n > 0);\n \n \t\t/* decode into a non-zero reftable_record to test for leaks. */\n \t\tm = reftable_record_decode(&out, key, i, dest, REFTABLE_HASH_SIZE_SHA1, &scratch);\n-\t\tcheck_int(n, ==, m);\n+\t\tcl_assert_equal_i(n, m);\n \n-\t\tcheck(reftable_ref_record_equal(&in.u.ref, &out.u.ref,\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_ref_record_equal(&in.u.ref,\n+\t\t\t\t\t\t &out.u.ref,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_record_release(&in);\n \n \t\treftable_buf_release(&key);\n@@ -194,7 +202,7 @@ static void t_reftable_ref_record_roundtrip(void)\n \treftable_buf_release(&scratch);\n }\n \n-static void t_reftable_log_record_comparison(void)\n+void test_reftable_record__log_record_comparison(void)\n {\n \tstruct reftable_record in[3] = {\n \t\t{\n@@ -215,21 +223,24 @@ static void t_reftable_log_record_comparison(void)\n \t};\n \tint cmp;\n \n-\tcheck(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n-\tcheck_int(cmp, >, 0);\n+\tcl_assert_equal_i(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_equal(&in[1], &in[2],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n+\tcl_assert(cmp > 0);\n \t/* comparison should be reversed for equal keys, because\n \t * comparison is now performed on the basis of update indices */\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck_int(cmp, <, 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(cmp < 0);\n \n \tin[1].u.log.update_index = in[0].u.log.update_index;\n-\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n+\tcl_assert(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n }\n \n-static void t_reftable_log_record_compare_key(void)\n+void test_reftable_record__log_record_compare_key(void)\n {\n \tstruct reftable_log_record logs[3] = {\n \t\t{\n@@ -246,19 +257,24 @@ static void t_reftable_log_record_compare_key(void)\n \t\t},\n \t};\n \n-\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[1]), <, 0);\n-\tcheck_int(reftable_log_record_compare_key(&logs[1], &logs[0]), >, 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[0],\n+\t\t\t\t\t\t &logs[1]) < 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[1],\n+\t\t\t\t\t\t &logs[0]) > 0);\n \n \tlogs[1].update_index = logs[0].update_index;\n-\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[1]), <, 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[0],\n+\t\t\t\t\t\t &logs[1]) < 0);\n \n-\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[2]), >, 0);\n-\tcheck_int(reftable_log_record_compare_key(&logs[2], &logs[0]), <, 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[0],\n+\t\t\t\t\t\t &logs[2]) > 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[2],\n+\t\t\t\t\t\t &logs[0]) < 0);\n \tlogs[2].update_index = logs[0].update_index;\n-\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[2]), ==, 0);\n+\tcl_assert_equal_i(reftable_log_record_compare_key(&logs[0], &logs[2]), 0);\n }\n \n-static void t_reftable_log_record_roundtrip(void)\n+void test_reftable_record__log_record_roundtrip(void)\n {\n \tstruct reftable_log_record in[] = {\n \t\t{\n@@ -292,9 +308,9 @@ static void t_reftable_log_record_roundtrip(void)\n \tset_hash(in[2].value.update.new_hash, 3);\n \tset_hash(in[2].value.update.old_hash, 4);\n \n-\tcheck(!reftable_log_record_is_deletion(&in[0]));\n-\tcheck(reftable_log_record_is_deletion(&in[1]));\n-\tcheck(!reftable_log_record_is_deletion(&in[2]));\n+\tcl_assert_equal_i(reftable_log_record_is_deletion(&in[0]), 0);\n+\tcl_assert(reftable_log_record_is_deletion(&in[1]) != 0);\n+\tcl_assert_equal_i(reftable_log_record_is_deletion(&in[2]), 0);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(in); i++) {\n \t\tstruct reftable_record rec = { .type = REFTABLE_BLOCK_TYPE_LOG };\n@@ -328,14 +344,14 @@ static void t_reftable_log_record_roundtrip(void)\n \t\treftable_record_key(&rec, &key);\n \n \t\tn = reftable_record_encode(&rec, dest, REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck_int(n, >=, 0);\n+\t\tcl_assert(n >= 0);\n \t\tvaltype = reftable_record_val_type(&rec);\n \t\tm = reftable_record_decode(&out, key, valtype, dest,\n \t\t\t\t\t REFTABLE_HASH_SIZE_SHA1, &scratch);\n-\t\tcheck_int(n, ==, m);\n+\t\tcl_assert_equal_i(n, m);\n \n-\t\tcheck(reftable_log_record_equal(&in[i], &out.u.log,\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_log_record_equal(&in[i], &out.u.log,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_log_record_release(&in[i]);\n \t\treftable_buf_release(&key);\n \t\treftable_record_release(&out);\n@@ -344,7 +360,7 @@ static void t_reftable_log_record_roundtrip(void)\n \treftable_buf_release(&scratch);\n }\n \n-static void t_key_roundtrip(void)\n+void test_reftable_record__key_roundtrip(void)\n {\n \tuint8_t buffer[1024] = { 0 };\n \tstruct string_view dest = {\n@@ -359,25 +375,28 @@ static void t_key_roundtrip(void)\n \tint n, m;\n \tuint8_t rt_extra;\n \n-\tcheck(!reftable_buf_addstr(&last_key, \"refs/heads/master\"));\n-\tcheck(!reftable_buf_addstr(&key, \"refs/tags/bla\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&last_key,\n+\t\t\t\t\t \"refs/heads/master\"), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&key,\n+\t\t\t\t\t \"refs/tags/bla\"), 0);\n \textra = 6;\n \tn = reftable_encode_key(&restart, dest, last_key, key, extra);\n-\tcheck(!restart);\n-\tcheck_int(n, >, 0);\n+\tcl_assert(!restart);\n+\tcl_assert(n > 0);\n \n-\tcheck(!reftable_buf_addstr(&roundtrip, \"refs/heads/master\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&roundtrip,\n+\t\t\t\t\t \"refs/heads/master\"), 0);\n \tm = reftable_decode_key(&roundtrip, &rt_extra, dest);\n-\tcheck_int(n, ==, m);\n-\tcheck(!reftable_buf_cmp(&key, &roundtrip));\n-\tcheck_int(rt_extra, ==, extra);\n+\tcl_assert_equal_i(n, m);\n+\tcl_assert_equal_i(reftable_buf_cmp(&key, &roundtrip), 0);\n+\tcl_assert_equal_i(rt_extra, extra);\n \n \treftable_buf_release(&last_key);\n \treftable_buf_release(&key);\n \treftable_buf_release(&roundtrip);\n }\n \n-static void t_reftable_obj_record_comparison(void)\n+void test_reftable_record__obj_record_comparison(void)\n {\n \n \tuint8_t id_bytes[] = { 0, 1, 2, 3, 4, 5, 6 };\n@@ -405,21 +424,23 @@ static void t_reftable_obj_record_comparison(void)\n \t};\n \tint cmp;\n \n-\tcheck(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert_equal_i(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n \n-\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n-\tcheck_int(cmp, >, 0);\n+\tcl_assert_equal_i(reftable_record_equal(&in[1], &in[2],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n+\tcl_assert(cmp > 0);\n \n \tin[1].u.obj.offset_len = in[0].u.obj.offset_len;\n-\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n }\n \n-static void t_reftable_obj_record_roundtrip(void)\n+void test_reftable_record__obj_record_roundtrip(void)\n {\n \tuint8_t testHash1[REFTABLE_HASH_SIZE_SHA1] = { 1, 2, 3, 4, 0 };\n \tuint64_t till9[] = { 1, 2, 3, 4, 500, 600, 700, 800, 9000 };\n@@ -460,17 +481,18 @@ static void t_reftable_obj_record_roundtrip(void)\n \t\tint n, m;\n \t\tuint8_t extra;\n \n-\t\tcheck(!reftable_record_is_deletion(&in));\n+\t\tcl_assert_equal_i(reftable_record_is_deletion(&in), 0);\n \t\tt_copy(&in);\n \t\treftable_record_key(&in, &key);\n \t\tn = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck_int(n, >, 0);\n+\t\tcl_assert(n > 0);\n \t\textra = reftable_record_val_type(&in);\n \t\tm = reftable_record_decode(&out, key, extra, dest,\n \t\t\t\t\t REFTABLE_HASH_SIZE_SHA1, &scratch);\n-\t\tcheck_int(n, ==, m);\n+\t\tcl_assert_equal_i(n, m);\n \n-\t\tcheck(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_record_equal(&in, &out,\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_buf_release(&key);\n \t\treftable_record_release(&out);\n \t}\n@@ -478,7 +500,7 @@ static void t_reftable_obj_record_roundtrip(void)\n \treftable_buf_release(&scratch);\n }\n \n-static void t_reftable_index_record_comparison(void)\n+void test_reftable_record__index_record_comparison(void)\n {\n \tstruct reftable_record in[3] = {\n \t\t{\n@@ -499,28 +521,33 @@ static void t_reftable_index_record_comparison(void)\n \t};\n \tint cmp;\n \n-\tcheck(!reftable_buf_addstr(&in[0].u.idx.last_key, \"refs/heads/master\"));\n-\tcheck(!reftable_buf_addstr(&in[1].u.idx.last_key, \"refs/heads/master\"));\n-\tcheck(!reftable_buf_addstr(&in[2].u.idx.last_key, \"refs/heads/branch\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&in[0].u.idx.last_key,\n+\t\t\t\t\t \"refs/heads/master\"), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&in[1].u.idx.last_key, \"refs/heads/master\"), 0);\n+\tcl_assert(reftable_buf_addstr(&in[2].u.idx.last_key,\n+\t\t\t\t \"refs/heads/branch\") == 0);\n \n-\tcheck(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert_equal_i(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n \n-\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n-\tcheck_int(cmp, >, 0);\n+\tcl_assert_equal_i(reftable_record_equal(&in[1], &in[2],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n+\tcl_assert(cmp > 0);\n \n \tin[1].u.idx.offset = in[0].u.idx.offset;\n-\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(in); i++)\n \t\treftable_record_release(&in[i]);\n }\n \n-static void t_reftable_index_record_roundtrip(void)\n+void test_reftable_record__index_record_roundtrip(void)\n {\n \tstruct reftable_record in = {\n \t\t.type = REFTABLE_BLOCK_TYPE_INDEX,\n@@ -543,43 +570,26 @@ static void t_reftable_index_record_roundtrip(void)\n \tint n, m;\n \tuint8_t extra;\n \n-\tcheck(!reftable_buf_addstr(&in.u.idx.last_key, \"refs/heads/master\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&in.u.idx.last_key,\n+\t\t\t\t\t \"refs/heads/master\"), 0);\n \treftable_record_key(&in, &key);\n \tt_copy(&in);\n \n-\tcheck(!reftable_record_is_deletion(&in));\n-\tcheck(!reftable_buf_cmp(&key, &in.u.idx.last_key));\n+\tcl_assert_equal_i(reftable_record_is_deletion(&in), 0);\n+\tcl_assert_equal_i(reftable_buf_cmp(&key, &in.u.idx.last_key), 0);\n \tn = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);\n-\tcheck_int(n, >, 0);\n+\tcl_assert(n > 0);\n \n \textra = reftable_record_val_type(&in);\n-\tm = reftable_record_decode(&out, key, extra, dest, REFTABLE_HASH_SIZE_SHA1,\n-\t\t\t\t &scratch);\n-\tcheck_int(m, ==, n);\n+\tm = reftable_record_decode(&out, key, extra, dest,\n+\t\t\t\t REFTABLE_HASH_SIZE_SHA1, &scratch);\n+\tcl_assert_equal_i(m, n);\n \n-\tcheck(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert(reftable_record_equal(&in, &out,\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n \n \treftable_record_release(&out);\n \treftable_buf_release(&key);\n \treftable_buf_release(&scratch);\n \treftable_buf_release(&in.u.idx.last_key);\n }\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_reftable_ref_record_comparison(), \"comparison operations work on ref record\");\n-\tTEST(t_reftable_log_record_comparison(), \"comparison operations work on log record\");\n-\tTEST(t_reftable_index_record_comparison(), \"comparison operations work on index record\");\n-\tTEST(t_reftable_obj_record_comparison(), \"comparison operations work on obj record\");\n-\tTEST(t_reftable_ref_record_compare_name(), \"reftable_ref_record_compare_name works\");\n-\tTEST(t_reftable_log_record_compare_key(), \"reftable_log_record_compare_key works\");\n-\tTEST(t_reftable_log_record_roundtrip(), \"record operations work on log record\");\n-\tTEST(t_reftable_ref_record_roundtrip(), \"record operations work on ref record\");\n-\tTEST(t_varint_roundtrip(), \"put_var_int and get_var_int work\");\n-\tTEST(t_varint_overflow(), \"get_var_int notices an integer overflow\");\n-\tTEST(t_key_roundtrip(), \"reftable_encode_key and reftable_decode_key work\");\n-\tTEST(t_reftable_obj_record_roundtrip(), \"record operations work on obj record\");\n-\tTEST(t_reftable_index_record_roundtrip(), \"record operations work on index record\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"519781","messageId":"20250605140644.239199-10-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250605140644.239199-1-kuforiji98@gmail.com","subject":"[PATCH v4 09/10] t/unit-tests: convert reftable stack test to use clar","fromName":"Seyi Kuforiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-06-05T14:06:43Z","receivedAt":"2025-06-05T14:08:41Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"Adapt reftable stack test file to use clar by using clar assertions\nwhere necessary.\n\nThis marks the end of all unit tests migrated away from the\n`unit-tests/t-*.c` pattern, there are no longer any files matching that\nglob. Remove the sanity check for `t-*.c` files to prevent Meson\nconfiguration errors during CI and local builds.\n\nSigned-off-by: Seyi Kuforiji \n---\n Makefile | 2 +-\n t/meson.build | 5 +-\n ...{t-reftable-stack.c => u-reftable-stack.c} | 780 ++++++++----------\n 3 files changed, 333 insertions(+), 454 deletions(-)\n rename t/unit-tests/{t-reftable-stack.c => u-reftable-stack.c} (59%)\n\ndiff --git a/Makefile b/Makefile\nindex 3b41342ddb..8ed8f234f4 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1369,6 +1369,7 @@ CLAR_TEST_SUITES += u-reftable-block\n CLAR_TEST_SUITES += u-reftable-merged\n CLAR_TEST_SUITES += u-reftable-pq\n CLAR_TEST_SUITES += u-reftable-readwrite\n+CLAR_TEST_SUITES += u-reftable-stack\n CLAR_TEST_SUITES += u-reftable-table\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n@@ -1383,7 +1384,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-stack\n UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o\ndiff --git a/t/meson.build b/t/meson.build\nindex 297937f307..fcbb659263 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -13,6 +13,8 @@ clar_test_suites = [\n 'unit-tests/u-reftable-merged.c',\n 'unit-tests/u-reftable-pq.c',\n 'unit-tests/u-reftable-readwrite.c',\n+ 'unit-tests/u-reftable-record.c',\n+ 'unit-tests/u-reftable-stack.c',\n 'unit-tests/u-reftable-table.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n@@ -61,7 +63,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-stack.c',\n ]\n \n foreach unit_test_program : unit_test_programs\n@@ -1163,8 +1164,6 @@ benchmarks = [\n # sufficient to catch missing test suites in our CI though.\n foreach glob, tests : {\n 't[0-9][0-9][0-9][0-9]-*.sh': integration_tests,\n- 'perf/p[0-9][0-9][0-9][0-9]-*.sh': benchmarks,\n- 'unit-tests/t-*.c': unit_test_programs,\n 'unit-tests/u-*.c': clar_test_suites,\n }\n actual_tests = run_command(shell, '-c', 'ls ' + glob,\ndiff --git a/t/unit-tests/t-reftable-stack.c b/t/unit-tests/u-reftable-stack.c\nsimilarity index 59%\nrename from t/unit-tests/t-reftable-stack.c\nrename to t/unit-tests/u-reftable-stack.c\nindex 2f49c97519..0e3e3f4f4a 100644\n--- a/t/unit-tests/t-reftable-stack.c\n+++ b/t/unit-tests/u-reftable-stack.c\n@@ -8,9 +8,9 @@ license that can be found in the LICENSE file or at\n \n #define DISABLE_SIGN_COMPARE_WARNINGS\n \n-#include \"test-lib.h\"\n-#include \"lib-reftable.h\"\n+#include \"unit-test.h\"\n #include \"dir.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/merged.h\"\n #include \"reftable/reftable-error.h\"\n #include \"reftable/stack.h\"\n@@ -70,11 +70,11 @@ static char *get_tmp_template(int linenumber)\n static char *get_tmp_dir(int linenumber)\n {\n \tchar *dir = get_tmp_template(linenumber);\n-\tcheck(mkdtemp(dir) != NULL);\n+\tcl_assert(mkdtemp(dir) != NULL);\n \treturn dir;\n }\n \n-static void t_read_file(void)\n+void test_reftable_stack__read_file(void)\n {\n \tchar *fn = get_tmp_template(__LINE__);\n \tstruct tempfile *tmp = mks_tempfile(fn);\n@@ -84,17 +84,17 @@ static void t_read_file(void)\n \tchar **names = NULL;\n \tconst char *want[] = { \"line1\", \"line2\", \"line3\" };\n \n-\tcheck_int(fd, >, 0);\n+\tcl_assert(fd > 0);\n \tn = write_in_full(fd, out, strlen(out));\n-\tcheck_int(n, ==, strlen(out));\n+\tcl_assert_equal_i(n, strlen(out));\n \terr = close(fd);\n-\tcheck_int(err, >=, 0);\n+\tcl_assert(err >= 0);\n \n \terr = read_lines(fn, &names);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (size_t i = 0; names[i]; i++)\n-\t\tcheck_str(want[i], names[i]);\n+\t\tcl_assert_equal_s(want[i], names[i]);\n \tfree_names(names);\n \t(void) remove(fn);\n \tdelete_tempfile(&tmp);\n@@ -103,8 +103,8 @@ static void t_read_file(void)\n static int write_test_ref(struct reftable_writer *wr, void *arg)\n {\n \tstruct reftable_ref_record *ref = arg;\n-\tcheck(!reftable_writer_set_limits(wr, ref->update_index,\n-\t\t\t\t\t ref->update_index));\n+\tcl_assert_equal_i(reftable_writer_set_limits(wr,\n+\t\t\t\t\t\t ref->update_index, ref->update_index), 0);\n \treturn reftable_writer_add_ref(wr, ref);\n }\n \n@@ -112,7 +112,6 @@ static void write_n_ref_tables(struct reftable_stack *st,\n \t\t\t size_t n)\n {\n \tint disable_auto_compact;\n-\tint err;\n \n \tdisable_auto_compact = st->opts.disable_auto_compact;\n \tst->opts.disable_auto_compact = 1;\n@@ -126,10 +125,10 @@ static void write_n_ref_tables(struct reftable_stack *st,\n \n \t\tsnprintf(buf, sizeof(buf), \"refs/heads/branch-%04\"PRIuMAX, (uintmax_t)i);\n \t\tref.refname = buf;\n-\t\tt_reftable_set_hash(ref.value.val1, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(ref.value.val1, i, REFTABLE_HASH_SHA1);\n \n-\t\terr = reftable_stack_add(st, &write_test_ref, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t &write_test_ref, &ref), 0);\n \t}\n \n \tst->opts.disable_auto_compact = disable_auto_compact;\n@@ -144,12 +143,13 @@ static int write_test_log(struct reftable_writer *wr, void *arg)\n {\n \tstruct write_log_arg *wla = arg;\n \n-\tcheck(!reftable_writer_set_limits(wr, wla->update_index,\n-\t\t\t\t\t wla->update_index));\n+\tcl_assert_equal_i(reftable_writer_set_limits(wr,\n+\t\t\t\t\t\t wla->update_index,\n+\t\t\t\t\t\t wla->update_index), 0);\n \treturn reftable_writer_add_log(wr, wla->log);\n }\n \n-static void t_reftable_stack_add_one(void)\n+void test_reftable_stack__add_one(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_buf scratch = REFTABLE_BUF_INIT;\n@@ -158,7 +158,6 @@ static void t_reftable_stack_add_one(void)\n \t\t.default_permissions = 0660,\n \t};\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"HEAD\",\n \t\t.update_index = 1,\n@@ -167,32 +166,37 @@ static void t_reftable_stack_add_one(void)\n \t};\n \tstruct reftable_ref_record dest = { 0 };\n \tstruct stat stat_result = { 0 };\n+\tint err;\n+\n \terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_stack_add(st, write_test_ref, &ref);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_stack_read_ref(st, ref.refname, &dest);\n-\tcheck(!err);\n-\tcheck(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));\n-\tcheck_int(st->tables_len, >, 0);\n+\tcl_assert(!err);\n+\tcl_assert(reftable_ref_record_equal(&ref, &dest,\n+\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert(st->tables_len > 0);\n \n #ifndef GIT_WINDOWS_NATIVE\n-\tcheck(!reftable_buf_addstr(&scratch, dir));\n-\tcheck(!reftable_buf_addstr(&scratch, \"/tables.list\"));\n-\terr = stat(scratch.buf, &stat_result);\n-\tcheck(!err);\n-\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n+\tcl_assert_equal_i(reftable_buf_addstr(&scratch, dir), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&scratch,\n+\t\t\t\t\t \"/tables.list\"), 0);\n+\tcl_assert_equal_i(stat(scratch.buf, &stat_result), 0);\n+\tcl_assert_equal_i((stat_result.st_mode & 0777),\n+\t\t\t opts.default_permissions);\n \n \treftable_buf_reset(&scratch);\n-\tcheck(!reftable_buf_addstr(&scratch, dir));\n-\tcheck(!reftable_buf_addstr(&scratch, \"/\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&scratch, dir), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&scratch, \"/\"), 0);\n \t/* do not try at home; not an external API for reftable. */\n-\tcheck(!reftable_buf_addstr(&scratch, st->tables[0]->name));\n+\tcl_assert(!reftable_buf_addstr(&scratch, st->tables[0]->name));\n \terr = stat(scratch.buf, &stat_result);\n-\tcheck(!err);\n-\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i((stat_result.st_mode & 0777),\n+\t\t\t opts.default_permissions);\n #else\n \t(void) stat_result;\n #endif\n@@ -204,14 +208,13 @@ static void t_reftable_stack_add_one(void)\n \tumask(mask);\n }\n \n-static void t_reftable_stack_uptodate(void)\n+void test_reftable_stack__uptodate(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st1 = NULL;\n \tstruct reftable_stack *st2 = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n \n-\tint err;\n \tstruct reftable_ref_record ref1 = {\n \t\t.refname = (char *) \"HEAD\",\n \t\t.update_index = 1,\n@@ -229,34 +232,25 @@ static void t_reftable_stack_uptodate(void)\n \t/* simulate multi-process access to the same stack\n \t by creating two stacks for the same directory.\n \t */\n-\terr = reftable_new_stack(&st1, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st1, write_test_ref, &ref1);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st2, write_test_ref, &ref2);\n-\tcheck_int(err, ==, REFTABLE_OUTDATED_ERROR);\n-\n-\terr = reftable_stack_reload(st2);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st2, write_test_ref, &ref2);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st1, write_test_ref,\n+\t\t\t\t\t &ref1), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st2, write_test_ref,\n+\t\t\t\t\t &ref2), REFTABLE_OUTDATED_ERROR);\n+\tcl_assert_equal_i(reftable_stack_reload(st2), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st2, write_test_ref,\n+\t\t\t\t\t &ref2), 0);\n \treftable_stack_destroy(st1);\n \treftable_stack_destroy(st2);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_transaction_api(void)\n+void test_reftable_stack__transaction_api(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tstruct reftable_addition *add = NULL;\n \n \tstruct reftable_ref_record ref = {\n@@ -267,37 +261,32 @@ static void t_reftable_stack_transaction_api(void)\n \t};\n \tstruct reftable_ref_record dest = { 0 };\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \treftable_addition_destroy(add);\n \n-\terr = reftable_stack_new_addition(&add, st, 0);\n-\tcheck(!err);\n-\n-\terr = reftable_addition_add(add, write_test_ref, &ref);\n-\tcheck(!err);\n-\n-\terr = reftable_addition_commit(add);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st, 0), 0);\n+\tcl_assert_equal_i(reftable_addition_add(add, write_test_ref,\n+\t\t\t\t\t\t&ref), 0);\n+\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \n \treftable_addition_destroy(add);\n \n-\terr = reftable_stack_read_ref(st, ref.refname, &dest);\n-\tcheck(!err);\n-\tcheck_int(REFTABLE_REF_SYMREF, ==, dest.value_type);\n-\tcheck(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert_equal_i(reftable_stack_read_ref(st, ref.refname,\n+\t\t\t\t\t\t &dest), 0);\n+\tcl_assert_equal_i(REFTABLE_REF_SYMREF, dest.value_type);\n+\tcl_assert(reftable_ref_record_equal(&ref, &dest,\n+\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \n \treftable_ref_record_release(&dest);\n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_transaction_with_reload(void)\n+void test_reftable_stack__transaction_with_reload(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_stack *st1 = NULL, *st2 = NULL;\n-\tint err;\n \tstruct reftable_addition *add = NULL;\n \tstruct reftable_ref_record refs[2] = {\n \t\t{\n@@ -315,17 +304,12 @@ static void t_reftable_stack_transaction_with_reload(void)\n \t};\n \tstruct reftable_ref_record ref = { 0 };\n \n-\terr = reftable_new_stack(&st1, dir, NULL);\n-\tcheck(!err);\n-\terr = reftable_new_stack(&st2, dir, NULL);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_new_addition(&add, st1, 0);\n-\tcheck(!err);\n-\terr = reftable_addition_add(add, write_test_ref, &refs[0]);\n-\tcheck(!err);\n-\terr = reftable_addition_commit(add);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, NULL), 0);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, NULL), 0);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st1, 0), 0);\n+\tcl_assert_equal_i(reftable_addition_add(add, write_test_ref,\n+\t\t\t\t\t\t&refs[0]), 0);\n+\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \treftable_addition_destroy(add);\n \n \t/*\n@@ -333,20 +317,20 @@ static void t_reftable_stack_transaction_with_reload(void)\n \t * create the addition and lock the stack by default, but allow the\n \t * reload to happen when REFTABLE_STACK_NEW_ADDITION_RELOAD is set.\n \t */\n-\terr = reftable_stack_new_addition(&add, st2, 0);\n-\tcheck_int(err, ==, REFTABLE_OUTDATED_ERROR);\n-\terr = reftable_stack_new_addition(&add, st2, REFTABLE_STACK_NEW_ADDITION_RELOAD);\n-\tcheck(!err);\n-\terr = reftable_addition_add(add, write_test_ref, &refs[1]);\n-\tcheck(!err);\n-\terr = reftable_addition_commit(add);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st2, 0),\n+\t\t\t\t\t\t REFTABLE_OUTDATED_ERROR);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st2,\n+\t\t\t\t\t\t REFTABLE_STACK_NEW_ADDITION_RELOAD), 0);\n+\tcl_assert_equal_i(reftable_addition_add(add, write_test_ref,\n+\t\t\t\t\t\t&refs[1]), 0);\n+\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \treftable_addition_destroy(add);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(refs); i++) {\n-\t\terr = reftable_stack_read_ref(st2, refs[i].refname, &ref);\n-\t\tcheck(!err);\n-\t\tcheck(reftable_ref_record_equal(&refs[i], &ref, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_stack_read_ref(st2,\n+\t\t\t\t\t\t\t refs[i].refname, &ref) , 0);\n+\t\tcl_assert(reftable_ref_record_equal(&refs[i], &ref,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t}\n \n \treftable_ref_record_release(&ref);\n@@ -355,17 +339,15 @@ static void t_reftable_stack_transaction_with_reload(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_transaction_api_performs_auto_compaction(void)\n+void test_reftable_stack__transaction_api_performs_auto_compaction(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = {0};\n \tstruct reftable_addition *add = NULL;\n \tstruct reftable_stack *st = NULL;\n \tsize_t n = 20;\n-\tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (size_t i = 0; i <= n; i++) {\n \t\tstruct reftable_ref_record ref = {\n@@ -385,14 +367,11 @@ static void t_reftable_stack_transaction_api_performs_auto_compaction(void)\n \t\t */\n \t\tst->opts.disable_auto_compact = i != n;\n \n-\t\terr = reftable_stack_new_addition(&add, st, 0);\n-\t\tcheck(!err);\n-\n-\t\terr = reftable_addition_add(add, write_test_ref, &ref);\n-\t\tcheck(!err);\n-\n-\t\terr = reftable_addition_commit(add);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_new_addition(&add,\n+\t\t\t\t\t\t\t st, 0), 0);\n+\t\tcl_assert_equal_i(reftable_addition_add(add,\n+\t\t\t\t\t\t\twrite_test_ref, &ref), 0);\n+\t\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \n \t\treftable_addition_destroy(add);\n \n@@ -402,16 +381,16 @@ static void t_reftable_stack_transaction_api_performs_auto_compaction(void)\n \t\t * all tables in the stack.\n \t\t */\n \t\tif (i != n)\n-\t\t\tcheck_int(st->merged->tables_len, ==, i + 1);\n+\t\t\tcl_assert_equal_i(st->merged->tables_len, i + 1);\n \t\telse\n-\t\t\tcheck_int(st->merged->tables_len, ==, 1);\n+\t\t\tcl_assert_equal_i(st->merged->tables_len, 1);\n \t}\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_auto_compaction_fails_gracefully(void)\n+void test_reftable_stack__auto_compaction_fails_gracefully(void)\n {\n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"refs/heads/master\",\n@@ -425,32 +404,31 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)\n \tchar *dir = get_tmp_dir(__LINE__);\n \tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_test_ref, &ref);\n-\tcheck(!err);\n-\tcheck_int(st->merged->tables_len, ==, 1);\n-\tcheck_int(st->stats.attempts, ==, 0);\n-\tcheck_int(st->stats.failures, ==, 0);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &ref), 0);\n+\tcl_assert_equal_i(st->merged->tables_len, 1);\n+\tcl_assert_equal_i(st->stats.attempts, 0);\n+\tcl_assert_equal_i(st->stats.failures, 0);\n \n \t/*\n \t * Lock the newly written table such that it cannot be compacted.\n \t * Adding a new table to the stack should not be impacted by this, even\n \t * though auto-compaction will now fail.\n \t */\n-\tcheck(!reftable_buf_addstr(&table_path, dir));\n-\tcheck(!reftable_buf_addstr(&table_path, \"/\"));\n-\tcheck(!reftable_buf_addstr(&table_path, st->tables[0]->name));\n-\tcheck(!reftable_buf_addstr(&table_path, \".lock\"));\n+\tcl_assert(!reftable_buf_addstr(&table_path, dir));\n+\tcl_assert(!reftable_buf_addstr(&table_path, \"/\"));\n+\tcl_assert(!reftable_buf_addstr(&table_path,\n+\t\t\t\t st->tables[0]->name));\n+\tcl_assert(!reftable_buf_addstr(&table_path, \".lock\"));\n \twrite_file_buf(table_path.buf, \"\", 0);\n \n \tref.update_index = 2;\n \terr = reftable_stack_add(st, write_test_ref, &ref);\n-\tcheck(!err);\n-\tcheck_int(st->merged->tables_len, ==, 2);\n-\tcheck_int(st->stats.attempts, ==, 1);\n-\tcheck_int(st->stats.failures, ==, 1);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st->merged->tables_len, 2);\n+\tcl_assert_equal_i(st->stats.attempts, 1);\n+\tcl_assert_equal_i(st->stats.failures, 1);\n \n \treftable_stack_destroy(st);\n \treftable_buf_release(&table_path);\n@@ -462,12 +440,11 @@ static int write_error(struct reftable_writer *wr UNUSED, void *arg)\n \treturn *((int *)arg);\n }\n \n-static void t_reftable_stack_update_index_check(void)\n+void test_reftable_stack__update_index_check(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tstruct reftable_ref_record ref1 = {\n \t\t.refname = (char *) \"name1\",\n \t\t.update_index = 1,\n@@ -481,39 +458,33 @@ static void t_reftable_stack_update_index_check(void)\n \t\t.value.symref = (char *) \"master\",\n \t};\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_test_ref, &ref1);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_test_ref, &ref2);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &ref1), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &ref2), REFTABLE_API_ERROR);\n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_lock_failure(void)\n+void test_reftable_stack__lock_failure(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err, i;\n+\tint i;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\tfor (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {\n-\t\terr = reftable_stack_add(st, write_error, &i);\n-\t\tcheck_int(err, ==, i);\n-\t}\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tfor (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--)\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_error,\n+\t\t\t\t\t\t &i), i);\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_add(void)\n+void test_reftable_stack__add(void)\n {\n-\tint err = 0;\n \tstruct reftable_write_options opts = {\n \t\t.exact_log_message = 1,\n \t\t.default_permissions = 0660,\n@@ -526,9 +497,10 @@ static void t_reftable_stack_add(void)\n \tstruct reftable_buf path = REFTABLE_BUF_INIT;\n \tstruct stat stat_result;\n \tsize_t i, N = ARRAY_SIZE(refs);\n+\tint err;\n \n \terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (i = 0; i < N; i++) {\n \t\tchar buf[256];\n@@ -536,66 +508,66 @@ static void t_reftable_stack_add(void)\n \t\trefs[i].refname = xstrdup(buf);\n \t\trefs[i].update_index = i + 1;\n \t\trefs[i].value_type = REFTABLE_REF_VAL1;\n-\t\tt_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \n \t\tlogs[i].refname = xstrdup(buf);\n \t\tlogs[i].update_index = N + i + 1;\n \t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n \t\tlogs[i].value.update.email = xstrdup(\"identity@invalid\");\n-\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n-\tfor (i = 0; i < N; i++) {\n-\t\tint err = reftable_stack_add(st, write_test_ref, &refs[i]);\n-\t\tcheck(!err);\n-\t}\n+\tfor (i = 0; i < N; i++)\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &refs[i]), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct write_log_arg arg = {\n \t\t\t.log = &logs[i],\n \t\t\t.update_index = reftable_stack_next_update_index(st),\n \t\t};\n-\t\tint err = reftable_stack_add(st, write_test_log, &arg);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t\t &arg), 0);\n \t}\n \n-\terr = reftable_stack_compact_all(st, NULL);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct reftable_ref_record dest = { 0 };\n \n-\t\tint err = reftable_stack_read_ref(st, refs[i].refname, &dest);\n-\t\tcheck(!err);\n-\t\tcheck(reftable_ref_record_equal(&dest, refs + i,\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_stack_read_ref(st,\n+\t\t\t\t\t\t\t refs[i].refname, &dest), 0);\n+\t\tcl_assert(reftable_ref_record_equal(&dest, refs + i,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_ref_record_release(&dest);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct reftable_log_record dest = { 0 };\n-\t\tint err = reftable_stack_read_log(st, refs[i].refname, &dest);\n-\t\tcheck(!err);\n-\t\tcheck(reftable_log_record_equal(&dest, logs + i,\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_stack_read_log(st,\n+\t\t\t\t\t\t\t refs[i].refname, &dest), 0);\n+\t\tcl_assert(reftable_log_record_equal(&dest, logs + i,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_log_record_release(&dest);\n \t}\n \n #ifndef GIT_WINDOWS_NATIVE\n-\tcheck(!reftable_buf_addstr(&path, dir));\n-\tcheck(!reftable_buf_addstr(&path, \"/tables.list\"));\n-\terr = stat(path.buf, &stat_result);\n-\tcheck(!err);\n-\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n+\tcl_assert_equal_i(reftable_buf_addstr(&path, dir), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&path, \"/tables.list\"), 0);\n+\tcl_assert_equal_i(stat(path.buf, &stat_result), 0);\n+\tcl_assert_equal_i((stat_result.st_mode & 0777), opts.default_permissions);\n \n \treftable_buf_reset(&path);\n-\tcheck(!reftable_buf_addstr(&path, dir));\n-\tcheck(!reftable_buf_addstr(&path, \"/\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&path, dir), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&path, \"/\"), 0);\n \t/* do not try at home; not an external API for reftable. */\n-\tcheck(!reftable_buf_addstr(&path, st->tables[0]->name));\n+\tcl_assert(!reftable_buf_addstr(&path, st->tables[0]->name));\n \terr = stat(path.buf, &stat_result);\n-\tcheck(!err);\n-\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i((stat_result.st_mode & 0777),\n+\t\t\t opts.default_permissions);\n #else\n \t(void) stat_result;\n #endif\n@@ -610,7 +582,7 @@ static void t_reftable_stack_add(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_iterator(void)\n+void test_reftable_stack__iterator(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n@@ -621,27 +593,27 @@ static void t_reftable_stack_iterator(void)\n \tsize_t N = ARRAY_SIZE(refs), i;\n \tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\trefs[i].refname = xstrfmt(\"branch%02\"PRIuMAX, (uintmax_t)i);\n \t\trefs[i].update_index = i + 1;\n \t\trefs[i].value_type = REFTABLE_REF_VAL1;\n-\t\tt_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \n \t\tlogs[i].refname = xstrfmt(\"branch%02\"PRIuMAX, (uintmax_t)i);\n \t\tlogs[i].update_index = i + 1;\n \t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n \t\tlogs[i].value.update.email = xstrdup(\"johndoe@invalid\");\n \t\tlogs[i].value.update.message = xstrdup(\"commit\\n\");\n-\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n-\tfor (i = 0; i < N; i++) {\n-\t\terr = reftable_stack_add(st, write_test_ref, &refs[i]);\n-\t\tcheck(!err);\n-\t}\n+\tfor (i = 0; i < N; i++)\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t write_test_ref, &refs[i]), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct write_log_arg arg = {\n@@ -649,8 +621,8 @@ static void t_reftable_stack_iterator(void)\n \t\t\t.update_index = reftable_stack_next_update_index(st),\n \t\t};\n \n-\t\terr = reftable_stack_add(st, write_test_log, &arg);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t write_test_log, &arg), 0);\n \t}\n \n \treftable_stack_init_ref_iterator(st, &it);\n@@ -661,16 +633,16 @@ static void t_reftable_stack_iterator(void)\n \t\terr = reftable_iterator_next_ref(&it, &ref);\n \t\tif (err > 0)\n \t\t\tbreak;\n-\t\tcheck(!err);\n-\t\tcheck(reftable_ref_record_equal(&ref, &refs[i], REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(!err);\n+\t\tcl_assert(reftable_ref_record_equal(&ref, &refs[i],\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_ref_record_release(&ref);\n \t}\n-\tcheck_int(i, ==, N);\n+\tcl_assert_equal_i(i, N);\n \n \treftable_iterator_destroy(&it);\n \n-\terr = reftable_stack_init_log_iterator(st, &it);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_init_log_iterator(st, &it), 0);\n \n \treftable_iterator_seek_log(&it, logs[0].refname);\n \tfor (i = 0; ; i++) {\n@@ -679,11 +651,12 @@ static void t_reftable_stack_iterator(void)\n \t\terr = reftable_iterator_next_log(&it, &log);\n \t\tif (err > 0)\n \t\t\tbreak;\n-\t\tcheck(!err);\n-\t\tcheck(reftable_log_record_equal(&log, &logs[i], REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(!err);\n+\t\tcl_assert(reftable_log_record_equal(&log, &logs[i],\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_log_record_release(&log);\n \t}\n-\tcheck_int(i, ==, N);\n+\tcl_assert_equal_i(i, N);\n \n \treftable_stack_destroy(st);\n \treftable_iterator_destroy(&it);\n@@ -694,9 +667,8 @@ static void t_reftable_stack_iterator(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_log_normalize(void)\n+void test_reftable_stack__log_normalize(void)\n {\n-\tint err = 0;\n \tstruct reftable_write_options opts = {\n \t\t0,\n \t};\n@@ -721,28 +693,26 @@ static void t_reftable_stack_log_normalize(void)\n \t\t.update_index = 1,\n \t};\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tinput.value.update.message = (char *) \"one\\ntwo\";\n-\terr = reftable_stack_add(st, write_test_log, &arg);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t &arg), REFTABLE_API_ERROR);\n \n \tinput.value.update.message = (char *) \"one\";\n-\terr = reftable_stack_add(st, write_test_log, &arg);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_log(st, input.refname, &dest);\n-\tcheck(!err);\n-\tcheck_str(dest.value.update.message, \"one\\n\");\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t &arg), 0);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, input.refname,\n+\t\t\t\t\t\t &dest), 0);\n+\tcl_assert_equal_s(dest.value.update.message, \"one\\n\");\n \n \tinput.value.update.message = (char *) \"two\\n\";\n \targ.update_index = 2;\n-\terr = reftable_stack_add(st, write_test_log, &arg);\n-\tcheck(!err);\n-\terr = reftable_stack_read_log(st, input.refname, &dest);\n-\tcheck(!err);\n-\tcheck_str(dest.value.update.message, \"two\\n\");\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t &arg), 0);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, input.refname,\n+\t\t\t\t\t\t &dest), 0);\n+\tcl_assert_equal_s(dest.value.update.message, \"two\\n\");\n \n \t/* cleanup */\n \treftable_stack_destroy(st);\n@@ -750,20 +720,18 @@ static void t_reftable_stack_log_normalize(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_tombstone(void)\n+void test_reftable_stack__tombstone(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tstruct reftable_ref_record refs[2] = { 0 };\n \tstruct reftable_log_record logs[2] = { 0 };\n \tsize_t i, N = ARRAY_SIZE(refs);\n \tstruct reftable_ref_record dest = { 0 };\n \tstruct reftable_log_record log_dest = { 0 };\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \t/* even entries add the refs, odd entries delete them. */\n \tfor (i = 0; i < N; i++) {\n@@ -772,8 +740,8 @@ static void t_reftable_stack_tombstone(void)\n \t\trefs[i].update_index = i + 1;\n \t\tif (i % 2 == 0) {\n \t\t\trefs[i].value_type = REFTABLE_REF_VAL1;\n-\t\t\tt_reftable_set_hash(refs[i].value.val1, i,\n-\t\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n+\t\t\t\t\t REFTABLE_HASH_SHA1);\n \t\t}\n \n \t\tlogs[i].refname = xstrdup(buf);\n@@ -785,42 +753,36 @@ static void t_reftable_stack_tombstone(void)\n \t\tlogs[i].update_index = 1;\n \t\tif (i % 2 == 0) {\n \t\t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n-\t\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i,\n-\t\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);\n \t\t\tlogs[i].value.update.email =\n \t\t\t\txstrdup(\"identity@invalid\");\n \t\t}\n \t}\n-\tfor (i = 0; i < N; i++) {\n-\t\tint err = reftable_stack_add(st, write_test_ref, &refs[i]);\n-\t\tcheck(!err);\n-\t}\n+\tfor (i = 0; i < N; i++)\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref, &refs[i]), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct write_log_arg arg = {\n \t\t\t.log = &logs[i],\n \t\t\t.update_index = reftable_stack_next_update_index(st),\n \t\t};\n-\t\tint err = reftable_stack_add(st, write_test_log, &arg);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t write_test_log, &arg), 0);\n \t}\n \n-\terr = reftable_stack_read_ref(st, \"branch\", &dest);\n-\tcheck_int(err, ==, 1);\n+\tcl_assert_equal_i(reftable_stack_read_ref(st, \"branch\",\n+\t\t\t\t\t\t &dest), 1);\n \treftable_ref_record_release(&dest);\n \n-\terr = reftable_stack_read_log(st, \"branch\", &log_dest);\n-\tcheck_int(err, ==, 1);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, \"branch\",\n+\t\t\t\t\t\t &log_dest), 1);\n \treftable_log_record_release(&log_dest);\n \n-\terr = reftable_stack_compact_all(st, NULL);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_ref(st, \"branch\", &dest);\n-\tcheck_int(err, ==, 1);\n-\n-\terr = reftable_stack_read_log(st, \"branch\", &log_dest);\n-\tcheck_int(err, ==, 1);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);\n+\tcl_assert_equal_i(reftable_stack_read_ref(st, \"branch\",\n+\t\t\t\t\t\t &dest), 1);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, \"branch\",\n+\t\t\t\t\t\t &log_dest), 1);\n \treftable_ref_record_release(&dest);\n \treftable_log_record_release(&log_dest);\n \n@@ -833,12 +795,11 @@ static void t_reftable_stack_tombstone(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_hash_id(void)\n+void test_reftable_stack__hash_id(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"master\",\n@@ -852,62 +813,57 @@ static void t_reftable_stack_hash_id(void)\n \tstruct reftable_stack *st_default = NULL;\n \tstruct reftable_ref_record dest = { 0 };\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_test_ref, &ref);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &ref), 0);\n \n \t/* can't read it with the wrong hash ID. */\n-\terr = reftable_new_stack(&st32, dir, &opts32);\n-\tcheck_int(err, ==, REFTABLE_FORMAT_ERROR);\n+\tcl_assert_equal_i(reftable_new_stack(&st32, dir,\n+\t\t\t\t\t &opts32), REFTABLE_FORMAT_ERROR);\n \n \t/* check that we can read it back with default opts too. */\n-\terr = reftable_new_stack(&st_default, dir, &opts_default);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_ref(st_default, \"master\", &dest);\n-\tcheck(!err);\n-\n-\tcheck(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert_equal_i(reftable_new_stack(&st_default, dir,\n+\t\t\t\t\t &opts_default), 0);\n+\tcl_assert_equal_i(reftable_stack_read_ref(st_default, \"master\",\n+\t\t\t\t\t\t &dest), 0);\n+\tcl_assert(reftable_ref_record_equal(&ref, &dest,\n+\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \treftable_ref_record_release(&dest);\n \treftable_stack_destroy(st);\n \treftable_stack_destroy(st_default);\n \tclear_dir(dir);\n }\n \n-static void t_suggest_compaction_segment(void)\n+void test_reftable_stack__suggest_compaction_segment(void)\n {\n \tuint64_t sizes[] = { 512, 64, 17, 16, 9, 9, 9, 16, 2, 16 };\n \tstruct segment min =\n \t\tsuggest_compaction_segment(sizes, ARRAY_SIZE(sizes), 2);\n-\tcheck_int(min.start, ==, 1);\n-\tcheck_int(min.end, ==, 10);\n+\tcl_assert_equal_i(min.start, 1);\n+\tcl_assert_equal_i(min.end, 10);\n }\n \n-static void t_suggest_compaction_segment_nothing(void)\n+void test_reftable_stack__suggest_compaction_segment_nothing(void)\n {\n \tuint64_t sizes[] = { 64, 32, 16, 8, 4, 2 };\n \tstruct segment result =\n \t\tsuggest_compaction_segment(sizes, ARRAY_SIZE(sizes), 2);\n-\tcheck_int(result.start, ==, result.end);\n+\tcl_assert_equal_i(result.start, result.end);\n }\n \n-static void t_reflog_expire(void)\n+void test_reftable_stack__reflog_expire(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n \tstruct reftable_log_record logs[20] = { 0 };\n \tsize_t i, N = ARRAY_SIZE(logs) - 1;\n-\tint err;\n \tstruct reftable_log_expiry_config expiry = {\n \t\t.time = 10,\n \t};\n \tstruct reftable_log_record log = { 0 };\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 1; i <= N; i++) {\n \t\tchar buf[256];\n@@ -918,8 +874,8 @@ static void t_reflog_expire(void)\n \t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n \t\tlogs[i].value.update.time = i;\n \t\tlogs[i].value.update.email = xstrdup(\"identity@invalid\");\n-\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n \tfor (i = 1; i <= N; i++) {\n@@ -927,31 +883,23 @@ static void t_reflog_expire(void)\n \t\t\t.log = &logs[i],\n \t\t\t.update_index = reftable_stack_next_update_index(st),\n \t\t};\n-\t\tint err = reftable_stack_add(st, write_test_log, &arg);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t\t &arg), 0);\n \t}\n \n-\terr = reftable_stack_compact_all(st, NULL);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_compact_all(st, &expiry);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_log(st, logs[9].refname, &log);\n-\tcheck_int(err, ==, 1);\n-\n-\terr = reftable_stack_read_log(st, logs[11].refname, &log);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, &expiry), 0);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, logs[9].refname,\n+\t\t\t\t\t\t &log), 1);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, logs[11].refname,\n+\t\t\t\t\t\t &log), 0);\n \n \texpiry.min_update_index = 15;\n-\terr = reftable_stack_compact_all(st, &expiry);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_log(st, logs[14].refname, &log);\n-\tcheck_int(err, ==, 1);\n-\n-\terr = reftable_stack_read_log(st, logs[16].refname, &log);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, &expiry), 0);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, logs[14].refname,\n+\t\t\t\t\t\t &log), 1);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, logs[16].refname,\n+\t\t\t\t\t\t &log), 0);\n \n \t/* cleanup */\n \treftable_stack_destroy(st);\n@@ -963,26 +911,21 @@ static void t_reflog_expire(void)\n \n static int write_nothing(struct reftable_writer *wr, void *arg UNUSED)\n {\n-\tcheck(!reftable_writer_set_limits(wr, 1, 1));\n+\tcl_assert_equal_i(reftable_writer_set_limits(wr, 1, 1), 0);\n \treturn 0;\n }\n \n-static void t_empty_add(void)\n+void test_reftable_stack__empty_add(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_stack *st2 = NULL;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_nothing, NULL);\n-\tcheck(!err);\n-\n-\terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_nothing,\n+\t\t\t\t\t NULL), 0);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n \tclear_dir(dir);\n \treftable_stack_destroy(st);\n \treftable_stack_destroy(st2);\n@@ -998,18 +941,17 @@ static int fastlogN(uint64_t sz, uint64_t N)\n \treturn l - 1;\n }\n \n-static void t_reftable_stack_auto_compaction(void)\n+void test_reftable_stack__auto_compaction(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.disable_auto_compact = 1,\n \t};\n \tstruct reftable_stack *st = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \tsize_t i, N = 100;\n+\tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tchar name[100];\n@@ -1022,32 +964,31 @@ static void t_reftable_stack_auto_compaction(void)\n \t\tsnprintf(name, sizeof(name), \"branch%04\"PRIuMAX, (uintmax_t)i);\n \n \t\terr = reftable_stack_add(st, write_test_ref, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \n \t\terr = reftable_stack_auto_compact(st);\n-\t\tcheck(!err);\n-\t\tcheck(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));\n+\t\tcl_assert(!err);\n+\t\tcl_assert(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));\n \t}\n \n-\tcheck_int(reftable_stack_compaction_stats(st)->entries_written, <,\n-\t (uint64_t)(N * fastlogN(N, 2)));\n+\tcl_assert(reftable_stack_compaction_stats(st)->entries_written <\n+\t\t\t (uint64_t)(N * fastlogN(N, 2)));\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_auto_compaction_factor(void)\n+void test_reftable_stack__auto_compaction_factor(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.auto_compaction_factor = 5,\n \t};\n \tstruct reftable_stack *st = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \tsize_t N = 100;\n+\tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (size_t i = 0; i < N; i++) {\n \t\tchar name[20];\n@@ -1059,16 +1000,16 @@ static void t_reftable_stack_auto_compaction_factor(void)\n \t\txsnprintf(name, sizeof(name), \"branch%04\"PRIuMAX, (uintmax_t)i);\n \n \t\terr = reftable_stack_add(st, &write_test_ref, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \n-\t\tcheck(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));\n+\t\tcl_assert(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));\n \t}\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_auto_compaction_with_locked_tables(void)\n+void test_reftable_stack__auto_compaction_with_locked_tables(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.disable_auto_compact = 1,\n@@ -1078,21 +1019,20 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)\n \tchar *dir = get_tmp_dir(__LINE__);\n \tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \twrite_n_ref_tables(st, 5);\n-\tcheck_int(st->merged->tables_len, ==, 5);\n+\tcl_assert_equal_i(st->merged->tables_len, 5);\n \n \t/*\n \t * Given that all tables we have written should be roughly the same\n \t * size, we expect that auto-compaction will want to compact all of the\n \t * tables. Locking any of the tables will keep it from doing so.\n \t */\n-\tcheck(!reftable_buf_addstr(&buf, dir));\n-\tcheck(!reftable_buf_addstr(&buf, \"/\"));\n-\tcheck(!reftable_buf_addstr(&buf, st->tables[2]->name));\n-\tcheck(!reftable_buf_addstr(&buf, \".lock\"));\n+\tcl_assert(!reftable_buf_addstr(&buf, dir));\n+\tcl_assert(!reftable_buf_addstr(&buf, \"/\"));\n+\tcl_assert(!reftable_buf_addstr(&buf, st->tables[2]->name));\n+\tcl_assert(!reftable_buf_addstr(&buf, \".lock\"));\n \twrite_file_buf(buf.buf, \"\", 0);\n \n \t/*\n@@ -1102,25 +1042,23 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)\n \t * only compact the newest two tables.\n \t */\n \terr = reftable_stack_auto_compact(st);\n-\tcheck(!err);\n-\tcheck_int(st->stats.failures, ==, 0);\n-\tcheck_int(st->merged->tables_len, ==, 4);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st->stats.failures, 0);\n+\tcl_assert_equal_i(st->merged->tables_len, 4);\n \n \treftable_stack_destroy(st);\n \treftable_buf_release(&buf);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_add_performs_auto_compaction(void)\n+void test_reftable_stack__add_performs_auto_compaction(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \tsize_t i, n = 20;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 0; i <= n; i++) {\n \t\tstruct reftable_ref_record ref = {\n@@ -1140,8 +1078,8 @@ static void t_reftable_stack_add_performs_auto_compaction(void)\n \t\tsnprintf(buf, sizeof(buf), \"branch-%04\"PRIuMAX, (uintmax_t)i);\n \t\tref.refname = buf;\n \n-\t\terr = reftable_stack_add(st, write_test_ref, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t write_test_ref, &ref), 0);\n \n \t\t/*\n \t\t * The stack length should grow continuously for all runs where\n@@ -1149,16 +1087,16 @@ static void t_reftable_stack_add_performs_auto_compaction(void)\n \t\t * all tables in the stack.\n \t\t */\n \t\tif (i != n)\n-\t\t\tcheck_int(st->merged->tables_len, ==, i + 1);\n+\t\t\tcl_assert_equal_i(st->merged->tables_len, i + 1);\n \t\telse\n-\t\t\tcheck_int(st->merged->tables_len, ==, 1);\n+\t\t\tcl_assert_equal_i(st->merged->tables_len, 1);\n \t}\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_compaction_with_locked_tables(void)\n+void test_reftable_stack__compaction_with_locked_tables(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.disable_auto_compact = 1,\n@@ -1168,17 +1106,16 @@ static void t_reftable_stack_compaction_with_locked_tables(void)\n \tchar *dir = get_tmp_dir(__LINE__);\n \tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \twrite_n_ref_tables(st, 3);\n-\tcheck_int(st->merged->tables_len, ==, 3);\n+\tcl_assert_equal_i(st->merged->tables_len, 3);\n \n \t/* Lock one of the tables that we're about to compact. */\n-\tcheck(!reftable_buf_addstr(&buf, dir));\n-\tcheck(!reftable_buf_addstr(&buf, \"/\"));\n-\tcheck(!reftable_buf_addstr(&buf, st->tables[1]->name));\n-\tcheck(!reftable_buf_addstr(&buf, \".lock\"));\n+\tcl_assert(!reftable_buf_addstr(&buf, dir));\n+\tcl_assert(!reftable_buf_addstr(&buf, \"/\"));\n+\tcl_assert(!reftable_buf_addstr(&buf, st->tables[1]->name));\n+\tcl_assert(!reftable_buf_addstr(&buf, \".lock\"));\n \twrite_file_buf(buf.buf, \"\", 0);\n \n \t/*\n@@ -1186,36 +1123,31 @@ static void t_reftable_stack_compaction_with_locked_tables(void)\n \t * compact all tables.\n \t */\n \terr = reftable_stack_compact_all(st, NULL);\n-\tcheck_int(err, ==, REFTABLE_LOCK_ERROR);\n-\tcheck_int(st->stats.failures, ==, 1);\n-\tcheck_int(st->merged->tables_len, ==, 3);\n+\tcl_assert_equal_i(err, REFTABLE_LOCK_ERROR);\n+\tcl_assert_equal_i(st->stats.failures, 1);\n+\tcl_assert_equal_i(st->merged->tables_len, 3);\n \n \treftable_stack_destroy(st);\n \treftable_buf_release(&buf);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_compaction_concurrent(void)\n+void test_reftable_stack__compaction_concurrent(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st1 = NULL, *st2 = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \n-\terr = reftable_new_stack(&st1, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n \twrite_n_ref_tables(st1, 3);\n \n-\terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_compact_all(st1, NULL);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st1, NULL), 0);\n \n \treftable_stack_destroy(st1);\n \treftable_stack_destroy(st2);\n \n-\tcheck_int(count_dir_entries(dir), ==, 2);\n+\tcl_assert_equal_i(count_dir_entries(dir), 2);\n \tclear_dir(dir);\n }\n \n@@ -1228,32 +1160,24 @@ static void unclean_stack_close(struct reftable_stack *st)\n \tREFTABLE_FREE_AND_NULL(st->tables);\n }\n \n-static void t_reftable_stack_compaction_concurrent_clean(void)\n+void test_reftable_stack__compaction_concurrent_clean(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st1 = NULL, *st2 = NULL, *st3 = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \n-\terr = reftable_new_stack(&st1, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n \twrite_n_ref_tables(st1, 3);\n \n-\terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_compact_all(st1, NULL);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st1, NULL), 0);\n \n \tunclean_stack_close(st1);\n \tunclean_stack_close(st2);\n \n-\terr = reftable_new_stack(&st3, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_clean(st3);\n-\tcheck(!err);\n-\tcheck_int(count_dir_entries(dir), ==, 2);\n+\tcl_assert_equal_i(reftable_new_stack(&st3, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_clean(st3), 0);\n+\tcl_assert_equal_i(count_dir_entries(dir), 2);\n \n \treftable_stack_destroy(st1);\n \treftable_stack_destroy(st2);\n@@ -1262,7 +1186,7 @@ static void t_reftable_stack_compaction_concurrent_clean(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_read_across_reload(void)\n+void test_reftable_stack__read_across_reload(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st1 = NULL, *st2 = NULL;\n@@ -1272,37 +1196,35 @@ static void t_reftable_stack_read_across_reload(void)\n \tint err;\n \n \t/* Create a first stack and set up an iterator for it. */\n-\terr = reftable_new_stack(&st1, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n \twrite_n_ref_tables(st1, 2);\n-\tcheck_int(st1->merged->tables_len, ==, 2);\n+\tcl_assert_equal_i(st1->merged->tables_len, 2);\n \treftable_stack_init_ref_iterator(st1, &it);\n-\terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_iterator_seek_ref(&it, \"\"), 0);\n \n \t/* Set up a second stack for the same directory and compact it. */\n \terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n-\tcheck_int(st2->merged->tables_len, ==, 2);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st2->merged->tables_len, 2);\n \terr = reftable_stack_compact_all(st2, NULL);\n-\tcheck(!err);\n-\tcheck_int(st2->merged->tables_len, ==, 1);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st2->merged->tables_len, 1);\n \n \t/*\n \t * Verify that we can continue to use the old iterator even after we\n \t * have reloaded its stack.\n \t */\n \terr = reftable_stack_reload(st1);\n-\tcheck(!err);\n-\tcheck_int(st1->merged->tables_len, ==, 1);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st1->merged->tables_len, 1);\n \terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\tcheck_str(rec.refname, \"refs/heads/branch-0000\");\n+\tcl_assert(!err);\n+\tcl_assert_equal_s(rec.refname, \"refs/heads/branch-0000\");\n \terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\tcheck_str(rec.refname, \"refs/heads/branch-0001\");\n+\tcl_assert(!err);\n+\tcl_assert_equal_s(rec.refname, \"refs/heads/branch-0001\");\n \terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck_int(err, >, 0);\n+\tcl_assert(err > 0);\n \n \treftable_ref_record_release(&rec);\n \treftable_iterator_destroy(&it);\n@@ -1311,7 +1233,7 @@ static void t_reftable_stack_read_across_reload(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_reload_with_missing_table(void)\n+void test_reftable_stack__reload_with_missing_table(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n@@ -1322,46 +1244,40 @@ static void t_reftable_stack_reload_with_missing_table(void)\n \tint err;\n \n \t/* Create a first stack and set up an iterator for it. */\n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \twrite_n_ref_tables(st, 2);\n-\tcheck_int(st->merged->tables_len, ==, 2);\n+\tcl_assert_equal_i(st->merged->tables_len, 2);\n \treftable_stack_init_ref_iterator(st, &it);\n-\terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_iterator_seek_ref(&it, \"\"), 0);\n \n \t/*\n \t * Update the tables.list file with some garbage data, while reusing\n \t * our old tables. This should trigger a partial reload of the stack,\n \t * where we try to reuse our old tables.\n \t*/\n-\tcheck(!reftable_buf_addstr(&content, st->tables[0]->name));\n-\tcheck(!reftable_buf_addstr(&content, \"\\n\"));\n-\tcheck(!reftable_buf_addstr(&content, st->tables[1]->name));\n-\tcheck(!reftable_buf_addstr(&content, \"\\n\"));\n-\tcheck(!reftable_buf_addstr(&content, \"garbage\\n\"));\n-\tcheck(!reftable_buf_addstr(&table_path, st->list_file));\n-\tcheck(!reftable_buf_addstr(&table_path, \".lock\"));\n+\tcl_assert(!reftable_buf_addstr(&content, st->tables[0]->name));\n+\tcl_assert(!reftable_buf_addstr(&content, \"\\n\"));\n+\tcl_assert(!reftable_buf_addstr(&content, st->tables[1]->name));\n+\tcl_assert(!reftable_buf_addstr(&content, \"\\n\"));\n+\tcl_assert(!reftable_buf_addstr(&content, \"garbage\\n\"));\n+\tcl_assert(!reftable_buf_addstr(&table_path, st->list_file));\n+\tcl_assert(!reftable_buf_addstr(&table_path, \".lock\"));\n \twrite_file_buf(table_path.buf, content.buf, content.len);\n-\terr = rename(table_path.buf, st->list_file);\n-\tcheck(!err);\n+\tcl_assert_equal_i(rename(table_path.buf, st->list_file), 0);\n \n \terr = reftable_stack_reload(st);\n-\tcheck_int(err, ==, -4);\n-\tcheck_int(st->merged->tables_len, ==, 2);\n+\tcl_assert_equal_i(err, -4);\n+\tcl_assert_equal_i(st->merged->tables_len, 2);\n \n \t/*\n \t * Even though the reload has failed, we should be able to continue\n \t * using the iterator.\n \t*/\n-\terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\tcheck_str(rec.refname, \"refs/heads/branch-0000\");\n-\terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\tcheck_str(rec.refname, \"refs/heads/branch-0001\");\n-\terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck_int(err, >, 0);\n+\tcl_assert_equal_i(reftable_iterator_next_ref(&it, &rec), 0);\n+\tcl_assert_equal_s(rec.refname, \"refs/heads/branch-0000\");\n+\tcl_assert_equal_i(reftable_iterator_next_ref(&it, &rec), 0);\n+\tcl_assert_equal_s(rec.refname, \"refs/heads/branch-0001\");\n+\tcl_assert(reftable_iterator_next_ref(&it, &rec) > 0);\n \n \treftable_ref_record_release(&rec);\n \treftable_iterator_destroy(&it);\n@@ -1374,12 +1290,13 @@ static void t_reftable_stack_reload_with_missing_table(void)\n static int write_limits_after_ref(struct reftable_writer *wr, void *arg)\n {\n \tstruct reftable_ref_record *ref = arg;\n-\tcheck(!reftable_writer_set_limits(wr, ref->update_index, ref->update_index));\n-\tcheck(!reftable_writer_add_ref(wr, ref));\n+\tcl_assert_equal_i(reftable_writer_set_limits(wr,\n+\t\t\t\t\t\t ref->update_index, ref->update_index), 0);\n+\tcl_assert_equal_i(reftable_writer_add_ref(wr, ref), 0);\n \treturn reftable_writer_set_limits(wr, ref->update_index, ref->update_index);\n }\n \n-static void t_reftable_invalid_limit_updates(void)\n+void test_reftable_stack__invalid_limit_updates(void)\n {\n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"HEAD\",\n@@ -1393,59 +1310,22 @@ static void t_reftable_invalid_limit_updates(void)\n \tstruct reftable_addition *add = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \treftable_addition_destroy(add);\n \n-\terr = reftable_stack_new_addition(&add, st, 0);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st, 0), 0);\n \n \t/*\n \t * write_limits_after_ref also updates the update indexes after adding\n \t * the record. This should cause an err to be returned, since the limits\n \t * must be set at the start.\n \t */\n-\terr = reftable_addition_add(add, write_limits_after_ref, &ref);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_addition_add(add,\n+\t\t\t\t\t\twrite_limits_after_ref, &ref), REFTABLE_API_ERROR);\n \n \treftable_addition_destroy(add);\n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_empty_add(), \"empty addition to stack\");\n-\tTEST(t_read_file(), \"read_lines works\");\n-\tTEST(t_reflog_expire(), \"expire reflog entries\");\n-\tTEST(t_reftable_invalid_limit_updates(), \"prevent limit updates after adding records\");\n-\tTEST(t_reftable_stack_add(), \"add multiple refs and logs to stack\");\n-\tTEST(t_reftable_stack_add_one(), \"add a single ref record to stack\");\n-\tTEST(t_reftable_stack_add_performs_auto_compaction(), \"addition to stack triggers auto-compaction\");\n-\tTEST(t_reftable_stack_auto_compaction(), \"stack must form geometric sequence after compaction\");\n-\tTEST(t_reftable_stack_auto_compaction_factor(), \"auto-compaction with non-default geometric factor\");\n-\tTEST(t_reftable_stack_auto_compaction_fails_gracefully(), \"failure on auto-compaction\");\n-\tTEST(t_reftable_stack_auto_compaction_with_locked_tables(), \"auto compaction with locked tables\");\n-\tTEST(t_reftable_stack_compaction_concurrent(), \"compaction with concurrent stack\");\n-\tTEST(t_reftable_stack_compaction_concurrent_clean(), \"compaction with unclean stack shutdown\");\n-\tTEST(t_reftable_stack_compaction_with_locked_tables(), \"compaction with locked tables\");\n-\tTEST(t_reftable_stack_hash_id(), \"read stack with wrong hash ID\");\n-\tTEST(t_reftable_stack_iterator(), \"log and ref iterator for reftable stack\");\n-\tTEST(t_reftable_stack_lock_failure(), \"stack addition with lockfile failure\");\n-\tTEST(t_reftable_stack_log_normalize(), \"log messages should be normalized\");\n-\tTEST(t_reftable_stack_read_across_reload(), \"stack iterators work across reloads\");\n-\tTEST(t_reftable_stack_reload_with_missing_table(), \"stack iteration with garbage tables\");\n-\tTEST(t_reftable_stack_tombstone(), \"'tombstone' refs in stack\");\n-\tTEST(t_reftable_stack_transaction_api(), \"update transaction to stack\");\n-\tTEST(t_reftable_stack_transaction_with_reload(), \"transaction with reload\");\n-\tTEST(t_reftable_stack_transaction_api_performs_auto_compaction(), \"update transaction triggers auto-compaction\");\n-\tTEST(t_reftable_stack_update_index_check(), \"update transactions with equal update indices\");\n-\tTEST(t_reftable_stack_uptodate(), \"stack must be reloaded before ref update\");\n-\tTEST(t_suggest_compaction_segment(), \"suggest_compaction_segment with basic input\");\n-\tTEST(t_suggest_compaction_segment_nothing(), \"suggest_compaction_segment with pre-compacted input\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"519782","messageId":"20250605140644.239199-11-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250605140644.239199-1-kuforiji98@gmail.com","subject":"[PATCH v4 10/10] t/unit-tests: finalize migration of reftable-related tests","fromName":"Seyi Kuforiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-06-05T14:06:44Z","receivedAt":"2025-06-05T14:08:44Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"The old `lib-reftable.{c,h}` implemented helper functions for our\nhomegrown unit-testing framework. As part of migrating reftable-related\ntests to the Clar framework, Clar-specific versions of these functions\nin `lib-reftable-clar.{c,h}` were introduced.\n\nNow that all test files using these helpers have been converted to Clar,\nwe can safely remove the original `lib-reftable.{c,h}` and rename the\nClar- specific versions back to `lib-reftable.{c,h}`. This restores a\nclean and consistent naming scheme for shared test utilities.\n\nFinally, update our build system to reflect the changes made and remove\nredundant code related to the reftable tests and our old homegrown\nunit-testing setup. `test-lib.{c,h}` remains unchanged in our build\nsystem as some files particularly `t/helper/test-example-tap.c` depends\non it in order to run, and removing that would be beyond the scope of\nthis patch.\n\nSigned-off-by: Seyi Kuforiji \n---\n Makefile | 8 +--\n t/Makefile | 1 -\n t/meson.build | 21 +-----\n t/unit-tests/lib-reftable-clar.c | 101 ----------------------------\n t/unit-tests/lib-reftable-clar.h | 20 ------\n t/unit-tests/lib-reftable.c | 35 +++++-----\n t/unit-tests/lib-reftable.h | 15 ++---\n t/unit-tests/u-reftable-basics.c | 2 +-\n t/unit-tests/u-reftable-block.c | 2 +-\n t/unit-tests/u-reftable-merged.c | 2 +-\n t/unit-tests/u-reftable-pq.c | 2 +-\n t/unit-tests/u-reftable-readwrite.c | 2 +-\n t/unit-tests/u-reftable-record.c | 2 +-\n t/unit-tests/u-reftable-stack.c | 4 +-\n t/unit-tests/u-reftable-table.c | 2 +-\n 15 files changed, 39 insertions(+), 180 deletions(-)\n delete mode 100644 t/unit-tests/lib-reftable-clar.c\n delete mode 100644 t/unit-tests/lib-reftable-clar.h\n\ndiff --git a/Makefile b/Makefile\nindex 8ed8f234f4..25e6558b7b 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1380,13 +1380,11 @@ CLAR_TEST_SUITES += u-urlmatch-normalization\n CLAR_TEST_PROG = $(UNIT_TEST_BIN)/unit-tests$(X)\n CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o\n-CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n-CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n+CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o\n+CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n \n-UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\n-UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o\n \n # xdiff and reftable libs may in turn depend on what is in libgit.a\n GITLIBS = common-main.o $(LIB_FILE) $(XDIFF_LIB) $(REFTABLE_LIB) $(LIB_FILE)\n@@ -3971,4 +3969,4 @@ $(LIBGIT_HIDDEN_EXPORT): $(LIBGIT_PARTIAL_EXPORT)\n \t$(OBJCOPY) --localize-hidden $^ $@\n \n contrib/libgit-sys/libgitpub.a: $(LIBGIT_HIDDEN_EXPORT)\n-\t$(AR) $(ARFLAGS) $@ $^\n\\ No newline at end of file\n+\t$(AR) $(ARFLAGS) $@ $^\ndiff --git a/t/Makefile b/t/Makefile\nindex 791e0a0978..757674e727 100644\n--- a/t/Makefile\n+++ b/t/Makefile\n@@ -125,7 +125,6 @@ check-meson:\n \t@mkdir -p mesontmp && \\\n \tprintf \"%s\\n\" \\\n \t\t\"integration_tests t[0-9][0-9][0-9][0-9]-*.sh\" \\\n-\t\t\"unit_test_programs unit-tests/t-*.c\" \\\n \t\t\"clar_test_suites unit-tests/u-*.c\" | \\\n \twhile read -r variable pattern; do \\\n \t\tawk \"/^$$variable = \\[\\$$/ {flag=1 ; next } /^]$$/ { flag=0 } flag { gsub(/^ \\047/, \\\"\\\"); gsub(/\\047,\\$$/, \\\"\\\"); print }\" meson.build >mesontmp/meson.txt && \\\ndiff --git a/t/meson.build b/t/meson.build\nindex fcbb659263..be96a9639f 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -28,7 +28,7 @@ clar_sources = [\n 'unit-tests/clar/clar.c',\n 'unit-tests/unit-test.c',\n 'unit-tests/lib-oid.c',\n- 'unit-tests/lib-reftable-clar.c'\n+ 'unit-tests/lib-reftable.c'\n ]\n \n clar_decls_h = custom_target(\n@@ -62,25 +62,6 @@ clar_unit_tests = executable('unit-tests',\n )\n test('unit-tests', clar_unit_tests)\n \n-unit_test_programs = [\n-]\n-\n-foreach unit_test_program : unit_test_programs\n- unit_test_name = fs.stem(unit_test_program)\n- unit_test = executable(unit_test_name,\n- sources: [\n- 'unit-tests/test-lib.c',\n- 'unit-tests/lib-reftable.c',\n- unit_test_program,\n- ],\n- dependencies: [libgit_commonmain],\n- )\n- test(unit_test_name, unit_test,\n- workdir: meson.current_source_dir(),\n- timeout: 0,\n- )\n-endforeach\n-\n subdir('helper')\n \n integration_tests = [\ndiff --git a/t/unit-tests/lib-reftable-clar.c b/t/unit-tests/lib-reftable-clar.c\ndeleted file mode 100644\nindex 64e40a106e..0000000000\n--- a/t/unit-tests/lib-reftable-clar.c\n+++ /dev/null\n@@ -1,101 +0,0 @@\n-#include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n-#include \"hex.h\"\n-#include \"parse-options.h\"\n-#include \"reftable/constants.h\"\n-#include \"reftable/writer.h\"\n-#include \"strbuf.h\"\n-#include \"string-list.h\"\n-#include \"strvec.h\"\n-\n-void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id)\n-{\n-\tmemset(p, (uint8_t)i, hash_size(id));\n-}\n-\n-static ssize_t strbuf_writer_write(void *b, const void *data, size_t sz)\n-{\n-\tstrbuf_add(b, data, sz);\n-\treturn sz;\n-}\n-\n-static int strbuf_writer_flush(void *arg UNUSED)\n-{\n-\treturn 0;\n-}\n-\n-struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,\n-\t\t\t\t\t\t struct reftable_write_options *opts)\n-{\n-\tstruct reftable_writer *writer;\n-\tint ret = reftable_writer_new(&writer, &strbuf_writer_write, &strbuf_writer_flush,\n-\t\t\t\t buf, opts);\n-\tcl_assert(!ret);\n-\treturn writer;\n-}\n-\n-void cl_reftable_write_to_buf(struct reftable_buf *buf,\n-\t\t\t struct reftable_ref_record *refs,\n-\t\t\t size_t nrefs,\n-\t\t\t struct reftable_log_record *logs,\n-\t\t\t size_t nlogs,\n-\t\t\t struct reftable_write_options *_opts)\n-{\n-\tstruct reftable_write_options opts = { 0 };\n-\tconst struct reftable_stats *stats;\n-\tstruct reftable_writer *writer;\n-\tuint64_t min = 0xffffffff;\n-\tuint64_t max = 0;\n-\tint ret;\n-\n-\tif (_opts)\n-\t\topts = *_opts;\n-\n-\tfor (size_t i = 0; i < nrefs; i++) {\n-\t\tuint64_t ui = refs[i].update_index;\n-\t\tif (ui > max)\n-\t\t\tmax = ui;\n-\t\tif (ui < min)\n-\t\t\tmin = ui;\n-\t}\n-\tfor (size_t i = 0; i < nlogs; i++) {\n-\t\tuint64_t ui = logs[i].update_index;\n-\t\tif (ui > max)\n-\t\t\tmax = ui;\n-\t\tif (ui < min)\n-\t\t\tmin = ui;\n-\t}\n-\n-\twriter = cl_reftable_strbuf_writer(buf, &opts);\n-\tret = reftable_writer_set_limits(writer, min, max);\n-\tcl_assert_equal_i(ret, 0);\n-\n-\tif (nrefs) {\n-\t\tret = reftable_writer_add_refs(writer, refs, nrefs);\n-\t\tcl_assert_equal_i(ret, 0);\n-\t}\n-\n-\tif (nlogs) {\n-\t\tret = reftable_writer_add_logs(writer, logs, nlogs);\n-\t\tcl_assert_equal_i(ret, 0);\n-\t}\n-\n-\tret = reftable_writer_close(writer);\n-\tcl_assert_equal_i(ret, 0);\n-\n-\tstats = reftable_writer_stats(writer);\n-\tfor (size_t i = 0; i < (size_t)stats->ref_stats.blocks; i++) {\n-\t\tsize_t off = i * (opts.block_size ? opts.block_size\n-\t\t\t\t\t\t : DEFAULT_BLOCK_SIZE);\n-\t\tif (!off)\n-\t\t\toff = header_size(opts.hash_id == REFTABLE_HASH_SHA256 ? 2 : 1);\n-\t\tcl_assert(buf->buf[off] == 'r');\n-\t}\n-\n-\tif (nrefs)\n-\t\tcl_assert(stats->ref_stats.blocks > 0);\n-\tif (nlogs)\n-\t\tcl_assert(stats->log_stats.blocks > 0);\n-\n-\treftable_writer_free(writer);\n-}\ndiff --git a/t/unit-tests/lib-reftable-clar.h b/t/unit-tests/lib-reftable-clar.h\ndeleted file mode 100644\nindex b562648973..0000000000\n--- a/t/unit-tests/lib-reftable-clar.h\n+++ /dev/null\n@@ -1,20 +0,0 @@\n-#include \"git-compat-util.h\"\n-#include \"clar/clar.h\"\n-#include \"clar-decls.h\"\n-#include \"git-compat-util.h\"\n-#include \"reftable/reftable-writer.h\"\n-#include \"strbuf.h\"\n-\n-struct reftable_buf;\n-\n-void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id);\n-\n-struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,\n-\t\t\t\t\t\t struct reftable_write_options *opts);\n-\n-void cl_reftable_write_to_buf(struct reftable_buf *buf,\n-\t\t\t struct reftable_ref_record *refs,\n-\t\t\t size_t nrecords,\n-\t\t\t struct reftable_log_record *logs,\n-\t\t\t size_t nlogs,\n-\t\t\t struct reftable_write_options *opts);\ndiff --git a/t/unit-tests/lib-reftable.c b/t/unit-tests/lib-reftable.c\nindex 8a69612266..fdb5b11a20 100644\n--- a/t/unit-tests/lib-reftable.c\n+++ b/t/unit-tests/lib-reftable.c\n@@ -1,12 +1,14 @@\n-#define DISABLE_SIGN_COMPARE_WARNINGS\n-\n+#include \"unit-test.h\"\n #include \"lib-reftable.h\"\n-#include \"test-lib.h\"\n+#include \"hex.h\"\n+#include \"parse-options.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/writer.h\"\n #include \"strbuf.h\"\n+#include \"string-list.h\"\n+#include \"strvec.h\"\n \n-void t_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id)\n+void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id)\n {\n \tmemset(p, (uint8_t)i, hash_size(id));\n }\n@@ -22,17 +24,17 @@ static int strbuf_writer_flush(void *arg UNUSED)\n \treturn 0;\n }\n \n-struct reftable_writer *t_reftable_strbuf_writer(struct reftable_buf *buf,\n+struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,\n \t\t\t\t\t\t struct reftable_write_options *opts)\n {\n \tstruct reftable_writer *writer;\n \tint ret = reftable_writer_new(&writer, &strbuf_writer_write, &strbuf_writer_flush,\n \t\t\t\t buf, opts);\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \treturn writer;\n }\n \n-void t_reftable_write_to_buf(struct reftable_buf *buf,\n+void cl_reftable_write_to_buf(struct reftable_buf *buf,\n \t\t\t struct reftable_ref_record *refs,\n \t\t\t size_t nrefs,\n \t\t\t struct reftable_log_record *logs,\n@@ -64,35 +66,36 @@ void t_reftable_write_to_buf(struct reftable_buf *buf,\n \t\t\tmin = ui;\n \t}\n \n-\twriter = t_reftable_strbuf_writer(buf, &opts);\n-\treftable_writer_set_limits(writer, min, max);\n+\twriter = cl_reftable_strbuf_writer(buf, &opts);\n+\tret = reftable_writer_set_limits(writer, min, max);\n+\tcl_assert(!ret);\n \n \tif (nrefs) {\n \t\tret = reftable_writer_add_refs(writer, refs, nrefs);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \t}\n \n \tif (nlogs) {\n \t\tret = reftable_writer_add_logs(writer, logs, nlogs);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \t}\n \n \tret = reftable_writer_close(writer);\n-\tcheck_int(ret, ==, 0);\n+\tcl_assert_equal_i(ret, 0);\n \n \tstats = reftable_writer_stats(writer);\n-\tfor (size_t i = 0; i < stats->ref_stats.blocks; i++) {\n+\tfor (size_t i = 0; i < (size_t)stats->ref_stats.blocks; i++) {\n \t\tsize_t off = i * (opts.block_size ? opts.block_size\n \t\t\t\t\t\t : DEFAULT_BLOCK_SIZE);\n \t\tif (!off)\n \t\t\toff = header_size(opts.hash_id == REFTABLE_HASH_SHA256 ? 2 : 1);\n-\t\tcheck_char(buf->buf[off], ==, 'r');\n+\t\tcl_assert(buf->buf[off] == 'r');\n \t}\n \n \tif (nrefs)\n-\t\tcheck_int(stats->ref_stats.blocks, >, 0);\n+\t\tcl_assert(stats->ref_stats.blocks > 0);\n \tif (nlogs)\n-\t\tcheck_int(stats->log_stats.blocks, >, 0);\n+\t\tcl_assert(stats->log_stats.blocks > 0);\n \n \treftable_writer_free(writer);\n }\ndiff --git a/t/unit-tests/lib-reftable.h b/t/unit-tests/lib-reftable.h\nindex e4c360fa7e..d7e6d3136f 100644\n--- a/t/unit-tests/lib-reftable.h\n+++ b/t/unit-tests/lib-reftable.h\n@@ -1,21 +1,20 @@\n-#ifndef LIB_REFTABLE_H\n-#define LIB_REFTABLE_H\n-\n+#include \"git-compat-util.h\"\n+#include \"clar/clar.h\"\n+#include \"clar-decls.h\"\n #include \"git-compat-util.h\"\n #include \"reftable/reftable-writer.h\"\n+#include \"strbuf.h\"\n \n struct reftable_buf;\n \n-void t_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id);\n+void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id);\n \n-struct reftable_writer *t_reftable_strbuf_writer(struct reftable_buf *buf,\n+struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,\n \t\t\t\t\t\t struct reftable_write_options *opts);\n \n-void t_reftable_write_to_buf(struct reftable_buf *buf,\n+void cl_reftable_write_to_buf(struct reftable_buf *buf,\n \t\t\t struct reftable_ref_record *refs,\n \t\t\t size_t nrecords,\n \t\t\t struct reftable_log_record *logs,\n \t\t\t size_t nlogs,\n \t\t\t struct reftable_write_options *opts);\n-\n-#endif\ndiff --git a/t/unit-tests/u-reftable-basics.c b/t/unit-tests/u-reftable-basics.c\nindex f105c22d15..a0471083e7 100644\n--- a/t/unit-tests/u-reftable-basics.c\n+++ b/t/unit-tests/u-reftable-basics.c\n@@ -7,7 +7,7 @@ license that can be found in the LICENSE file or at\n */\n \n #include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/basics.h\"\n \n struct integer_needle_lesseq_args {\ndiff --git a/t/unit-tests/u-reftable-block.c b/t/unit-tests/u-reftable-block.c\nindex 97a1348563..f4bded7d26 100644\n--- a/t/unit-tests/u-reftable-block.c\n+++ b/t/unit-tests/u-reftable-block.c\n@@ -7,7 +7,7 @@ license that can be found in the LICENSE file or at\n */\n \n #include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/block.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/constants.h\"\ndiff --git a/t/unit-tests/u-reftable-merged.c b/t/unit-tests/u-reftable-merged.c\nindex 62b02baa14..54cb7fc2a7 100644\n--- a/t/unit-tests/u-reftable-merged.c\n+++ b/t/unit-tests/u-reftable-merged.c\n@@ -7,7 +7,7 @@ license that can be found in the LICENSE file or at\n */\n \n #include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/merged.h\"\ndiff --git a/t/unit-tests/u-reftable-pq.c b/t/unit-tests/u-reftable-pq.c\nindex d55792ca6f..f8a28f6e07 100644\n--- a/t/unit-tests/u-reftable-pq.c\n+++ b/t/unit-tests/u-reftable-pq.c\n@@ -7,7 +7,7 @@ license that can be found in the LICENSE file or at\n */\n \n #include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/pq.h\"\n #include \"strbuf.h\"\ndiff --git a/t/unit-tests/u-reftable-readwrite.c b/t/unit-tests/u-reftable-readwrite.c\nindex 9aac74a011..4d8c4be5f1 100644\n--- a/t/unit-tests/u-reftable-readwrite.c\n+++ b/t/unit-tests/u-reftable-readwrite.c\n@@ -9,7 +9,7 @@ license that can be found in the LICENSE file or at\n #define DISABLE_SIGN_COMPARE_WARNINGS\n \n #include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/basics.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/reftable-error.h\"\ndiff --git a/t/unit-tests/u-reftable-record.c b/t/unit-tests/u-reftable-record.c\nindex 650b0aa0d3..6c8c0d5374 100644\n--- a/t/unit-tests/u-reftable-record.c\n+++ b/t/unit-tests/u-reftable-record.c\n@@ -7,7 +7,7 @@\n */\n \n #include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/basics.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/record.h\"\ndiff --git a/t/unit-tests/u-reftable-stack.c b/t/unit-tests/u-reftable-stack.c\nindex 0e3e3f4f4a..e4ea57138e 100644\n--- a/t/unit-tests/u-reftable-stack.c\n+++ b/t/unit-tests/u-reftable-stack.c\n@@ -10,7 +10,7 @@ license that can be found in the LICENSE file or at\n \n #include \"unit-test.h\"\n #include \"dir.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/merged.h\"\n #include \"reftable/reftable-error.h\"\n #include \"reftable/stack.h\"\n@@ -497,7 +497,7 @@ void test_reftable_stack__add(void)\n \tstruct reftable_buf path = REFTABLE_BUF_INIT;\n \tstruct stat stat_result;\n \tsize_t i, N = ARRAY_SIZE(refs);\n-\tint err;\n+\tint err = 0;\n \n \terr = reftable_new_stack(&st, dir, &opts);\n \tcl_assert(!err);\ndiff --git a/t/unit-tests/u-reftable-table.c b/t/unit-tests/u-reftable-table.c\nindex 839107d8a4..14fae8b199 100644\n--- a/t/unit-tests/u-reftable-table.c\n+++ b/t/unit-tests/u-reftable-table.c\n@@ -1,5 +1,5 @@\n #include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/iter.h\"\n-- \n2.43.0\n\n"},{"id":"519799","messageId":"xmqqikla86id.fsf@gitster.g","threadId":"63589","inReplyTo":"20250605140644.239199-7-kuforiji98@gmail.com","subject":"Re: [PATCH v4 06/10] t/unit-tests: convert reftable table test to use clar","fromName":"Junio C Hamano","fromEmail":"gitster@pobox.com","sentAt":"2025-06-05T17:04:10Z","receivedAt":"2025-06-05T17:04:13Z","isPatch":true,"sender":{"key":"gitster@pobox.com","avatar":"https://avatars.githubusercontent.com/u/54884?v=4"},"body":"Seyi Kuforiji writes:\n\n> diff --git a/Makefile b/Makefile\n> index 3cccc73073..0227fdb3e1 100644\n> --- a/Makefile\n> +++ b/Makefile\n> @@ -1368,6 +1368,7 @@ CLAR_TEST_SUITES += u-reftable-basics\n> ...\n> @@ -3972,4 +3972,4 @@ $(LIBGIT_HIDDEN_EXPORT): $(LIBGIT_PARTIAL_EXPORT)\n> \t$(OBJCOPY) --localize-hidden $^ $@\n> \n> contrib/libgit-sys/libgitpub.a: $(LIBGIT_HIDDEN_EXPORT)\n> -\t$(AR) $(ARFLAGS) $@ $^\n> +\t$(AR) $(ARFLAGS) $@ $^\n> \\ No newline at end of file\n\nI am sure I pointed this breakage out, locally fixed it in my tree,\nand told you about the consequences of such breakage. Next time\nplease make sure you fetch back from what upstream has its 'seen'\nand start your work from that state.\n\nIn addition, perhaps you should fix your editor settings to avoid\nfiles with such an incomplete line at the end. There may be other\nincomplete lines in this seris.\n\nAnd a possible #leftoverbits is probably to teach the whitespace\nerror checking code to optionally flag a new incomplete line as an\nerror (this is obviously way outside the topic of this series).\n\nThanks.\n"},{"id":"522606","messageId":"xmqq5xfimw7i.fsf@gitster.g","threadId":"63589","inReplyTo":"20250605140644.239199-1-kuforiji98@gmail.com","subject":"Re: [PATCH v4 00/10] t/unit-tests: convert unit-tests to use clar","fromName":"Junio C Hamano","fromEmail":"gitster@pobox.com","sentAt":"2025-07-23T21:30:25Z","receivedAt":"2025-07-23T21:30:28Z","isPatch":true,"sender":{"key":"gitster@pobox.com","avatar":"https://avatars.githubusercontent.com/u/54884?v=4"},"body":"Seyi Kuforiji writes:\n\n> This patch series marks the final batch of our existing unit test files\n> transitioned to the Clar testing framework. It covers all the\n> reftable-related test files, and is part of our ongoing effort to\n> standardize our testing framework to enhance its maintainability.\n>\n> Changes in v4:\n> - some code refactoring and cleanup based on review.\n\nNothing seems to have happened to the topic (other than one obvious\nbreakage pointed out on 06/10) and it has been more than a month and\na half. What's the status of this topic?\n\nThanks.\n"},{"id":"522629","messageId":"aIHW9rW-VkhkR8nn@pks.im","threadId":"63589","inReplyTo":"xmqq5xfimw7i.fsf@gitster.g","subject":"Re: [PATCH v4 00/10] t/unit-tests: convert unit-tests to use clar","fromName":"Patrick Steinhardt","fromEmail":"ps@pks.im","sentAt":"2025-07-24T06:47:18Z","receivedAt":"2025-07-24T06:47:26Z","isPatch":true,"sender":{"key":"ps@pks.im","avatar":"https://avatars.githubusercontent.com/u/4056630?v=4"},"body":"On Wed, Jul 23, 2025 at 02:30:25PM -0700, Junio C Hamano wrote:\n> Seyi Kuforiji writes:\n> \n> > This patch series marks the final batch of our existing unit test files\n> > transitioned to the Clar testing framework. It covers all the\n> > reftable-related test files, and is part of our ongoing effort to\n> > standardize our testing framework to enhance its maintainability.\n> >\n> > Changes in v4:\n> > - some code refactoring and cleanup based on review.\n> \n> Nothing seems to have happened to the topic (other than one obvious\n> breakage pointed out on 06/10) and it has been more than a month and\n> a half. What's the status of this topic?\n\nSorry, I completely lost this from my radar. There's a single line\nthat's part of the wrong commit, but other than that I think this series\nis good enough now.\n\nThanks for the ping!\n\nPatrick\n"},{"id":"522630","messageId":"aIHXAA7DmZ2JDKN1@pks.im","threadId":"63589","inReplyTo":"20250605140644.239199-10-kuforiji98@gmail.com","subject":"Re: [PATCH v4 09/10] t/unit-tests: convert reftable stack test to use clar","fromName":"Patrick Steinhardt","fromEmail":"ps@pks.im","sentAt":"2025-07-24T06:47:28Z","receivedAt":"2025-07-24T06:47:33Z","isPatch":true,"sender":{"key":"ps@pks.im","avatar":"https://avatars.githubusercontent.com/u/4056630?v=4"},"body":"On Thu, Jun 05, 2025 at 03:06:43PM +0100, Seyi Kuforiji wrote:\n> diff --git a/t/meson.build b/t/meson.build\n> index 297937f307..fcbb659263 100644\n> --- a/t/meson.build\n> +++ b/t/meson.build\n> @@ -13,6 +13,8 @@ clar_test_suites = [\n> 'unit-tests/u-reftable-merged.c',\n> 'unit-tests/u-reftable-pq.c',\n> 'unit-tests/u-reftable-readwrite.c',\n> + 'unit-tests/u-reftable-record.c',\n\nThis change belongs into the previous commit.\n\n> + 'unit-tests/u-reftable-stack.c',\n> 'unit-tests/u-reftable-table.c',\n> 'unit-tests/u-reftable-tree.c',\n> 'unit-tests/u-strbuf.c',\n\nPatrick\n"},{"id":"522661","messageId":"20250724132813.59627-1-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250605140644.239199-1-kuforiji98@gmail.com","subject":"[PATCH v5 0/5] t/unit-tests: convert unit-tests to use clar","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T13:28:08Z","receivedAt":"2025-07-24T13:29:14Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kufoiji \n\nHello,\n\nThis patch series marks the final batch of our existing unit test files\ntransitioned to the Clar testing framework. It covers all the\nreftable-related test files, and is part of our ongoing effort to\nstandardize our testing framework to enhance its maintainability.\n\nChanges in v5:\n - some code refactoring and cleanup based on review.\n\nThanks\nSeyi\n\nSigned-off-by: Seyi Kuforiji \n\nSeyi Kuforiji (5):\n t/unit-tests: convert reftable table test to use clar\n t/unit-tests: convert reftable readwrite test to use clar\n t/unit-tests: convert reftable record test to use clar\n t/unit-tests: convert reftable stack test to use clar\n t/unit-tests: finalize migration of reftable-related tests\n\n Makefile | 13 +-\n t/Makefile | 1 -\n t/meson.build | 34 +-\n t/unit-tests/lib-reftable-clar.c | 101 ---\n t/unit-tests/lib-reftable-clar.h | 20 -\n t/unit-tests/lib-reftable.c | 35 +-\n t/unit-tests/lib-reftable.h | 15 +-\n t/unit-tests/u-reftable-basics.c | 2 +-\n t/unit-tests/u-reftable-block.c | 2 +-\n t/unit-tests/u-reftable-merged.c | 2 +-\n t/unit-tests/u-reftable-pq.c | 2 +-\n ...ble-readwrite.c => u-reftable-readwrite.c} | 403 ++++-----\n ...-reftable-record.c => u-reftable-record.c} | 250 +++---\n ...{t-reftable-stack.c => u-reftable-stack.c} | 780 ++++++++----------\n ...{t-reftable-table.c => u-reftable-table.c} | 73 +-\n 15 files changed, 711 insertions(+), 1022 deletions(-)\n delete mode 100644 t/unit-tests/lib-reftable-clar.c\n delete mode 100644 t/unit-tests/lib-reftable-clar.h\n rename t/unit-tests/{t-reftable-readwrite.c => u-reftable-readwrite.c} (68%)\n rename t/unit-tests/{t-reftable-record.c => u-reftable-record.c} (62%)\n rename t/unit-tests/{t-reftable-stack.c => u-reftable-stack.c} (59%)\n rename t/unit-tests/{t-reftable-table.c => u-reftable-table.c} (75%)\n\nRange-diff against v4:\n1: cf8b0471fd ! 1: 7c159bd2fe t/unit-tests: convert reftable table test to use clar\n @@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o\n +@@ Makefile: $(LIBGIT_HIDDEN_EXPORT): $(LIBGIT_PARTIAL_EXPORT)\n + \t$(OBJCOPY) --localize-hidden $^ $@\n + \n + contrib/libgit-sys/libgitpub.a: $(LIBGIT_HIDDEN_EXPORT)\n +-\t$(AR) $(ARFLAGS) $@ $^\n ++\t$(AR) $(ARFLAGS) $@ $^\n + \\ No newline at end of file\n \n ## t/meson.build ##\n @@ t/meson.build: clar_test_suites = [\n2: cbe70c5c23 = 2: 3ae3b2cf9c t/unit-tests: convert reftable readwrite test to use clar\n3: 38e2198eac ! 3: d4303eb913 t/unit-tests: convert reftable record test to use clar\n @@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\n \n ## t/meson.build ##\n -@@ t/meson.build: clar_test_suites = [\n - 'unit-tests/u-reftable-merged.c',\n - 'unit-tests/u-reftable-pq.c',\n - 'unit-tests/u-reftable-readwrite.c',\n -+ 'unit-tests/u-reftable-record.c',\n - 'unit-tests/u-reftable-table.c',\n - 'unit-tests/u-reftable-tree.c',\n - 'unit-tests/u-strbuf.c',\n @@ t/meson.build: clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n4: 8de9dbbd3b ! 4: df582f6e2c t/unit-tests: convert reftable stack test to use clar\n @@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n \n ## t/meson.build ##\n @@ t/meson.build: clar_test_suites = [\n + 'unit-tests/u-reftable-merged.c',\n 'unit-tests/u-reftable-pq.c',\n 'unit-tests/u-reftable-readwrite.c',\n - 'unit-tests/u-reftable-record.c',\n ++ 'unit-tests/u-reftable-record.c',\n + 'unit-tests/u-reftable-stack.c',\n 'unit-tests/u-reftable-table.c',\n 'unit-tests/u-reftable-tree.c',\n5: a69c3370ee ! 5: 9340e7ce88 t/unit-tests: finalize migration of reftable-related tests\n @@ Makefile: CLAR_TEST_SUITES += u-urlmatch-normalization\n \n # xdiff and reftable libs may in turn depend on what is in libgit.a\n GITLIBS = common-main.o $(LIB_FILE) $(XDIFF_LIB) $(REFTABLE_LIB) $(LIB_FILE)\n +@@ Makefile: $(LIBGIT_HIDDEN_EXPORT): $(LIBGIT_PARTIAL_EXPORT)\n + \t$(OBJCOPY) --localize-hidden $^ $@\n + \n + contrib/libgit-sys/libgitpub.a: $(LIBGIT_HIDDEN_EXPORT)\n +-\t$(AR) $(ARFLAGS) $@ $^\n + \\ No newline at end of file\n ++\t$(AR) $(ARFLAGS) $@ $^\n \n ## t/Makefile ##\n @@ t/Makefile: check-meson:\n-- \n2.43.0\n\n"},{"id":"522662","messageId":"20250724132813.59627-2-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250724132813.59627-1-kuforiji98@gmail.com","subject":"[PATCH v5 1/5] t/unit-tests: convert reftable table test to use clar","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T13:28:09Z","receivedAt":"2025-07-24T13:29:38Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kuforiji \n\nAdapt reftable table test file to use clar by using clar assertions\nwhere necessary.\n\nSigned-off-by: Seyi Kuforiji \nSigned-off-by: Junio C Hamano \n---\n Makefile | 4 +-\n t/meson.build | 5 +-\n ...{t-reftable-table.c => u-reftable-table.c} | 75 +++++++++----------\n 3 files changed, 39 insertions(+), 45 deletions(-)\n rename t/unit-tests/{t-reftable-table.c => u-reftable-table.c} (75%)\n\ndiff --git a/Makefile b/Makefile\nindex 3cccc73073..0227fdb3e1 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1368,6 +1368,7 @@ CLAR_TEST_SUITES += u-reftable-basics\n CLAR_TEST_SUITES += u-reftable-block\n CLAR_TEST_SUITES += u-reftable-merged\n CLAR_TEST_SUITES += u-reftable-pq\n+CLAR_TEST_SUITES += u-reftable-table\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n CLAR_TEST_SUITES += u-strcmp-offset\n@@ -1384,7 +1385,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n UNIT_TEST_PROGRAMS += t-reftable-readwrite\n UNIT_TEST_PROGRAMS += t-reftable-record\n UNIT_TEST_PROGRAMS += t-reftable-stack\n-UNIT_TEST_PROGRAMS += t-reftable-table\n UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o\n@@ -3972,4 +3972,4 @@ $(LIBGIT_HIDDEN_EXPORT): $(LIBGIT_PARTIAL_EXPORT)\n \t$(OBJCOPY) --localize-hidden $^ $@\n \n contrib/libgit-sys/libgitpub.a: $(LIBGIT_HIDDEN_EXPORT)\n-\t$(AR) $(ARFLAGS) $@ $^\n+\t$(AR) $(ARFLAGS) $@ $^\n\\ No newline at end of file\ndiff --git a/t/meson.build b/t/meson.build\nindex ac4394b7a2..46d3a8580b 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -12,6 +12,7 @@ clar_test_suites = [\n 'unit-tests/u-reftable-block.c',\n 'unit-tests/u-reftable-merged.c',\n 'unit-tests/u-reftable-pq.c',\n+ 'unit-tests/u-reftable-table.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n 'unit-tests/u-strcmp-offset.c',\n@@ -59,11 +60,9 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-reader.c',\n 'unit-tests/t-reftable-readwrite.c',\n 'unit-tests/t-reftable-record.c',\n 'unit-tests/t-reftable-stack.c',\n- 'unit-tests/t-reftable-table.c',\n ]\n \n foreach unit_test_program : unit_test_programs\n@@ -1233,4 +1232,4 @@ if perl.found() and time.found()\n timeout: 0,\n )\n endforeach\n-endif\n+endif\n\\ No newline at end of file\ndiff --git a/t/unit-tests/t-reftable-table.c b/t/unit-tests/u-reftable-table.c\nsimilarity index 75%\nrename from t/unit-tests/t-reftable-table.c\nrename to t/unit-tests/u-reftable-table.c\nindex 7e1eb533d0..839107d8a4 100644\n--- a/t/unit-tests/t-reftable-table.c\n+++ b/t/unit-tests/u-reftable-table.c\n@@ -1,12 +1,12 @@\n-#include \"test-lib.h\"\n-#include \"lib-reftable.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/iter.h\"\n #include \"reftable/table.h\"\n #include \"strbuf.h\"\n \n-static int t_table_seek_once(void)\n+void test_reftable_table__seek_once(void)\n {\n \tstruct reftable_ref_record records[] = {\n \t\t{\n@@ -22,32 +22,32 @@ static int t_table_seek_once(void)\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tint ret;\n \n-\tt_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);\n+\tcl_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);\n \tblock_source_from_buf(&source, &buf);\n \n \tret = reftable_table_new(&table, &source, \"name\");\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \treftable_table_init_ref_iterator(table, &it);\n \tret = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \tret = reftable_iterator_next_ref(&it, &ref);\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n-\tret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1);\n-\tcheck_int(ret, ==, 1);\n+\tret = reftable_ref_record_equal(&ref, &records[0],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1);\n+\tcl_assert_equal_i(ret, 1);\n \n \tret = reftable_iterator_next_ref(&it, &ref);\n-\tcheck_int(ret, ==, 1);\n+\tcl_assert_equal_i(ret, 1);\n \n \treftable_ref_record_release(&ref);\n \treftable_iterator_destroy(&it);\n \treftable_table_decref(table);\n \treftable_buf_release(&buf);\n-\treturn 0;\n }\n \n-static int t_table_reseek(void)\n+void test_reftable_table__reseek(void)\n {\n \tstruct reftable_ref_record records[] = {\n \t\t{\n@@ -63,35 +63,35 @@ static int t_table_reseek(void)\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tint ret;\n \n-\tt_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);\n+\tcl_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records),\n+\t\t\t\t NULL, 0, NULL);\n \tblock_source_from_buf(&source, &buf);\n \n \tret = reftable_table_new(&table, &source, \"name\");\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \treftable_table_init_ref_iterator(table, &it);\n \n \tfor (size_t i = 0; i < 5; i++) {\n \t\tret = reftable_iterator_seek_ref(&it, \"\");\n-\t\tcheck(!ret);\n+\t\tcl_assert(!ret);\n \t\tret = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck(!ret);\n+\t\tcl_assert(!ret);\n \n \t\tret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck_int(ret, ==, 1);\n+\t\tcl_assert_equal_i(ret, 1);\n \n \t\tret = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck_int(ret, ==, 1);\n+\t\tcl_assert_equal_i(ret, 1);\n \t}\n \n \treftable_ref_record_release(&ref);\n \treftable_iterator_destroy(&it);\n \treftable_table_decref(table);\n \treftable_buf_release(&buf);\n-\treturn 0;\n }\n \n-static int t_table_block_iterator(void)\n+void test_reftable_table__block_iterator(void)\n {\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_table_iterator it = { 0 };\n@@ -147,14 +147,14 @@ static int t_table_block_iterator(void)\n \t\t\t\t\t (uintmax_t) i);\n \t}\n \n-\tt_reftable_write_to_buf(&buf, records, nrecords, NULL, 0, NULL);\n+\tcl_reftable_write_to_buf(&buf, records, nrecords, NULL, 0, NULL);\n \tblock_source_from_buf(&source, &buf);\n \n \tret = reftable_table_new(&table, &source, \"name\");\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \tret = reftable_table_iterator_init(&it, table);\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(expected_blocks); i++) {\n \t\tstruct reftable_iterator record_it = { 0 };\n@@ -163,22 +163,26 @@ static int t_table_block_iterator(void)\n \t\t};\n \n \t\tret = reftable_table_iterator_next(&it, &block);\n-\t\tcheck(!ret);\n+\t\tcl_assert(!ret);\n \n-\t\tcheck_int(block->block_type, ==, expected_blocks[i].block_type);\n-\t\tcheck_int(block->header_off, ==, expected_blocks[i].header_off);\n-\t\tcheck_int(block->restart_count, ==, expected_blocks[i].restart_count);\n+\t\tcl_assert_equal_i(block->block_type,\n+\t\t\t\t expected_blocks[i].block_type);\n+\t\tcl_assert_equal_i(block->header_off,\n+\t\t\t\t expected_blocks[i].header_off);\n+\t\tcl_assert_equal_i(block->restart_count,\n+\t\t\t\t expected_blocks[i].restart_count);\n \n \t\tret = reftable_block_init_iterator(block, &record_it);\n-\t\tcheck(!ret);\n+\t\tcl_assert(!ret);\n \n \t\tfor (size_t j = 0; ; j++) {\n \t\t\tret = iterator_next(&record_it, &record);\n \t\t\tif (ret > 0) {\n-\t\t\t\tcheck_int(j, ==, expected_blocks[i].record_count);\n+\t\t\t\tcl_assert_equal_i(j,\n+\t\t\t\t\t\t expected_blocks[i].record_count);\n \t\t\t\tbreak;\n \t\t\t}\n-\t\t\tcheck(!ret);\n+\t\t\tcl_assert(!ret);\n \t\t}\n \n \t\treftable_iterator_destroy(&record_it);\n@@ -186,7 +190,7 @@ static int t_table_block_iterator(void)\n \t}\n \n \tret = reftable_table_iterator_next(&it, &block);\n-\tcheck_int(ret, ==, 1);\n+\tcl_assert_equal_i(ret, 1);\n \n \tfor (size_t i = 0; i < nrecords; i++)\n \t\treftable_free(records[i].refname);\n@@ -194,13 +198,4 @@ static int t_table_block_iterator(void)\n \treftable_table_decref(table);\n \treftable_buf_release(&buf);\n \treftable_free(records);\n-\treturn 0;\n-}\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_table_seek_once(), \"table can seek once\");\n-\tTEST(t_table_reseek(), \"table can reseek multiple times\");\n-\tTEST(t_table_block_iterator(), \"table can iterate through blocks\");\n-\treturn test_done();\n }\n-- \n2.43.0\n\n"},{"id":"522663","messageId":"20250724132813.59627-3-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250724132813.59627-1-kuforiji98@gmail.com","subject":"[PATCH v5 2/5] t/unit-tests: convert reftable readwrite test to use clar","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T13:28:10Z","receivedAt":"2025-07-24T13:29:44Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kuforiji \n\nAdapt reftable readwrite test file to use clar by using clar assertions\nwhere necessary.\n\nSigned-off-by: Seyi Kuforiji \nSigned-off-by: Junio C Hamano \n---\n Makefile | 2 +-\n t/meson.build | 2 +-\n ...ble-readwrite.c => u-reftable-readwrite.c} | 405 ++++++++----------\n 3 files changed, 179 insertions(+), 230 deletions(-)\n rename t/unit-tests/{t-reftable-readwrite.c => u-reftable-readwrite.c} (68%)\n\ndiff --git a/Makefile b/Makefile\nindex 0227fdb3e1..d86ef5a142 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1368,6 +1368,7 @@ CLAR_TEST_SUITES += u-reftable-basics\n CLAR_TEST_SUITES += u-reftable-block\n CLAR_TEST_SUITES += u-reftable-merged\n CLAR_TEST_SUITES += u-reftable-pq\n+CLAR_TEST_SUITES += u-reftable-readwrite\n CLAR_TEST_SUITES += u-reftable-table\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n@@ -1382,7 +1383,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-readwrite\n UNIT_TEST_PROGRAMS += t-reftable-record\n UNIT_TEST_PROGRAMS += t-reftable-stack\n UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\ndiff --git a/t/meson.build b/t/meson.build\nindex 46d3a8580b..5189176472 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -12,6 +12,7 @@ clar_test_suites = [\n 'unit-tests/u-reftable-block.c',\n 'unit-tests/u-reftable-merged.c',\n 'unit-tests/u-reftable-pq.c',\n+ 'unit-tests/u-reftable-readwrite.c',\n 'unit-tests/u-reftable-table.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n@@ -60,7 +61,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-readwrite.c',\n 'unit-tests/t-reftable-record.c',\n 'unit-tests/t-reftable-stack.c',\n ]\ndiff --git a/t/unit-tests/t-reftable-readwrite.c b/t/unit-tests/u-reftable-readwrite.c\nsimilarity index 68%\nrename from t/unit-tests/t-reftable-readwrite.c\nrename to t/unit-tests/u-reftable-readwrite.c\nindex 4c49129439..9aac74a011 100644\n--- a/t/unit-tests/t-reftable-readwrite.c\n+++ b/t/unit-tests/u-reftable-readwrite.c\n@@ -8,8 +8,8 @@ license that can be found in the LICENSE file or at\n \n #define DISABLE_SIGN_COMPARE_WARNINGS\n \n-#include \"test-lib.h\"\n-#include \"lib-reftable.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/basics.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/reftable-error.h\"\n@@ -19,24 +19,24 @@ license that can be found in the LICENSE file or at\n \n static const int update_index = 5;\n \n-static void t_buffer(void)\n+void test_reftable_readwrite__buffer(void)\n {\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_block_data out = { 0 };\n \tint n;\n \tuint8_t in[] = \"hello\";\n-\tcheck(!reftable_buf_add(&buf, in, sizeof(in)));\n+\tcl_assert_equal_i(reftable_buf_add(&buf, in, sizeof(in)), 0);\n \tblock_source_from_buf(&source, &buf);\n-\tcheck_int(block_source_size(&source), ==, 6);\n+\tcl_assert_equal_i(block_source_size(&source), 6);\n \tn = block_source_read_data(&source, &out, 0, sizeof(in));\n-\tcheck_int(n, ==, sizeof(in));\n-\tcheck(!memcmp(in, out.data, n));\n+\tcl_assert_equal_i(n, sizeof(in));\n+\tcl_assert(!memcmp(in, out.data, n));\n \tblock_source_release_data(&out);\n \n \tn = block_source_read_data(&source, &out, 1, 2);\n-\tcheck_int(n, ==, 2);\n-\tcheck(!memcmp(out.data, \"el\", 2));\n+\tcl_assert_equal_i(n, 2);\n+\tcl_assert(!memcmp(out.data, \"el\", 2));\n \n \tblock_source_release_data(&out);\n \tblock_source_close(&source);\n@@ -55,41 +55,41 @@ static void write_table(char ***names, struct reftable_buf *buf, int N,\n \tint i;\n \n \tREFTABLE_CALLOC_ARRAY(*names, N + 1);\n-\tcheck(*names != NULL);\n+\tcl_assert(*names != NULL);\n \tREFTABLE_CALLOC_ARRAY(refs, N);\n-\tcheck(refs != NULL);\n+\tcl_assert(refs != NULL);\n \tREFTABLE_CALLOC_ARRAY(logs, N);\n-\tcheck(logs != NULL);\n+\tcl_assert(logs != NULL);\n \n \tfor (i = 0; i < N; i++) {\n \t\trefs[i].refname = (*names)[i] = xstrfmt(\"refs/heads/branch%02d\", i);\n \t\trefs[i].update_index = update_index;\n \t\trefs[i].value_type = REFTABLE_REF_VAL1;\n-\t\tt_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n \t\tlogs[i].refname = (*names)[i];\n \t\tlogs[i].update_index = update_index;\n \t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n-\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t\tlogs[i].value.update.message = (char *) \"message\";\n \t}\n \n-\tt_reftable_write_to_buf(buf, refs, N, logs, N, &opts);\n+\tcl_reftable_write_to_buf(buf, refs, N, logs, N, &opts);\n \n \treftable_free(refs);\n \treftable_free(logs);\n }\n \n-static void t_log_buffer_size(void)\n+void test_reftable_readwrite__log_buffer_size(void)\n {\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 4096,\n \t};\n-\tint err;\n \tint i;\n \tstruct reftable_log_record\n \t\tlog = { .refname = (char *) \"refs/heads/master\",\n@@ -102,7 +102,8 @@ static void t_log_buffer_size(void)\n \t\t\t\t\t .time = 0x5e430672,\n \t\t\t\t\t .message = (char *) \"commit: 9\\n\",\n \t\t\t\t } } };\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \n \t/* This tests buffer extension for log compression. Must use a random\n \t hash, to ensure that the compressed part is larger than the original.\n@@ -112,22 +113,19 @@ static void t_log_buffer_size(void)\n \t\tlog.value.update.new_hash[i] = (uint8_t)(git_rand(0) % 256);\n \t}\n \treftable_writer_set_limits(w, update_index, update_index);\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck(!err);\n-\terr = reftable_writer_close(w);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_log_overflow(void)\n+void test_reftable_readwrite__log_overflow(void)\n {\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tchar msg[256] = { 0 };\n \tstruct reftable_write_options opts = {\n \t\t.block_size = ARRAY_SIZE(msg),\n \t};\n-\tint err;\n \tstruct reftable_log_record log = {\n \t\t.refname = (char *) \"refs/heads/master\",\n \t\t.update_index = update_index,\n@@ -144,21 +142,22 @@ static void t_log_overflow(void)\n \t\t\t},\n \t\t},\n \t};\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \n \tmemset(msg, 'x', sizeof(msg) - 1);\n \treftable_writer_set_limits(w, update_index, update_index);\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck_int(err, ==, REFTABLE_ENTRY_TOO_BIG_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), REFTABLE_ENTRY_TOO_BIG_ERROR);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_log_write_limits(void)\n+void test_reftable_readwrite__log_write_limits(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \tstruct reftable_log_record log = {\n \t\t.refname = (char *)\"refs/head/master\",\n \t\t.update_index = 0,\n@@ -174,29 +173,25 @@ static void t_log_write_limits(void)\n \t\t\t},\n \t\t},\n \t};\n-\tint err;\n \n \treftable_writer_set_limits(w, 1, 1);\n \n \t/* write with update_index (0) below set limits (1, 1) */\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck_int(err, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n \n \t/* write with update_index (1) in the set limits (1, 1) */\n \tlog.update_index = 1;\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck_int(err, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n \n \t/* write with update_index (3) above set limits (1, 1) */\n \tlog.update_index = 3;\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), REFTABLE_API_ERROR);\n \n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_log_write_read(void)\n+void test_reftable_readwrite__log_write_read(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 256,\n@@ -207,13 +202,14 @@ static void t_log_write_read(void)\n \tstruct reftable_table *table;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tconst struct reftable_stats *stats = NULL;\n-\tint N = 2, err, i, n;\n+\tint N = 2, i;\n \tchar **names;\n+\tint err;\n \n \tnames = reftable_calloc(N + 1, sizeof(*names));\n-\tcheck(names != NULL);\n+\tcl_assert(names != NULL);\n \n \treftable_writer_set_limits(w, 0, N);\n \n@@ -225,8 +221,7 @@ static void t_log_write_read(void)\n \t\tref.refname = name;\n \t\tref.update_index = i;\n \n-\t\terr = reftable_writer_add_ref(w, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n@@ -235,60 +230,57 @@ static void t_log_write_read(void)\n \t\tlog.refname = names[i];\n \t\tlog.update_index = i;\n \t\tlog.value_type = REFTABLE_LOG_UPDATE;\n-\t\tt_reftable_set_hash(log.value.update.old_hash, i,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n-\t\tt_reftable_set_hash(log.value.update.new_hash, i + 1,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(log.value.update.old_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(log.value.update.new_hash, i + 1,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \n-\t\terr = reftable_writer_add_log(w, &log);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n \t}\n \n-\tn = reftable_writer_close(w);\n-\tcheck_int(n, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \n \tstats = reftable_writer_stats(w);\n-\tcheck_int(stats->log_stats.blocks, >, 0);\n+\tcl_assert(stats->log_stats.blocks > 0);\n \treftable_writer_free(w);\n \tw = NULL;\n \n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.log\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_iterator_seek_ref(&it, names[N - 1]);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_iterator_next_ref(&it, &ref);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \t/* end of iteration. */\n-\terr = reftable_iterator_next_ref(&it, &ref);\n-\tcheck_int(err, >, 0);\n+\tcl_assert(reftable_iterator_next_ref(&it, &ref) > 0);\n \n \treftable_iterator_destroy(&it);\n \treftable_ref_record_release(&ref);\n \n \terr = reftable_table_init_log_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_log(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (i = 0; ; i++) {\n \t\tint err = reftable_iterator_next_log(&it, &log);\n \t\tif (err > 0)\n \t\t\tbreak;\n-\t\tcheck(!err);\n-\t\tcheck_str(names[i], log.refname);\n-\t\tcheck_int(i, ==, log.update_index);\n+\t\tcl_assert(!err);\n+\t\tcl_assert_equal_s(names[i], log.refname);\n+\t\tcl_assert_equal_i(i, log.update_index);\n \t\treftable_log_record_release(&log);\n \t}\n \n-\tcheck_int(i, ==, N);\n+\tcl_assert_equal_i(i, N);\n \treftable_iterator_destroy(&it);\n \n \t/* cleanup. */\n@@ -297,7 +289,7 @@ static void t_log_write_read(void)\n \treftable_table_decref(table);\n }\n \n-static void t_log_zlib_corruption(void)\n+void test_reftable_readwrite__log_zlib_corruption(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 256,\n@@ -306,10 +298,12 @@ static void t_log_zlib_corruption(void)\n \tstruct reftable_table *table;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \tconst struct reftable_stats *stats = NULL;\n \tchar message[100] = { 0 };\n-\tint err, i, n;\n+\tint i;\n+\tint err;\n \tstruct reftable_log_record log = {\n \t\t.refname = (char *) \"refname\",\n \t\t.value_type = REFTABLE_LOG_UPDATE,\n@@ -329,14 +323,11 @@ static void t_log_zlib_corruption(void)\n \n \treftable_writer_set_limits(w, 1, 1);\n \n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck(!err);\n-\n-\tn = reftable_writer_close(w);\n-\tcheck_int(n, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \n \tstats = reftable_writer_stats(w);\n-\tcheck_int(stats->log_stats.blocks, >, 0);\n+\tcl_assert(stats->log_stats.blocks > 0);\n \treftable_writer_free(w);\n \tw = NULL;\n \n@@ -346,12 +337,12 @@ static void t_log_zlib_corruption(void)\n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.log\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_log_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_log(&it, \"refname\");\n-\tcheck_int(err, ==, REFTABLE_ZLIB_ERROR);\n+\tcl_assert_equal_i(err, REFTABLE_ZLIB_ERROR);\n \n \treftable_iterator_destroy(&it);\n \n@@ -360,7 +351,7 @@ static void t_log_zlib_corruption(void)\n \treftable_buf_release(&buf);\n }\n \n-static void t_table_read_write_sequential(void)\n+void test_reftable_readwrite__table_read_write_sequential(void)\n {\n \tchar **names;\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n@@ -376,24 +367,24 @@ static void t_table_read_write_sequential(void)\n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.ref\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (j = 0; ; j++) {\n \t\tstruct reftable_ref_record ref = { 0 };\n \t\tint r = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck_int(r, >=, 0);\n+\t\tcl_assert(r >= 0);\n \t\tif (r > 0)\n \t\t\tbreak;\n-\t\tcheck_str(names[j], ref.refname);\n-\t\tcheck_int(update_index, ==, ref.update_index);\n+\t\tcl_assert_equal_s(names[j], ref.refname);\n+\t\tcl_assert_equal_i(update_index, ref.update_index);\n \t\treftable_ref_record_release(&ref);\n \t}\n-\tcheck_int(j, ==, N);\n+\tcl_assert_equal_i(j, N);\n \n \treftable_iterator_destroy(&it);\n \treftable_table_decref(table);\n@@ -401,42 +392,42 @@ static void t_table_read_write_sequential(void)\n \tfree_names(names);\n }\n \n-static void t_table_write_small_table(void)\n+void test_reftable_readwrite__table_write_small_table(void)\n {\n \tchar **names;\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tint N = 1;\n \twrite_table(&names, &buf, N, 4096, REFTABLE_HASH_SHA1);\n-\tcheck_int(buf.len, <, 200);\n+\tcl_assert(buf.len < 200);\n \treftable_buf_release(&buf);\n \tfree_names(names);\n }\n \n-static void t_table_read_api(void)\n+void test_reftable_readwrite__table_read_api(void)\n {\n \tchar **names;\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tint N = 50;\n \tstruct reftable_table *table;\n \tstruct reftable_block_source source = { 0 };\n-\tint err;\n \tstruct reftable_log_record log = { 0 };\n \tstruct reftable_iterator it = { 0 };\n+\tint err;\n \n \twrite_table(&names, &buf, N, 256, REFTABLE_HASH_SHA1);\n \n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.ref\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, names[0]);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_iterator_next_log(&it, &log);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(err, REFTABLE_API_ERROR);\n \n \treftable_buf_release(&buf);\n \tfree_names(names);\n@@ -464,42 +455,43 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)\n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.ref\");\n-\tcheck(!err);\n-\tcheck_int(hash_id, ==, reftable_table_hash_id(table));\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(hash_id, reftable_table_hash_id(table));\n \n \tif (!index) {\n \t\ttable->ref_offsets.index_offset = 0;\n \t} else {\n-\t\tcheck_int(table->ref_offsets.index_offset, >, 0);\n+\t\tcl_assert(table->ref_offsets.index_offset > 0);\n \t}\n \n \tfor (i = 1; i < N; i++) {\n \t\terr = reftable_table_init_ref_iterator(table, &it);\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \t\terr = reftable_iterator_seek_ref(&it, names[i]);\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \t\terr = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck(!err);\n-\t\tcheck_str(names[i], ref.refname);\n-\t\tcheck_int(REFTABLE_REF_VAL1, ==, ref.value_type);\n-\t\tcheck_int(i, ==, ref.value.val1[0]);\n+\t\tcl_assert(!err);\n+\t\tcl_assert_equal_s(names[i], ref.refname);\n+\t\tcl_assert_equal_i(REFTABLE_REF_VAL1, ref.value_type);\n+\t\tcl_assert_equal_i(i, ref.value.val1[0]);\n \n \t\treftable_ref_record_release(&ref);\n \t\treftable_iterator_destroy(&it);\n \t}\n \n-\tcheck(!reftable_buf_addstr(&pastLast, names[N - 1]));\n-\tcheck(!reftable_buf_addstr(&pastLast, \"/\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&pastLast, names[N - 1]),\n+\t\t\t\t\t 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&pastLast, \"/\"), 0);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, pastLast.buf);\n \tif (err == 0) {\n \t\tstruct reftable_ref_record ref = { 0 };\n \t\tint err = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck_int(err, >, 0);\n+\t\tcl_assert(err > 0);\n \t} else {\n-\t\tcheck_int(err, >, 0);\n+\t\tcl_assert(err > 0);\n \t}\n \n \treftable_buf_release(&pastLast);\n@@ -510,17 +502,17 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)\n \treftable_table_decref(table);\n }\n \n-static void t_table_read_write_seek_linear(void)\n+void test_reftable_readwrite__table_read_write_seek_linear(void)\n {\n \tt_table_read_write_seek(0, REFTABLE_HASH_SHA1);\n }\n \n-static void t_table_read_write_seek_linear_sha256(void)\n+void test_reftable_readwrite__table_read_write_seek_linear_sha256(void)\n {\n \tt_table_read_write_seek(0, REFTABLE_HASH_SHA256);\n }\n \n-static void t_table_read_write_seek_index(void)\n+void test_reftable_readwrite__table_read_write_seek_index(void)\n {\n \tt_table_read_write_seek(1, REFTABLE_HASH_SHA1);\n }\n@@ -538,14 +530,16 @@ static void t_table_refs_for(int indexed)\n \tstruct reftable_table *table;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \tstruct reftable_iterator it = { 0 };\n-\tint N = 50, n, j, err, i;\n+\tint N = 50, j, i;\n+\tint err;\n \n \twant_names = reftable_calloc(N + 1, sizeof(*want_names));\n-\tcheck(want_names != NULL);\n+\tcl_assert(want_names != NULL);\n \n-\tt_reftable_set_hash(want_hash, 4, REFTABLE_HASH_SHA1);\n+\tcl_reftable_set_hash(want_hash, 4, REFTABLE_HASH_SHA1);\n \n \tfor (i = 0; i < N; i++) {\n \t\tuint8_t hash[REFTABLE_HASH_SIZE_SHA1];\n@@ -561,24 +555,22 @@ static void t_table_refs_for(int indexed)\n \t\tref.refname = name;\n \n \t\tref.value_type = REFTABLE_REF_VAL2;\n-\t\tt_reftable_set_hash(ref.value.val2.value, i / 4,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n-\t\tt_reftable_set_hash(ref.value.val2.target_value, 3 + i / 4,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(ref.value.val2.value, i / 4,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(ref.value.val2.target_value,\n+\t\t\t\t 3 + i / 4, REFTABLE_HASH_SHA1);\n \n \t\t/* 80 bytes / entry, so 3 entries per block. Yields 17\n \t\t */\n \t\t/* blocks. */\n-\t\tn = reftable_writer_add_ref(w, &ref);\n-\t\tcheck_int(n, ==, 0);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);\n \n \t\tif (!memcmp(ref.value.val2.value, want_hash, REFTABLE_HASH_SIZE_SHA1) ||\n \t\t !memcmp(ref.value.val2.target_value, want_hash, REFTABLE_HASH_SIZE_SHA1))\n \t\t\twant_names[want_names_len++] = xstrdup(name);\n \t}\n \n-\tn = reftable_writer_close(w);\n-\tcheck_int(n, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \n \treftable_writer_free(w);\n \tw = NULL;\n@@ -586,29 +578,29 @@ static void t_table_refs_for(int indexed)\n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.ref\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \tif (!indexed)\n \t\ttable->obj_offsets.is_present = 0;\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \treftable_iterator_destroy(&it);\n \n \terr = reftable_table_refs_for(table, &it, want_hash);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (j = 0; ; j++) {\n \t\tint err = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck_int(err, >=, 0);\n+\t\tcl_assert(err >= 0);\n \t\tif (err > 0)\n \t\t\tbreak;\n-\t\tcheck_int(j, <, want_names_len);\n-\t\tcheck_str(ref.refname, want_names[j]);\n+\t\tcl_assert(j < want_names_len);\n+\t\tcl_assert_equal_s(ref.refname, want_names[j]);\n \t\treftable_ref_record_release(&ref);\n \t}\n-\tcheck_int(j, ==, want_names_len);\n+\tcl_assert_equal_i(j, want_names_len);\n \n \treftable_buf_release(&buf);\n \tfree_names(want_names);\n@@ -616,21 +608,21 @@ static void t_table_refs_for(int indexed)\n \treftable_table_decref(table);\n }\n \n-static void t_table_refs_for_no_index(void)\n+void test_reftable_readwrite__table_refs_for_no_index(void)\n {\n \tt_table_refs_for(0);\n }\n \n-static void t_table_refs_for_obj_index(void)\n+void test_reftable_readwrite__table_refs_for_obj_index(void)\n {\n \tt_table_refs_for(1);\n }\n \n-static void t_write_empty_table(void)\n+void test_reftable_readwrite__write_empty_table(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_table *table = NULL;\n \tstruct reftable_ref_record rec = { 0 };\n@@ -639,43 +631,41 @@ static void t_write_empty_table(void)\n \n \treftable_writer_set_limits(w, 1, 1);\n \n-\terr = reftable_writer_close(w);\n-\tcheck_int(err, ==, REFTABLE_EMPTY_TABLE_ERROR);\n+\tcl_assert_equal_i(reftable_writer_close(w), REFTABLE_EMPTY_TABLE_ERROR);\n \treftable_writer_free(w);\n \n-\tcheck_uint(buf.len, ==, header_size(1) + footer_size(1));\n+\tcl_assert_equal_i(buf.len, header_size(1) + footer_size(1));\n \n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"filename\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck_int(err, >, 0);\n+\tcl_assert(err > 0);\n \n \treftable_iterator_destroy(&it);\n \treftable_table_decref(table);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_object_id_min_length(void)\n+void test_reftable_readwrite__write_object_id_min_length(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 75,\n \t};\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_ref_record ref = {\n \t\t.update_index = 1,\n \t\t.value_type = REFTABLE_REF_VAL1,\n \t\t.value.val1 = {42},\n \t};\n-\tint err;\n \tint i;\n \n \treftable_writer_set_limits(w, 1, 1);\n@@ -686,30 +676,27 @@ static void t_write_object_id_min_length(void)\n \t\tchar name[256];\n \t\tsnprintf(name, sizeof(name), \"ref%05d\", i);\n \t\tref.refname = name;\n-\t\terr = reftable_writer_add_ref(w, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);\n \t}\n \n-\terr = reftable_writer_close(w);\n-\tcheck(!err);\n-\tcheck_int(reftable_writer_stats(w)->object_id_len, ==, 2);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n+\tcl_assert_equal_i(reftable_writer_stats(w)->object_id_len, 2);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_object_id_length(void)\n+void test_reftable_readwrite__write_object_id_length(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 75,\n \t};\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_ref_record ref = {\n \t\t.update_index = 1,\n \t\t.value_type = REFTABLE_REF_VAL1,\n \t\t.value.val1 = {42},\n \t};\n-\tint err;\n \tint i;\n \n \treftable_writer_set_limits(w, 1, 1);\n@@ -721,44 +708,39 @@ static void t_write_object_id_length(void)\n \t\tsnprintf(name, sizeof(name), \"ref%05d\", i);\n \t\tref.refname = name;\n \t\tref.value.val1[15] = i;\n-\t\terr = reftable_writer_add_ref(w, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert(reftable_writer_add_ref(w, &ref) == 0);\n \t}\n \n-\terr = reftable_writer_close(w);\n-\tcheck(!err);\n-\tcheck_int(reftable_writer_stats(w)->object_id_len, ==, 16);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n+\tcl_assert_equal_i(reftable_writer_stats(w)->object_id_len, 16);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_empty_key(void)\n+void test_reftable_readwrite__write_empty_key(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"\",\n \t\t.update_index = 1,\n \t\t.value_type = REFTABLE_REF_DELETION,\n \t};\n-\tint err;\n \n \treftable_writer_set_limits(w, 1, 1);\n-\terr = reftable_writer_add_ref(w, &ref);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n-\n-\terr = reftable_writer_close(w);\n-\tcheck_int(err, ==, REFTABLE_EMPTY_TABLE_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_writer_close(w),\n+\t\t\t REFTABLE_EMPTY_TABLE_ERROR);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_key_order(void)\n+void test_reftable_readwrite__write_key_order(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_ref_record refs[2] = {\n \t\t{\n \t\t\t.refname = (char *) \"b\",\n@@ -776,24 +758,21 @@ static void t_write_key_order(void)\n \t\t\t},\n \t\t}\n \t};\n-\tint err;\n \n \treftable_writer_set_limits(w, 1, 1);\n-\terr = reftable_writer_add_ref(w, &refs[0]);\n-\tcheck(!err);\n-\terr = reftable_writer_add_ref(w, &refs[1]);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_ref(w, &refs[0]), 0);\n+\tcl_assert_equal_i(reftable_writer_add_ref(w, &refs[1]),\n+\t\t\t REFTABLE_API_ERROR);\n \n \trefs[0].update_index = 2;\n-\terr = reftable_writer_add_ref(w, &refs[0]);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_ref(w, &refs[0]), REFTABLE_API_ERROR);\n \n \treftable_writer_close(w);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_multiple_indices(void)\n+void test_reftable_readwrite__write_multiple_indices(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 100,\n@@ -805,9 +784,10 @@ static void t_write_multiple_indices(void)\n \tstruct reftable_writer *writer;\n \tstruct reftable_table *table;\n \tchar buf[128];\n-\tint err, i;\n+\tint i;\n+\tint err;\n \n-\twriter = t_reftable_strbuf_writer(&writer_buf, &opts);\n+\twriter = cl_reftable_strbuf_writer(&writer_buf, &opts);\n \treftable_writer_set_limits(writer, 1, 1);\n \tfor (i = 0; i < 100; i++) {\n \t\tstruct reftable_ref_record ref = {\n@@ -819,8 +799,7 @@ static void t_write_multiple_indices(void)\n \t\tsnprintf(buf, sizeof(buf), \"refs/heads/%04d\", i);\n \t\tref.refname = buf;\n \n-\t\terr = reftable_writer_add_ref(writer, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(writer, &ref), 0);\n \t}\n \n \tfor (i = 0; i < 100; i++) {\n@@ -836,8 +815,7 @@ static void t_write_multiple_indices(void)\n \t\tsnprintf(buf, sizeof(buf), \"refs/heads/%04d\", i);\n \t\tlog.refname = buf;\n \n-\t\terr = reftable_writer_add_log(writer, &log);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_log(writer, &log), 0);\n \t}\n \n \treftable_writer_close(writer);\n@@ -847,22 +825,22 @@ static void t_write_multiple_indices(void)\n \t * for each of the block types.\n \t */\n \tstats = reftable_writer_stats(writer);\n-\tcheck_int(stats->ref_stats.index_offset, >, 0);\n-\tcheck_int(stats->obj_stats.index_offset, >, 0);\n-\tcheck_int(stats->log_stats.index_offset, >, 0);\n+\tcl_assert(stats->ref_stats.index_offset > 0);\n+\tcl_assert(stats->obj_stats.index_offset > 0);\n+\tcl_assert(stats->log_stats.index_offset > 0);\n \n \tblock_source_from_buf(&source, &writer_buf);\n \terr = reftable_table_new(&table, &source, \"filename\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \t/*\n \t * Seeking the log uses the log index now. In case there is any\n \t * confusion regarding indices we would notice here.\n \t */\n \terr = reftable_table_init_log_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_log(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \treftable_iterator_destroy(&it);\n \treftable_writer_free(writer);\n@@ -870,7 +848,7 @@ static void t_write_multiple_indices(void)\n \treftable_buf_release(&writer_buf);\n }\n \n-static void t_write_multi_level_index(void)\n+void test_reftable_readwrite__write_multi_level_index(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 100,\n@@ -883,7 +861,7 @@ static void t_write_multi_level_index(void)\n \tstruct reftable_table *table;\n \tint err;\n \n-\twriter = t_reftable_strbuf_writer(&writer_buf, &opts);\n+\twriter = cl_reftable_strbuf_writer(&writer_buf, &opts);\n \treftable_writer_set_limits(writer, 1, 1);\n \tfor (size_t i = 0; i < 200; i++) {\n \t\tstruct reftable_ref_record ref = {\n@@ -896,8 +874,7 @@ static void t_write_multi_level_index(void)\n \t\tsnprintf(buf, sizeof(buf), \"refs/heads/%03\" PRIuMAX, (uintmax_t)i);\n \t\tref.refname = buf;\n \n-\t\terr = reftable_writer_add_ref(writer, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(writer, &ref), 0);\n \t}\n \treftable_writer_close(writer);\n \n@@ -906,19 +883,19 @@ static void t_write_multi_level_index(void)\n \t * multi-level index.\n \t */\n \tstats = reftable_writer_stats(writer);\n-\tcheck_int(stats->ref_stats.max_index_level, ==, 2);\n+\tcl_assert_equal_i(stats->ref_stats.max_index_level, 2);\n \n \tblock_source_from_buf(&source, &writer_buf);\n \terr = reftable_table_new(&table, &source, \"filename\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \t/*\n \t * Seeking the last ref should work as expected.\n \t */\n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"refs/heads/199\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \treftable_iterator_destroy(&it);\n \treftable_writer_free(writer);\n@@ -927,7 +904,7 @@ static void t_write_multi_level_index(void)\n \treftable_buf_release(&buf);\n }\n \n-static void t_corrupt_table_empty(void)\n+void test_reftable_readwrite__corrupt_table_empty(void)\n {\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tstruct reftable_block_source source = { 0 };\n@@ -936,50 +913,22 @@ static void t_corrupt_table_empty(void)\n \n \tblock_source_from_buf(&source, &buf);\n \terr = reftable_table_new(&table, &source, \"file.log\");\n-\tcheck_int(err, ==, REFTABLE_FORMAT_ERROR);\n+\tcl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);\n }\n \n-static void t_corrupt_table(void)\n+void test_reftable_readwrite__corrupt_table(void)\n {\n \tuint8_t zeros[1024] = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_table *table;\n \tint err;\n-\tcheck(!reftable_buf_add(&buf, zeros, sizeof(zeros)));\n+\n+\tcl_assert(!reftable_buf_add(&buf, zeros, sizeof(zeros)));\n \n \tblock_source_from_buf(&source, &buf);\n \terr = reftable_table_new(&table, &source, \"file.log\");\n-\tcheck_int(err, ==, REFTABLE_FORMAT_ERROR);\n+\tcl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);\n \n \treftable_buf_release(&buf);\n }\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_buffer(), \"strbuf works as blocksource\");\n-\tTEST(t_corrupt_table(), \"read-write on corrupted table\");\n-\tTEST(t_corrupt_table_empty(), \"read-write on an empty table\");\n-\tTEST(t_log_buffer_size(), \"buffer extension for log compression\");\n-\tTEST(t_log_overflow(), \"log overflow returns expected error\");\n-\tTEST(t_log_write_limits(), \"writer limits for writing log records\");\n-\tTEST(t_log_write_read(), \"read-write on log records\");\n-\tTEST(t_log_zlib_corruption(), \"reading corrupted log record returns expected error\");\n-\tTEST(t_table_read_api(), \"read on a table\");\n-\tTEST(t_table_read_write_seek_index(), \"read-write on a table with index\");\n-\tTEST(t_table_read_write_seek_linear(), \"read-write on a table without index (SHA1)\");\n-\tTEST(t_table_read_write_seek_linear_sha256(), \"read-write on a table without index (SHA256)\");\n-\tTEST(t_table_read_write_sequential(), \"sequential read-write on a table\");\n-\tTEST(t_table_refs_for_no_index(), \"refs-only table with no index\");\n-\tTEST(t_table_refs_for_obj_index(), \"refs-only table with index\");\n-\tTEST(t_table_write_small_table(), \"write_table works\");\n-\tTEST(t_write_empty_key(), \"write on refs with empty keys\");\n-\tTEST(t_write_empty_table(), \"read-write on empty tables\");\n-\tTEST(t_write_key_order(), \"refs must be written in increasing order\");\n-\tTEST(t_write_multi_level_index(), \"table with multi-level index\");\n-\tTEST(t_write_multiple_indices(), \"table with indices for multiple block types\");\n-\tTEST(t_write_object_id_length(), \"prefix compression on writing refs\");\n-\tTEST(t_write_object_id_min_length(), \"prefix compression on writing refs\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"522664","messageId":"20250724132813.59627-4-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250724132813.59627-1-kuforiji98@gmail.com","subject":"[PATCH v5 3/5] t/unit-tests: convert reftable record test to use clar","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T13:28:11Z","receivedAt":"2025-07-24T13:29:50Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kuforiji \n\nAdapt reftable record test file to use clar by using clar assertions\nwhere necessary.\n\nSigned-off-by: Seyi Kuforiji \nSigned-off-by: Junio C Hamano \n---\n Makefile | 1 -\n t/meson.build | 1 -\n ...-reftable-record.c => u-reftable-record.c} | 250 +++++++++---------\n 3 files changed, 130 insertions(+), 122 deletions(-)\n rename t/unit-tests/{t-reftable-record.c => u-reftable-record.c} (62%)\n\ndiff --git a/Makefile b/Makefile\nindex d86ef5a142..3b41342ddb 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1383,7 +1383,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-record\n UNIT_TEST_PROGRAMS += t-reftable-stack\n UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\ndiff --git a/t/meson.build b/t/meson.build\nindex 5189176472..297937f307 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -61,7 +61,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-record.c',\n 'unit-tests/t-reftable-stack.c',\n ]\n \ndiff --git a/t/unit-tests/t-reftable-record.c b/t/unit-tests/u-reftable-record.c\nsimilarity index 62%\nrename from t/unit-tests/t-reftable-record.c\nrename to t/unit-tests/u-reftable-record.c\nindex 553a007664..650b0aa0d3 100644\n--- a/t/unit-tests/t-reftable-record.c\n+++ b/t/unit-tests/u-reftable-record.c\n@@ -6,7 +6,8 @@\n https://developers.google.com/open-source/licenses/bsd\n */\n \n-#include \"test-lib.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/basics.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/record.h\"\n@@ -17,16 +18,17 @@ static void t_copy(struct reftable_record *rec)\n \tuint8_t typ;\n \n \ttyp = reftable_record_type(rec);\n-\tcheck(!reftable_record_init(©, typ));\n+\tcl_assert_equal_i(reftable_record_init(©, typ), 0);\n \treftable_record_copy_from(©, rec, REFTABLE_HASH_SIZE_SHA1);\n \t/* do it twice to catch memory leaks */\n \treftable_record_copy_from(©, rec, REFTABLE_HASH_SIZE_SHA1);\n-\tcheck(reftable_record_equal(rec, ©, REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert(reftable_record_equal(rec, ©,\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n \n \treftable_record_release(©);\n }\n \n-static void t_varint_roundtrip(void)\n+void test_reftable_record__varint_roundtrip(void)\n {\n \tuint64_t inputs[] = { 0,\n \t\t\t 1,\n@@ -49,16 +51,16 @@ static void t_varint_roundtrip(void)\n \t\tint n = put_var_int(&out, in);\n \t\tuint64_t got = 0;\n \n-\t\tcheck_int(n, >, 0);\n+\t\tcl_assert(n > 0);\n \t\tout.len = n;\n \t\tn = get_var_int(&got, &out);\n-\t\tcheck_int(n, >, 0);\n+\t\tcl_assert(n > 0);\n \n-\t\tcheck_int(got, ==, in);\n+\t\tcl_assert_equal_i(got, in);\n \t}\n }\n \n-static void t_varint_overflow(void)\n+void test_reftable_record__varint_overflow(void)\n {\n \tunsigned char buf[] = {\n \t\t0xFF, 0xFF, 0xFF, 0xFF,\n@@ -70,8 +72,7 @@ static void t_varint_overflow(void)\n \t\t.len = sizeof(buf),\n \t};\n \tuint64_t value;\n-\tint err = get_var_int(&value, &view);\n-\tcheck_int(err, ==, -1);\n+\tcl_assert_equal_i(get_var_int(&value, &view), -1);\n }\n \n static void set_hash(uint8_t *h, int j)\n@@ -80,7 +81,7 @@ static void set_hash(uint8_t *h, int j)\n \t\th[i] = (j >> i) & 0xff;\n }\n \n-static void t_reftable_ref_record_comparison(void)\n+void test_reftable_record__ref_record_comparison(void)\n {\n \tstruct reftable_record in[3] = {\n \t\t{\n@@ -102,21 +103,23 @@ static void t_reftable_ref_record_comparison(void)\n \t};\n \tint cmp;\n \n-\tcheck(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n \n-\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n-\tcheck_int(cmp, >, 0);\n+\tcl_assert(reftable_record_equal(&in[1], &in[2],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) == 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n+\tcl_assert(cmp > 0);\n \n \tin[1].u.ref.value_type = in[0].u.ref.value_type;\n-\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n }\n \n-static void t_reftable_ref_record_compare_name(void)\n+void test_reftable_record__ref_record_compare_name(void)\n {\n \tstruct reftable_ref_record recs[3] = {\n \t\t{\n@@ -130,12 +133,15 @@ static void t_reftable_ref_record_compare_name(void)\n \t\t},\n \t};\n \n-\tcheck_int(reftable_ref_record_compare_name(&recs[0], &recs[1]), <, 0);\n-\tcheck_int(reftable_ref_record_compare_name(&recs[1], &recs[0]), >, 0);\n-\tcheck_int(reftable_ref_record_compare_name(&recs[0], &recs[2]), ==, 0);\n+\tcl_assert(reftable_ref_record_compare_name(&recs[0],\n+\t\t\t\t\t\t &recs[1]) < 0);\n+\tcl_assert(reftable_ref_record_compare_name(&recs[1],\n+\t\t\t\t\t\t &recs[0]) > 0);\n+\tcl_assert_equal_i(reftable_ref_record_compare_name(&recs[0],\n+\t\t\t\t\t\t\t &recs[2]), 0);\n }\n \n-static void t_reftable_ref_record_roundtrip(void)\n+void test_reftable_record__ref_record_roundtrip(void)\n {\n \tstruct reftable_buf scratch = REFTABLE_BUF_INIT;\n \n@@ -172,19 +178,21 @@ static void t_reftable_ref_record_roundtrip(void)\n \n \t\tt_copy(&in);\n \n-\t\tcheck_int(reftable_record_val_type(&in), ==, i);\n-\t\tcheck_int(reftable_record_is_deletion(&in), ==, i == REFTABLE_REF_DELETION);\n+\t\tcl_assert_equal_i(reftable_record_val_type(&in), i);\n+\t\tcl_assert_equal_i(reftable_record_is_deletion(&in),\n+\t\t\t\t i == REFTABLE_REF_DELETION);\n \n \t\treftable_record_key(&in, &key);\n \t\tn = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck_int(n, >, 0);\n+\t\tcl_assert(n > 0);\n \n \t\t/* decode into a non-zero reftable_record to test for leaks. */\n \t\tm = reftable_record_decode(&out, key, i, dest, REFTABLE_HASH_SIZE_SHA1, &scratch);\n-\t\tcheck_int(n, ==, m);\n+\t\tcl_assert_equal_i(n, m);\n \n-\t\tcheck(reftable_ref_record_equal(&in.u.ref, &out.u.ref,\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_ref_record_equal(&in.u.ref,\n+\t\t\t\t\t\t &out.u.ref,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_record_release(&in);\n \n \t\treftable_buf_release(&key);\n@@ -194,7 +202,7 @@ static void t_reftable_ref_record_roundtrip(void)\n \treftable_buf_release(&scratch);\n }\n \n-static void t_reftable_log_record_comparison(void)\n+void test_reftable_record__log_record_comparison(void)\n {\n \tstruct reftable_record in[3] = {\n \t\t{\n@@ -215,21 +223,24 @@ static void t_reftable_log_record_comparison(void)\n \t};\n \tint cmp;\n \n-\tcheck(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n-\tcheck_int(cmp, >, 0);\n+\tcl_assert_equal_i(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_equal(&in[1], &in[2],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n+\tcl_assert(cmp > 0);\n \t/* comparison should be reversed for equal keys, because\n \t * comparison is now performed on the basis of update indices */\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck_int(cmp, <, 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(cmp < 0);\n \n \tin[1].u.log.update_index = in[0].u.log.update_index;\n-\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n+\tcl_assert(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n }\n \n-static void t_reftable_log_record_compare_key(void)\n+void test_reftable_record__log_record_compare_key(void)\n {\n \tstruct reftable_log_record logs[3] = {\n \t\t{\n@@ -246,19 +257,24 @@ static void t_reftable_log_record_compare_key(void)\n \t\t},\n \t};\n \n-\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[1]), <, 0);\n-\tcheck_int(reftable_log_record_compare_key(&logs[1], &logs[0]), >, 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[0],\n+\t\t\t\t\t\t &logs[1]) < 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[1],\n+\t\t\t\t\t\t &logs[0]) > 0);\n \n \tlogs[1].update_index = logs[0].update_index;\n-\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[1]), <, 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[0],\n+\t\t\t\t\t\t &logs[1]) < 0);\n \n-\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[2]), >, 0);\n-\tcheck_int(reftable_log_record_compare_key(&logs[2], &logs[0]), <, 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[0],\n+\t\t\t\t\t\t &logs[2]) > 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[2],\n+\t\t\t\t\t\t &logs[0]) < 0);\n \tlogs[2].update_index = logs[0].update_index;\n-\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[2]), ==, 0);\n+\tcl_assert_equal_i(reftable_log_record_compare_key(&logs[0], &logs[2]), 0);\n }\n \n-static void t_reftable_log_record_roundtrip(void)\n+void test_reftable_record__log_record_roundtrip(void)\n {\n \tstruct reftable_log_record in[] = {\n \t\t{\n@@ -292,9 +308,9 @@ static void t_reftable_log_record_roundtrip(void)\n \tset_hash(in[2].value.update.new_hash, 3);\n \tset_hash(in[2].value.update.old_hash, 4);\n \n-\tcheck(!reftable_log_record_is_deletion(&in[0]));\n-\tcheck(reftable_log_record_is_deletion(&in[1]));\n-\tcheck(!reftable_log_record_is_deletion(&in[2]));\n+\tcl_assert_equal_i(reftable_log_record_is_deletion(&in[0]), 0);\n+\tcl_assert(reftable_log_record_is_deletion(&in[1]) != 0);\n+\tcl_assert_equal_i(reftable_log_record_is_deletion(&in[2]), 0);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(in); i++) {\n \t\tstruct reftable_record rec = { .type = REFTABLE_BLOCK_TYPE_LOG };\n@@ -328,14 +344,14 @@ static void t_reftable_log_record_roundtrip(void)\n \t\treftable_record_key(&rec, &key);\n \n \t\tn = reftable_record_encode(&rec, dest, REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck_int(n, >=, 0);\n+\t\tcl_assert(n >= 0);\n \t\tvaltype = reftable_record_val_type(&rec);\n \t\tm = reftable_record_decode(&out, key, valtype, dest,\n \t\t\t\t\t REFTABLE_HASH_SIZE_SHA1, &scratch);\n-\t\tcheck_int(n, ==, m);\n+\t\tcl_assert_equal_i(n, m);\n \n-\t\tcheck(reftable_log_record_equal(&in[i], &out.u.log,\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_log_record_equal(&in[i], &out.u.log,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_log_record_release(&in[i]);\n \t\treftable_buf_release(&key);\n \t\treftable_record_release(&out);\n@@ -344,7 +360,7 @@ static void t_reftable_log_record_roundtrip(void)\n \treftable_buf_release(&scratch);\n }\n \n-static void t_key_roundtrip(void)\n+void test_reftable_record__key_roundtrip(void)\n {\n \tuint8_t buffer[1024] = { 0 };\n \tstruct string_view dest = {\n@@ -359,25 +375,28 @@ static void t_key_roundtrip(void)\n \tint n, m;\n \tuint8_t rt_extra;\n \n-\tcheck(!reftable_buf_addstr(&last_key, \"refs/heads/master\"));\n-\tcheck(!reftable_buf_addstr(&key, \"refs/tags/bla\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&last_key,\n+\t\t\t\t\t \"refs/heads/master\"), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&key,\n+\t\t\t\t\t \"refs/tags/bla\"), 0);\n \textra = 6;\n \tn = reftable_encode_key(&restart, dest, last_key, key, extra);\n-\tcheck(!restart);\n-\tcheck_int(n, >, 0);\n+\tcl_assert(!restart);\n+\tcl_assert(n > 0);\n \n-\tcheck(!reftable_buf_addstr(&roundtrip, \"refs/heads/master\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&roundtrip,\n+\t\t\t\t\t \"refs/heads/master\"), 0);\n \tm = reftable_decode_key(&roundtrip, &rt_extra, dest);\n-\tcheck_int(n, ==, m);\n-\tcheck(!reftable_buf_cmp(&key, &roundtrip));\n-\tcheck_int(rt_extra, ==, extra);\n+\tcl_assert_equal_i(n, m);\n+\tcl_assert_equal_i(reftable_buf_cmp(&key, &roundtrip), 0);\n+\tcl_assert_equal_i(rt_extra, extra);\n \n \treftable_buf_release(&last_key);\n \treftable_buf_release(&key);\n \treftable_buf_release(&roundtrip);\n }\n \n-static void t_reftable_obj_record_comparison(void)\n+void test_reftable_record__obj_record_comparison(void)\n {\n \n \tuint8_t id_bytes[] = { 0, 1, 2, 3, 4, 5, 6 };\n@@ -405,21 +424,23 @@ static void t_reftable_obj_record_comparison(void)\n \t};\n \tint cmp;\n \n-\tcheck(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert_equal_i(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n \n-\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n-\tcheck_int(cmp, >, 0);\n+\tcl_assert_equal_i(reftable_record_equal(&in[1], &in[2],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n+\tcl_assert(cmp > 0);\n \n \tin[1].u.obj.offset_len = in[0].u.obj.offset_len;\n-\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n }\n \n-static void t_reftable_obj_record_roundtrip(void)\n+void test_reftable_record__obj_record_roundtrip(void)\n {\n \tuint8_t testHash1[REFTABLE_HASH_SIZE_SHA1] = { 1, 2, 3, 4, 0 };\n \tuint64_t till9[] = { 1, 2, 3, 4, 500, 600, 700, 800, 9000 };\n@@ -460,17 +481,18 @@ static void t_reftable_obj_record_roundtrip(void)\n \t\tint n, m;\n \t\tuint8_t extra;\n \n-\t\tcheck(!reftable_record_is_deletion(&in));\n+\t\tcl_assert_equal_i(reftable_record_is_deletion(&in), 0);\n \t\tt_copy(&in);\n \t\treftable_record_key(&in, &key);\n \t\tn = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck_int(n, >, 0);\n+\t\tcl_assert(n > 0);\n \t\textra = reftable_record_val_type(&in);\n \t\tm = reftable_record_decode(&out, key, extra, dest,\n \t\t\t\t\t REFTABLE_HASH_SIZE_SHA1, &scratch);\n-\t\tcheck_int(n, ==, m);\n+\t\tcl_assert_equal_i(n, m);\n \n-\t\tcheck(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_record_equal(&in, &out,\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_buf_release(&key);\n \t\treftable_record_release(&out);\n \t}\n@@ -478,7 +500,7 @@ static void t_reftable_obj_record_roundtrip(void)\n \treftable_buf_release(&scratch);\n }\n \n-static void t_reftable_index_record_comparison(void)\n+void test_reftable_record__index_record_comparison(void)\n {\n \tstruct reftable_record in[3] = {\n \t\t{\n@@ -499,28 +521,33 @@ static void t_reftable_index_record_comparison(void)\n \t};\n \tint cmp;\n \n-\tcheck(!reftable_buf_addstr(&in[0].u.idx.last_key, \"refs/heads/master\"));\n-\tcheck(!reftable_buf_addstr(&in[1].u.idx.last_key, \"refs/heads/master\"));\n-\tcheck(!reftable_buf_addstr(&in[2].u.idx.last_key, \"refs/heads/branch\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&in[0].u.idx.last_key,\n+\t\t\t\t\t \"refs/heads/master\"), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&in[1].u.idx.last_key, \"refs/heads/master\"), 0);\n+\tcl_assert(reftable_buf_addstr(&in[2].u.idx.last_key,\n+\t\t\t\t \"refs/heads/branch\") == 0);\n \n-\tcheck(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert_equal_i(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n \n-\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n-\tcheck_int(cmp, >, 0);\n+\tcl_assert_equal_i(reftable_record_equal(&in[1], &in[2],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n+\tcl_assert(cmp > 0);\n \n \tin[1].u.idx.offset = in[0].u.idx.offset;\n-\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(in); i++)\n \t\treftable_record_release(&in[i]);\n }\n \n-static void t_reftable_index_record_roundtrip(void)\n+void test_reftable_record__index_record_roundtrip(void)\n {\n \tstruct reftable_record in = {\n \t\t.type = REFTABLE_BLOCK_TYPE_INDEX,\n@@ -543,43 +570,26 @@ static void t_reftable_index_record_roundtrip(void)\n \tint n, m;\n \tuint8_t extra;\n \n-\tcheck(!reftable_buf_addstr(&in.u.idx.last_key, \"refs/heads/master\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&in.u.idx.last_key,\n+\t\t\t\t\t \"refs/heads/master\"), 0);\n \treftable_record_key(&in, &key);\n \tt_copy(&in);\n \n-\tcheck(!reftable_record_is_deletion(&in));\n-\tcheck(!reftable_buf_cmp(&key, &in.u.idx.last_key));\n+\tcl_assert_equal_i(reftable_record_is_deletion(&in), 0);\n+\tcl_assert_equal_i(reftable_buf_cmp(&key, &in.u.idx.last_key), 0);\n \tn = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);\n-\tcheck_int(n, >, 0);\n+\tcl_assert(n > 0);\n \n \textra = reftable_record_val_type(&in);\n-\tm = reftable_record_decode(&out, key, extra, dest, REFTABLE_HASH_SIZE_SHA1,\n-\t\t\t\t &scratch);\n-\tcheck_int(m, ==, n);\n+\tm = reftable_record_decode(&out, key, extra, dest,\n+\t\t\t\t REFTABLE_HASH_SIZE_SHA1, &scratch);\n+\tcl_assert_equal_i(m, n);\n \n-\tcheck(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert(reftable_record_equal(&in, &out,\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n \n \treftable_record_release(&out);\n \treftable_buf_release(&key);\n \treftable_buf_release(&scratch);\n \treftable_buf_release(&in.u.idx.last_key);\n }\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_reftable_ref_record_comparison(), \"comparison operations work on ref record\");\n-\tTEST(t_reftable_log_record_comparison(), \"comparison operations work on log record\");\n-\tTEST(t_reftable_index_record_comparison(), \"comparison operations work on index record\");\n-\tTEST(t_reftable_obj_record_comparison(), \"comparison operations work on obj record\");\n-\tTEST(t_reftable_ref_record_compare_name(), \"reftable_ref_record_compare_name works\");\n-\tTEST(t_reftable_log_record_compare_key(), \"reftable_log_record_compare_key works\");\n-\tTEST(t_reftable_log_record_roundtrip(), \"record operations work on log record\");\n-\tTEST(t_reftable_ref_record_roundtrip(), \"record operations work on ref record\");\n-\tTEST(t_varint_roundtrip(), \"put_var_int and get_var_int work\");\n-\tTEST(t_varint_overflow(), \"get_var_int notices an integer overflow\");\n-\tTEST(t_key_roundtrip(), \"reftable_encode_key and reftable_decode_key work\");\n-\tTEST(t_reftable_obj_record_roundtrip(), \"record operations work on obj record\");\n-\tTEST(t_reftable_index_record_roundtrip(), \"record operations work on index record\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"522665","messageId":"20250724132813.59627-5-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250724132813.59627-1-kuforiji98@gmail.com","subject":"[PATCH v5 4/5] t/unit-tests: convert reftable stack test to use clar","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T13:28:12Z","receivedAt":"2025-07-24T13:29:56Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kuforiji \n\nAdapt reftable stack test file to use clar by using clar assertions\nwhere necessary.\n\nThis marks the end of all unit tests migrated away from the\n`unit-tests/t-*.c` pattern, there are no longer any files matching that\nglob. Remove the sanity check for `t-*.c` files to prevent Meson\nconfiguration errors during CI and local builds.\n\nSigned-off-by: Seyi Kuforiji \nSigned-off-by: Junio C Hamano \n---\n Makefile | 2 +-\n t/meson.build | 5 +-\n ...{t-reftable-stack.c => u-reftable-stack.c} | 780 ++++++++----------\n 3 files changed, 333 insertions(+), 454 deletions(-)\n rename t/unit-tests/{t-reftable-stack.c => u-reftable-stack.c} (59%)\n\ndiff --git a/Makefile b/Makefile\nindex 3b41342ddb..8ed8f234f4 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1369,6 +1369,7 @@ CLAR_TEST_SUITES += u-reftable-block\n CLAR_TEST_SUITES += u-reftable-merged\n CLAR_TEST_SUITES += u-reftable-pq\n CLAR_TEST_SUITES += u-reftable-readwrite\n+CLAR_TEST_SUITES += u-reftable-stack\n CLAR_TEST_SUITES += u-reftable-table\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n@@ -1383,7 +1384,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-stack\n UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o\ndiff --git a/t/meson.build b/t/meson.build\nindex 297937f307..fcbb659263 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -13,6 +13,8 @@ clar_test_suites = [\n 'unit-tests/u-reftable-merged.c',\n 'unit-tests/u-reftable-pq.c',\n 'unit-tests/u-reftable-readwrite.c',\n+ 'unit-tests/u-reftable-record.c',\n+ 'unit-tests/u-reftable-stack.c',\n 'unit-tests/u-reftable-table.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n@@ -61,7 +63,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-stack.c',\n ]\n \n foreach unit_test_program : unit_test_programs\n@@ -1163,8 +1164,6 @@ benchmarks = [\n # sufficient to catch missing test suites in our CI though.\n foreach glob, tests : {\n 't[0-9][0-9][0-9][0-9]-*.sh': integration_tests,\n- 'perf/p[0-9][0-9][0-9][0-9]-*.sh': benchmarks,\n- 'unit-tests/t-*.c': unit_test_programs,\n 'unit-tests/u-*.c': clar_test_suites,\n }\n actual_tests = run_command(shell, '-c', 'ls ' + glob,\ndiff --git a/t/unit-tests/t-reftable-stack.c b/t/unit-tests/u-reftable-stack.c\nsimilarity index 59%\nrename from t/unit-tests/t-reftable-stack.c\nrename to t/unit-tests/u-reftable-stack.c\nindex 2f49c97519..0e3e3f4f4a 100644\n--- a/t/unit-tests/t-reftable-stack.c\n+++ b/t/unit-tests/u-reftable-stack.c\n@@ -8,9 +8,9 @@ license that can be found in the LICENSE file or at\n \n #define DISABLE_SIGN_COMPARE_WARNINGS\n \n-#include \"test-lib.h\"\n-#include \"lib-reftable.h\"\n+#include \"unit-test.h\"\n #include \"dir.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/merged.h\"\n #include \"reftable/reftable-error.h\"\n #include \"reftable/stack.h\"\n@@ -70,11 +70,11 @@ static char *get_tmp_template(int linenumber)\n static char *get_tmp_dir(int linenumber)\n {\n \tchar *dir = get_tmp_template(linenumber);\n-\tcheck(mkdtemp(dir) != NULL);\n+\tcl_assert(mkdtemp(dir) != NULL);\n \treturn dir;\n }\n \n-static void t_read_file(void)\n+void test_reftable_stack__read_file(void)\n {\n \tchar *fn = get_tmp_template(__LINE__);\n \tstruct tempfile *tmp = mks_tempfile(fn);\n@@ -84,17 +84,17 @@ static void t_read_file(void)\n \tchar **names = NULL;\n \tconst char *want[] = { \"line1\", \"line2\", \"line3\" };\n \n-\tcheck_int(fd, >, 0);\n+\tcl_assert(fd > 0);\n \tn = write_in_full(fd, out, strlen(out));\n-\tcheck_int(n, ==, strlen(out));\n+\tcl_assert_equal_i(n, strlen(out));\n \terr = close(fd);\n-\tcheck_int(err, >=, 0);\n+\tcl_assert(err >= 0);\n \n \terr = read_lines(fn, &names);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (size_t i = 0; names[i]; i++)\n-\t\tcheck_str(want[i], names[i]);\n+\t\tcl_assert_equal_s(want[i], names[i]);\n \tfree_names(names);\n \t(void) remove(fn);\n \tdelete_tempfile(&tmp);\n@@ -103,8 +103,8 @@ static void t_read_file(void)\n static int write_test_ref(struct reftable_writer *wr, void *arg)\n {\n \tstruct reftable_ref_record *ref = arg;\n-\tcheck(!reftable_writer_set_limits(wr, ref->update_index,\n-\t\t\t\t\t ref->update_index));\n+\tcl_assert_equal_i(reftable_writer_set_limits(wr,\n+\t\t\t\t\t\t ref->update_index, ref->update_index), 0);\n \treturn reftable_writer_add_ref(wr, ref);\n }\n \n@@ -112,7 +112,6 @@ static void write_n_ref_tables(struct reftable_stack *st,\n \t\t\t size_t n)\n {\n \tint disable_auto_compact;\n-\tint err;\n \n \tdisable_auto_compact = st->opts.disable_auto_compact;\n \tst->opts.disable_auto_compact = 1;\n@@ -126,10 +125,10 @@ static void write_n_ref_tables(struct reftable_stack *st,\n \n \t\tsnprintf(buf, sizeof(buf), \"refs/heads/branch-%04\"PRIuMAX, (uintmax_t)i);\n \t\tref.refname = buf;\n-\t\tt_reftable_set_hash(ref.value.val1, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(ref.value.val1, i, REFTABLE_HASH_SHA1);\n \n-\t\terr = reftable_stack_add(st, &write_test_ref, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t &write_test_ref, &ref), 0);\n \t}\n \n \tst->opts.disable_auto_compact = disable_auto_compact;\n@@ -144,12 +143,13 @@ static int write_test_log(struct reftable_writer *wr, void *arg)\n {\n \tstruct write_log_arg *wla = arg;\n \n-\tcheck(!reftable_writer_set_limits(wr, wla->update_index,\n-\t\t\t\t\t wla->update_index));\n+\tcl_assert_equal_i(reftable_writer_set_limits(wr,\n+\t\t\t\t\t\t wla->update_index,\n+\t\t\t\t\t\t wla->update_index), 0);\n \treturn reftable_writer_add_log(wr, wla->log);\n }\n \n-static void t_reftable_stack_add_one(void)\n+void test_reftable_stack__add_one(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_buf scratch = REFTABLE_BUF_INIT;\n@@ -158,7 +158,6 @@ static void t_reftable_stack_add_one(void)\n \t\t.default_permissions = 0660,\n \t};\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"HEAD\",\n \t\t.update_index = 1,\n@@ -167,32 +166,37 @@ static void t_reftable_stack_add_one(void)\n \t};\n \tstruct reftable_ref_record dest = { 0 };\n \tstruct stat stat_result = { 0 };\n+\tint err;\n+\n \terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_stack_add(st, write_test_ref, &ref);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_stack_read_ref(st, ref.refname, &dest);\n-\tcheck(!err);\n-\tcheck(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));\n-\tcheck_int(st->tables_len, >, 0);\n+\tcl_assert(!err);\n+\tcl_assert(reftable_ref_record_equal(&ref, &dest,\n+\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert(st->tables_len > 0);\n \n #ifndef GIT_WINDOWS_NATIVE\n-\tcheck(!reftable_buf_addstr(&scratch, dir));\n-\tcheck(!reftable_buf_addstr(&scratch, \"/tables.list\"));\n-\terr = stat(scratch.buf, &stat_result);\n-\tcheck(!err);\n-\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n+\tcl_assert_equal_i(reftable_buf_addstr(&scratch, dir), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&scratch,\n+\t\t\t\t\t \"/tables.list\"), 0);\n+\tcl_assert_equal_i(stat(scratch.buf, &stat_result), 0);\n+\tcl_assert_equal_i((stat_result.st_mode & 0777),\n+\t\t\t opts.default_permissions);\n \n \treftable_buf_reset(&scratch);\n-\tcheck(!reftable_buf_addstr(&scratch, dir));\n-\tcheck(!reftable_buf_addstr(&scratch, \"/\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&scratch, dir), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&scratch, \"/\"), 0);\n \t/* do not try at home; not an external API for reftable. */\n-\tcheck(!reftable_buf_addstr(&scratch, st->tables[0]->name));\n+\tcl_assert(!reftable_buf_addstr(&scratch, st->tables[0]->name));\n \terr = stat(scratch.buf, &stat_result);\n-\tcheck(!err);\n-\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i((stat_result.st_mode & 0777),\n+\t\t\t opts.default_permissions);\n #else\n \t(void) stat_result;\n #endif\n@@ -204,14 +208,13 @@ static void t_reftable_stack_add_one(void)\n \tumask(mask);\n }\n \n-static void t_reftable_stack_uptodate(void)\n+void test_reftable_stack__uptodate(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st1 = NULL;\n \tstruct reftable_stack *st2 = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n \n-\tint err;\n \tstruct reftable_ref_record ref1 = {\n \t\t.refname = (char *) \"HEAD\",\n \t\t.update_index = 1,\n@@ -229,34 +232,25 @@ static void t_reftable_stack_uptodate(void)\n \t/* simulate multi-process access to the same stack\n \t by creating two stacks for the same directory.\n \t */\n-\terr = reftable_new_stack(&st1, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st1, write_test_ref, &ref1);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st2, write_test_ref, &ref2);\n-\tcheck_int(err, ==, REFTABLE_OUTDATED_ERROR);\n-\n-\terr = reftable_stack_reload(st2);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st2, write_test_ref, &ref2);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st1, write_test_ref,\n+\t\t\t\t\t &ref1), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st2, write_test_ref,\n+\t\t\t\t\t &ref2), REFTABLE_OUTDATED_ERROR);\n+\tcl_assert_equal_i(reftable_stack_reload(st2), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st2, write_test_ref,\n+\t\t\t\t\t &ref2), 0);\n \treftable_stack_destroy(st1);\n \treftable_stack_destroy(st2);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_transaction_api(void)\n+void test_reftable_stack__transaction_api(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tstruct reftable_addition *add = NULL;\n \n \tstruct reftable_ref_record ref = {\n@@ -267,37 +261,32 @@ static void t_reftable_stack_transaction_api(void)\n \t};\n \tstruct reftable_ref_record dest = { 0 };\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \treftable_addition_destroy(add);\n \n-\terr = reftable_stack_new_addition(&add, st, 0);\n-\tcheck(!err);\n-\n-\terr = reftable_addition_add(add, write_test_ref, &ref);\n-\tcheck(!err);\n-\n-\terr = reftable_addition_commit(add);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st, 0), 0);\n+\tcl_assert_equal_i(reftable_addition_add(add, write_test_ref,\n+\t\t\t\t\t\t&ref), 0);\n+\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \n \treftable_addition_destroy(add);\n \n-\terr = reftable_stack_read_ref(st, ref.refname, &dest);\n-\tcheck(!err);\n-\tcheck_int(REFTABLE_REF_SYMREF, ==, dest.value_type);\n-\tcheck(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert_equal_i(reftable_stack_read_ref(st, ref.refname,\n+\t\t\t\t\t\t &dest), 0);\n+\tcl_assert_equal_i(REFTABLE_REF_SYMREF, dest.value_type);\n+\tcl_assert(reftable_ref_record_equal(&ref, &dest,\n+\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \n \treftable_ref_record_release(&dest);\n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_transaction_with_reload(void)\n+void test_reftable_stack__transaction_with_reload(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_stack *st1 = NULL, *st2 = NULL;\n-\tint err;\n \tstruct reftable_addition *add = NULL;\n \tstruct reftable_ref_record refs[2] = {\n \t\t{\n@@ -315,17 +304,12 @@ static void t_reftable_stack_transaction_with_reload(void)\n \t};\n \tstruct reftable_ref_record ref = { 0 };\n \n-\terr = reftable_new_stack(&st1, dir, NULL);\n-\tcheck(!err);\n-\terr = reftable_new_stack(&st2, dir, NULL);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_new_addition(&add, st1, 0);\n-\tcheck(!err);\n-\terr = reftable_addition_add(add, write_test_ref, &refs[0]);\n-\tcheck(!err);\n-\terr = reftable_addition_commit(add);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, NULL), 0);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, NULL), 0);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st1, 0), 0);\n+\tcl_assert_equal_i(reftable_addition_add(add, write_test_ref,\n+\t\t\t\t\t\t&refs[0]), 0);\n+\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \treftable_addition_destroy(add);\n \n \t/*\n@@ -333,20 +317,20 @@ static void t_reftable_stack_transaction_with_reload(void)\n \t * create the addition and lock the stack by default, but allow the\n \t * reload to happen when REFTABLE_STACK_NEW_ADDITION_RELOAD is set.\n \t */\n-\terr = reftable_stack_new_addition(&add, st2, 0);\n-\tcheck_int(err, ==, REFTABLE_OUTDATED_ERROR);\n-\terr = reftable_stack_new_addition(&add, st2, REFTABLE_STACK_NEW_ADDITION_RELOAD);\n-\tcheck(!err);\n-\terr = reftable_addition_add(add, write_test_ref, &refs[1]);\n-\tcheck(!err);\n-\terr = reftable_addition_commit(add);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st2, 0),\n+\t\t\t\t\t\t REFTABLE_OUTDATED_ERROR);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st2,\n+\t\t\t\t\t\t REFTABLE_STACK_NEW_ADDITION_RELOAD), 0);\n+\tcl_assert_equal_i(reftable_addition_add(add, write_test_ref,\n+\t\t\t\t\t\t&refs[1]), 0);\n+\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \treftable_addition_destroy(add);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(refs); i++) {\n-\t\terr = reftable_stack_read_ref(st2, refs[i].refname, &ref);\n-\t\tcheck(!err);\n-\t\tcheck(reftable_ref_record_equal(&refs[i], &ref, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_stack_read_ref(st2,\n+\t\t\t\t\t\t\t refs[i].refname, &ref) , 0);\n+\t\tcl_assert(reftable_ref_record_equal(&refs[i], &ref,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t}\n \n \treftable_ref_record_release(&ref);\n@@ -355,17 +339,15 @@ static void t_reftable_stack_transaction_with_reload(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_transaction_api_performs_auto_compaction(void)\n+void test_reftable_stack__transaction_api_performs_auto_compaction(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = {0};\n \tstruct reftable_addition *add = NULL;\n \tstruct reftable_stack *st = NULL;\n \tsize_t n = 20;\n-\tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (size_t i = 0; i <= n; i++) {\n \t\tstruct reftable_ref_record ref = {\n@@ -385,14 +367,11 @@ static void t_reftable_stack_transaction_api_performs_auto_compaction(void)\n \t\t */\n \t\tst->opts.disable_auto_compact = i != n;\n \n-\t\terr = reftable_stack_new_addition(&add, st, 0);\n-\t\tcheck(!err);\n-\n-\t\terr = reftable_addition_add(add, write_test_ref, &ref);\n-\t\tcheck(!err);\n-\n-\t\terr = reftable_addition_commit(add);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_new_addition(&add,\n+\t\t\t\t\t\t\t st, 0), 0);\n+\t\tcl_assert_equal_i(reftable_addition_add(add,\n+\t\t\t\t\t\t\twrite_test_ref, &ref), 0);\n+\t\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \n \t\treftable_addition_destroy(add);\n \n@@ -402,16 +381,16 @@ static void t_reftable_stack_transaction_api_performs_auto_compaction(void)\n \t\t * all tables in the stack.\n \t\t */\n \t\tif (i != n)\n-\t\t\tcheck_int(st->merged->tables_len, ==, i + 1);\n+\t\t\tcl_assert_equal_i(st->merged->tables_len, i + 1);\n \t\telse\n-\t\t\tcheck_int(st->merged->tables_len, ==, 1);\n+\t\t\tcl_assert_equal_i(st->merged->tables_len, 1);\n \t}\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_auto_compaction_fails_gracefully(void)\n+void test_reftable_stack__auto_compaction_fails_gracefully(void)\n {\n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"refs/heads/master\",\n@@ -425,32 +404,31 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)\n \tchar *dir = get_tmp_dir(__LINE__);\n \tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_test_ref, &ref);\n-\tcheck(!err);\n-\tcheck_int(st->merged->tables_len, ==, 1);\n-\tcheck_int(st->stats.attempts, ==, 0);\n-\tcheck_int(st->stats.failures, ==, 0);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &ref), 0);\n+\tcl_assert_equal_i(st->merged->tables_len, 1);\n+\tcl_assert_equal_i(st->stats.attempts, 0);\n+\tcl_assert_equal_i(st->stats.failures, 0);\n \n \t/*\n \t * Lock the newly written table such that it cannot be compacted.\n \t * Adding a new table to the stack should not be impacted by this, even\n \t * though auto-compaction will now fail.\n \t */\n-\tcheck(!reftable_buf_addstr(&table_path, dir));\n-\tcheck(!reftable_buf_addstr(&table_path, \"/\"));\n-\tcheck(!reftable_buf_addstr(&table_path, st->tables[0]->name));\n-\tcheck(!reftable_buf_addstr(&table_path, \".lock\"));\n+\tcl_assert(!reftable_buf_addstr(&table_path, dir));\n+\tcl_assert(!reftable_buf_addstr(&table_path, \"/\"));\n+\tcl_assert(!reftable_buf_addstr(&table_path,\n+\t\t\t\t st->tables[0]->name));\n+\tcl_assert(!reftable_buf_addstr(&table_path, \".lock\"));\n \twrite_file_buf(table_path.buf, \"\", 0);\n \n \tref.update_index = 2;\n \terr = reftable_stack_add(st, write_test_ref, &ref);\n-\tcheck(!err);\n-\tcheck_int(st->merged->tables_len, ==, 2);\n-\tcheck_int(st->stats.attempts, ==, 1);\n-\tcheck_int(st->stats.failures, ==, 1);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st->merged->tables_len, 2);\n+\tcl_assert_equal_i(st->stats.attempts, 1);\n+\tcl_assert_equal_i(st->stats.failures, 1);\n \n \treftable_stack_destroy(st);\n \treftable_buf_release(&table_path);\n@@ -462,12 +440,11 @@ static int write_error(struct reftable_writer *wr UNUSED, void *arg)\n \treturn *((int *)arg);\n }\n \n-static void t_reftable_stack_update_index_check(void)\n+void test_reftable_stack__update_index_check(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tstruct reftable_ref_record ref1 = {\n \t\t.refname = (char *) \"name1\",\n \t\t.update_index = 1,\n@@ -481,39 +458,33 @@ static void t_reftable_stack_update_index_check(void)\n \t\t.value.symref = (char *) \"master\",\n \t};\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_test_ref, &ref1);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_test_ref, &ref2);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &ref1), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &ref2), REFTABLE_API_ERROR);\n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_lock_failure(void)\n+void test_reftable_stack__lock_failure(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err, i;\n+\tint i;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\tfor (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {\n-\t\terr = reftable_stack_add(st, write_error, &i);\n-\t\tcheck_int(err, ==, i);\n-\t}\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tfor (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--)\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_error,\n+\t\t\t\t\t\t &i), i);\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_add(void)\n+void test_reftable_stack__add(void)\n {\n-\tint err = 0;\n \tstruct reftable_write_options opts = {\n \t\t.exact_log_message = 1,\n \t\t.default_permissions = 0660,\n@@ -526,9 +497,10 @@ static void t_reftable_stack_add(void)\n \tstruct reftable_buf path = REFTABLE_BUF_INIT;\n \tstruct stat stat_result;\n \tsize_t i, N = ARRAY_SIZE(refs);\n+\tint err;\n \n \terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (i = 0; i < N; i++) {\n \t\tchar buf[256];\n@@ -536,66 +508,66 @@ static void t_reftable_stack_add(void)\n \t\trefs[i].refname = xstrdup(buf);\n \t\trefs[i].update_index = i + 1;\n \t\trefs[i].value_type = REFTABLE_REF_VAL1;\n-\t\tt_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \n \t\tlogs[i].refname = xstrdup(buf);\n \t\tlogs[i].update_index = N + i + 1;\n \t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n \t\tlogs[i].value.update.email = xstrdup(\"identity@invalid\");\n-\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n-\tfor (i = 0; i < N; i++) {\n-\t\tint err = reftable_stack_add(st, write_test_ref, &refs[i]);\n-\t\tcheck(!err);\n-\t}\n+\tfor (i = 0; i < N; i++)\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &refs[i]), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct write_log_arg arg = {\n \t\t\t.log = &logs[i],\n \t\t\t.update_index = reftable_stack_next_update_index(st),\n \t\t};\n-\t\tint err = reftable_stack_add(st, write_test_log, &arg);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t\t &arg), 0);\n \t}\n \n-\terr = reftable_stack_compact_all(st, NULL);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct reftable_ref_record dest = { 0 };\n \n-\t\tint err = reftable_stack_read_ref(st, refs[i].refname, &dest);\n-\t\tcheck(!err);\n-\t\tcheck(reftable_ref_record_equal(&dest, refs + i,\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_stack_read_ref(st,\n+\t\t\t\t\t\t\t refs[i].refname, &dest), 0);\n+\t\tcl_assert(reftable_ref_record_equal(&dest, refs + i,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_ref_record_release(&dest);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct reftable_log_record dest = { 0 };\n-\t\tint err = reftable_stack_read_log(st, refs[i].refname, &dest);\n-\t\tcheck(!err);\n-\t\tcheck(reftable_log_record_equal(&dest, logs + i,\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_stack_read_log(st,\n+\t\t\t\t\t\t\t refs[i].refname, &dest), 0);\n+\t\tcl_assert(reftable_log_record_equal(&dest, logs + i,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_log_record_release(&dest);\n \t}\n \n #ifndef GIT_WINDOWS_NATIVE\n-\tcheck(!reftable_buf_addstr(&path, dir));\n-\tcheck(!reftable_buf_addstr(&path, \"/tables.list\"));\n-\terr = stat(path.buf, &stat_result);\n-\tcheck(!err);\n-\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n+\tcl_assert_equal_i(reftable_buf_addstr(&path, dir), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&path, \"/tables.list\"), 0);\n+\tcl_assert_equal_i(stat(path.buf, &stat_result), 0);\n+\tcl_assert_equal_i((stat_result.st_mode & 0777), opts.default_permissions);\n \n \treftable_buf_reset(&path);\n-\tcheck(!reftable_buf_addstr(&path, dir));\n-\tcheck(!reftable_buf_addstr(&path, \"/\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&path, dir), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&path, \"/\"), 0);\n \t/* do not try at home; not an external API for reftable. */\n-\tcheck(!reftable_buf_addstr(&path, st->tables[0]->name));\n+\tcl_assert(!reftable_buf_addstr(&path, st->tables[0]->name));\n \terr = stat(path.buf, &stat_result);\n-\tcheck(!err);\n-\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i((stat_result.st_mode & 0777),\n+\t\t\t opts.default_permissions);\n #else\n \t(void) stat_result;\n #endif\n@@ -610,7 +582,7 @@ static void t_reftable_stack_add(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_iterator(void)\n+void test_reftable_stack__iterator(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n@@ -621,27 +593,27 @@ static void t_reftable_stack_iterator(void)\n \tsize_t N = ARRAY_SIZE(refs), i;\n \tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\trefs[i].refname = xstrfmt(\"branch%02\"PRIuMAX, (uintmax_t)i);\n \t\trefs[i].update_index = i + 1;\n \t\trefs[i].value_type = REFTABLE_REF_VAL1;\n-\t\tt_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \n \t\tlogs[i].refname = xstrfmt(\"branch%02\"PRIuMAX, (uintmax_t)i);\n \t\tlogs[i].update_index = i + 1;\n \t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n \t\tlogs[i].value.update.email = xstrdup(\"johndoe@invalid\");\n \t\tlogs[i].value.update.message = xstrdup(\"commit\\n\");\n-\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n-\tfor (i = 0; i < N; i++) {\n-\t\terr = reftable_stack_add(st, write_test_ref, &refs[i]);\n-\t\tcheck(!err);\n-\t}\n+\tfor (i = 0; i < N; i++)\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t write_test_ref, &refs[i]), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct write_log_arg arg = {\n@@ -649,8 +621,8 @@ static void t_reftable_stack_iterator(void)\n \t\t\t.update_index = reftable_stack_next_update_index(st),\n \t\t};\n \n-\t\terr = reftable_stack_add(st, write_test_log, &arg);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t write_test_log, &arg), 0);\n \t}\n \n \treftable_stack_init_ref_iterator(st, &it);\n@@ -661,16 +633,16 @@ static void t_reftable_stack_iterator(void)\n \t\terr = reftable_iterator_next_ref(&it, &ref);\n \t\tif (err > 0)\n \t\t\tbreak;\n-\t\tcheck(!err);\n-\t\tcheck(reftable_ref_record_equal(&ref, &refs[i], REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(!err);\n+\t\tcl_assert(reftable_ref_record_equal(&ref, &refs[i],\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_ref_record_release(&ref);\n \t}\n-\tcheck_int(i, ==, N);\n+\tcl_assert_equal_i(i, N);\n \n \treftable_iterator_destroy(&it);\n \n-\terr = reftable_stack_init_log_iterator(st, &it);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_init_log_iterator(st, &it), 0);\n \n \treftable_iterator_seek_log(&it, logs[0].refname);\n \tfor (i = 0; ; i++) {\n@@ -679,11 +651,12 @@ static void t_reftable_stack_iterator(void)\n \t\terr = reftable_iterator_next_log(&it, &log);\n \t\tif (err > 0)\n \t\t\tbreak;\n-\t\tcheck(!err);\n-\t\tcheck(reftable_log_record_equal(&log, &logs[i], REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(!err);\n+\t\tcl_assert(reftable_log_record_equal(&log, &logs[i],\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_log_record_release(&log);\n \t}\n-\tcheck_int(i, ==, N);\n+\tcl_assert_equal_i(i, N);\n \n \treftable_stack_destroy(st);\n \treftable_iterator_destroy(&it);\n@@ -694,9 +667,8 @@ static void t_reftable_stack_iterator(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_log_normalize(void)\n+void test_reftable_stack__log_normalize(void)\n {\n-\tint err = 0;\n \tstruct reftable_write_options opts = {\n \t\t0,\n \t};\n@@ -721,28 +693,26 @@ static void t_reftable_stack_log_normalize(void)\n \t\t.update_index = 1,\n \t};\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tinput.value.update.message = (char *) \"one\\ntwo\";\n-\terr = reftable_stack_add(st, write_test_log, &arg);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t &arg), REFTABLE_API_ERROR);\n \n \tinput.value.update.message = (char *) \"one\";\n-\terr = reftable_stack_add(st, write_test_log, &arg);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_log(st, input.refname, &dest);\n-\tcheck(!err);\n-\tcheck_str(dest.value.update.message, \"one\\n\");\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t &arg), 0);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, input.refname,\n+\t\t\t\t\t\t &dest), 0);\n+\tcl_assert_equal_s(dest.value.update.message, \"one\\n\");\n \n \tinput.value.update.message = (char *) \"two\\n\";\n \targ.update_index = 2;\n-\terr = reftable_stack_add(st, write_test_log, &arg);\n-\tcheck(!err);\n-\terr = reftable_stack_read_log(st, input.refname, &dest);\n-\tcheck(!err);\n-\tcheck_str(dest.value.update.message, \"two\\n\");\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t &arg), 0);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, input.refname,\n+\t\t\t\t\t\t &dest), 0);\n+\tcl_assert_equal_s(dest.value.update.message, \"two\\n\");\n \n \t/* cleanup */\n \treftable_stack_destroy(st);\n@@ -750,20 +720,18 @@ static void t_reftable_stack_log_normalize(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_tombstone(void)\n+void test_reftable_stack__tombstone(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tstruct reftable_ref_record refs[2] = { 0 };\n \tstruct reftable_log_record logs[2] = { 0 };\n \tsize_t i, N = ARRAY_SIZE(refs);\n \tstruct reftable_ref_record dest = { 0 };\n \tstruct reftable_log_record log_dest = { 0 };\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \t/* even entries add the refs, odd entries delete them. */\n \tfor (i = 0; i < N; i++) {\n@@ -772,8 +740,8 @@ static void t_reftable_stack_tombstone(void)\n \t\trefs[i].update_index = i + 1;\n \t\tif (i % 2 == 0) {\n \t\t\trefs[i].value_type = REFTABLE_REF_VAL1;\n-\t\t\tt_reftable_set_hash(refs[i].value.val1, i,\n-\t\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n+\t\t\t\t\t REFTABLE_HASH_SHA1);\n \t\t}\n \n \t\tlogs[i].refname = xstrdup(buf);\n@@ -785,42 +753,36 @@ static void t_reftable_stack_tombstone(void)\n \t\tlogs[i].update_index = 1;\n \t\tif (i % 2 == 0) {\n \t\t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n-\t\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i,\n-\t\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);\n \t\t\tlogs[i].value.update.email =\n \t\t\t\txstrdup(\"identity@invalid\");\n \t\t}\n \t}\n-\tfor (i = 0; i < N; i++) {\n-\t\tint err = reftable_stack_add(st, write_test_ref, &refs[i]);\n-\t\tcheck(!err);\n-\t}\n+\tfor (i = 0; i < N; i++)\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref, &refs[i]), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct write_log_arg arg = {\n \t\t\t.log = &logs[i],\n \t\t\t.update_index = reftable_stack_next_update_index(st),\n \t\t};\n-\t\tint err = reftable_stack_add(st, write_test_log, &arg);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t write_test_log, &arg), 0);\n \t}\n \n-\terr = reftable_stack_read_ref(st, \"branch\", &dest);\n-\tcheck_int(err, ==, 1);\n+\tcl_assert_equal_i(reftable_stack_read_ref(st, \"branch\",\n+\t\t\t\t\t\t &dest), 1);\n \treftable_ref_record_release(&dest);\n \n-\terr = reftable_stack_read_log(st, \"branch\", &log_dest);\n-\tcheck_int(err, ==, 1);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, \"branch\",\n+\t\t\t\t\t\t &log_dest), 1);\n \treftable_log_record_release(&log_dest);\n \n-\terr = reftable_stack_compact_all(st, NULL);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_ref(st, \"branch\", &dest);\n-\tcheck_int(err, ==, 1);\n-\n-\terr = reftable_stack_read_log(st, \"branch\", &log_dest);\n-\tcheck_int(err, ==, 1);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);\n+\tcl_assert_equal_i(reftable_stack_read_ref(st, \"branch\",\n+\t\t\t\t\t\t &dest), 1);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, \"branch\",\n+\t\t\t\t\t\t &log_dest), 1);\n \treftable_ref_record_release(&dest);\n \treftable_log_record_release(&log_dest);\n \n@@ -833,12 +795,11 @@ static void t_reftable_stack_tombstone(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_hash_id(void)\n+void test_reftable_stack__hash_id(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"master\",\n@@ -852,62 +813,57 @@ static void t_reftable_stack_hash_id(void)\n \tstruct reftable_stack *st_default = NULL;\n \tstruct reftable_ref_record dest = { 0 };\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_test_ref, &ref);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &ref), 0);\n \n \t/* can't read it with the wrong hash ID. */\n-\terr = reftable_new_stack(&st32, dir, &opts32);\n-\tcheck_int(err, ==, REFTABLE_FORMAT_ERROR);\n+\tcl_assert_equal_i(reftable_new_stack(&st32, dir,\n+\t\t\t\t\t &opts32), REFTABLE_FORMAT_ERROR);\n \n \t/* check that we can read it back with default opts too. */\n-\terr = reftable_new_stack(&st_default, dir, &opts_default);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_ref(st_default, \"master\", &dest);\n-\tcheck(!err);\n-\n-\tcheck(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert_equal_i(reftable_new_stack(&st_default, dir,\n+\t\t\t\t\t &opts_default), 0);\n+\tcl_assert_equal_i(reftable_stack_read_ref(st_default, \"master\",\n+\t\t\t\t\t\t &dest), 0);\n+\tcl_assert(reftable_ref_record_equal(&ref, &dest,\n+\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \treftable_ref_record_release(&dest);\n \treftable_stack_destroy(st);\n \treftable_stack_destroy(st_default);\n \tclear_dir(dir);\n }\n \n-static void t_suggest_compaction_segment(void)\n+void test_reftable_stack__suggest_compaction_segment(void)\n {\n \tuint64_t sizes[] = { 512, 64, 17, 16, 9, 9, 9, 16, 2, 16 };\n \tstruct segment min =\n \t\tsuggest_compaction_segment(sizes, ARRAY_SIZE(sizes), 2);\n-\tcheck_int(min.start, ==, 1);\n-\tcheck_int(min.end, ==, 10);\n+\tcl_assert_equal_i(min.start, 1);\n+\tcl_assert_equal_i(min.end, 10);\n }\n \n-static void t_suggest_compaction_segment_nothing(void)\n+void test_reftable_stack__suggest_compaction_segment_nothing(void)\n {\n \tuint64_t sizes[] = { 64, 32, 16, 8, 4, 2 };\n \tstruct segment result =\n \t\tsuggest_compaction_segment(sizes, ARRAY_SIZE(sizes), 2);\n-\tcheck_int(result.start, ==, result.end);\n+\tcl_assert_equal_i(result.start, result.end);\n }\n \n-static void t_reflog_expire(void)\n+void test_reftable_stack__reflog_expire(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n \tstruct reftable_log_record logs[20] = { 0 };\n \tsize_t i, N = ARRAY_SIZE(logs) - 1;\n-\tint err;\n \tstruct reftable_log_expiry_config expiry = {\n \t\t.time = 10,\n \t};\n \tstruct reftable_log_record log = { 0 };\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 1; i <= N; i++) {\n \t\tchar buf[256];\n@@ -918,8 +874,8 @@ static void t_reflog_expire(void)\n \t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n \t\tlogs[i].value.update.time = i;\n \t\tlogs[i].value.update.email = xstrdup(\"identity@invalid\");\n-\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n \tfor (i = 1; i <= N; i++) {\n@@ -927,31 +883,23 @@ static void t_reflog_expire(void)\n \t\t\t.log = &logs[i],\n \t\t\t.update_index = reftable_stack_next_update_index(st),\n \t\t};\n-\t\tint err = reftable_stack_add(st, write_test_log, &arg);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t\t &arg), 0);\n \t}\n \n-\terr = reftable_stack_compact_all(st, NULL);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_compact_all(st, &expiry);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_log(st, logs[9].refname, &log);\n-\tcheck_int(err, ==, 1);\n-\n-\terr = reftable_stack_read_log(st, logs[11].refname, &log);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, &expiry), 0);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, logs[9].refname,\n+\t\t\t\t\t\t &log), 1);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, logs[11].refname,\n+\t\t\t\t\t\t &log), 0);\n \n \texpiry.min_update_index = 15;\n-\terr = reftable_stack_compact_all(st, &expiry);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_log(st, logs[14].refname, &log);\n-\tcheck_int(err, ==, 1);\n-\n-\terr = reftable_stack_read_log(st, logs[16].refname, &log);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, &expiry), 0);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, logs[14].refname,\n+\t\t\t\t\t\t &log), 1);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, logs[16].refname,\n+\t\t\t\t\t\t &log), 0);\n \n \t/* cleanup */\n \treftable_stack_destroy(st);\n@@ -963,26 +911,21 @@ static void t_reflog_expire(void)\n \n static int write_nothing(struct reftable_writer *wr, void *arg UNUSED)\n {\n-\tcheck(!reftable_writer_set_limits(wr, 1, 1));\n+\tcl_assert_equal_i(reftable_writer_set_limits(wr, 1, 1), 0);\n \treturn 0;\n }\n \n-static void t_empty_add(void)\n+void test_reftable_stack__empty_add(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_stack *st2 = NULL;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_nothing, NULL);\n-\tcheck(!err);\n-\n-\terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_nothing,\n+\t\t\t\t\t NULL), 0);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n \tclear_dir(dir);\n \treftable_stack_destroy(st);\n \treftable_stack_destroy(st2);\n@@ -998,18 +941,17 @@ static int fastlogN(uint64_t sz, uint64_t N)\n \treturn l - 1;\n }\n \n-static void t_reftable_stack_auto_compaction(void)\n+void test_reftable_stack__auto_compaction(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.disable_auto_compact = 1,\n \t};\n \tstruct reftable_stack *st = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \tsize_t i, N = 100;\n+\tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tchar name[100];\n@@ -1022,32 +964,31 @@ static void t_reftable_stack_auto_compaction(void)\n \t\tsnprintf(name, sizeof(name), \"branch%04\"PRIuMAX, (uintmax_t)i);\n \n \t\terr = reftable_stack_add(st, write_test_ref, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \n \t\terr = reftable_stack_auto_compact(st);\n-\t\tcheck(!err);\n-\t\tcheck(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));\n+\t\tcl_assert(!err);\n+\t\tcl_assert(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));\n \t}\n \n-\tcheck_int(reftable_stack_compaction_stats(st)->entries_written, <,\n-\t (uint64_t)(N * fastlogN(N, 2)));\n+\tcl_assert(reftable_stack_compaction_stats(st)->entries_written <\n+\t\t\t (uint64_t)(N * fastlogN(N, 2)));\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_auto_compaction_factor(void)\n+void test_reftable_stack__auto_compaction_factor(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.auto_compaction_factor = 5,\n \t};\n \tstruct reftable_stack *st = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \tsize_t N = 100;\n+\tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (size_t i = 0; i < N; i++) {\n \t\tchar name[20];\n@@ -1059,16 +1000,16 @@ static void t_reftable_stack_auto_compaction_factor(void)\n \t\txsnprintf(name, sizeof(name), \"branch%04\"PRIuMAX, (uintmax_t)i);\n \n \t\terr = reftable_stack_add(st, &write_test_ref, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \n-\t\tcheck(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));\n+\t\tcl_assert(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));\n \t}\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_auto_compaction_with_locked_tables(void)\n+void test_reftable_stack__auto_compaction_with_locked_tables(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.disable_auto_compact = 1,\n@@ -1078,21 +1019,20 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)\n \tchar *dir = get_tmp_dir(__LINE__);\n \tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \twrite_n_ref_tables(st, 5);\n-\tcheck_int(st->merged->tables_len, ==, 5);\n+\tcl_assert_equal_i(st->merged->tables_len, 5);\n \n \t/*\n \t * Given that all tables we have written should be roughly the same\n \t * size, we expect that auto-compaction will want to compact all of the\n \t * tables. Locking any of the tables will keep it from doing so.\n \t */\n-\tcheck(!reftable_buf_addstr(&buf, dir));\n-\tcheck(!reftable_buf_addstr(&buf, \"/\"));\n-\tcheck(!reftable_buf_addstr(&buf, st->tables[2]->name));\n-\tcheck(!reftable_buf_addstr(&buf, \".lock\"));\n+\tcl_assert(!reftable_buf_addstr(&buf, dir));\n+\tcl_assert(!reftable_buf_addstr(&buf, \"/\"));\n+\tcl_assert(!reftable_buf_addstr(&buf, st->tables[2]->name));\n+\tcl_assert(!reftable_buf_addstr(&buf, \".lock\"));\n \twrite_file_buf(buf.buf, \"\", 0);\n \n \t/*\n@@ -1102,25 +1042,23 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)\n \t * only compact the newest two tables.\n \t */\n \terr = reftable_stack_auto_compact(st);\n-\tcheck(!err);\n-\tcheck_int(st->stats.failures, ==, 0);\n-\tcheck_int(st->merged->tables_len, ==, 4);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st->stats.failures, 0);\n+\tcl_assert_equal_i(st->merged->tables_len, 4);\n \n \treftable_stack_destroy(st);\n \treftable_buf_release(&buf);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_add_performs_auto_compaction(void)\n+void test_reftable_stack__add_performs_auto_compaction(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \tsize_t i, n = 20;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 0; i <= n; i++) {\n \t\tstruct reftable_ref_record ref = {\n@@ -1140,8 +1078,8 @@ static void t_reftable_stack_add_performs_auto_compaction(void)\n \t\tsnprintf(buf, sizeof(buf), \"branch-%04\"PRIuMAX, (uintmax_t)i);\n \t\tref.refname = buf;\n \n-\t\terr = reftable_stack_add(st, write_test_ref, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t write_test_ref, &ref), 0);\n \n \t\t/*\n \t\t * The stack length should grow continuously for all runs where\n@@ -1149,16 +1087,16 @@ static void t_reftable_stack_add_performs_auto_compaction(void)\n \t\t * all tables in the stack.\n \t\t */\n \t\tif (i != n)\n-\t\t\tcheck_int(st->merged->tables_len, ==, i + 1);\n+\t\t\tcl_assert_equal_i(st->merged->tables_len, i + 1);\n \t\telse\n-\t\t\tcheck_int(st->merged->tables_len, ==, 1);\n+\t\t\tcl_assert_equal_i(st->merged->tables_len, 1);\n \t}\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_compaction_with_locked_tables(void)\n+void test_reftable_stack__compaction_with_locked_tables(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.disable_auto_compact = 1,\n@@ -1168,17 +1106,16 @@ static void t_reftable_stack_compaction_with_locked_tables(void)\n \tchar *dir = get_tmp_dir(__LINE__);\n \tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \twrite_n_ref_tables(st, 3);\n-\tcheck_int(st->merged->tables_len, ==, 3);\n+\tcl_assert_equal_i(st->merged->tables_len, 3);\n \n \t/* Lock one of the tables that we're about to compact. */\n-\tcheck(!reftable_buf_addstr(&buf, dir));\n-\tcheck(!reftable_buf_addstr(&buf, \"/\"));\n-\tcheck(!reftable_buf_addstr(&buf, st->tables[1]->name));\n-\tcheck(!reftable_buf_addstr(&buf, \".lock\"));\n+\tcl_assert(!reftable_buf_addstr(&buf, dir));\n+\tcl_assert(!reftable_buf_addstr(&buf, \"/\"));\n+\tcl_assert(!reftable_buf_addstr(&buf, st->tables[1]->name));\n+\tcl_assert(!reftable_buf_addstr(&buf, \".lock\"));\n \twrite_file_buf(buf.buf, \"\", 0);\n \n \t/*\n@@ -1186,36 +1123,31 @@ static void t_reftable_stack_compaction_with_locked_tables(void)\n \t * compact all tables.\n \t */\n \terr = reftable_stack_compact_all(st, NULL);\n-\tcheck_int(err, ==, REFTABLE_LOCK_ERROR);\n-\tcheck_int(st->stats.failures, ==, 1);\n-\tcheck_int(st->merged->tables_len, ==, 3);\n+\tcl_assert_equal_i(err, REFTABLE_LOCK_ERROR);\n+\tcl_assert_equal_i(st->stats.failures, 1);\n+\tcl_assert_equal_i(st->merged->tables_len, 3);\n \n \treftable_stack_destroy(st);\n \treftable_buf_release(&buf);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_compaction_concurrent(void)\n+void test_reftable_stack__compaction_concurrent(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st1 = NULL, *st2 = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \n-\terr = reftable_new_stack(&st1, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n \twrite_n_ref_tables(st1, 3);\n \n-\terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_compact_all(st1, NULL);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st1, NULL), 0);\n \n \treftable_stack_destroy(st1);\n \treftable_stack_destroy(st2);\n \n-\tcheck_int(count_dir_entries(dir), ==, 2);\n+\tcl_assert_equal_i(count_dir_entries(dir), 2);\n \tclear_dir(dir);\n }\n \n@@ -1228,32 +1160,24 @@ static void unclean_stack_close(struct reftable_stack *st)\n \tREFTABLE_FREE_AND_NULL(st->tables);\n }\n \n-static void t_reftable_stack_compaction_concurrent_clean(void)\n+void test_reftable_stack__compaction_concurrent_clean(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st1 = NULL, *st2 = NULL, *st3 = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \n-\terr = reftable_new_stack(&st1, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n \twrite_n_ref_tables(st1, 3);\n \n-\terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_compact_all(st1, NULL);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st1, NULL), 0);\n \n \tunclean_stack_close(st1);\n \tunclean_stack_close(st2);\n \n-\terr = reftable_new_stack(&st3, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_clean(st3);\n-\tcheck(!err);\n-\tcheck_int(count_dir_entries(dir), ==, 2);\n+\tcl_assert_equal_i(reftable_new_stack(&st3, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_clean(st3), 0);\n+\tcl_assert_equal_i(count_dir_entries(dir), 2);\n \n \treftable_stack_destroy(st1);\n \treftable_stack_destroy(st2);\n@@ -1262,7 +1186,7 @@ static void t_reftable_stack_compaction_concurrent_clean(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_read_across_reload(void)\n+void test_reftable_stack__read_across_reload(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st1 = NULL, *st2 = NULL;\n@@ -1272,37 +1196,35 @@ static void t_reftable_stack_read_across_reload(void)\n \tint err;\n \n \t/* Create a first stack and set up an iterator for it. */\n-\terr = reftable_new_stack(&st1, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n \twrite_n_ref_tables(st1, 2);\n-\tcheck_int(st1->merged->tables_len, ==, 2);\n+\tcl_assert_equal_i(st1->merged->tables_len, 2);\n \treftable_stack_init_ref_iterator(st1, &it);\n-\terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_iterator_seek_ref(&it, \"\"), 0);\n \n \t/* Set up a second stack for the same directory and compact it. */\n \terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n-\tcheck_int(st2->merged->tables_len, ==, 2);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st2->merged->tables_len, 2);\n \terr = reftable_stack_compact_all(st2, NULL);\n-\tcheck(!err);\n-\tcheck_int(st2->merged->tables_len, ==, 1);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st2->merged->tables_len, 1);\n \n \t/*\n \t * Verify that we can continue to use the old iterator even after we\n \t * have reloaded its stack.\n \t */\n \terr = reftable_stack_reload(st1);\n-\tcheck(!err);\n-\tcheck_int(st1->merged->tables_len, ==, 1);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st1->merged->tables_len, 1);\n \terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\tcheck_str(rec.refname, \"refs/heads/branch-0000\");\n+\tcl_assert(!err);\n+\tcl_assert_equal_s(rec.refname, \"refs/heads/branch-0000\");\n \terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\tcheck_str(rec.refname, \"refs/heads/branch-0001\");\n+\tcl_assert(!err);\n+\tcl_assert_equal_s(rec.refname, \"refs/heads/branch-0001\");\n \terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck_int(err, >, 0);\n+\tcl_assert(err > 0);\n \n \treftable_ref_record_release(&rec);\n \treftable_iterator_destroy(&it);\n@@ -1311,7 +1233,7 @@ static void t_reftable_stack_read_across_reload(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_reload_with_missing_table(void)\n+void test_reftable_stack__reload_with_missing_table(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n@@ -1322,46 +1244,40 @@ static void t_reftable_stack_reload_with_missing_table(void)\n \tint err;\n \n \t/* Create a first stack and set up an iterator for it. */\n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \twrite_n_ref_tables(st, 2);\n-\tcheck_int(st->merged->tables_len, ==, 2);\n+\tcl_assert_equal_i(st->merged->tables_len, 2);\n \treftable_stack_init_ref_iterator(st, &it);\n-\terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_iterator_seek_ref(&it, \"\"), 0);\n \n \t/*\n \t * Update the tables.list file with some garbage data, while reusing\n \t * our old tables. This should trigger a partial reload of the stack,\n \t * where we try to reuse our old tables.\n \t*/\n-\tcheck(!reftable_buf_addstr(&content, st->tables[0]->name));\n-\tcheck(!reftable_buf_addstr(&content, \"\\n\"));\n-\tcheck(!reftable_buf_addstr(&content, st->tables[1]->name));\n-\tcheck(!reftable_buf_addstr(&content, \"\\n\"));\n-\tcheck(!reftable_buf_addstr(&content, \"garbage\\n\"));\n-\tcheck(!reftable_buf_addstr(&table_path, st->list_file));\n-\tcheck(!reftable_buf_addstr(&table_path, \".lock\"));\n+\tcl_assert(!reftable_buf_addstr(&content, st->tables[0]->name));\n+\tcl_assert(!reftable_buf_addstr(&content, \"\\n\"));\n+\tcl_assert(!reftable_buf_addstr(&content, st->tables[1]->name));\n+\tcl_assert(!reftable_buf_addstr(&content, \"\\n\"));\n+\tcl_assert(!reftable_buf_addstr(&content, \"garbage\\n\"));\n+\tcl_assert(!reftable_buf_addstr(&table_path, st->list_file));\n+\tcl_assert(!reftable_buf_addstr(&table_path, \".lock\"));\n \twrite_file_buf(table_path.buf, content.buf, content.len);\n-\terr = rename(table_path.buf, st->list_file);\n-\tcheck(!err);\n+\tcl_assert_equal_i(rename(table_path.buf, st->list_file), 0);\n \n \terr = reftable_stack_reload(st);\n-\tcheck_int(err, ==, -4);\n-\tcheck_int(st->merged->tables_len, ==, 2);\n+\tcl_assert_equal_i(err, -4);\n+\tcl_assert_equal_i(st->merged->tables_len, 2);\n \n \t/*\n \t * Even though the reload has failed, we should be able to continue\n \t * using the iterator.\n \t*/\n-\terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\tcheck_str(rec.refname, \"refs/heads/branch-0000\");\n-\terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\tcheck_str(rec.refname, \"refs/heads/branch-0001\");\n-\terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck_int(err, >, 0);\n+\tcl_assert_equal_i(reftable_iterator_next_ref(&it, &rec), 0);\n+\tcl_assert_equal_s(rec.refname, \"refs/heads/branch-0000\");\n+\tcl_assert_equal_i(reftable_iterator_next_ref(&it, &rec), 0);\n+\tcl_assert_equal_s(rec.refname, \"refs/heads/branch-0001\");\n+\tcl_assert(reftable_iterator_next_ref(&it, &rec) > 0);\n \n \treftable_ref_record_release(&rec);\n \treftable_iterator_destroy(&it);\n@@ -1374,12 +1290,13 @@ static void t_reftable_stack_reload_with_missing_table(void)\n static int write_limits_after_ref(struct reftable_writer *wr, void *arg)\n {\n \tstruct reftable_ref_record *ref = arg;\n-\tcheck(!reftable_writer_set_limits(wr, ref->update_index, ref->update_index));\n-\tcheck(!reftable_writer_add_ref(wr, ref));\n+\tcl_assert_equal_i(reftable_writer_set_limits(wr,\n+\t\t\t\t\t\t ref->update_index, ref->update_index), 0);\n+\tcl_assert_equal_i(reftable_writer_add_ref(wr, ref), 0);\n \treturn reftable_writer_set_limits(wr, ref->update_index, ref->update_index);\n }\n \n-static void t_reftable_invalid_limit_updates(void)\n+void test_reftable_stack__invalid_limit_updates(void)\n {\n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"HEAD\",\n@@ -1393,59 +1310,22 @@ static void t_reftable_invalid_limit_updates(void)\n \tstruct reftable_addition *add = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \treftable_addition_destroy(add);\n \n-\terr = reftable_stack_new_addition(&add, st, 0);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st, 0), 0);\n \n \t/*\n \t * write_limits_after_ref also updates the update indexes after adding\n \t * the record. This should cause an err to be returned, since the limits\n \t * must be set at the start.\n \t */\n-\terr = reftable_addition_add(add, write_limits_after_ref, &ref);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_addition_add(add,\n+\t\t\t\t\t\twrite_limits_after_ref, &ref), REFTABLE_API_ERROR);\n \n \treftable_addition_destroy(add);\n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_empty_add(), \"empty addition to stack\");\n-\tTEST(t_read_file(), \"read_lines works\");\n-\tTEST(t_reflog_expire(), \"expire reflog entries\");\n-\tTEST(t_reftable_invalid_limit_updates(), \"prevent limit updates after adding records\");\n-\tTEST(t_reftable_stack_add(), \"add multiple refs and logs to stack\");\n-\tTEST(t_reftable_stack_add_one(), \"add a single ref record to stack\");\n-\tTEST(t_reftable_stack_add_performs_auto_compaction(), \"addition to stack triggers auto-compaction\");\n-\tTEST(t_reftable_stack_auto_compaction(), \"stack must form geometric sequence after compaction\");\n-\tTEST(t_reftable_stack_auto_compaction_factor(), \"auto-compaction with non-default geometric factor\");\n-\tTEST(t_reftable_stack_auto_compaction_fails_gracefully(), \"failure on auto-compaction\");\n-\tTEST(t_reftable_stack_auto_compaction_with_locked_tables(), \"auto compaction with locked tables\");\n-\tTEST(t_reftable_stack_compaction_concurrent(), \"compaction with concurrent stack\");\n-\tTEST(t_reftable_stack_compaction_concurrent_clean(), \"compaction with unclean stack shutdown\");\n-\tTEST(t_reftable_stack_compaction_with_locked_tables(), \"compaction with locked tables\");\n-\tTEST(t_reftable_stack_hash_id(), \"read stack with wrong hash ID\");\n-\tTEST(t_reftable_stack_iterator(), \"log and ref iterator for reftable stack\");\n-\tTEST(t_reftable_stack_lock_failure(), \"stack addition with lockfile failure\");\n-\tTEST(t_reftable_stack_log_normalize(), \"log messages should be normalized\");\n-\tTEST(t_reftable_stack_read_across_reload(), \"stack iterators work across reloads\");\n-\tTEST(t_reftable_stack_reload_with_missing_table(), \"stack iteration with garbage tables\");\n-\tTEST(t_reftable_stack_tombstone(), \"'tombstone' refs in stack\");\n-\tTEST(t_reftable_stack_transaction_api(), \"update transaction to stack\");\n-\tTEST(t_reftable_stack_transaction_with_reload(), \"transaction with reload\");\n-\tTEST(t_reftable_stack_transaction_api_performs_auto_compaction(), \"update transaction triggers auto-compaction\");\n-\tTEST(t_reftable_stack_update_index_check(), \"update transactions with equal update indices\");\n-\tTEST(t_reftable_stack_uptodate(), \"stack must be reloaded before ref update\");\n-\tTEST(t_suggest_compaction_segment(), \"suggest_compaction_segment with basic input\");\n-\tTEST(t_suggest_compaction_segment_nothing(), \"suggest_compaction_segment with pre-compacted input\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"522668","messageId":"20250724142837.67149-1-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250605140644.239199-1-kuforiji98@gmail.com","subject":"[PATCH v5 00/10] t/unit-tests: convert unit-tests to use clar","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T14:28:27Z","receivedAt":"2025-07-24T14:29:49Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"Hello,\n\nThis patch series marks the final batch of our existing unit test files\ntransitioned to the Clar testing framework. It covers all the\nreftable-related test files, and is part of our ongoing effort to\nstandardize our testing framework to enhance its maintainability.\n\nChanges in v5:\n - some code refactoring and cleanup based on review.\n\nThanks\nSeyi\n\nSigned-off-by: Seyi Kuforiji \n\nSeyi Kuforiji (10):\n t/unit-tests: implement clar specific reftable test helper functions\n t/unit-tests: convert reftable basics test to use clar test framework\n t/unit-tests: convert reftable block test to use clar\n t/unit-tests: convert reftable merged test to use clar\n t/unit-tests: convert reftable pq test to use clar\n t/unit-tests: convert reftable table test to use clar\n t/unit-tests: convert reftable readwrite test to use clar\n t/unit-tests: convert reftable record test to use clar\n t/unit-tests: convert reftable stack test to use clar\n t/unit-tests: finalize migration of reftable-related tests\n\n Makefile | 20 +-\n t/Makefile | 1 -\n t/meson.build | 42 +-\n t/unit-tests/lib-reftable.c | 35 +-\n t/unit-tests/lib-reftable.h | 15 +-\n t/unit-tests/t-reftable-basics.c | 219 -----\n t/unit-tests/u-reftable-basics.c | 227 +++++\n ...{t-reftable-block.c => u-reftable-block.c} | 164 ++--\n ...-reftable-merged.c => u-reftable-merged.c} | 160 ++--\n .../{t-reftable-pq.c => u-reftable-pq.c} | 59 +-\n ...ble-readwrite.c => u-reftable-readwrite.c} | 403 ++++-----\n ...-reftable-record.c => u-reftable-record.c} | 250 +++---\n ...{t-reftable-stack.c => u-reftable-stack.c} | 780 ++++++++----------\n ...{t-reftable-table.c => u-reftable-table.c} | 73 +-\n 14 files changed, 1117 insertions(+), 1331 deletions(-)\n delete mode 100644 t/unit-tests/t-reftable-basics.c\n create mode 100644 t/unit-tests/u-reftable-basics.c\n rename t/unit-tests/{t-reftable-block.c => u-reftable-block.c} (74%)\n rename t/unit-tests/{t-reftable-merged.c => u-reftable-merged.c} (77%)\n rename t/unit-tests/{t-reftable-pq.c => u-reftable-pq.c} (64%)\n rename t/unit-tests/{t-reftable-readwrite.c => u-reftable-readwrite.c} (68%)\n rename t/unit-tests/{t-reftable-record.c => u-reftable-record.c} (62%)\n rename t/unit-tests/{t-reftable-stack.c => u-reftable-stack.c} (59%)\n rename t/unit-tests/{t-reftable-table.c => u-reftable-table.c} (75%)\n\nRange-diff against v4:\n -: ---------- > 1: 4a04557ae3 t/unit-tests: implement clar specific reftable test helper functions\n -: ---------- > 2: 2c576ddd11 t/unit-tests: convert reftable basics test to use clar test framework\n -: ---------- > 3: 04d54fef89 t/unit-tests: convert reftable block test to use clar\n -: ---------- > 4: 06eba27f8e t/unit-tests: convert reftable merged test to use clar\n -: ---------- > 5: eaa8b8d636 t/unit-tests: convert reftable pq test to use clar\n 1: 7c159bd2fe ! 6: cf8b0471fd t/unit-tests: convert reftable table test to use clar\n @@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o\n -@@ Makefile: $(LIBGIT_HIDDEN_EXPORT): $(LIBGIT_PARTIAL_EXPORT)\n - \t$(OBJCOPY) --localize-hidden $^ $@\n - \n - contrib/libgit-sys/libgitpub.a: $(LIBGIT_HIDDEN_EXPORT)\n --\t$(AR) $(ARFLAGS) $@ $^\n -+\t$(AR) $(ARFLAGS) $@ $^\n - \\ No newline at end of file\n \n ## t/meson.build ##\n @@ t/meson.build: clar_test_suites = [\n 2: 3ae3b2cf9c = 7: cbe70c5c23 t/unit-tests: convert reftable readwrite test to use clar\n 3: d4303eb913 ! 8: 38e2198eac t/unit-tests: convert reftable record test to use clar\n @@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\n \n ## t/meson.build ##\n +@@ t/meson.build: clar_test_suites = [\n + 'unit-tests/u-reftable-merged.c',\n + 'unit-tests/u-reftable-pq.c',\n + 'unit-tests/u-reftable-readwrite.c',\n ++ 'unit-tests/u-reftable-record.c',\n + 'unit-tests/u-reftable-table.c',\n + 'unit-tests/u-reftable-tree.c',\n + 'unit-tests/u-strbuf.c',\n @@ t/meson.build: clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n 4: df582f6e2c ! 9: 8de9dbbd3b t/unit-tests: convert reftable stack test to use clar\n @@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n \n ## t/meson.build ##\n @@ t/meson.build: clar_test_suites = [\n - 'unit-tests/u-reftable-merged.c',\n 'unit-tests/u-reftable-pq.c',\n 'unit-tests/u-reftable-readwrite.c',\n -+ 'unit-tests/u-reftable-record.c',\n + 'unit-tests/u-reftable-record.c',\n + 'unit-tests/u-reftable-stack.c',\n 'unit-tests/u-reftable-table.c',\n 'unit-tests/u-reftable-tree.c',\n 5: 9340e7ce88 ! 10: a69c3370ee t/unit-tests: finalize migration of reftable-related tests\n @@ Makefile: CLAR_TEST_SUITES += u-urlmatch-normalization\n \n # xdiff and reftable libs may in turn depend on what is in libgit.a\n GITLIBS = common-main.o $(LIB_FILE) $(XDIFF_LIB) $(REFTABLE_LIB) $(LIB_FILE)\n -@@ Makefile: $(LIBGIT_HIDDEN_EXPORT): $(LIBGIT_PARTIAL_EXPORT)\n - \t$(OBJCOPY) --localize-hidden $^ $@\n - \n - contrib/libgit-sys/libgitpub.a: $(LIBGIT_HIDDEN_EXPORT)\n --\t$(AR) $(ARFLAGS) $@ $^\n - \\ No newline at end of file\n -+\t$(AR) $(ARFLAGS) $@ $^\n \n ## t/Makefile ##\n @@ t/Makefile: check-meson:\n-- \n2.43.0\n\n"},{"id":"522669","messageId":"20250724142837.67149-2-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250724142837.67149-1-kuforiji98@gmail.com","subject":"[PATCH v5 01/10] t/unit-tests: implement clar specific reftable test helper functions","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T14:28:28Z","receivedAt":"2025-07-24T14:29:54Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kuforiji \n\nHelper functions defined in `t/unit-tests/lib-reftable.{c,h}` are\nrequired for the reftable-related test files to run. In the current\nimplementation these functions are designed to conform with our\nhomegrown unit-testing structure. So in other to convert the reftable\ntest files, there is need for a clar specific implementation of these\nhelper functions.\n\nImplement equivalent helper functions in `lib-reftable-clar.{c,h}` to\nuse clar. These functions conform with the clar testing framework and\nbecome available for all reftable-related test files implemented using\nthe clar testing framework, which requires them. This will be used by\nsubsequent commits.\n\nSigned-off-by: Seyi Kuforiji \nSigned-off-by: Junio C Hamano \n---\n Makefile | 1 +\n t/meson.build | 3 +-\n t/unit-tests/lib-reftable-clar.c | 101 +++++++++++++++++++++++++++++++\n t/unit-tests/lib-reftable-clar.h | 20 ++++++\n 4 files changed, 124 insertions(+), 1 deletion(-)\n create mode 100644 t/unit-tests/lib-reftable-clar.c\n create mode 100644 t/unit-tests/lib-reftable-clar.h\n\ndiff --git a/Makefile b/Makefile\nindex 70d1543b6b..e4fa038508 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1375,6 +1375,7 @@ CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n+CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n UNIT_TEST_PROGRAMS += t-reftable-basics\n UNIT_TEST_PROGRAMS += t-reftable-block\ndiff --git a/t/meson.build b/t/meson.build\nindex d052fc3e23..f77f21536e 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -19,7 +19,8 @@ clar_test_suites = [\n clar_sources = [\n 'unit-tests/clar/clar.c',\n 'unit-tests/unit-test.c',\n- 'unit-tests/lib-oid.c'\n+ 'unit-tests/lib-oid.c',\n+ 'unit-tests/lib-reftable-clar.c'\n ]\n \n clar_decls_h = custom_target(\ndiff --git a/t/unit-tests/lib-reftable-clar.c b/t/unit-tests/lib-reftable-clar.c\nnew file mode 100644\nindex 0000000000..64e40a106e\n--- /dev/null\n+++ b/t/unit-tests/lib-reftable-clar.c\n@@ -0,0 +1,101 @@\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n+#include \"hex.h\"\n+#include \"parse-options.h\"\n+#include \"reftable/constants.h\"\n+#include \"reftable/writer.h\"\n+#include \"strbuf.h\"\n+#include \"string-list.h\"\n+#include \"strvec.h\"\n+\n+void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id)\n+{\n+\tmemset(p, (uint8_t)i, hash_size(id));\n+}\n+\n+static ssize_t strbuf_writer_write(void *b, const void *data, size_t sz)\n+{\n+\tstrbuf_add(b, data, sz);\n+\treturn sz;\n+}\n+\n+static int strbuf_writer_flush(void *arg UNUSED)\n+{\n+\treturn 0;\n+}\n+\n+struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,\n+\t\t\t\t\t\t struct reftable_write_options *opts)\n+{\n+\tstruct reftable_writer *writer;\n+\tint ret = reftable_writer_new(&writer, &strbuf_writer_write, &strbuf_writer_flush,\n+\t\t\t\t buf, opts);\n+\tcl_assert(!ret);\n+\treturn writer;\n+}\n+\n+void cl_reftable_write_to_buf(struct reftable_buf *buf,\n+\t\t\t struct reftable_ref_record *refs,\n+\t\t\t size_t nrefs,\n+\t\t\t struct reftable_log_record *logs,\n+\t\t\t size_t nlogs,\n+\t\t\t struct reftable_write_options *_opts)\n+{\n+\tstruct reftable_write_options opts = { 0 };\n+\tconst struct reftable_stats *stats;\n+\tstruct reftable_writer *writer;\n+\tuint64_t min = 0xffffffff;\n+\tuint64_t max = 0;\n+\tint ret;\n+\n+\tif (_opts)\n+\t\topts = *_opts;\n+\n+\tfor (size_t i = 0; i < nrefs; i++) {\n+\t\tuint64_t ui = refs[i].update_index;\n+\t\tif (ui > max)\n+\t\t\tmax = ui;\n+\t\tif (ui < min)\n+\t\t\tmin = ui;\n+\t}\n+\tfor (size_t i = 0; i < nlogs; i++) {\n+\t\tuint64_t ui = logs[i].update_index;\n+\t\tif (ui > max)\n+\t\t\tmax = ui;\n+\t\tif (ui < min)\n+\t\t\tmin = ui;\n+\t}\n+\n+\twriter = cl_reftable_strbuf_writer(buf, &opts);\n+\tret = reftable_writer_set_limits(writer, min, max);\n+\tcl_assert_equal_i(ret, 0);\n+\n+\tif (nrefs) {\n+\t\tret = reftable_writer_add_refs(writer, refs, nrefs);\n+\t\tcl_assert_equal_i(ret, 0);\n+\t}\n+\n+\tif (nlogs) {\n+\t\tret = reftable_writer_add_logs(writer, logs, nlogs);\n+\t\tcl_assert_equal_i(ret, 0);\n+\t}\n+\n+\tret = reftable_writer_close(writer);\n+\tcl_assert_equal_i(ret, 0);\n+\n+\tstats = reftable_writer_stats(writer);\n+\tfor (size_t i = 0; i < (size_t)stats->ref_stats.blocks; i++) {\n+\t\tsize_t off = i * (opts.block_size ? opts.block_size\n+\t\t\t\t\t\t : DEFAULT_BLOCK_SIZE);\n+\t\tif (!off)\n+\t\t\toff = header_size(opts.hash_id == REFTABLE_HASH_SHA256 ? 2 : 1);\n+\t\tcl_assert(buf->buf[off] == 'r');\n+\t}\n+\n+\tif (nrefs)\n+\t\tcl_assert(stats->ref_stats.blocks > 0);\n+\tif (nlogs)\n+\t\tcl_assert(stats->log_stats.blocks > 0);\n+\n+\treftable_writer_free(writer);\n+}\ndiff --git a/t/unit-tests/lib-reftable-clar.h b/t/unit-tests/lib-reftable-clar.h\nnew file mode 100644\nindex 0000000000..b562648973\n--- /dev/null\n+++ b/t/unit-tests/lib-reftable-clar.h\n@@ -0,0 +1,20 @@\n+#include \"git-compat-util.h\"\n+#include \"clar/clar.h\"\n+#include \"clar-decls.h\"\n+#include \"git-compat-util.h\"\n+#include \"reftable/reftable-writer.h\"\n+#include \"strbuf.h\"\n+\n+struct reftable_buf;\n+\n+void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id);\n+\n+struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,\n+\t\t\t\t\t\t struct reftable_write_options *opts);\n+\n+void cl_reftable_write_to_buf(struct reftable_buf *buf,\n+\t\t\t struct reftable_ref_record *refs,\n+\t\t\t size_t nrecords,\n+\t\t\t struct reftable_log_record *logs,\n+\t\t\t size_t nlogs,\n+\t\t\t struct reftable_write_options *opts);\n-- \n2.43.0\n\n"},{"id":"522670","messageId":"20250724142837.67149-3-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250724142837.67149-1-kuforiji98@gmail.com","subject":"[PATCH v5 02/10] t/unit-tests: convert reftable basics test to use clar test framework","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T14:28:29Z","receivedAt":"2025-07-24T14:30:01Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kuforiji \n\nAdapt reftable basics test file to clar by using clar assertions\nwhere necessary.Break up test edge case to improve modularity and\nclarity.\n\nSigned-off-by: Seyi Kuforiji \nSigned-off-by: Junio C Hamano \n---\n Makefile | 2 +-\n t/meson.build | 2 +-\n t/unit-tests/t-reftable-basics.c | 219 -----------------------------\n t/unit-tests/u-reftable-basics.c | 227 +++++++++++++++++++++++++++++++\n 4 files changed, 229 insertions(+), 221 deletions(-)\n delete mode 100644 t/unit-tests/t-reftable-basics.c\n create mode 100644 t/unit-tests/u-reftable-basics.c\n\ndiff --git a/Makefile b/Makefile\nindex e4fa038508..a01103e3a6 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1364,6 +1364,7 @@ CLAR_TEST_SUITES += u-oid-array\n CLAR_TEST_SUITES += u-oidmap\n CLAR_TEST_SUITES += u-oidtree\n CLAR_TEST_SUITES += u-prio-queue\n+CLAR_TEST_SUITES += u-reftable-basics\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n CLAR_TEST_SUITES += u-strcmp-offset\n@@ -1377,7 +1378,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-basics\n UNIT_TEST_PROGRAMS += t-reftable-block\n UNIT_TEST_PROGRAMS += t-reftable-merged\n UNIT_TEST_PROGRAMS += t-reftable-pq\ndiff --git a/t/meson.build b/t/meson.build\nindex f77f21536e..e00e8d41d6 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -8,6 +8,7 @@ clar_test_suites = [\n 'unit-tests/u-oidmap.c',\n 'unit-tests/u-oidtree.c',\n 'unit-tests/u-prio-queue.c',\n+ 'unit-tests/u-reftable-basics.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n 'unit-tests/u-strcmp-offset.c',\n@@ -55,7 +56,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-basics.c',\n 'unit-tests/t-reftable-block.c',\n 'unit-tests/t-reftable-merged.c',\n 'unit-tests/t-reftable-pq.c',\ndiff --git a/t/unit-tests/t-reftable-basics.c b/t/unit-tests/t-reftable-basics.c\ndeleted file mode 100644\nindex c9e751e49e..0000000000\n--- a/t/unit-tests/t-reftable-basics.c\n+++ /dev/null\n@@ -1,219 +0,0 @@\n-/*\n-Copyright 2020 Google LLC\n-\n-Use of this source code is governed by a BSD-style\n-license that can be found in the LICENSE file or at\n-https://developers.google.com/open-source/licenses/bsd\n-*/\n-\n-#include \"test-lib.h\"\n-#include \"reftable/basics.h\"\n-\n-struct integer_needle_lesseq_args {\n-\tint needle;\n-\tint *haystack;\n-};\n-\n-static int integer_needle_lesseq(size_t i, void *_args)\n-{\n-\tstruct integer_needle_lesseq_args *args = _args;\n-\treturn args->needle <= args->haystack[i];\n-}\n-\n-static void *realloc_stub(void *p UNUSED, size_t size UNUSED)\n-{\n-\treturn NULL;\n-}\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tif_test (\"binary search with binsearch works\") {\n-\t\tint haystack[] = { 2, 4, 6, 8, 10 };\n-\t\tstruct {\n-\t\t\tint needle;\n-\t\t\tsize_t expected_idx;\n-\t\t} testcases[] = {\n-\t\t\t{-9000, 0},\n-\t\t\t{-1, 0},\n-\t\t\t{0, 0},\n-\t\t\t{2, 0},\n-\t\t\t{3, 1},\n-\t\t\t{4, 1},\n-\t\t\t{7, 3},\n-\t\t\t{9, 4},\n-\t\t\t{10, 4},\n-\t\t\t{11, 5},\n-\t\t\t{9000, 5},\n-\t\t};\n-\n-\t\tfor (size_t i = 0; i < ARRAY_SIZE(testcases); i++) {\n-\t\t\tstruct integer_needle_lesseq_args args = {\n-\t\t\t\t.haystack = haystack,\n-\t\t\t\t.needle = testcases[i].needle,\n-\t\t\t};\n-\t\t\tsize_t idx;\n-\n-\t\t\tidx = binsearch(ARRAY_SIZE(haystack),\n-\t\t\t\t\t&integer_needle_lesseq, &args);\n-\t\t\tcheck_int(idx, ==, testcases[i].expected_idx);\n-\t\t}\n-\t}\n-\n-\tif_test (\"names_length returns size of a NULL-terminated string array\") {\n-\t\tconst char *a[] = { \"a\", \"b\", NULL };\n-\t\tcheck_int(names_length(a), ==, 2);\n-\t}\n-\n-\tif_test (\"names_equal compares NULL-terminated string arrays\") {\n-\t\tconst char *a[] = { \"a\", \"b\", \"c\", NULL };\n-\t\tconst char *b[] = { \"a\", \"b\", \"d\", NULL };\n-\t\tconst char *c[] = { \"a\", \"b\", NULL };\n-\n-\t\tcheck(names_equal(a, a));\n-\t\tcheck(!names_equal(a, b));\n-\t\tcheck(!names_equal(a, c));\n-\t}\n-\n-\tif_test (\"parse_names works for basic input\") {\n-\t\tchar in1[] = \"line\\n\";\n-\t\tchar in2[] = \"a\\nb\\nc\";\n-\t\tchar **out = parse_names(in1, strlen(in1));\n-\t\tcheck(out != NULL);\n-\t\tcheck_str(out[0], \"line\");\n-\t\tcheck(!out[1]);\n-\t\tfree_names(out);\n-\n-\t\tout = parse_names(in2, strlen(in2));\n-\t\tcheck(out != NULL);\n-\t\tcheck_str(out[0], \"a\");\n-\t\tcheck_str(out[1], \"b\");\n-\t\tcheck_str(out[2], \"c\");\n-\t\tcheck(!out[3]);\n-\t\tfree_names(out);\n-\t}\n-\n-\tif_test (\"parse_names drops empty string\") {\n-\t\tchar in[] = \"a\\n\\nb\\n\";\n-\t\tchar **out = parse_names(in, strlen(in));\n-\t\tcheck(out != NULL);\n-\t\tcheck_str(out[0], \"a\");\n-\t\t/* simply '\\n' should be dropped as empty string */\n-\t\tcheck_str(out[1], \"b\");\n-\t\tcheck(!out[2]);\n-\t\tfree_names(out);\n-\t}\n-\n-\tif_test (\"common_prefix_size works\") {\n-\t\tstruct reftable_buf a = REFTABLE_BUF_INIT;\n-\t\tstruct reftable_buf b = REFTABLE_BUF_INIT;\n-\t\tstruct {\n-\t\t\tconst char *a, *b;\n-\t\t\tint want;\n-\t\t} cases[] = {\n-\t\t\t{\"abcdef\", \"abc\", 3},\n-\t\t\t{ \"abc\", \"ab\", 2 },\n-\t\t\t{ \"\", \"abc\", 0 },\n-\t\t\t{ \"abc\", \"abd\", 2 },\n-\t\t\t{ \"abc\", \"pqr\", 0 },\n-\t\t};\n-\n-\t\tfor (size_t i = 0; i < ARRAY_SIZE(cases); i++) {\n-\t\t\tcheck(!reftable_buf_addstr(&a, cases[i].a));\n-\t\t\tcheck(!reftable_buf_addstr(&b, cases[i].b));\n-\t\t\tcheck_uint(common_prefix_size(&a, &b), ==, cases[i].want);\n-\t\t\treftable_buf_reset(&a);\n-\t\t\treftable_buf_reset(&b);\n-\t\t}\n-\t\treftable_buf_release(&a);\n-\t\treftable_buf_release(&b);\n-\t}\n-\n-\tif_test (\"reftable_put_be64 and reftable_get_be64 work\") {\n-\t\tuint64_t in = 0x1122334455667788;\n-\t\tuint8_t dest[8];\n-\t\tuint64_t out;\n-\t\treftable_put_be64(dest, in);\n-\t\tout = reftable_get_be64(dest);\n-\t\tcheck_int(in, ==, out);\n-\t}\n-\n-\tif_test (\"reftable_put_be32 and reftable_get_be32 work\") {\n-\t\tuint32_t in = 0x11223344;\n-\t\tuint8_t dest[4];\n-\t\tuint32_t out;\n-\t\treftable_put_be32(dest, in);\n-\t\tout = reftable_get_be32(dest);\n-\t\tcheck_int(in, ==, out);\n-\t}\n-\n-\tif_test (\"reftable_put_be24 and reftable_get_be24 work\") {\n-\t\tuint32_t in = 0x112233;\n-\t\tuint8_t dest[3];\n-\t\tuint32_t out;\n-\t\treftable_put_be24(dest, in);\n-\t\tout = reftable_get_be24(dest);\n-\t\tcheck_int(in, ==, out);\n-\t}\n-\n-\tif_test (\"put_be16 and get_be16 work\") {\n-\t\tuint32_t in = 0xfef1;\n-\t\tuint8_t dest[3];\n-\t\tuint32_t out;\n-\t\treftable_put_be16(dest, in);\n-\t\tout = reftable_get_be16(dest);\n-\t\tcheck_int(in, ==, out);\n-\t}\n-\n-\tif_test (\"REFTABLE_ALLOC_GROW works\") {\n-\t\tint *arr = NULL, *old_arr;\n-\t\tsize_t alloc = 0, old_alloc;\n-\n-\t\tcheck(!REFTABLE_ALLOC_GROW(arr, 1, alloc));\n-\t\tcheck(arr != NULL);\n-\t\tcheck_uint(alloc, >=, 1);\n-\t\tarr[0] = 42;\n-\n-\t\told_alloc = alloc;\n-\t\told_arr = arr;\n-\t\treftable_set_alloc(NULL, realloc_stub, NULL);\n-\t\tcheck(REFTABLE_ALLOC_GROW(arr, old_alloc + 1, alloc));\n-\t\tcheck(arr == old_arr);\n-\t\tcheck_uint(alloc, ==, old_alloc);\n-\n-\t\told_alloc = alloc;\n-\t\treftable_set_alloc(NULL, NULL, NULL);\n-\t\tcheck(!REFTABLE_ALLOC_GROW(arr, old_alloc + 1, alloc));\n-\t\tcheck(arr != NULL);\n-\t\tcheck_uint(alloc, >, old_alloc);\n-\t\tarr[alloc - 1] = 42;\n-\n-\t\treftable_free(arr);\n-\t}\n-\n-\tif_test (\"REFTABLE_ALLOC_GROW_OR_NULL works\") {\n-\t\tint *arr = NULL;\n-\t\tsize_t alloc = 0, old_alloc;\n-\n-\t\tREFTABLE_ALLOC_GROW_OR_NULL(arr, 1, alloc);\n-\t\tcheck(arr != NULL);\n-\t\tcheck_uint(alloc, >=, 1);\n-\t\tarr[0] = 42;\n-\n-\t\told_alloc = alloc;\n-\t\tREFTABLE_ALLOC_GROW_OR_NULL(arr, old_alloc + 1, alloc);\n-\t\tcheck(arr != NULL);\n-\t\tcheck_uint(alloc, >, old_alloc);\n-\t\tarr[alloc - 1] = 42;\n-\n-\t\told_alloc = alloc;\n-\t\treftable_set_alloc(NULL, realloc_stub, NULL);\n-\t\tREFTABLE_ALLOC_GROW_OR_NULL(arr, old_alloc + 1, alloc);\n-\t\tcheck(arr == NULL);\n-\t\tcheck_uint(alloc, ==, 0);\n-\t\treftable_set_alloc(NULL, NULL, NULL);\n-\n-\t\treftable_free(arr);\n-\t}\n-\n-\treturn test_done();\n-}\ndiff --git a/t/unit-tests/u-reftable-basics.c b/t/unit-tests/u-reftable-basics.c\nnew file mode 100644\nindex 0000000000..f105c22d15\n--- /dev/null\n+++ b/t/unit-tests/u-reftable-basics.c\n@@ -0,0 +1,227 @@\n+/*\n+Copyright 2020 Google LLC\n+\n+Use of this source code is governed by a BSD-style\n+license that can be found in the LICENSE file or at\n+https://developers.google.com/open-source/licenses/bsd\n+*/\n+\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n+#include \"reftable/basics.h\"\n+\n+struct integer_needle_lesseq_args {\n+\tint needle;\n+\tint *haystack;\n+};\n+\n+static int integer_needle_lesseq(size_t i, void *_args)\n+{\n+\tstruct integer_needle_lesseq_args *args = _args;\n+\treturn args->needle <= args->haystack[i];\n+}\n+\n+static void *realloc_stub(void *p UNUSED, size_t size UNUSED)\n+{\n+\treturn NULL;\n+}\n+\n+void test_reftable_basics__binsearch(void)\n+{\n+\tint haystack[] = { 2, 4, 6, 8, 10 };\n+\tstruct {\n+\t\tint needle;\n+\t\tsize_t expected_idx;\n+\t} testcases[] = {\n+\t\t{-9000, 0},\n+\t\t{-1, 0},\n+\t\t{0, 0},\n+\t\t{2, 0},\n+\t\t{3, 1},\n+\t\t{4, 1},\n+\t\t{7, 3},\n+\t\t{9, 4},\n+\t\t{10, 4},\n+\t\t{11, 5},\n+\t\t{9000, 5},\n+\t};\n+\n+\tfor (size_t i = 0; i < ARRAY_SIZE(testcases); i++) {\n+\t\tstruct integer_needle_lesseq_args args = {\n+\t\t\t.haystack = haystack,\n+\t\t\t.needle = testcases[i].needle,\n+\t\t};\n+\t\tsize_t idx;\n+\n+\t\tidx = binsearch(ARRAY_SIZE(haystack),\n+\t\t\t\t&integer_needle_lesseq, &args);\n+\t\tcl_assert_equal_i(idx, testcases[i].expected_idx);\n+\t}\n+}\n+\n+void test_reftable_basics__names_length(void)\n+{\n+\tconst char *a[] = { \"a\", \"b\", NULL };\n+\tcl_assert_equal_i(names_length(a), 2);\n+}\n+\n+void test_reftable_basics__names_equal(void)\n+{\n+\tconst char *a[] = { \"a\", \"b\", \"c\", NULL };\n+\tconst char *b[] = { \"a\", \"b\", \"d\", NULL };\n+\tconst char *c[] = { \"a\", \"b\", NULL };\n+\n+\tcl_assert(names_equal(a, a));\n+\tcl_assert(!names_equal(a, b));\n+\tcl_assert(!names_equal(a, c));\n+}\n+\n+void test_reftable_basics__parse_names(void)\n+{\n+\tchar in1[] = \"line\\n\";\n+\tchar in2[] = \"a\\nb\\nc\";\n+\tchar **out = parse_names(in1, strlen(in1));\n+\tcl_assert(out != NULL);\n+\tcl_assert_equal_s(out[0], \"line\");\n+\tcl_assert(!out[1]);\n+\tfree_names(out);\n+\n+\tout = parse_names(in2, strlen(in2));\n+\tcl_assert(out != NULL);\n+\tcl_assert_equal_s(out[0], \"a\");\n+\tcl_assert_equal_s(out[1], \"b\");\n+\tcl_assert_equal_s(out[2], \"c\");\n+\tcl_assert(!out[3]);\n+\tfree_names(out);\n+}\n+\n+void test_reftable_basics__parse_names_drop_empty_string(void)\n+{\n+\tchar in[] = \"a\\n\\nb\\n\";\n+\tchar **out = parse_names(in, strlen(in));\n+\tcl_assert(out != NULL);\n+\tcl_assert_equal_s(out[0], \"a\");\n+\t/* simply '\\n' should be dropped as empty string */\n+\tcl_assert_equal_s(out[1], \"b\");\n+\tcl_assert(out[2] == NULL);\n+\tfree_names(out);\n+}\n+\n+void test_reftable_basics__common_prefix_size(void)\n+{\n+\tstruct reftable_buf a = REFTABLE_BUF_INIT;\n+\tstruct reftable_buf b = REFTABLE_BUF_INIT;\n+\tstruct {\n+\t\tconst char *a, *b;\n+\t\tint want;\n+\t} cases[] = {\n+\t\t{\"abcdef\", \"abc\", 3},\n+\t\t{ \"abc\", \"ab\", 2 },\n+\t\t{ \"\", \"abc\", 0 },\n+\t\t{ \"abc\", \"abd\", 2 },\n+\t\t{ \"abc\", \"pqr\", 0 },\n+\t};\n+\n+\tfor (size_t i = 0; i < ARRAY_SIZE(cases); i++) {\n+\t\tcl_assert_equal_i(reftable_buf_addstr(&a, cases[i].a), 0);\n+\t\tcl_assert_equal_i(reftable_buf_addstr(&b, cases[i].b), 0);\n+\t\tcl_assert_equal_i(common_prefix_size(&a, &b), cases[i].want);\n+\t\treftable_buf_reset(&a);\n+\t\treftable_buf_reset(&b);\n+\t}\n+\treftable_buf_release(&a);\n+\treftable_buf_release(&b);\n+}\n+\n+void test_reftable_basics__put_get_be64(void)\n+{\n+\tuint64_t in = 0x1122334455667788;\n+\tuint8_t dest[8];\n+\tuint64_t out;\n+\treftable_put_be64(dest, in);\n+\tout = reftable_get_be64(dest);\n+\tcl_assert(in == out);\n+}\n+\n+void test_reftable_basics__put_get_be32(void)\n+{\n+\tuint32_t in = 0x11223344;\n+\tuint8_t dest[4];\n+\tuint32_t out;\n+\treftable_put_be32(dest, in);\n+\tout = reftable_get_be32(dest);\n+\tcl_assert_equal_i(in, out);\n+}\n+\n+void test_reftable_basics__put_get_be24(void)\n+{\n+\tuint32_t in = 0x112233;\n+\tuint8_t dest[3];\n+\tuint32_t out;\n+\treftable_put_be24(dest, in);\n+\tout = reftable_get_be24(dest);\n+\tcl_assert_equal_i(in, out);\n+}\n+\n+void test_reftable_basics__put_get_be16(void)\n+{\n+\tuint32_t in = 0xfef1;\n+\tuint8_t dest[3];\n+\tuint32_t out;\n+\treftable_put_be16(dest, in);\n+\tout = reftable_get_be16(dest);\n+\tcl_assert_equal_i(in, out);\n+}\n+\n+void test_reftable_basics__alloc_grow(void)\n+{\n+\tint *arr = NULL, *old_arr;\n+\tsize_t alloc = 0, old_alloc;\n+\n+\tcl_assert_equal_i(REFTABLE_ALLOC_GROW(arr, 1, alloc), 0);\n+\tcl_assert(arr != NULL);\n+\tcl_assert(alloc >= 1);\n+\tarr[0] = 42;\n+\n+\told_alloc = alloc;\n+\told_arr = arr;\n+\treftable_set_alloc(NULL, realloc_stub, NULL);\n+\tcl_assert(REFTABLE_ALLOC_GROW(arr, old_alloc + 1, alloc));\n+\tcl_assert(arr == old_arr);\n+\tcl_assert_equal_i(alloc, old_alloc);\n+\n+\told_alloc = alloc;\n+\treftable_set_alloc(NULL, NULL, NULL);\n+\tcl_assert_equal_i(REFTABLE_ALLOC_GROW(arr, old_alloc + 1, alloc), 0);\n+\tcl_assert(arr != NULL);\n+\tcl_assert(alloc > old_alloc);\n+\tarr[alloc - 1] = 42;\n+\n+\treftable_free(arr);\n+}\n+\n+void test_reftable_basics__alloc_grow_or_null(void)\n+{\n+\tint *arr = NULL;\n+\tsize_t alloc = 0, old_alloc;\n+\n+\tREFTABLE_ALLOC_GROW_OR_NULL(arr, 1, alloc);\n+\tcl_assert(arr != NULL);\n+\tcl_assert(alloc >= 1);\n+\tarr[0] = 42;\n+\n+\told_alloc = alloc;\n+\tREFTABLE_ALLOC_GROW_OR_NULL(arr, old_alloc + 1, alloc);\n+\tcl_assert(arr != NULL);\n+\tcl_assert(alloc > old_alloc);\n+\tarr[alloc - 1] = 42;\n+\n+\told_alloc = alloc;\n+\treftable_set_alloc(NULL, realloc_stub, NULL);\n+\tREFTABLE_ALLOC_GROW_OR_NULL(arr, old_alloc + 1, alloc);\n+\tcl_assert(arr == NULL);\n+\tcl_assert_equal_i(alloc, 0);\n+\treftable_set_alloc(NULL, NULL, NULL);\n+\n+\treftable_free(arr);\n+}\n-- \n2.43.0\n\n"},{"id":"522671","messageId":"20250724142837.67149-4-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250724142837.67149-1-kuforiji98@gmail.com","subject":"[PATCH v5 03/10] t/unit-tests: convert reftable block test to use clar","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T14:28:30Z","receivedAt":"2025-07-24T14:30:18Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kuforiji \n\nAdapt reftable block test file to use clar testing framework by using\nclar assertions where necessary.\n\nSigned-off-by: Seyi Kuforiji \nSigned-off-by: Junio C Hamano \n---\n Makefile | 2 +-\n t/meson.build | 2 +-\n ...{t-reftable-block.c => u-reftable-block.c} | 164 +++++++++---------\n 3 files changed, 80 insertions(+), 88 deletions(-)\n rename t/unit-tests/{t-reftable-block.c => u-reftable-block.c} (74%)\n\ndiff --git a/Makefile b/Makefile\nindex a01103e3a6..d01dfd179b 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1365,6 +1365,7 @@ CLAR_TEST_SUITES += u-oidmap\n CLAR_TEST_SUITES += u-oidtree\n CLAR_TEST_SUITES += u-prio-queue\n CLAR_TEST_SUITES += u-reftable-basics\n+CLAR_TEST_SUITES += u-reftable-block\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n CLAR_TEST_SUITES += u-strcmp-offset\n@@ -1378,7 +1379,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-block\n UNIT_TEST_PROGRAMS += t-reftable-merged\n UNIT_TEST_PROGRAMS += t-reftable-pq\n UNIT_TEST_PROGRAMS += t-reftable-readwrite\ndiff --git a/t/meson.build b/t/meson.build\nindex e00e8d41d6..b1d9dea9e7 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -9,6 +9,7 @@ clar_test_suites = [\n 'unit-tests/u-oidtree.c',\n 'unit-tests/u-prio-queue.c',\n 'unit-tests/u-reftable-basics.c',\n+ 'unit-tests/u-reftable-block.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n 'unit-tests/u-strcmp-offset.c',\n@@ -56,7 +57,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-block.c',\n 'unit-tests/t-reftable-merged.c',\n 'unit-tests/t-reftable-pq.c',\n 'unit-tests/t-reftable-readwrite.c',\ndiff --git a/t/unit-tests/t-reftable-block.c b/t/unit-tests/u-reftable-block.c\nsimilarity index 74%\nrename from t/unit-tests/t-reftable-block.c\nrename to t/unit-tests/u-reftable-block.c\nindex 52f1dae1c9..97a1348563 100644\n--- a/t/unit-tests/t-reftable-block.c\n+++ b/t/unit-tests/u-reftable-block.c\n@@ -6,14 +6,15 @@ license that can be found in the LICENSE file or at\n https://developers.google.com/open-source/licenses/bsd\n */\n \n-#include \"test-lib.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/block.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/reftable-error.h\"\n #include \"strbuf.h\"\n \n-static void t_ref_block_read_write(void)\n+void test_reftable_block__read_write(void)\n {\n \tconst int header_off = 21; /* random */\n \tstruct reftable_record recs[30];\n@@ -34,17 +35,18 @@ static void t_ref_block_read_write(void)\n \tstruct reftable_buf block_data = REFTABLE_BUF_INIT;\n \n \tREFTABLE_CALLOC_ARRAY(block_data.buf, block_size);\n-\tcheck(block_data.buf != NULL);\n+\tcl_assert(block_data.buf != NULL);\n \tblock_data.len = block_size;\n \n-\tret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_REF, (uint8_t *) block_data.buf, block_size,\n+\tret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_REF,\n+\t\t\t\t(uint8_t *) block_data.buf, block_size,\n \t\t\t\theader_off, hash_size(REFTABLE_HASH_SHA1));\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \trec.u.ref.refname = (char *) \"\";\n \trec.u.ref.value_type = REFTABLE_REF_DELETION;\n \tret = block_writer_add(&bw, &rec);\n-\tcheck_int(ret, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(ret, REFTABLE_API_ERROR);\n \n \tfor (i = 0; i < N; i++) {\n \t\trec.u.ref.refname = xstrfmt(\"branch%02\"PRIuMAX, (uintmax_t)i);\n@@ -55,11 +57,11 @@ static void t_ref_block_read_write(void)\n \t\tret = block_writer_add(&bw, &rec);\n \t\trec.u.ref.refname = NULL;\n \t\trec.u.ref.value_type = REFTABLE_REF_DELETION;\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \t}\n \n \tret = block_writer_finish(&bw);\n-\tcheck_int(ret, >, 0);\n+\tcl_assert(ret > 0);\n \n \tblock_writer_release(&bw);\n \n@@ -71,32 +73,32 @@ static void t_ref_block_read_write(void)\n \n \tfor (i = 0; ; i++) {\n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, >=, 0);\n+\t\tcl_assert(ret >= 0);\n \t\tif (ret > 0) {\n-\t\t\tcheck_int(i, ==, N);\n+\t\t\tcl_assert_equal_i(i, N);\n \t\t\tbreak;\n \t\t}\n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n \t\treftable_record_key(&recs[i], &want);\n \n \t\tret = block_iter_seek_key(&it, &want);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \n \t\twant.len--;\n \t\tret = block_iter_seek_key(&it, &want);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, ==, 0);\n-\t\tcheck(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(ret, 0);\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \treftable_block_release(&block);\n@@ -108,7 +110,7 @@ static void t_ref_block_read_write(void)\n \t\treftable_record_release(&recs[i]);\n }\n \n-static void t_log_block_read_write(void)\n+void test_reftable_block__log_read_write(void)\n {\n \tconst int header_off = 21;\n \tstruct reftable_record recs[30];\n@@ -129,12 +131,12 @@ static void t_log_block_read_write(void)\n \tstruct reftable_buf block_data = REFTABLE_BUF_INIT;\n \n \tREFTABLE_CALLOC_ARRAY(block_data.buf, block_size);\n-\tcheck(block_data.buf != NULL);\n+\tcl_assert(block_data.buf != NULL);\n \tblock_data.len = block_size;\n \n \tret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_LOG, (uint8_t *) block_data.buf, block_size,\n \t\t\t\theader_off, hash_size(REFTABLE_HASH_SHA1));\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \tfor (i = 0; i < N; i++) {\n \t\trec.u.log.refname = xstrfmt(\"branch%02\"PRIuMAX , (uintmax_t)i);\n@@ -145,11 +147,11 @@ static void t_log_block_read_write(void)\n \t\tret = block_writer_add(&bw, &rec);\n \t\trec.u.log.refname = NULL;\n \t\trec.u.log.value_type = REFTABLE_LOG_DELETION;\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \t}\n \n \tret = block_writer_finish(&bw);\n-\tcheck_int(ret, >, 0);\n+\tcl_assert(ret > 0);\n \n \tblock_writer_release(&bw);\n \n@@ -161,33 +163,33 @@ static void t_log_block_read_write(void)\n \n \tfor (i = 0; ; i++) {\n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, >=, 0);\n+\t\tcl_assert(ret >= 0);\n \t\tif (ret > 0) {\n-\t\t\tcheck_int(i, ==, N);\n+\t\t\tcl_assert_equal_i(i, N);\n \t\t\tbreak;\n \t\t}\n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n \t\treftable_buf_reset(&want);\n-\t\tcheck(!reftable_buf_addstr(&want, recs[i].u.log.refname));\n+\t\tcl_assert(reftable_buf_addstr(&want, recs[i].u.log.refname) == 0);\n \n \t\tret = block_iter_seek_key(&it, &want);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \n \t\twant.len--;\n \t\tret = block_iter_seek_key(&it, &want);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, ==, 0);\n-\t\tcheck(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(ret, 0);\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \treftable_block_release(&block);\n@@ -199,7 +201,7 @@ static void t_log_block_read_write(void)\n \t\treftable_record_release(&recs[i]);\n }\n \n-static void t_obj_block_read_write(void)\n+void test_reftable_block__obj_read_write(void)\n {\n \tconst int header_off = 21;\n \tstruct reftable_record recs[30];\n@@ -220,12 +222,12 @@ static void t_obj_block_read_write(void)\n \tstruct reftable_buf block_data = REFTABLE_BUF_INIT;\n \n \tREFTABLE_CALLOC_ARRAY(block_data.buf, block_size);\n-\tcheck(block_data.buf != NULL);\n+\tcl_assert(block_data.buf != NULL);\n \tblock_data.len = block_size;\n \n \tret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_OBJ, (uint8_t *) block_data.buf, block_size,\n \t\t\t\theader_off, hash_size(REFTABLE_HASH_SHA1));\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \tfor (i = 0; i < N; i++) {\n \t\tuint8_t bytes[] = { i, i + 1, i + 2, i + 3, i + 5 }, *allocated;\n@@ -238,11 +240,11 @@ static void t_obj_block_read_write(void)\n \t\tret = block_writer_add(&bw, &rec);\n \t\trec.u.obj.hash_prefix = NULL;\n \t\trec.u.obj.hash_prefix_len = 0;\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \t}\n \n \tret = block_writer_finish(&bw);\n-\tcheck_int(ret, >, 0);\n+\tcl_assert(ret > 0);\n \n \tblock_writer_release(&bw);\n \n@@ -254,24 +256,24 @@ static void t_obj_block_read_write(void)\n \n \tfor (i = 0; ; i++) {\n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, >=, 0);\n+\t\tcl_assert(ret >= 0);\n \t\tif (ret > 0) {\n-\t\t\tcheck_int(i, ==, N);\n+\t\t\tcl_assert_equal_i(i, N);\n \t\t\tbreak;\n \t\t}\n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n \t\treftable_record_key(&recs[i], &want);\n \n \t\tret = block_iter_seek_key(&it, &want);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \treftable_block_release(&block);\n@@ -283,7 +285,7 @@ static void t_obj_block_read_write(void)\n \t\treftable_record_release(&recs[i]);\n }\n \n-static void t_index_block_read_write(void)\n+void test_reftable_block__ref_read_write(void)\n {\n \tconst int header_off = 21;\n \tstruct reftable_record recs[30];\n@@ -305,12 +307,12 @@ static void t_index_block_read_write(void)\n \tstruct reftable_buf block_data = REFTABLE_BUF_INIT;\n \n \tREFTABLE_CALLOC_ARRAY(block_data.buf, block_size);\n-\tcheck(block_data.buf != NULL);\n+\tcl_assert(block_data.buf != NULL);\n \tblock_data.len = block_size;\n \n \tret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_INDEX, (uint8_t *) block_data.buf, block_size,\n \t\t\t\theader_off, hash_size(REFTABLE_HASH_SHA1));\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \tfor (i = 0; i < N; i++) {\n \t\tchar buf[128];\n@@ -319,15 +321,15 @@ static void t_index_block_read_write(void)\n \n \t\treftable_buf_init(&recs[i].u.idx.last_key);\n \t\trecs[i].type = REFTABLE_BLOCK_TYPE_INDEX;\n-\t\tcheck(!reftable_buf_addstr(&recs[i].u.idx.last_key, buf));\n+\t\tcl_assert(!reftable_buf_addstr(&recs[i].u.idx.last_key, buf));\n \t\trecs[i].u.idx.offset = i;\n \n \t\tret = block_writer_add(&bw, &recs[i]);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \t}\n \n \tret = block_writer_finish(&bw);\n-\tcheck_int(ret, >, 0);\n+\tcl_assert(ret > 0);\n \n \tblock_writer_release(&bw);\n \n@@ -339,32 +341,32 @@ static void t_index_block_read_write(void)\n \n \tfor (i = 0; ; i++) {\n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, >=, 0);\n+\t\tcl_assert(ret >= 0);\n \t\tif (ret > 0) {\n-\t\t\tcheck_int(i, ==, N);\n+\t\t\tcl_assert_equal_i(i, N);\n \t\t\tbreak;\n \t\t}\n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n \t\treftable_record_key(&recs[i], &want);\n \n \t\tret = block_iter_seek_key(&it, &want);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n-\t\tcheck(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \n \t\twant.len--;\n \t\tret = block_iter_seek_key(&it, &want);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \n \t\tret = block_iter_next(&it, &rec);\n-\t\tcheck_int(ret, ==, 0);\n-\t\tcheck(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(ret, 0);\n+\t\tcl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);\n \t}\n \n \treftable_block_release(&block);\n@@ -376,7 +378,7 @@ static void t_index_block_read_write(void)\n \t\treftable_record_release(&recs[i]);\n }\n \n-static void t_block_iterator(void)\n+void test_reftable_block__iterator(void)\n {\n \tstruct reftable_block_source source = { 0 };\n \tstruct block_writer writer = {\n@@ -391,11 +393,12 @@ static void t_block_iterator(void)\n \n \tdata.len = 1024;\n \tREFTABLE_CALLOC_ARRAY(data.buf, data.len);\n-\tcheck(data.buf != NULL);\n+\tcl_assert(data.buf != NULL);\n \n-\terr = block_writer_init(&writer, REFTABLE_BLOCK_TYPE_REF, (uint8_t *) data.buf, data.len,\n+\terr = block_writer_init(&writer, REFTABLE_BLOCK_TYPE_REF,\n+\t\t\t\t(uint8_t *) data.buf, data.len,\n \t\t\t\t0, hash_size(REFTABLE_HASH_SHA1));\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(expected_refs); i++) {\n \t\texpected_refs[i] = (struct reftable_record) {\n@@ -408,42 +411,42 @@ static void t_block_iterator(void)\n \t\tmemset(expected_refs[i].u.ref.value.val1, i, REFTABLE_HASH_SIZE_SHA1);\n \n \t\terr = block_writer_add(&writer, &expected_refs[i]);\n-\t\tcheck_int(err, ==, 0);\n+\t\tcl_assert_equal_i(err, 0);\n \t}\n \n \terr = block_writer_finish(&writer);\n-\tcheck_int(err, >, 0);\n+\tcl_assert(err > 0);\n \n \tblock_source_from_buf(&source, &data);\n \treftable_block_init(&block, &source, 0, 0, data.len,\n \t\t\t REFTABLE_HASH_SIZE_SHA1, REFTABLE_BLOCK_TYPE_REF);\n \n \terr = reftable_block_init_iterator(&block, &it);\n-\tcheck_int(err, ==, 0);\n+\tcl_assert_equal_i(err, 0);\n \n \tfor (size_t i = 0; ; i++) {\n \t\terr = reftable_iterator_next_ref(&it, &ref);\n \t\tif (err > 0) {\n-\t\t\tcheck_int(i, ==, ARRAY_SIZE(expected_refs));\n+\t\t\tcl_assert_equal_i(i, ARRAY_SIZE(expected_refs));\n \t\t\tbreak;\n \t\t}\n-\t\tcheck_int(err, ==, 0);\n+\t\tcl_assert_equal_i(err, 0);\n \n-\t\tcheck(reftable_ref_record_equal(&ref, &expected_refs[i].u.ref,\n-\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_ref_record_equal(&ref,\n+\t\t\t\t\t\t &expected_refs[i].u.ref, REFTABLE_HASH_SIZE_SHA1));\n \t}\n \n \terr = reftable_iterator_seek_ref(&it, \"refs/heads/does-not-exist\");\n-\tcheck_int(err, ==, 0);\n+\tcl_assert_equal_i(err, 0);\n \terr = reftable_iterator_next_ref(&it, &ref);\n-\tcheck_int(err, ==, 1);\n+\tcl_assert_equal_i(err, 1);\n \n \terr = reftable_iterator_seek_ref(&it, \"refs/heads/branch-13\");\n-\tcheck_int(err, ==, 0);\n+\tcl_assert_equal_i(err, 0);\n \terr = reftable_iterator_next_ref(&it, &ref);\n-\tcheck_int(err, ==, 0);\n-\tcheck(reftable_ref_record_equal(&ref, &expected_refs[13].u.ref,\n-\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert_equal_i(err, 0);\n+\tcl_assert(reftable_ref_record_equal(&ref,\n+\t\t\t\t\t &expected_refs[13].u.ref,REFTABLE_HASH_SIZE_SHA1));\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(expected_refs); i++)\n \t\treftable_free(expected_refs[i].u.ref.refname);\n@@ -453,14 +456,3 @@ static void t_block_iterator(void)\n \tblock_writer_release(&writer);\n \treftable_buf_release(&data);\n }\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_index_block_read_write(), \"read-write operations on index blocks work\");\n-\tTEST(t_log_block_read_write(), \"read-write operations on log blocks work\");\n-\tTEST(t_obj_block_read_write(), \"read-write operations on obj blocks work\");\n-\tTEST(t_ref_block_read_write(), \"read-write operations on ref blocks work\");\n-\tTEST(t_block_iterator(), \"block iterator works\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"522672","messageId":"20250724142837.67149-5-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250724142837.67149-1-kuforiji98@gmail.com","subject":"[PATCH v5 04/10] t/unit-tests: convert reftable merged test to use clar","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T14:28:31Z","receivedAt":"2025-07-24T14:30:22Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kuforiji \n\nAdapt reftable merged test file to use clar testing framework by using\nclar assertions where necessary.\n\nSigned-off-by: Seyi Kuforiji \nSigned-off-by: Junio C Hamano \n---\n Makefile | 2 +-\n t/meson.build | 2 +-\n ...-reftable-merged.c => u-reftable-merged.c} | 162 ++++++++----------\n 3 files changed, 72 insertions(+), 94 deletions(-)\n rename t/unit-tests/{t-reftable-merged.c => u-reftable-merged.c} (77%)\n\ndiff --git a/Makefile b/Makefile\nindex d01dfd179b..fb0ef10ff2 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1366,6 +1366,7 @@ CLAR_TEST_SUITES += u-oidtree\n CLAR_TEST_SUITES += u-prio-queue\n CLAR_TEST_SUITES += u-reftable-basics\n CLAR_TEST_SUITES += u-reftable-block\n+CLAR_TEST_SUITES += u-reftable-merged\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n CLAR_TEST_SUITES += u-strcmp-offset\n@@ -1379,7 +1380,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-merged\n UNIT_TEST_PROGRAMS += t-reftable-pq\n UNIT_TEST_PROGRAMS += t-reftable-readwrite\n UNIT_TEST_PROGRAMS += t-reftable-record\ndiff --git a/t/meson.build b/t/meson.build\nindex b1d9dea9e7..d25dfb0c92 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -10,6 +10,7 @@ clar_test_suites = [\n 'unit-tests/u-prio-queue.c',\n 'unit-tests/u-reftable-basics.c',\n 'unit-tests/u-reftable-block.c',\n+ 'unit-tests/u-reftable-merged.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n 'unit-tests/u-strcmp-offset.c',\n@@ -57,7 +58,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-merged.c',\n 'unit-tests/t-reftable-pq.c',\n 'unit-tests/t-reftable-readwrite.c',\n 'unit-tests/t-reftable-record.c',\ndiff --git a/t/unit-tests/t-reftable-merged.c b/t/unit-tests/u-reftable-merged.c\nsimilarity index 77%\nrename from t/unit-tests/t-reftable-merged.c\nrename to t/unit-tests/u-reftable-merged.c\nindex 18c3251a56..62b02baa14 100644\n--- a/t/unit-tests/t-reftable-merged.c\n+++ b/t/unit-tests/u-reftable-merged.c\n@@ -6,8 +6,8 @@ license that can be found in the LICENSE file or at\n https://developers.google.com/open-source/licenses/bsd\n */\n \n-#include \"test-lib.h\"\n-#include \"lib-reftable.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/merged.h\"\n@@ -29,21 +29,21 @@ merged_table_from_records(struct reftable_ref_record **refs,\n \tint err;\n \n \tREFTABLE_CALLOC_ARRAY(*tables, n);\n-\tcheck(*tables != NULL);\n+\tcl_assert(*tables != NULL);\n \tREFTABLE_CALLOC_ARRAY(*source, n);\n-\tcheck(*source != NULL);\n+\tcl_assert(*source != NULL);\n \n \tfor (size_t i = 0; i < n; i++) {\n-\t\tt_reftable_write_to_buf(&buf[i], refs[i], sizes[i], NULL, 0, &opts);\n+\t\tcl_reftable_write_to_buf(&buf[i], refs[i], sizes[i], NULL, 0, &opts);\n \t\tblock_source_from_buf(&(*source)[i], &buf[i]);\n \n \t\terr = reftable_table_new(&(*tables)[i], &(*source)[i],\n \t\t\t\t\t \"name\");\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \t}\n \n \terr = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \treturn mt;\n }\n \n@@ -54,7 +54,7 @@ static void tables_destroy(struct reftable_table **tables, const size_t n)\n \treftable_free(tables);\n }\n \n-static void t_merged_single_record(void)\n+void test_reftable_merged__single_record(void)\n {\n \tstruct reftable_ref_record r1[] = { {\n \t\t.refname = (char *) \"b\",\n@@ -85,13 +85,14 @@ static void t_merged_single_record(void)\n \tint err;\n \n \terr = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"a\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_iterator_next_ref(&it, &ref);\n-\tcheck(!err);\n-\tcheck(reftable_ref_record_equal(&r2[0], &ref, REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert(!err);\n+\tcl_assert(reftable_ref_record_equal(&r2[0], &ref,\n+\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \treftable_ref_record_release(&ref);\n \treftable_iterator_destroy(&it);\n \ttables_destroy(tables, 3);\n@@ -101,7 +102,7 @@ static void t_merged_single_record(void)\n \treftable_free(bs);\n }\n \n-static void t_merged_refs(void)\n+void test_reftable_merged__refs(void)\n {\n \tstruct reftable_ref_record r1[] = {\n \t\t{\n@@ -165,12 +166,12 @@ static void t_merged_refs(void)\n \tsize_t i;\n \n \terr = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"a\");\n-\tcheck(!err);\n-\tcheck_int(reftable_merged_table_hash_id(mt), ==, REFTABLE_HASH_SHA1);\n-\tcheck_int(reftable_merged_table_min_update_index(mt), ==, 1);\n-\tcheck_int(reftable_merged_table_max_update_index(mt), ==, 3);\n+\tcl_assert(err == 0);\n+\tcl_assert_equal_i(reftable_merged_table_hash_id(mt), REFTABLE_HASH_SHA1);\n+\tcl_assert_equal_i(reftable_merged_table_min_update_index(mt), 1);\n+\tcl_assert_equal_i(reftable_merged_table_max_update_index(mt), 3);\n \n \twhile (len < 100) { /* cap loops/recursion. */\n \t\tstruct reftable_ref_record ref = { 0 };\n@@ -178,15 +179,15 @@ static void t_merged_refs(void)\n \t\tif (err > 0)\n \t\t\tbreak;\n \n-\t\tcheck(!REFTABLE_ALLOC_GROW(out, len + 1, cap));\n+\t\tcl_assert(REFTABLE_ALLOC_GROW(out, len + 1, cap) == 0);\n \t\tout[len++] = ref;\n \t}\n \treftable_iterator_destroy(&it);\n \n-\tcheck_int(ARRAY_SIZE(want), ==, len);\n+\tcl_assert_equal_i(ARRAY_SIZE(want), len);\n \tfor (i = 0; i < len; i++)\n-\t\tcheck(reftable_ref_record_equal(want[i], &out[i],\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_ref_record_equal(want[i], &out[i],\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \tfor (i = 0; i < len; i++)\n \t\treftable_ref_record_release(&out[i]);\n \treftable_free(out);\n@@ -198,7 +199,7 @@ static void t_merged_refs(void)\n \treftable_free(bs);\n }\n \n-static void t_merged_seek_multiple_times(void)\n+void test_reftable_merged__seek_multiple_times(void)\n {\n \tstruct reftable_ref_record r1[] = {\n \t\t{\n@@ -248,20 +249,17 @@ static void t_merged_seek_multiple_times(void)\n \n \tfor (size_t i = 0; i < 5; i++) {\n \t\tint err = reftable_iterator_seek_ref(&it, \"c\");\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \n-\t\terr = reftable_iterator_next_ref(&it, &rec);\n-\t\tcheck(!err);\n-\t\terr = reftable_ref_record_equal(&rec, &r1[1], REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck(err == 1);\n+\t\tcl_assert(reftable_iterator_next_ref(&it, &rec) == 0);\n+\t\tcl_assert_equal_i(reftable_ref_record_equal(&rec, &r1[1],\n+\t\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1), 1);\n \n-\t\terr = reftable_iterator_next_ref(&it, &rec);\n-\t\tcheck(!err);\n-\t\terr = reftable_ref_record_equal(&rec, &r2[1], REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck(err == 1);\n+\t\tcl_assert(reftable_iterator_next_ref(&it, &rec) == 0);\n+\t\tcl_assert_equal_i(reftable_ref_record_equal(&rec, &r2[1],\n+\t\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1), 1);\n \n-\t\terr = reftable_iterator_next_ref(&it, &rec);\n-\t\tcheck(err > 0);\n+\t\tcl_assert(reftable_iterator_next_ref(&it, &rec) > 0);\n \t}\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(bufs); i++)\n@@ -273,7 +271,7 @@ static void t_merged_seek_multiple_times(void)\n \treftable_free(sources);\n }\n \n-static void t_merged_seek_multiple_times_without_draining(void)\n+void test_reftable_merged__seek_multiple_times_no_drain(void)\n {\n \tstruct reftable_ref_record r1[] = {\n \t\t{\n@@ -317,24 +315,19 @@ static void t_merged_seek_multiple_times_without_draining(void)\n \tstruct reftable_ref_record rec = { 0 };\n \tstruct reftable_iterator it = { 0 };\n \tstruct reftable_merged_table *mt;\n-\tint err;\n \n \tmt = merged_table_from_records(refs, &sources, &tables, sizes, bufs, 2);\n \tmerged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);\n \n-\terr = reftable_iterator_seek_ref(&it, \"b\");\n-\tcheck(!err);\n-\terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\terr = reftable_ref_record_equal(&rec, &r2[0], REFTABLE_HASH_SIZE_SHA1);\n-\tcheck(err == 1);\n+\tcl_assert(reftable_iterator_seek_ref(&it, \"b\") == 0);\n+\tcl_assert(reftable_iterator_next_ref(&it, &rec) == 0);\n+\tcl_assert_equal_i(reftable_ref_record_equal(&rec, &r2[0],\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1), 1);\n \n-\terr = reftable_iterator_seek_ref(&it, \"a\");\n-\tcheck(!err);\n-\terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\terr = reftable_ref_record_equal(&rec, &r1[0], REFTABLE_HASH_SIZE_SHA1);\n-\tcheck(err == 1);\n+\tcl_assert(reftable_iterator_seek_ref(&it, \"a\") == 0);\n+\tcl_assert(reftable_iterator_next_ref(&it, &rec) == 0);\n+\tcl_assert_equal_i(reftable_ref_record_equal(&rec, &r1[0],\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1), 1);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(bufs); i++)\n \t\treftable_buf_release(&bufs[i]);\n@@ -359,25 +352,25 @@ merged_table_from_log_records(struct reftable_log_record **logs,\n \tint err;\n \n \tREFTABLE_CALLOC_ARRAY(*tables, n);\n-\tcheck(*tables != NULL);\n+\tcl_assert(*tables != NULL);\n \tREFTABLE_CALLOC_ARRAY(*source, n);\n-\tcheck(*source != NULL);\n+\tcl_assert(*source != NULL);\n \n \tfor (size_t i = 0; i < n; i++) {\n-\t\tt_reftable_write_to_buf(&buf[i], NULL, 0, logs[i], sizes[i], &opts);\n+\t\tcl_reftable_write_to_buf(&buf[i], NULL, 0, logs[i], sizes[i], &opts);\n \t\tblock_source_from_buf(&(*source)[i], &buf[i]);\n \n \t\terr = reftable_table_new(&(*tables)[i], &(*source)[i],\n \t\t\t\t\t \"name\");\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \t}\n \n \terr = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \treturn mt;\n }\n \n-static void t_merged_logs(void)\n+void test_reftable_merged__logs(void)\n {\n \tstruct reftable_log_record r1[] = {\n \t\t{\n@@ -439,19 +432,19 @@ static void t_merged_logs(void)\n \tstruct reftable_merged_table *mt = merged_table_from_log_records(\n \t\tlogs, &bs, &tables, sizes, bufs, 3);\n \tstruct reftable_iterator it = { 0 };\n-\tint err;\n \tstruct reftable_log_record *out = NULL;\n \tsize_t len = 0;\n \tsize_t cap = 0;\n \tsize_t i;\n+\tint err;\n \n \terr = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_log(&it, \"a\");\n-\tcheck(!err);\n-\tcheck_int(reftable_merged_table_hash_id(mt), ==, REFTABLE_HASH_SHA1);\n-\tcheck_int(reftable_merged_table_min_update_index(mt), ==, 1);\n-\tcheck_int(reftable_merged_table_max_update_index(mt), ==, 3);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(reftable_merged_table_hash_id(mt), REFTABLE_HASH_SHA1);\n+\tcl_assert_equal_i(reftable_merged_table_min_update_index(mt), 1);\n+\tcl_assert_equal_i(reftable_merged_table_max_update_index(mt), 3);\n \n \twhile (len < 100) { /* cap loops/recursion. */\n \t\tstruct reftable_log_record log = { 0 };\n@@ -459,24 +452,24 @@ static void t_merged_logs(void)\n \t\tif (err > 0)\n \t\t\tbreak;\n \n-\t\tcheck(!REFTABLE_ALLOC_GROW(out, len + 1, cap));\n+\t\tcl_assert(REFTABLE_ALLOC_GROW(out, len + 1, cap) == 0);\n \t\tout[len++] = log;\n \t}\n \treftable_iterator_destroy(&it);\n \n-\tcheck_int(ARRAY_SIZE(want), ==, len);\n+\tcl_assert_equal_i(ARRAY_SIZE(want), len);\n \tfor (i = 0; i < len; i++)\n-\t\tcheck(reftable_log_record_equal(want[i], &out[i],\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_log_record_equal(want[i], &out[i],\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \n \terr = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_log_at(&it, \"a\", 2);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \treftable_log_record_release(&out[0]);\n-\terr = reftable_iterator_next_log(&it, &out[0]);\n-\tcheck(!err);\n-\tcheck(reftable_log_record_equal(&out[0], &r3[0], REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert(reftable_iterator_next_log(&it, &out[0]) == 0);\n+\tcl_assert(reftable_log_record_equal(&out[0], &r3[0],\n+\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \treftable_iterator_destroy(&it);\n \n \tfor (i = 0; i < len; i++)\n@@ -490,11 +483,11 @@ static void t_merged_logs(void)\n \treftable_free(bs);\n }\n \n-static void t_default_write_opts(void)\n+void test_reftable_merged__default_write_opts(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_ref_record rec = {\n \t\t.refname = (char *) \"master\",\n \t\t.update_index = 1,\n@@ -507,40 +500,25 @@ static void t_default_write_opts(void)\n \n \treftable_writer_set_limits(w, 1, 1);\n \n-\terr = reftable_writer_add_ref(w, &rec);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_writer_add_ref(w, &rec), 0);\n \n-\terr = reftable_writer_close(w);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \treftable_writer_free(w);\n \n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"filename\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \thash_id = reftable_table_hash_id(table);\n-\tcheck_int(hash_id, ==, REFTABLE_HASH_SHA1);\n+\tcl_assert_equal_i(hash_id, REFTABLE_HASH_SHA1);\n \n \terr = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA256);\n-\tcheck_int(err, ==, REFTABLE_FORMAT_ERROR);\n+\tcl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);\n \terr = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA1);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \treftable_table_decref(table);\n \treftable_merged_table_free(merged);\n \treftable_buf_release(&buf);\n }\n-\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_default_write_opts(), \"merged table with default write opts\");\n-\tTEST(t_merged_logs(), \"merged table with multiple log updates for same ref\");\n-\tTEST(t_merged_refs(), \"merged table with multiple updates to same ref\");\n-\tTEST(t_merged_seek_multiple_times(), \"merged table can seek multiple times\");\n-\tTEST(t_merged_seek_multiple_times_without_draining(), \"merged table can seek multiple times without draining\");\n-\tTEST(t_merged_single_record(), \"ref occurring in only one record can be fetched\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"522673","messageId":"20250724142837.67149-6-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250724142837.67149-1-kuforiji98@gmail.com","subject":"[PATCH v5 05/10] t/unit-tests: convert reftable pq test to use clar","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T14:28:32Z","receivedAt":"2025-07-24T14:30:26Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kuforiji \n\nAdapt reftable priority queue test file to use clar by using clar\nassertions where necessary.\n\nSigned-off-by: Seyi Kuforiji \nSigned-off-by: Junio C Hamano \n---\n Makefile | 2 +-\n t/meson.build | 3 +-\n .../{t-reftable-pq.c => u-reftable-pq.c} | 59 +++++++++----------\n 3 files changed, 30 insertions(+), 34 deletions(-)\n rename t/unit-tests/{t-reftable-pq.c => u-reftable-pq.c} (64%)\n\ndiff --git a/Makefile b/Makefile\nindex fb0ef10ff2..3cccc73073 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1367,6 +1367,7 @@ CLAR_TEST_SUITES += u-prio-queue\n CLAR_TEST_SUITES += u-reftable-basics\n CLAR_TEST_SUITES += u-reftable-block\n CLAR_TEST_SUITES += u-reftable-merged\n+CLAR_TEST_SUITES += u-reftable-pq\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n CLAR_TEST_SUITES += u-strcmp-offset\n@@ -1380,7 +1381,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-pq\n UNIT_TEST_PROGRAMS += t-reftable-readwrite\n UNIT_TEST_PROGRAMS += t-reftable-record\n UNIT_TEST_PROGRAMS += t-reftable-stack\ndiff --git a/t/meson.build b/t/meson.build\nindex d25dfb0c92..ac4394b7a2 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -11,6 +11,7 @@ clar_test_suites = [\n 'unit-tests/u-reftable-basics.c',\n 'unit-tests/u-reftable-block.c',\n 'unit-tests/u-reftable-merged.c',\n+ 'unit-tests/u-reftable-pq.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n 'unit-tests/u-strcmp-offset.c',\n@@ -58,7 +59,7 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-pq.c',\n+ 'unit-tests/t-reftable-reader.c',\n 'unit-tests/t-reftable-readwrite.c',\n 'unit-tests/t-reftable-record.c',\n 'unit-tests/t-reftable-stack.c',\ndiff --git a/t/unit-tests/t-reftable-pq.c b/t/unit-tests/u-reftable-pq.c\nsimilarity index 64%\nrename from t/unit-tests/t-reftable-pq.c\nrename to t/unit-tests/u-reftable-pq.c\nindex fb5a4eb187..d55792ca6f 100644\n--- a/t/unit-tests/t-reftable-pq.c\n+++ b/t/unit-tests/u-reftable-pq.c\n@@ -6,7 +6,8 @@ license that can be found in the LICENSE file or at\n https://developers.google.com/open-source/licenses/bsd\n */\n \n-#include \"test-lib.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/pq.h\"\n #include \"strbuf.h\"\n@@ -15,18 +16,18 @@ static void merged_iter_pqueue_check(const struct merged_iter_pqueue *pq)\n {\n \tfor (size_t i = 1; i < pq->len; i++) {\n \t\tsize_t parent = (i - 1) / 2;\n-\t\tcheck(pq_less(&pq->heap[parent], &pq->heap[i]));\n+\t\tcl_assert(pq_less(&pq->heap[parent], &pq->heap[i]) != 0);\n \t}\n }\n \n static int pq_entry_equal(struct pq_entry *a, struct pq_entry *b)\n {\n \tint cmp;\n-\tcheck(!reftable_record_cmp(a->rec, b->rec, &cmp));\n+\tcl_assert_equal_i(reftable_record_cmp(a->rec, b->rec, &cmp), 0);\n \treturn !cmp && (a->index == b->index);\n }\n \n-static void t_pq_record(void)\n+void test_reftable_pq__record(void)\n {\n \tstruct merged_iter_pqueue pq = { 0 };\n \tstruct reftable_record recs[54];\n@@ -34,7 +35,8 @@ static void t_pq_record(void)\n \tchar *last = NULL;\n \n \tfor (i = 0; i < N; i++) {\n-\t\tcheck(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));\n+\t\tcl_assert(!reftable_record_init(&recs[i],\n+\t\t\t\t\t\tREFTABLE_BLOCK_TYPE_REF));\n \t\trecs[i].u.ref.refname = xstrfmt(\"%02\"PRIuMAX, (uintmax_t)i);\n \t}\n \n@@ -53,13 +55,13 @@ static void t_pq_record(void)\n \t\tstruct pq_entry top = merged_iter_pqueue_top(pq);\n \t\tstruct pq_entry e;\n \n-\t\tcheck(!merged_iter_pqueue_remove(&pq, &e));\n+\t\tcl_assert_equal_i(merged_iter_pqueue_remove(&pq, &e), 0);\n \t\tmerged_iter_pqueue_check(&pq);\n \n-\t\tcheck(pq_entry_equal(&top, &e));\n-\t\tcheck(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);\n+\t\tcl_assert(pq_entry_equal(&top, &e));\n+\t\tcl_assert(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);\n \t\tif (last)\n-\t\t\tcheck_int(strcmp(last, e.rec->u.ref.refname), <, 0);\n+\t\t\tcl_assert(strcmp(last, e.rec->u.ref.refname) < 0);\n \t\tlast = e.rec->u.ref.refname;\n \t}\n \n@@ -68,7 +70,7 @@ static void t_pq_record(void)\n \tmerged_iter_pqueue_release(&pq);\n }\n \n-static void t_pq_index(void)\n+void test_reftable_pq__index(void)\n {\n \tstruct merged_iter_pqueue pq = { 0 };\n \tstruct reftable_record recs[13];\n@@ -76,7 +78,8 @@ static void t_pq_index(void)\n \tsize_t N = ARRAY_SIZE(recs), i;\n \n \tfor (i = 0; i < N; i++) {\n-\t\tcheck(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));\n+\t\tcl_assert(!reftable_record_init(&recs[i],\n+\t\t\t\t\t\tREFTABLE_BLOCK_TYPE_REF));\n \t\trecs[i].u.ref.refname = (char *) \"refs/heads/master\";\n \t}\n \n@@ -96,28 +99,29 @@ static void t_pq_index(void)\n \t\tstruct pq_entry top = merged_iter_pqueue_top(pq);\n \t\tstruct pq_entry e;\n \n-\t\tcheck(!merged_iter_pqueue_remove(&pq, &e));\n+\t\tcl_assert_equal_i(merged_iter_pqueue_remove(&pq, &e), 0);\n \t\tmerged_iter_pqueue_check(&pq);\n \n-\t\tcheck(pq_entry_equal(&top, &e));\n-\t\tcheck(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);\n-\t\tcheck_int(e.index, ==, i);\n+\t\tcl_assert(pq_entry_equal(&top, &e));\n+\t\tcl_assert(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);\n+\t\tcl_assert_equal_i(e.index, i);\n \t\tif (last)\n-\t\t\tcheck_str(last, e.rec->u.ref.refname);\n+\t\t\tcl_assert_equal_s(last, e.rec->u.ref.refname);\n \t\tlast = e.rec->u.ref.refname;\n \t}\n \n \tmerged_iter_pqueue_release(&pq);\n }\n \n-static void t_merged_iter_pqueue_top(void)\n+void test_reftable_pq__merged_iter_pqueue_top(void)\n {\n \tstruct merged_iter_pqueue pq = { 0 };\n \tstruct reftable_record recs[13];\n \tsize_t N = ARRAY_SIZE(recs), i;\n \n \tfor (i = 0; i < N; i++) {\n-\t\tcheck(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));\n+\t\tcl_assert(!reftable_record_init(&recs[i],\n+\t\t\t\t\t\tREFTABLE_BLOCK_TYPE_REF));\n \t\trecs[i].u.ref.refname = (char *) \"refs/heads/master\";\n \t}\n \n@@ -137,25 +141,16 @@ static void t_merged_iter_pqueue_top(void)\n \t\tstruct pq_entry top = merged_iter_pqueue_top(pq);\n \t\tstruct pq_entry e;\n \n-\t\tcheck(!merged_iter_pqueue_remove(&pq, &e));\n+\t\tcl_assert_equal_i(merged_iter_pqueue_remove(&pq, &e), 0);\n \n \t\tmerged_iter_pqueue_check(&pq);\n-\t\tcheck(pq_entry_equal(&top, &e));\n-\t\tcheck(reftable_record_equal(top.rec, &recs[i], REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(pq_entry_equal(&top, &e) != 0);\n+\t\tcl_assert(reftable_record_equal(top.rec, &recs[i], REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\tfor (size_t j = 0; i < pq.len; j++) {\n-\t\t\tcheck(pq_less(&top, &pq.heap[j]));\n-\t\t\tcheck_int(top.index, >, j);\n+\t\t\tcl_assert(pq_less(&top, &pq.heap[j]) != 0);\n+\t\t\tcl_assert(top.index > j);\n \t\t}\n \t}\n \n \tmerged_iter_pqueue_release(&pq);\n }\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_pq_record(), \"pq works with record-based comparison\");\n-\tTEST(t_pq_index(), \"pq works with index-based comparison\");\n-\tTEST(t_merged_iter_pqueue_top(), \"merged_iter_pqueue_top works\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"522674","messageId":"20250724142837.67149-7-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250724142837.67149-1-kuforiji98@gmail.com","subject":"[PATCH v5 06/10] t/unit-tests: convert reftable table test to use clar","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T14:28:33Z","receivedAt":"2025-07-24T14:30:29Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kuforiji \n\nAdapt reftable table test file to use clar by using clar assertions\nwhere necessary.\n\nSigned-off-by: Seyi Kuforiji \nSigned-off-by: Junio C Hamano \n---\n Makefile | 2 +-\n t/meson.build | 5 +-\n ...{t-reftable-table.c => u-reftable-table.c} | 75 +++++++++----------\n 3 files changed, 38 insertions(+), 44 deletions(-)\n rename t/unit-tests/{t-reftable-table.c => u-reftable-table.c} (75%)\n\ndiff --git a/Makefile b/Makefile\nindex 3cccc73073..e4b90052be 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1368,6 +1368,7 @@ CLAR_TEST_SUITES += u-reftable-basics\n CLAR_TEST_SUITES += u-reftable-block\n CLAR_TEST_SUITES += u-reftable-merged\n CLAR_TEST_SUITES += u-reftable-pq\n+CLAR_TEST_SUITES += u-reftable-table\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n CLAR_TEST_SUITES += u-strcmp-offset\n@@ -1384,7 +1385,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n UNIT_TEST_PROGRAMS += t-reftable-readwrite\n UNIT_TEST_PROGRAMS += t-reftable-record\n UNIT_TEST_PROGRAMS += t-reftable-stack\n-UNIT_TEST_PROGRAMS += t-reftable-table\n UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o\ndiff --git a/t/meson.build b/t/meson.build\nindex ac4394b7a2..46d3a8580b 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -12,6 +12,7 @@ clar_test_suites = [\n 'unit-tests/u-reftable-block.c',\n 'unit-tests/u-reftable-merged.c',\n 'unit-tests/u-reftable-pq.c',\n+ 'unit-tests/u-reftable-table.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n 'unit-tests/u-strcmp-offset.c',\n@@ -59,11 +60,9 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-reader.c',\n 'unit-tests/t-reftable-readwrite.c',\n 'unit-tests/t-reftable-record.c',\n 'unit-tests/t-reftable-stack.c',\n- 'unit-tests/t-reftable-table.c',\n ]\n \n foreach unit_test_program : unit_test_programs\n@@ -1233,4 +1232,4 @@ if perl.found() and time.found()\n timeout: 0,\n )\n endforeach\n-endif\n+endif\n\\ No newline at end of file\ndiff --git a/t/unit-tests/t-reftable-table.c b/t/unit-tests/u-reftable-table.c\nsimilarity index 75%\nrename from t/unit-tests/t-reftable-table.c\nrename to t/unit-tests/u-reftable-table.c\nindex 7e1eb533d0..839107d8a4 100644\n--- a/t/unit-tests/t-reftable-table.c\n+++ b/t/unit-tests/u-reftable-table.c\n@@ -1,12 +1,12 @@\n-#include \"test-lib.h\"\n-#include \"lib-reftable.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/iter.h\"\n #include \"reftable/table.h\"\n #include \"strbuf.h\"\n \n-static int t_table_seek_once(void)\n+void test_reftable_table__seek_once(void)\n {\n \tstruct reftable_ref_record records[] = {\n \t\t{\n@@ -22,32 +22,32 @@ static int t_table_seek_once(void)\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tint ret;\n \n-\tt_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);\n+\tcl_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);\n \tblock_source_from_buf(&source, &buf);\n \n \tret = reftable_table_new(&table, &source, \"name\");\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \treftable_table_init_ref_iterator(table, &it);\n \tret = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \tret = reftable_iterator_next_ref(&it, &ref);\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n-\tret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1);\n-\tcheck_int(ret, ==, 1);\n+\tret = reftable_ref_record_equal(&ref, &records[0],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1);\n+\tcl_assert_equal_i(ret, 1);\n \n \tret = reftable_iterator_next_ref(&it, &ref);\n-\tcheck_int(ret, ==, 1);\n+\tcl_assert_equal_i(ret, 1);\n \n \treftable_ref_record_release(&ref);\n \treftable_iterator_destroy(&it);\n \treftable_table_decref(table);\n \treftable_buf_release(&buf);\n-\treturn 0;\n }\n \n-static int t_table_reseek(void)\n+void test_reftable_table__reseek(void)\n {\n \tstruct reftable_ref_record records[] = {\n \t\t{\n@@ -63,35 +63,35 @@ static int t_table_reseek(void)\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tint ret;\n \n-\tt_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);\n+\tcl_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records),\n+\t\t\t\t NULL, 0, NULL);\n \tblock_source_from_buf(&source, &buf);\n \n \tret = reftable_table_new(&table, &source, \"name\");\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \treftable_table_init_ref_iterator(table, &it);\n \n \tfor (size_t i = 0; i < 5; i++) {\n \t\tret = reftable_iterator_seek_ref(&it, \"\");\n-\t\tcheck(!ret);\n+\t\tcl_assert(!ret);\n \t\tret = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck(!ret);\n+\t\tcl_assert(!ret);\n \n \t\tret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck_int(ret, ==, 1);\n+\t\tcl_assert_equal_i(ret, 1);\n \n \t\tret = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck_int(ret, ==, 1);\n+\t\tcl_assert_equal_i(ret, 1);\n \t}\n \n \treftable_ref_record_release(&ref);\n \treftable_iterator_destroy(&it);\n \treftable_table_decref(table);\n \treftable_buf_release(&buf);\n-\treturn 0;\n }\n \n-static int t_table_block_iterator(void)\n+void test_reftable_table__block_iterator(void)\n {\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_table_iterator it = { 0 };\n@@ -147,14 +147,14 @@ static int t_table_block_iterator(void)\n \t\t\t\t\t (uintmax_t) i);\n \t}\n \n-\tt_reftable_write_to_buf(&buf, records, nrecords, NULL, 0, NULL);\n+\tcl_reftable_write_to_buf(&buf, records, nrecords, NULL, 0, NULL);\n \tblock_source_from_buf(&source, &buf);\n \n \tret = reftable_table_new(&table, &source, \"name\");\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \tret = reftable_table_iterator_init(&it, table);\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(expected_blocks); i++) {\n \t\tstruct reftable_iterator record_it = { 0 };\n@@ -163,22 +163,26 @@ static int t_table_block_iterator(void)\n \t\t};\n \n \t\tret = reftable_table_iterator_next(&it, &block);\n-\t\tcheck(!ret);\n+\t\tcl_assert(!ret);\n \n-\t\tcheck_int(block->block_type, ==, expected_blocks[i].block_type);\n-\t\tcheck_int(block->header_off, ==, expected_blocks[i].header_off);\n-\t\tcheck_int(block->restart_count, ==, expected_blocks[i].restart_count);\n+\t\tcl_assert_equal_i(block->block_type,\n+\t\t\t\t expected_blocks[i].block_type);\n+\t\tcl_assert_equal_i(block->header_off,\n+\t\t\t\t expected_blocks[i].header_off);\n+\t\tcl_assert_equal_i(block->restart_count,\n+\t\t\t\t expected_blocks[i].restart_count);\n \n \t\tret = reftable_block_init_iterator(block, &record_it);\n-\t\tcheck(!ret);\n+\t\tcl_assert(!ret);\n \n \t\tfor (size_t j = 0; ; j++) {\n \t\t\tret = iterator_next(&record_it, &record);\n \t\t\tif (ret > 0) {\n-\t\t\t\tcheck_int(j, ==, expected_blocks[i].record_count);\n+\t\t\t\tcl_assert_equal_i(j,\n+\t\t\t\t\t\t expected_blocks[i].record_count);\n \t\t\t\tbreak;\n \t\t\t}\n-\t\t\tcheck(!ret);\n+\t\t\tcl_assert(!ret);\n \t\t}\n \n \t\treftable_iterator_destroy(&record_it);\n@@ -186,7 +190,7 @@ static int t_table_block_iterator(void)\n \t}\n \n \tret = reftable_table_iterator_next(&it, &block);\n-\tcheck_int(ret, ==, 1);\n+\tcl_assert_equal_i(ret, 1);\n \n \tfor (size_t i = 0; i < nrecords; i++)\n \t\treftable_free(records[i].refname);\n@@ -194,13 +198,4 @@ static int t_table_block_iterator(void)\n \treftable_table_decref(table);\n \treftable_buf_release(&buf);\n \treftable_free(records);\n-\treturn 0;\n-}\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_table_seek_once(), \"table can seek once\");\n-\tTEST(t_table_reseek(), \"table can reseek multiple times\");\n-\tTEST(t_table_block_iterator(), \"table can iterate through blocks\");\n-\treturn test_done();\n }\n-- \n2.43.0\n\n"},{"id":"522675","messageId":"20250724142837.67149-8-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250724142837.67149-1-kuforiji98@gmail.com","subject":"[PATCH v5 07/10] t/unit-tests: convert reftable readwrite test to use clar","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T14:28:34Z","receivedAt":"2025-07-24T14:30:34Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kuforiji \n\nAdapt reftable readwrite test file to use clar by using clar assertions\nwhere necessary.\n\nSigned-off-by: Seyi Kuforiji \nSigned-off-by: Junio C Hamano \n---\n Makefile | 2 +-\n t/meson.build | 2 +-\n ...ble-readwrite.c => u-reftable-readwrite.c} | 405 ++++++++----------\n 3 files changed, 179 insertions(+), 230 deletions(-)\n rename t/unit-tests/{t-reftable-readwrite.c => u-reftable-readwrite.c} (68%)\n\ndiff --git a/Makefile b/Makefile\nindex e4b90052be..1c91787b6a 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1368,6 +1368,7 @@ CLAR_TEST_SUITES += u-reftable-basics\n CLAR_TEST_SUITES += u-reftable-block\n CLAR_TEST_SUITES += u-reftable-merged\n CLAR_TEST_SUITES += u-reftable-pq\n+CLAR_TEST_SUITES += u-reftable-readwrite\n CLAR_TEST_SUITES += u-reftable-table\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n@@ -1382,7 +1383,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-readwrite\n UNIT_TEST_PROGRAMS += t-reftable-record\n UNIT_TEST_PROGRAMS += t-reftable-stack\n UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\ndiff --git a/t/meson.build b/t/meson.build\nindex 46d3a8580b..5189176472 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -12,6 +12,7 @@ clar_test_suites = [\n 'unit-tests/u-reftable-block.c',\n 'unit-tests/u-reftable-merged.c',\n 'unit-tests/u-reftable-pq.c',\n+ 'unit-tests/u-reftable-readwrite.c',\n 'unit-tests/u-reftable-table.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n@@ -60,7 +61,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-readwrite.c',\n 'unit-tests/t-reftable-record.c',\n 'unit-tests/t-reftable-stack.c',\n ]\ndiff --git a/t/unit-tests/t-reftable-readwrite.c b/t/unit-tests/u-reftable-readwrite.c\nsimilarity index 68%\nrename from t/unit-tests/t-reftable-readwrite.c\nrename to t/unit-tests/u-reftable-readwrite.c\nindex 4c49129439..9aac74a011 100644\n--- a/t/unit-tests/t-reftable-readwrite.c\n+++ b/t/unit-tests/u-reftable-readwrite.c\n@@ -8,8 +8,8 @@ license that can be found in the LICENSE file or at\n \n #define DISABLE_SIGN_COMPARE_WARNINGS\n \n-#include \"test-lib.h\"\n-#include \"lib-reftable.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/basics.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/reftable-error.h\"\n@@ -19,24 +19,24 @@ license that can be found in the LICENSE file or at\n \n static const int update_index = 5;\n \n-static void t_buffer(void)\n+void test_reftable_readwrite__buffer(void)\n {\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_block_data out = { 0 };\n \tint n;\n \tuint8_t in[] = \"hello\";\n-\tcheck(!reftable_buf_add(&buf, in, sizeof(in)));\n+\tcl_assert_equal_i(reftable_buf_add(&buf, in, sizeof(in)), 0);\n \tblock_source_from_buf(&source, &buf);\n-\tcheck_int(block_source_size(&source), ==, 6);\n+\tcl_assert_equal_i(block_source_size(&source), 6);\n \tn = block_source_read_data(&source, &out, 0, sizeof(in));\n-\tcheck_int(n, ==, sizeof(in));\n-\tcheck(!memcmp(in, out.data, n));\n+\tcl_assert_equal_i(n, sizeof(in));\n+\tcl_assert(!memcmp(in, out.data, n));\n \tblock_source_release_data(&out);\n \n \tn = block_source_read_data(&source, &out, 1, 2);\n-\tcheck_int(n, ==, 2);\n-\tcheck(!memcmp(out.data, \"el\", 2));\n+\tcl_assert_equal_i(n, 2);\n+\tcl_assert(!memcmp(out.data, \"el\", 2));\n \n \tblock_source_release_data(&out);\n \tblock_source_close(&source);\n@@ -55,41 +55,41 @@ static void write_table(char ***names, struct reftable_buf *buf, int N,\n \tint i;\n \n \tREFTABLE_CALLOC_ARRAY(*names, N + 1);\n-\tcheck(*names != NULL);\n+\tcl_assert(*names != NULL);\n \tREFTABLE_CALLOC_ARRAY(refs, N);\n-\tcheck(refs != NULL);\n+\tcl_assert(refs != NULL);\n \tREFTABLE_CALLOC_ARRAY(logs, N);\n-\tcheck(logs != NULL);\n+\tcl_assert(logs != NULL);\n \n \tfor (i = 0; i < N; i++) {\n \t\trefs[i].refname = (*names)[i] = xstrfmt(\"refs/heads/branch%02d\", i);\n \t\trefs[i].update_index = update_index;\n \t\trefs[i].value_type = REFTABLE_REF_VAL1;\n-\t\tt_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n \t\tlogs[i].refname = (*names)[i];\n \t\tlogs[i].update_index = update_index;\n \t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n-\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t\tlogs[i].value.update.message = (char *) \"message\";\n \t}\n \n-\tt_reftable_write_to_buf(buf, refs, N, logs, N, &opts);\n+\tcl_reftable_write_to_buf(buf, refs, N, logs, N, &opts);\n \n \treftable_free(refs);\n \treftable_free(logs);\n }\n \n-static void t_log_buffer_size(void)\n+void test_reftable_readwrite__log_buffer_size(void)\n {\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 4096,\n \t};\n-\tint err;\n \tint i;\n \tstruct reftable_log_record\n \t\tlog = { .refname = (char *) \"refs/heads/master\",\n@@ -102,7 +102,8 @@ static void t_log_buffer_size(void)\n \t\t\t\t\t .time = 0x5e430672,\n \t\t\t\t\t .message = (char *) \"commit: 9\\n\",\n \t\t\t\t } } };\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \n \t/* This tests buffer extension for log compression. Must use a random\n \t hash, to ensure that the compressed part is larger than the original.\n@@ -112,22 +113,19 @@ static void t_log_buffer_size(void)\n \t\tlog.value.update.new_hash[i] = (uint8_t)(git_rand(0) % 256);\n \t}\n \treftable_writer_set_limits(w, update_index, update_index);\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck(!err);\n-\terr = reftable_writer_close(w);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_log_overflow(void)\n+void test_reftable_readwrite__log_overflow(void)\n {\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tchar msg[256] = { 0 };\n \tstruct reftable_write_options opts = {\n \t\t.block_size = ARRAY_SIZE(msg),\n \t};\n-\tint err;\n \tstruct reftable_log_record log = {\n \t\t.refname = (char *) \"refs/heads/master\",\n \t\t.update_index = update_index,\n@@ -144,21 +142,22 @@ static void t_log_overflow(void)\n \t\t\t},\n \t\t},\n \t};\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \n \tmemset(msg, 'x', sizeof(msg) - 1);\n \treftable_writer_set_limits(w, update_index, update_index);\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck_int(err, ==, REFTABLE_ENTRY_TOO_BIG_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), REFTABLE_ENTRY_TOO_BIG_ERROR);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_log_write_limits(void)\n+void test_reftable_readwrite__log_write_limits(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \tstruct reftable_log_record log = {\n \t\t.refname = (char *)\"refs/head/master\",\n \t\t.update_index = 0,\n@@ -174,29 +173,25 @@ static void t_log_write_limits(void)\n \t\t\t},\n \t\t},\n \t};\n-\tint err;\n \n \treftable_writer_set_limits(w, 1, 1);\n \n \t/* write with update_index (0) below set limits (1, 1) */\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck_int(err, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n \n \t/* write with update_index (1) in the set limits (1, 1) */\n \tlog.update_index = 1;\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck_int(err, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n \n \t/* write with update_index (3) above set limits (1, 1) */\n \tlog.update_index = 3;\n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), REFTABLE_API_ERROR);\n \n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_log_write_read(void)\n+void test_reftable_readwrite__log_write_read(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 256,\n@@ -207,13 +202,14 @@ static void t_log_write_read(void)\n \tstruct reftable_table *table;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tconst struct reftable_stats *stats = NULL;\n-\tint N = 2, err, i, n;\n+\tint N = 2, i;\n \tchar **names;\n+\tint err;\n \n \tnames = reftable_calloc(N + 1, sizeof(*names));\n-\tcheck(names != NULL);\n+\tcl_assert(names != NULL);\n \n \treftable_writer_set_limits(w, 0, N);\n \n@@ -225,8 +221,7 @@ static void t_log_write_read(void)\n \t\tref.refname = name;\n \t\tref.update_index = i;\n \n-\t\terr = reftable_writer_add_ref(w, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n@@ -235,60 +230,57 @@ static void t_log_write_read(void)\n \t\tlog.refname = names[i];\n \t\tlog.update_index = i;\n \t\tlog.value_type = REFTABLE_LOG_UPDATE;\n-\t\tt_reftable_set_hash(log.value.update.old_hash, i,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n-\t\tt_reftable_set_hash(log.value.update.new_hash, i + 1,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(log.value.update.old_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(log.value.update.new_hash, i + 1,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \n-\t\terr = reftable_writer_add_log(w, &log);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n \t}\n \n-\tn = reftable_writer_close(w);\n-\tcheck_int(n, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \n \tstats = reftable_writer_stats(w);\n-\tcheck_int(stats->log_stats.blocks, >, 0);\n+\tcl_assert(stats->log_stats.blocks > 0);\n \treftable_writer_free(w);\n \tw = NULL;\n \n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.log\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_iterator_seek_ref(&it, names[N - 1]);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_iterator_next_ref(&it, &ref);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \t/* end of iteration. */\n-\terr = reftable_iterator_next_ref(&it, &ref);\n-\tcheck_int(err, >, 0);\n+\tcl_assert(reftable_iterator_next_ref(&it, &ref) > 0);\n \n \treftable_iterator_destroy(&it);\n \treftable_ref_record_release(&ref);\n \n \terr = reftable_table_init_log_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_log(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (i = 0; ; i++) {\n \t\tint err = reftable_iterator_next_log(&it, &log);\n \t\tif (err > 0)\n \t\t\tbreak;\n-\t\tcheck(!err);\n-\t\tcheck_str(names[i], log.refname);\n-\t\tcheck_int(i, ==, log.update_index);\n+\t\tcl_assert(!err);\n+\t\tcl_assert_equal_s(names[i], log.refname);\n+\t\tcl_assert_equal_i(i, log.update_index);\n \t\treftable_log_record_release(&log);\n \t}\n \n-\tcheck_int(i, ==, N);\n+\tcl_assert_equal_i(i, N);\n \treftable_iterator_destroy(&it);\n \n \t/* cleanup. */\n@@ -297,7 +289,7 @@ static void t_log_write_read(void)\n \treftable_table_decref(table);\n }\n \n-static void t_log_zlib_corruption(void)\n+void test_reftable_readwrite__log_zlib_corruption(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 256,\n@@ -306,10 +298,12 @@ static void t_log_zlib_corruption(void)\n \tstruct reftable_table *table;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \tconst struct reftable_stats *stats = NULL;\n \tchar message[100] = { 0 };\n-\tint err, i, n;\n+\tint i;\n+\tint err;\n \tstruct reftable_log_record log = {\n \t\t.refname = (char *) \"refname\",\n \t\t.value_type = REFTABLE_LOG_UPDATE,\n@@ -329,14 +323,11 @@ static void t_log_zlib_corruption(void)\n \n \treftable_writer_set_limits(w, 1, 1);\n \n-\terr = reftable_writer_add_log(w, &log);\n-\tcheck(!err);\n-\n-\tn = reftable_writer_close(w);\n-\tcheck_int(n, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_add_log(w, &log), 0);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \n \tstats = reftable_writer_stats(w);\n-\tcheck_int(stats->log_stats.blocks, >, 0);\n+\tcl_assert(stats->log_stats.blocks > 0);\n \treftable_writer_free(w);\n \tw = NULL;\n \n@@ -346,12 +337,12 @@ static void t_log_zlib_corruption(void)\n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.log\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_log_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_log(&it, \"refname\");\n-\tcheck_int(err, ==, REFTABLE_ZLIB_ERROR);\n+\tcl_assert_equal_i(err, REFTABLE_ZLIB_ERROR);\n \n \treftable_iterator_destroy(&it);\n \n@@ -360,7 +351,7 @@ static void t_log_zlib_corruption(void)\n \treftable_buf_release(&buf);\n }\n \n-static void t_table_read_write_sequential(void)\n+void test_reftable_readwrite__table_read_write_sequential(void)\n {\n \tchar **names;\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n@@ -376,24 +367,24 @@ static void t_table_read_write_sequential(void)\n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.ref\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (j = 0; ; j++) {\n \t\tstruct reftable_ref_record ref = { 0 };\n \t\tint r = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck_int(r, >=, 0);\n+\t\tcl_assert(r >= 0);\n \t\tif (r > 0)\n \t\t\tbreak;\n-\t\tcheck_str(names[j], ref.refname);\n-\t\tcheck_int(update_index, ==, ref.update_index);\n+\t\tcl_assert_equal_s(names[j], ref.refname);\n+\t\tcl_assert_equal_i(update_index, ref.update_index);\n \t\treftable_ref_record_release(&ref);\n \t}\n-\tcheck_int(j, ==, N);\n+\tcl_assert_equal_i(j, N);\n \n \treftable_iterator_destroy(&it);\n \treftable_table_decref(table);\n@@ -401,42 +392,42 @@ static void t_table_read_write_sequential(void)\n \tfree_names(names);\n }\n \n-static void t_table_write_small_table(void)\n+void test_reftable_readwrite__table_write_small_table(void)\n {\n \tchar **names;\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tint N = 1;\n \twrite_table(&names, &buf, N, 4096, REFTABLE_HASH_SHA1);\n-\tcheck_int(buf.len, <, 200);\n+\tcl_assert(buf.len < 200);\n \treftable_buf_release(&buf);\n \tfree_names(names);\n }\n \n-static void t_table_read_api(void)\n+void test_reftable_readwrite__table_read_api(void)\n {\n \tchar **names;\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tint N = 50;\n \tstruct reftable_table *table;\n \tstruct reftable_block_source source = { 0 };\n-\tint err;\n \tstruct reftable_log_record log = { 0 };\n \tstruct reftable_iterator it = { 0 };\n+\tint err;\n \n \twrite_table(&names, &buf, N, 256, REFTABLE_HASH_SHA1);\n \n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.ref\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, names[0]);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_iterator_next_log(&it, &log);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(err, REFTABLE_API_ERROR);\n \n \treftable_buf_release(&buf);\n \tfree_names(names);\n@@ -464,42 +455,43 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)\n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.ref\");\n-\tcheck(!err);\n-\tcheck_int(hash_id, ==, reftable_table_hash_id(table));\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(hash_id, reftable_table_hash_id(table));\n \n \tif (!index) {\n \t\ttable->ref_offsets.index_offset = 0;\n \t} else {\n-\t\tcheck_int(table->ref_offsets.index_offset, >, 0);\n+\t\tcl_assert(table->ref_offsets.index_offset > 0);\n \t}\n \n \tfor (i = 1; i < N; i++) {\n \t\terr = reftable_table_init_ref_iterator(table, &it);\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \t\terr = reftable_iterator_seek_ref(&it, names[i]);\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \t\terr = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck(!err);\n-\t\tcheck_str(names[i], ref.refname);\n-\t\tcheck_int(REFTABLE_REF_VAL1, ==, ref.value_type);\n-\t\tcheck_int(i, ==, ref.value.val1[0]);\n+\t\tcl_assert(!err);\n+\t\tcl_assert_equal_s(names[i], ref.refname);\n+\t\tcl_assert_equal_i(REFTABLE_REF_VAL1, ref.value_type);\n+\t\tcl_assert_equal_i(i, ref.value.val1[0]);\n \n \t\treftable_ref_record_release(&ref);\n \t\treftable_iterator_destroy(&it);\n \t}\n \n-\tcheck(!reftable_buf_addstr(&pastLast, names[N - 1]));\n-\tcheck(!reftable_buf_addstr(&pastLast, \"/\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&pastLast, names[N - 1]),\n+\t\t\t\t\t 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&pastLast, \"/\"), 0);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, pastLast.buf);\n \tif (err == 0) {\n \t\tstruct reftable_ref_record ref = { 0 };\n \t\tint err = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck_int(err, >, 0);\n+\t\tcl_assert(err > 0);\n \t} else {\n-\t\tcheck_int(err, >, 0);\n+\t\tcl_assert(err > 0);\n \t}\n \n \treftable_buf_release(&pastLast);\n@@ -510,17 +502,17 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)\n \treftable_table_decref(table);\n }\n \n-static void t_table_read_write_seek_linear(void)\n+void test_reftable_readwrite__table_read_write_seek_linear(void)\n {\n \tt_table_read_write_seek(0, REFTABLE_HASH_SHA1);\n }\n \n-static void t_table_read_write_seek_linear_sha256(void)\n+void test_reftable_readwrite__table_read_write_seek_linear_sha256(void)\n {\n \tt_table_read_write_seek(0, REFTABLE_HASH_SHA256);\n }\n \n-static void t_table_read_write_seek_index(void)\n+void test_reftable_readwrite__table_read_write_seek_index(void)\n {\n \tt_table_read_write_seek(1, REFTABLE_HASH_SHA1);\n }\n@@ -538,14 +530,16 @@ static void t_table_refs_for(int indexed)\n \tstruct reftable_table *table;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf,\n+\t\t\t\t\t\t\t &opts);\n \tstruct reftable_iterator it = { 0 };\n-\tint N = 50, n, j, err, i;\n+\tint N = 50, j, i;\n+\tint err;\n \n \twant_names = reftable_calloc(N + 1, sizeof(*want_names));\n-\tcheck(want_names != NULL);\n+\tcl_assert(want_names != NULL);\n \n-\tt_reftable_set_hash(want_hash, 4, REFTABLE_HASH_SHA1);\n+\tcl_reftable_set_hash(want_hash, 4, REFTABLE_HASH_SHA1);\n \n \tfor (i = 0; i < N; i++) {\n \t\tuint8_t hash[REFTABLE_HASH_SIZE_SHA1];\n@@ -561,24 +555,22 @@ static void t_table_refs_for(int indexed)\n \t\tref.refname = name;\n \n \t\tref.value_type = REFTABLE_REF_VAL2;\n-\t\tt_reftable_set_hash(ref.value.val2.value, i / 4,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n-\t\tt_reftable_set_hash(ref.value.val2.target_value, 3 + i / 4,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(ref.value.val2.value, i / 4,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(ref.value.val2.target_value,\n+\t\t\t\t 3 + i / 4, REFTABLE_HASH_SHA1);\n \n \t\t/* 80 bytes / entry, so 3 entries per block. Yields 17\n \t\t */\n \t\t/* blocks. */\n-\t\tn = reftable_writer_add_ref(w, &ref);\n-\t\tcheck_int(n, ==, 0);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);\n \n \t\tif (!memcmp(ref.value.val2.value, want_hash, REFTABLE_HASH_SIZE_SHA1) ||\n \t\t !memcmp(ref.value.val2.target_value, want_hash, REFTABLE_HASH_SIZE_SHA1))\n \t\t\twant_names[want_names_len++] = xstrdup(name);\n \t}\n \n-\tn = reftable_writer_close(w);\n-\tcheck_int(n, ==, 0);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n \n \treftable_writer_free(w);\n \tw = NULL;\n@@ -586,29 +578,29 @@ static void t_table_refs_for(int indexed)\n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"file.ref\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \tif (!indexed)\n \t\ttable->obj_offsets.is_present = 0;\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \treftable_iterator_destroy(&it);\n \n \terr = reftable_table_refs_for(table, &it, want_hash);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (j = 0; ; j++) {\n \t\tint err = reftable_iterator_next_ref(&it, &ref);\n-\t\tcheck_int(err, >=, 0);\n+\t\tcl_assert(err >= 0);\n \t\tif (err > 0)\n \t\t\tbreak;\n-\t\tcheck_int(j, <, want_names_len);\n-\t\tcheck_str(ref.refname, want_names[j]);\n+\t\tcl_assert(j < want_names_len);\n+\t\tcl_assert_equal_s(ref.refname, want_names[j]);\n \t\treftable_ref_record_release(&ref);\n \t}\n-\tcheck_int(j, ==, want_names_len);\n+\tcl_assert_equal_i(j, want_names_len);\n \n \treftable_buf_release(&buf);\n \tfree_names(want_names);\n@@ -616,21 +608,21 @@ static void t_table_refs_for(int indexed)\n \treftable_table_decref(table);\n }\n \n-static void t_table_refs_for_no_index(void)\n+void test_reftable_readwrite__table_refs_for_no_index(void)\n {\n \tt_table_refs_for(0);\n }\n \n-static void t_table_refs_for_obj_index(void)\n+void test_reftable_readwrite__table_refs_for_obj_index(void)\n {\n \tt_table_refs_for(1);\n }\n \n-static void t_write_empty_table(void)\n+void test_reftable_readwrite__write_empty_table(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_table *table = NULL;\n \tstruct reftable_ref_record rec = { 0 };\n@@ -639,43 +631,41 @@ static void t_write_empty_table(void)\n \n \treftable_writer_set_limits(w, 1, 1);\n \n-\terr = reftable_writer_close(w);\n-\tcheck_int(err, ==, REFTABLE_EMPTY_TABLE_ERROR);\n+\tcl_assert_equal_i(reftable_writer_close(w), REFTABLE_EMPTY_TABLE_ERROR);\n \treftable_writer_free(w);\n \n-\tcheck_uint(buf.len, ==, header_size(1) + footer_size(1));\n+\tcl_assert_equal_i(buf.len, header_size(1) + footer_size(1));\n \n \tblock_source_from_buf(&source, &buf);\n \n \terr = reftable_table_new(&table, &source, \"filename\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck_int(err, >, 0);\n+\tcl_assert(err > 0);\n \n \treftable_iterator_destroy(&it);\n \treftable_table_decref(table);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_object_id_min_length(void)\n+void test_reftable_readwrite__write_object_id_min_length(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 75,\n \t};\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_ref_record ref = {\n \t\t.update_index = 1,\n \t\t.value_type = REFTABLE_REF_VAL1,\n \t\t.value.val1 = {42},\n \t};\n-\tint err;\n \tint i;\n \n \treftable_writer_set_limits(w, 1, 1);\n@@ -686,30 +676,27 @@ static void t_write_object_id_min_length(void)\n \t\tchar name[256];\n \t\tsnprintf(name, sizeof(name), \"ref%05d\", i);\n \t\tref.refname = name;\n-\t\terr = reftable_writer_add_ref(w, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);\n \t}\n \n-\terr = reftable_writer_close(w);\n-\tcheck(!err);\n-\tcheck_int(reftable_writer_stats(w)->object_id_len, ==, 2);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n+\tcl_assert_equal_i(reftable_writer_stats(w)->object_id_len, 2);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_object_id_length(void)\n+void test_reftable_readwrite__write_object_id_length(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 75,\n \t};\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_ref_record ref = {\n \t\t.update_index = 1,\n \t\t.value_type = REFTABLE_REF_VAL1,\n \t\t.value.val1 = {42},\n \t};\n-\tint err;\n \tint i;\n \n \treftable_writer_set_limits(w, 1, 1);\n@@ -721,44 +708,39 @@ static void t_write_object_id_length(void)\n \t\tsnprintf(name, sizeof(name), \"ref%05d\", i);\n \t\tref.refname = name;\n \t\tref.value.val1[15] = i;\n-\t\terr = reftable_writer_add_ref(w, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert(reftable_writer_add_ref(w, &ref) == 0);\n \t}\n \n-\terr = reftable_writer_close(w);\n-\tcheck(!err);\n-\tcheck_int(reftable_writer_stats(w)->object_id_len, ==, 16);\n+\tcl_assert_equal_i(reftable_writer_close(w), 0);\n+\tcl_assert_equal_i(reftable_writer_stats(w)->object_id_len, 16);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_empty_key(void)\n+void test_reftable_readwrite__write_empty_key(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"\",\n \t\t.update_index = 1,\n \t\t.value_type = REFTABLE_REF_DELETION,\n \t};\n-\tint err;\n \n \treftable_writer_set_limits(w, 1, 1);\n-\terr = reftable_writer_add_ref(w, &ref);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n-\n-\terr = reftable_writer_close(w);\n-\tcheck_int(err, ==, REFTABLE_EMPTY_TABLE_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_ref(w, &ref), REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_writer_close(w),\n+\t\t\t REFTABLE_EMPTY_TABLE_ERROR);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_key_order(void)\n+void test_reftable_readwrite__write_key_order(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n-\tstruct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);\n+\tstruct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);\n \tstruct reftable_ref_record refs[2] = {\n \t\t{\n \t\t\t.refname = (char *) \"b\",\n@@ -776,24 +758,21 @@ static void t_write_key_order(void)\n \t\t\t},\n \t\t}\n \t};\n-\tint err;\n \n \treftable_writer_set_limits(w, 1, 1);\n-\terr = reftable_writer_add_ref(w, &refs[0]);\n-\tcheck(!err);\n-\terr = reftable_writer_add_ref(w, &refs[1]);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_ref(w, &refs[0]), 0);\n+\tcl_assert_equal_i(reftable_writer_add_ref(w, &refs[1]),\n+\t\t\t REFTABLE_API_ERROR);\n \n \trefs[0].update_index = 2;\n-\terr = reftable_writer_add_ref(w, &refs[0]);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_writer_add_ref(w, &refs[0]), REFTABLE_API_ERROR);\n \n \treftable_writer_close(w);\n \treftable_writer_free(w);\n \treftable_buf_release(&buf);\n }\n \n-static void t_write_multiple_indices(void)\n+void test_reftable_readwrite__write_multiple_indices(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 100,\n@@ -805,9 +784,10 @@ static void t_write_multiple_indices(void)\n \tstruct reftable_writer *writer;\n \tstruct reftable_table *table;\n \tchar buf[128];\n-\tint err, i;\n+\tint i;\n+\tint err;\n \n-\twriter = t_reftable_strbuf_writer(&writer_buf, &opts);\n+\twriter = cl_reftable_strbuf_writer(&writer_buf, &opts);\n \treftable_writer_set_limits(writer, 1, 1);\n \tfor (i = 0; i < 100; i++) {\n \t\tstruct reftable_ref_record ref = {\n@@ -819,8 +799,7 @@ static void t_write_multiple_indices(void)\n \t\tsnprintf(buf, sizeof(buf), \"refs/heads/%04d\", i);\n \t\tref.refname = buf;\n \n-\t\terr = reftable_writer_add_ref(writer, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(writer, &ref), 0);\n \t}\n \n \tfor (i = 0; i < 100; i++) {\n@@ -836,8 +815,7 @@ static void t_write_multiple_indices(void)\n \t\tsnprintf(buf, sizeof(buf), \"refs/heads/%04d\", i);\n \t\tlog.refname = buf;\n \n-\t\terr = reftable_writer_add_log(writer, &log);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_log(writer, &log), 0);\n \t}\n \n \treftable_writer_close(writer);\n@@ -847,22 +825,22 @@ static void t_write_multiple_indices(void)\n \t * for each of the block types.\n \t */\n \tstats = reftable_writer_stats(writer);\n-\tcheck_int(stats->ref_stats.index_offset, >, 0);\n-\tcheck_int(stats->obj_stats.index_offset, >, 0);\n-\tcheck_int(stats->log_stats.index_offset, >, 0);\n+\tcl_assert(stats->ref_stats.index_offset > 0);\n+\tcl_assert(stats->obj_stats.index_offset > 0);\n+\tcl_assert(stats->log_stats.index_offset > 0);\n \n \tblock_source_from_buf(&source, &writer_buf);\n \terr = reftable_table_new(&table, &source, \"filename\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \t/*\n \t * Seeking the log uses the log index now. In case there is any\n \t * confusion regarding indices we would notice here.\n \t */\n \terr = reftable_table_init_log_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_log(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \treftable_iterator_destroy(&it);\n \treftable_writer_free(writer);\n@@ -870,7 +848,7 @@ static void t_write_multiple_indices(void)\n \treftable_buf_release(&writer_buf);\n }\n \n-static void t_write_multi_level_index(void)\n+void test_reftable_readwrite__write_multi_level_index(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.block_size = 100,\n@@ -883,7 +861,7 @@ static void t_write_multi_level_index(void)\n \tstruct reftable_table *table;\n \tint err;\n \n-\twriter = t_reftable_strbuf_writer(&writer_buf, &opts);\n+\twriter = cl_reftable_strbuf_writer(&writer_buf, &opts);\n \treftable_writer_set_limits(writer, 1, 1);\n \tfor (size_t i = 0; i < 200; i++) {\n \t\tstruct reftable_ref_record ref = {\n@@ -896,8 +874,7 @@ static void t_write_multi_level_index(void)\n \t\tsnprintf(buf, sizeof(buf), \"refs/heads/%03\" PRIuMAX, (uintmax_t)i);\n \t\tref.refname = buf;\n \n-\t\terr = reftable_writer_add_ref(writer, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_writer_add_ref(writer, &ref), 0);\n \t}\n \treftable_writer_close(writer);\n \n@@ -906,19 +883,19 @@ static void t_write_multi_level_index(void)\n \t * multi-level index.\n \t */\n \tstats = reftable_writer_stats(writer);\n-\tcheck_int(stats->ref_stats.max_index_level, ==, 2);\n+\tcl_assert_equal_i(stats->ref_stats.max_index_level, 2);\n \n \tblock_source_from_buf(&source, &writer_buf);\n \terr = reftable_table_new(&table, &source, \"filename\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \t/*\n \t * Seeking the last ref should work as expected.\n \t */\n \terr = reftable_table_init_ref_iterator(table, &it);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \terr = reftable_iterator_seek_ref(&it, \"refs/heads/199\");\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \treftable_iterator_destroy(&it);\n \treftable_writer_free(writer);\n@@ -927,7 +904,7 @@ static void t_write_multi_level_index(void)\n \treftable_buf_release(&buf);\n }\n \n-static void t_corrupt_table_empty(void)\n+void test_reftable_readwrite__corrupt_table_empty(void)\n {\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tstruct reftable_block_source source = { 0 };\n@@ -936,50 +913,22 @@ static void t_corrupt_table_empty(void)\n \n \tblock_source_from_buf(&source, &buf);\n \terr = reftable_table_new(&table, &source, \"file.log\");\n-\tcheck_int(err, ==, REFTABLE_FORMAT_ERROR);\n+\tcl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);\n }\n \n-static void t_corrupt_table(void)\n+void test_reftable_readwrite__corrupt_table(void)\n {\n \tuint8_t zeros[1024] = { 0 };\n \tstruct reftable_buf buf = REFTABLE_BUF_INIT;\n \tstruct reftable_block_source source = { 0 };\n \tstruct reftable_table *table;\n \tint err;\n-\tcheck(!reftable_buf_add(&buf, zeros, sizeof(zeros)));\n+\n+\tcl_assert(!reftable_buf_add(&buf, zeros, sizeof(zeros)));\n \n \tblock_source_from_buf(&source, &buf);\n \terr = reftable_table_new(&table, &source, \"file.log\");\n-\tcheck_int(err, ==, REFTABLE_FORMAT_ERROR);\n+\tcl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);\n \n \treftable_buf_release(&buf);\n }\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_buffer(), \"strbuf works as blocksource\");\n-\tTEST(t_corrupt_table(), \"read-write on corrupted table\");\n-\tTEST(t_corrupt_table_empty(), \"read-write on an empty table\");\n-\tTEST(t_log_buffer_size(), \"buffer extension for log compression\");\n-\tTEST(t_log_overflow(), \"log overflow returns expected error\");\n-\tTEST(t_log_write_limits(), \"writer limits for writing log records\");\n-\tTEST(t_log_write_read(), \"read-write on log records\");\n-\tTEST(t_log_zlib_corruption(), \"reading corrupted log record returns expected error\");\n-\tTEST(t_table_read_api(), \"read on a table\");\n-\tTEST(t_table_read_write_seek_index(), \"read-write on a table with index\");\n-\tTEST(t_table_read_write_seek_linear(), \"read-write on a table without index (SHA1)\");\n-\tTEST(t_table_read_write_seek_linear_sha256(), \"read-write on a table without index (SHA256)\");\n-\tTEST(t_table_read_write_sequential(), \"sequential read-write on a table\");\n-\tTEST(t_table_refs_for_no_index(), \"refs-only table with no index\");\n-\tTEST(t_table_refs_for_obj_index(), \"refs-only table with index\");\n-\tTEST(t_table_write_small_table(), \"write_table works\");\n-\tTEST(t_write_empty_key(), \"write on refs with empty keys\");\n-\tTEST(t_write_empty_table(), \"read-write on empty tables\");\n-\tTEST(t_write_key_order(), \"refs must be written in increasing order\");\n-\tTEST(t_write_multi_level_index(), \"table with multi-level index\");\n-\tTEST(t_write_multiple_indices(), \"table with indices for multiple block types\");\n-\tTEST(t_write_object_id_length(), \"prefix compression on writing refs\");\n-\tTEST(t_write_object_id_min_length(), \"prefix compression on writing refs\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"522676","messageId":"20250724142837.67149-9-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250724142837.67149-1-kuforiji98@gmail.com","subject":"[PATCH v5 08/10] t/unit-tests: convert reftable record test to use clar","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T14:28:35Z","receivedAt":"2025-07-24T14:30:38Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kuforiji \n\nAdapt reftable record test file to use clar by using clar assertions\nwhere necessary.\n\nSigned-off-by: Seyi Kuforiji \nSigned-off-by: Junio C Hamano \n---\n Makefile | 1 -\n t/meson.build | 2 +-\n ...-reftable-record.c => u-reftable-record.c} | 250 +++++++++---------\n 3 files changed, 131 insertions(+), 122 deletions(-)\n rename t/unit-tests/{t-reftable-record.c => u-reftable-record.c} (62%)\n\ndiff --git a/Makefile b/Makefile\nindex 1c91787b6a..dd0bc2642d 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1383,7 +1383,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-record\n UNIT_TEST_PROGRAMS += t-reftable-stack\n UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\ndiff --git a/t/meson.build b/t/meson.build\nindex 5189176472..a15b396e42 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -13,6 +13,7 @@ clar_test_suites = [\n 'unit-tests/u-reftable-merged.c',\n 'unit-tests/u-reftable-pq.c',\n 'unit-tests/u-reftable-readwrite.c',\n+ 'unit-tests/u-reftable-record.c',\n 'unit-tests/u-reftable-table.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n@@ -61,7 +62,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-record.c',\n 'unit-tests/t-reftable-stack.c',\n ]\n \ndiff --git a/t/unit-tests/t-reftable-record.c b/t/unit-tests/u-reftable-record.c\nsimilarity index 62%\nrename from t/unit-tests/t-reftable-record.c\nrename to t/unit-tests/u-reftable-record.c\nindex 553a007664..650b0aa0d3 100644\n--- a/t/unit-tests/t-reftable-record.c\n+++ b/t/unit-tests/u-reftable-record.c\n@@ -6,7 +6,8 @@\n https://developers.google.com/open-source/licenses/bsd\n */\n \n-#include \"test-lib.h\"\n+#include \"unit-test.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/basics.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/record.h\"\n@@ -17,16 +18,17 @@ static void t_copy(struct reftable_record *rec)\n \tuint8_t typ;\n \n \ttyp = reftable_record_type(rec);\n-\tcheck(!reftable_record_init(©, typ));\n+\tcl_assert_equal_i(reftable_record_init(©, typ), 0);\n \treftable_record_copy_from(©, rec, REFTABLE_HASH_SIZE_SHA1);\n \t/* do it twice to catch memory leaks */\n \treftable_record_copy_from(©, rec, REFTABLE_HASH_SIZE_SHA1);\n-\tcheck(reftable_record_equal(rec, ©, REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert(reftable_record_equal(rec, ©,\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n \n \treftable_record_release(©);\n }\n \n-static void t_varint_roundtrip(void)\n+void test_reftable_record__varint_roundtrip(void)\n {\n \tuint64_t inputs[] = { 0,\n \t\t\t 1,\n@@ -49,16 +51,16 @@ static void t_varint_roundtrip(void)\n \t\tint n = put_var_int(&out, in);\n \t\tuint64_t got = 0;\n \n-\t\tcheck_int(n, >, 0);\n+\t\tcl_assert(n > 0);\n \t\tout.len = n;\n \t\tn = get_var_int(&got, &out);\n-\t\tcheck_int(n, >, 0);\n+\t\tcl_assert(n > 0);\n \n-\t\tcheck_int(got, ==, in);\n+\t\tcl_assert_equal_i(got, in);\n \t}\n }\n \n-static void t_varint_overflow(void)\n+void test_reftable_record__varint_overflow(void)\n {\n \tunsigned char buf[] = {\n \t\t0xFF, 0xFF, 0xFF, 0xFF,\n@@ -70,8 +72,7 @@ static void t_varint_overflow(void)\n \t\t.len = sizeof(buf),\n \t};\n \tuint64_t value;\n-\tint err = get_var_int(&value, &view);\n-\tcheck_int(err, ==, -1);\n+\tcl_assert_equal_i(get_var_int(&value, &view), -1);\n }\n \n static void set_hash(uint8_t *h, int j)\n@@ -80,7 +81,7 @@ static void set_hash(uint8_t *h, int j)\n \t\th[i] = (j >> i) & 0xff;\n }\n \n-static void t_reftable_ref_record_comparison(void)\n+void test_reftable_record__ref_record_comparison(void)\n {\n \tstruct reftable_record in[3] = {\n \t\t{\n@@ -102,21 +103,23 @@ static void t_reftable_ref_record_comparison(void)\n \t};\n \tint cmp;\n \n-\tcheck(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n \n-\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n-\tcheck_int(cmp, >, 0);\n+\tcl_assert(reftable_record_equal(&in[1], &in[2],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) == 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n+\tcl_assert(cmp > 0);\n \n \tin[1].u.ref.value_type = in[0].u.ref.value_type;\n-\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n }\n \n-static void t_reftable_ref_record_compare_name(void)\n+void test_reftable_record__ref_record_compare_name(void)\n {\n \tstruct reftable_ref_record recs[3] = {\n \t\t{\n@@ -130,12 +133,15 @@ static void t_reftable_ref_record_compare_name(void)\n \t\t},\n \t};\n \n-\tcheck_int(reftable_ref_record_compare_name(&recs[0], &recs[1]), <, 0);\n-\tcheck_int(reftable_ref_record_compare_name(&recs[1], &recs[0]), >, 0);\n-\tcheck_int(reftable_ref_record_compare_name(&recs[0], &recs[2]), ==, 0);\n+\tcl_assert(reftable_ref_record_compare_name(&recs[0],\n+\t\t\t\t\t\t &recs[1]) < 0);\n+\tcl_assert(reftable_ref_record_compare_name(&recs[1],\n+\t\t\t\t\t\t &recs[0]) > 0);\n+\tcl_assert_equal_i(reftable_ref_record_compare_name(&recs[0],\n+\t\t\t\t\t\t\t &recs[2]), 0);\n }\n \n-static void t_reftable_ref_record_roundtrip(void)\n+void test_reftable_record__ref_record_roundtrip(void)\n {\n \tstruct reftable_buf scratch = REFTABLE_BUF_INIT;\n \n@@ -172,19 +178,21 @@ static void t_reftable_ref_record_roundtrip(void)\n \n \t\tt_copy(&in);\n \n-\t\tcheck_int(reftable_record_val_type(&in), ==, i);\n-\t\tcheck_int(reftable_record_is_deletion(&in), ==, i == REFTABLE_REF_DELETION);\n+\t\tcl_assert_equal_i(reftable_record_val_type(&in), i);\n+\t\tcl_assert_equal_i(reftable_record_is_deletion(&in),\n+\t\t\t\t i == REFTABLE_REF_DELETION);\n \n \t\treftable_record_key(&in, &key);\n \t\tn = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck_int(n, >, 0);\n+\t\tcl_assert(n > 0);\n \n \t\t/* decode into a non-zero reftable_record to test for leaks. */\n \t\tm = reftable_record_decode(&out, key, i, dest, REFTABLE_HASH_SIZE_SHA1, &scratch);\n-\t\tcheck_int(n, ==, m);\n+\t\tcl_assert_equal_i(n, m);\n \n-\t\tcheck(reftable_ref_record_equal(&in.u.ref, &out.u.ref,\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_ref_record_equal(&in.u.ref,\n+\t\t\t\t\t\t &out.u.ref,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_record_release(&in);\n \n \t\treftable_buf_release(&key);\n@@ -194,7 +202,7 @@ static void t_reftable_ref_record_roundtrip(void)\n \treftable_buf_release(&scratch);\n }\n \n-static void t_reftable_log_record_comparison(void)\n+void test_reftable_record__log_record_comparison(void)\n {\n \tstruct reftable_record in[3] = {\n \t\t{\n@@ -215,21 +223,24 @@ static void t_reftable_log_record_comparison(void)\n \t};\n \tint cmp;\n \n-\tcheck(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n-\tcheck_int(cmp, >, 0);\n+\tcl_assert_equal_i(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_equal(&in[1], &in[2],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n+\tcl_assert(cmp > 0);\n \t/* comparison should be reversed for equal keys, because\n \t * comparison is now performed on the basis of update indices */\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck_int(cmp, <, 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(cmp < 0);\n \n \tin[1].u.log.update_index = in[0].u.log.update_index;\n-\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n+\tcl_assert(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n }\n \n-static void t_reftable_log_record_compare_key(void)\n+void test_reftable_record__log_record_compare_key(void)\n {\n \tstruct reftable_log_record logs[3] = {\n \t\t{\n@@ -246,19 +257,24 @@ static void t_reftable_log_record_compare_key(void)\n \t\t},\n \t};\n \n-\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[1]), <, 0);\n-\tcheck_int(reftable_log_record_compare_key(&logs[1], &logs[0]), >, 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[0],\n+\t\t\t\t\t\t &logs[1]) < 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[1],\n+\t\t\t\t\t\t &logs[0]) > 0);\n \n \tlogs[1].update_index = logs[0].update_index;\n-\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[1]), <, 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[0],\n+\t\t\t\t\t\t &logs[1]) < 0);\n \n-\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[2]), >, 0);\n-\tcheck_int(reftable_log_record_compare_key(&logs[2], &logs[0]), <, 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[0],\n+\t\t\t\t\t\t &logs[2]) > 0);\n+\tcl_assert(reftable_log_record_compare_key(&logs[2],\n+\t\t\t\t\t\t &logs[0]) < 0);\n \tlogs[2].update_index = logs[0].update_index;\n-\tcheck_int(reftable_log_record_compare_key(&logs[0], &logs[2]), ==, 0);\n+\tcl_assert_equal_i(reftable_log_record_compare_key(&logs[0], &logs[2]), 0);\n }\n \n-static void t_reftable_log_record_roundtrip(void)\n+void test_reftable_record__log_record_roundtrip(void)\n {\n \tstruct reftable_log_record in[] = {\n \t\t{\n@@ -292,9 +308,9 @@ static void t_reftable_log_record_roundtrip(void)\n \tset_hash(in[2].value.update.new_hash, 3);\n \tset_hash(in[2].value.update.old_hash, 4);\n \n-\tcheck(!reftable_log_record_is_deletion(&in[0]));\n-\tcheck(reftable_log_record_is_deletion(&in[1]));\n-\tcheck(!reftable_log_record_is_deletion(&in[2]));\n+\tcl_assert_equal_i(reftable_log_record_is_deletion(&in[0]), 0);\n+\tcl_assert(reftable_log_record_is_deletion(&in[1]) != 0);\n+\tcl_assert_equal_i(reftable_log_record_is_deletion(&in[2]), 0);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(in); i++) {\n \t\tstruct reftable_record rec = { .type = REFTABLE_BLOCK_TYPE_LOG };\n@@ -328,14 +344,14 @@ static void t_reftable_log_record_roundtrip(void)\n \t\treftable_record_key(&rec, &key);\n \n \t\tn = reftable_record_encode(&rec, dest, REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck_int(n, >=, 0);\n+\t\tcl_assert(n >= 0);\n \t\tvaltype = reftable_record_val_type(&rec);\n \t\tm = reftable_record_decode(&out, key, valtype, dest,\n \t\t\t\t\t REFTABLE_HASH_SIZE_SHA1, &scratch);\n-\t\tcheck_int(n, ==, m);\n+\t\tcl_assert_equal_i(n, m);\n \n-\t\tcheck(reftable_log_record_equal(&in[i], &out.u.log,\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_log_record_equal(&in[i], &out.u.log,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_log_record_release(&in[i]);\n \t\treftable_buf_release(&key);\n \t\treftable_record_release(&out);\n@@ -344,7 +360,7 @@ static void t_reftable_log_record_roundtrip(void)\n \treftable_buf_release(&scratch);\n }\n \n-static void t_key_roundtrip(void)\n+void test_reftable_record__key_roundtrip(void)\n {\n \tuint8_t buffer[1024] = { 0 };\n \tstruct string_view dest = {\n@@ -359,25 +375,28 @@ static void t_key_roundtrip(void)\n \tint n, m;\n \tuint8_t rt_extra;\n \n-\tcheck(!reftable_buf_addstr(&last_key, \"refs/heads/master\"));\n-\tcheck(!reftable_buf_addstr(&key, \"refs/tags/bla\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&last_key,\n+\t\t\t\t\t \"refs/heads/master\"), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&key,\n+\t\t\t\t\t \"refs/tags/bla\"), 0);\n \textra = 6;\n \tn = reftable_encode_key(&restart, dest, last_key, key, extra);\n-\tcheck(!restart);\n-\tcheck_int(n, >, 0);\n+\tcl_assert(!restart);\n+\tcl_assert(n > 0);\n \n-\tcheck(!reftable_buf_addstr(&roundtrip, \"refs/heads/master\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&roundtrip,\n+\t\t\t\t\t \"refs/heads/master\"), 0);\n \tm = reftable_decode_key(&roundtrip, &rt_extra, dest);\n-\tcheck_int(n, ==, m);\n-\tcheck(!reftable_buf_cmp(&key, &roundtrip));\n-\tcheck_int(rt_extra, ==, extra);\n+\tcl_assert_equal_i(n, m);\n+\tcl_assert_equal_i(reftable_buf_cmp(&key, &roundtrip), 0);\n+\tcl_assert_equal_i(rt_extra, extra);\n \n \treftable_buf_release(&last_key);\n \treftable_buf_release(&key);\n \treftable_buf_release(&roundtrip);\n }\n \n-static void t_reftable_obj_record_comparison(void)\n+void test_reftable_record__obj_record_comparison(void)\n {\n \n \tuint8_t id_bytes[] = { 0, 1, 2, 3, 4, 5, 6 };\n@@ -405,21 +424,23 @@ static void t_reftable_obj_record_comparison(void)\n \t};\n \tint cmp;\n \n-\tcheck(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert_equal_i(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n \n-\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n-\tcheck_int(cmp, >, 0);\n+\tcl_assert_equal_i(reftable_record_equal(&in[1], &in[2],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n+\tcl_assert(cmp > 0);\n \n \tin[1].u.obj.offset_len = in[0].u.obj.offset_len;\n-\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n }\n \n-static void t_reftable_obj_record_roundtrip(void)\n+void test_reftable_record__obj_record_roundtrip(void)\n {\n \tuint8_t testHash1[REFTABLE_HASH_SIZE_SHA1] = { 1, 2, 3, 4, 0 };\n \tuint64_t till9[] = { 1, 2, 3, 4, 500, 600, 700, 800, 9000 };\n@@ -460,17 +481,18 @@ static void t_reftable_obj_record_roundtrip(void)\n \t\tint n, m;\n \t\tuint8_t extra;\n \n-\t\tcheck(!reftable_record_is_deletion(&in));\n+\t\tcl_assert_equal_i(reftable_record_is_deletion(&in), 0);\n \t\tt_copy(&in);\n \t\treftable_record_key(&in, &key);\n \t\tn = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);\n-\t\tcheck_int(n, >, 0);\n+\t\tcl_assert(n > 0);\n \t\textra = reftable_record_val_type(&in);\n \t\tm = reftable_record_decode(&out, key, extra, dest,\n \t\t\t\t\t REFTABLE_HASH_SIZE_SHA1, &scratch);\n-\t\tcheck_int(n, ==, m);\n+\t\tcl_assert_equal_i(n, m);\n \n-\t\tcheck(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(reftable_record_equal(&in, &out,\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_buf_release(&key);\n \t\treftable_record_release(&out);\n \t}\n@@ -478,7 +500,7 @@ static void t_reftable_obj_record_roundtrip(void)\n \treftable_buf_release(&scratch);\n }\n \n-static void t_reftable_index_record_comparison(void)\n+void test_reftable_record__index_record_comparison(void)\n {\n \tstruct reftable_record in[3] = {\n \t\t{\n@@ -499,28 +521,33 @@ static void t_reftable_index_record_comparison(void)\n \t};\n \tint cmp;\n \n-\tcheck(!reftable_buf_addstr(&in[0].u.idx.last_key, \"refs/heads/master\"));\n-\tcheck(!reftable_buf_addstr(&in[1].u.idx.last_key, \"refs/heads/master\"));\n-\tcheck(!reftable_buf_addstr(&in[2].u.idx.last_key, \"refs/heads/branch\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&in[0].u.idx.last_key,\n+\t\t\t\t\t \"refs/heads/master\"), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&in[1].u.idx.last_key, \"refs/heads/master\"), 0);\n+\tcl_assert(reftable_buf_addstr(&in[2].u.idx.last_key,\n+\t\t\t\t \"refs/heads/branch\") == 0);\n \n-\tcheck(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert_equal_i(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n \n-\tcheck(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[1], &in[2], &cmp));\n-\tcheck_int(cmp, >, 0);\n+\tcl_assert_equal_i(reftable_record_equal(&in[1], &in[2],\n+\t\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1), 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[1], &in[2], &cmp), 0);\n+\tcl_assert(cmp > 0);\n \n \tin[1].u.idx.offset = in[0].u.idx.offset;\n-\tcheck(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));\n-\tcheck(!reftable_record_cmp(&in[0], &in[1], &cmp));\n-\tcheck(!cmp);\n+\tcl_assert(reftable_record_equal(&in[0], &in[1],\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n+\tcl_assert_equal_i(reftable_record_cmp(&in[0], &in[1], &cmp), 0);\n+\tcl_assert(!cmp);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(in); i++)\n \t\treftable_record_release(&in[i]);\n }\n \n-static void t_reftable_index_record_roundtrip(void)\n+void test_reftable_record__index_record_roundtrip(void)\n {\n \tstruct reftable_record in = {\n \t\t.type = REFTABLE_BLOCK_TYPE_INDEX,\n@@ -543,43 +570,26 @@ static void t_reftable_index_record_roundtrip(void)\n \tint n, m;\n \tuint8_t extra;\n \n-\tcheck(!reftable_buf_addstr(&in.u.idx.last_key, \"refs/heads/master\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&in.u.idx.last_key,\n+\t\t\t\t\t \"refs/heads/master\"), 0);\n \treftable_record_key(&in, &key);\n \tt_copy(&in);\n \n-\tcheck(!reftable_record_is_deletion(&in));\n-\tcheck(!reftable_buf_cmp(&key, &in.u.idx.last_key));\n+\tcl_assert_equal_i(reftable_record_is_deletion(&in), 0);\n+\tcl_assert_equal_i(reftable_buf_cmp(&key, &in.u.idx.last_key), 0);\n \tn = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);\n-\tcheck_int(n, >, 0);\n+\tcl_assert(n > 0);\n \n \textra = reftable_record_val_type(&in);\n-\tm = reftable_record_decode(&out, key, extra, dest, REFTABLE_HASH_SIZE_SHA1,\n-\t\t\t\t &scratch);\n-\tcheck_int(m, ==, n);\n+\tm = reftable_record_decode(&out, key, extra, dest,\n+\t\t\t\t REFTABLE_HASH_SIZE_SHA1, &scratch);\n+\tcl_assert_equal_i(m, n);\n \n-\tcheck(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert(reftable_record_equal(&in, &out,\n+\t\t\t\t\tREFTABLE_HASH_SIZE_SHA1) != 0);\n \n \treftable_record_release(&out);\n \treftable_buf_release(&key);\n \treftable_buf_release(&scratch);\n \treftable_buf_release(&in.u.idx.last_key);\n }\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_reftable_ref_record_comparison(), \"comparison operations work on ref record\");\n-\tTEST(t_reftable_log_record_comparison(), \"comparison operations work on log record\");\n-\tTEST(t_reftable_index_record_comparison(), \"comparison operations work on index record\");\n-\tTEST(t_reftable_obj_record_comparison(), \"comparison operations work on obj record\");\n-\tTEST(t_reftable_ref_record_compare_name(), \"reftable_ref_record_compare_name works\");\n-\tTEST(t_reftable_log_record_compare_key(), \"reftable_log_record_compare_key works\");\n-\tTEST(t_reftable_log_record_roundtrip(), \"record operations work on log record\");\n-\tTEST(t_reftable_ref_record_roundtrip(), \"record operations work on ref record\");\n-\tTEST(t_varint_roundtrip(), \"put_var_int and get_var_int work\");\n-\tTEST(t_varint_overflow(), \"get_var_int notices an integer overflow\");\n-\tTEST(t_key_roundtrip(), \"reftable_encode_key and reftable_decode_key work\");\n-\tTEST(t_reftable_obj_record_roundtrip(), \"record operations work on obj record\");\n-\tTEST(t_reftable_index_record_roundtrip(), \"record operations work on index record\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"522677","messageId":"20250724142837.67149-10-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250724142837.67149-1-kuforiji98@gmail.com","subject":"[PATCH v5 09/10] t/unit-tests: convert reftable stack test to use clar","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T14:28:36Z","receivedAt":"2025-07-24T14:30:43Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kuforiji \n\nAdapt reftable stack test file to use clar by using clar assertions\nwhere necessary.\n\nThis marks the end of all unit tests migrated away from the\n`unit-tests/t-*.c` pattern, there are no longer any files matching that\nglob. Remove the sanity check for `t-*.c` files to prevent Meson\nconfiguration errors during CI and local builds.\n\nSigned-off-by: Seyi Kuforiji \nSigned-off-by: Junio C Hamano \n---\n Makefile | 2 +-\n t/meson.build | 4 +-\n ...{t-reftable-stack.c => u-reftable-stack.c} | 780 ++++++++----------\n 3 files changed, 332 insertions(+), 454 deletions(-)\n rename t/unit-tests/{t-reftable-stack.c => u-reftable-stack.c} (59%)\n\ndiff --git a/Makefile b/Makefile\nindex dd0bc2642d..cbbb2ec05a 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1369,6 +1369,7 @@ CLAR_TEST_SUITES += u-reftable-block\n CLAR_TEST_SUITES += u-reftable-merged\n CLAR_TEST_SUITES += u-reftable-pq\n CLAR_TEST_SUITES += u-reftable-readwrite\n+CLAR_TEST_SUITES += u-reftable-stack\n CLAR_TEST_SUITES += u-reftable-table\n CLAR_TEST_SUITES += u-reftable-tree\n CLAR_TEST_SUITES += u-strbuf\n@@ -1383,7 +1384,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n \n-UNIT_TEST_PROGRAMS += t-reftable-stack\n UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o\ndiff --git a/t/meson.build b/t/meson.build\nindex a15b396e42..fcbb659263 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -14,6 +14,7 @@ clar_test_suites = [\n 'unit-tests/u-reftable-pq.c',\n 'unit-tests/u-reftable-readwrite.c',\n 'unit-tests/u-reftable-record.c',\n+ 'unit-tests/u-reftable-stack.c',\n 'unit-tests/u-reftable-table.c',\n 'unit-tests/u-reftable-tree.c',\n 'unit-tests/u-strbuf.c',\n@@ -62,7 +63,6 @@ clar_unit_tests = executable('unit-tests',\n test('unit-tests', clar_unit_tests)\n \n unit_test_programs = [\n- 'unit-tests/t-reftable-stack.c',\n ]\n \n foreach unit_test_program : unit_test_programs\n@@ -1164,8 +1164,6 @@ benchmarks = [\n # sufficient to catch missing test suites in our CI though.\n foreach glob, tests : {\n 't[0-9][0-9][0-9][0-9]-*.sh': integration_tests,\n- 'perf/p[0-9][0-9][0-9][0-9]-*.sh': benchmarks,\n- 'unit-tests/t-*.c': unit_test_programs,\n 'unit-tests/u-*.c': clar_test_suites,\n }\n actual_tests = run_command(shell, '-c', 'ls ' + glob,\ndiff --git a/t/unit-tests/t-reftable-stack.c b/t/unit-tests/u-reftable-stack.c\nsimilarity index 59%\nrename from t/unit-tests/t-reftable-stack.c\nrename to t/unit-tests/u-reftable-stack.c\nindex 2f49c97519..0e3e3f4f4a 100644\n--- a/t/unit-tests/t-reftable-stack.c\n+++ b/t/unit-tests/u-reftable-stack.c\n@@ -8,9 +8,9 @@ license that can be found in the LICENSE file or at\n \n #define DISABLE_SIGN_COMPARE_WARNINGS\n \n-#include \"test-lib.h\"\n-#include \"lib-reftable.h\"\n+#include \"unit-test.h\"\n #include \"dir.h\"\n+#include \"lib-reftable-clar.h\"\n #include \"reftable/merged.h\"\n #include \"reftable/reftable-error.h\"\n #include \"reftable/stack.h\"\n@@ -70,11 +70,11 @@ static char *get_tmp_template(int linenumber)\n static char *get_tmp_dir(int linenumber)\n {\n \tchar *dir = get_tmp_template(linenumber);\n-\tcheck(mkdtemp(dir) != NULL);\n+\tcl_assert(mkdtemp(dir) != NULL);\n \treturn dir;\n }\n \n-static void t_read_file(void)\n+void test_reftable_stack__read_file(void)\n {\n \tchar *fn = get_tmp_template(__LINE__);\n \tstruct tempfile *tmp = mks_tempfile(fn);\n@@ -84,17 +84,17 @@ static void t_read_file(void)\n \tchar **names = NULL;\n \tconst char *want[] = { \"line1\", \"line2\", \"line3\" };\n \n-\tcheck_int(fd, >, 0);\n+\tcl_assert(fd > 0);\n \tn = write_in_full(fd, out, strlen(out));\n-\tcheck_int(n, ==, strlen(out));\n+\tcl_assert_equal_i(n, strlen(out));\n \terr = close(fd);\n-\tcheck_int(err, >=, 0);\n+\tcl_assert(err >= 0);\n \n \terr = read_lines(fn, &names);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (size_t i = 0; names[i]; i++)\n-\t\tcheck_str(want[i], names[i]);\n+\t\tcl_assert_equal_s(want[i], names[i]);\n \tfree_names(names);\n \t(void) remove(fn);\n \tdelete_tempfile(&tmp);\n@@ -103,8 +103,8 @@ static void t_read_file(void)\n static int write_test_ref(struct reftable_writer *wr, void *arg)\n {\n \tstruct reftable_ref_record *ref = arg;\n-\tcheck(!reftable_writer_set_limits(wr, ref->update_index,\n-\t\t\t\t\t ref->update_index));\n+\tcl_assert_equal_i(reftable_writer_set_limits(wr,\n+\t\t\t\t\t\t ref->update_index, ref->update_index), 0);\n \treturn reftable_writer_add_ref(wr, ref);\n }\n \n@@ -112,7 +112,6 @@ static void write_n_ref_tables(struct reftable_stack *st,\n \t\t\t size_t n)\n {\n \tint disable_auto_compact;\n-\tint err;\n \n \tdisable_auto_compact = st->opts.disable_auto_compact;\n \tst->opts.disable_auto_compact = 1;\n@@ -126,10 +125,10 @@ static void write_n_ref_tables(struct reftable_stack *st,\n \n \t\tsnprintf(buf, sizeof(buf), \"refs/heads/branch-%04\"PRIuMAX, (uintmax_t)i);\n \t\tref.refname = buf;\n-\t\tt_reftable_set_hash(ref.value.val1, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(ref.value.val1, i, REFTABLE_HASH_SHA1);\n \n-\t\terr = reftable_stack_add(st, &write_test_ref, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t &write_test_ref, &ref), 0);\n \t}\n \n \tst->opts.disable_auto_compact = disable_auto_compact;\n@@ -144,12 +143,13 @@ static int write_test_log(struct reftable_writer *wr, void *arg)\n {\n \tstruct write_log_arg *wla = arg;\n \n-\tcheck(!reftable_writer_set_limits(wr, wla->update_index,\n-\t\t\t\t\t wla->update_index));\n+\tcl_assert_equal_i(reftable_writer_set_limits(wr,\n+\t\t\t\t\t\t wla->update_index,\n+\t\t\t\t\t\t wla->update_index), 0);\n \treturn reftable_writer_add_log(wr, wla->log);\n }\n \n-static void t_reftable_stack_add_one(void)\n+void test_reftable_stack__add_one(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_buf scratch = REFTABLE_BUF_INIT;\n@@ -158,7 +158,6 @@ static void t_reftable_stack_add_one(void)\n \t\t.default_permissions = 0660,\n \t};\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"HEAD\",\n \t\t.update_index = 1,\n@@ -167,32 +166,37 @@ static void t_reftable_stack_add_one(void)\n \t};\n \tstruct reftable_ref_record dest = { 0 };\n \tstruct stat stat_result = { 0 };\n+\tint err;\n+\n \terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_stack_add(st, write_test_ref, &ref);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \terr = reftable_stack_read_ref(st, ref.refname, &dest);\n-\tcheck(!err);\n-\tcheck(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));\n-\tcheck_int(st->tables_len, >, 0);\n+\tcl_assert(!err);\n+\tcl_assert(reftable_ref_record_equal(&ref, &dest,\n+\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert(st->tables_len > 0);\n \n #ifndef GIT_WINDOWS_NATIVE\n-\tcheck(!reftable_buf_addstr(&scratch, dir));\n-\tcheck(!reftable_buf_addstr(&scratch, \"/tables.list\"));\n-\terr = stat(scratch.buf, &stat_result);\n-\tcheck(!err);\n-\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n+\tcl_assert_equal_i(reftable_buf_addstr(&scratch, dir), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&scratch,\n+\t\t\t\t\t \"/tables.list\"), 0);\n+\tcl_assert_equal_i(stat(scratch.buf, &stat_result), 0);\n+\tcl_assert_equal_i((stat_result.st_mode & 0777),\n+\t\t\t opts.default_permissions);\n \n \treftable_buf_reset(&scratch);\n-\tcheck(!reftable_buf_addstr(&scratch, dir));\n-\tcheck(!reftable_buf_addstr(&scratch, \"/\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&scratch, dir), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&scratch, \"/\"), 0);\n \t/* do not try at home; not an external API for reftable. */\n-\tcheck(!reftable_buf_addstr(&scratch, st->tables[0]->name));\n+\tcl_assert(!reftable_buf_addstr(&scratch, st->tables[0]->name));\n \terr = stat(scratch.buf, &stat_result);\n-\tcheck(!err);\n-\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i((stat_result.st_mode & 0777),\n+\t\t\t opts.default_permissions);\n #else\n \t(void) stat_result;\n #endif\n@@ -204,14 +208,13 @@ static void t_reftable_stack_add_one(void)\n \tumask(mask);\n }\n \n-static void t_reftable_stack_uptodate(void)\n+void test_reftable_stack__uptodate(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st1 = NULL;\n \tstruct reftable_stack *st2 = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n \n-\tint err;\n \tstruct reftable_ref_record ref1 = {\n \t\t.refname = (char *) \"HEAD\",\n \t\t.update_index = 1,\n@@ -229,34 +232,25 @@ static void t_reftable_stack_uptodate(void)\n \t/* simulate multi-process access to the same stack\n \t by creating two stacks for the same directory.\n \t */\n-\terr = reftable_new_stack(&st1, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st1, write_test_ref, &ref1);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st2, write_test_ref, &ref2);\n-\tcheck_int(err, ==, REFTABLE_OUTDATED_ERROR);\n-\n-\terr = reftable_stack_reload(st2);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st2, write_test_ref, &ref2);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st1, write_test_ref,\n+\t\t\t\t\t &ref1), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st2, write_test_ref,\n+\t\t\t\t\t &ref2), REFTABLE_OUTDATED_ERROR);\n+\tcl_assert_equal_i(reftable_stack_reload(st2), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st2, write_test_ref,\n+\t\t\t\t\t &ref2), 0);\n \treftable_stack_destroy(st1);\n \treftable_stack_destroy(st2);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_transaction_api(void)\n+void test_reftable_stack__transaction_api(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tstruct reftable_addition *add = NULL;\n \n \tstruct reftable_ref_record ref = {\n@@ -267,37 +261,32 @@ static void t_reftable_stack_transaction_api(void)\n \t};\n \tstruct reftable_ref_record dest = { 0 };\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \treftable_addition_destroy(add);\n \n-\terr = reftable_stack_new_addition(&add, st, 0);\n-\tcheck(!err);\n-\n-\terr = reftable_addition_add(add, write_test_ref, &ref);\n-\tcheck(!err);\n-\n-\terr = reftable_addition_commit(add);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st, 0), 0);\n+\tcl_assert_equal_i(reftable_addition_add(add, write_test_ref,\n+\t\t\t\t\t\t&ref), 0);\n+\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \n \treftable_addition_destroy(add);\n \n-\terr = reftable_stack_read_ref(st, ref.refname, &dest);\n-\tcheck(!err);\n-\tcheck_int(REFTABLE_REF_SYMREF, ==, dest.value_type);\n-\tcheck(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert_equal_i(reftable_stack_read_ref(st, ref.refname,\n+\t\t\t\t\t\t &dest), 0);\n+\tcl_assert_equal_i(REFTABLE_REF_SYMREF, dest.value_type);\n+\tcl_assert(reftable_ref_record_equal(&ref, &dest,\n+\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \n \treftable_ref_record_release(&dest);\n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_transaction_with_reload(void)\n+void test_reftable_stack__transaction_with_reload(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_stack *st1 = NULL, *st2 = NULL;\n-\tint err;\n \tstruct reftable_addition *add = NULL;\n \tstruct reftable_ref_record refs[2] = {\n \t\t{\n@@ -315,17 +304,12 @@ static void t_reftable_stack_transaction_with_reload(void)\n \t};\n \tstruct reftable_ref_record ref = { 0 };\n \n-\terr = reftable_new_stack(&st1, dir, NULL);\n-\tcheck(!err);\n-\terr = reftable_new_stack(&st2, dir, NULL);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_new_addition(&add, st1, 0);\n-\tcheck(!err);\n-\terr = reftable_addition_add(add, write_test_ref, &refs[0]);\n-\tcheck(!err);\n-\terr = reftable_addition_commit(add);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, NULL), 0);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, NULL), 0);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st1, 0), 0);\n+\tcl_assert_equal_i(reftable_addition_add(add, write_test_ref,\n+\t\t\t\t\t\t&refs[0]), 0);\n+\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \treftable_addition_destroy(add);\n \n \t/*\n@@ -333,20 +317,20 @@ static void t_reftable_stack_transaction_with_reload(void)\n \t * create the addition and lock the stack by default, but allow the\n \t * reload to happen when REFTABLE_STACK_NEW_ADDITION_RELOAD is set.\n \t */\n-\terr = reftable_stack_new_addition(&add, st2, 0);\n-\tcheck_int(err, ==, REFTABLE_OUTDATED_ERROR);\n-\terr = reftable_stack_new_addition(&add, st2, REFTABLE_STACK_NEW_ADDITION_RELOAD);\n-\tcheck(!err);\n-\terr = reftable_addition_add(add, write_test_ref, &refs[1]);\n-\tcheck(!err);\n-\terr = reftable_addition_commit(add);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st2, 0),\n+\t\t\t\t\t\t REFTABLE_OUTDATED_ERROR);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st2,\n+\t\t\t\t\t\t REFTABLE_STACK_NEW_ADDITION_RELOAD), 0);\n+\tcl_assert_equal_i(reftable_addition_add(add, write_test_ref,\n+\t\t\t\t\t\t&refs[1]), 0);\n+\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \treftable_addition_destroy(add);\n \n \tfor (size_t i = 0; i < ARRAY_SIZE(refs); i++) {\n-\t\terr = reftable_stack_read_ref(st2, refs[i].refname, &ref);\n-\t\tcheck(!err);\n-\t\tcheck(reftable_ref_record_equal(&refs[i], &ref, REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_stack_read_ref(st2,\n+\t\t\t\t\t\t\t refs[i].refname, &ref) , 0);\n+\t\tcl_assert(reftable_ref_record_equal(&refs[i], &ref,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t}\n \n \treftable_ref_record_release(&ref);\n@@ -355,17 +339,15 @@ static void t_reftable_stack_transaction_with_reload(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_transaction_api_performs_auto_compaction(void)\n+void test_reftable_stack__transaction_api_performs_auto_compaction(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = {0};\n \tstruct reftable_addition *add = NULL;\n \tstruct reftable_stack *st = NULL;\n \tsize_t n = 20;\n-\tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (size_t i = 0; i <= n; i++) {\n \t\tstruct reftable_ref_record ref = {\n@@ -385,14 +367,11 @@ static void t_reftable_stack_transaction_api_performs_auto_compaction(void)\n \t\t */\n \t\tst->opts.disable_auto_compact = i != n;\n \n-\t\terr = reftable_stack_new_addition(&add, st, 0);\n-\t\tcheck(!err);\n-\n-\t\terr = reftable_addition_add(add, write_test_ref, &ref);\n-\t\tcheck(!err);\n-\n-\t\terr = reftable_addition_commit(add);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_new_addition(&add,\n+\t\t\t\t\t\t\t st, 0), 0);\n+\t\tcl_assert_equal_i(reftable_addition_add(add,\n+\t\t\t\t\t\t\twrite_test_ref, &ref), 0);\n+\t\tcl_assert_equal_i(reftable_addition_commit(add), 0);\n \n \t\treftable_addition_destroy(add);\n \n@@ -402,16 +381,16 @@ static void t_reftable_stack_transaction_api_performs_auto_compaction(void)\n \t\t * all tables in the stack.\n \t\t */\n \t\tif (i != n)\n-\t\t\tcheck_int(st->merged->tables_len, ==, i + 1);\n+\t\t\tcl_assert_equal_i(st->merged->tables_len, i + 1);\n \t\telse\n-\t\t\tcheck_int(st->merged->tables_len, ==, 1);\n+\t\t\tcl_assert_equal_i(st->merged->tables_len, 1);\n \t}\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_auto_compaction_fails_gracefully(void)\n+void test_reftable_stack__auto_compaction_fails_gracefully(void)\n {\n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"refs/heads/master\",\n@@ -425,32 +404,31 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)\n \tchar *dir = get_tmp_dir(__LINE__);\n \tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_test_ref, &ref);\n-\tcheck(!err);\n-\tcheck_int(st->merged->tables_len, ==, 1);\n-\tcheck_int(st->stats.attempts, ==, 0);\n-\tcheck_int(st->stats.failures, ==, 0);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &ref), 0);\n+\tcl_assert_equal_i(st->merged->tables_len, 1);\n+\tcl_assert_equal_i(st->stats.attempts, 0);\n+\tcl_assert_equal_i(st->stats.failures, 0);\n \n \t/*\n \t * Lock the newly written table such that it cannot be compacted.\n \t * Adding a new table to the stack should not be impacted by this, even\n \t * though auto-compaction will now fail.\n \t */\n-\tcheck(!reftable_buf_addstr(&table_path, dir));\n-\tcheck(!reftable_buf_addstr(&table_path, \"/\"));\n-\tcheck(!reftable_buf_addstr(&table_path, st->tables[0]->name));\n-\tcheck(!reftable_buf_addstr(&table_path, \".lock\"));\n+\tcl_assert(!reftable_buf_addstr(&table_path, dir));\n+\tcl_assert(!reftable_buf_addstr(&table_path, \"/\"));\n+\tcl_assert(!reftable_buf_addstr(&table_path,\n+\t\t\t\t st->tables[0]->name));\n+\tcl_assert(!reftable_buf_addstr(&table_path, \".lock\"));\n \twrite_file_buf(table_path.buf, \"\", 0);\n \n \tref.update_index = 2;\n \terr = reftable_stack_add(st, write_test_ref, &ref);\n-\tcheck(!err);\n-\tcheck_int(st->merged->tables_len, ==, 2);\n-\tcheck_int(st->stats.attempts, ==, 1);\n-\tcheck_int(st->stats.failures, ==, 1);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st->merged->tables_len, 2);\n+\tcl_assert_equal_i(st->stats.attempts, 1);\n+\tcl_assert_equal_i(st->stats.failures, 1);\n \n \treftable_stack_destroy(st);\n \treftable_buf_release(&table_path);\n@@ -462,12 +440,11 @@ static int write_error(struct reftable_writer *wr UNUSED, void *arg)\n \treturn *((int *)arg);\n }\n \n-static void t_reftable_stack_update_index_check(void)\n+void test_reftable_stack__update_index_check(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tstruct reftable_ref_record ref1 = {\n \t\t.refname = (char *) \"name1\",\n \t\t.update_index = 1,\n@@ -481,39 +458,33 @@ static void t_reftable_stack_update_index_check(void)\n \t\t.value.symref = (char *) \"master\",\n \t};\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_test_ref, &ref1);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_test_ref, &ref2);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &ref1), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &ref2), REFTABLE_API_ERROR);\n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_lock_failure(void)\n+void test_reftable_stack__lock_failure(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err, i;\n+\tint i;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\tfor (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {\n-\t\terr = reftable_stack_add(st, write_error, &i);\n-\t\tcheck_int(err, ==, i);\n-\t}\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tfor (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--)\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_error,\n+\t\t\t\t\t\t &i), i);\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_add(void)\n+void test_reftable_stack__add(void)\n {\n-\tint err = 0;\n \tstruct reftable_write_options opts = {\n \t\t.exact_log_message = 1,\n \t\t.default_permissions = 0660,\n@@ -526,9 +497,10 @@ static void t_reftable_stack_add(void)\n \tstruct reftable_buf path = REFTABLE_BUF_INIT;\n \tstruct stat stat_result;\n \tsize_t i, N = ARRAY_SIZE(refs);\n+\tint err;\n \n \terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert(!err);\n \n \tfor (i = 0; i < N; i++) {\n \t\tchar buf[256];\n@@ -536,66 +508,66 @@ static void t_reftable_stack_add(void)\n \t\trefs[i].refname = xstrdup(buf);\n \t\trefs[i].update_index = i + 1;\n \t\trefs[i].value_type = REFTABLE_REF_VAL1;\n-\t\tt_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \n \t\tlogs[i].refname = xstrdup(buf);\n \t\tlogs[i].update_index = N + i + 1;\n \t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n \t\tlogs[i].value.update.email = xstrdup(\"identity@invalid\");\n-\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n-\tfor (i = 0; i < N; i++) {\n-\t\tint err = reftable_stack_add(st, write_test_ref, &refs[i]);\n-\t\tcheck(!err);\n-\t}\n+\tfor (i = 0; i < N; i++)\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &refs[i]), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct write_log_arg arg = {\n \t\t\t.log = &logs[i],\n \t\t\t.update_index = reftable_stack_next_update_index(st),\n \t\t};\n-\t\tint err = reftable_stack_add(st, write_test_log, &arg);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t\t &arg), 0);\n \t}\n \n-\terr = reftable_stack_compact_all(st, NULL);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct reftable_ref_record dest = { 0 };\n \n-\t\tint err = reftable_stack_read_ref(st, refs[i].refname, &dest);\n-\t\tcheck(!err);\n-\t\tcheck(reftable_ref_record_equal(&dest, refs + i,\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_stack_read_ref(st,\n+\t\t\t\t\t\t\t refs[i].refname, &dest), 0);\n+\t\tcl_assert(reftable_ref_record_equal(&dest, refs + i,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_ref_record_release(&dest);\n \t}\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct reftable_log_record dest = { 0 };\n-\t\tint err = reftable_stack_read_log(st, refs[i].refname, &dest);\n-\t\tcheck(!err);\n-\t\tcheck(reftable_log_record_equal(&dest, logs + i,\n-\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert_equal_i(reftable_stack_read_log(st,\n+\t\t\t\t\t\t\t refs[i].refname, &dest), 0);\n+\t\tcl_assert(reftable_log_record_equal(&dest, logs + i,\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_log_record_release(&dest);\n \t}\n \n #ifndef GIT_WINDOWS_NATIVE\n-\tcheck(!reftable_buf_addstr(&path, dir));\n-\tcheck(!reftable_buf_addstr(&path, \"/tables.list\"));\n-\terr = stat(path.buf, &stat_result);\n-\tcheck(!err);\n-\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n+\tcl_assert_equal_i(reftable_buf_addstr(&path, dir), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&path, \"/tables.list\"), 0);\n+\tcl_assert_equal_i(stat(path.buf, &stat_result), 0);\n+\tcl_assert_equal_i((stat_result.st_mode & 0777), opts.default_permissions);\n \n \treftable_buf_reset(&path);\n-\tcheck(!reftable_buf_addstr(&path, dir));\n-\tcheck(!reftable_buf_addstr(&path, \"/\"));\n+\tcl_assert_equal_i(reftable_buf_addstr(&path, dir), 0);\n+\tcl_assert_equal_i(reftable_buf_addstr(&path, \"/\"), 0);\n \t/* do not try at home; not an external API for reftable. */\n-\tcheck(!reftable_buf_addstr(&path, st->tables[0]->name));\n+\tcl_assert(!reftable_buf_addstr(&path, st->tables[0]->name));\n \terr = stat(path.buf, &stat_result);\n-\tcheck(!err);\n-\tcheck_int((stat_result.st_mode & 0777), ==, opts.default_permissions);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i((stat_result.st_mode & 0777),\n+\t\t\t opts.default_permissions);\n #else\n \t(void) stat_result;\n #endif\n@@ -610,7 +582,7 @@ static void t_reftable_stack_add(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_iterator(void)\n+void test_reftable_stack__iterator(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n@@ -621,27 +593,27 @@ static void t_reftable_stack_iterator(void)\n \tsize_t N = ARRAY_SIZE(refs), i;\n \tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\trefs[i].refname = xstrfmt(\"branch%02\"PRIuMAX, (uintmax_t)i);\n \t\trefs[i].update_index = i + 1;\n \t\trefs[i].value_type = REFTABLE_REF_VAL1;\n-\t\tt_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \n \t\tlogs[i].refname = xstrfmt(\"branch%02\"PRIuMAX, (uintmax_t)i);\n \t\tlogs[i].update_index = i + 1;\n \t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n \t\tlogs[i].value.update.email = xstrdup(\"johndoe@invalid\");\n \t\tlogs[i].value.update.message = xstrdup(\"commit\\n\");\n-\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n-\tfor (i = 0; i < N; i++) {\n-\t\terr = reftable_stack_add(st, write_test_ref, &refs[i]);\n-\t\tcheck(!err);\n-\t}\n+\tfor (i = 0; i < N; i++)\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t write_test_ref, &refs[i]), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct write_log_arg arg = {\n@@ -649,8 +621,8 @@ static void t_reftable_stack_iterator(void)\n \t\t\t.update_index = reftable_stack_next_update_index(st),\n \t\t};\n \n-\t\terr = reftable_stack_add(st, write_test_log, &arg);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t write_test_log, &arg), 0);\n \t}\n \n \treftable_stack_init_ref_iterator(st, &it);\n@@ -661,16 +633,16 @@ static void t_reftable_stack_iterator(void)\n \t\terr = reftable_iterator_next_ref(&it, &ref);\n \t\tif (err > 0)\n \t\t\tbreak;\n-\t\tcheck(!err);\n-\t\tcheck(reftable_ref_record_equal(&ref, &refs[i], REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(!err);\n+\t\tcl_assert(reftable_ref_record_equal(&ref, &refs[i],\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_ref_record_release(&ref);\n \t}\n-\tcheck_int(i, ==, N);\n+\tcl_assert_equal_i(i, N);\n \n \treftable_iterator_destroy(&it);\n \n-\terr = reftable_stack_init_log_iterator(st, &it);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_init_log_iterator(st, &it), 0);\n \n \treftable_iterator_seek_log(&it, logs[0].refname);\n \tfor (i = 0; ; i++) {\n@@ -679,11 +651,12 @@ static void t_reftable_stack_iterator(void)\n \t\terr = reftable_iterator_next_log(&it, &log);\n \t\tif (err > 0)\n \t\t\tbreak;\n-\t\tcheck(!err);\n-\t\tcheck(reftable_log_record_equal(&log, &logs[i], REFTABLE_HASH_SIZE_SHA1));\n+\t\tcl_assert(!err);\n+\t\tcl_assert(reftable_log_record_equal(&log, &logs[i],\n+\t\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \t\treftable_log_record_release(&log);\n \t}\n-\tcheck_int(i, ==, N);\n+\tcl_assert_equal_i(i, N);\n \n \treftable_stack_destroy(st);\n \treftable_iterator_destroy(&it);\n@@ -694,9 +667,8 @@ static void t_reftable_stack_iterator(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_log_normalize(void)\n+void test_reftable_stack__log_normalize(void)\n {\n-\tint err = 0;\n \tstruct reftable_write_options opts = {\n \t\t0,\n \t};\n@@ -721,28 +693,26 @@ static void t_reftable_stack_log_normalize(void)\n \t\t.update_index = 1,\n \t};\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tinput.value.update.message = (char *) \"one\\ntwo\";\n-\terr = reftable_stack_add(st, write_test_log, &arg);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t &arg), REFTABLE_API_ERROR);\n \n \tinput.value.update.message = (char *) \"one\";\n-\terr = reftable_stack_add(st, write_test_log, &arg);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_log(st, input.refname, &dest);\n-\tcheck(!err);\n-\tcheck_str(dest.value.update.message, \"one\\n\");\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t &arg), 0);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, input.refname,\n+\t\t\t\t\t\t &dest), 0);\n+\tcl_assert_equal_s(dest.value.update.message, \"one\\n\");\n \n \tinput.value.update.message = (char *) \"two\\n\";\n \targ.update_index = 2;\n-\terr = reftable_stack_add(st, write_test_log, &arg);\n-\tcheck(!err);\n-\terr = reftable_stack_read_log(st, input.refname, &dest);\n-\tcheck(!err);\n-\tcheck_str(dest.value.update.message, \"two\\n\");\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t &arg), 0);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, input.refname,\n+\t\t\t\t\t\t &dest), 0);\n+\tcl_assert_equal_s(dest.value.update.message, \"two\\n\");\n \n \t/* cleanup */\n \treftable_stack_destroy(st);\n@@ -750,20 +720,18 @@ static void t_reftable_stack_log_normalize(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_tombstone(void)\n+void test_reftable_stack__tombstone(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tstruct reftable_ref_record refs[2] = { 0 };\n \tstruct reftable_log_record logs[2] = { 0 };\n \tsize_t i, N = ARRAY_SIZE(refs);\n \tstruct reftable_ref_record dest = { 0 };\n \tstruct reftable_log_record log_dest = { 0 };\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \t/* even entries add the refs, odd entries delete them. */\n \tfor (i = 0; i < N; i++) {\n@@ -772,8 +740,8 @@ static void t_reftable_stack_tombstone(void)\n \t\trefs[i].update_index = i + 1;\n \t\tif (i % 2 == 0) {\n \t\t\trefs[i].value_type = REFTABLE_REF_VAL1;\n-\t\t\tt_reftable_set_hash(refs[i].value.val1, i,\n-\t\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\t\tcl_reftable_set_hash(refs[i].value.val1, i,\n+\t\t\t\t\t REFTABLE_HASH_SHA1);\n \t\t}\n \n \t\tlogs[i].refname = xstrdup(buf);\n@@ -785,42 +753,36 @@ static void t_reftable_stack_tombstone(void)\n \t\tlogs[i].update_index = 1;\n \t\tif (i % 2 == 0) {\n \t\t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n-\t\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i,\n-\t\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);\n \t\t\tlogs[i].value.update.email =\n \t\t\t\txstrdup(\"identity@invalid\");\n \t\t}\n \t}\n-\tfor (i = 0; i < N; i++) {\n-\t\tint err = reftable_stack_add(st, write_test_ref, &refs[i]);\n-\t\tcheck(!err);\n-\t}\n+\tfor (i = 0; i < N; i++)\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref, &refs[i]), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tstruct write_log_arg arg = {\n \t\t\t.log = &logs[i],\n \t\t\t.update_index = reftable_stack_next_update_index(st),\n \t\t};\n-\t\tint err = reftable_stack_add(st, write_test_log, &arg);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t write_test_log, &arg), 0);\n \t}\n \n-\terr = reftable_stack_read_ref(st, \"branch\", &dest);\n-\tcheck_int(err, ==, 1);\n+\tcl_assert_equal_i(reftable_stack_read_ref(st, \"branch\",\n+\t\t\t\t\t\t &dest), 1);\n \treftable_ref_record_release(&dest);\n \n-\terr = reftable_stack_read_log(st, \"branch\", &log_dest);\n-\tcheck_int(err, ==, 1);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, \"branch\",\n+\t\t\t\t\t\t &log_dest), 1);\n \treftable_log_record_release(&log_dest);\n \n-\terr = reftable_stack_compact_all(st, NULL);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_ref(st, \"branch\", &dest);\n-\tcheck_int(err, ==, 1);\n-\n-\terr = reftable_stack_read_log(st, \"branch\", &log_dest);\n-\tcheck_int(err, ==, 1);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);\n+\tcl_assert_equal_i(reftable_stack_read_ref(st, \"branch\",\n+\t\t\t\t\t\t &dest), 1);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, \"branch\",\n+\t\t\t\t\t\t &log_dest), 1);\n \treftable_ref_record_release(&dest);\n \treftable_log_record_release(&log_dest);\n \n@@ -833,12 +795,11 @@ static void t_reftable_stack_tombstone(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_hash_id(void)\n+void test_reftable_stack__hash_id(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"master\",\n@@ -852,62 +813,57 @@ static void t_reftable_stack_hash_id(void)\n \tstruct reftable_stack *st_default = NULL;\n \tstruct reftable_ref_record dest = { 0 };\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_test_ref, &ref);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_test_ref,\n+\t\t\t\t\t &ref), 0);\n \n \t/* can't read it with the wrong hash ID. */\n-\terr = reftable_new_stack(&st32, dir, &opts32);\n-\tcheck_int(err, ==, REFTABLE_FORMAT_ERROR);\n+\tcl_assert_equal_i(reftable_new_stack(&st32, dir,\n+\t\t\t\t\t &opts32), REFTABLE_FORMAT_ERROR);\n \n \t/* check that we can read it back with default opts too. */\n-\terr = reftable_new_stack(&st_default, dir, &opts_default);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_ref(st_default, \"master\", &dest);\n-\tcheck(!err);\n-\n-\tcheck(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));\n+\tcl_assert_equal_i(reftable_new_stack(&st_default, dir,\n+\t\t\t\t\t &opts_default), 0);\n+\tcl_assert_equal_i(reftable_stack_read_ref(st_default, \"master\",\n+\t\t\t\t\t\t &dest), 0);\n+\tcl_assert(reftable_ref_record_equal(&ref, &dest,\n+\t\t\t\t\t REFTABLE_HASH_SIZE_SHA1) != 0);\n \treftable_ref_record_release(&dest);\n \treftable_stack_destroy(st);\n \treftable_stack_destroy(st_default);\n \tclear_dir(dir);\n }\n \n-static void t_suggest_compaction_segment(void)\n+void test_reftable_stack__suggest_compaction_segment(void)\n {\n \tuint64_t sizes[] = { 512, 64, 17, 16, 9, 9, 9, 16, 2, 16 };\n \tstruct segment min =\n \t\tsuggest_compaction_segment(sizes, ARRAY_SIZE(sizes), 2);\n-\tcheck_int(min.start, ==, 1);\n-\tcheck_int(min.end, ==, 10);\n+\tcl_assert_equal_i(min.start, 1);\n+\tcl_assert_equal_i(min.end, 10);\n }\n \n-static void t_suggest_compaction_segment_nothing(void)\n+void test_reftable_stack__suggest_compaction_segment_nothing(void)\n {\n \tuint64_t sizes[] = { 64, 32, 16, 8, 4, 2 };\n \tstruct segment result =\n \t\tsuggest_compaction_segment(sizes, ARRAY_SIZE(sizes), 2);\n-\tcheck_int(result.start, ==, result.end);\n+\tcl_assert_equal_i(result.start, result.end);\n }\n \n-static void t_reflog_expire(void)\n+void test_reftable_stack__reflog_expire(void)\n {\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n \tstruct reftable_log_record logs[20] = { 0 };\n \tsize_t i, N = ARRAY_SIZE(logs) - 1;\n-\tint err;\n \tstruct reftable_log_expiry_config expiry = {\n \t\t.time = 10,\n \t};\n \tstruct reftable_log_record log = { 0 };\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 1; i <= N; i++) {\n \t\tchar buf[256];\n@@ -918,8 +874,8 @@ static void t_reflog_expire(void)\n \t\tlogs[i].value_type = REFTABLE_LOG_UPDATE;\n \t\tlogs[i].value.update.time = i;\n \t\tlogs[i].value.update.email = xstrdup(\"identity@invalid\");\n-\t\tt_reftable_set_hash(logs[i].value.update.new_hash, i,\n-\t\t\t\t REFTABLE_HASH_SHA1);\n+\t\tcl_reftable_set_hash(logs[i].value.update.new_hash, i,\n+\t\t\t\t REFTABLE_HASH_SHA1);\n \t}\n \n \tfor (i = 1; i <= N; i++) {\n@@ -927,31 +883,23 @@ static void t_reflog_expire(void)\n \t\t\t.log = &logs[i],\n \t\t\t.update_index = reftable_stack_next_update_index(st),\n \t\t};\n-\t\tint err = reftable_stack_add(st, write_test_log, &arg);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st, write_test_log,\n+\t\t\t\t\t\t &arg), 0);\n \t}\n \n-\terr = reftable_stack_compact_all(st, NULL);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_compact_all(st, &expiry);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_log(st, logs[9].refname, &log);\n-\tcheck_int(err, ==, 1);\n-\n-\terr = reftable_stack_read_log(st, logs[11].refname, &log);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, NULL), 0);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, &expiry), 0);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, logs[9].refname,\n+\t\t\t\t\t\t &log), 1);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, logs[11].refname,\n+\t\t\t\t\t\t &log), 0);\n \n \texpiry.min_update_index = 15;\n-\terr = reftable_stack_compact_all(st, &expiry);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_read_log(st, logs[14].refname, &log);\n-\tcheck_int(err, ==, 1);\n-\n-\terr = reftable_stack_read_log(st, logs[16].refname, &log);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st, &expiry), 0);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, logs[14].refname,\n+\t\t\t\t\t\t &log), 1);\n+\tcl_assert_equal_i(reftable_stack_read_log(st, logs[16].refname,\n+\t\t\t\t\t\t &log), 0);\n \n \t/* cleanup */\n \treftable_stack_destroy(st);\n@@ -963,26 +911,21 @@ static void t_reflog_expire(void)\n \n static int write_nothing(struct reftable_writer *wr, void *arg UNUSED)\n {\n-\tcheck(!reftable_writer_set_limits(wr, 1, 1));\n+\tcl_assert_equal_i(reftable_writer_set_limits(wr, 1, 1), 0);\n \treturn 0;\n }\n \n-static void t_empty_add(void)\n+void test_reftable_stack__empty_add(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_stack *st2 = NULL;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_add(st, write_nothing, NULL);\n-\tcheck(!err);\n-\n-\terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_add(st, write_nothing,\n+\t\t\t\t\t NULL), 0);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n \tclear_dir(dir);\n \treftable_stack_destroy(st);\n \treftable_stack_destroy(st2);\n@@ -998,18 +941,17 @@ static int fastlogN(uint64_t sz, uint64_t N)\n \treturn l - 1;\n }\n \n-static void t_reftable_stack_auto_compaction(void)\n+void test_reftable_stack__auto_compaction(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.disable_auto_compact = 1,\n \t};\n \tstruct reftable_stack *st = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \tsize_t i, N = 100;\n+\tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 0; i < N; i++) {\n \t\tchar name[100];\n@@ -1022,32 +964,31 @@ static void t_reftable_stack_auto_compaction(void)\n \t\tsnprintf(name, sizeof(name), \"branch%04\"PRIuMAX, (uintmax_t)i);\n \n \t\terr = reftable_stack_add(st, write_test_ref, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \n \t\terr = reftable_stack_auto_compact(st);\n-\t\tcheck(!err);\n-\t\tcheck(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));\n+\t\tcl_assert(!err);\n+\t\tcl_assert(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));\n \t}\n \n-\tcheck_int(reftable_stack_compaction_stats(st)->entries_written, <,\n-\t (uint64_t)(N * fastlogN(N, 2)));\n+\tcl_assert(reftable_stack_compaction_stats(st)->entries_written <\n+\t\t\t (uint64_t)(N * fastlogN(N, 2)));\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_auto_compaction_factor(void)\n+void test_reftable_stack__auto_compaction_factor(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.auto_compaction_factor = 5,\n \t};\n \tstruct reftable_stack *st = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \tsize_t N = 100;\n+\tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (size_t i = 0; i < N; i++) {\n \t\tchar name[20];\n@@ -1059,16 +1000,16 @@ static void t_reftable_stack_auto_compaction_factor(void)\n \t\txsnprintf(name, sizeof(name), \"branch%04\"PRIuMAX, (uintmax_t)i);\n \n \t\terr = reftable_stack_add(st, &write_test_ref, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert(!err);\n \n-\t\tcheck(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));\n+\t\tcl_assert(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));\n \t}\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_auto_compaction_with_locked_tables(void)\n+void test_reftable_stack__auto_compaction_with_locked_tables(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.disable_auto_compact = 1,\n@@ -1078,21 +1019,20 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)\n \tchar *dir = get_tmp_dir(__LINE__);\n \tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \twrite_n_ref_tables(st, 5);\n-\tcheck_int(st->merged->tables_len, ==, 5);\n+\tcl_assert_equal_i(st->merged->tables_len, 5);\n \n \t/*\n \t * Given that all tables we have written should be roughly the same\n \t * size, we expect that auto-compaction will want to compact all of the\n \t * tables. Locking any of the tables will keep it from doing so.\n \t */\n-\tcheck(!reftable_buf_addstr(&buf, dir));\n-\tcheck(!reftable_buf_addstr(&buf, \"/\"));\n-\tcheck(!reftable_buf_addstr(&buf, st->tables[2]->name));\n-\tcheck(!reftable_buf_addstr(&buf, \".lock\"));\n+\tcl_assert(!reftable_buf_addstr(&buf, dir));\n+\tcl_assert(!reftable_buf_addstr(&buf, \"/\"));\n+\tcl_assert(!reftable_buf_addstr(&buf, st->tables[2]->name));\n+\tcl_assert(!reftable_buf_addstr(&buf, \".lock\"));\n \twrite_file_buf(buf.buf, \"\", 0);\n \n \t/*\n@@ -1102,25 +1042,23 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)\n \t * only compact the newest two tables.\n \t */\n \terr = reftable_stack_auto_compact(st);\n-\tcheck(!err);\n-\tcheck_int(st->stats.failures, ==, 0);\n-\tcheck_int(st->merged->tables_len, ==, 4);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st->stats.failures, 0);\n+\tcl_assert_equal_i(st->merged->tables_len, 4);\n \n \treftable_stack_destroy(st);\n \treftable_buf_release(&buf);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_add_performs_auto_compaction(void)\n+void test_reftable_stack__add_performs_auto_compaction(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \tsize_t i, n = 20;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \tfor (i = 0; i <= n; i++) {\n \t\tstruct reftable_ref_record ref = {\n@@ -1140,8 +1078,8 @@ static void t_reftable_stack_add_performs_auto_compaction(void)\n \t\tsnprintf(buf, sizeof(buf), \"branch-%04\"PRIuMAX, (uintmax_t)i);\n \t\tref.refname = buf;\n \n-\t\terr = reftable_stack_add(st, write_test_ref, &ref);\n-\t\tcheck(!err);\n+\t\tcl_assert_equal_i(reftable_stack_add(st,\n+\t\t\t\t\t\t write_test_ref, &ref), 0);\n \n \t\t/*\n \t\t * The stack length should grow continuously for all runs where\n@@ -1149,16 +1087,16 @@ static void t_reftable_stack_add_performs_auto_compaction(void)\n \t\t * all tables in the stack.\n \t\t */\n \t\tif (i != n)\n-\t\t\tcheck_int(st->merged->tables_len, ==, i + 1);\n+\t\t\tcl_assert_equal_i(st->merged->tables_len, i + 1);\n \t\telse\n-\t\t\tcheck_int(st->merged->tables_len, ==, 1);\n+\t\t\tcl_assert_equal_i(st->merged->tables_len, 1);\n \t}\n \n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_compaction_with_locked_tables(void)\n+void test_reftable_stack__compaction_with_locked_tables(void)\n {\n \tstruct reftable_write_options opts = {\n \t\t.disable_auto_compact = 1,\n@@ -1168,17 +1106,16 @@ static void t_reftable_stack_compaction_with_locked_tables(void)\n \tchar *dir = get_tmp_dir(__LINE__);\n \tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \twrite_n_ref_tables(st, 3);\n-\tcheck_int(st->merged->tables_len, ==, 3);\n+\tcl_assert_equal_i(st->merged->tables_len, 3);\n \n \t/* Lock one of the tables that we're about to compact. */\n-\tcheck(!reftable_buf_addstr(&buf, dir));\n-\tcheck(!reftable_buf_addstr(&buf, \"/\"));\n-\tcheck(!reftable_buf_addstr(&buf, st->tables[1]->name));\n-\tcheck(!reftable_buf_addstr(&buf, \".lock\"));\n+\tcl_assert(!reftable_buf_addstr(&buf, dir));\n+\tcl_assert(!reftable_buf_addstr(&buf, \"/\"));\n+\tcl_assert(!reftable_buf_addstr(&buf, st->tables[1]->name));\n+\tcl_assert(!reftable_buf_addstr(&buf, \".lock\"));\n \twrite_file_buf(buf.buf, \"\", 0);\n \n \t/*\n@@ -1186,36 +1123,31 @@ static void t_reftable_stack_compaction_with_locked_tables(void)\n \t * compact all tables.\n \t */\n \terr = reftable_stack_compact_all(st, NULL);\n-\tcheck_int(err, ==, REFTABLE_LOCK_ERROR);\n-\tcheck_int(st->stats.failures, ==, 1);\n-\tcheck_int(st->merged->tables_len, ==, 3);\n+\tcl_assert_equal_i(err, REFTABLE_LOCK_ERROR);\n+\tcl_assert_equal_i(st->stats.failures, 1);\n+\tcl_assert_equal_i(st->merged->tables_len, 3);\n \n \treftable_stack_destroy(st);\n \treftable_buf_release(&buf);\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_compaction_concurrent(void)\n+void test_reftable_stack__compaction_concurrent(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st1 = NULL, *st2 = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \n-\terr = reftable_new_stack(&st1, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n \twrite_n_ref_tables(st1, 3);\n \n-\terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_compact_all(st1, NULL);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st1, NULL), 0);\n \n \treftable_stack_destroy(st1);\n \treftable_stack_destroy(st2);\n \n-\tcheck_int(count_dir_entries(dir), ==, 2);\n+\tcl_assert_equal_i(count_dir_entries(dir), 2);\n \tclear_dir(dir);\n }\n \n@@ -1228,32 +1160,24 @@ static void unclean_stack_close(struct reftable_stack *st)\n \tREFTABLE_FREE_AND_NULL(st->tables);\n }\n \n-static void t_reftable_stack_compaction_concurrent_clean(void)\n+void test_reftable_stack__compaction_concurrent_clean(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st1 = NULL, *st2 = NULL, *st3 = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n-\tint err;\n \n-\terr = reftable_new_stack(&st1, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n \twrite_n_ref_tables(st1, 3);\n \n-\terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_compact_all(st1, NULL);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st2, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_compact_all(st1, NULL), 0);\n \n \tunclean_stack_close(st1);\n \tunclean_stack_close(st2);\n \n-\terr = reftable_new_stack(&st3, dir, &opts);\n-\tcheck(!err);\n-\n-\terr = reftable_stack_clean(st3);\n-\tcheck(!err);\n-\tcheck_int(count_dir_entries(dir), ==, 2);\n+\tcl_assert_equal_i(reftable_new_stack(&st3, dir, &opts), 0);\n+\tcl_assert_equal_i(reftable_stack_clean(st3), 0);\n+\tcl_assert_equal_i(count_dir_entries(dir), 2);\n \n \treftable_stack_destroy(st1);\n \treftable_stack_destroy(st2);\n@@ -1262,7 +1186,7 @@ static void t_reftable_stack_compaction_concurrent_clean(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_read_across_reload(void)\n+void test_reftable_stack__read_across_reload(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st1 = NULL, *st2 = NULL;\n@@ -1272,37 +1196,35 @@ static void t_reftable_stack_read_across_reload(void)\n \tint err;\n \n \t/* Create a first stack and set up an iterator for it. */\n-\terr = reftable_new_stack(&st1, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st1, dir, &opts), 0);\n \twrite_n_ref_tables(st1, 2);\n-\tcheck_int(st1->merged->tables_len, ==, 2);\n+\tcl_assert_equal_i(st1->merged->tables_len, 2);\n \treftable_stack_init_ref_iterator(st1, &it);\n-\terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_iterator_seek_ref(&it, \"\"), 0);\n \n \t/* Set up a second stack for the same directory and compact it. */\n \terr = reftable_new_stack(&st2, dir, &opts);\n-\tcheck(!err);\n-\tcheck_int(st2->merged->tables_len, ==, 2);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st2->merged->tables_len, 2);\n \terr = reftable_stack_compact_all(st2, NULL);\n-\tcheck(!err);\n-\tcheck_int(st2->merged->tables_len, ==, 1);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st2->merged->tables_len, 1);\n \n \t/*\n \t * Verify that we can continue to use the old iterator even after we\n \t * have reloaded its stack.\n \t */\n \terr = reftable_stack_reload(st1);\n-\tcheck(!err);\n-\tcheck_int(st1->merged->tables_len, ==, 1);\n+\tcl_assert(!err);\n+\tcl_assert_equal_i(st1->merged->tables_len, 1);\n \terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\tcheck_str(rec.refname, \"refs/heads/branch-0000\");\n+\tcl_assert(!err);\n+\tcl_assert_equal_s(rec.refname, \"refs/heads/branch-0000\");\n \terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\tcheck_str(rec.refname, \"refs/heads/branch-0001\");\n+\tcl_assert(!err);\n+\tcl_assert_equal_s(rec.refname, \"refs/heads/branch-0001\");\n \terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck_int(err, >, 0);\n+\tcl_assert(err > 0);\n \n \treftable_ref_record_release(&rec);\n \treftable_iterator_destroy(&it);\n@@ -1311,7 +1233,7 @@ static void t_reftable_stack_read_across_reload(void)\n \tclear_dir(dir);\n }\n \n-static void t_reftable_stack_reload_with_missing_table(void)\n+void test_reftable_stack__reload_with_missing_table(void)\n {\n \tstruct reftable_write_options opts = { 0 };\n \tstruct reftable_stack *st = NULL;\n@@ -1322,46 +1244,40 @@ static void t_reftable_stack_reload_with_missing_table(void)\n \tint err;\n \n \t/* Create a first stack and set up an iterator for it. */\n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \twrite_n_ref_tables(st, 2);\n-\tcheck_int(st->merged->tables_len, ==, 2);\n+\tcl_assert_equal_i(st->merged->tables_len, 2);\n \treftable_stack_init_ref_iterator(st, &it);\n-\terr = reftable_iterator_seek_ref(&it, \"\");\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_iterator_seek_ref(&it, \"\"), 0);\n \n \t/*\n \t * Update the tables.list file with some garbage data, while reusing\n \t * our old tables. This should trigger a partial reload of the stack,\n \t * where we try to reuse our old tables.\n \t*/\n-\tcheck(!reftable_buf_addstr(&content, st->tables[0]->name));\n-\tcheck(!reftable_buf_addstr(&content, \"\\n\"));\n-\tcheck(!reftable_buf_addstr(&content, st->tables[1]->name));\n-\tcheck(!reftable_buf_addstr(&content, \"\\n\"));\n-\tcheck(!reftable_buf_addstr(&content, \"garbage\\n\"));\n-\tcheck(!reftable_buf_addstr(&table_path, st->list_file));\n-\tcheck(!reftable_buf_addstr(&table_path, \".lock\"));\n+\tcl_assert(!reftable_buf_addstr(&content, st->tables[0]->name));\n+\tcl_assert(!reftable_buf_addstr(&content, \"\\n\"));\n+\tcl_assert(!reftable_buf_addstr(&content, st->tables[1]->name));\n+\tcl_assert(!reftable_buf_addstr(&content, \"\\n\"));\n+\tcl_assert(!reftable_buf_addstr(&content, \"garbage\\n\"));\n+\tcl_assert(!reftable_buf_addstr(&table_path, st->list_file));\n+\tcl_assert(!reftable_buf_addstr(&table_path, \".lock\"));\n \twrite_file_buf(table_path.buf, content.buf, content.len);\n-\terr = rename(table_path.buf, st->list_file);\n-\tcheck(!err);\n+\tcl_assert_equal_i(rename(table_path.buf, st->list_file), 0);\n \n \terr = reftable_stack_reload(st);\n-\tcheck_int(err, ==, -4);\n-\tcheck_int(st->merged->tables_len, ==, 2);\n+\tcl_assert_equal_i(err, -4);\n+\tcl_assert_equal_i(st->merged->tables_len, 2);\n \n \t/*\n \t * Even though the reload has failed, we should be able to continue\n \t * using the iterator.\n \t*/\n-\terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\tcheck_str(rec.refname, \"refs/heads/branch-0000\");\n-\terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck(!err);\n-\tcheck_str(rec.refname, \"refs/heads/branch-0001\");\n-\terr = reftable_iterator_next_ref(&it, &rec);\n-\tcheck_int(err, >, 0);\n+\tcl_assert_equal_i(reftable_iterator_next_ref(&it, &rec), 0);\n+\tcl_assert_equal_s(rec.refname, \"refs/heads/branch-0000\");\n+\tcl_assert_equal_i(reftable_iterator_next_ref(&it, &rec), 0);\n+\tcl_assert_equal_s(rec.refname, \"refs/heads/branch-0001\");\n+\tcl_assert(reftable_iterator_next_ref(&it, &rec) > 0);\n \n \treftable_ref_record_release(&rec);\n \treftable_iterator_destroy(&it);\n@@ -1374,12 +1290,13 @@ static void t_reftable_stack_reload_with_missing_table(void)\n static int write_limits_after_ref(struct reftable_writer *wr, void *arg)\n {\n \tstruct reftable_ref_record *ref = arg;\n-\tcheck(!reftable_writer_set_limits(wr, ref->update_index, ref->update_index));\n-\tcheck(!reftable_writer_add_ref(wr, ref));\n+\tcl_assert_equal_i(reftable_writer_set_limits(wr,\n+\t\t\t\t\t\t ref->update_index, ref->update_index), 0);\n+\tcl_assert_equal_i(reftable_writer_add_ref(wr, ref), 0);\n \treturn reftable_writer_set_limits(wr, ref->update_index, ref->update_index);\n }\n \n-static void t_reftable_invalid_limit_updates(void)\n+void test_reftable_stack__invalid_limit_updates(void)\n {\n \tstruct reftable_ref_record ref = {\n \t\t.refname = (char *) \"HEAD\",\n@@ -1393,59 +1310,22 @@ static void t_reftable_invalid_limit_updates(void)\n \tstruct reftable_addition *add = NULL;\n \tchar *dir = get_tmp_dir(__LINE__);\n \tstruct reftable_stack *st = NULL;\n-\tint err;\n \n-\terr = reftable_new_stack(&st, dir, &opts);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_new_stack(&st, dir, &opts), 0);\n \n \treftable_addition_destroy(add);\n \n-\terr = reftable_stack_new_addition(&add, st, 0);\n-\tcheck(!err);\n+\tcl_assert_equal_i(reftable_stack_new_addition(&add, st, 0), 0);\n \n \t/*\n \t * write_limits_after_ref also updates the update indexes after adding\n \t * the record. This should cause an err to be returned, since the limits\n \t * must be set at the start.\n \t */\n-\terr = reftable_addition_add(add, write_limits_after_ref, &ref);\n-\tcheck_int(err, ==, REFTABLE_API_ERROR);\n+\tcl_assert_equal_i(reftable_addition_add(add,\n+\t\t\t\t\t\twrite_limits_after_ref, &ref), REFTABLE_API_ERROR);\n \n \treftable_addition_destroy(add);\n \treftable_stack_destroy(st);\n \tclear_dir(dir);\n }\n-\n-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)\n-{\n-\tTEST(t_empty_add(), \"empty addition to stack\");\n-\tTEST(t_read_file(), \"read_lines works\");\n-\tTEST(t_reflog_expire(), \"expire reflog entries\");\n-\tTEST(t_reftable_invalid_limit_updates(), \"prevent limit updates after adding records\");\n-\tTEST(t_reftable_stack_add(), \"add multiple refs and logs to stack\");\n-\tTEST(t_reftable_stack_add_one(), \"add a single ref record to stack\");\n-\tTEST(t_reftable_stack_add_performs_auto_compaction(), \"addition to stack triggers auto-compaction\");\n-\tTEST(t_reftable_stack_auto_compaction(), \"stack must form geometric sequence after compaction\");\n-\tTEST(t_reftable_stack_auto_compaction_factor(), \"auto-compaction with non-default geometric factor\");\n-\tTEST(t_reftable_stack_auto_compaction_fails_gracefully(), \"failure on auto-compaction\");\n-\tTEST(t_reftable_stack_auto_compaction_with_locked_tables(), \"auto compaction with locked tables\");\n-\tTEST(t_reftable_stack_compaction_concurrent(), \"compaction with concurrent stack\");\n-\tTEST(t_reftable_stack_compaction_concurrent_clean(), \"compaction with unclean stack shutdown\");\n-\tTEST(t_reftable_stack_compaction_with_locked_tables(), \"compaction with locked tables\");\n-\tTEST(t_reftable_stack_hash_id(), \"read stack with wrong hash ID\");\n-\tTEST(t_reftable_stack_iterator(), \"log and ref iterator for reftable stack\");\n-\tTEST(t_reftable_stack_lock_failure(), \"stack addition with lockfile failure\");\n-\tTEST(t_reftable_stack_log_normalize(), \"log messages should be normalized\");\n-\tTEST(t_reftable_stack_read_across_reload(), \"stack iterators work across reloads\");\n-\tTEST(t_reftable_stack_reload_with_missing_table(), \"stack iteration with garbage tables\");\n-\tTEST(t_reftable_stack_tombstone(), \"'tombstone' refs in stack\");\n-\tTEST(t_reftable_stack_transaction_api(), \"update transaction to stack\");\n-\tTEST(t_reftable_stack_transaction_with_reload(), \"transaction with reload\");\n-\tTEST(t_reftable_stack_transaction_api_performs_auto_compaction(), \"update transaction triggers auto-compaction\");\n-\tTEST(t_reftable_stack_update_index_check(), \"update transactions with equal update indices\");\n-\tTEST(t_reftable_stack_uptodate(), \"stack must be reloaded before ref update\");\n-\tTEST(t_suggest_compaction_segment(), \"suggest_compaction_segment with basic input\");\n-\tTEST(t_suggest_compaction_segment_nothing(), \"suggest_compaction_segment with pre-compacted input\");\n-\n-\treturn test_done();\n-}\n-- \n2.43.0\n\n"},{"id":"522678","messageId":"20250724142837.67149-11-kuforiji98@gmail.com","threadId":"63589","inReplyTo":"20250724142837.67149-1-kuforiji98@gmail.com","subject":"[PATCH v5 10/10] t/unit-tests: finalize migration of reftable-related tests","fromName":"Seyi Kufoiji","fromEmail":"kuforiji98@gmail.com","sentAt":"2025-07-24T14:28:37Z","receivedAt":"2025-07-24T14:30:47Z","isPatch":true,"sender":{"key":"kuforiji98@gmail.com","avatar":"https://avatars.githubusercontent.com/u/94905626?v=4"},"body":"From: Seyi Kuforiji \n\nThe old `lib-reftable.{c,h}` implemented helper functions for our\nhomegrown unit-testing framework. As part of migrating reftable-related\ntests to the Clar framework, Clar-specific versions of these functions\nin `lib-reftable-clar.{c,h}` were introduced.\n\nNow that all test files using these helpers have been converted to Clar,\nwe can safely remove the original `lib-reftable.{c,h}` and rename the\nClar- specific versions back to `lib-reftable.{c,h}`. This restores a\nclean and consistent naming scheme for shared test utilities.\n\nFinally, update our build system to reflect the changes made and remove\nredundant code related to the reftable tests and our old homegrown\nunit-testing setup. `test-lib.{c,h}` remains unchanged in our build\nsystem as some files particularly `t/helper/test-example-tap.c` depends\non it in order to run, and removing that would be beyond the scope of\nthis patch.\n\nSigned-off-by: Seyi Kuforiji \nSigned-off-by: Junio C Hamano \n---\n Makefile | 6 +-\n t/Makefile | 1 -\n t/meson.build | 21 +-----\n t/unit-tests/lib-reftable-clar.c | 101 ----------------------------\n t/unit-tests/lib-reftable-clar.h | 20 ------\n t/unit-tests/lib-reftable.c | 35 +++++-----\n t/unit-tests/lib-reftable.h | 15 ++---\n t/unit-tests/u-reftable-basics.c | 2 +-\n t/unit-tests/u-reftable-block.c | 2 +-\n t/unit-tests/u-reftable-merged.c | 2 +-\n t/unit-tests/u-reftable-pq.c | 2 +-\n t/unit-tests/u-reftable-readwrite.c | 2 +-\n t/unit-tests/u-reftable-record.c | 2 +-\n t/unit-tests/u-reftable-stack.c | 4 +-\n t/unit-tests/u-reftable-table.c | 2 +-\n 15 files changed, 38 insertions(+), 179 deletions(-)\n delete mode 100644 t/unit-tests/lib-reftable-clar.c\n delete mode 100644 t/unit-tests/lib-reftable-clar.h\n\ndiff --git a/Makefile b/Makefile\nindex cbbb2ec05a..25e6558b7b 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -1380,13 +1380,11 @@ CLAR_TEST_SUITES += u-urlmatch-normalization\n CLAR_TEST_PROG = $(UNIT_TEST_BIN)/unit-tests$(X)\n CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o\n-CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o\n-CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n+CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o\n+CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n \n-UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\n UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\n-UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o\n \n # xdiff and reftable libs may in turn depend on what is in libgit.a\n GITLIBS = common-main.o $(LIB_FILE) $(XDIFF_LIB) $(REFTABLE_LIB) $(LIB_FILE)\ndiff --git a/t/Makefile b/t/Makefile\nindex 791e0a0978..757674e727 100644\n--- a/t/Makefile\n+++ b/t/Makefile\n@@ -125,7 +125,6 @@ check-meson:\n \t@mkdir -p mesontmp && \\\n \tprintf \"%s\\n\" \\\n \t\t\"integration_tests t[0-9][0-9][0-9][0-9]-*.sh\" \\\n-\t\t\"unit_test_programs unit-tests/t-*.c\" \\\n \t\t\"clar_test_suites unit-tests/u-*.c\" | \\\n \twhile read -r variable pattern; do \\\n \t\tawk \"/^$$variable = \\[\\$$/ {flag=1 ; next } /^]$$/ { flag=0 } flag { gsub(/^ \\047/, \\\"\\\"); gsub(/\\047,\\$$/, \\\"\\\"); print }\" meson.build >mesontmp/meson.txt && \\\ndiff --git a/t/meson.build b/t/meson.build\nindex fcbb659263..be96a9639f 100644\n--- a/t/meson.build\n+++ b/t/meson.build\n@@ -28,7 +28,7 @@ clar_sources = [\n 'unit-tests/clar/clar.c',\n 'unit-tests/unit-test.c',\n 'unit-tests/lib-oid.c',\n- 'unit-tests/lib-reftable-clar.c'\n+ 'unit-tests/lib-reftable.c'\n ]\n \n clar_decls_h = custom_target(\n@@ -62,25 +62,6 @@ clar_unit_tests = executable('unit-tests',\n )\n test('unit-tests', clar_unit_tests)\n \n-unit_test_programs = [\n-]\n-\n-foreach unit_test_program : unit_test_programs\n- unit_test_name = fs.stem(unit_test_program)\n- unit_test = executable(unit_test_name,\n- sources: [\n- 'unit-tests/test-lib.c',\n- 'unit-tests/lib-reftable.c',\n- unit_test_program,\n- ],\n- dependencies: [libgit_commonmain],\n- )\n- test(unit_test_name, unit_test,\n- workdir: meson.current_source_dir(),\n- timeout: 0,\n- )\n-endforeach\n-\n subdir('helper')\n \n integration_tests = [\ndiff --git a/t/unit-tests/lib-reftable-clar.c b/t/unit-tests/lib-reftable-clar.c\ndeleted file mode 100644\nindex 64e40a106e..0000000000\n--- a/t/unit-tests/lib-reftable-clar.c\n+++ /dev/null\n@@ -1,101 +0,0 @@\n-#include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n-#include \"hex.h\"\n-#include \"parse-options.h\"\n-#include \"reftable/constants.h\"\n-#include \"reftable/writer.h\"\n-#include \"strbuf.h\"\n-#include \"string-list.h\"\n-#include \"strvec.h\"\n-\n-void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id)\n-{\n-\tmemset(p, (uint8_t)i, hash_size(id));\n-}\n-\n-static ssize_t strbuf_writer_write(void *b, const void *data, size_t sz)\n-{\n-\tstrbuf_add(b, data, sz);\n-\treturn sz;\n-}\n-\n-static int strbuf_writer_flush(void *arg UNUSED)\n-{\n-\treturn 0;\n-}\n-\n-struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,\n-\t\t\t\t\t\t struct reftable_write_options *opts)\n-{\n-\tstruct reftable_writer *writer;\n-\tint ret = reftable_writer_new(&writer, &strbuf_writer_write, &strbuf_writer_flush,\n-\t\t\t\t buf, opts);\n-\tcl_assert(!ret);\n-\treturn writer;\n-}\n-\n-void cl_reftable_write_to_buf(struct reftable_buf *buf,\n-\t\t\t struct reftable_ref_record *refs,\n-\t\t\t size_t nrefs,\n-\t\t\t struct reftable_log_record *logs,\n-\t\t\t size_t nlogs,\n-\t\t\t struct reftable_write_options *_opts)\n-{\n-\tstruct reftable_write_options opts = { 0 };\n-\tconst struct reftable_stats *stats;\n-\tstruct reftable_writer *writer;\n-\tuint64_t min = 0xffffffff;\n-\tuint64_t max = 0;\n-\tint ret;\n-\n-\tif (_opts)\n-\t\topts = *_opts;\n-\n-\tfor (size_t i = 0; i < nrefs; i++) {\n-\t\tuint64_t ui = refs[i].update_index;\n-\t\tif (ui > max)\n-\t\t\tmax = ui;\n-\t\tif (ui < min)\n-\t\t\tmin = ui;\n-\t}\n-\tfor (size_t i = 0; i < nlogs; i++) {\n-\t\tuint64_t ui = logs[i].update_index;\n-\t\tif (ui > max)\n-\t\t\tmax = ui;\n-\t\tif (ui < min)\n-\t\t\tmin = ui;\n-\t}\n-\n-\twriter = cl_reftable_strbuf_writer(buf, &opts);\n-\tret = reftable_writer_set_limits(writer, min, max);\n-\tcl_assert_equal_i(ret, 0);\n-\n-\tif (nrefs) {\n-\t\tret = reftable_writer_add_refs(writer, refs, nrefs);\n-\t\tcl_assert_equal_i(ret, 0);\n-\t}\n-\n-\tif (nlogs) {\n-\t\tret = reftable_writer_add_logs(writer, logs, nlogs);\n-\t\tcl_assert_equal_i(ret, 0);\n-\t}\n-\n-\tret = reftable_writer_close(writer);\n-\tcl_assert_equal_i(ret, 0);\n-\n-\tstats = reftable_writer_stats(writer);\n-\tfor (size_t i = 0; i < (size_t)stats->ref_stats.blocks; i++) {\n-\t\tsize_t off = i * (opts.block_size ? opts.block_size\n-\t\t\t\t\t\t : DEFAULT_BLOCK_SIZE);\n-\t\tif (!off)\n-\t\t\toff = header_size(opts.hash_id == REFTABLE_HASH_SHA256 ? 2 : 1);\n-\t\tcl_assert(buf->buf[off] == 'r');\n-\t}\n-\n-\tif (nrefs)\n-\t\tcl_assert(stats->ref_stats.blocks > 0);\n-\tif (nlogs)\n-\t\tcl_assert(stats->log_stats.blocks > 0);\n-\n-\treftable_writer_free(writer);\n-}\ndiff --git a/t/unit-tests/lib-reftable-clar.h b/t/unit-tests/lib-reftable-clar.h\ndeleted file mode 100644\nindex b562648973..0000000000\n--- a/t/unit-tests/lib-reftable-clar.h\n+++ /dev/null\n@@ -1,20 +0,0 @@\n-#include \"git-compat-util.h\"\n-#include \"clar/clar.h\"\n-#include \"clar-decls.h\"\n-#include \"git-compat-util.h\"\n-#include \"reftable/reftable-writer.h\"\n-#include \"strbuf.h\"\n-\n-struct reftable_buf;\n-\n-void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id);\n-\n-struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,\n-\t\t\t\t\t\t struct reftable_write_options *opts);\n-\n-void cl_reftable_write_to_buf(struct reftable_buf *buf,\n-\t\t\t struct reftable_ref_record *refs,\n-\t\t\t size_t nrecords,\n-\t\t\t struct reftable_log_record *logs,\n-\t\t\t size_t nlogs,\n-\t\t\t struct reftable_write_options *opts);\ndiff --git a/t/unit-tests/lib-reftable.c b/t/unit-tests/lib-reftable.c\nindex 8a69612266..fdb5b11a20 100644\n--- a/t/unit-tests/lib-reftable.c\n+++ b/t/unit-tests/lib-reftable.c\n@@ -1,12 +1,14 @@\n-#define DISABLE_SIGN_COMPARE_WARNINGS\n-\n+#include \"unit-test.h\"\n #include \"lib-reftable.h\"\n-#include \"test-lib.h\"\n+#include \"hex.h\"\n+#include \"parse-options.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/writer.h\"\n #include \"strbuf.h\"\n+#include \"string-list.h\"\n+#include \"strvec.h\"\n \n-void t_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id)\n+void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id)\n {\n \tmemset(p, (uint8_t)i, hash_size(id));\n }\n@@ -22,17 +24,17 @@ static int strbuf_writer_flush(void *arg UNUSED)\n \treturn 0;\n }\n \n-struct reftable_writer *t_reftable_strbuf_writer(struct reftable_buf *buf,\n+struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,\n \t\t\t\t\t\t struct reftable_write_options *opts)\n {\n \tstruct reftable_writer *writer;\n \tint ret = reftable_writer_new(&writer, &strbuf_writer_write, &strbuf_writer_flush,\n \t\t\t\t buf, opts);\n-\tcheck(!ret);\n+\tcl_assert(!ret);\n \treturn writer;\n }\n \n-void t_reftable_write_to_buf(struct reftable_buf *buf,\n+void cl_reftable_write_to_buf(struct reftable_buf *buf,\n \t\t\t struct reftable_ref_record *refs,\n \t\t\t size_t nrefs,\n \t\t\t struct reftable_log_record *logs,\n@@ -64,35 +66,36 @@ void t_reftable_write_to_buf(struct reftable_buf *buf,\n \t\t\tmin = ui;\n \t}\n \n-\twriter = t_reftable_strbuf_writer(buf, &opts);\n-\treftable_writer_set_limits(writer, min, max);\n+\twriter = cl_reftable_strbuf_writer(buf, &opts);\n+\tret = reftable_writer_set_limits(writer, min, max);\n+\tcl_assert(!ret);\n \n \tif (nrefs) {\n \t\tret = reftable_writer_add_refs(writer, refs, nrefs);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \t}\n \n \tif (nlogs) {\n \t\tret = reftable_writer_add_logs(writer, logs, nlogs);\n-\t\tcheck_int(ret, ==, 0);\n+\t\tcl_assert_equal_i(ret, 0);\n \t}\n \n \tret = reftable_writer_close(writer);\n-\tcheck_int(ret, ==, 0);\n+\tcl_assert_equal_i(ret, 0);\n \n \tstats = reftable_writer_stats(writer);\n-\tfor (size_t i = 0; i < stats->ref_stats.blocks; i++) {\n+\tfor (size_t i = 0; i < (size_t)stats->ref_stats.blocks; i++) {\n \t\tsize_t off = i * (opts.block_size ? opts.block_size\n \t\t\t\t\t\t : DEFAULT_BLOCK_SIZE);\n \t\tif (!off)\n \t\t\toff = header_size(opts.hash_id == REFTABLE_HASH_SHA256 ? 2 : 1);\n-\t\tcheck_char(buf->buf[off], ==, 'r');\n+\t\tcl_assert(buf->buf[off] == 'r');\n \t}\n \n \tif (nrefs)\n-\t\tcheck_int(stats->ref_stats.blocks, >, 0);\n+\t\tcl_assert(stats->ref_stats.blocks > 0);\n \tif (nlogs)\n-\t\tcheck_int(stats->log_stats.blocks, >, 0);\n+\t\tcl_assert(stats->log_stats.blocks > 0);\n \n \treftable_writer_free(writer);\n }\ndiff --git a/t/unit-tests/lib-reftable.h b/t/unit-tests/lib-reftable.h\nindex e4c360fa7e..d7e6d3136f 100644\n--- a/t/unit-tests/lib-reftable.h\n+++ b/t/unit-tests/lib-reftable.h\n@@ -1,21 +1,20 @@\n-#ifndef LIB_REFTABLE_H\n-#define LIB_REFTABLE_H\n-\n+#include \"git-compat-util.h\"\n+#include \"clar/clar.h\"\n+#include \"clar-decls.h\"\n #include \"git-compat-util.h\"\n #include \"reftable/reftable-writer.h\"\n+#include \"strbuf.h\"\n \n struct reftable_buf;\n \n-void t_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id);\n+void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id);\n \n-struct reftable_writer *t_reftable_strbuf_writer(struct reftable_buf *buf,\n+struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,\n \t\t\t\t\t\t struct reftable_write_options *opts);\n \n-void t_reftable_write_to_buf(struct reftable_buf *buf,\n+void cl_reftable_write_to_buf(struct reftable_buf *buf,\n \t\t\t struct reftable_ref_record *refs,\n \t\t\t size_t nrecords,\n \t\t\t struct reftable_log_record *logs,\n \t\t\t size_t nlogs,\n \t\t\t struct reftable_write_options *opts);\n-\n-#endif\ndiff --git a/t/unit-tests/u-reftable-basics.c b/t/unit-tests/u-reftable-basics.c\nindex f105c22d15..a0471083e7 100644\n--- a/t/unit-tests/u-reftable-basics.c\n+++ b/t/unit-tests/u-reftable-basics.c\n@@ -7,7 +7,7 @@ license that can be found in the LICENSE file or at\n */\n \n #include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/basics.h\"\n \n struct integer_needle_lesseq_args {\ndiff --git a/t/unit-tests/u-reftable-block.c b/t/unit-tests/u-reftable-block.c\nindex 97a1348563..f4bded7d26 100644\n--- a/t/unit-tests/u-reftable-block.c\n+++ b/t/unit-tests/u-reftable-block.c\n@@ -7,7 +7,7 @@ license that can be found in the LICENSE file or at\n */\n \n #include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/block.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/constants.h\"\ndiff --git a/t/unit-tests/u-reftable-merged.c b/t/unit-tests/u-reftable-merged.c\nindex 62b02baa14..54cb7fc2a7 100644\n--- a/t/unit-tests/u-reftable-merged.c\n+++ b/t/unit-tests/u-reftable-merged.c\n@@ -7,7 +7,7 @@ license that can be found in the LICENSE file or at\n */\n \n #include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/merged.h\"\ndiff --git a/t/unit-tests/u-reftable-pq.c b/t/unit-tests/u-reftable-pq.c\nindex d55792ca6f..f8a28f6e07 100644\n--- a/t/unit-tests/u-reftable-pq.c\n+++ b/t/unit-tests/u-reftable-pq.c\n@@ -7,7 +7,7 @@ license that can be found in the LICENSE file or at\n */\n \n #include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/pq.h\"\n #include \"strbuf.h\"\ndiff --git a/t/unit-tests/u-reftable-readwrite.c b/t/unit-tests/u-reftable-readwrite.c\nindex 9aac74a011..4d8c4be5f1 100644\n--- a/t/unit-tests/u-reftable-readwrite.c\n+++ b/t/unit-tests/u-reftable-readwrite.c\n@@ -9,7 +9,7 @@ license that can be found in the LICENSE file or at\n #define DISABLE_SIGN_COMPARE_WARNINGS\n \n #include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/basics.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/reftable-error.h\"\ndiff --git a/t/unit-tests/u-reftable-record.c b/t/unit-tests/u-reftable-record.c\nindex 650b0aa0d3..6c8c0d5374 100644\n--- a/t/unit-tests/u-reftable-record.c\n+++ b/t/unit-tests/u-reftable-record.c\n@@ -7,7 +7,7 @@\n */\n \n #include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/basics.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/record.h\"\ndiff --git a/t/unit-tests/u-reftable-stack.c b/t/unit-tests/u-reftable-stack.c\nindex 0e3e3f4f4a..e4ea57138e 100644\n--- a/t/unit-tests/u-reftable-stack.c\n+++ b/t/unit-tests/u-reftable-stack.c\n@@ -10,7 +10,7 @@ license that can be found in the LICENSE file or at\n \n #include \"unit-test.h\"\n #include \"dir.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/merged.h\"\n #include \"reftable/reftable-error.h\"\n #include \"reftable/stack.h\"\n@@ -497,7 +497,7 @@ void test_reftable_stack__add(void)\n \tstruct reftable_buf path = REFTABLE_BUF_INIT;\n \tstruct stat stat_result;\n \tsize_t i, N = ARRAY_SIZE(refs);\n-\tint err;\n+\tint err = 0;\n \n \terr = reftable_new_stack(&st, dir, &opts);\n \tcl_assert(!err);\ndiff --git a/t/unit-tests/u-reftable-table.c b/t/unit-tests/u-reftable-table.c\nindex 839107d8a4..14fae8b199 100644\n--- a/t/unit-tests/u-reftable-table.c\n+++ b/t/unit-tests/u-reftable-table.c\n@@ -1,5 +1,5 @@\n #include \"unit-test.h\"\n-#include \"lib-reftable-clar.h\"\n+#include \"lib-reftable.h\"\n #include \"reftable/blocksource.h\"\n #include \"reftable/constants.h\"\n #include \"reftable/iter.h\"\n-- \n2.43.0\n\n"},{"id":"522679","messageId":"aIJGNGxhkz9CESFu@pks.im","threadId":"63589","inReplyTo":"20250724142837.67149-1-kuforiji98@gmail.com","subject":"Re: [PATCH v5 00/10] t/unit-tests: convert unit-tests to use clar","fromName":"Patrick Steinhardt","fromEmail":"ps@pks.im","sentAt":"2025-07-24T14:41:56Z","receivedAt":"2025-07-24T14:42:03Z","isPatch":true,"sender":{"key":"ps@pks.im","avatar":"https://avatars.githubusercontent.com/u/4056630?v=4"},"body":"On Thu, Jul 24, 2025 at 03:28:27PM +0100, Seyi Kufoiji wrote:\n> Range-diff against v4:\n> -: ---------- > 1: 4a04557ae3 t/unit-tests: implement clar specific reftable test helper functions\n> -: ---------- > 2: 2c576ddd11 t/unit-tests: convert reftable basics test to use clar test framework\n> -: ---------- > 3: 04d54fef89 t/unit-tests: convert reftable block test to use clar\n> -: ---------- > 4: 06eba27f8e t/unit-tests: convert reftable merged test to use clar\n> -: ---------- > 5: eaa8b8d636 t/unit-tests: convert reftable pq test to use clar\n\nSomething here went wrong. :) But the remainder of the range-diff looks\nexactly like I'd expect it to:\n\n - The Meson change gets moved to the correct commit.\n\n - The missing newline got fixed up.\n\nThanks!\n\nPatrick\n\n> 1: 7c159bd2fe ! 6: cf8b0471fd t/unit-tests: convert reftable table test to use clar\n> @@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o\n> UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))\n> UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\n> UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o\n> -@@ Makefile: $(LIBGIT_HIDDEN_EXPORT): $(LIBGIT_PARTIAL_EXPORT)\n> - \t$(OBJCOPY) --localize-hidden $^ $@\n> - \n> - contrib/libgit-sys/libgitpub.a: $(LIBGIT_HIDDEN_EXPORT)\n> --\t$(AR) $(ARFLAGS) $@ $^\n> -+\t$(AR) $(ARFLAGS) $@ $^\n> - \\ No newline at end of file\n> \n> ## t/meson.build ##\n> @@ t/meson.build: clar_test_suites = [\n> 2: 3ae3b2cf9c = 7: cbe70c5c23 t/unit-tests: convert reftable readwrite test to use clar\n> 3: d4303eb913 ! 8: 38e2198eac t/unit-tests: convert reftable record test to use clar\n> @@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n> UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o\n> \n> ## t/meson.build ##\n> +@@ t/meson.build: clar_test_suites = [\n> + 'unit-tests/u-reftable-merged.c',\n> + 'unit-tests/u-reftable-pq.c',\n> + 'unit-tests/u-reftable-readwrite.c',\n> ++ 'unit-tests/u-reftable-record.c',\n> + 'unit-tests/u-reftable-table.c',\n> + 'unit-tests/u-reftable-tree.c',\n> + 'unit-tests/u-strbuf.c',\n> @@ t/meson.build: clar_unit_tests = executable('unit-tests',\n> test('unit-tests', clar_unit_tests)\n> \n> 4: df582f6e2c ! 9: 8de9dbbd3b t/unit-tests: convert reftable stack test to use clar\n> @@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o\n> \n> ## t/meson.build ##\n> @@ t/meson.build: clar_test_suites = [\n> - 'unit-tests/u-reftable-merged.c',\n> 'unit-tests/u-reftable-pq.c',\n> 'unit-tests/u-reftable-readwrite.c',\n> -+ 'unit-tests/u-reftable-record.c',\n> + 'unit-tests/u-reftable-record.c',\n> + 'unit-tests/u-reftable-stack.c',\n> 'unit-tests/u-reftable-table.c',\n> 'unit-tests/u-reftable-tree.c',\n> 5: 9340e7ce88 ! 10: a69c3370ee t/unit-tests: finalize migration of reftable-related tests\n> @@ Makefile: CLAR_TEST_SUITES += u-urlmatch-normalization\n> \n> # xdiff and reftable libs may in turn depend on what is in libgit.a\n> GITLIBS = common-main.o $(LIB_FILE) $(XDIFF_LIB) $(REFTABLE_LIB) $(LIB_FILE)\n> -@@ Makefile: $(LIBGIT_HIDDEN_EXPORT): $(LIBGIT_PARTIAL_EXPORT)\n> - \t$(OBJCOPY) --localize-hidden $^ $@\n> - \n> - contrib/libgit-sys/libgitpub.a: $(LIBGIT_HIDDEN_EXPORT)\n> --\t$(AR) $(ARFLAGS) $@ $^\n> - \\ No newline at end of file\n> -+\t$(AR) $(ARFLAGS) $@ $^\n> \n> ## t/Makefile ##\n> @@ t/Makefile: check-meson:\n> -- \n> 2.43.0\n> \n"},{"id":"522699","messageId":"xmqq34alh1c4.fsf@gitster.g","threadId":"63589","inReplyTo":"aIJGNGxhkz9CESFu@pks.im","subject":"Re: [PATCH v5 00/10] t/unit-tests: convert unit-tests to use clar","fromName":"Junio C Hamano","fromEmail":"gitster@pobox.com","sentAt":"2025-07-24T18:48:27Z","receivedAt":"2025-07-24T18:48:31Z","isPatch":true,"sender":{"key":"gitster@pobox.com","avatar":"https://avatars.githubusercontent.com/u/54884?v=4"},"body":"Patrick Steinhardt writes:\n\n> Something here went wrong. :) But the remainder of the range-diff looks\n> exactly like I'd expect it to:\n>\n> - The Meson change gets moved to the correct commit.\n>\n> - The missing newline got fixed up.\n>\n> Thanks!\n\nLooking good.\n\nLet's mark the topic for 'next'.\n\nThanks, both of you.\n"}]}