From 18a992b7b7f213deeede5aa923f13f6aee4e206e Mon Sep 17 00:00:00 2001 From: Seyi Kuforiji Date: Thu, 24 Jul 2025 15:28:33 +0100 Subject: t/unit-tests: convert reftable table test to use clar Adapt reftable table test file to use clar by using clar assertions where necessary. Signed-off-by: Seyi Kuforiji Signed-off-by: Junio C Hamano --- t/meson.build | 5 +- t/unit-tests/t-reftable-table.c | 206 ---------------------------------------- t/unit-tests/u-reftable-table.c | 201 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 203 insertions(+), 209 deletions(-) delete mode 100644 t/unit-tests/t-reftable-table.c create mode 100644 t/unit-tests/u-reftable-table.c (limited to 't') diff --git a/t/meson.build b/t/meson.build index ac4394b7a2..46d3a8580b 100644 --- a/t/meson.build +++ b/t/meson.build @@ -12,6 +12,7 @@ clar_test_suites = [ 'unit-tests/u-reftable-block.c', 'unit-tests/u-reftable-merged.c', 'unit-tests/u-reftable-pq.c', + 'unit-tests/u-reftable-table.c', 'unit-tests/u-reftable-tree.c', 'unit-tests/u-strbuf.c', 'unit-tests/u-strcmp-offset.c', @@ -59,11 +60,9 @@ clar_unit_tests = executable('unit-tests', test('unit-tests', clar_unit_tests) unit_test_programs = [ - 'unit-tests/t-reftable-reader.c', 'unit-tests/t-reftable-readwrite.c', 'unit-tests/t-reftable-record.c', 'unit-tests/t-reftable-stack.c', - 'unit-tests/t-reftable-table.c', ] foreach unit_test_program : unit_test_programs @@ -1233,4 +1232,4 @@ if perl.found() and time.found() timeout: 0, ) endforeach -endif +endif \ No newline at end of file diff --git a/t/unit-tests/t-reftable-table.c b/t/unit-tests/t-reftable-table.c deleted file mode 100644 index 7e1eb533d0..0000000000 --- a/t/unit-tests/t-reftable-table.c +++ /dev/null @@ -1,206 +0,0 @@ -#include "test-lib.h" -#include "lib-reftable.h" -#include "reftable/blocksource.h" -#include "reftable/constants.h" -#include "reftable/iter.h" -#include "reftable/table.h" -#include "strbuf.h" - -static int t_table_seek_once(void) -{ - struct reftable_ref_record records[] = { - { - .refname = (char *) "refs/heads/main", - .value_type = REFTABLE_REF_VAL1, - .value.val1 = { 42 }, - }, - }; - struct reftable_block_source source = { 0 }; - struct reftable_ref_record ref = { 0 }; - struct reftable_iterator it = { 0 }; - struct reftable_table *table; - struct reftable_buf buf = REFTABLE_BUF_INIT; - int ret; - - t_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL); - block_source_from_buf(&source, &buf); - - ret = reftable_table_new(&table, &source, "name"); - check(!ret); - - reftable_table_init_ref_iterator(table, &it); - ret = reftable_iterator_seek_ref(&it, ""); - check(!ret); - ret = reftable_iterator_next_ref(&it, &ref); - check(!ret); - - ret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1); - check_int(ret, ==, 1); - - ret = reftable_iterator_next_ref(&it, &ref); - check_int(ret, ==, 1); - - reftable_ref_record_release(&ref); - reftable_iterator_destroy(&it); - reftable_table_decref(table); - reftable_buf_release(&buf); - return 0; -} - -static int t_table_reseek(void) -{ - struct reftable_ref_record records[] = { - { - .refname = (char *) "refs/heads/main", - .value_type = REFTABLE_REF_VAL1, - .value.val1 = { 42 }, - }, - }; - struct reftable_block_source source = { 0 }; - struct reftable_ref_record ref = { 0 }; - struct reftable_iterator it = { 0 }; - struct reftable_table *table; - struct reftable_buf buf = REFTABLE_BUF_INIT; - int ret; - - t_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL); - block_source_from_buf(&source, &buf); - - ret = reftable_table_new(&table, &source, "name"); - check(!ret); - - reftable_table_init_ref_iterator(table, &it); - - for (size_t i = 0; i < 5; i++) { - ret = reftable_iterator_seek_ref(&it, ""); - check(!ret); - ret = reftable_iterator_next_ref(&it, &ref); - check(!ret); - - ret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1); - check_int(ret, ==, 1); - - ret = reftable_iterator_next_ref(&it, &ref); - check_int(ret, ==, 1); - } - - reftable_ref_record_release(&ref); - reftable_iterator_destroy(&it); - reftable_table_decref(table); - reftable_buf_release(&buf); - return 0; -} - -static int t_table_block_iterator(void) -{ - struct reftable_block_source source = { 0 }; - struct reftable_table_iterator it = { 0 }; - struct reftable_ref_record *records; - const struct reftable_block *block; - struct reftable_table *table; - struct reftable_buf buf = REFTABLE_BUF_INIT; - struct { - uint8_t block_type; - uint16_t header_off; - uint16_t restart_count; - uint16_t record_count; - } expected_blocks[] = { - { - .block_type = REFTABLE_BLOCK_TYPE_REF, - .header_off = 24, - .restart_count = 10, - .record_count = 158, - }, - { - .block_type = REFTABLE_BLOCK_TYPE_REF, - .restart_count = 10, - .record_count = 159, - }, - { - .block_type = REFTABLE_BLOCK_TYPE_REF, - .restart_count = 10, - .record_count = 159, - }, - { - .block_type = REFTABLE_BLOCK_TYPE_REF, - .restart_count = 2, - .record_count = 24, - }, - { - .block_type = REFTABLE_BLOCK_TYPE_INDEX, - .restart_count = 1, - .record_count = 4, - }, - { - .block_type = REFTABLE_BLOCK_TYPE_OBJ, - .restart_count = 1, - .record_count = 1, - }, - }; - const size_t nrecords = 500; - int ret; - - REFTABLE_CALLOC_ARRAY(records, nrecords); - for (size_t i = 0; i < nrecords; i++) { - records[i].value_type = REFTABLE_REF_VAL1; - records[i].refname = xstrfmt("refs/heads/branch-%03"PRIuMAX, - (uintmax_t) i); - } - - t_reftable_write_to_buf(&buf, records, nrecords, NULL, 0, NULL); - block_source_from_buf(&source, &buf); - - ret = reftable_table_new(&table, &source, "name"); - check(!ret); - - ret = reftable_table_iterator_init(&it, table); - check(!ret); - - for (size_t i = 0; i < ARRAY_SIZE(expected_blocks); i++) { - struct reftable_iterator record_it = { 0 }; - struct reftable_record record = { - .type = expected_blocks[i].block_type, - }; - - ret = reftable_table_iterator_next(&it, &block); - check(!ret); - - check_int(block->block_type, ==, expected_blocks[i].block_type); - check_int(block->header_off, ==, expected_blocks[i].header_off); - check_int(block->restart_count, ==, expected_blocks[i].restart_count); - - ret = reftable_block_init_iterator(block, &record_it); - check(!ret); - - for (size_t j = 0; ; j++) { - ret = iterator_next(&record_it, &record); - if (ret > 0) { - check_int(j, ==, expected_blocks[i].record_count); - break; - } - check(!ret); - } - - reftable_iterator_destroy(&record_it); - reftable_record_release(&record); - } - - ret = reftable_table_iterator_next(&it, &block); - check_int(ret, ==, 1); - - for (size_t i = 0; i < nrecords; i++) - reftable_free(records[i].refname); - reftable_table_iterator_release(&it); - reftable_table_decref(table); - reftable_buf_release(&buf); - reftable_free(records); - return 0; -} - -int cmd_main(int argc UNUSED, const char *argv[] UNUSED) -{ - TEST(t_table_seek_once(), "table can seek once"); - TEST(t_table_reseek(), "table can reseek multiple times"); - TEST(t_table_block_iterator(), "table can iterate through blocks"); - return test_done(); -} diff --git a/t/unit-tests/u-reftable-table.c b/t/unit-tests/u-reftable-table.c new file mode 100644 index 0000000000..839107d8a4 --- /dev/null +++ b/t/unit-tests/u-reftable-table.c @@ -0,0 +1,201 @@ +#include "unit-test.h" +#include "lib-reftable-clar.h" +#include "reftable/blocksource.h" +#include "reftable/constants.h" +#include "reftable/iter.h" +#include "reftable/table.h" +#include "strbuf.h" + +void test_reftable_table__seek_once(void) +{ + struct reftable_ref_record records[] = { + { + .refname = (char *) "refs/heads/main", + .value_type = REFTABLE_REF_VAL1, + .value.val1 = { 42 }, + }, + }; + struct reftable_block_source source = { 0 }; + struct reftable_ref_record ref = { 0 }; + struct reftable_iterator it = { 0 }; + struct reftable_table *table; + struct reftable_buf buf = REFTABLE_BUF_INIT; + int ret; + + cl_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL); + block_source_from_buf(&source, &buf); + + ret = reftable_table_new(&table, &source, "name"); + cl_assert(!ret); + + reftable_table_init_ref_iterator(table, &it); + ret = reftable_iterator_seek_ref(&it, ""); + cl_assert(!ret); + ret = reftable_iterator_next_ref(&it, &ref); + cl_assert(!ret); + + ret = reftable_ref_record_equal(&ref, &records[0], + REFTABLE_HASH_SIZE_SHA1); + cl_assert_equal_i(ret, 1); + + ret = reftable_iterator_next_ref(&it, &ref); + cl_assert_equal_i(ret, 1); + + reftable_ref_record_release(&ref); + reftable_iterator_destroy(&it); + reftable_table_decref(table); + reftable_buf_release(&buf); +} + +void test_reftable_table__reseek(void) +{ + struct reftable_ref_record records[] = { + { + .refname = (char *) "refs/heads/main", + .value_type = REFTABLE_REF_VAL1, + .value.val1 = { 42 }, + }, + }; + struct reftable_block_source source = { 0 }; + struct reftable_ref_record ref = { 0 }; + struct reftable_iterator it = { 0 }; + struct reftable_table *table; + struct reftable_buf buf = REFTABLE_BUF_INIT; + int ret; + + cl_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), + NULL, 0, NULL); + block_source_from_buf(&source, &buf); + + ret = reftable_table_new(&table, &source, "name"); + cl_assert(!ret); + + reftable_table_init_ref_iterator(table, &it); + + for (size_t i = 0; i < 5; i++) { + ret = reftable_iterator_seek_ref(&it, ""); + cl_assert(!ret); + ret = reftable_iterator_next_ref(&it, &ref); + cl_assert(!ret); + + ret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1); + cl_assert_equal_i(ret, 1); + + ret = reftable_iterator_next_ref(&it, &ref); + cl_assert_equal_i(ret, 1); + } + + reftable_ref_record_release(&ref); + reftable_iterator_destroy(&it); + reftable_table_decref(table); + reftable_buf_release(&buf); +} + +void test_reftable_table__block_iterator(void) +{ + struct reftable_block_source source = { 0 }; + struct reftable_table_iterator it = { 0 }; + struct reftable_ref_record *records; + const struct reftable_block *block; + struct reftable_table *table; + struct reftable_buf buf = REFTABLE_BUF_INIT; + struct { + uint8_t block_type; + uint16_t header_off; + uint16_t restart_count; + uint16_t record_count; + } expected_blocks[] = { + { + .block_type = REFTABLE_BLOCK_TYPE_REF, + .header_off = 24, + .restart_count = 10, + .record_count = 158, + }, + { + .block_type = REFTABLE_BLOCK_TYPE_REF, + .restart_count = 10, + .record_count = 159, + }, + { + .block_type = REFTABLE_BLOCK_TYPE_REF, + .restart_count = 10, + .record_count = 159, + }, + { + .block_type = REFTABLE_BLOCK_TYPE_REF, + .restart_count = 2, + .record_count = 24, + }, + { + .block_type = REFTABLE_BLOCK_TYPE_INDEX, + .restart_count = 1, + .record_count = 4, + }, + { + .block_type = REFTABLE_BLOCK_TYPE_OBJ, + .restart_count = 1, + .record_count = 1, + }, + }; + const size_t nrecords = 500; + int ret; + + REFTABLE_CALLOC_ARRAY(records, nrecords); + for (size_t i = 0; i < nrecords; i++) { + records[i].value_type = REFTABLE_REF_VAL1; + records[i].refname = xstrfmt("refs/heads/branch-%03"PRIuMAX, + (uintmax_t) i); + } + + cl_reftable_write_to_buf(&buf, records, nrecords, NULL, 0, NULL); + block_source_from_buf(&source, &buf); + + ret = reftable_table_new(&table, &source, "name"); + cl_assert(!ret); + + ret = reftable_table_iterator_init(&it, table); + cl_assert(!ret); + + for (size_t i = 0; i < ARRAY_SIZE(expected_blocks); i++) { + struct reftable_iterator record_it = { 0 }; + struct reftable_record record = { + .type = expected_blocks[i].block_type, + }; + + ret = reftable_table_iterator_next(&it, &block); + cl_assert(!ret); + + cl_assert_equal_i(block->block_type, + expected_blocks[i].block_type); + cl_assert_equal_i(block->header_off, + expected_blocks[i].header_off); + cl_assert_equal_i(block->restart_count, + expected_blocks[i].restart_count); + + ret = reftable_block_init_iterator(block, &record_it); + cl_assert(!ret); + + for (size_t j = 0; ; j++) { + ret = iterator_next(&record_it, &record); + if (ret > 0) { + cl_assert_equal_i(j, + expected_blocks[i].record_count); + break; + } + cl_assert(!ret); + } + + reftable_iterator_destroy(&record_it); + reftable_record_release(&record); + } + + ret = reftable_table_iterator_next(&it, &block); + cl_assert_equal_i(ret, 1); + + for (size_t i = 0; i < nrecords; i++) + reftable_free(records[i].refname); + reftable_table_iterator_release(&it); + reftable_table_decref(table); + reftable_buf_release(&buf); + reftable_free(records); +} -- cgit v1.3