kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

t/unit-tests: convert reftable merged test to use clar 

Adapt reftable merged test file to use clar testing framework by using
clar assertions where necessary.

Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
Seyi Kuforiji 2025-07-24 15:28:31 +01:00 committed by Junio C Hamano
parent a83bf04d8b
commit c7784ba600
3 changed files with 72 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -1366,6 +1366,7 @@ CLAR_TEST_SUITES += u-oidtree
CLAR_TEST_SUITES += u-prio-queue CLAR_TEST_SUITES += u-prio-queue
CLAR_TEST_SUITES += u-reftable-basics CLAR_TEST_SUITES += u-reftable-basics
CLAR_TEST_SUITES += u-reftable-block CLAR_TEST_SUITES += u-reftable-block
CLAR_TEST_SUITES += u-reftable-merged
CLAR_TEST_SUITES += u-reftable-tree CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf CLAR_TEST_SUITES += u-strbuf
CLAR_TEST_SUITES += u-strcmp-offset CLAR_TEST_SUITES += u-strcmp-offset
@ -1379,7 +1380,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o


UNIT_TEST_PROGRAMS += t-reftable-merged
UNIT_TEST_PROGRAMS += t-reftable-pq UNIT_TEST_PROGRAMS += t-reftable-pq
UNIT_TEST_PROGRAMS += t-reftable-readwrite UNIT_TEST_PROGRAMS += t-reftable-readwrite
UNIT_TEST_PROGRAMS += t-reftable-record UNIT_TEST_PROGRAMS += t-reftable-record

2
t/meson.build
View File

@ -10,6 +10,7 @@ clar_test_suites = [
'unit-tests/u-prio-queue.c', 'unit-tests/u-prio-queue.c',
'unit-tests/u-reftable-basics.c', 'unit-tests/u-reftable-basics.c',
'unit-tests/u-reftable-block.c', 'unit-tests/u-reftable-block.c',
'unit-tests/u-reftable-merged.c',
'unit-tests/u-reftable-tree.c', 'unit-tests/u-reftable-tree.c',
'unit-tests/u-strbuf.c', 'unit-tests/u-strbuf.c',
'unit-tests/u-strcmp-offset.c', 'unit-tests/u-strcmp-offset.c',
@ -57,7 +58,6 @@ clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests) test('unit-tests', clar_unit_tests)


unit_test_programs = [ unit_test_programs = [
'unit-tests/t-reftable-merged.c',
'unit-tests/t-reftable-pq.c', 'unit-tests/t-reftable-pq.c',
'unit-tests/t-reftable-readwrite.c', 'unit-tests/t-reftable-readwrite.c',
'unit-tests/t-reftable-record.c', 'unit-tests/t-reftable-record.c',

162
t/unit-tests/t-reftable-merged.c → t/unit-tests/u-reftable-merged.c
View File

@ -6,8 +6,8 @@ license that can be found in the LICENSE file or at
https://developers.google.com/open-source/licenses/bsd https://developers.google.com/open-source/licenses/bsd
*/ */


#include "test-lib.h" #include "unit-test.h"
#include "lib-reftable.h" #include "lib-reftable-clar.h"
#include "reftable/blocksource.h" #include "reftable/blocksource.h"
#include "reftable/constants.h" #include "reftable/constants.h"
#include "reftable/merged.h" #include "reftable/merged.h"
@ -29,21 +29,21 @@ merged_table_from_records(struct reftable_ref_record **refs,
int err; int err;


REFTABLE_CALLOC_ARRAY(*tables, n); REFTABLE_CALLOC_ARRAY(*tables, n);
check(*tables != NULL); cl_assert(*tables != NULL);
REFTABLE_CALLOC_ARRAY(*source, n); REFTABLE_CALLOC_ARRAY(*source, n);
check(*source != NULL); cl_assert(*source != NULL);


for (size_t i = 0; i < n; i++) { for (size_t i = 0; i < n; i++) {
t_reftable_write_to_buf(&buf[i], refs[i], sizes[i], NULL, 0, &opts); cl_reftable_write_to_buf(&buf[i], refs[i], sizes[i], NULL, 0, &opts);
block_source_from_buf(&(*source)[i], &buf[i]); block_source_from_buf(&(*source)[i], &buf[i]);


err = reftable_table_new(&(*tables)[i], &(*source)[i], err = reftable_table_new(&(*tables)[i], &(*source)[i],
"name"); "name");
check(!err); cl_assert(!err);
} }


err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1); err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);
check(!err); cl_assert(!err);
return mt; return mt;
} }


@ -54,7 +54,7 @@ static void tables_destroy(struct reftable_table **tables, const size_t n)
reftable_free(tables); reftable_free(tables);
} }


static void t_merged_single_record(void) void test_reftable_merged__single_record(void)
{ {
struct reftable_ref_record r1[] = { { struct reftable_ref_record r1[] = { {
.refname = (char *) "b", .refname = (char *) "b",
@ -85,13 +85,14 @@ static void t_merged_single_record(void)
int err; int err;


err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF); err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_ref(&it, "a"); err = reftable_iterator_seek_ref(&it, "a");
check(!err); cl_assert(!err);


err = reftable_iterator_next_ref(&it, &ref); err = reftable_iterator_next_ref(&it, &ref);
check(!err); cl_assert(!err);
check(reftable_ref_record_equal(&r2[0], &ref, REFTABLE_HASH_SIZE_SHA1)); cl_assert(reftable_ref_record_equal(&r2[0], &ref,
REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_ref_record_release(&ref); reftable_ref_record_release(&ref);
reftable_iterator_destroy(&it); reftable_iterator_destroy(&it);
tables_destroy(tables, 3); tables_destroy(tables, 3);
@ -101,7 +102,7 @@ static void t_merged_single_record(void)
reftable_free(bs); reftable_free(bs);
} }


static void t_merged_refs(void) void test_reftable_merged__refs(void)
{ {
struct reftable_ref_record r1[] = { struct reftable_ref_record r1[] = {
{ {
@ -165,12 +166,12 @@ static void t_merged_refs(void)
size_t i; size_t i;


err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF); err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_ref(&it, "a"); err = reftable_iterator_seek_ref(&it, "a");
check(!err); cl_assert(err == 0);
check_int(reftable_merged_table_hash_id(mt), ==, REFTABLE_HASH_SHA1); cl_assert_equal_i(reftable_merged_table_hash_id(mt), REFTABLE_HASH_SHA1);
check_int(reftable_merged_table_min_update_index(mt), ==, 1); cl_assert_equal_i(reftable_merged_table_min_update_index(mt), 1);
check_int(reftable_merged_table_max_update_index(mt), ==, 3); cl_assert_equal_i(reftable_merged_table_max_update_index(mt), 3);


while (len < 100) { /* cap loops/recursion. */ while (len < 100) { /* cap loops/recursion. */
struct reftable_ref_record ref = { 0 }; struct reftable_ref_record ref = { 0 };
@ -178,15 +179,15 @@ static void t_merged_refs(void)
if (err > 0) if (err > 0)
break; break;


check(!REFTABLE_ALLOC_GROW(out, len + 1, cap)); cl_assert(REFTABLE_ALLOC_GROW(out, len + 1, cap) == 0);
out[len++] = ref; out[len++] = ref;
} }
reftable_iterator_destroy(&it); reftable_iterator_destroy(&it);


check_int(ARRAY_SIZE(want), ==, len); cl_assert_equal_i(ARRAY_SIZE(want), len);
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
check(reftable_ref_record_equal(want[i], &out[i], cl_assert(reftable_ref_record_equal(want[i], &out[i],
REFTABLE_HASH_SIZE_SHA1)); REFTABLE_HASH_SIZE_SHA1) != 0);
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
reftable_ref_record_release(&out[i]); reftable_ref_record_release(&out[i]);
reftable_free(out); reftable_free(out);
@ -198,7 +199,7 @@ static void t_merged_refs(void)
reftable_free(bs); reftable_free(bs);
} }


static void t_merged_seek_multiple_times(void) void test_reftable_merged__seek_multiple_times(void)
{ {
struct reftable_ref_record r1[] = { struct reftable_ref_record r1[] = {
{ {
@ -248,20 +249,17 @@ static void t_merged_seek_multiple_times(void)


for (size_t i = 0; i < 5; i++) { for (size_t i = 0; i < 5; i++) {
int err = reftable_iterator_seek_ref(&it, "c"); int err = reftable_iterator_seek_ref(&it, "c");
check(!err); cl_assert(!err);


err = reftable_iterator_next_ref(&it, &rec); cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
check(!err); cl_assert_equal_i(reftable_ref_record_equal(&rec, &r1[1],
err = reftable_ref_record_equal(&rec, &r1[1], REFTABLE_HASH_SIZE_SHA1); REFTABLE_HASH_SIZE_SHA1), 1);
check(err == 1);


err = reftable_iterator_next_ref(&it, &rec); cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
check(!err); cl_assert_equal_i(reftable_ref_record_equal(&rec, &r2[1],
err = reftable_ref_record_equal(&rec, &r2[1], REFTABLE_HASH_SIZE_SHA1); REFTABLE_HASH_SIZE_SHA1), 1);
check(err == 1);


err = reftable_iterator_next_ref(&it, &rec); cl_assert(reftable_iterator_next_ref(&it, &rec) > 0);
check(err > 0);
} }


for (size_t i = 0; i < ARRAY_SIZE(bufs); i++) for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)
@ -273,7 +271,7 @@ static void t_merged_seek_multiple_times(void)
reftable_free(sources); reftable_free(sources);
} }


static void t_merged_seek_multiple_times_without_draining(void) void test_reftable_merged__seek_multiple_times_no_drain(void)
{ {
struct reftable_ref_record r1[] = { struct reftable_ref_record r1[] = {
{ {
@ -317,24 +315,19 @@ static void t_merged_seek_multiple_times_without_draining(void)
struct reftable_ref_record rec = { 0 }; struct reftable_ref_record rec = { 0 };
struct reftable_iterator it = { 0 }; struct reftable_iterator it = { 0 };
struct reftable_merged_table *mt; struct reftable_merged_table *mt;
int err;


mt = merged_table_from_records(refs, &sources, &tables, sizes, bufs, 2); mt = merged_table_from_records(refs, &sources, &tables, sizes, bufs, 2);
merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF); merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);


err = reftable_iterator_seek_ref(&it, "b"); cl_assert(reftable_iterator_seek_ref(&it, "b") == 0);
check(!err); cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
err = reftable_iterator_next_ref(&it, &rec); cl_assert_equal_i(reftable_ref_record_equal(&rec, &r2[0],
check(!err); REFTABLE_HASH_SIZE_SHA1), 1);
err = reftable_ref_record_equal(&rec, &r2[0], REFTABLE_HASH_SIZE_SHA1);
check(err == 1);


err = reftable_iterator_seek_ref(&it, "a"); cl_assert(reftable_iterator_seek_ref(&it, "a") == 0);
check(!err); cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
err = reftable_iterator_next_ref(&it, &rec); cl_assert_equal_i(reftable_ref_record_equal(&rec, &r1[0],
check(!err); REFTABLE_HASH_SIZE_SHA1), 1);
err = reftable_ref_record_equal(&rec, &r1[0], REFTABLE_HASH_SIZE_SHA1);
check(err == 1);


for (size_t i = 0; i < ARRAY_SIZE(bufs); i++) for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)
reftable_buf_release(&bufs[i]); reftable_buf_release(&bufs[i]);
@ -359,25 +352,25 @@ merged_table_from_log_records(struct reftable_log_record **logs,
int err; int err;


REFTABLE_CALLOC_ARRAY(*tables, n); REFTABLE_CALLOC_ARRAY(*tables, n);
check(*tables != NULL); cl_assert(*tables != NULL);
REFTABLE_CALLOC_ARRAY(*source, n); REFTABLE_CALLOC_ARRAY(*source, n);
check(*source != NULL); cl_assert(*source != NULL);


for (size_t i = 0; i < n; i++) { for (size_t i = 0; i < n; i++) {
t_reftable_write_to_buf(&buf[i], NULL, 0, logs[i], sizes[i], &opts); cl_reftable_write_to_buf(&buf[i], NULL, 0, logs[i], sizes[i], &opts);
block_source_from_buf(&(*source)[i], &buf[i]); block_source_from_buf(&(*source)[i], &buf[i]);


err = reftable_table_new(&(*tables)[i], &(*source)[i], err = reftable_table_new(&(*tables)[i], &(*source)[i],
"name"); "name");
check(!err); cl_assert(!err);
} }


err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1); err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);
check(!err); cl_assert(!err);
return mt; return mt;
} }


static void t_merged_logs(void) void test_reftable_merged__logs(void)
{ {
struct reftable_log_record r1[] = { struct reftable_log_record r1[] = {
{ {
@ -439,19 +432,19 @@ static void t_merged_logs(void)
struct reftable_merged_table *mt = merged_table_from_log_records( struct reftable_merged_table *mt = merged_table_from_log_records(
logs, &bs, &tables, sizes, bufs, 3); logs, &bs, &tables, sizes, bufs, 3);
struct reftable_iterator it = { 0 }; struct reftable_iterator it = { 0 };
int err;
struct reftable_log_record *out = NULL; struct reftable_log_record *out = NULL;
size_t len = 0; size_t len = 0;
size_t cap = 0; size_t cap = 0;
size_t i; size_t i;
int err;


err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG); err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_log(&it, "a"); err = reftable_iterator_seek_log(&it, "a");
check(!err); cl_assert(!err);
check_int(reftable_merged_table_hash_id(mt), ==, REFTABLE_HASH_SHA1); cl_assert_equal_i(reftable_merged_table_hash_id(mt), REFTABLE_HASH_SHA1);
check_int(reftable_merged_table_min_update_index(mt), ==, 1); cl_assert_equal_i(reftable_merged_table_min_update_index(mt), 1);
check_int(reftable_merged_table_max_update_index(mt), ==, 3); cl_assert_equal_i(reftable_merged_table_max_update_index(mt), 3);


while (len < 100) { /* cap loops/recursion. */ while (len < 100) { /* cap loops/recursion. */
struct reftable_log_record log = { 0 }; struct reftable_log_record log = { 0 };
@ -459,24 +452,24 @@ static void t_merged_logs(void)
if (err > 0) if (err > 0)
break; break;


check(!REFTABLE_ALLOC_GROW(out, len + 1, cap)); cl_assert(REFTABLE_ALLOC_GROW(out, len + 1, cap) == 0);
out[len++] = log; out[len++] = log;
} }
reftable_iterator_destroy(&it); reftable_iterator_destroy(&it);


check_int(ARRAY_SIZE(want), ==, len); cl_assert_equal_i(ARRAY_SIZE(want), len);
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
check(reftable_log_record_equal(want[i], &out[i], cl_assert(reftable_log_record_equal(want[i], &out[i],
REFTABLE_HASH_SIZE_SHA1)); REFTABLE_HASH_SIZE_SHA1) != 0);


err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG); err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_log_at(&it, "a", 2); err = reftable_iterator_seek_log_at(&it, "a", 2);
check(!err); cl_assert(!err);
reftable_log_record_release(&out[0]); reftable_log_record_release(&out[0]);
err = reftable_iterator_next_log(&it, &out[0]); cl_assert(reftable_iterator_next_log(&it, &out[0]) == 0);
check(!err); cl_assert(reftable_log_record_equal(&out[0], &r3[0],
check(reftable_log_record_equal(&out[0], &r3[0], REFTABLE_HASH_SIZE_SHA1)); REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_iterator_destroy(&it); reftable_iterator_destroy(&it);


for (i = 0; i < len; i++) for (i = 0; i < len; i++)
@ -490,11 +483,11 @@ static void t_merged_logs(void)
reftable_free(bs); reftable_free(bs);
} }


static void t_default_write_opts(void) void test_reftable_merged__default_write_opts(void)
{ {
struct reftable_write_options opts = { 0 }; struct reftable_write_options opts = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts); struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_ref_record rec = { struct reftable_ref_record rec = {
.refname = (char *) "master", .refname = (char *) "master",
.update_index = 1, .update_index = 1,
@ -507,40 +500,25 @@ static void t_default_write_opts(void)


reftable_writer_set_limits(w, 1, 1); reftable_writer_set_limits(w, 1, 1);


err = reftable_writer_add_ref(w, &rec); cl_assert_equal_i(reftable_writer_add_ref(w, &rec), 0);
check(!err);


err = reftable_writer_close(w); cl_assert_equal_i(reftable_writer_close(w), 0);
check(!err);
reftable_writer_free(w); reftable_writer_free(w);


block_source_from_buf(&source, &buf); block_source_from_buf(&source, &buf);


err = reftable_table_new(&table, &source, "filename"); err = reftable_table_new(&table, &source, "filename");
check(!err); cl_assert(!err);


hash_id = reftable_table_hash_id(table); hash_id = reftable_table_hash_id(table);
check_int(hash_id, ==, REFTABLE_HASH_SHA1); cl_assert_equal_i(hash_id, REFTABLE_HASH_SHA1);


err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA256); err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA256);
check_int(err, ==, REFTABLE_FORMAT_ERROR); cl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);
err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA1); err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA1);
check(!err); cl_assert(!err);


reftable_table_decref(table); reftable_table_decref(table);
reftable_merged_table_free(merged); reftable_merged_table_free(merged);
reftable_buf_release(&buf); reftable_buf_release(&buf);
} }


int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
{
TEST(t_default_write_opts(), "merged table with default write opts");
TEST(t_merged_logs(), "merged table with multiple log updates for same ref");
TEST(t_merged_refs(), "merged table with multiple updates to same ref");
TEST(t_merged_seek_multiple_times(), "merged table can seek multiple times");
TEST(t_merged_seek_multiple_times_without_draining(), "merged table can seek multiple times without draining");
TEST(t_merged_single_record(), "ref occurring in only one record can be fetched");

return test_done();
}