@matheusbsbs / matheus-bagliano / commits / c7784ba600

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>

Seyi Kuforiji committed Jul 24, 2025 at 15:28 UTC c7784ba6002e020472bdff55995cc1f6f252f09b

3 files changed +72 -94

Makefile

+1 -1

@@ -1366,6 +1366,7 @@ CLAR_TEST_SUITES += u-oidtree

1366 CLAR_TEST_SUITES += u-prio-queue

1367 CLAR_TEST_SUITES += u-reftable-basics

1368 CLAR_TEST_SUITES += u-reftable-block

1369 +CLAR_TEST_SUITES += u-reftable-merged

1370 CLAR_TEST_SUITES += u-reftable-tree

1371 CLAR_TEST_SUITES += u-strbuf

1372 CLAR_TEST_SUITES += u-strcmp-offset

@@ -1379,7 +1380,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o

1380 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o

1381 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o

1382

1382 -UNIT_TEST_PROGRAMS += t-reftable-merged

1383 UNIT_TEST_PROGRAMS += t-reftable-pq

1384 UNIT_TEST_PROGRAMS += t-reftable-readwrite

1385 UNIT_TEST_PROGRAMS += t-reftable-record

t/meson.build

+1 -1

@@ -10,6 +10,7 @@ clar_test_suites = [

10 'unit-tests/u-prio-queue.c',

11 'unit-tests/u-reftable-basics.c',

12 'unit-tests/u-reftable-block.c',

13 + 'unit-tests/u-reftable-merged.c',

14 'unit-tests/u-reftable-tree.c',

15 'unit-tests/u-strbuf.c',

16 'unit-tests/u-strcmp-offset.c',

@@ -57,7 +58,6 @@ clar_unit_tests = executable('unit-tests',

58 test('unit-tests', clar_unit_tests)

60 unit_test_programs = [

60 - 'unit-tests/t-reftable-merged.c',

61 'unit-tests/t-reftable-pq.c',

62 'unit-tests/t-reftable-readwrite.c',

63 'unit-tests/t-reftable-record.c',

t/unit-tests/u-reftable-merged.c renamed

+70 -92

@@ -6,8 +6,8 @@ license that can be found in the LICENSE file or at

6 https://developers.google.com/open-source/licenses/bsd

7 */

9 -#include "test-lib.h"

10 -#include "lib-reftable.h"

9 +#include "unit-test.h"

10 +#include "lib-reftable-clar.h"

11 #include "reftable/blocksource.h"

12 #include "reftable/constants.h"

13 #include "reftable/merged.h"

@@ -29,21 +29,21 @@ merged_table_from_records(struct reftable_ref_record **refs,

29 int err;

31 REFTABLE_CALLOC_ARRAY(*tables, n);

32 - check(*tables != NULL);

32 + cl_assert(*tables != NULL);

33 REFTABLE_CALLOC_ARRAY(*source, n);

34 - check(*source != NULL);

34 + cl_assert(*source != NULL);

36 for (size_t i = 0; i < n; i++) {

37 - t_reftable_write_to_buf(&buf[i], refs[i], sizes[i], NULL, 0, &opts);

37 + cl_reftable_write_to_buf(&buf[i], refs[i], sizes[i], NULL, 0, &opts);

38 block_source_from_buf(&(*source)[i], &buf[i]);

40 err = reftable_table_new(&(*tables)[i], &(*source)[i],

41 "name");

42 - check(!err);

42 + cl_assert(!err);

43 }

45 err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);

46 - check(!err);

46 + cl_assert(!err);

47 return mt;

48 }

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

54 reftable_free(tables);

55 }

57 -static void t_merged_single_record(void)

57 +void test_reftable_merged__single_record(void)

58 {

59 struct reftable_ref_record r1[] = { {

60 .refname = (char *) "b",

@@ -85,13 +85,14 @@ static void t_merged_single_record(void)

85 int err;

87 err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);

88 - check(!err);

88 + cl_assert(!err);

89 err = reftable_iterator_seek_ref(&it, "a");

90 - check(!err);

90 + cl_assert(!err);

92 err = reftable_iterator_next_ref(&it, &ref);

93 - check(!err);

94 - check(reftable_ref_record_equal(&r2[0], &ref, REFTABLE_HASH_SIZE_SHA1));

93 + cl_assert(!err);

94 + cl_assert(reftable_ref_record_equal(&r2[0], &ref,

95 + REFTABLE_HASH_SIZE_SHA1) != 0);

96 reftable_ref_record_release(&ref);

97 reftable_iterator_destroy(&it);

98 tables_destroy(tables, 3);

@@ -101,7 +102,7 @@ static void t_merged_single_record(void)

102 reftable_free(bs);

103 }

104

104 -static void t_merged_refs(void)

105 +void test_reftable_merged__refs(void)

106 {

107 struct reftable_ref_record r1[] = {

108 {

@@ -165,12 +166,12 @@ static void t_merged_refs(void)

166 size_t i;

167

168 err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);

168 - check(!err);

169 + cl_assert(!err);

170 err = reftable_iterator_seek_ref(&it, "a");

170 - check(!err);

171 - check_int(reftable_merged_table_hash_id(mt), ==, REFTABLE_HASH_SHA1);

172 - check_int(reftable_merged_table_min_update_index(mt), ==, 1);

173 - check_int(reftable_merged_table_max_update_index(mt), ==, 3);

171 + cl_assert(err == 0);

172 + cl_assert_equal_i(reftable_merged_table_hash_id(mt), REFTABLE_HASH_SHA1);

173 + cl_assert_equal_i(reftable_merged_table_min_update_index(mt), 1);

174 + cl_assert_equal_i(reftable_merged_table_max_update_index(mt), 3);

175

176 while (len < 100) { /* cap loops/recursion. */

177 struct reftable_ref_record ref = { 0 };

@@ -178,15 +179,15 @@ static void t_merged_refs(void)

179 if (err > 0)

180 break;

181

181 - check(!REFTABLE_ALLOC_GROW(out, len + 1, cap));

182 + cl_assert(REFTABLE_ALLOC_GROW(out, len + 1, cap) == 0);

183 out[len++] = ref;

184 }

185 reftable_iterator_destroy(&it);

186

186 - check_int(ARRAY_SIZE(want), ==, len);

187 + cl_assert_equal_i(ARRAY_SIZE(want), len);

188 for (i = 0; i < len; i++)

188 - check(reftable_ref_record_equal(want[i], &out[i],

189 - REFTABLE_HASH_SIZE_SHA1));

189 + cl_assert(reftable_ref_record_equal(want[i], &out[i],

190 + REFTABLE_HASH_SIZE_SHA1) != 0);

191 for (i = 0; i < len; i++)

192 reftable_ref_record_release(&out[i]);

193 reftable_free(out);

@@ -198,7 +199,7 @@ static void t_merged_refs(void)

199 reftable_free(bs);

200 }

201

201 -static void t_merged_seek_multiple_times(void)

202 +void test_reftable_merged__seek_multiple_times(void)

203 {

204 struct reftable_ref_record r1[] = {

205 {

@@ -248,20 +249,17 @@ static void t_merged_seek_multiple_times(void)

249

250 for (size_t i = 0; i < 5; i++) {

251 int err = reftable_iterator_seek_ref(&it, "c");

251 - check(!err);

252 + cl_assert(!err);

253

253 - err = reftable_iterator_next_ref(&it, &rec);

254 - check(!err);

255 - err = reftable_ref_record_equal(&rec, &r1[1], REFTABLE_HASH_SIZE_SHA1);

256 - check(err == 1);

254 + cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);

255 + cl_assert_equal_i(reftable_ref_record_equal(&rec, &r1[1],

256 + REFTABLE_HASH_SIZE_SHA1), 1);

257

258 - err = reftable_iterator_next_ref(&it, &rec);

259 - check(!err);

260 - err = reftable_ref_record_equal(&rec, &r2[1], REFTABLE_HASH_SIZE_SHA1);

261 - check(err == 1);

258 + cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);

259 + cl_assert_equal_i(reftable_ref_record_equal(&rec, &r2[1],

260 + REFTABLE_HASH_SIZE_SHA1), 1);

261

263 - err = reftable_iterator_next_ref(&it, &rec);

264 - check(err > 0);

262 + cl_assert(reftable_iterator_next_ref(&it, &rec) > 0);

263 }

264

265 for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)

@@ -273,7 +271,7 @@ static void t_merged_seek_multiple_times(void)

271 reftable_free(sources);

272 }

273

276 -static void t_merged_seek_multiple_times_without_draining(void)

274 +void test_reftable_merged__seek_multiple_times_no_drain(void)

275 {

276 struct reftable_ref_record r1[] = {

277 {

@@ -317,24 +315,19 @@ static void t_merged_seek_multiple_times_without_draining(void)

315 struct reftable_ref_record rec = { 0 };

316 struct reftable_iterator it = { 0 };

317 struct reftable_merged_table *mt;

320 - int err;

318

319 mt = merged_table_from_records(refs, &sources, &tables, sizes, bufs, 2);

320 merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);

321

325 - err = reftable_iterator_seek_ref(&it, "b");

326 - check(!err);

327 - err = reftable_iterator_next_ref(&it, &rec);

328 - check(!err);

329 - err = reftable_ref_record_equal(&rec, &r2[0], REFTABLE_HASH_SIZE_SHA1);

330 - check(err == 1);

322 + cl_assert(reftable_iterator_seek_ref(&it, "b") == 0);

323 + cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);

324 + cl_assert_equal_i(reftable_ref_record_equal(&rec, &r2[0],

325 + REFTABLE_HASH_SIZE_SHA1), 1);

326

332 - err = reftable_iterator_seek_ref(&it, "a");

333 - check(!err);

334 - err = reftable_iterator_next_ref(&it, &rec);

335 - check(!err);

336 - err = reftable_ref_record_equal(&rec, &r1[0], REFTABLE_HASH_SIZE_SHA1);

337 - check(err == 1);

327 + cl_assert(reftable_iterator_seek_ref(&it, "a") == 0);

328 + cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);

329 + cl_assert_equal_i(reftable_ref_record_equal(&rec, &r1[0],

330 + REFTABLE_HASH_SIZE_SHA1), 1);

331

332 for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)

333 reftable_buf_release(&bufs[i]);

@@ -359,25 +352,25 @@ merged_table_from_log_records(struct reftable_log_record **logs,

352 int err;

353

354 REFTABLE_CALLOC_ARRAY(*tables, n);

362 - check(*tables != NULL);

355 + cl_assert(*tables != NULL);

356 REFTABLE_CALLOC_ARRAY(*source, n);

364 - check(*source != NULL);

357 + cl_assert(*source != NULL);

358

359 for (size_t i = 0; i < n; i++) {

367 - t_reftable_write_to_buf(&buf[i], NULL, 0, logs[i], sizes[i], &opts);

360 + cl_reftable_write_to_buf(&buf[i], NULL, 0, logs[i], sizes[i], &opts);

361 block_source_from_buf(&(*source)[i], &buf[i]);

362

363 err = reftable_table_new(&(*tables)[i], &(*source)[i],

364 "name");

372 - check(!err);

365 + cl_assert(!err);

366 }

367

368 err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);

376 - check(!err);

369 + cl_assert(!err);

370 return mt;

371 }

372

380 -static void t_merged_logs(void)

373 +void test_reftable_merged__logs(void)

374 {

375 struct reftable_log_record r1[] = {

376 {

@@ -439,19 +432,19 @@ static void t_merged_logs(void)

432 struct reftable_merged_table *mt = merged_table_from_log_records(

433 logs, &bs, &tables, sizes, bufs, 3);

434 struct reftable_iterator it = { 0 };

442 - int err;

435 struct reftable_log_record *out = NULL;

436 size_t len = 0;

437 size_t cap = 0;

438 size_t i;

439 + int err;

440

441 err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);

449 - check(!err);

442 + cl_assert(!err);

443 err = reftable_iterator_seek_log(&it, "a");

451 - check(!err);

452 - check_int(reftable_merged_table_hash_id(mt), ==, REFTABLE_HASH_SHA1);

453 - check_int(reftable_merged_table_min_update_index(mt), ==, 1);

454 - check_int(reftable_merged_table_max_update_index(mt), ==, 3);

444 + cl_assert(!err);

445 + cl_assert_equal_i(reftable_merged_table_hash_id(mt), REFTABLE_HASH_SHA1);

446 + cl_assert_equal_i(reftable_merged_table_min_update_index(mt), 1);

447 + cl_assert_equal_i(reftable_merged_table_max_update_index(mt), 3);

448

449 while (len < 100) { /* cap loops/recursion. */

450 struct reftable_log_record log = { 0 };

@@ -459,24 +452,24 @@ static void t_merged_logs(void)

452 if (err > 0)

453 break;

454

462 - check(!REFTABLE_ALLOC_GROW(out, len + 1, cap));

455 + cl_assert(REFTABLE_ALLOC_GROW(out, len + 1, cap) == 0);

456 out[len++] = log;

457 }

458 reftable_iterator_destroy(&it);

459

467 - check_int(ARRAY_SIZE(want), ==, len);

460 + cl_assert_equal_i(ARRAY_SIZE(want), len);

461 for (i = 0; i < len; i++)

469 - check(reftable_log_record_equal(want[i], &out[i],

470 - REFTABLE_HASH_SIZE_SHA1));

462 + cl_assert(reftable_log_record_equal(want[i], &out[i],

463 + REFTABLE_HASH_SIZE_SHA1) != 0);

464

465 err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);

473 - check(!err);

466 + cl_assert(!err);

467 err = reftable_iterator_seek_log_at(&it, "a", 2);

475 - check(!err);

468 + cl_assert(!err);

469 reftable_log_record_release(&out[0]);

477 - err = reftable_iterator_next_log(&it, &out[0]);

478 - check(!err);

479 - check(reftable_log_record_equal(&out[0], &r3[0], REFTABLE_HASH_SIZE_SHA1));

470 + cl_assert(reftable_iterator_next_log(&it, &out[0]) == 0);

471 + cl_assert(reftable_log_record_equal(&out[0], &r3[0],

472 + REFTABLE_HASH_SIZE_SHA1) != 0);

473 reftable_iterator_destroy(&it);

474

475 for (i = 0; i < len; i++)

@@ -490,11 +483,11 @@ static void t_merged_logs(void)

483 reftable_free(bs);

484 }

485

493 -static void t_default_write_opts(void)

486 +void test_reftable_merged__default_write_opts(void)

487 {

488 struct reftable_write_options opts = { 0 };

489 struct reftable_buf buf = REFTABLE_BUF_INIT;

497 - struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);

490 + struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);

491 struct reftable_ref_record rec = {

492 .refname = (char *) "master",

493 .update_index = 1,

@@ -507,40 +500,25 @@ static void t_default_write_opts(void)

500

501 reftable_writer_set_limits(w, 1, 1);

502

510 - err = reftable_writer_add_ref(w, &rec);

511 - check(!err);

503 + cl_assert_equal_i(reftable_writer_add_ref(w, &rec), 0);

504

513 - err = reftable_writer_close(w);

514 - check(!err);

505 + cl_assert_equal_i(reftable_writer_close(w), 0);

506 reftable_writer_free(w);

507

508 block_source_from_buf(&source, &buf);

509

510 err = reftable_table_new(&table, &source, "filename");

520 - check(!err);

511 + cl_assert(!err);

512

513 hash_id = reftable_table_hash_id(table);

523 - check_int(hash_id, ==, REFTABLE_HASH_SHA1);

514 + cl_assert_equal_i(hash_id, REFTABLE_HASH_SHA1);

515

516 err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA256);

526 - check_int(err, ==, REFTABLE_FORMAT_ERROR);

517 + cl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);

518 err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA1);

528 - check(!err);

519 + cl_assert(!err);

520

521 reftable_table_decref(table);

522 reftable_merged_table_free(merged);

523 reftable_buf_release(&buf);

524 }

534 -

535 -

536 -int cmd_main(int argc UNUSED, const char *argv[] UNUSED)

537 -{

538 - TEST(t_default_write_opts(), "merged table with default write opts");

539 - TEST(t_merged_logs(), "merged table with multiple log updates for same ref");

540 - TEST(t_merged_refs(), "merged table with multiple updates to same ref");

541 - TEST(t_merged_seek_multiple_times(), "merged table can seek multiple times");

542 - TEST(t_merged_seek_multiple_times_without_draining(), "merged table can seek multiple times without draining");

543 - TEST(t_merged_single_record(), "ref occurring in only one record can be fetched");

544 -

545 - return test_done();

546 -}