@matheusbsbs / matheus-bagliano / commits / a83bf04d8b

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

Adapt reftable block 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 a83bf04d8bb635d17888e4d502f0ce73a5d5f0a3

3 files changed +80 -88

Makefile

+1 -1

@@ -1365,6 +1365,7 @@ CLAR_TEST_SUITES += u-oidmap

1365 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-tree

1370 CLAR_TEST_SUITES += u-strbuf

1371 CLAR_TEST_SUITES += u-strcmp-offset

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

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

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

1381

1381 -UNIT_TEST_PROGRAMS += t-reftable-block

1382 UNIT_TEST_PROGRAMS += t-reftable-merged

1383 UNIT_TEST_PROGRAMS += t-reftable-pq

1384 UNIT_TEST_PROGRAMS += t-reftable-readwrite

t/meson.build

+1 -1

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

9 'unit-tests/u-oidtree.c',

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-tree.c',

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

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

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

57 test('unit-tests', clar_unit_tests)

59 unit_test_programs = [

59 - 'unit-tests/t-reftable-block.c',

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

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

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

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

+78 -86

@@ -6,14 +6,15 @@ 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"

9 +#include "unit-test.h"

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

11 #include "reftable/block.h"

12 #include "reftable/blocksource.h"

13 #include "reftable/constants.h"

14 #include "reftable/reftable-error.h"

15 #include "strbuf.h"

16 -static void t_ref_block_read_write(void)

17 +void test_reftable_block__read_write(void)

18 {

19 const int header_off = 21; /* random */

20 struct reftable_record recs[30];

@@ -34,17 +35,18 @@ static void t_ref_block_read_write(void)

35 struct reftable_buf block_data = REFTABLE_BUF_INIT;

37 REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);

37 - check(block_data.buf != NULL);

38 + cl_assert(block_data.buf != NULL);

39 block_data.len = block_size;

40 - ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_REF, (uint8_t *) block_data.buf, block_size,

41 + ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_REF,

42 + (uint8_t *) block_data.buf, block_size,

43 header_off, hash_size(REFTABLE_HASH_SHA1));

42 - check(!ret);

44 + cl_assert(!ret);

46 rec.u.ref.refname = (char *) "";

47 rec.u.ref.value_type = REFTABLE_REF_DELETION;

48 ret = block_writer_add(&bw, &rec);

47 - check_int(ret, ==, REFTABLE_API_ERROR);

49 + cl_assert_equal_i(ret, REFTABLE_API_ERROR);

51 for (i = 0; i < N; i++) {

52 rec.u.ref.refname = xstrfmt("branch%02"PRIuMAX, (uintmax_t)i);

@@ -55,11 +57,11 @@ static void t_ref_block_read_write(void)

57 ret = block_writer_add(&bw, &rec);

58 rec.u.ref.refname = NULL;

59 rec.u.ref.value_type = REFTABLE_REF_DELETION;

58 - check_int(ret, ==, 0);

60 + cl_assert_equal_i(ret, 0);

61 }

63 ret = block_writer_finish(&bw);

62 - check_int(ret, >, 0);

64 + cl_assert(ret > 0);

66 block_writer_release(&bw);

@@ -71,32 +73,32 @@ static void t_ref_block_read_write(void)

74 for (i = 0; ; i++) {

75 ret = block_iter_next(&it, &rec);

74 - check_int(ret, >=, 0);

76 + cl_assert(ret >= 0);

77 if (ret > 0) {

76 - check_int(i, ==, N);

78 + cl_assert_equal_i(i, N);

79 break;

80 }

79 - check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));

81 + cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);

82 }

84 for (i = 0; i < N; i++) {

85 reftable_record_key(&recs[i], &want);

87 ret = block_iter_seek_key(&it, &want);

86 - check_int(ret, ==, 0);

88 + cl_assert_equal_i(ret, 0);

90 ret = block_iter_next(&it, &rec);

89 - check_int(ret, ==, 0);

91 + cl_assert_equal_i(ret, 0);

91 - check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));

93 + cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);

95 want.len--;

96 ret = block_iter_seek_key(&it, &want);

95 - check_int(ret, ==, 0);

97 + cl_assert_equal_i(ret, 0);

99 ret = block_iter_next(&it, &rec);

98 - check_int(ret, ==, 0);

99 - check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));

100 + cl_assert_equal_i(ret, 0);

101 + cl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);

102 }

103

104 reftable_block_release(&block);

@@ -108,7 +110,7 @@ static void t_ref_block_read_write(void)

110 reftable_record_release(&recs[i]);

111 }

112

111 -static void t_log_block_read_write(void)

113 +void test_reftable_block__log_read_write(void)

114 {

115 const int header_off = 21;

116 struct reftable_record recs[30];

@@ -129,12 +131,12 @@ static void t_log_block_read_write(void)

131 struct reftable_buf block_data = REFTABLE_BUF_INIT;

132

133 REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);

132 - check(block_data.buf != NULL);

134 + cl_assert(block_data.buf != NULL);

135 block_data.len = block_size;

136

137 ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_LOG, (uint8_t *) block_data.buf, block_size,

138 header_off, hash_size(REFTABLE_HASH_SHA1));

137 - check(!ret);

139 + cl_assert(!ret);

140

141 for (i = 0; i < N; i++) {

142 rec.u.log.refname = xstrfmt("branch%02"PRIuMAX , (uintmax_t)i);

@@ -145,11 +147,11 @@ static void t_log_block_read_write(void)

147 ret = block_writer_add(&bw, &rec);

148 rec.u.log.refname = NULL;

149 rec.u.log.value_type = REFTABLE_LOG_DELETION;

148 - check_int(ret, ==, 0);

150 + cl_assert_equal_i(ret, 0);

151 }

152

153 ret = block_writer_finish(&bw);

152 - check_int(ret, >, 0);

154 + cl_assert(ret > 0);

155

156 block_writer_release(&bw);

157

@@ -161,33 +163,33 @@ static void t_log_block_read_write(void)

163

164 for (i = 0; ; i++) {

165 ret = block_iter_next(&it, &rec);

164 - check_int(ret, >=, 0);

166 + cl_assert(ret >= 0);

167 if (ret > 0) {

166 - check_int(i, ==, N);

168 + cl_assert_equal_i(i, N);

169 break;

170 }

169 - check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));

171 + cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);

172 }

173

174 for (i = 0; i < N; i++) {

175 reftable_buf_reset(&want);

174 - check(!reftable_buf_addstr(&want, recs[i].u.log.refname));

176 + cl_assert(reftable_buf_addstr(&want, recs[i].u.log.refname) == 0);

177

178 ret = block_iter_seek_key(&it, &want);

177 - check_int(ret, ==, 0);

179 + cl_assert_equal_i(ret, 0);

180

181 ret = block_iter_next(&it, &rec);

180 - check_int(ret, ==, 0);

182 + cl_assert_equal_i(ret, 0);

183

182 - check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));

184 + cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);

185

186 want.len--;

187 ret = block_iter_seek_key(&it, &want);

186 - check_int(ret, ==, 0);

188 + cl_assert_equal_i(ret, 0);

189

190 ret = block_iter_next(&it, &rec);

189 - check_int(ret, ==, 0);

190 - check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));

191 + cl_assert_equal_i(ret, 0);

192 + cl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);

193 }

194

195 reftable_block_release(&block);

@@ -199,7 +201,7 @@ static void t_log_block_read_write(void)

201 reftable_record_release(&recs[i]);

202 }

203

202 -static void t_obj_block_read_write(void)

204 +void test_reftable_block__obj_read_write(void)

205 {

206 const int header_off = 21;

207 struct reftable_record recs[30];

@@ -220,12 +222,12 @@ static void t_obj_block_read_write(void)

222 struct reftable_buf block_data = REFTABLE_BUF_INIT;

223

224 REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);

223 - check(block_data.buf != NULL);

225 + cl_assert(block_data.buf != NULL);

226 block_data.len = block_size;

227

228 ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_OBJ, (uint8_t *) block_data.buf, block_size,

229 header_off, hash_size(REFTABLE_HASH_SHA1));

228 - check(!ret);

230 + cl_assert(!ret);

231

232 for (i = 0; i < N; i++) {

233 uint8_t bytes[] = { i, i + 1, i + 2, i + 3, i + 5 }, *allocated;

@@ -238,11 +240,11 @@ static void t_obj_block_read_write(void)

240 ret = block_writer_add(&bw, &rec);

241 rec.u.obj.hash_prefix = NULL;

242 rec.u.obj.hash_prefix_len = 0;

241 - check_int(ret, ==, 0);

243 + cl_assert_equal_i(ret, 0);

244 }

245

246 ret = block_writer_finish(&bw);

245 - check_int(ret, >, 0);

247 + cl_assert(ret > 0);

248

249 block_writer_release(&bw);

250

@@ -254,24 +256,24 @@ static void t_obj_block_read_write(void)

256

257 for (i = 0; ; i++) {

258 ret = block_iter_next(&it, &rec);

257 - check_int(ret, >=, 0);

259 + cl_assert(ret >= 0);

260 if (ret > 0) {

259 - check_int(i, ==, N);

261 + cl_assert_equal_i(i, N);

262 break;

263 }

262 - check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));

264 + cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);

265 }

266

267 for (i = 0; i < N; i++) {

268 reftable_record_key(&recs[i], &want);

269

270 ret = block_iter_seek_key(&it, &want);

269 - check_int(ret, ==, 0);

271 + cl_assert_equal_i(ret, 0);

272

273 ret = block_iter_next(&it, &rec);

272 - check_int(ret, ==, 0);

274 + cl_assert_equal_i(ret, 0);

275

274 - check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));

276 + cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);

277 }

278

279 reftable_block_release(&block);

@@ -283,7 +285,7 @@ static void t_obj_block_read_write(void)

285 reftable_record_release(&recs[i]);

286 }

287

286 -static void t_index_block_read_write(void)

288 +void test_reftable_block__ref_read_write(void)

289 {

290 const int header_off = 21;

291 struct reftable_record recs[30];

@@ -305,12 +307,12 @@ static void t_index_block_read_write(void)

307 struct reftable_buf block_data = REFTABLE_BUF_INIT;

308

309 REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);

308 - check(block_data.buf != NULL);

310 + cl_assert(block_data.buf != NULL);

311 block_data.len = block_size;

312

313 ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_INDEX, (uint8_t *) block_data.buf, block_size,

314 header_off, hash_size(REFTABLE_HASH_SHA1));

313 - check(!ret);

315 + cl_assert(!ret);

316

317 for (i = 0; i < N; i++) {

318 char buf[128];

@@ -319,15 +321,15 @@ static void t_index_block_read_write(void)

321

322 reftable_buf_init(&recs[i].u.idx.last_key);

323 recs[i].type = REFTABLE_BLOCK_TYPE_INDEX;

322 - check(!reftable_buf_addstr(&recs[i].u.idx.last_key, buf));

324 + cl_assert(!reftable_buf_addstr(&recs[i].u.idx.last_key, buf));

325 recs[i].u.idx.offset = i;

326

327 ret = block_writer_add(&bw, &recs[i]);

326 - check_int(ret, ==, 0);

328 + cl_assert_equal_i(ret, 0);

329 }

330

331 ret = block_writer_finish(&bw);

330 - check_int(ret, >, 0);

332 + cl_assert(ret > 0);

333

334 block_writer_release(&bw);

335

@@ -339,32 +341,32 @@ static void t_index_block_read_write(void)

341

342 for (i = 0; ; i++) {

343 ret = block_iter_next(&it, &rec);

342 - check_int(ret, >=, 0);

344 + cl_assert(ret >= 0);

345 if (ret > 0) {

344 - check_int(i, ==, N);

346 + cl_assert_equal_i(i, N);

347 break;

348 }

347 - check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));

349 + cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);

350 }

351

352 for (i = 0; i < N; i++) {

353 reftable_record_key(&recs[i], &want);

354

355 ret = block_iter_seek_key(&it, &want);

354 - check_int(ret, ==, 0);

356 + cl_assert_equal_i(ret, 0);

357

358 ret = block_iter_next(&it, &rec);

357 - check_int(ret, ==, 0);

359 + cl_assert_equal_i(ret, 0);

360

359 - check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));

361 + cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);

362

363 want.len--;

364 ret = block_iter_seek_key(&it, &want);

363 - check_int(ret, ==, 0);

365 + cl_assert_equal_i(ret, 0);

366

367 ret = block_iter_next(&it, &rec);

366 - check_int(ret, ==, 0);

367 - check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));

368 + cl_assert_equal_i(ret, 0);

369 + cl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);

370 }

371

372 reftable_block_release(&block);

@@ -376,7 +378,7 @@ static void t_index_block_read_write(void)

378 reftable_record_release(&recs[i]);

379 }

380

379 -static void t_block_iterator(void)

381 +void test_reftable_block__iterator(void)

382 {

383 struct reftable_block_source source = { 0 };

384 struct block_writer writer = {

@@ -391,11 +393,12 @@ static void t_block_iterator(void)

393

394 data.len = 1024;

395 REFTABLE_CALLOC_ARRAY(data.buf, data.len);

394 - check(data.buf != NULL);

396 + cl_assert(data.buf != NULL);

397

396 - err = block_writer_init(&writer, REFTABLE_BLOCK_TYPE_REF, (uint8_t *) data.buf, data.len,

398 + err = block_writer_init(&writer, REFTABLE_BLOCK_TYPE_REF,

399 + (uint8_t *) data.buf, data.len,

400 0, hash_size(REFTABLE_HASH_SHA1));

398 - check(!err);

401 + cl_assert(!err);

402

403 for (size_t i = 0; i < ARRAY_SIZE(expected_refs); i++) {

404 expected_refs[i] = (struct reftable_record) {

@@ -408,42 +411,42 @@ static void t_block_iterator(void)

411 memset(expected_refs[i].u.ref.value.val1, i, REFTABLE_HASH_SIZE_SHA1);

412

413 err = block_writer_add(&writer, &expected_refs[i]);

411 - check_int(err, ==, 0);

414 + cl_assert_equal_i(err, 0);

415 }

416

417 err = block_writer_finish(&writer);

415 - check_int(err, >, 0);

418 + cl_assert(err > 0);

419

420 block_source_from_buf(&source, &data);

421 reftable_block_init(&block, &source, 0, 0, data.len,

422 REFTABLE_HASH_SIZE_SHA1, REFTABLE_BLOCK_TYPE_REF);

423

424 err = reftable_block_init_iterator(&block, &it);

422 - check_int(err, ==, 0);

425 + cl_assert_equal_i(err, 0);

426

427 for (size_t i = 0; ; i++) {

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

429 if (err > 0) {

427 - check_int(i, ==, ARRAY_SIZE(expected_refs));

430 + cl_assert_equal_i(i, ARRAY_SIZE(expected_refs));

431 break;

432 }

430 - check_int(err, ==, 0);

433 + cl_assert_equal_i(err, 0);

434

432 - check(reftable_ref_record_equal(&ref, &expected_refs[i].u.ref,

433 - REFTABLE_HASH_SIZE_SHA1));

435 + cl_assert(reftable_ref_record_equal(&ref,

436 + &expected_refs[i].u.ref, REFTABLE_HASH_SIZE_SHA1));

437 }

438

439 err = reftable_iterator_seek_ref(&it, "refs/heads/does-not-exist");

437 - check_int(err, ==, 0);

440 + cl_assert_equal_i(err, 0);

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

439 - check_int(err, ==, 1);

442 + cl_assert_equal_i(err, 1);

443

444 err = reftable_iterator_seek_ref(&it, "refs/heads/branch-13");

442 - check_int(err, ==, 0);

445 + cl_assert_equal_i(err, 0);

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

444 - check_int(err, ==, 0);

445 - check(reftable_ref_record_equal(&ref, &expected_refs[13].u.ref,

446 - REFTABLE_HASH_SIZE_SHA1));

447 + cl_assert_equal_i(err, 0);

448 + cl_assert(reftable_ref_record_equal(&ref,

449 + &expected_refs[13].u.ref,REFTABLE_HASH_SIZE_SHA1));

450

451 for (size_t i = 0; i < ARRAY_SIZE(expected_refs); i++)

452 reftable_free(expected_refs[i].u.ref.refname);

@@ -453,14 +456,3 @@ static void t_block_iterator(void)

456 block_writer_release(&writer);

457 reftable_buf_release(&data);

458 }

456 -

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

458 -{

459 - TEST(t_index_block_read_write(), "read-write operations on index blocks work");

460 - TEST(t_log_block_read_write(), "read-write operations on log blocks work");

461 - TEST(t_obj_block_read_write(), "read-write operations on obj blocks work");

462 - TEST(t_ref_block_read_write(), "read-write operations on ref blocks work");

463 - TEST(t_block_iterator(), "block iterator works");

464 -

465 - return test_done();

466 -}